home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1993 #2 / Image.iso / clipper / bcklib2.zip / ALIAS.CH next >
Encoding:
Text File  |  1992-12-20  |  25.6 KB  |  480 lines
  1. /* Allow ALIAS clause on most commands */
  2.  
  3. #command SET RELATION                                                   ;
  4.          [<add:ADDITIVE>]                                               ;
  5.          [TO <key1> INTO <(alias1)>                                ]    ;
  6.          ALIAS <a>                                                      ;
  7.                                                                         ;
  8.       => if ( !<.add.> )                                                ;
  9.        ;    <a> -> (dbClearRel())                                       ;
  10.        ; end                                                            ;
  11.                                                                         ;
  12.        ; <a> -> (dbSetRelation( <(alias1)>, <{key1}>, <"key1"> ))
  13.  
  14. #command REINDEX              ALIAS <a> => <a> -> ( dbReindex() )
  15. #command SET ORDER TO <n>     ALIAS <a> => <a> -> ( dbSetOrder( <n> ) )
  16. #command SET ORDER TO         ALIAS <a> => <a> -> ( dbSetOrder(0) )
  17. #command APPEND BLANK         ALIAS <a> => <a> -> ( dbAppend() )
  18. #command PACK                 ALIAS <a> => <a> -> ( __dbPack() )
  19. #command ZAP                  ALIAS <a> => <a> -> ( __dbZap() )
  20. #command UNLOCK               ALIAS <a>  => <a> -> ( dbUnlock() )
  21. #command UNLOCK ALL           ALIAS <a>  => <a> -> ( dbUnlockAll() )
  22. #command COMMIT               ALIAS <a>  => <a> -> ( dbCommitAll() )
  23. #command GOTO <n>             ALIAS <a>  => <a> -> ( dbGoto(<n>) )
  24. #command GO <n>               ALIAS <a>  => <a> -> ( dbGoto(<n>) )
  25. #command GOTO TOP             ALIAS <a>  => <a> -> ( dbGoTop() )
  26. #command GO TOP               ALIAS <a>  => <a> -> ( dbGoTop() )
  27. #command GOTO BOTTOM          ALIAS <a>  => <a> -> ( dbGoBottom() )
  28. #command GO BOTTOM            ALIAS <a>  => <a> -> ( dbGoBottom() )
  29. #command SEEK <xpr>           ALIAS <a>  => <a> -> ( dbSeek( <xpr> ) )
  30. /* note FIND not included */
  31. #command CONTINUE             ALIAS <a>  => <a> -> ( __dbContinue() )
  32. #command LOCATE                                                         ;
  33.          [FOR <for>]                                                    ;
  34.          [WHILE <while>]                                                ;
  35.          [NEXT <next>]                                                  ;
  36.          [RECORD <rec>]                                                 ;
  37.          [<rest:REST>]                                                  ;
  38.          [ALL]                                                          ;
  39.          ALIAS <a>                                                      ;
  40.                                                                         ;
  41.       => <a> -> ( __dbLocate( <{for}>, <{while}>, <next>, <rec>, <.rest.> ) )
  42. #command SET FILTER TO        ALIAS <a>  => <a> -> ( dbClearFilter(NIL) )
  43. #command SET FILTER TO <xpr>  ALIAS <a>  => <a> -> ( dbSetFilter( <{xpr}>, <"xpr"> ) )
  44.  
  45. #command SET FILTER TO <x:&>  ALIAS <a>                                 ;
  46.       => if ( Empty(<(x)>) )                                            ;
  47.        ;    <a> -> ( dbClearFilter()                                    ;
  48.        ; else                                                           ;
  49.        ;    <a> -> ( dbSetFilter( <{x}>, <(x)> )                        ;
  50.        ; end
  51. #command DELETE                                                         ;
  52.          [FOR <for>]                                                    ;
  53.          [WHILE <while>]                                                ;
  54.          [NEXT <next>]                                                  ;
  55.          [RECORD <rec>]                                                 ;
  56.          [<rest:REST>]                                                  ;
  57.          [ALL]                                                          ;
  58.          ALIAS <a>                                                      ;
  59.                                                                         ;
  60.       => <a> -> ( DBEval(                                               ;
  61.                  {|| dbDelete() },                                      ;
  62.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  63.                ) )
  64. #command RECALL                                                         ;
  65.          [FOR <for>]                                                    ;
  66.          [WHILE <while>]                                                ;
  67.          [NEXT <next>]                                                  ;
  68.          [RECORD <rec>]                                                 ;
  69.          [<rest:REST>]                                                  ;
  70.          [ALL]                                                          ;
  71.          ALIAS <a>                                                      ;
  72.       => <a> -> ( DBEval(                                                        ;
  73.                  {|| dbRecall()},                                       ;
  74.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  75.                ) )
  76. #command DELETE               ALIAS <a>  =>  <a> -> ( dbDelete() )
  77. #command RECALL               ALIAS <a>  =>  <a> -> ( dbRecall() )
  78. #command SORT [TO <(file)>] [ON <fields,...>]                           ;
  79.          [FOR <for>]                                                    ;
  80.          [WHILE <while>]                                                ;
  81.          [NEXT <next>]                                                  ;
  82.          [RECORD <rec>]                                                 ;
  83.          [<rest:REST>]                                                  ;
  84.          [ALL]                                                          ;
  85.          ALIAS <a>                                                      ;
  86.       => <a> -> ( __dbSort(                                                      ;
  87.                    <(file)>, { <(fields)> },                            ;
  88.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>          ;
  89.                  ) )
  90. #command TOTAL [TO <(file)>] [ON <key>]                                 ;
  91.          [FIELDS <fields,...>]                                          ;
  92.          [FOR <for>]                                                    ;
  93.          [WHILE <while>]                                                ;
  94.          [NEXT <next>]                                                  ;
  95.          [RECORD <rec>]                                                 ;
  96.          [<rest:REST>]                                                  ;
  97.          [ALL]                                                          ;
  98.          ALIAS <a>                                                      ;
  99.       => <a> -> ( __dbTotal(                                                     ;
  100.                     <(file)>, <{key}>, { <(fields)> },                  ;
  101.                     <{for}>, <{while}>, <next>, <rec>, <.rest.>         ;
  102.                   ) )
  103. #command UPDATE [FROM <(alias)>] [ON <key>]                             ;
  104.          [REPLACE <f1> WITH <x1> [, <fn> WITH <xn>]]                    ;
  105.          [<rand:RANDOM>]                                                ;
  106.          ALIAS <a>                                                      ;
  107.       => <a> -> ( __dbUpdate(                                                    ;
  108.                      <(alias)>, <{key}>, <.rand.>,                      ;
  109.                      {|| _FIELD-><f1> := <x1> [, _FIELD-><fn> := <xn>]} ;
  110.                    ) )
  111. #command JOIN [WITH <(alias)>] [TO <file>]                              ;
  112.          [FIELDS <fields,...>]                                          ;
  113.          [FOR <for>]                                                    ;
  114.          ALIAS <a>                                                      ;
  115.       => <a> -> ( __dbJoin( <(alias)>, <(file)>, { <(fields)> }, <{for}> ) )
  116. #command COUNT [TO <var>]                                               ;
  117.          [FOR <for>]                                                    ;
  118.          [WHILE <while>]                                                ;
  119.          [NEXT <next>]                                                  ;
  120.          [RECORD <rec>]                                                 ;
  121.          [<rest:REST>]                                                  ;
  122.          [ALL]                                                          ;
  123.          ALIAS <a>                                                      ;
  124.       => <var> := 0                                                     ;
  125.        ; <a> -> ( DBEval(                                                        ;
  126.                  {|| <var> := <var> + 1},                               ;
  127.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  128.                ) )
  129. #command SUM [ <x1> [, <xn>]  TO  <v1> [, <vn>] ]                       ;
  130.          [FOR <for>]                                                    ;
  131.          [WHILE <while>]                                                ;
  132.          [NEXT <next>]                                                  ;
  133.          [RECORD <rec>]                                                 ;
  134.          [<rest:REST>]                                                  ;
  135.          [ALL]                                                          ;
  136.          ALIAS <a>                                                      ;
  137.       => <v1> := [ <vn> := ] 0                                          ;
  138.        ; <a> -> ( DBEval(                                                        ;
  139.                  {|| <v1> := <v1> + <x1> [, <vn> := <vn> + <xn> ]},     ;
  140.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  141.                ) )
  142. #command AVERAGE [ <x1> [, <xn>]  TO  <v1> [, <vn>] ]                   ;
  143.          [FOR <for>]                                                    ;
  144.          [WHILE <while>]                                                ;
  145.          [NEXT <next>]                                                  ;
  146.          [RECORD <rec>]                                                 ;
  147.          [<rest:REST>]                                                  ;
  148.          [ALL]                                                          ;
  149.          ALIAS <a>                                                      ;
  150.       => M->__Avg := <v1> := [ <vn> := ] 0                              ;
  151.                                                                         ;
  152.        ; <a> -> ( DBEval(                                                        ;
  153.                  {|| M->__Avg := M->__Avg + 1,                          ;
  154.                  <v1> := <v1> + <x1> [, <vn> := <vn> + <xn>] },         ;
  155.                  <{for}>, <{while}>, <next>, <rec>, <.rest.>            ;
  156.                )                                                        ;
  157.                                                                         ;
  158.        ; <v1> := <v1> / M->__Avg [; <vn> := <vn> / M->__Avg ]
  159. #command LIST [<list,...>]                                              ;
  160.          [<off:OFF>]                                                    ;
  161.          [<toPrint: TO PRINTER>]                                        ;
  162.          [TO FILE <(toFile)>]                                           ;
  163.          [FOR <for>]                                                    ;
  164.          [WHILE <while>]                                                ;
  165.          [NEXT <next>]                                                  ;
  166.          [RECORD <rec>]                                                 ;
  167.          [<rest:REST>]                                                  ;
  168.          [ALL]                                                          ;
  169.          ALIAS <a>                                                      ;
  170.       => <a> -> ( __dbList(                                                      ;
  171.                    <.off.>, { <{list}> }, .t.,                          ;
  172.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>,         ;
  173.                    <.toPrint.>, <(toFile)>                              ;
  174.                  ) )
  175. #command DISPLAY [<list,...>]                                           ;
  176.          [<off:OFF>]                                                    ;
  177.          [<toPrint: TO PRINTER>]                                        ;
  178.          [TO FILE <(toFile)>]                                           ;
  179.          [FOR <for>]                                                    ;
  180.          [WHILE <while>]                                                ;
  181.          [NEXT <next>]                                                  ;
  182.          [RECORD <rec>]                                                 ;
  183.          [<rest:REST>]                                                  ;
  184.          [<all:ALL>]                                                    ;
  185.          ALIAS <a>                                                      ;
  186.       => <a> -> ( __DBList(                                                      ;
  187.                    <.off.>, { <{list}> }, <.all.>,                      ;
  188.                    <{for}>, <{while}>, <next>, <rec>, <.rest.>,         ;
  189.                    <.toPrint.>, <(toFile)>                              ;
  190.                  ) )
  191. #command REPORT FORM <frm>                                              ;
  192.          [HEADING <heading>]                                            ;
  193.          [<plain: PLAIN>]                                               ;
  194.          [<noeject: NOEJECT>]                                           ;
  195.          [<summary: SUMMARY>]                                           ;
  196.          [<noconsole: NOCONSOLE>]                                       ;
  197.          [<print: TO PRINTER>]                                          ;
  198.          [TO FILE <(toFile)>]                                           ;
  199.          [FOR <for>]                                                    ;
  200.          [WHILE <while>]                                                ;
  201.          [NEXT <next>]                                                  ;
  202.          [RECORD <rec>]                                                 ;
  203.          [<rest:REST>]                                                  ;
  204.          [ALL]                                                          ;
  205.          ALIAS <a>                                                      ;
  206.       => <a> -> ( __ReportForm(                                                  ;
  207.                        <(frm)>, <.print.>, <(toFile)>, <.noconsole.>,   ;
  208.                        <{for}>, <{while}>, <next>, <rec>, <.rest.>,     ;
  209.                        <.plain.>, <heading>,                            ;
  210.                        <.noeject.>, <.summary.>                         ;
  211.                      ) )
  212. #command LABEL FORM <lbl>                                               ;
  213.          [<sample: SAMPLE>]                                             ;
  214.          [<noconsole: NOCONSOLE>]                                       ;
  215.          [<print: TO PRINTER>]                                          ;
  216.          [TO FILE <(toFile)>]                                           ;
  217.          [FOR <for>]                                                    ;
  218.          [WHILE <while>]                                                ;
  219.          [NEXT <next>]                                                  ;
  220.          [RECORD <rec>]                                                 ;
  221.          [<rest:REST>]                                                  ;
  222.          [ALL]                                                          ;
  223.          ALIAS <a>                                                      ;
  224.       => <a> -> ( __LabelForm(                                                   ;
  225.                       <(lbl)>, <.print.>, <(toFile)>, <.noconsole.>,    ;
  226.                       <{for}>, <{while}>, <next>, <rec>, <.rest.>,      ;
  227.                       <.sample.>                                        ;
  228.                     ) )
  229.  
  230. // NOTE:  CLOSE <alias> must precede the others
  231. #command CLOSE <alias>          => <alias>->( dbCloseArea() )
  232.  
  233. #command CLOSE                  => dbCloseArea()
  234. #command CLOSE DATABASES        => dbCloseAll()
  235. #command CLOSE ALTERNATE        => Set(_SET_ALTFILE, "")
  236. #command CLOSE FORMAT           => __SetFormat(NIL)
  237. #command CLOSE INDEXES          => dbClearIndex()
  238. #command CLOSE INDEXES ALIAS <a> => <a> -> (dbClearIndex())
  239. #command CLOSE ALIAS <a>        => <a> -> (dbCloseArea())
  240. #command CLOSE PROCEDURE        =>
  241.  
  242. #command CLOSE ALL                                                      ;
  243.                                                                         ;
  244.       => CLOSE DATABASES                                                ;
  245.        ; SELECT 1                                                       ;
  246.        ; CLOSE FORMAT
  247.  
  248. /* SETs with SAVE TO clauses */
  249.  
  250. #include "set.ch"
  251.  
  252. #command SET EXACT <x:ON,OFF,&>                     SAVE TO <y>         ;
  253.       => <y> := Set( _SET_EXACT, <(x)> )
  254.  
  255. #command SET EXACT (<x>)                            SAVE TO <y>         ;
  256.       => <y> := Set( _SET_EXACT, <x> )
  257.  
  258. #command SET FIXED <x:ON,OFF,&>                     SAVE TO <y>         ;
  259.       => <y> := Set( _SET_FIXED, <(x)> )
  260.  
  261. #command SET FIXED (<x>)                            SAVE TO <y>         ;
  262.       => <y> := Set( _SET_FIXED, <x> )
  263.  
  264. #command SET DECIMALS TO <x>                        SAVE TO <y>         ;
  265.       => <y> := Set( _SET_DECIMALS, <x> )
  266.  
  267. #command SET DECIMALS TO                            SAVE TO <y>         ;
  268.       => <y> := Set( _SET_DECIMALS, 0 )
  269.  
  270. #command SET PATH TO <*path*>                       SAVE TO <y>         ;
  271.       => <y> := Set( _SET_PATH, <(path)> )
  272.  
  273. #command SET PATH TO                                SAVE TO <y>         ;
  274.       => <y> := Set( _SET_PATH, "" )
  275.  
  276. #command SET DEFAULT TO <(path)>                    SAVE TO <y>         ;
  277.       => <y> := Set( _SET_DEFAULT, <(path)> )
  278.  
  279. #command SET DEFAULT TO                             SAVE TO <y>         ;
  280.       => <y> := Set( _SET_DEFAULT, "" )
  281.  
  282. #command SET CENTURY <x:ON,OFF,&>                   SAVE TO <y>         ;
  283.       => <y> := __SetCentury( <(x)> )
  284.  
  285. #command SET CENTURY (<x>)                          SAVE TO <y>         ;
  286.       => <y> := __SetCentury( <x> )
  287.  
  288. #command SET EPOCH TO <year>                        SAVE TO <y>         ;
  289.       => <y> := Set( _SET_EPOCH, <year> )
  290.  
  291. #command SET DATE FORMAT [TO] <c>                   SAVE TO <y>         ;
  292.       => <y> := Set( _SET_DATEFORMAT, <c> )
  293.  
  294. #define  _DFSETA(x, z)  <y> := Set(_SET_DATEFORMAT, iif(__SetCentury(), x, z))
  295.  
  296. #command SET DATE [TO] AMERICAN                     SAVE TO <y>         ;
  297.       => _DFSETA( "mm/dd/yyyy", "mm/dd/yy" )
  298.  
  299. #command SET DATE [TO] ANSI                         SAVE TO <y>         ;
  300.       => _DFSETA( "yyyy.mm.dd", "yy.mm.dd" )
  301.  
  302. #command SET DATE [TO] BRITISH                      SAVE TO <y>         ;
  303.       => _DFSETA( "dd/mm/yyyy", "dd/mm/yy" )
  304.  
  305. #command SET DATE [TO] FRENCH                       SAVE TO <y>         ;
  306.       => _DFSETA( "dd/mm/yyyy", "dd/mm/yy" )
  307.  
  308. #command SET DATE [TO] GERMAN                       SAVE TO <y>         ;
  309.       => _DFSETA( "dd.mm.yyyy", "dd.mm.yy" )
  310.  
  311. #command SET DATE [TO] ITALIAN                      SAVE TO <y>         ;
  312.       => _DFSETA( "dd-mm-yyyy", "dd-mm-yy" )
  313.  
  314. #command SET DATE [TO] JAPANESE                     SAVE TO <y>         ;
  315.       => _DFSETA( "yyyy/mm/dd", "yy/mm/dd" )
  316.  
  317. #command SET DATE [TO] USA                          SAVE TO <y>         ;
  318.       => _DFSETA( "mm-dd-yyyy", "mm-dd-yy" )
  319.  
  320. #command SET ALTERNATE <x:ON,OFF,&>                 SAVE TO <y>         ;
  321.       => <y> := Set( _SET_ALTERNATE, <(x)> )
  322.  
  323. #command SET ALTERNATE (<x>)                        SAVE TO <y>         ;
  324.       => <y> := Set( _SET_ALTERNATE, <x> )
  325.  
  326. #command SET ALTERNATE TO                           SAVE TO <y>         ;
  327.       => <y> := Set( _SET_ALTFILE, "" )
  328.  
  329. #command SET ALTERNATE TO <(file)> [<add: ADDITIVE>] SAVE TO <y>        ;
  330.       => <y> := Set( _SET_ALTFILE, <(file)>, <.add.> )
  331.  
  332. #command SET CONSOLE <x:ON,OFF,&>                   SAVE TO <y>         ;
  333.       => <y> := Set( _SET_CONSOLE, <(x)> )
  334.  
  335. #command SET CONSOLE (<x>)                          SAVE TO <y>         ;
  336.       => <y> := Set( _SET_CONSOLE, <x> )
  337.  
  338. #command SET MARGIN TO <x>                          SAVE TO <y>         ;
  339.       => <y> := Set( _SET_MARGIN, <x> )
  340.  
  341. #command SET MARGIN TO                              SAVE TO <y>         ;
  342.       => <y> := Set( _SET_MARGIN, 0 )
  343.  
  344. #command SET PRINTER <x:ON,OFF,&>                   SAVE TO <y>         ;
  345.       => <y> := Set( _SET_PRINTER, <(x)> )
  346.  
  347. #command SET PRINTER (<x>)                          SAVE TO <y>         ;
  348.       => <y> := Set( _SET_PRINTER, <x> )
  349.  
  350. #command SET PRINTER TO                             SAVE TO <y>         ;
  351.       => <y> := Set( _SET_PRINTFILE, "" )
  352.  
  353. #command SET PRINTER TO <(file)> [<add: ADDITIVE>]  SAVE TO <y>         ;
  354.       => <y> := Set( _SET_PRINTFILE, <(file)>, <.add.> )
  355.  
  356. #command SET DEVICE TO SCREEN                       SAVE TO <y>         ;
  357.       => <y> := Set( _SET_DEVICE, "SCREEN" )
  358.  
  359. #command SET DEVICE TO PRINTER                      SAVE TO <y>         ;
  360.       => <y> := Set( _SET_DEVICE, "PRINTER" )
  361.  
  362. #command SET COLOR TO [<*spec*>]                    SAVE TO <y>         ;
  363.       => <y> := SetColor( #<spec> )
  364.  
  365. #command SET COLOR TO ( <c> )                       SAVE TO <y>         ;
  366.       => <y> := SetColor( <c> )
  367.  
  368. #command SET COLOUR TO <*spec*>                     SAVE TO <y>         ;
  369.       => SET COLOR TO <spec> SAVE TO <y>
  370.  
  371. #command SET CURSOR <x:ON,OFF,&>                    SAVE TO <y>         ;
  372.       => <y> := SetCursor( if(Upper(<(x)>) == "ON", 1, 0) )
  373.  
  374. #command SET CURSOR (<x>)                           SAVE TO <y>         ;
  375.       => <y> := SetCursor( if(<x>, 1, 0) )
  376.  
  377. #command SET BELL <x:ON,OFF,&>                      SAVE TO <y>         ;
  378.       => <y> := Set( _SET_BELL, <(x)> )
  379.  
  380. #command SET BELL (<x>)                             SAVE TO <y>         ;
  381.       => <y> := Set( _SET_BELL, <x> )
  382.  
  383. #command SET CONFIRM <x:ON,OFF,&>                   SAVE TO <y>         ;
  384.       => <y> := Set( _SET_CONFIRM, <(x)> )
  385.  
  386. #command SET CONFIRM (<x>)                          SAVE TO <y>         ;
  387.       => <y> := Set( _SET_CONFIRM, <x> )
  388.  
  389. #command SET ESCAPE <x:ON,OFF,&>                    SAVE TO <y>         ;
  390.       => <y> := Set( _SET_ESCAPE, <(x)> )
  391.  
  392. #command SET ESCAPE (<x>)                           SAVE TO <y>         ;
  393.       => <y> := Set( _SET_ESCAPE, <x> )
  394.  
  395. #command SET INTENSITY <x:ON,OFF,&>                 SAVE TO <y>         ;
  396.       => <y> := Set( _SET_INTENSITY, <(x)> )
  397.  
  398. #command SET INTENSITY (<x>)                        SAVE TO <y>         ;
  399.       => <y> := Set( _SET_INTENSITY, <x> )
  400.  
  401. #command SET SCOREBOARD <x:ON,OFF,&>                SAVE TO <y>         ;
  402.       => <y> := Set( _SET_SCOREBOARD, <(x)> )
  403.  
  404. #command SET SCOREBOARD (<x>)                       SAVE TO <y>         ;
  405.       => <y> := Set( _SET_SCOREBOARD, <x> )
  406.  
  407. #command SET DELIMITERS <x:ON,OFF,&>                SAVE TO <y>         ;
  408.       => <y> := Set( _SET_DELIMITERS, <(x)> )
  409.  
  410. #command SET DELIMITERS (<x>)                       SAVE TO <y>         ;
  411.       => <y> := Set( _SET_DELIMITERS, <x> )
  412.  
  413. #command SET DELIMITERS TO <c>                      SAVE TO <y>         ;
  414.       => <y> := Set( _SET_DELIMCHARS, <c> )
  415.  
  416. #command SET DELIMITERS TO DEFAULT                  SAVE TO <y>         ;
  417.       => <y> := Set( _SET_DELIMCHARS, "::" )
  418.  
  419. #command SET DELIMITERS TO                          SAVE TO <y>         ;
  420.       => <y> := Set( _SET_DELIMCHARS, "::" )
  421.  
  422. #command SET WRAP <x:ON,OFF,&>                      SAVE TO <y>         ;
  423.       => <y> := Set( _SET_WRAP, <(x)> )
  424.  
  425. #command SET WRAP (<x>)                             SAVE TO <y>         ;
  426.       => <y> := Set( _SET_WRAP, <x> )
  427.  
  428. #command SET MESSAGE TO <n> [<cent: CENTER, CENTRE>] SAVE TO <y>        ;
  429.       => <y> := {Set( _SET_MESSAGE, <n> ), Set( _SET_MCENTER, <.cent.> ) }
  430.  
  431. #command SET MESSAGE TO                             SAVE TO <y>         ;
  432.       => <y> := {Set( _SET_MESSAGE, 0 ), Set( _SET_MCENTER, .f. ) }
  433.  
  434. #command SET TYPEAHEAD TO <n>                       SAVE TO <y>         ;
  435.       => <y> := Set( _SET_TYPEAHEAD, <n> )
  436.  
  437. #command SET KEY <n> TO <proc>                      SAVE TO <y>         ;
  438.       => <y> := SetKey( <n>, {|p, l, v| <proc>(p, l, v)} )
  439.  
  440. #command SET KEY <n> TO <proc> ( [<list,...>] )     SAVE TO <y>         ;
  441.       => SET KEY <n> TO <proc> SAVE TO <y>
  442.  
  443. #command SET KEY <n> [TO]                           SAVE TO <y>         ;
  444.       => <y> := SetKey( <n>, NIL )
  445.  
  446. #command SET FUNCTION <n> [TO] [<c>]                SAVE TO <y>         ;
  447.       => <y> := __SetFunction( <n>, <c> )
  448.  
  449. #command SET EXCLUSIVE <x:ON,OFF,&>                 SAVE TO <y>         ;
  450.       =>  <y> := Set( _SET_EXCLUSIVE, <(x)> )
  451.  
  452. #command SET EXCLUSIVE (<x>)                        SAVE TO <y>         ;
  453.       =>  <y> := Set( _SET_EXCLUSIVE, <x> )
  454.  
  455. #command SET SOFTSEEK <x:ON,OFF,&>                  SAVE TO <y>         ;
  456.       =>  <y> := Set( _SET_SOFTSEEK, <(x)> )
  457.  
  458. #command SET SOFTSEEK (<x>)                         SAVE TO <y>         ;
  459.       =>  <y> := Set( _SET_SOFTSEEK, <x> )
  460.  
  461. #command SET UNIQUE <x:ON,OFF,&>                    SAVE TO <y>         ;
  462.       =>  <y> := Set( _SET_UNIQUE, <(x)> )
  463.  
  464. #command SET UNIQUE (<x>)                           SAVE TO <y>         ;
  465.       =>  <y> := Set( _SET_UNIQUE, <x> )
  466.  
  467. #command SET DELETED <x:ON,OFF,&>                   SAVE TO <y>         ;
  468.       =>  <y> := Set( _SET_DELETED, <(x)> )
  469.  
  470. #command SET DELETED (<x>)                          SAVE TO <y>         ;
  471.       =>  <y> := Set( _SET_DELETED, <x> )
  472.  
  473. #command SET ORDER TO <n>                           SAVE TO <y>         ;
  474.       => <y> := dbSetOrder( <n> )
  475.  
  476. #command SET ORDER TO                               SAVE TO <y>         ;
  477.       => <y> := dbSetOrder(0)
  478.  
  479.  
  480.