-------------------------------- | LA PROGRAMMATION EN EXTERNAL | -------------------------------- I/ Généralitées Pour programmer en external il est nécéssaire d'avoir en tête les structures d'objets et une idée sur le fonctionnement du système.Le langage External n'est en fait qu'une extension du RPL.les fonctions RPL sont en effet programmées en External. Celui-ci ne controle generalement pas les objets présents sur la pile, ni les erreurs de syntaxe dans les programmes et demande ainsi beaucoup de rigueur dans la programmation. Une étape sur le papier est quasi-indispensable. N'ayant pas une multitude de tests et de contrôle à effectuer, les programmes en external sont beaucoup plus rapide (2 à 7 fois), surtout pour les graphiques. Pour programmer,utiliser la liste des Points d'entree ( ENT.TXT ) Pour appeler un objet en ROM dans un programme,il suffit de mettre son adresse inversée dans la séquence du programme. Par exemple le DUP sans contrôle sera codé 88130 dans la séquence du programme car l'adresse est $ 3188. D9D20.....88130.....B2130 Si on a Librairie 1795 , il suffit de taper son programme normalement et lorsque l'on veut par exemple appeller l'adresse de DUP , il suffit de composer $ 3188 (la syntaxe est la meme que celle des entiers binaires. ex: << ... $ 3188 ... >> De meme ,si l'adresse est a l'envers,il suffit de la taper avec un "c barré " (shift droite 4 ). Pour des fonctions nécéssitant des entiers,(comme les opérations sur les chaînes) la machine travaille avec des System Binary. Avec la 1795 :"chain " (shift gauche 6 ) ex: "chain" 12A La plupart des sb existent deja dans la memoire ,voir la liste jointe. Parfois il sera même plus judicieux encore d'utiliser des Character(s) si les adresses appropriées existent(1795: "espace" K$ puis la valeur en hexa). Avec la 1795 ,On peut aussi utiliser PROG ou PRG pour marquer le debut d'un programme ( END pour le finir mais il est facultatif ),la difference etant que un prgm tapé avec PROG est deposé tel quel sur la pile (il n'est pas immediatement evalué ) Pour marquer le résultat d'un test,la machine utilisera 2 externaux spécifiques et inevaluables.Ceci signifie que si l'un d'eux est sur la pile et que l'on presse EVAL rien ne se passe. On appelle ce type de drapeau 'External Flag' et on note 'Eflag'. Toutes les opérations logiques existent pour les Eflags. $3A81 est le drapeau de test positif noté $yes $3AC0 est le drapeau de test négatif noté $no Il est possible de transformer un Eflag en drapeau réel (0/1) et vice-versa: Eflag->Real:#5380E SYSEVAL (cela fait aussi EXIT ) Real->Eflag:#2A7CF SYSEVAL Toutes les Adresses sont donnees en Hexa,ne pas oublier d'etre dans le mode Hexa (composer par ex: HEX ) Des exemples de programation sont donnes a la fin du fichier. II/ Les Tests Il y a deux parites dans un test : le test effectif qui renvoie un eflag et la routine d'execution qui utilise cet eflag. Les tests sont nombreux:les principaux sont reportés dans la liste d'adresses ENT.TXT. Les routines d'execution: a) #61AD8h Eflag sur la pile ....$ 61AD8 P1 P2 ..... (P1=Obyes P2=Obno) ( if then P1 else P2 end ) Cette adresse en fonction de l'eflag sur la pile va evaluer l'un ou l'autre des objets qui suivent et continuer le programme. b) # 70FDh/# 619BCh Eflag sur la pile .....$ 70FD P1 ..... (P1=Obno) ( if then else P1 end ) Eflag sur la pile .....$ 619BC P1 .... (P1=Obyes) (if then P1 end ) Ces routines de test sont à clause simple;si l'eflag correspond alors l'objet-clause est evalué ,sinon on se place après. c) #070C3h Sur la pile: 3: Eflag 2: Objet Yes 1: Objet No .....$ 70C3...... $70C3 évalue l'un des deux objets en fonction de l'eflag.La différence ici est que les objet-clauses sont sur la pile et non au sein du programme (Cette instruction correspond un peu à IFTE) Beaucoup d'autres Tests existent,pour les trouver,parcourir ENT.TXT. On trouvera parfois la syntaxe EXIT: cela correspond a descendre d'un niveau dans la pile de prgm(on sort du sous-prgm ou de la boucle). De meme pour les fonctions de pile sur la pile de prgm ( prgmSTK ), en imaginant que le prgm en cours est sur le niveau 1 de la prgmSTK et les autres sur les autres niveau par ordres de hierarchie (le prgm principale est au dernier niveau). III/ Programmation des boucles conditionnelles a) DO Prg UNTIL END (Prg doit renvoyer un Eflag.) .....$ 71A2 DO Prg-->Eflag Prg $ 71C8 UNTIL END ..... Prg n'a pas besoin d'être un objet unique,ce peut être une suite d'objet. $no provoque un retour de boucle comme le 0 dans DO UNTIL END en RPL. Si on veut que le retour soit automatique on fait un LOOP: on appelle l'adresse $ 71AB (on a alors plus besoins de l'eflag ) il faut faire un EXIT ou un KILL pour en sortir. b) WHILE test REPEAT PrgmYes END Le WHILE REPEAT n'existe pas mais on peut le simuler par: DO IF test THEN PrgmYes $no ELSE $yes END UNTIL END Ce qui se traduit par: .....2A170 Test->eflag 8DA16 D9D20 PrgmYes 0CA30 B2130 18A30 8C170..... Avec la 1795: ... $ 71A2 Test->eflag $ 61AD8 PRG PrgmYes $ 3AC0 END $ 3A81 $ 71C8 ... c) La Boucle CASE: On peut la simuler par (avec la 1795 ): ... PRG PrgmClause1 $ 61993 PrgmYes1 ( PrgmNo1 ) PrgmClause2 $ 61993 PrgmYes2 ( PrgmNo2 ) . . . PrgmClausen $ 61993 PrgmYesn ( PrgmNon ) ( PrgmToutLesTestsSontFaux ) END ... ( tout ce qui est entre parentheses est facultatif ) IV/ NoEval Pour placer un objet évaluable comme un programme ou un code sur la pile sans qu'il soit evalué: ...... 79E60 objet .... par 1795 : .... $ 6E97 Object ... V/ Les Variables Locales a) Pour déclarer des variables locales : 1) Sur la pile : obj1 , obj2 , ... , objn,loc1,loc2 ... locn < n > puis $ 74E4..... Ces locaux sont utilisable comme les locaux crés par '->'. 2) Sur la pile : obj1 obj2 ... objn < n > local puis $ 61CE9 .... Tout les locaux ont alors le meme nom; utiliser pour cela les Points d'entree a partir de $ 613B6, c'est la methode la plus rapide et celle qui prend le moins de place, meme quand les locaux ont des noms differents !!! b) .....$7497..... Cette instruction detruit un etage de variables locale. (purge toutes les derniers locaux declares ) Il est indispensable de purger les variables locales en fin de prgrm sinon on peut rencontrer des erreurs du type : NEXT Error: Bad Argument Type 6°) Les boucles non conditionnelles Elles utilisent exclusivement les System Binary comme argument;elles sont de la forme: .....DEBUT....PRG....FIN..... DEBUT: sur la pile 2: | 1: | | |-------------------------------------------| | $ 73CE | $ 73C3 | $ 73DB | $ 73F7 | For i= | 1 to n-1 | 0 to n-1 | 1 to n | m to n-1 | |-------------------------------------------| $ 7221 ressort la valeur du compteur de la derniere boucle dans un system binary.On peut ainsi imbriquer deux boucles (voir Point d'entree a partir de $ 7221 ). FIN: sur la pile 1: | |--------------------| | $7334 | $73A5 | | NEXT | s STEP | |--------------------| VI/ Controle de Syntaxe Le controle sauvegarde LASTARG s'il est activé, place l'adresse du prgm principal dans un pointeur en RAM réservée appelé COMMAND NUMBER. Si la pile ne contient pas les objets demandé,alors la routine d'erreur est declenchée.Celle-ci lit les 6 quartes précedant l'adresse du pointeur pour former les coordonnées d'un Xlib: 29E20.n°lib(3).n°fcn(3) La routine affiche le nom correspondant au Xlib et un message: "Too Few Arguments" ou "Bad Argument Type". On peut controler jusqu'à 5 objets avec deux options: -Controle du nombre d'arguments: Le controle dépend uniquement du nombre d'objets demandés,s'il est valide,le programme continue. -Controle du nombre d'arguments et du type: D9D20 ....$controle...objet.......objet.B2130 Le $controle est encore une fois spécifique au nombre d'objets à tester.Pour avoir les Codes Check,reportez-vous au chapitre sur les objets ou au tableau ci-dessous.Il y a autant de Codes Check que d'objets à tester,ceux-ci étant placés de haut en bas dans la pile. Exemple: On veut tester 3:Real 2:String 1:Library Data On prend donc le system binary <13AF> pour le Code Check et $ 18EF0 pour la routine de controle. La routine de test vérifie en premier lieu la présence du nombre d'objects sur la pile,puis la routine parcourt un à un les Sustem Binary dans le prgrm jusqu'à ce qu'elle trouve le bon.A ce moment elle évalue l'objet qui suit le System Binary. Si elle arrive au B2130 sans avoir trouvé le bon Code Check, la routine d'erreur est executée. Il est à noter que certains Codes Check d'objet sont sur 2 quartets;on ne peut alors pas coder 5 objets de ce type dans un System Binary. Tableau Récapitulatif 1 : Nbre d'objet | Nombre+Type | Nombre -------------|--------------|-------- 0 | ****** | $ 18E1A 1 | $ 18ECE | $ 18AA5 2 | $ 18EDF | $ 18A80 3 | $ 18EF0 | $ 18A5B 4 | $ 18F01 | $ 18B92 5 | $ 18F12 | $ 18B6D n ****** $ 18C34 ( n entier sur le niveau 1 ) Tableau Récapitulatif 2 : Objet | Prologue | Code Check de l'objet -------------|----------|---------------------- Any Object | ***** | 0 Real | 33920 | 1 Complex | 77920 | 2 String | C2A20 | 3 Array | 8E920 | 4 List | 47A20 | 5 Global | 84E20 | 6 Local | D6E20 | 7 Program | D9D20 | 8 Algebraic | 8BA20 | 9 Symbolic | ***** | A (Algebraic ou Global ou Local) Binary | E4A20 | B Grob | E1B20 | C Tagged | CFA20 | D Unit | ADA20 | E XLIB | 29E20 | F System Binary| 11920 | 1F Directory | 69A20 | 2F Long Real | 55920 | 3F Long Complex | D9920 | 4F Linked Array | A0A20 | 5F Character | FB920 | 6F Code | CCD20 | 7F Library | 04B20 | 8F Backup | 26B20 | 9F Library Data | 88B20 | AF String-ob. #1| AAB20 | BF " #2| CCB20 | CF " #3| EEB20 | DF " #4| 01C20 | EF Exemples d'Utilisations _______________________ ( Donnés avec la lib 1795 ) Commentaire: - Avec $ 61AD8: PROG $ E7CE Clock?->eflag $ 61AD8 If then PRG "Mode Time" DOERR END "mode Time" DOERR else PRG "Pas de Mode time" DOERR END "Pas de mode time"DOERR END end - Avec $ 71A2 : Exemple 1 : PROG << 1 1 $ 71A2 DO 1 + DUP 1 DISP 1 + DUP 1 DISP $ 71AB LOOP END >> Ce prgm affiche un compteur jusqu'a l'arret systeme (c'est trop rapide pour ON ). Exemple 2 : PROG << 1 1 $ 71A2 do 4 RAND * $ 18CEA donne un entre 0 et 4 10 RAND * $ 18CEA donne un entre 0 et 10 $ 4053 < A > $ 139E7 Inverse la case graphique $ 4714 until Key $ 71C8 end DROP DROP END >> Ce prgm affiche un compteur jusqu'a l'appui sur une touche Exemple 3 :Avec Interruptions: PROG << CLLCD CLLCD $ CED9 Active l'interruption clock $ 71A2 do DATE TIME TSTR $ 123E5 Affiche l'heure $ 4912 Attend 1s ou 1 touche $ 4714 key $ 71C8 until end DROP DROP END >> Ce prgm utilise $ 4912 qui attend une interruption Clock ou une touche , si c'est l'interruption clock (toutes les secondes ) alors key revoie $no ce qui provoque le bouclage sinon on en sort. - Les Variables Locales: Nous Allons simuler ROT par un prgm utilisant des locaux: (le seul interet est ici pedagogique ) PROG << 3 y a t'il $ 18C34 3 Objects ? sinon Erreur $ 400D < 3 > $ 6E97 NoEval Sur $ 34D30 Le Local Vide (le pose sur la pile ) $ 61CE9 Construit a partir des args sur la pile un etage de locaux $ 6140E Ressort Local2 $ 613E7 Ressort Local1 $ 61438 Ressort Local3 $ 7497 Detruit les locaux END >> - Les Boucles: Exemple 1 : Ce prgm descend le grob menu jusqu'a sa place normale. PROG << $ 4E34C < 37h > $ 73C3 <0> <37> for $ 7221 Ressort $ 4E37E Def la pos du grob menu $ 7334 next END >> Exemple 2 : Voici un Prgm tres rapide qui affiche un compteur ( pour l'arreter,faire un arret systeme ) PROG << $ 6B035 < 80000 > $ 73DB <1> < 80000 > for $ 7221 Ressort $ 167E4 SB->R ->STR $ 1245B 1 DISP $ 7334 next END >> Exemple 3 : A vous de voir !!!!!!! (consultez la liste ENT.TXT et des SB ) PROG ? $ 1CC9A ? $ 73DB ? $ 7221 ? $ 3FF9 ? $ 3188 ? $ 611FE ? $ 50AF9 ? $ 7334 ? END ? - Les Tests: Ce prgm teste si l'object est un reel, un complex et affiche le resultat en erreur: PROG << PRG << $ 18ECE test si l'object $ 3FF9 est un reel "Real" alors "Real" $ 4003 est un complex "Complex" alors "Complex" $ 3FEF d'un autre type "Ni un Real ni un complex" alors "...... END >> DOERR DOERR END >> On aurait pu, bien sur, mettre des prgm a la place des chaines Pour les clauses erreur voir ENT.TXT °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° Bonne programmation en External et n'oubliez pas qu'un bon prgm en External ne comporte pas de RPN ,c'est comme ca que fait la machine. °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°