//////////////////////////////////////////////////////////////////////
//
//  STD.CH // (ak)
//
//  Copyright:
//      Alaska Software GmbH, (c) 1998-2002. Alle Rechte vorbehalten.
//
//  Inhalt:
//      Direktiven fr die Xbase++ - Standard Sprachdefinitionen
//
//  Bemerkungen:
//      Funktionen, die mit einem Unterstrich beginnen,
//      sind reserviert. Sie k”nnen versionsabh„ngig sein
//      und sollten nicht direkt aufgerufen werden!
//
//////////////////////////////////////////////////////////////////////


// Std.ch ist noch nicht eingebunden
#ifndef _STD_CH
// Mehrfaches #include verhindern
#define _STD_CH

/*******************************************************************************
 * Allgemeine Konstanten fuer den Sprachumfang
 *******************************************************************************/
#define SCOPE_TOP    0x01
#define SCOPE_BOTTOM 0x02
#define SCOPE_BOTH   0xFF

#ifdef __XPP__
*******************************************************************************
* Weitere #include Dateien einbinden, die zum Sprachumfang geh”ren
*******************************************************************************

// Direktiven fr SET und SET() einbinden
#ifndef _SET_CH
   #include "Set.ch"
#endif

// Direktiven fr das Get-System einbinden
#ifndef _GET_CH
   #include "Get.ch"
#endif

// Direktiven fr das Men-System einbinden
#ifndef _PROMPT_CH
   #include "Prompt.ch"
#endif

// Direktiven fr SAVE und RESTORE von
#ifndef _MEMVAR_CH
// PRIVATE und PUBLIC Variablen einbinden
   #include "Memvar.ch"
#endif

// Definitionen fr SET LEXICAL TO
#ifndef _COLLAT_CH
   #include "collat.ch"
#endif

*******************************************************************************
* Anweisungen fr Kontrollstrukturen
*******************************************************************************

#command  DO WHILE <cond>    =>  while <cond>

#command  END <what>         =>  end
#command  END SEQUENCE       =>  end
#command  ENDSEQUENCE        =>  end
#command  BREAK  [ <x> ]     =>  _break([<x>])
#command  ENDDO   <*what*>   =>  enddo
#command  ENDIF   <*what*>   =>  endif
#command  ENDCASE <*what*>   =>  endcase
#command  ENDFOR [<*what*>]  =>  next

#command  NEXT <x> [TO <y>] [STEP <z>]  =>  next

*******************************************************************************
* SET Befehle fr Vergleiche, Datums- und Zahlenformat
*******************************************************************************
#command  SET CHARSET TO ANSI       =>  Set( _SET_CHARSET, CHARSET_ANSI )
#command  SET CHARSET TO OEM        =>  Set( _SET_CHARSET, CHARSET_OEM )

#command  SET EXACT <x:ON,OFF,&>    =>  Set( _SET_EXACT, <(x)> )
#command  SET EXACT (<x>)           =>  Set( _SET_EXACT, <x> )

#command  SET LEXICAL <x:ON,OFF,&>  =>  Set( _SET_LEXICAL, <(x)> )
#command  SET LEXICAL (<x>)         =>  Set( _SET_LEXICAL, <x> )

#command  SET COLLATION TO          =>  Set( _SET_COLLATION, COLLAT_ASCII )
#command  SET COLLATION TO <x:AMERICAN,BRITISH,DANISH,DUTCH,FINNISH,FRENCH,GERMAN,;;
                              GREEK437,GREEK851,ICELANDIC850,ICELANDIC861,ITALIAN,;;
                              NORWEGIAN,PORTUGUESE,SPANISH,SWEDISH,SYSTEM,ASCII> => ;
                                        Set( _SET_COLLATION, COLLAT_<x> )
#command  SET COLLATION TO DIN      =>  Set( _SET_COLLATION, COLLAT_GERMAN );;
          SetLexRule( {{"„","ae"},{"”","oe"},{"","ue"},;
                       {"Ž","AE"},{"™","OE"},{"š","UE"},;
                       {"á","ss"}})

#command  SET FIXED <x:ON,OFF,&>    =>  Set( _SET_FIXED, <(x)> )
#command  SET FIXED (<x>)           =>  Set( _SET_FIXED, <x> )

#command  SET DECIMALS TO <x>       =>  Set( _SET_DECIMALS, <x> )
#command  SET DECIMALS TO           =>  Set( _SET_DECIMALS, 0 )

#command  SET DATE FORMAT [TO] <c>  =>  Set( _SET_DATEFORMAT, <c> )

#define  _DFSET(x, y)  Set( _SET_DATEFORMAT, iif(Set( _SET_CENTURY ), x, y) )

