home *** CD-ROM | disk | FTP | other *** search
/ AMIGA PD 1 / AMIGA-PD-1.iso / Programme_zum_Heft / Programmieren / Workshops / E-Compiler / Doks / E-Doku.Deutsch.TXT < prev    next >
Text File  |  1994-04-08  |  112KB  |  3,213 lines
  1. Inhalt
  2.  
  3. }                        Compiler für die E Sprache
  4.                          Von Wouter van Oortmerssen
  5.  
  6.                        Supertolle Preise zu gewinnen
  7.  
  8. }
  9.       1. Formatierung
  10.       2. Direkte Werte
  11.       3. Ausdrücke
  12.       4. Operatoren
  13.       5. Statements
  14.       6. Funktions Definition und Deklaration
  15.       7. Deklaration von Konstanten
  16.       8. Typen
  17.       9. Eingebaute Funktionen
  18.       10. Library Funktionen und Module
  19.       11. Ausgewertete Ausdrücke
  20.       12. Fließkommaunterstützung
  21.       13. Exception Behandlung
  22.       14. Objekt-Orientiertes Programmieren
  23.       15. Der Inline Assembler
  24.       16. Eingebaute Ausgaben
  25. Bemerkung
  26.  
  27.  
  28. Hääää, reingelegt... ROFL
  29.  
  30. Für den Fall, daß irgendjemand Fragen zur Übersetzung einzelner Kapitel
  31. hat, wende er sich bitte an:
  32.  
  33.   Kapitel 1,4-5,7-9,11-12,15  :  Rolf Breuer
  34.                                  Marktstr. 13
  35.                                  45891 Gelsenkirchen
  36.  
  37.   Kapitel 2,3,14,             :  Daniel van Gerpen
  38.   Amiga-Guide Fassung            Alter Postweg 3
  39.                                  26759 Hinte
  40.  
  41.   Kapitel 10                  :  Gregor Goldbach
  42.                                  Grüner Weg 10
  43.                                  21423 Pattensen
  44.  
  45.   Kapitel 16                  :  Christoph Lange
  46.                                  Altdorferstr. 19
  47.                                  63739 Aschaffenburg
  48.  
  49.   Kapitel 6, 13               :  Jörg Wach
  50.                                  Waitzstr. 75
  51.                                  24105 Kiel
  52.  
  53.  
  54. Wenn jemand eine, seiner Meinung nach besser, Übersetzung eines oder
  55. mehrerer Kapitel hat, dann kann er diese an Daniel van Gerpen (s.o.)
  56. schicken, und wird dann beim nächsten Mal hier erwähnt.
  57.  
  58. Index
  59.  
  60.  
  61. }                        Compiler für die E Sprache
  62.                          Von Wouter van Oortmerssen
  63.  
  64.                                     Index
  65.  
  66.  
  67.       1. Formatierung
  68.          A. Tabulatoren(tabs), Zeilenvorschübe(lf) usw.
  69.          B. Kommentare
  70.          C. Identifier und Typen
  71.       2. Direkte Werte
  72.          A. Dezimalzahlen (1)
  73.          B. Hexadezimalzahlen ($1)
  74.          C. Binärzahlen (%1)
  75.          D. Fließkommazahlen (1.0)
  76.          E. Zeichen ('a')
  77.          F. Zeichenketten ('bla')
  78.          G. Listen ([1,2,3]) und symbolische Listen
  79.       3. Ausdrücke
  80.          A. Format
  81.          B. Abarbeitung und Anordnung
  82.          C. Arten von Ausdrücken
  83.          D. Funktionsaufrufe
  84.       4. Operatoren
  85.          A. Mathematische (+ - * /)
  86.          B. Vergleiche (= <> > < >= <=)
  87.          C. Logische und Bitweise (AND OR)
  88.          D. Unary (SIZEOF ` ^ {} ++ -- -)
  89.          E. Dreifach (IF THEN ELSE)
  90.          F. Strukturen (.)
  91.          G. Felder ([])
  92.          H. Fließkommaoperator (|)
  93.          I. Zuweisungsoperator (:=)
  94.          J. Reihenfolge (BUT)
  95.       5. Statements
  96.          A. Format (;)
  97.          B. Sprungmarken und Sprunganweisungen (JUMP)
  98.          C. Zuweisungen (:=)
  99.          D. Assembler Mnemonics
  100.          E. Bedingte Anweisungen (IF)
  101.          F. For-Anweisung (FOR)
  102.          G. While-Anweisung (WHILE)
  103.          H. Repeat-Anweisung (REPEAT)
  104.          I. Loop-Anweisung (LOOP)
  105.          J. Auswahl-Anweisungen (SELECT)
  106.          K. Zuwachs-Anweisungen (INC/DEC)
  107.          L. Void-Ausdrücke (VOID)
  108.       6. Funktions Deklaration und Definition
  109.          A. Prozedur Definition und Argumente (PROC)
  110.          B. Lokale und globale Definitionen (DEF)
  111.          C. Endproc/return
  112.          D. Die 'main' Funktion
  113.          E. E-eigene Systemvariablen
  114.       7. Deklaration von Konstanten
  115.          A. Konstanten (CONST)
  116.          B. Aufzählungen (ENUM)
  117.          C. Sets (SET)
  118.          D. E-eigene Konstanten
  119.       8. Typen
  120.          A. Über das 'type' System
  121.          B. Der Grundtyp (LONG/PTR)
  122.          C. Die einfachen Typen (CHAR/INT/LONG)
  123.          D. Der Feldtyp (ARRAY)
  124.          E. Die komplexen Typen (STRING/LIST)
  125.          F. Der Verbundtyp (OBJECT)
  126.          G. Einrichtung
  127.       9. Eingebaute Funktionen
  128.          A. Ein-/Ausgabeoperationen
  129.          B. Zeichenketten und Zeichenkettenfunktionen
  130.          C. Listen und Listen Funktionen
  131.          D. Intuition unterstützende Funktionen
  132.          E. Grafikfunktionen
  133.          F. Systemfunktionen
  134.          G. Mathematische Funktionen
  135.          H. Funktionen zum Verbinden von Zeichenketten und Listen
  136.       10. Library Funktionen und Module
  137.          A. Eingebaute Library Aufrufe
  138.          B. Schnittstellen zum Amiga Sytem mit den 2.04 Modulen bilden
  139.       11. Ausgewertete Ausdrücke
  140.          A. Auswertung und Bereich
  141.          B. Eval()
  142.          C. Eingebaute Funktionen
  143.       12. Fließkommaunterstützung
  144.          A. Gebrauch/Überladen von Fließkommazahlen/-operatoren
  145.          B. Fließkommaausdrüke und Umwandlungen
  146.       13. Exception Behandlung
  147.          A. Definition von Exceptionhandlern (HANDLE/EXCEPT)
  148.          B. Benutzung der Raise() Funktion
  149.          C. Exceptions für eingebaute Funktionen (RAISE/IF)
  150.          D. Benutzung von Exception-ID's
  151.       14. Objektorientierte Programmierung
  152.       15. Der Inline-Assembler
  153.          A. Variablenteilung
  154.          B. Vergleich zwischen Inline-/Makroassembler
  155.          C. Wege, Binäredaten zu nutzen (INCBIN/CHAR..)
  156.          D. OPT ASM
  157.       16. Dinge über den Compiler
  158.          A. Das OPT Schlüsselwort
  159.          B. Small/Large Modell
  160.          C. Stack Organisation
  161.          D. Festgeschriebene Begrenzungen
  162.          E. Fehlermeldungen, Warnungen und nicht dokumentierte Tests
  163.          F. Compiler Puffer Organisation und Anforderung
  164.          G. Eine kurze Entstehungsgeschichte
  165.  
  166. Formatierung
  167.  
  168.  
  169.          }1.FORMATIERUNG@{uu}
  170.  
  172.          B. Kommentare
  173.          C. Identifier und Typen
  174.  
  175.  
  176.          Vorheriges Kapitel     Nächstes Kapitel
  177. Formatierung
  178.  
  179. }1A.
  180. -----------------------------------------------
  181.  
  182. E-Sources sind reine ASCII-Dateien, mit Zeilenvorschüben (lf) und Semiko-
  183. lons ";" als Trennung zwischen zwei Ausdrücken. Ausdrücke die mehrere Ar-
  184. gumente haben, die durch ein Komma "," getrennt sind, können über mehrere
  185. Zeilen verteilt werden, wenn die Zeile mit einem Komma endet, indem der
  186. folgende Zeilenvorschub ignoriert wird.
  187. Jedes lexikalische Elemente in einer Source-Code-Datei kann durch eine
  188. beliebige Anzahl von Leerzeichen oder Tabulatoren vonm nächsten getrennt
  189. werden.
  190. Formatierung
  191.  
  192. }1B.
  193. --------------
  194.  
  195. Kommentare können überall im Sourcecode plaziert werden, wo Leerzeichen
  196. korrekt wären. Sie beginnen mit "/*" und enden mit "*/" und können unend-
  197. lich verschachtelt werden.
  198. Formatierung
  199.  
  200. }1C.
  201. ------------------------
  202.  
  203. Identifier sind Strings die Programmierer benutzen um bestimmte Objekte zu
  204. benennen, in den meisten Fällen Variabeln, oder nur Schlüsselwörter oder
  205. Funktionsnamen die vom Compiler vordefiniert wurden. Ein Identifier kann
  206. aus folgenden bestehen:
  207.  
  208. -große und kleine Buchstaben
  209. -"0".."9" außer als ersten Buchstaben
  210. -"_" dem Unterstrich
  211.  
  212. Alle Zeichen werden beachtet, aber der Compiler benutzt nur die ersten
  213. beiden um den Typ des Identifiers zu bestimmen, mit dem er ihn behandelt:
  214.  
  215. beide groß      - Schüsselwort wie IF, PROC usw
  216.                 - Konstanten wie MAX-LENGTH
  217.                 - Assembler Mnemonic, wie MOVE
  218.  
  219. erster klein    - Identifier von Variabel/Sprungmarken/Objekten usw.
  220.  
  221. erster groß und
  222. zweiter klein   - E-System-Funktionen
  223.                 - Library Aufrufe: z.B. OpenWindow()
  224.  
  225. Zu bedenken ist, daß alle Identifier dieser Schreibweise folgen, zum Bei-
  226. spiel: WBenchToFront wird zu WbenchToFront
  227.  
  228. Direkte Werte
  229.  
  230.  
  231.          }2.DIREKTE
  232.  
  233.          Direkte  Werte  werden  in  E  immer zu einem 32 Bit Ergebniss
  234.          umgewandelt.   Der  einzige Unterschied zwischen diesen Werten
  235.          (A-G)   ist   entweder  ihre  interne  Darstellung,  oder  die
  236.          Tatsache,   daß   sie   einen   Zeiger  anstatt  eines  Wertes
  237.          zurückgeben.
  238.  
  239.          A. Dezimalzahlen (1)
  240.          B. Hexadezimalzahlen ($1)
  241.          C. Binärzahlen (%1)
  242.          D. Fließkommazahlen (1.0)
  243.          E. Zeichen ('a')
  244.          F. Zeichenketten ('bla')
  245.          G. Listen ([1,2,3]) und symbolische Listen
  246.  
  247.  
  248.  
  249.          Vorheriges Kapitel     Nächstes Kapitel
  250. Direkte Werte
  251.  
  252. }2A.
  253. ---------------------
  254.  
  255. Eine Dezimalzahl ist eine Folge der Zeichen "0"..."9", möglicherweise durch
  256. ein Minuszeichen "-" angeführt um negative Zahlen zu kennzeichnen.
  257. Beispiel: 1, 100, -12, 1024
  258. Direkte Werte
  259.  
  260. }2B.
  261. --------------------------
  262.  
  263. Ein hexadezimaler Wert benutzt die zusätzlichen Zeichen "A"..."F" (oder
  264. "a"..."f") und wird mit einem "$" Zeichen begonnen.
  265. Beispiele: $FC, $DFF180, -$ABCD
  266.  
  267. Direkte Werte
  268.  
  269. }2C.
  270. --------------------
  271.  
  272. Binärzahlen beginnen mit einem "%" Zeichen und benutzen nur die Zeichen
  273. "1" und "0" um einen Wert zu bilden.
  274. Beispiele: %111, %1010100001, -%10101
  275.  
  276. Direkte Werte
  277.  
  278. }2D.
  279. --------------------------
  280.  
  281. Fließkommazahlen unterscheiden sich nur durch einen "." von normalen
  282. Dezimalzahlen, der dazu dient die beiden Teile auseinander zu halten.
  283. Jeweils einer der beiden Teile darf weggelassen werden, nie beide. Zu
  284. Bedenken ist, daß Fließkommazahlen eine andere interne 32 Bit Darstellung
  285. (FFP) haben. Mehr Informationen über Fließkommazahlen gibt es im Kapitel
  286. 12.
  287. Beispiele: 3.14159, .1 (entspricht 0.1), 1. (entspricht 1.0)
  288.  
  289. Direkte Werte
  290.  
  291. }2E.
  292. -----------------
  293.  
  294. Der Wert eines Zeichens (in Anführungszeichen "" eingeschlossen) ist ihr
  295. ASCII Wert, z.B. "A"=65. In E können direkte Zeichenwerte kurze Zeichen-
  296. ketten mit bis zu 4 Zeichen sein, zum Beispiel "FORM", wobei das erste
  297. Zeichen "F" das MSB und "M" das LSB (least significat Bit) der 32 Bit-Dar-
  298. stellung ist.
  299.  
  300. Direkte Werte
  301.  
  302. }2F.
  303. -------------------------
  304.  
  305. Zeichenketten sind irgendwelche ASCII-Darstellungen, die von Hochkommatas
  306. '' (Alt+'Ä') eingeschlossen sind. Der Wert einer solchen Zeichenkette ist
  307. ein Zeiger auf das erste Zeichen der Kette. Spezifischer: 'bla' erzeugt
  308. einen 32 Bit Zeiger zu einem Speicherbereich wo wir die Bytes "b", "l"
  309. und "a" finden können. Alle Zeichenketten in E werden mit einem 0 Byte ab-
  310. geschlossen.
  311. Zeichenketten können Formatzeichen, von einem Backslash "/" angeführt, ent-
  312. halten. Entweder um Zeichen in eine Zeichenkette einzufügen, die aus irgend-
  313. welchen Gründen nicht darstellbar sind, oder um Zeichenkettenformatierungs-
  314. funktionen wie von WriteF(), TextF() und StringF(), oder der Kickstart 2.0
  315. Funktion Vprintf zu nutzen.
  316.  
  317. \n          ein Zeilenvorschub
  318. \a oder ''  ein Hochkomma (das zum Einschließen von Zeichenketten benutzt
  319.             wird)
  320. \e          Escape (ASCII 27)
  321. \t          Tabulator (ASCII 9)
  322. \\          Backslash
  323. \0          ein Null-Byte. Wird nur selten benutzt, da jede Zeichenkette
  324.             mit einem Null-Byte abgeschlossen wird
  325. \b          ein Carriage Return (Wagenrücklauf)
  326.  
  327. Zusätzlich, bei Benutzung mit Format-Funktionen:
  328.  
  329. \d          schreibt ein Dezimalzahl
  330. \h          schreibt eine Hexadezimalzahl
  331. \s          schreibt eine String
  332. \c          schreibt ein Zeichen
  333. \z          schreibt Füllzeichen bei Nullen
  334. \l          formatiert linksbündig
  335. \r          formatiert rechtsbündig
  336.  
  337. Feldvariabeln können /d,/h und /s Codes folgen:
  338.  
  339. [x]         bezeichnet die genaue Feldbreite x
  340. (x,y)       bezeichnet das Minimum und das Maximum y (nur bei Zeichenketten)
  341.  
  342. Beispiel: Schreibt eine Hexadezimalzahl mit 8 Stllen und führenden Nullen
  343.           WriteF ('\z\h[8]\n',num)
  344.  
  345. Eine Zeichenkette kann über meherer Zeilen verteilt werde, indem man sie mit
  346. einem "+" Zeichen und einen <lf> (Zeilenvorschub) verbindet:
  347.  
  348. 'dies ist eine sehr lange Zeichenkette'+
  349. 'sie wurde über mehrere Zeilen verteilt'
  350.  
  351. Direkte Werte
  352.  
  353. }2G.
  354. -------------------------------------------
  355.  
  356. Eine direkte Liste ist das konstante Gegenstück des List Datentyps, genauso
  357. wie eine "Zeichenkette" das konstante Gegenstück für den STRING oder den
  358. ARRAY OF CHAR Datentyp ist. Beispiel:
  359.  
  360. [3,2,1,4]
  361.  
  362. ist ein Ausdruck, das als Wert einen Zeiger auf eine bereits fertigestellte
  363. Liste hat. Eine Liste ist eine Darstellung im Speicher, die gleichwertig
  364. mit ARRAY OF LONG ist, mit einigen zusätzlichen Längeninformationen an
  365. einem negativen Offset. Du kannst diese direkten Listen überall benutzen,
  366. wo eine Funktion einen Zeiger auf ein Feld von 32 Bit Werten oder eine Liste
  367. erwartet. Beispiele:
  368.  
  369. ['Zeichenkette',1.0,2.1]
  370. [WA_FLAGS,1,WA_IDCMP,$200,WA_WIDTH,120,WA_HEIGHT,150,TAGDONE]
  371.  
  372. Schaue Dir das Kapitel über List-Funktionen für eine Besprechung von symbo-
  373. lischen Listen und Detailinformationen an.
  374.  
  375.  
  376. Ausdrücke
  377.  
  378.  
  379.          }3.AUSDRÜCKE@{uu}
  380.  
  382.          B. precedence and grouping
  383.          C. types of expressions
  384.          D. function calls
  385.  
  386.  
  387.  
  388.          Vorheriges Kapitel     Nächstes Kapitel
  389. Ausdrücke
  390.  
  391. }3A.
  392. ----------
  393.  
  394. Ein Ausdruck ist ein Stück Quelltext, das aus Operatoren, Funktionen und
  395. Klammern besteht, um einen Wert zu erstellen.
  396. Sie bestehen meistens aus:
  397.  
  398. - direkten Werten wie im Kapitel 2 besprochen
  399. - Operatoren wie im Kapitel 4 besprochen
  400. - Funktionsaufrufen wie im Kapitel 3D besprochen
  401. - Klammern wie im Kapitel 3B besprochen
  402. - Variabeln oder Variabelausdrücken (siehe Kapitel 3C)
  403.  
  404. Beispiele für Ausdrücke
  405.  
  406. 1
  407. 'Hallo'
  408. $ABCD+(2*5)+Abs(a)
  409. (a<1) OR (b>=100)
  410.  
  411. Ausdrücke
  412.  
  413. }3B.
  414. -----------------------------
  415.  
  416. E hat keinen Abarbeitungsvorrang. D. h., daß Ausdrücke von links nach
  417. rechts ausgewertet werden. Du kannst die Abarbeitung durch Einklammern
  418. von (Unter-) Funktionen ändern:
  419.  
  420. 1+2*3 /*=9*/    1+(2*3) /*=7*/   2*3+1 /*=7*/
  421.  
  422. Ausdrücke
  423.  
  424. }3C.
  425. ------------------------
  426.  
  427. Es gibt drei Arten von Ausdrücken, die für unterschiedliche Verwendungs-
  428. zwecke genutzt werden:
  429.  
  430. - <var> besteht nur aus einer Variabel
  431. - <varexp> bestehend aus einer Variabel, möglicherweise mit einem unary(??)
  432.   Operator dazu, wie ++ (increment) oder [] (Array Operator). Hierfür siehe
  433.   Kapitel 4D und 4G. Es zeigt einen veränderbaren Ausdruck an, wie Lvalues
  434.   in C.
  435.   Bedenke das diese unary (??) Operatoren nie Teil der Abarbeitung sind
  436. - <exp>. Dies beinhaltet <var> und <varexp, und jede andere Art von Aus-
  437.   druck
  438.  
  439. Ausdrücke
  440.  
  441. }3D.
  442. --------------------
  443.  
  444. Ein Funktionsaufruf ist eine zeitweilig Unterbrechung des aktuellen Codes,
  445. um in eine Funktion zu springen. Dies kann entweder eine selbstgeschriebene
  446. Funktion (PROC), oder eine Funktion die vom System zu verfügung gestellt
  447. wird.
  448. Das Format eines solchen Funktionsaufruf ist der Name der Funktion, gefolgt
  449. von zwei Klammern(), die von Null bis zu unendlich vielen Argumenten, die
  450. durch Kommas getrennt werden, enthält. Argumente für Funktionen sind
  451. wiederum Ausdrücke. In Kapitel 6 steht wie man seine eigene Funktion er-
  452. stellt und Kapitel 9 und 10 beschreiben die eingebauten Funktionen. Bei-
  453. spiele:
  454.  
  455. foo (1,2)
  456. Gadget(buffer,glist,2,0,40,80+offset,100,'Cancel')
  457. Close(handle)
  458.  
  459. Operatoren
  460.  
  461.  
  462.          }4.OPERATOREN@{uu}
  463.  
  465.          B. Vergleiche (= <> > < >= <=)
  466.          C. Logische und Bitweise (AND OR)
  467.          D. Unary (SIZEOF ` ^ {} ++ -- -)
  468.          E. Dreifach (IF THEN ELSE)
  469.          F. Strukturen (.)
  470.          G. Felder ([])
  471.          H. Fließkommaoperator (|)
  472.          I. Zuweisungsoperator (:=)
  473.          J. Reihenfolge (BUT)
  474.  
  475.  
  476.          Vorheriges Kapitel     Nächstes Kapitel
  477. Operatoren
  478.  
  479. }4A.
  480. ---------------------------
  481.  
  482. Diese festen Operatoren verbindett einen Ausdruck mit einem anderen Wert,
  483. um einen neuen Wert zu bilden. Beispiele:
  484.  
  485. 1+2, MAX-1*5
  486.  
  487. in Kapitel 12 wird beschrieben, wie man diese Operatoren überlädt um sie
  488. Fließkommazahlen zu benutzen. "-" kann als erster Teil eines Ausdrucks be-
  489. nutzt werden, natürlich inklusive 0.
  490.  
  491. z.B. sind -a oder -b+1 zulässig
  492.  
  493. Bedenke, daß * und / standardmäßig 16 Bit Operatoren sind: siehe Mul()
  494.  
  495. Operatoren
  496.  
  497. }4B.
  498. -------------------------------
  499.  
  500. Gleich wie mathematische Operatoren, mit dem Unterschied, das ihr Ergebniss
  501. entweder TRUE (Wahr) (32 Bit Wert -1) oder FALSE (Falsch). Diese können
  502. auch für Fließkommazahlen überladen werden.
  503.  
  504. Operatoren
  505.  
  506. }4C.
  507. ----------------------------------
  508.  
  509. Diese Operatoren kombinieren entweder Wahrheitswerte zu neuen oder operie-
  510. ren bitweise mit AND und OR. Beispiele:
  511.  
  512. (a>1) AND ((b=2) OR (c>=3))   /*logisch */
  513. a:=b AND $FF                  /*bitweise*/
  514.  
  515. Operatoren
  516.  
  517. }4D. ++ -- `)b}
  518. ---------------------------------
  519.  
  520. -4E. Dreifach (IF THEN ELSE)b}
  521. ---------------------------
  522.  
  523. Der4F. Strukturen (.)b}
  524. ------------------
  525.  
  526. <prt2objekt>.<memberofobjekt>4G. Felder ([])b}
  527. ---------------
  528.  
  529. <var>[<indexexp>]4H. Fließkommaoperator (|)b}
  530. --------------------------
  531.  
  532. <exp>\<exp>
  533. Wandelt4I. Zuweisungsoperator (:=)b}
  534. ---------------------------
  535.  
  536. Zuweisungen4J. Reihenfolge (BUT)b}
  537. ---------------------
  538.  
  539. Der5.STATEMENTSu}
  540.  
  542.          B. Sprungmarken und Sprunganweisungen (JUMP)
  543.          C. Zuweisungen (:=)
  544.          D. Assembler Mnemonics
  545.          E. Bedingte Anweisungen (IF)
  546.          F. For-Anweisung (FOR)
  547.          G. While-Anweisung (WHILE)
  548.          H. Repeat-Anweisung (REPEAT)
  549.          I. Loop-Anweisung (LOOP)
  550.          J. Auswahl-Anweisungen (SELECT)
  551.          K. Zuwachs-Anweisungen (INC/DEC)
  552.          L. Void-Ausdrücke (VOID)
  553.  
  554.  
  555.          Vorheriges Kapitel     Nächstes Kapitel
  556. Statements
  557.  
  558. }5A.
  559. --------------
  560.  
  561. Wie im Kapitel 1A, steht ein Statement in seiner eigenen Reihe, aber mehrere
  562. von ihnen können in einer Reihe, durch ein Semikolon getrennt, geschrieben
  563. werden. Auch kann ein Statement über mehr als eine Zeile verteilt werde,
  564. wobei jede Zeile mit einem Komma enden muß. Beispiel:
  565.  
  566. a:=1, WriteF('Hallo!\n')
  567. DEF a,b,c,d,        /*zuviele Argumente für eine Zeile (vorgemacht)*/
  568.     e,f,g
  569.  
  570. Statement können sein
  571.  
  572. - Zuweisungen
  573. - Bedingt Zuweisungen für Statement und sowas, siehe auch Kapitel 5E-5K
  574. - Rückgabefreie Ausdrücke
  575. - Sprungmarken
  576. - Assembleranweisungen
  577.  
  578. Das Komma ist das erste Zeichen um zu zeigen, das Du das Statement nach dem
  579. nächsten Zeilenvorschub noch nicht beenden willst, aber auch die folgenden
  580. Zeichen zeigen an, daß das Statement in der folgenden Zeile fortgeführt
  581. wird:
  582.  
  583. + - * /
  584. = > < <> >= <=
  585. AND OR BUT THEN
  586.  
  587. Statements
  588.  
  589. }5B.
  590. ---------------------------------------------
  591.  
  592. Lables sind globale Identifier mit einem zusätzlichen ":", wie bei
  593.  
  594. mylable:
  595.  
  596. sie können von Anweisungen wie JUMP benutzt werden, aber auch um statische
  597. Daten zu erzeugen. Sie können benutzt werden, um aus jeder Art von Schleife
  598. zu springen (obwohl diese Technik nicht gut ist), aber es kann nicht aus
  599. einer Prozedure gesprungen werden. In normalen E-Programmen werden sie
  600. meistens für den Inline-Assembler benutzt. Lables sind immer global sicht-
  601. bar.
  602.  
  603. Benutzung von JUMP: JUMP <lable>
  604.  
  605. führt die Abarbeitung beim <lable> fort. Du solltest dies aber nicht be-
  606. nutzen, es ist eigentlich nur für Situationen da, wo man die Komplexität
  607. eines Programms vermindert. Beispiel:
  608.  
  609. IF Mouse()=1 THEN JUMP stopnow
  610.  
  611. /*andere Programmteile*/
  612.  
  613. stopnow:
  614.  
  615. Statements
  616.  
  617. }5C.
  618. --------------------
  619.  
  620. Das grundsätzliche Format einer Zuweisung ist <var>:=<exp>
  621. Beispiele: a:=1, a:=myfunc(), a:=b*3
  622.  
  623. Statements
  624.  
  625. }5D.
  626. -----------------------
  627.  
  628. In E ist der Inline-Assembler ein wirklicher Teil der Sprache, er muß nicht
  629. in spezielle "ASM" Blöcke oder sowas, wie es in anderen Sprachen notwendig
  630. ist, noch ist ein extra Assembler nötig, um den Code zu Asseblieren. Das
  631. heißt auch, daß er den normalen E Syntax-Regeln gehorcht, usw. In Kapitel
  632. 15 kannst Du alles über den Inline-Assembler lesen. Beispiele:
  633.  
  634. DEF a,b
  635. b:=2
  636. MOVEQ   #1,D0       /*nur einige Assembler-Statements*/
  637. MOVEL   D0,a        /*a:=1+D*/
  638. ADD.C   b,a
  639. WriteF('a=\d\n',a)  /*a wird 3 sein*/
  640.  
  641. Statements
  642.  
  643. }5E.
  644. -----------------------------
  645.  
  646. IF, THEN, ELSE, ELSEIF, ENDIF
  647.  
  648. Syntax: IF <exp> THEN <Statment> [ELSE <Statement>]
  649. oder  : IF <exp>
  650.                 <Statements>
  651.         [ELSEIF <exp>           /*mehrere elseifs können vorkommen*/
  652.                 <Statements>]
  653.         [ELSE
  654.                 <Statements>]
  655.         ENDIF
  656.  
  657. bilden einen Bedingten-Block. Bedenke das es zwei Hauptformen von diesem
  658. Statement gibt, eine einzeilen und eine mehrzeilen Version.
  659.  
  660. Statements
  661.  
  662. }5F.
  663. -----------------------
  664.  
  665. FOR, TO, STEP, DO, ENDFOR
  666.  
  667. Syntax: FOR <var>:=<exp> STEP <Schrittweite> DO <Statement>
  668. oder  : FOR <var>:=<exp> STEP <Schrittweite>
  669.                         <Statements>
  670.         ENDFOR
  671.  
  672. bilden einen FOR-Block, beachte die beiden Hauptformen. <Schrittweite> kann
  673. jede positive oder negative Konstanten, außer 0 sein. Beispiele:
  674.  
  675. FOR a:=1 TO 10 DO WriteF('\d\n'a)
  676.  
  677. Statements
  678.  
  679. }5G.
  680. ---------------------------
  681.  
  682. WHILE, DO, ENDWHILE
  683.  
  684. Syntax: WHILE <exp> DO <Statement>
  685. oder  : WHILE <exp>
  686.                 <Statements>
  687.         ENDWHILE
  688.  
  689. bilden eine While-Schleife, die solange durchlaufen wird, wie <exp> TRUE
  690. ergibt. Beachte die Ein-Zeile/Ein-Statement-Version und die Mehrzeilen-
  691. Version.
  692.  
  693. Statements
  694.  
  695. }5H.
  696. -----------------------------
  697.  
  698. REPEAT, UNTIL
  699.  
  700. Syntax: REPEAT
  701.             <Statements>
  702.         UNTIL <exp>
  703.  
  704. bilden einen Repeat-Until-Block. Die Schleife wird fortgesetzt bis <exp>=
  705. TRUE ist. Beispiel:
  706.  
  707. REPEAT
  708.     WriteF('Möchtest du wirklich dieses Programm beenden?\n'
  709.     ReadStr(stdout,s)
  710. UNTIL StrCmp(s,'ja bitte!')
  711.  
  712. Statements
  713.  
  714. }5I.
  715. -------------------------
  716.  
  717. LOOP, ENDLOOP
  718.  
  719. Syntax: LOOP
  720.             <Statements>
  721.         ENDLOOP
  722.  
  723. bilden eine unendliche Schleife.
  724.  
  725. Statements
  726.  
  727. }5J.
  728. --------------------------------
  729.  
  730. Syntax: SELECT <var>
  731.             [CASE <exp>
  732.                 <Statements>]
  733.             [CASE <exp>
  734.                 <Statements>]   /*eine beliebige Anzahl weiterer Blöcke*/
  735.             [DEFAULT <exp>
  736.                 <Statement>]
  737.         ENDSELECT
  738.  
  739. bilden einen Select-Case-Block. Beliebige Ausdrücke werden mit der Varia-
  740. bel <var> verglichen, und der erste passende Block wird ausgeführt. Wenn
  741. kein gleicher Ausdruck vorhanden ist, kann ein Default-Block ausgeführt
  742. werden.
  743.  
  744. SELECT zeichen
  745.     CASE 10
  746.         WriteF('Hey, wir haben einen Zeilenvorschub gefunden\n')
  747.     CASE 9
  748.         WriteF('Wow, das muß ein Tabulator sein!\n')
  749.     DEFAULT('Kennst Du dieses Zeichen: \c?\n',zeichen)
  750.  
  751. ENDSELECT
  752.  
  753. Statements
  754.  
  755. }5K.
  756. ---------------------------------
  757.  
  758. INC, DEC
  759.  
  760. Syntax: INC <var>
  761.         DEC <var>
  762.  
  763. kurz für <var>:=<var+1> und <var>:=var-1. Der einzige Unterschied zu var++
  764. und var-- ist, daß dies Statements sind, und keinen Wert zurückgeben und
  765. folglich optimaler sind.
  766.  
  767. Statements
  768.  
  769. }5L.
  770. ------------------------
  771.  
  772. Syntax: VOID <exp>
  773.  
  774. Berchnet den Ausdruck ohnen das der Wert irgendwohin geht. Dies ist nur
  775. für eine lesbarere Syntax nützlich, da Ausdrücke in E auch als Statement
  776. ohne VOID benutzt werden können. Dies kann heikle Fehler verursachen, da
  777. "a:=1" a den Wert 1 zuweist, aber "a=1" als Statement nichts tut. E warnt
  778. Dich, wenn das passiert.
  779.  
  780. Function Definitions and Declarations
  781.  
  782.  
  783.          }6.FUNKTIONS
  784.  
  785.          A. Prozedur Definition und Argumente (PROC)
  786.          B. Lokale und globale Definitionen (DEF)
  787.          C. Endproc/return
  788.          D. Die 'main' Funktion
  789.          E. E-eigene Systemvariablen
  790.  
  791.  
  792.  
  793.          Vorheriges Kapitel     Nächstes Kapitel
  794. Funktions Deklaration und Definition
  795.  
  796. }6A.
  797. --------------------------------------------
  798.  
  799. Du darfst PROC und ENDPROC zur Zusammenfassung von Ausdrücken in deinen
  800. eigenen Funktionen zu verwenden.
  801.  
  802. Solche ein Funktion darf irgendwelche Anzahl von Argumente haben und liefert
  803. einen Wert zurück.
  804.  
  805.  
  806.  
  807.  
  808. PROC, ENDPROC
  809.  
  810.  
  811.  
  812. Syntax:         PROC <Marke> ( <Argumente> , ... )
  813.  
  814.                 ENDPROC <Rückgabewert>
  815.  
  816. Definiert eine Prozedur mit irgendeiner Anzahl von Argumenten.
  817. Argumente sind von Typ LONG oder Optional als PTR TO <TYP> (siehe Kapitel 8)
  818. und brauchen kein weitere Deklarationen.
  819.  
  820. Das Ende einer Prozedur wird gekennzeichnet durch ENDPROC. Wenn kein Rück-
  821. gabewert mitgegeben wird, so wird 0 zurückgeliefert.
  822.  
  823. Beispiel: Eine Funktion, die zwei Argumente zusammengefasst zurückliefert:
  824.  
  825.  
  826. PROC add(x,y)         /* x und y sind lokale Variablen */
  827. ENDPROC x+y           /* liefert das Resultat zurück  */
  828. Funktions Deklaration und Definition
  829.  
  830. }6B.
  831. -----------------------------------------
  832.  
  833. Du darfst lokale Variablen definieren, indem Du die Argumente mit der
  834. DEF-Angabe bestimmst. Der leichteste Weg ist
  835.  
  836.  
  837. DEF a,b,c
  838.  
  839.  
  840. erklärt die Bezeichner a, b und c als Variablen deiner Funktion.
  841.  
  842. Beachten daß solche Deklarationen am Anfang Deiner Funktionen stehen müssen.
  843.  
  844.  
  845.  
  846.  
  847. DEF
  848.  
  849.  
  850. Syntax:         DEF <Deklarationen>,...
  851.  
  852. Beschreibung    definiert Variablen. Eine Deklarationen hat eine der Formen:
  853.  
  854.                 <Variable>
  855.  
  856.                 <Variable>:<Typ>          wobei <typ>=LONG,<objectidentifizierer>
  857.  
  858.                 <Variable>[<Größe>]:<Typ> wobei <typ>=ARRAY,STRING,LIST
  859.  
  860.  
  861.  
  862. Siehe Kapitel 8 für mehr Beispiele, wo steht, wie die Typen benutzt
  863. werden.
  864.  
  865. Fürs erste ist es gut die <Variable>-Form zu benutzen.
  866. Argumente für Funktionen sind beschränkt auf die Basis-Typen; siehe Kapitel 8B.
  867.  
  868. Ein Deklarationen eines Basis-Types kann eine Initialisierung haben, in der
  869. aktuellen Version muß dieses ein Integer sein (kein Ausdruck):
  870.  
  871.  
  872. DEF a=1,b=2
  873.  
  874.  
  875.  
  876. Ein Programm beinhaltet mehrere Funktionen, genannt PROCs. Jede
  877.  
  878. procedure may have Local variables, and the program as a whole may have
  879. Prozedur darf lokale Variablen haben, und das Programm als ganzes
  880. darf globale Variablen haben.
  881. Ein Programm muß mindestens aus der Prozedur PROC main() bestehen, da diese
  882. Prozedur den Anfang der Ausführung bestimmt.
  883.  
  884. Ein einfaches Programm könnte wie folgt ausschauen:
  885.  
  886.  
  887. DEF a, b                            /* Definition der globalen Variablen */
  888.  
  889. PROC main()                         /* alle Funktionen in zufälliger Ordnung */
  890.  
  891.   bla(1)
  892.  
  893. ENDPROC
  894.  
  895. PROC bla(x)
  896.  
  897.   DEF y,z                           /* Eigene, lokalen Variablen möglich. */
  898.  
  899. ENDPROC
  900.  
  901.  
  902.  
  903. Zusammengefasst: lokale Definitionen sind diejenigen, die Du am Start der
  904. Prozeduren nennst und welche erst in der Prozedur sichtbar werden. Globale
  905. Definitionen werden vor der ersten PROC gemacht, also am Start deines
  906. Quell-Codes, und sie sind global verfügbar. Globale und lokale Variablen
  907. (und natürlich lokale Variablen von zwei unterschiedlichen Funktionen)
  908. dürfen den gleichen Name haben.
  909.  
  910. Lokale Variablen haben immer höhere Priorität!
  911. Funktions Deklaration und Definition
  912.  
  913. }6C.
  914. ------------------
  915.  
  916. Wie zuvor gesagt, markiert ENDPROC das Ende einer Funktionen-Definition,
  917. und darf einen Wert zurückliefern.
  918. Optional kann RETURN an irgendwelchen Punkt in der Funktion zum beenden der
  919. Funktion benutzt werden. Wenn REURN in der Prozedur main() benutzt wird,
  920. dann endet das Programm.
  921.  
  922. Siehe auch CleanUp() in Kapitel 9F.
  923.  
  924. RETURN [<Rückgabewert>]          /* optional */
  925.  
  926.  
  927. Beispiel:
  928.  
  929.  
  930.  
  931. PROC getresources()
  932.  
  933.   /* ... */
  934.  
  935.   IF error THEN RETURN FALSE  /* etwas ist schiefgegangen, also raus
  936.                                  aus der Funktion mit dem Rückgabewert
  937.                                  "FALSCH". */
  938.  
  939.   /* ... */
  940.  
  941. ENDPROC TRUE  /* wir sind soweit, damit liefern wir TRUE zurück. */
  942.  
  943.  
  944. Eine sehr kurz Version bei einer Funktion-Definition ist
  945.  
  946.  
  947.  
  948. PROC <marke> ( <Argument> , ... ) RETURN <Ausdruck>
  949.  
  950.  
  951. These are function definitions that only make small computations, like
  952. Diese sind Funktions-Definitionen die kleine Berechnungen machen, wie
  953. fakultative Funktionen und sie sind (ein-Zeiler :-)
  954.  
  955.  
  956.  
  957. PROC fac(n) RETURN IF n=1 THEN 1 ELSE fac(n-1)*n
  958. Funktions Deklaration und Definition
  959.  
  960. }6D.
  961. -----------------------
  962. Die PROC mit dem Namen main() ist unheimlich Wichtig, weil es
  963. die erste aufgerufene Funktion ist; sie ist genauso aufgebaut wie andere
  964. Funktionen und darf auch lokale Variablen haben.
  965.  
  966. main() hat keine Argumente; die CLI-Kommando-Zeilen Argumente werden in
  967. der System-Variable "arg" geliefert, oder können überprüft werden mit
  968.  
  969. ReadArgs()
  970. Funktions Deklaration und Definition
  971.  
  972. }6E.
  973. ----------------------------
  974. Folgende globale Variablen sind immer verfügbar in Deinem Programm,
  975. sie werden System Variablen genannt.
  976.  
  977.  
  978.  
  979.  
  980. arg             Wie oben gesagt, beinhaltet "arg" einen Zeiger zu einem mit
  981.                 mit Null abgeschlossen String. Der String wiederum
  982.                 beinhaltet die CLI-Kommando-Zeilen-Argumente.
  983.                 Benutze nicht diese Variable wenn du ReadArgs() in
  984.                 Deinem Programm benutzt.
  985.  
  986. stdout          Beinhaltet ein File-Handle zu der Standard Ausgabe
  987.                 (und Eingabe).
  988.                 Wenn dein Programm von der Workbench gestartet wurde, so daß
  989.                 kein Shell-Fenster verfügbar ist, WriteF() öffnet ein CON:
  990.                 Fenster für dich und setzt den entsprechenden File-Handler
  991.                 hier hinein.
  992.  
  993. conout          Hier wird das File-Handle abgelegt, und das CON:
  994.                 Fenster wird automatisch geschlossen nach einem exit
  995.                 von Deinem Programm.
  996.                 Siehe WriteF() in Abschnitt 9E, um zu sehen, wie die zwei
  997.                 Variablen richtig benutzt werden.
  998.  
  999. execbase,       Diese fünf Variablen enthalten IMMER die
  1000. dosbase,        richtigen Werte.
  1001. gfxbase,
  1002. intuitionbase,
  1003. mathbase
  1004.  
  1005. stdrast         Zeiger zum Standard-Rastport, um diesen in deinem Programm
  1006.                 benutzten zu können, oder NIL.
  1007.                 Die eingebauten Grafik-Funktionen wie Line() benutzen
  1008.                 diese Variable.
  1009.  
  1010. wbmessage       Beinhaltet einen Zeiger zu ein Nachricht die du bekommst,
  1011.                 wenn du von der Worbench startest, sonst NIL.
  1012.                 Darf benutzt werden wie ein Boolean-Wert um festzustellen,
  1013.                 ob du von der Workbench gestartet bist oder sogar zum
  1014.                 überprüfen irgendwelcher Argumente, die mit Deinem ICON
  1015.                 "Shift-ausgewählt" wurden.
  1016.                 Siehe WbArgs.e in dem sources/Examples Verzeichnis, um zu
  1017.                 sehen, wie gut man wbmessage benutzen kann.
  1018. Deklaration von Konstanten
  1019.  
  1020.  
  1021.          }7.DEKLARATION
  1022.  
  1023.          A. Konstanten (CONST)
  1024.          B. Aufzählungen (ENUM)
  1025.          C. Sets (SET)
  1026.          D. E-eigene Konstanten
  1027.  
  1028.  
  1029.  
  1030.          Vorheriges Kapitel     Nächstes Kapitel
  1031. Deklaration von Konstanten
  1032.  
  1033. }7A.
  1034. ----------------------
  1035. Syntax: CONST <Deklaration>
  1036.  
  1037. Ermöglicht es Dir eine Konstante zu deklarieren. Eine Deklaration sieht so
  1038. aus:
  1039.  
  1040. <ident>=<Wert>
  1041.  
  1042. Konstanten müssen großgeschrieben sein, und werden für den Rest des Pro-
  1043. gramms als <Wert> behandelt. Beispiel:
  1044.  
  1045. CONST MAX_LINES=100, ER_NOMEM=1, ER_NOFILE=2
  1046.  
  1047. Man kann keine Konstanten mit Termen deklarieren in denen Konstanten sind
  1048. die im selben Statement deklarier werden: Schreibe diese ins nächste.
  1049.  
  1050. Deklaration von Konstanten
  1051.  
  1052. }7B.
  1053. -----------------------
  1054.  
  1055. Aufzählungen sind ein spezieller Typ von Konstanten, bei denen kein Wert an-
  1056. gegeben werden braucht, da sie im Bereich von 0..n definiert sind, das erste
  1057. Element ist 0. An einem beliebigen Punkt in einer Aufzählung kannst Du
  1058. "=<Wert>" einsetzen um den Zähler auf einen Wert zu setzen oder rückzuset-
  1059. zen. Beispiele:
  1060.  
  1061. ENUM ZERO, ONE, TWO, THREE, MONDAY=1, TUESDAY, WENDSDAY
  1062. ENUM ER_NOFILE=100, ER_NOMEM, ER_NOWINDOW
  1063.  
  1064. Deklaration von Konstanten
  1065.  
  1066. }7C.
  1067. --------------
  1068. Sets sind den Aufzählungen ähnlich, mit dem Unterschied, daß anstatt einem
  1069. Wert wie (0,1,2..) eine Bitnummer hat (0,1,2...) die erhöht wird. So haben
  1070. Sets die Werte (1,2,4,8...). Das hat den zusätzlichen Vorteil, daß sie als
  1071. Sets von Flags benutzt werden können, wie das Schlüsselwort sagt.
  1072. Stellen wir uns ein Set wie oben vor, das die Einrichtung eines Fensters
  1073. beschreibt:
  1074.  
  1075. SET SIZEGAD, CLOSEGAD, SCROLLBAR, DEPTH
  1076.  
  1077. um eine Variabel mit den Werten DEPTH und SIZEGAD vorzubereiten:
  1078.  
  1079. winflags:=DEPTH OR SIZEGAD
  1080.  
  1081. um einen zusätzlichen SCROLLBAR einzurichten
  1082.  
  1083. winflags:=winflags OR SCROLLBAR
  1084.  
  1085. und testen ob zwei Einrichtung gehalten wurden
  1086.  
  1087. IF winflags AND (SCROLLBAR OR DEPTH) THEN /*   */
  1088.  
  1089. Deklaration von Konstanten
  1090.  
  1091. }7D.
  1092. -----------------------
  1093. Folgende eingebaute Konstanten können benutzt werden:
  1094.  
  1095. TRUE, FALSE         Repräsentiert die boolschen Wert Wahr und Falsch (-1,0)
  1096. NIL                 (=0) nicht initialisierter Pointer
  1097. ALL                 wird bei String-Funktionen wie StrCopy benutzt, damit
  1098.                     alle Zeichen kopiert werden.
  1099. GADGETSIZE          kleinste Größe in Bytes um ein Gadget zu erhalten, siehe
  1100.                     auch Gadget() 9D
  1101. OLDFILE, NEWFILE    Modusprameter beim benutzen von Open()
  1102. STRLEN              Hat immer den Wert der zuletzt benutzten Zeichenkette.
  1103.                     Beispiel: Write(handle,'Hallo Leute!',STRLEN) /* =9 /*
  1104.  
  1105.  
  1106. Typen
  1107.  
  1108.  
  1109.          }8.TYPEN@{uu}
  1110.  
  1112.          B. Der Grundtyp (LONG/PTR)
  1113.          C. Die einfachen Typen (CHAR/INT/LONG)
  1114.          D. Der Feldtyp (ARRAY)
  1115.          E. Die komplexen Typen (STRING/LIST)
  1116.          F. Der Verbundtyp (OBJECT)
  1117.          G. Einrichtung
  1118.  
  1119.  
  1120.          Vorheriges Kapitel     Nächstes Kapitel
  1121. Typen
  1122.  
  1123. }8A.
  1124. --------------------------
  1125. E hat kein strenges Typen-System wie in Pascal oder Modula2, es ist sogar
  1126. flexibler als in C. Du kannst es auch ein Datentypen-System. Dies geht Hand
  1127. in Hand mit der Philosophie, daß alle Datentypen in E gleich sind: alle
  1128. kleinen Grundtypen wie Zeichen, Dezimalzahlen etc. Alle haben die gleichen
  1129. 32 Bitgröße und alle anderen Daten und alle anderen Datentypen wie Felder
  1130. und Zeichenketten werden von auf einen 32 Bitzeiger auf sie. So kann der
  1131. Compiler einen vielseitigen Code generieren.
  1132. Die Vor- und Nachteile sind offensichtlich:
  1133.  
  1134. Nachteile des E-Typen-Systems:
  1135.  
  1136. - weniger Compiler-Überprüfungen für dumme Fehler von DIR!
  1137.  
  1138. Vorteile:
  1139.  
  1140. - Low-Level Vielseitigkeit
  1141. - flexible Programmgestaltung: kein Problem das einige Typen Werte zurück
  1142.   geben die nicht zu anderen Aufrufe usw.
  1143. - es ist nicht schwer Fehler beim mischen von verschieden großer Daten in
  1144.   Ausdrücken zu finden
  1145. - er werden immer noch selbstdokumentierende Typen unterstützt, wie:
  1146.  
  1147.   PTR to newscreen
  1148.  
  1149. Typen
  1150.  
  1151. }8B.
  1152. ---------------------------
  1153. Es gibt nur einen nicht komplexen Grundtyp in E, es ist der 32 Bit Typ LONG.
  1154. Da er der Defaulttyp ist, kann er so definiert werden:
  1155.  
  1156. DEF a:LONG          oder nur    DEF a
  1157.  
  1158. Diese Variabel kann das aufnehmen, was in anderen Programmiersprachen die
  1159. Typen CHAR/INT/PTR/LONG enthalten. Eine spezielle Art des LONG Typen ist
  1160. der PTR-Typ. Dieser Typ ist kompatibel mi dem LONG-Typen, mit dem Unter-
  1161. schied, daß angegeben wird, auf was er zeigt. Als Voreinstellung gilt, das
  1162. LONG als PRT TO CHAR angegeben wird. Syntax:
  1163.  
  1164. DEF <var>:PTR TO <Typ>
  1165.  
  1166. wobei Typ entweder ein einfacher oder ein zusammengesetzter Typ ist. Bei-
  1167. spiel:
  1168.  
  1169. DEF x:PTR TO INT, myscreen: PTR TO screen
  1170.  
  1171. Beachte, daß 'screen' der Name eines Objekts ist, das im Module intuition/
  1172. screens.m definiert ist. Zu Beispiel wenn Du Deinen eigenen Screen öffnest
  1173. mit:
  1174.  
  1175. myscreen:=OpenS(... usw.
  1176.  
  1177. kannst Du den Zeiger myscreen z.B. als 'myscreen.rastport' benutzen. Wenn
  1178. Du aber nichts mit den Variabeln machen willst, bis Du CloseS(myscree)
  1179. aufrufst, kannst Du sie so deklarieren:
  1180.  
  1181. DEF myscreen
  1182.  
  1183. Typen
  1184.  
  1185. }8C.
  1186. ---------------------------------------
  1187. Die einfachen Typen CHAR(8 Bit) und INT (16 Bit) sollten nicht als Grund-
  1188. typen für (einzelne) Variabeln benutzt werden; der Grund dafür sollten
  1189. jetzt wohl klar sein. Trotzdem können sie als Datentypen zum Bilden von
  1190. Arrays benutzt werden. Sie können auch in Objektdefinitionen benutzt wer-
  1191. den, und man kann einen Zeiger auf sie setzen.
  1192.  
  1193. Typen
  1194.  
  1195. }8D.
  1196. -----------------------
  1197. ARRAYs werden über ihre Länge in Bytes definiert:
  1198.  
  1199. DEF b[100]:ARRAY
  1200.  
  1201. dies definiert ein Feld von 100 Bytes. Intern ist b eine Variabel des Typs
  1202. LONG und ein Zeiger auf diesen Speicherbereich. Standardmäßig ist der Typ
  1203. eines Feldelements CHAR, es kann aber jeder andere sein:
  1204.  
  1205. DEF x[100]: ARRAY OF LONG
  1206. DEF mymenus[10]:ARRAY OF newmenu
  1207.  
  1208. wobei "newmenu" ein Beispiel für eine Struktur ist, die in E OBJECT genannt
  1209. werden.
  1210. Der Feldzugriff ist sehr einfach mit <var>[<sexp>]:
  1211.  
  1212. b[1]:="a"
  1213. z:=mymenu[a+1].multiexclude
  1214.  
  1215. Bedenke das der Index eines Felds der Größe n von 0 bis n-1 und nicht von
  1216. 1 bis n geht.
  1217. ARRAY OF <Typ> ist kompatibel mit PRT TO <Typ>, mit dem Unterschied das die
  1218. Variabeln die in einem Feld sind schon eingerichtet.
  1219.  
  1220.  
  1221. Typen
  1222.  
  1223. }8E.
  1224. -------------------------------------
  1225. - STRINGs. Ähnlich den Feldern, sind aber anders, weil sie nur von den E
  1226.   Zeichkettenfunktionen geändert werden können, und das sie Größen- und
  1227.   Maximalgrößenangaben enthalten. So können die E-Funktionen den String
  1228.   auf sichere Art verändern. Z. B.: Der String kann nie größer werden als
  1229.   der Speicherbereich, indem er steht. Definition:
  1230.  
  1231.   DEF s[80]:STRING
  1232.  
  1233.   Der String-Typ ist abwärtskompatibel mit PTR OF CHAR und natürlich mit
  1234.   ARRAY OF CHAR, aber nicht andersherum. Mehr Details im Abschnitt über
  1235.   Zeichenkettenfunktionen.
  1236.  
  1237. - LISTs. Diesen Datentyp gibt es in anderen prozedualen Programmiersprachen
  1238.   nicht, es gibt ihn in Programmiersprachen wie Lisp oder Prolog. Die E-
  1239.   Variante kann als Mischung zwischen STRING und ARRAY OF LONG interpre-
  1240.   tiert werden. Zum Beispiel kann diese Datenstruktur eine Liste von LONG-
  1241.   Variabeln aufnehmen, welche als STRINGs erweitert oder verkürzt werden
  1242.   können. Definition:
  1243.  
  1244.   DEF x[100]:LIST
  1245.  
  1246.   Eine mächtige Erweiterung dieses Typs ist, daß er ein konstantes Gegen-
  1247.   stück [], wie Zeichenketten mit '', hat. LIST ist abwärtskompatibel mit
  1248.   PTR TO LONG und natürlich ARRAY OF LONG, aber nichts andersherum. In
  1249.   Kapitel 2G und 9C steht mehr darüber.
  1250.  
  1251. Typen
  1252.  
  1253. }8F.
  1254. ---------------------------
  1255. OBJECTs sind fast wie eine struct in C oder ein RECORD in Pascal. Beispiel:
  1256.  
  1257. OBJECT meinobject
  1258.     a: LONG
  1259.     b: CHAR
  1260.     c: INT
  1261. ENDOBJECT
  1262.  
  1263. Dies definiert eine Struktur die aus drei Elementen. Syntax:
  1264.  
  1265. OBJECT
  1266.     <Elementname>[:<Typ>]   /*hiervon eine unbeschränkte Zahl*/
  1267. ENDOBJECT
  1268.  
  1269. wobei Typ wieder ein einfacher Typ, ein zusammengesetzter Typ oder ein
  1270. einfacher Feldtyp ist, z. B. [<Elementzahl>]:ARRAY mit der Größe von CHAR
  1271. für ein Element. Bedenke das <Elementname> nicht ein einzigartiger Identi-
  1272. fier sein muß, er kann auch in anderen Objekten enthalten sein. Es gibt
  1273. viele Arten um Objekte zu benutzen:
  1274.  
  1275. DEF x:meinobj               /* x ist eine Strucktur*/
  1276. DEF y:PRT TO meinobj        /* y ist ein Zeiger auf ein Struktur*/
  1277. DEF z[10]:ARRAY OF meinobj
  1278.  
  1279. y:=[-1,"a",100]:meinobj     /*geschriebene Liste*/
  1280. IF y.b="a" THEN /*...*/
  1281. z[4].c:=z[d+1].b++
  1282.  
  1283. ARRAY in Objekten werden immer auf gerade Zahlen gerundet und werden auf
  1284. gerade Offsets gesetzt.
  1285.  
  1286. OBJECT meinstring
  1287.     len:CHAR, daten[9]:ARRAY
  1288. ENDOBJECT
  1289.  
  1290. SIZEOF meinstring ist 12, und "daten" beginnt auf dem Offset 2.
  1291. Bedenke: OBJECTs in E sind nicht so wie sie in anderen Sprachen benutzt
  1292. werden können. Z. B. kann nicht jeder Typ ein Element eines Objekts bilden,
  1293. und deswegen machen rekursive Zugriffe wie x.y.z wenig Sinn (bis jetzt).
  1294.  
  1295. Typen
  1296.  
  1297. }8G.
  1298. ---------------
  1299. 1. Immer mit NIL eingerichtet (oder anders wenn extra angegeben)
  1300.    -Globale Variabel
  1301.     Bedenke: Für Dokumentationszwecke ist es immer besser wnn Du =NIL in
  1302.              Definitionen von Variabeln schreibst, die du als NIL erwartest
  1303. 2. Als '' oder [] eingerichtet:
  1304.    -Globale und lokale STRINGs
  1305.    -Globale und lokale LISTs
  1306. 3. Nicht eingerichtet
  1307.    -Lokale Variabel (wenn nicht extra angegeben)
  1308.    -Globale und lokale ARRAYs
  1309.    -Globale und lokale OBJECTs
  1310.  
  1311. Eingebaute Funktionen
  1312.  
  1313.  
  1314.          }9.EINGEBAUTE
  1315.  
  1316.          A. Ein-/Ausgabeoperationen
  1317.          B. Zeichenketten und Zeichenkettenfunktionen
  1318.          C. Listen und Listen Funktionen
  1319.          D. Intuition unterstützende Funktionen
  1320.          E. Grafikfunktionen
  1321.          F. Systemfunktionen
  1322.          G. Mathematische Funktionen
  1323.          H. Funktionen zum Verbinden von Zeichenketten und Listen
  1324.  
  1325.  
  1326.          Vorheriges Kapitel     Nächstes Kapitel
  1327. Eingebaute Funktionen
  1328.  
  1329. }9A.
  1330. ---------------------------
  1331. WriteF(Formatzeichenkett, Argumente,...)
  1332.  
  1333. schreibt eine Zeichenkette (die Formatcodes enthalten kann) in den stdout.
  1334. Es können von keinem bis zu unendlich vielen Argumenten angefügt werden.
  1335. Bedenke, daß Formatzeichenketten dynamisch erzeugt werden können. Die An-
  1336. zahl der Argumente wird nicht überprüft. Beispiele:
  1337.  
  1338. WriteF('Hallo Welt!\n') /*schreibt nur eine Zeichenkette mit einem Zeilen-
  1339.                           vorschub am Ende*/
  1340. WriteF('a=\d\n',a)      /*schreibt "a=123" wenn a=123 ist*/
  1341.  
  1342. Alles andere mußt Du unter dem Thema Strings nachschauen.
  1343. Wenn stdout=NIList, zum Beispiel wenn Dein Programm von der Workbench ge-
  1344. startet wir, erzeugt WriteF() ein Ausgabefenster, und schreibt den Handle
  1345. in conout und stdout. Dieses Fenster wird am Ende des Programms geschlossen,
  1346. nachdem der Anwender ein <Return> eingegeben hat. WriteF() ist die einzige
  1347. Funktion die dieses Fenster öffnet. als, wenn Du eine Ein-/Ausgabefunktion
  1348. über stdout machen willst, un nicht sicher weißt ob stdout<>NIL benutze ein
  1349. WriteF('') als ersten Befehl deines Programms um die Ausgabe sicher zu
  1350. stellen. Wenn Du selbst ein Consolen-Fenster öffnen willst, solltest Du den
  1351. resultierenden Filehandle in die 'stdout' und 'conout' Variabel schreiben,
  1352. da Dein Fenster so nach dem Programmende automatisch geschlossen wird. Wenn
  1353. Du das Fenster manuelle schließen willst, vergewisser Dich, daß Du 'conout'
  1354. wieder auf NIL gesetzt hast, um E anzuzeigen das es kein Console-Fenster
  1355. gibt, das geschlossen werden muß.
  1356.  
  1357. Out(filehandle, char) und char:=Inp(filehandle)
  1358.  
  1359. Schreibt oder ließt ein einzelnes Byte in/aus einem File oder stdout. Wenn
  1360. char=-1 ist, ist das Ende des Files erreicht oder ein Fehler ist aufgetre-
  1361. ten.
  1362.  
  1363.     len:=FileLength(Namenstring)
  1364.  
  1365. Bestimmt die Länge eines Files, den Du vielleicht laden willst, und gibt
  1366. ebenso an, ob er existiert (gibt -1 zurück, wenn ein Fehler auftritt oder
  1367. der File nicht vorhanden ist.
  1368.  
  1369.     ok:=ReadStr(filehandle, estring)
  1370.  
  1371. siehe Stringunterstützung
  1372.  
  1373.     oldout:=StdOut(newstdout)
  1374.  
  1375. setzt die Standard-Output-Variabel 'stdout' auf den neuen Wert. Gleich mit:
  1376. oldout:=stdout; stdout:=newstdout
  1377.  
  1378. Eingebaute Funktionen
  1379.  
  1380. }9B.
  1381. ---------------------------------------------
  1382. E hat einen Datentyp STRING. Dies ist ein String, von nun an 'EString' ge-
  1383. nannt, der in der Größe modifizier und verändert werden kann, als Gegen-
  1384. stück zu einem normalen 'String', welcher als durch ein Null-Byte beendete
  1385. Zeichenfolge benutzt wird. EStrings sind abwärtskompatibel, aber nicht an-
  1386. dersherum. Also wen ein Argument ein String erfordert, können beide benutzt
  1387. werden. Wenn ein EString erforderlich ist, kann nur ein solcher benutz wer-
  1388. den. Beispiele fü die Anwendung:
  1389.  
  1390. DEF s[80]:STRING    /*s ist ein EString mit einer maximalen Länge von 80
  1391.                       Zeichen*/
  1392. ReadStr(stdout,s)   /*ließt eine Eingabe von der Console*/
  1393. m:=Val(s,N)         /*holt eine Nummer von der Console*/
  1394.  
  1395. Bei allen Zeichenkettenfunktionen bei denen Strings größer werden können
  1396. als ihr Maximum, werden Vorsichtsmaßnahmen getroffen.
  1397.  
  1398. DEF s[6]:STRING
  1399. StrAdd(s,'dieser String ist länger als 6 Zeichen',ALL)
  1400.  
  1401. s wird nur 'dieser' enthalten.
  1402. Ein String kann dynamisch aus dem Systemspeicher mit der Funktion String()
  1403. angefordert werden (der Zeiger hierfür muß auf NIL geprüft werden)
  1404.  
  1405.     s:=String(maxlen)
  1406.  
  1407. DEF s[80] ist gleich mit DEF s und s:=String(10)
  1408.  
  1409.     bool:=StrCmp(string,string,len)
  1410.  
  1411. vergleicht zwei Zeichenketten, len ist die Anzahl der Bytes, die verglichen
  1412. werden sollen, oder All, wenn die ganze Länge überprüft werden soll. Gibt
  1413. True oder False zurück.
  1414.  
  1415.     StrCopy(estring,string,len)
  1416.  
  1417. kopiert den String in EString. Wenn len=ALL ist, wird alles kopiert.
  1418.  
  1419.     StrAdd(estring,string,len)
  1420.  
  1421. genauso wie StrCopy(), nur das der String am Ende angehängt wird.
  1422.  
  1423.     len:=StrLen(string)
  1424.  
  1425. berechnet die Länge eines Strings der durch ein Null-Byte abgeschlossen
  1426. wurde
  1427.  
  1428.     len:=EstrLen(estring)
  1429.  
  1430. gibt die maximale Länge eines EStrings zurück.
  1431.  
  1432.     RightStr(estring,estring,n)
  1433.  
  1434. Füllt den ersten EString mit den letzten n Bytes des zweiten EStrings.
  1435.  
  1436.     MidStr(estring,string,pos,len)
  1437.  
  1438. kopiert jede beliebige Anzahl von Zeichen (alle eingeschloseen, wenn len=
  1439. All) von der Position pos im String in den EString.
  1440. WICHTIG: Bei allen stringverarbeitenden Funktionen ist zu Bedenken, daß das
  1441.          erste Zeichen die Position 0 hat, und nicht 1, wie in normalen
  1442.          Sprachen, wie Basic.
  1443.  
  1444.     wert:=Val(string,read)
  1445.  
  1446. Findet eine Dezimalzahl im ASCII-Code codiert aus einr Zeichenkette. Führen-
  1447. de Leerzeichen/Tabulatoren werden übersprungen. Auch Hexadezimalzahlen
  1448. (1234567890ABCDEFabcdef) und Binärzahlen (01) können so gelesen werden,
  1449. wenn sie von einem "$"- oder "%"-Zeichen angeführt werden. Ein Minuszeichen
  1450. kann eine negative Zahl anzeigen. Val() gibt die Anzahl der gelesenen
  1451. Zeichen im zweiten Argument zurück, welches über Referenz (<-!!!) übergeben
  1452. werden muß. Wenn read den Wert 0 (wert wird auch 0 sein) hat, dann enthält
  1453. der String keine Dezimalzahl, oder der Wert ist zu groß um in 32 Bit auf-
  1454. genommen zu werden. "read" kann NIL sein.
  1455.  
  1456. Beispiel für Zeichenketten die korrekt übersetzt werden:
  1457.  
  1458. '-12345', '%10101010', '-$ABcd12'
  1459.  
  1460. diese würden in "wert" und der Variabel [read] eine 0 zurückgeben:
  1461.  
  1462. '', 'Hallo'
  1463.  
  1464.     findepos:=IntStr(string1, string2, startpos)
  1465.  
  1466. sucht in string1 nach dem Vorkommen von string2. Es kann auch von einer
  1467. anderen Position  als 0 gestartet werden. Zurückgegeben wird die *Addresse*,
  1468. an der der Unterstring gefunden wurde, ansonsten -1.
  1469.  
  1470.     neuestringadr:=TrimStr(string)
  1471.  
  1472. gibt die *Addresse* des ersten Zeichen in einem String, z.B. nach führenden
  1473. Leerzeiche, Tabulatoren usw.
  1474.  
  1475.     UperStr(string)     und     LowerStr(string)
  1476.  
  1477. ändert die Groß- und Kleinschreibung einer Zeichenkette.
  1478. BEACHTE: diese Funktion verändert die Elemente einer Zeichenkette. Deshalb
  1479. sollte man sie nur bei EStrings und Zeichenketten die ein Teil des Codes
  1480. sind verwenden. Effektiv heißt das, daß wenn Du eine Stringaddresse vom
  1481. Betriebssystem bekommen hast, mußt Du diesen erst mit StrCopy() in einen
  1482. String Deines Programms kopieren, und dann erst mit diesem Programm be-
  1483. nutzen.
  1484.  
  1485.     ok:=ReadStr(filehandle, EString)
  1486.  
  1487. ließt eine String (mit ASCII 10 endent) aus einem File oder stdout. ok ent-
  1488. hält -1 wenn ein Fehler festgestellt oder das EOF erreicht wurde.
  1489. Bedenke: Die Elemente des Strings, die bis dahin gelesen wurden sind gültig.
  1490.  
  1491.     SetStr(EString,neuelänge)
  1492.  
  1493. Setzt manuelle die Länge eines Strings. Dies ist nur nützlich, wenn Du Daten
  1494. in einen EString über nicht E-String-Funktionen ließ, und ihn als EString
  1495. weiter benutzen willst. Z. B. nach der Benutzung einer Funktion die nur
  1496. einen Null-Byte-Beendeten String auf die Addresse eines EStrings schreibt,
  1497. benutze SetStr(meinstr,StrLen(meinstr)) um ihn wieder manipulierbar zu
  1498. machen.
  1499. Für String-Zusammenführungsfunktionen siehe Kapitel 9H
  1500.  
  1501. Eingebaute Funktionen
  1502.  
  1503. }9C.
  1504. --------------------------------
  1505. Listen sind wie Strings nur das sie sich aus LONGs und nicht aus CHARs zu-
  1506. sammensetzen. Sie können auch entweder global, lokal oder dynamisch angefor-
  1507. dert werden:
  1508.  
  1509. DEF meineliste[100]:LIST    /*lokal oder global*/
  1510. DEF a
  1511. a:=LIST(10)                 /*dynamisch*/
  1512.  
  1513. (beachte das im letzteren Fall der Zeiger a NIL enthalten kann). Genauso wie
  1514. Strings als Konstanten in Ausdrücken dargestellt werden können, haben Listen
  1515. ihr konstantes Equivalent:
  1516.  
  1517. [1,2,3,4]
  1518.  
  1519. Der Wert eines solchen Ausdrucks ist ein Zeiger auf eine fertig initalisier-
  1520. te Liste. Eine spezielle Eigenschaft ist, das sie dynamische Teile, z. B.,
  1521. welche während der Laufzeit gefüllt werden:
  1522.  
  1523. a:=3
  1524. [1,2,a,4]
  1525.  
  1526. außerdem können Listen auch einige andere Typen als die Voreinstellung LONG
  1527. enthalten, wie:
  1528.  
  1529. [1,2,3]:INT
  1530. [65,66,67,0]:CHAR               /*gleich mit 'ABC' *
  1531. ['topaz.font',8,0,0]:textattr
  1532. OpenScreenTagList(NIL,[SA_TITEL,'MeinScreen',TAG_DONE])
  1533.  
  1534. Wie im letzten Beispiel gezeigt, sind Listen extrem nützlich bei der Benut-
  1535. zung von Systemfunktionen: Sie sind abwärtskompatibel mit einem ARRAY OF
  1536. LONG, und auf ein Objektzeigende können überall dort benutzt werden, wo eine
  1537. Systemfunktion einen benutzt werden, wo eine Systemfunktion einen Zeiger auf
  1538. einige Strukturen oder ein Feld von Zeigern benötigt. Taglist und vararg-
  1539. Funktionen können auch auf diese Weise benutzt werden.
  1540. BEACHTE: Alle Funktionen arbeiten nur mit LONG Listen, typenzugeordnete
  1541.          Listen sind nur geeignet um komplexe Datenstrukturen und Ausdrücke
  1542.          aufzubauen.
  1543.  
  1544. Wie bei Strings gibt es eine klare Hierachie.
  1545.  
  1546. Listen Variabeln -> Konstante Liste -> Feld von Longs/Zeiger auf Longs
  1547.  
  1548. Wenn eine Funktion ein Feld von Longs braucht, kannst Du auch eine Liste als
  1549. Argument angegeben. Wenn aber eine Funktion eine Listenvariabel oder eine
  1550. konstante Liste braucht, reicht ein Feld von Longs nicht aus.
  1551.  
  1552. Es ist wichtig, daß Du die Mächtigkeit von Listen besonders typenorien-
  1553. tierter verstehst: dis kann Dir viel Ärger beim Aufbau irgendeiner Daten-
  1554. struktur ersparen. Versuche diese Listen in Deinen eigenen Programmen zu
  1555. benutzen und schauen  welche Funktion sie in den Beispielprogrammen haben.
  1556. Wenn Du Listen einmal im Griff hast, möchtest Du niemals ein Programm ohne
  1557. sie schreiben.
  1558.  
  1559. Zusammenfassung:
  1560.  
  1561. [<Element>, <Element>,...]          direkte Liste (von LONGs, Benutzung mit
  1562.                                     Listenfunktion
  1563. [<Element>, <Element>,...]:<Typ>    Typenorientierte Liste (nur um Daten-
  1564.                                     strukturen zu bauen)
  1565.  
  1566. Wenn <Typ> ein einfacher Typ wie INT oder CHAR ist, hast Du nur das einge-
  1567. richtete Gegenstück zu ARRAY OF <Typ> ein Objektname ist erzeugst Du ein
  1568. eingerichtetes Objekt oder ARRAY OF <Objekt>, sich auf die Länge der Liste
  1569. stützend.
  1570.  
  1571. Wenn Du schreibst [1,2,3]:INT erzeugst Du eine Datenstruktur von 6 Bytes,
  1572. von 3 16 Bit Werten um genau zu sein. Der Wert eines solchen Ausdrucks ist
  1573. dann ein Zeiger zu einem Speicherbereich um genau zu sein. Es funktoniert
  1574. z. B. mit einem Objekt.
  1575.  
  1576. OBJECT meinobjekt
  1577.     a:LONG, b:CHAR, c:INT
  1578. ENDOBJECT
  1579.  
  1580. wenn Du jetzt schreibst:  [1,2,3]:meinobjekt würde dann eine Datenstruktur
  1581. von 8 Bytes im Speicher erstellen. Diese ersten vier Byte sind eine LONG-
  1582. Zahl mit dem Wert 1, das folgende Byte ist ein CHAR mit dem Wert 2, dann
  1583. ein Füllbyte, um die Wort-Anordnung zu erhalten (16 Bit). Es ist trotzdem
  1584. sehr wahrscheinlich, daß ein E-Compiler für eine 80x86 Architektur das Füll-
  1585. byte nicht nutzen wird und eine 7 Byte Struktur erzeugen wird. Und ein E-
  1586. Compiler für eine Sun-Sparc Architektur (wenn ich mich nicht vertue) wird
  1587. versuchen alles auf 32 Bit Grenzen zu stzen, so macht er eine 10 oder 12
  1588. Byte Struktur. Einige Mikroprozessoren (sie sind selten aber es gibt sie)
  1589. benutzen sogar (36:18:9) als Anzahl von Bits für ihre Typen (LONG:INT:CHAR)
  1590. anstatt von (32:16:8) wie wir es gewöhnt sind. Mache Dir kein zu großen
  1591. Vorstellungen der Struktur eines OBJECTS oder einer LISTe, wenn Du Code
  1592. schreiben willst, der eine Chance haben soll portabel zu sein oder sich auf
  1593. Seiteneffekte zu verlassen.
  1594.  
  1595.     ListCopy(Listenvar,Liste,Anzahl)
  1596.  
  1597. Kopiert Anzahl Elemente aus Liste in die Listenvar. Beispiel:
  1598.  
  1599. DEF meineliste[10]:LIST
  1600. ListCopy(meineliste,[1,2,3,4,5],ALL)
  1601.  
  1602.     ListAdd(Listenvariabel, Liste, Anzahl)
  1603.  
  1604. Kopiert Anzahl Elemente von Liste an die erste nicht belegte Stelle von
  1605. Listenvariabel
  1606.  
  1607.     ListCmp(Liste, Liste, Anzahl)
  1608.  
  1609. Vergleicht zwei Listen, oder Anzahl Teile von ihnen.
  1610.  
  1611.     länge:=ListLen(Liste)
  1612.  
  1613. Gibt die Länge der Liste zurück, wie ListLen([a,b,c]) 3 zurückgeben würde.
  1614.  
  1615.     maximum:=ListMax(Listenvariabel)
  1616.  
  1617. Gibt die maximal mögliche Listenlänge von Listenvariabel zurück.
  1618.  
  1619.     wert:=ListItem(Liste,Index)
  1620.  
  1621. funktioniert wie wert:=Liste[Index] mit dem Unterschied, daß Liste ein kon-
  1622. stanter Wert anstatt eines Zeiger sein kann. Dies kann in Situationen sehr
  1623. nützlich sein, in denen wir direkt ein Liste von Werten benutzen wollen:
  1624.  
  1625. WriteF(ListItem(['ok','kein Speicher','keine Datei'],fehler))
  1626.  
  1627. Es verhält sich wie:
  1628.  
  1629. dummy:=['ok','kein Speicher','keine Datei']
  1630. WriteF(dummy[fehler])
  1631.  
  1632.     SetList(Listenvariabel, neuelänge)
  1633.  
  1634. setzt manuell die Länge einer Liste. Dies is nur nützlich, wenn Du mit nicht
  1635. listenspezifischen Funktionen Daten in eine Liste schreibst, sie aber als
  1636. richtige Liste weiterverwenden willst.
  1637.  
  1638. Für Listenfunktion, die ausgewertete Ausdrücke benutzen siehe Kapitel 11C.
  1639. Für Listenverbindungsfunktionen siehe Kapitel 9H
  1640.  
  1641.  
  1642. Eingebaute Funktionen
  1643.  
  1644. }9D.
  1645. ---------------------------------------
  1646.     wptr:=OpenW(x,y,Breite,Höhe,IDCMP,WFlags,Titel,Screen,SFlags,Gadgets)
  1647.  
  1648. erzeugt ein Fenster, wobei WFlags die Flags für das Windowlayout sind (wie
  1649. BACKDROP, SIMPLEREFRESH usw, normalerweise $F) und SFlags ist da um die
  1650. Screenart zu bestimmen auf der das Fenster geöffnet werden soll (1=WB,
  1651. 15=Custom). Screen muß nur gültig sein, wenn SFlags=15, ansonsten reicht
  1652. NIL. Gadgets kann auf eine GList-Struktur zeigen, welche einfach mit Gad-
  1653. get() erzeugt werden kann, ansonsten NIL.
  1654.  
  1655.     CloseW(wptr)
  1656.  
  1657. schließt das Fenster wieder. Der einzige Unterschied zu CloseWindow ist
  1658. das es NIL-Zeiger akzeptiert und den stdrast wieder auf NIL setzt.
  1659.  
  1660.     sptr:=OpenS(Weite,Höhe,Tiefe,SFlags,Titel)
  1661.  
  1662. Öffnet einen Customscreen. Tiefe ist die Anzahl der Bitplanes (1-6, 1-8
  1663. AGA), SFlags ist etwas wie 0, oder $8000 für Hires (addiere 4 für Interlace)
  1664.  
  1665.     CloseS(sptr)
  1666.  
  1667. wie CloseW(), nun für Screens.
  1668.  
  1669.     nächsterbuffer:=Gadget(buffer,glist,id,flags,x,y,Breite,string)
  1670.  
  1671. Diese Funktion erstellt eine Liste von Gadgets, welche in Deinem Fenster
  1672. angezeigt werden können, in dem Du sie als Argument bei OpenW() als Argu-
  1673. ment übergibst. Später kannst Du das auch mit der Intuitionfunktion
  1674. AddGlist() erledigen.
  1675. Bufer ist meistens ein ARRAY on mindestens der GrößeGADGETSIZE Bytes um alle
  1676. Strukturen die zu einem Gadget gehören aufzunehmen. ID ist eine beliebige
  1677. Nummer die Dir helfen soll später zu erkennen welches Gadget gedrückt wurde,
  1678. wenn ine IntuiMessage ankommt. Flags sind 0=normal, 1=Boolean Gadget, 3=
  1679. Boolean Gadget das ausgewählt ist. Width ist die Weite in Pixeln, die groß
  1680. genug sein sollte um den String aufzunehmen, welcher automatisch zentriert
  1681. wird. Glist sollte beim ersten Gadget NIL sein, und glistvar für alle ande-
  1682. ren, so kann E alle Gadget zusammenlinken. Die Funktion gibt einen Zeiger
  1683. auf den nächsten Buffer zurück (=buffer+GADGETSIZE). Beispiel für 3 Gadgets:
  1684.  
  1685. CONST   MAXGADGETS=GADGETSIZE*3
  1686.  
  1687. DEF buf[MAXGADGETS]:ARRAY, next, wptr
  1688.  
  1689. next:=Gadget(buf,NIL,1,0,10,20,80,'bla' /*das erste Gadget*/
  1690. next:=Gadget(next,buf...)
  1691. next:=Gadget(next,buf...)    /*jede Anzahl kann zum ersten gelinkt werden*/
  1692.  
  1693. wptr:=OpenW(...,buf)
  1694.  
  1695. Schaue Dir die richtigen Beispiele wie SuperVisor.e für richtige Anwendugen
  1696. an.
  1697.  
  1698.     code:=Mouse()
  1699.  
  1700. gibt Dir den momentanen Status von allen 2 oder 3 Mausknöpfen zurück, links
  1701. =1, rechts=2 und mitte=4. Wenn der Code z.B. gleich 3 ist, sind die linke
  1702. und die rechte Maustaste gedrückt.
  1703. WICHTIG: die ist keine richtige Inituition-Funktion, wenn Du auf regulären
  1704. Weg etwas über die Maus-Events erfahren willst, muß Du die IntuiMessages
  1705. kontrollieren, die an Deinem Window ankommen. Das ist die einezige E-Funk-
  1706. tion die direkt auf die Hardware zugreift, und ist deshalb nur für demo-
  1707. artige Programme nützlich:
  1708.  
  1709.     x:=MouseX(win)       und     y:=MouseY(win)
  1710.  
  1711. ermöglicht es Dir die Mauskoordinaten zu lesen. Win ist das Window zu dem
  1712. sie relativ sind.
  1713.  
  1714.     class:=WaitIMessage(window)
  1715.  
  1716. Diese Funktion macht es einfacher auf ein Window-Event zu warten. Es spei-
  1717. chert andere Variabeln wie Cod und Qualifiers als private, globale Varia-
  1718. beln, für den Zugriff mit Funktionen, die unten beschrieben werden.
  1719. WaitIMessage() representiert folgenden Code:
  1720.  
  1721. PROC waitimessage(win:PTR TO window)
  1722.   DEF port,mes:PTR TO intuimessage,class,code,qual,iaddr
  1723.   port:=win.userport
  1724.   IF (mes:=GetMsg(port))=NIL
  1725.     REPEAT
  1726.       WaitPort(port)
  1727.     UNTIL (mes:=GetMsg(port))<>NIL
  1728.   ENDIF
  1729.   class:=mes.class
  1730.   code:=mes.code             /* intern abgespeichert */
  1731.   qual:=mes.qualifier
  1732.   iaddr:=mes.iaddress
  1733.   ReplyMsg(mes)
  1734. ENDPROC class
  1735.  
  1736. wie Du siehst, holt es exakt eine Nachricht, und vergißt keinen mehrfach
  1737. Message, die bei einem Ereigniss ankommt. Wenn mehr als ein Aufruf erfolgt.
  1738. Zum Beispiel, sagen wir Du hast ein Window geöffnet, das etwas anzeigt, und
  1739. nur auf das Cosegadget wartet (Du hast nur IDCMP_CLOSEWINDOW angegeben):
  1740.  
  1741.     WaitMessage(meinwindow)
  1742.  
  1743. oder Du hast ein Programm das auf mehrere Arten von Events wartet, sie in
  1744. einer Schleife bearbeitet, un mit einem Closewindow-Event endet:
  1745.  
  1746. WHILE (class:=WaitIMessag(win))<>IDCMP_CLOSWINDOW
  1747.     /*Bearbeitung der anderen Klassen */
  1748. ENDWHILE
  1749.  
  1750.     code:=MsgCode()     qual:=MsgQualifier()    iaddr:=MsgIaddr()
  1751.  
  1752. Dies alles versorgt Dich mit den privaten globalen Variabel, die vorher er-
  1753. wähnt wurden. Die Werte die zurückgegeben werden, wurden alle vom letzten
  1754. Aufruf von WaitIMessage() definiert. Beispiel:
  1755.  
  1756. IF class:=IDCMP_GADGETUP
  1757.     mygadget:=MsgIaddr()
  1758.     If mygadget.userdata=1 THEN     /* der Anwender hat Gadget #1 gedrückt*/
  1759. ENDIF
  1760.  
  1761. Eingebaute Funktionen
  1762.  
  1763. }9E.
  1764. --------------------
  1765. Alle grafikunterstützenden Funktionen, die nicht extra einen Rastport ver-
  1766. langen, benutzen die System-Variabel 'stdrast'. Sie wird automatisch vom
  1767. letzten Aufruf von OpenW() oder OpenS() definiert, und wird von CloseW()
  1768. und CloseS() auf NIL gesetzt. Der Aufruf dieser Routinen, während 'stdrast'
  1769. NIL ist, ist erlaubt. stdrast kann manuelle über SetStdRast() oder stdrast:=
  1770. meinrast geändert werden.
  1771.  
  1772.     Plot(x,y,Farbe)
  1773.  
  1774. Malt einen einzelnen Punkt auf Deinem Screen/Window in einer der verfügbaren
  1775. Farben. Die Farbe geht von 0-255, oder 0-31 auf vor-AGA Maschinen.
  1776.  
  1777.     Line(x1,y1,x2,y2,Farbe)
  1778.  
  1779. Malt eine Linie.
  1780.  
  1781.     Box(x1,y1,x2,y2,Farbe)
  1782.  
  1783. Malt ein Rechteck.
  1784.  
  1785.     Colour(Vordergrund, Hintergrund)
  1786.  
  1787. setzt die Farbe für alle Grafikfunktionen (aus dem Library), die kein Farb-
  1788. argumente annehmen. Dies ist das *Farbregister* (z.B. 0-31) und nicht der
  1789. *Farbwert*.
  1790. BEACHTE: Funktionen, die ein "Farbe" als Argument haben, verändern den Apen
  1791. des stdrast.
  1792.  
  1793.     TextF(x,y,Formatstring,args,....)
  1794.  
  1795. hat genau dieselbe Funktion wie WriteF(), nur an irgendeiner (x,y) Position
  1796. in deinem stdrast, anstatt von stdout. Siehe auch WriteF() und Strings in
  1797. der Sprachbeschreibung.
  1798.  
  1799.     alterrast:=SetStdRast(neuerrast)
  1800.  
  1801. verändert den Ausgaberastprot der E-Grafik-Funktionen.
  1802.  
  1803.     SetTopaz(größe)
  1804.  
  1805. setzt den Font des Rastport "stdras" auf Topaz, nur um sicher zu sein, daß
  1806. einige Custom-Fonts des Anwenders nicht unser Bildschirmlayout durchein-
  1807. ander werfen. Größe ist natürlich 8 oder 9.
  1808.  
  1809. Eingebaute Funktionen
  1810.  
  1811. }9F.
  1812. --------------------
  1813.  
  1814.     bool:=KickVersion(vers)
  1815.  
  1816. Gibt TRUE zurück, wenn die Kickstart in der Maschine, auf der Dein Programm
  1817. läuft, gleich oder größer ist, ansonsten FALSE.
  1818.  
  1819.     mem:=New(n)
  1820.  
  1821. Dies erzeugt dynamisch ein Feld (oder Speicherbereich, wenn Du möchtest) von
  1822. n Bytes. Unterschiede zu AllocMem() sind, daß es automatisch die Flaggs
  1823. $10000 (also gelöschter Speicher, jeder Typ) angibt und keine Dispose()
  1824. Aufrufe notwendig sind, da es an eine Speicherliste angefügt wird, die auto-
  1825. matisch am Ende des Programms freigegeben wird.
  1826.  
  1827.     Dispose(mem)
  1828.  
  1829. Gibt jedes mem frei, das durch New() angefordert wurde. Du muß diese Funk-
  1830. tion nur benutzen, wenn Speicher während des Programmablaufs freigegeben
  1831. werden soll, da es am Ende sowieso freigegeben wird.
  1832.  
  1833.     CleanUp(Rückgabewert)
  1834.  
  1835. Beendet das Programm von jeden Punkt. Es ist der Ersatzt für den DOS-Aufruf
  1836. Exit(): benutze diesen niemals!!!!!! anstatt von CleanUp(), welcher es
  1837. ermöglicht Speicher freizugeben, Libraries richtig zu schließen usw. Der
  1838. Rückgabewert wird als Returncode an DOS zurückgegeben.
  1839.  
  1840.     menge:=FreeStack
  1841.  
  1842. gibt die Menge des freien Stackspeichers zurück. Diese sollte immer 1000
  1843. oder mehr betragen. Siehe in Kapitel 16 wie E seinen Stack organisiert.
  1844. Wenn Du nicht im Rekursionswahn bist, brauchst Du Dir über den freien Stack-
  1845. Speicher keine Sorgen zu machen.
  1846.  
  1847.     bool:=CtrlC()
  1848.  
  1849. Gibt TRUE zurück, wenn Ctrl-C nach der letzten Überprüfung gedrückt wurde,
  1850. ansonsten FALSE. Dies arbeitet nur mit Programmen, die über die Console
  1851. laufen, d.h. CLI-Programme.
  1852.  
  1853. /*berechnet die Fakultät des CLI-Arguments*/
  1854.  
  1855. OPT STACK=100000
  1856.  
  1857. PROC main()
  1858.   DEF num,r
  1859.   num:=Val(arg,{r})
  1860.   IF r=0 THEN WriteF('Argumentfehler.\n') ELSE WriteF('Wert: \d\n',fac(num))
  1861. ENDPROC
  1862.  
  1863. PROC fac(n)
  1864.   DEF r
  1865.   IF FreeStack()<1000 OR CtrlC() THEN CleanUp(5)    /* Extra Controlle */
  1866.   IF n=1 THEN r:=1 ELSE r:=fac(n-1)*n
  1867. ENDPROC r
  1868.  
  1869. Natürlich wird diese Rekursion kaum den Stack zum überlaufen bringen, und
  1870. wenn dies passiert, wird es so schnell von FreeStack() angehalten, das Du
  1871. keine Zeit hast Ctrl-C zu drücken, aber es ist die Idee die hier zählt.
  1872. Eine Definition von fac(n) wie:
  1873.  
  1874. Proc fac(n) RETURN IF n=1 THEN 1 ELSE fac(n-1)*n
  1875.  
  1876. wäre nicht so sicher.
  1877.  
  1878. Eingebaute Funktionen
  1879.  
  1880. }9G.
  1881. ----------------------------
  1882.  
  1883.     a:=And(b,c)     a:=Or(b,c)      a:=Not(b)
  1884.     a:=Eor(b,c)
  1885.  
  1886. Diese arbeiten mit den normalen Operatoren, boolschen genauso wie aritme-
  1887. thische. Beachte, daß für And() und Or() Operatoren existieren:
  1888.  
  1889.     a:=Mul(b,c)     a:=Div(a,b)
  1890.  
  1891. Macht dasselbe wie die '*' und '/' Operatoren, aber jetzt mit vollen 32 Bit.
  1892. Aus Geschwindigkeitsgründen sind normale Operationen 16 Bit * 16 Bit =
  1893. 32 bit und 32 Bit/ 16 Bit = 16 Bit. Dies reicht für fast alle Rechnungen aus
  1894. und wo nicht, kannst Du Mul() und Div() benutzen. BEACHTE: im Fall von Div()
  1895. wird a durch b geteilt und nicht umgekehrt.
  1896.  
  1897.     bool:=Odd(x)        bool:=Even(x)
  1898.  
  1899. Gibt TRUE oder FALSE zurück wenn ein Ausdruck gerade oder ungerade ist.
  1900.  
  1901.     randnum:=Rnd(max)   seed:=RndQ(seed)
  1902.  
  1903. Rnd() berechnet eine Zufallszahl aus einer Internen seed im Raum von 0..
  1904. max-1. Zum Beispiel, Rnd(1000) gibt eine Dezimalzahl von 0..999 zurück. Um
  1905. die Interne  Quelle zu Initalisieren, rufe Rnd() mit einem negativen Wert
  1906. auf. Der Abs() dieses Werts wird dann als Ursprungs'seed' genommen.
  1907. RndQ() berechnet eine Zufallszahl schneller als Rnd(), aber gibt nur ganze
  1908. 32 Bit Zufallszahlen zurück. Benutze das Ergebniss als seed für den nächsten
  1909. Aufruf, und als Anfangs'seed' benutze einen großen Wert wie $AGF87EC1
  1910.  
  1911.     abswert:=Abs(wert)
  1912.  
  1913. berechnet den absoluten Wert.
  1914.  
  1915.     a:=Mod(b,c)
  1916.  
  1917. Dividiert 32 Bit b durch 16 Bit c und gibt den 16 Bit Modulo a zurück.
  1918.  
  1919.     x:=Shl(y,num)       x:=Shr(y,num)
  1920.  
  1921. Schiebt y um num Bits nach links oder nach rechts.
  1922.  
  1923.     a:=Long(adr)        a:=Int(adr)     a:=Char(adr)
  1924.  
  1925. Ließt aus einer Speicheraddresse einen Wert und gibt ihn zurück. Dies geht
  1926. mit 32, 16 und 8 Bit Werten in dieser Reihenfolge. Der Compiler überprüft
  1927. nicht ob die Addresse gültig ist. Diese Funktionen sind in E verfügbar für
  1928. den Fall, daß das Lesen und Schreiben im Speicher mit PTR TO <Typ> das Pro-
  1929. gramm nur noch komplexer und uneffizienter machen würde. Du solltest aber
  1930. nicht dazu ermutigt werden, diese Funktionen zu benutzen.
  1931.  
  1932.     PutLong(adr,a)      PutInt(adr,a)       und     PutChar(adr,a)
  1933.  
  1934. Poket (schreibt) den Wert 'a' in den Speicher, Siehe auch Long()
  1935.  
  1936. Eingebaute Funktionen
  1937.  
  1938. }9H.
  1939. ---------------------------------------------------------
  1940.  
  1941. E ist mit einer Reihe von Funktionen ausgestattet, die die Erstellung von
  1942. verketteten Listen mit dem STRING und LIST Datentyp, oder Strings und
  1943. Listen, die mit String() und List() erstellt wurden, erlaubt. Wie Du viel-
  1944. leicht weißt, sind Listen, Strings, komplexe Datentypen Zeiger auf ihre
  1945. verschiedenen Daten, und haben ein extra Feld an einem negativen Offset
  1946. dieses Zeigers die ihre aktuelle und ihre maximale Länge enthält. Die Off-
  1947. sets dieses Feld sind PRIVATE. Als Zusatzt zu diesen beiden, hat jeder
  1948. komplexe Datentyp ein 'next' Feld, welches Defaultmäßig auf NIL gesetzt ist.
  1949. Dieses kann benutzt werden, um verkettete Listen zu erzeugen, z.B. von
  1950. Strings. Ab jetzt verstehe ich unter komplex einen ptr auf einen STRING
  1951. oder eine LISTe, und unter 'tail' noch einen solchen Zeiger, oder einen
  1952. der schon einen solchen String anghängt hat. 'tail' kann auch ein NIL Zeiger
  1953. sein, der das Ende einer verketteten Liste anzeigt. Die folgenden Funktionen
  1954. können benutzt werden.
  1955.  
  1956.     komplex:=Link(komplex,tail)
  1957.  
  1958. schreibt den Wert von tail in das 'next'-Feld von komplex. Beispiel:
  1959.  
  1960. DEF s[10]:STRING, t[10]:STRING
  1961. Link(s,t)
  1962.  
  1963. erzeugt eine verkettete Liste wie: s-->t-->NIL
  1964.  
  1965.     tail:=Next(komplex)
  1966.  
  1967. ließt das 'next' Feld einer komplexen Variabel. Dies kann natürlich NIL
  1968. sein, oder eine komplett verkettete Liste. Next(NIL) aufrufen ergibt NIL,
  1969. so ist es sicher Next aufzurufen, wnn man sich nicht sicher ist ob man am
  1970. Ende einer verketteten Liste ist.
  1971.  
  1972.     tail:=Forward(c,1)
  1973.  
  1974. genau dasselbe, geht nur um num Links vorwärts, anstatt von einem, also:
  1975.  
  1976. Next(c)=Forward(c,1)
  1977.  
  1978. Du kannst Forward sicher mit Nummern aufrufen, die zu weit gehen; Forward
  1979. hält an sobald es ein NIL beim suchen eines Links entdeckt und gibt NIL
  1980. zurück.
  1981.  
  1982.     DisposeLink(complex)
  1983.  
  1984. dasselbe wie Dispose(), mit dem Unterschied: es ist nur für Strings und
  1985. Listen die mit String() und List() angefordert wurden, und entfernt auto-
  1986. matisch den 'tail' eines komplexen Datentyps. Beachte, daß in große verket-
  1987. teten Listen, die Strings enthalten, die sowohl mit String() als auch einige
  1988. lokal und global mit STRING allociert wurden können auch auf diese Art
  1989. freigegeben werden.
  1990.  
  1991. Für ein gutes Beispiel, wie man Listen von Strings gut im wirklichen Leben
  1992. gebrauchen kann, siehe 'D.e'.
  1993.  
  1994. Library Funktionen und Module
  1995.  
  1996.  
  1997.          }10.LIBRARY
  1998.  
  1999.          A. Eingebaute Library Aufrufe
  2000.          B. Schnittstellen zum Amiga Sytem mit den 2.04 Modulen bilden
  2001.  
  2002.  
  2003.  
  2004.          Vorheriges Kapitel     Nächstes Kapitel
  2005. Library Funktionen und Module
  2006.  
  2007. }10A.
  2008. -------------------------------
  2009. Wie Du vielleicht schon aus den vorherigen Abschnitten weißt, wird vor Dein
  2010. Programm automatisch um ein Programmteil (der "initialisation code") ergänzt,
  2011. der beim Programmstart immer folgende vier Bibliotheken öffnet: Intuition,
  2012. Dos, Graphics und Mathffp. Daher sind die Funktionsaufrufe zu diesen fünf
  2013. Bibliotheken (Exec eingeschlossen) im Compiler integriert (es sind einige
  2014. Hundert). Jedenfalls bis zu AmigaDos v2.04, v3.00 sollte bis zur nächsten
  2015. Version von Amiga E implementiert sein. Um Open() von der dos.library
  2016. aufzurufen, genügt ein schlichtes:
  2017.  
  2018. handle:=Open('meinedatei',OLDFILE)
  2019.  
  2020. oder AddDisplayInfo() von graphics.library:
  2021.  
  2022. AddDisplayInfo(meindispinfo)
  2023.  
  2024. So einfach ist das.
  2025.  
  2026. Library Funktionen und Module
  2027.  
  2028. }10B.
  2029. ---------------------------------------------------------------
  2030. Um eine beliebige andere Bibliothek als die fünf im vorherigen Abschnitt
  2031. genannten zu benutzen, mußt Du Module wählen. Du brauchst auch Module, wenn
  2032. Du - wie in C oder Assembler üblich - OBJECT oder CONST Definition aus den
  2033. Amiga-Includes benutzt. Module sind Binärdateien, die Definitionen von
  2034. Konstanten, Objekten, Bibliotheken und Funktionen (code) beinhalten können.
  2035. Die Tatsache, daß sie binär vorliegen, hat den ASCII-Dateien (benutzt in C
  2036. und Assembler) gegenüber den Vorteil, daß sie nicht jedesmal neu compiliert
  2037. werden müßen, wenn Dein Programm neu compiliert wird. Der Nachteil ist, daß
  2038. man sie sich nicht einfach anschauen kann; um ihren Inhalt sichtbar zu
  2039. machen, ist ein Utility wie ShowModule (siehe utility.doc) nötig. Die
  2040. Module, die die Bibliotheksdefinitionen (d.h. deren Aufrufe) enthalten,
  2041. stehen im Wurzelverzeichnis von emodules: (dem Modul-Verzeichnis in der
  2042. Distribution), die Definitionen der Konstanten/Objekte befinden sich in den
  2043. Unterverzeichnissen, sie sind wie die Originale von Commodore aufgebaut.
  2044.  
  2045.  
  2046. MODULE
  2047.  
  2048. Sytax:          MODULE <Modulname>,...
  2049. Lädt ein Modul. Ein Modul ist eine Binärdatei, die Informationen über
  2050. Bibliotheken, Konstanten und manchmal auch Funktionen enthält. Durch
  2051. Modulbenutzung ist es Dir möglich, Bibliotheken und Funktionen zu benutzen,
  2052. die dem Compiler vorher nicht bekannt waren.
  2053.  
  2054. Nun zu einem Beispiel, unten steht ein kleine Version des Sources
  2055. sources/examples/asldemo.e, das Module verwendet, um einen Filerequester
  2056. der 2.0 Asl.library darzustellen.
  2057.  
  2058.  
  2059. MODULE 'Asl', 'libraries/Asl'
  2060.  
  2061. PROC main()
  2062.   DEF req:PTR TO filerequestr
  2063.   IF aslbase:=OpenLibrary('asl.library',37)
  2064.     IF req:=AllocFileRequest()
  2065.       IF RequestFile(req) THEN WriteF('File: "\s" in "\s"\n',req.file,req.dir)
  2066.       FreeFileRequest(req)
  2067.     ENDIF
  2068.     CloseLibrary(aslbase)
  2069.   ENDIF
  2070. ENDPROC
  2071.  
  2072.  
  2073. Aus dem Modul 'asl' erfährt der Compiler die Definitionen der
  2074. asl-Funktionen, wie zum Beispiel RequestFile(), und die globale Variable
  2075. 'aslbase', die vom Programmierer lediglich initialisiert werden muß. Aus
  2076. 'libraries/asl' erfährt er die Definition des Objektes filerequestr, das
  2077. wir benutzen, um zu erfahren, welche Datei der Anwender ausgewählt hat.
  2078. Das war doch nun wirklich nicht schwer: hast Du gedacht, daß es so einfach
  2079. wäre, einen Filerequester in E zu programmieren?
  2080.  
  2081.  
  2082. Ausgewertete Ausdrücke
  2083.  
  2084.  
  2085.          }11.AUSGEWERTETE
  2086.  
  2087.          A. Auswertung und Bereich
  2088.          B. Eval()
  2089.          C. Eingebaute Funktionen
  2090.  
  2091.  
  2092.          Vorheriges Kapitel     Nächstes Kapitel
  2093. Ausgewertete Ausdrücke
  2094.  
  2095. }11A.
  2096. ---------------------------
  2097. Quotierte Ausdrücke beginnen mit dem Hochkomma. Der Wert eines ausgewerteten
  2098. Ausdrucks ist nicht das Ergebniss von einer Berechnung eines Ausdrucks, son-
  2099. dern die Adddresse des Codes. Dieses Ergebniss kann als eine normale Varia-
  2100. bel weiterverwendet werden, oder als ein Argument für bestimmte Funktionen.
  2101.  
  2102. meinefunk:=`x*x*x
  2103.  
  2104. meinefunk ist nun ein Zeiger auf eine Funktion die x^3 berechnet, wenn sie
  2105. berechnet wird. Diese Zeiger auf Funktionen sind sehr unterschiedlich zu
  2106. normalen PROCs, und Du solltest die beiden nie durcheinander bringen. Die
  2107. größten Unterschiede sinde, daß quotierte Ausdrücke nur einfache Ausdrücke
  2108. sind, und deshalb keine eigenen lokalen Variabeln haben kann. In unserem
  2109. Beispiel ist "x" nur eine lokale oder globale Variabel. Das ist warum vor-
  2110. sicht sein muß: Wenn meinefunk irgendwo später gleichen PROC auswertest,
  2111. kann x lokal sein, aber wenn meinefunk als Parameter an einen anderen PROC
  2112. übergibst, und dann auswertest, muß x natürlich global sein. Es gibt keine
  2113. Bereichsprüfung hierbei.
  2114.  
  2115. Ausgewertete Ausdrücke
  2116.  
  2117. }11B.
  2118. -----------
  2119.     Eval(funk)
  2120.  
  2121. wertet einfach einen quotierten Ausdruck (exp=Eval('exp)) aus.
  2122. BEDENKE: Weil E eine etwas typenlose Sprache ist, wird vom Compiler dummer-
  2123. weise nicht bemerkt, wenn wir "Eval(x*x)" anstatt von "Eval(`x*x)" schrei-
  2124. ben, und das macht Dir große Laufzeitprobleme: der Wert von x*x wird als
  2125. Zeiger auf Code benutzt.
  2126. Um zu verstehen warum "quotierte Ausdrücke" so mächtig sind, danke an die
  2127. folgenden Fälle: wenn Du eine Reihe von Aktionen mit einer Reihe von Varia-
  2128. beln abarbeiten mußt, schreibst Due eine Funktion und rufst die Funktion
  2129. mit verschiedenen Argumenten auf. Aber was ist, wenn das Argument ein Teil
  2130. des Codes ist. In traditionellen Programmiersprachen wäre dies nicht mög-
  2131. lich, so müßtest Du die Blöcke die Deine Funktion repräsentieren "kopieren",
  2132. und dann den Ausdruck hineinschreiben. Nicht in E. Sagen wir, Du möchtest
  2133. ein Programm schreiben, das die Arbeitungszeit von verschiedenen Ausdrücken
  2134. vergleicht. In E würdest Du einfach nur schreiben:
  2135.  
  2136. PROC timing(funk,titel)
  2137.  
  2138.     /*macht alle Dinge um die Zeit zu stellen+/
  2139.  
  2140.     Eval(funk)
  2141.  
  2142.     /*und den Rest*/
  2143.  
  2144.     Write('Die gemessene Zeit von \s war \d\n',titel,t)
  2145.  
  2146. ENDPROC
  2147.  
  2148. und rufen es auf mit:
  2149.  
  2150. timing (`x*x*x,'Multiplication')
  2151. timing (`großeberechnung(),'Große Rechnung')
  2152.  
  2153. in jeder anderen Befehlssprache, müßtest Du für jeden timing-Aufruf eine Ko-
  2154. pie schreiben, oder Du müßtest jeden Ausdruck in eine seperate Funktion
  2155. schreiben. Dies ist nur ein einfaches Beispiel: denke daran, was Du mit Da-
  2156. tenstrukturen (LISTs) mit unausgewerteten Code machen kannst.
  2157.  
  2158. malfunks:   [`Plot(x,y,c), `Line(x,y,x+10,y+10,c), `Box(x,y,x+20,y+20,c)]
  2159.  
  2160. Die Idee von Funktionen als normale Variabeln/Werten ist keine Neuheit von
  2161. E. Quotierte Ausdrücke wurden von LISP beschrieben, welche auch noch etwas
  2162. mächtigeres, Lambda Funktionen genannt, hat, was auch als Argument an Funk-
  2163. tionen übergeben wird. E`s quotierte Ausdrücke können auch als parameterlo-
  2164. se (oder nur globale Parameter) Lambdas angesehen werden.
  2165.  
  2166. Ausgewertete Ausdrücke
  2167.  
  2168. }11C.
  2169. --------------------------
  2170.  
  2171.     MapList(variabeladr,liste,listenvar,funk)
  2172.  
  2173. unterstützt einige Funktionen auf alle Elemente von liste und gibt alle Er-
  2174. gebnisse in listenvar zurück. funk muß ein quotierter Ausdruck sein (siehe
  2175. oben) und variabel (im welchen Bereich der liste) muß als Referenz überge-
  2176. ben werden.
  2177.  
  2178. MapList([x],[1,2,3,4,5],r,`x*x) ergibt in r:[1,4,9,16,25]
  2179.  
  2180.     ForAll(variabeladr,liste,funk)
  2181.  
  2182. Gibt TRUE zurück, wenn alle Werte in liste die Funktion (quotierter Aus-
  2183. druck) zu TRUE verarbeiten, ansonsten FALSE. Kann auch benutzt werden, um
  2184. eine bestimmte Funktion auf alle Elemente einer Liste abzuarbeiten.
  2185.  
  2186. ForAll([x],['eins','zwei','drei'],`WriteF('Beispiel: \s\n',x)
  2187.  
  2188.     Exists(variabeladr,liste,funk)
  2189.  
  2190. Wie ForAll(), nur diese gibt TRUE zurück, wenn irgend ein Element TRUE(<>)
  2191. ergibt. Beachte, daß ForAll() immer alle Elemente berechnet, aber Exists()
  2192. möglicherweise nicht.
  2193.  
  2194. Beispiele, wie man diese Funktionen auf eine spezielle Art und Weise be-
  2195. nutzt:
  2196. wir allozieren verschiedene Größen von Speicher in einem Statement, über-
  2197. prüfen Sie alle auf einmal und geben nur die frei, die erfolgreich angefor-
  2198. dert wurden. (Beispiel für v37+)
  2199.  
  2200. PROC main()
  2201.   LOCAL mem[4]:LIST,x
  2202.   MapList({x},[200,80,10,2500],mem,`AllocVec(x,0)) /* einige allozieren */
  2203.   IF ForAll({x},mem,`x)                            /* Erfolg ? */
  2204.     WriteF('Yes!\n')
  2205.   ELSE
  2206.     WriteF('No!\n')
  2207.   ENDIF
  2208.   ForAll({x},mem,`IF x THEN FreeVec(x) ELSE NOP)   /* nur die <>NIL frei-
  2209.                                                       geben*/
  2210. ENDPROC
  2211.  
  2212. Beachte das fehlen von Wiederholungen in diesem Code. Versuche doch einfach
  2213. dieses Beispiel in irgendeiner anderen Programmiersprache zu schreiben, und
  2214. siehe warum dies besonders ist.
  2215.  
  2216. Fließkommaunterstützung
  2217.  
  2218.  
  2219.          }12.FLIEßKOMMAUNTERSTÜTZUNG@{uu}
  2220.  
  2222.          B. Fließkommaausdrüke und Umwandlungen
  2223.  
  2224.  
  2225.  
  2226.          Vorheriges Kapitel     Nächstes Kapitel
  2227.  
  2228. Fließkommaunterstützung
  2229.  
  2230. }12A.
  2231. --------------------------------------------------------
  2232. Das überladen der standard Operatoren + * usw mit den fließkomma Gegen-
  2233. stücken ist seit der E Version 2.0 möglich, aber ich habe die Hauptdokumen-
  2234. tation davon entfernt, da wahrscheinlich das Fließkommakonzept ab der Ver-
  2235. sion v2.2 oder später sich ändern wird: diese Version wird dann 68881 In-
  2236. line-Code neben den normalen FFP-Routinen in einer transparenten Art er-
  2237. lauben.
  2238. Wenn Du wirklich Fließkommazahlen benutzen willst, mußt Du die eingebauten
  2239. SpXxx()-Routinen des mathffp.library benutzen.
  2240.  
  2241. Beispiel
  2242.  
  2243. x:=SpMul(y,0.013483)
  2244.  
  2245. Sei Dir bewußt, daß wenn v2.5 rauskommt, Dein Code vielleicht geändert wer-
  2246. den muß. (Für die besseren)
  2247.  
  2248. Fließkommaunterstützung
  2249.  
  2250. }12B.
  2251. ----------------------------------------
  2252. wie 12A.
  2253. Exception Behandlung
  2254.  
  2255.  
  2256.          }13.EXCEPTION
  2257.  
  2258.          A. Definition von Exceptionhandlern (HANDLE/EXCEPT)
  2259.          B. Benutzung der Raise() Funktion
  2260.          C. Exceptions für eingebaute Funktionen (RAISE/IF)
  2261.          D. Benutzung von Exception-ID's
  2262.  
  2263.  
  2264.  
  2265.          Vorheriges Kapitel     Nächstes Kapitel
  2266. Exception Behandlung
  2267.  
  2268. }13A.
  2269. -----------------------------------------------------
  2270. Der Ausnahme Mechanismus in E ist hauptsächlich der gleiche wie in ADA;
  2271. es steht für flexible Reaktionen auf Fehler in deinem Programm und
  2272. komplexe Ressourcen Leitung. Beachte: der Ausdruck 'exeption' in E hat
  2273. sehr wenig zu tun mit Ausnahmen ("GURUS"), die vom 680x0 Prozessor verursacht werden!
  2274.  
  2275. Ein Exeption-Handler ist ein Stück des Programm-Codes, daß aufgerufen wird,
  2276. wenn Laufzeitfehler geschehen, solche wie erfolgloses Öffnen von Fenstern
  2277. oder Speicher, der nicht mehr verfügbar ist. Du, oder das Laufzeit-System
  2278. selber, dürfen Signalisieren, daß etwas falsch ist (diese wird "Reaktion
  2279. auf einen Ausnahmezustand genannt), und dann wird das Laufzeit-System
  2280. versuchen, den zutreffenden Ausnahme Handler zu finden.
  2281.  
  2282. Ich sage "zutreffend", weil ein Programm mehr als einen Ausnahme Handler
  2283. enthalten kann, auf allen Stufen eines Programmes.
  2284.  
  2285. Eine normale Funktionen-Definition darf (wie wir alle wissen) folgendermaßen
  2286. ausschauen:
  2287.  
  2288.  
  2289. PROC bla()
  2290.  
  2291.   /* ... */
  2292.  
  2293. ENDPROC
  2294.  
  2295.  
  2296. Eine Funktion mit einem Ausnahme Handler sieht wie diese aus:
  2297.  
  2298.  
  2299. PROC bla() HANDLE
  2300.  
  2301.   /* ... */
  2302.  
  2303. EXCEPT
  2304.  
  2305.   /* ... */
  2306.  
  2307. ENDPROC
  2308.  
  2309.  
  2310. Der Block zwischen PROC und EXCEPT wird normal ausgeführt, und wenn keine
  2311. Ausnahme passiert ist, wird der Block zwischen EXCEPT und ENDPROC
  2312. übersprungen, und die Prozedur wird bei ENDPROC verlassen.
  2313.  
  2314. Wenn eine Ausnahme passiert, entweder im PROC-Abschnitt oder in
  2315. irgendeiner Funktion, die in dem Block aufgerufen wurde, dann wird der
  2316. Ausnahme-Handler ausgelöst.
  2317.  
  2318. Exception Behandlung
  2319.  
  2320. }13B.
  2321. -----------------------------------
  2322.  
  2323. Es gibt viele Wege um ein Ausnahme-Situation auszulösen, der einfachste
  2324. ist der über die Funktion Raise():
  2325.  
  2326.  
  2327.         Raise(exceptionID)
  2328.  
  2329.  
  2330. Die exeptionID ist einfach eine Konstante die den Typ der Ausnahme
  2331. definiert und wird benutzt von Ausnahme-Handlern, um zu untersuchen,
  2332. was schief gegangen ist.
  2333.  
  2334. Beispiel:
  2335.  
  2336.  
  2337. ENUM NOMEM,NOFILE  /* und andere */
  2338.  
  2339.  
  2340. PROC bla() HANDLE
  2341.  
  2342.   DEF mem
  2343.  
  2344.   IF (mem:=New(10))=NIL THEN Raise(NOMEM)
  2345.   myfunc()
  2346.  
  2347. EXCEPT
  2348.  
  2349.   SELECT exception
  2350.  
  2351.     CASE NOMEM
  2352.  
  2353.       WriteF('Kein Speicher!\n')
  2354.  
  2355.     /* ... und anderes */
  2356.  
  2357.   ENDSELECT
  2358.  
  2359. ENDPROC
  2360.  
  2361.  
  2362. PROC myfunc()
  2363.  
  2364.   DEF mem
  2365.  
  2366.   IF (mem:=New(10))=NIL THEN Raise(NOMEM)
  2367.  
  2368. ENDPROC
  2369.  
  2370.  
  2371. Die "Ausnahme"-Variable im Handler beinhaltet immer den Wert des Arguments,
  2372. das durch den Aufruf der Raise()-Funktion übergeben worden ist.
  2373. In beiden New()-Fällen übergab die Raise()-Funktion dem Handler der
  2374. Funktion bla(), und dann ging es richtig zurück zum Aufrufer von bla().
  2375.  
  2376. Wenn myfunc() einen eigenen Ausnahme-Handler hätte würde dieser aufegrufen
  2377. werden für den New()-Funktionsaufruf in myfunc(). Der Umfang eines Ausnahme-
  2378. Handler ist vom Start der PROC, in welcher er definiert wurde, bis zum
  2379. EXCEPT-Schlüsselwort, einschliesslich alle Aufrufe, die von hier gemacht
  2380. werden.
  2381.  
  2382.  
  2383. Dieses hat drei Konsequenzen:
  2384.  
  2385. A. Handler sind rekursiv organisiert, und welcher Handler eigentlich
  2386.    aufgerufen wird ist abhängig von dem Fuknktionsaufruf bei
  2387.    Programmausführung;
  2388.  
  2389. B. wenn eine Ausnahme in einem Handler ausgelöst wird, dann wird der Handler
  2390.    einer niedrigeren Stufe ausgeführt. Dieses Verhalten der Handler
  2391.    darf benutzt werden, um komplex zusammengesetzte rekursive
  2392.    Zuteilungsarien mit großartig Bequemlichkeit zu benutzen, wie wir in
  2393.    Kürze sehen werden.
  2394.  
  2395. C. Wenn eine Ausnahme ausgelöst wird auf einer Stufe, in der kein
  2396.    niedriger "Stufen"-Handler verfügbar ist (oder in einem Programm, daß
  2397.    keinen Handler bekommen hat), dann wird das Programm abgebrochen
  2398.  
  2399.    Z.B.: Raise(x) hat den gleichen Effekt wie CleanUp(0)
  2400.  
  2401. Exception Behandlung
  2402.  
  2403. }13C.
  2404. ----------------------------------------------
  2405. Mit Ausnahmen, wie zuvor beschrieben, haben wir etwas Bedeutendes erreichet
  2406. Über den alten Weg der Definition unserer eigenen "Fehler()"-Funktionen,
  2407. aber dennoch gibt es eine Menge einzugeben, um NIL bei jedem Aufruf von
  2408. New() zu prüfen.
  2409.  
  2410. Das E-Ausnahme-Laufzeitsystem erlaubt Definition von Ausnahmen
  2411. für alle E Funktionen (wie New(), OpenW() usw..), und für alle Library
  2412. Funktionen (OpenLibrary(), AllocMem() usw..), sogar für eingebundene Module.
  2413.  
  2414. Syntax:
  2415.  
  2416.  
  2417. RAISE <exceptionId> IF <Funktion> <Vergleich> <Wert> , ...
  2418.  
  2419.  
  2420. der Teil nach RAISE darf wiederholt werden mit einem ",".
  2421.  
  2422. Beispiel:
  2423.  
  2424.  
  2425. RAISE NOMEM IF New()=NIL,
  2426.  
  2427.       NOLIBRARY IF OpenLibrary()=NIL
  2428.  
  2429.  
  2430. die ersten Zeilen sagen etwas wie "immer wenn ein Aufruf von New()
  2431. in NIL resultiert, dann rufe automatisch die NOMEM Ausnahme auf".
  2432.  
  2433. <Vergleich> kann irgendetwas wie = <> > < >= <= sein.
  2434.  
  2435. Nach dieser Definition dürfen wir alles über unser Programm schreiben:
  2436.  
  2437.  
  2438. mem:=New(size)
  2439.  
  2440.  
  2441. ohne zu schreiben:
  2442.  
  2443.  
  2444. IF mem=NIL THEN Raise(NOMEM)
  2445.  
  2446.  
  2447. Beachte, daß der einzige Unterschied ist, daß "mem" nie einen Wert bekommt,
  2448. wenn das Laufzeit-System den Handler aufruft: Code wird erzeugt für
  2449. jeden aufruf zu New() um nach der Rückkehr von New() zu prüfen
  2450. und evtl. Raise() aufzurufen, wenn dieses notwendig ist.
  2451.  
  2452.  
  2453.  
  2454. Wir haben jetzt ein kleines Beispiel, daß komplex genug ist, um ohne
  2455. Ausnahme-Handling auszukommen: wir rufen eine Funktion rekursiv auf und
  2456. in jedem Aufruf teilen wir eine Ressource zu (in diese Fall Speicher),
  2457. welchen wir vorher allokiert haben, und führen danach den rekursiv Aufruf
  2458. aus.
  2459.  
  2460. Was geschieht, wenn irgendwo oben in der Rekursion ein Fehler entsteht und
  2461. wir das Programm zu verlassen haben?
  2462.  
  2463. Richtig: wir würden (in einer konventionellen Sprache) nicht die niedrigeren
  2464. Resourcen freibekommen, während wir das Programm verlassen, weil alle
  2465. Zeiger zu diesem Speicher in unerreichbaren lokalen Variablen hinterlegt
  2466. sind!
  2467.  
  2468. In E erhöhen wir einfach eine Ausnahme und von dem Ende des Handlers
  2469. erhöhen wir wieder eine Ausnahme, so daß wir alle Handler Rekursiv aufrufen
  2470. und alle Resourcen freigeben.
  2471.  
  2472. Beispiel:
  2473.  
  2474.  
  2475.  
  2476. CONST SIZE=100000
  2477. ENUM NOMEM  /* ,... */
  2478.  
  2479. RAISE NOMEM IF AllocMem()=NIL
  2480.  
  2481. PROC main()
  2482.  
  2483.   alloc()
  2484.  
  2485. ENDPROC
  2486.  
  2487.  
  2488. PROC alloc() HANDLE
  2489.  
  2490.   DEF mem
  2491.  
  2492.   mem:=AllocMem(SIZE,0)         /* sehen, wie viele Blöcke wir bekommen
  2493.                                    können */
  2494.  
  2495.   alloc()                       /* und jetzt die Rekursion .... */
  2496.  
  2497.   FreeMem(mem,SIZE)             /* wir werden nie hierher kommen ... */
  2498.  
  2499. EXCEPT
  2500.  
  2501.   IF mem THEN FreeMem(mem,SIZE)
  2502.   Raise(exception)              /* Rekursiver Aufruf aller Handler */
  2503.  
  2504. ENDPROC
  2505.  
  2506.  
  2507.  
  2508.  
  2509. Dieses ist, natürlich, eine Simulation eines natürlichen Programm-Problem,
  2510. daß gewönlich komplexer ist, und soll auch nur den Gebrauch der
  2511. Ausnahme-Benutzung darstellen. Für ein echtes Beispiel Programm würde das
  2512. Fehlerhandling ohne Ausnahmezustände wesentlich schwieriger werden,
  2513. siehe auch das 'D.e'-Utility Programm.
  2514.  
  2515. Exception Behandlung
  2516.  
  2517. }13D.
  2518. ---------------------------------
  2519.  
  2520. Im echten Leben ist die Ausnahme-ID ein normaler 32-Bit-Wert
  2521. und du darfst alles mögliche an einen Ausnahme-Handler geben, z.B.
  2522. um es als Ausgabe für fehlerhafte Strings zu nutzen:
  2523.  
  2524.  
  2525. Raise('Could not open "gadtools.library"!')
  2526.  
  2527.  
  2528. Wie auch immer, wenn du die Ausnahmen in einer ausführbaren Weise
  2529. nutzen möchtest und Du möchtest auch zukünftige Module nutzen,
  2530. deren Ausnahmen nicht in Deinem Programm definiert sind, dann folge
  2531. den folgenden Vorschlägen:
  2532.  
  2533. - Benutze und definiere die ID 0 als "kein Fehler" (z.B. normaler Abbruch)
  2534.  
  2535. - Um Ausnahmezustände in Deinem Programm zu bestimmen, nutze die
  2536.   ID's 1-10000.
  2537.  
  2538.   Definiere diese mit der gewöhnlichen Methode von ENUM:
  2539.  
  2540.  
  2541.   ENUM OK,NOMEM,NOFILE,...
  2542.  
  2543.  
  2544.   (OK wird 0, und andere werden 1+)
  2545.  
  2546.  
  2547. - ID's 12336 bis 2054847098 (dieses sind alles Bezeichner als
  2548.   Bestandteil von groß-/kleingeschriebenen Buchstaben und Ziffern
  2549.   der Länge 2,3 oder 4 eingeschlossen in "") sind reserviert als
  2550.   gemeinsam benutzte Ausnahmen. Eine gemeinsame Ausnahme ist ein Ausnahme,
  2551.   die nicht in Deinem Programm definiert werden braucht, und die
  2552.   benutzt wird von Vorgaben von Modulen (mit Funktionen in ihnen) um
  2553.   Ausnahmen zu erhöhen: z.B., wenn du eine Anzahl von Prozeduren
  2554.   erstellst die in einem eigenem Task laufen, dann kannst Du die Ausnahmen
  2555.   erhöhen.
  2556.  
  2557.   Wenn du diese Funktionen in verschiedenen Programme nutzen möchtest,
  2558.   dann würde es nicht praktisch sein, die ID's mit dem Haupt Programm
  2559.   zu koordinieren, und ferner, wenn du mehr als eine Funktionen benutzt
  2560.   (in einem Modul, in der Zukunft) und jedes Modul würde eine
  2561.   unterschiedliche Id haben für 'kein Speicher!', dann können Dir die Dinge
  2562.   aus der Hand gleiten.
  2563.  
  2564.   Und hier kommen die gemeinsamen Ausnahmen zum tragen: die gemeinsame
  2565.   'kein Speicher'-ID ist "MEM" (einschliesslich den Anführungsstrichen):
  2566.   jeder kann jetzt einfach von jedem Punkt
  2567.  
  2568.  
  2569.   Raise("MEM")
  2570.  
  2571.  
  2572.   von allen unterschiedlichen Prozeduren aufrufen, und der Programmierer,
  2573.   der diese Module benutzt, braucht nur einen Ausnahme-Handler,
  2574.   der "MEM" versteht.
  2575.  
  2576.  
  2577.   Zukünftige Module, die verschiede Funktionen beinhalten, werden angeben,
  2578.   was für Ausnahmen ein gesichertes Verfahren auslösen darf, und wenn diese
  2579.   sich überlappen mit den ID's von anderen Prozeduren, dann wird die
  2580.   Umgebung des Programmierers, die mit der Ausnahme zu arbeiten hat,
  2581.   außerordentlich schwierig sein.
  2582.  
  2583.  
  2584.   Beispiele
  2585.  
  2586.  
  2587.   (system)
  2588.  
  2589.   "MEM"         kein Speicher
  2590.   "FLOW"        (beinahe) Stack überfließend
  2591.   "^C"          Kontrollieren-C-Tasten-Abbruch
  2592.   "ARGS"        schlecht Argumente
  2593.  
  2594.  
  2595.   (exec/libraries)
  2596.  
  2597.   "SIG"         konnte kein Signal zuteilen
  2598.   "PORT"        konnte keinen Nachrichtenport erstellen
  2599.   "LIB"         Library nicht verfügbar
  2600.   "ASL"         keine asl.library
  2601.   "UTIL"        keine utility.library
  2602.   "LOC"         keine locale.library
  2603.   "REQ"         keine req.library
  2604.   "RT"          keine reqtools.library
  2605.   "GT"          keinen gadtools.library  (ähnlich für anderen)
  2606.  
  2607.  
  2608.   (intuition/gadtools/asl)
  2609.  
  2610.   "WIN"         kein Fenster zu öffnen
  2611.   "SCR"         kein Schirm zu öffnen
  2612.   "REQ"         kein Requester zu öffnen
  2613.   "FREQ"        Kein Filerequester zu öffnen
  2614.   "GAD"         konnte kein Gadget erstellen
  2615.   "MENU"        konnte kein Menu erstellen
  2616.  
  2617.  
  2618.   (dos)
  2619.  
  2620.   "OPEN"        konnte kein File aufmachen/File existiert nicht
  2621.   "OUT"         Proble beim lesen
  2622.   "IN"          Probleme beim schreiben
  2623.   "EOF"         Ende des Files
  2624.   "FORM"        Eingabe Format Fehler
  2625.  
  2626.  
  2627.   Die allgemeine Tendenz ist Großschreibung für allgemeine System
  2628.   Ausnahmen und Kleinschreibung (oder gemischt) für spezifizierte Module.
  2629.  
  2630.  
  2631. - alles anderen (einschliesslich aller negativen ID's) sind reserviert.
  2632.  
  2633.  
  2634. Objektorientierte Programmierung
  2635.  
  2636.  
  2637.          }14.OBJEKTORIENTIERTE
  2638.  
  2639.  
  2640.          Da in Version 2.1b noch nichts eingebaut ist, ist auch nichts
  2641.          dokumentiert. (Im Gegensatz zu Version 3.0 !!!)
  2642.  
  2643.  
  2644.          Vorheriges Kapitel     Nächstes Kapitel
  2645. Der Inline-Assembler
  2646.  
  2647.  
  2648.          }15.DER
  2649.  
  2650.          A. Variablenteilung
  2651.          B. Vergleich zwischen Inline-/Makroassembler
  2652.          C. Wege, Binäredaten zu nutzen (INCBIN/CHAR..)
  2653.          D. OPT ASM
  2654.  
  2655.  
  2656.  
  2657.          Vorheriges Kapitel     Nächstes Kapitel
  2658. Der Inline-Assembler
  2659.  
  2660. }15A.
  2661. ---------------------
  2662. Wie Du wahrscheinlich beim Beispiel im Kapitel 5D erraten hast, können
  2663. Assembleranweisungen frei mit E-Anweisungen vermischt werden. Das große Ge-
  2664. heimniss ist, das ein kompletter Assembler in den Compiler eingebaut
  2665. wurde.
  2666. Getrennt von den normalen Assembler Addressierungsmodies kannst Du auch fol-
  2667. gende Identifiers benutzen:
  2668.  
  2669. meinlabel:
  2670. LEA mylabel(PC),A1      /* Labels */
  2671.  
  2672. DEF a                   /* Variablen */
  2673. MOVE.L (A0)+,a          /* Beachte das <var> ein <offset>(A4) (or A5) ist */
  2674.  
  2675. MOVE.L dosbase,A6       /* Identifiers für Library-Aufrufe */
  2676. JSR    Output(A6)
  2677.  
  2678. MOVEQ  #TRUE,D0         /* Konstanten */
  2679.  
  2680. Der Inline-Assembler
  2681.  
  2682. }15B.
  2683. ----------------------------------------------
  2684. Der Inline-Assembler unterscheidet sich etwas von einem normalen Macro-
  2685. Assembler. Dies ist dadurch bedingt, daß er eine Erweiterung von E ist, und
  2686. deshalb der E-Syntax folgt. Hauptunterschiede sind:
  2687.  
  2688. - Kommentare werden nicht mit einem ';' Semikolon eingeleitet, sondern in /*
  2689.   */ eingeschlossen, sie haben unterschiedlich Bedeutung.
  2690. - Schlüsselworte und Register werden großgeschrieben, alles ist von der Groß-
  2691.   und Kleinschreibung abhängig.
  2692. - keine Macros und ander luxuriöse Assemblereigenschaften (es gibt schließ-
  2693.   lich den kompletten E-Sprachumfang dafür)
  2694. - Du solltest aufpassen, daß Du den Inhalt der Register A4/A5 nicht mit dem
  2695.   Inline-Assembler überschreibst, da sie vom E-Code benutzt werden.
  2696. - keine Unterstützung des Large Modells/Relloc-Hunks im Assembler -JETZT-
  2697.   Dies bedeutet hauptsächlich, das Du bis jetzt die PC-Relative Addressie-
  2698.   rung benutzen mußt.
  2699.  
  2700. Der Inline-Assembler
  2701.  
  2702. }15C.
  2703. ------------------------------------------------
  2704. INCBIN
  2705.  
  2706. Syntax: INCBIN <filename>
  2707.  
  2708. Fügt einen Binär-File genau am Punkt des Statements ein, und sollte deshalb
  2709. vom Code getrennt werden. Beispiel:
  2710.  
  2711. meinetab:   INCBIN <filename>
  2712.  
  2713. LONG, INT, CHAR
  2714.  
  2715. Syntax: LONG <werte>
  2716.         INT  <werte>
  2717.         CHAR <werte>
  2718.  
  2719. Erlaubt Dir binäre Daten direkt in ein Programm einzufügen. Funktioniert
  2720. fast wie DC.x in Assembler. Beachte, daß das CHAR-Statement auch Strings
  2721. annimmt und immer auf gerade Wortaddressen gelegt wird. Beispiel:
  2722.  
  2723. meinedaten: LONG 1,2; CHAR 3,4,'Hey Leute',0,1
  2724.  
  2725. Der Inline-Assembler
  2726.  
  2727. }15D.
  2728. ------------
  2729. OPT ASM  wird im Kaptel 16A besprochen. Es erlaubt Dir EC wie einen Assemb-
  2730. ler zu programmieren. Es gibt keinen guten Grund, EC anstatt eines Assemb-
  2731. lers zu  nehmen, außer der Geschwindigkeit. Er ist wesentlich schneller als
  2732. zum Beispiel A68k, gleich mit dem DevPac und langsamer als AsmOne. Du wirst
  2733. auch eine schwere Zeit haben, wenn Du die alten Seka-Sources von deiner
  2734. Disk schröpfen willst, aufgrund der aufgeführten Unterschiede (siehe 15B).
  2735. Wenn Du Assembler-Programme mit EC schreiben und sie zu anderen Assemblern
  2736. kompatibel halten willst, schreibe vor jede E-Speziefische Funktion ein ";",
  2737. EC wird sie benutzen und jeder andere Assembler ihn wird als Kommentar an-
  2738. sehen.
  2739. Beispiel:
  2740.  
  2741. ;OPT ASM
  2742.  
  2743. start:  MOVEQ   #1,D0   ;/*macht etwas dummes*/
  2744.         RTS             ;/*und steigt aus*/
  2745.  
  2746. dies wird von jedem Assembler assembliert, EC eingeschlossen.
  2747.  
  2748. Dinge über den Compiler
  2749.  
  2750.  
  2751.          }16.DINGE
  2752.  
  2753.          A. Das OPT Schlüsselwort
  2754.          B. Small/Large Modell
  2755.          C. Stack Organisation
  2756.          D. Festgeschriebene Begrenzungen
  2757.          E. Fehlermeldungen, Warnungen und nicht dokumentierte Tests
  2758.          F. Compiler Puffer Organisation und Anforderung
  2759.          G. Eine kurze Entstehungsgeschichte
  2760.  
  2761.  
  2762.          Vorheriges Kapitel     Nächstes Kapitel
  2763. Dinge über den Compiler
  2764.  
  2765. }16A.
  2766. --------------------------
  2767.  
  2768. OPT, LARGE, STACK, ASM, NOWARN, DIR, OSVERSION
  2769.  
  2770. syntax: OPT <Optionen>
  2771.  
  2772. Bietet die Möglichkeit, die Einstellungen des Compilers zu verändern.
  2773.  
  2774. LARGE  Das Code- und Datenmodell wird auf "LARGE" gestellt. Grundein-
  2775.        stellung ist "SMALL"; der Compiler generiert einen 100% pc-
  2776.        ähnlichen Code, mit einer Maximalgröße von 32K. Mit "LARGE"
  2777.        gibt es keine solchen Begrenzungen, zudem werden "reloc-hunks"
  2778.        generiert. Siehe -L
  2779. STACK=x  Setzt die Stackgröße auf x Bytes. Man sollte diese Option
  2780.          nur verwenden, wenn man weiß, was man tut. Normalerweise
  2781.          schätzt der Compiler die benötigte Stackgröße selbstständig
  2782.          recht gut ein.
  2783. ASM  Der Compiler wird in den Assembler-Modus geschaltet. Von da an
  2784.      sind nur noch Assembler-Befehle erlaubt und es wird kein Initi-
  2785.      alisierungscode generiert. Siehe: das Kapitel über integriertes
  2786.      Assembler.
  2787. NOWARN  Schaltet die Warnungen aus. Der Compiler gibt eine Warnung
  2788.         aus, wenn er *glaubt*, daß das Programm falsch ist, syntakt-
  2789.         isch aber in Ordnung ist. Siehe -n
  2790. DIR=moduledir  Legt das Verzeichnis fest, in dem der Compiler nach
  2791.                Modulen sucht. Grundeinstellung ist 'emodules:'
  2792. OSVERSION=vers  Grundeinstellung ist 33.(V1.2). Setzt die Minimum-
  2793.                 Version des Kickstarts (wie z.B. 37. für V2.04) fest,
  2794.                 ab denen das Programm laufen soll. Auf diesem Weg
  2795.                 bricht das Programm einfach ab, wenn die dos.library
  2796.                 einer älteren Version in der Initialisierungsroutine
  2797.                 auf einer älteren Maschine geöffnet wird. Allerdings
  2798.                 ist es für den User hilfreicher, wenn man die Kick-
  2799.                 startversion selber testet und eine geeignete Fehler-
  2800.                 meldung ausgibt.
  2801. Beispiel:
  2802. OPT STACK=20000,NOWARN,DIR='DF1:Modules',OSVERSON=39
  2803. Dinge über den Compiler
  2804.  
  2805. }16B.
  2806. -----------------------
  2807.  
  2808. Amiga-E läßt einem die Wahl zwischen einem SMALL und einem LARGE Code/
  2809. Daten-Modell. Allerdings dürften die meisten Programme, die man schreibt
  2810. (besonders, wenn man gerade erst mit Amiga-E angefangen hat), in die
  2811. 32K passen, wenn compiliert wird: man braucht sich also keine Gedanken
  2812. über das Einstellen eines Code-Genrierungs-Modelles machen. Man kann die
  2813. Notwendigkeit eines LARGE-Modelles daran erkennen, daß sich EC darüber
  2814. beschwert, daß es den Code nicht mehr in die 32K hineinbekommt. Folgender
  2815. Befehl compiliert einen Source-Code mit dem LARGE-Modell:
  2816. 1> ec -l sizy.e
  2817. oder, besser, setzen sie die Anweisung
  2818. OPT LARGE
  2819. in ihren Code.
  2820.  
  2821. Dinge über den Compiler
  2822.  
  2823. }16C.
  2824. -----------------------
  2825.  
  2826. Um alle lokalen und globalen Variablen zu speichern, weißt das run-time Sys-
  2827. tem eines von E generierten ausführbaren Programmes einen Speicherbereich zu,
  2828. von dem es einen festen Teil verwendet, um alle globalen Variablen zu speichern.
  2829. Der Rest wird dynamisch verwendet, wenn Funktionen aufgerufen werden. Wenn in E
  2830. eine Funktion aufgerufen wird, wird ein Bereich im Stack reserviert, um alle
  2831. lokalen Daten zu speichern, sobald die Funktion beendet ist, wird der Bereich
  2832. wieder freigegeben. Deshalb ist es gefährlich, große Arrays für lokale Daten
  2833. zu haben, wenn diese rekursiv aufgerufen werden: alle Daten der vorherigen Auf-
  2834. rufe der selben Funktion befinden sich noch immer im Stack und besetzen somit
  2835. einen großen Bereich in diesem. Werden Prozeduren jedoch linear aufgerufen, dann
  2836. kann der Stack nicht überlaufen.
  2837. Beispiel:
  2838.  
  2839. global data:        10K (arrays e.d)
  2840. local data PROC #1:  1K
  2841. local data PROC #1:  3K
  2842.  
  2843. Das run-time System reserviert immer zusätzliche 10K für normale Rekursion (z.B. mit
  2844. kleinen lokalen Arrays) und weitere Buffers/Systemspeicher, so daß insgesamt 24K
  2845. Stackspeicher zugewiesen werden.
  2846.  
  2847. Dinge über den Compiler
  2848.  
  2849. }16D.
  2850. ----------------------------------
  2851.  
  2852. Beachte diese Zeichen:  (+-)   ungefähr, hängt von der Situation ab
  2853.                         (n.l.) kein klares Limit, aber dieser Wert scheint sinnvoll
  2854.  
  2855. OBJEKT/GEGENSTAND                                      WERT/MENGE/MAX
  2856. ---------------------------------------------------------------------------------
  2857. Wert des Datentyps CHAR                                0 ... 255
  2858. Wert des Datentyps INT                                 -32K ... +32K
  2859. Wert des Datentyps LONG/PTR                            -2Gig ... +2 Gig
  2860.  
  2861. Identifierlänge                                        100 bytes (n.l.)
  2862. Länge einer Quellcodezeile                             2000 lexikalische Zeichen (+-)
  2863. Quellcode Länge                                        2 Gig (theoretisch)
  2864. konkrete listen                                        einige hundert Elemente (+-)
  2865. konstante Strings                                      1000 Zeichen (n.l.)
  2866. max. Tiefe der Schleifen                               500 tief
  2867. max. Tiefe der Kommentare                              unbegrenzt
  2868.  
  2869. # der lokalen Variablen pro Prozedur                   8000
  2870. # der globalen Variablen                               7500
  2871. # der Argumente für eigene Funktionen                  8000 (zusammen mit locals (?))
  2872. # der für E-varargs Funktionen [WriteF()]              64
  2873.  
  2874. ein Objekt (lokal/global oder dyn. zugewiesen)         8K
  2875. ein Array, List oder String (lokal oder global)        32K
  2876. ein String (dynamisch)                                 32K
  2877. ein List dynamisch)                                    128K
  2878. ein Array (dynamisch)                                  250MB
  2879.  
  2880. lokale Daten pro Prozedur                              250MB
  2881. globale Daten                                          250MB
  2882.  
  2883. Code-Größe einer Prozedur                              32K
  2884. Code-Größe eines ausführbaren Progs.                   32K SMALL, 2Gig LARGE Modell
  2885.  
  2886. Buffer-Größe eines generierten Codes und Identifiers   abhängig vom Quellcode
  2887. Buffer-Größe von Sprungmarken/Zweigen                  unabhängig (wieder)zugewiesen
  2888.  
  2889. Dinge über den Compiler
  2890.  
  2891. }16E.
  2892. --------------------------------------------------------------
  2893.  
  2894. Manchmal. wenn sie ihren Quellcode mit EC compilieren, erhalten sie eine Meldung, die
  2895. ungefähr folgendermaßen aussieht: UNREFERENCED <ident.>, <ident.>, ...
  2896. Dies passiert, wenn sie Variable, Funktionen oder Sprungmarken definieren, diese aber
  2897. nicht verwenden. Dies ist ein Extra-Service des Compilers, der helfen soll, solche
  2898. schwer zu findenden Fehler zu entdecken. Es gibt mehrere Warnungen, die der Compiler
  2899. ausgiebt, um sie darauf aufmerksam zu machen, daß etwas nicht in Ordnung ist, dies aber
  2900. kein echter Fehler ist.
  2901.  
  2902. - "A4/A5 used in line assembly"
  2903.   Diese Warnung wird ausgegeben, wenn sie Register A4 und A5 in ihrem Assembler Code
  2904.   verwenden. Der Grund dafür ist, daß diese Register von E intern verwendet werden,
  2905.   um lokale und globale Variable richtig zu addressieren. Natürlich kann es gute Gründe
  2906.   geben, diese zu gebrauchen, wie MOVEM.L A4/A5,-(A7) vor einen großen Stück Inline-
  2907.   Assembler-Code.
  2908.  
  2909. - "keep eye on stacksize"
  2910. - "stack is definitely too small"
  2911.   Beides kann ausgegeben werden, wenn sie OPT STACK=<size> verwenden. Der Compiler ver-
  2912.   gleicht einfach ihre Angabe mit seiner eigene Schätzung (siehe Kapitel 16C.), und gibt
  2913.   erstere Meldung aus, wenn er meint, die Größe sei etwas knapp kalkuliert oder letztere,
  2914.   wenn sie definitiv zu klein ist.
  2915.  
  2916. - 'suspicious use of "=" in void expression'
  2917.   Diese Warnung erscheint, wenn sie den Ausdruck 'a=1' als Anweisung gebrauchen. Ein Grund
  2918.   ist, daß ein Vergleich als Anweisung wenig Sinn macht, aber der Hauptgrund ist, daß dies
  2919.   oft vorkommende Rechtschreibfehler bei 'a:=1' ist. Den vergessenen ":" zu finden ist
  2920.   schwer, aber er kann ernsthafte Konsequenzen haben.
  2921.  
  2922. FEHLER:
  2923.  
  2924. - 'syntax error'
  2925.   Häufigster Fehler. Diese Fehlermeldung erscheint, wenn entweder keine andere Meldung passt,
  2926.   oder ihre Anordnung des Codes dem Compiler etwas seltsam erscheint.
  2927.  
  2928. - 'unknown keyword/const'
  2929.   Sie haben einen Identifier in Großbuchstaben (wie "IF" oder "TRUE") verwendet, und der Compiler
  2930.   konnte keine Definition dafür finden. Gründe:
  2931.   * falschgeschriebenes Schlüsselwort
  2932.   * sie haben eine Konstante verwendet, diese aber nicht zuvor mit CONST definiert
  2933.   * sie haben vergessen, das Modul anzugeben, in dem ihre Konstante definiert ist
  2934.  
  2935. - '":=" expected'
  2936.   Sie haben eine FOR Anweisung oder eine Zuweisung geschrieben, und haben dabei etwas anderes als
  2937.   ":=" verwendet.
  2938.  
  2939. - 'unexpected characters in line'
  2940.   Sie haben Zeichen verwendet die in E außerhalb von Strings keine syntaktische Bedeutung haben.
  2941.   Beispiel: "§!&Öß"
  2942.  
  2943. - 'label expected'
  2944.   In bestimmten Fällen, zum Beispiel nach den Schlüsselwörtern PROC oder JUMP, ist ein Iden-
  2945.   tifier notwendig. Sie haben irgendetwas anderes geschrieben.
  2946.  
  2947. - '"," expected'
  2948.   Innerhalb einer Gegenstandsliste (z.B. eine Parameter Liste), haben sie etwas anderes als
  2949.   ein Komma verwendet.
  2950.  
  2951. - 'variable expected'
  2952.   Diese Konstruktion braucht eine Variable, Beispiel:
  2953.   FOR <var>:= ... etc.
  2954.  
  2955. - 'value does not fit into 32 bit'
  2956.   Beim spezifizieren einer Konstanten haben sie einen zu großen Wert einegegeben, Beispiel:
  2957.   $FFFFFFFFF, "abcdef"  /siehe Kapitel 2A-2E)
  2958.   Diese Meldung erscheint auch, wenn ein SET-Befehl mit mehr als 32 Elementen verwendet wird.
  2959.  
  2960. - 'missing apostrophe/quote'
  2961.   Sie haben ein ' am Ende einer String vergessen.
  2962.  
  2963. - 'incoherrent program structure'
  2964.   * sie haben eine neue PROCedure gestartet, ohne die vorherige zu beenden.
  2965.   * die Verzweigung ihrer Programme ist falsch, z.B.:
  2966.     FOR
  2967.       IF
  2968.       ENDFOR
  2969.     ENDIF
  2970.  
  2971. - 'illegal command-line option'
  2972.   Innerhalb der Befehlszeile 'EC -opt source' haben sie für -opt einen Ausdruck verwendet, der
  2973.   EC unbekannt ist.
  2974.  
  2975. - ' division and multiplication 16 bit only'
  2976.   Der Compiler hat festgestellt, daß sie einen 32 bit Wert für * oder / verwendet haben. Dies
  2977.   würde nicht den erwünschten Wert im Runtime ergeben.
  2978.   Siehe Mul() und Div().
  2979.  
  2980. - 'superfluous items in expression/statement'
  2981.   Nachdem der Compiler ihren Anweisung bearbeitet hat, hat er immer noch Zeichen anstelle
  2982.   eines Linefeeds gefunden. Sie haben wahrscheinlich den <lf> oder ";" vergessen, um zwei
  2983.   Anweisungen zu trennen.
  2984.  
  2985. - 'procedure "main" not available'
  2986.   Ihre Programm hat keine 'main procedure'.
  2987.  
  2988. - 'double declaration of label'
  2989.   Sie haben eine Sprungmarke zweimal vergeben, z.B.:
  2990.   label:
  2991.   PROC label()
  2992.  
  2993. - 'unsafe use of "*" or "/"'
  2994.   Dies hat wieder etwas mit 16 Bit anstelle von 32 Bit * und / zu tun. Siehe 'division and
  2995.   multiplication 16 bit only'.
  2996.  
  2997. - 'reading sourcefile didn't succed'
  2998.   Überprüfen sie ihre Angaben für die Quelle, die sie mit 'ec mysource' angegeben haben.
  2999.   Achten sie darauf, daß die Quelle und nicht die Kommandozeile auf '.e' endet.
  3000.  
  3001. - 'writing executable didn't succed'
  3002.   Der Versuch, das eben generierte ausführbare Programm zu schreiben verursachte einen DOS-
  3003.   Fehler. Unter umständen existierte das Programm bereits und konnte nicht überschrieben
  3004.   werden.
  3005.  
  3006. - 'no args'
  3007.   "GEBRAUCH: ec [-opts] <Quellcodedateiname> ('.e' wird hinzugefügt)"
  3008.   Sie erhalten diese Meldung, wenn sie ec ohne Argumente verwenden.
  3009.  
  3010. - 'unknown/illegal addressing mode'
  3011.   Dieser Fehler erscheint nur, wenn sie den inline Assembler verwenden. Mögliche Gründe:
  3012.   * sie haben eine Addressierungsweise verwendet, die es für den 68000er nicht gibt.
  3013.   * die Addressierungsmethode existiert, aber nicht für diesen Befehl. Nicht alle Assembler-
  3014.     Befehle unterstützen alle Kombinationen der effektiven Addressen für Quelle und Ziel.
  3015.  
  3016. - 'unmatched parentheses'
  3017.   Ihre Anweisung hat mehr "(" als ")" oder umgekehrt.
  3018.  
  3019. - 'double declaration'
  3020.   Ein Identifier wird in zwei oder mehr Deklarationen verwendet.
  3021.  
  3022. - 'unknown'
  3023.   Ein Identifier wird in keiner Deklaration verwendet; er ist unbekannt. Wahrscheinlich haben
  3024.   sie vergessen, ihn in eine DEF-Anweisung zu setzen.
  3025.  
  3026. - 'incorrect # of args or use of ()'
  3027.   * sie haben vergessen "(" oder ")" an die richtige Stelle zu setzen
  3028.   * sie haben eine falsche Anzahl von Argumenten für eine Funktion verwendet
  3029.  
  3030. - 'unknown e/library function'
  3031.   Sie haben einen Identifier mit einem Großbuchstaben begonnen und dann mit Kleinbuchstaben
  3032.   fortgesetzt, aber der Compiler konnte keine Definition finden.
  3033.   Mögliche Gründe:
  3034.   * eine Funktion wurde falschgeschrieben
  3035.   * sie haben das Modul miteinzuschließen, das diesen Bibliotheksaufruf enthält
  3036.  
  3037. - 'illegal function call'
  3038.   Erscheint selten. Sie erhalten diesen Fehler, wenn sie seltsame Funktionsaufrufe starten,
  3039.   wie z.B. verzweigte WriteF()'s :
  3040.   WriteF(WriteF('hi'))
  3041.  
  3042. - 'unknown format code following ""'
  3043.   Sie haben in einer String einen Formatcode verwendet, der unzulässig ist.
  3044.   Siehe Kapitel 2F für eine Liste der Formatcodes.
  3045.  
  3046. - '/* not properly nested comment structure */'
  3047.   Die Anzahl der '/*' stimmt nicht mit der Anzahl der '*/' überein, oder haben eine komische
  3048.   Reihenfolge.
  3049.  
  3050. - 'could not load binary'
  3051.   <filespec> innerhalb von INCBIN <filespec> konnte nicht gelesen werden.
  3052.  
  3053. - '"}" expected'
  3054.   Sie haben einen Ausdruck mit "{<var>" begonnen, aber das "}" vergessen.
  3055.  
  3056. - 'immediate value expected'
  3057.   Manche Konstruktione erfordern einen direkten Wert anstelle eines Ausdrucks.
  3058.   Beispiel:
  3059.   DEF s[x*y]:STRING   /* falsch, nur etwas wie s[100]:STRING ist zulässig */
  3060.  
  3061. - 'incorrect size of value'
  3062.   Sie haben einen unzulässig großen/kleinen Wert in einer Konstruktion verwendet.
  3063.   Beispiel:
  3064.   DEF s[-1]:STRING, +[1000000]:STRING    /* muß 0 ... 32000 sein */
  3065.   MOVEQ #1000,D2                         /* muß -128 ... 127 sein */
  3066.  
  3067. - 'no e code allowed in assembly modus'
  3068.   Sie haben den Compiler als Assembler arbeiten lassen, aber, aus Versehen, E-Code
  3069.   geschrieben.
  3070.  
  3071. - 'illegal/inappropriate type'
  3072.   An einer Stelle wo eine <type> Spezifikation notwendig gewesen wäre, haben sie etwas
  3073.   unpassendes eingegeben. Beispiele:
  3074.   DEF a:PTR TO ARRAY        /* es gibt keinen solchen Typ */
  3075.   [1,2,3]:STRING
  3076.  
  3077. - '"]" expected
  3078.   Sie haben mit einem "[" begonnen, aber nie mit einem "]" aufgehört.
  3079.  
  3080. - ' statement out of local/global scope'
  3081.   Ein wesentlicher Punkt bei der Kontrolle ist die erste PROC-Anweisung. Davor sind nur
  3082.   globale Definitionen (DEF, CONST,MODULE etc.) erlaubt, und keinerlei Code. Im zweiten
  3083.   Teil sind nur Code, aber keine globalen Definitionen erlaubt.
  3084.  
  3085. - 'could not read module correctly'
  3086.   Es gab einen DOS-Fehler beim Versuch, ein Modul von einer MODULE-Anweisung einzulesen.
  3087.   Gründe:
  3088.   * emodules:wurden nciht korrekt zugewiesen (assign emodules: ...)
  3089.   * der Modulname wurde falsch geschrieben, oder es existiert nicht
  3090.   * sie haben MODULE 'bla.m' anstelle von MODULE 'bla'
  3091.  
  3092. - 'workspace full'
  3093.   Erscheint selten. Wenn dieser Fehler erscheint, müssen sie EC mit der '-m' Option dazu
  3094.   zwingen, die Schätzung über die benötigte Speichermenge höher anzusetzen. Versuchen sie
  3095.   es zuerst mit '-m2', dann '-m3', bis der Fehler verschwindet. Sie müssen aber schon rie-
  3096.   sige Anwendungsprogramme, mit einer Unmenge Daten schreiben, damit dieser Fehler er-
  3097.   scheint.
  3098.  
  3099. - 'not enough memory while (re-)allocating'
  3100.   Mögliche Lösungen für dieses Problem:
  3101.   1. Sie haben andere Programme im Multitasking laufen. Stoppen sie diese und versuchen
  3102.      sie es nocheinmal.
  3103.   2. Sie haben akuten Speichermangel und der Speicher war fragmentiert. Rebooten sie.
  3104.   3. Weder 1. noch 2., kaufen sie sich eine Speichererweiterung (hüstel).
  3105.  
  3106. - 'incorrect object definition'
  3107.   Sie haben bei einer Definition zwischen OBJECT und ENDOBJECT Blödsinn geschrieben.
  3108.   Siehe Kapitel 8F, um herauszufinden, wie's richtig geht.
  3109.  
  3110. - 'incomplete if-then-else expression'
  3111.   Wenn sie IF als einen Operator verwenden, dann muß ELSE ein Teil dieses Ausdrucks sein:
  3112.   ein Ausdruck mit einer IF-Anweisung muß immer einen Wert zurückgeben, aber wenn keine
  3113.   ELSE-Anweisung da ist, kann IF im Prinzip nichts tun.
  3114.  
  3115. - 'unknown object identifier'
  3116.   Sie haben einen Identifier verwendet, den der Compiler als einen Teil eines Objekts er-
  3117.   kannt hat, aber sie haben vergessen, ihn zu deklarieren. Gründe:
  3118.   * falsch geschriebener Name
  3119.   * fehlendes Modul
  3120.   * der Identifier innerhalb des Modules wird nicht so geschrieben, wie sie es aus den
  3121.     Rom-Kernel-Manuals erwartet haben. Überprüfen sie es mit ShowModule.
  3122.     Beachten sie, daß Amiga-System-Objekte auf Assembler Identifiern basieren und nicht auf
  3123.     C. Zweitens: Identifier folgen dem E-Syntax.
  3124.  
  3125. - 'double declaration of object identifier'
  3126.   Ein Identifier wurde in zwei Objekt Definitionen verwendet.
  3127.  
  3128. - 'reference(s) out of 32K range: switch to LARGE model'
  3129.   Ihr Programm wird größer als 32K. Fügen sie einfach 'OPT LARGE' in ihren Quellcode mit
  3130.   ein. Siehe Kapitel 16B.
  3131.  
  3132. - 'reference(s) out of 256 byte range'
  3133.   Sie haben wahrscheinlich BRA.S oder Bcc.S über eine zu große Distanz geschrieben.
  3134.  
  3135. - 'too sizy expression'
  3136.   Sie haben wahrscheinlich eine Liste von [], möglicherweise [[]], geschrieben, die zu groß
  3137.   ist.
  3138.  
  3139. - 'incomplete exception handler definition'
  3140.   Sie haben unter Umstaänden EXCEPT ohne HANDLE verwendet, oder aber auch anders herum.
  3141.   Siehe Kapitel 13 für "exception handling".
  3142.  
  3143. Dinge über den Compiler
  3144.  
  3145. }16F.
  3146. -------------------------------------------------
  3147.  
  3148. Wenn sie den Fehler 'workspace full' (sehr unwahrscheinlich) erhalten, oder wissen wollen was
  3149. wirklich passiert, wenn ihr Programm compiliert wird, ist es wichtig, zu wissen, wie EC seine
  3150. Buffer organisiert.
  3151. Ein Compiler, und in diesem Fall EC, braucht Buffer, um alle möglichen Dinge, wie z.B. Identi-
  3152. fier nachverfolgen zu können. Es braucht diese auch, um darin den generierten Code zu speichern.
  3153. EC weiß nicht, wie groß diese Buffer sein müssen. Bei manchen Buffern, wie dem für Konstanten,
  3154. ist das kein Problem: wenn der Buffer voll ist, weißt EC einfach ein weiteres Stück Speicher zu
  3155. und arbeitet dann weiter. Andere Buffer, wie der für den generierten Code, müssen ein einziger
  3156. Speicherblock sein, der sich während des Compilierens nicht verändert: EC muß also den notwendigen
  3157. Speicher gut abschätzen, um große und kleine Quellcodes compilieren zu können. EC berechnet also
  3158. anhand des Quellcodes den benötigten Speicherplatz und fügt dazu nocheinmal eine ansehnliche Menge
  3159. hinzu. Somit reicht in 99% aller Fälle der Speicher aus, andern Falls erhalten sie eine Fehler-
  3160. meldung un müssen weiteren Speicher mit der '-m' Option hinzufügen.
  3161. Experimentieren sie mit unterschiedlichen Typen und Größen von Quellcoden in Verbindung mit der
  3162. '-b' Option um herauszufinden, wie es funktioniert.
  3163.  
  3164. Dinge über den Compiler
  3165.  
  3166. }16G.
  3167. --------------------------------------
  3168.  
  3169. E ist nicht einfach einen weitere Programmiersprache: sie wurde schrittweise und vorsichtig
  3170. vom Autor entwickelt, da er mit den existierenden Programmiersprachen nicht besonders glück-
  3171. lich war, speziell den langsamen und "schlabrige-Codes-erzeugenden" Compilern, die es für
  3172. diese gab. E hatte als primäres Ziel dem Autor für seine Entwickling von Amiga Programmen zu
  3173. dienen, und war dabei bisher sehr erfolgreich. E wurde in einen Zeitraum von 1½ Jahren in Ver-
  3174. bindung mit intensiver Arbeit entwickelt und war nicht der erste Compiler, den der Autor ge-
  3175. schrieben hat: manch einer erinnert sich vielleicht an den DEX-Compiler.
  3176.  
  3177. Dieser war langsam und nicht besonders mächtig und kann nur schwerlich mit dem Amiga E Com-
  3178. piler verglichen werden, aber er gab dem Autor wichtige Erfahrungen, die halfen, Amiga E zu
  3179. dem zu machen, was es heute ist. DEX Programierer werden feststellen, daß es sehr einfach ist
  3180. ihre Quellcodes in E umzuwandeln, und die Entwicklung mit der 10fachen Power und der 20fachen
  3181. Geschwindigkeit fortzusetzen. Eine witzige Sache an DEX ist, daß sich die Entwicklung von DEX
  3182. und E überschnitten hat: als DEX fertig war, war E V1.6 zur Hälfte geschrieben. Weil E schon
  3183. damals wesentlich besser war, wurden E Bibliotheken/Beispiele und Codes auf allgemeinen Wunsch
  3184. hin auf DEX übertragen, so daß der Vorgänger Teile seines Nachfolgers beinhaltete.
  3185. Der AUtor hat auch noch weitere Compiler und Interpreter geschrieben, die aber teilweise nie
  3186. veröffentlicht wurden.
  3187.  
  3188. Amiga E ist ein Produkt, das weiter entwickelt wird, bis es die ultimative Sprache und Amiga
  3189. Entwicklungssystem ist:
  3190.  
  3191. - indem diese, bisher fehlenden Teile, in die Sprache miteinbezogen werden
  3192.   * Objektorientierung
  3193.   * besseres Fließkomma Konzept
  3194.  
  3195. - indem am Compiler einige Veränderungen vorgenommen werden
  3196.   * mögliche Genrierung von 020/030/881 Code
  3197.   * Optimierung des Compilierungsprozesses, so daß unter Umstäden sich Zeile/Minute Figuren
  3198.     verdoppeln
  3199.   * es soll dem User ermöglicht werden, eigenen Code in Module zu wandeln, um somit große
  3200.     Anwendungen modular aufbauen zu können
  3201.  
  3202. - indem wetvolle Elemente dem Packet hinzugefügt werden
  3203.   * ein integrierte Editor ?
  3204.   * source-level debugger ?
  3205.   * CASE Werkzeuge, zum Beispiel
  3206.  
  3207. - indem Bugs entfernt werden (welche Bugs ??!!)
  3208.  
  3209.  
  3210. Das ENDE! Schnauf! Viel Spaß mit E!
  3211.  
  3212.  
  3213.