home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a009 / 5.ddi / INCLUDE.LIF / STD.CH < prev   
Encoding:
Text File  |  1991-04-14  |  45.4 KB  |  1,032 lines

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