#command  SET DATE [TO] SYSTEM      =>  Set( _SET_DATEFORMAT, "" )
#command  SET DATE [TO] AMERICAN    =>  _DFSET( "mm/dd/yyyy", "mm/dd/yy" )
#command  SET DATE [TO] ANSI        =>  _DFSET( "yyyy.mm.dd", "yy.mm.dd" )
#command  SET DATE [TO] BRITISH     =>  _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
#command  SET DATE [TO] FRENCH      =>  _DFSET( "dd/mm/yyyy", "dd/mm/yy" )
#command  SET DATE [TO] GERMAN      =>  _DFSET( "dd.mm.yyyy", "dd.mm.yy" )
#command  SET DATE [TO] ITALIAN     =>  _DFSET( "dd-mm-yyyy", "dd-mm-yy" )
#command  SET DATE [TO] JAPANESE    =>  _DFSET( "yyyy/mm/dd", "yy/mm/dd" )
#command  SET DATE [TO] USA         =>  _DFSET( "mm-dd-yyyy", "mm-dd-yy" )

#command  SET TIME TO <(x)>         =>  Set( _SET_TIME, <(x)> )
#command  SET TIME TO SYSTEM        =>  Set( _SET_TIME, "" )
#command  SET CENTURY <x:ON,OFF,&>  =>  Set( _SET_CENTURY, <(x)> )
#command  SET CENTURY (<x>)         =>  Set( _SET_CENTURY,  <x> )
#command  SET EPOCH TO <year>       =>  Set( _SET_EPOCH, <year> )

*******************************************************************************
* SET Befehle fr Verzeichnisse
*******************************************************************************

#command  SET PATH TO <(path)>      =>  Set( _SET_PATH, <(path)> )
#command  SET PATH TO               =>  Set( _SET_PATH, "" )

#command  SET DEFAULT TO <(path)>   =>  Set( _SET_DEFAULT, <(path)> )
#command  SET DEFAULT TO            =>  Set( _SET_DEFAULT, "" )

*******************************************************************************
* SET Befehle fr die Database-Engine
*******************************************************************************

#command  SET EXCLUSIVE <x:ON,OFF,&> =>  Set( _SET_EXCLUSIVE, <(x)> )
#command  SET EXCLUSIVE (<x>)        =>  Set( _SET_EXCLUSIVE, <x> )

#command  SET SOFTSEEK <x:ON,OFF,&>  =>  Set( _SET_SOFTSEEK, <(x)> )
#command  SET SOFTSEEK (<x>)         =>  Set( _SET_SOFTSEEK, <x> )

#command  SET UNIQUE <x:ON,OFF,&>    =>  Set( _SET_UNIQUE, <(x)> )
#command  SET UNIQUE (<x>)           =>  Set( _SET_UNIQUE, <x> )

#command  SET DELETED <x:ON,OFF,&>   =>  Set( _SET_DELETED, <(x)> )
#command  SET DELETED (<x>)          =>  Set( _SET_DELETED, <x> )

#command  SET OPTIMIZE <x:ON,OFF,&>   =>  Set( _SET_OPTIMIZE , <(x)> )
#command  SET OPTIMIZE (<x>)          =>  Set( _SET_OPTIMIZE, <x> )

#command  SET RUSHMORE <x:ON,OFF,&>   =>  Set( _SET_RUSHMORE , <(x)> )
#command  SET RUSHMORE (<x>)          =>  Set( _SET_RUSHMORE, <x> )

#command  SET SMARTFILTER <x:ON,OFF,&>   =>  Set( _SET_SMARTFILTER , <(x)> )
#command  SET SMARTFILTER (<x>)          =>  Set( _SET_SMARTFILTER , <x> )

*******************************************************************************
* SET Befehle fr die Tastatur
*******************************************************************************

#command  SET TYPEAHEAD TO <n>       =>  Set( _SET_TYPEAHEAD, <n> )

*******************************************************************************
* SET Befehle fr die Bildschirmanzeige
*******************************************************************************

#command  SET COLOR TO [<*spec*>]    =>  SetColor( #<spec> )
#command  SET COLOR TO ( <c> )       =>  SetColor( <c> )
#command  SET COLOUR TO [<*spec*>]   =>  SET COLOR TO [<spec>]

#command  SET CURSOR <x:ON,OFF,&> ;
      =>  SetCursor( iif(upper(<(x)>)=="ON", 1, 0) )

#command  SET CURSOR (<x>)           =>  SetCursor( iif(<x>, 1, 0) )

#command  SET CONSOLE <x:ON,OFF,&>   =>  Set( _SET_CONSOLE, <(x)> )
#command  SET CONSOLE (<x>)          =>  Set( _SET_CONSOLE, <x> )

*******************************************************************************
* SET Befehle fr die Druckausgabe
*******************************************************************************

#command  SET ALTERNATE <x:ON,OFF,&> =>  Set( _SET_ALTERNATE, <(x)> )
#command  SET ALTERNATE (<x>)        =>  Set( _SET_ALTERNATE, <x> )
#command  SET ALTERNATE TO           =>  Set( _SET_ALTFILE, "" )

#command  SET ALTERNATE TO <(file)> [<add: ADDITIVE>] ;
      =>  Set( _SET_ALTFILE, <(file)>, <.add.> )

