Здравствуйте, Кодт, Вы писали:

К>Здравствуйте, GlebZ, Вы писали:

GZ>>Может фиг, с ним, с Обероном. Все OS можно на форте накатать. И детишек форту учить. Пускай знают зачем мозги нужны.
С Обероном фиг.
RetroForth, кстати первый Форт, который я по-настоящему заценил.
Это не то уродство типа Forth ANS-83(94) с заглавными буквами, кривым режимом IMMEDIATE и интерпретирующей природой _компилятора_.
RetroForth — это самостроящийся NATIVE-компилятор, т.е. генерирующий в реальном времени native-код процессора. Хотя можно и байт-код прикрутить без проблем.
Ядро лишь позволяет определять новые слова и весит около килобайта.
Всё определяется уже в исходниках.
Т.е. все операции типа "+", "-", "*" и т.д. идут в исходниках в машкоде.

Вот, кстати, исходничек Retroforth(v7.5) на нём же самом (линкуется в чистом виде в ядрышко на асме),
пожатый UPX-ом весь этот RetroForth весит 4кб(>150 уже готовых слов):

forth
: swap [ $0687 2, ] ;
: drop [ $ad 1, ] ;
: dup [ $fc4689 3, $fc768d 3, ] ;
: nip swap drop ;
: and [ $0623 2, ] nip ;
: or [ $060b 2, ] nip ;
: xor [ $0633 2, ] nip ;
: >> [ $c189 2, $d3ad 2, $e8 1, ] ;
: not -1 xor ;
: @ [ $008b 2, ] ;
: ! [ $c289 2, $89ad 2, $ad02 2, ] ;
: c@ @ $ff and ;
: c! [ $c289 2, ] drop [ $0288 2, ] drop ;
: + [ $0603 2, ] nip ;
: * [ $26f7 2, ] nip ;
: negate -1 * ;
: — negate + ;
: / [ $c389 2, $99ad 2, $fbf7 2, ] ;
: mod / [ $d089 2, ] ;


