Bonjour,
Étant en train de surfer je suis tombé sur cette discussion.
Je dois dire que je ne sais pas vraiment pour quelle raison il n'y a pas de sorties multiples dans les fonctions.
A vrai dire, ne travaillant pas avec des langages de programmation je suis encore moins capable de comprendre.
La technique de travail mise en œuvre est relativement simple, ça consiste à faire une liste de données puis
ensuite dire ce qu'il faut faire avec.
Seul dans le cas de déclaration d'un conteneur le nom de celui-ci est post fixé.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
255 JsF.Box File$                                                                                       \ Création d'un conteneur de 255 Caractères max et de nom File$
( H:\Easywindows\Apps\Developpement\StartExternalProcess.FTH) File$ Js.$!      \ Enregistrement du Path dans le Conteneur de nom File$
File$ JsF.FileSize.Get JsF.Box Dbase:ClassList$  ClassList$ JsF.$!                         \ En mémoire Globale, construit une base de données de type Dbase et de nom ClassList$, Charge le Fichier dans la base de données  
ClassList$ ClassParser.Init                                                                      \ Branche un ClassParser sur la base de données
ClassParser.Parse                                                                                         \ Retourne la CLASS de début de fichier
BEGIN
   ?NIL NOT
WHILE
    .... BLA BLA BLA...                              \  RETOURNE UN BLOC DE DONNEES ENTIER sous formes de paires pointées
                                                                                                                                  
                                                           \  *****
                                                           \  "#CLASS":"EW.AppTitle","Position":"55   7 160  10","Units":"mm","Text":"Explorer     EASYWINDOWS   
                                                           \  - Gestion des fichiers et des répertoires Easywindows  - Gestion des Block Chains    - Gestion des accès Internet",
                                                           \  "Fonte":" Arial","Height":"20","Width":"10","Underline":"0","TextColor":"250 230 25","justify":"-1 0",
                                                           \ "AttachedMethod":"TextShow.001.C8A41186F4","};{
                                                           \
                                                           \  *****
                                                           \  avec une méthode attachée qui vient piocher les infos dont elle à besoin pour travailler. L'ordre d'écriture des données est sans importance.
ClassParser.Parse                                       \ Next CLASS
REPEAT
2DROP
;
EN CLAIR,
Pas de syntaxe, pas de langage, pas de déclaration de variables, juste des emplacements mémoire nommés ( Conteneurs) on passe des infos et on dit ce qu'il faut faire avec.
Les méthodes quand à elles sont rangées dans une structure chainée de type neuronal. Ce qui signifie pas de programme non plus. Le seul travail de programmation consiste
à construire de nouveaux outils ( Neurones) et à les intégrer dans la structure. Mais tout ça c'est pas nouveau ça fait plus de 50 ans que ça existe.

EXEMPLE DE CODAGE d'un PARSER:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

\ =============================================================================================
\ =====================================       CLASS PARSER      ===============================
\ =============================================================================================

\ NOTA:  Avant utilisation, le CLASS Parser doit être connecté sur un FRAME avec <ClassParser.Init>  

PACKAGE CLASS-PARSER

PUBLIC

VARIABLE   >IN.ClassParser%            \ Pointeur de caractères dans le bloc de données en cours d'analyse 
2VARIABLE  ClassParser%                \ Adresse et taille du Frame à parser 

: ClassParser.Reset                    S( --- )
  >IN.ClassParser% OFF
;

: ClassParser.Init                     S( F-addr,u --- )

  ClassParser% 2!
  ClassParser.Reset
;

:  ClassParser.Parse                   S( --- c-addr,u ) \  Class Parser, à me ne pas utiliser pour les applications. Dans FRAME pointé 
                                            \ par F-addr,u retourne la CLASS C-addr,u. Si aucunne CLASS n'est trouvée, <u> est NIL  
** Code   
   ClassParser% 2@ >IN.ClassParser% @
   /STRING 2DUP S" };{" SEARCH DROP
   ROT SWAP - 3 + >IN.ClassParser%  +!
   OVER -
;

END-PACKAGE

\ DEBUG ClassParser.Parse
On peut remarquer que la seule syntaxe est l'espace entre les mots.
Quand on décompile ClassParser.Parse

SEE ClassParser.Parse, on obtient le code machine

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

