Ludwig1, tu utilises donc Swift Forth.
Comme tu l'as acheté, bénéficies-tu d'un support technique à la hauteur ?
J'ai acheté leurs bouquins (il y a quelques années) et franchement j'ai été déçu
car les exemples sont très basiques et... ils ne m'ont rien appris...
Leur Forum est tout vide, il vaut mieux aller trainer sur le groupe google (Elisabeth Rather y est très présente)
à quelles fins utilises-tu le Forth ?
As-tu essayé GForth ? d'autres peut-être ?
Salut,
Si tu as un PB il faut expédier le source via mail dire ou est le PB puis ils te répondent en général dans les 24h. Si tu veux apprendre à programmer avec SwiftForth tu fais un Download à partir du lien que j'ai indiqué. Si t'as des questions tu peux les poser ici sur ce fil, je te répondrais aussi dans les 24h dans la mesure de mes moyens. Je pense, J'espère que la modération n'aura pas d'objection.Envoyé par Forthman
Ludwig1, tu utilises donc Swift Forth.
Comme tu l'as acheté, bénéficies-tu d'un support technique à la hauteur ?
J'ai acheté leurs bouquins (il y a quelques années) et franchement j'ai été déçu
car les exemples sont très basiques et... ils ne m'ont rien appris...
Leur Forum est tout vide, il vaut mieux aller trainer sur le groupe google (Elisabeth Rather y est très présente)
à quelles fins utilises-tu le Forth ?
As-tu essayé GForth ? d'autres peut-être ?
Leur doc (Forth Inc. ) n'est pas terrible, je leurs ai déjà dit plusieurs fois.
C'est tout à fait vrai, avec cette doc tu n'apprends pas grand chose.
Je ne connais pas le groupe Google, par le passé il m'est arrivé de discuter avec Elisabeth. ( J'avais proposé une Extension au niveau de la manipulation des chaines de caractères), certains trouvaient bien, d'autres comme Elisabeth pensaient que ce qui existait dans le Kernel suffisait. C'est resté à downloader à partir du serveur.
En fait je n'utilise pas Forth pour faire une application spécifique, je suis en train d'y incorporer des extensions, Bases de données, Cloud ... etc... par exemple.
Comme dit, si tu le souhaites, dans la mesure de mes moyens, volontier à ton service.
Cordialement
Ludwig
Merci d'utiliser les MP dans ce cas.
Rien ne sert de penser, il faut réfléchir avant - Pierre Dac
Rhoo ! ça c'est pas très gentil monsieur le modérateur...
Si quelqu'un venait à poser une question en relation avec le langage Forth, j'espère qu'il aurait le droit de la poser sur le forum.
J'avais même envie de poster une question "à la con" pour l'exemple, mais j'aime bien ce forum et je ne voulais pas me prendre un ban
Pour le coup je suis de son avis, pour moi les Forth "modernes" (J'avais proposé une Extension au niveau de la manipulation des chaines de caractèresceux qui ont moins de 20ans ),
sont trop complexes et possèdent trop de mots dans le dictionnaire.
Les structures de données sont simples à implémenter, on peut faire ce que l'on veut et chaque programmeur
a "sa" solutions (d'ailleurs ça part souvent en sucette avec ces sujets là sur le groupe).
Par contre il manque des fonctions pour interagir avec le système de manière simple.
En clair, tu peux taper et afficher du texte sur une console toute moche et... et c'est tout... ça fait pas trop rêver
Voilà, c'est ce que je disais, les gens font du Forth pour faire du Forth.En fait je n'utilise pas Forth pour faire une application spécifique, je suis en train d'y incorporer des extensions, Bases de données, Cloud
Attention, je ne critique pas, en plus je sais que c'est passionnant, moi-même je passe beaucoup de temps dans mes librairies,
déjà parce que c'est assez intéressant, mais aussi parce que je suis obligé de réinventer la roue
dernièrement c'était sur ma lib de gestion du VESA (oui, je suis toujours à la bourre de 10 ans par rapport au standard actuel)
histoire de pouvoir gérer mon affichage graphique indépendamment de la résolution (portabilité de mes prog entre mes machines)
Mais c'est plutôt frustrant cette impression que personne n'a écrit autre chose que du "hello world"
Enfin voilà, je pense que je vais continuer ma petite route tout seul
pour info, le lien vers le groupe forth : https://groups.google.com/forum/#!forum/comp.lang.forth
Salut
En fait c'est de ça que je parle,
https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx
Pas vraiment un compilo..., il y a les mots de création de définition c.a.d. ceux que j'ai cité, deux points et point virgule.
Oui, on a tous compris, Forth n'est pas commun... Mais qu'il y a quand même un genre de compilo...
En sous-jacent il y a aussi le mot CREATE
Comme déjà dit, la seule syntaxe est l'espace entre les mots.
En fait on pourrai dire qu'il y a des mots de "compilation". Fondamentalement, le mécanisme de création de définitions (Mots, Fonctions, Méthodes...) est totalement différent de ce qui est connu par ailleurs c'est simple pour l'utilisateur et complexe dans sa structure. Par exemple, connaissant le point d'entrée d'un mot (fonction), on peut remonter à son nom et de cette façon indiquer le nom de la fonction qui est à l'origine d'une erreur. Le gestionnaire d'erreurs se sert de cette particularité. Donc si une fonction (mot) que t'es en train de mettre au point contient une erreur, à l'exécution t'as un message qui te dis ou t'as fait une faute. Les mécanismes de création de définitions dans le ou les dictionnaires, ainsi que la gestion des erreurs, sont dans leurs structures internes d'une grande complexité, mais dans leur utilisation d'une extrême simplicité.
Boff ça fait longtemps que je passe pour un C.. ça change pas grand chose.
Pour ne pas passer pour un has-been, une recherche sur gogol ou wiki t'aurait renseigné...
C'est un processeur Forth avec comme jeu d'instruction le Kernel de Forth.
ça date de plus de 25 ans...Sauf que la doc dit:
""" RTX Microcontrollers support the C and Forth programming languages. """
Bref, c'est un (drôle) de micro durci qu'on peut programmer en C ou en Forth, ce n'est pas un "processeur Forth", et au vu de l'archi, en 90, il devait déjà être en fin de vie...
MPE assurait le support technique, je l'ai dit je crois.
MPE à également développé ceci:
http://www.mpeforth.com/sockpuppet/
j'ai dit que c'était des archives, j'ai bien dit avènement de VHDL et machines implantées dans des FPGAs ultra-puissantes.
Architecture RISC etc...
Mais ça change rien c'est toujours des machines virtuelles taillées sur mesure et implantées dans le silicium.
Note qu'il y a eu des tentatives d'implantation de C dans le silicium, à ma connaissance les résultats n'étaient pas probants.
Cordialement
Ludwig
Ceci était manifestement du domaine de la discussion privée, ce qui explique mon message. Cette discussion porte sur un sujet qui a soulevé pas mal de contestations, sur les raisons de défendre ce langage et sur celles d'en contester l'intérêt actuellement ; elle n'est donc pas du domaine de l'aide personnelle.
Rien ne sert de penser, il faut réfléchir avant - Pierre Dac
Re Salut
Un post processeur Fichiers .DFX Issue de la CAO vers ISO machines outils ça te va ?
le tous écris en Forth évidement.
Je veux bien t'aider mais c'est toi qui programme.
ça fait une jolie application sous Windows non?
Pour ce qui est des applications graphiques, on à tous ce qu'il faut.
J'ai incorporé Fastgraf de Ted Gruber dans les extensions de la machine. C'est fait en langage machine donc ultra puissant
c'est bien plus rapide que ce qu'a fait MS.
Merci pour le lien
Cordialement
Ludwig
Salut,
Ok j'en prend note
Cordialement
Ludwig
Je me répète : par MP uniquement.
Rien ne sert de penser, il faut réfléchir avant - Pierre Dac
C'est ce que j'avais compris
Cordialement
Ludwig
Tiens, justement ça m’intéresse.
Je me demandais s'il y avait quelque-chose d'équivalent à l'opengl (graphiques 3D) et l'openal (sons 3D) sous forth ?
Quand je dis équivalent, je pense également en terme de performance.
C'est juste un malloc dans le user-land. pas de séparation de droits et ce n'est pas du Forth.Mais si, il y a un compilo, il compile en opcodes "Forth" (un peu comme java).Pas vraiment un compilo..., il y a les mots de création de définition c.a.d. ceux que j'ai cité, deux points et point virgule.
...
Donc encore une lib externe (chère) dans l'univers Microsoft, pas écrit en Forth. Juste un binding...
Ce genre de truc n'est absolument pas portable...
Jusqu'ici tout va bien...
Complexe complexe... faut pas abuser non plus, le premier venu (presque) peut faire son Forth.
les mécanismes sont plutôt simples, c'est juste qu'il est facile de se perdre dans la gestion de la pile de retour
ça reste du traitement de données...
Je fais ça souvent : je fais mon dessin autocad, sauvegarde mon dxf et le balance dans ma moulinette qui me pond du code G pour mes machines.
Il m'arrive même de ne même pas passer par la case "dessin" quand la forme relève d'un calcul mathématique (dernièrement usinage d'une parabole pour un mini four solaire)
Mais ça reste léger (quelques centaines de lignes de Forth)
Mon programme pour mon rameur est bien plus gros (qui tourne sur mon petit eeepc700)
La compilation en Forth consiste juste à placer en mémoire l'adresse d'un mot, et d'ailleurs il n'y a pas de
mot spécifique pour ça, c'est l'interpréteur qui s'occupe de ça.
en mode interprété : recherche du mot dans le dico -> si existe : récupère son adresse et l'execute (sinon message d'erreur)
en mode compilation : recherche du mot dans le dico -> si existe : récupère son adresse et la stocke mémoire (et incrémente le pointeur de programme)
L’exécution d'un mot consiste donc en un tout petit bout de code machine (quelques octets) qui saute d'adresses en adresses.
C'est bien plus rapide qu'un langage interprété, mais ça reste beaucoup plus lent que n'importe quel autre langage compilé.
D'ailleurs certains forth ont un compilateur un peu plus évolué qui transforme un mot directement en code machine, pour
les mots simples les plus utilisés, comme DUP DROP SWAP ...etc... (swiftforth le fait je crois)
Mais pour moi ça n'est plus vraiment du Forth
+1 ... pardon! je voulais écrire 1 +
Salut
Pa s d'objection si tu considère que:Complexe complexe... faut pas abuser non plus, le premier venu (presque) peut faire son Forth.
les mécanismes sont plutôt simples, c'est juste qu'il est facile de se perdre dans la gestion de la pile de retour
Les mécanismes de "Treads" c'est simple
Les mécanismes qui gèrent les liens avec le gestionnaire d'erreurs de Windows c'est simple
Les mécanismes de la POO par classe c'est simple
Les mécanismes de la POO par prototype c'est simple
Les mécanismes de gestion des Callback c'est simple
Les mécanismes d'optimisation du code c'est simple
etc...
Ceci est à la portée du premier venu alors tu as raison, c'est simple.
C'est certainement simple d'utilisation, par contre je ne vois pas de simplicité dans la structure
interne. Mais comme celle-ci est totalement transparente pour l'utilisateur ça ne pose pas de PB.
Ben oui on aime bien que ça reste léger, devoir produire des kilomètres de listing pour pour la moindre application
n'est pas un gage de performance.
Bien au contraire.
Pour fixer les idées, et mieux qu'un long discours, voici comment c'est fait
Ici je souhaite tous de même faire une remarque:Code:{ ==================================================================== interp.f Interpreter support Copyright (C) FORTH, Inc. ==================================================================== } { ------------------------------------------------------------------------ Delayed Compilation ' <tick> looks up the next word in the dictionary and aborts if it is not found. The value returned is an XT. ['] is the compile-time behaviour of <tick> . POSTPONE appends the compilation semantics of name to the current definition. ------------------------------------------------------------------------ } : HUH? ( flag -- ) 0= ABORT" ? " ; : WHAT ( a n -- ) 0 HUH? ; : ' ( "name" -- xt ) BL WORD DUP C@ HUH? FIND HUH? ; : ['] ' POSTPONE LITERAL ; IMMEDIATE : POSTPONE ( "name ") BL WORD DUP C@ HUH? FIND DUP HUH? 0< IF ( non-immediate) POSTPONE LITERAL POSTPONE COMPILE, ELSE ( immediate ) COMPILE, THEN ; IMMEDIATE { -------------------------------------------------------------------- -------------------------------------------------------------------- } : ?DSTACK ( -- ) DEPTH 0< -4 ?THROW ; XDEFER ?STACK ( -- ) ' ?DSTACK , { -------------------------------------------------------------------- -------------------------------------------------------------------- } | : NOLOCALS ( c-addr len -- 0 ) 2DROP 0 ; XDEFER (FINDEXT) ' NOLOCALS , ( c-addr len -- c-addr len 0 | xt flag ) : IS-KNOWN? ( c-addr len -- c-addr len 0 | xt flag ) 2DUP (FINDEXT) DUP IF 2NIP EXIT THEN DROP 2DUP (FIND) DUP IF 2NIP THEN ; : INTEGER? ( addr len 0 | ... xt -- addr len 0 | ... xt ) DUP ?EXIT DROP 2DUP ANY-NUMBER? DUP -EXIT 1 = IF NIP NIP ['] LITERAL ELSE 2NIP ['] 2LITERAL THEN ; ( addr len 0 | ... xt -- addr len 0 | ... xt ) XDEFER IS-NUMBER? ' INTEGER? , XDEFER NOT-DEFINED ( a n -- ) ' WHAT , { -------------------------------------------------------------------- -------------------------------------------------------------------- } | : COMPILE ( xt flag -- ) 0< IF COMPILE, ELSE EXECUTE THEN ; : WORD-COMPILER ( c-addr len -- ) IS-KNOWN? DUP IF COMPILE EXIT THEN IS-NUMBER? DUP IF EXECUTE EXIT THEN DROP NOT-DEFINED ; : WORD-INTERPRETER ( c-addr len -- ) IS-KNOWN? IF EXECUTE EXIT THEN 0 IS-NUMBER? ?EXIT NOT-DEFINED ; { -------------------------------------------------------------------- -------------------------------------------------------------------- } \ return true when input exausted or 0 when state is wrong : (INTERPRETING) ( -- flag ) BEGIN STATE @ 0= WHILE BL WORD DUP C@ WHILE COUNT WORD-INTERPRETER ?STACK REPEAT 0<> ELSE 0 THEN ; : (COMPILING) ( -- flag ) BEGIN STATE @ WHILE BL WORD DUP C@ WHILE COUNT WORD-COMPILER ?STACK REPEAT 0<> ELSE 0 THEN ; XDEFER COMPILING ' (COMPILING) , XDEFER INTERPRETING ' (INTERPRETING) , : INTERPRET ( -- ) BEGIN STATE @ IF COMPILING ELSE INTERPRETING THEN UNTIL ; { -------------------------------------------------------------------- State manipulation -------------------------------------------------------------------- } : [ ( -- ) STATE OFF ; IMMEDIATE : ] ( -- ) STATE ON ; { ------------------------------------------------------------------------ Error reports and input prompting .CATCH is the most primitive error reporting for catch/throw. .OK prints " ok" if not compiling. 'CATCH vectors the error reporting routine. PROMPT checks the stack and updates status and prompt. ------------------------------------------------------------------------ } | : (.CATCH) ( n -- ) ." Catch = " DUP . -2 = IF ERRMSG COUNT TYPE THEN CR ; XDEFER .CATCH ' (.CATCH) , XDEFER .STACK 0 , | : (PROMPT) .STACK STATE @ 0= IF ." ok" THEN CR ; XDEFER PROMPT ' (PROMPT) , { ------------------------------------------------------------------------ (QUIT) is the heart of the text interpreter: updating status, refilling the input stream, interpreting the input stream, and prompting the user for more -- over and over and over again. QUIT is the main loop for the entire system. It clears the return stack, CATCHES (QUIT), and reports errors. INTERPRET is run via CATCH, so all errors should come back here. The data stack is cleared on any error. ------------------------------------------------------------------------ } XDEFER /NDP 0 , : (QUIT) ( -- ) .STACK BEGIN REFILL DROP INTERPRET PROMPT AGAIN ; : /INTERPRETER ( -- ) 'TIB CELL+ @ 'TIB ! 'SOURCE-ID OFF BLK OFF POSTPONE [ ; : QUIT ( -- ) BEGIN R0 @ RP! \ clear return stack /INTERPRETER ['] (QUIT) CATCH .CATCH CR S0 @ SP! /NDP AGAIN ; { ------------------------------------------------------------------------ Input stream preservation Save and restore information about the current input stream. This should be sufficient to allow EVALUATE, INCLUDE, and LOAD to be nested in arbitrary orders. ------------------------------------------------------------------------ } | : SYNC-INFILE ( -- ) SOURCE-ID 0> IF 'LINEPOS 2@ 'LINEPOS @ 0 SOURCE-ID REPOSITION-FILE DROP 'TIB @ #TIB @ SOURCE-ID READ-LINE 2DROP #TIB ! #TIB 2@ /CONTROLS 'LINEPOS 2! THEN ; : RESTORE-INPUT ( ... n -- 0 ) 8 <> ABORT" Bad arguments to RESTORE-INPUT" 'LINEPOS 2! LINE ! BLK ! 'SOURCE-ID ! >IN ! 'TIB ! #TIB ! SYNC-INFILE 0 ; : SAVE-INPUT ( -- ... n ) #TIB @ 'TIB @ >IN @ 'SOURCE-ID @ BLK @ LINE @ 'LINEPOS 2@ 8 ; { ------------------------------------------------------------------------ Evaluate Given a string and length on the stack, evaluate it in the current system context. ------------------------------------------------------------------------ } : EVALUATE ( i*x c-addr u -- j*x ) SAVE-INPUT N>R ( c-addr u) #TIB 2! >IN OFF LINE OFF BLK OFF -1 'SOURCE-ID ! ['] INTERPRET CATCH ( *) ( *) DUP IF CR ." EVAL: " #TIB 2@ TYPE CR POSTPONE [ THEN NR> RESTORE-INPUT DROP ( *) THROW ; { ------------------------------------------------------------------------ Comments \ comments to end of line. FILE-SKIP ignores data from the current file input stream until a matching character is found, refilling as necessary. TEXT-SKIP ignores data from the current input stream until a matching character is found. ( comments to the next ) . { comments to the next <right curly brace> . .( prints text until the next ) . ------------------------------------------------------------------------ } : \\ ( -- ) SOURCE-ID IF BEGIN REFILL 0= UNTIL THEN ; : \ ( " ccc") #TIB @ >IN ! ; IMMEDIATE { -------------------------------------------------------------------- -------------------------------------------------------------------- } : SKIP-PAST ( char -- ) BEGIN /SOURCE THIRD SCAN NIP IF PARSE 2DROP EXIT THEN REFILL 0= UNTIL DROP ; : ( [CHAR] ) SKIP-PAST ; IMMEDIATE : { [CHAR] } SKIP-PAST ; IMMEDIATE : ECHO-UNTIL ( char -- ) BEGIN /SOURCE THIRD SCAN NIP IF PARSE TYPE EXIT THEN /SOURCE TYPE CR REFILL 0= UNTIL DROP ; : .( [CHAR] ) ECHO-UNTIL ; IMMEDIATE : ?( ( flag -- ) CR .( ; IMMEDIATE { ------------------------------------------------------------------------ More defining word behaviour (;CODE) fixes the compiled CALL of the most recent word so that it calls the code following where it was called from, normally in a defining word. DOES> defines a new behaviour for a CREATE-d word. RECURSE forces a word to call itself. ASSIGN writes a pseudo-xt for the code following it into a variable. For example: VARIABLE 'DOTHIS : HEREITIS 'DOTHIS ASSIGN HERE 100 DUMP ; HEREITIS 'DOTHIS @EXECUTE will execute the code following the ASSIGN in HEREITIS. ------------------------------------------------------------------------ } : (;CODE) R> ( addr to call to ) LAST @ NAME> >BODY - LAST @ NAME> >CODE $E8 OVER C! 1+ ! ; : DOES> POSTPONE (;CODE) POSTPONE (DOES>) ; IMMEDIATE : RECURSE LAST CELL+ CELL+ @ CODE> COMPILE, ; IMMEDIATE : ASSIGN ( a -- ) R> CODE> SWAP ! ; \\
On peut relever une des caractéristiques intéressante de la machine virtuelle:
Le mot INTERPRET utilise deux mots différés, à savoirCode:XDEFER COMPILING ' (COMPILING) , XDEFER INTERPRETING ' (INTERPRETING) , : INTERPRET ( -- ) BEGIN STATE @ IF COMPILING ELSE INTERPRETING THEN UNTIL ;
COMPILING et INTERPETING
ces mots sont branchés respectivement comme suit
XDEFER COMPILING ' (COMPILING) ,
XDEFER INTERPRETING ' (INTERPRETING) ,
Si par exemple on veux faire parler PHP à la machine virtuelle, après avoir codé en Forth les fonctions de PHP,
on va écrire
' PHPCOMPILING IS COMPILING
' PHPINTERPRETING IS INTERPRETING
à partir de là, la machine virtuelle va parler PHP, l'utilisateur ne verra pas qu'il tourne dans une machine
virtuelle Forth.
Dans les faits c'est un peu plus que ça.L’exécution d'un mot consiste donc en un tout petit bout de code machine (quelques octets) qui saute d'adresses en adresses.
CertainC'est bien plus rapide qu'un langage interprété,
pas tous tous à fait juste, il y a eu bien des expériences qui ont montrées qu'une application écrite avec
mais ça reste beaucoup plus lent que n'importe quel autre langage compilé.
Forth, tourne à environ 80% de la vitesse de la même application écrite en langage machine. Ceci est une vielle
discussion il a été démontré et prouvé que la majorité des applications compilées avec des compilateurs classiques, sont plus lentes, en tous cas pas plus rapides, en ce qui concerne la vitesse d'exécution.
Cordialement
Ludwig
PS: Suite voir message suivant
Re Salut,
Ce n'est pas tout à fait ça,
Une bonne partie des mots du Kernel sont écris en langage machine du processeur hôte de cette façon on assure la portabilité.
Voici un extrait du Kernel de Swift Forth, ça ressemble à ceci:
Code:{ ==================================================================== core.f Forth core wordset Copyright (C) FORTH, Inc. ==================================================================== } { -------------------------------------------------------------------- Memory Reference Operators Memory reference operators @ , ! , and +! operate on cell wide values. H@ and H! operate on half cell values, and C@ and C! operate on byte or character values. Note that H@ is a signed fetch, where as C@ and U@ are unsigned. W@ and W! are provided as compatability words for other Forths. -------------------------------------------------------------------- } ICODE @ ( a -- n) 0 [EBX] EBX MOV \ replace address in ebx with contents RET END-CODE ICODE U@ ( a -- c ) 0 [EBX] EBX MOVZXW \ replace address in ebx with contents RET END-CODE ICODE H@ ( a -- c ) 0 [EBX] EBX MOVSXW \ replace address in ebx with contents RET END-CODE ICODE W@ ( a -- c ) 0 [EBX] EBX MOVZXW \ replace address in ebx with contents RET END-CODE ICODE C@ ( a -- c ) EAX EAX XOR 0 [EBX] AL MOV EAX EBX MOV RET END-CODE ICODE ! ( n a -- ) 0 [EBP] EAX MOV EAX 0 [EBX] MOV 4 [EBP] EBX MOV 8 # EBP ADD RET END-CODE ICODE H! ( n a -- ) EBX ECX MOV \ address into ecx 0 [EBP] EAX MOV \ data into eax 4 [EBP] EBX MOV \ refresh tos 16BIT: EAX 0 [ECX] MOV \ write data to address 8 # EBP ADD \ discard unused stack space RET END-CODE ICODE C! ( c a -- ) 0 [EBP] EAX MOV AL 0 [EBX] MOV 4 [EBP] EBX MOV 8 # EBP ADD RET END-CODE ICODE W! ( n a -- ) EBX ECX MOV \ address into ecx 0 [EBP] EAX MOV \ data into eax 4 [EBP] EBX MOV \ refresh tos 16BIT: EAX 0 [ECX] MOV \ write data to address 8 # EBP ADD \ discard unused stack space RET END-CODE ICODE 2C@ ( addr -- nh nl ) 4 # EBP SUB \ make room on stack for a cell 1 [EBX] EAX MOVZX \ read byte at addr+1 to eax 0 [EBX] EBX MOVZX \ read byte at addr+0 to ebx (tos) EAX 0 [EBP] MOV \ byte at addr+1 becomes second on stack RET END-CODE ICODE 2C! ( nh nl a -- ) EBX ECX MOV \ address into ecx 0 [EBP] AL MOV \ byte from second to al 4 [EBP] AH MOV \ byte from third to ah 8 [EBP] EBX MOV \ refresh tos AL 0 [ECX] MOV \ write low byte AH 1 [ECX] MOV \ and hi byte to memory 12 # EBP ADD \ discard unused stack space RET END-CODE ICODE 2! ( x1 x2 a-addr -- ) 0 [EBP] EAX MOV \ read x2 into eax 4 [EBP] ECX MOV \ and x1 into ecx EAX 0 [EBX] MOV \ write x2 to addr+0 ECX 4 [EBX] MOV \ and x1 to addr+4 8 [EBP] EBX MOV \ read new tos 12 # EBP ADD \ discard unused stack space RET END-CODE ICODE 2@ ( a-addr -- x1 x2 ) 4 # EBP SUB \ make room on stack for a cell 4 [EBX] EAX MOV \ read x1 from addr+4 EAX 0 [EBP] MOV \ write onto stack 0 [EBX] EBX MOV \ read x2 from addr+0, replacing tos RET END-CODE { ------------------------------------------------------------------------ Return Stack Operators We often store temporary values on the return stack. These words move data to and from the return stack. Note that the double number operators leave the top of the return stack with the same value that was on top of the data stack. This means that, for instance, 2>R is equivalent to "SWAP >R >R" All of the operators that move data to and from the return stack are designed to be used in matching pairs, as ">R ... R>" "2>R ... 2R>" and "N>R ... NR>" . The N>R operator takes a parameter and saves that many items on the return stack plus the number of items saved. NR> depends on the number of items being top on the return stack. ------------------------------------------------------------------------ } ICODE R> ( -- x ) ( R: x -- ) PUSH(EBX) \ save tos on stack EBX POP \ pop return stack to tos RET END-CODE ICODE >R ( x -- ) ( R: -- x ) EBX PUSH \ push tos to return stack POP(EBX) \ update tos RET END-CODE ICODE R@ ( -- x ) ( R: x -- x ) PUSH(EBX) \ save tos on stack 0 [ESP] EBX MOV \ read top of return stack to tos RET END-CODE ICODE DUP>R ( x -- x ) ( R: -- x ) EBX PUSH \ write tos to return stack RET END-CODE ICODE R>DROP ( -- ) ( R: x -- ) EAX POP \ discard top of return stack RET END-CODE ICODE R>2DROP ( x -- ) ( R: x -- ) 4 # ESP ADD POP(EBX) RET END-CODE ICODE DROPR> ( n -- x ) ( R: x -- ) EBX POP \ replace tos with top of return stack RET END-CODE ICODE 2>R ( x1 x2 -- ) ( R: -- x1 x2 ) 0 [EBP] PUSH \ push x1 on return stack EBX PUSH \ then push x2 on return stack 4 [EBP] EBX MOV \ reload tos 8 # EBP ADD \ discard unused stack space RET END-CODE ICODE 2R> ( -- x1 x2 ) ( R: x1 x2 -- ) 8 # EBP SUB \ make room on stack for two cells EBX 4 [EBP] MOV \ write tos to stack EBX POP \ read x2; new tos 0 [EBP] POP \ pop x1 directly onto data stack RET END-CODE ICODE 2R@ ( -- x1 x2 ) ( R: x1 x2 -- x1 x2 ) 8 # EBP SUB \ make room on stack for two cells EBX 4 [EBP] MOV \ write tos to stack 0 [ESP] EBX MOV \ copy x2 to tos 4 [ESP] EAX MOV \ copy x1 to eax EAX 0 [EBP] MOV \ and then to stack RET END-CODE \ Write N items to the return stack. N is also written. CODE N>R ( x1 x2 .. xn n -- ) ( R: -- x1 x2 .. xn n ) EDX POP \ save return address EBX ECX MOV \ how many ECX ECX OR 0<> IF BEGIN \ 0 [EBP] PUSH \ get data from stack 4 # EBP ADD \ dispose of space on stack LOOP \ and repeat THEN \ EBX PUSH \ save count EDX PUSH \ restore return address POP(EBX) \ refresh tos RET END-CODE \ Read N items from the return stack. N must be on top of return stack \ for this to work! CODE NR> ( -- x1 x2 .. xn n ) ( R: x1 x2 .. xn n -- ) 4 # EBP SUB \ make room on data stack EBX 0 [EBP] MOV \ save current tos EDX POP \ save return address EBX POP \ get n, the new tos EBX ECX MOV \ copy for loop counter ECX ECX OR 0<> IF BEGIN \ 4 # EBP SUB \ make room 0 [EBP] POP \ write to data stack LOOP \ and repeat THEN \ EDX PUSH \ restore return address RET END-CODE { ------------------------------------------------------------------------ Return stack workspace allocation A provision to allocate temporary data space on the return stack makes many windows-related programming tasks easier. The space is allocated in bytes by the R-ALLOC function which returns the address of the space allocated. The space is automatically de-allocated when the calling routine executes a return. The trick is that R-ALLOC intercepts its return address before completing, and by calling R-GO-ON to do its return, pushes a new return address for the eventual return from its caller to come back to and thereby restore the return stack. Do not use this after a >R operation or inside a DO..LOOP ! ------------------------------------------------------------------------ } LABEL R-GO-ON EAX JMP \ jump to address eax END-CODE CODE R-ALLOC ( n -- addr ) EAX POP \ get my return address into eax ESP ECX MOV \ save esp in ecx BEGIN \ make the allocation in 4k chunks 4096 # EBX CMP \ since this is the size of the windows > WHILE \ allocation units 4096 # ESP SUB 4096 # EBX SUB 0 [ESP] EDX MOV REPEAT EBX ESP SUB ESP EBX MOV \ get the new ESP onto TOS ECX PUSH \ push saved ESP onto return stack R-GO-ON CALL \ make return to R-ALLOC 's caller \ when R-ALLOC 's caller returns, it ECX POP \ comes here, reads the old esp ECX ESP MOV \ and write back to discard space RET END-CODE LABEL R-GO-ON2 EDX PUSH \ put the address on rp initially EAX JMP \ jump to address eax END-CODE CODE R-BUF ( -- ) \ create buffer and push address on rp EAX POP \ get my return address into eax ESP ECX MOV \ save esp in ecx MAX_PATH # ESP SUB \ allocate 260 bytes below esp ESP EDX MOV \ hold buffer address ECX PUSH \ push saved ESP onto return stack R-GO-ON2 CALL \ make return to R-ALLOC 's caller \ when R-ALLOC 's caller returns, it ECX POP \ comes here, reads the old esp ECX ESP MOV \ and write back to discard space RET END-CODE ICODE +RP ( n -- ) EBX ESP ADD \ adjust return stack pointer POP(EBX) RET END-CODE { ------------------------------------------------------------------------ Data Stack Operations The data stack operators manipulate the top items on the data stack. ------------------------------------------------------------------------ } ICODE NIP ( x1 x2 -- x2 ) 4 # EBP ADD \ discard x1 RET END-CODE ICODE DROP ( x -- ) POP(EBX) \ discard x by replacing it from second RET END-CODE ICODE DUP ( x -- x x ) PUSH(EBX) \ copy x onto the stack RET END-CODE ICODE SWAP ( x1 x2 -- x2 x1 ) \ exchange top and second 0 [EBP] EAX MOV EBX 0 [EBP] MOV EAX EBX MOV RET END-CODE ICODE OVER ( x1 x2 -- x1 x2 x1 ) PUSH(EBX) \ push x2 into memory 4 [EBP] EBX MOV \ replace tos with x1 RET END-CODE ICODE THIRD ( x1 x2 x3 -- x1 x2 x3 x1 ) PUSH(EBX) \ push x3 into memory 8 [EBP] EBX MOV \ replace tos with x1 RET END-CODE ICODE FOURTH ( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 ) PUSH(EBX) \ push x4 into memory 12 [EBP] EBX MOV \ replace tos with x1 RET END-CODE ICODE ROT ( x1 x2 x3 -- x2 x3 x1 ) EBX ECX MOV \ save x3 4 [EBP] EBX MOV \ tos is x1 0 [EBP] EAX MOV \ get x2 EAX 4 [EBP] MOV \ write to where x1 was ECX 0 [EBP] MOV \ write x3 to where x2 was RET END-CODE ICODE -ROT ( x1 x2 x3 -- x3 x1 x2 ) EBX ECX MOV \ save x3 4 [EBP] EAX MOV \ get x1 0 [EBP] EBX MOV \ x2 replaces tos EAX 0 [EBP] MOV \ write x1 to where x2 was ECX 4 [EBP] MOV \ write x3 to where x1 was RET END-CODE ICODE TUCK ( x1 x2 -- x2 x1 x2 ) 0 [EBP] EAX MOV \ get x1 4 # EBP SUB \ make room for another cell EBX 4 [EBP] MOV \ write x2 to where x1 was EAX 0 [EBP] MOV \ write x1 to new space RET END-CODE ICODE ?DUP ( x -- 0 | x x ) EBX EBX OR \ check x 0<> IF \ if not zero PUSH(EBX) \ push another copy of it THEN \ RET END-CODE ICODE NOOP ( -- ) NOP \ do nothing but waste time and space RET END-CODE \\
En clair, pour un processeur donné, on écrit le Kernel des mots Forth (DUP SWAP Etc...) en langage machine du processeur cible, une fois ceci fait, on rajoute le reste qui est écris en Forth. Ce qui permet de dire que Forth est écris en Forth.
Ce qui, comme déjà dit, assure la parfaite portabilité.
L'extrait du Kernel ci-dessus, concerne les processeurs Intel de la famille XX86.
Cordialement
Ludwig
Tu vas croire que je m'acharne, mais tant pis
oui, ça permet juste de faire une recherche plus rapide en séparant en plusieurs brins un vocabulaire suivant (généralement) la première lettre du mot.Les mécanismes de "Treads" c'est simple
Je n'utilise pas ce système, j'ai un dictionnaire séparé, et les mots les plus utilisés sont en tête de liste
Ça ne concerne pas le langage directement.Les mécanismes qui gèrent les liens avec le gestionnaire d'erreurs de Windows c'est simple
ça non plus ça ne concerne pas directement le Forth, , comme la POO était à la mode il y a quelque années, les Forthiens on dit "nous aussi on peut le faire !"Les mécanismes de la POO par classe c'est simple
Les mécanismes de la POO par prototype c'est simple
mais ce n'est pas natif au langage.
c'est ce dont je parlais : jongler avec la pile de retourLes mécanismes de gestion des Callback c'est simple
à la base, il n'y a pas d'optimisation, mais elle a été introduite pour palier à la faible vitesse du forth comparée aux langages compilésLes mécanismes d'optimisation du code c'est simple
quand je dis "léger" je pense plutôt au type d'application, moi j'appelle ça une moulinette, et quel que soit le langage, ça ne demandera pas beaucoupBen oui on aime bien que ça reste léger, devoir produire des kilomètres de listing pour pour la moindre application
n'est pas un gage de performance.
Bien au contraire.
de lignes de code. Le plus long étant de potasser le format des fichiers dxf et de connaître la programmation sur machines outils ("code G" ou autre)
Je ne suis pas sûr que pour les non initiés ça soit très parlantPour fixer les idées, et mieux qu'un long discours, voici comment c'est fait
(long listing forth)
Et bien, juste parce que je n'aime pas dire de bêtises, j'ai chargé SwiftForthCe n'est pas tout à fait ça,
et j'ai fait le test suivant :
pour tester si ça fonctionne je lance un 1234 AFFICHE_TEST , et ça m'affiche :Code:: PUISS2 ( n --- n*n ) \ calcule le carré d'une valeur et laisse le résultat sur la pile DUP * ; : AFFICHE_TEST ( n --- ) \ test d'affichage du carre ." Nombre rentré : " DUP . CR ." Valeur du carré de ce nombre : " PUISS2 . CR ;
Nombre rentré : 1234
Valeur du carré de ce nombre : 1522756
donc c'est bon (je sais, je suis trop fort)
pour voir comment est codé le mot PUISS2 j'utilise SEE :
ce qui correspond pour un assembleur classique à :Code:SEE PUISS2 808396F 4 # EBP SUB 83ED04 8083972 EBX 0 [EBP] MOV 895D00 8083975 0 [EBP] EAX MOV 8B4500 8083978 EBX MUL F7E3 808397A EAX EBX MOV 8BD8 808397C 4 # EBP ADD 83C504 808397F RET C3 ok
donc ma définition a bien été transformée intégralement en code machine et non pas en ForthCode:sub ebp,4 mov [ebp],ebx mov eax,[ebp] mul ebx mov ebx,eax add ebp,4 ret
par contre si j'utilise SEE sur mon mot AFFICHE_TEST : (j'ai viré toutes les valeurs hexa qui ne nous servent à rien ici)
on voit que tous les mots ont été remplacés par des CALL et que seul le mot DUP a été codé en code machine "brut"Code:SEE AFFICHE_TEST (S") CALL "nombre rentré : " TYPE CALL 4 # EBP SUB EBX 0 [EBP] MOV . CALL CR CALL (S") CALL "Valeur du carré de ce nombre : " TYPE CALL ** CALL . CALL CR JMP
Mais sinon, à part nous deux, il y en a d'autres qui suivent cette discussion ?
si oui qu'ils se manifestent parce que là j'ai l'impression de parler dans le vide
Oui, je suis mais disons que je n'ai pas spécialement d'intérêt ni de motivation à participer...Mais sinon, à part nous deux, il y en a d'autres qui suivent cette discussion ?
si oui qu'ils se manifestent parce que là j'ai l'impression de parler dans le vide
Bonsoir,
Oui, je lis soigneusement ces échanges.
Pour moi, il y a d'abord l’algorithmique. Je sais que c'est un terme qui sert à tout, pour moi, c'est la description dans un langage compréhensible par tout le monde, en l'occurrence dans le présent forum, le français.
L'interface avec la machine, c'est le langage utilisé. A ce propos chacun sait que le meilleur langage, d'une façon générale, est celui que l'on connait le mieux. Il y a des langages plus spécialisés, mais il ne sont ni meilleurs ni moins bon, sinon, on le saurait. Il y a des langages que l'on n'aime pas, d'autres que l'on préfère, pour ceux des développeurs qui en connaissent plusieurs.
Par contre, on peut faire des paris sur la pérennité de certains langages. Bien évidemment je ne dirai pas pour lequel (ou lesquels) je parie.
Bonne soirée.
En fait pas vraiment. C'est vrai à l'intérieur d'une classe de langages pas trop différents. Quelqu'un qui connait le mieux un assembleur ou Fortran n'a pas le meilleur langage pour faire du développement Web.
C'est une autre affirmation très générale et pas du tout étayée. Là aussi, il y a de nombreux cas où avec un jeu de critères, on sait que tel langage est meilleur qu'un autre. Par exemple, pour faire des maths, on peut dire qu'aujourd'hui, il y a mieux qu'APL qui est pourtant toujours utilisé.
Je me suis un peu mal exprimé, et je ne voudrais pas que Ludwig1 le prenne comme une attaque.Mais sinon, à part nous deux, il y en a d'autres qui suivent cette discussion ?
si oui qu'ils se manifestent parce que là j'ai l'impression de parler dans le vide
Quand j'écris que j'ai l'impression de parler dans le vide, c'est que même si nous avons une approche différente du langage,
nous sommes déjà adepte de cette secte, donc si c'est juste pour parler Forth entre nous, autant le faire en privé comme
l'avait suggéré JPL.
Bon dimanche à tous
Parler d'un langage pourquoi pas. Mais là, c'est effectivement très technique et cela n'apprend rien au lecteur occasionnel en effet. Ceci dit, perso cela ne me gène pas mais c'est JPL le modérateur et il connait la charte mieux que moi.nous sommes déjà adepte de cette secte, donc si c'est juste pour parler Forth entre nous, autant le faire en privé comme
l'avait suggéré JPL.
La question du "langage" est pourtant essentielle en informatique.
Souvent les débutants confondent les instructions natives, avec les procédures, fonctions, composants etc, qui ne font pas partie du langage.
Comparer le C avec le Forth, ce n'est pas comparer le C auquel on adjoint les bibliothèques windows par exemple.
Après, un langage peut-être plus ou moins "équipé" pour prendre en compte tel ou tel système, et ça, effectivement, ça joue beaucoup lorsqu'il s'agit de choisir tel ou tel langage, selon certains critères et selon le type de projet évidemment (on n'a pas les mêmes contraintes pour un programme de 100 lignes et un programme de 1000000 lignes).
Les critères sont variés :
Portabilité.
Performance.
Compacité.
Lisibilité.
Facilité de maintenance.
Sécurité.
Fiabilité.
Nombre de programmeurs disponibles connaissant le langage.
Vitesse de développement.
Cout de l'environnement de développement.
Etc...
Etre à priori pour ou contre un langage c'est passer à côté du problème et de sa solution.
Et on est d'accord pour dire, certes, qu'à titre personnel le "meilleur" langage employé sera celui déjà connu...
Salut,
Je penses que la discussion publique peut 'être utile, ne serait-ce que pour montrer qu'il existe une autre façon de faire quiJe me suis un peu mal exprimé, et je ne voudrais pas que Ludwig1 le prenne comme une attaque.
Quand j'écris que j'ai l'impression de parler dans le vide, c'est que même si nous avons une approche différente du langage,
nous sommes déjà adepte de cette secte, donc si c'est juste pour parler Forth entre nous, autant le faire en privé comme
l'avait suggéré JPL.
Bon dimanche à tous
est bien plus rapide que les méthodes classiques.
Je ne sais plus qui à dit un jour que le progrès nait de la diversité.
Note que personnellement ça ne me gène pas si quelqu'un choisi de développer de façon classique et de pondre des
listings kilométriques, avec des temps de compilation/Debug exorbitants.
Sache que j'ai par le passé développé en langage machine (beaucoup), Basic, puis Pascal, puis aussi du C et autres Gracieusetés.
Il se trouve que je n'aime pas les langages à crochet, il se trouve que je considère toute syntaxe comme inutile (nom avis personnel). Il se trouve que la notation post fixée impose un compilateur qui traite les n cas autorisés, mais dans la pratique, c'est souvent du cas n + 1 dont on a besoin. Résultat des courses, ça impose une complexification des compilateurs.
Le seul fait de traiter seulement les données comme étant des objets et de procéder à la notation Polonaise inversée, apporte une simplification majeure dans la structuration du codage.
C'est le principe de moindre action.
Il se trouve que la machine Virtuelle dont nous parlons fonctionne selon le principe de la notation Polonaise inversée.
Je pense que la vrai question consiste à analyser les méthodes de développement, selon des critères qui ressemblent un peu
à des critères scientifiques comme le principe de moindre action par exemple.
Une saine discussion serait alors une confrontation des # langages avec ce principe.
C'est bien comme l'a dit St. Ex,
CordialementUn système est parfait non pas quand on ne peux plus rien y rajouter mais quand on ne peut plus rien y retrancher
Ludwig
Parler du langage dans cette discussion est normal, par contre si cela devient des conseils ou une assistance personnalisés , comme cela m'avais paru se dessiner dans un message, les MP sont plus appropriés.
Rien ne sert de penser, il faut réfléchir avant - Pierre Dac
Mais c'est alors au codeur de se palucher l'inversion...
Puis c'est à celui qui reprend le code de refaire à l'envers cette gymnastique...
Autant, un cpu ne va pas rechigner, autant le programmeur moyen va tordre le nez.
Sincèrement, je trouve qu'il y a plus "sexy" comme travail, que le compilo s'en charge très bien et que ce n'est pas le plus dur pour lui.
Une chose est sûre: ce n'est pas le fait de balancer des pages de code assembleur qui va attirer le chaland...
Par contre, j'ai en mémoire une façon élégante de convertir des secondes en heures/minutes/secondes en jouant sur la base de sortie...
Jusqu'ici tout va bien...
je le reconnais bien volontiers.
par ailleurs, il ne s'agit pas d'un fil sur LES langages qui pourrait éveiller l'intérêt d'autres intervenants mais d'un débat très ciblé uniquement sur Forth.
avec comme l' impression d'une démarche prosélitiste et dithyrambique de Ludwig sur sa marotte.
cela étant, si cela intéresse certaines personnes, on est pas obliger de se coltiner ces pages de codes, et il y a d'autres sujet sur le site.
bonne discussion.
La RPN n'est pas un problème, on s'y fait vite. (d'ailleurs j'ai un peu de mal à utiliser des calculatrices autres qu'en RPN
Les opérateurs agissent sur les éléments au sommet de la pile, il faut juste s'imaginer ce que l'on veut faire avec ces valeurs.
Après il y a les purs et durs qui ne veulent pas créer la moindre variable pour manipuler plus de 4 nombres et qui passent tout par la pile,
et LÀ c'est imbuvable
Pour ma part je me contente de quelques mots comme DUP,SWAP,OVER, DROP, NIP et parfois ROLL.
Pour certains profils oui (j'ai 5 HP RPN sur mon bureau au moment où j'écris et un paquet d'autresLa RPN n'est pas un problème, on s'y fait vite. (d'ailleurs j'ai un peu de mal à utiliser des calculatrices autres qu'en RPN
Pour la majorité, elle apporte une complexité supplémentaire et écrire une formule mathématique directement plutôt que de la passer en RPN simplifie beaucoup en programmation.
Sans parler de la lisibilité du code, de l'absence de risque dans la manipulation de la pile, du typage fort, des possibilités d'optimisation par le compilo plutôt que par le programmeur...
Bref, c'est chouette pour certains usages et types d'esprit mais comme tu le disais plus haut, pas quelque chose qu'on peut recommander largement.
Salut,
En fait, dans la mesure ou seul les données sont considérées comme étant des objets la RPN ne devrai pas poser de PB me semble t'il.
On met en place les données sur la pile puis on appelle la méthode qui va utiliser ces données.
A mon avis c'est d'avantage une question de langue.
Dans la langue Allemande on passe le sujet avant le verbe, dans la langue Française on passe le sujet après le verbe semblerait 'il.
EX:
Türe schliesen en allemand.
Fermer la porte en français.
Donc d'abord citer l'objet sur lequel on veut agir puis ensuite citer l'action à entreprendre ne me semble pas un handicap.
Par ailleurs, je souhaite rappeler qu'un ordinateur n'est jamais autre chose qu'une machine. De ce fait, il me semble qu'un programme devrai d'avantage ressembler à un mode opératoire, c.a.d. une liste ou on cite les objets puis ou on dit ce qu'il faut faire avec.
de ce fait écrire
12 25 additionner \ ne devrait pas à mon sens, poser de difficulté majeure.
C:\myrepertory\Myfile.TXT OpenFile \ me semble suffisement explicite et ne nécessite pas de commentaires particuliers.
ou bien encore
C:\myrepertory\Myfile.TXT 95 GetLine
Par ailleurs on peut remarquer qu'une telle façon de procéder ne met pas en Oeuvre de syntaxe compliquée.
Il me semble que cette façon de faire est très proche de la description algorithmique des opérations à réaliser.
Cordialement
Ludwig
Salut,
Il me semble qu'il s'agit d'un fil ou l'on parle d'une machine Virtuelle et de sa mise en Oeuvre. On aurai aussi pu parler de la JVM pour découvrir quelques étranges ressemblances avec la VM sujet de cette discussion.
On parle également de RPN (Notation Polonaise Inversée) notation qui conduit à mettre en place des objets puis à leur appliquer une action.
Il se trouve que cette notation peut semble t'il conduire à un principe d'invariance, par exemple:
En langage machine pour un Mu P de la famille xx86 d'Intel on écrira:
Objets sur lesquels s'applique la méthode
ou encore:Code:EBX ECX MOV
Nous montrons ici le début d'un principe d'invariance, qu'on développe au niveau machine ou en haut niveau, on appliqueCode:S" http://forums.futura-sciences.com/programmation-langages-algorithmique/" >SHELL
toujours la même technique.
Citation du ou des Objet(s), puis action sur le ou les objets et surtout pas d'expressions ésotériques en guise de syntaxe.
Donc pas de syntaxe à apprendre.
Ceci correspond à un autre principe de la science, celui de moindre action selon Maupertuis ou encore au principe
du rasoir d'Occam.
En outre une description
" Objets, puis actions sur les objets"
peut facilement être utilisée en tant que description algorithmique ou les objets puis les tâches à appliquer
sont minutieusement définis.
Ceci correspond parfaitement à ce Descartes nous à appris " Discours de la méthode"
Je ne penses pas faire du prosélitisme en citant Descartes ou Maupertuis.
Si j'ai fini par travailler avec la VM sujet de cette discussion c'est qu'elle à la mérite de contenir quelques principes scientifiques, qu'elle à été mise au point par des gens ayant travaillés avec Mac Carthy au MIT.
Cordialement
Ludwig
