home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / robot-pd / 12400.ZIP / 12400B.DSK / manual05.txt < prev    next >
Text File  |  1998-04-30  |  21KB  |  635 lines
  1. ═
  2.                  ╩C H A P T E R   F I V EΩ
  3.  
  4.  
  5. ╩5 COMP - Extended BASIC Language CompilerΩ
  6.  
  7. ╩FormatΩ :╔COMP [<selectors>] <source.file> <object.file>Θ
  8.  
  9. The compiler reads  through  the  given  source  file  and
  10. converts it into a BASIC program. This program can then be
  11. executed under Centrox in the  same  way  as  a  transient
  12. program. The object code produced by COMP will  be  placed
  13. in the destination file path.
  14.  
  15. Compilation can be aborted by holding down the "Q" key for
  16. about one second.
  17.  
  18. The selector "S" produces  system  object  code.  If  this
  19. option is selected then COMP will create a /COM file.  The
  20. file name element of the destination  file  path  will  be
  21. acknowledged but the directory path and file type will  be
  22. ignored.
  23.  
  24. Single drive users can only use this option if the  source
  25. code is held on  the  SYSTEM  disk.  The  easiest  way  to
  26. transfer your source across is to load it into  CTX,  then
  27. save it back onto the system disk.
  28.  
  29. The selector "E" produces error trapped code. If an  error
  30. occurs the program will display the BASIC error number and
  31. line, by default this switch is disabled which means  that
  32. errors cause the system to return to BASIC.
  33.  
  34.  
  35. ╩5.1 Source File RequirementsΩ
  36.  
  37. EBL differs from BASIC  in  that  it  does  not  use  line
  38. numbers.  The  program  is  laid  out  as  a   series   of
  39. statements, for which only the  order  is  important.  The
  40. actual "style" of the text is irrelevant to the computer.
  41.  
  42. It is recommended that all global variables be defined  in
  43. one go, right at the start.  The  term  "global  variable"
  44. simply means a type of variable which can be  accessed  by
  45. any part of the program. All  locomotive  BASIC  variables
  46. are global, for example.
  47.  
  48. Note that all the commands listed here can be  abbreviated
  49. by truncating the command name, and following it by a dot.
  50.  
  51. Comments can be inserted by enclosing the text between two
  52. braces eg: {This is a comment}
  53.  
  54. Commands must  be  followed  by  a  semicolon  `;'.  Older
  55. versions of the  compiler  allowed  the  semicolon  to  be
  56. omitted if it was at the end of a line-THIS IS  NO  LONGER
  57. ALLOWED.
  58.  
  59. Extensive use  is  made  of  complex  overlay  techniques.
  60. Whilst this releases  useful  memory,  it  does  have  the
  61. disadvantage of increasing disk access. As a  result,  the
  62. compiler does run fairly slowly. With a trailing  wind  it
  63. can average 10 lines per minute!
  64.  
  65.  
  66. ╩5.2 ProceduresΩ
  67.  
  68. Procedures are similar to subroutines. That is,  they  are
  69. sections of code which can be "called"  (invoked)  at  any
  70. time to carry out  frequently  required  tasks.  The  main
  71. difference between a subroutine and a  procedure  is  that
  72. procedures have defined entry and exit  points-subroutines
  73. do not.
  74.  
  75. The other difference is that procedures usually provide  a
  76. means by which arguments can be passed into  the  routine.
  77. They also provide for the creation of  "local"  variables.
  78.  
  79. Local variables become invisible  whenever  a  section  of
  80. code outside "their" procedure  is  being  executed.  This
  81. provides TOTAL  isolation  for  a  procedure's  variables,
  82. reducing the possibility of unwanted interference.
  83.  
  84.  
  85. ╩5.3 Using CommandsΩ
  86.  
  87. The compiler is only programmed with program flow commands
  88. such as IF..THEN, WHILE..WEND etc. It is up to the user to
  89. define ╔actionΘ commands such as PRINT,≤DRAW etc.≤They can
  90. be defined using the DEFCOM command, or inserted  directly
  91. into the BASIC code using the "INLINE" command.
  92.  
  93.  
  94. ╩5.4 Code BlocksΩ
  95.  
  96. Most of the structure commands work on a  principle  known
  97. as code  blocking.  One  example  of  this  is  the  BASIC
  98. WHILE...WEND structure. The code  being  repeated  can  be
  99. thought of as a block of instructions. This  principle  is
  100. extended in EBL.
  101.  
  102. It is considered good practice to indent each  section  of
  103. code in a block. This improves readability of the code, as
  104. it makes it easier to see where a code block has not  been
  105. closed.
  106.  
  107.  
  108. ╩5.5 Command DictionaryΩ
  109.  
  110. Each of the commands listed  is  given  in  the  following
  111. format:-
  112.  
  113. 1.Command Format.
  114.  
  115. Describes the general form of the command-ie exactly  what
  116. the compiler can expect. This information is given in  the
  117. same form as for the O.S. command list.
  118.  
  119. 2.Example Code.
  120.  
  121. This is a short section of code which shows one use of the
  122. command under consideration. In all the examples, only the
  123. relevant section  of  code  is  given.  The  commands  and
  124. functions shown may need to have  been  defined  elsewhere
  125. for the example to ╔workΘ.
  126.  
  127.  
  128. ╩5.5.1 Definition CommandsΩ
  129.  
  130.  
  131. ╩FormatΩ :╔DEFTITLE("<Title string>"[,version[,mark]]);Θ
  132. (Overlayed)
  133.  
  134. This  changes  the  program  title  from  the  default  of
  135. <program name>. This title will form part of the copyright
  136. banner. The version and mark numbers can  also  be  added.
  137. Note that the message:-
  138.  
  139. The format of the copyright banner is:-
  140. <Title String> v<version>.<mark> - (c) <user name>, <year>
  141. Where <version> and <mark> default to 1 and 0.
  142.  
  143. The copyright banner is always displayed  by  COMP  object
  144. code and is  displayed  after  the  program  has  finished
  145. loading.
  146.  
  147.  
  148. ╩FormatΩ :╔DEFVAR ++<<variable><type>[=<expression>]>;Θ
  149. (Overlayed)
  150.  
  151. ╩ExampleΩ :DEFVAR name$="This is my name"
  152.                 count%
  153.                 money!=0
  154.          ENDVAR;
  155.  
  156. Defines the  following  list  of  variables  so  that  the
  157. compiler will recognise them when they appear  (later)  in
  158. the code. If DEFVAR  is  used  outside  a  procedure,  the
  159. variables will be global. If it is used within a procedure
  160. they will be local to that procedure.
  161.  
  162. If the optional expession is included, then  the  variable
  163. will be given that value every time the  DEFVAR  statement
  164. is executed. Note that  for  this  to  happen  the  DEFVAR
  165. statement be inside the main program body or a procedure.
  166.  
  167. External variables-variables which were  created  by  some
  168. other program-can be defined  simply  by  placing  a  star
  169. between the name and type. The most common use of external
  170. variables  is  accessing  Centrox  variables.  A  list  of
  171. Centrox variables can be found in the technical section of
  172. this manual.
  173.  
  174.  
  175. ╩FormatΩ :╔DEFFUNC <name>:<keyword>[<type>]
  176. ╙≤≤≤≤ ([++<<name><type>>])Θ
  177. (Overlayed)
  178.  
  179. ╩ExampleΩ :DEFFUNC left:left$(string$,posn%);
  180.  
  181. Defines a BASIC function. The  keyword  will  replace  the
  182. name  when  compiled.  The  list  of  types  indicate  the
  183. parameter type required for the function.  If  a  function
  184. has optional parameters, then define more than one version
  185. of the function:-
  186.  
  187.                   ╔DEFFUNC rnd0:RND!();Θ
  188.                   ╔DEFFUNC rnd1:RND!(value%);Θ
  189.  
  190. The name supplied as a parameter serves only as a reminder
  191. to the programmer as to the argument required to be passed
  192. to the function. The  parameters  do,  however,  exist  as
  193. global variables in their own right.  You  can  use  these
  194. parameters by name if you find  yourself  running  out  of
  195. memory. Note that string functions MUST be suffixed by the
  196. dollar sign as normal.
  197.  
  198.  
  199. ╩FormatΩ :╔DEFPROC <name>([++<<variable><type>>]);Θ
  200. (Overlayed)
  201.  
  202. ╩ExampleΩ :DEFPROC box(xco%,
  203.                      yco%,
  204.                     side%)
  205.           move(xco,yco);
  206.           drawr(side,0);
  207.           drawr(0,-side);
  208.           drawr(-side,0);
  209.           drawr(0,side);
  210.          ENDPROC;
  211.  
  212. Defines a section of code such that  its  actions  can  be
  213. invoked by name and treated as a  command.  It  should  be
  214. noted however that procedures do involve some overhead  in
  215. code  and  will  therefore  execute  slower  than   normal
  216. commands.
  217.  
  218. The list of variables are the parameters of the procedure.
  219. The best way to think of parameter variables is that  they
  220. are normal variables (like  those  that  might  have  been
  221. created with  DEFVAR)  but  that  when  the  procedure  is
  222. invoked, they take  on  the  value  of  the  corresponding
  223. argument.
  224.  
  225. The above ╔BOXΘ procedure could be invoked by:-
  226.  
  227.                         ╔box(50,50,100);Θ
  228.  
  229. Which would draw a box whose  top  left  coordinates  were
  230. 50,50 and whose sides were 100 pixels long.
  231.  
  232.  
  233. ╩FormatΩ :╔DEFPROG <name>([++<<variable><type>>]);Θ
  234. (Overlayed)
  235.  
  236. ╩ExampleΩ :DEFPROG mode(mode.number%)
  237.           mode(mode.number);
  238.          ENDPROG;
  239.  
  240. NB:The name given with the command has no  affect  on  the
  241. program, it only  serves  as  a  useful  reminder  to  the
  242. programmer.
  243.  
  244. Defines the start of a program. The list of variables  may
  245. be given to allow argument passing  from  the  Shell.  The
  246. Shell command line format  for  such  arguments  is  given
  247. below:-
  248.  
  249. 1.INTEGERs and REAL numbers.
  250.  
  251. Simply type the number after the command name or  previous
  252. arguments:-
  253.  
  254.                     ╔1>box 50 50 100Θ
  255.  
  256. 2.STRING values.
  257.  
  258. These should be entered enclosed between quotes.
  259.  
  260.        ╔2>centre 12 "Centres text on given line"Θ
  261.  
  262. It is NOT recommended that you read filenames into  string
  263. parameters, since users may  be  confused  by  the  double
  264. quotes (remember-the Shell does not normally require  that
  265. you use double quotes). The solution to this problem  will
  266. be covered in the section on using KERNEL vectors.
  267.  
  268. Arguments must be constant values. Expressions will NOT be
  269. evaluated-only misinterpreted.  Take  care  when  entering
  270. numeric data from the Shell, programs may crash if numeric
  271. data is given in an invalid format. At the very  least,  a
  272. value of zero will be placed in the parameter.
  273.  
  274.  
  275. ╩FormatΩ :╔DEFLOOP <number of times>[ USING <variable>];Θ
  276. (Internal)
  277.  
  278. ╩ExampleΩ :prints("8 Times table");
  279.          count=1;
  280.          DEFLOOP 12;
  281.           printn(count);prints("times 8 is");
  282.           printn(count*8);
  283.          ENDLOOP
  284.  
  285. In most programs there will be a  section  of  code  which
  286. needs to be  repeated  a  certain  number  of  times.  The
  287. DEFLOOP command defines the start of  such  a  section  of
  288. code, and the number of repetitions. The section  of  code
  289. is terminated by an ENDLOOP command.
  290.  
  291. The  optional  USING  clause  allows  you  to  specify   a
  292. particular variable to be used as the  loop  counter.  The
  293. above example could (and should) be written as:-
  294.  
  295.          Prints("8 Times table");
  296.          DEFLOOP 12 USING Count;
  297.           Printn(Count);Prints("times 8 is");
  298.           Printn(Count*8);
  299.          ENDLOOP
  300.  
  301. Loops may be nested - that is, one  loop  may  be  defined
  302. inside another, up to the level of ten nested  loops.  The
  303. compiler will associate ONE AND ONLY ONE  ENDLOOP  command
  304. with every DEFLOOP.
  305.  
  306.  
  307. ╩FormatΩ :╔DEFCASE <variable>:++<<expression>
  308. ≤≤≤≤≤ DO <procedure call> {CONT DONE DEFAULT ENDCASE}>;Θ
  309. (Overlayed)
  310.  
  311. ╩ExampleΩ :DEFCASE menu.choice "L" DO load.file;DONE;
  312.                              "S" DO save.file;DONE;
  313.                              "P" DO print.file;DEFAULT;
  314.                                     not.a.choice;ENDCASE;
  315.  
  316. Defines a multiple 'IF' command. In effect,  each  of  the
  317. expressions is evaluated in turn. When the result  matches
  318. the  contents  of  the  given  variable,   the   procedure
  319. associated with the expression will be called.  There  are
  320. four possible actions after the procedure has been called.
  321. The action depends on the next identifier.
  322.  
  323. CONT - Continue searching down  the  tree  for  a  further
  324. match.
  325.  
  326. DONE - Jump past the remaining tree tests.
  327.  
  328. DEFAULT - The next procedure call (NO expression) is to be
  329. executed if no match has been found so far.
  330.  
  331. ENDCASE - End of tree.
  332.  
  333.  
  334. ╩FormatΩ :╔DEFCOM <command name><BASIC.name>
  335. ≤≤≤≤≤ ([++<<name><type>>]);Θ
  336. (Overlayed)
  337.  
  338. ╩ExampleΩ :DEFCOM prints:print(string$);
  339.  
  340. As mentioned above, COMP knows very  few  BASIC  commands.
  341. There are two methods of entering commands  that  it  does
  342. not know about. DEFCOM is ideal for  BASIC  commands  that
  343. have a set number of parameters. When it finds the command
  344. name, the compiler will swap it for the  BASIC  name.  The
  345. brackets will ┴NOTß appear in the object code.
  346.  
  347. If a command has optional parameters, then define  several
  348. versions with different command names, but the same  BASIC
  349. name. The parameter name serves only as a reminder  as  to
  350. the nature of the argument.
  351.  
  352.  
  353. ╩FormatΩ :╔DEFLABEL <name>[=<address>];Θ
  354. (Overlayed)
  355.  
  356. ╩ExampleΩ :DEFLABEL data1;
  357.            INLINE restore^data1
  358.  
  359. This defines a label that can be  referenced  from  INLINE
  360. code-see later. The optional [=<address>]  clause  can  be
  361. used to assign a particular  line  number  to  the  label.
  362.  
  363.  
  364. ╩FormatΩ :╔DEFWHILE <condition>;Θ
  365. (Internal)
  366.  
  367. ╩ExampleΩ :count=0;
  368.          DEFWHILE count<10;
  369.           count=count+1;
  370.           prints("Now at number");printn(count);
  371.          ENDWHILE;
  372.  
  373. In a lot of programs there will be a section of code which
  374. needs to be repeated until  a  certain  condition  becomes
  375. true. The DEFWHILE command defines the start of just  such
  376. a section of program  code.  The  code  is  terminated  by
  377. ENDWHILE.
  378.  
  379. WHILE loops can be nested up to ten deep.
  380.  
  381.  
  382. ╩FormatΩ :╔DEFARRAY <array name><type.id>
  383. ≤≤≤≤≤ [++<subscript range>]Θ
  384. (Overlayed)
  385.  
  386. ╩ExampleΩ :DEFARRAY name$[6-10]
  387.  
  388. Warns the compiler that space should be made available for
  389. the given array. Note that the command allows the user  to
  390. choose the range of subscripts, ie choose  the  number  of
  391. the first subscript instead of it starting at  zero.  COMP
  392. will NOT accept a starting subscript number less than one.
  393.  
  394. Note that COMP produces object code  in  which  the  first
  395. subscript of an array is ALWAYS zero, by compensating  for
  396. any offset. This means that care needs to  be  taken  when
  397. accessing arrays using INLINE code-it must be  written  to
  398. allow for this.
  399.  
  400. As an example:-
  401.  
  402. ╔DEFARRAY fred$[6-6] {Single dimension array !}
  403.  ....
  404.  fred[6]="Example"
  405.  INLINE ?fred[0]  {Display `Example'}Θ
  406.  
  407. Once defined, arrays can  be  accessed  like  variables-as
  408. long as the subscripts are given. They can also  be  local
  409. if required.≤Array ╔elementsΘ can ≤be passed as  arguments
  410. but not if they are to form part of an array's  subscript.
  411. Arrays or their elements may NOT be defined as  parameters
  412. under any circumstances !
  413.  
  414. Note that array  notation  requires  that  subscripts  are
  415. enclosed in square brackets,  hence  the  square  brackets
  416. used  to  define  the  command  do  NOT  imply  that   the
  417. subscripts are optional.
  418.  
  419.  
  420. ╩5.5.2 Control StructuresΩ
  421.  
  422. ╩FormatΩ :╔IF <cond.> THEN <comd.> [ELSE <comd.>] ENDIFΘ
  423. (Internal)
  424.  
  425. ╩ExampleΩ :IF choice=1 THEN got.it.right;
  426.                      ELSE got.it.wrong;
  427.          ENDIF;
  428.  
  429. If the result of the condition is TRUE, the first  section
  430. of commands  will  be  executed.  If  the  result  of  the
  431. condition is FALSE then the second  set  of  commands  (if
  432. given) will be executed, control then jumps  to  the  next
  433. command after the ENDIF command.
  434.  
  435.  
  436. ╩5.5.3 General CommandsΩ
  437.  
  438. ╩FormatΩ :╔READARG([++<<variable><type>])Θ
  439. (Overlayed)
  440.  
  441. ╩ExampleΩ :READARG(name$);
  442.  
  443. Reads arguments into the given variables, in the same  way
  444. as DEFPROG. Note that, again, the variables do not have to
  445. have been defined already.
  446.  
  447.  
  448. ╩FormatΩ :╔INLINE(<inline code>);Θ
  449. (Overlayed)
  450.  
  451. ╩ExampleΩ :INLINE(?using"╤##±";var!);
  452.  
  453. The INLINE command is the alternative method for  entering
  454. BASIC commands. The inline code will be  copied  into  the
  455. object code exactly  as  read  except  for  certain  "meta
  456. characters":-
  457.  
  458.                     ╔_<expression>_Θ
  459.  
  460. This signals that the following text is a COMP evaluatable
  461. expression. The resulting code will then be inserted  into
  462. the text. The use of "_" as an  expression  terminator  is
  463. optional. Any other legal terminator would  also  suffice,
  464. with the following proviso.
  465.  
  466. Standard terminators  like  ";,)]"  are  accepted  by  the
  467. expression parser and not returned to INLINE.  This  means
  468. that the following INLINE statement would not work:-
  469.  
  470.          ╔INLINE(ink _expr1,_expr2);Θ
  471.  
  472. The  separating  comma  would  be   "swallowed"   by   the
  473. expression parser and would hence not appear in the object
  474. code. The solution is to add a "throwaway" terminator. The
  475. "_" sysmbol is intended to be used for this  purpose.  The
  476. correct code might be:-
  477.  
  478.          ╔INLINE(ink _expr1_,_expr2_);Θ
  479.  
  480.                        ╔"^<label>"Θ
  481.  
  482. This allows the user to reference a label. (see  DEFLABEL)
  483. note that this command causes the current line  of  object
  484. code to be written to disk and hence the  following  would
  485. not have the intended result:-
  486.  
  487.      ╔INLINE(If true% THEN GOSUB^DoThis:GOTO ^DoThatΘ
  488.  
  489. The GOTO≤statement would be≤placed on the line ╔afterΘ the
  490. GOSUB and IF.
  491.  
  492.  
  493. ╩FormatΩ :╔INCLUDE <file path>Θ
  494. (Overlayed)
  495.  
  496. ╩ExampleΩ :INCLUDE -/eblc.src/basiccom.lib;
  497.  
  498. Tells≤the compiler≤to ╔temporarilyΘ abandon  reading  from
  499. the current file, and to start reading from the given file
  500. instead. INCLUDE should be used to build up library  files
  501. which contain  useful  sections  of  code.  The  following
  502. library files are provided as standard:-
  503.  
  504. "BASICCOM.LIB"
  505.  
  506. Contains  common  BASIC   command   definitions.   It   is
  507. recommended that this file be  automatically  INCLUDEd  at
  508. the start of all programs.
  509.  
  510.  
  511. "TURTLE.LIB"
  512.  
  513. This file contains turtle extensions, mainly in  the  form
  514. of procedures. Note that these  definitions  require  that
  515. the "BASICCOM.LIB" and  "BASICFN.LIB"  files  be  included
  516. BEFORE the "TURTLE.LIB" file.
  517.  
  518.  
  519. "BASICFN.LIB"
  520.  
  521. Contains common BASIC function definitions.
  522.  
  523. It is recommended that users CAT each LIB file to see what
  524. commands are available.
  525.  
  526. Note that≤all ╔proceduresΘ appear in the≤resulting  object
  527. code-even if they  haven't  been  used.  This  means  that
  528. surplus procedures will waste  disk  storage  space.  Bare
  529. this in mind when creating  library  text  files.  Such  a
  530. problem≤will not occur≤with ╔commandsΘ and ╔functionsΘ  as
  531. they don't translate to BASIC code.
  532.  
  533. INCLUDEd files can themselves use INCLUDE, but  only  four
  534. files can be suspended at any one  time.  INCLUDE  can  be
  535. used any number of times provided that the above  rule  is
  536. adhered to.
  537.  
  538.  
  539. ╩FormatΩ :╔EXCLUDEΘ
  540. (Overlayed)
  541.  
  542. Instructs the compiler to abandon  the  current  file  and
  543. return to the previous file suspended by INCLUDE.
  544.  
  545.  
  546. ╩FormatΩ :╔SETLINE <line number>Θ
  547. (Overlayed)
  548.  
  549. Instruct the compiler to compile  subsequent  object  code
  550. with a new sequence of line  numbers,  starting  with  the
  551. number  given.  This  command  can  be  used  to  generate
  552. Compiler LINK files, by making the first  command  in  the
  553. file:-
  554.                        SETLINE 10000
  555.  
  556.  
  557. ╩FormatΩ :╔LINETO <address>[,<offset>]Θ
  558.  
  559. This marks the start of a block of  code  that  is  to  be
  560. compiled from the given line number.  The  <offset>  saves
  561. your from having to use the DEFSEG command, but  works  in
  562. the same way. The block  of  code  is  terminated  by  the
  563. LINEBACK command and subsequent code is generated  in  the
  564. original sequence until further SETLINE or LINETO commands
  565. are issued.
  566.  
  567.  
  568. ╩FormatΩ :╔EXIT LOOPΘ
  569.         or
  570.       ╔EXIT WHILEΘ
  571.       ╔EXIT PROCΘ
  572.       ╔EXIT VIA <proc call>Θ
  573.  
  574. EXIT LOOP  and  EXIT  WHILE  cause  a  jump  to  the  next
  575. statement after the current ENDLOOP or ENDWHILE. Note that
  576. use of EXIT LOOP while inside a DEFLOOP  nested   DEFWHILE
  577. block will terminate both the DEFWHILE and DEFLOOP blocks.
  578.  
  579. EXIT PROC simply terminates the current  procedure,  while
  580. EXIT VIA  terminates  the  current  procedure  by  jumping
  581. directly into another, specified, procedure.
  582.  
  583.  
  584. ╩FormatΩ :╔SYSTEM <vector>[++<argument>]Θ
  585. (Overlayed)
  586.  
  587. Calls one of the system vectors.  The  list  of  arguments
  588. vary for each vector and are listed here:-
  589.  
  590. ╤#±1 :<directory number>
  591. ╤#±2 :<directory path>╟+τ
  592. ╤#±3 :<File path>╟+τ
  593. ╤#±4 :None.
  594. ╤#±5 :<command phrase>
  595. ╤#±6 :<AMSDOS file.name>,<USER number>,<drive flag>
  596. ╤#±7 :None.
  597. ╤#±8 :<Type flag>
  598. ╤#±9 :<phrase or word>
  599. ╤#±10:As ╤#±6
  600. ╤#±11:None.
  601. ╤#±12:None.
  602. ╤#±13:<drive flag>
  603.  
  604. ╟+τ:These should be prefixed by a space eg; " test.bas"
  605.  
  606. ╩Passing Filenames As Arguments From The ShellΩ
  607.  
  608. If your program requires a filename to be passed, use  the
  609. following method:-
  610.  
  611. ╔Command format:1>MYPROG <number> <filename> <selectors>Θ
  612.  
  613. ╔Program:-Θ
  614. DEFPROG myprog(number%); {Read number direct}
  615.  INLINE vectr%=3:GOSUB 60000;
  616.  {Above line evaluates file path as received from Shell}
  617.  READARG(selectors$); {read string of selectors}
  618. ...
  619. ENDPROG
  620.  
  621. Note that SYSTEM 3 is NOT used, since this requires that a
  622. file path is already known.
  623.  
  624. Note that your program picks up command tail arguments  in
  625. the same way as other programs, allowing  the  intermixing
  626. of vector╤#±3 with READARG() as above.
  627.  
  628. For further details, see the technical information section
  629. at the end of this manual.
  630.   F I V EΩ
  631.  
  632.  
  633. ╩5 COMP - Extended BASIC Language CompilerΩ
  634.  
  635. ╩FormatΩ :╔COMP [<selectors>]