SEE ClassParser.Parse
7B67CF   4 # EBP SUB                    83ED04
7B67D2   EBX 0 [EBP] MOV                895D00
7B67D5   3B4634 [EDI] EBX LEA           8D9F34463B00
7B67DB   4 # EBP SUB                    83ED04
7B67DE   4 [EBX] EAX MOV                8B4304
7B67E1   EAX 0 [EBP] MOV                894500
7B67E4   0 [EBX] EBX MOV                8B1B
7B67E6   4 # EBP SUB                    83ED04
7B67E9   EBX 0 [EBP] MOV                895D00
7B67EC   3B4604 [EDI] EBX MOV           8B9F04463B00
7B67F2   EBX 4 [EBP] ADD                015D04
7B67F5   0 [EBP] EBX SUB                2B5D00
7B67F8   4 # EBP ADD                    83C504
7B67FB   EBX NEG                        F7DB
7B67FD   8 # EBP SUB                    83ED08
7B6800   EBX 4 [EBP] MOV                895D04
7B6803   8 [EBP] EAX MOV                8B4508
7B6806   EAX 0 [EBP] MOV                894500
7B6809   404FAF ( (S") ) CALL           E8A1E7C4FF
7B680E   "};{"
7B6813   45535F ( SEARCH ) CALL         E847EBC9FF
7B6818   0 [EBP] EBX MOV                8B5D00
7B681B   4 # EBP ADD                    83C504
7B681E   EBX ECX MOV                    8BCB
7B6820   4 [EBP] EBX MOV                8B5D04
7B6823   0 [EBP] EAX MOV                8B4500
7B6826   EAX 4 [EBP] MOV                894504
7B6829   ECX 0 [EBP] MOV                894D00
7B682C   0 [EBP] EBX SUB                2B5D00
7B682F   4 # EBP ADD                    83C504
7B6832   3 # EBX ADD                    83C303
7B6835   EBX 3B4604 [EDI] ADD           019F04463B00
7B683B   0 [EBP] EBX MOV                8B5D00
7B683E   4 # EBP ADD                    83C504
7B6841   0 [EBP] EBX SUB                2B5D00
7B6844   RET                            C3
On remarquera les CALL qui réalisent les connections sur d'autres structures Etc..
Comme on peut constater, tout ceci n'a pas grand chose à voir avec les techniques classiques de
développement.

On peut également remarquer que les données sont transmises via une pile de données S( --- c-addr,u ) ici en sortie un pointeur sur l'adresse Zéro de la CLASS et u la taille en caractères de la CLASS.
Ici en entrée S( F-addr,u --- ) un pointeur sur Un Frame et sa taille. A cette pile de données nous rajoutons une pile de retour et avec la structure neuronale associée nous obtenons une machine
informatique virtuelle implantée en mémoire.
Si pour des raisons commerciales ou autres, nous déguisons le tout en rajoutant et en imposant une syntaxe infâme avec des crochets et autre complications, nous OBTENONS QUOI ??????


***********************************************************************************************************************************************
*********************************** ****************************************
*********************************** JAVA ****************************************
*********************************** ****************************************
***********************************************************************************************************************************************

Ce que je viens de dire ci-dessus est, que JAVA n'est rien d'autre que la machine FORTH brillament déguisée et diminuée dans ses fonctionalitées, par James Gosling et Patrick Naughton, employés de Sun Microsystems,
ceci avec le soutien de Bill Joy (cofondateur de Sun Microsystems en 1982). Tous les produits SUN de l'époque étaient basés sur la machine virtuelle FORTH implantée en mémoire montrée plus haut.
Cette machine virtuelle à été inventée par Chuck MOORE astrophysicien (MIT) et à l'époque asistant de McCarthy (MIT, Lisp), elle porte le nom de ???? FORTH
Ben oui, sans le savoir, vous travaillez avec une machine FORTH dégénérée nommée JAVA. Java comporte toujours le moteur interne FORTH, mais vous n'y avez plus accès. Sur les stations SUN on pouvait
accèder à la machine FORTH avec la commande "STOP a" et développer du code ultra puissant. C'était très drôle de voir les commandes UNIX écrites avec FORTH. Mais ils ont pas fait deux fois la
même erreur, l'accès est bouclé verouillé ( spy oblige)

Quand à moi je travaille avec l'original fait par Chuck MOORE,


Cordialement
Ludwig