home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Database / CLIPR503.W96 / STD.C_ / STD.C
Text File  |  1995-06-26  |  64KB  |  1,336 lines
  1. /***
  2. *
  3. *  Std.ch
  4. *
  5. *  Clipper standard language definitions.
  6. *
  7. *  Copyright (c) 1990-1994, 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. *  Basic statement synonyms
  26. */
  27.  
  28. #command DO WHILE <exp>         => while <exp>
  29.  
  30. #command END <x>                => end
  31. #command END SEQUENCE           => end
  32. #command ENDSEQUENCE            => end
  33. #command ENDDO    <*x*>         => enddo
  34. #command ENDIF    <*x*>         => endif
  35. #command ENDCASE  <*x*>         => endcase
  36. #command ENDFOR [ <*x*> ]       => next
  37.  
  38. #command NEXT <v> [TO <x>] [STEP <s>]                                   ;
  39.       => next
  40.  
  41. #command DO <proc>.PRG [WITH <list,...>]                                ;
  42.       => do <proc> [ WITH <list>]
  43.  
  44. #command CALL <proc>() [WITH <list,...>]                                ;
  45.       => call <proc> [ WITH <list>]
  46.  
  47. #command STORE <value> TO <var1> [, <varN> ]                            ;
  48.       => <var1> := [ <varN> := ] <value>
  49.  
  50.  
  51.  
  52. /***
  53. *  Compatibility
  54. */
  55.  
  56. #command SET ECHO <*x*>         =>
  57. #command SET HEADING <*x*>      =>
  58. #command SET MENU <*x*>         =>
  59. #command SET STATUS <*x*>       =>
  60. #command SET STEP <*x*>         =>
  61. #command SET SAFETY <*x*>       =>
  62. #command SET TALK <*x*>         =>
  63. #command SET PROCEDURE TO       =>
  64. #command SET PROCEDURE TO <f>   =>  _ProcReq_( <(f)> )
  65.  
  66.  
  67.  
  68. /***
  69. *  System SETs
  70. */
  71.  
  72. #command SET EXACT <x:ON,OFF,&>         => Set( _SET_EXACT, <(x)> )
  73. #command SET EXACT (<x>)                => Set( _SET_EXACT, <x> )
  74.  
  75. #command SET FIXED <x:ON,OFF,&>         => Set( _SET_FIXED, <(x)> )
  76. #command SET FIXED (<x>)                => Set( _SET_FIXED, <x> )
  77.  
  78. #command SET DECIMALS TO <x>            => Set( _SET_DECIMALS, <x> )
  79. #command SET DECIMALS TO                => Set( _SET_DECIMALS, 0 )
  80.  
  81. #command SET PATH TO <*path*>           => Set( _SET_PATH, <(path)> )
  82. #command SET PATH TO                    => Set( _SET_PATH, "" )
  83.  
  84. #command SET DEFAULT TO <(path)>        => Set( _SET_DEFAULT, <(path)> )
  85. #command SET DEFAULT TO                 => Set( _SET_DEFAULT, "" )
  86.  
  87.  
  88.  
  89. /***
  90. *  Date format SETs
  91. */
  92.  
  93. #command SET CENTURY <x:ON,OFF,&>       => __SetCentury( <(x)> )
  94. #command SET CENTURY (<x>)              => __SetCentury( <x> )
  95. #command SET EPOCH TO <year>            => Set( _SET_EPOCH, <year> )
  96. #command SET DATE FORMAT [TO] <c>       => Set( _SET_DATEFORMAT, <c> )
  97.  
  98. #define  _DFSET(x, y)  Set( _SET_DATEFORMAT, if(__SetCentury(), x, y) )
  99.  
  100. #command SET DATE [TO] AMERICAN         => _DFSET( "mm/dd/yyyy", "mm/dd/yy" )
  101. #command SET DATE [TO] ANSI             => _DFSET( "yyyy.mm.dd", "yy.mm.dd" )
  102. #command SET DATE [TO] BRITISH          => _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
  103. #command SET DATE [TO] FRENCH           => _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
  104. #command SET DATE [TO] GERMAN           => _DFSET( "dd.mm.yyyy", "dd.mm.yy" )
  105. #command SET DATE [TO] ITALIAN          => _DFSET( "dd-mm-yyyy", "dd-mm-yy" )
  106. #command SET DATE [TO] JAPANESE         => _DFSET( "yyyy/mm/dd", "yy/mm/dd" )
  107. #command SET DATE [TO] USA              => _DFSET( "mm-dd-yyyy", "mm-dd-yy" )
  108.  
  109.  
  110.  
  111. /***
  112. *  Terminal I/O SETs
  113. */
  114.  
  115. #command SET ALTERNATE <x:ON,OFF,&>     => Set( _SET_ALTERNATE, <(x)> )
  116. #command SET ALTERNATE (<x>)            => Set( _SET_ALTERNATE, <x> )
  117.  
  118. #command SET ALTERNATE TO               => Set( _SET_ALTFILE, "" )
  119.  
  120. #command SET ALTERNATE TO <(file)> [<add: ADDITIVE>]                    ;
  121.       => Set( _SET_ALTFILE, <(file)>, <.add.> )
  122.  
  123.  
  124. #command SET CONSOLE <x:ON,OFF,&>       => Set( _SET_CONSOLE, <(x)> )
  125. #command SET CONSOLE (<x>)              => Set( _SET_CONSOLE, <x> )
  126.  
  127. #command SET MARGIN TO <x>              => Set( _SET_MARGIN, <x> )
  128. #command SET MARGIN TO                  => Set( _SET_MARGIN, 0 )
  129.  
  130.  
  131. #command SET PRINTER <x:ON,OFF,&>       => Set( _SET_PRINTER, <(x)> )
  132. #command SET PRINTER (<x>)              => Set( _SET_PRINTER, <x> )
  133.  
  134. #command SET PRINTER TO                 => Set( _SET_PRINTFILE, "" )
  135.  
  136. #command SET PRINTER TO <(file)> [<add: ADDITIVE>]                      ;
  137.       => Set( _SET_PRINTFILE, <(file)>, <.add.> )
  138.  
  139.  
  140. #command SET DEVICE TO SCREEN           => Set( _SET_DEVICE, "SCREEN" )
  141. #command SET DEVICE TO PRINTER          => Set( _SET_DEVICE, "PRINTER" )
  142.  
  143. #command SET COLOR TO [<*spec*>]        => SetColor( #<spec> )
  144. #command SET COLOR TO ( <c> )           => SetColor( <c> )
  145. #command SET COLOUR TO [<*spec*>]       => SET COLOR TO [<spec>]
  146.  
  147. #command SET CURSOR <x:ON,OFF,&>                                        ;
  148.       => SetCursor( if(Upper(<(x)>) == "ON", 1, 0) )
  149.  
  150. #command SET CURSOR (<x>)                                               ;
  151.       => SetCursor( if(<x>, 1, 0) )
  152.  
  153. #command SET EVENTMASK TO <x>            => Set( _SET_EVENTMASK, <x> )
  154.  
  155. #command SET VIDEOMODE TO <x>            => Set( _SET_VIDEOMODE, <x> )
  156.  
  157.  
  158. /***
  159. *  RDD Sets
  160. */
  161. #command SET SCOPETOP TO <x>            => OrdScope( 0, <x> )
  162. #command SET SCOPEBOTTOM TO <x>         => OrdScope( 1, <x> )
  163. #command SET SCOPE TO <x>, <y>          => OrdScope( 0, <x> );
  164.                                            OrdScope( 1, <y> )
  165. #command SET SCOPE TO <x>               => OrdScope( 0, <x> )
  166. #command SET SCOPE TO ,<x>              => OrdScope( 1, <x> )
  167.  
  168. #command SET MBLOCKSIZE TO <x>          => Set( _SET_MBLOCKSIZE, <x> )
  169. #command SET MEMOBLOCK TO <x>           => Set( _SET_MBLOCKSIZE, <x> )
  170.  
  171. #command SET MFILEEXT TO <x>            => Set( _SET_MFILEEXT, <x> )
  172.  
  173. #command SET STRICTREAD <x:ON,OFF,&>    => Set( _SET_STRICTREAD, <(x)> )
  174. #command SET STRICTREAD (<x>)           => Set( _SET_STRICTREAD, <x> )
  175.  
  176. #command SET OPTIMIZE <x:ON,OFF,&>      => Set( _SET_OPTIMIZE, <(x)> )
  177. #command SET OPTIMIZE (<x>)             => Set( _SET_OPTIMIZE, <x> )
  178.  
  179. #command SET AUTOPEN <x:ON,OFF,&>       => Set( _SET_AUTOPEN, <(x)> )
  180. #command SET AUTOPEN (<x>)              => Set( _SET_AUTOPEN, <x> )
  181.  
  182. #command SET AUTORDER TO <x>            => Set( _SET_AUTORDER, <x> )
  183.  
  184. #command SET AUTOSHARE TO <x>           => Set( _SET_AUTOSHARE, <x> )
  185.  
  186.  
  187. /***
  188. *  "Console" / printer output
  189. */
  190.  
  191. #command ?  [ <list,...> ]      => QOut( <list> )
  192. #command ?? [ <list,...> ]      => QQOut( <list> )
  193.  
  194. #command EJECT                  => __Eject()
  195.  
  196. #command TEXT                                                           ;
  197.       => text QOut, QQOut
  198.  
  199. #command TEXT TO FILE <(file)>                                          ;
  200.       => __TextSave( <(file)> )                                         ;
  201.        ; text QOut, __TextRestore
  202.  
  203. #command TEXT TO PRINTER                                                ;
  204.       => __TextSave("PRINTER")                                          ;
  205.        ; text QOut, __TextRestore
  206.  
  207.  
  208.  
  209. /***
  210. *  Clear screen
  211. */
  212.  
  213. #command CLS                                                            ;
  214.       => Scroll()                                                       ;
  215.        ; SetPos(0,0)
  216.  
  217. #command CLEAR SCREEN                                                   ;
  218.       => CLS
  219.  
  220. #command @ <row>, <col>                                                 ;
  221.       => Scroll( <row>, <col>, <row> )                                  ;
  222.        ; SetPos( <row>, <col> )
  223.  
  224. #command @ <top>, <left> CLEAR                                          ;
  225.       => Scroll( <top>, <left> )                                        ;
  226.        ; SetPos( <top>, <left> )
  227.  
  228.  
  229. #command @ <top>, <left> CLEAR TO <bottom>, <right>                     ;
  230.       => Scroll( <top>, <left>, <bottom>, <right> )                     ;
  231.        ; SetPos( <top>, <left> )
  232.  
  233.  
  234.  
  235. /***
  236. *  @..BOX
  237. */
  238.  
  239. #command @ <top>, <left>, <bottom>, <right> BOX <string>                ;
  240.                                             [COLOR <color>]             ;
  241.       => DispBox(                                                       ;
  242.                   <top>, <left>, <bottom>, <right>, <string>            ;
  243.                   [, <color> ]                                          ;
  244.                 )
  245.  
  246.  
  247. #command @ <top>, <left> TO <bottom>, <right> [DOUBLE]                  ;
  248.                                               [COLOR <color>]           ;
  249.       => DispBox(                                                       ;
  250.                   <top>, <left>, <bottom>, <right>, 2                   ;
  251.                   [, <color> ]                                          ;
  252.                 )
  253.  
  254.  
  255. #command @ <top>, <left> TO <bottom>, <right> [COLOR <color>]           ;
  256.                                                                         ;
  257.       => DispBox(                                                       ;
  258.                   <top>, <left>, <bottom>, <right>, 1                   ;
  259.                   [, <color> ]                                          ;
  260.                 )
  261.  
  262.  
  263.  
  264. /***
  265. *  @..SAY
  266. */
  267.  
  268. #command @ <row>, <col> SAY <xpr>                                       ;
  269.                         [PICTURE <pic>]                                 ;
  270.                         [COLOR <color>]                                 ;
  271.                                                                         ;
  272.       => DevPos( <row>, <col> )                                         ;
  273.        ; DevOutPict( <xpr>, <pic> [, <color>] )
  274.  
  275.  
  276. #command @ <row>, <col> SAY <xpr>                                       ;
  277.                         [COLOR <color>]                                 ;
  278.                                                                         ;
  279.       => DevPos( <row>, <col> )                                         ;
  280.        ; DevOut( <xpr> [, <color>] )
  281.  
  282.  
  283.  
  284. /***
  285. *  GET SETs
  286. */
  287.  
  288. #command SET BELL <x:ON,OFF,&>          => Set( _SET_BELL, <(x)> )
  289. #command SET BELL (<x>)                 => Set( _SET_BELL, <x> )
  290.  
  291. #command SET CONFIRM <x:ON,OFF,&>       => Set( _SET_CONFIRM, <(x)> )
  292. #command SET CONFIRM (<x>)              => Set( _SET_CONFIRM, <x> )
  293.  
  294. #command SET ESCAPE <x:ON,OFF,&>        => Set( _SET_ESCAPE, <(x)> )
  295. #command SET ESCAPE (<x>)               => Set( _SET_ESCAPE, <x> )
  296.  
  297. #command SET INTENSITY <x:ON,OFF,&>     => Set( _SET_INTENSITY, <(x)> )
  298. #command SET INTENSITY (<x>)            => Set( _SET_INTENSITY, <x> )
  299.  
  300. #command SET SCOREBOARD <x:ON,OFF,&>    => Set( _SET_SCOREBOARD, <(x)> )
  301. #command SET SCOREBOARD (<x>)           => Set( _SET_SCOREBOARD, <x> )
  302.  
  303. #command SET DELIMITERS <x:ON,OFF,&>    => Set( _SET_DELIMITERS, <(x)> )
  304. #command SET DELIMITERS (<x>)           => Set( _SET_DELIMITERS, <x> )
  305.  
  306. #command SET DELIMITERS TO <c>          => Set( _SET_DELIMCHARS, <c> )
  307. #command SET DELIMITERS TO DEFAULT      => Set( _SET_DELIMCHARS, "::" )
  308. #command SET DELIMITERS TO              => Set( _SET_DELIMCHARS, "::" )
  309.  
  310.  
  311. #command SET FORMAT TO <proc>                                           ;
  312.                                                                         ;
  313.       => _ProcReq_( <(proc)> + ".FMT" )                                 ;
  314.        ; __SetFormat( {|| <proc>()} )
  315.  
  316. #command SET FORMAT TO <proc>.<ext>                                     ;
  317.                                                                         ;
  318.       => _ProcReq_( <(proc)> + "." + <(ext)> )                          ;
  319.        ; __SetFormat( {|| <proc>()} )
  320.  
  321. #command SET FORMAT TO <x:&>                                            ;
  322.                                                                         ;
  323.       => if ( Empty(<(x)>) )                                            ;
  324.        ;   SET FORMAT TO                                                ;
  325.        ; else                                                           ;
  326.        ;   __SetFormat( &("{||" + <(x)> + "()}") )                      ;
  327.        ; end
  328.  
  329. #command SET FORMAT TO                                                  ;
  330.       => __SetFormat()
  331.  
  332.  
  333.  
  334. /***
  335. *  @..GET
  336. */
  337.  
  338. #command @ <row>, <col> GET <var>                                       ;
  339.                         [PICTURE <pic>]                                 ;
  340.                         [VALID <valid>]                                 ;
  341.                         [WHEN <when>]                                   ;
  342.                         [CAPTION <caption>]                             ;
  343.                         [MESSAGE <message>]                             ;
  344.                         [SEND <msg>]                                    ;
  345.                                                                         ;
  346.       => SetPos( <row>, <col> )                                         ;
  347.        ; AAdd(                                                          ;
  348.            GetList,                                                     ;
  349.            _GET_( <var>, <"var">, <pic>, <{valid}>, <{when}> ):display();
  350.              )                                                          ;
  351.       [; ATail(GetList):<msg>]                                          ;
  352.       [; ATail(GetList):Caption := <caption>]                           ;
  353.       [; ATail(GetList):CapRow  := <row>                                ;
  354.        ; ATail(GetList):CapCol  := <col> - __CapLength( #<caption> ) + 1];
  355.       [; ATail(GetList):message := <message>]                           ;
  356.        ; ATail(GetList):Display()
  357.  
  358.  
  359. /***
  360. *   @..SAY..GET
  361. */
  362.  
  363. #command @ <row>, <col> SAY <sayxpr>                                    ;
  364.                         [<sayClauses,...>]                              ;
  365.                         GET <var>                                       ;
  366.                         [<getClauses,...>]                              ;
  367.                                                                         ;
  368.       => @ <row>, <col> SAY <sayxpr> [<sayClauses>]                     ;
  369.        ; @ Row(), Col()+1 GET <var> [<getClauses>]
  370.  
  371.  
  372.  
  373. /***
  374. *   fancy GETs...
  375. */
  376.  
  377. // @..GET..RANGE (preprocessed to @..GET..VALID)
  378.  
  379. #command @ <row>, <col> GET <var>                                       ;
  380.                         [<clauses,...>]                                 ;
  381.                         RANGE <lo>, <hi>                                ;
  382.                         [<moreClauses,...>]                             ;
  383.                                                                         ;
  384.       => @ <row>, <col> GET <var>                                       ;
  385.                         [<clauses>]                                     ;
  386.                         VALID {|_1| RangeCheck(_1,, <lo>, <hi>)}        ;
  387.                         [<moreClauses>]
  388.  
  389.  
  390. // @..GET COLOR
  391.  
  392. #command @ <row>, <col> GET <var>                                       ;
  393.                         [<clauses,...>]                                 ;
  394.                         COLOR <color>                                   ;
  395.                         [<moreClauses,...>]                             ;
  396.                                                                         ;
  397.       => @ <row>, <col> GET <var>                                       ;
  398.                         [<clauses>]                                     ;
  399.                         SEND colorDisp(<color>)                         ;
  400.                         [<moreClauses>]
  401.  
  402.  
  403.  
  404. /***
  405. *  @..GET CHECKBOX
  406. */
  407.  
  408. #command @ <row>, <col> GET <var>                                       ;
  409.                         CHECKBOX                                        ;
  410.                         [VALID <valid>]                                 ;
  411.                         [WHEN <when>]                                   ;
  412.                         [CAPTION <caption>]                             ;
  413.                         [MESSAGE <message>]                             ;
  414.                         [COLOR <color>]                                 ;
  415.                         [FOCUS <fblock>]                                ;
  416.                         [STATE <sblock>]                                ;
  417.                         [STYLE <style>]                                 ;
  418.                         [SEND <msg>]                                    ;
  419.                         [GUISEND <guimsg>]                              ;
  420.                         [BITMAPS <aBitmaps>]                             ;
  421.                                                                         ;
  422.       => SetPos( <row>, <col> )                                         ;
  423.        ; AAdd(                                                          ;
  424.            GetList,                                                     ;
  425.            _GET_( <var>, <(var)>, NIL, <{valid}>, <{when}> )            ;
  426.              )                                                          ;
  427.          ; ATail(GetList):Control := _CheckBox_( <var>, <caption>,      ;
  428.                         <message>, <color>, <{fblock}>, <{sblock}>,     ;
  429.                         <style>, <aBitmaps> ):Display()                             ;
  430.        ; ATail(GetList):reader := { | a, b, c, d, e, f |                ;
  431.                                     GuiReader( a, b, c, d, e, f ) }     ;
  432.       [; ATail(GetList):<msg>]                                          ;
  433.       [; ATail(GetList):Control:<guimsg>]
  434.  
  435.  
  436. /***
  437. *  @..GET LISTBOX
  438. */
  439.  
  440. #command @ <top>, <left>, <bottom>, <right> GET <var>                    ;
  441.                         LISTBOX    <items>                               ;
  442.                         [VALID <valid>]                                  ;
  443.                         [WHEN <when>]                                    ;
  444.                         [CAPTION <caption>]                              ;
  445.                         [MESSAGE <message>]                              ;
  446.                         [COLOR <color>]                                  ;
  447.                         [FOCUS <fblock>]                                 ;
  448.                         [STATE <sblock>]                                 ;
  449.                         [<drop: DROPDOWN>]                               ;
  450.                         [<scroll: SCROLLBAR>]                            ;
  451.                         [SEND <msg>]                                     ;
  452.                         [GUISEND <guimsg>]                               ;
  453.                         [BITMAP <cBitmap>]                               ;
  454.                                                                          ;
  455.       => SetPos( <top>, <left> )                                         ;
  456.        ; AAdd(                                                           ;
  457.            GetList,                                                      ;
  458.            _GET_( <var>, <(var)>, NIL, <{valid}>, <{when}> )             ;
  459.              )                                                           ;
  460.          ; ATail(GetList):Control := _ListBox_( <top>, <left>, <bottom>, ;
  461.                        <right>, <var>, <items>, <caption>, <message>,    ;
  462.                        <color>, <{fblock}>, <{sblock}>, <.drop.>,        ;
  463.                        <.scroll.>, <cBitmap> ):display()                            ;
  464.        ; ATail(GetList):reader := { | a, b, c, d, e, f |                 ;
  465.                                     GuiReader( a, b, c, d, e, f ) }      ;
  466.       [; ATail(GetList):<msg>]                                           ;
  467.       [; ATail(GetList):Control:<guimsg>]
  468.  
  469.  
  470. /***
  471. *  @..GET PUSHBUTTON
  472. */
  473.  
  474. #command @ <row>, <col> GET <var>                                           ;
  475.                         PUSHBUTTON                                          ;
  476.                         [VALID <valid>]                                     ;
  477.                         [WHEN <when>]                                       ;
  478.                         [CAPTION <caption>]                                 ;
  479.                         [MESSAGE <message>]                                 ;
  480.                         [COLOR <color>]                                     ;
  481.                         [FOCUS <fblock>]                                    ;
  482.                         [STATE <sblock>]                                    ;
  483.                         [STYLE <style>]                                     ;
  484.                         [SEND <msg>]                                        ;
  485.                         [GUISEND <guimsg>]                                  ;
  486.                         [SIZE X <sizex> Y <sizey>]                          ;
  487.                         [CAPOFF X <capxoff> Y <capyoff>]                    ;
  488.                         [BITMAP <bitmap>]                                   ;
  489.                         [BMPOFF X <bmpxoff> Y <bmpyoff>]                    ;
  490.                                                                             ;
  491.       => SetPos( <row>, <col> )                                             ;
  492.        ; AAdd(                                                              ;
  493.            GetList,                                                         ;
  494.            _GET_( <var>, <(var)>, NIL, <{valid}>, <{when}> )                ;
  495.              )                                                              ;
  496.          ; ATail(GetList):Control := _PushButt_( <caption>, <message>,      ;
  497.                        <color>, <{fblock}>, <{sblock}>, <style>,            ;
  498.                        <sizex>, <sizey>, <capxoff>, <capyoff>,              ;
  499.                        <bitmap>, <bmpxoff>, <bmpyoff> ):display()           ;
  500.        ; ATail(GetList):reader := { | a, b, c, d, e, f |                    ;
  501.                                     GuiReader( a, b, c, d, e, f ) }         ;
  502.       [; ATail(GetList):<msg>]                                              ;
  503.       [; ATail(GetList):Control:<guimsg>]
  504.  
  505.  
  506. /***
  507. *  @..GET RADIOGROUP
  508. */
  509.  
  510. #command @ <top>, <left>, <bottom>, <right> GET <var>                     ;
  511.                         RADIOGROUP <buttons>                              ;
  512.                         [VALID <valid>]                                   ;
  513.                         [WHEN <when>]                                     ;
  514.                         [CAPTION <caption>]                               ;
  515.                         [MESSAGE <message>]                               ;
  516.                         [COLOR <color>]                                   ;
  517.                         [FOCUS <fblock>]                                  ;
  518.                         [STYLE <style>]                                   ;
  519.                         [SEND <msg>]                                      ;
  520.                         [GUISEND <guimsg>]                                ;
  521.                                                                           ;
  522.       => SetPos( <top>, <left> )                                          ;
  523.        ; AAdd(                                                            ;
  524.            GetList,                                                       ;
  525.            _GET_( <var>, <(var)>, NIL, <{valid}>, <{when}> )              ;
  526.              )                                                            ;
  527.          ; ATail(GetList):Control := _RadioGrp_( <top>, <left>, <bottom>, ;
  528.                        <right>, <var>, <buttons>, <caption>, <message>,   ;
  529.                        <color>, <{fblock}>, <style> ):display()           ;
  530.        ; ATail(GetList):reader := { | a, b, c, d, e, f |                  ;
  531.                                     GuiReader( a, b, c, d, e, f ) }       ;
  532.       [; ATail(GetList):<msg>]                                            ;
  533.       [; ATail(GetList):Control:<guimsg>]
  534.  
  535.  
  536. /***
  537. *  @..GET TBROWSE
  538. *  a browsin' I will go,
  539. *  a browsin' I will go,
  540. *  high ho duh merry oh,
  541. *  a browsin' I will go...
  542. */
  543.  
  544. #command @ <top>, <left>, <bottom>, <right> GET <var>                   ;
  545.                         TBROWSE <oBrowse>                               ;
  546.                         [VALID <preBlock>]                              ;
  547.                         [WHEN <postBlock>]                              ;
  548.                         [MESSAGE <message>]                             ;
  549.                         [SEND <msg>]                                    ;
  550.                         [GUISEND <guimsg>]                              ;
  551.                                                                         ;
  552.       => SetPos( <top>, <left> )                                        ;
  553.        ; AAdd(                                                          ;
  554.            GetList,                                                     ;
  555.            _GET_( <var>, <(var)>, NIL, <{preBlock}>, <{postBlock}> )    ;
  556.              )                                                          ;
  557.          ; <oBrowse>:ntop := <top>                                      ;
  558.          ; <oBrowse>:nleft := <left>                                    ;
  559.          ; <oBrowse>:nbottom := <bottom>                                ;
  560.          ; <oBrowse>:nright := <right>                                  ;
  561.          ; <oBrowse>:Configure()                                        ;
  562.          ; ATail(GetList):Control := <oBrowse>                          ;
  563.                                                                         ;
  564.        ; ATail(GetList):reader := { | a, b, c, d, e, f |                ;
  565.                                     tbReader( a, b, c, d, e, f ) }      ;
  566.       [; ATail(GetList):Control:Message := <message>]                   ;
  567.       [; ATail(GetList):<msg>]                                          ;
  568.       [; ATail(GetList):Control:<guimsg>]
  569.  
  570.  
  571. /***
  572. *  READ
  573. */
  574.  
  575. #command READ SAVE                                                      ;
  576.        => ReadModal(GetList)
  577.  
  578. #command READ                                                           ;
  579.       => ReadModal(GetList)                                             ;
  580.        ; GetList := {}
  581.  
  582. #command READ [MENU <oMenu>] [MSG AT <nRow>, <nLeft>, <nRight>          ;
  583.                [MSG COLOR <cColor>]]                                    ;
  584.       => ReadModal(GetList, NIL, <oMenu>, <nRow>, <nLeft>, <nRight>, <cColor>) ;
  585.        ; GetList := {}
  586.  
  587. #command READ SAVE [MENU <oMenu>] [MSG AT <nRow>, <nLeft>, <nRight>     ;
  588.                [MSG COLOR <cColor>]]                                    ;
  589.       => ReadModal(GetList, NIL, <oMenu>, <nRow>, <nLeft>, <nRight>, <cColor>)
  590.  
  591. #command CLEAR GETS                                                     ;
  592.       => ReadKill(.T.)                                                  ;
  593.        ; GetList := {}
  594.  
  595.  
  596.  
  597. /***
  598. *  Refinement...
  599. */
  600.  
  601. #command @ [<clauses,...>] COLOUR [<moreClauses,...>]                   ;
  602.       => @ [<clauses>] COLOR [<moreClauses>]
  603.  
  604.  
  605.  
  606. /***
  607. *  MENU TO
  608. */
  609.  
  610. #command SET WRAP <x:ON,OFF,&>  => Set( _SET_WRAP, <(x)> )
  611. #command SET WRAP (<x>)         => Set( _SET_WRAP, <x> )
  612.  
  613. #command SET MESSAGE TO <n> [<cent: CENTER, CENTRE>]                    ;
  614.       => Set( _SET_MESSAGE, <n> )                                       ;
  615.        ; Set( _SET_MCENTER, <.cent.> )
  616.  
  617. #command SET MESSAGE TO                                                 ;
  618.       => Set( _SET_MESSAGE, 0 )                                         ;
  619.        ; Set( _SET_MCENTER, .f. )
  620.  
  621. #command @ <row>, <col> PROMPT <prompt> [MESSAGE <msg>]                 ;
  622.       => __AtPrompt( <row>, <col>, <prompt> , <msg> )
  623.  
  624. #command MENU TO <v>                                                    ;
  625.       => <v> := __MenuTo( {|_1| if(PCount() == 0, <v>, <v> := _1)}, #<v> )
  626.  
  627.  
  628.  
  629. /***
  630. *  SAVE / RESTORE SCREEN
  631. */
  632.  
  633. #command SAVE SCREEN            => __XSaveScreen()
  634. #command RESTORE SCREEN         => __XRestScreen()
  635.  
  636. #command SAVE SCREEN TO <var>                                           ;
  637.       => <var> := SaveScreen( 0, 0, Maxrow(), Maxcol() )
  638.  
  639. #command RESTORE SCREEN FROM <c>                                        ;
  640.       => RestScreen( 0, 0, Maxrow(), Maxcol(), <c> )
  641.  
  642.  
  643.  
  644. /***
  645. *  Modal keyboard input
  646. */
  647.  
  648. #command WAIT [<c>]             => __Wait( <c> )
  649. #command WAIT [<c>] TO <var>    => <var> := __Wait( <c> )
  650. #command ACCEPT [<c>] TO <var>  => <var> := __Accept( <c> )
  651.  
  652. #command INPUT [<c>] TO <var>                                           ;
  653.                                                                         ;
  654.       => if ( !Empty(__Accept(<c>)) )                                   ;
  655.        ;    <var> := &( __AcceptStr() )                                 ;
  656.        ; end
  657.  
  658.  
  659. #command KEYBOARD <c>           => __Keyboard( <c> )
  660. #command CLEAR TYPEAHEAD        => __Keyboard()
  661. #command SET TYPEAHEAD TO <n>   => Set( _SET_TYPEAHEAD, <n> )
  662.  
  663. #command SET KEY <n> TO <proc>                                          ;
  664.       => SetKey( <n>, {|p, l, v| <proc>(p, l, v)} )
  665.  
  666. #command SET KEY <n> TO <proc> ( [<list,...>] )                         ;
  667.       => SET KEY <n> TO <proc>
  668.  
  669. #command SET KEY <n> TO <proc:&>                                        ;
  670.                                                                         ;
  671.       => if ( Empty(<(proc)>) )                                         ;
  672.        ;   SetKey( <n>, NIL )                                           ;
  673.        ; else                                                           ;
  674.        ;   SetKey( <n>, {|p, l, v| <proc>(p, l, v)} )                   ;
  675.        ; end
  676.  
  677. #command SET KEY <n> [TO]                                               ;
  678.       => SetKey( <n>, NIL )
  679.  
  680. #command SET FUNCTION <n> [TO] [<c>]                                    ;
  681.       => __SetFunction( <n>, <c> )
  682.  
  683.  
  684.  
  685. /***
  686. *  MEMVAR variables
  687. */
  688.  
  689. #command CLEAR MEMORY                   => __MClear()
  690. #command RELEASE <vars,...>             => __MXRelease( <"vars"> )
  691. #command RELEASE ALL                    => __MRelease("*", .t.)
  692. #command RELEASE ALL LIKE <skel>        => __MRelease( #<skel>, .t. )
  693. #command RELEASE ALL EXCEPT <skel>      => __MRelease( #<skel>, .f. )
  694.  
  695. #command RESTORE [FROM <(file)>] [<add: ADDITIVE>]                      ;
  696.       => __MRestore( <(file)>, <.add.> )
  697.  
  698. #command SAVE ALL LIKE <skel> TO <(file)>                               ;
  699.       => __MSave( <(file)>, <(skel)>, .t. )
  700.  
  701. #command SAVE TO <(file)> ALL LIKE <skel>                               ;
  702.       => __MSave( <(file)>, <(skel)>, .t. )
  703.  
  704. #command SAVE ALL EXCEPT <skel> TO <(file)>                             ;
  705.       => __MSave( <(file)>, <(skel)>, .f. )
  706.  
  707. #command SAVE TO <(file)> ALL EXCEPT <skel>                             ;
  708.       => __MSave( <(file)>, <(skel)>, .f. )
  709.  
  710. #command SAVE [TO <(file)>] [ALL]                                       ;
  711.       => __MSave( <(file)>, "*", .t. )
  712.  
  713.  
  714.  
  715. /***
  716. *  DOS file commands
  717. */
  718.  
  719. #command ERASE <(file)>                 => FErase( <(file)> )
  720. #command DELETE FILE <(file)>           => FErase( <(file)> )
  721. #command RENAME <(old)> TO <(new)>      => FRename( <(old)>, <(new)> )
  722.  
  723. #command COPY FILE <(src)> TO <(dest)>  => __CopyFile( <(src)>, <(dest)> )
  724. #command DIR [<(spec)>]                 => __Dir( <(spec)> )
  725.  
  726. #command TYPE <(file)> [<print: TO PRINTER>] [TO FILE <(dest)>]         ;
  727.                                                                         ;
  728.       => __TypeFile( <(file)>, <.print.> )                              ;
  729.       [; COPY FILE <(file)> TO <(dest)> ]
  730.  
  731. #command TYPE <(file)> [<print: TO PRINTER>]                            ;
  732.                                                                         ;
  733.       => __TypeFile( <(file)>, <.print.> )
  734.  
  735.  
  736. /***
  737. *  Declaration
  738. */
  739.  
  740. #command REQUEST <vars,...>             => EXTERNAL <vars>
  741.  
  742. /***
  743. *  Process
  744. */
  745.  
  746. #command CANCEL                 => __Quit()
  747. #command QUIT                   => __Quit()
  748.  
  749. #command RUN <*cmd*>            => __Run( #<cmd> )
  750. #command RUN ( <c> )            => __Run( <c> )
  751. #command ! <*cmd*>              => RUN <cmd>
  752. #command RUN = <xpr>            => ( run := <xpr> )
  753. #command RUN := <xpr>           => ( run := <xpr> )
  754.  
  755.  
  756.  
  757. /***
  758. *  DB SETs
  759. */
  760.  
  761. #command SET EXCLUSIVE <x:ON,OFF,&>     =>  Set( _SET_EXCLUSIVE, <(x)> )
  762. #command SET EXCLUSIVE (<x>)            =>  Set( _SET_EXCLUSIVE, <x> )
  763.  
  764. #command SET SOFTSEEK <x:ON,OFF,&>      =>  Set( _SET_SOFTSEEK, <(x)> )
  765. #command SET SOFTSEEK (<x>)             =>  Set( _SET_SOFTSEEK, <x> )
  766.  
  767. #command SET UNIQUE <x:ON,OFF,&>        =>  Set( _SET_UNIQUE, <(x)> )
  768. #command SET UNIQUE (<x>)               =>  Set( _SET_UNIQUE, <x> )
  769.  
  770. #command SET DELETED <x:ON,OFF,&>       =>  Set( _SET_DELETED, <(x)> )
  771. #command SET DELETED (<x>)              =>  Set( _SET_DELETED, <x> )
  772.  
  773.  
  774.  
  775. /***
  776. *  DB
  777. */
  778.  
  779. #command SELECT <whatever>              => dbSelectArea( <(whatever)> )
  780. #command SELECT <f>([<list,...>])       => dbSelectArea( <f>(<list>) )
  781.  
  782.  
  783. #command USE                            => dbCloseArea()
  784.  
  785. #command USE <(db)>                                                     ;
  786.              [VIA <rdd>]                                                ;
  787.              [ALIAS <a>]                                                ;
  788.              [<new: NEW>]                                               ;
  789.              [<ex: EXCLUSIVE>]                                          ;
  790.              [<sh: SHARED>]                                             ;
  791.              [<ro: READONLY>]                                           ;
  792.              [INDEX <(index1)> [, <(indexn)>]]                          ;
  793.                                                                         ;
  794.       => dbUseArea(                                                     ;
  795.                     <.new.>, <rdd>, <(db)>, <(a)>,                      ;
  796.                     if(<.sh.> .or. <.ex.>, !<.ex.>, NIL), <.ro.>        ;
  797.                   )                                                     ;
  798.                                                                         ;
  799.       [; dbSetIndex( <(index1)> )]                                      ;
  800.       [; dbSetIndex( <(indexn)> )]
  801.  
  802. #command APPEND BLANK           => dbAppend()
  803. #command PACK                   => __dbPack()
  804. #command ZAP                    => __dbZap()
  805. #command UNLOCK                 => dbUnlock()
  806. #command UNLOCK ALL             => dbUnlockAll()
  807. #command COMMIT                 => dbCommitAll()
  808.  
  809.  
  810. #command GOTO <n>               => dbGoto(<n>)
  811. #command GO <n>                 => dbGoto(<n>)
  812. #command GOTO TOP               => dbGoTop()
  813. #command GO TOP                 => dbGoTop()
  814. #command GOTO BOTTOM            => dbGoBottom()
  815. #command GO BOTTOM              => dbGoBottom()
  816.  
  817. #command SKIP                   => dbSkip(1)
  818. #command SKIP <n>               => dbSkip( <n> )
  819. #command SKIP ALIAS <a>         => <a> -> ( dbSkip(1) )
  820. #command SKIP <n> ALIAS <a>     => <a> -> ( dbSkip(<n>) )
  821.  
  822. #command SEEK <xpr>                                                     ;
  823.          [<soft: SOFTSEEK>]                                             ;
  824.       => dbSeek( <xpr>, if( <.soft.>, .T., NIL ) )
  825.  
  826. #command FIND <*text*>          => dbSeek( <(text)> )
  827. #command FIND := <xpr>          => ( find := <xpr> )
  828. #command FIND = <xpr>           => ( find := <xpr> )
  829.  
  830.  
  831. #command CONTINUE               => __dbContinue()
  832.  
  833. #command LOCATE                                                         ;
  834.          [FOR <for>]                                                    ;
  835.          [WHILE <while>]                                                ;
  836.          [NEXT <next>]                                                  ;
  837.          [RECORD <rec>]                                                 ;
  838.          [<rest:REST>]                                                  ;
  839.          [ALL]                                                          ;
  840.                                                                         ;
  841.       => __dbLocate( <{for}>, <{while}>, <next>, <rec>, <.rest.> )
  842.  
  843.  
  844.  
  845. #command SET RELATION TO        => dbClearRel()
  846.  
  847. #command SET RELATION                                                   ;
  848.          [<add:ADDITIVE>]                                               ;
  849.          [TO <key1> INTO <(alias1)> [, [TO] <keyn> INTO <(aliasn)>]]    ;
  850.                                                                         ;
  851.       => if ( !<.add.> )                                                ;
  852.        ;    dbClearRel()                                                ;
  853.        ; end                                                            ;
  854.                                                                         ;
  855.        ; dbSetRelation( <(alias1)>, <{key1}>, <"key1"> )                ;
  856.       [; dbSetRelation( <(aliasn)>, <{keyn}>, <"keyn"> )]
  857.  
  858.  
  859. #command SET FILTER TO          => dbClearFilter(NIL)
  860. #command SET FILTER TO <xpr>    => dbSetFilter( <{xpr}>, <"xpr"> )
  861.  
  862. #command SET FILTER TO <x:&>                                            ;
  863.       => if ( Empty(<(x)>) )                                            ;
  864.        ;    dbClearFilter()                                             ;
  865.        ; else                                                           ;
  866.        ;    dbSetFilter( <{x}>, <(x)> )                                 ;
  867.        ; end
  868.  
  869.  
  870. #command REPLACE [ <f1> WITH <x1> [, <fn> WITH <xn>] ]                  ;
  871.          [FOR <for>]                                                    ;
  872.          [WHILE <while>]                                                ;
  873.          [NEXT <next>]                                                  ;
  874.          [RECORD <rec>]                                                 ;
  875.          [<rest:REST>]                                                  ;
  876.          [ALL]                                                          ;
  877.                                                                         ;
  878.       => DBEval(                                                        ;
  879.                  {|| _FIELD-><f1> := <x1> [, _FIELD-><fn> := <xn>]},    ;
  880.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  881.                )
  882.  
  883.  
  884. #command REPLACE <f1> WITH <v1> [, <fN> WITH <vN> ]                     ;
  885.       => _FIELD-><f1> := <v1> [; _FIELD-><fN> := <vN>]
  886.  
  887.  
  888.  
  889. #command DELETE                                                         ;
  890.          [FOR <for>]                                                    ;
  891.          [WHILE <while>]                                                ;
  892.          [NEXT <next>]                                                  ;
  893.          [RECORD <rec>]                                                 ;
  894.          [<rest:REST>]                                                  ;
  895.          [ALL]                                                          ;
  896.                                                                         ;
  897.       => DBEval(                                                        ;
  898.                  {|| dbDelete()},                                       ;
  899.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  900.                )
  901.  
  902.  
  903. #command RECALL                                                         ;
  904.          [FOR <for>]                                                    ;
  905.          [WHILE <while>]                                                ;
  906.          [NEXT <next>]                                                  ;
  907.          [RECORD <rec>]                                                 ;
  908.          [<rest:REST>]                                                  ;
  909.          [ALL]                                                          ;
  910.                                                                         ;
  911.       => DBEval(                                                        ;
  912.                  {|| dbRecall()},                                       ;
  913.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  914.                )
  915.  
  916.  
  917. #command DELETE                 =>  dbDelete()
  918. #command RECALL                 =>  dbRecall()
  919.  
  920.  
  921. #command CREATE <(file1)>                                               ;
  922.             [FROM <(file2)>]                                            ;
  923.             [VIA <rdd>]                                                 ;
  924.             [ALIAS <a>]                                                 ;
  925.             [<new: NEW>]                                                ;
  926.                                                                         ;
  927.       => __dbCreate( <(file1)>, <(file2)>, <rdd>, <.new.>, <(a)> )
  928.  
  929.  
  930.  
  931. #command COPY [STRUCTURE] [EXTENDED] [TO <(file)>]                      ;
  932.       => __dbCopyXStruct( <(file)> )
  933.  
  934.  
  935. #command COPY [STRUCTURE] [TO <(file)>] [FIELDS <fields,...>]           ;
  936.       => __dbCopyStruct( <(file)>, { <(fields)> } )
  937.  
  938.  
  939. #command COPY [TO <(file)>] [DELIMITED [WITH <*delim*>]]                ;
  940.          [FIELDS <fields,...>]                                          ;
  941.          [FOR <for>]                                                    ;
  942.          [WHILE <while>]                                                ;
  943.          [NEXT <next>]                                                  ;
  944.          [RECORD <rec>]                                                 ;
  945.          [<rest:REST>]                                                  ;
  946.          [ALL]                                                          ;
  947.                                                                         ;
  948.       => __dbDelim(                                                     ;
  949.                         .T., <(file)>, <(delim)>, { <(fields)> },       ;
  950.                         <{for}>, <{while}>, <next>, <rec>, <.rest.>     ;
  951.                       )
  952.  
  953.  
  954. #command COPY [TO <(file)>] [SDF]                                       ;
  955.          [FIELDS <fields,...>]                                          ;
  956.          [FOR <for>]                                                    ;
  957.          [WHILE <while>]                                                ;
  958.          [NEXT <next>]                                                  ;
  959.          [RECORD <rec>]                                                 ;
  960.          [<rest:REST>]                                                  ;
  961.          [ALL]                                                          ;
  962.                                                                         ;
  963.       => __dbSDF(                                                       ;
  964.                   .T., <(file)>, { <(fields)> },                        ;
  965.                   <{for}>, <{while}>, <next>, <rec>, <.rest.>           ;
  966.                 )
  967.  
  968.  
  969. #command COPY [TO <(file)>]                                             ;
  970.          [FIELDS <fields,...>]                                          ;
  971.          [FOR <for>]                                                    ;
  972.          [WHILE <while>]                                                ;
  973.          [NEXT <next>]                                                  ;
  974.          [RECORD <rec>]                                                 ;
  975.          [<rest:REST>]                                                  ;
  976.          [VIA <rdd>]                                                    ;
  977.          [ALL]                                                          ;
  978.                                                                         ;
  979.       => __dbCopy(                                                      ;
  980.                    <(file)>, { <(fields)> },                            ;
  981.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>, <rdd>   ;
  982.                  )
  983.  
  984.  
  985. #command APPEND [FROM <(file)>] [DELIMITED [WITH <*delim*>]]            ;
  986.          [FIELDS <fields,...>]                                          ;
  987.          [FOR <for>]                                                    ;
  988.          [WHILE <while>]                                                ;
  989.          [NEXT <next>]                                                  ;
  990.          [RECORD <rec>]                                                 ;
  991.          [<rest:REST>]                                                  ;
  992.          [ALL]                                                          ;
  993.                                                                         ;
  994.       => __dbDelim(                                                     ;
  995.                        .F., <(file)>, <(delim)>, { <(fields)> },        ;
  996.                        <{for}>, <{while}>, <next>, <rec>, <.rest.>      ;
  997.                      )
  998.  
  999.  
  1000. #command APPEND [FROM <(file)>] [SDF]                                   ;
  1001.          [FIELDS <fields,...>]                                          ;
  1002.          [FOR <for>]                                                    ;
  1003.          [WHILE <while>]                                                ;
  1004.          [NEXT <next>]                                                  ;
  1005.          [RECORD <rec>]                                                 ;
  1006.          [<rest:REST>]                                                  ;
  1007.          [ALL]                                                          ;
  1008.                                                                         ;
  1009.       => __dbSDF(                                                       ;
  1010.                      .F., <(file)>, { <(fields)> },                     ;
  1011.                      <{for}>, <{while}>, <next>, <rec>, <.rest.>        ;
  1012.                    )
  1013.  
  1014.  
  1015. #command APPEND [FROM <(file)>]                                         ;
  1016.          [FIELDS <fields,...>]                                          ;
  1017.          [FOR <for>]                                                    ;
  1018.          [WHILE <while>]                                                ;
  1019.          [NEXT <next>]                                                  ;
  1020.          [RECORD <rec>]                                                 ;
  1021.          [<rest:REST>]                                                  ;
  1022.          [VIA <rdd>]                                                    ;
  1023.          [ALL]                                                          ;
  1024.                                                                         ;
  1025.       => __dbApp(                                                       ;
  1026.                   <(file)>, { <(fields)> },                             ;
  1027.                   <{for}>, <{while}>, <next>, <rec>, <.rest.>, <rdd>    ;
  1028.                 )
  1029.  
  1030.  
  1031.  
  1032. #command SORT [TO <(file)>] [ON <fields,...>]                           ;
  1033.          [FOR <for>]                                                    ;
  1034.          [WHILE <while>]                                                ;
  1035.          [NEXT <next>]                                                  ;
  1036.          [RECORD <rec>]                                                 ;
  1037.          [<rest:REST>]                                                  ;
  1038.          [ALL]                                                          ;
  1039.                                                                         ;
  1040.       => __dbSort(                                                      ;
  1041.                    <(file)>, { <(fields)> },                            ;
  1042.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>          ;
  1043.                  )
  1044.  
  1045.  
  1046. #command TOTAL [TO <(file)>] [ON <key>]                                 ;
  1047.          [FIELDS <fields,...>]                                          ;
  1048.          [FOR <for>]                                                    ;
  1049.          [WHILE <while>]                                                ;
  1050.          [NEXT <next>]                                                  ;
  1051.          [RECORD <rec>]                                                 ;
  1052.          [<rest:REST>]                                                  ;
  1053.          [ALL]                                                          ;
  1054.                                                                         ;
  1055.       => __dbTotal(                                                     ;
  1056.                     <(file)>, <{key}>, { <(fields)> },                  ;
  1057.                     <{for}>, <{while}>, <next>, <rec>, <.rest.>         ;
  1058.                   )
  1059.  
  1060.  
  1061. #command UPDATE [FROM <(alias)>] [ON <key>]                             ;
  1062.          [REPLACE <f1> WITH <x1> [, <fn> WITH <xn>]]                    ;
  1063.          [<rand:RANDOM>]                                                ;
  1064.                                                                         ;
  1065.       => __dbUpdate(                                                    ;
  1066.                      <(alias)>, <{key}>, <.rand.>,                      ;
  1067.                      {|| _FIELD-><f1> := <x1> [, _FIELD-><fn> := <xn>]} ;
  1068.                    )
  1069.  
  1070.  
  1071. #command JOIN [WITH <(alias)>] [TO <file>]                              ;
  1072.          [FIELDS <fields,...>]                                          ;
  1073.          [FOR <for>]                                                    ;
  1074.                                                                         ;
  1075.       => __dbJoin( <(alias)>, <(file)>, { <(fields)> }, <{for}> )
  1076.  
  1077.  
  1078. #command COUNT [TO <var>]                                               ;
  1079.          [FOR <for>]                                                    ;
  1080.          [WHILE <while>]                                                ;
  1081.          [NEXT <next>]                                                  ;
  1082.          [RECORD <rec>]                                                 ;
  1083.          [<rest:REST>]                                                  ;
  1084.          [ALL]                                                          ;
  1085.                                                                         ;
  1086.       => <var> := 0                                                     ;
  1087.        ; DBEval(                                                        ;
  1088.                  {|| <var> := <var> + 1},                               ;
  1089.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  1090.                )
  1091.  
  1092.  
  1093. #command SUM [ <x1> [, <xn>]  TO  <v1> [, <vn>] ]                       ;
  1094.          [FOR <for>]                                                    ;
  1095.          [WHILE <while>]                                                ;
  1096.          [NEXT <next>]                                                  ;
  1097.          [RECORD <rec>]                                                 ;
  1098.          [<rest:REST>]                                                  ;
  1099.          [ALL]                                                          ;
  1100.                                                                         ;
  1101.       => <v1> := [ <vn> := ] 0                                          ;
  1102.        ; DBEval(                                                        ;
  1103.                  {|| <v1> := <v1> + <x1> [, <vn> := <vn> + <xn> ]},     ;
  1104.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  1105.                )
  1106.  
  1107.  
  1108. #command AVERAGE [ <x1> [, <xn>]  TO  <v1> [, <vn>] ]                   ;
  1109.          [FOR <for>]                                                    ;
  1110.          [WHILE <while>]                                                ;
  1111.          [NEXT <next>]                                                  ;
  1112.          [RECORD <rec>]                                                 ;
  1113.          [<rest:REST>]                                                  ;
  1114.          [ALL]                                                          ;
  1115.                                                                         ;
  1116.       => M->__Avg := <v1> := [ <vn> := ] 0                              ;
  1117.                                                                         ;
  1118.        ; DBEval(                                                        ;
  1119.                  {|| M->__Avg := M->__Avg + 1,                          ;
  1120.                  <v1> := <v1> + <x1> [, <vn> := <vn> + <xn>] },         ;
  1121.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  1122.                )                                                        ;
  1123.                                                                         ;
  1124.        ; <v1> := <v1> / M->__Avg [; <vn> := <vn> / M->__Avg ]
  1125.  
  1126.  
  1127. #command LIST [<list,...>]                                              ;
  1128.          [<off:OFF>]                                                    ;
  1129.          [<toPrint: TO PRINTER>]                                        ;
  1130.          [TO FILE <(toFile)>]                                           ;
  1131.          [FOR <for>]                                                    ;
  1132.          [WHILE <while>]                                                ;
  1133.          [NEXT <next>]                                                  ;
  1134.          [RECORD <rec>]                                                 ;
  1135.          [<rest:REST>]                                                  ;
  1136.          [ALL]                                                          ;
  1137.                                                                         ;
  1138.       => __dbList(                                                      ;
  1139.                    <.off.>, { <{list}> }, .t.,                          ;
  1140.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>,         ;
  1141.                    <.toPrint.>, <(toFile)>                              ;
  1142.                  )
  1143.  
  1144.  
  1145. #command DISPLAY [<list,...>]                                           ;
  1146.          [<off:OFF>]                                                    ;
  1147.          [<toPrint: TO PRINTER>]                                        ;
  1148.          [TO FILE <(toFile)>]                                           ;
  1149.          [FOR <for>]                                                    ;
  1150.          [WHILE <while>]                                                ;
  1151.          [NEXT <next>]                                                  ;
  1152.          [RECORD <rec>]                                                 ;
  1153.          [<rest:REST>]                                                  ;
  1154.          [<all:ALL>]                                                    ;
  1155.                                                                         ;
  1156.       => __DBList(                                                      ;
  1157.                    <.off.>, { <{list}> }, <.all.>,                      ;
  1158.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>,         ;
  1159.                    <.toPrint.>, <(toFile)>                              ;
  1160.                  )
  1161.  
  1162.  
  1163.  
  1164. /***
  1165. *   REPORT / LABEL
  1166. */
  1167.  
  1168. #command REPORT FORM <frm>                                              ;
  1169.          [HEADING <heading>]                                            ;
  1170.          [<plain: PLAIN>]                                               ;
  1171.          [<noeject: NOEJECT>]                                           ;
  1172.          [<summary: SUMMARY>]                                           ;
  1173.          [<noconsole: NOCONSOLE>]                                       ;
  1174.          [<print: TO PRINTER>]                                          ;
  1175.          [TO FILE <(toFile)>]                                           ;
  1176.          [FOR <for>]                                                    ;
  1177.          [WHILE <while>]                                                ;
  1178.          [NEXT <next>]                                                  ;
  1179.          [RECORD <rec>]                                                 ;
  1180.          [<rest:REST>]                                                  ;
  1181.          [ALL]                                                          ;
  1182.                                                                         ;
  1183.       => __ReportForm(                                                  ;
  1184.                        <(frm)>, <.print.>, <(toFile)>, <.noconsole.>,   ;
  1185.                        <{for}>, <{while}>, <next>, <rec>, <.rest.>,     ;
  1186.                        <.plain.>, <heading>,                            ;
  1187.                        <.noeject.>, <.summary.>                         ;
  1188.                      )
  1189.  
  1190.  
  1191. #command LABEL FORM <lbl>                                               ;
  1192.          [<sample: SAMPLE>]                                             ;
  1193.          [<noconsole: NOCONSOLE>]                                       ;
  1194.          [<print: TO PRINTER>]                                          ;
  1195.          [TO FILE <(toFile)>]                                           ;
  1196.          [FOR <for>]                                                    ;
  1197.          [WHILE <while>]                                                ;
  1198.          [NEXT <next>]                                                  ;
  1199.          [RECORD <rec>]                                                 ;
  1200.          [<rest:REST>]                                                  ;
  1201.          [ALL]                                                          ;
  1202.                                                                         ;
  1203.       => __LabelForm(                                                   ;
  1204.                       <(lbl)>, <.print.>, <(toFile)>, <.noconsole.>,    ;
  1205.                       <{for}>, <{while}>, <next>, <rec>, <.rest.>,      ;
  1206.                       <.sample.>                                        ;
  1207.                     )
  1208.  
  1209.  
  1210.  
  1211. // NOTE:  CLOSE <alias> must precede the others
  1212. #command CLOSE <alias>          => <alias>->( dbCloseArea() )
  1213.  
  1214. #command CLOSE                  => dbCloseArea()
  1215. #command CLOSE DATABASES        => dbCloseAll()
  1216. #command CLOSE ALTERNATE        => Set(_SET_ALTFILE, "")
  1217. #command CLOSE FORMAT           => __SetFormat(NIL)
  1218. #command CLOSE INDEXES          => dbClearIndex()
  1219. #command CLOSE PROCEDURE        =>
  1220.  
  1221. #command CLOSE ALL                                                      ;
  1222.                                                                         ;
  1223.       => CLOSE DATABASES                                                ;
  1224.        ; SELECT 1                                                       ;
  1225.        ; CLOSE FORMAT
  1226.  
  1227. #command CLEAR                                                          ;
  1228.                                                                         ;
  1229.       => CLEAR SCREEN                                                   ;
  1230.        ; CLEAR GETS                                                     ;
  1231.  
  1232. #command CLEAR ALL                                                      ;
  1233.                                                                         ;
  1234.       => CLOSE DATABASES                                                ;
  1235.        ; CLOSE FORMAT                                                   ;
  1236.        ; CLEAR MEMORY                                                   ;
  1237.        ; CLEAR GETS                                                     ;
  1238.        ; SET ALTERNATE OFF                                              ;
  1239.        ; SET ALTERNATE TO
  1240.  
  1241. /***
  1242. *  ORD - Ordering commands
  1243. */
  1244. #command INDEX ON <key> [TAG <(cOrderName)> ] TO <(cOrderBagName)>      ;
  1245.          [FOR <for>]                                                    ;
  1246.          [<all:ALL>]                                                    ;
  1247.          [WHILE <while>]                                                ;
  1248.          [NEXT <next>]                                                  ;
  1249.          [RECORD <rec>]                                                 ;
  1250.          [<rest:REST>]                                                  ;
  1251.          [EVAL <eval>]                                                  ;
  1252.          [EVERY <every>]                                                ;
  1253.          [<unique: UNIQUE>]                                             ;
  1254.          [<ascend: ASCENDING>]                                          ;
  1255.          [<descend: DESCENDING>]                                        ;
  1256.       => ordCondSet( <"for">, <{for}>,                                  ;
  1257.                      [<.all.>],                                         ;
  1258.                      <{while}>,                                         ;
  1259.                      <{eval}>, <every>,                                 ;
  1260.                      RECNO(), <next>, <rec>,                            ;
  1261.                      [<.rest.>], [<.descend.>] )                        ;
  1262.       ;  ordCreate(<(cOrderBagName)>, <(cOrderName)>,                   ;
  1263.                    <"key">, <{key}>, [<.unique.>]    )
  1264.  
  1265. #command INDEX ON <key> TAG <(cOrderName)> [TO <(cOrderBagName)>]       ;
  1266.          [FOR <for>]                                                    ;
  1267.          [<all:ALL>]                                                    ;
  1268.          [WHILE <while>]                                                ;
  1269.          [NEXT <next>]                                                  ;
  1270.          [RECORD <rec>]                                                 ;
  1271.          [<rest:REST>]                                                  ;
  1272.          [EVAL <eval>]                                                  ;
  1273.          [EVERY <every>]                                                ;
  1274.          [<unique: UNIQUE>]                                             ;
  1275.          [<ascend: ASCENDING>]                                          ;
  1276.          [<descend: DESCENDING>]                                        ;
  1277.       => ordCondSet( <"for">, <{for}>,                                  ;
  1278.                      [<.all.>],                                         ;
  1279.                      <{while}>,                                         ;
  1280.                      <{eval}>, <every>,                                 ;
  1281.                      RECNO(), <next>, <rec>,                            ;
  1282.                      [<.rest.>], [<.descend.>] )                        ;
  1283.       ;  ordCreate(<(cOrderBagName)>, <(cOrderName)>,                   ;
  1284.                    <"key">, <{key}>, [<.unique.>]    )
  1285.  
  1286. #command INDEX ON <key> TO <(file)> [<u: UNIQUE>]                       ;
  1287.       => dbCreateIndex(                                                 ;
  1288.                         <(file)>, <"key">, <{key}>,                     ;
  1289.                         if( <.u.>, .t., NIL )                           ;
  1290.                       )
  1291.  
  1292. #command DELETE TAG <(cOrdName1)> [ IN <(cOrdBag1)> ]                   ;
  1293.                   [, <(cOrdNameN)> [ IN <(cOrdBagN)> ] ]                ;
  1294.       => ordDestroy( <(cOrdName1)>, <(cOrdBag1)> )                      ;
  1295.       [; ordDestroy( <(cOrdNameN)>, <(cOrdBagN)> ) ]
  1296.  
  1297. #command REINDEX                                                        ;
  1298.          [EVAL <eval>]                                                  ;
  1299.          [EVERY <every>]                                                ;
  1300.       => ordCondSet(,,,, <{eval}>, <every>,,,,,,,)                      ;
  1301.       ;  ordListRebuild()
  1302.  
  1303.  
  1304. #command REINDEX                => ordListRebuild()
  1305.  
  1306. #command SET INDEX TO [ <(index1)> [, <(indexn)>]] [<add: ADDITIVE>]    ;
  1307.                                                                         ;
  1308.       => if !<.add.> ; ordListClear() ; end                             ;
  1309.                                                                         ;
  1310.       [; ordListAdd( <(index1)> )]                                      ;
  1311.       [; ordListAdd( <(indexn)> )]
  1312.  
  1313.  
  1314. #command SET ORDER TO <xOrder>                                          ;
  1315.          [IN <(cOrdBag)>]                                               ;
  1316.                                                                         ;
  1317.       => ordSetFocus( <xOrder> [, <(cOrdBag)>] )
  1318.  
  1319.  
  1320. #command SET ORDER TO TAG <(cOrder)>                                                 ;
  1321.          [IN <(cOrdBag)>]                                               ;
  1322.                                                                         ;
  1323.       => ordSetFocus( <(cOrder)> [, <(cOrdBag)>] )
  1324.  
  1325.  
  1326.  
  1327. #command SET ORDER TO           => ordSetFocus(0)
  1328.  
  1329.  
  1330. /***
  1331. *  repository support
  1332. */
  1333.  
  1334. #xcommand TEXTBLOCK <*cText*>   => // <cText>
  1335. 
  1336.