home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 623a.lha / TurboDEX / Dex.doc.pp / Dex.doc
Text File  |  1992-04-04  |  48KB  |  1,206 lines
  1.  
  2.                     TurboDEX Compiler v1.1 by $#%!
  3.  
  4.                              M A N U A L
  5.  
  6.  
  7.         Contents:
  8.  
  9.         1. Introduction, The Features
  10.         2. Installation And Running
  11.         3. The Language In General
  12.                 4. Step by step Tutorials
  13.         5. Alfabetical Overview Of Instructions
  14.                 6. Advanced Programming And Language Info's
  15.         7. Additional Info's
  16.  
  17.  
  18.  
  19. -------------------------------------------------------------------------
  20.                   CHAPTER 1, INTRODUCTION; THE FEATURES. 
  21. -------------------------------------------------------------------------
  22.  
  23. What is DEX ?
  24. DEX is a Compiler-Language, like C, Modula2, GfaBasic, Pascal etc. it
  25. features a similar programming structure and programming possibilities as
  26. above languages. Yet you'll have to consider that DEX as to offer a lot
  27. more, and, on the other hand, it's not a totally 'complete' language.
  28.  
  29. Dex Features:
  30. - Possibility of clear program structure (like f.e. Pascal and Gfa, no
  31.   C-spaghetti).
  32. - Short Executables; small to medium size DEX-sources will compile nearly
  33.   always compile to less than 1K, where above languages will need nearly
  34.   always more than 5K. (examples: the program given as an example with
  35.   the WRITE statement in the reference section would compile into an
  36.   executable of ± 300 bytes, the code of a complete vectordemo was done in
  37.   ± 1300 bytes, and a shell in ± 500 bytes. All inclusive hunks,
  38.   reloc-tables, opening of librarys etc.) 
  39. - Clear assembly source output: DEX generates fully commented assembly
  40.   source, in which you will be able to find all the variables you used,
  41.   and compare the code-generation directly to the DEX-source.
  42. - Direct access of all routines of EXEC, DOS, INTUITION, GRAPHICS and MATH,
  43.   without ANY includefiles and without opening ANY library. All 
  44.   customchip registers can adressed by their name, without ANY include.
  45. - Advanced features like Global/Local variables, easy calling of 
  46.   procedures and libraryroutines with return values, inline assembly
  47.   code (like aztec C), use of registervariables.
  48. - Faaast executables, extensive use of registers, fast parameter passing,
  49.   smart solutions for local variables and structs, quick optimization,
  50.   pc relative branching and adressing, special HYPER optimize mode for
  51.   loops and other instuctions where every clockcycle counts.
  52. - Easy to manage development system: just one compiler will do the job,
  53.   no 5 meg of includes, linkfiles, objects, optimizers, profilers etc.
  54.   All instructions needed for writing a substancial program integrated
  55.   in the compiler.
  56.  
  57. What is wrong with TurboDEX? (in this version, that is.)
  58. - some things haven't been implemented.
  59. - some errors which you might make while programming are not recognised,
  60.   and will be compiled, (if you're lucky, a68k discovers them)
  61.   since no things like stack-overflow checking are implemented.
  62. - Its mosly faster than above languages, but still not optimized enough.
  63. - it doesn't do any type-checking, so things like dividing a CHAR
  64.   variable by a LONG, or messing up pointers to wrong memory-area's
  65.   are not flagged by the compiler.
  66. - The compiler can be *very* slow sometimes
  67. - The development system is not adequate for big app's.
  68. - kick 2.0 compatible but not 2.0 specific (generates 1.2-and-up code).
  69. - It's not idiot-proof.
  70.   
  71. Generally, DEX gets you ASSEMBLY quality performance an size executables,
  72. with BASIC effort. But the prize to pay for this that the programmer
  73. needs to know what he's doing. That's why this language is not ideal
  74. for beginners, but more appropriate for advanced coders who want to
  75. write a high performance util with minimum effort.
  76.  
  77. If you're eager to see what a DEX-source looks like, browse through
  78. the drawer with examples, kick-ass with 'HelloWorld.dex', then check
  79. out the other small sources. For your convenience here's some example:
  80.  
  81. ' oh look, it's my first DEX program! 
  82.  
  83. PROC main()
  84.   WRITE 'Hello, World!\n'
  85. ENDPROC
  86.  
  87. ' well, that was exiting, wasn't it? hmmm?
  88.  
  89.  
  90. -------------------------------------------------------------------------
  91.                        2. INSTALLATION AND RUNNING
  92. -------------------------------------------------------------------------
  93.  
  94. How to work with TurboDEX.
  95. First of all: all you really need is the compiler 'DEX'. just type
  96. something like:
  97.  
  98. DEX [-opts] <sourcefile>
  99.  
  100. example:
  101.  
  102. DEX:> dex -a helloworld
  103.  
  104. the compiler will take a pure ascii file with the name 'HELLOWORLD.DEX'
  105. as input in the current directory (this file contains some dex program
  106. you wrote), and will produce a file 'HELLOWORLD.S' as output (this file
  107. contains the assembly language translation from your DEX-source).
  108. The -a flag will cause DEX to invoke A68k and Blink straight away, to
  109. assemble and link the .S file..
  110. Now type:
  111.  
  112. DEX:> HELLOWORLD
  113.  
  114. Hello, World!
  115.  
  116. DEX:>
  117.  
  118. If you don't use the -a flag, you'll have to assemble by hand. Almost
  119. any assembler will do, supported are A68k and DEVPAC (tm).
  120. Compile with an assembler like A68K and link it with for example Blink:
  121.  
  122. Dh0:> A68K HELLOWORLD.S
  123. Dh0:> BLINK HELLOWORLD.O
  124.  
  125. Another example:
  126.  
  127. Dh0:> dex -flgr
  128.  
  129. This will enable you to pick your source by means of a file-requester,
  130. dex will generate a list-file, invoke Devpac's GENAM instead of the
  131. A68k/Blink duo, and execute your program afterwards.
  132.  
  133. Above is all you need.
  134.  
  135. Additional suggestions:
  136. Best you shove DEX into your C: dir next to A68K and BLINK.
  137. You may want to make Genam or Blink resident to speed up the process,
  138. and if don't own a HD, copy DEX to ram: so you can 
  139. Compile-Assemble-Link-Run without disk Access.
  140. NOTE: DEX outputs code suitable for A68K, so if you'd like to use
  141. some other Assembler, you could be forced to make some minor changes.
  142. (see -o option).
  143.  
  144. CommandLine Options:
  145. Executing DEX with nothing following it will result in DEX opening
  146. a window, where you can enter the commandline at the 'IN>' prompt.
  147.  
  148. options:
  149. ?   Display a 'usage:' and some info
  150. -a  If compiling succeeded, invoke A68K and BLINK from the compiler.
  151.     NOTES: both need to be in the search-path (i.e: mostly C: or the
  152.     active directory). this will need c:run (<2.0) and some free-memory.
  153. -c  Don't add comments to assembly source (because you're not interested
  154.     in the generated code anyway), makes file smaller.
  155. -f  Pops up a filerequester to let you choose a source to compile
  156.     instead of having to enter it at the commandline.
  157. -g  Have GENAM (part of the Devpac (tm) assembler) assemble and
  158.     link your program. Includes -o, excludes -a.
  159. -l  Produce a list file named <source>.LIST, containing statistical
  160.     info's about the program, the compiler-status, and lists of
  161.     identifiers, procedures etc.
  162. -o  Generate assembly source for any other assembler than A68k.
  163. -r  Run the executable after being generated. needs -a or -g
  164. -s  Try to generate code that is more reliable, but slower. The compiler
  165.     will insert extra intructions to do extending of wrong-size variables,
  166.     and make some extra checks. This option must only be used for
  167.     test-purposes. Not guaranteed to help.
  168. -t  Don't compile file at the command line, but internal test-source
  169.     instead (for test-purposes only).
  170.     
  171. NOTE: options are case-INsensitive, may be put anywhere on the commandline,
  172. and can be but together. so 'DEX -c test -A' has the same effect as
  173. 'DEX -ac test'.
  174.  
  175. Ok. Now over to the real stuff:
  176.  
  177. -------------------------------------------------------------------------
  178.                          3. THE LANUAGE IN GENERAL
  179. -------------------------------------------------------------------------
  180.  
  181. Procedures.
  182. All programming instructions are gathered in modules, called PROCs.
  183. The most important of these is the procedure PROC main() which always
  184. has to be part of a program (it doen't have to be the first procedure).
  185. this is the actuall program, where all variables are global. Other
  186. procedures can be added, that can have own (local) variables. These
  187. procedures can be called with or without parameters, like: 
  188. 'VOID getpicture(rastport,x+4,y/8)' 
  189. Procedures cannot be called recursively.
  190.  
  191. Loops.
  192. Lots of loops are supported, like FOR ... ENDFOR, WHILE ... ENDWHILE and
  193. some others. These can be nested infinetely (well, nearly).
  194.  
  195. Variables.
  196. At the moment 10 types of variables are supported:
  197. - LONG, a 32 bit wide integer variable, can hold any value from 
  198.   somewhat less than -2.14 to a little more than 2.14 milliard. this
  199.   is the most used variable since all addresses are kept in these,
  200.   most system routines expect longints, and nearly all calculations
  201.   are done in 32 bit.
  202. - INT, a 16 bit variable, keeps values from -32k to +32k. Used with
  203.   multiplies/divides.
  204. - CHAR, an 8 bit variable, most used with texts, and other small data.
  205.   range 0 to 255.
  206. - REGLONG, REGINT and REGCHAR. These are the same ase those three described
  207.   above, with some small differences: - max. 6 of them can be used per
  208.   module, - 680x0 registers are used for their storage. 
  209.   The advantage of these is mainly their speed, as wel as the smaller and
  210.   better code they produce. They are best used with DOWN loops, and 
  211.   everywhere you need to have a certain part of your program to be as
  212.   faaast as possible.
  213.   NOTE WELL: these may only be declared with LOCAL
  214. - ARRAY and ARRAYCHIP. These are simple implementations of arrays, and 
  215.   function as CharArray only. They are defined as variable, and the
  216.   variable (compatible with LONG) contains a pointer to the array.
  217.   ARRAYCHIP is the version of ARRAY where the array is forced to 
  218.   chipmem. (for the 'insiders': BSS_c ).
  219. - CUSTOMREGS. all customregs can be used as variable. Just type the 
  220.   official name in capitals, like DMACON. this enables lines like:
  221.   AUD0LEN := samplelen/2   or even   COLOR00 := VPOSR*VHPOSR
  222.   its up to you to see which registers you can read or write.
  223. - ABSOLUTE, if you would write or read absolute addresses, you can
  224.   use a value (specifying the adress) between [], following the variable-
  225.   name in the definition, like: sysbase[4]:LONG, would enable you to
  226.   use sysbase as an absolute variable. Like this you can specify a
  227.   variable as part of a STRUCT, which provides extremely flexibel
  228.   programming, like: depth[newscreen.8]:INT
  229.  
  230. all these variables (except for the CustomRegs) have to be defined before
  231. use. See DEF in the reference section for more info's.
  232.  
  233. Other parameters.
  234. these can be used as value only.
  235. supported in this version are:
  236. - Values: dependent on the instruction you use, values like 4, 100,
  237.   4543836, $ff, $c00000, %101110 etc. can be used.
  238. - Adresses of labels and STRUCTS. you may need to now the address of a
  239.   label or stuct in your program. e.g. if somewhere in your program is
  240.   something like 'PROC text()', 'STRUCT text' or 'text:' the address could
  241.   be obtained with  adr := {text}  (use {} with the labelname).
  242. - A text string. in the current version, strings that can be altered
  243.   are not supported. Though, you may give a string between '' as a
  244.   parameter. if the string is one character long, the ascii code will
  245.   be passed: c := 'A' equals c := 65 . If the string is longer, however,
  246.   the address of the string is passed, thus enabling flexible programming
  247.   were routines need the address of a textstring, for example:
  248.   VOID Text(rast,'Hello There !',LEN). LEN is a systemvariable, always
  249.   containing the lenght of the last string used. In the string you
  250.   may use the following codes:
  251.   \n    a return + linefeed (ascii 10 and 13)
  252.   \a    an apostophe, the one you need for enclosing the string
  253.   \t    insert a TAB (9)
  254.   \e    insert an escape-code (27), '\e[' will work as CSI.
  255.   \0    a null byte (not often needed, as all strings in DEX
  256.         are terminated with a '0').
  257.   \\    a backslash.
  258.         example: 'this: \a\\\a is a backslash \n\0'
  259.         Additionally, following codes may be used only when using a
  260.         string as part of a WRITE-statement:
  261.   \d    print out a LONG as decimal.
  262.   \h    print out a LONG as hexadecimal
  263.   \c    print out a LONG as character
  264.   \s    print out a 0-terminated string at address.
  265.   \w<x> sets minimum width for print, rest will be padded with spaces.
  266.   \z    pad with zeroes instead of spaces.
  267.   \m<x> sets maximum width for strings.
  268.   \l    put data to the right of the field (default).
  269.   \r    put data to the left in the field instead of to the right.
  270.         example:
  271.         WRITE 'some results: \z\w8 $\h \c.',65535,65
  272.         will print:
  273.         some results:  $0000FFFF A.
  274.   note: changes to print-formatting made with \w\z\m\l\r are only
  275.         valid within one WRITE-statement, they are reset to default
  276.         values at the start of the next statement.
  277. - A string as integer value. you may use strings of lenght 1-4 between
  278.   double quotes ("") to, for example, quickly compare short strings:
  279.   
  280.     IF {buffer}="FORM"               and          a := "A"
  281.  
  282.   are equal to
  283.  
  284.     IF {buffer}=$464F524D            and          a := 65
  285.  
  286.   The first character is stored in the MSB of the LONG. If only
  287.   one character is supplied, it is stored in the LSB.
  288.       
  289.  
  290. Parameters needed;
  291. mostly a parameter could be one of 2 different types, in the description
  292. of the commands that follows specified as var or exp.
  293. var = parameter that must be a variable. examples;
  294.       a, count, COLOR01, etc.
  295. exp = parameter that can be a variable, a value, or an expression (a
  296.       combination of more aspects). examples;
  297.       1, 200, $ff, a, DMACON, count+3/a-2000
  298.       these can be all mentioned above, including combinations.
  299. For example, the parameter of FOR that is the counter would be a var,
  300. and the two parameters specifying the range could be any exp(ression).
  301.  
  302. Expressions.
  303. as stated above, everywhere an instructions needs a parameter that is
  304. is an exp, you can use any of these operators with variables/values mentioned:
  305. -,+      minus and plus, no restrictions.
  306.          examples: 3+a, 60-{text}+$ff
  307. /,*      divide and product, these are always done 16bit wide, watch
  308.          carefully when using them. examples: a/20, counter*256.
  309.          for 32bit operations, see MUL() and DIV().
  310. &,^      AND and OR, used only as mathematical, not logical operators.
  311. =,<,>,?  comparisons. in the current version they are only usefull with
  312.          IF and WHILE. They need to be the last operator used.
  313.          In order: equal, smaller than, bigger than or equal, unequal.
  314.          examples: a=3, {data}-1024>$c00000, flag?0, 3*b+a
  315. IMPORTANT: in the current version of the compiler, expressions are compiled
  316. in the same order as written in the sourcecode, and () are not supported.
  317. thus, a+(3*b) shouldn't be written as a+3*b, but 3*b+a, otherwise a+3 would
  318. be calculated first, instead of 3*b. same goes for comparison (!) operators.
  319.  
  320. Labels and remarks.
  321. in the current version, labels and remarks stand on their own line.
  322. a label is any string followed by a ':' and can be used only to point at
  323. instructions, not structs etc. (see above) example:
  324. startofprogram:
  325. when you program very structured, you won't need labels.
  326. remarks start with a ' and are totally ignored by the compiler. f.e.:
  327. ' Here the screen is setup
  328.  
  329. Syntax.
  330. first of all, the only place where spaces are obigatory, is after an
  331. instruction keyword: WHILE<space>a=3
  332. furthermore, the whole language is case sensitive.
  333. uppercase: keywords, customregisternames
  334. lowercase: variablenames, labelnames, procnames, structnames
  335. both     : systemcallnames. every part of the name starts of with
  336.            an uppercaseletter, like: VOID WindowToFront()
  337.  
  338. Startup options.
  339. optional keywords about what sort of startup-code TurboDEX should
  340. generate, may be given between the brackets of PROC main() :
  341. ARG     The variables 'argadr' and 'argl' contain the command-line
  342.         passed to your program (both LONG).
  343. WB      Code will be added to start your program from workbench too.
  344. DETACH  makes a program auto-detaching, can be started from shell
  345.         without 'C:RUN'
  346. INIT    compiles no initcode at all, no opening of librarys etc,
  347.         for programs that need to be _VERY_ small (<200 bytes),
  348.         rarely usefull.
  349. example: PROC main(ARG)
  350. NOTE: it is not advisable to use more than one option at a time.
  351.  
  352. Build-In Variables:
  353. Presently, seven of them may be used: stdout, dosbase, graphicsbase,
  354. intuitionbase and mathffpbase (execbase is DEF sysbase[4]:LONG).
  355. When using these variables, code is genereated to provide a correct
  356. contents, and, when using a function from a library, the base is also
  357. defined. stdout contains the output filehandle (mostly the shell window),
  358. when using the WRITE statement: when it's 0, you can open a CON:, and
  359. put it's filehandle into the variable stdout. Furthermore, the variables
  360. argadr and argl (both LONG) may be used if the flag ARG is used
  361. in the header of main().
  362.  
  363.  
  364.  
  365. ------------------------------------------------------------------------
  366.                        4. STEP BY STEP TUTORIALS
  367. ------------------------------------------------------------------------
  368.  
  369. Assuming you copied DEX, A68K and BLINK to your C: directory, made
  370. a directory for storing your sources and the examplesources, and
  371. started up some editor to get things going, i will now give some small
  372. tutorials on DEX-programming.
  373.  
  374. Best you try to get the HelloWorld.dex program running first. This
  375. will give you a good impression on how the system works. load it in your
  376. editor to see what it looks like:
  377.  
  378. ' The HelloWorld program in DEX !
  379.  
  380. PROC main()
  381.   WRITE 'Hello, World!\n'
  382. ENDPROC
  383.  
  384. Now, change it to your needs, save it, and compile it with:
  385.  
  386. DEX HelloWorld -a
  387.  
  388. After all compiling has been done, check the directory the source is
  389. in. It should now contain two new files: HelloWorld.s and HelloWorld.
  390. I'll get back later on the contents of the .s file, now just execute
  391. the program by typing it's name. Please take note of the small size
  392. of the executable (i guess about 300 bytes).
  393.  
  394. You now used the basis of any dex program: the PROC main().
  395. this is the minimum of any program: you may add other procedures,
  396. which may have arguments and local variables. The WRITE instruction
  397. can be used for many more purposes than just writing string-contants:
  398. it can print variables in decimal, hexadecimal and ascii format,
  399. and nil-terminated strings. as an example we will now make a program
  400. that prints the starting address of the exec.library to the screen:
  401.  
  402. PROC main()
  403.   DEF sysbase[4]:LONG
  404.   WRITE 'execbase = $\h',sysbase
  405. ENDPROC
  406.  
  407. Here we do something new, we declare a global variable, like 'a'
  408.  
  409. DEF a:LONG
  410.  
  411. but now we state we would like to have it at a fixed address, $00000004.
  412. We can print out the contents of the variable sysbase by putting
  413. the formatcode '\h' (hexadecimal) in the outputstring, and the value
  414. following it.
  415.  
  416. I will now discuss some of the programs to be found in the directory
  417. with example sources to show how small programs could be developped.
  418. First here's the SHELL.DEX program:
  419.  
  420. ' TurboShell in TurboDEX
  421.  
  422. PROC main(DETACH)
  423.   DEF window:LONG, buffer=60:ARRAY, a:REGLONG, text:REGLONG
  424.   window := Open('con:10/10/400/100/TurboShell v0.0\0',1006)
  425.   VOID Write(window,'Shell by $#%! in 1991. \aquit\a to stop.\n',LEN)
  426.   WHILE text?"quit"
  427.     VOID Execute(buffer,0,window)
  428.     VOID Write(window,'Turbo> ',LEN)
  429.     a := Read(window,buffer,59)
  430.     MCHAR buffer+a,0
  431.     text := MLONG(buffer)
  432.   ENDWHILE
  433.   VOID Close(window)
  434. ENDPROC
  435.  
  436. It's a very small program that show's clearly enough how to use some of
  437. the language's features. Here's a step-by-step explanation of how
  438. it works:
  439.  
  440. Because it's a small program, all code is gathered in one procedure,
  441. and we tell the compiler that we want to give the Shell-prompt back
  442. after our program is loaded with the DETACH option. Now we define
  443. a couple of variables for use in the program: in 'window' we will
  444. store the filehandle to our CON:-window, 'a' and 'text' are for use
  445. lateron and buffer is an array of 60 bytes, which we will use to store
  446. the commandline Note that 'buffer' is actually a variabele of the type
  447. LONG which contains a pointer to that array. Now we use Open() from
  448. the dos.library to open our console window, and we do not check if
  449. an error occurred, for the simplicity of the example. Note that you
  450. do not need include-files modules to be linked or whatever to be 
  451. able to use functions like Open, they're build in to the language.
  452. Now we use the dos.library Write() (not the DEX WRITE!) to output
  453. a message to it: We could have done this using WRITE, but the example
  454. is about system-functions. Now we come in a loop which we will only
  455. exit if 'text' is unequal to the (LONG-encoded) string "quit".
  456. In this loop, we will Read() something from the console, and then
  457. Exexute() it as a cli-command. Note that we use MCHAR (put a CHAR-sized
  458. value into memory) to terminate the string.
  459.  
  460. Here's a somewhat longer example to get the feeling of how things
  461. are done in DEX, COLORSCREEN.DEX
  462.  
  463.  
  464. ' Open a screen and do something
  465.  
  466. PROC main()
  467.   DEF rast:LONG,screen:LONG
  468.   DEF sx:REGINT, sy:REGINT
  469.   screen := screen(320,256,5,0,' TurboDEX Screen \0')
  470.   rast := screen+84
  471.   MOUSE
  472.     FOR sx,0,319
  473.       FOR sy,0,255
  474.         VOID SetAPen(rast,sx*sy)
  475.         VOID WritePixel(rast,sx,sy)
  476.         JUMPMOUSE leave
  477.       ENDFOR
  478.     ENDFOR
  479.   ENDMOUSE
  480.   leave:
  481.   VOID CloseScreen(screen)
  482. ENDPROC
  483.  
  484. PROC screen( width, height, depth, mode, title)
  485.   LOCAL width[ns.4]:INT, height[ns.6]:INT, depth[ns.8]:INT, mode[ns.12]:INT
  486.   LOCAL title[ns.20]:LONG, return:REGLONG
  487.   return := OpenScreen({ns})
  488.   STRUCT ns
  489.     INT  0,0,320,256,2,$203,0,1
  490.     LONG 0,0,0,0
  491.   ENDSTRUCT
  492. ENDPROC return
  493.  
  494.  
  495. Because there's no command like OPENSCREEN in in DEX (yet), we make 
  496. a usefull procedure to easily open screen (see NEWWINDOW.DEX) for a
  497. window example), which we can add to our sources anytime we want a screen.
  498. We pass the characteristics of the screen via screen(), and get
  499. back the pointer to the screen, which we should, in a non-example 
  500. program, check against zero. Note well: all local variables used are
  501. declared as being part of a struct, which allows very flexible
  502. addressing, and effecient code.
  503.  
  504. In the main program we enter the big MOUSE - ENDMOUSE loop which
  505. is very handy for demo-like programs like this one. it is accompanied
  506. by an extra JUMPMOUSE for faster exit. The inner loop draws the screen
  507. full of colourfull pixels. Note the VOID intruction: we're not interested
  508. in the returnvalues ( 'VOID' is like 'dummy:=' ), when calling the
  509. procedure screen(), we are: ENDPROC gives us the screenptr.
  510.  
  511. Now we will look at a complete utility in DEX, with errorchecks
  512. To make it usefull for everyday use: a three-column dir-command!
  513. DIRQUICK.DEX displays filelenght too and makes use of extended WRITE
  514. string-formatting.
  515.  
  516.  
  517. ' nice directory command in dex !
  518.  
  519. PROC main(ARG)
  520.   DEF lock:LONG, info=260:ARRAY, ok:REGLONG, d:REGLONG, c:REGLONG
  521.   DEF dir:LONG
  522.   MCHAR argadr+argl-1,0
  523.   lock := Lock(argadr,-2)
  524.   IF lock?0
  525.     ok := Examine(lock,info)
  526.     IF ok?0
  527.       dir := MLONG(info+4)
  528.       IF dir>0
  529.         WRITE 'Directory of: \s\n',info+8
  530.         c := 0
  531.         WHILE ok?0
  532.           ok := ExNext(lock,info)
  533.           INC 1,c
  534.           IF ok?0
  535.             d := MLONG(info+124)
  536.             dir := MLONG(info+4)
  537.             IF dir>0
  538.               WRITE '\e[1;32m\w25\m25\l\s\e[0;31m',info+8
  539.             ELSE
  540.               WRITE '\w17\m17\l\s \r\w7\d',info+8,d
  541.             ENDIF
  542.             IF c=3
  543.               WRITE '\n'
  544.               c := 0
  545.             ELSE
  546.               WRITE ' '  
  547.             ENDIF
  548.           ENDIF
  549.         ENDWHILE
  550.         IF c?1
  551.           WRITE '\n'
  552.         ENDIF
  553.       ELSE
  554.         WRITE 'No Dir!\n'
  555.       ENDIF
  556.     ENDIF
  557.     VOID UnLock(lock)
  558.   ELSE
  559.     WRITE 'What ?!?\n'
  560.   ENDIF
  561. ENDPROC
  562.  
  563.  
  564. At every step in the program we check if an error may have occurred,
  565. and we put all the nested IF's into one procedure: after making the
  566. neccesary locks and examines, we read each entry, and put it directly
  567. on the screen, directory's and files each their own color for distinction.
  568. Those WRITE statements are good examples of somewhat more complex
  569. string/integer formatting. Note we keep track of the column we're in 
  570. with variable 'c'.
  571.  
  572. Here's short description of all other examples:
  573.  
  574. DIRSORT.DEX     An extented version of DIRQUICK.DEX, does a very
  575.                 slow bubble sort on the entries before displaying, and
  576.                 separates the directories from the files. can only read
  577.                 dir's with less than 400 entries (changeable).
  578. ASLREQ.DEX      a demo of how non-DEX-standard-kick-2-libraries may be 
  579.                 used: it puts up the ASL-filerequester, and checks
  580.                 nicely if you have KICK2, if it could open the library etc.
  581. PLAYSAMPLE.DEX  Show's how the buil-in hardware-register variables
  582.                 can be used to play a beep.
  583. COPPER.DEX      Show's the ease of copper-programming from DEX
  584. NEWWINDOW.DEX   Opens a intuition-window and output's a text it.
  585. ARG.DEX         Show's how to handle commandline arguments from DEX.
  586. SPEED.DEX       Proggie to show off DEX's optimed loops.
  587. RESIDENT.DEX    Display's all exec resident modules. Shows how for example
  588.                 system lists can be dumped.
  589. VECTOR.DEX      A vectorDemo in DEX that rotates the word 'TurboDEX' on
  590.                 the screen in three colours, using the graphics.library,
  591.                 double-buffering and a precalculated-coordinate list
  592.                 in the file VECTOR.BIN. If you want to compile
  593.                 this program, make sure the INCLUDE statement in the
  594.                 source points to where you have the .BIN file.
  595.  
  596.  
  597.  
  598. -------------------------------------------------------------------------
  599.                5. ALPHABETICAL DESCRIPTION OF INSTRUCTIONS
  600. -------------------------------------------------------------------------
  601.  
  602. -----------
  603. AND, OR, NOT
  604. -----------
  605. syntax:      AND value,variable
  606.              OR value,variable
  607.              NOT variable
  608. description: Performs logical and, or and not on a variable.
  609.              NOTE: AND and OR  are also available as operators in an
  610.              expression (&,^).
  611. example:     AND $ff,c
  612.              NOT x
  613.  
  614. -----------
  615. ASM, ENDASM
  616. -----------
  617. syntax:      ASM
  618.              ENDASM
  619. description: all following this statement until ENDASM will not be compiled
  620.              by the compiler, and is put unchanged into the output file,
  621.              thus enabling inline assembly. if registers D2-D7 are used,
  622.              these should be put on the stack first. Make sure you use
  623.              distinct labels: best way is to prefix them.
  624. example      ASM
  625.                moveq #0,d0
  626.              ENDASM
  627.  
  628. -----------
  629. CALL
  630. -----------
  631. syntax:      CALL address, paraddress, returnvar
  632.              CALL base[offset], paraddress, returnvar
  633. par:         address = any memory location that is the start of a routine
  634.              base = base address of a library
  635.              offset = offset from a librarybase, like -552
  636.              paraddress = pointer to memory chunk of 14 longwords,
  637.              containing the parameters to a routine, in d0-d7/a0-a5 order.
  638.              returnvar = variable to put the returnvalue in
  639.              NOTE: both paraddress and returnvar are optional.
  640. description: this instruction enables you to call any assembly language
  641.              subroutine, and in particular librarycalls that are not
  642.              part of the DEX set.
  643.              see the ASLREQ.DEX source for a good example.
  644. example:     ' assuming you have an initialized variable called 'aslbase':
  645.  
  646.              CALL aslbase[-30],,reqadr
  647.  
  648.              ' this will call AllocFileRequest() from the asl.library 
  649.              ' reqadr may contain 0
  650.  
  651.  
  652. -----------
  653. CMOVE, CWAIT, CSKIP, CPART, CSTOP
  654. -----------
  655. syntax:      CMOVE value,customreg
  656.              CWAIT rastline,rastpos
  657.              CSKIP rastline,rastpos
  658.              CPART
  659.              CSTOP
  660. par:         customreg = valid name for a customchip register, like: BLTSIZE
  661.              rastline = beam y position (0-255)
  662.              rastpos = beam x position (0-$E0)
  663. description: Instructionset to code the copper coprocessor. these
  664.              instructions need to be gathered in a CHIPSTRUCT
  665.              See your Hardware Reference Manual for more information on
  666.              functioning of these instructions. CSTOP designates the 
  667.              end of a copper-list, CPART needs to precede any intructions
  668.              that are to be executed after rasterline 255.
  669. example:     ' Split screen in two colors and be very rude to multitasking;
  670.  
  671.              PROC main()
  672.                COP2LCH := {coplist}
  673.                INTENA := $4000
  674.                MOUSE
  675.                ENDMOUSE
  676.              ENDPROC
  677.  
  678.              CHIPSTRUCT coplist
  679.                CMOVE $fff,COLOR00
  680.                CWAIT 80,$01
  681.                CMOVE $f00,COLOR00
  682.                CSTOP
  683.              ENDCHIPSTRUCT
  684.  
  685. -----------
  686. DEC, INC
  687. -----------
  688. syntax:      DEC value,variable
  689.              INC value,variable
  690. description: Substracts or adds the value (-8 to 8 excluding 0)
  691.              to the indicated variable.
  692. example:     INC count
  693.  
  694. -----------
  695. DEF, LOCAL
  696. -----------
  697. syntax:      DEF varname:TYPE [, ... ]
  698.              LOCAL varname:TYPE [, ... ]
  699. par:         type = any of the types of variables discussed in the above 
  700.              section of variabletypes (like LONG, ARRAY etc.)
  701.              varname = any string, signifying the name of the variable. may
  702.              be followed by = with a value (LONG, INT, CHAR only) to 
  703.              initialize it before use (default = 0). Using = with ARRAY
  704.              signifies the size of the array (like string=100:ARRAY).
  705. description: declares a variable before use, where DEF defines the
  706.              variables that can be used in any module (global), and LOCAL those
  707.              which can only be used in one module (local).
  708. example:     DEF adr:LONG, sign=25:CHAR, count:REGINT, string=256:ARRAY
  709.              LOCAL item[data.6]:INT, picture=10240:ARRAYCHIP
  710.  
  711. -----------
  712. DIV, MUL
  713. -----------
  714. syntax:      var := MUL(exp,exp)
  715.              var := DIV(exp,exp)
  716. description: MUL and DIV are 32 bit substitutes for the * and / operators.
  717.              The 68000 processor doesn't support 32 bit multiplication and
  718.              division, only 16 bit. dex compiles * and / using 16 bit,
  719.              for speed reasons, and tries to use 32 bit shifts when
  720.              possible. Mostly this isn't a problem, but when it is,
  721.              the slower DIV and MUL routines can be called to use
  722.              the full 32 bit.
  723.  
  724. -----------
  725. DOWN, ENDDOWN
  726. -----------
  727. syntax:      DOWN counter,loops
  728.              ENDDOWN
  729. par:         counter = (var) variable decreased by the loop
  730.              loops = (exp) number of times loops should be executed
  731. description: this is a simple FOR loop. the counter will be decreased
  732.              to zero, f.e. if you specify 100 for loops, the counter will
  733.              go from 99 to 0. the must end with an ENDDOWN.
  734.              NOTE: Because the only reason to use DOWN over FOR is
  735.              speed, it can only be used with REG variables (i.e. REGLONG).
  736. example:     DOWN count,1000000
  737.                ' fast loop here
  738.              ENDDOWN
  739.  
  740. -----------
  741. ENDPROC
  742. -----------
  743. syntax:      ENDPROC returnvalue
  744. par:         returnvalue = (exp) result of the PROC
  745. description: marks the end of a procedure and returnes a value to the
  746.              whatever called it. Default is zero
  747. example      see PROC example 2
  748.  
  749. -----------
  750. EXIT
  751. -----------
  752. syntax:      EXIT returnvalue
  753. par:         returnvalue (exp) = returncode for dos
  754. description: exits program at any point in the program.
  755. example:     EXIT 5
  756.  
  757. -----------
  758. FOR, ENDFOR
  759. -----------
  760. syntax:      FOR counter,start,end [,step]
  761.              ENDFOR
  762. par:         counter = (var) the variable that counts the loops
  763.              start = (exp) begin value of counter
  764.              end = (var or value) value for the loop to end with.
  765.              step = a value between 8 and -8 (excluding 0), default 1
  766. description: The loop will be executed as many times as specified by 
  767.              start and end. meanwhile, the counter is being increased
  768.              with every loop. as standard, the counter will be increased
  769.              by 1, specifying a step changes this.
  770. example:     FOR counter,0,319,2
  771.                VOID Move(rast,counter,0)
  772.                VOID Draw(rast,counter,255)
  773.              ENDFOR
  774.  
  775. -----------
  776. GOTO
  777. -----------
  778. syntax:      GOTO labelname
  779. description: continues the execution of the program within one module
  780.              at the place of the label.
  781. example:     IF a/20=3
  782.                GOTO someplace
  783.              ENDIF
  784.              ' rest of the program
  785.              someplace:
  786.  
  787. -----------
  788. IF, ELSEIF ELSE, ENDIF
  789. -----------
  790. syntax:      IF equation
  791.              ...
  792.              [ ELSEIF equation ]
  793.              ...
  794.              [ ELSEIF equation ]
  795.              ...
  796.              [ ELSE ]
  797.              ...
  798.              ENDIF
  799. par:         equation (exp) = expression to be equated.
  800. description: the programblock between IF and ENDIF will only be executed
  801.              if the expression is TRUE. if it is FALSE, however, it will
  802.              be skipped, and an ELSEIF block may be executed if that
  803.              equation is TRUE. If an ELSE block is present, it will only be
  804.              executed if all the other IF's were FALSE.
  805. example:     IF a>1000
  806.                WRITE 'hey dude, \d is a little too much!!!\n',a
  807.              ELSEIF a<0
  808.                WRITE 'what about that?\n'
  809.              ELSE
  810.                WRITE 'that's more like it!\n'
  811.              ENDIF
  812.  
  813. -----------
  814. INCLUDE
  815. -----------
  816. syntax:      INCLUDE filename
  817. description: Includes any binary file into the program. Statement
  818.              needs to be part of a STRUCT to be accessed properly.
  819.              filename doesn't need quotes.
  820.  
  821. -----------
  822. JUMPMOUSE
  823. -----------
  824. syntax:      JUMPMOUSE label
  825. description: If the leftmousebutton is pressed at the moment this
  826.              instruction is executed, execution of the program will be
  827.              continued at <label> (only within one module).
  828.  
  829. -----------
  830. LONG, INT, CHAR
  831. -----------
  832. syntax:      LONG value1, value2, ...
  833.              INT value1, value1, ...
  834.              CHAR value1, value2, ...
  835. par:         value = any number like 4, 100, $c00000 etc. additionally,
  836.              with CHAR you may use strings, like: CHAR 'hello\0', and with
  837.              LONG you may use the adresses of programlabels, like:
  838.              LONG vectordata .
  839. description: with these statements you can put data of the appropriate
  840.              format into your program. they are only usefull within a
  841.              struct.
  842. example:     anylabel:
  843.              structadr := {anystruct}
  844.              STRUCT anystruct
  845.                INT 0,10240,512
  846.                LONG $c00000,anylabel,4
  847.                CHAR 0,25,'anystring\n\0',34,227
  848.              ENDSTRUCT
  849.  
  850. -----------
  851. LOOP, ENDLOOP
  852. -----------
  853. syntax:      LOOP
  854.              ENDLOOP
  855. description: builds an infinite loop. Must end with ENDLOOP. be sure there
  856.              is an exit out of the loop.
  857. example:     LOOP
  858.                WRITE 'An everlasting loop\n'
  859.              ENDLOOP
  860.  
  861. -----------
  862. MLONG,MINT,MCHAR
  863. -----------
  864. syntax:      MLONG address,value
  865.                       or
  866.              value := MLONG(address)
  867. par:         address (exp) = any valid memory address, with MLONG and
  868.              MINT this needs to be at an equal address.
  869.              value (exp) = the value to be 'poked' into, or read from
  870.              that memorylocation.
  871. description: Commands similar to PEEK and POKE in basic, poke a longword,
  872.              word and byte respectively.
  873. example:     MCHAR $40000+a,b-1
  874.  
  875. -----------
  876. MOUSE, ENDMOUSE
  877. -----------
  878. syntax:      MOUSE
  879.              ENDMOUSE
  880. description: these make a loop that will be repeated as long as the
  881.              left mousebutton is not pushed.
  882. example:     MOUSE
  883.                VOID movesprites(x,y,3)
  884.                VOID playtune()
  885.              ENDMOUSE
  886.  
  887. -----------
  888. WRITE
  889. -----------
  890. syntax:      WRITE 'string'
  891. par:         'string' = any string of ascii signs, that may contain
  892.              codes with an '\' (see above for a discussion on strings
  893.              and codes).
  894. description: prints any string and/or integers etc. to standard output
  895.              (normally the cli/shell window); can be used to write to
  896.              files by saying:  stdout:=Open(...)  etc. 
  897. example:     PROC main()
  898.                WRITE 'Hello, World!\n'
  899.              ENDPROC
  900.  
  901. -----------
  902. PROC
  903. -----------
  904. syntax:      PROC name(par1, par2, ...) 
  905. par:         name,par = any normal string like 'dosomething', 'rastport'
  906.              these must be defined in this PROC as local variables.
  907. description: designates the beginning of a procedure. procedures should
  908.              not be nested, and the end of a procedure should always end
  909.              with an ENDPROC statement. Zero upto eight parameters can be
  910.              passed to localvars. Arguments for a PROC need to declared
  911.              as the first local variables in that module. for more info on
  912.              return values (as in example 2) see ENDPROC
  913.              Info on the main PROC can be found elsewhere
  914. example 1  : PROC screenflash()
  915.                VOID DisplayBeep(0)
  916.              ENDPROC
  917. example 2  : result=addition(x,y)
  918.              ...
  919.              PROC addition(value1, value2)
  920.                LOCAL value1:LONG, value2:LONG 
  921.              ENDPROC value1+value2
  922.  
  923. -----------
  924. REPEAT, UNTIL
  925. -----------
  926. syntax:      REPEAT
  927.              UNTIL equation
  928. description: The block within REPEAT/UNTIL is repeated as long as the
  929.              truth for the equation holds. Thus, this loop will always
  930.              be executed atleast once: the UNTIL will jump to the
  931.              beginning of the loop if the equation is TRUE.
  932. example:     REPEAT
  933.                Read(fh,buf,10)
  934.              UNTIL {buf}="quit"
  935.  
  936. -----------
  937. SIZEOF
  938. -----------
  939. syntax:      size := SIZEOF(label)
  940. description: SIZEOF returns the size of the STRUCT indicated by the label.
  941. example:     see STRUCT
  942.  
  943. -----------
  944. STRUCT, ENDSTRUCT
  945. -----------
  946. syntax:      STRUCT structname
  947.              ENDSTRUCT
  948. description: this statemenent adds a struct to your program. it can be
  949.              anywhere in the program, since it will be compiled to a
  950.              place separate from the code. see description of LONG etc.
  951.              for more info's. The statements CHIPSTRUCT and ENDCHIPSTRUCT
  952.              function exactly the same way, but will be allocated in
  953.              chipmem (handy for copperlists, see CMOVE etc.).
  954. example:     a := SIZEOF(newscreen)
  955.              STRUCT newscreen
  956.                INT 0,0,640,256
  957.                LONG 0,0, ... etc.
  958.                CHAR 'WindowTitle\0'
  959.              ENDSTRUCT
  960.  
  961. -----------
  962. WHILE, ENDWHILE
  963. -----------
  964. syntax:      WHILE equation
  965. par:         equation = (exp) comparison to be equated.
  966. description: the loop between WHILE and ENDWHILE is repeated as long as
  967.              the equation is TRUE. the program will continue after
  968.              ENDWHILE as soon as the equation is false. this loop must
  969.              end with ENDWHILE.
  970. example:     WHILE a/3+1 > 100
  971.                a := a-1
  972.              ENDWHILE
  973.  
  974.  
  975.  
  976.  
  977. ------------------------------------------------------------------------
  978.                 6. ADVANCED PROGRAMMING AND LANGUAGE INFO'S
  979. ------------------------------------------------------------------------
  980.  
  981. This chapter is about:
  982.  
  983. - DEX <-> Assembly conventions.
  984. - Code generated by DEX / Optimizing.
  985. - Debugging.
  986. - EBNF overview of DEX syntax.
  987. - DEX as a language concept / The future of DEX.
  988.  
  989.  
  990. To use the inline assembly feature without trouble, it's best to
  991. know a few things about TurboDEX code-generation:
  992.  
  993. Register use: normally you may trash ALL (except A7, ofcourse!)
  994. registers, since none are used to point at vital data during the
  995. course of the program. However, REG variables are stored in D2-D7,
  996. (starting with D7) so if you use these in your DEX code, you may not
  997. trash these. Using REG-variables can also be a fine way to allocate
  998. a register for permanent use in a PROC, for example:
  999.  
  1000. PROC bla()
  1001.   LOCAL a:REGINT, b:REGLONG
  1002.   ...
  1003.   ASM
  1004.     ...  (use D6/D7 here)
  1005.   ENDASM
  1006.   ...    (use a/b here)
  1007. ENDPROC
  1008.  
  1009. In this module you could store something permanent in D6/D7, without
  1010. the danger of getting them trashed: DEX will preserve these registers
  1011. if they need to be used for a (system-)functioncall.
  1012. This is the sort of PROC-setup you'd be using to obtain very optimized
  1013. code.
  1014.  
  1015. D0-D1/A0-A1 may ofcourse be trashed by assembly as well as DEX code.
  1016. Functions like WRITE are likely to trash more address-registers than
  1017. just these.
  1018.  
  1019. Sharing local and global variables:
  1020. Each variable has a label that can be used to access DEX-variables
  1021. from within the inline assembler, they are build as folows:
  1022.  
  1023. ModuleName + 'var' + VariableName
  1024.  
  1025.           PROC bla()
  1026. Example:    DEF screen:LONG      gives EA:   mainvarscreen
  1027.             LOCAL a:INT                      blavara
  1028.           ENDPROC
  1029.  
  1030. note that global variables always have ModuleName = 'main'
  1031.  
  1032. if you want to have an overview of the each effective address
  1033. then compile your program with option -l, also have a look at the
  1034. source (the .s file) TurboDEX generates to get the idea.
  1035.  
  1036. Accessing of labels and arrays is just as easy:
  1037.  
  1038. PROC main()                 will yield:     proglabmain
  1039. DEF string=80:ARRAY                         arraylabstring
  1040. start:                                      proglabstart
  1041. STRUCT newscreen                            proglabnewscreen
  1042.  
  1043. If your program uses functions from a certain library, the base of
  1044. that library can be accessed by LibraryName + 'base' (f.e. dosbase).
  1045.  
  1046. Debugging hints:
  1047. Apart from debuggingmethods that may be used on any language/compiler,
  1048. following are specifically handy with DEX:
  1049. - expressions: as these are different from other other languages,
  1050.   it's very likely mistakes are made: check out the order of
  1051.   operators/comparison's, problems that may occur when using/comparing
  1052.   variables of different sizes (LONG/CHAR) etc.
  1053. - compile with -l to see if you possibly made errors in declaration
  1054.   of variables etc.
  1055. - check variables that contain pointers, as DEX does no type-checking
  1056. - throwing the assembly source through a source-level debugger will
  1057.   mostly indicate the problem :-) .
  1058.  
  1059. BNF overview of the language:
  1060. The compiler-builders under the readers may find it clarifying
  1061. to see some structural elements formalized (not complete): 
  1062.  
  1063. <program> ::= { <procedure> }
  1064. <procedure> ::= PROC <label> ( <definitionlist> )
  1065.         { <defstatement> | <localstatement> }
  1066.         { <statementblock }
  1067.         ENDPROC <exp>
  1068. <label> ::= <ident>
  1069. <variable> ::= <ident>
  1070. <ident> ::= <letter> { <character> }
  1071. <character> ::= <letter> | <digit>
  1072. <definitionlist> ::= <definition> { , <definition> }
  1073. <definition> ::= <variable> : <type> | 
  1074.         <variable> = <integer> : <type> |
  1075.         <variable> [ <absolute> ] : <type>
  1076. <type> ::= CHAR | INT | LONG | REGLONG | REGCHAR | REGINT |
  1077.         ARRAY | ARRAYCHIP
  1078. <integer> ::= <digit> { <digit> } |
  1079.         $ <hexcharacter> { <hexcharacter> }
  1080.         % 0 | 1 { 0 | 1 }
  1081. <absolute> ::= <integer> | <label> . <integer>
  1082. <defstatement> ::= DEF <definitionlist>
  1083. <localstatement> ::= LOCAL <definitionlist>
  1084. <statementblock> ::= { <statement> | <assignment> }
  1085. <exp> ::= <empty> | <expitem> { <operator> <expitem> }
  1086. <empty> ::=
  1087. <expitem> ::= <integer> | <variable> | '{' <label> '}' | " <ascii's> " |
  1088.         ' <ascii and format characters> '
  1089. <operator> ::= + | - | * | / | & | ^ | = | > | < | ?
  1090. <assignment> ::= <variable> := { <exp> | <procedurecall> |
  1091.         <function> | <systemcall> }
  1092. <procedurecall> ::= <label> <argumentlist>
  1093. <function ::= <keyword> <argumentlist>
  1094. <systemcall> ::= <amigasystemcall> <argumentlist>
  1095. <argumentlist> ::= () | ( <exp> { , <exp> } )
  1096. <statement> ::= { <structuralstatement> | <otherstatement> }
  1097. <structuralstatement> ::= <conditionalstatement> | <loopstatement>
  1098. <loopstatement> ::= <repeatstatement> | <forstatement> | ...
  1099. <repeatstatement> ::= REPEAT <statementblock> UNTIL <exp>
  1100. <forstatement> ::= FOR <variable> , <exp> , <integer>
  1101.         <statementblock> ENDFOR
  1102. <conditionalstatement> ::= <ifstatement> | ...
  1103. <ifstatement> ::= IF <exp> <statementblock> ENDIF |
  1104.         IF <exp> <statementblock> <elseblock> ENDIF
  1105. <elseblock> ::= { ELSEIF <exp> <statementblock> } |
  1106.         { ELSEIF <exp> <statementblock> } ELSE <statementblock>
  1107.  
  1108. Some definitions are missing, some things are simplified, and
  1109. of all instructions only a few are taken as an example. Just
  1110. to give the reader a view on the matter.
  1111.  
  1112.  
  1113.  
  1114. DEX as a language concept.
  1115. As you might have noticed, DEX is not a complicated language when
  1116. it comes to structural and typological elements. It belongs to
  1117. a family of three languages sofar, and is derived from the language E,
  1118. which inturn has mostly been influenced by Modula2 and some C.
  1119. In DEX only the fundamentals of E are left, nearly all advanced features
  1120. of the language are not contained in DEX, and DEX has few enhancements,
  1121. some as replacement of the proffessional features in E, others just
  1122. Amiga-specific add-ons.
  1123.                                E
  1124.                               / \
  1125.                              /   \
  1126.                             /    EEX
  1127.                            /
  1128.                          DEX
  1129.  
  1130. Another language in the family, also derived from E, is EEX. It
  1131. stands much closer to the original E language definition, and is
  1132. richer in structure, it only misses some of the complex OOP features
  1133. of E.
  1134.  
  1135. Import characteristics of E (and to some extend, also DEX and EEX)
  1136. as opposed to typical influences such as Modula2 (and some C) are:
  1137.  
  1138. 1. The Principle of True Inline Assembly:
  1139.    As no higher programming language can be an 'ideal' programming
  1140.    language, because only Assembly is, E has the feature of true
  1141.    inline assembly: assembly instructions are part of the language,
  1142.    and are equal to E instructions when it comes to using identifiers
  1143.    etc. Note that DEX has this feature only partly
  1144. 2. The Principle of System-Integration:
  1145.    the E language has OS-specific features in the core of the language.
  1146.    Because of 1 and 2 principle 3 automatically holds:
  1147. 3. The Principle of Non-Portability:
  1148.    Languages like DEX and EEX derived from E are designed to be non-
  1149.    portable: Programs should use machine-specific features (in this
  1150.    case AmigaOs 1.2 and up) for highest quality app's.
  1151. 4. The Principle of the Typeless Variables:
  1152.    E is Typeless. Types, as do exist in DEX (not to mention Oberon),
  1153.    are gathered to one, as for example in EEX, where all types are
  1154.    LONG. Only where it comes to OBJECT's and reading CHAR's out of
  1155.    memory, EEX has some type-definitions.
  1156.  
  1157.  
  1158.  
  1159.  
  1160. ------------------------------------------------------------------------
  1161.                           7. ADDITIONAL INFO'S
  1162. ------------------------------------------------------------------------
  1163.  
  1164. TurboDEX Compiler v1.1 released as DonationWare in 1992, first
  1165. public release.
  1166.  
  1167. Together with this distribution you will find A68k, Blink and their docs,
  1168. see those for distribution contraints. Thanx go to Charlie Gibbs (A68k)
  1169. and The Software Distillery (Blink), as well as Raymond Hoving and Chris
  1170. Straman (for their beta-testing and moral support :*-)
  1171.  
  1172. NOTE to future DEX coders: people that use DEX more than occasionally
  1173. and get stuck may count on full support by me, the compiler author. Send 
  1174. your unsolvable problems or requests for hints/tips/tricks/enhancements
  1175. to me (i prefer electronic above paper mail). Also sources of for example
  1176. completed utilities in DEX may be send for inclusion in a library of
  1177. DEX-sources to be distributed with future releases for the benefit of
  1178. beginning DEX programmers.
  1179.  
  1180. Needless to say, but: TurboDEX may be copied, crunched and used freely as
  1181. long as the full distribution is with it, and no modifications are made
  1182. to either the executable, the doc or the supportfiles.. For spreading on (pd)
  1183. disk series other than that of Fred Fish you need my written permission.
  1184. I will personally RemHead() and AbortIO() those 'Pd-Distributors' that sell
  1185. this program for more than a copy-fee.
  1186.  
  1187. For those of you who don't know DonationWare, it's the same as Shareware,
  1188. with three principle differences: You may yourself decide on the size of the
  1189. gift, payment can be done in anything, and you don't have to feel guilty if
  1190. you don't send anything at all. Future versions, and other productions
  1191. (yes: lotsa nice stuf coming up) depend on YOU. (you guessed that .. right?)
  1192.  
  1193. Also bug-reports, nice letters, software, turboboards are all accepted as
  1194. donation ...
  1195.  
  1196.          Wouter van Oortmerssen ($#%!)
  1197.          Levendaal 87
  1198.          2311 JG  Leiden
  1199.          HOLLAND
  1200.  
  1201. Or even better Email:
  1202.  
  1203.          Wouter@alf.let.uva.nl
  1204.  
  1205.  
  1206.