// (Original->) #command  SET DEVICE TO SCREEN       =>  Set( _SET_DEVICE, "SCREEN" )
// (Original->) #command  SET DEVICE TO PRINTER      =>  Set( _SET_DEVICE, "PRINTER" )
// SET DEVICE TO steht am Ende dieser Datei (AK)
// (Original->) #command  SET PRINTER <x:ON,OFF,&>   =>  Set( _SET_PRINTER, <(x)> )
// SET PRINTER ON steht am Ende dieser Datei (AK)
#command  SET PRINTER <x:OFF,&>   =>  Set( _SET_PRINTER, <(x)> )
#command  SET PRINTER (<x>)          =>  Set( _SET_PRINTER, <x> )
#command  SET PRINTER TO             =>  Set( _SET_PRINTFILE, "" )

#command  SET PRINTER TO <(file)> [<add: ADDITIVE>] ;
      =>  Set( _SET_PRINTFILE, <(file)>, <.add.> )

#command  SET MARGIN TO <x>          =>  Set( _SET_MARGIN, <x> )
#command  SET MARGIN TO              =>  Set( _SET_MARGIN, 0 )

*******************************************************************************
* SET Befehle fr das Get-System
*******************************************************************************

#command  SET BELL <x:ON,OFF,&>       =>  Set( _SET_BELL, <(x)> )
#command  SET BELL (<x>)              =>  Set( _SET_BELL, <x> )

#command  SET CONFIRM <x:ON,OFF,&>    =>  Set( _SET_CONFIRM, <(x)> )
#command  SET CONFIRM (<x>)           =>  Set( _SET_CONFIRM, <x> )

#command  SET ESCAPE <x:ON,OFF,&>     =>  Set( _SET_ESCAPE, <(x)> )
#command  SET ESCAPE (<x>)            =>  Set( _SET_ESCAPE, <x> )

#command  SET INTENSITY <x:ON,OFF,&>  =>  Set( _SET_INTENSITY, <(x)> )
#command  SET INTENSITY (<x>)         =>  Set( _SET_INTENSITY, <x> )

#command  SET SCOREBOARD <x:ON,OFF,&> =>  Set( _SET_SCOREBOARD, <(x)> )
#command  SET SCOREBOARD (<x>)        =>  Set( _SET_SCOREBOARD, <x> )

#command  SET DELIMITERS <x:ON,OFF,&> =>  Set( _SET_DELIMITERS, <(x)> )
#command  SET DELIMITERS (<x>)        =>  Set( _SET_DELIMITERS, <x> )

#command  SET DELIMITERS TO <c>       =>  Set( _SET_DELIMCHARS, <c> )
#command  SET DELIMITERS TO DEFAULT   =>  Set( _SET_DELIMCHARS, "::" )
#command  SET DELIMITERS TO           =>  Set( _SET_DELIMCHARS, "::" )

*******************************************************************************
* Befehle fr die Ausgabe am Bildschirm oder Drucker
*******************************************************************************

#command  ?  [<list,...>]  =>  QOUT( <list> )
#command  ?? [<list,...>]  =>  QQOUT( <list> )

//#command  EJECT            => _Eject()
// ak:
#command  EJECT            => NeueSeite()

*******************************************************************************
* Bildschirm l”schen
*******************************************************************************

#command  CLS ;
      =>  Scroll() ; SetPos(0,0)

#command  CLEAR SCREEN ;
      =>  Scroll() ; SetPos(0,0)

#command  @ <nT>, <nL> ;
      =>  Scroll(<nT>, <nL>, <nT>) ; SetPos(<nT>, <nL>)

#command  @ <nT>, <nL> CLEAR ;
      =>  Scroll(<nT>, <nL>) ; SetPos(<nT>, <nL>)

#command  @ <nT>, <nL> CLEAR TO <nB>, <nR> ;
      =>  Scroll(<nT>, <nL>, <nB>, <nR>) ; SetPos(<nT>, <nL>)

*******************************************************************************
* Box am Bildschirm ausgeben
*******************************************************************************

#command  @ <nT>, <nL>, <nB>, <nR> BOX <cBox> [COLOR <Color>] ;
      =>  DispBox(<nT>, <nL>, <nB>, <nR>, <cBox> [,<Color>])

#command  @ <nT>, <nL> TO <nB>, <nR> [DOUBLE] [COLOR <Color>] ;
      =>  DispBox(<nT>, <nL>, <nB>, <nR>, 2 [,<Color>])

#command  @ <nT>, <nL> TO <nB>, <nR> [COLOR <Color>] ;
      =>  DispBox(<nT>, <nL>, <nB>, <nR>, 1 [,<Color>])

*******************************************************************************
* Befehl: @...SAY
*******************************************************************************

#command  @ <nRow>, <nCol> SAY <say> [PICTURE <pic>] [COLOR <Color>] ;
      =>  DevPos(<nRow>, <nCol>) ; DevOutPict(<say>, <pic> [,<Color>])