forth
: variable create 0 , ;
: variable, create , ;
: constant create , does> @ ;
: here h0 @ ;
macro
: : create here -5 + h0 ! ;
: repeat here ;
: again compile ;
: until $48 1, $c009 2, $850f 2, here — 4 — , $ad 1, ;
: f: 32 parse find compile ;
: m: 32 parse mfind compile ;
: >r $ad50 2, ;
: r> $83 1, $ee 1, $04 1, $89 1, $06 1, $58 1, ;
: <>if $063b 2, $adad 2, $74 1, here 0 1, ;
: =if $063b 2, $adad 2, $75 1, here 0 1, ;
: <if $063b 2, $adad 2, $7e 1, here 0 1, ;
: >if $063b 2, $adad 2, $7d 1, here 0 1, ;
: then dup here swap — 1 — swap c! $90 1, ;
: ( ') parse drop drop ;
: | 10 parse drop drop ;
: 1+ $40 1, ;
: 1- $48 1, ;
: ['] 32 parse find m: literal ;

forth
: rot >r swap r> swap ;
: -rot rot rot ;
: over swap dup -rot ;
: tuck swap over ;
: 2dup over over ;
: 2drop drop drop ;
: +! over @ + swap ! ;
: hex 16 base ! ;
: decimal 10 base ! ;
: binary 2 base ! ;
: octal 8 base ! ;
: /mod over over / -rot mod ;
: */ >r * r> / ;
: pad here 1024 + ;
: allot here + h0 ! ;
: align 0 here 4 mod allot ;
: cell+ 4 + ;
: cells 4 * ;
: char+ 1 + ;
: chars 1 * ;
: 2over >r >r 2dup r> -rot r> -rot ;
: 2swap rot >r rot r> ; forth
25 variable, lines
80 variable, columns
: ' 32 parse find ;
: alias create , does> @ >r ;
: fill swap repeat >r swap 2dup c! 1+ swap r> until ;
: 0; dup 0 =if r> 2drop ;; then ;
: << repeat >r dup + r> until ;
: cr 10 emit ;
: space 32 emit ;
: tab 9 emit ;
: del 8 emit ;
: clear lines @ repeat cr until ;
: >pad dup >r pad swap cmove pad r> ;
: " '" parse >pad ;
: ." " >pad type ;
: words last @ repeat @ 0; dup 8 + dup 1+ swap c@ type space again ;
: zt-make here over 4 / 1+ cells dup allot >r
2dup + >r dup >r
swap cmove r> 0 r> c! r> ;
: zt-free negate allot ;
: | 10 parse 2drop ;
here s0 ! 4096 allot
: .version s" RetroForth 7.5" type cr ;


Кстати, по моей (Alexey Abramov) наводке, автор (Chris Childers) взялся делать новый проект TetraForth (хе-хе, я придумал бренд ), более комплексный, чем RetroForth.

Retroforth неплох как скриптовая система для игр.
Это круче, чем CLR в NET.

За счёт того, что нет пролога/эпилога функций, многие функции работают быстрее, чем на том же асме/с++/delphi.
Внешние инклюды тоже цепляются. Пишется система инклюдов также на самом же форте. Там, кстати, в CodeLibrary есть блок, где я написал реализацию слова include для цепляния в рантайме исходников.
Также я писал систему пространств имён:

: namespace ( xt -- )
create last @ @ ,
does>
last @ @ swap
dup @ last @ !
;

: ns; ( n n -- )
last @ @ swap !
last @ !
;

Это вложенные пространства имён, как в .NET.

Ха-ха.
Вот асм на форте:

namespace asm

asm

| RetroForth Assembler
| ------------------------------------------------------------
| We aren't supporting a full-blown assembler yet; this is a
| small, carefully selected subset of x86 assembly.
| ------------------------------------------------------------
here sp ! 1024 4 * chars allot | Reserve 4k for strings
: error s" An error has been detected" type cr ;
variable state |

: m/r 0 state ! ; | memory->register
: r/m 1 state ! ; | register->memory
: i/r 2 state ! ; | immediate->register
: i/m 3 state ! ; | immediate->memory
: r/r 4 state ! ; | register->register
: m 5 state ! ; | memory address
0 constant eax 1 constant ebx |
2 constant ecx 3 constant edx |
4 constant esi 5 constant edi |
| ------------------------------------------------------------
: mov-i/r dup 0 = if drop $b8 1, , ;; then
dup 1 = if drop $bb 1, , ;; then
dup 2 = if drop $b9 1, , ;; then
dup 3 = if drop $ba 1, , ;; then
dup 4 = if drop $be 1, , ;; then
dup 5 = if drop $bf 1, , ;; then
error ;

: mov-m/r dup 0 = if drop $b8 1, , ;; then
dup 1 = if drop $bb 1, , ;; then
dup 2 = if drop $b9 1, , ;; then
dup 3 = if drop $ba 1, , ;; then
dup 4 = if drop $be 1, , ;; then
dup 5 = if drop $bf 1, , ;; then
error ;


: mov, state @ dup 0 = if drop s" m/r" type cr ;; then
dup 1 = if drop s" r/m" type cr ;; then
dup 2 = if drop mov-i/r ;; then
dup 3 = if drop s" i/m" type cr ;; then
dup 4 = if drop s" r/r" type cr ;; then
error ;

: push-r/m dup 0 = if drop $50 1, ;; then
dup 1 = if drop $53 1, ;; then
dup 2 = if drop $51 1, ;; then
dup 3 = if drop $52 1, ;; then
dup 4 = if drop $56 1, ;; then
dup 5 = if drop $57 1, ;; then
error ;
: push, state @ dup 1 = if drop push-r/m ;; then
dup 3 = if drop $68 1, , ;; then
error ;

: pop, dup 0 = if drop $58 1, ;; then
dup 1 = if drop $5B 1, ;; then
dup 2 = if drop $59 1, ;; then
dup 3 = if drop $5A 1, ;; then
dup 4 = if drop $5E 1, ;; then
dup 5 = if drop $5F 1, ;; then
error ;

| ------------------------------------------------------------
: label create here 5 — h ! ; | Create a label
: opcode create , does> @ 1, ; |
$c3 opcode ret, |
$ad opcode lodsd, |

ns;

asm
| ------------------------------------------------------------
| This is a test program:
label a 100 i/m push, eax pop, ret,
| If it works, it'll change the value on TOS to 100
200 a .
ns;


: testa
[ asm ]
300 a .
[ ns; ]
;


---
Жаль, что с плавающей точкой траблы.
Но ничего, пишешь на дельфях dll-ку на 10 к-байт, цепляешь её и юзаешь себе плавающую точку.
Это для винды.
Под линухом, юнихом и беосом на дельяфях не попишешь уже. Только ся. Или на том же асме набить. Тока хрен наёдёшь корректные float to string и vice versa сырцы.

А. Ещё ретрофорт юзается как мультиплатформенный веб-сервер (forth-wiki)
Нехилая штучка, сервер в 8 кб, да притом, что в standalone exe-шнике (или dll-ке) видны его же исходники.

К> Тем более что, программируя на Форте, приходится постоянно упражнять ум и память (а что у нас будет на стеке? а вот сейчас? а как это значение выцарапать?)
А то на сях ты не упражняешься, будет ли Aceess Violation или не будет?

К>И кстати о Форте. Постскрипт — это тоже Форт, только специально заточенный. (насколько я знаю)
Постскрипт — это та ещё гадость.
Кто на нём вручную ришет?
А никто!
Только принтеры и печатают.
Да PDF-ридеры рендерят месиво псевдо-фортовых слов.
Маразм кривой, одни словом.
Но ведь работает!

Заходите на форум (инглиш)
http://retroforth.org/board/
я там бываю иногда (Alexey Abramov).
Мож слонов новых вместе изобретём

За сим кланяюсь.
http://dkdens.narod.ru