J'aimerais bien qu'on m'explique?

[invite2800a7c8]

Bonsoir,

Voila, pour développer des applications sous Windows (Entre autre) j'utilise un système de développement
basé sur une machine virtuelle de nom Forth.
Je précise que j'ais acheté une licence, 399$ US. Comme tout compilateur professionnel C, C++, ou autre, C'est également un système de développement de type professionnel. Il permet la POO, il fonctionne sous Windows, 95 à Win 10, Mac OS, Linux etc..
La dernière mise à jour date du 29-Jun-2016. Ce système de développement, aux Etats Unis est utilisé par un nombre incalculables d'industries et de développeurs, y compris NASA et autres.
Ce système de développement est également connu en Europe. Par contre, il semblerait qu'en France c'est parfaitement inconnus au bataillon.
Chaque fois que je poste le moindre message, je me fait agresser par des gens qui n'ont peut' être jamais écris, avec ce système, 10 lignes de code qui fonctionnent.
Je me fais insulter de toutes parts. Je souhaite faire remarquer que ceci n'est pas une attitude de scientifique.
Alors Messieurs ( je n'ai pas le sentiments que les dames participent à cette opération de dénigrement),

de quel droit prétendez-vous détenir la vérité au sujet d'une technique de programmation, alors que ce n'est pas une science?

je n'ai jamais critiqué les méthodes de travail de qui que ce soit.
La seule chose que j'ais fais est de dire qu'il existe d'autres méthodes que celles décrites couremment ici.
Qu'il se pourrait bien que ces méthodes autres soient également efficaces.
Alors Messieurs, expliquez-moi votre attitude, s.v.p. mais sans insultes.

Cordialement

Ludwig
-----

[Jack]

Et quel est le nom de ce système de développement si célèbre?

[inviteaa639fb9]

à tout hasard je dirais... Forth

[invite2800a7c8]

Et quel est le nom de ce système de développement si célèbre?

Salut,
C'est pas célèbre c'est inconnu . Voici un lien vers la version d'essai qui est gratuite.

https://www.forth.com/download/

mais s.t.p. ne m'accuse pas de vouloir faire de la Pub.

Il faut lancer l'exécutable sf.exe que tu trouveras dans le répertoire BIN

à ta disposition si tu le souhaites

Cordialement
Ludwig

[A voir en vidéo sur Futura]

[invite29cafaf3]

Salut,
C'est pas célèbre c'est inconnu

Alors là, sans agressivité, c'est quelque peu contradictoire avec les déclarations de votre premier post :

Ce système de développement, aux Etats Unis est utilisé par un nombre incalculables d'industries et de développeurs, y compris NASA et autres.

Et, lorsque je cherche à partir de "forth" ou "swiftforth" je tombe uniquement sur des liens promotionnels ou commerciaux.
Curieusement, et ceci dit sans animosité aucune, aucun centre important qui nous dise utiliser ce système de développement miraculeux (même la NASA n'en fait pas état).
Serait-ce "secret defense".

J'espère ne pas vous avoir froissé, j'espère que vous ne vous êtes pas senti insulté, j'espère aussi que votre susceptibilité n'a pas été trop affectée par mon outrecuidance d'oser vous contrarier.

Pour terminer, VOUS proposez un système de développement révolutionnaire, OK. Prouvez qu'il est révolutionnaire, ce qu'il apporte de plus, en ergonomie, en gain de temps, en facilité de lecture, en fiabilité, en sécurité.

Si vous croyez que c'est en fournissant un lien vers une version d'essai gratuite (c'est à mourir de rire), ben non, c'est pas la bonne démarche?.

D'accord, là je suis moins aimable, mais : c'est vous qui prétendez, vous qui nous apportez le "graal" ... à VOUS de le prouvez, le renversement de la preuve n'est ni éthique ... ni scientifique (à vrai dire c'est de la malhonnêteté).

[pm42]

Si, si, j'ai fait pas mal de Forth mais dans les années 80 quand ça avait encore du sens...

Je cite l'article de Wikipedia sur le sujet :

"L'augmentation de performance des micro-contrôleurs permettant désormais la programmation des applications de ce type en langage C, désormais érigé en assembleur universel, l'utilisation de Forth régresse sur son terrain de prédilection. Plus généralement, la tendance étant à ce que le programmeur devienne une ressource interchangeable (ce qui permet déjà l'externalisation de certains développements) au détriment de l'expérience et de la compétence, l'utilisation de Forth ne peut que décliner."

Ca donne une idée de l'avenir du langage.
On peut également noter qu'il n'est pas dans les 50 langages les plus utilisés du classement TIOBE et n'apparait même pas dans les autres (Redmonk, etc).

Pour le reste, le problème est que quelque soit le sujet, Ludwig1 répond avec Forth et finit par expliquer les architectures de Turing comme réponse à toute objection...
Je ne commenterais pas son niveau en informatique, ceux qui ont participé à sa pollution systématique de presque tous les fils sur la programmation savent ce que j'en pense.

[invite2800a7c8]

Salut,

Alors là, sans agressivité, c'est quelque peu contradictoire avec les déclarations de votre premier post :

C’est dit avec humour Comprendre Inconnu en France

Et, lorsque je cherche à partir de "forth" ou "swiftforth" je tombe uniquement sur des liens promotionnels ou commerciaux. Curieusement, et ceci dit sans animosité aucune, aucun centre important qui nous dise utiliser ce système de développement miraculeux (même la NASA n'en fait pas état). Serait-ce "secret défense".

Pas de dialectique s.t.p. je n’ai à aucun moment utilisé le mot miraculeux. Pour ce qui est du reste, je donne la parole au regretté Julian Noble qui enseignait la physique nucléaire à l’université de Virginie.

Posté par Julian Noble

Forth est un langage informatique inhabituel qui a probablement été appliqué à des projets plus variés que tout autre. C'est le choix évident quand le projet est exceptionnellement exigeant en termes de vitesse d'exécution, de compacité du code ou toute combinaison de
ce qui précède.
Il a également été appelé "... l'un des secrets les mieux gardés dans le monde de l'informatique." Ce n'est pas exagéré: les grandes entreprises ont acheté des systèmes de développement professionnels Forth de fournisseurs tels que :
Laboratoire Microsystèmes, Inc, ForthInc. Ou MicroProcessor Engineering, Ltd. et les ont contraint au secret.
Certains spéculent (méchamment) que les géants de la profession préfèrent cacher leur honte à utiliser Forth; Mais je crois plutôt que ce faisant, ils dissimulent une arme secrète envers leurs rivaux. Chaque fois que Forth a concouru directement avec un langage plus conventionnel comme C ou autre, il a gagné en plus efficace, produisant plus petit, plus rapide, du code plus fiable dans beaucoup moins de temps. J'ai cherché des exemples avec le résultat opposé, mais nous avons a été incapables de trouver un seul cas.

J'espère ne pas vous avoir froissé, j'espère que vous ne vous êtes pas senti insulté, j'espère aussi que votre susceptibilité n'a pas été trop affectée par mon outrecuidance d'oser vous contrarier.

Pourquoi serait- je froissé ? Ou contrarié, tant que la discussion reste objective il n’y a pas de raison.

Pour terminer, VOUS proposez un système de développement révolutionnaire, OK. Prouvez qu'il est révolutionnaire, ce qu'il apporte de plus, en ergonomie, en gain de temps, en facilité de lecture, en fiabilité, en sécurité.

Encore une fois, pas de dialectique, moi je ne propose rien du tout, je dis juste comment je fais et avec quoi je travaille. Je ne dois rien prouver du tout je ne suis pas vendeur mais juste utilisateur. Personne n’est obligé de travailler avec ces outils.

Si vous croyez que c'est en fournissant un lien vers une version d'essai gratuite (c'est à mourir de rire), ben non, c'est pas la bonne démarche?

J’ai mis ce lien pour ceux qui veulent voir, si tu connais tu peux également essayer d’écrire quelques lignes de codes ça n’engage à rien. Au moins tu pourras mieux voir de quoi on parle. Ça c’est pragmatique.

D'accord, là je suis moins aimable, mais : c'est vous qui prétendez, vous qui nous apportez le "graal" ... à VOUS de le prouvez, le renversement de la preuve n'est ni éthique ... ni scientifique (à vrai dire c'est de la malhonnêteté).

Encore une fois, je ne n’apporte rien, je n’ai rien à prouver, je dis juste ce qui existe et comment je fais.
Cordialement
Ludwig

[invite2800a7c8]

Salut,

Si, si, j'ai fait pas mal de Forth mais dans les années 80 quand ça avait encore du sens...

Justement ça fait 35 ans, entre temps il a passé beaucoup d'eau sous les ponts, tu devrais essayer à nouveau.
Maintenant que tu sais sur quel site tu peux charger une machine virtuelle ça ne devrai pas être très compliqué pour toi.

Cordialement

Ludwig

[pm42]

Justement ça fait 35 ans, entre temps il a passé beaucoup d'eau sous les ponts, tu devrais essayer à nouveau.

Le Forth, c'est ton obsession. Il se trouve que je connais assez de langages et paradigmes et que j'ai continué à manipuler même des langages à piles très récemment pour savoir ce que je trouve le plus efficace. Et que j'ai regardé aussi Forth assez récemment.
Et ce n'est pas du tout cela.

Au demeurant, le sujet n'est pas le Forth : c'est ton obsession à polluer tous les fils de programmation avec des hors sujets qui terminent toujours par toi, tes collègues, ta vie et j'en passe.
On aimerait pouvoir simplement répondre aux questions sans que tout se ramène à tes problèmes perso.

[JPL]

On aimerait pouvoir simplement répondre aux questions sans que tout se ramène à tes problèmes perso.

Et sans parler de ce qui n'est pas demandé.

[invite29cafaf3]

Pour ce qui est du reste, je donne la parole au regretté Julian Noble qui enseignait la physique nucléaire à l’université de Virginie.

Alors, pour autant que je sache, un physicien nucléaire n'est pas un informaticien ni un spécialiste en informatique (chacun son domaine s'il vous plaît), secundo les arguments d'autorité sont très mal venus.

Encore une fois, pas de dialectique, moi je ne propose rien du tout, je dis juste comment je fais et avec quoi je travaille. Je ne dois rien prouver du tout

Ah :

Ce système de développement, aux Etats-Unis est utilisé par un nombre incalculables d'industries et de développeurs, y compris NASA et autres.

A part cela, vous ne proposez rien, ... vous connaissez la notion de prosélytisme ? D'accord, vous allez m'accuser de "dialectique" (j'aimerais d'ailleurs que vous me fournissiez la définition de ce mot qui semble vous faire horreur.

Encore une fois, je ne n’apporte rien, je n’ai rien à prouver, je dis juste ce qui existe et comment je fais.

Ben c'est bien ce que l'on vous dit, vous n'apportez rien, hormis nous ressassez que vous utilisez un langage utilisé par un nombre "incalculable" d'industries et de développeurs (on est vraiment cons de ce côté-ci de l'atlantique).
Prouver, ben oui, prouvez nous, montrez nous donc un programme fabuleux développé par vos soins avec ce langage si performant.
Ce qui existe oui, nous savons que forth existe, ce que vous en faites ben on attend ... et citer la NASA et de "nombreuses industries" n'est pas une preuve, même pas une référence.

Bonne soirée

[invite6486d7bd]

Ca y est, je me souviens de Forth

Je l'ai en fait pratiqué sous sa forme RPL, sur une calculatrice HP48GX.
Et effectivement, ça permet de produire des logiciels parfois compliqués (j'ai fait par exemple des simlifes de type amibe avec), très compact et très sûrs.
Le contre-coup c'est qu'il faut s'habituer à programmer par empilage, c'est très déroutant au début mais curieusement on s'y fait assez vite.
http://www.gecif.net/articles/mathematiques/hp48gx/

[Jack]

Quand je pense que j'ai failli me laisser tenter par ceci à l'époque ...

[invite6486d7bd]

Quand je pense que j'ai failli me laisser tenter par ceci à l'époque ...

A l'époque il me semblait que c'était le must de la "calculatrice" scientifique, graphique qui plus est.
Très utile avec ses nombreuses fonctions scientifiques réemployable, évidement (c'est du forth...) dans les programmes.
Maintenant, c'est vrai qu'un vrai PC aurait été plus performant, mais moins facile à déplacer.

Peut-être un petit bémol quand même concernant Forth, la programmation multitâche doit être un peu compliquée.

[Jack]

A l'époque il me semblait que c'était le must de la "calculatrice" scientifique, graphique qui plus est.
Très utile avec ses nombreuses fonctions scientifiques réemployable, évidement (c'est du forth...) dans les programmes.
Maintenant, c'est vrai qu'un vrai PC aurait été plus performant, mais moins facile à déplacer.

Peut-être un petit bémol quand même concernant Forth, la programmation multitâche doit être un peu compliquée.

Et un petit peu plus cher: il fallait compter dans les 30 000 F pour un PC

[invite6486d7bd]

Et un petit peu plus cher: il fallait compter dans les 30 000 F pour un PC

Je ne me suis même pas posé la question à l'époque, effectivement ça devait être cher.
Mais même la calculatrice, elle n'était pas donnée à l'époque (par contre elle s'est bien revendue).
Et petit gadget amusant, pour l'anecdote, elle pouvait emmètre des signaux infrarouges.

[invite2800a7c8]

Peut-être un petit bémol quand même concernant Forth, la programmation multitâche doit être un peu compliquée.

Salut,

Regarde ceci, c'est le code source de la gestion du multitâche,
Personnellement, ( par habitude ) j'utilise le Round Robin au travers des mots STOP et PAUSE
c'est ultra simple.

NOTA: dans le monde Forth il est de tradition depuis toujours, de fournir tous les codes sources, pas seulement des exécutables, ceci comme le réclament les gens qui s'occupent de sécurité informatique.
Demandez donc les codes sources chez Microsoft.

Voici le source qui gère le multitâche c'est parfaitement intégré
dans les systèmes d'exploitations.
Ici de win 95 Jusqu 'à Win 10

{ ====================================================================
tasking.f
MultiTasking support


==================================================================== }

?( MultiTasking support)

$7FFF CONSTANT WM_BREAK         \ constant for message dispatcher

: NOD ( -- )
   BEGIN STOP AGAIN ;

: HIS ( a a - a)   STATUS -  SWAP @ + ;
: MYSELF ( -- a )   TCB @ ;

{ --------------------------------------------------------------------

Multitasking initialization and Critical Sections

Note that a critical section _must_ be cleared before calling
InitializeCriticalSection, else the api may fail and delete
another process-owned critical section...

-------------------------------------------------------------------- }

CREATE SF-CRITICAL  512 /ALLOT

: [C
   SF-CRITICAL EnterCriticalSection DROP ;

: C]
   SF-CRITICAL LeaveCriticalSection DROP ;

{ --------------------------------------------------------------------

RESOURCE SEMAPHORES

-------------------------------------------------------------------- }

: ?FREE ( a -- a t )
   DUP @  DUP 0=  SWAP STATUS =  OR ;

: GRAB ( a -- )   BEGIN
   [C ?FREE NOT WHILE C] PAUSE REPEAT
   STATUS SWAP ! C] ;

: RELEASE ( a -- )
   [C ?FREE IF  OFF  ELSE  DROP  THEN  C] ;

: GET ( a -- )
   PAUSE GRAB ;

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

?( ... Operator and deferred PAUSE)

VARIABLE TASKS

CREATE OPERATOR
   UP@ ,        \ user area
    -1 ,        \ size
    -1 ,        \ threadid
    -1 ,        \ hthread
    -1 ,        \ link

:ONSYSLOAD   UP@ OPERATOR ! ;

: OPERATOR'S ( -- )

   OPERATOR 'PERSONALITY HIS @ 'PERSONALITY ! ;

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

CODE MSG@ ( -- msg )

   PUSH(EBX)
   WINMSG CELL+ [U] EBX MOV
   $FFFF # EBX AND
   RET
 
END-CODE

VARIABLE DLGACTIVE

: GOODBYE
   'ONENVEXIT CALLS 'ONSYSEXIT CALLS  0 ExitProcess DROP ;

-? : FINISHED ( -- )
   UP@ OPERATOR @ = IF  GOODBYE  THEN  0 ExitThread DROP ;

-? : MSGDISPATCH ( -- )
   DLGACTIVE @ IF  DLGACTIVE @ WINMSG IsDialogMessage ?EXIT  THEN
   MSG@ WM_QUIT = IF FINISHED THEN
   MSG@ WM_BREAK = IF IOR_BREAK THROW THEN
   WINMSG TranslateMessage DROP
   WINMSG DispatchMessage DROP ;

{ --------------------------------------------------------------------

STOP and PAUSE are holdover terminology from cooperative round-robin
multitasking models of Forth. The paradigm is so ingrained that it
is probably reasonable to leave them in, but to encourage the user to
use the real base functions that represent what the program is doing.

So, the user must always have the program do one of two things: either
check to see if a message is waiting (via PAUSE) or wait for a message
(via STOP).

A thread that has stopped without a message loop must be
activated in order to run again.

-------------------------------------------------------------------- }

: WINSTOP ( -- )
   HWND IF
      WINMSG 0 0 0 GetMessage
      0> IF  MSGDISPATCH EXIT THEN
      FINISHED EXIT
   THEN
   GetCurrentThread SuspendThread DROP ;

: WINPAUSE ( -- )
   HWND IF
      BEGIN
         WINMSG 0 0 0 PM_NOREMOVE PeekMessage WHILE
         WINMSG 0 0 0 GetMessage  0> WHILE
         MSGDISPATCH
      REPEAT FINISHED THEN EXIT
   THEN  1 Sleep DROP ;

' WINSTOP IS STOP
' WINPAUSE IS PAUSE

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

: DISPATCHER ( -- res )
   BEGIN
      WINMSG 0 0 0 GetMessage WHILE
      WINMSG TranslateMessage DROP
      WINMSG DispatchMessage DROP
   REPEAT WINMSG 2 CELLS + @ ( wparam) ;

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

: /TASKING
   OPERATOR TCB !
   OPERATOR  UP@ !+
   #USER 8192 + 8191 AND !+
   GetCurrentThreadId !+
   GetCurrentThread   !+ DROP
   SF-CRITICAL 512 ERASE        \ erase because the api expects a clean structure
   SF-CRITICAL InitializeCriticalSection DROP ;

: TASKING/   SF-CRITICAL DeleteCriticalSection DROP ;

:ONSYSLOAD   /TASKING ;
:ONDLLLOAD   /TASKING ;

:ONSYSEXIT   TASKING/ ;
:ONDLLEXIT   TASKING/ ;

{ --------------------------------------------------------------------

Threads can be of two types in windows:

1) an entity that runs, spending most of its time waiting for events
2) an entity that has a window associated with it and waits for messages

Note that both types of threads must spend most of their time waiting;
this is as it should be for almost all windows programs.

Type 1 routines may call @MESSAGE or ?MESSAGE, but the effect is
to give up the rest of it's time slice. The resulting execution
granularity is about 10ms for @MESSAGE and 1ms for ?MESSAGE.

Type 2 must call @MESSAGE and ?MESSAGE.

This is the user's responsibility to do, although many of the standard Forth
words will do it automatically.

-------------------------------------------------------------------- }

{ --------------------------------------------------------------------

A created task consists of only a data structure containing a size
and a link to the other tasks in the system.  To be useful, it
must be CONSTRUCT -ed at runtime.

TASK  defines a task whose combined user and data stack will be n
   bytes in size. Invoking <taskname> returns the address of the
   task's Task Control Block (TCB).

-------------------------------------------------------------------- }

: TASK ( n -- ) \ Usage: n TASK <name>
   CREATE
      0 ,               \ user area
      16384 MAX ,       \ size
      0 ,               \ threadid
      0 ,               \ hthread
      TASKS >LINK ;     \ link

: TASKHANDLE ( task -- a )   [ 3 CELLS ] LITERAL + ;

THROW#
   S" Can't construct task" >THROW ENUM IOR_CONSTRUCTTASK
   S" Can't resume task"    >THROW ENUM IOR_RESUMETASK
TO THROW#

{ --------------------------------------------------------------------

Windows 95/98 requres that a created task be run before it is
modified via the SetThreadContext function. On task construction,
we call the /THREAD behaviour, which initializes the running
task and then sleeps immediately.  That it is running and almost
suspended is detectable via the USERAREA pointer in the TCB being
changed from its initial zero.

-------------------------------------------------------------------- }

LABEL /THREAD
   EAX EAX XOR                    \ zero
   ESP EBP MOV                    \ top of data stack
   32 # EBP SUB                   \ padding on data stack
   36 [EBP] EBX MOV             \ get param from task control block
   4 [EBX] ECX MOV              \ ecx = total memory required
   ECX 2 # SAR                     \ ecx = total cells required
   BEGIN  EAX PUSH  LOOP    \ fill dstack+user area with zero
   ESP ESI MOV                     \ set user area pointer
   8 # ECX MOV                     \ 8 more for top of return stack
   BEGIN  EAX PUSH  LOOP     \ fill rstack pad with zero
   'ORG CALL
   ASM]
      UP@ #USER ERASE          \ clear my user area completely
      ( task) TCB !                    \ remember my own tcb
      SP@ S0 !  RP@ R0 !         \ and my initial stack pointers
      WPARMS 'WF !                \ dummy wf so hwnd works and is zero
      UP@ #USER + H !           \ dummy dictionary
      DECIMAL                        \ default base
      [C UP@ TCB @ ! C]         \ write my user pointer into tcb
      NOD ;                            \ and doze off

: CONSTRUCT ( task -- )   >R
      0                                   \ security attributes
      R@ CELL+ @ 4096 +      \ stack size
      /THREAD                       \ start address
      R@                               \ argument for new thread
      0                                  \ creation flag
      R@ 2 CELLS +               \ where to put thread id
     CreateThread                 \ returns 0 or handle
     DUP 0= IOR_CONSTRUCTTASK ?THROW      \ throw if can't create
     R@ TASKHANDLE !          \ save thread handle
   BEGIN                              \ and wait for init to finish
      PAUSE                           \
      R@  @                           \ /THREAD sets this when done
   UNTIL R> DROP ;              \ save thread handle

{ --------------------------------------------------------------------

ACTIVATE instantiates the specified task and starts it executing the
   words following ACTIVATE. Must be used inside a definition. The words
   following ACTIVATE must be either structured as an infinite loop or
   must end with TERMINATE, so that the semicolon at the end of the
   definition is never executed.

   If the task was already instantiated, ACTIVATE will simply set
   a new value into its EIP.  The task will begin executing the
   specified code when it RESUMES.

-------------------------------------------------------------------- }

: RESUMES ( task -- )
   TASKHANDLE @ BEGIN
      DUP ResumeThread  DUP 0< IOR_RESUMETASK ?THROW
      2 <
   UNTIL DROP ;

{ --------------------------------------------------------------------

SUSPEND and RESUME are convenient words for managing tasks.
The return IORs because we can't guarantee that we can perform
the operation; we do our best.

-------------------------------------------------------------------- }

: RESUME ( task -- ior )
   TASKHANDLE @ BEGIN
      DUP ResumeThread  DUP 0< ?EXIT
      2 <
   UNTIL DROP 0 ;
   
: SUSPEND ( task -- ior )
   TASKHANDLE @ SuspendThread 0< ;


{ --------------------------------------------------------------------
#######################################
-------------------------------------------------------------------- }


WINDOWS-INTERFACE +ORDER

#USER |CPU_CONTEXT| +USER CPU-CONTEXT  TO #USER

: ACTIVATE ( task -- )   R> SWAP >R  ( addr to activate)
   R@ @ 0= IF R@ CONSTRUCT THEN

   R@ TASKHANDLE @ SuspendThread DROP
   $10003 R@ CPU-CONTEXT HIS !
   R@ TASKHANDLE @  R@ CPU-CONTEXT HIS GetThreadContext DROP

   ( addr)      R@ CPU-CONTEXT HIS 'EIP + !
   R@ @         R@ CPU-CONTEXT HIS 'ESI + !
   R@ S0 HIS @  R@ CPU-CONTEXT HIS 'EBP + !
   R@ R0 HIS @  R@ CPU-CONTEXT HIS 'ESP + !
   ORIGIN       R@ CPU-CONTEXT HIS 'EDI + !

   R@ TASKHANDLE @  R@ CPU-CONTEXT HIS SetThreadContext DROP

   'THIS @  R@ 'THIS HIS !
   'SELF @  R@ 'SELF HIS !

   R> RESUMES ;

WINDOWS-INTERFACE -ORDER

{ --------------------------------------------------------------------

TERMINATE  causes the task executing this word to cease operation
                  and release all its memory back to windows.  A task that has been
                  terminated may be re-activated.
        
KILL            causes a task to end itself and remove itself from memory.

HALT           stops the specified task.

-------------------------------------------------------------------- }

: TERMINATE ( -- )

   [C TCB @ OFF C]  0 ExitThread DROP NOD ;

: KILL ( task -- )

   ACTIVATE TERMINATE ;

: HALT ( a -- )

   ACTIVATE NOD ;

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

: TASK\ ( task -- )   


   >R
   R@ KILL BEGIN
      PAUSE R@ @ 0=
   UNTIL R> DROP 

;

: TASKS/ ( -- )

   TASKS BEGIN
      DUP @REL WHILE
      DUP @REL  ?PRUNED IF
         DUP @REL 4 CELLS - TASK\
         DUP @REL UNLINK
      ELSE  @REL
      THEN
   REPEAT  DROP 

;

: /TASKS

   TASKS BEGIN
      @REL ?DUP WHILE
      DUP OPERATOR 4 CELLS + <> IF
         4 CELLS -  0 !+ CELL+ 0 !+ 0 !+
      THEN
   REPEAT

 ;

:ONSYSLOAD /TASKS ;
:ONDLLLOAD /TASKS ;

:PRUNE  TASKS/ ;

\\

{ --------------------------------------------------------------------


*********************      MultiTasking test cases **********************


-------------------------------------------------------------------- }

20000 TASK FOO

VARIABLE BAR

: GO1
   FOO CONSTRUCT ;
: GO2 FOO ACTIVATE
   BEGIN   1 BAR +!  100 Sleep DROP AGAIN ;



20000 TASK T0
20000 TASK T1
20000 TASK T2
20000 TASK T3
20000 TASK T4
20000 TASK T5

: TRY ( n task -- )
   DUP CONSTRUCT
   SWAP OVER BLK HIS !
   ACTIVATE BEGIN
      BLK @ MS
      DPL ++
   AGAIN ;

VARIABLE FOO

: BOTHER
   T0 ACTIVATE BEGIN
      0 Sleep DROP
      DPL ++
      DPL @ $FFF AND 0= IF
         0 ['] @ CATCH 2DROP
         FOO ++
      THEN
   AGAIN ;

: GO
   10 T0 TRY
   20 T1 TRY
   30 T2 TRY
   40 T3 TRY
   50 T4 TRY
   60 T5 TRY ;

: ??
   T0 DPL HIS ?
   T1 DPL HIS ?
   T2 DPL HIS ?
   T3 DPL HIS ?
   T4 DPL HIS ?
   T5 DPL HIS ? ;

: OBSERVE
   BEGIN CR ?? 500 MS KEY? UNTIL ;

Cordialement

Ludwig

[Jack]

mmmmh, des adresses en dur, des registres CPU, du langage d'assemblage: pas très portable tout çà ...

[invite6486d7bd]

Regarde ceci, c'est le code source de la gestion du multitâche,

D'accord, effectivement, le multitache avec file d'attente de message semble bien géré.

mmmmh, des adresses en dur, des registres CPU, du langage d'assemblage: pas très portable tout çà ...

Je ne vois pas les adresses en dur.
Par contre les registres CPU et les instructions d'Assembleur (gage de contrôle sur les performances) sont effectivement fixés.
A voir comment c'est géré au niveau compilateur peut-être ?

[invite2800a7c8]

mmmmh, des adresses en dur, des registres CPU, du langage d'assemblage: pas très portable tout çà ...

Salut,

Ca c'est la partie qui est incluse dans le kernel du système. Dans le cas présent un kernel qui tourne sous Windows avec des processeurs Intel ou équivalents.
Lors de la programmation, on est utilisateur de ces mots, on n'a donc pas à se soucier de la portabilité.
Exemple: quand j'utilise le mot PAUSE je ne me préoccupe pas du processeur hôte qui va exécuter ce mot.
Pour voir comment est construit le mot PAUSE pour le Processeur Intel de nom Laptop,

j'écris au clavier see PAUSE

see PAUSE
409CCF   4022AF ( (DEFER) ) CALL        E8DB85FFFF

WINPAUSE
4319CF   4 # EBP SUB                    83ED04
4319D2   EBX 0 [EBP] MOV                895D00
4319D5   44 [ESI] EBX MOV               8B5E44
4319D8   0 [EBX] EBX MOV                8B1B
4319DA   EBX EBX OR                     09DB
4319DC   0 [EBP] EBX MOV                8B5D00
4319DF   4 [EBP] EBP LEA                8D6D04
4319E2   431A71 JZ                      0F8489000000
4319E8   4 # EBP SUB                    83ED04
4319EB   EBX 0 [EBP] MOV                895D00
4319EE   24 [ESI] EBX LEA               8D5E24
4319F1   8 # EBP SUB                    83ED08
4319F4   EBX 4 [EBP] MOV                895D04
4319F7   0 # 0 [EBP] MOV                C7450000000000
4319FE   0 # EBX MOV                    BB00000000
431A03   8 # EBP SUB                    83ED08
431A06   EBX 4 [EBP] MOV                895D04
431A09   0 # 0 [EBP] MOV                C7450000000000
431A10   0 # EBX MOV                    BB00000000
431A15   406F4F ( PeekMessage ) CALL    E83555FDFF
431A1A   EBX EBX OR                     09DB
431A1C   0 [EBP] EBX MOV                8B5D00
431A1F   4 [EBP] EBP LEA                8D6D04
431A22   431A70 JZ                      0F8448000000
431A28   4 # EBP SUB                    83ED04
431A2B   EBX 0 [EBP] MOV                895D00
431A2E   24 [ESI] EBX LEA               8D5E24
431A31   8 # EBP SUB                    83ED08
431A34   EBX 4 [EBP] MOV                895D04
431A37   0 # 0 [EBP] MOV                C7450000000000
431A3E   0 # EBX MOV                    BB00000000
431A43   4 # EBP SUB                    83ED04
431A46   EBX 0 [EBP] MOV                895D00
431A49   0 # EBX MOV                    BB00000000
431A4E   406F1F ( GetMessage ) CALL     E8CC54FDFF
431A53   EBX EBX OR                     09DB
431A55   0 [EBP] EBX MOV                8B5D00
431A58   4 [EBP] EBP LEA                8D6D04
431A5B   431A6B JLE                     0F8E0A000000
431A61   43188F ( MSGDISPATCH ) CALL    E829FEFFFF
431A66   4319E8 JMP                     E97DFFFFFF
431A6B   43182F ( FINISHED ) CALL       E8BFFDFFFF
431A70   RET                            C3
431A71   4 # EBP SUB                    83ED04
431A74   EBX 0 [EBP] MOV                895D00
431A77   1 # EBX MOV                    BB01000000
431A7C   42D84F ( Sleep ) CALL          E8CEBDFFFF
431A81   0 [EBP] EBX MOV                8B5D00
431A84   4 # EBP ADD                    83C504
431A87   RET                            C3

Pour faire du multitâche sur un Arduino j'utiliserai également le mot PAUSE, sans me soucier du processeur hôte.
Mais tous ça c'est rien de particulier tout le monde fait comme ça. Java marche aussi comme ça je crois.

Pour ce qui est des adresses en dur, elles sont exprimées par rapport à la structure interne de la machine virtuelle donc aucune incidence.

Il faut savoir qu'une fois installée, la machine virtuelle prend le contrôle des opérations. C'est la grande différence par rapport à ce qui existe par ailleurs. Il est vrai qu'il faut une période d'adaptation pour assimiler ceci.
Dans le cas de Windows de Microsoft, on procède de la façon suivante:
On déguise la machine virtuelle en .EXE qui est vu par MS comme étant une banale application avec un seul Callback. Tous se passe comme si tu avais une console reliée à un calculateur au travers d'une liaison série.
A l'intérieur de la machine Virtuelle, on reconstruit les callbacks particuliers pour une application donnée qui elle tourne maintenant dans la machine virtuelle, qui va se servir des ressources mises à disposition par MS.

https://msdn.microsoft.com/en-us/lib...49(VS.85).aspx

et tout le reste.

Vu coté MS on est une bête application, vu coté MV ont pilote le calculateur, en clair, on est maitre à bord.
C.a.d un monde totalement différent de ce que tu as l'habitude de faire.

Cordialement
Ludwig

[pm42]

On est dans le ridicule habituel...
De l'assembleur en boucle. Encore mieux que du Forth

[invite2800a7c8]

Resalut,

D'accord, effectivement, le multitache avec file d'attente de message semble bien géré.

A voir comment c'est géré au niveau compilateur peut-être ?

A vrai dire, ici la notion de compilateur n'est pas celle généralement utilisée.
Il n'y a pas de compilateur pris au sens propre du terme.

Tu auras probablement remarqué que les définitions de mots commencent par le caractère : ( Lire deux points )
et se terminent par le caractère ; (Lire point virgule)

Je reprend un extrait de code du module de gestion multitâche.

{ --------------------------------------------------------------------

STOP and PAUSE are holdover terminology from cooperative round-robin
multitasking models of Forth. The paradigm is so ingrained that it
is probably reasonable to leave them in, but to encourage the user to
use the real base functions that represent what the program is doing.

So, the user must always have the program do one of two things: either
check to see if a message is waiting (via PAUSE) or wait for a message
(via STOP).

A thread that has stopped without a message loop must be
activated in order to run again.

-------------------------------------------------------------------- }

: WINSTOP ( -- )
   HWND IF
      WINMSG 0 0 0 GetMessage
      0> IF  MSGDISPATCH EXIT THEN
      FINISHED EXIT
   THEN
   GetCurrentThread SuspendThread DROP ;

: WINPAUSE ( -- )
   HWND IF
      BEGIN
         WINMSG 0 0 0 PM_NOREMOVE PeekMessage WHILE
         WINMSG 0 0 0 GetMessage  0> WHILE
         MSGDISPATCH
      REPEAT FINISHED THEN EXIT
   THEN  1 Sleep DROP ;

' WINSTOP IS STOP
' WINPAUSE IS PAUSE

on peut lire : WINSTOP

le mot : (deux points) fait passer la machine virtuelle en mode compilation c'est à dire qu'on va commencer par ajouter une entrée de dictionnaire de nom WINSTOP puis on va compiler dans le dictionnaire les uns après les autres les pointeurs sur les mots qui suivent ( ils sont déjà connus ) puis on ferme la nouvelle définition ( mot ) par ; (point virgule) qui fait repasser la machine
virtuelle en mode interprété.

Chaque fois que j'aurai besoin de la fonction (ou méthode, ou procédure ou, ou, .... ) j'écrirais dans mon source
WINSTOP ou STOP ( comme on fait partout d'ailleurs).

Cordialement

Ludwig

[invite2800a7c8]

Salut,

On est dans le ridicule habituel...
De l'assembleur en boucle. Encore mieux que du Forth

De quoi occuper ton après-midi, un exemple comment écrire un cross assembleur avec notation Polonaise inversée,
tu pourras t'en inspirer au cas ou tu souhaite écrire un cross pour un PowerPC.

PACKAGE ASM-WORDLIST

{ --------------------------------------------------------------------
This assembler assumes at least an 80386 operating in protected mode.

Exports: Assembler word set
-------------------------------------------------------------------- }

HEX

THROW#
     S" Destination must be a register" >THROW ENUM IOR_ASM_NOTREG
     S" Illegal operand"                >THROW ENUM IOR_ASM_ILLOP
     S" Unresolved forward references"  >THROW ENUM IOR_ASM_FWDREF
     S" Branch out of range"            >THROW ENUM IOR_ASM_RANGE
     S" Invalid condition code"         >THROW ENUM IOR_ASM_INVALIDCC
TO THROW#

{ ---------------------------------------------------------------------

Assembler support

HERE(A), ALLOT(A), and C!(A) are defined here so their actions can be
changed to support the target compiler.

SHORT? returns true if n can be represented by a signed byte.
LONG? returns true if n requires greater than signed byte.
ILLOP? aborts if illegal operand flag is true.

--------------------------------------------------------------------- }

DEFER HERE(A)           ' HERE IS HERE(A)
DEFER ALLOT(A)          ' ALLOT IS ALLOT(A)
DEFER C!(A)             ' C! IS C!(A)

: C,(A) ( n -- )   HERE(A)  1 ALLOT(A)  C!(A)  ;
: W,(A) ( n -- )   DUP C,(A)  >< C,(A)  ;
: ,(A) ( n -- )   DUP W,(A)  >H< W,(A) ;

: SHORT? ( n -- flag)   -80 80 WITHIN ;
: LONG? ( n -- flag)   SHORT? NOT ;
: ILLOP? ( flag -- )   IOR_ASM_ILLOP ?THROW ;


{ ---------------------------------------------------------------------

Local labels

Unresolved fwd reference associative stack.  Associate stacks can be
"popped" from the middle, or wherever the key is found.

BWDS is the resolved label value array.  Cleared by /ASM.
LPUSH pushes unresolved reference.
LPOP pops any unresolved references.
L? returns the address of the label n or 0 if unresolved.

L: assigns HERE to label n-1.  Resolves any forward references.
Assumes 8-bit relative displacements.

/ASM initializes local labels and switches.

--------------------------------------------------------------------- }

20 CONSTANT MXL#

CREATE FWDS
   2 CELLS ALLOT  ( pointers)
   MXL# 2 * CELLS ALLOT  ( pairs)

CREATE BWDS
   MXL# CELLS ALLOT

: LPUSH ( value=here' key=label# -- )
   FWDS 2@ = 0= HUH? ( full?)  FWDS @ 2!  2 CELLS FWDS +! ;

: LPOP  ( key=label# - value=addr true | key 0 )
   >R  FWDS @  FWDS 2 CELLS + BEGIN ( end start)
      2DUP = 0= WHILE
      DUP @  R@ = IF ( found!)
         DUP CELL+ @ ( addr) >R
         SWAP 2 CELLS -  DUP FWDS !  2@ ROT 2!  \ promote last pair
         R> R> ( addr key)  -1 OR  ( addr true)  EXIT
      THEN
      2 CELLS +
   REPEAT  2DROP  R> 0 ;

: L? ( n - a | 0)   DUP MXL# U< HUH?  CELLS  BWDS + @ ;

: L: ( n -- )
   DUP L? 0= HUH?  ( should be unknown)
   HERE(A)  OVER CELLS BWDS + !     ( now known)
   BEGIN  DUP LPOP  ( a -1 | n 0)
   WHILE  HERE(A) OVER - 1-  TUCK  SHORT? HUH?  C!(A)  ( resolve ref)
   REPEAT  2DROP ;

: L# ( n -- a )   \ retrieves the value of label n-1.
   DUP L?  ?DUP 0=
   IF  HERE(A) 1+ 2DUP SWAP  LPUSH  THEN  NIP ;

: ?DANGLING ( -- )
   FWDS 2 CELLS + FWDS @ <> IOR_ASM_FWDREF ?THROW ;

: /LABELS ( -- )
   FWDS 2 CELLS + DUP FWDS !  MXL# 2 * CELLS + FWDS CELL+ !
   BWDS MXL# CELLS ERASE ;


{ ---------------------------------------------------------------------

Operands and modes

Operand and mode specifiers have A5A5 in the high half which is unlikely
to be confused with a 32-bit address.

Mode specifier format:  A5A5 <flags> <value>

Flag byte: -sss tttt
  sss (size)
      0  8-bit or N/A
      1  16-bit
      2  32-bit
      3  64-bit
      4  80-bit
  tttt (type)
      0  general register
      1  segment register
      2  special register
      3  memory (ModR/M)
      4  memory (ModR/M + SIB)
      5  immediate
      6  conditional
      7  absolute (displacement only)
      8  NDP ST register

Value byte depends on the flags.  Examples: ModR/M, Reg, SIB.

SIMPLE defines simple operand specifiers.  Most of these are registers,
except for [] and # which specify memory and immediate operands.

Examples of [] which is the same as OFFSET:

        1234 [] EAX MOV         1234 @
        1234 [] JMP             1234 @ EXECUTE

--------------------------------------------------------------------- }

: SIMPLE ( x -- )   A5A50000 + CONSTANT ;

0000 SIMPLE AL    1000 SIMPLE AX    2000 SIMPLE EAX    0100 SIMPLE ES
0001 SIMPLE CL    1001 SIMPLE CX    2001 SIMPLE ECX    0101 SIMPLE CS
0002 SIMPLE DL    1002 SIMPLE DX    2002 SIMPLE EDX    0102 SIMPLE SS
0003 SIMPLE BL    1003 SIMPLE BX    2003 SIMPLE EBX    0103 SIMPLE DS
0004 SIMPLE AH    1004 SIMPLE SP    2004 SIMPLE ESP    0104 SIMPLE FS
0005 SIMPLE CH    1005 SIMPLE BP    2005 SIMPLE EBP    0105 SIMPLE GS
0006 SIMPLE DH    1006 SIMPLE SI    2006 SIMPLE ESI
0007 SIMPLE BH    1007 SIMPLE DI    2007 SIMPLE EDI

4800 SIMPLE ST    4800 SIMPLE ST(0)
4801 SIMPLE ST(1)
4802 SIMPLE ST(2)
4803 SIMPLE ST(3)
4804 SIMPLE ST(4)
4805 SIMPLE ST(5)
4806 SIMPLE ST(6)
4807 SIMPLE ST(7)

2500 SIMPLE #     2705 SIMPLE []    2705 SIMPLE OFFSET

{ ---------------------------------------------------------------------

Operand test and access

R/M masks off the R/M field.
REG moves the low 3 bits to the REG field.

REG? returns true if m specifies any general register.
R8? returns true only if m specifies a 8-bit register.
R16? returns true only if m specifies a 16-bit register.
R32? returns true only if m specifies a 32-bit register.
ACC? returns true if m specifies EAX or AL accumulator.
SEG? returns true if m specifies a segment register.
SIZE? returns the w flag in bit 0 (see above).
@SIZE returns the size field.
IMM? returns true if there's immediate data.
ABS? returns true if m specifies an absolute address.
SIB? returns true if m specifies scaled index + base.
IDX? returns true if m specifies an indexed memory operand.
ADDR? returns true if x is an address (i.e. not a mode specifier).
MEM? returns true if m specifies a memory operand.
COND? returns true if x specifies a structured branch condition.

SIZES defines pairs of words which define a size field constant
and modify the size field of an operand.  For example, S8 is the
contents of the size field (0), and BYTE sets the size field to 0.

--------------------------------------------------------------------- }

: R/M ( m -- r)   7 AND ;
: REG ( m -- r)   R/M 3 LSHIFT ;

: REG? ( m -- flag)   FFFF8FF8 AND AL = ;
: R8? ( m -- flag)   FFFFFFF8 AND AL = ;
: R16? ( m -- flag)   FFFFFFF8 AND AX = ;
: R32? ( m -- flag)   FFFFFFF8 AND EAX = ;
: ACC? ( m -- flag)   FFFF8FFF AND AL = ;
: SEG? ( m -- flag)   FFFFFFF8 AND ES = ;
: SIZE? ( m -- w )   7000 AND 0<> 1 AND ;
: @SIZE ( m -- n)   7000 AND  1000 / ;

: IMM? ( m -- flag)   FFFF8FFF AND 2000 OR # = ;
: ABS? ( m -- flag)   2000 OR  [] = ;
: ADDR? ( x -- flag)   FFFF0000 AND A5A50000 <> ;
: IDX? ( m -- flag)   FFFF8F00 AND  A5A50300 = ;
: SIB? ( m -- flag)   FFFF8F00 AND  A5A50400 = ;
: MEM? ( m -- flag)   DUP IDX?  OVER SIB? OR  SWAP ABS? OR ;
: COND? ( x -- flag)   FFFFFF00 AND  A5A50600 = ;
: ST? ( m -- flag)   FFFFFFF0 AND  ST(0) = ;

: SIZES ( n -- )   DUP CONSTANT  CREATE 1000 * ,
   DOES> ( x1 -- x2)  @ SWAP  DUP ADDR? ILLOP?
   FFFF8FFF AND OR ;

0 SIZES S8  BYTE        \ 8-bit
1 SIZES S16 WORD        \ 16-bit integer
2 SIZES S32 DWORD       \ 32-bit integer and real
3 SIZES S64 QWORD       \ 64-bit integer and real
4 SIZES S80 TBYTE       \ BCD or 80-bit internal real

: S16? ( m -- flag)   @SIZE S16 = ;

{ ---------------------------------------------------------------------
Indexed and scaled addressing modes

INDEX defines indexed mode specifiers.  A pair of indexed mode specifiers
is used to specify base + index addressing which forces the SIB byte.

SCALE defines words which add scale factor forcing SIB byte.
--------------------------------------------------------------------- }

: INDEX  ( n -- )   CREATE  A5A50000 + ,
   DOES> ( x -- x m | m)   @  OVER SIB? ILLOP?
   OVER IDX? IF  REG OR  100 +  THEN ;

2300 INDEX [EAX]
2301 INDEX [ECX]
2302 INDEX [EDX]
2303 INDEX [EBX]
2304 SIMPLE [ESP]
2305 INDEX [EBP]
2306 INDEX [ESI]
2307 INDEX [EDI]

: SCALE  ( n -- )   CREATE  A5A50000 + ,
   DOES> ( x -- x m | m)   @  OVER IDX? NOT ILLOP?
   SWAP R/M OR ;

2440 SCALE [EAX*2]    2480 SCALE [EAX*4]    24C0 SCALE [EAX*8]
2448 SCALE [ECX*2]    2488 SCALE [ECX*4]    24C8 SCALE [ECX*8]
2450 SCALE [EDX*2]    2490 SCALE [EDX*4]    24D0 SCALE [EDX*8]
2458 SCALE [EBX*2]    2498 SCALE [EBX*4]    24D8 SCALE [EBX*8]
2468 SCALE [EBP*2]    24A8 SCALE [EBP*4]    24E8 SCALE [EBP*8]
2470 SCALE [ESI*2]    24B0 SCALE [ESI*4]    24F0 SCALE [ESI*8]
2478 SCALE [EDI*2]    24B8 SCALE [EDI*4]    24F8 SCALE [EDI*8]

Cordialement

Ludwig

[invite2800a7c8]

Re,

On est dans le ridicule habituel...
De l'assembleur en boucle. Encore mieux que du Forth

suite

{ ---------------------------------------------------------------------

Opcode compiling

OP, assembles combined opcode byte.

SIZE, takes opcode byte with reg/mode specifier and assembles opcode with
W field set for size in m.

DISP, assembles 8, 16, 32 bit displacement or immediate value.
EXT, assembles 8 or 32 bit displacement.

RR, assembles register to register ModR/M byte.  The register in m1 is placed
in the R/M field, m2 goes in the reg/opc field.

SOP, assembles ModR/M and optional SIB bytes for MR, below.
MR, assembles memory to register ModR/M byte (and SIB byte if needed).
RR/RM, assembles either reg to reg or reg to mem mode byte(s).
WRM, assembles 2-operand mem to reg opcode with w field set by register.

WRR, assembles 2-operand reg to reg opcode with w field set by regsters
whose sizes must match.

WRR/MR, assembles 2-operand reg to reg or mem to reg opcode with w field.

WR/SM,  assembles either reg to reg or reg to mem opcode with the size
field of the opcode determined by the first operand.

--------------------------------------------------------------------- }

: OP, ( op m -- )   OR C,(A)  ;

: SIZE, ( opc m --)   SIZE? OP, ;

: EXT, ( n t -- )   IF  ,(A)  ELSE  C,(A)  THEN ;

: DISP, ( n x -- )
   @SIZE CASE
      S8 OF  C,(A)  ENDOF
      S16 OF  W,(A)  ENDOF
      S32 OF  ,(A)  ENDOF
   ILLOP?  ENDCASE ;

: RR, ( m1 m2 -- )   SWAP R/M  SWAP REG OR  C0 OP, ;

: SOP, ( m reg mod -- )   ROT
   DUP SIB? IF  >R  4 OR OP,  R> C,(A)  EXIT THEN
   DUP>R  R/M OR  OP,  R> DWORD [ESP] = IF  $24 C,(A)  THEN ;

: MR, ( mem reg -- )   REG                              \ reg/opc field
   OVER ABS? IF  0 SOP, ,(A)  EXIT THEN                 \ disp32
   2 PICK LONG? IF  80 SOP, ,(A)  EXIT THEN             \ disp32 [reg]
   2 PICK 0<> IF  40 SOP, C,(A)   EXIT THEN             \ disp8 [reg]
   OVER R/M 5 = IF  40 SOP, C,(A)  EXIT THEN            \ 0 [EBP] ...
   0 SOP, DROP ;                                        \ [reg]

: RR/RM, ( disp m reg | reg reg -- )   OVER REG? IF  RR,  ELSE  MR,  THEN  ;

: WRM, ( disp m reg opc  -- )   OVER SIZE,  MR, ;

: WRR, ( reg reg opc  -- )   >R  2DUP XOR 300 AND ILLOP?
   R> OVER SIZE, RR, ;

: WRR/RM, ( disp m reg opc | reg reg opc -- )
   2 PICK REG? IF  WRR,  ELSE  WRM,  THEN ;

: WR/SM, ( r/m r op -- )   2 PICK  DUP REG? IF  SIZE, RR,
   ELSE  SIZE, MR,  THEN ;

{ ---------------------------------------------------------------------

Define instruction classes

INH1 defines simple 1-byte instructions with inherent operands.
16BIT: is the override prefix required for 16-bit operations.
16BIT, automatically compiles the prefix if either operand is 16bit.
INH2 defines simple 2-byte instructions with inherent operands.
ALU1 defines single-operand arithmetic and logical instructions.
ALU2 defines 2-operand arithmetic and logical instructions.
SH defines shift/rotate instructions.
MR defines 2-operand mem->reg32 instructions.
RMR defines 2-operand mem8/reg->reg32 instructions.
RMRW defines 2-operand mem8/reg->reg16/32 instructions.
I/D  define increment/decrement instructions.
SET defines the Set Byte on Condition class.

NPC defines numeric processor control instructions.
Format of opc passed to this defining word is:  --ppii0d
The low byte (d) is the /digit field for the R/M byte.
The ii field is the opcode byte and the optional pp field is the
prefix.  If pp is 0, no prefix is appended.

NFMR defines numeric instructions which take a single memory operand
or a pair of ST registers one of which must be ST(0).

NFR defines numeric instructions which take a pair of ST registers
whose source must be ST(0) or have ST(0) ST(1) implied.

NIM defines numeric processor instructions whose integer operand is
in memory.

NPS defines numeric processor instructions which take a single
ST register or have ST(1) implied.

REL8? takes the branch address (before opcode byte is compiled)
and returns true if an 8-bit branch will work.

REL8, and REL32, assemble the short and long branch offsets
(after the opcode is compiled).

REL  defines relative branch instructions.
--------------------------------------------------------------------- }

: INH1 ( opc)   CREATE C,
   DOES> ( -- )     C@  DUP C,(A)
   D4 D6 WITHIN IF  0A C,(A)  THEN ;            \ AAM, AAD -> Append 0A

: PRE ( opc)   CREATE C,
   DOES> ( -- )     C@ C,(A) ;

$66 PRE 16BIT:

: 16BIT, ( m -- )
   @SIZE  S16 = IF  16BIT:  THEN ;

: INH2 ( opc)   CREATE ,
   DOES> ( -- )     @ W,(A) ;

: ALU1 ( opc -- )   CREATE  C,
   DOES> ( r/m -- )    C@
   OVER 16BIT,  F6 WR/SM, ;

: ALU2 ( opc -- )   CREATE  3 LSHIFT  C,
   DOES> ( src dst -- )     C@ >R
   DUP REG? IF  DUP 16BIT,
      OVER REG? IF  SWAP R> WRR,  EXIT THEN             \ reg -> reg
      OVER MEM? IF  R> 2+ WRM,  EXIT THEN               \ mem -> reg
      SWAP IMM? NOT ILLOP?                              \ imm -> acc/reg
      DUP ACC? IF  R> 4 OR OVER SIZE,
         DISP,  EXIT THEN                               \ imm -> acc
      OVER SHORT? 2 AND 1+  OVER R32? 3 AND AND
      DUP 80 OP,  SWAP R/M C0 +  R> OP,
      1 = EXT,  EXIT  THEN
   ROT DUP REG? IF  DUP 16BIT,  R> WRM,  EXIT THEN      \ reg -> mem
   IMM? NOT ILLOP?  DUP 16BIT,                          \ imm -> mem
   2 PICK SHORT? 2 AND 1+  OVER SIZE? 0<> 3 AND AND
   DUP 80 OP,  -ROT R> 3 RSHIFT MR,  1 = EXT, ;

: SH ( /dig -- )  CREATE  C,
   DOES> ( r/m # | r/m cl | r/m -- )    C@
   OVER CL =  IF  NIP  OVER 16BIT,                      \ r/m CL shift
      D2 WR/SM,  EXIT THEN
   OVER # = IF  NIP SWAP >R  OVER 16BIT,                \ r/m imm shift
      C0 WR/SM,  R> C,(A)  EXIT THEN
   OVER 16BIT,  D0 WR/SM, ;                             \ r/m shift

: MR ( opc -- )   CREATE  C,
   DOES> ( m r --)     C@
   OVER R32? NOT ILLOP?                                 \ dest must be r32
   DUP B2 BF WITHIN IF  0F C,(A)  THEN  C,(A)  MR, ;    \ B2-BE need prefix

: RMR ( opc -- )   CREATE  C,
   DOES> ( m r --)     C@
   OVER R32? NOT ILLOP?                                 \ dest must be r32
   0F C,(A)  C,(A)  RR/RM, ;

: RMRW ( opc -- )   CREATE  C,
   DOES> ( m r --)    C@
   OVER REG? NOT ILLOP?  OVER R8? ILLOP?  OVER R16? -
   0F C,(A)  C,(A)  RR/RM, ;

: I/D ( opc -- )   CREATE  C,
   DOES> ( r/m -- )    C@
   OVER 16BIT,  OVER REG? IF  OVER R8? NOT IF           \ r16/32
      40 OR SWAP R/M OP,  EXIT  THEN THEN
   3 RSHIFT  0FE WR/SM, ;                               \ r8/m

: SET ( opc -- )   CREATE C,
   DOES> ( r/m -- )     C@
   OVER REG? IF  OVER R8? NOT ILLOP?  THEN              \ r8/m
   0F C,(A) C,(A)  0 RR/RM, ;

: NPC ( opc -- )   CREATE ,
   DOES> ( m -- )
   OVER MEM? NOT ILLOP?  @ 100 /MOD  100 /MOD
   ?DUP IF  C,(A)  THEN  C,(A)  MR, ;

: NFMR ( opc -- )   CREATE C,
   DOES> ( m | r r -- )     C@ >R
   DUP ST? IF  DUP ST(0) = IF  D8 C,(A)   SWAP R> RR,
         ELSE  OVER ST(0) <> ILLOP?  0DC C,(A)  R> RR,
   THEN DROP  EXIT  THEN  DUP MEM? NOT ILLOP?  DUP @SIZE
   CASE  S32 OF  D8  ENDOF  S64 OF  0DC   ENDOF
   1 ILLOP?  ENDCASE  C,(A)  R> MR, ;

: NFR ( opc -- )   CREATE C,
   DOES> ( r | -- )     C@
   0DE C,(A)  OVER ST? IF  RR,  ST(0) <> ILLOP?  ELSE
   1 SWAP RR,  THEN ;

: NIM ( opc -- )   CREATE C,
   DOES> ( mem -- )     C@
   OVER MEM? NOT ILLOP?  OVER @SIZE CASE  S32 OF  0DA  ENDOF
   S16 OF  0DE  ENDOF  1 ILLOP?  ENDCASE  C,(A) MR, ;

: NPS ( opc -- )   CREATE ,
   DOES> ( reg | -- )     COUNT C,(A) C@
   OVER ST? NOT IF  1 SWAP  THEN  RR, ;

: REL8? ( addr -- flag)   HERE(A) 2 + - SHORT? ;
: REL8, ( addr -- )   HERE(A) 1+ - C,(A) ;
: REL32, ( addr -- )  HERE(A) 4 + - ,(A) ;
: RANGE? ( flag -- )   IOR_ASM_RANGE ?THROW ;

: REL ( opc -- )   CREATE  C,
   DOES> ( addr -- )    C@
   OVER REL8? IF  C,(A)  REL8,  EXIT THEN               \ Short offset
   DUP 80 AND RANGE?  0F C,(A)  10 + C,(A)  REL32, ;    \ Long offset

suite

Cordialement
Ludwig

[invite51d17075]

bjr tous,
heuu ! quel est l'objet du fil, à part nous faire une demo d'un compilateur ?

[invite2800a7c8]

RE

On est dans le ridicule habituel...
De l'assembleur en boucle. Encore mieux que du Forth

suite et fin

{ ---------------------------------------------------------------------

Special instructions

These instructions don't fit into any of the above groups.

--------------------------------------------------------------------- }

: JMP  ( addr | r | disp m -- )
   DUP ADDR? IF  $E9  OVER REL8? IF  2+ C,(A)  REL8,    \ rel8
      EXIT THEN  C,(A)  REL32,  EXIT THEN               \ rel32
   0FF C,(A)  4 RR/RM, ;                                \ r/m

: LJMP  ( addr | r | disp m -- )
   DUP ADDR? IF  $E9 C,(A)  REL32,  EXIT THEN           \ rel32
   0FF C,(A)  4 RR/RM, ;                                \ r/m

: CALL  ( addr | r/m -- )
   DUP ADDR? IF  E8 C,(A)  REL32,  EXIT THEN            \ rel32
   0FF C,(A)  2 RR/RM, ;                                \ r/m

: RET ( n # | -- )
   DUP IMM? IF  DROP  ?DUP IF  C2 C,(A) W,(A)           \ imm16
   EXIT  THEN THEN  C3 C,(A) ;

: TEST ( src dst -- )

   DUP REG? IF  DUP 16BIT,
      OVER REG? IF  84 WRR/RM,  EXIT THEN               \ r/m -> reg
      SWAP IMM? NOT ILLOP?                              \ imm -> acc/reg
      DUP ACC? IF  A8 OVER SIZE,                        \ imm -> acc
      ELSE  F6 OVER SIZE,  DUP R/M C0 OP,  THEN         \ imm -> reg
      DISP,  EXIT  THEN
   ROT DUP REG? IF  DUP 16BIT,  84 WRM,  EXIT THEN      \ reg -> mem
   IMM? NOT ILLOP?  DUP >R 16BIT,  F6 R@ SIZE,          \ imm -> mem
   R@ 0 MR,  R> DISP, ;

: INT ( n -- )     DUP 3 = IF  DROP 0CC
   ELSE  0CD C,(A)  THEN  C,(A) ;

: XCHG ( r/m r | r r/m -- )
   DUP REG? NOT IF  ROT  DUP REG? NOT ILLOP?  THEN
   OVER R32?  OVER EAX = AND IF  DROP R/M 90 OP,  EXIT  THEN
   OVER EAX =  OVER R32? AND IF  R/M 90 OP, DROP  EXIT  THEN
   OVER R16?  OVER AX = AND IF  16BIT: DROP R/M 90 OP,  EXIT  THEN
   OVER AX =  OVER R16? AND IF  16BIT: R/M 90 OP, DROP  EXIT  THEN
   DUP 16BIT,  86 WRR/RM, ;

: MOV ( src dst -- )
   DUP SEG? IF  8E C,(A) RR/RM,  EXIT THEN              \ r/m -> seg
   DUP REG? IF
      OVER SEG? IF  8C C,(A) SWAP RR,  EXIT THEN        \ seg -> reg
      DUP 16BIT,  OVER IMM? IF  NIP  DUP R/M            \ imm -> reg
      OVER R8? NOT 8 AND OR  B0 OP,  DISP,  EXIT THEN
      8A WRR/RM,  EXIT THEN                             \ r/m -> reg
   ROT DUP SEG? IF  8C C,(A) MR,  EXIT THEN             \ seg -> mem
   DUP IMM? IF  DROP  DUP 16BIT,  C6 OVER SIZE,         \ imm -> mem
      DUP -ROT 0 MR,  DISP,  EXIT THEN
   DUP 16BIT,  88 WRR/RM, ;                             \ reg -> mem

: PUSH ( r32 | mem | imm -- )
   DUP SEG? IF  REG 6 OP,  EXIT THEN                    \ seg
   DUP R32? IF  R/M 50 OP,  EXIT THEN                   \ r32
   DUP R16? IF  16BIT:  R/M 50 OP,  EXIT THEN           \ r16
   DUP MEM? IF  DUP 16BIT,  0FF C,(A) 6 MR,  EXIT THEN  \ mem
   DUP IMM? NOT ILLOP?  16BIT,  DUP SHORT? IF           \ imm
      6A C,(A) C,(A)                                    \ imm8
   ELSE  68 C,(A) ,(A)  THEN ;                          \ imm32

: POP ( r32 | mem -- )
   DUP SEG? IF
      DUP CS = ILLOP?  REG 7 OP,  EXIT THEN             \ seg (not CS)
   DUP R32? IF  R/M 58 OP,  EXIT THEN                   \ r32
   DUP R16? IF  16BIT:  R/M 58 OP,  EXIT THEN           \ r16
   DUP MEM? NOT ILLOP?  DUP 16BIT, 8F C,(A)  0 MR, ;    \ mem

: IN ( src dst -- )
   DUP ACC? NOT ILLOP?  DUP 16BIT,
   OVER EDX = IF  0EC SWAP SIZE, DROP                   \ Variable port
   ELSE  E4 SWAP SIZE, C,(A)  THEN ;                    \ Fixed port

: OUT ( src dst -- )
   OVER ACC? NOT ILLOP?  OVER 16BIT,
   DUP EDX = IF  0EE ROT SIZE, DROP  ELSE               \ Variable port
   E6 ROT SIZE, C,(A)  THEN ;                           \ Fixed port


{ ---------------------------------------------------------------------
Special numeric processor instructions

--------------------------------------------------------------------- }

: FILD ( mem -- )
   DUP MEM? NOT ILLOP?  DUP @SIZE CASE                  \ mem
      S16 OF  0 0DF  ENDOF                              \ m16int
      S32 OF  0 0DB  ENDOF                              \ m32int
      S64 OF  5 0DF  ENDOF                              \ m64int
   1 ILLOP?  ENDCASE  C,(A)  MR, ;

: FIST ( mem -- )
   DUP MEM? NOT ILLOP?  DUP @SIZE CASE                  \ mem
      S16 OF  2 0DF  ENDOF                              \ m16int
      S32 OF  2 0DB  ENDOF                              \ m32int
   1 ILLOP?  ENDCASE  C,(A)  MR, ;

: FISTP ( mem -- )
   DUP MEM? NOT ILLOP?  DUP @SIZE CASE                  \ mem
      S16 OF  3 0DF  ENDOF                              \ m16int
      S32 OF  3 0DB  ENDOF                              \ m32int
      S64 OF  7 0DF  ENDOF                              \ m64int
   1 ILLOP?  ENDCASE  C,(A)  MR, ;

: FLD ( mem | reg -- )
   DUP ST? IF  D9 C,(A)  0 RR,  EXIT  THEN              \ reg
   DUP MEM? NOT ILLOP?  DUP @SIZE CASE                  \ mem
      S32 OF  0 0D9  ENDOF                              \ m32real
      S64 OF  0 0DD  ENDOF                              \ m64real
      S80 OF  5 0DB  ENDOF                              \ m80real
   1 ILLOP?  ENDCASE  C,(A)  MR, ;

: FST ( mem  | reg -- )
   DUP ST? IF  0DD C,(A)  2 RR,  EXIT THEN              \ reg
   DUP MEM? NOT ILLOP?  DUP @SIZE CASE                  \ mem
      S32 OF  2 0D9  ENDOF                              \ m32real
      S64 OF  2 0DD  ENDOF                              \ m64real
   1 ILLOP?  ENDCASE  C,(A)  MR, ;

: FSTP ( mem | reg -- )
   DUP ST? IF  0DD C,(A)  3 RR,  EXIT THEN              \ reg
   DUP MEM? NOT ILLOP?  DUP @SIZE CASE                  \ mem
      S32 OF  3 0D9  ENDOF                              \ m32real
      S64 OF  3 0DD  ENDOF                              \ m64real
      S80 OF  7 0DB  ENDOF                              \ m80real
   1 ILLOP?  ENDCASE  C,(A)  MR, ;

: FCOM ( mem | reg | -- )
   DUP ST? IF  D8 C,(A)  2 RR,  EXIT THEN               \ reg
   DUP MEM? IF  DUP @SIZE CASE                          \ mem
      S32 OF  2 0D8  ENDOF                              \ m32real
      S64 OF  2 0DC  ENDOF                              \ m64real
   1 ILLOP?  ENDCASE  C,(A)  MR,  EXIT THEN
   D8 C,(A) 1 2 RR, ;                                   \ ST(1)

: FCOMP ( mem | reg | -- )
   DUP ST? IF  D8 C,(A)  3 RR,  EXIT THEN               \ reg
   DUP MEM? IF  DUP @SIZE CASE                          \ mem
      S32 OF  3 0D8  ENDOF                              \ m33real
      S64 OF  3 0DC  ENDOF                              \ m64real
   1 ILLOP?  ENDCASE  C,(A)  MR,  EXIT THEN
   D8 C,(A) 1 3 RR, ;                                   \ ST(1)


{ ---------------------------------------------------------------------
Structured transfers

COND defines condition codes required by IF, WHILE, and UNTIL.

COND, compiles the condition code.  Also allows CS ("Carry Set" which
is also the name of the Code Segment register).

NOT is defined here to invert a condition code or assemble the Intel
NOT instruction if there isn't a cc on the stack.
--------------------------------------------------------------------- }

: COND ( opc -- )   A5A50600 + CONSTANT ;

71 COND OV              \ Overflow
72 COND U>=             \ Unsigned greater than or equal
72 COND CC              \ Carry clear
73 COND U<              \ Unsigned less than
74 COND 0<>             \ Not zero
75 COND 0=              \ Zero
76 COND U>              \ Unsigned greater than
77 COND U<=             \ Unsigned less than or equal
78 COND 0>=             \ Not negative
79 COND 0<              \ Negative
7A COND PO              \ Parity odd
7B COND PE              \ Parity even
7C COND >=              \ Signed greater or equal
7D COND <               \ Signed less than
7E COND >               \ Signed greater than
7E COND 0>              \ Positive
7F COND <=              \ Signed less than or equal
E3 COND ECXNZ           \ CX not zero
EB COND NEVER           \ Unconditional

: CS? ( x1 -- x2)   DUP CS = IF  DROP U<  THEN ;

: COND, ( x -- )   CS?  DUP COND? NOT
   IOR_ASM_INVALIDCC ?THROW    C,(A) ;

2 ALU1 (NOT)

: NOT ( i*x -- j*x)   CS?  DUP COND? IF  1 XOR  ELSE  (NOT)  THEN ;

: -SHORT ( addr1 addr2 -- n)   1+ - DUP LONG? RANGE? ;

: IF ( cc -- addr)   COND,  HERE(A)  0 C,(A) ;
: THEN ( addr -- )   HERE(A) OVER -SHORT  SWAP C!(A) ;
: ELSE ( addr1 -- addr2)   NEVER IF  SWAP THEN ;
: BEGIN ( -- addr)   HERE(A) ;
: AGAIN ( addr -- )   JMP ;
: WHILE ( addr1 cc - addr2 addr1)   IF SWAP ;
: REPEAT ( addr1 addr2 -- )   AGAIN THEN ;
: UNTIL ( addr cc -- )   COND,  HERE(A) -SHORT C,(A) ;


{ ---------------------------------------------------------------------
Instruction groups
--------------------------------------------------------------------- }

27 INH1 DAA      2F INH1 DAS      37 INH1 AAA      3F INH1 AAS
60 INH1 PUSHA    61 INH1 POPA     90 INH1 NOP      98 INH1 CBW
99 INH1 CDQ      9B INH1 WAIT     9C INH1 PUSHF    9D INH1 POPF
9E INH1 SAHF     9F INH1 LAHF     CE INH1 INTO     CF INH1 IRET
D4 INH1 AAM      D5 INH1 AAD      D7 INH1 XLAT     F0 INH1 LOCK
F2 INH1 REPNE    F2 INH1 REPNZ    F3 INH1 REP      F3 INH1 REPE
F3 INH1 REPZ     F4 INH1 HLT      F5 INH1 CMC      F8 INH1 CLC
F9 INH1 STC      FA INH1 CLI      FB INH1 STI      FC INH1 CLD
FD INH1 STD

26 PRE ES:      2E PRE CS:      36 PRE SS:      3E PRE DS:
64 PRE FS:      65 PRE GS:

3 ALU1 NEG      4 ALU1 MUL      5 ALU1 IMUL     6 ALU1 DIV
7 ALU1 IDIV

0 ALU2 ADD      1 ALU2 OR       2 ALU2 ADC      3 ALU2 SBB
4 ALU2 AND      5 ALU2 SUB      6 ALU2 XOR      7 ALU2 CMP

0 SH ROL        1 SH ROR        2 SH RCL        3 SH RCR
4 SH SHL        5 SH SHR        7 SH SAR

62 MR BOUND     8D MR LEA       C4 MR LES       C5 MR LDS
B2 MR LSS       B4 MR LFS       B5 MR LGS

BC RMR BSF      BD RMR BSR

B6 RMRW MOVZX   BE RMRW MOVSX
B7 RMRW MOVZXW  BF RMRW MOVSXW

00 I/D INC      08 I/D DEC

70 REL JO       71 REL JNO      72 REL JB       72 REL JC
73 REL JAE      73 REL JNC      74 REL JE       74 REL JZ
75 REL JNE      75 REL JNZ      76 REL JBE      77 REL JA
78 REL JS       79 REL JNS      7A REL JPE      7B REL JPO
7C REL JL       7D REL JGE      7E REL JLE      7F REL JG
E0 REL LOOPNE   E1 REL LOOPE    E2 REL LOOP     E3 REL JECXZ

{ ---------------------------------------------------------------------
Set on conditions instructions
--------------------------------------------------------------------- }

90 SET SETO     \ Set byte if overflow (OF=1)
91 SET SETNO    \ Set byte if not overflow (OF=0)
92 SET SETB     \ Set byte if below (CF=1)
92 SET SETC     \ Set if carry (CF=1)
92 SET SETNAE   \ Set byte if not above or equal (CF=1)
93 SET SETAE    \ Set byte if above or equal (CF=0)
93 SET SETNB    \ Set byte if not below (CF=0)
93 SET SETNC    \ Set byte if not carry (CF=0)
94 SET SETE     \ Set byte if equal (ZF=1)
94 SET SETZ     \ Set byte if zero (ZF=1)
95 SET SETNE    \ Set byte if not equal (ZF=0)
95 SET SETNZ    \ Set byte if not zero (ZF=0)
96 SET SETBE    \ Set byte if below or equal (CF=1 or ZF=1)
96 SET SETNA    \ Set byte if not above (CF=1 or ZF=1)
97 SET SETA     \ Set byte if above (CF=0 and ZF=0)
97 SET SETNBE   \ Set byte if not below or equal (CF=0 and ZF=0)
98 SET SETS     \ Set byte if sign (SF=1)
99 SET SETNS    \ Set byte if not sign (SF=0)
9A SET SETP     \ Set byte if parity (PF=1)
9A SET SETPE    \ Set byte if parity even (PF=1)
9B SET SETNP    \ Set byte if not parity (PF=0)
9B SET SETPO    \ Set byte if parity odd (PF=0)
9C SET SETL     \ Set byte if less (SF<>OF)
9C SET SETNGE   \ Set if not greater or equal (SF<>OF)
9D SET SETGE    \ Set byte if greater or equal (SF=OF)
9D SET SETNL    \ Set byte if not less (SF=OF)
9E SET SETLE    \ Set byte if less or equal (ZF=1 or SF<>OF)
9E SET SETNG    \ Set byte if not greater (ZF=1 or SF<>OF)
9F SET SETG     \ Set byte if greater (ZF=0 and SF=OF)
9F SET SETNLE   \ Set byte if not less or equal (ZF=0 and SF=OF)

{ ---------------------------------------------------------------------
String instructions
--------------------------------------------------------------------- }

6C INH1 INSB     6D INH1 INSD     6D66 INH2 INSW
6E INH1 OUTSB    6F INH1 OUTSD    6F66 INH2 OUTSW
A4 INH1 MOVSB    A5 INH1 MOVSD    A566 INH2 MOVSW
A6 INH1 CMPSB    A7 INH1 CMPSD    A766 INH2 CMPSW
AA INH1 STOSB    AB INH1 STOSD    AB66 INH2 STOSW
AC INH1 LODSB    AD INH1 LODSD    AD66 INH2 LODSW
AE INH1 SCASB    AF INH1 SCASD    AF66 INH2 SCASW

{ ---------------------------------------------------------------------
Floating point instructions
--------------------------------------------------------------------- }

D0D9 INH2 FNOP          D9DE INH2 FCOMPP
E0D9 INH2 FCHS          E0DB INH2 FENI
E0DF INH2 FSTSWAX       E1D9 INH2 FABS
E1DB INH2 FDISI         E2DB INH2 FCLEX
E3DB INH2 FINIT         E4D9 INH2 FTST
E4DB INH2 FSETPM        E5D9 INH2 FXAM
E8D9 INH2 FLD1          E9D9 INH2 FLDL2T
E9DA INH2 FUCOMPP       EAD9 INH2 FLDL2E
EBD9 INH2 FLDPI         ECD9 INH2 FLDLG2
EDD9 INH2 FLDLN2        EED9 INH2 FLDZ
F0D9 INH2 F2XM1         F1D9 INH2 FYL2X
F2D9 INH2 FPTAN         F3D9 INH2 FPATAN
F4D9 INH2 FXTRACT       F5D9 INH2 FPREM1
F6D9 INH2 FDECSTP       F7D9 INH2 FINCSTP
F8D9 INH2 FPREM         F9D9 INH2 FYL2XP1
FAD9 INH2 FSQRT         FBD9 INH2 FSINCOS
FCD9 INH2 FRNDINT       FDD9 INH2 FSCALE
FED9 INH2 FSIN          FFD9 INH2 FCOS

D904 NPC FLDENV
D905 NPC FLDCW
D906 NPC FNSTENV        9BD906 NPC FSTENV
D907 NPC FNSTCW         9BD907 NPC FSTCW
DD04 NPC FRSTOR
DD06 NPC FNSAVE         9BDD06 NPC FSAVE
DD07 NPC FNSTSW         9BDD07 NPC FSTSW
DF04 NPC FBLD
DF06 NPC FBSTP

0 NFMR FADD     0 NFR FADDP     0 NIM FIADD
1 NFMR FMUL     1 NFR FMULP     1 NIM FIMUL
4 NFMR FSUB     4 NFR FSUBRP    4 NIM FISUB
5 NFMR FSUBR    5 NFR FSUBP     5 NIM FISUBR
6 NFMR FDIVR    6 NFR FDIVRP    6 NIM FIDIV
7 NFMR FDIV     7 NFR FDIVP     7 NIM FIDIVR

0DD NPS FFREE   1D9 NPS FXCH    4DD NPS FUCOM   5DD NPS FUCOMP

DECIMAL

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

: [U] ( user -- )
   UP@ - [ESI] ;

: POP(EBX) ( -- )
   0 [EBP] EBX MOV  4 # EBP ADD  ;

: PUSH(EBX)
   4 # EBP SUB  EBX 0 [EBP] MOV  ;

: ADDR ( address reg -- )
   DUP R32? 0 = IOR_ASM_NOTREG ?THROW >R
   ORIGIN - [EDI] R> LEA ;

{ --------------------------------------------------------------------
-------------------------------------------------------------------- }

DECIMAL

END-PACKAGE

Note que je n'ai pas été méchant, j'ai pris pour exemple un 386 ce qui est encore relativement simple.

Cordialement

Ludwig

[invite2800a7c8]

bjr tous,
heuu ! quel est l'objet du fil, à part nous faire une demo d'un compilateur ?

Salut,

Une discussion sur deux visions du monde totalement différentes, le progrès nait de la confrontations des idées
ai-je entendu dire.

Cordialement

Ludwig

[invite51d17075]

Salut,

Une discussion sur deux visions du monde totalement différentes, le progrès nait de la confrontations des idées
ai-je entendu dire.

"deux visions du monde" ! carrément .
ben dis donc, ça vole très haut aujourd'hui.
ps : et je te prie de m'excuser si je ne vois pas du tout en quoi.

[JPL]

heuu ! quel est l'objet du fil... ?

Permettre à Ludwig de s'étaler ici au lieu de le faire en polluant toutes les autres discussions. cela s'appelle un abcès de fixation.

[invite2800a7c8]

Re,

"deux visions du monde" ! carrément .
ben dis donc, ça vole très haut aujourd'hui.
ps : et je te prie de m'excuser si je ne vois pas du tout en quoi.

Dans mon élan à répondre à cher pm42 j'ai probablement exagéré. En fait la discussion porte sur les méthodes de développement d'applications logicielles. D'un coté on a si je ne me trompe pas la méthode dite classique ( édition, compilation, debugg etc... ) de l'autre côté on trouve une machine virtuelle ou le développement consiste essentiellement
à lui apprendre des mots nouveaux qu'elle va enregistrer dans un dictionnaire. Ces mots nouveaux pouvant être
réutilisés pour définir d'autres mots et ainsi de suite. Le développement se faisant de façon interactive c.a.d. on teste le fonctionnement d'un mot en dehors de toute application.
Pour résumer, il se trouve que j'utilise ce mode de développement qui est très rapide au point de vue du temps de développement, puisque le travail fourni est capitalisé.
J'ai eu la mauvaise idée de parler de cette méthode et je me suis fait insulter de toute part, j'ai donc ouvert ce fil afin que tout un chacun puisse participer à un débat sur le sujet, mais avec respect.


Cordialement

Ludwig