#command  @ <nRow>, <nCol> SAY <say> [COLOR <Color>] ;
      =>  Sage( <nRow>, <nCol>, <say> )       // nur mit Printer_anG() in Sonnex.prg
//      =>  DevPos(<nRow>, <nCol>) ; DevOut(<say> [,<Color>])

*******************************************************************************
* Befehl: @...COLOUR
*******************************************************************************

#command  @ [<options,...>] COLOUR [<moreOptions,...>] ;
      =>  @ [<options>] COLOR [<moreOptions>]

*******************************************************************************
* Befehle: SAVE / RESTORE SCREEN
*******************************************************************************

#command  SAVE SCREEN     =>  _XSaveScreen()
#command  RESTORE SCREEN  =>  _XRestScreen()

#command  SAVE SCREEN TO <screen> ;
      =>  <screen> := SaveScreen(0, 0, Maxrow(), Maxcol())

#command  RESTORE SCREEN FROM <screen> ;
      =>  RestScreen(0, 0, Maxrow(), Maxcol(), <screen>)

*******************************************************************************
* Befehle fr Tastatureingaben
*******************************************************************************

#command  WAIT <cInput> ;
      =>  _Wait(<cInput>)

#command  WAIT [<cInput>] TO <var> ;
      =>  <var> := _Wait(<cInput>)

#command  WAIT ;
      =>  _Wait("Press any key to continue...")

#command  ACCEPT [<cInput>] TO <var> ;
      =>  <var> := _Accept(<(cInput)>)

#command  ACCEPT TO <var> ;
      =>  <var> := _Accept("")

#command  INPUT [<cInput>] TO <var> ;
      =>  if ( .not. Empty(_Accept(<cInput>)) ) ;;
             <var> := &(_AcceptStr()) ;;
          endif

#command  KEYBOARD <cInput> ;
      =>  _Keyboard(<cInput>)

#command  CLEAR TYPEAHEAD ;
      =>  _Keyboard()

#command  SET KEY <nInkey> TO <proc> ;
      =>  SetKey(<nInkey>, {|pn,pl,vn,obj| <proc>(pn,pl,vn,obj)})

#command  SET KEY <nInkey> TO <proc> ( [<list,...>] ) ;
      =>  SET KEY <nInkey> TO <proc>

#command  SET KEY <nInkey> TO <proc:&> ;
      =>  if ( Empty(<(proc)>) ) ;;
             SetKey(<nInkey>, NIL) ;;
          else ;;
             SetKey(<nInkey>, {|pn,pl,vn,obj| <proc>(pn,pl,vn,obj)}) ;;
          endif

#command  SET KEY <nInkey> [TO] ;
      =>  SetKey(<nInkey>, NIL)

*******************************************************************************
* Datei-Befehle
*******************************************************************************

#command  ERASE <(file)> ;
      =>  fErase( <(file)> )

#command  DELETE FILE <(file)> ;
      =>  fErase( <(file)> )

#command  RENAME <(oldFile)> TO <(newFile)> ;
      =>  fRename( <(oldFile)>, <(newFile)> )

#command  COPY FILE <(source)> TO <(target)> ;
      =>  _copyFile(<(source)>, <(target)>)

#command  TYPE <(file)> [<prn: TO PRINTER>] [TO FILE <(target)>] ;
      =>  _typeFile(<(file)>, <.prn.>) ;
          [; COPY FILE <(file)> TO <(target)> ]

#command  TYPE <(file)> [<prn: TO PRINTER>];
      =>  _typeFile(<(file)>, <.prn.>)

*******************************************************************************
* Befehle fr die Ausfhrung von Programmen
*******************************************************************************

#command  CANCEL        =>  _quit()
#command  QUIT [<exp>]  =>  _quit(<exp>)

#command  RUN <*cmd*>   =>  runShell( "/C " + #<cmd> )
#command  RUN ( <c> )   =>  runShell( "/C " + <c> )
#command  ! <*cmd*>     =>  RUN <cmd>
#command  RUN = <exp>   =>  (run := <exp>)
#command  RUN := <exp>  =>  (run := <exp>)

*******************************************************************************
* Befehle fr die Database-Engine
*******************************************************************************

#command  SELECT <area> ;
      =>  dbSelectArea( <(area)> )

#command  SELECT <func>([<para,...>]) ;
      =>  dbSelectArea( <func>(<para>) )

#command  USE ;
      =>  dbCloseArea()

#command     USE <(dbFile)> ;
            [VIA <dbe>] ;
          [ALIAS <alias>] ;
          [<new: NEW>] ;
          [<exc: EXCLUSIVE>] ;
          [<sha: SHARED>] ;
          [<reo: READONLY>] ;
          [INDEX <(index1)> [,;
                 <(indexN)>]] ;
      =>  dbUseArea( <.new.>, <(dbe)>, <(dbFile)>, <(alias)>, ;
                    iif(<.sha.> .or. <.exc.>, !<.exc.>, NIL), <.reo.>) ;
          [; dbSetIndex( <(index1)> )] [; dbSetIndex( <(indexN)> )]


