home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1993 #2 / Image.iso / clipper / 52capi.zip / STD.CH < prev    next >
Text File  |  1993-08-06  |  51KB  |  1,117 lines

  1. /***
  2. *
  3. *  Std.ch
  4. *
  5. *  Clipper standard language definitions.
  6. *
  7. *  Copyright (c) 1990-1993, Computer Associates International, Inc.
  8. *  All rights reserved.
  9. *
  10. *  IMPORTANT:  Functions beginning with an underscore
  11. *  character are reserved, version-dependent functions.
  12. *  These functions should not be called directly.
  13. *
  14. */
  15.  
  16.  
  17. /***
  18. *  Definitions from Set.ch are used in SET commands
  19. */
  20. #ifndef _SET_CH
  21.    #include "Set.ch"
  22. #endif
  23.  
  24.  
  25. /***
  26. *  Basic statement synonyms
  27. */
  28.  
  29. #command DO WHILE <exp>         => while <exp>
  30.  
  31. #command END <x>                => end
  32. #command END SEQUENCE           => end
  33. #command ENDSEQUENCE            => end
  34. #command ENDDO    <*x*>         => enddo
  35. #command ENDIF    <*x*>         => endif
  36. #command ENDCASE  <*x*>         => endcase
  37. #command ENDFOR [ <*x*> ]       => next
  38.  
  39. #command NEXT <v> [TO <x>] [STEP <s>]                                   ;
  40.       => next
  41.  
  42. #command DO <proc>.PRG [WITH <list,...>]                                ;
  43.       => do <proc> [ WITH <list>]
  44.  
  45. #command CALL <proc>() [WITH <list,...>]                                ;
  46.       => call <proc> [ WITH <list>]
  47.  
  48. #command STORE <value> TO <var1> [, <varN> ]                            ;
  49.       => <var1> := [ <varN> := ] <value>
  50.  
  51.  
  52.  
  53. /***
  54. *  Compatibility
  55. */
  56.  
  57. #command SET ECHO <*x*>         =>
  58. #command SET HEADING <*x*>      =>
  59. #command SET MENU <*x*>         =>
  60. #command SET STATUS <*x*>       =>
  61. #command SET STEP <*x*>         =>
  62. #command SET SAFETY <*x*>       =>
  63. #command SET TALK <*x*>         =>
  64. #command SET PROCEDURE TO       =>
  65. #command SET PROCEDURE TO <f>   =>  _ProcReq_( <(f)> )
  66.  
  67.  
  68.  
  69. /***
  70. *  System SETs
  71. */
  72.  
  73. #command SET EXACT <x:ON,OFF,&>         => Set( _SET_EXACT, <(x)> )
  74. #command SET EXACT (<x>)                => Set( _SET_EXACT, <x> )
  75.  
  76. #command SET FIXED <x:ON,OFF,&>         => Set( _SET_FIXED, <(x)> )
  77. #command SET FIXED (<x>)                => Set( _SET_FIXED, <x> )
  78.  
  79. #command SET DECIMALS TO <x>            => Set( _SET_DECIMALS, <x> )
  80. #command SET DECIMALS TO                => Set( _SET_DECIMALS, 0 )
  81.  
  82. #command SET PATH TO <*path*>           => Set( _SET_PATH, <(path)> )
  83. #command SET PATH TO                    => Set( _SET_PATH, "" )
  84.  
  85. #command SET DEFAULT TO <(path)>        => Set( _SET_DEFAULT, <(path)> )
  86. #command SET DEFAULT TO                 => Set( _SET_DEFAULT, "" )
  87.  
  88.  
  89.  
  90. /***
  91. *  Date format SETs
  92. */
  93.  
  94. #command SET CENTURY <x:ON,OFF,&>       => __SetCentury( <(x)> )
  95. #command SET CENTURY (<x>)              => __SetCentury( <x> )
  96. #command SET EPOCH TO <year>            => Set( _SET_EPOCH, <year> )
  97. #command SET DATE FORMAT [TO] <c>       => Set( _SET_DATEFORMAT, <c> )
  98.  
  99. #define  _DFSET(x, y)  Set( _SET_DATEFORMAT, if(__SetCentury(), x, y) )
  100.  
  101. #command SET DATE [TO] AMERICAN         => _DFSET( "mm/dd/yyyy", "mm/dd/yy" )
  102. #command SET DATE [TO] ANSI             => _DFSET( "yyyy.mm.dd", "yy.mm.dd" )
  103. #command SET DATE [TO] BRITISH          => _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
  104. #command SET DATE [TO] FRENCH           => _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
  105. #command SET DATE [TO] GERMAN           => _DFSET( "dd.mm.yyyy", "dd.mm.yy" )
  106. #command SET DATE [TO] ITALIAN          => _DFSET( "dd-mm-yyyy", "dd-mm-yy" )
  107. #command SET DATE [TO] JAPANESE         => _DFSET( "yyyy/mm/dd", "yy/mm/dd" )
  108. #command SET DATE [TO] USA              => _DFSET( "mm-dd-yyyy", "mm-dd-yy" )
  109.  
  110.  
  111.  
  112. /***
  113. *  Terminal I/O SETs
  114. */
  115.  
  116. #command SET ALTERNATE <x:ON,OFF,&>     => Set( _SET_ALTERNATE, <(x)> )
  117. #command SET ALTERNATE (<x>)            => Set( _SET_ALTERNATE, <x> )
  118.  
  119. #command SET ALTERNATE TO               => Set( _SET_ALTFILE, "" )
  120.  
  121. #command SET ALTERNATE TO <(file)> [<add: ADDITIVE>]                    ;
  122.       => Set( _SET_ALTFILE, <(file)>, <.add.> )
  123.  
  124.  
  125. #command SET CONSOLE <x:ON,OFF,&>       => Set( _SET_CONSOLE, <(x)> )
  126. #command SET CONSOLE (<x>)              => Set( _SET_CONSOLE, <x> )
  127.  
  128. #command SET MARGIN TO <x>              => Set( _SET_MARGIN, <x> )
  129. #command SET MARGIN TO                  => Set( _SET_MARGIN, 0 )
  130.  
  131.  
  132. #command SET PRINTER <x:ON,OFF,&>       => Set( _SET_PRINTER, <(x)> )
  133. #command SET PRINTER (<x>)              => Set( _SET_PRINTER, <x> )
  134.  
  135. #command SET PRINTER TO                 => Set( _SET_PRINTFILE, "" )
  136.  
  137. #command SET PRINTER TO <(file)> [<add: ADDITIVE>]                      ;
  138.       => Set( _SET_PRINTFILE, <(file)>, <.add.> )
  139.  
  140.  
  141. #command SET DEVICE TO SCREEN           => Set( _SET_DEVICE, "SCREEN" )
  142. #command SET DEVICE TO PRINTER          => Set( _SET_DEVICE, "PRINTER" )
  143.  
  144. #command SET COLOR TO [<*spec*>]        => SetColor( #<spec> )
  145. #command SET COLOR TO ( <c> )           => SetColor( <c> )
  146. #command SET COLOUR TO [<*spec*>]       => SET COLOR TO [<spec>]
  147.  
  148. #command SET CURSOR <x:ON,OFF,&>                                        ;
  149.       => SetCursor( if(Upper(<(x)>) == "ON", 1, 0) )
  150.  
  151. #command SET CURSOR (<x>)                                               ;
  152.       => SetCursor( if(<x>, 1, 0) )
  153.  
  154.  
  155.  
  156. /***
  157. *  "Console" / printer output
  158. */
  159.  
  160. #command ?  [ <list,...> ]      => QOut( <list> )
  161. #command ?? [ <list,...> ]      => QQOut( <list> )
  162.  
  163. #command EJECT                  => __Eject()
  164.  
  165. #command TEXT                                                           ;
  166.       => text QOut, QQOut
  167.  
  168. #command TEXT TO FILE <(file)>                                          ;
  169.       => __TextSave( <(file)> )                                         ;
  170.        ; text QOut, __TextRestore
  171.  
  172. #command TEXT TO PRINTER                                                ;
  173.       => __TextSave("PRINTER")                                          ;
  174.        ; text QOut, __TextRestore
  175.  
  176.  
  177.  
  178. /***
  179. *  Clear screen
  180. */
  181.  
  182. #command CLS                                                            ;
  183.       => Scroll()                                                       ;
  184.        ; SetPos(0,0)
  185.  
  186. #command CLEAR SCREEN                                                   ;
  187.       => CLS
  188.  
  189. #command @ <row>, <col>                                                 ;
  190.       => Scroll( <row>, <col>, <row> )                                  ;
  191.        ; SetPos( <row>, <col> )
  192.  
  193. #command @ <top>, <left> CLEAR                                          ;
  194.       => Scroll( <top>, <left> )                                        ;
  195.        ; SetPos( <top>, <left> )
  196.  
  197.  
  198. #command @ <top>, <left> CLEAR TO <bottom>, <right>                     ;
  199.       => Scroll( <top>, <left>, <bottom>, <right> )                     ;
  200.        ; SetPos( <top>, <left> )
  201.  
  202.  
  203.  
  204. /***
  205. *  @..BOX
  206. */
  207.  
  208. #command @ <top>, <left>, <bottom>, <right> BOX <string>                ;
  209.                                             [COLOR <color>]             ;
  210.       => DispBox(                                                       ;
  211.                   <top>, <left>, <bottom>, <right>, <string>            ;
  212.                   [, <color> ]                                          ;
  213.                 )
  214.  
  215.  
  216. #command @ <top>, <left> TO <bottom>, <right> [DOUBLE]                  ;
  217.                                               [COLOR <color>]           ;
  218.       => DispBox(                                                       ;
  219.                   <top>, <left>, <bottom>, <right>, 2                   ;
  220.                   [, <color> ]                                          ;
  221.                 )
  222.  
  223.  
  224. #command @ <top>, <left> TO <bottom>, <right> [COLOR <color>]           ;
  225.                                                                         ;
  226.       => DispBox(                                                       ;
  227.                   <top>, <left>, <bottom>, <right>, 1                   ;
  228.                   [, <color> ]                                          ;
  229.                 )
  230.  
  231.  
  232.  
  233. /***
  234. *  @..SAY
  235. */
  236.  
  237. #command @ <row>, <col> SAY <xpr>                                       ;
  238.                         [PICTURE <pic>]                                 ;
  239.                         [COLOR <color>]                                 ;
  240.                                                                         ;
  241.       => DevPos( <row>, <col> )                                         ;
  242.        ; DevOutPict( <xpr>, <pic> [, <color>] )
  243.  
  244.  
  245. #command @ <row>, <col> SAY <xpr>                                       ;
  246.                         [COLOR <color>]                                 ;
  247.                                                                         ;
  248.       => DevPos( <row>, <col> )                                         ;
  249.        ; DevOut( <xpr> [, <color>] )
  250.  
  251.  
  252.  
  253. /***
  254. *  GET SETs
  255. */
  256.  
  257. #command SET BELL <x:ON,OFF,&>          => Set( _SET_BELL, <(x)> )
  258. #command SET BELL (<x>)                 => Set( _SET_BELL, <x> )
  259.  
  260. #command SET CONFIRM <x:ON,OFF,&>       => Set( _SET_CONFIRM, <(x)> )
  261. #command SET CONFIRM (<x>)              => Set( _SET_CONFIRM, <x> )
  262.  
  263. #command SET ESCAPE <x:ON,OFF,&>        => Set( _SET_ESCAPE, <(x)> )
  264. #command SET ESCAPE (<x>)               => Set( _SET_ESCAPE, <x> )
  265.  
  266. #command SET INTENSITY <x:ON,OFF,&>     => Set( _SET_INTENSITY, <(x)> )
  267. #command SET INTENSITY (<x>)            => Set( _SET_INTENSITY, <x> )
  268.  
  269. #command SET SCOREBOARD <x:ON,OFF,&>    => Set( _SET_SCOREBOARD, <(x)> )
  270. #command SET SCOREBOARD (<x>)           => Set( _SET_SCOREBOARD, <x> )
  271.  
  272. #command SET DELIMITERS <x:ON,OFF,&>    => Set( _SET_DELIMITERS, <(x)> )
  273. #command SET DELIMITERS (<x>)           => Set( _SET_DELIMITERS, <x> )
  274.  
  275. #command SET DELIMITERS TO <c>          => Set( _SET_DELIMCHARS, <c> )
  276. #command SET DELIMITERS TO DEFAULT      => Set( _SET_DELIMCHARS, "::" )
  277. #command SET DELIMITERS TO              => Set( _SET_DELIMCHARS, "::" )
  278.  
  279.  
  280. #command SET FORMAT TO <proc>                                           ;
  281.                                                                         ;
  282.       => _ProcReq_( <(proc)> + ".FMT" )                                 ;
  283.        ; __SetFormat( {|| <proc>()} )
  284.  
  285. #command SET FORMAT TO <proc>.<ext>                                     ;
  286.                                                                         ;
  287.       => _ProcReq_( <(proc)> + "." + <(ext)> )                          ;
  288.        ; __SetFormat( {|| <proc>()} )
  289.  
  290. #command SET FORMAT TO <x:&>                                            ;
  291.                                                                         ;
  292.       => if ( Empty(<(x)>) )                                            ;
  293.        ;   SET FORMAT TO                                                ;
  294.        ; else                                                           ;
  295.        ;   __SetFormat( &("{||" + <(x)> + "()}") )                      ;
  296.        ; end
  297.  
  298. #command SET FORMAT TO                                                  ;
  299.       => __SetFormat()
  300.  
  301.  
  302.  
  303. /***
  304. *  @..GET
  305. */
  306.  
  307. #command @ <row>, <col> GET <var>                                       ;
  308.                         [PICTURE <pic>]                                 ;
  309.                         [VALID <valid>]                                 ;
  310.                         [WHEN <when>]                                   ;
  311.                         [SEND <msg>]                                    ;
  312.                                                                         ;
  313.       => SetPos( <row>, <col> )                                         ;
  314.        ; AAdd(                                                          ;
  315.            GetList,                                                     ;
  316.            _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}> ):display();
  317.              )                                                          ;
  318.       [; ATail(GetList):<msg>]
  319.  
  320.  
  321.  
  322. /***
  323. *   @..SAY..GET
  324. */
  325.  
  326. #command @ <row>, <col> SAY <sayxpr>                                    ;
  327.                         [<sayClauses,...>]                              ;
  328.                         GET <var>                                       ;
  329.                         [<getClauses,...>]                              ;
  330.                                                                         ;
  331.       => @ <row>, <col> SAY <sayxpr> [<sayClauses>]                     ;
  332.        ; @ Row(), Col()+1 GET <var> [<getClauses>]
  333.  
  334.  
  335.  
  336. /***
  337. *   fancy GETs...
  338. */
  339.  
  340. // @..GET..RANGE (preprocessed to @..GET..VALID)
  341.  
  342. #command @ <row>, <col> GET <var>                                       ;
  343.                         [<clauses,...>]                                 ;
  344.                         RANGE <lo>, <hi>                                ;
  345.                         [<moreClauses,...>]                             ;
  346.                                                                         ;
  347.       => @ <row>, <col> GET <var>                                       ;
  348.                         [<clauses>]                                     ;
  349.                         VALID {|_1| RangeCheck(_1,, <lo>, <hi>)}        ;
  350.                         [<moreClauses>]
  351.  
  352.  
  353. // @..GET COLOR
  354.  
  355. #command @ <row>, <col> GET <var>                                       ;
  356.                         [<clauses,...>]                                 ;
  357.                         COLOR <color>                                   ;
  358.                         [<moreClauses,...>]                             ;
  359.                                                                         ;
  360.       => @ <row>, <col> GET <var>                                       ;
  361.                         [<clauses>]                                     ;
  362.                         SEND colorDisp(<color>)                         ;
  363.                         [<moreClauses>]
  364.  
  365.  
  366.  
  367. /***
  368. *  READ
  369. */
  370.  
  371. #command READ SAVE                                                      ;
  372.        => ReadModal(GetList)
  373.  
  374. #command READ                                                           ;
  375.       => ReadModal(GetList)                                             ;
  376.        ; GetList := {}
  377.  
  378. #command CLEAR GETS                                                     ;
  379.       => ReadKill(.T.)                                                  ;
  380.        ; GetList := {}
  381.  
  382.  
  383.  
  384. /***
  385. *  Refinement...
  386. */
  387.  
  388. #command @ [<clauses,...>] COLOUR [<moreClauses,...>]                   ;
  389.       => @ [<clauses>] COLOR [<moreClauses>]
  390.  
  391.  
  392.  
  393. /***
  394. *  MENU TO
  395. */
  396.  
  397. #command SET WRAP <x:ON,OFF,&>  => Set( _SET_WRAP, <(x)> )
  398. #command SET WRAP (<x>)         => Set( _SET_WRAP, <x> )
  399.  
  400. #command SET MESSAGE TO <n> [<cent: CENTER, CENTRE>]                    ;
  401.       => Set( _SET_MESSAGE, <n> )                                       ;
  402.        ; Set( _SET_MCENTER, <.cent.> )
  403.  
  404. #command SET MESSAGE TO                                                 ;
  405.       => Set( _SET_MESSAGE, 0 )                                         ;
  406.        ; Set( _SET_MCENTER, .f. )
  407.  
  408. #command @ <row>, <col> PROMPT <prompt> [MESSAGE <msg>]                 ;
  409.       => __AtPrompt( <row>, <col>, <prompt> , <msg> )
  410.  
  411. #command MENU TO <v>                                                    ;
  412.       => <v> := __MenuTo( {|_1| if(PCount() == 0, <v>, <v> := _1)}, #<v> )
  413.  
  414.  
  415.  
  416. /***
  417. *  SAVE / RESTORE SCREEN
  418. */
  419.  
  420. #command SAVE SCREEN            => __XSaveScreen()
  421. #command RESTORE SCREEN         => __XRestScreen()
  422.  
  423. #command SAVE SCREEN TO <var>                                           ;
  424.       => <var> := SaveScreen( 0, 0, Maxrow(), Maxcol() )
  425.  
  426. #command RESTORE SCREEN FROM <c>                                        ;
  427.       => RestScreen( 0, 0, Maxrow(), Maxcol(), <c> )
  428.  
  429.  
  430.  
  431. /***
  432. *  Modal keyboard input
  433. */
  434.  
  435. #command WAIT [<c>]             => __Wait( <c> )
  436. #command WAIT [<c>] TO <var>    => <var> := __Wait( <c> )
  437. #command ACCEPT [<c>] TO <var>  => <var> := __Accept( <c> )
  438.  
  439. #command INPUT [<c>] TO <var>                                           ;
  440.                                                                         ;
  441.       => if ( !Empty(__Accept(<c>)) )                                   ;
  442.        ;    <var> := &( __AcceptStr() )                                 ;
  443.        ; end
  444.  
  445.  
  446. #command KEYBOARD <c>           => __Keyboard( <c> )
  447. #command CLEAR TYPEAHEAD        => __Keyboard()
  448. #command SET TYPEAHEAD TO <n>   => Set( _SET_TYPEAHEAD, <n> )
  449.  
  450. #command SET KEY <n> TO <proc>                                          ;
  451.       => SetKey( <n>, {|p, l, v| <proc>(p, l, v)} )
  452.  
  453. #command SET KEY <n> TO <proc> ( [<list,...>] )                         ;
  454.       => SET KEY <n> TO <proc>
  455.  
  456. #command SET KEY <n> TO <proc:&>                                        ;
  457.                                                                         ;
  458.       => if ( Empty(<(proc)>) )                                         ;
  459.        ;   SetKey( <n>, NIL )                                           ;
  460.        ; else                                                           ;
  461.        ;   SetKey( <n>, {|p, l, v| <proc>(p, l, v)} )                   ;
  462.        ; end
  463.  
  464. #command SET KEY <n> [TO]                                               ;
  465.       => SetKey( <n>, NIL )
  466.  
  467. #command SET FUNCTION <n> [TO] [<c>]                                    ;
  468.       => __SetFunction( <n>, <c> )
  469.  
  470.  
  471.  
  472. /***
  473. *  MEMVAR variables
  474. */
  475.  
  476. #command CLEAR MEMORY                   => __MClear()
  477. #command RELEASE <vars,...>             => __MXRelease( <"vars"> )
  478. #command RELEASE ALL                    => __MRelease("*", .t.)
  479. #command RELEASE ALL LIKE <skel>        => __MRelease( #<skel>, .t. )
  480. #command RELEASE ALL EXCEPT <skel>      => __MRelease( #<skel>, .f. )
  481.  
  482. #command RESTORE [FROM <(file)>] [<add: ADDITIVE>]                      ;
  483.       => __MRestore( <(file)>, <.add.> )
  484.  
  485. #command SAVE ALL LIKE <skel> TO <(file)>                               ;
  486.       => __MSave( <(file)>, <(skel)>, .t. )
  487.  
  488. #command SAVE TO <(file)> ALL LIKE <skel>                               ;
  489.       => __MSave( <(file)>, <(skel)>, .t. )
  490.  
  491. #command SAVE ALL EXCEPT <skel> TO <(file)>                             ;
  492.       => __MSave( <(file)>, <(skel)>, .f. )
  493.  
  494. #command SAVE TO <(file)> ALL EXCEPT <skel>                             ;
  495.       => __MSave( <(file)>, <(skel)>, .f. )
  496.  
  497. #command SAVE [TO <(file)>] [ALL]                                       ;
  498.       => __MSave( <(file)>, "*", .t. )
  499.  
  500.  
  501.  
  502. /***
  503. *  DOS file commands
  504. */
  505.  
  506. #command ERASE <(file)>                 => FErase( <(file)> )
  507. #command DELETE FILE <(file)>           => FErase( <(file)> )
  508. #command RENAME <(old)> TO <(new)>      => FRename( <(old)>, <(new)> )
  509.  
  510. #command COPY FILE <(src)> TO <(dest)>  => __CopyFile( <(src)>, <(dest)> )
  511. #command DIR [<(spec)>]                 => __Dir( <(spec)> )
  512.  
  513. #command TYPE <(file)> [<print: TO PRINTER>] [TO FILE <(dest)>]         ;
  514.                                                                         ;
  515.       => __TypeFile( <(file)>, <.print.> )                              ;
  516.       [; COPY FILE <(file)> TO <(dest)> ]
  517.  
  518. #command TYPE <(file)> [<print: TO PRINTER>]                            ;
  519.                                                                         ;
  520.       => __TypeFile( <(file)>, <.print.> )
  521.  
  522.  
  523. /***
  524. *  Declaration
  525. */
  526.  
  527. #command REQUEST <vars,...>             => EXTERNAL <vars>
  528.  
  529. /***
  530. *  Process
  531. */
  532.  
  533. #command CANCEL                 => __Quit()
  534. #command QUIT                   => __Quit()
  535.  
  536. #command RUN <*cmd*>            => __Run( #<cmd> )
  537. #command RUN ( <c> )            => __Run( <c> )
  538. #command ! <*cmd*>              => RUN <cmd>
  539. #command RUN = <xpr>            => ( run := <xpr> )
  540. #command RUN := <xpr>           => ( run := <xpr> )
  541.  
  542.  
  543.  
  544. /***
  545. *  DB SETs
  546. */
  547.  
  548. #command SET EXCLUSIVE <x:ON,OFF,&>     =>  Set( _SET_EXCLUSIVE, <(x)> )
  549. #command SET EXCLUSIVE (<x>)            =>  Set( _SET_EXCLUSIVE, <x> )
  550.  
  551. #command SET SOFTSEEK <x:ON,OFF,&>      =>  Set( _SET_SOFTSEEK, <(x)> )
  552. #command SET SOFTSEEK (<x>)             =>  Set( _SET_SOFTSEEK, <x> )
  553.  
  554. #command SET UNIQUE <x:ON,OFF,&>        =>  Set( _SET_UNIQUE, <(x)> )
  555. #command SET UNIQUE (<x>)               =>  Set( _SET_UNIQUE, <x> )
  556.  
  557. #command SET DELETED <x:ON,OFF,&>       =>  Set( _SET_DELETED, <(x)> )
  558. #command SET DELETED (<x>)              =>  Set( _SET_DELETED, <x> )
  559.  
  560.  
  561.  
  562. /***
  563. *  DB
  564. */
  565.  
  566. #command SELECT <whatever>              => dbSelectArea( <(whatever)> )
  567. #command SELECT <f>([<list,...>])       => dbSelectArea( <f>(<list>) )
  568.  
  569.  
  570. #command USE                            => dbCloseArea()
  571.  
  572. #command USE <(db)>                                                     ;
  573.              [VIA <rdd>]                                                ;
  574.              [ALIAS <a>]                                                ;
  575.              [<new: NEW>]                                               ;
  576.              [<ex: EXCLUSIVE>]                                          ;
  577.              [<sh: SHARED>]                                             ;
  578.              [<ro: READONLY>]                                           ;
  579.              [INDEX <(index1)> [, <(indexn)>]]                          ;
  580.                                                                         ;
  581.       => dbUseArea(                                                     ;
  582.                     <.new.>, <rdd>, <(db)>, <(a)>,                      ;
  583.                     if(<.sh.> .or. <.ex.>, !<.ex.>, NIL), <.ro.>        ;
  584.                   )                                                     ;
  585.                                                                         ;
  586.       [; dbSetIndex( <(index1)> )]                                      ;
  587.       [; dbSetIndex( <(indexn)> )]
  588.  
  589. #command APPEND BLANK           => dbAppend()
  590. #command PACK                   => __dbPack()
  591. #command ZAP                    => __dbZap()
  592. #command UNLOCK                 => dbUnlock()
  593. #command UNLOCK ALL             => dbUnlockAll()
  594. #command COMMIT                 => dbCommitAll()
  595.  
  596.  
  597. #command GOTO <n>               => dbGoto(<n>)
  598. #command GO <n>                 => dbGoto(<n>)
  599. #command GOTO TOP               => dbGoTop()
  600. #command GO TOP                 => dbGoTop()
  601. #command GOTO BOTTOM            => dbGoBottom()
  602. #command GO BOTTOM              => dbGoBottom()
  603.  
  604. #command SKIP                   => dbSkip(1)
  605. #command SKIP <n>               => dbSkip( <n> )
  606. #command SKIP ALIAS <a>         => <a> -> ( dbSkip(1) )
  607. #command SKIP <n> ALIAS <a>     => <a> -> ( dbSkip(<n>) )
  608.  
  609. #command SEEK <xpr>                                                     ;
  610.          [<soft: SOFTSEEK>]                                             ;
  611.       => dbSeek( <xpr>, if( <.soft.>, .T., NIL ) )
  612.  
  613. #command FIND <*text*>          => dbSeek( <(text)> )
  614. #command FIND := <xpr>          => ( find := <xpr> )
  615. #command FIND = <xpr>           => ( find := <xpr> )
  616.  
  617.  
  618. #command CONTINUE               => __dbContinue()
  619.  
  620. #command LOCATE                                                         ;
  621.          [FOR <for>]                                                    ;
  622.          [WHILE <while>]                                                ;
  623.          [NEXT <next>]                                                  ;
  624.          [RECORD <rec>]                                                 ;
  625.          [<rest:REST>]                                                  ;
  626.          [ALL]                                                          ;
  627.                                                                         ;
  628.       => __dbLocate( <{for}>, <{while}>, <next>, <rec>, <.rest.> )
  629.  
  630.  
  631.  
  632. #command SET RELATION TO        => dbClearRel()
  633.  
  634. #command SET RELATION                                                   ;
  635.          [<add:ADDITIVE>]                                               ;
  636.          [TO <key1> INTO <(alias1)> [, [TO] <keyn> INTO <(aliasn)>]]    ;
  637.                                                                         ;
  638.       => if ( !<.add.> )                                                ;
  639.        ;    dbClearRel()                                                ;
  640.        ; end                                                            ;
  641.                                                                         ;
  642.        ; dbSetRelation( <(alias1)>, <{key1}>, <"key1"> )                ;
  643.       [; dbSetRelation( <(aliasn)>, <{keyn}>, <"keyn"> )]
  644.  
  645.  
  646. #command SET FILTER TO          => dbClearFilter(NIL)
  647. #command SET FILTER TO <xpr>    => dbSetFilter( <{xpr}>, <"xpr"> )
  648.  
  649. #command SET FILTER TO <x:&>                                            ;
  650.       => if ( Empty(<(x)>) )                                            ;
  651.        ;    dbClearFilter()                                             ;
  652.        ; else                                                           ;
  653.        ;    dbSetFilter( <{x}>, <(x)> )                                 ;
  654.        ; end
  655.  
  656.  
  657. #command REPLACE [ <f1> WITH <x1> [, <fn> WITH <xn>] ]                  ;
  658.          [FOR <for>]                                                    ;
  659.          [WHILE <while>]                                                ;
  660.          [NEXT <next>]                                                  ;
  661.          [RECORD <rec>]                                                 ;
  662.          [<rest:REST>]                                                  ;
  663.          [ALL]                                                          ;
  664.                                                                         ;
  665.       => DBEval(                                                        ;
  666.                  {|| _FIELD-><f1> := <x1> [, _FIELD-><fn> := <xn>]},    ;
  667.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  668.                )
  669.  
  670.  
  671. #command REPLACE <f1> WITH <v1> [, <fN> WITH <vN> ]                     ;
  672.       => _FIELD-><f1> := <v1> [; _FIELD-><fN> := <vN>]
  673.  
  674.  
  675.  
  676. #command DELETE                                                         ;
  677.          [FOR <for>]                                                    ;
  678.          [WHILE <while>]                                                ;
  679.          [NEXT <next>]                                                  ;
  680.          [RECORD <rec>]                                                 ;
  681.          [<rest:REST>]                                                  ;
  682.          [ALL]                                                          ;
  683.                                                                         ;
  684.       => DBEval(                                                        ;
  685.                  {|| dbDelete()},                                       ;
  686.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  687.                )
  688.  
  689.  
  690. #command RECALL                                                         ;
  691.          [FOR <for>]                                                    ;
  692.          [WHILE <while>]                                                ;
  693.          [NEXT <next>]                                                  ;
  694.          [RECORD <rec>]                                                 ;
  695.          [<rest:REST>]                                                  ;
  696.          [ALL]                                                          ;
  697.                                                                         ;
  698.       => DBEval(                                                        ;
  699.                  {|| dbRecall()},                                       ;
  700.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  701.                )
  702.  
  703.  
  704. #command DELETE                 =>  dbDelete()
  705. #command RECALL                 =>  dbRecall()
  706.  
  707.  
  708. #command CREATE <(file1)>                                               ;
  709.             [FROM <(file2)>]                                            ;
  710.             [VIA <rdd>]                                                 ;
  711.             [ALIAS <a>]                                                 ;
  712.             [<new: NEW>]                                                ;
  713.                                                                         ;
  714.       => __dbCreate( <(file1)>, <(file2)>, <rdd>, <.new.>, <(a)> )
  715.  
  716.  
  717.  
  718. #command COPY [STRUCTURE] [EXTENDED] [TO <(file)>]                      ;
  719.       => __dbCopyXStruct( <(file)> )
  720.  
  721.  
  722. #command COPY [STRUCTURE] [TO <(file)>] [FIELDS <fields,...>]           ;
  723.       => __dbCopyStruct( <(file)>, { <(fields)> } )
  724.  
  725.  
  726. #command COPY [TO <(file)>] [DELIMITED [WITH <*delim*>]]                ;
  727.          [FIELDS <fields,...>]                                          ;
  728.          [FOR <for>]                                                    ;
  729.          [WHILE <while>]                                                ;
  730.          [NEXT <next>]                                                  ;
  731.          [RECORD <rec>]                                                 ;
  732.          [<rest:REST>]                                                  ;
  733.          [ALL]                                                          ;
  734.                                                                         ;
  735.       => __dbDelim(                                                     ;
  736.                         .T., <(file)>, <(delim)>, { <(fields)> },       ;
  737.                         <{for}>, <{while}>, <next>, <rec>, <.rest.>     ;
  738.                       )
  739.  
  740.  
  741. #command COPY [TO <(file)>] [SDF]                                       ;
  742.          [FIELDS <fields,...>]                                          ;
  743.          [FOR <for>]                                                    ;
  744.          [WHILE <while>]                                                ;
  745.          [NEXT <next>]                                                  ;
  746.          [RECORD <rec>]                                                 ;
  747.          [<rest:REST>]                                                  ;
  748.          [ALL]                                                          ;
  749.                                                                         ;
  750.       => __dbSDF(                                                       ;
  751.                   .T., <(file)>, { <(fields)> },                        ;
  752.                   <{for}>, <{while}>, <next>, <rec>, <.rest.>           ;
  753.                 )
  754.  
  755.  
  756. #command COPY [TO <(file)>]                                             ;
  757.          [FIELDS <fields,...>]                                          ;
  758.          [FOR <for>]                                                    ;
  759.          [WHILE <while>]                                                ;
  760.          [NEXT <next>]                                                  ;
  761.          [RECORD <rec>]                                                 ;
  762.          [<rest:REST>]                                                  ;
  763.          [VIA <rdd>]                                                    ;
  764.          [ALL]                                                          ;
  765.                                                                         ;
  766.       => __dbCopy(                                                      ;
  767.                    <(file)>, { <(fields)> },                            ;
  768.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>, <rdd>   ;
  769.                  )
  770.  
  771.  
  772. #command APPEND [FROM <(file)>] [DELIMITED [WITH <*delim*>]]            ;
  773.          [FIELDS <fields,...>]                                          ;
  774.          [FOR <for>]                                                    ;
  775.          [WHILE <while>]                                                ;
  776.          [NEXT <next>]                                                  ;
  777.          [RECORD <rec>]                                                 ;
  778.          [<rest:REST>]                                                  ;
  779.          [ALL]                                                          ;
  780.                                                                         ;
  781.       => __dbDelim(                                                     ;
  782.                        .F., <(file)>, <(delim)>, { <(fields)> },        ;
  783.                        <{for}>, <{while}>, <next>, <rec>, <.rest.>      ;
  784.                      )
  785.  
  786.  
  787. #command APPEND [FROM <(file)>] [SDF]                                   ;
  788.          [FIELDS <fields,...>]                                          ;
  789.          [FOR <for>]                                                    ;
  790.          [WHILE <while>]                                                ;
  791.          [NEXT <next>]                                                  ;
  792.          [RECORD <rec>]                                                 ;
  793.          [<rest:REST>]                                                  ;
  794.          [ALL]                                                          ;
  795.                                                                         ;
  796.       => __dbSDF(                                                       ;
  797.                      .F., <(file)>, { <(fields)> },                     ;
  798.                      <{for}>, <{while}>, <next>, <rec>, <.rest.>        ;
  799.                    )
  800.  
  801.  
  802. #command APPEND [FROM <(file)>]                                         ;
  803.          [FIELDS <fields,...>]                                          ;
  804.          [FOR <for>]                                                    ;
  805.          [WHILE <while>]                                                ;
  806.          [NEXT <next>]                                                  ;
  807.          [RECORD <rec>]                                                 ;
  808.          [<rest:REST>]                                                  ;
  809.          [VIA <rdd>]                                                    ;
  810.          [ALL]                                                          ;
  811.                                                                         ;
  812.       => __dbApp(                                                       ;
  813.                   <(file)>, { <(fields)> },                             ;
  814.                   <{for}>, <{while}>, <next>, <rec>, <.rest.>, <rdd>    ;
  815.                 )
  816.  
  817.  
  818.  
  819. #command SORT [TO <(file)>] [ON <fields,...>]                           ;
  820.          [FOR <for>]                                                    ;
  821.          [WHILE <while>]                                                ;
  822.          [NEXT <next>]                                                  ;
  823.          [RECORD <rec>]                                                 ;
  824.          [<rest:REST>]                                                  ;
  825.          [ALL]                                                          ;
  826.                                                                         ;
  827.       => __dbSort(                                                      ;
  828.                    <(file)>, { <(fields)> },                            ;
  829.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>          ;
  830.                  )
  831.  
  832.  
  833. #command TOTAL [TO <(file)>] [ON <key>]                                 ;
  834.          [FIELDS <fields,...>]                                          ;
  835.          [FOR <for>]                                                    ;
  836.          [WHILE <while>]                                                ;
  837.          [NEXT <next>]                                                  ;
  838.          [RECORD <rec>]                                                 ;
  839.          [<rest:REST>]                                                  ;
  840.          [ALL]                                                          ;
  841.                                                                         ;
  842.       => __dbTotal(                                                     ;
  843.                     <(file)>, <{key}>, { <(fields)> },                  ;
  844.                     <{for}>, <{while}>, <next>, <rec>, <.rest.>         ;
  845.                   )
  846.  
  847.  
  848. #command UPDATE [FROM <(alias)>] [ON <key>]                             ;
  849.          [REPLACE <f1> WITH <x1> [, <fn> WITH <xn>]]                    ;
  850.          [<rand:RANDOM>]                                                ;
  851.                                                                         ;
  852.       => __dbUpdate(                                                    ;
  853.                      <(alias)>, <{key}>, <.rand.>,                      ;
  854.                      {|| _FIELD-><f1> := <x1> [, _FIELD-><fn> := <xn>]} ;
  855.                    )
  856.  
  857.  
  858. #command JOIN [WITH <(alias)>] [TO <file>]                              ;
  859.          [FIELDS <fields,...>]                                          ;
  860.          [FOR <for>]                                                    ;
  861.                                                                         ;
  862.       => __dbJoin( <(alias)>, <(file)>, { <(fields)> }, <{for}> )
  863.  
  864.  
  865. #command COUNT [TO <var>]                                               ;
  866.          [FOR <for>]                                                    ;
  867.          [WHILE <while>]                                                ;
  868.          [NEXT <next>]                                                  ;
  869.          [RECORD <rec>]                                                 ;
  870.          [<rest:REST>]                                                  ;
  871.          [ALL]                                                          ;
  872.                                                                         ;
  873.       => <var> := 0                                                     ;
  874.        ; DBEval(                                                        ;
  875.                  {|| <var> := <var> + 1},                               ;
  876.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  877.                )
  878.  
  879.  
  880. #command SUM [ <x1> [, <xn>]  TO  <v1> [, <vn>] ]                       ;
  881.          [FOR <for>]                                                    ;
  882.          [WHILE <while>]                                                ;
  883.          [NEXT <next>]                                                  ;
  884.          [RECORD <rec>]                                                 ;
  885.          [<rest:REST>]                                                  ;
  886.          [ALL]                                                          ;
  887.                                                                         ;
  888.       => <v1> := [ <vn> := ] 0                                          ;
  889.        ; DBEval(                                                        ;
  890.                  {|| <v1> := <v1> + <x1> [, <vn> := <vn> + <xn> ]},     ;
  891.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  892.                )
  893.  
  894.  
  895. #command AVERAGE [ <x1> [, <xn>]  TO  <v1> [, <vn>] ]                   ;
  896.          [FOR <for>]                                                    ;
  897.          [WHILE <while>]                                                ;
  898.          [NEXT <next>]                                                  ;
  899.          [RECORD <rec>]                                                 ;
  900.          [<rest:REST>]                                                  ;
  901.          [ALL]                                                          ;
  902.                                                                         ;
  903.       => M->__Avg := <v1> := [ <vn> := ] 0                              ;
  904.                                                                         ;
  905.        ; DBEval(                                                        ;
  906.                  {|| M->__Avg := M->__Avg + 1,                          ;
  907.                  <v1> := <v1> + <x1> [, <vn> := <vn> + <xn>] },         ;
  908.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  909.                )                                                        ;
  910.                                                                         ;
  911.        ; <v1> := <v1> / M->__Avg [; <vn> := <vn> / M->__Avg ]
  912.  
  913.  
  914. #command LIST [<list,...>]                                              ;
  915.          [<off:OFF>]                                                    ;
  916.          [<toPrint: TO PRINTER>]                                        ;
  917.          [TO FILE <(toFile)>]                                           ;
  918.          [FOR <for>]                                                    ;
  919.          [WHILE <while>]                                                ;
  920.          [NEXT <next>]                                                  ;
  921.          [RECORD <rec>]                                                 ;
  922.          [<rest:REST>]                                                  ;
  923.          [ALL]                                                          ;
  924.                                                                         ;
  925.       => __dbList(                                                      ;
  926.                    <.off.>, { <{list}> }, .t.,                          ;
  927.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>,         ;
  928.                    <.toPrint.>, <(toFile)>                              ;
  929.                  )
  930.  
  931.  
  932. #command DISPLAY [<list,...>]                                           ;
  933.          [<off:OFF>]                                                    ;
  934.          [<toPrint: TO PRINTER>]                                        ;
  935.          [TO FILE <(toFile)>]                                           ;
  936.          [FOR <for>]                                                    ;
  937.          [WHILE <while>]                                                ;
  938.          [NEXT <next>]                                                  ;
  939.          [RECORD <rec>]                                                 ;
  940.          [<rest:REST>]                                                  ;
  941.          [<all:ALL>]                                                    ;
  942.                                                                         ;
  943.       => __DBList(                                                      ;
  944.                    <.off.>, { <{list}> }, <.all.>,                      ;
  945.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>,         ;
  946.                    <.toPrint.>, <(toFile)>                              ;
  947.                  )
  948.  
  949.  
  950.  
  951. /***
  952. *   REPORT / LABEL
  953. */
  954.  
  955. #command REPORT FORM <frm>                                              ;
  956.          [HEADING <heading>]                                            ;
  957.          [<plain: PLAIN>]                                               ;
  958.          [<noeject: NOEJECT>]                                           ;
  959.          [<summary: SUMMARY>]                                           ;
  960.          [<noconsole: NOCONSOLE>]                                       ;
  961.          [<print: TO PRINTER>]                                          ;
  962.          [TO FILE <(toFile)>]                                           ;
  963.          [FOR <for>]                                                    ;
  964.          [WHILE <while>]                                                ;
  965.          [NEXT <next>]                                                  ;
  966.          [RECORD <rec>]                                                 ;
  967.          [<rest:REST>]                                                  ;
  968.          [ALL]                                                          ;
  969.                                                                         ;
  970.       => __ReportForm(                                                  ;
  971.                        <(frm)>, <.print.>, <(toFile)>, <.noconsole.>,   ;
  972.                        <{for}>, <{while}>, <next>, <rec>, <.rest.>,     ;
  973.                        <.plain.>, <heading>,                            ;
  974.                        <.noeject.>, <.summary.>                         ;
  975.                      )
  976.  
  977.  
  978. #command LABEL FORM <lbl>                                               ;
  979.          [<sample: SAMPLE>]                                             ;
  980.          [<noconsole: NOCONSOLE>]                                       ;
  981.          [<print: TO PRINTER>]                                          ;
  982.          [TO FILE <(toFile)>]                                           ;
  983.          [FOR <for>]                                                    ;
  984.          [WHILE <while>]                                                ;
  985.          [NEXT <next>]                                                  ;
  986.          [RECORD <rec>]                                                 ;
  987.          [<rest:REST>]                                                  ;
  988.          [ALL]                                                          ;
  989.                                                                         ;
  990.       => __LabelForm(                                                   ;
  991.                       <(lbl)>, <.print.>, <(toFile)>, <.noconsole.>,    ;
  992.                       <{for}>, <{while}>, <next>, <rec>, <.rest.>,      ;
  993.                       <.sample.>                                        ;
  994.                     )
  995.  
  996.  
  997.  
  998. // NOTE:  CLOSE <alias> must precede the others
  999. #command CLOSE <alias>          => <alias>->( dbCloseArea() )
  1000.  
  1001. #command CLOSE                  => dbCloseArea()
  1002. #command CLOSE DATABASES        => dbCloseAll()
  1003. #command CLOSE ALTERNATE        => Set(_SET_ALTFILE, "")
  1004. #command CLOSE FORMAT           => __SetFormat(NIL)
  1005. #command CLOSE INDEXES          => dbClearIndex()
  1006. #command CLOSE PROCEDURE        =>
  1007.  
  1008. #command CLOSE ALL                                                      ;
  1009.                                                                         ;
  1010.       => CLOSE DATABASES                                                ;
  1011.        ; SELECT 1                                                       ;
  1012.        ; CLOSE FORMAT
  1013.  
  1014. #command CLEAR                                                          ;
  1015.                                                                         ;
  1016.       => CLEAR SCREEN                                                   ;
  1017.        ; CLEAR GETS                                                     ;
  1018.  
  1019. #command CLEAR ALL                                                      ;
  1020.                                                                         ;
  1021.       => CLOSE DATABASES                                                ;
  1022.        ; CLOSE FORMAT                                                   ;
  1023.        ; CLEAR MEMORY                                                   ;
  1024.        ; CLEAR GETS                                                     ;
  1025.        ; SET ALTERNATE OFF                                              ;
  1026.        ; SET ALTERNATE TO
  1027.  
  1028. /***
  1029. *  ORD - Ordering commands
  1030. */
  1031. #command INDEX ON <key> [TAG <(cOrderName)> ] TO <(cOrderBagName)>      ;
  1032.          [FOR <for>]                                                    ;
  1033.          [<all:ALL>]                                                    ;
  1034.          [WHILE <while>]                                                ;
  1035.          [NEXT <next>]                                                  ;
  1036.          [RECORD <rec>]                                                 ;
  1037.          [<rest:REST>]                                                  ;
  1038.          [EVAL <eval>]                                                  ;
  1039.          [EVERY <every>]                                                ;
  1040.          [<unique: UNIQUE>]                                             ;
  1041.          [<ascend: ASCENDING>]                                          ;
  1042.          [<descend: DESCENDING>]                                        ;
  1043.       => ordCondSet( <"for">, <{for}>,                                  ;
  1044.                      [<.all.>],                                         ;
  1045.                      <{while}>,                                         ;
  1046.                      <{eval}>, <every>,                                 ;
  1047.                      RECNO(), <next>, <rec>,                            ;
  1048.                      [<.rest.>], [<.descend.>] )                        ;
  1049.       ;  ordCreate(<(cOrderBagName)>, <(cOrderName)>,                   ;
  1050.                    <"key">, <{key}>, [<.unique.>]    )
  1051.  
  1052. #command INDEX ON <key> TAG <(cOrderName)> [TO <(cOrderBagName)>]       ;
  1053.          [FOR <for>]                                                    ;
  1054.          [<all:ALL>]                                                    ;
  1055.          [WHILE <while>]                                                ;
  1056.          [NEXT <next>]                                                  ;
  1057.          [RECORD <rec>]                                                 ;
  1058.          [<rest:REST>]                                                  ;
  1059.          [EVAL <eval>]                                                  ;
  1060.          [EVERY <every>]                                                ;
  1061.          [<unique: UNIQUE>]                                             ;
  1062.          [<ascend: ASCENDING>]                                          ;
  1063.          [<descend: DESCENDING>]                                        ;
  1064.       => ordCondSet( <"for">, <{for}>,                                  ;
  1065.                      [<.all.>],                                         ;
  1066.                      <{while}>,                                         ;
  1067.                      <{eval}>, <every>,                                 ;
  1068.                      RECNO(), <next>, <rec>,                            ;
  1069.                      [<.rest.>], [<.descend.>] )                        ;
  1070.       ;  ordCreate(<(cOrderBagName)>, <(cOrderName)>,                   ;
  1071.                    <"key">, <{key}>, [<.unique.>]    )
  1072.  
  1073. #command INDEX ON <key> TO <(file)> [<u: UNIQUE>]                       ;
  1074.       => dbCreateIndex(                                                 ;
  1075.                         <(file)>, <"key">, <{key}>,                     ;
  1076.                         if( <.u.>, .t., NIL )                           ;
  1077.                       )
  1078.  
  1079. #command DELETE TAG <(cOrdName1)> [ IN <(cOrdBag1)> ]                   ;
  1080.                   [, <(cOrdNameN)> [ IN <(cOrdBagN)> ] ]                ;
  1081.       => ordDestroy( <(cOrdName1)>, <(cOrdBag1)> )                      ;
  1082.       [; ordDestroy( <(cOrdNameN)>, <(cOrdBagN)> ) ]
  1083.  
  1084. #command REINDEX                                                        ;
  1085.          [EVAL <eval>]                                                  ;
  1086.          [EVERY <every>]                                                ;
  1087.       => ordCondSet(,,,, <{eval}>, <every>,,,,,,,)                      ;
  1088.       ;  ordListRebuild()
  1089.  
  1090.  
  1091. #command REINDEX                => ordListRebuild()
  1092.  
  1093. #command SET INDEX TO [ <(index1)> [, <(indexn)>]] [<add: ADDITIVE>]    ;
  1094.                                                                         ;
  1095.       => if !<.add.> ; ordListClear() ; end                             ;
  1096.                                                                         ;
  1097.       [; ordListAdd( <(index1)> )]                                      ;
  1098.       [; ordListAdd( <(indexn)> )]
  1099.  
  1100.  
  1101. #command SET ORDER TO <xOrder>                                          ;
  1102.          [IN <(cOrdBag)>]                                               ;
  1103.                                                                         ;
  1104.       => ordSetFocus( <xOrder> [, <(cOrdBag)>] )
  1105.  
  1106.  
  1107. #command SET ORDER TO TAG <(cOrder)>                                                 ;
  1108.          [IN <(cOrdBag)>]                                               ;
  1109.                                                                         ;
  1110.       => ordSetFocus( <(cOrder)> [, <(cOrdBag)>] )
  1111.  
  1112.  
  1113.  
  1114. #command SET ORDER TO           => ordSetFocus(0)
  1115.  
  1116. 
  1117.