J'aimerais bien qu'on m'explique?
Répondre à la discussion
Page 1 sur 5 12 3 4 DernièreDernière
Affichage des résultats 1 à 30 sur 134

J'aimerais bien qu'on m'explique?



  1. #1
    Ludwig1

    J'aimerais bien qu'on m'explique?


    ------

    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

    -----

  2. #2
    Jack
    Modérateur

    Re : J'aimerais bien qu'on m'explique?

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

  3. #3
    Freemaster

    Re : J'aimerais bien qu'on m'explique?

    à tout hasard je dirais... Forth
    o_O

  4. #4
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Jack Voir le message
    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

  5. A voir en vidéo sur Futura
  6. #5
    pelkin

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Ludwig1 Voir le message
    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 :
    Citation Envoyé par Ludwig1 Voir le message
    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é).
    Spécialisé en sadanthropomicrobitubulabibaquophtalmologie

  7. #6
    pm42

    Re : J'aimerais bien qu'on m'explique?

    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.

  8. #7
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Salut,
    Citation Envoyé par pelkin Voir le message
    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

  9. #8
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Salut,

    Citation Envoyé par pm42 Voir le message
    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

  10. #9
    pm42

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Ludwig1 Voir le message
    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.

  11. #10
    JPL
    Responsable des forums

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par pm42 Voir le message
    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é.
    Rien ne sert de penser, il faut réfléchir avant - Pierre Dac

  12. #11
    pelkin

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Ludwig1 Voir le message
    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.

    Citation Envoyé par Ludwig1 Voir le message
    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 :
    Citation Envoyé par Ludwig1 Voir le message
    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.

    Citation Envoyé par Ludwig1 Voir le message
    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
    Spécialisé en sadanthropomicrobitubulabibaquophtalmologie

  13. #12
    LeMulet

    Re : J'aimerais bien qu'on m'explique?

    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/

  14. #13
    Jack
    Modérateur

    Re : J'aimerais bien qu'on m'explique?

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

  15. #14
    LeMulet

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Jack Voir le message
    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.
    Dernière modification par LeMulet ; 06/11/2016 à 00h32.

  16. #15
    Jack
    Modérateur

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par LeMulet Voir le message
    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

  17. #16
    LeMulet

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Jack Voir le message
    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.

  18. #17
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par LeMulet Voir le message

    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


    Code:
    { ====================================================================
    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

  19. #18
    Jack
    Modérateur

    Re : J'aimerais bien qu'on m'explique?

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

  20. #19
    LeMulet

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Ludwig1 Voir le message
    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é.

    Citation Envoyé par Jack
    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 ?

  21. #20
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Jack Voir le message
    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

    Code:
    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
    Dernière modification par Ludwig1 ; 06/11/2016 à 13h21.

  22. #21
    pm42

    Re : J'aimerais bien qu'on m'explique?

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

  23. #22
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Resalut,

    Citation Envoyé par LeMulet Voir le message
    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.

    Code:
    { --------------------------------------------------------------------
    
    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
    Dernière modification par Ludwig1 ; 06/11/2016 à 14h13.

  24. #23
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Salut,
    Citation Envoyé par pm42 Voir le message
    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.

    Code:
    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

  25. #24
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Re,
    Citation Envoyé par pm42 Voir le message
    On est dans le ridicule habituel...
    De l'assembleur en boucle. Encore mieux que du Forth

    suite

    Code:
    { ---------------------------------------------------------------------
    
    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

  26. #25
    ansset
    Animateur Mathématiques

    Re : J'aimerais bien qu'on m'explique?

    bjr tous,
    heuu ! quel est l'objet du fil, à part nous faire une demo d'un compilateur ?
    y'a quelque chose qui cloche là dedans, j'y retourne immédiatement !

  27. #26
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    RE

    Citation Envoyé par pm42 Voir le message
    On est dans le ridicule habituel...
    De l'assembleur en boucle. Encore mieux que du Forth
    suite et fin

    Code:
    { ---------------------------------------------------------------------
    
    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

  28. #27
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par ansset Voir le message
    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

  29. #28
    ansset
    Animateur Mathématiques

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par Ludwig1 Voir le message
    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.
    y'a quelque chose qui cloche là dedans, j'y retourne immédiatement !

  30. #29
    JPL
    Responsable des forums

    Re : J'aimerais bien qu'on m'explique?

    Citation Envoyé par ansset Voir le message
    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.
    Rien ne sert de penser, il faut réfléchir avant - Pierre Dac

  31. #30
    Ludwig1

    Re : J'aimerais bien qu'on m'explique?

    Re,
    Citation Envoyé par ansset Voir le message
    "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

Page 1 sur 5 12 3 4 DernièreDernière

Discussions similaires

  1. J'aimerais cree une enceinte pour mon portable je m'explique....
    Par david8520 dans le forum Électronique
    Réponses: 4
    Dernier message: 05/12/2014, 00h21
  2. j'aimerais bien faire économie!
    Par invite08c63ad6 dans le forum Orientation après le BAC
    Réponses: 1
    Dernier message: 09/09/2009, 17h20
  3. Un exercice sur les Exponentielles, j'aimerai bien que l'on m'explique quelques notio
    Par invitebf58d26c dans le forum Mathématiques du supérieur
    Réponses: 3
    Dernier message: 26/03/2006, 22h05