#command  GO <record>        =>  dbGoto(<record>)
#command  GO TOP             =>  dbGoTop()
#command  GO BOTTOM          =>  dbGoBottom()
#command  GOTO <record>      =>  dbGoto(<record>)
#command  GOTO TOP           =>  dbGoTop()
#command  GOTO BOTTOM        =>  dbGoBottom()

#command  SKIP               =>  dbSkip(1)
#command  SKIP <n>           =>  dbSkip(<n>)
#command  SKIP ALIAS <a>     =>  <a>->(dbSkip(1))
#command  SKIP <n> ALIAS <a> =>  <a>->(dbSkip(<n>))

#command  APPEND BLANK       =>  dbAppend()
#command  ZAP                =>  dbZap()
#command  PACK               =>  dbPack()
#command  COMMIT             =>  dbCommitAll()
#command  UNLOCK             =>  dbUnlock()
#command  UNLOCK ALL         =>  dbUnlockAll()


#command  FIND <*text*>      =>  dbSeek(<(text)>)
#command  FIND := <exp>      =>  (find := <exp>)
#command  FIND = <exp>       =>  (find := <exp>)


#command  SEEK <exp> [<ss: SOFTSEEK>] ;
      =>  dbSeek(<exp>, iif(<.ss.>,.T., NIL))


#command  LOCATE ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rcd>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      =>  dbLocate( __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.> )

#command  CONTINUE ;
      =>  dbContinue()


#command  SET RELATION TO ;
      =>  dbClearRelation()

#command  SET RELATION [<add:ADDITIVE>]  [;
           TO  <key1> INTO <(alias1)> [<sel1:SELECTIVE>] [,;
          [TO] <keyN> INTO <(aliasN)> [<selN:SELECTIVE>]]];
      =>  if (.not. <.add.>) ;;
             dbClearRelation() ;;
          endif ;;
          dbSetRelation(<(alias1)>, __EBCB(<key1>), <"key1">, <.sel1.>) [;;
          dbSetRelation(<(aliasN)>, __EBCB(<keyN>), <"keyN">, <.selN.>) ]


#command  SET FILTER TO ;
      =>  dbClearFilter(NIL)

#command  SET FILTER TO <exp> ;
      =>  dbSetFilter(__EBCB(<exp>), <"exp">)

#command  SET FILTER TO <x:&> ;
      =>  if ( Empty(<(x)>) ) ;;
             dbClearFilter() ;;
          else ;;
            dbSetFilter(__EBCB(<x>), <(x)>) ;;
          endif

#xcommand SET SCOPE TO                                                   ;
       => DbClearScope(SCOPE_BOTH)
        
#xcommand SET SCOPE TO <xValue>                                          ;
       => DbSetScope(SCOPE_BOTH,<xValue>)

#xcommand SET SCOPE TO <xVal1>, <xVal2>                                  ;
       => DbSetScope(SCOPE_TOP   , <xVal1>)                              ;
       ; DbSetScope(SCOPE_BOTTOM, <xVal2>)

#xcommand SET SCOPETOP TO                                               ;
       => DbClearScope(SCOPE_TOP)

#xcommand SET SCOPETOP TO <xValue>                                      ;
       => DbSetScope(SCOPE_TOP, <xValue>)

#xcommand SET SCOPEBOTTOM TO                                            ;
       => DbClearScope(SCOPE_BOTTOM)

#xcommand SET SCOPEBOTTOM TO <xValue>                                   ;
       => DbSetScope(SCOPE_BOTTOM, <xValue>)

#command  REPLACE [<fld1> WITH <val1> [,;
                   <fldN> WITH <valN> ] ] ;
          [   FOR <for>] ;
          [ WHILE <whl>] ;
          [  NEXT <nxt>] ;
          [RECORD <rcd>] ;
          [ <rst: REST>] ;
          [ ALL ] ;
      =>  dbEval( {|| FIELD-><fld1> := <val1>[, ;
                      FIELD-><fldN> := <valN>]  }, ;
                 __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>)

#command  REPLACE <fld1> WITH <val1> [, <fldN> WITH <valN> ]                     ;
      =>  FIELD-><fld1> := <val1> [; FIELD-><fldN> := <valN>]


// siehe hinten:
//#command   DELETE ;
//          [   FOR <for>] ;
//          [ WHILE <whl>] ;
//          [  NEXT <nxt>] ;
//          [RECORD <rcd>] ;
//          [ <rst: REST>] ;
//          [ ALL ] ;
//      =>  dbEval( {|| dbDelete()}, ;
//                 __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>)

// siehe hinten:
//#command  DELETE ;
//      =>  dbDelete()


// siehe hinten:
//#command   RECALL ;
//          [   FOR <for>] ;
//          [ WHILE <whl>] ;
//          [  NEXT <nxt>] ;
//          [RECORD <rcd>] ;
//          [ <rst: REST>] ;
//          [ ALL ] ;
//      =>  dbEval( {|| dbRecall()}, ;
//                 __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>)

