home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 4 / CDPD_IV.bin / e / amiga_e_v2.1b / docs-françaises / référence.doc < prev    next >
Text File  |  1994-05-26  |  117KB  |  3,242 lines
  1.  
  2.                 +-----------------------------------------------+
  3.                 |                                               |
  4.                 |                 Amiga E v2.1b                 |
  5.                 |           Compilateur du Langage E            |
  6.                 |          Par Wouter van Oortmerssen           |
  7.                 |                                               |
  8.                 |              Référence du Langage             |
  9.                 |                                               |
  10.                 |           Traduction : Olivier ANH            |
  11.                 |                   Membre du                   |
  12.                 |   Bordeaux User Group of Scientific Students  |
  13.                 |             Copyright 1994 BUGSS              |
  14.                 |                                               |
  15.                 +-----------------------------------------------+
  16.  
  17. Contenu :
  18.  
  19.          1. format
  20.             A. tabulations, saut de ligne (lf) etc.
  21.             B. commentaires
  22.             C. identificateurs et types
  23.          2. valeurs immédiates
  24.             A. décimales (1)
  25.             B. héxadecimales ($1)
  26.             C. binaires (%1)
  27.             D. flottans (1.0)
  28.             E. caractère ("a")
  29.             F. chaine ('bla')
  30.             G. listes ([1,2,3]) et listes typées
  31.          3. expressions
  32.             A. format
  33.             B. priorité des opérateurs
  34.             C. types d'expressions
  35.             D. appels de fonction
  36.          4. operateurs
  37.             A. mathématiques (+ - * /)
  38.             B. de comparaison (= <> > < >= <=)
  39.             C. logiques (AND OR)
  40.             D. unaire (SIZEOF ` ^ {} ++ -- -)
  41.             E. triple (IF THEN ELSE)
  42.             F. de structure (.)
  43.             G. de tableau ([])
  44.             H. flottants (|)
  45.             I. expressions d'assignement (:=)
  46.             J. séquence (BUT)
  47.          5. déclaration
  48.             A. format (;)
  49.             B. labels et gotos (JUMP)
  50.             C. assignement (:=)
  51.             D. mnémoniques assembleur
  52.             E. conditionel (IF)
  53.             F. for (FOR)
  54.             G. while (WHILE)
  55.             H. repeat (REPEAT)
  56.             I. loop (LOOP)
  57.             J. select-case (SELECT)
  58.             K. incrémentation (INC/DEC)
  59.             L. expressions vides (VOID)
  60.          6. fonction : définitions et déclarations
  61.             A. définition et arguments des procédures (PROC)
  62.             B. définitions locales et globales (DEF)
  63.             C. endproc/return
  64.             D. la fonction "main"
  65.             E. variables système prédéfinies (built-in)
  66.          7. déclaration de constantes
  67.             A. constantes (CONST)
  68.             B. énumerations (ENUM)
  69.             C. sets (SET)
  70.             D. constantes prédéfinies (built-in)
  71.          8. types
  72.             A. a propos du système "type"
  73.             B. letype de base (LONG/PTR)
  74.             C. le type simple (CHAR/INT/LONG)
  75.             D. le type tableau (ARRAY)
  76.             E. le type complexe (STRING/LIST)
  77.             F. le type composé (OBJECT)
  78.             G. initialisation
  79.          9. fonctions prédéfinies (built-in)
  80.             A. fonctions d'entrées-sorties (I/O)
  81.             B. chaines et fonctions de chaine
  82.             C. listes et fonctions de liste
  83.             D. fonctions de support Intuition
  84.             E. fonctions de support graphique
  85.             F. fonctions de support système
  86.             G. mathémathiques et autres fonctions
  87.             H. chaine et fonctions de lien entre listes
  88.         10. fonctions de bibliothèques (libraries) et modules
  89.             A. appels de bibliothèque prédéfinies (built-in)
  90.             B. interfacer le système amiga avec les modules 2.04
  91.         11. expressions cotées (`)
  92.             A. les cotes simple et l'analyse
  93.             B. Eval()
  94.             C. fonctions prédéfinies (built-in)
  95.         12. support des nombres flottants
  96.             A. utilisation des flottants et fonctions d'opérateurs flottants
  97.             B. expressions flottantes et conversions
  98.         13. Gestion des exceptions
  99.             A. définition des gestionnaires d'exceptions (HANDLE/EXCEPT)
  100.             B. utilisation de la fonction Raise()
  101.             C. définition des exceptions pour les fonctions prédéfinies (RAISE/IF)
  102.             D. utilisation des identificateurs d'exception
  103.         14. programmation orientée objet (OO)
  104.         15. assembleur inline
  105.             A. les identificateurs
  106.             B. l'assembleur en linge comparé au macro assembleur
  107.             C. comment utiliser les données binaires (INCBIN/CHAR..)
  108.             D. OPT ASM
  109.         16. implementations
  110.             A. le mot-clé OPT
  111.             B. le modèle small/large
  112.             C. l'organisation de la pile
  113.             D. les limites du code
  114.             E. les messages d'érreurs, d'avertissements et de non-référence
  115.             F. l'organisation des tampons du compilateur et allocation
  116.             G. un bref histotique
  117.  
  118.  
  119.  
  120.  
  121.  
  122. +---------------------------------------------------------------+
  123. |                           1. FORMAT                           |
  124. +---------------------------------------------------------------+
  125.  
  126.  
  127. 1A. tabs,lf etc.
  128. ----------------
  129.  
  130. Les sources E sont de pures fichiers ASCII, avec saut de ligne <lf> et point-
  131. virgule ";" servant de séparateurs de déclarations. Les déclarations, qui ont
  132. des arguments particuliers, séparés par une virgule ",", peuvent s'étendre
  133. sur plus d'une ligne terminée par une virgule, ignorant alors les sauts de
  134. ligne.
  135.  
  136.  
  137. 1B. commentaires
  138. ----------------
  139.  
  140. Les commentaires peuvent être placés n'importe où dans le source où
  141. normalement un espace aurait été correct. Ils commencent avec '/*' et se
  142. terminent avec '*/' et peuvent être imbriqués les uns dans les autres.
  143.  
  144.  
  145. 1C. identificateurs et types
  146. ----------------------------
  147.  
  148. Les identificateurs sont des chaines que le programmeur utilise pour
  149. caractériser certains objets, dans la plupart des cas des variables, ou même
  150. des mots-clé ou des noms de fonction prédéfinies par le compilateur. Un
  151. identificateur consiste en :
  152.  
  153.     - caractères MAJUSCULEs  et minuscules
  154.     - "0" .. "9" (sauf pour le premier character)
  155.     - "_" (le souligné)
  156.  
  157. Tous les caractères sont significatifs, mais le compilateur ne regarde que
  158. les 2 premiers pour identifier le type d'identificateur avec lequel il a
  159. affaire :
  160.  
  161. majuscule tous les deux :     - mots-clé comme IF, PROC etc.
  162.                               - constantes comme MAX_LENGTH
  163.                               - mnémoniques assembleur comme MOVE
  164. le premier en minuscule :     - identificateurs de variable/label/objet etc.
  165. premier en majuscule, second en minuscule :
  166.                               - fonctions système du E system comme WriteF()
  167.                               - appels de bibliothèque : OpenWindow()
  168.  
  169. Notez que tous les identificateurs obéissent à cette syntaxe, par exemple :
  170. WBenchToFront() devient WbenchToFront()
  171.  
  172.  
  173.  
  174. +---------------------------------------------------------------+
  175. |                      2. VALEURS IMMEDIATES                    |
  176. +---------------------------------------------------------------+
  177.  
  178. Les valeurs immédiates en E sont évaluées en 32 bits ; la seule différence
  179. parmi ces valeurs (A-G) est soit leur représentation interne, ou le fait qu'
  180. elles retournent un pointeur plutôt qu'une valeur.
  181.  
  182.  
  183. 2A. décimales (1)
  184. -----------------
  185.  
  186. Une valeur décimales est un séquence de caractères "0"..."9", avec la
  187. possibilité d'être précédé par un signe moins "-" pour les chiffres négatifs.
  188. Exemples : 1, 100 ,-12, 1024
  189.  
  190.  
  191. 2B. héxadecimales ($1)
  192. ----------------------
  193.  
  194. Une valeurs héxadécimales utilise les caractères "A"..."F" en plus, ou
  195. "a"..."f" et est précédées par un $.
  196. Exemples:
  197.     $FC, $DFF180, -$ABCD
  198.  
  199.  
  200. 2C. binaires (%1)
  201. -----------------
  202.  
  203. Le snmbres binaires commencent par un "%" et n'utilise que "0" et "1" pour
  204. former une valeur.
  205. Exemples: %111, %1010100001, -%10101
  206.  
  207.  
  208. 2D. flottants (1.0)
  209. -------------------
  210.  
  211. Les flottants diffèrent des nombres décimaux de part le "." qui les séparent
  212. en deux. Une des parties peut être omise, pas les 2.
  213. Notez que le flottants ont une représentation interne de 32bits (FFP). Reportez
  214. vous au chapitre 12 pour plus d'informations.
  215. Exemples:
  216.     3.14159, .1 (=0.1), 1. (=1.0)
  217.  
  218.  
  219. 2E. caractères ("a")
  220. ---------------------
  221.  
  222. La valeur d'un caractère (encadré par des double cotes "") est leur valeurs
  223. ASCII, par ex. "A" = 65. En E, les valeurs immédiates des caractères doivent
  224. être des chaines d'au plus 4 caractères, par exemple "FORM", où le premier
  225. caractère "F" sera le poids fort (MSB) de la représentation 32 bits, et "M"
  226. le poids faible (LSB : least significant byte).
  227.  
  228.  
  229. 2F. chaines ('bla')
  230. -------------------
  231.  
  232. Les chaines sont des représentations ASCII, encadrées pour des simple cotes.
  233. La valeur de ces chaines est un pointeur sur le premier caractères.
  234. Plus spécifique : 'bla' produit un pointeur de 32 bits dans la mémoire, où
  235. on trouve les octets "b, "l", "a". TOUTES les chaines en E sont terminées
  236. par un octet zéro (0).
  237. Les chaines peuvent contenir des symboles de format introduit par "\" (anti
  238. slash), soit pour introduire des caractères dans la chaine, qui sont pour
  239. quelques raisons non affichables, soit pour formatter la chaine avec les
  240. fonctions de format telles que WriteF(), TextF() and StringF(), ou
  241. sous kick2.0, Vprintf().
  242.  
  243.     \n              saut de ligne (ascii 10)
  244.     \a or ''        apostrophe ' (celui pour encadrer une chaine)
  245.     \e              escape (ascii 27)
  246.     \t              tabulation (ascii 9)
  247.     \\              barre oblique inverse
  248.     \0              octet zéro 0. D'utilisation rare, car les chaines
  249.                     finissant toutes par un zéro.
  250.     \b              retour chariot (carriage return) (ascii 13)
  251.  
  252. De plus, quand utilisé avec les fonctions de format :
  253.  
  254.     \d      affiche un nombre décimal
  255.     \h      affiche un nombre héxadecimal
  256.     \s      affiche une chaine
  257.     \c      affiche un caractère
  258.     \z      met l'octet de remplissage à '0'
  259.     \l      justifie le champ à gauche
  260.     \r      justifie le champ à droite
  261.  
  262. Les spécificateurs de champs doivent suivrent les codes \d, \h et \s :
  263.  
  264.     [x]     specifie un champ de largeur x
  265.     (x,y)   specifie le x minimum et le y maximum (chaine seulement)
  266.  
  267. Exemple: affiche un nombre héxadécimal avec 8 caractères laissant la place
  268. aux zéros :
  269.     WriteF('\z\h[8]\n',num)
  270.  
  271. Une chaine peut-être étendue sur plusieurs ligne en insérant entre eux un "+"
  272. et un saut de ligne (lf) :
  273.  
  274.     'Ceux sont 2 longues lignes ' +
  275.     'qui sont mises sur 2 lignes'
  276.  
  277.  
  278. 2G. listes ([1,2,3]) et listes typées
  279. -------------------------------------
  280.  
  281. Une liste immédiate est la partie constante du type LISTe, comme une 'chaine'
  282. est la partie constante pour une chaine ou un tableau de cractères (ARRAY OF
  283. TYPE).
  284. Exemple :
  285.  
  286.     [3,2,1,4]
  287.  
  288. est une expression qui a comme vameur un PoinTeuR sur une liste initialisée,
  289. une liste comme représentation en mémoire est compatible avec un tableau
  290. (ARRAY OF LONG), avec quelques informations en plus en offset négatif. Vous
  291. devez utiliser ces listes immédiates n'importe où, où une fonction demande un
  292. pointeur sur un tableau de valeurs 32bits, ou une liste.
  293. Exemple :
  294.  
  295.     ['chaine',1.0,2.1]
  296.     [WA_FLAGS,1,WA_IDCMP,$200,WA_WIDTH,120,WA_HEIGHT,150,TAG_DONE]
  297.  
  298. Voir la partie sur les fonctions de liste pour différencier les listes
  299. immédiates et typées, et pour des informations détailées.
  300.  
  301.  
  302.  
  303. +---------------------------------------------------------------+
  304. |                         3. EXPRESSIONS                        |
  305. +---------------------------------------------------------------+
  306.  
  307.  
  308. 3A. format
  309. ----------
  310.  
  311. Une expression est un morceau de code lié par des opérateurs, fonctions et
  312. parenthèses pour former une valeur.
  313. Il consiste dans la plupart des cas en :
  314.  
  315.     - des valeurs immédiates (chapitre 2)
  316.     - des opérateurs (chapitre 4)
  317.     - des appels de fonction (chapitre 3D)
  318.     - des parenthèses () (chapitre 3B)
  319.     - des variables ou des expressions-variables (chapitre 3C)
  320.  
  321. Exemples d'expressions :
  322.  
  323.     1
  324.     'hello'
  325.     $ABCD+(2*6)+Abs(a)
  326.     (a<1) OR (b>=100)
  327.  
  328.  
  329. 3B. priorité des opérateurs
  330. ---------------------------
  331.  
  332. Le langage E n'a pas de priorité. Cela signifie que les expressions
  333. sont évaluées de gauche vers la droite. Vous pouvez changer cette priorité
  334. en mettant entre parenthèses des (sous-)expressions :
  335.     1+2*3 /* =9 */     1+(2*3) /* =7 */       2*3+1  /* =7 */
  336.  
  337.  
  338. 3C. types d'expressions
  339. -----------------------
  340.  
  341. Il y a 3 types d'expressions qui peuvent être utilisés pour différentes
  342. applications :
  343.  
  344.     - <var>, juste une variable
  345.     - <varexp>, un variable, avec un opérateurs unaire possible
  346.       comme ++ (incrémentation) ou [] (opérateur de tableau). Pour cela,
  347.       voir les chapitre 4D et 4G. Il cractérise un expression modifiable
  348.       comme Lvaleur en C.
  349.       Notez que ces opérateurs unaires ne font pas partie des priorité.
  350.     - <exp>. Cela inclue <var> et <varexp>, et n'importe quelle autre
  351.       expression.
  352.  
  353.  
  354. 3D. appels de fonction
  355. ----------------------
  356.  
  357. Un appel de fonction est arrêt temporaire du code pour un saut vers une
  358. fonction, qui peut-être une procédure (PROC), ou juste une fonction du
  359. système. Le format d'un appel de fonction est le nom de la fonction, suivit
  360. par 2 parenthèses () encadrant de zéro à un nombre illimité d'argument,
  361. séparés par des virgules ",".
  362. Notez que les arguments de fonctions sont des expressions.
  363. Voir le chapitre 6 pour savoir comment faire sa propre fonction, et chapitre
  364. 9 et 10 pour les fonctions prédéfinis.
  365. Exemples :
  366.  
  367.     foo(1,2)
  368.     Gadget(buffer,glist,2,0,40,80+offset,100,'Cancel')
  369.     Close(handle)
  370.  
  371.  
  372.  
  373. +---------------------------------------------------------------+
  374. |                          4. OPERATEURS                        |
  375. +---------------------------------------------------------------+
  376.  
  377.  
  378. 4A. mathématiques (+ - * /)
  379. ---------------------------
  380.  
  381. Ces opérateurs combinent une expression à un autre valeur pour produire une
  382. nouvelle valeur.
  383. Exemples :
  384.  
  385.     1+2, MAX-1*5
  386.  
  387. Voir le chapitre 12 pour savoir comment utiliser les opérateurs sur les
  388. flottants.
  389. Le "-" peut être utilisé en première d'expression, avec un 0 implicite,
  390. par ex.  -a  ou -b+1  sont egaux.
  391. Notez que * et / sont par défaut des opérateurs 16 bits : Voir Mul()
  392.  
  393.  
  394. 4B. comparaison (= <> > < >= <=)
  395. --------------------------------
  396.  
  397. Idem aux opérateurs mathématiques, à la différence qu'ils renvoient soit VRAI
  398. (TRUE, valeur 32 bits = -1), ou FAUX (FALSE =0). Ils peuvent être surpassé
  399. par les flottants.
  400.  
  401.  
  402. 4C. logique (AND et OR)
  403. -----------------------
  404.  
  405. Ces opérateurs soit combinent des valeurs vraies en de nouvelles, soit
  406. réalisent des opérateurs sur des bits AND et OR.
  407. Exemples :
  408.  
  409.     (a>1) AND ((b=2) OR (c>=3))         /* logique */
  410.     a:=b AND $FF                        /* opérateur de bits */
  411.  
  412.  
  413. 4D. unaire (SIZEOF ^ {} ++ -- `)
  414. --------------------------------
  415.  
  416. - SIZEOF <objet>
  417.   retourne simplement la taille d'un objet.
  418.   Exemple: SIZEOF newscreen
  419. - {<var>}
  420.   retourne l'adresse d'une variable ou d'un label. C'est cet opérateur que
  421.   vous utiliserez pour donner une variable comme argument à une fonction par
  422.   référence, et non pas par valeur, ce qui est le défaut en E. Voir "^".
  423.   Exemple:  Val(input,{x})
  424. - ^<var>
  425.   A l'inverse de {}, il écrit ou lit des variables qui sont donnés par
  426.   référence.
  427.   Examples:      ^a:=1     b:=^a
  428.   Il est alors utilisé pour aller chercher (peek) et poser (poke) des valeurs
  429.   LONG en mémoire, si <var> est un pointeur sur cette valeur.
  430.   Exemple pour {} et ^: écrit votre fonction d'assignement :
  431.  
  432.       PROC set(var,exp)
  433.         ^var:=exp
  434.       ENDPROC
  435.  
  436.   et appelez le avec :     set({a},1)     /* egale a:=1 */
  437. - <varexp>++   et  <varexp>--
  438.   Incréménte (++) ou décrémente (--) le pointeur caractérisé par <varexp> par
  439.   par la taille des données vers lequel il pointe. Cela a pour effet que ce
  440.   pointeur pointe vers l'article (item) suivant ou précédent. Quand il est
  441.   utilisé sur des variables qui ne sont pas des pointeurs, il changera
  442.   simplement en 1. Notez que ++ prend effet _après_ le calcul de <varexp>, et
  443.   -- toujours _avant_.
  444.   Exemples :
  445.  
  446.       a++          /* retourne la valeur de a, et l'incrémente de 1 */
  447.       sp[]--       /* décrémente le pointeur sp de 4 (si il y avait un tableau),
  448.                       et lit la valeur pointée par sp */
  449. - `<exp>
  450.   On appelle un telle expression, un expression cotée, venant du LISP. <exp>
  451.   n'est pas évaluée, mais retourne l'adresse de l'expression, qui peut être
  452.   plus tard évaluéeau moment voulu. Voir le chapitre 11 pour plus
  453.   d'informations.
  454.  
  455.  
  456. 4E. triple (IF THEN ELSE)
  457. -------------------------
  458.  
  459. L'opérateur IF a presque la même fonction que la déclaration IF, seulement il
  460. choisit entre 2 expressions au lieu de 2 déclarations ou blocs de code.
  461. Il est équivalant à l'opérateur x?y:z en C.
  462.  
  463. IF <boolexp> THEN <exp1> ELSE <exp2>
  464.  
  465. retourne exp1 ou exp2, suivant l'expression booléenne boolexp. Par exemple,
  466. au lieu de :
  467.  
  468.     IF a<1 THEN b:=2 ELSE b:=3
  469.     IF x=3 THEN WriteF('x égale 3\n') ELSE WriteF('x égale autre chose\n')
  470.  
  471. écrivez:
  472.  
  473.     b:=IF a<1 THEN 2 ELSE 3
  474.     WriteF(IF x=3 THEN 'x égale 3\n' ELSE 'x égale autre chose\n')
  475.  
  476.  
  477. 4F. structures (.)
  478. -----------------
  479.  
  480. <ptr2object>.<memberofobject> forme une <varexp>
  481. Le pointeur doit être déclaré comme PTR TO <objet> ou ARRAY OF <objet>
  482. (voir le chapitre 8 pour cela), et le membre doit être un identificateur
  483. d'un objet déclaré. Notez que lire un sous objet d'un objet comme cela
  484. donne un pointeur sur cet objet.
  485. Exemple :
  486.  
  487.     cettetache.userdata:=1
  488.     rast:=myscreen.rastport
  489.  
  490.  
  491. 4G. tableaux ([])
  492. -----------------
  493.  
  494. <var>[<indexexp>] (est une <varexp>)
  495. Cet opérateur lit la valeur d'un tableau sur lequel <var> pointe, et avec
  496. pour index <indexexp>. Cet index peut être simplement une expression, avec un
  497. petite limitation : il ne doit pas contenir des appels de fonction quand
  498. utilisé sur la partie gauche de l'assignement.
  499. Note 1 : "[]" est un raccourcit de "[0]"
  500. Note 2 : avec un tableau de n éléments, l'index va de 0 .. n-1
  501. Exemples:
  502.  
  503.     a[1]:=10           /* met le second élément à 10 */
  504.     x:=table[y*4+1]    /* lit le tableau */
  505.  
  506.  
  507. 4H. opérateurs flottants (|)
  508. ----------------------------
  509.  
  510. <exp>|<exp>
  511. Convertis des expressions d'entier en flottants et inversement, et surpasse
  512. les opérateurs + - * / = <> < > <= >= avec les équivalents flottants.
  513. Voir le chapitre 12 pour tout savoir sur les flottants et cet opérateur.
  514.  
  515.  
  516. 4I. expressions d'assignements (:=)
  517. -----------------------------------
  518.  
  519. Les assignements (donner une valeur a une variable) existe comme déclaration
  520. et comme expression. La seule différence est que la déclaration est de la forme
  521. <varexp>:=<exp> et l'expression <var>:=<exp>.
  522. Ce dernier a la valeur <exp> comme résultats.
  523. Notez que comme <var>:= prend une expression, vous aurez souvent besoin de
  524. parenthèses pour forcer la bonne interprétation, comme :
  525.  
  526.     IF mem:=New(100)=NIL THEN error()
  527.  
  528. est interprété comme :
  529.  
  530.     IF mem:=(New(100)=NIL) THEN error()
  531.  
  532. ce qui n'est pas ce qu'on veut : mem doit être un pointeur, pas un booléen.
  533. On doit écrire :
  534.  
  535.     IF (mem:=New(100))=NIL THEN error()
  536.  
  537.  
  538. 4J. séquence (BUT)
  539. -------------------
  540.  
  541. L'opérateur de séquence "BUT" vous permet d'écrire 2 expressions dans une
  542. construction n'en acceptnt qu'une seule. Souvent en écrivant de complexes
  543. appels de fonction, on voudrait faire une autre action 'à la volée', comme
  544. un assignement :
  545.  
  546.     <exp1> BUT <exp1>
  547.  
  548. Cela veux dire : évalue exp1, mais retourne la valeur de exp2.
  549. Exemple:
  550.  
  551.     mafonction((x:=2) BUT x*x)
  552.  
  553. assigne 2 à x, et appelle la fonction mafonction avec x*x. Les () autour
  554. de l'assignementsont nécessaire pour prévenir l'opérateur := qu'il s'agit
  555. d'une expression.
  556.  
  557.  
  558.  
  559. +---------------------------------------------------------------+
  560. |                          5. DECLARATIONS                      |
  561. +---------------------------------------------------------------+
  562.  
  563.  
  564. 5A. format (;)
  565. --------------
  566.  
  567. Comme suggéré au chapitre 1A, une déclaration est en général mise sur sa
  568. propre ligne, mais plusieurs peuvent être mise ensemble sur une seule ligne,
  569. en les séparant par un point-virgule ";", ou bien une déclaration peut être
  570. étendue sur plus d'une ligne, celles-ci finissant par une virgule.
  571. Exemples :
  572.  
  573.     a:=1; WriteF('salut!\n')
  574.     DEF a,b,c,d,             /* trop d'arguments sur la ligne */
  575.         e,f,g
  576.  
  577. Les déclarations peuvent être :
  578.     - des assignements
  579.     - des déclarations conditionelles, voir aussi les chapitres 5E-5K
  580.     - des expressions vides
  581.     - des labels
  582.     - des instructions assembleurs
  583.  
  584. La virgule est le premier caractère montrant uevous ne voulez pas terminer la
  585. déclaration avec le prochain saut de ligne (lf), mais les caractères suivants
  586. signalent la suite de la déclaration sur la ligne suivante :
  587.  
  588.     + - * /
  589.     = > < <> >= <=
  590.     AND OR BUT THEN
  591.  
  592.  
  593. 5B. déclarations de labels et gotos (JUMP)
  594. ------------------------------------------
  595.  
  596. Les labels sont des identificateurs globals avec un ":" à la fin :
  597.  
  598.     monlabel:
  599.  
  600. Ils peuvent être utilisés par des instructions comme JUMP, et comme référence
  601. de données statiques. Ils peuvent être utilisés pour sortir de tous types de
  602. boucles (cette technique n'est pas recommandée), mais pas en dehors de
  603. procédures. Dans un programme E normal, ils sont souvent utilisés dans les
  604. lignes assembleurs.
  605. Les labels sont toujours très visible.
  606.  
  607.     JUMP <label>
  608.  
  609. continue l'éxécution à prtir du <label>. Vous n'êtes pas encouragé à utiliser
  610. cette instruction, elle est là pour des situations qui devrait augmenter la
  611. compléxité du programme si elle n'était pas là.
  612. Exemple :
  613.  
  614.     IF Mouse()=1 THEN JUMP stopmaintenant
  615.  
  616.     /* suite du programme */
  617.  
  618.     stopmaintenant:
  619.  
  620.  
  621. 5C. assignement (:=)
  622. --------------------
  623.  
  624. Le format de base d'un assignement est :   <var> := <exp>
  625. Exemples:
  626.  
  627.     a:=1
  628.     a:=mafonction()
  629.     a:=b*3
  630.  
  631.  
  632. 5D. mnémoniques assembleurs
  633. ---------------------------
  634.  
  635. En E, les lignes assembleurs font partie intégrante du langage, elles n'ont
  636. pas besoin d'être encadré dans un blocs "ASM" spécial, comme il est usuel
  637. dans d'autres langages, ni être assemblé par un assembleur externe pour
  638. assembler le code. Cela veut dire qu'elles obéissent aux règles de syntaxe
  639. du E, etc. Voir le chapitre 15 pour plus de détails.
  640. Exemple :
  641.  
  642.     DEF a,b
  643.     b:=2
  644.     MOVEQ  #1,D0             /* quelques lignes assembleurs */
  645.     MOVE.L D0,a              /* a:=1+b  */
  646.     ADD.L  b,a
  647.     WriteF('a=\d\n',a)       /* a sera égal à 3 */
  648.  
  649.  
  650. 5E. déclaration conditionelle (IF)
  651. ----------------------------------
  652.  
  653. IF, THEN, ELSE, ELSEIF, ENDIF
  654.  
  655. syntaxe:        IF <exp> THEN <déclaration> [ ELSE <instruction> ]
  656. ou:             IF <exp>
  657.                   <instructions>
  658.                 [ ELSEIF <exp>           /* plusieurs elseif peuvent */
  659.                   <instructions> ]       /* avoir lieu               */
  660.                 [ ELSE ]
  661.                   <instructions>
  662.                 ENDIF
  663.  
  664. construit un bloc conditionnel. Notez qu'il y a 2 formes générales de cette
  665. déclaration, en ligne unique et en ligne étendue.
  666.  
  667.  
  668. 5F. instruction for (FOR)
  669. -------------------------
  670.  
  671. FOR, TO, STEP, DO, ENDFOR
  672.  
  673. syntaxe:        FOR <var> := <exp> TO <exp> STEP <pas> DO <instruction>
  674. ou:             FOR <var> := <exp> TO <exp> STEP <pas>
  675.                   <instructions>
  676.                 ENDFOR
  677.  
  678. construit une boucle for. Notez les 2 formes générales. <pas> est une
  679. constante positive ou négative, à l'exclusion de 0.
  680. Exemple :
  681.  
  682.     FOR a:=1 TO 10 DO WriteF('\d\n',a)
  683.  
  684.  
  685. 5G. intruction while (WHILE)
  686. ----------------------------
  687.  
  688. WHILE, DO, ENDWHILE
  689.  
  690. syntaxe:        WHILE <exp> DO <instruction>
  691. ou:             WHILE <exp>
  692.                   <instructions>
  693.                 ENDWHILE
  694.  
  695. construit une boucle while, qui est répétée tant que <exp> est vraie (TRUE).
  696. Notez les 2 formes générales.
  697.  
  698.  
  699. 5H. instruction repeat (REPEAT)
  700. -------------------------------
  701.  
  702. REPEAT, UNTIL
  703.  
  704. syntaxe:        REPEAT
  705.                 UNTIL <exp>
  706.  
  707. contruit un block en boucle repeat-until : la boucle sera répétée jusqu'à ce
  708. que <exp> soit vraie (TRUE) .
  709. Exemple :
  710.  
  711.     REPEAT
  712.       WriteF('Vous voulez vraiment sortir du programme ?\n')
  713.       ReadStr(stdout,s)
  714.     UNTIL StrCmp(s,'oui !')
  715.  
  716.  
  717. 5I. instruction loop (LOOP)
  718. ---------------------------
  719.  
  720. LOOP, ENDLOOP
  721.  
  722. syntaxe:        LOOP
  723.                   <instructions>
  724.                 ENDLOOP
  725.  
  726. construit une boucle infinie.
  727.  
  728.  
  729. 5J. instruction select-case (SELECT)
  730. ------------------------------------
  731.  
  732. SELECT, CASE, DEFAULT, ENDSELECT
  733.  
  734. syntax:e        SELECT <var>
  735.                 [ CASE <exp>
  736.                   <intructions> ]
  737.                 [ CASE <exp>
  738.                   <instructions> ]   /* autant de bloc de ce type */
  739.                 [ DEFAULT
  740.                   <instructions> ]
  741.                 ENDSELECT
  742.  
  743. construit un bloc select-case. De nombreuses expressions vont être comparées
  744. à la variable, et seulement le premier bon bloc sera éxécuté. Si rien n'est
  745. trouvé, le bloc par défaut est éxécuté.
  746.  
  747.     SELECT caractère
  748.       CASE 10
  749.         WriteF('He, j'ai trouvé un saut de ligne\n')
  750.       CASE 9
  751.         WriteF('Ouah, ca doit être une tabulation!\n')
  752.       DEFAULT
  753.         WriteF('Vous connaissez celui là : \c ?\n',caractère)
  754.     ENDSELECT
  755.  
  756.  
  757. 5K. instruction d'incrémentation (INC/DEC)
  758. ------------------------------------------
  759.  
  760. INC, DEC
  761.  
  762. syntaxe:        INC <var>
  763.                 DEC <var>
  764.  
  765. raccourcit de <var>:=<var>+1 et <var>:=<var>-1. La seule différence avec
  766. <var>++ et <var>-- est que INC et DEC sont des instructions, etne retourne
  767. aucune valeurs, et sont plus efficient.
  768.  
  769.  
  770. 5L. expressions vide (VOID)
  771. ---------------------------
  772.  
  773. VOID
  774.  
  775. syntaxe:         VOID <exp>
  776.  
  777. calcule l'expression sans que le résultat n'aille quelque part. Utile
  778. seulement pour une syntaxe claire, comme les expressions peuvent être
  779. utilisées comme intruction sans VOID en E ! Cela peut provoquer une subtile
  780. érreur : alors que "a:=1" assigne à a la valeur 1, "a=1" est une instruction
  781. qui ne fait rien. E vous le signalera si cela arrive.
  782.  
  783.  
  784. +---------------------------------------------------------------+
  785. |            6. DEFINITIONS DE FONCTIONS ET DECLARATIONS        |
  786. +---------------------------------------------------------------+
  787.  
  788.  
  789. 6A. définition et arguments des procédures(PROC)
  790. ------------------------------------------------
  791.  
  792. Vous devez utiliser PROC et ENDPROC pour définir les instructions dans vos
  793. propres fonction. Ces fonctions peuvent avoir plusieurs arguments, mais
  794. retourne une seule valeur.
  795.  
  796. syntaxe:        PROC <label> ( <args> , ... )
  797.                 ENDPROC <valeur_retournée>
  798.  
  799. définie une procédure avec un nombre d'arguments. Les arguments sont de type
  800. LONG ou de type PTR TO <type> (voir chapitre 8) et n'ont pas besoin d'autre
  801. déclaration.
  802. La fin de la procédure est désigné par ENDPROC. Si aucune valeur n'est donnée,
  803. 0 est retournée.
  804. Exemple : écrire une fonction qui retourne la somme de 2 arguments :
  805.  
  806.  
  807.     PROC add(x,y)         /* x et y sont des variables locales */
  808.     ENDPROC x+y           /* retourne le résultat */
  809.  
  810.  
  811. 6B. définitions locales and globales (DEF)
  812. ------------------------------------------
  813.  
  814. Vous devez définir des variables locales en plus de celles qui sont définies
  815. avec DEF. Le plus simple est :
  816.  
  817.     DEF a,b,c
  818.  
  819. déclare les identificateurs a, b et c de votre fonction.
  820. Notez que ces déclarations doivent être au début de votre fonction.
  821.  
  822. syntaxe:        DEF <déclarations>,...
  823. description:    declare les variables. Une déclaration est une de ces formes:
  824.                 <var>
  825.                 <var>:<type>              where <type>=LONG,<objet>
  826.                 <var>[<taille>]:<type>    where <type>=ARRAY,STRING,LIST
  827.  
  828. Voir le chapitre 8 pour plus d'exemples, c'est là que les type sont introduit.
  829. A partir de maintenant, on utilisera l'écriture <var>.
  830. Les arguments de fonctions sont réduit aux type simple : voir chapitre 8B.
  831. Une déclaration de type simple peut avoir une initiaisation. Dans cette
  832. version elle doit être faite par un entier (pas d'expression) :
  833.  
  834.     DEF a=1,b=2
  835.  
  836. Un programme consiste en une suite de fonctions, appellé procédures, PROC.
  837. Chacune d'elles puevent avoir des variables locales, et le programme en son
  838. entier, peut avoir des variables globales. Enfin, une procédure doit être
  839. un PROC main(), car c'est cette procédure qui est éxécutée en premier. Un
  840. programme simple peut ressembler à ça :
  841.  
  842.     DEF a, b                /* définition des variables globales */
  843.  
  844.     PROC main()             /* l'ordre des fonctions peut être */
  845.       bla(1)                /* mis au hasard                   */
  846.     ENDPROC
  847.  
  848.     PROC bla(x)
  849.       DEF y,z               /* possibilité de variables locales */
  850.     ENDPROC
  851.  
  852. Pour résumer, les définitions locales sont celles que vous faites au début
  853. des procédures, et qui ne sont visible qu'à l'intérieure de celles-ci.
  854. Les définitions globales sont faites avant le premier PROC, au début de votre
  855. source, et ils sont visibles dans toutes les procédures.
  856. Les variables globales et locales (et bien sûr les variables locales de 2
  857. différentes fonctions) peuvent avoir le même nom ; les variables locales ont
  858. tjours la priorité sout les variables globales.
  859.  
  860.  
  861. 6C. endproc/return
  862. ------------------
  863.  
  864. Comme décrit plus haut, ENDPROC marque la fin d'une définition de fonction, et
  865. peuvent retourner une valeur. De plus RETURN peux être utilisé n'importe où
  866. dans la fonction pour en sortir. Si il est utilisé dans la procédure main(),
  867. on sortira du programme. Voir aussi CleanUp() au chapitre 9F.
  868.  
  869.     RETURN [<valeur_retournée>]          /* optionel */
  870.  
  871. Exemple:
  872.  
  873.     PROC getresources()
  874.       /* ... */
  875.       IF error THEN RETURN FALSE  /* quelque s'est mal passé, on sort */
  876.       /* ... */
  877.     ENDPROC TRUE   /* on est allé aussi loin, on retourne TRUE */
  878.  
  879. Une version très raccourcit d'un définition de fonction peu-être :
  880.  
  881.     PROC <label> ( <arg> , ... ) RETURN <exp>
  882.  
  883. Ce sont des définitions de fonctions qui ont besoin de peu de calcul, comme
  884. les fonctions de puissances et associé : (en une ligne :-)
  885.  
  886.     PROC fac(n) RETURN IF n=1 THEN 1 ELSE fac(n-1)*n
  887.  
  888.  
  889. 6D. la fonction "main"
  890. ----------------------
  891.  
  892. La procédure appelée main a son importance, car elle est appelé en première ;
  893. elle fonctionne de la même minère que les autres fontions, et peut donc avoir
  894. des variables locales. Main n'a pas d'arguments : les arguments de la ligne
  895. de commande (du shell) sont fournis par la variable système "arg", ou peuvent
  896. être collectée avec ReadArgs().
  897.  
  898.  
  899. 6E. variables système prédéfinies (built-in)
  900. --------------------------------------------
  901.  
  902. Les variables globales suivantes sont toujours accessible au sein du programme.
  903. Ils sont appellés variables système :
  904.  
  905. arg             Vu plus haut, arg contient un pointeur sur une chaine terminée
  906.                 par un zéro. arg contient les arguments de la ligne de
  907.                 commande. Ne l'utilisez pas si vous voulez utiliser ReadArgs().
  908. stdout          Contient le gestionnaire de fichier de la sortie et de
  909.                 l'entrée standard. Si votre programme est lancé du workbench,
  910.                 aucune sortie shell n'est possible. WriteF() ouvrira une
  911.                 fenêtre CON: pour vous, et mettra son gestionnaire là.
  912. conout          Ces de là que le gestionnaire de fichier est pris et la
  913.                 fenêtre console sera automatiquement fermée à la fin de votre
  914.                 programme. Voir WriteF() dans le chapitre 9A pour savoir
  915.                 comment utiliser proprement les variables.
  916. execbase,       Ces 5 variables sont toujours définies avec leur valeur
  917. dosbase,        correcte.
  918. gfxbase,
  919. intuitionbase,
  920. mathbase
  921. stdrast         Pointeur sur le rastport standard utilisé dans votre
  922.                 programme, ou bien NIL. Les fonctions graphique prédéfinies
  923.                 comme Line() utilisent cette variable.
  924. wbmessage       Contient un pointeur sur un message reçu si le programme est
  925.                 lancé du workbench, sinon NIL. Il peut être utilisé comme
  926.                 variable booléenne pour détecter si vous vous êtes partis du
  927.                 workbench, ou pour pour collecter les arguments d'éventuelles
  928.                 icones cliquées. Voir le programme WbArgs.e dans le
  929.                 répertoire sources/exemples, pour savoir comment bien
  930.                 l'utiliser.
  931.  
  932.  
  933. +---------------------------------------------------------------+
  934. |                  7. DECLARATION DE CONSTANTES                 |
  935. +---------------------------------------------------------------+
  936.  
  937.  
  938. 7A. constantes (CONST)
  939. ----------------------
  940.  
  941. syntaxe:         CONST <déclarations>,...
  942.  
  943. Vous permet de déclarer une constante. Une déclaration ressemble à :
  944.     <ident>=<valeur>
  945.  
  946. Les constantes doivent être en majuscule, et seront traité dans le reste du
  947. programme comme <valeur>.
  948. Exemple :
  949.  
  950.     CONST MAX_LINES=100, ER_NOMEM=1, ER_NOFILE=2
  951.  
  952. Vous ne pouvez pas déclarer des constantes dans les mêmes termes qu'une autres
  953. dans la même instruction CONST. Mettez le dans une autre.
  954.  
  955.  
  956. 7B. énumerations (ENUM)
  957. -----------------------
  958.  
  959. Les énumérations sont un type de constante particulier, qui n'ont pas besoin
  960. de valeur, car ils sont définis de 0 à n ; le premier étant égal à zéro. A
  961. n'importe quel moment de l'énumération, vous pouvez utiliser la notation
  962. '=<value>' pour fixer ou remettre à zéro le compteur.
  963. Exemple :
  964.  
  965.     ENUM ZERO, ONE, TWO, THREE, MONDAY=1, TUESDAY, WEDNESDAY
  966.  
  967.     ENUM ER_NOFILE=100, ER_NOMEM, ER_NOWINDOW
  968.  
  969.  
  970. 7C. sets (SET)
  971. --------------
  972.  
  973. Les sets sont du même type que les énumérations, à la différence qu'au lieu
  974. d'augmenter leur valeur (0,1,2,...), on augmenter leur nombre de bit
  975. (0,1,2,...) et donc leur valeur deviennent (1,2,4,8,...). Cela a pour avantage
  976. qu'ils peuvent être utilisés comme des drapeaux (flags).
  977. Supposez un set comme celui--ci pour décrire les propriété d'un fenétre :
  978.  
  979.     SET SIZEGAD,CLOSEGAD,SCROLLBAR,DEPTH
  980.  
  981. pour initialiser une variable au pripriété DEPTH et SIZEGAD :
  982.  
  983.     winflags:=DEPTH OR SIZEGAD
  984.  
  985. pour ajouter un SCROLLBAR :
  986.  
  987.     winflags:=winflags OR SCROLLBAR
  988.  
  989. et pour tester si 2 propriétés sont pris en compte :
  990.  
  991.     IF winflags AND (SCROLLBAR OR DEPTH) THEN /* ... */
  992.  
  993.  
  994. 7D. constantes prédéfinies (built-in)
  995. -------------------------------------
  996.  
  997. Les constantes suivantes sont prédéfinies et peuvent être utilisées :
  998.  
  999. TRUE,FALSE      Représente les valeurs booléennes (-1,0)
  1000. NIL             (=0), le poineur non initialisé
  1001. ALL             Utilisé avec les fonctions de chaine comme StrCopy() pour
  1002.                 copier tous les caractères
  1003. GADGETSIZE      taille minimum en octets nécessaire pour définir un gadget ;
  1004.                 voir Gadget() au chapitre 9D
  1005. OLDFILE,NEWFILE Paramètres de mode à utiliser avec Open()
  1006. STRLEN          A toujours la longueur de la dernière chaine utilisée.
  1007.                 Exemple :
  1008.  
  1009.                 Write(handle,'Salut tous le monde!',STRLEN)      /* =20 */
  1010.  
  1011.  
  1012.  
  1013. +---------------------------------------------------------------+
  1014. |                           8. TYPES                            |
  1015. +---------------------------------------------------------------+
  1016.  
  1017. 8A. à propos du système "type"
  1018. ------------------------------
  1019.  
  1020. Le E n'a pas une système de type rigid comme le Pascal ou le Modula2, il est
  1021. même plus flexible que clui du C : on doit plutôt l'appeler un système de type
  1022. de donnée (datatype system). Il en résulte qu'en E tous les types de données
  1023. sont égaux : toutes les valeurs simples comme les carctères, entiers, etc.
  1024. Ils ont tousla même taille de 32 bits, et les autres types comme les tableaux,
  1025. les chaines sont représentés par des pointeurs de 32 bits pointant sur eux.
  1026. Ainsi, le compilateur E peut générer un code de façon très polymorphe.
  1027. Les (dés)avantages sont nombreux :
  1028.  
  1029.     désavantages :
  1030.  
  1031.     - peu de vérification sur des érreurs que vous faites.
  1032.  
  1033.     avantages :
  1034.  
  1035.     - polymorphisme de bas niveau,
  1036.     - programmation très flexible : aucune crainte de voir certaines valeurs
  1037.       retournées, ne correspondant pas à la variable cible, etc.,
  1038.     - facilité de retrouver des érreurs lors de mélange de données
  1039.       d'expressions de taille différentes,
  1040.     - bénéficie de types 'auto-documentés', si vous voulez comme ça :
  1041.  
  1042.           PTR to newscreen
  1043.  
  1044.  
  1045. 8B. le type simple (LONG/PTR)
  1046. -----------------------------
  1047.  
  1048. Il n'y a qu'un seul simple et non-complexe type en E, qui est le type
  1049. LONG de 32 bits. Comme c'est le type par défaut, il peut être déclaré comme :
  1050.  
  1051.     DEF a:LONG             ou juste:            DEF a
  1052.  
  1053. Ce type de variable a les mêmes caractèristiques que les types
  1054. CHAR/INT/OTR/LONG d'autres langages. Un variation de LONG est le type pointeur
  1055. PTR. Ce type est compatible avec le LONG, à la différence qu'il est spécifié
  1056. en tant que pointeur. Par défaut, le type LONG est spécifié comme PTR TO CHAR.
  1057.  
  1058. Syntaxe:    DEF <var>:PTR TO <type>
  1059.  
  1060. où le <type> est de type simple ou composé.
  1061. Exemple :
  1062.  
  1063.     DEF x:PTR TO INT, mon_écran:PTR TO screen
  1064.  
  1065. Notez que 'screen' est le nom d'un objet défini par le module
  1066. 'intuition/screens.m'. Par exemple, si vous ouvrez votre propre écran avec :
  1067.  
  1068.     mon_écran:=OpenS(...   etc.
  1069.  
  1070. vous devez utiliser le pointeur mon_écran tout comme 'mon_écran.rastport'.
  1071. Si vous ne voulez pas utiliser cette variable jusqu'à la fermeture de l'écran
  1072. par CloseS(mon_écran), vous pouvez simplement le déclarer comme :
  1073.  
  1074.     DEF mon_écran
  1075.  
  1076.  
  1077. 8C. le type simple (CHAR/INT/LONG)
  1078. ----------------------------------
  1079.  
  1080. Les types simples CHAR (8 bits) et INT (16 bits) ne doivent pas être utilisés
  1081. pour des variables de base. La raison de cela doit être clair maintenant.
  1082. Malgré tout, ils peuvent être utilisés comme type de données pour construire
  1083. des tableaux, ou poser des pointeurs, ou être utilisé dans des objets, etc.
  1084.  
  1085.  
  1086. 8D. le type tableau (ARRAY)
  1087. ---------------------------
  1088.  
  1089. Les tableaux sont déclarés en spécifiant leur longueur en octets :
  1090.  
  1091.     DEF b[100]:ARRAY
  1092.  
  1093. définie un tableaux de 100 octets. De façon interne, b est une variable de type
  1094. LONG et un pointeur sur cet espace mémoire.
  1095. Le type par défaut d'un élément du tableau est CHAR, mais peut être autre
  1096. chose en le spécifiant :
  1097.  
  1098.     DEF x[100]:ARRAY OF LONG
  1099.     DEF mes_menus[10]:ARRAY OF newmenu
  1100.  
  1101. où 'newmenu' est une exemple de structure (appelé OBJEcT en E).
  1102. L'accès au tableau est très simple :
  1103.     <var>[<exp>]
  1104. Exemples :
  1105.  
  1106.     b[1]:="a"
  1107.     z:=mes_menus[a+1].mutualexclude
  1108.  
  1109. Notez que l'index d'un tableaux de taille n, est définis de 0 à n-1,
  1110. et pas de 1 à n.
  1111. Notez que les tableaux de type x (ARRAY OF <type>) est compatible avec les
  1112. pointeurs sur un type x (PTR TO <type>, à la différence que la variable
  1113. tableau est déja initialisée.
  1114.  
  1115.  
  1116. 8E. le type complexe (STRING/LIST)
  1117. ----------------------------------
  1118.  
  1119. - STRING (chaine). Similaire aux tableaux, mais différent dans le sens
  1120.   qu'elles ne peuvent être modifiées que par les fonctions de chaines du E,
  1121.   et qu'ils contiennent les informations de longueurs (length et maxlength).
  1122.   Ainsi les fonctions de chaines peuvent les modifier sans crainte : la
  1123.   chaine ne peut pas être plus grande que l'espace mémoire où elle est.
  1124.  
  1125.   Syntaxe :     DEF s[80]:STRING
  1126.  
  1127.   Le type de données STRING est rétroactivement compatible avec PTR TO CHAR
  1128.   et bien sûr ARRAY TO CHAR, et c'est tout.
  1129.   Voir la chapitre sur les fonctions de chaines pour plus de détails.
  1130.  
  1131. - LIST (liste). C'est un type de données que l'on ne retrouve que dans
  1132.   d'autres langages comme le Prolog ou le Lisp. La version E peut être
  1133.   interprétée comme un mélange de chaine et de tableaux de LONG :
  1134.   cette structure de données est une liste de variables LONG qui peuvent
  1135.   être étendu ou résumé à des chaines.
  1136.  
  1137.   Syntaxe :     DEF x[100]:LIST
  1138.  
  1139.   Un plus puissant à ce type de données est qu'il a un équivalent 'constant'
  1140.   [], comme les chaines ont ''. Les listes sont rétroactivement compatible
  1141.   avec PTR TO lONG et bien sûr ARRAY OF LONG, et c'est tout.
  1142.   Voir les chapitres 2G et 9C pour plus d'informations.
  1143.  
  1144.  
  1145. 8F. le type composé (OBJECT)
  1146. ----------------------------
  1147.  
  1148.   Les objets sont l'équivalent des structures en C ou RECORD en Pascal.
  1149.   Exemple :
  1150.  
  1151.       OBJECT myobj
  1152.         a:LONG
  1153.         b:CHAR
  1154.         c:INT
  1155.       ENDOBJECT
  1156.  
  1157.   définie une structure de données de 3 éléments.
  1158.  
  1159.   Syntaxe:      OBJECT <nom_objet>
  1160.                   <nom_membre> [ : <type> ]      /* autant que vous voulez */
  1161.                 ENDOBJECT
  1162.  
  1163.   où le type est un type simple ou composé, ou un tableau simple :
  1164.   [<nb_éléments>]:ARRAY avec par défaut, la taille CHAR pour un élément.
  1165.   Notez que <nom_membre> peut ne pas être seul, et peut se trouver dans
  1166.   d'autres objets. Il y a beaucoup de manière d'utiliser les objets :
  1167.  
  1168.       DEF x:mon_objet                  /* x est une structure */
  1169.       DEF y:PTR TO mon_objet           /* y est juste un pointer dessus */
  1170.       DEF z[10]:ARRAY OF mon_objet
  1171.  
  1172.       y:=[-1,"a",100]:myobj            /* listes typées */
  1173.  
  1174.       IF y.b="a" THEN /* ... */
  1175.  
  1176.       z[4].c:=z[d+1].b++
  1177.  
  1178.   Les tableaux dans les objets sont toujours arrondis à la taille paire,
  1179.   et mis sur des offsets pairs :
  1180.  
  1181.       OBJECT machaine
  1182.         longueur:CHAR,
  1183.         donnée[9]:ARRAY
  1184.       ENDOBJECT
  1185.  
  1186.   La taille (SIZEOF) de 'machaine' est de 12, et 'donnée' commence à
  1187.   l'offset 2.
  1188.  
  1189.   NOTE : les objet du E ne sont pas ce que vous imaginez dans d'autres
  1190.   langages. Par exemple, pas seulement les types peuvent former un membre
  1191.   d'un objet, et grace à ça, des accès récursif aux objets comme x.y.z
  1192.   non aucun sens (pour le moment).
  1193.  
  1194. 8G. initialisation
  1195. ------------------
  1196.  
  1197. 1. Sont toujours initialisées à NIL (or autres, si explicitement décrit)
  1198.     - les variables globales,
  1199.       NOTE : pour une bonne documentation, il est conseillé d'écrire
  1200.       xxx =NIL dans la définition de variables qui vous voulez avoir nulle
  1201. 2. Sont initialisées a '' et respectivement []
  1202.     - les chaines globales et locales
  1203.     - les listes globales et locales
  1204. 3. Ne sont pas initialisés
  1205.     - les variables locales (tant qu'elle ne sont pas définies explicitement)
  1206.     - les tableaux globals et locaux
  1207.     - les objets globals et locaux
  1208.  
  1209.  
  1210.  
  1211. +---------------------------------------------------------------+
  1212. |                     9. FONCTIONS PREDEFINIES                  |
  1213. +---------------------------------------------------------------+
  1214.  
  1215. 9A. fonctions d'entrée - sortie (I/O)
  1216. -------------------------------------
  1217.  
  1218.  
  1219. WriteF(formatstring,args,...)
  1220.  
  1221.     affiche une chaine (qui peut contenir des codes de format) vers stdout. De
  1222.     zéro à un nombre illimité d'arguments peut être ajoutés. Notez qu'une
  1223.     chaine formattée peut être crée dynamiquement, aucune vérification sur le
  1224.     nombre d'arguments est (peut être) fait.
  1225.     Exemple :
  1226.  
  1227.         WriteF('salut à tous!\n')       /* juste écrit un saut de ligne à */
  1228.                                         /* la fin de la chaine */
  1229.  
  1230.         WriteF('a = \d \n',a)           /* écrit : "a = 123", si a est 123 */
  1231.  
  1232.     Voir le morceau concernant les chaines, quelque part par ici.
  1233.     NOTE : si stdout=NIL, par exemple si votre programme a été lancé du
  1234.     Workbench, WriteF() ouvrira une fenêtre de sortie (uniquement sous 2.0),
  1235.     et mettra le gestionnaire dans conout et stdout. Cette fenêtre sera
  1236.     automatiquement refermée à la sortie du programme, après que l'utilisateur
  1237.     aie frappé <return>.
  1238.     WriteF() est la seule fonction qui ouvre une fenêtre, donc si vous voulez
  1239.     faire des entrées/sorties sur stdout, et pour être sûr que stdout<>NIL,
  1240.     faites un WriteF('') comme première instruction de votre programme par
  1241.     sécurité.
  1242.     Si vous voulez ouvrir une fenêtre console vous même, vous devez faire de
  1243.     la sorte de placer le résultat du gestionnaire de fichier (file handle)
  1244.     dans les variables stdout et conout, comme ça votre fenêtre sera fermé
  1245.     automatiquement à la fin du programme.
  1246.     Si vous voulez fermer vous même votre fenêtre, assurez vous de remettre
  1247.     conout à NIL, pour signaler au E qu'il n'y a aucune fenêtre console à
  1248.     fermer.
  1249.  
  1250.  
  1251. Out(gestionnaire,car)
  1252. char:=Inp(gestionnaire)
  1253.  
  1254.     D'une part écrit, d'autre part lit un octet vers un fichier ou sur stdout.
  1255.     Si car=-1 alors un EOF est atteint, ou une érreur s'est passé.
  1256.  
  1257.  
  1258. longueur:=FileLength(nom_chaine)
  1259.  
  1260.     vous donne la longueur d'un fichier que vous voulez charger, et donc si
  1261.     il éxiste ; ou retourne -1 pour une érreur ou si il n'est pas trouvé.
  1262.  
  1263.  
  1264. ok:=ReadStr(filehandle,estring)
  1265.  
  1266.     Voir les fonctions de chaine
  1267.  
  1268.  
  1269. oldout:=SetStdOut(newstdout)
  1270.  
  1271.     Fixe la variable de sortie standard stdout. C'est l'équivalent de :
  1272.  
  1273.         oldout:=stdout ; stdout:=newstdout
  1274.  
  1275.  
  1276.  
  1277. 9B. chaines et fonctions de chaine
  1278. ----------------------------------
  1279.  
  1280. Le E possède le type de données STRING. C'est une chaine, appelée à partir de
  1281. maintenant chaine E ('Estring'), qui peut être modifié et changé en taille,
  1282. à opposer à la chaine normale ('string'), qui sera utilisé pour n'importe
  1283. quelle séquence terminée par un zéro.
  1284. Les chaines E sont rétroactivement compatible avec les chaines, et rien
  1285. d'autres. Alors si un argument demande une chaine normale, on y mettre
  1286. indifféremment l'une des 2 chaines. Si parcontre une chaine E est demandée,
  1287. n'utilisez pas une chaine normale.
  1288. Exemple :
  1289.  
  1290.     DEF s[80]:STRING, n            /* s est une chaine E avec une  */
  1291.                                    /* longueur maximum de 80       */
  1292.     ReadStr(stdout,s)              /* lit un entrée sur la console */
  1293.     n:=Val(s,NIL)                  /* et en sort une valeur        */
  1294.         ... etc.
  1295.  
  1296. Notez que toutes les fonctions de chaine sont gérer de façon à tendre vers
  1297. leur longueur maximum correctement
  1298.  
  1299.     DEF s[5]:STRING
  1300.     StrAdd(s,'ceci est une chaine de 5 caractères',ALL)
  1301.  
  1302. s va contenir 'ceci '.
  1303.  
  1304.  
  1305. s:=String(maxlen)
  1306.  
  1307.     Une chaine peut donc allouée dynamiquement en mémoire système avec la
  1308.     fonction String(), (note: le pointeur retourné par cette fonction doit
  1309.     toujours être vérifiée.
  1310.  
  1311.         DEF s[80]:STRING
  1312.  
  1313.     est équivalent à :
  1314.  
  1315.         DEF s
  1316.         s:=String(10)
  1317.  
  1318.  
  1319. bool:=StrCmp(chaine1,chaine2,long)
  1320.  
  1321.     compare 2 chaines.
  1322.  
  1323.     long        est le nombre d'octet à comparer, ou ALL pour comparer
  1324.                 toute la longueur.
  1325.     Retourne :  TRUE ou FALSE
  1326.  
  1327.  
  1328. StrCopy(chaineE,chaine,long)
  1329.  
  1330.     copie le chaine vers la chaine E
  1331.  
  1332.     long : nombre d'octet à copier ou ALL
  1333.  
  1334.  
  1335. StrAdd(chaineE,chaine,len)
  1336.  
  1337.     fait comme StrCopy(), à la différence que la chaine est mis à la fin
  1338.     de la chaine E (concaténation)
  1339.  
  1340.  
  1341. long:=StrLen(chaine)
  1342.  
  1343.     calcule la longueur d'une chaine terminée par un zéro.
  1344.  
  1345.  
  1346. long:=EstrLen(chaineE)
  1347.  
  1348.     retourne la longueur d'un chaine E.
  1349.  
  1350.  
  1351. max:=StrMax(chaineE)
  1352.  
  1353.     retourne la longueur maximale d'un chaine E
  1354.  
  1355.  
  1356. RightStr(chaineE1,chainE2,n)
  1357.  
  1358.     copie les n derniers caractères de la chaine 1 sur la chaine 2
  1359.  
  1360.  
  1361. MidStr(chaineE1,chaine2,pos,long)
  1362.  
  1363.     copie un nombre de caractère (long) (tous si long=ALL) à partir de la
  1364.     position pos de la chaine 2 sur la chaine 1.
  1365.     NOTEZ : dans toutes les fonctions de chaines, le premier caractères à la
  1366.     position 0 et non pas 1, comme c'est le cas dans des langages comme le
  1367.     BASIC.
  1368.  
  1369.  
  1370. valeur:=Val(chaine,lecture)
  1371.  
  1372.     trouve un entier dans une chaine ASCII. Les espaces/tabulations/etc...
  1373.     sont sauté, et ainsi les nombres héxadécimaux (123456789abcdef) et
  1374.     binaire (01) peuvent être lu de cette manière si ils sont précédés par
  1375.     un '$' ou un '%' respectivement. Un '-' signifie un entier négatif.
  1376.     Val() retourne le nombre de caractères lu, dans 'lecture', qui doit être
  1377.     donné par référence (<-!!!). Si 'lecture' retourne 0 (et la valeur sera
  1378.     aussi 0), alors la chaine ne contient pas d'entier, ou la valeur et trop
  1379.     grande pour entré dans 32 bits. 'lecture' peut être NIL.
  1380.  
  1381.     Exemples de chaines qui seront correctement analysées :
  1382.         '-12345', '%10101010', '   -$ABcd12'
  1383.  
  1384.     Ces chaines seront retournés en tant que 'valeur' et dans une variable
  1385.     {lu} un zéro :
  1386.         '', 'hello!'
  1387.  
  1388.  
  1389. quelle_pos:=InStr(chaine1,chaine2,pos_départ)
  1390.  
  1391.     cherche dans la chaine 1, la chaine 2, a partir du caractère pos_départ.
  1392.     L'*adresse* a laquelle lachaine 2 a été retrouvé, est retournée, sinon -1.
  1393.  
  1394.  
  1395. nouv_adr_chaine:=TrimStr(chaine)
  1396.  
  1397.     retourne l'*adresse* du premier caractère, après avoir enlevé les espaces,
  1398.     tabulations, etc...
  1399.  
  1400.  
  1401. UpperStr(chaineE)
  1402. LowerStr(chaineE)
  1403.  
  1404.     Transforme les minuscule en masjuscule (respectivement masjuscule en
  1405.     minuscule)
  1406.     NOTE : ces fonctions modifient le contenu de 'chaine'. On ne peut donc
  1407.     utiliser que des chaines E. Cela suppose que vous obteniez l'adresse d'une
  1408.     chaine grace à une fonctions de l'Amiga. Vous devez alors faire une copie
  1409.     (par StrCopy()) de cette chaine dans une chaine E, puis utiliser ces
  1410.     fonctions.
  1411.  
  1412.  
  1413. ok:=ReadStr(gest_fichier,chaineE)
  1414.  
  1415.     lit une chaine (se terminant par le code ASCII 10) de n'importe quel
  1416.     fichier ou de stdout.
  1417.     ok contient -1 si il y a erreur, ou une fin de fichier (EOF) si on est
  1418.     à la fin.
  1419.     NOTE : le contenu de la chaine lue est toujours valide.
  1420.  
  1421.  
  1422. SetStr(chainE,nouv_long)
  1423.  
  1424.     modifie manuellement la longueur d'une chaine E. C'est pratique lorsque
  1425.     qu'une fonction autre que les fonctions E, lit une chaine E, et vous
  1426.     voulez continuer à utiliser cette variable.
  1427.     Par exemple, après avoir utilisé une fonction qui ajoute un zero à la fin
  1428.     d'un chaine E, prenez SetStr(ma_chaine,StrLen(ma_chaine)) pour manipuler
  1429.     ma_chaine à nouveau.
  1430.  
  1431. Pour les fonctions liant les chaines, voir la chapitre 9H
  1432.  
  1433.  
  1434.  
  1435. 9C. listes et fonctions de liste
  1436. --------------------------------
  1437.  
  1438. Les listes sont comme les chaines, à la différence qu'elles consistent en
  1439. LONG, et pas en CHAR.
  1440. Elles peuvent être declarées en globale, locale ou dynamiquement :
  1441.  
  1442.     DEF maliste[100]:LIST        /* local ou global */
  1443.     DEF a
  1444.     a:=List(10)                  /* dynamique */
  1445.  
  1446. Note que dans le dernier cas, le pointeur 'a' contient NIL
  1447. Tout comme les chaines sont représentées comme constantes dans les
  1448. expressions, les listes ont aussi cette possibilité :
  1449.  
  1450.     [1,2,3,4]
  1451.  
  1452. La valeur d'une telle expression est un pointeur sur une liste initialisée.
  1453. Il en résulte que vous pouvez alors avoir une déclaration dynamique, qui sera
  1454. remplit au moment même de la déclaration :
  1455.  
  1456.     a:=3
  1457.     [1,2,a,4]
  1458.  
  1459. De plus, les listes peuvent avoir d'autres types que LONG par défaut :
  1460.  
  1461.     [1,2,3]:INT
  1462.     [65,66,67,0]:CHAR                    /* équivalent à 'ABC' */
  1463.     ['topaz.font',8,0,0]:textattr
  1464.     OpenScreenTagList(NIL,[SA_TITLE,'Mon Ecran',TAG_DONE])
  1465.  
  1466. Comme le dernier exemple le montre, les listes sont très utiles dans les
  1467. fonctions système : elles sont rétroactivement compatible avec les tableaux
  1468. (ARRAY OF LONG). Les objects peuvent être utilisé n'importe où une fonction
  1469. à besoin d'un pointeur sur une structure, ou un un tableaux.
  1470. Les fonctions de listes de tags (taglist) et les arguments (vararg) peuvent
  1471. être utilisé de cette façon.
  1472. NOTE : toutes les fonctions delistes travaillent avec des listes de LONG.
  1473. Les listes typées ne sont pratiques que pour construire des structures et des
  1474. expressions.
  1475.  
  1476. Comme pour les chaines, une certaine hiérarchie est de rigueur :
  1477. variables de liste -> listes de constantes -> tableau de LONG/pointeur sur LONG
  1478. Quand une fonction a besoin d'un tableau de LONG, vous n'avez qu'à donner une
  1479. liste comme argument, mais qudn une fonction demande une variable de liste
  1480. (listvar) ou une liste de constante, alors un tableau de LONG ne marchera pas.
  1481.  
  1482. Il est important que vous compreniez la puissance des listes et en particulier
  1483. les listes typées : elles peuvent vous éviter beaucoup soucis lors du codage
  1484. d'une structure de données. Essayez d'utiliser ces listes dans vos propres
  1485. programmes, et regrdez en les fonctions dans les programmes exemples. Une fois
  1486. que vous aurez pris le coup, vous ne pourrez vous en passer !
  1487.  
  1488. Résumé :
  1489.  
  1490.     [<élément>,<élément>,... ]          liste immédiate (de LONGs, à utiliser
  1491.                                         avec les fonctions de liste)
  1492.     [<élément>,<élément>,... ]:<type>   listes typées (pour construire des
  1493.                                         structures)
  1494.  
  1495. Si <type> est un type simple comme INT ou CHAR, vous n'avez que l'équivalent
  1496. initialisé d'un tableau de <type>.
  1497. Si <type> est le nom d'un objet, vous devez construire cet objet, ou un
  1498. tableau d'<objet>, suivant la longueur de la liste.
  1499. Exemple :
  1500.  
  1501.     [1,2,3]:INT
  1502.  
  1503. vous créez une structure de 6 octets, de 3 fois
  1504. 16 bits pour être précis. La valeur de cette expression est un pointeur sur
  1505. cette espace mémoire. Il en va de même si vous avez un objet :
  1506.  
  1507.     OBJECT mon_object
  1508.       a:LONG, b:CHAR, c:INT
  1509.     ENDOBJECT
  1510.  
  1511. écrire
  1512.  
  1513.     [1,2,3]:mon_object
  1514.  
  1515. signifiera la création d'un structure en mémoire de 8 octets, avec les 4
  1516. premiers octets étant un LONG de valeur 1. L'octet suivant et un CHAR de
  1517. valeur 2, et les 2 derniers octets un INT (2 octets) de valeur 3. Vous pouvez
  1518. aussi écrire :
  1519.  
  1520.     [1,2,3,4,5,6,7,8,9]:mon_object
  1521.  
  1522. vous créez un tableau de <mon_objet> de taille 3. Notez que de telles listes
  1523. n'ont pas besoin d'être complêtes (3,6,9... éléments), vous pouvez créer
  1524. partiellement des objets avec des listes de n'importe quelle taille.
  1525.  
  1526. Une dernière note sur la taille des données :
  1527. Sur l'Amiga, vous remarquerez qu'une structure comme 'mon_objet' a une taille
  1528. de 8, et rempli à 16 pour avoir un mot. Il est certainement peu probable
  1529. qu'un compilateur E pour une architecture 80x86 n'utilisera pas ce
  1530. remplissage et en fera une structure de 7 octets, et qu'un compilateur pour
  1531. une architecture sun-sparc (si je ne me trompe pas) essayera de remplire à 32
  1532. bits, qui fera une structure de 10 ou 12 octets. Certains microprocesseurs
  1533. (rares, pas existants) utilise même les nombres de bits 38:18:9 pour leur type
  1534. LONG:INT:CHAR, au lieu de 32:16:8, comme on le fait. Alors, ne concluez pas
  1535. trop vite en ce qui concerne les objets et les listes, si vous voulez que
  1536. votre code soit portable au maximum, ou n'aie d'effets secondaires.
  1537.  
  1538.  
  1539. ListCopy(listevar,liste,n)
  1540.  
  1541.     copie n éléments de la <liste> sur la <listevar>.
  1542.     Exemple :
  1543.         DEF maliste[10]:LIST
  1544.         ListCopy(maliste,[1,2,3,4,5],ALL)
  1545.  
  1546.  
  1547. ListAdd(listvar,liste,n)
  1548.  
  1549.     copie n éléments de la <liste> à la fin de <listevar>.
  1550.  
  1551.  
  1552. ListCmp(list1,list2,n)
  1553.  
  1554.     compare les 2 listes, ou n éléments d'elles.
  1555.  
  1556.  
  1557. long:=ListLen(liste)
  1558.  
  1559.     retourne la longueur de la <liste>.
  1560.     Exemple :
  1561.         ListLen([a,b,c])    retourne 3
  1562.  
  1563.  
  1564. max:=ListMax(listevar)
  1565.  
  1566.     retourne la longueur maximale possible de <listevar>
  1567.  
  1568.  
  1569. valeur:=ListItem(liste,index)
  1570.  
  1571.     est l'équivalent de : valeur:=liste[index]
  1572.     à la différence que <liste> doit être une constante au lieu d'être un
  1573.     pointeur. C'est treès utile dans des cas où vous voulez directement
  1574.     utiliser une liste de valeurs :
  1575.  
  1576.         WriteF(ListItem(['ok!','pas de mem!','pas de fichier!'],erreur))
  1577.  
  1578.     Cet exemple écrit un message d'erreur en fonction d'<erreur>.
  1579.     C'est l'équivalent de :
  1580.  
  1581.     DEF dummy:PTR TO LONG
  1582.     dummy:=['ok!','pas de mem!','pas de fichier!']
  1583.     WriteF(dummy[error])
  1584.  
  1585.  
  1586. SetList(listevar,nouv_long)
  1587.  
  1588.     fixe manuellement la longueur d'une liste. C'est seulement utile lorsque
  1589.     vous lisez utiliser des listes par des fonctions autres que les fonctions
  1590.     spécifiques aux listes, et aue vous voulez continuer à l'utiliser comme
  1591.     vraie liste.
  1592.  
  1593.  
  1594. Pour les fonstion de liste qui utilise des expressions cotées '', voir le
  1595. chapitre 11C.
  1596. Pour les fonctions liant les listes, voir le chapitre 9h.
  1597.  
  1598.  
  1599. 9D. fonctions de support Intuition
  1600. ----------------------------------
  1601.  
  1602. wptr:=OpenW(x,y,largeur,hauteur,IDCMP,wdrapeaux,titre,écran,sdrapeaux,gadlist)
  1603.  
  1604.     crée une fenêtre où :
  1605.     - wdrapeaux (wflags) sont des drapeaux pour la mise en forme de la fenêtre
  1606.       comme BACKDROP, SIMPLEREFRESH... engénéral $f
  1607.     - sdrapeaux (sflags) est le type d'écran où doit s'ouvrir la fenêtre
  1608.       1 = workbench, 15 = particulier (custom)
  1609.     - screen est un pointeur sur l'écran qui doit être valide si sdrapeux = 15
  1610.       sinon screen=NIL (0)
  1611.     - gadlist pointe sur une structure de liste de gadgets, que vous pouvez
  1612.       facilement créer avec la fonction Gadget(), sinon NIL.
  1613.  
  1614.  
  1615. CloseW(wptr)
  1616.  
  1617.     ferme la fenêtre de nouveau. La seule différence avec CloseWindow()
  1618.     (fonction système) est qu'elle accepte le pointeur null (NIL) et remet
  1619.     stdrast à zéro (NIL).
  1620.     - wptr est le pointeur donné par OpenW() ou OpenWindow() pour cette
  1621.       fenêtre.
  1622.  
  1623.  
  1624. sptr:=OpenS(largeur,hauteur,profondeur,sdrapeaux,titre)
  1625.  
  1626.     ouvre un écran pour vous.
  1627.     - profondeur est le nombre de plan de bit (bitplanes) (1 à 6, 1 à 8 pour
  1628.       les machines AGA),
  1629.     - sdrapeaux est le type de résolutions, 0 pour basse résolution, $8000
  1630.       pour haute résolution, ajoutez 4 pour l'entrelacement
  1631.  
  1632.  
  1633. CloseS(sptr)
  1634.  
  1635.     ferme l'écran. Fonctionne de même facon que CloseW().
  1636.     - wptr est le pointeur donné par OpenS() ou OpenScreen() pour cet écran.
  1637.  
  1638.  
  1639. tampon_suivant:=Gadget(tampon,gadlist,id,drapeaux,x,y,largeur,chaine)
  1640.  
  1641.     Cette fonction crée une liste de gadgets, qui peuvent être mis dans votre
  1642.     fenêtre en les donnant comme argument à OpenW(), ou après l'ouverture
  1643.     avec une fonctions Intiotin comme AddGlist().
  1644.     - tampon (buffer) est souvent un tableaux de taille GADGETSIZE octets
  1645.       pour sauver toutes les structures associées à un gadget,
  1646.     - id est le n'importe quelle nombre vous permettnt de vous rappelez de
  1647.       quel gadget il s'agit lorsqu'il est pressé,
  1648.     - drapeaux : 0 = gadget normal
  1649.                  1 = gadget booléen (interrupteur)
  1650.                  3 = gadget booléen pressé
  1651.     - largeur est la largeur en pixel. Il doit être suffisament grand pour
  1652.       contenir la chaine qui est auto-centrée,
  1653.     - gadlist doit être NIL pour le premier gadget, puis glistvar pour le
  1654.       tampon suivant, comme ça le E poura faire le lien entre les gadgets.
  1655.     La fonction retourne un pointeur sur le tampon suivant
  1656.     (=tampon+GADGETSIZE).
  1657.     Exemple pour 3 gadgets :
  1658.  
  1659.         CONST MAXGADGETS=GADGETSIZE*3
  1660.  
  1661.         DEF tampon[MAXGADGETS]:ARRAY, suivant, wptr
  1662.  
  1663.         suivant:=Gadget(tampon,NIL,1,0,10,20,80,'bla')  /* le premier gadget */
  1664.         suivant:=Gadget(suivant,tampon,... )
  1665.         suivant:=Gadget(suivant,tampon,... )          /* n'importe lequel  */
  1666.                                                       /* lie les 2 premiers */
  1667.  
  1668.         wptr:=OpenW( ...,buf)
  1669.  
  1670.     Regardez les exemples comme SuperVisor.e pour une exemple parlant.
  1671.  
  1672.  
  1673. code:=Mouse()
  1674.  
  1675.     donne l'état actuel des 2 ou 3 boutons de la souris ;
  1676.     1 = gauche, 2 = droit, 4 = centre
  1677.     Si par exemple code=3 alors les boutons gauches est droit sont pressés.
  1678.     NOTE : ce n'est pas une réelle fonction Intuition. Si vous voulez connaitre
  1679.     les évènements de la souris de manière propre, regardez dans la structure
  1680.     intuimessage que votre fenêtre recoit.
  1681.     C'est la seule fonction du E qui contrôle le hardware, et n'est utile aue
  1682.     dans des programmes de style démos.
  1683.  
  1684.  
  1685. x:=MouseX(fenêtre)
  1686. y:=MouseY(fenêtre)
  1687.  
  1688.     vous permet de lire les coordonées de la souris.
  1689.     - fenêtre est le pointeur sur la fenêtre par rapport a laquelle les
  1690.     coordonées seront relatifs
  1691.  
  1692.  
  1693. classe:=WaitIMessage(fenêtre)
  1694.  
  1695.     Cette fonction rend plus facile l'attente d'un évènement dans une fenêtre.
  1696.     Elle attend simplement qu'un intuimessage arrive, et retourne la classe
  1697.     de cet évènement. Elle mets les autres variables comme le code comme
  1698.     variables globales privées, afin d'y accéder grace aux fonctions
  1699.     ci-dessous.
  1700.     WaitImessages est l'équivalent du code suivant :
  1701.  
  1702.         PROC waitimessage(win:PTR TO window)
  1703.           DEF port,mes:PTR TO intuimessage,class,code,qual,iaddr
  1704.           port:=win.userport
  1705.           IF (mes:=GetMsg(port))=NIL
  1706.             REPEAT
  1707.               WaitPort(port)
  1708.             UNTIL (mes:=GetMsg(port))<>NIL
  1709.           ENDIF
  1710.           class:=mes.class
  1711.           code:=mes.code             /* sauvé en interne */
  1712.           qual:=mes.qualifier
  1713.           iaddr:=mes.iaddress
  1714.           ReplyMsg(mes)
  1715.         ENDPROC class
  1716.  
  1717.     comme vous le voyez, la fonction prend exactement un message, et n'oubliez
  1718.     pas qu'il peut arriver plusieurs messages dans un évènement, si appelé
  1719.     plus d'une fois.
  1720.     Par exemple, ovus ouvrez une fenêtre qui affiche quelque chose et attend
  1721.     que l'on presse sur le gqdget de fermeture de l'écran (vous avez spécifiez
  1722.     IDCMP_CLOSEWINDOW) à l'ouverture de la fenêtre) :
  1723.  
  1724.         WaitIMessage(ma_fenêtre)
  1725.  
  1726.     ou vous avez un programme qui attend plusieurs type d'évènements, les gére
  1727.     dans une boucle, et sort avec le gadget de fermeture :
  1728. or, you have a program that waits for more types of events, handles
  1729. them in a loop, and ends on a closewindow event:
  1730.  
  1731.         WHILE (class:=WaitIMessage(win))<>IDCMP_CLOSEWINDOW
  1732.           /* gestion de classes */
  1733.         ENDWHILE
  1734.  
  1735.  
  1736. code:=MsgCode()
  1737. qual:=MsgQualifier()
  1738. iaddr:=MsgIaddr()
  1739.  
  1740.     Ces fonctions vous donneront les variables globales privées mentionnées
  1741.     plus haut. Les valeurs retournnées sont définies d'près l'appel le plus
  1742.     récent de WaitIntuiMessage().
  1743.     Exemple :
  1744.  
  1745.     IF class:=IDCMP_GADGETUP
  1746.       mon_gadget:=MsgIaddr()
  1747.       IF mon_gadget.userdata=1 THEN  /* ... on a pressé le gadget #1 */
  1748.     ENDIF
  1749.  
  1750.  
  1751.  
  1752. 9E. fonctions de support graphique
  1753. ----------------------------------
  1754.  
  1755. Toutes les fonctions de support graphique qui n'implique pas directement
  1756. un rastport, utilise la variable système 'stdrast'. Elle est automatiquement
  1757. définie par le dernier appel de OpenW ou OpenS(), et remis à NIL avec CloseW()
  1758. et CloseS.
  1759. Appeler ces fonctions avec stdrast égal à NIL est légal. stdrast peut être
  1760. manuellement modifié par SetStdRast() ou stdrast:=mon_rastport.
  1761.  
  1762.  
  1763. Plot(x,y,couleur)
  1764.  
  1765.     dessine un point sur l'écran/fenêtre dans la couleur voulue.
  1766.     - couleur = 0 à 31, 0 à 255 pour les machines AGA.
  1767.  
  1768.  
  1769. Line(x1,y1,x2,y2,colour)
  1770.  
  1771.     trace une ligne
  1772.  
  1773.  
  1774. Box(x1,y1,x2,y2,colour)
  1775.  
  1776.     trace une boite
  1777.  
  1778.  
  1779. Colour(avant,fond)
  1780.  
  1781.     fixe les couleurs des fonctions graphiques qui ne prennent pas de couleur
  1782.     comme argument. C'est le *registre* de couleur qui est demqndé, pas la
  1783.     *valeur*.
  1784.     NOTE : les fonctions qui ont un argument de 'couleur', modifie le Apen du
  1785.     stdrast.
  1786.  
  1787.  
  1788. TextF(x,y,chaine_formattée,args,...)
  1789.  
  1790.     tout comme la fonction WriteF(), mais uniquement à (x,y) sur votre
  1791.     stdrast, au lieu de stdout.
  1792.     Voir WriteF() et les chaines
  1793.  
  1794.  
  1795. anc_rast:=SetStdRast(nouv_rast)
  1796.  
  1797.     chnge le rastport de sortie des fonctions graphiques du E
  1798.  
  1799.  
  1800. SetTopaz(taille)
  1801.  
  1802.     fixe la police de caractères (font) du rastport 'stdrast'. Assurez vous
  1803.     que certaine police système de l'utilisateur ne modifieront pas votre
  1804.     mise en page.
  1805.     - taille = 8 ou 9
  1806.  
  1807.  
  1808.  
  1809. 9F. fonctions de support du système
  1810. -----------------------------------
  1811.  
  1812. bool:=KickVersion(vers)
  1813.  
  1814.     retourne TRUE si le Kickstart de la machine est égal ou supérieur à
  1815.     <vers>, sinon FALSE
  1816.  
  1817.  
  1818. mem:=New(n)
  1819.  
  1820.     créé dynamiquement un tableau (ou un espace mémoire, si vous voulez) de
  1821.     <n> octets. La différence avec AllocMem() est que l'appel se fait
  1822.     automatiquement avec un dreapeau de $10000 et que vous n'avez pas à
  1823.     appeler Dispose(), car lié à une liste mémoire qui est automatiquement
  1824.     désallouée à la sortie du programme.
  1825.  
  1826.  
  1827. Dispose(mem)
  1828.  
  1829.     gèle n'importe quelle <mem> alloué par New(). Vous ne devez utiliser cette
  1830.     fonction que si vous voulez libérer explicitement de la mémoire _pendant_
  1831.     que la programme tourne, tout comme cela se fait à la sortie de celui-ci.
  1832.  
  1833.  
  1834. CleanUp(valeur_retournée)
  1835.  
  1836.     sort du programme à n'importe quel moment. Il remplace la fonction DOS
  1837.     Exit() : n'utilisez jamais celui-là ! plutôt CleanUp(), qui permet de
  1838.     désallouer la mémoire, de fermer correctement les bibliothèques, etc.
  1839.     La <valeur_retournée> est donnée au DOS comme code de retour (returncode).
  1840.  
  1841.  
  1842. espace:=FreeStack()
  1843.  
  1844.     retourne l'espace libre de la pile. Cela doit toujours être 1000 ou plus.
  1845.     Voir le chapitre 'implémentation' sur comment le E organise sa pile.
  1846.     Si vous n'avez pas de trop grosses récursions, vous n'avez pas à vous en
  1847.     faire quant à cet espace libre.
  1848.  
  1849.  
  1850. bool:=CtrlC()
  1851.  
  1852.     retourne TRUE si Ctrl-C est pressé depuis la dernière fois, sinon FALSE.
  1853.     Cela ne marche que pour les programmes lancés via le shell (des programmes
  1854.     CLI).
  1855.  
  1856.  
  1857. Exemple montrant comment les 3 dernière fonctions peuvent être utilisées :
  1858.  
  1859.     /* calcule le factoriel de l'argument de la ligne de commande */
  1860.  
  1861.     OPT STACK=100000
  1862.  
  1863.     PROC main()
  1864.       DEF num,r
  1865.       num:=Val(arg,{r})
  1866.       IF r=0
  1867.         WriteF('mauvais args.\n')
  1868.       ELSE
  1869.         WriteF('résultat: \d\n',fac(num))
  1870.       ENDPROC
  1871.     ENDPROC
  1872.  
  1873.     PROC fac(n)
  1874.       DEF r
  1875.       IF FreeStack()<1000 OR CtrlC() THEN CleanUp(5)    /* vérif suppl */
  1876.       IF n=1 THEN r:=1 ELSE r:=fac(n-1)*n
  1877.     ENDPROC r
  1878.  
  1879. Bien sûr, cette récursion marchera difficilement avec peu de pile, et quand il
  1880. marche, il est stoppé si vite par FreeStack() que vous n'aurez pas le temps
  1881. de presser Ctrl-C, mais l'idée est là.
  1882. Une définition de fac(n) comme suit est moins sûre :
  1883.  
  1884.     PROC fac(n) RETURN IF n=1 THEN 1 ELSE fac(n-1)*n
  1885.  
  1886.  
  1887.  
  1888. 9G. mathématiques et autres fonctions
  1889. -------------------------------------
  1890.  
  1891. a:=And(b,c)
  1892. a:=Or(b,c)
  1893. a:=Not(b)
  1894. a:=Eor(b,c)
  1895.  
  1896.     Ceux-ci marche comme les opérations usuelles, aussi bien booléennes
  1897.     qu'arithmétiques.
  1898.     Notez que pour And() et Or(), un opérateur existe.
  1899.  
  1900.  
  1901. a:=Mul(b,c)
  1902. a:=Div(a,b)
  1903.  
  1904.     réalise les mêmes opérations que les opérateurs '*' et '/', mais
  1905.     maintenant en vrai 32 bits. Pour des raisons de rapidité, les opérations
  1906.     normale sont faites en 16 bits * 16 bits = 32 bits et 32 bits / 16 bits
  1907.     = 16 bits. C'est suffisent pour quasiment tous les calculs, et quand ce
  1908.     n'est pas le cas, utilisez Mul() et Div().
  1909.     NOTE : pour Div(), a est divisé par b, pas l'inverse.
  1910.  
  1911.  
  1912. bool:=Odd(x)
  1913. bool:=Even(x)
  1914.  
  1915.     retourne TRUE ou FALSE si x est impaire (Odd) ou paire (Even)
  1916.  
  1917.  
  1918. num:=Rnd(max)
  1919. seed:=RndQ(seuil)
  1920.  
  1921.     Rnd() donne un nombre au 'hasard' a partir d'un seuil allant de 0 à max-1.
  1922.     Par exemple, Rnd(1000) retourne un entier entre 0 et 999.
  1923.     Pour initialiser le seuil interne, appelez Rnd() avec un nombre négatif.
  1924.     la valeur absolue de cette valeur sera le seuil initial.
  1925.  
  1926.     RndQ() calcul un nombre au 'hasard' plus vite (Quicker) que Rnd(), mais
  1927.     retourne un nombre sur 32 bits. Utilisez le résultats comme seuil pour le
  1928.     prochain appel, et pour seuil de départ, utilisez un grande valeur, comme
  1929.     $A6F87EC1.
  1930.  
  1931.  
  1932. valeur_abs:=Abs(valeur)
  1933.  
  1934.     calcule la valeur absolue.
  1935.  
  1936.  
  1937. a:=Mod(b,c)
  1938.  
  1939.     divise b (32bits) par c(16bits) et retourne le modulo a (16bits)
  1940.  
  1941.  
  1942. x:=Shl(y,n)
  1943. x:=Shr(y,n)
  1944.  
  1945.     déplace y de n bits vers la gauche (Shl) ou vers la droite (Shr)
  1946.  
  1947.  
  1948. a:=Long(adr)
  1949. a:=Int(adr)
  1950. a:=Char(adr)
  1951.  
  1952.     lit (peek) la mémoire à l'adresse <adr>, et retourne la valeur trouvée.
  1953.     Ces fonctions travaille avec respectivement des valeurs de 32, 16 et 8
  1954.     bits. Notez que le compilateur ne vérifie pas si l'<adr> est valide. Ces
  1955.     fonctions sont implementées en E pour les cas où écrire ou lire la mémoire
  1956.     par des pointeur (PTR TO <type>) demanderait une progammation complexe,
  1957.     voire moins bonne.
  1958.     Vous n'êtes pas encouragé à utiliser ces fonctions.
  1959.  
  1960.  
  1961. PutLong(adr,a)
  1962. PutInt(adr,a)
  1963. PutChar(adr,a)
  1964.  
  1965.     écrit (poke) la valeur <a> à l'adresse <adr> en mémoire.
  1966.     Voir : Long()
  1967.  
  1968.  
  1969.  
  1970. 9H. fonctions liants les chaines, les listes
  1971. --------------------------------------------
  1972.  
  1973. Le E propose un ensemble de fonctions qui permettent la création de listes
  1974. liées (linked) avec les types de données STRING et LIST, ou chaines et
  1975. listes qui sont créés avec String() et List(). Comme vous devez le savoir
  1976. maintenant, les chaines et les listes sont des pointeurs sur leurs données
  1977. respectives, et ont des champs suppléméntaires d'offset négatif décrivant
  1978. leur longueur actuelle et leur longueur maximale. Ces offsets dont PRIVÉs.
  1979. Ajouté à ces 2 champs, n'importe quel type de donnée complexe, a un champ
  1980. 'next' (suivant), égal à NIL par défaut, qui peut servir à construire une
  1981. liste de chaines liées (linked), par exemple.
  1982. Dans la suite, j'utiliserai le terme 'complexe' pour signifier un pointeur
  1983. sur une chaine ou une liste, et 'queue' (tail) pour signifier un tel pointeur
  1984. ou un qui a déja d'autres chaines liées à lui. 'queue' peut alors être un
  1985. pointeur NIL, ce qui signifie la fin de la liste.
  1986.  
  1987.  
  1988. complexe:=Link(complexe,queue)
  1989.  
  1990.     mets la valeur <queue> dans le prochain champ de <complexe>. Retourne de
  1991.     nouveau <complexe>.
  1992.     Exemple :
  1993.  
  1994.         DEF s[10]:STRING, t[10]:STRING
  1995.         Link(s,t)
  1996.  
  1997.     crée une liste liée comme : s --> t --> NIL
  1998.  
  1999.  
  2000. queue:=Next(complexe)
  2001.  
  2002.     lit le champ suivant de la variable <complexe>. Cela peut être bien sûr
  2003.     NIL, ou une liste liées entière. Appeler Next(NIL) donnera NIL, il est
  2004.     donc prudent d'appeler Next() si vous n'êtes pas sûr que vous êtes à la
  2005.     fin de la liste liée.
  2006.  
  2007.  
  2008. queue:=Forward(complexe,n)
  2009.  
  2010.     pareil que Next(), seulement avance de n liens, au lieu d'un seul, donc :
  2011.  
  2012.         Next(c) = Forward(c,1)
  2013.  
  2014.     Vous pouvez sans crainte appeler Forward() avec n trop grand, la fonction
  2015.     s'arrètera si elle rencontre NIL pendant la recherche de liens, et
  2016.     retournera NIL.
  2017.  
  2018.  
  2019. DisposeLink(complexe)
  2020.  
  2021.     fait de même que Dispose(), avec 2 différences : la fonction ne marche
  2022.     qu'avec les chaines et listes allouées par String() et List(), et
  2023.     désallouera automatiquementla queue du complexe aussi.
  2024.     Notez que de grandes listes liées contenant des chaines alouées par
  2025.     String(), tout comme celles allouée localement ou globalement avec
  2026.     STRING, doivent être désallouée de cette façon.
  2027.  
  2028. Pour un bon exemple de comment des listes liées de chaines peuvent être
  2029. utilisé, voir le programme 'D.e'
  2030.  
  2031.  
  2032.  
  2033. +---------------------------------------------------------------+
  2034. |               10. FONCTIONS DE BIBLIOTHEQUES ET MODULES       |
  2035. +---------------------------------------------------------------+
  2036.  
  2037. 10A. appels de bibliothèque prédéfinis (built-in)
  2038. -------------------------------------------------
  2039.  
  2040. Comme vous l'avez remarqué dans les sections précédentes, le morceau de code
  2041. lié (linked) automatiquement au début de votre source, appelé 'code
  2042. d'initialisation', ouvre toujours les 4 bibliothèques INtuition, Dos, Graphics,
  2043. Mathffp, et à cause de ça, le compilateur possède tous les appels des 5
  2044. bibliothèques (avec l'exec) (il y en a une petite centaine).
  2045. Ces appels sont valables jusqu'au workbench 2.04. Ceux du système 3.0 devrait
  2046. être inclus dans la prochaine version d'Amiga E.
  2047. Exemple, pour appeler la fonction Open(), de la bibliothèque Dos, écrivez :
  2048.  
  2049.     gestion:=Open('mon_fichier',OLDFILE)
  2050.  
  2051. ou AddDisplayInfo() de la bibliothèques graphics :
  2052.  
  2053.     AddDisplayInfo(mes_info)
  2054.  
  2055. Aussi simple que ça !
  2056.  
  2057.  
  2058. 10B. interfacer le système Amiga avec les modules 2.04
  2059. ------------------------------------------------------
  2060.  
  2061. Pour utiliser d'autres bibliothèques que les 5 décrit dans la section
  2062. précédente, vous avez besoin de modules. Aussi, si vous voulez utiliser des
  2063. objet (OBJECT) ou des constantes (CONST) d'includes utilisé en C ou en
  2064. Assembleur, vous vew besoin de modules.
  2065. Les modules sont des fichiers binaires qui peuvent inclure des définitions de
  2066. constantes, d'objets, de bibliothèques et de fonction. L'avantage que les
  2067. modules soient compilées, par rapport à des fichiers ASCII, est qu'ils n'ont
  2068. pas besoin d'être recompilé encore et encore, chaque fois que votre programme
  2069. est compilé. Le désavantage est qu'ils ne peuvent pas être facilement être
  2070. visualisés ; ils ont besoin d'utilitaires comme ShowModule (voir
  2071. utilitaire.doc) pour les rendre visible.
  2072. Les modules contenant les définitions de bibliothèque (les appels) sont dans
  2073. le répertoire racine de emodules: (le répertoire de module de la distribution)
  2074. Les définitions des constantes/objets sont dans les sous-répertoires,
  2075. structurés comme les modules originaux de Commodore.
  2076.  
  2077. syntaxe:         MODULE <nom_module>,...
  2078.  
  2079. charge un module. Utiliser les modules vous permet d'utiliser des bibiothèques
  2080. et des fonctions alors inconnus du compilateur (et du système).
  2081.  
  2082. Exemple : un raccourcit du programme 'source/examples/asldemo.e' qui utilise
  2083. des modules pour afficher une boites de requête de fichier (filerequester), de
  2084. la bibliothèque Asl.library du système 2.0.
  2085.  
  2086.     MODULE 'Asl', 'libraries/Asl'
  2087.  
  2088.     PROC main()
  2089.       DEF req:PTR TO filerequestr
  2090.       IF aslbase:=OpenLibrary('asl.library',37)
  2091.         IF req:=AllocFileRequest()
  2092.           IF RequestFile(req) THEN WriteF('File: "\s" in "\s"\n',
  2093.                                            req.file,req.dir)
  2094.           FreeFileRequest(req)
  2095.         ENDIF
  2096.         CloseLibrary(aslbase)
  2097.       ENDIF
  2098.     ENDPROC
  2099.  
  2100.  
  2101. Du module 'asl', le compilateur prend les définitions des fonctions de l'asl
  2102. comme RequestFile(), et la variable globale 'aslbase', qui doit seulement être
  2103. initialisée par le programmeur.
  2104. Du module 'libraries/asl', il prend la définition de l'objet de la boite de
  2105. requête de fichier (filerequester), qu'on utilise pour lire le fichier choisit
  2106. par l'utilisateur.
  2107. Alors, ce n'était pas trop dur de programmer une boite de requête en E ?
  2108.  
  2109.  
  2110. +---------------------------------------------------------------+
  2111. |                    11. EXPRESSIONS COTÉES                     |
  2112. +---------------------------------------------------------------+
  2113.  
  2114. 11A. les cotes (quotes) et analyse (scope)
  2115. ------------------------------------------
  2116.  
  2117. Les expressions cotées commence avec une apostrophe inverse `. La valeur
  2118. d'une expressions cotées n'est pas le résultats d'un calcul d'une expression,
  2119. mais l'adresse du code. Le résultat peut être passé à une variable normale, ou
  2120. comme argument de certaines fonctions.
  2121. Exemple:
  2122.  
  2123.     mafonc:=`x*x*x
  2124.  
  2125. mafonc est maintenant un pointeur sur une fonction qui calcule x^3 quand il
  2126. est évaluée. Ces pointeurs de fonctions sont très différent des procédures
  2127. normales et ne doivent jamais être mélangées. Les plus grandes différences
  2128. sont qu'une expression cotée est une simple expression, et donc, ne peut pas
  2129. avoir sa propre. Dans notre exemple, 'x' est juste une variable locale ou
  2130. globale. C'est là que nous devons être prudent :
  2131. Si on évalue mafonc plus tard dans la même procédure, 'x' doit être local,
  2132. mais si mafonc est donné comme paramètre à une autre procédure, et puis
  2133. évauluée, 'x' doit être global. Il n'y a aucune verification du compilateur.
  2134.  
  2135. 11B. Eval(fonc)
  2136. ---------------
  2137.  
  2138. évalue simplement une expressions cotées (exp = Eval(`exp)).
  2139.  
  2140. NOTE : parce que le E est un langage peu typé, écrire accidentellement
  2141. 'Eval(x*x)' au lieu de 'Eval(`x*x) ne sera pas remarqué par le compilateur,
  2142. et vous donnera beaucoup de problême : la valeur de x*x sera utilié comme
  2143. pointeur à coder.
  2144.  
  2145. Pour comprendre pourquoi les 'expressions cotées' sont un atout puissant,
  2146. pensez au cas suivant :
  2147.  - if vous voulez réalisqer un ensemble d'actions suisvant un ensemble de
  2148. variables, vous devez normalement écrire une fonction, et l'appeler avec
  2149. différents arguments. Mais que ce passe-t-il si l'élément que vous voulez
  2150. passer tout un code ? Dans les langages traditionnels, c'est impossible.
  2151. Pas en E.
  2152. Exemple : supposons quez vous voulez écrire qui comptele temps de différentes
  2153. expressions. En E, on écrire :
  2154.  
  2155.     PROC timing(fonc,titre)
  2156.       /* faites plein de chose pour définir le temps */
  2157.       Eval(fonc)
  2158.       /* et le reste */
  2159.       WriteF('temps mesuré pour \s est \d\n',titre,t)
  2160.     ENDPROC
  2161.  
  2162. et appelez le avec :
  2163.  
  2164.     timing(`x*x*x,'multiplication')
  2165.     timing(`sizycalc(),'gros calcul')
  2166.  
  2167.  
  2168. dans d'autres langages, vous devez avoir des copies de 'timing()' pour
  2169. chaque appel, ou vous devez mettre chaque expression dans une fonction
  2170. séparé.
  2171.  
  2172. Un autre exemple simple : pensez à ce que vous pouvez faire avec des
  2173. structures de données (listes) rempli de code non évalué :
  2174.  
  2175.     tracefonc:=[`Plot(x,y,c),`Line(x,y,x+10,y+10,c),`Box(x,y,x+20,y+20,c)]
  2176.  
  2177. Notez que l'idée de fonctions comme des variables/valeurs normales n'est pas
  2178. nouvelles en E. Les expressions cotées viennent literalement du LISP, qui
  2179. possède la fonction encore plus puissante appelé Lambda, qui peut être donnée
  2180. comme arguments à des fonctions ; les expressions cotées de E peuvent aussi
  2181. être vu comme des fonction Lambda sans paramêtre (ou seulement avec des
  2182. paramêtres globals).
  2183.  
  2184.  
  2185. 11C. built-in functions
  2186. ----------------------
  2187.  
  2188. MapList(varadr,liste,listevar,fonc)
  2189.  
  2190.     calcule la fonction sur tous les éléments de <liste>, et retourne tous les
  2191.     résultats dans <listevar>. <func> doit être une expressions cotées (voir
  2192.     plus haut). <varadr> est donné par référence.
  2193.     Exemple :
  2194.  
  2195.         MapList({x},[1,2,3,4,5],r,`x*x)     r est alors :     [1,4,9,16,25]
  2196.  
  2197.  
  2198. ForAll(varadr,list,func)
  2199.  
  2200.     retourne TRUE si tous les éléments de la liste sont évalués par la
  2201.     fonction comme vrais, sinon FAUX. Peut être aussi utilisé pour réaliser
  2202.     une certaine fonction sur tous les éléments d'une liste :
  2203.  
  2204.         ForAll({x},['un','deux','trois'],`WriteF('exemple: \s\n',x))
  2205.  
  2206.  
  2207. Exists(varadr,list,func)
  2208.  
  2209.     Comme pour ForAll(), mais retourne TRUE si la fonction évalue au moins
  2210.     un élément de vrai (<>0).
  2211.     Notez que ForAll() évalue toujours tous les éléments, mais pas forcément
  2212.     Exist().
  2213.  
  2214. Exemple de comment utiliser ces fonctions en pratique :
  2215. on alloue differentes tailles en mémoire en une définition, les vérifie en
  2216. une seule fois, et les libère toutes, mais uniquement celles qui ont été
  2217. alouée. (v37+) :
  2218.  
  2219.     PROC main()
  2220.       LOCAL mem[4]:LIST,x
  2221.       MapList({x},[200,80,10,2500],mem,`AllocVec(x,0)) /* alloue quelques */
  2222.       IF ForAll({x},mem,`x)                            /* suxxes ? */
  2223.         WriteF('Yes!\n')
  2224.       ELSE
  2225.         WriteF('No!\n')
  2226.       ENDIF
  2227.       ForAll({x},mem,`IF x THEN FreeVec(x) ELSE NOP)   /* libère seulement */
  2228.                                                     /* ceux qui sont <>NIL */
  2229.     ENDPROC
  2230.  
  2231.  
  2232. Notez l'abscence d'itération dans ce code. Essayez de reécrire cet exemple
  2233. dans autre langage pour c'est si spécial.
  2234.  
  2235.  
  2236. +---------------------------------------------------------------+
  2237. |                  12. SUPPORT DES NOMBRES FLOTTANTS            |
  2238. +---------------------------------------------------------------+
  2239.  
  2240. 12A. utiliser les flottants et les opérateurs flottants
  2241. -------------------------------------------------------
  2242.  
  2243. Surpasser les opérateurs standard + * etc, avec leurs équivalents flottants
  2244. est possible à partir du système 2.0 de l'Amiga E, maisj'ai enlevé la partie
  2245. principale de la documentation les concernant, car le concept flottant en E
  2246. changera avec les versions supérieures : ces versions vous permettra du code
  2247. inline pour 68881 pour des routines FFP, et de façon transparente.
  2248.  
  2249. Si vous voulez réellement utiliser les flottants avec la version 2.1b, vous
  2250. êtes prié d'utiliser les routines prédéfinies SpXxx() de la bibliothèque
  2251. mathffp.library.
  2252. Exemple:
  2253.  
  2254.     x:=SpMul(y,0.013483)
  2255.  
  2256. Attention quand la prochaine version sortira, votre source devra être modifié
  2257. (en mieux !).
  2258.  
  2259. 12B. expressions flottantes et conversion
  2260. -----------------------------------------
  2261.  
  2262. Comme 12A.
  2263.  
  2264.  
  2265. +---------------------------------------------------------------+
  2266. |                      13. GESTION DES ERREURS                  |
  2267. +---------------------------------------------------------------+
  2268.  
  2269. 13A. définition des gestion d'erreurs (HANDLE/EXCEPT)
  2270. -----------------------------------------------------
  2271.  
  2272. Le mécanisme d'exception est a peu près le même qu'en ADA ; il permet des
  2273. réactions flexibles sur les erreurs de votre programme et les opérations
  2274. de resources complexes.
  2275. NOTE : le terme d'exception' en E n'a que peut de relation avec les
  2276. exceptions venant des processeurs 680x0.
  2277.  
  2278. Une gestion d'erreur se fait par un bout de code qui sera appelé quand une
  2279. erreur survient lors du fonctionnement du programme, comme une fenêtre qui
  2280. ne s'ouvre pas, ou de la mémoire non allouée. Vous, ou le système lui-même,
  2281. dira que quelque chose ne va pas (cela s'appelle 'raising an exception' -
  2282. 'lever une exception'), alors le système cherchera le bon gestionnaire que
  2283. vous aurez programmé. Je dit 'le bon' car le programme peux avoir plusieurs
  2284. gestionnaire, a chaque niveau du programme.
  2285. Une définition de fonction normale doit (comme on le sait) ressembler à ça :
  2286.  
  2287.     PROC bla()
  2288.       /* ... */
  2289.     ENDPROC
  2290.  
  2291. Une fonction avec un gestionnaire d'exception, à ça :
  2292.  
  2293.     PROC bla() HANDLE
  2294.       /* ... */
  2295.     EXCEPT
  2296.       /* ... */
  2297.     ENDPROC
  2298.  
  2299. Le bloc entre PROC et EXCEPT est éxécuter normalement, et si aucune erreur
  2300. n'arrive, le bloc ntre EXCEPT et ENDPROC est sauté. La procédure se termine
  2301. au ENDPROC. Si une exception est levée, soit dans les partie du PROC, ou
  2302. dans n'importe quelle fonction appelée dans ce bloc, le gestionnaire
  2303. d'exception est invoqué.
  2304.  
  2305. 13B. utiliser la fontion Raise()
  2306. --------------------------------
  2307.  
  2308. Il y a beaucoup de moyens de lever une exception, la plus simple est
  2309. d'utiliser la fonction Raise() :
  2310.  
  2311.         Raise(exceptionID)
  2312.  
  2313. <exceptionID> est simplement une constante qui définie le type d'exception,
  2314. et est utilisé par les gestionnaires pour définir ce qui n'allait pas.
  2315. Exemple :
  2316.  
  2317.     ENUM NOMEM,NOFILE  /* et d'autres */
  2318.  
  2319.     PROC bla() HANDLE
  2320.       DEF mem
  2321.       IF (mem:=New(10))=NIL THEN Raise(NOMEM)
  2322.       ma_fonc()
  2323.     EXCEPT
  2324.       SELECT exception
  2325.         CASE NOMEM
  2326.           WriteF('Pas de mémoire!\n')
  2327.         /* ... et d'autres */
  2328.       ENDSELECT
  2329.     ENDPROC
  2330.  
  2331. PROC mafonc()
  2332.   DEF mem
  2333.   IF (mem:=New(10))=NIL THEN Raise(NOMEM)
  2334. ENDPROC
  2335.  
  2336. La variable 'exception' dans le gestionnaire contient toujours la valeur
  2337. de l'argument passé par la fonction Raise().
  2338. Dans les 2 cas du New(), la fonction Raise() appel le gestionnaire de la
  2339. fonction bla(), et retourne à la fonction qui a appelé.
  2340. Si ma_fonc() avait son propre gestionnaire d'exception, c'est celui là qui
  2341. serait appelé par le New() de la fonction ma_fonc(). La recherche d'un
  2342. gestionnaire se fait dès le début de la procédure où il est définit
  2343. jusqu'au EXCEPT, en incluant tous les appels fait a partir de là.
  2344.  
  2345. Cela a 3 conséquences :
  2346. A. les gestionnaires sont organisés de façon récursive. Le gestionnaire
  2347.    actuellement appelé est dépendant de la fonction appelé durant le
  2348.    fonctionnement du programme.
  2349. B. Si une exception est levée au sein d'un gestionnaire, le gestionnaire du
  2350.    niveau inférieur (le précédent) est appelé. Cette caractèristique peut
  2351.    être utilisé pour construire des schémas d'allocation de resources
  2352.    récursives complexes avec une grande facilité, comme on l'a vu rapidement.
  2353. C. Si une exception est levée à un niveau où aucun autre gestionnaire de
  2354.    niveau inférieur existe (ou dans un programme qui n'a pas du tout de
  2355.    gestionnaire du tout), le programme est arrté (c'est à dire qu'un Raise(x)
  2356.    à le même effet qu'un CLeanUp(0)).
  2357.  
  2358.  
  2359. 13C. definition des exceptions pour les fonctions prédéfinies (RAISE/IF)
  2360. ------------------------------------------------------------------------
  2361.  
  2362. Avec les exceptions précédentes, nous nous sommes épargné le gros travail de
  2363. ocnstruction de notre propre fonction d'erreur. Mais il faut toujours faire
  2364. des vérification à chaque appel de New().
  2365.  
  2366. Le système de gestion des exceptions du E permet la défintion d'exceptions
  2367. pour toutes les fonctions du E (comme New(), OPenW, etc.) et pour toutes les
  2368. fonction sur les bibliothèques (OpenLibrary(), AllocMem(), etc.) et même
  2369. celles inclues dans les moidules.
  2370.  
  2371. Syntaxe :   RAISE <exceptionId> IF <fonc> <comp> <valeur> , ...
  2372.  
  2373. La partie après RAISE peut être répétée, et séparé par une virgule ','.
  2374. Exemple:
  2375.  
  2376.     RAISE NOMEM IF New()=NIL,
  2377.           NOLIBRARY IF OpenLibrary()=NIL
  2378.  
  2379. La première ligne dit quelque chose comme : 'chaque fois qu'un appel de New()
  2380. retourne NIL, alors automatiquement, lève l'exception NOMEM'.
  2381. <comp> est l'un de ces symboles = <> > < >= <=
  2382. Apreès cette défnition, vous pouvez écrire votre programme :
  2383.  
  2384.     mem:=New(taile)
  2385.  
  2386. sans avoir à écrire :
  2387.  
  2388.     IF mem=NIL THEN Raise(NOMEM)
  2389.  
  2390. Notez que la seule différence est que <mem> ne recoit alors aucune valeur
  2391. si le gestionnaire est appelé : le code est généré pour tous les appels de
  2392. New(), vérifie directement après la fin de l'éxécution de New() et appelle
  2393. Raise() si névessaire.
  2394.  
  2395. Nous allons implémenter un petit exemple qui serait  difficile à résoudre
  2396. sans gestion d'exceptions : on appel une fonction récursivement, et dans
  2397. chacune on alloue une resource (dans notre cas, de la mémoire), que l'on
  2398. alloue avant, et que l'on libère après l'appel récursif. Que se passe-t-il
  2399. si une erreur survient quelque part loin dans la récursion ; doit-on quitter
  2400. le programme? Oui : dans un langage conventionnel, on ne pourrait pas libérer
  2401. les resources plus bas dans la récursion en sortant du programme, car tous les
  2402. pointeurs sur cette mémoire sont sauvés dans des variables locales impossibles
  2403. à atteindre. En E, on n'a seulement qu'à lever un exception, appelant
  2404. récursivement tous les gestionnaires et libérant toutes les resources.
  2405. Exemple :
  2406.  
  2407.     CONST SIZE=100000
  2408.     ENUM NOMEM  /* ,... */
  2409.  
  2410.     RAISE NOMEM IF AllocMem()=NIL
  2411.  
  2412.     PROC main()
  2413.       alloc()
  2414.     ENDPROC
  2415.  
  2416.     PROC alloc() HANDLE
  2417.       DEF mem
  2418.       mem:=AllocMem(SIZE,0)         /* regarde combien de bloc peuvent */
  2419.                                     /* être alloué */
  2420.       alloc()                       /* fait la récursion */
  2421.       FreeMem(mem,SIZE)             /* on n'ira jamais jusqu'ici */
  2422.     EXCEPT
  2423.       IF mem THEN FreeMem(mem,SIZE)
  2424.       Raise(exception)              /* appelle récursivement tous les */
  2425.                                     /* gestionnaires */
  2426.     ENDPROC
  2427.  
  2428.  
  2429. C'est bien sûr une simulation d'un problême de programmation courant qui est
  2430. beaucoup plus complexe, et la nécessité d'une gestion d'exceptions devient
  2431. évidente. Pour un exemple concret de programme où une gestion d'erreur serait
  2432. serait très difficile sans gestion d'exception, voir l'utilitaire 'D.e'.
  2433.  
  2434. 13D. utilisation des identificateurs d'exceptions (ID)
  2435. ------------------------------------------------------
  2436.  
  2437. En réalité, un identificateur d'exceptions est bien sûr une valeur de 32
  2438. bits, et vous puvez passer pratiquement n'importe quoi à un gestionnaire
  2439. d'exception : par exemple, certain l'utilise pour passer des descriptions
  2440. d'erreur.
  2441.  
  2442.     Raise('Ne peut pas ouvrir la "gadtools.library"!')
  2443.  
  2444. En tout cas, si vous voulez bien utiliser les exceptions, et voulez avoir la
  2445. posiibilité d'utilise de futur module qui lève des exceptions non définies
  2446. par votre programme, suivez les conseils suivants :
  2447.  
  2448. - Utilisez et definissez l'ID 0 comme 'pas d'erreur'
  2449.  
  2450. - Pour des exceptions particulières, utilisez des IDs de 1 à 10000.
  2451.   Définissez les avec ENUM :
  2452. - For exceptions specific to your program, use the ID's 1-10000.
  2453.  
  2454.       ENUM OK,NOMEM,NOFILE,...
  2455.  
  2456.       (OK est égale à 0, et les suivant 1+)
  2457.  
  2458. - Les IDs de 12336 à 2054847098 sont réservés pour des exceptions courantes.
  2459.   (Ces identificateurs consistent en des lettres majuscule/minuscule de
  2460.   longueur 2, 3 ou 4, encadrés par "").
  2461.   Une exception courantes est une exception qui n'a pas besoin d'être définie
  2462.   dans votre programme, et qui peuvent être utiliser par des modules
  2463.   (incorporants aussi des fonctions) pour lever un exception :
  2464.   Par exemple, vous contruisez un ensemble de procédures qui réalisent une
  2465.   certaine tâche, et voulez lever des exceptions. Comme vous voulez utiliser
  2466.   ces fonctions dans plusieurs programmes, vous aurez du mal à coordonner les
  2467.   IDs avec le programme principal, d'autant plus dure si vous utilisez
  2468.   plusieurs ensemble de procédures, qui utilisent différents IDs pour la même
  2469.   erreur !
  2470.   C'est qu'interviennent les exceptions courantes : l'ID commun pour 'plus de
  2471.   mémoire' (out of memory) est "MEM" (avec le guillemets) : chaque
  2472.   implementation n'a qu'a appeler
  2473.  
  2474.       Raise("MEM")
  2475.  
  2476.   de n'importe quelle procedure, et le programmeur qui utilise le module
  2477.   n'a besoin que de gérer un exception qui reconnait "MEM".
  2478.  
  2479.   Les futurs modules qui contiendront des ensembles de fonctions spécifieront
  2480.   quelle exception est levée par telle procédure, et si elle prend le dessus
  2481.   sur un autre ID d' autres procédures. La tâche du programmeur qui à affaire
  2482.   aux exceptions est grandement simplifiée.
  2483.   Exemples:
  2484.  
  2485.   (système)
  2486.  
  2487.       "MEM"         plus de mémoire
  2488.       "FLOW"        (proche du) dépassement de la pile
  2489.       "^C"          arrêt par Control-C
  2490.       "ARGS"        mauvais arguments
  2491.  
  2492.   (exec/libraries)
  2493.  
  2494.       "SIG"         ne peut allouer le signal
  2495.       "PORT"        ne peut créer de messageport
  2496.       "LIB"         bibliothèque non accessible
  2497.       "ASL"         pas d' asl.library
  2498.       "UTIL"        pas d' utility.library
  2499.       "LOC"         pas de locale.library
  2500.       "REQ"         pas de req.library
  2501.       "RT"          pas de reqtools.library
  2502.       "GT"          pas de gadtools.library (pareil pour les autres)
  2503.  
  2504.   (intuition/gadtools/asl)
  2505.  
  2506.       "WIN"         impossible d'ouvrir une fenêtre
  2507.       "SCR"         impossible d'ouvrir un écran
  2508.       "REQ"         ne peut pas ouvrir une boite de requête (requester)
  2509.       "FREQ"        ne peut pas ouvrir une boite de requete de fichier
  2510.                                                             (filerequester)
  2511.       "GAD"         ne peut pas créer de gadget
  2512.       "MENU"        ne peut pas créer de menu(s)
  2513.  
  2514.   (dos)
  2515.  
  2516.       "OPEN"        ne peut pas ouvrir le fichier / le fichier n'éxiste pas
  2517.       "OUT"         problême de lecture
  2518.       "IN"          problême d'écriture
  2519.       "EOF"         fin de fichier (end of file) mal placé
  2520.       "FORM"        mauvais format d'entrée (input format)
  2521.  
  2522.   La tendance générale est aux majuscules pour les exceptions système général
  2523.   et minuscule (et melange) pour les modules spécifiques.
  2524.  
  2525. Tous les autres IDs (avec les IDs négatifs) sont réservés.
  2526.  
  2527.  
  2528. +---------------------------------------------------------------+
  2529. |                      14. PROGRAMMATION ORIENTEE OBJECT (OO)   |
  2530. +---------------------------------------------------------------+
  2531.  
  2532. Comme elle n'a pas encore été iplémentée, elle n'est pas n'ont plus
  2533. documentée.
  2534.  
  2535.  
  2536. +---------------------------------------------------------------+
  2537. |                      15. ASSEMBLEUR INLINE                    |
  2538. +---------------------------------------------------------------+
  2539.  
  2540. 15A. utilisation des identificateurs
  2541. ------------------------------------
  2542.  
  2543. Comme vous l'aurez préssenti dans l'exemple du chapitre 5D, les instructions
  2544. assembleurs peuvent librement mélangé avec le code E. Le grand secret est
  2545. qu'un assembleur complet est construit dans le compilateur.
  2546. En plus des modes d'adressage assembleur normaux, vous pouvez utiliser les
  2547. identificateurs suivant :
  2548.  
  2549.     mylabel:
  2550.     LEA mylabel(PC),A1              /* labels */
  2551.  
  2552.     DEF a                           /* variables */
  2553.     MOVE.L (A0)+,a                  /* notez que <var> est un <offset>(A4) */
  2554.                                     /* (or A5) */
  2555.  
  2556.     MOVE.L dosbase,A6               /* identificateur d'appel */
  2557.                                     /* d'un bibliothèque */
  2558.     JSR    Output(A6)
  2559.  
  2560.     MOVEQ  #TRUE,D0                 /* constantes */
  2561.  
  2562.  
  2563. 15B. l'assembleur en ligne comparé à un macro assembleur
  2564. --------------------------------------------------------
  2565.  
  2566. L'assembleur en ligne diffère un peu d'un macro assembleur moyen, et ce à
  2567. cause du fait que c'est une extension du E, et qu'il obéit à la syntaxe du E.
  2568. Les grosses différences sont :
  2569.  
  2570. - les commentaires sont fait avec /* et */ et non par ';', ils ont une
  2571.   significations différentes.
  2572. - les mots-clé et regirstres sont en majuscules, tout est sensible (case
  2573.   sensitive).
  2574. - pas de macros ou autres (IL y a le langage E fait pour ça !)
  2575. - vous devez faire attention que les registres A4/A5 ne sont pas détruit par
  2576.   un code assembleur en ligne, car utilisé par le E.
  2577. - pas _encore_ de support pour le modèle LARGE/reloc-hunks en assembleur.
  2578.   Cela siginifie en pratique que vous devz utiliser un adressage relativ pour
  2579.   l'instant.
  2580.  
  2581.  
  2582. 15C. comment utiliser des données binaires (INCBIN/CHAR..)
  2583. ----------------------------------------------------------
  2584.  
  2585. INCBIN
  2586.  
  2587.     syntaxe:         INCBIN <nom_fichier>
  2588.  
  2589.     inclue un fichier binaire a ce point précis, doit être séparé du code.
  2590.     Exemple:
  2591.  
  2592.         montab: INCBIN 'df1:data/blabla.bin'
  2593.  
  2594.  
  2595. LONG, INT, CHAR
  2596.  
  2597.     syntaxe:         LONG <valeurs>,...
  2598.                      INT <valeurs>,...
  2599.                      CHAR <valeurs>,...
  2600.  
  2601.     vous permet de placer des données binaires dans votre programme comme
  2602.     DC.x en assembleur. Notez que la déclaration CHAR prend aussi les chaines,
  2603.     et sera toujours mis à un mot pair.
  2604.     Exemple :
  2605.  
  2606.     mes_données: LONG 1,2; CHAR 3,4,'Salut !',0,1
  2607.  
  2608.  
  2609.  
  2610. 15D. OPT ASM
  2611. ------------
  2612.  
  2613. On peut trouver quelques autres détails sur OPT ASM dans le chapitre 16A.
  2614. Cette option vous permet de mettre 'EC' en mode assembleur. Il n'y a aucune
  2615. bonne raison d'utiliser EC plutôt que quelques macro-assembleurs à part le
  2616. fait qu'il est significativement plus rapide que par exemple A68k, égale
  2617. DevPac et est derrière ASmOne (snif... 8-{). Vous passerez aussi beaucoup de
  2618. temps en essayant de réduire le nombre de disquettes des bons vieux sources
  2619. du Seka via EC, à cause des différences décrite dans la chapitre 15B. Si vous
  2620. voulez écrire un programme en assembleur avec EC, et voulez rendre le source
  2621. compatible avec d'autres assembleurs, simplement faites précéder chaque
  2622. élément spécifique du E d'un ';', EC les utilisera mais les autres assembleurs
  2623. les verrons comme commentaires.
  2624. Exemple :
  2625.  
  2626.     ; OPT ASM
  2627.  
  2628.     start:  MOVEQ   #1,D0           ; /* faite n'importe quoi */
  2629.             RTS                     ; /* et sort */
  2630.  
  2631. Ceci sera assemblé par n'importe quel assembleur, même EC
  2632.  
  2633.  
  2634. +---------------------------------------------------------------+
  2635. |                    16. REVUE D'IMPLEMENTATION                 |
  2636. +---------------------------------------------------------------+
  2637.  
  2638. 16A. le mot-clé OPT
  2639. -------------------
  2640.  
  2641. OPT, LARGE, STACK, ASM, NOWARN, DIR, OSVERSION
  2642.  
  2643.     syntaxe:         OPT <options>,...
  2644.     vous permet de changer les options par défaut du compilateur :
  2645.  
  2646.     LARGE           met le modèle de données et du code sur grand (LARGE).
  2647.                     Petit par défaut. Le compilateur génère un code 100%
  2648.                     relatif de style pc, avec un taile maximum de 32k. Avec
  2649.                     LARGE, il n'y a pas de limites, et reloc-hunks est généré.
  2650.                     Voir -l
  2651.     STACK=x         fixe la taille de la pile à x octets. A utiliser
  2652.                     uniquement si vous savez ce que vous faites. Normalement
  2653.                     le compilateur fait une bonne approximation de l'espace
  2654.                     nécessaire.
  2655.     ASM             met le compilateur en mode assembleur. A partir de là,
  2656.                     uniquement des instructions assembleur sont acceptés, et
  2657.                     aucun code d'initialisation n'est généré. Voir le chapitre
  2658.                     assembleur en ligne.
  2659.     NOWARN          Ne fait pas afficher les avertissements. Le compilateur
  2660.                     vous préviendra si il *pense* que votre programme est
  2661.                     incorrect, mais a une bonne syntaxe. Voir -n
  2662.     DIR=moduledir   fixe le répertoire dans lequel le compilateur cherchera
  2663.                     les modules. 'Emodules:' par défault
  2664.     OSVERSION=ver   =33 par défaut (v1.2). Fixe la version minimum du
  2665.                     kickstart (comme 37 pour v2.04)sur lequel votre programme
  2666.                     doit tourner. Comme ca, votre programme ne s'arrêtera lors
  2667.                     de l'ouverture de la dos.library si vous avez une ancienne
  2668.                     machine. En tout cas, vérifiez vous-même la version et
  2669.                     donner un message d'erreur approprié sera une aide à
  2670.                     l'utilisateur.
  2671.  
  2672.     Exemple:
  2673.  
  2674.     OPT STACK=20000,NOWARN,DIR='df1:modules',OSVERSION=39
  2675.  
  2676.  
  2677. 16B. petit et grand modèle
  2678. --------------------------
  2679.  
  2680. L'Amiga E vous laisse le choix entre un petit (SMALL) et un grand (LARGE)
  2681. modèle. Notez que la plupart des programmes que vous écrirez (spécialement si
  2682. vous débiutez en E) rentrera dans les 32 Ko une fois compilés : vous n'aurez
  2683. pas à vous soucier du modèle du code. Vous saurez qu'il faudra utiliser le
  2684. grand modèle dès que EC commencera à dire qu'il ne peut plus réduire le code
  2685. à 32k. Pour compiler un source avec un grand modèle :
  2686.  
  2687.     1> ec -l grand.e
  2688.  
  2689. ou mieux encore, mettez
  2690.  
  2691.     OPT LARGE
  2692.  
  2693. dans votre code.
  2694.  
  2695.  
  2696. 16C. organisation de la pile
  2697. ----------------------------
  2698.  
  2699. Pour garder les variables locales et globales, le système d'un éxécutable
  2700. généré par Amiga E alloue un bloc de mémoire, duquel il prendra un bout pour
  2701. les variables globales. Le reste sera utilisé dynamiquement par les appels
  2702. des fonctions.
  2703.  
  2704. Quand une fonction est appelé en E, un espace dans la pile est reservée
  2705. pour les données locales, qui sera libéré à la sortie de la fonction.
  2706. C'est pourquoi avoir un grand tableau comme données locales peut être
  2707. dangereux si utilisé récursivement : toutes les données de lappel précédent
  2708. de la même fonction reste dans la pile, et consomme une grande partie de la
  2709. pile encore libre. Toutefois si les procédures sont correctement appelées,
  2710. il n'y a aucune raison d'avoir un débordement.
  2711. Exemple:
  2712.  
  2713.     donnée globale       :     10k (par ex. un tableau)
  2714.     donnée locale PROC #1:      1k
  2715.     donnée locale PORC #1:      3k
  2716.  
  2717. Le système reserve toujours 10k d'espace supplementaire pour les récursions
  2718. normales (par exemple avec un petit tableau local) et des espaces pour des
  2719. tampons (buffers) et le système, qui prendront en tout 24 k de pile en plus.
  2720.  
  2721.  
  2722. 16D. limites du code
  2723. --------------------
  2724.  
  2725. Notez ces signes : (+-)   = dépend du contexte
  2726.                    (n.l.) = pas de limite, mais semble raisonnable.
  2727.  
  2728. --------------------------------------------------------------------------
  2729. OBJECT/ITEM (objet/membre)                      SIZE/AMOUNT/MAX (taille)
  2730. --------------------------------------------------------------------------
  2731.  
  2732. type de donnée CHAR                             0 .. 255
  2733. type de donnée INT                              -32 k .. +32 k
  2734. type de donnée LONG/PTR                         -2 gig .. +2 giga
  2735.  
  2736. longueur d'identificateur                       100 octets (n.l.)
  2737. longueur d'un ligne de commandes                2000 tokens léxicaux(+-)
  2738. longueur d'un source                            2 giga (théoriquement)
  2739. listes de constantes                            quelques 100aines (+-)
  2740. chaines constantes                              1000 chars (n.l.)
  2741. nombre max. de boucle imbriqué (IF, FOR etc.)   500
  2742. nombre max. de commentaire imbriqué             infini
  2743.  
  2744. # de variables locales par procédure            8000
  2745. # de variables globales                         7500
  2746. # d'arguments pour vos propres fonctions        8000 (ensemble avec locales)
  2747. # d'arguments de fonction E (WriteF())          64
  2748.  
  2749. un objet (alloué en  local/global ou dyn.)      8 k
  2750. un tableau, liste ou chaine (local or global)   32 k
  2751. une chaine (dynamique)                          32 k
  2752. une liste (dynamique)                           128 k
  2753. un tableau (dynamique)                          2 giga
  2754.  
  2755. données locales par procédure                   250 méga
  2756. données globales                                250 méga
  2757.  
  2758. taille du code d'une procédure                  32 k
  2759. taille du code d'un éxécutable                  32 k en petit (SMALL) modèle,
  2760.                                                 2 giga en grand (LARGE) modèle
  2761. limite courante (étendu dans la futur)          2-5 méga
  2762.  
  2763. taille des tampons du code généré
  2764.  et des identificateurs                         suivant le source
  2765. taille des tampons des labels/branches et
  2766.  intermédiaire                                  (re) alloué indépendamment
  2767.  
  2768.  
  2769.  
  2770.  
  2771. 16E. les messages d'erreurs, d'avertissements et de non référence
  2772. -----------------------------------------------------------------
  2773.  
  2774. Quelques fois, à la compilation de votre source avec EC, vous aurez un
  2775. message du style : UNREFFRENCED: <ident>, <ident>, ...
  2776. C'est le cas si vous déclarez des variables, fonctions ou labels dont vous
  2777. ne vous servez pas. C'est en service qui vous est rendu par le compilateur
  2778. pour vous aidez à trouver ces erreurs difficiles à trouver.
  2779.  
  2780. Il y a plusieurs avertissements que le compilateur envoie pour vous dire que
  2781. quelquechose devrait mal se passer, mais n'est pas vraiment une erreur.
  2782.  
  2783.  
  2784. - 'A4/A5 used in inline assembly'   'A4/A5 utilisé dans les lignes assembleur'
  2785.  
  2786.   Cet avertissment  apparait lorsque vous utilisez les registres A4 ou A5 dans
  2787.   votre code. La raison de cela est que ces registres sont utilisé de façon
  2788.   interne par le E pour adreser les variables globales et locales.
  2789.   Bien sûr il y a de bonne raison de les utiliser, comme pour faire un
  2790.   MOVEM.L A4/A5,-(A7) avant un grand morceau de code assembleur.
  2791.  
  2792.  
  2793. - 'keep an eye on your stacksize'       'jetez un oeil à la taile de votre pile'
  2794. - 'stack is definitely too small'       'la pile est vraiment trop petite'
  2795.  
  2796.   Ces deux apparaitrons si vcous utilisez OPT STACK=<size>. Le compilateur
  2797.   comparera votre taille à sa propre estimation (voir le chapitre 16C), et
  2798.   retournera la première des erreurs si il pense que c'est bien mais un peu
  2799.   juste, et la seconde si c'est bien trop petit.
  2800.  
  2801.  
  2802. - 'suspicious use of "=" in void expressions'
  2803.                         'mauvaise utilisation de "=" dans une expression vide'
  2804.  
  2805.   Cet avertissment sera retourné si vous écrivez des expressions comme 'a=1'
  2806.   comme déclaration. Un raison de cela est le fait qu'un comparaison n'a pas
  2807.   de sens comme déclaration, mais la principale raison est que cela provient
  2808.   souvent d'une faute de frappe en voulant écrire 'a:=1'. Oublier ces ':'
  2809.   serait difficile à trouver, et aurait des conséquences désastreuses.
  2810.  
  2811.  
  2812. Erreurs.
  2813.  
  2814. - 'syntax error'    'Erreur de syntaxe'
  2815.  
  2816.     Erreur le plus souvent rencontrée. Cette erreur survient soit
  2817.     lorsqu'aucune other erreur est appriopriée, soit l'agencment de votre
  2818.     code est anormal.
  2819.  
  2820.  
  2821. - 'unknown keyword/const'   'mot-clé ou constantes inconnus'
  2822.  
  2823.     Vous avez utilisé un identificateur en majuscule (comme 'IF' ou 'TRUE'),
  2824.     et le compilateur ne trouve aucune définition. Causes :
  2825.     - mot-clé mal écrit,
  2826.     - vous utilisez une constante, mais vous avez oublié de la définir dans
  2827.       la déclaration d'un CONST,
  2828.     - vous avez oublié to spécifier le module dans lequel la constante est
  2829.       définie.
  2830.  
  2831.  
  2832. - '":=" expected'   '":=" nécessaire'
  2833.  
  2834.     Vous avez écrit un FOR ou un assignement, et écrit quelque chose d'autre
  2835.     que ':='.
  2836.  
  2837.  
  2838. - 'unexpected characters in line'   'caractères non corrects dans la ligne'
  2839.  
  2840.     Vous utilisez des caratères en dehors d'une chaine, et qui n'ont aucun
  2841.     sens pour le E
  2842.     Exemple : @, !, &, \, ~
  2843.  
  2844.  
  2845. - 'label expected'  'label nécessaire'
  2846.  
  2847.     A certains endroit, par exemple aprés un PROC ou un JUMP, un label est
  2848.     nécessaire, et vous avez écrit autre chose.
  2849.  
  2850.  
  2851. - '"," expected'    '"," nécessaire'
  2852.  
  2853.     En spécifiant une list d'éléments (par exemple une liste de paramètres)
  2854.     vous avez écrit quelque chose d'autre à la place de la virgule.
  2855.  
  2856.  
  2857. - 'variable expected'   'variable nécessaire'
  2858.  
  2859.     Cette constructio demande un variable.
  2860.     Exemple :
  2861.         FOR <var>:= ... etc.
  2862.  
  2863.  
  2864. - 'value does not fit in 32 bit'    'valeur ne rentre pas dans les 32 bits'
  2865.  
  2866.     En spécifiant une constante (voir les chapitres 2A-2E), vous avez écrit
  2867.     un nombre trop grand (par exemple : $FFFFFFFFF, "abcdef").
  2868.     Cette erreur apparait aussi lorsque vous définissez plus de 32 éléments
  2869.     dans la déclaration d'un SET.
  2870.  
  2871.  
  2872. - 'missing apostrophe/quote'    'apostrophe/cote manquante'
  2873.  
  2874.     Vous avez oublié une ' à la fin de la chaine.
  2875.  
  2876.  
  2877. - 'incoherent program structure'    'structure incohérente du programme'
  2878.  
  2879.     - vous avez commencer une nouvelle procédure (PROC) avant de terminer
  2880.       la précédente.
  2881.     - vous n'avez pas correctement inclue les boucles les unes dans les
  2882.       autres.
  2883.       Exemple :
  2884.         FOR
  2885.           IF
  2886.           ENDFOR  /* inversion du ENDFOR et du ENDIF */
  2887.         ENDIF
  2888.  
  2889.  
  2890. - 'illegal command-line option'     'mauvaise option dans la ligne de commande'
  2891.  
  2892.     En spécifiant 'EC -opt source' vous avez écrit les options avec quelque
  2893.     chose que EC ne connait pas.
  2894.  
  2895.  
  2896. - 'division and multiplication 16bit only'
  2897.                             'division et multiplication seulement sur 16 bits'
  2898.  
  2899.     Le compilateur a détecté que vous utilisez des valeurs sur 32 bits pour
  2900.     * ou /. Cela ne donnera pas la valeur désiré lorsquele programme sera
  2901.     lancé. Voir Mul() et Div().
  2902.  
  2903.  
  2904. - 'superfluous items in expression/statement'
  2905.                                 'trop de membres dans l'expression/déclaration'
  2906.  
  2907.     Après la compilation, le compilateur trouve touours des 'tokens' au lieu
  2908.     d'une fin de fichier (end of line). Vous avez probablement oublié une
  2909.     saut de ligne <lf> ou un ';' pour séparer 2 déclarations.
  2910.  
  2911.  
  2912. - 'procedure "main" not available'      'pas de procédure Main()'
  2913.  
  2914.     Votre programme n'a pas de proceédure Main() !
  2915.  
  2916.  
  2917. - 'double declaration of label'     'double déclaration d'un label'
  2918.  
  2919.     Vous avez déclaré 2 fois un label.
  2920.     Exemple :
  2921.         label:
  2922.         PROC label()
  2923.  
  2924.  
  2925. - 'unsafe use of "*" or "/"'    'utilisation peu prudente de "*" ou "/"'
  2926.  
  2927.     Ceci encore concerne les 16 bits au lieu des opérateur 32 bits * ey /.
  2928.     Voir 'division and multiplication 16bit only'.
  2929.  
  2930.  
  2931. - "reading sourcefile didn't succeed"
  2932.                                 'la lecture du fichier source n'a pas réussi'
  2933.  
  2934.     Vérifiez votre source, en particulier si en donnant 'ec monsource',
  2935.     assurez vous que le nom du fichier se termine par '.e' (ce qui n'est pas
  2936.     le cas dansla ligne de commande)
  2937.  
  2938.  
  2939. - "writing executable didn't succeed"
  2940.                                     'l'écriture de l'éxécutable n'a pas réussi'
  2941.  
  2942.     En écrivant le code généré, comme éxécutable, le DOS retourne une erreur.
  2943.     Par exemple, l'éxécutable déja existant ne peut être effacé et rééecrit.
  2944.  
  2945.  
  2946. - 'no args'     'pas d'arguments'
  2947.   "USAGE: ec [-opts] <sourcecodefilename> (`.e' is added)"
  2948.                   "USAGE: ec [-opts] <nom_du_fichier_soure> (`.e' est rajouté)"
  2949.  
  2950.     Vous aurez ceci en tapant uniquement 'ec', sans arguments.
  2951.  
  2952.  
  2953. - 'unknown/illegal addressing mode'     'mode d'adressage inconnu/illégal'
  2954.  
  2955.     Cette erreur est retourné uniquement par les lignes assembleur. Les causes
  2956.     possibles sont :
  2957.     - vous avez utilisé un mode d'adressage qui n'éxiste pas sur le 68000,
  2958.     - le mode d'adressage éxiste, mais pas pour cette instruction.
  2959.       Toutes les instructions assembleur ne supporte pas tutes les
  2960.       combinaisons d'adresses effective comme source et destination.
  2961.  
  2962.  
  2963. - 'unmatched parentheses'   'mauvais nombre de parenthèses'
  2964.  
  2965.     Votre déclaration comporte plus de '(' que de ')' ou l'inverse.
  2966.  
  2967.  
  2968. - 'double declaration'      'double déclaration'
  2969.  
  2970.     Un identificateur est utilisé dans 2 ou plus déclarations.
  2971.  
  2972.  
  2973. - 'unknown identifier'      'identificateur inconnu'
  2974.  
  2975.     Un identificateur n'est utilisé dans aucune déclaration; il est inconnu.
  2976.     Vous avez certzinement oublié de le mettre dans la déclaration DEF.
  2977.  
  2978.  
  2979. - 'incorrect #of args or use of ()'    'nombre incorrect d'arguments ou de ()'
  2980.  
  2981.     - vous avez oublié de mettre une '(' ou une ')' au bon endroit,
  2982.     - vous donner un nombre incorrect d'argument à un fonction.
  2983.  
  2984.  
  2985. - 'unknown e/library function'      'fonction inconnue du E/bibliothèque'
  2986.  
  2987.     Vous avez écrit un identificateur avec le premier caractère en majuscule,
  2988.     et le second en minuscule, mais le compilateur ne trouve aucune
  2989.     définition. Causes possibles :
  2990.     - le nom de la fonction est mal écrit,
  2991.     - vous avez oublié d'inclure le module qui défini l'appel de la
  2992.       bibliothèque.
  2993.  
  2994.  
  2995. - 'illegal function call'       'appel de fonction illégal'
  2996.  
  2997.     N'arrive que rarement. Vous l'aurez si vous essayez de construire
  2998.     des appels de fonction complexe, comme :
  2999.         WriteF(WriteF('hi!'))
  3000.  
  3001.  
  3002. - 'unknown format code following "\"'   'format du code suivant "\" inconnu'
  3003.  
  3004.     Vous spécifiez un code de format dans une chaine, qui est illégal.
  3005.     Voir le chapitre 2F pour une liste des codes de format.
  3006.  
  3007.  
  3008. - '/* not properly nested comment structure */'
  3009.                                         '/* commentaires mal imbriqués */'
  3010.  
  3011.     Le nombre de '/*' n'est pas égal au nombre de '*/', ou placé dans un
  3012.     ordre bizarre.
  3013.  
  3014.  
  3015. - 'could not load binary'       'ne peut pas ouvrir la bibliothèque'
  3016.  
  3017.     le fichier spécifié dans le ligne INCBIN <fichier> ne peut pas être lu.
  3018.  
  3019.  
  3020. - '"}" expected'        '"}" nécessaire'
  3021.  
  3022.     Vous avez commencé une expression comme '{<var>', et vous avez oublié
  3023.     le "}".
  3024.  
  3025.  
  3026. - 'immediate value expected'        'valeur immédiate nécessaire'
  3027.  
  3028.     Certaines constructions demandent une valeur immédiate à la place d'une
  3029.     expression.
  3030.     Exemple :
  3031.         DEF s[x*y]:STRING   /* mauvais :uniquement quelque chose comme */
  3032.                             /* s[100]:STRING est bon */
  3033.  
  3034.  
  3035. - 'incorrect size of value'     'taille de la valeur incorrecte'
  3036.  
  3037.     Vous spécifiez une valeur trop grande (ou trop petite).
  3038.     Exemples:
  3039.         DEF s[-1]:STRING, t[1000000]:STRING   /* doit être entre 0..32000  */
  3040.         MOVEQ #1000,D2                        /* doit être entre -128..127 */
  3041.  
  3042.  
  3043. - 'no e code allowed in assembly modus'
  3044.                                     'pas de code E accepté en mode assembleur'
  3045.  
  3046.     Vous voulez compiler en mode assembleur, en écrivant 'OPT ASM', et par
  3047.     accident, vous avez mis du code E.
  3048.  
  3049.  
  3050. - 'illegal/inappropriate type'      'type inapproprié/illégal'
  3051.  
  3052.     A certain endroit ou un <type> est demandé, vous avez écrit quelque chose
  3053.     d'inaproprié.
  3054.     Exemple :
  3055.         DEF a:PTR TO ARRAY       /* aucun type de ce type :) */
  3056.         [1,2,3]:STRING
  3057.  
  3058.  
  3059. - '"]" expected'        '"]" nécessaire'
  3060.  
  3061.     Vous avez commencé avec un "[", mais vous avez oublié de terminer
  3062.     avec un "]".
  3063.  
  3064.  
  3065. - 'statement out of local/global scope'
  3066.                    'déclaration en dehors des déclarations locales ou globales'
  3067.  
  3068.     Un point de déclaration est la première déclaration PROC. Avant ça,
  3069.     uniquement des définitions globales (DEF, CONST, MODULE, etc) sont
  3070.     permises, et aucun code. Dans la secondes parties, seulement les
  3071.     définitions de code et de fonctions sont légales, aucune définition
  3072.     globale n'est possible.
  3073.  
  3074.  
  3075. - 'could not read module correctly'     'ne peut lire le module correctement'
  3076.  
  3077.     Une erreur du DOS est survenue en voulant lire un module à partir de la
  3078.     déclaration MODULE. Causes :
  3079.     - 'Emodules:' est mal assigné,
  3080.     - le nom du module est mal écrit, ou n'éxiste pas,
  3081.     - vous avez écrit MODULE 'bla.m' au lieu de 'bla' (sans suffixe).
  3082.  
  3083.  
  3084. - 'workspace full!'     'espace de travial plein !'
  3085.  
  3086.     N'arrive que rarement. Si cela survient, you devez mettre l'option '-m'
  3087.     pour forcer manuellement EC à faire une estimation plus large sur la
  3088.     quantité de mémoire nécessaire.
  3089.     Essayez de compiler avec -m2, puis -m3 jusqu'à ce que l'erreur
  3090.     disparaisse. Vous aurez certainement écrit une gigantesque application
  3091.     avec une grande quantité de données pour arriver à cette erreur.
  3092.  
  3093.  
  3094. - 'not enough memory while (re-)allocating'
  3095.                               'pas assez de mémoire pendant la (ré)allocation'
  3096.  
  3097.     Tout simplement. Solutions possibles :
  3098.     1. vous avez plusieurs programmes marchant en multitache. Quittez en
  3099.        quelques uns et reéssayez.
  3100.     2. il vous reste peux de mémoire, ou votre mémoire est fragmentée.
  3101.     3. aucun des 2 possibilités. Achetez de la mémoire (Hum..)
  3102.  
  3103.  
  3104. - 'incorrect object definition'     'définition d'objet incorrect'
  3105.  
  3106.     Vous avez écrit quelque chose en OBJECT et ENDOBJECT qui n'est pas
  3107.     correct. Voir le chapitre 8F pour savoir comment bien écrire.
  3108.  
  3109.  
  3110. - 'illegal use of/reference to object'
  3111.                                 'mauvaise utilisation ou référence à un objet'
  3112.  
  3113.     Si vous utilisez une expressions comme ptr.membre, membre doit être un
  3114.     membre définit dans l'object ptr.
  3115.  
  3116.  
  3117. - 'incomplete if-then-else expression'     'expression if-then-else incomplète'
  3118.  
  3119.     Si vous utilisez IF comme opérateur (chapitre 4E), alors un ELSE doit
  3120.     être présent : une expression avec un IF à l'interieur a toujours besoin
  3121.     de retourner une valeur, alors qu'une déclaration avec un IF peut ne rien
  3122.     faire si aucun ELSE n'est présent.
  3123.  
  3124.  
  3125. - 'unknown object identifier'       'identificateur d'objet inconnu'
  3126.  
  3127.     Vous utilisez un identificateur qui est reconnu par le compilateur comme
  3128.     une partie d'un objet, et vous avez oublié de le déclarer. Causes :
  3129.     - nom mal écrit,
  3130.     - module manquant,
  3131.     - l'identificateur dans le module est écrit différemment de ce que vous
  3132.       pensiez (des RKRM par exemple) Vérifiez avec ShowModule.
  3133.       NOtez que le système d'objet Amiga hérite des identificateurs de
  3134.       l'assembleur, pas du C. Les idientificateurs obéissent à la syntaxe
  3135.       du E.
  3136.  
  3137.  
  3138. - 'double declaration of object identifier'
  3139.                                 'double déclaration d'idenficateur d'objet'
  3140.  
  3141.     Un identificateur est utiisé dans le définition de 2 objets.
  3142.  
  3143.  
  3144. - 'reference(s) out of 32k range: switch to LARGE model'
  3145.                 'référence(s) en dehors des 32ko : utilisez le grand modèle'
  3146.  
  3147.     Votre programme est plus grand que 32ko. Mettez simplement 'OPT LARGE'
  3148.     dans votre code source. Voir le chapitre 16B.
  3149.  
  3150.  
  3151. - 'reference(s) out of 256 byte range' 'référence(s) en dehors des 256 octets'
  3152.  
  3153.     Vous avez probablement écrit BRA.S ou Bcc.S sur un trop grand espace.
  3154.  
  3155.  
  3156. - 'too sizy expression'     'expression trop grande'
  3157.  
  3158.     Vous utilisez une liste, qui est peut-être récursivment, qui est trop
  3159.     grande.
  3160.  
  3161.  
  3162. - 'incomplete exception handler definition'
  3163.                         'définition incomplète du gestionnaire d'exception'
  3164.  
  3165.     Vous avez certainement utilisé EXCEPT sans HANDLE, ou quelque chose dans
  3166.     ce genre. Voir le chapitre 13 sur les gestions d'exception.
  3167.  
  3168.  
  3169.  
  3170. 16F. organisation et allocation des tampons (buffer) du compilateur
  3171. -------------------------------------------------------------------
  3172.  
  3173. Quand vous revevez une erreur 'workspace full' (espace de travail plein)
  3174. (peu probable), ou si vous voulez savoir ce qui se passe quand votre
  3175. programme est compilé, il est utile de savoir comment EC organise ses
  3176. tampons.
  3177.  
  3178. Un compilateur, et c'est le cas d'EC, a besoin de tampons (buffers) pour le
  3179. suivi de beaucoup de choses, comme les identificateurs, etc., et pour y
  3180. mettre le code généré. EC ne sait pas de quelle taille doivent être les
  3181. tampons. Pour certains, ceux par exemple pour garder les constantes, il n'y
  3182. a pas de problêmes : si le tampons est plein lors de la compilation, EC alloue
  3183. un nouveau tampon et continue. D'autres tampons, comme celui réservé au code
  3184. généré, doit être continue en mémoire et ne peut être déplacé pendant la
  3185. compilation : EC doit donc faire une bonne estimation de la taille des tampons
  3186. pour être capable de compiler des sources de toutes tailles.
  3187. Pour faire cela, EC calcule la mémoire nécessaire suivant le cas du source
  3188. donné. Dans 99% des cas, EC aura alloué suffisament de mémoire pour compiler
  3189. quasiment tous les sources. Dans les autres cas, vous aurez un erreur à la
  3190. compilation et vous aurez a spécifier plus de mémoire grace à l'option '-m'.
  3191.  
  3192. Essayez les différents sources (de taille et de type différent) en les
  3193. combinant avec l'option '-b', pour voir comment ca marche en réalité.
  3194.  
  3195.  
  3196. 16G. un petit historique
  3197. ------------------------
  3198.  
  3199. Le E n'est pas seulement 'un autre langage' : il a été construit avec
  3200. attention et pas à pas par l'auteur du compilateur, parce qu'il n'était pas
  3201. content des langages éxistants et particiulièrement de l'horrible code généré
  3202. et la lenteur des compilateurs écrit pour eux.
  3203. L'Amiga E a pour but premier d'être utilisé comme langage par l'auteur pour
  3204. programmer ces programmes Amiga, et il y a réussi. Le E a été développé
  3205. intensivement sur un an et demi et n'a certainement pas été le premier
  3206. compilateur écrit par l'auteur : certain doivent se rappeler le compilateur
  3207. DEX.
  3208.  
  3209. Celui-ci tait lent et peu puissant et ne peut être que difficilement comparé
  3210. à un compilateur comme l'Amiga E, mais certainement a donné à l'auteur une
  3211. expérience qui l'a rendu capable de faire ce que l'Amiga E est aujourd'hui.
  3212.  
  3213. Les programmeurs en DEX noterons qu'il est très facile de convertir leurs
  3214. anciens sources DEX en E, et continuer le développement avec une puissance
  3215. multiplié par 10, et une vitesse par 20. Pour la petite histoire : DEX et le
  3216. E se sont dépassés, qudn DEX était terminé, le E était à la moitié de v1.6.
  3217. Parceque le E était déja plus performant à l'époque, les exemples de
  3218. bibliothèques E et les codes on été transférés en DEX à la demande générale.
  3219. Ainsi le prédécesseur a hérité des caractéristiques de son succésseur.
  3220. L'auteur écrit aussi de nombreux autres compilateurs et d'interpréteurs,
  3221. certains d'entre eux n'ont jamais été distribués.
  3222.  
  3223. L'Amiga E est un produit qui sera développé en direction du meilleur langage
  3224. pour le système de développement Amiga :
  3225. - par implementation des parties manquantes dans la définition du langages :
  3226.   * Orientation Objet
  3227.   * meilleur concept des flottants
  3228. - en faisant des améliorations spécifiques du compilateur
  3229.   * génération de code 020/030/881 possible
  3230.   * optimisation du processus de compilation, et donc possibilité de doubler
  3231.     la vitesse en ligne par minute annoncé dans le fichier 'compilateur.doc'
  3232.   * permet la compilation de code programmé en modules, et donc développer de
  3233.     grande application de manière plus modulaire
  3234. - par addition d'élément utile à la distribution
  3235.   * un éditeur intégré ?
  3236.   * un debuggeur au niveau du source ?
  3237.   * des outils comme CASE, par exemple
  3238. - par correction des bugs (quel bugs?!) 8*-)
  3239.  
  3240.  
  3241. F I N ! Ouf ! Bonne programmation... en E, bien sûr !
  3242.