// siehe hinten:
//#command  RECALL ;
//      =>  dbRecall()


#command  CREATE <(dbFile1)> ;
          [ FROM <(dbFile2)>] ;
          [  VIA <dbe>] ;
          [ALIAS <alias>] ;
          [<new: NEW>] ;
      =>  dbCreateFrom(<(dbFile1)>, <(dbe)>, <(dbFile2)>, <(dbe)>, <.new.>, <(alias)>)

#command  CREATE <(dbFile)> ;
      =>  dbCreateExtStruct( <(dbFile)> )

#command  COPY [STRUCTURE] [EXTENDED] [TO <(dbFile)>] ;
      =>  dbCopyExtStruct( <(dbFile)> )


#command  COPY [STRUCTURE] [TO <(dbFile)>] [FIELDS <flds,...>] ;
      =>  dbCopyStruct( <(dbFile)>, {<(flds)>} )


#command    COPY [TO <(file)>] ;
                 [ DELIMITED [ WITH <*lim*>] ] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rcd>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      => _dbExport( <(file)>, { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>, "DELDBE", <(lim)> )


#command    COPY [TO <(file)>] ;
                 [SDF ] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rcd>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      => _dbExport( <(file)>, { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>, "SDFDBE" )


#command    COPY [TO <(file)>] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rcd>] ;
         [ <rst: REST>] ;
         [   VIA <dbe>] ;
         [ ALL ] ;
      => _dbExport( <(file)>, { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>, <dbe> )


#command  APPEND [FROM <(file)>] ;
                 [DELIMITED [WITH <*lim*> ]] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rcd>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      => _dbImport( <(file)>, { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>, "DELDBE", <(lim)> )


#command  APPEND [FROM <(file)>] ;
                 [SDF] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rcd>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      => _dbImport( <(file)>, { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>, "SDFDBE" )


#command  APPEND [FROM <(file)>] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [   VIA <dbe>] ;
         [ ALL ] ;
      => _dbImport( <(file)>, { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.>, <(dbe)>)


#command    SORT [TO <(file)>] ;
                 [ON <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      =>  dbSort( <(file)>, { <(flds)> }, ;
                  __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.>)


#command  TOTAL [TO <(file)>] ;
                [ON <key>] ;
         [FIELDS <flds,...>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      =>  dbTotal( <(file)>, __EBCB(<key>), { <(flds)> }, ;
                    __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.> )


#command  UPDATE [FROM <(alias)>] [ON <key>] ;
          [REPLACE <fld1> WITH <val1> [,;
                   <fldN> WITH <valN> ] ] ;
          [<rnd: RANDOM>] ;
      =>  dbUpdate( <(alias)>, ;
                    {|| FIELD-><fld1> := <val1> [, ;
                        FIELD-><fldN> := <valN> ] }, ;
                      __EBCB(<key>), <.rnd.> )


#command JOIN [WITH <(alias)>] ;
                [TO <file>] ;
            [FIELDS <flds,...>] ;
               [FOR <for>] ;
      =>  dbJoin( <(alias)>, <(file)>, { <(flds)> }, __EBCB(<for>) )


#command   COUNT [TO <var>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      =>  <var> := 0 ;;
          dbEval( {|| <var> ++ }, ;
                  __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.> )


#command     SUM [<var1> [, <varN>] ;
              TO  <val1> [, <valN>] ] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      =>  <val1> := [ <valN> := ] 0 ;;
          dbEval( {|| <val1> += <var1> [, ;
                      <valN> += <varN> ] }, ;
                  __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.> )


#command AVERAGE [<var1> [, <varN>] ;
              TO  <val1> [, <valN>] ] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      => M->_Avg_ := <val1> := [ <valN> := ] 0 ;;
         dbEval( {|| M->_Avg_ ++  , ;
                 <val1> += <var1>[, ;
                 <valN> += <varN>]  }, ;
                 __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.> ) ;;
         <val1> /= M->_Avg_ [;;
         <valN> /= M->_Avg_ ]


#command    LIST [<flds,...>] ;
                 [<off: OFF>] ;
                 [<prn: TO PRINTER>] ;
                 [TO FILE <(file)>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ ALL ] ;
      =>  dbList( { <{flds}> }, <.off.>, .T., ;
                  __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.>, ;
                  <.prn.>, <(file)> )


#command DISPLAY [<flds,...>] ;
                 [<off: OFF>] ;
                 [<prn: TO PRINTER>] ;
                 [TO FILE <(file)>] ;
         [   FOR <for>] ;
         [ WHILE <whl>] ;
         [  NEXT <nxt>] ;
         [RECORD <rec>] ;
         [ <rst: REST>] ;
         [ <all: ALL> ] ;
      =>   dbList( { <{flds}> }, <.off.>, <.all.>, ;
                   __EBCB(<for>), __EBCB(<whl>), <nxt>, <rec>, <.rst.>, ;
                   <.prn.>, <(file)> )


#command  CLOSE <alias>    =>  <alias>->( dbCloseArea() )
#command  CLOSE            =>  dbCloseArea()
#command  CLOSE DATABASES  =>  dbCloseAll()
#command  CLOSE ALTERNATE  =>  Set(_SET_ALTFILE, "")
#command  CLOSE INDEXES    =>  dbClearIndex()
#command  CLOSE ALL        =>  dbCloseAll() ; dbSelectArea(1)

#command  CLEAR ;
      =>  CLEAR SCREEN ;;
          CLEAR GETS

#command  CLEAR ALL ;
      =>  CLOSE DATABASES ;;
          CLEAR MEMORY ;;
          CLEAR GETS ;;
          SET ALTERNATE OFF ;;
          SET ALTERNATE TO

*******************************************************************************
* Befehle fr die Database-Engine: Index-Dateien
*******************************************************************************

#command  INDEX ON <key> [TAG <(cOrdName)> ] TO <(cOrdBagName)> ;
           [   FOR <for>] ;
           [ WHILE <whl>] ;
           [  NEXT <nxt>] ;
           [RECORD <rec>] ;
           [  EVAL <eval>];
           [ EVERY <evry>];
           [ <rst: REST>] ;
           [ <all: ALL> ] ;
           [<uniq: UNIQUE>] ;
           [ <asc: ASCENDING>] ;
           [<desc: DESCENDING>] ;
           [ <add: ADDITIVE>] ;
      =>  ordCondSet( <"for">, __EBCB(<for>) ,[<.all.>], ;
                      __EBCB(<whl>), __EBCB(<eval>), <evry> , ;
                      RECNO(), <nxt>, <rec>, ;
                      [<.rst.>], [<.desc.>] ) ;;
          ordCreate( <(cOrdBagName)>, <(cOrdName)>, ;
                     <"key">, __EBCB(<key>), [<.uniq.>], <.add.> )

#command INDEX ON <key> TAG <(cOrdName)> [TO <(cOrdBagName)>] ;
           [   FOR <for>] ;
           [ WHILE <whl>] ;
           [  NEXT <nxt>] ;
           [RECORD <rec>] ;
           [  EVAL <eval>];
           [ EVERY <evry>];
           [ <rst: REST>] ;
           [ <all: ALL> ] ;
           [<uniq: UNIQUE>] ;
           [ <asc: ASCENDING>] ;
           [<desc: DESCENDING>] ;
           [ <add: ADDITIVE>] ;
      =>  ordCondSet( <"for">, __EBCB(<for>) ,[<.all.>], ;
                      __EBCB(<whl>), __EBCB(<eval>), <evry> , ;
                      RECNO(), <nxt>, <rec>, ;
                      [<.rst.>], [<.desc.>] ) ;;
          ordCreate(<(cOrdBagName)>, <(cOrdName)>, ;
                    <"key">, __EBCB(<key>), [<.uniq.>], <.add.> )


#command  INDEX ON <key> TO <(file)> [<uniq: UNIQUE>] ;
      =>  dbCreateIndex( <(file)>, <"key">, __EBCB(<key>), ;
                         iif(<.uniq.>, .T., NIL) )


#command  DELETE TAG <(cOrdName1)> [ IN <(cOrdBag1)> ] [, ;
                     <(cOrdNameN)> [ IN <(cOrdBagN)> ] ] ;
      =>  ordDestroy(<(cOrdName1)>, <(cOrdBag1)>) [ ;;
          ordDestroy(<(cOrdNameN)>, <(cOrdBagN)>) ]


#command  REINDEX ;
      =>  ordListRebuild()


#command  SET INDEX TO [ <(index1)> [, <(indexN)>]] ;
      =>  ordListClear() ;
          [; ordListAdd( <(index1)> )] [; ordListAdd( <(indexN)> )]

#command  SET INDEX TO <(index1)> [, <(indexN)> ] ADDITIVE ;
      =>  ordListAdd( <(index1)> ) [; ordListAdd( <(indexN)> )]

#command  SET ORDER TO <xOrder> ;
                   [IN <(cOrdBag)>] ;
      =>  ordSetFocus( <xOrder> [, <(cOrdBag)>] )


#command  SET ORDER TO TAG <(cOrd)> ;
                   [IN <(cOrdBag)>] ;
      =>  ordSetFocus( <(cOrd)> [, <(cOrdBag)>] )

#command  SET ORDER TO ;
      =>  ordSetFocus(0)

*******************************************************************************
* Kompatibilit„t
*******************************************************************************

#command SET ECHO <*x*> ;
      =>

#command SET SAFETY <*x*>;
      =>

#command SET STATUS <*x*>;
      =>

#command SET TALK <*x*>;
      =>

#command  SET PROCEDURE TO ;
      =>

#command  SET PROCEDURE TO <proc> ;
      =>  #PROCREQ <(proc)>

#command  DO <proc>.PRG [WITH <para,...>] ;
      =>  do <proc> [ WITH <para>]

#command  STORE <val> TO <var1> [, <varN> ] ;
      =>  <var1> := [<varN> :=] <val>

#command  TEXT ;
      =>  text QOut, QQOut

#command  TEXT INTO <varname> ;
      =>  text literal, <varname>

#command  TEXT INTO <varname> TRIMMED;
      =>  text literal, <varname>,, ltrim

#command  TEXT INTO <varname> WRAP <lnbreak>;
      =>  text literal, <varname>, <lnbreak>

#command  TEXT INTO <varname> WRAP <lnbreak> TRIMMED ;
      =>  text literal, <varname>, <lnbreak>, ltrim

#command  TEXT INTO <varname> WRAP 
      =>  text literal, <varname>, CHR(13)+CHR(10)

#command  TEXT TO FILE <(file)> ;
      =>  _TextSave( <(file)> ) ;;
          text QOut, _TextRestore

#command  TEXT TO PRINTER ;
      =>  _TextSave("PRINTER") ;;
          text QOut, _TextRestore

#command  EXTERNAL <*procList*> ;
      =>  REQUEST <procList>


#xtranslate :assign   => :_assign
#xtranslate :end      => :_end


*******************************************************************************
* Erzwinge Early Binding von Makroausdrcken in Codebl”cken
*******************************************************************************

#xtrans  __EBCB()             =>
#xtrans  __EBCB( <exp> )      => _EarlyBoundCodeblock(<{exp}>)


*******************************************************************************
* Inkompatibilit„t
*******************************************************************************

#command CALL <*x*>            =>  #error Unsupported command: CALL
#command CLOSE FORMAT <*x*>    =>  #error Unsupported command: CLOSE FORMAT
#command CLOSE PROCEDURE <*x*> =>  #error Unsupported command: CLOSE PROCEDURE
#command DIR <*x*>             =>  #error Unsupported command: DIR
#command LABEL FORM <*x*>      =>  #error Unsupported command: LABEL FORM
#command REPORT FORM <*x*>     =>  #error Unsupported command: REPORT FORM
#command SET FORMAT TO <*x*>   =>  #error Unsupported command: SET FORMAT
#command SET FUNCTION <*x*>    =>  #error Unsupported command: SET FUNCTION

#ifdef __XPP_PROFILE__
#xtranslate PrfHold([<x>])   => _prfHold(<x>)
#xtranslate PrfResume([<x>]) => _prfResume(<x>)
#else
#xtranslate PrfHold([<x>])   =>
#xtranslate PrfResume([<x>]) =>
#endif

//#endif                         // #ifndef _STD_CH


// Achtung
//
// Hier kommen eigene Zeilen von A.K.
//

#command USE <f> ;
        => DBaufmachen( <(f)>, , "S" )
#command USE <f> INDEX <i>;
        => DBaufmachen( <(f)>, <(i)>, "S" )
#command USE <f> INDEX <i> EXCLUSIVE;
        => DBaufmachen( <(f)>, <(i)>, "E" )
#command USE <f> EXCLUSIVE;
        => DBaufmachen( <(f)>, , "E" )
#command   DELETE ;
          [   FOR <for>] ;
          [ WHILE <whl>] ;
          [  NEXT <nxt>] ;
          [RECORD <rcd>] ;
          [ <rst: REST>] ;
          [ ALL ] ;
      =>  dbEval( {|| SatzDelete()}, ;
                 __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>)
#command DELETE;
        => Satzdelete()
#command   RECALL ;
          [   FOR <for>] ;
          [ WHILE <whl>] ;
          [  NEXT <nxt>] ;
          [RECORD <rcd>] ;
          [ <rst: REST>] ;
          [ ALL ] ;
      =>  dbEval( {|| SatzRecall()}, ;
                 __EBCB(<for>), __EBCB(<whl>), <nxt>, <rcd>, <.rst.>)
#command RECALL;
        => Satzrecall()
#xcommand APPEND BLANK;
        => Satzappend()
//
#command SET FUNCTION <nFKey> TO <cString>;
        => __SETFUNCTION( <nFKey>, <cString> )
//
#command SET FUNC <nFKey> TO <cString> ;
        => __SETFUNCTION( <nFKey>, <cString> )

//
#command  SET PRINTER ON   =>  Drucker_an(nP:=1)
#command  SET PRINTW ON   =>  Drucker_anW(nP:=1)

//
#command  SET DEVICE TO SCREEN      =>  Drucker_aus()
#command  SET DEVICE TO PRINTER      =>  Drucker_an(nP:=2)
#command  SET DEVICE TO PRINTW      =>  Drucker_anW(nP:=2)
#command  SET DEVICE TO PRINT      =>  Drucker_an(nP:=2)

// Ende der eigenen Zeilen von A.K.
//

#endif // #ifdef __XPP__
#endif // #ifndef _STD_CH

// * EOF *

