          nB (nano Base)
          Copyright (c) 1996   Daniele Giacomini




          

          ##INDEX##
          ================================================================


          <Index>

          <Copyright>

          <Introduction>

          <Composition>

          <How to use nB>

          <Status Line>

          <The menu system>
               <Menu File>
               <Menu Edit>
               <Menu Report>
               <Menu Htf>
               <Menu Macro>
               <Menu Info>
               <Menu Doc>

          <The Text Editor Doc()>

          <The Help Text File>

          <Macro>
               <Macro statements>
               <Macro structure>
               <Macro comments>
               <Macro long lines split>
               <The macro recorder>

          <Operators>

          <Delimiters>

          <Standard functions>
               <AADD()>
               <ABS()>
               <ACHOICE()>
               <ACLONE()>
               <ACOPY()>
               <ADEL()>
               <ALERT()>
               <ALIAS()>
               <AFILL()>
               <AINS()>
               <ALERT()>
               <ALIAS()>
               <ALLTRIM()>
               <ARRAY()>
               <ASC()>
               <ASCAN()>
               <ASIZE()>
               <ASORT()>
               <AT()>
               <ATAIL()>
               <BIN2I()>
               <BIN2L()>
               <BIN2W()>
               <BOF()>
               <CDOW()>
               <CHR()>
               <CMONTH()>
               <COL()>
               <COLORSELECT()>
               <CTOD()>
               <CURDIR()>
               <DATE()>
               <DAY()>
               <DBAPPEND()>
               <DBCLEARFILTER()>
               <DBCLEARINDEX()>
               <DBCLEARRELATION()>
               <DBCLOSEALL()>
               <DBCLOSEAREA()>
               <DBCOMMIT()>
               <DBCOMMITALL()>
               <DBCREATE()>
               <DBCREATEINDEX()>
               <DBDELETE()>
               <DBEVAL()>
               <DBFILTER()>
               <DBGOBOTTOM()>
               <DBGOTO()>
               <DBGOTOP()>
               <DBRECALL()>
               <DBREINDEX()>
               <DBRELATION()>
               <DBRLOCK()>
               <DBRLOCKLIST()>
               <DBRSELECT()>
               <DBRUNLOCK()
               <DBSEEK()>
               <DBSELECTAREA()>
               <DBSETDRIVER()>
               <DBSETFILTER()>
               <DBSETINDEX()>
               <DBSETORDER()>
               <DBSETRELATION()>
               <DBSKIP()>
               <DBSTRUCT()>
               <DBUNLOCK()>
               <DBUNLOCKALL()>
               <DBUSEAREA()>
               <DESCEND()>
               <DEVOUT()>
               <DEVOUTPICT()>
               <DEVPOS()>
               <DIRECTORY()>
               <DISKSPACE()>
               <DISPBOX()>
               <DISPOUT()>
               <DOW()>
               <DTOC()>
               <DTOS()>
               <EMPTY()>
               <EOF()>
               <DTOC()>
               <EXP()>
               <FCLOSE()>
               <FCOUNT()>
               <FCREATE()>
               <FERASE()>
               <FERROR()>
               <FIELDBLOCk()>
               <FIELDGET()>
               <FIELDNAME()>
               <FIELDPOS()>
               <FIELDPUT()>
               <FIELDWBLOCK()>
               <FILE()>
               <FLOCK()>
               <FOPEN()>
               <FOUND()>
               <FREAD()>
               <FREADSTR()>
               <FRENAME()>
               <FSEEK()>
               <FWRITE()>
               <GETENV()>
               <HARDCR()>
               <HEADER()>
               <I2BIN()>
               <IF()>
               <INDEXEXT()>
               <INDEXKEY()>
               <INDEXORD()>
               <INKEY()>
               <INT()>
               <ISALPHA()>
               <ISCOLOR()>
               <ISDIGIT()>
               <ISLOWER()>
               <ISPRINTER()>
               <ISUPPER()>
               <L2BIN()>
               <LASTKEY()>
               <LASTREC()>
               <LEFT()>
               <LEN()>
               <LOG()>
               <LOWER()>
               <LTRIM()>
               <LUPDATE()>
               <MAX()>
               <MAXCOL()>
               <MAXROW()>
               <MEMOEDIT()>
               <MEMOLINE()>
               <MEMOREAD()>
               <MEMORY()>
               <MEMOTRAN()>
               <MEMOWRIT()>
               <MEMVARBLOCK()>
               <MIN()>
               <MLCOUNT()>
               <MLCTOPOS()>
               <MLPOS()>
               <MONTH()>
               <MPOSTOLC()>
               <NETERR()>
               <NEXTKEY()>
               <NOSNOW()>
               <ORDBAGEXT()>
               <ORDBAGNAME()>
               <ORDCREATE()>
               <ORDDESTROY()>
               <ORDFOR()>
               <ORDKEY()>
               <ORDLISTADD()>
               <ORDLISTCLEAR()>
               <ORDLISTREBUILD()>
               <ORDNAME()>
               <ORDNUMBER()>
               <ORDSETFOCUS()>
               <OS()>
               <OUTERR()>
               <OUTSTD()>
               <PAD?()>
               <PCOL()>
               <PROW()>
               <QOUT()>
               <RAT()>
               <RDDLIST()>
               <RDDNAME()>
               <RDDSETDEFAULT()>
               <READEXIT()>
               <READINSERT()>
               <READMODAL()>
               <READVAR()>
               <RECNO()>
               <RECSIZE()>
               <REPLICATE()>
               <RIGHT()>
               <RLOCK()>
               <ROUND()>
               <ROW()>
               <RTRIM()>
               <SAVESCREEN()>
               <SCROLL()>
               <SECONDS()>
               <SELECT()>
               <SET()>
               <SETBLINK()>
               <SETCANCEL()>
               <SETCOLOR()>
               <SETCURSOR()>
               <SETKEY()>
               <SETMODE()>
               <SETPOS()>
               <SETPRC()>
               <SOUNDEX()>
               <SPACE()>
               <SQRT()>
               <STR()>
               <STRTRAN()>
               <STUFF()>
               <SUBSTR()>
               <TIME()>
               <TONE()>
               <TRANSFORM()>
               <TYPE()>
               <UPDATED()>
               <UPPER()>
               <USED()>
               <VAL()>
               <VALTYPE()>
               <YEAR()>

          <nB functions>
               <ACCEPT()>
               <BCOMPILE()>
               <DBCLOSE()>
               <DIR()>
               <DOC()>
               <DOTLINE()>
               <DTEMONTH()>
               <DTEWEEK()>
               <EX()>
               <HTF()>
               <ISFILE()>
               <ISWILD()>
               <ISMEMVAR()>
               <ISCONSOLEON()>
               <ISPRINTERON()>
               <LISTWINDOW()>
               <MEMOWINDOW()>
               <RF()>
               <RPT()>
               <RPTMANY()>
               <RPTTRANSLATE()>
               <SETRPTEJECT()>
               <SETOUTPUT()>
               <STRADDEXTENTION()>
               <STRCUTEXTENTION()>
               <STRDRIVE()>
               <STREXTENTION()>
               <STRFILE()>
               <STROCCURS>
               <STRPARENT()>
               <STRPATH()>
               <STRTEMPPATH()>
               <STRXTOSTRING()>
               <TB()>
               <TEXT()>
               <WAITFILEEVAL()>
               <WAITFOR()>
               <WAITPROGRESS()>
          <Normal command substitution>
               <?>
               <@BOX>
               <@TO>
               <@GET>
               <@SAY>
               <APPEND>
               <CLEAR>
               <CLOSE>
               <COMMIT>
               <COUNT>
               <DELETE>
               <EJECT>
               <ERASE>
               <FIND>
               <GO>
               <INDEX ON>
               <READ>
               <RECALL>
               <REINDEX>
               <RENAME>
               <REPLACE>
               <RESTORE>
               <SAVE>
               <SEEK>
               <SELECT>
               <SET>
               <SKIP>
               <STORE>
               <SUM>
               <UNLOCK>
               <USE>

          <nB command substitution functions>
               <GET>
               <SAY>
               <APPEND FROM>
               <CONTINUE>
               <COPY>
               <CREATE>
               <JOIN>
               <LABEL FORM>
               <LIST>
               <LOCATE>
               <PACK>
               <PUBLIC>
               <QUIT>
               <RELEASE>
               <REPORT FORM>
               <RESTORE FROM>
               <RUN>
               <SAVE TO>
               <SET FUNCTION>
               <SORT>
               <TOTAL>
               <UPDATE>
               <ZAP>

          <RPT - the nB print function>
               <RPT - memvars and fields>

          <RPT - commands>
               <*COMMAND>
               <*DBSKIP>
               <*FOOT>
               <*IF>
               <*INSERT>
               <*HEAD>
               <*LPP>
               <*NEED>
               <*PA>
               <*REM>
               <*WHILE>

          <RPT - examples>
               <Page definition>
               <Header and footer>
               <Code insertion>

          <The source files>

          <Aknoledgments>

          <Known problems>

          <nB history>

          <How to contact the author>






          ##COPYRIGHT##
          ================================================================


          nB (nano Base)
          Copyright (c) 1996   Daniele Giacomini

          This program is  free software;  you can  redistribute it  and/or
          modify it under the  terms of the GNU  General Public License  as
          published by the  Free Software Foundation;  either version 2  of
          the License, or (at your option) any later version.

          This program is distributed in the  hope that it will be  useful,
          but WITHOUT ANY  WARRANTY; without even  the implied warranty  of
          MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  GNU
          General Public License for more details.

          You should have received a copy of the GNU General Public License
          along with  this program;  if not,  write  to the  Free  Software
          Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

          Send your  comments, suggestions,  bug reports  and english  text
          corrections to:

          Daniele Giacomini
          Via Turati, 15
          I-31100 Treviso
          Italy

          daniele@system.abacom.it






          ##INTRODUCTION##
          ================================================================


          First of all, I am sorry for my bad English.

          nB ("nano Base": "n"  = "nano" = 10**(-9)  = "very little") is  a
          little DOS  xBase written  in CA-Clipper  5.2  that can  help  to
          access .DBF file created with different standards. nB can  access
          files created with Fox Pro 2, dBASE IV, dBASE III, dBASE III PLUS
          and CA-Clipper.

          nB is:

          *    a dot command interpreter,

          *    a macro executor (a program interpreter), slow but usefull,

          *    a macro recorder (a program writer),
          *    a .DBF, .FRM, .LBL utility,

          *    a simple reporter.

          nB may be usefull:

          *    for CA-Clipper programmers who may need a all-in-one tool,

          *    for everyone who  need something like  "dBaseIII" and  don't
               want to pay for it (that is: for everyone who like a  little
               free xBase).

          Macro files can be written with a normal text editor or inside nB
          with the  help of  the internal  macro recorder.  The macro  file
          structure is a  simplified version of  a CA-Clipper program.  The
          macro interpretation is slow, but you don't need to complile  and
          link. nB recognise only functions and not commands.

          nB includes  the ASSIST()  function: a  menu driven  system  that
          recalls the old ASSIST command from dBase III +.

          nB includes the DOC() function: a  little text editor usefull  to
          create and edit simple  text files or report  file used with  the
          RPT printer interpreter functions.

          nB includes RPT,  a group of  functions for  the realization  and
          print of simple reports. RPT is accessible from DOC()






          ##COMPOSITION##
          ================================================================


          nB is composed from the following files.

          COPYING             GNU General Public Licence version 2.

          COPYING.TXT         GNU General Public Licence  version 2 in  Dos
                              text format.

          README.TXT          the readme file.

          FILE_ID.DIZ         definition.

          NB.HLP              this manual in "Help Text File" format.

          NB.PRN              this manual in printed text format.

          NB.RTF              this manual in RTF format.

          NB.TXT              this manual in ASCII text format.

          NB.EXE              the executable program for DBFNTX and  DBFNDX
                              files, linked with RTLINK.

          NB_BIG.EXE          the executable  program for  DBFCDX,  DBFMDX,
                              DBFNDX  and   DBFNTX   files,   linked   with
                              EXOSPACE.

          NB_SOURC.ZIP        packed nB source code files.

          NB_MACRO.ZIP        packed macro examples.



          The file NB_SOURC.ZIP contains the following files.

          NB.PRG              the main source file.

          NB_REQ.PRG          the source file  conatinig links  to all  the
                              standard functions.

          NB.LNK              link file for compilation.

          NB_NRMAL.RMK        rmake file to compile with RTLink.

          NB_EXOSP.RMK        rmake file to compile with Exospace.

          NB_RUNTI.RMK        rmake file  to compile  with RTLink  defining
                              RUNTIME to obtain a small nB runtime version.

          MACRO.LNK           link file to compile and link a macro.

          MACRO.RMK           rmake file to compile and link a macro.



          The file NB_MACRO.ZIP contains the following files.

          ADDRESS.&           macro example.

          ADDRESS.NB          compiled macro ADDRESS.&.

          ADDRESS.BAT         batch file to start the macro ADDRESS.

          ADDRESS.DBF         database file used from ADDRESS.

          ADDRESS.NTX         index file used from ADDRESS.

          ADDRESS.FRM         report form file used from ADDRESS.

          ADDRESS.LBL         label form file used form ADDRESS.

          ADDRESS.TXT         RPT text file used from ADDRESS.

          BROWSE.&            macro example to start an automatic browse.

          BROWSE.NB           compiled macro BROWSE.&.

          BROWSE.BAT          batch file to start a .DBF browse with BROWSE
                              macro.

          MENU.&              macro example for a Dos menu.

          MENU.NB             compiled macro MENU.

          MENU.BAT            batch file to use the MENU macro.






          ##HOW TO USE nB##
          ================================================================


          nB normal syntax is:

          nB [<nB_parameters>] [<macro_filename>] [<macro_parameters>]

          To run nB, just type the word "NB" and press [Enter] to  execute.
          It will run in command mode, this means that it will look like an
          old xBASE command prompt.

          To run  the program  as a  macro interpreter,  type the  word  NB
          followed from  the macro  file name  with extention  (no  default
          extention is supposed). If parameters are given, after the  macro
          file name, these will be  available inside the public  variables:
          c_Par1, c_Par2, ..., c_Par9. c_Par0  will contain the macro  file
          name (see the macro file  BROWSE.&). nB will terminate  execution
          when the macro terminates.

          These parameters are available for nB:

          -c   Suppress the copyright notice. It  is usefull when using  nB
               for macro interpretation.
          -w   Suppress the "Wait-Wheel" if not desired. It is the  "Wheel"
               that appears  at top-left  when a  macro is  interpreted  or
               other long elaborarions are executed.

          -?   Shows a short help.



          nB macro "compilation" syntax is:

          nB -m <source_macro_filename> [<destination_macro_filename>]

          With   the    -m    parameter,   nB    "compiles"    the    ascii
          <source_macro_filename> into <destination_macro_filename>.






          ##STATUS LINE##
          ================================================================


          nB shows a "status  line" at the  top of the  screen when the  nB
          command prompt  or  the menu  system  is active.  It  shows  some
          important informations.

          | |DBFNTX    ||*|  1|ADDRESS   |     1/     4|ADDRESS.NTX |
           |  |          |  |    |             |      |
           |  |          |  |    |             |      |
           |  |          |  |    |             |    Last record (7).
           |  |          |  |    |             |
           |  |          |  |    |           Record pointer position (6).
           |  |          |  |    |
           |  |          |  |   Active Alias (5).
           |  |          |  |
           |  |          |  Current Work Area (4)
           |  |          |
           |  |          Deleted record appearence (3)
           |  |
           |  Actual default database driver (2).
           |
           Macro recorder indicator (1).

          |     1/     4|ADDRESS.NTX |  1|ADDRESS   |
                          |             |   |
                          |             |   |
                          |             |  Order Tag Name (10)
                          |             |
                          |           Order number (9)
                          |
                         Order Bag name (8)

          (1)  This is  the place  for the  macro recorder  indicator.  The
               symbol used is "&".
               BLANK - means that the macro recorder is OFF;
               & blink - means that the macro recorder is ON;
               & - means that the macro recorder is PAUSED.

          (2)  The  name  of  the  default  database  driver.  It  is   not
               necessarily the database driver for the active Alias; it  is
               only the  database driver  that will  be used  for the  next
               open/create operation.

          (3)  An asterisk (*) at this position indicates that SET  DELETED
               is OFF. This  means that deleted  records are not  filtered.
               When a BLANK is  in this place, SET  DELETED is ON, so  that
               deleted records are filtered.

          (4)  The active work area number, that is, the area of the active
               Alias.

          (5)  The active  Alias name.  Note that  the  Alias name  is  not
               necessarily equal to the .DBF file name.

          (6)  The actual record pointer position for the active Alias.

          (7)  The number of records contained inside the active Alias.

          (8)  The Order Bag name; that is the index file name.

          (9)  The order number.

          (10) The order tag (name). When  DBFNTX database driver is  used,
               it correspond to the Order Bag name.





          ##THE MENU SYSTEM##
          ================================================================


          The nB menu  system appears  differently depending  on the  place
          where it is  "called". When  available, the  menu system  appears
          pressing [Alt]+[M] or [F10].

          It follows the menu system description.






          ##MENU FILE##
          ----------------------------------------------------------------


          CHANGE DIRECTORY
                    changes the actual drive and directory.

          FILE .DBF / NEW .DBF
                    creates a new .DBF file.

          FILE .DBF / MODIFY .DBF STRUCTURE
                    modifies a .DBF file structure.

          FILE .DBF / OPEN .DBF
                    opens a .DBF file.

          FILE .NTX / CREATE A NEW .NTX FILE
                    creates a new index file.

          FILE .NTX / OPEN A .NTX FILE
                    opens an index.

          ALIAS / SELECT
                    selects an Alias or a new area from the available ones.

          ALIAS / DISPLAY STRUCTURE
                    displays the active Alias structure.

          ALIAS / CLOSE ACTIVE ALIAS
                    closes the active Alias.
          ALIAS / CLOSE ALL ALIASES
                    close all Aliases.

          ORDER / ORDER LIST REBUILD
                    makes a reindex.

          ORDER / ORDER SET FOCUS
                    selects an order from the list of available ones.

          ORDER / ORDER LIST CLEAR
                    closes all indexes associated to the active Alias.

          RELATION / SET RELATION
                    creates a new relation.

          RELATION / CLEAR RELATION
                    releases all relation.

          RDD DEFAULT / SHOW ACTUAL RDD DEFAULT
                    shows the active database driver.

          RDD DEFAULT / SET DEFAULT RDD
                    changes the default database driver showing the list of
                    availables ones.






          ##MENU EDIT##
          ----------------------------------------------------------------


          VIEW
                    browse  the  active  Alias  with  eventual   relations,
                    without the possibility to modify it.

          EDIT/BROWSE
                    browse the active Alias with eventual relations.

          REPLACE
                    interactive replace on the active Alias.

          RECALL
                    interactive recall of previously deleted records on the
                    active Alias.

          DELETE
                    interactive delete of records on the active Alias.
          PACK
                    packs the active Alias eliminating the deleted  records
                    on the active Alias.






          ##MENU REPORT##
          ----------------------------------------------------------------


          DBGOTOP()
                    move record the  pointer for  the active  Alias at  the
                    first logical record.

          NEW LABEL
                    creates a new label form file (.LBL).

          MODIFY LABEL
                    modifies a label form file (.LBL).

          LABEL FORM
                    prints labels using the active Alias.

          NEW REPORT
                    creates a new report form file (.FRM).

          MODIFY REPORT
                    modifies a report form file (.FRM).

          REPORT FORM
                    prints a report using the active Alias.

          CREATE/MODIFY/PRINT TEXT
                    activates the function DOC() that is a text editor with
                    the ability to include Fields, form the active Alias.





          ##MENU HTF##
          ----------------------------------------------------------------


          NEW HELP TEXT FILE
                    generates a new  "help text file"  (.DBF) from a  Ascii
                    file source.

          OPEN HELP TEXT FILE
                    opens and browse a "help text file" (.DBF).






          ##MENU MACRO##
          ----------------------------------------------------------------


          START|PAUSE RECORDING
                    starts or pause the macro recorder.

          SAVE RECORDING
                    save recorded macro on a macro file.

          ERASE RECORDING
                    erase the actual recording session.

          EDIT RECORDING
                    edits the actual recording.

          MACRO "COMPILATION"
                    compiles a ascii macro into a compiled file.

          LOAD + EXECUTE MACRO
                    loads a macro file and executes it.





          ##MENU INFO##
          ----------------------------------------------------------------


          ABOUT
                    a brief copyright notice.

          MANUAL BROWSE
                    starts the browse of MANUAL.DBF, the nB Help Text  File
                    manual if it is present in the current directory.

          [F1] HELP
                    [F1] reminder.

          [F3] ALIAS INFO
                    [F3] reminder. It shows  all the available  information
                    on the active Alias.

          [F5] SET ALTERNATE TO
                    [F5] reminder.  It  defines the  output  peripheral  or
                    file.






          ##MENU DOC##
          ----------------------------------------------------------------


          This menu actually appears only inside the DOC() function.

          NEW
                    empties the work area.

          OPEN
                    opens a new text file.

          SAVE
                    saves the text file in use.

          SAVE AS
                    saves the file with a new name.

          SET ALTERNATE TO
                    changes the output peripheral or file.

          PRINT AS IT IS
                    prints the text file without transforming the variables
                    or executing print commands.

          PRINT WITH RPT() ONCE
                    prints the  text  using  Memvars and  Fields  from  the
                    actual record on the active  Alias: it calls the  RPT()
                    functions.

          PRINT WITH RPT() STD
                    prints the text using all logical records in the active
                    Alias: it calls the RPT() functions.

          EXIT
                    terminates the Doc() execution.






          ##THE TEXT EDITOR DOC()##
          ================================================================


          The function  Doc() activates  a simple  text editor  usefull  to
          build some simple reports.

          Inside this  function  a  menu  is  available  and  is  activated
          pressing [Alt]+[M] or  [F10]. The Doc()  menu is part  of the  nB
          menu system.

          See also:
                    <The menu system>
                    <Menu Doc>
                    <RPT - the nB print function>





          ##THE HELP TEXT FILE##
          ================================================================


          nB provides a basic hypertext system to build simple help  files.
          A source text file  with "indexes" and  "pointers" to indexes  is
          translated into a "help text file" (a .DBF file); then, this file
          is browsed by nB.

          The source file can have a  maximum line width of 80  characters;
          each line can temrinate with CR or CR+LF.

          "Indexes" are  string  delimited  by  index  delimiters  (default
          "##"); "pointers"  are  string delimited  by  pointer  delimiters
          (default "<" and ">") and refers to indexes.

          Inside a text, indexes must be  unique; pointers can be  repeated
          anywhere. A text can contain a maximum of 4000 indexes.

          Inside this manual, titles  are delimited with  "##" as they  are
          indexes; strings delimited with "<" and ">" identify a  reference
          to a title with the same string.

          To browse a previously created Help Text File, use the  following
          keys:

          [Esc]               Exit.

          [UpArrow]           Move cursor up.

          [DownArrow]         Move cursor down.

          [PgUp]              Move cursor PageUp.

          [PgDn]              Move cursor Pagedown.

          [Ctrl]+[PgUp]       Move cursor Top.

          [Ctrl]+[PgDn]       Move cursor Bottom.

          [Enter]             Select a reference (pointer).

          [<-]                Go to previous selected reference (pointer).

          [->]                Go to next selected reference (pointer).
          [Shift]+[F3]        Search for a new pattern.

          [F3]                Repeat previous search.






          ##MACRO##
          ================================================================


          nB can execute  (run) macro  files. There  may be  three kind  of
          macro files:

          *         ascii (usually with .& extention),

          *         "compiled" (usually with .NB extention),

          *         EXE files (compiled with CA-Clipper and linked).

          "Compiled" macro files are executed faster then the ascii  source
          files.

          EXE macro files are the fastest.






          ##MACRO STATEMENTS##
          ----------------------------------------------------------------


          The statemens recognised from nB are very similar to  CA-Clipper,
          with some restrictions.




          PROCEDURE <procedure name>
               <statements>...
               [RETURN]
               <statements>...
          ENDPROCEDURE



          DO PROCEDURE <procedure name>




          BEGIN SEQUENCE
               <statements>...
               [BREAK]
               <statements>...
          END




          DO CASE
          CASE <lCondition1>
               <statements>...
          [CASE <lCondition2>]
               <statements>...
          [OTHERWISE]
               <statements>...
          END




          WHILE <lCondition>
               <statements>...
               [EXIT]
               <statements>...
               [LOOP]
               <statements>...
          END




          IF <lCondition1>
               <statements>...
          [ELSE]
               <statements>...
          END



          Note that:

          *    The FOR statement is not included;

          *    there is no function declaration;

          *    procedure calls cannot transfer variables;

          *    only public variables are allowed.






          ##MACRO STRUCTURE##
          ----------------------------------------------------------------


          A nB  macro  must  be  organised as  follow.  There  may  be  two
          situations: Macros with procedures and macros without procedures.

          Macro with procedures:

               PROCEDURE <procedure name1>
                    <statements>...
                    [RETURN]
                    <statements>...
               ENDPROCEDURE
               PROCEDURE <procedure name2>
                    <statements>...
                    [RETURN]
                    <statements>...
               ENDPROCEDURE
               PROCEDURE <procedure name3>
                    <statements>...
                    [RETURN]
                    <statements>...
               ENDPROCEDURE
               ...
               ...
               DO PROCEDURE <procedure name nth>

          Macro without procedures:
               <statements>...
               <statements>...
               <statements>...
               <statements>...
               <statements>...
               <statements>...
               <statements>...

          nB Macros may be  compiled with CA-Clipper. To  do so, the  first
          structure example must be changed as follows:

               #INCLUDE MACRO.CH

               DO PROCEDURE <procedure name nth>
               ...
               PROCEDURE <procedure name1>
                    <statements>...
                    [RETURN]
                    <statements>...
               ENDPROCEDURE
               PROCEDURE <procedure name2>
                    <statements>...
                    [RETURN]
                    <statements>...
               ENDPROCEDURE
               PROCEDURE <procedure name3>
                    <statements>...
                    [RETURN]
                    <statements>...
               ENDPROCEDURE
               ...
               ...

          To compile a macro  with CA-Clipper, the macro  file name can  be
          changed into MACRO.PRG and

               RTLINK MACRO.RMK [Enter]

          should be started.





          ##MACRO COMMENTS##
          ----------------------------------------------------------------


          A nB  Macro  source file  can  contain comments.  only  the  "//"
          comment is  recognised! This  way: *  and /*...*/  will  generate
          errors!

               ATTENTION: to simplify the macro interpretation,  lines
               such as this:

               qqout( "You can't do that // you can't do that!" )

               will generate  an error  as the  interpreter will  read
               only:

               qqout( "You can't do that

               Sorry!






          ##MACRO LONG LINES SPLIT##
          ----------------------------------------------------------------


          Inside  a  nB  macro,  long  lines  may  be  splitted  using  ";"
          (semicolon).

          *         Lines can only be splitted and not joined!

          *         A resulting  command line  cannot be  longher then  254
                    characters.





          ##THE MACRO RECORDER##
          ----------------------------------------------------------------


          Inside the functions  ASSIST() and DOC()  is available the  Macro
          recorder menu.

          When a macro recording is started, a "&" appears on the left side
          of the status bar. It it  blinks, the recording is active, if  it
          is stable, the recording is paused.

          The macro recording  is not exactly  a step-by-step recording  of
          all action taken, but a translation (as good as posible) of  what
          you have done.

          The macro recorder is able to record only the menu functions that
          terminates with the "&"  symbol and all what  is inserted at  the
          dot command line.

          The  macro  recording  can  be  viewed  and  edited  during   the
          recording. The macro recording can be  saved into a text file  (a
          macro file).






          ##OPERATORS##
          ================================================================


          Here is  a  list  with  a  brief  description  of  the  operators
          available inside nB.




          <cString1> $ <cString2>

          Substring comparison.
          If <cString1> is contained inside <cString2> the result is true
          (.T.).



          <nNumber1> % <nNumber2>

          Modulus.
          The result is the remainder of <nNumber1> divided by <nNuber2>.




          ()

          Function or grouping indicator.




          <nNumber1> * <nNumber2>

          Multiplication.




          <nNumber1> ** <nNumber2>
          <nNumber1> ^ <nNumber2>

          Exponentiation.




          <nNumber1> + <nNumber2>
          <dDate> + <nNumber>

          Addition, unary positive.




          <cString1> + <cString2>

          String concatenation.
          The result is the a string beguinning with the content fo
          <cString1> and following with the content of <cString2>.



          <nNumber1> - <nNumber2>
          <dDate1> - <dDate2>
          <dDate> - <nNumber>

          Subtraction, unary negative.




          <cString1> - <cString2>

          String concatenation.
          The result is a string containing <cString1> after trimming
          trailing blanks and <cString2>.




          <idAlias>-><idField>
          FIELD-><idVar>
          MEMVAR-><idVar>

          Alias assignment.
          The alias operator implicitly SELECTs the <idAlias> before
          evaluating <idField>. When the evaluation is complete, the
          original work area is SELECTed again.




          <lCondition1> .AND. <lCondition2>

          Logical AND.




          .NOT. <lCondition>

          Logical NOT.




          <lCondition1> .OR. <lCondition2>

          Logical OR.



          <nNumber1> / <nNumber2>

          Division.




          <object>:<message>[(argument list)]

          Send.




          <idVar> := <exp>

          Inline assign.




          <exp1> <= <exp2>

          Less than or equal.




          <exp1> <> <exp2>

          Not equal.




          <exp1> = <exp2>

          Equal.




          <exp1> == <exp2>

          Exactly equal.



          <exp1> > <exp2>

          Greater than.




          <exp1> >= <exp2>

          Greater than or equal.




          @<idVar>

          Pass-by-reference.




          []
          <aArray>[<nSubscript>, ...]
          <aArray>[<nSubscript1>][<nSubscript2>] ...

          Array element indicator.






          ##DELIMITERS##
          ================================================================


          Here is the delimiter list recognised from nB.




          { <exp list> }

          Literal array delimiters.



          { |<param list>| <exp list> }

          Code block delimiters.




          "<cString>"
          '<cString>'
          [<cString>]

          String delimiters.






          ##STANDARD FUNCTIONS##
          ================================================================


          With nB  All  CA-Clipper standard  functions  may be  used.  Here
          follows a short description.






          ##AADD()##
          ----------------------------------------------------------------


          Array ADD

          AADD(<aTarget>, <expValue>) --> Value

          <aTarget>           is the array to add a new element to.

          <expValue>          is the value assigned to the new element.

          It increases the actual  length of the target  array by one.  The
          newly created array  element is assigned  the value specified  by
          <expValue>.





          ##ABS()##
          ----------------------------------------------------------------


          ABSolute

          ABS(<nExp>) --> nPositive

          <nExp>    is the numeric expression to evaluate.

          ABS() returns a  number representing  the absolute  value of  its
          argument.






          ##ACHOICE()##
          ----------------------------------------------------------------


          Array CHOICE

          ACHOICE(<nTop>, <nLeft>, <nBottom>, <nRight>,
               <acMenuItems>,
               [<alSelectableItems> | <lSelectableItems>],
               [<cUserFunction>],
               [<nInitialItem>],
               [<nWindowRow>]) --> nPosition

          <nTop>, <nLeft>, <nBottom>, <nRight>
                              are the window coordinates.

          <acMenuItems>       is an array of  character strings to  display
                              as the menu items.
          <alSelectableItems> is a parallel  array of  logical values  (one
                              element for each item in <acMenuItems>)  that
                              specify the selectable  menu items.  Elements
                              can be logical  values or character  strings.
                              If the element is  a character string, it  is
                              evaluated as a macro expression which  should
                              evaluate to a logical  data type. A value  of
                              false (.F.) means that the corresponding menu
                              item is not  available, and a  value of  true
                              (.T.) means that it is available. By default,
                              all menu items are available for selection.

          <cUserFunction>     is the name of  a user-defined function  that
                              executes  when  an   unrecognizable  key   is
                              pressed.  Specify  the  function  name  as  a
                              character expression  without parentheses  or
                              arguments.

          <nInitialItem>      is the position in the <acMenuItems> array of
                              the item that  will be  highlighted when  the
                              menu is initially displayed.

          <nWindowRow>        is the window row number on which the initial
                              menu item will appear.

          ACHOICE() returns the numeric position in the <acMenuItems> array
          of the  menu  item selected.  If  no choice  is  made,  ACHOICE()
          returns zero.






          ##ACLONE()##
          ----------------------------------------------------------------


          Array CLONE

          ACLONE(<aSource>) --> aDuplicate

          <aSource>           is the array to duplicate.

          ACLONE() returns a duplicate of <aSource>.





          ##ACOPY()##
          ----------------------------------------------------------------


          Array COPY

          ACOPY(<aSource>, <aTarget>,
               [<nStart>], [<nCount>], [<nTargetPos>]) --> aTarget

          <aSource>           is the array to copy elements from.

          <aTarget>           is the array to copy elements to.

          <nStart>            is  the  starting  element  position  in  the
                              <aSource>  array.  If   not  specified,   the
                              default value is one.

          <nCount>            is the number  of elements to  copy from  the
                              <aSource> array  beginning  at  the  <nStart>
                              position. If <nCount>  is not specified,  all
                              elements  in  <aSource>  beginning  with  the
                              starting element are copied.

          <nTargetPos>        is  the  starting  element  position  in  the
                              <aTarget>  array  to  receive  elements  from
                              <aSource>.  If  not  specified,  the  default
                              value is one.

          ACOPY() is  an  array  function that  copies  elements  from  the
          <aSource> array to the <aTarget> array. The <aTarget> array  must
          already exist and be large enough to hold the copied elements.





          ##ADEL()##
          ----------------------------------------------------------------


          Array DELete

          ADEL(<aTarget>, <nPosition>) --> aTarget

          <aTarget>           is the array to delete an element from.

          <nPosition>         is the position of  the target array  element
                              to delete.

          ADEL() is  an array  function that  deletes  an element  from  an
          array. The contents of the specified  array element is lost,  and
          all elements  from that  position to  the end  of the  array  are
          shifted up one  element. The last  element in  the array  becomes
          NIL.






          ##AEVAL()##
          ----------------------------------------------------------------


          Array EVALuation

          AEVAL(<aArray>, <bBlock>,
               [<nStart>], [<nCount>]) --> aArray

          <aArray>  is the array to be evaluated.

          <bBlock>  is  a   code  block   to  execute   for  each   element
                    encountered.

          <nStart>  is the starting element. If not specified, the  default
                    is element one.

          <nCount>  is the number of elements to process from <nStart>.  If
                    not specified, the default is  all elements to the  end
                    of the array.
          AEVAL() is an array function that evaluates a code block once for
          each element  of an  array, passing  the  element value  and  the
          element index as block parameters. The return value of the  block
          is ignored. All elements in <aArray> are processed unless  either
          the <nStart> or the <nCount> argument is specified.






          ##AFILL()##
          ----------------------------------------------------------------


          Array FILL

          AFILL(<aTarget>, <expValue>,
               [<nStart>], [<nCount>]) --> aTarget

          <aTarget>           is the array to fill.

          <expValue>          is the value to place in each array  element.
                              It can  be an  expression of  any valid  data
                              type.

          <nStart>            is the position of the first element to fill.
                              If this  argument  is  omitted,  the  default
                              value is one.

          <nCount>            is the number  of elements  to fill  starting
                              with element  <nStart>. If  this argument  is
                              omitted,  elements   are  filled   from   the
                              starting element position to  the end of  the
                              array.

          AFILL() is an array function that fills the specified array  with
          a single value of any data type (including an array, code  block,
          or NIL)  by assigning  <expValue> to  each array  element in  the
          specified range.





          ##AINS()##
          ----------------------------------------------------------------


          Array INSert

          AINS(<aTarget>, <nPosition>) --> aTarget

          <aTarget>           is the array into which a new element will be
                              inserted.

          <nPosition>         is the position at which the new element will
                              be inserted.

          AINS() is an  array function that  inserts a new  element into  a
          specified array.  The newly  inserted element  is NIL  data  type
          until a new  value is assigned  to it. After  the insertion,  the
          last element in the  array is discarded,  and all elements  after
          the new element are shifted down one position.






          ##ALERT()##
          ----------------------------------------------------------------


          ALERT( <cMessage>, [<aOptions>] ) --> nChoice

          <cMessage>          is the message  text displayed, centered,  in
                              the alert box. If the message contains one or
                              more   semicolons,   the   text   after   the
                              semicolons is centered on succeeding lines in
                              the dialog box.

          <aOptions>          defines a list of up to 4 possible  responses
                              to the dialog box.
          ALERT() returns  a  numeric  value indicating  which  option  was
          chosen. If the Esc  key is pressed, the  value returned is  zero.
          The ALERT() function creates a simple modal dialog. The user  can
          respond by  moving a  highlight bar  and pressing  the Return  or
          SpaceBar keys, or by pressing the key corresponding to the  first
          letter of the  option. If <aOptions>  is not  supplied, a  single
          "Ok" option is presented.






          ##ALIAS()##
          ----------------------------------------------------------------


          ALIAS([<nWorkArea>]) --> cAlias

          <nWorkArea>    is any work area number.

          ALIAS() returns  the  alias  of the  specified  work  area  as  a
          character string. If <nWorkArea> is  not specified, the alias  of
          the current work area is returned.  If there is no database  file
          in USE for the specified work area, ALIAS() returns a null string
          ("").






          ##ALLTRIM()##
          ----------------------------------------------------------------


          ALLTRIM(<cString>) --> cTrimmedString

          <cString>           is the character expression to trim.

          ALLTRIM() returns a  character string with  leading and  trailing
          spaces removed.





          ##ARRAY()##
          ----------------------------------------------------------------


          ARRAY(<nElements> [, <nElements>...]) --> aArray

          <nElements>         is the number  of elements  in the  specified
                              dimension.

          ARRAY() is an array function that returns an uninitialized  array
          with the specified number of elements and dimensions.






          ##ASC()##
          ----------------------------------------------------------------


          ASCii

          ASC(<cExp>) --> nCode

          <cExp>    is the character expression to convert to a number.

          ASC() returns an integer  numeric value in the  range of zero  to
          255, representing the ASCII value of <cExp>.






          ##ASCAN()##
          ----------------------------------------------------------------


          Array SCAN

          ASCAN(<aTarget>, <expSearch>,
               [<nStart>], [<nCount>]) --> nStoppedAt

          <aTarget>           is the array to scan.
          <expSearch>         is either a  simple value to  scan for, or  a
                              code block. If <expSearch> is a simple  value
                              it  can  be  character,  date,  logical,   or
                              numeric type.

          <nStart>            is the starting element of the scan. If  this
                              argument  is  not   specified,  the   default
                              starting position is one.

          <nCount>            is the number  of elements to  scan from  the
                              starting position.  If this  argument is  not
                              specified, all  elements  from  the  starting
                              element to the end of the array are scanned.

          ASCAN() returns a numeric  value representing the array  position
          of the last element  scanned. If <expSearch>  is a simple  value,
          ASCAN() returns the  position of the  first matching element,  or
          zero if a  match is not  found. If <expSearch>  is a code  block,
          ASCAN() returns  the  position of  the  element where  the  block
          returned true (.T.).






          ##ASIZE()##
          ----------------------------------------------------------------


          Array SIZE

          ASIZE(<aTarget>, <nLength>) --> aTarget

          <aTarget>           is the array to grow or shrink.

          <nLength>           is the new size of the array.

          ASIZE() is an array  function that changes  the actual length  of
          the <aTarget>  array. The  array is  shortened or  lengthened  to
          match the specified length. If  the array is shortened,  elements
          at the end of the array are lost. If the array is lengthened, new
          elements are added to the end of the array and assigned NIL.





          ##ASORT()##
          ----------------------------------------------------------------


          Array SORT

          ASORT(<aTarget>, [<nStart>],
               [<nCount>], [<bOrder>]) --> aTarget

          <aTarget>           is the array to sort.

          <nStart>            is the  first element  of  the sort.  If  not
                              specified, the default  starting position  is
                              one.

          <nCount>            is the  number of  elements to  sort. If  not
                              specified,  all   elements   in   the   array
                              beginning  with  the  starting  element   are
                              sorted.

          <bOrder>            is an optional code  block used to  determine
                              sorting order. If not specified, the  default
                              order is ascending.

          ASORT() is an array function that  sorts all or part of an  array
          containing elements of a single data type. Data types that can be
          sorted include  character, date,  logical,  and numeric.  If  the
          <bOrder>  argument  is  not  specified,  the  default  order   is
          ascending. Each time  the block is  evaluated, two elements  from
          the target array are passed as  block parameters. The block  must
          return true (.T.) if the elements are in sorted order.






          ##AT()##
          ----------------------------------------------------------------


          AT(<cSearch>, <cTarget>) --> nPosition

          <cSearch>           is  the  character  substring  for  which  to
                              search.
          <cTarget>           is the character string to search.

          AT() returns  the position  of the  first instance  of  <cSearch>
          within <cTarget> as an integer numeric value. If <cSearch> is not
          found, AT() returns zero.

          AT() is a character  function used to  determine the position  of
          the first  occurrence of  a  character substring  within  another
          string.






          ##ATAIL()##
          ----------------------------------------------------------------


          Array TAIL

          ATAIL(<aArray>) --> Element

          <aArray>  is the array.

          ATAIL() is an  array function that  returns the highest  numbered
          element of an array. It can be used in applications as  shorthand
          for <aArray>[LEN(<aArray>)]  when you  need  to obtain  the  last
          element of an array.






          ##BIN2I()##
          ----------------------------------------------------------------


          BINary to Integer

          BIN2I(<cSignedInt>) --> nNumber

          <cSignedInt>        is a character string in the form of a 16-bit
                              signed integer number--least significant byte
                              first.

          BIN2I() returns an integer obtained converting the first two byte
          contained inside <cSignedInt>.





          ##BIN2L()##
          ----------------------------------------------------------------


          BINary to Large

          BIN2L(<cSignedInt>) --> nNumber

          <cSignedInt>        is a character string in the form of a 32-bit
                              signed integer number--least significant byte
                              first.

          BIN2L()  returns  an  integer   obtained  from  the  first   tour
          characters contained in <cSignedInt>.






          ##BIN2W()##
          ----------------------------------------------------------------


          BINary to Word

          BIN2W(<cUnsignedInt>) --> nNumber

          <cUnsignedInt>      is a character string in the form of a 16-bit
                              unsigned  integer  number--least  significant
                              byte first.

          BIN2W() returns an integer obtained from the first two characters
          contained in <cSignedInt>.





          ##BOF()##
          ----------------------------------------------------------------


          Begin Of File

          BOF() --> lBoundary

          BOF() returns true (.T.) after an attempt to SKIP backward beyond
          the first  logical  record  in a  database  file;  otherwise,  it
          returns false (.F.).  If there is  no database file  open in  the
          current work  area, BOF()  returns false  (.F.). If  the  current
          database file contains no records, BOF() returns true (.T.).






          ##CDOW()##
          ----------------------------------------------------------------


          Character Day Of Week

          CDOW(<dExp>) --> cDayName

          <dExp>    is the date value to convert.

          CDOW() returns the  name of the  day of the  week as a  character
          string. The first letter is uppercase and the rest of the  string
          is lowercase. For a null date value, CDOW() returns a null string
          ("").





          ##CHR()##
          ----------------------------------------------------------------


          CHaRacter

          CHR(<nCode>) --> cChar

          <nCode>   is an ASCII code in the range of zero to 255.

          CHR() returns  a  single  character value  whose  ASCII  code  is
          specified by <nCode>.






          ##CMONTH()##
          ----------------------------------------------------------------


          Character MONTH

          CMONTH(<dDate>) --> cMonth

          <dDate>   is the date value to convert.

          CMONTH() returns the name of the month as a character string from
          a date value with the first letter uppercase and the rest of  the
          string lowercase. For a null date value, CMONTH() returns a  null
          string ("").





          ##COL()##
          ----------------------------------------------------------------


          COLumn

          COL() --> nCol

          COL() is  a  screen  function that  returns  the  current  column
          position of the cursor. The value  of COL() changes whenever  the
          cursor position changes on the screen.






          ##COLORSELECT()##
          ----------------------------------------------------------------


          COLORSELECT(<nColorIndex>) --> NIL

          <nColorIndex>       is a  number  corresponding  to  the  oridnal
                              positions  in  the  current  list  of   color
                              attributes, as set by SETCOLOR().

          COLORSELECT() activates the specified color pair from the current
          list of color attributes (established by SETCOLOR()).





          ##CTOD()##
          ----------------------------------------------------------------


          Character To Date

          CTOD(<cDate>) --> dDate

          <cDate>   is   a   character   string   consisting   of   numbers
                    representing the month, day, and year separated by  any
                    character other than a number. The month, day, and year
                    digits must  be specified  in accordance  with the  SET
                    DATE format. If the  century digits are not  specified,
                    the century is determined by the rules of SET EPOCH.

          CTOD() returns a  date value.  If <cDate>  is not  a valid  date,
          CTOD() returns an empty date.






          ##CURDIR()##
          ----------------------------------------------------------------


          CURrent DIRectory

          CURDIR([<cDrivespec>]) --> cDirectory

          <cDrivespec>        specifies the  letter of  the disk  drive  to
                              query. If not specified,  the default is  the
                              current DOS drive.

          CURDIR() returns the current DOS directory of the drive specified
          by <cDrivespec> as a character  string without either leading  or
          trailing backslash (\) characters.





          ##DATE()##
          ----------------------------------------------------------------


          DATE() --> dSystemDate

          DATE() returns the system date as a date value.






          ##DAY()##
          ----------------------------------------------------------------


          DAY(<dDate>) --> nDay

          <dDate>   is a date value to convert.

          DAY() returns the day number from <dDate>.






          ##DBAPPEND()##
          ----------------------------------------------------------------


          DBAPPEND([<lReleaseRecLocks>]) --> NIL

          <lReleaseRecLocks>  is a logical  data type that  if true  (.T.),
                              clears all pending record locks, then appends
                              the next  record.  If  <lReleaseRecLocks>  is
                              false (.F.),  all  pending record  locks  are
                              maintained and the new record is added to the
                              end of the  Lock List. The  default value  of
                              <lReleaseRecLocks> is true (.T.).

          DBAPPEND() adds a new empty record to the active Alias.





          ##DBCLEARFILTER()##
          ----------------------------------------------------------------


          DBCLEARFILTER() --> NIL

          DBCLEARFILTER() clears the logical filter condition, if any,  for
          the current work area.






          ##DBCLEARINDEX()##
          ----------------------------------------------------------------


          DBCLEARINDEX() --> NIL

          DBCLEARINDEX() closes any active indexes for the active Alias.






          ##DBCLEARRELATION()##
          ----------------------------------------------------------------


          DBCLEARRELATION() --> NIL

          DBCLEARRELATION() clears  any  active relations  for  the  active
          Alias.





          ##DBCLOSEALL()##
          ----------------------------------------------------------------


          DBCLOSEALL() --> NIL

          DBCLOSEALL() releases all  occupied work  areas from  use. It  is
          equivalent to calling DBCLOSEAREA() on every occupied work area.

               Attention:  DBCLOSEALL()  cannot   be  used  inside   a
               "compiled" macro as this will stop the macro execution.
               In substitution, DBCLOSE() should be used.






          ##DBCLOSEAREA()##
          ----------------------------------------------------------------


          DBCLOSEAREA() --> NIL

          DBCLOSEAREA() releases the current work area from use.






          ##DBCOMMIT()##
          ----------------------------------------------------------------


          DBCOMMIT() --> NIL

          DBCOMMIT() causes  all updates  to the  current work  area to  be
          written to  disk.  All updated  database  and index  buffers  are
          written to  DOS  and a  DOS  COMMIT  request is  issued  for  the
          database (.dbf) file and any index files associated with the work
          area. Inside  a network  environment, DBCOMMIT()  makes  database
          updates visible  to other  processes. To  insure data  integrity,
          issue DBCOMMIT() before an UNLOCK operation.





          ##DBCOMMITALL()##
          ----------------------------------------------------------------


          DBCOMMITALL() --> NIL

          DBCOMMITALL() causes all pending updates to all work areas to  be
          written to disk. It is equivalent to calling DBCOMMIT() for every
          occupied work area.






          ##DBCREATE()##
          ----------------------------------------------------------------


          DBCREATE(<cDatabase>, <aStruct>, [<cDriver>]) --> NIL

          <cDatabase>         is the name of the new database file, with an
                              optional drive and directory, specified as  a
                              character string.  If  specified  without  an
                              extension (.dbf) is assumed.

          <aStruct>           is an array  that contains  the structure  of
                              <cDatabase> as a series of subarrays, one per
                              field. Each subarray contains the  definition
                              of  each  field's  attributes  and  has   the
                              following structure:
                              <aStruct[n][1]>     cName
                              <aStruct[n][2]>     cType
                              <aStruct[n][3]>     nLength
                              <aStruct[n][4]>     nDecimals

          <cDriver>           specifies  the  replaceable  database  driver
                              (RDD) to  use  to process  the  current  work
                              area. <cDriver> is name of the RDD  specified
                              as a character expression.

          DBCREATE() is a  database function that  creates a database  file
          from an array containing the structure of the file.





          ##DBCREATEINDEX()##
          ----------------------------------------------------------------


          DBCREATEINDEX(<cIndexName>, <cKeyExpr>, <bKeyExpr>, [<lUnique>])
               --> NIL

          <cIndexName>        is  a  character  value  that  specifies  the
                              filename of the index file (order bag) to  be
                              created.

          <cKeyExpr>          is a character value that expresses the index
                              key expression in textual form.

          <bKeyExpr>          is a code block that expresses the index  key
                              expression in executable form.

          <lUnique>           is an optional  logical value that  specifies
                              whether a unique index  is to be created.  If
                              <lUnique>  is  omitted,  the  current  global
                              _SET_UNIQUE setting is used.

          DBCREATEINDEX() creates an  index for  the active  Alias. If  the
          Alias has active indexes, they are closed.






          ##DBDELETE()##
          ----------------------------------------------------------------


          DBDELETE() --> NIL

          DBDELETE() marks  the  current  record as  deleted  (*).  Records
          marked for deletion can be filtered using SET DELETED or  removed
          from the file using the PACK command.





          ##DBEVAL()##
          ----------------------------------------------------------------


          DB EVALuate

          DBEVAL(<bBlock>,
               [<bForCondition>],
               [<bWhileCondition>],
               [<nNextRecords>],
               [<nRecord>],
               [<lRest>]) --> NIL

          <bBlock>            is a code  block to execute  for each  record
                              processed.

          <bForCondition>     the FOR condition expressed as code block.

          <bWhileCondition>   the WHILE condition expressed as code block.

          <nNextRecords>      is an  optional  number  that  specifies  the
                              number of  records to  process starting  with
                              the current  record. It  is the  same as  the
                              NEXT clause.

          <nRecord>           is an optional record  number to process.  If
                              this argument is specified, <bBlock> will  be
                              evaluated  for  the  specified  record.  This
                              argument is the same as the RECORD clause.

          <lRest>             is an optional logical value that  determines
                              whether the scope of DBEVAL() is all records,
                              or, starting  with  the current  record,  all
                              records to the end of file.

          DBEVAL() is a database function that evaluates a single block for
          each record within the active Alias.





          ##DBFILTER()##
          ----------------------------------------------------------------


          DBFILTER() --> cFilter

          BFILTER() returns  the filter  condition defined  in the  current
          work area  as a  character string.  If no  FILTER has  been  SET,
          DBFILTER() returns a null string ("").






          ##DBGOBOTTOM()##
          ----------------------------------------------------------------


          DBGOBOTTOM() --> NIL

          DBGOBOTTOM() moves to last logical record in the active Alias.






          ##DBGOTO()##
          ----------------------------------------------------------------


          DBGOTO(<nRecordNumber>) --> NIL

          <nRecordNumber>     is a numeric value that specifies the  record
                              number of the desired record.

          DBGOTO() moves  to the  record whose  record number  is equal  to
          <nRecordNumber>. If  no  such record  exists,  the work  area  is
          positioned to LASTREC() + 1 and both EOF() and BOF() return  true
          (.T.).





          ##DBGOTOP()##
          ----------------------------------------------------------------


          DBGOTOP() --> NIL

          DBGOTOP() moves to the first logical  record in the current  work
          area.






          ##DBRECALL()##
          ----------------------------------------------------------------


          DBRECALL() --> NIL

          DBRECALL() causes the current  record to be  reinstated if it  is
          marked for deletion.






          ##DBREINDEX()##
          ----------------------------------------------------------------


          DBREINDEX() --> NIL

          DBREINDEX() rebuilds  all  active  indexes  associated  with  the
          active Alias.





          ##DBRELATION()##
          ----------------------------------------------------------------


          DBRELATION(<nRelation>) --> cLinkExp

          <nRelation>         is the position  of the  desired relation  in
                              the list of activr Alias relations.

          DBRELATION() returns a  character string  containing the  linking
          expression of the relation specified by <nRelation>. If there  is
          no RELATION  SET for  <nRelation>,  DBRELATION() returns  a  null
          string ("").






          ##DBRLOCK()##
          ----------------------------------------------------------------


          DB Record LOCK

          DBRLOCK([<nRecNo>]) --> lSuccess

          <nRecNo>       is the record number to be locked. The default  is
                         the current record.

          DBRLOCK() is a database function that locks the record identified
          by <nRecNo> or the current record.





          ##DBRLOCKLIST()##
          ----------------------------------------------------------------


          DBRLOCKLIST() --> aRecordLocks

          DBRLOCKLIST() returns  a  one-dimensional  array  of  the  locked
          records in the active Alias.






          ##DBRSELECT()##
          ----------------------------------------------------------------


          DB Relation SELECT

          DBRSELECT(<nRelation>) --> nWorkArea

          <nRelation>         is the position  of the  desired relation  in
                              the list of current work area relations.

          DBRSELECT()  returns  the  work  area  number  of  the   relation
          specified by <nRelation> as an integer numeric value. If there is
          no RELATION SET for <nRelation>, DBRSELECT() returns zero.






          ##DBRUNLOCK()##
          ----------------------------------------------------------------


          DBRUNLOCK([<nRecNo>]) --> NIL

          <nRecNo>       is the record number  to be unlocked. The  default
                         is all previously locked records.

          DBRUNLOCK() is  a  database  function  that  unlocks  the  record
          identified by <nRecNo> or all locked records.





          ##DBSEEK()##
          ----------------------------------------------------------------


          DBSEEK(<expKey>, [<lSoftSeek>]) --> lFound

          <expKey>            is a value of any type that specifies the key
                              value associated with the desired record.

          <lSoftSeek>         is an optional  logical value that  specifies
                              whether a soft seek is to be performed.  This
                              determines how the work area is positioned if
                              the specified  key  value is  not  found.  If
                              <lSoftSeek> is  omitted, the  current  global
                              _SET_SOFTSEEK setting is used.

          DBSEEK() returns true (.T.) if the specified key value was found;
          otherwise, it returns false (.F.).






          ##DBSELECTAREA()##
          ----------------------------------------------------------------


          DBSELECTAREA(<nArea> | <cAlias>) --> NIL

          <nArea>             is a  numeric  value between  zero  and  250,
                              inclusive, that specifies the work area being
                              selected.

          <cAlias>            is a character value that specifies the alias
                              of  a  currently  occupied  work  area  being
                              selected.

          DBSELECTAREA() causes  the  specified  work area  to  become  the
          current work area. All subsequent database operations will  apply
          to  this  work  area  unless  another  work  area  is  explicitly
          specified for an operation.





          ##DBSETDRIVER()##
          ----------------------------------------------------------------


          DBSETDRIVER([<cDriver>]) --> cCurrentDriver

          <cDriver>           is an optional character value that specifies
                              the name of the  database driver that  should
                              be used to activate and manage new work areas
                              when no driver is explicitly specified.

          DBSETDRIVER() returns the name of the current default driver.






          ##DBSETFILTER()##
          ----------------------------------------------------------------


          DBSETFILTER(<bCondition>, [<cCondition>]) --> NIL

          <bCondition>        is a  code block  that expresses  the  filter
                              condition in executable form.

          <cCondition>        is  a  character  value  that  expresses  the
                              filter  condition   in   textual   form.   If
                              <cCondition> is  omitted,  the  DBSETFILTER()
                              function will return an empty string for  the
                              work area.

          DBSETFILTER() sets  a logical  filter condition  for the  current
          work area. When a  filter is set, records  which do not meet  the
          filter condition  are not  logically visible.  That is,  database
          operations which act on logical  records will not consider  these
          records.  The   filter  expression   supplied  to   DBSETFILTER()
          evaluates to true (.T.)  if the current  record meets the  filter
          condition; otherwise, it should evaluate to false (.F.).





          ##DBSETINDEX()##
          ----------------------------------------------------------------


          DBSETINDEX(<cOrderBagName>) --> NIL

          <cOrderBagName>     is  a  character  value  that  specifies  the
                              filename of the index file (index bag) to  be
                              opened.

          DBSETINDEX() is a database function that adds the contents of  an
          Order Bag  into the  Order List  of the  current work  area.  Any
          Orders already  associated  with the  work  area continue  to  be
          active.  If  the  newly  opened  Order  Bag  is  the  only  Order
          associated with the work area, it becomes the controlling  Order;
          otherwise, the controlling Order remains unchanged. If the  Order
          Bag contains more than one Order,  and there are no other  Orders
          associated with the work area, the  first Order in the new  Order
          Bag becomes the controlling Order.






          ##DBSETORDER()##
          ----------------------------------------------------------------


          DBSETORDER(<nOrderNum>) --> NIL

          <nOrderNum>         is a numeric  value that  specifies which  of
                              the active indexes is  to be the  controlling
                              index.

          DBSETORDER() controls which of  the active Alias' active  indexes
          is the controlling index.





          ##DBSETRELATION()##
          ----------------------------------------------------------------


          DBSETRELATION(<nArea> | <cAlias>, <bExpr>, [<cExpr>]) --> NIL

          <nArea>   is a numeric value that specifies the work area  number
                    of the child work area.

          <cAlias>  is a character  value that specifies  the alias of  the
                    child work area.

          <bExpr>   is  a  code   block  that   expresses  the   relational
                    expression in executable form.

          <cExpr>   is an  optional  character  value  that  expresses  the
                    relational expression in  textual form.  If <cExpr>  is
                    omitted, the  DBRELATION()  function returns  an  empty
                    string for the relation.

          DBSETRELATION() relates  the work  area specified  by <nArea>  or
          <cAlias> (the child  work area), to  the current  work area  (the
          parent work area). Any existing relations remain active.






          ##DBSKIP()##
          ----------------------------------------------------------------


          DBSKIP([<nRecords>]) --> NIL

          <nRecords>          is the  number of  logical records  to  move,
                              relative to  the current  record. A  positive
                              value means to skip  forward, and a  negative
                              value means to  skip backward. If  <nRecords>
                              is omitted, a value of 1 is assumed.
          DBSKIP() moves either forward or backward relative to the current
          record.  Attempting  to  skip  forward  beyond  the  last  record
          positions the work area to LASTREC()  + 1 and EOF() returns  true
          (.T.). Attempting  to  skip  backward  beyond  the  first  record
          positions the work  area to the  first record  and BOF()  returns
          true (.T.).






          ##DBSTRUCT()##
          ----------------------------------------------------------------


          DBSTRUCT() --> aStruct

          DBSTRUCT() returns the structure of the current database file  in
          an array whose  length is equal  to the number  of fields in  the
          database file. Each element of the array is a subarray containing
          information for  one  field.  The subarrays  have  the  following
          format:
          <aStruct[n][1]>     cName
          <aStruct[n][2]>     cType
          <aStruct[n][3]>     nLength
          <aStruct[n][4]>     nDecimals
          If there is  no database file  in USE in  the current work  area,
          DBSTRUCT() returns an empty array ({}).






          ##DBUNLOCK()##
          ----------------------------------------------------------------


          DBUNLOCK() --> NIL

          DBUNLOCK() releases  any record  or file  locks obtained  by  the
          current process for  the current  work area.  DBUNLOCK() is  only
          meaningful on a shared database in a network environment.





          ##DBUNLOCKALL()##
          ----------------------------------------------------------------


          DBUNLOCKALL() --> NIL

          DBUNLOCKALL() releases any record or  file locks obtained by  the
          current  process  for  any  work  area.  DBUNLOCKALL()  is   only
          meaningful on a shared database in a network environment.






          ##DBUSEAREA()##
          ----------------------------------------------------------------





          DBUSEAREA( [<lNewArea>], [<cDriver>], <cName>, [<xcAlias>],
               [<lShared>], [<lReadonly>]) --> NIL

          <lNewArea>          is an optional logical value. A value of true
                              (.T.) selects the lowest numbered  unoccupied
                              work area as the current work area before the
                              use operation. If  <lNewArea> is false  (.F.)
                              or omitted, the current work area is used; if
                              the work  area  is  occupied,  it  is  closed
                              first.

          <cDriver>           is an optional  character value. If  present,
                              it specifies the name of the database  driver
                              which  will   service  the   work  area.   If
                              <cDriver> is  omitted,  the  current  default
                              driver is used.

          <cName>             specifies the  name  of the  database  (.dbf)
                              file to be opened.
          <xcAlias>           is an optional  character value. If  present,
                              it specifies the alias to be associated  with
                              the work area.  The alias  must constitute  a
                              valid identifier.  A valid  <xcAlias> may  be
                              any legal  identifier  (i.e., it  must  begin
                              with an alphabetic character and may  contain
                              numeric  or  alphabetic  characters  and  the
                              underscore).  If  <xcAlias>  is  omitted,   a
                              default alias is constructed from <cName>.

          <lShared>           is an optional logical value. If present,  it
                              specifies whether  the database  (.dbf)  file
                              should be accessible to other processes on  a
                              network. A value of true (.T.) specifies that
                              other processes should  be allowed access;  a
                              value  of  false  (.F.)  specifies  that  the
                              current process is to have exclusive  access.
                              If <lShared> is  omitted, the current  global
                              _SET_EXCLUSIVE  setting  determines   whether
                              shared access is allowed.

          <lReadonly>         is an optional  logical value that  specifies
                              whether  updates   to  the   work  area   are
                              prohibited. A value  of true (.T.)  prohibits
                              updates;  a  value  of  false  (.F.)  permits
                              updates. A value of  true (.T.) also  permits
                              read-only access  to the  specified  database
                              (.dbf) file. If  <lReadonly> is omitted,  the
                              default value is false (.F.).

          DBUSEAREA() opens the specified database (.dbf).






          ##DBDELETE()##
          ----------------------------------------------------------------


          DELETED() --> lDeleted

          DELETED() returns true (.T.) if the current record is marked  for
          deletion; otherwise,  it  returns false  (.F.).  If there  is  no
          database file in USE in the current work area, DELETED()  returns
          false (.F.).





          ##DESCEND()##
          ----------------------------------------------------------------


          DESCEND(<exp>) --> ValueInverted

          <exp>     is any valid expression of character, date, logical, or
                    numeric type.

          DESCEND() returns an inverted expression of the same data type as
          the <exp>,  except for  dates which  return  a numeric  value.  A
          DESCEND() of CHR(0) always returns CHR(0).






          ##DEVOUT()##
          ----------------------------------------------------------------


          DEVice OUTput

          DEVOUT(<exp>, [<cColorString>]) --> NIL

          <exp>               is the value to display.

          <cColorString>      is an  optional  argument  that  defines  the
                              display color of <exp>.

          DEVOUT() is a full-screen display function that writes the  value
          of a  single expression  to the  current  device at  the  current
          cursor or printhead position.





          ##DEVOUTPICT()##
          ----------------------------------------------------------------


          DEVice OUTput PICTure

          DEVOUTPICT(<exp>, <cPicture>, [<cColorString>]) --> NIL

          <exp>               is the value to display.

          <cPicture>          defines  the  formatting   control  for   the
                              display of <exp>.

          <cColorString>      is an  optional  argument  that  defines  the
                              display color of <exp>.

          DEVOUTPICT() is a  full-screen display function  that writes  the
          value of a single expression to the current device at the current
          cursor or printhead position.






          ##DEVPOS()##
          ----------------------------------------------------------------


          DEVice POSition

          DEVPOS(<nRow>, <nCol>) --> NIL

          <nRow>, <nCol>      are the new row  and column positions of  the
                              cursor or printhead.

          DEVPOS() is  an environment  function that  moves the  screen  or
          printhead depending on the current DEVICE.





          ##DIRECTORY()##
          ----------------------------------------------------------------


          DIRECTORY(<cDirSpec>, [<cAttributes>]) --> aDirectory

          <cDirSpec>          identifies  the  drive,  directory  and  file
                              specification  for   the  directory   search.
                              Wildcards   are   allowed    in   the    file
                              specification. If <cDirSpec> is omitted,  the
                              default value is *.*.

          <cAttributes>       specifies inclusion  of  files  with  special
                              attributes  in   the  returned   information.
                              <cAttributes> is a  string containing one  or
                              more of the following characters:
                              H    Include hidden files
                              S    Include system files
                              D    Include directories
                              V    Search for the DOS volume label only
                              Normal  files  are  always  included  in  the
                              search, unless you specify V.

          DIRECTORY() returns  an array  of subarrays,  with each  subarray
          containing information about each  file matching <cDirSpec>.  The
          subarray has the following structure:
          <aDirectory[N][1]>  cName
          <aDirectory[N][2]>  cSize
          <aDirectory[N][3]>  dDate
          <aDirectory[N][4]>  cTime
          <aDirectory[N][5]>  cAttributes
          If no files are found matching <cDirSpec> or if <cDirSpec> is  an
          illegal path or file specification, DIRECTORY() returns an  empty
          ({}) array.





          ##DISKSPACE()##
          ----------------------------------------------------------------


          DISKSPACE([<nDrive>]) --> nBytes

          <nDrive>  is the number of the drive to query, where one is drive
                    A, two  is B,  three  is C,  etc.  The default  is  the
                    current DOS drive if  <nDrive> is omitted or  specified
                    as zero.

          DISKSPACE() returns the  number of bytes  of empty  space on  the
          specified disk drive as an integer numeric value.






          ##DISPBOX()##
          ----------------------------------------------------------------


          DISPlay BOX

          DISPBOX(<nTop>, <nLeft>, <nBottom>, <nRight>,
               [<cnBoxString>], [<cColorString>]) --> NIL

          <nTop>, <nLeft>, <nBottom>, <nRight>
                              define the coordinates of the box.

          <cnBoxString>       is a  numeric  or character  expression  that
                              defines the border characters of the box.  If
                              specified as a numeric expression, a value of
                              1 displays a single-line box and a value of 2
                              displays a double-line box. All other numeric
                              values  display   a   single-line   box.   If
                              <cnBoxString> is a  character expression,  it
                              specifies  the  characters  to  be  used   in
                              drawing the box.  This is a  string of  eight
                              border characters and a fill character.

          <cColorString>      defines the display color of the box that  is
                              drawn.
          DISPBOX() is a screen function that draws a box at the  specified
          display coordinates in the specified color.






          ##DISPOUT()##
          ----------------------------------------------------------------


          DISPlay OUT

          DISPOUT(<exp>, [<cColorString>]) --> NIL

          <exp>               is the value to display.

          <cColorString>      is an  optional  argument  that  defines  the
                              display color of <exp>.

          <cColorString>      is  a  character  expression  containing  the
                              standard color setting.

          DISPOUT() is a simple output function that writes the value of  a
          single expression to the display at the current cursor  position.
          This function ignores the SET DEVICE setting; output always  goes
          to the screen.






          ##DOW()##
          ----------------------------------------------------------------


          Day Of Week

          DOW(<dDate>) --> nDay

          <dDate>   is a date value to convert.

          DOW() returns the day  of the week as  a number between zero  and
          seven. The first day of the week is one (Sunday) and the last day
          is seven (Saturday). If <dDate> is empty, DOW() returns zero.





          ##DTOC()##
          ----------------------------------------------------------------


          Dat TO Character

          DTOC(<dDate>) --> cDate

          <dDate>        is the date value to convert.

          DTOC() returns a character string representation of a date value.
          The return value is formatted in the current date format. A  null
          date returns a string  of spaces equal in  length to the  current
          date format.






          ##DTOS()##
          ----------------------------------------------------------------


          Dat TO Sort

          DTOS(<dDate>) --> cDate

          <dDate>        is the date value to convert.

          DTOS() returns a  character string eight  characters long in  the
          form, yyyymmdd. When  <dDate> is a  null date (CTOD("")),  DTOS()
          returns a string of eight spaces.





          ##EMPTY()##
          ----------------------------------------------------------------


          EMPTY(<exp>) --> lEmpty

          <exp>     is an expression of any data type.

          EMPTY() returns true (.T.) if the expression results in an  empty
          value; otherwise, it returns false (.F.):
          Array               {}
          Character/Memo      Spaces, tabs, CR/LF, or ""
          Numeric             0
          Date                CTOD("")
          Logical             .F.
          NIL                 NIL






          ##EOF()##
          ----------------------------------------------------------------


          End Of File

          EOF() --> lBoundary

          EOF() returns true  (.T.) when  an attempt  is made  to move  the
          record pointer beyond the last logical record in a database file;
          otherwise, it returns false (.F.). If  there is no database  file
          open in the current work area, EOF() returns false (.F.). If  the
          current database  file contains  no records,  EOF() returns  true
          (.T.).





          ##DTOC()##
          ----------------------------------------------------------------


          Day TO Character

          EVAL(<bBlock>, [<BlockArg list>]) --> LastBlockValue

          <bBlock>            is the code block to evaluate.

          <BlockArg list>     is a list  of arguments to  send to the  code
                              block before it is evaluated.

          To execute or evaluate a code  block, call EVAL() with the  block
          value and  any parameters.  The parameters  are supplied  to  the
          block when  it  is executed.  Code  blocks  may be  a  series  of
          expressions separated by commas. When a code block is  evaluated,
          the returned value  is the value  of the last  expression in  the
          block.






          ##EXP()##
          ----------------------------------------------------------------


          EXPonent

          EXP(<nExponent>) --> nAntilogarithm

          <nExponent>         is the natural logarithm for which a  numeric
                              value is to be calculated.

          EXP() returns a numeric value that  is equivalent to the value  e
          raised to the specified power.





          ##FCLOSE()##
          ----------------------------------------------------------------


          File CLOSE

          FCLOSE(<nHandle>) --> lError

          <nHandle>           is the file  handle obtained previously  from
                              FOPEN() or FCREATE().

          FCLOSE() is a  low-level file function  that closes binary  files
          and forces the associated DOS buffers  to be written to disk.  If
          the operation fails, FCLOSE()  returns false (.F.). FERROR()  can
          then be used to determine the reason for the failure.






          ##FCOUNT()##
          ----------------------------------------------------------------


          Field COUNT

          FCOUNT() --> nFields

          FCOUNT() returns the number of fields in the database file in the
          active Alias as an integer numeric value. If there is no database
          file open, FCOUNT() returns zero.





          ##FCREATE()##
          ----------------------------------------------------------------


          Field CREATE

          FCREATE(<cFile>, [<nAttribute>]) --> nHandle

          <cFile>             is the name  of the  file to  create. If  the
                              file already exists, its length is  truncated
                              to zero without warning.

          <nAttribute>        is the  binary  file attribute,  the  default
                              value is zero.
                              <nAttribute> = 0    Normal (default)
                              <nAttribute> = 1    Read-only
                              <nAttribute> = 2    Hidden
                              <nAttribute> = 4    System

          FCREATE() returns the DOS  file handle number  of the new  binary
          file in  the  range  of  zero to  65,535.  If  an  error  occurs,
          FCREATE() returns -1  and FERROR() is  set to  indicate an  error
          code.






          ##FERASE()##
          ----------------------------------------------------------------


          File ERASE

          FERASE(<cFile>) --> nSuccess

          <cFile>   is the name (with  or without path) of  the file to  be
                    deleted from disk.

          FERASE() is a file  function that deletes  a specified file  from
          disk. FERASE() returns -1 if the  operation fails and zero if  it
          succeeds.





          ##FERROR()##
          ----------------------------------------------------------------


          File ERROR

          FERROR() --> nErrorCode

          FERROR() returns the DOS error from the last file operation as an
          integer numeric value.  If there  is no  error, FERROR()  returns
          zero.
          <nErrorCode> = 0    Successful
          <nErrorCode> = 2    File not found
          <nErrorCode> = 3    Path not found
          <nErrorCode> = 4    Too many files open
          <nErrorCode> = 5    Access denied
          <nErrorCode> = 6    Invalid handle
          <nErrorCode> = 8    Insufficient memory
          <nErrorCode> = 15   Invalid drive specified
          <nErrorCode> = 19   Attempted to write to a write-protected disk
          <nErrorCode> = 21   Drive not ready
          <nErrorCode> = 23   Data CRC error
          <nErrorCode> = 29   Write fault
          <nErrorCode> = 30   Read fault
          <nErrorCode> = 32   Sharing violation
          <nErrorCode> = 33   Lock Violation

          FERROR() is a low-level file function that indicates a DOS  error
          after a file function is used.






          ##FIELDBLOCK()##
          ----------------------------------------------------------------


          FIELDBLOCK(<cFieldName>) --> bFieldBlock

          <cFieldName>        is the name of the field to which the set-get
                              block will refer.
          FIELDBLOCK() returns  a code  block  that, when  evaluated,  sets
          (assigns) or gets (retrieves)  the value of  the given field.  If
          <cFieldName>  does   not  exist   in  the   current  work   area,
          FIELDBLOCK() returns NIL.






          ##FIELDGET()##
          ----------------------------------------------------------------


          FIELDGET(<nField>) --> ValueField

          <nField>            is the ordinal position  of the field in  the
                              record structure for the current work area.

          FIELDGET() returns the value of the specified field. If  <nField>
          does not correspond to the position  of any field in the  current
          database file, FIELDGET() returns NIL.






          ##FIELDNAME()##
          ----------------------------------------------------------------


          FIELDNAME(<nPosition>) --> cFieldName

          <nPosition>         is the position  of a field  in the  database
                              file structure.

          FIELDNAME()  returns  the  name  of  the  specified  field  as  a
          character string.  If  <nPosition>  does  not  correspond  to  an
          existing field in  the current database  file or  if no  database
          file is open in the current work area, FIELDNAME() returns a null
          string ("").





          ##FIELDPOS()##
          ----------------------------------------------------------------


          FIELD POSition

          FIELDPOS(<cFieldName>) --> nFieldPos

          <cFieldName>        is the  name of  a field  in the  current  or
                              specified work area.

          FIELDPOS() returns the position of the specified field within the
          list of  fields associated  with the  current or  specified  work
          area. If the current  work area has no  field with the  specified
          name, FIELDPOS() returns zero.






          ##FIELDPUT()##
          ----------------------------------------------------------------


          FIELDPUT(<nField>, <expAssign>) --> ValueAssigned

          <nField>            is the ordinal position  of the field in  the
                              current database file.

          <expAssign>         is the value  to assign to  the given  field.
                              The data type of  this expression must  match
                              the  data  type   of  the  designated   field
                              variable.

          FIELDPUT() is a database function that assigns <expAssign> to the
          field at ordinal position <nField> in the current work area. This
          function allows  you  to set  the  value  of a  field  using  its
          position within the database file structure rather than its field
          name.





          ##FIELDWBLOCK()##
          ----------------------------------------------------------------


          FIELD Work area BLOCK

          FIELDWBLOCK(<cFieldName>, <nWorkArea>) --> bFieldWBlock

          <cFieldName>        is the  name  of  the field  specified  as  a
                              character string.

          <nWorkArea>         is the  work  area  number  where  the  field
                              resides specified as a numeric value.

          FIELDWBLOCK() returns  a code  block that,  when evaluated,  sets
          (assigns) or gets  (retrieves) the value  of <cFieldName> in  the
          work area  designated by  <nWorkArea>. If  <cFieldName> does  not
          exist in the specified work area, FIELDWBLOCK() returns NIL.






          ##FILE()##
          ----------------------------------------------------------------


          FILE(<cFilespec>) --> lExists

          <cFilespec>         is in the current default directory and path.
                              It is a standard file specification that  can
                              include the wildcard  characters *  and ?  as
                              well as a drive and path reference.

          FILE() returns  true (.T.)  if  there is  a  match for  any  file
          matching the  <cFilespec> pattern;  otherwise, it  returns  false
          (.F.).





          ##FLOCK()##
          ----------------------------------------------------------------


          File LOCK

          FLOCK() --> lSuccess

          FLOCK() tries to lock the active Alias and returns true (.T.)  if
          it succeeds; otherwise, it returns false (.F.).






          ##FOPEN()##
          ----------------------------------------------------------------


          File OPEN

          FOPEN(<cFile>, [<nMode>]) --> nHandle

          <cFile>   is the name of the file  to open including the path  if
                    there is one.

          <nMode>   is the  requested  DOS  open mode  indicating  how  the
                    opened file  is  to  be  accessed.  The  open  mode  is
                    composed of the sum of two elements: the Open mode  and
                    the Sharing mode.
                    Open mode:
                         0    Open for reading (default)
                         1    Open for writing
                         2    Open for reading or writing
                    Sharing Mode:
                         0    Compatibility mode (default)
                         16   Exclusive use
                         32   Prevent others from writing
                         48   Prevent others from reading
                         64   Allow others to read or write

          FOPEN() returns the file handle of  the opened file in the  range
          of zero to 65,535. If an error occurs, FOPEN() returns -1.





          ##FOUND()##
          ----------------------------------------------------------------


          FOUND() --> lSuccess

          FOUND() returns  true  (.T.)  if  the  last  search  command  was
          successful; otherwise, it returns false (.F.).






          ##FREAD()##
          ----------------------------------------------------------------


          File READ

          FREAD(<nHandle>, @<cBufferVar>, <nBytes>) --> nBytes

          <nHandle>           is the  file  handle obtained  from  FOPEN(),
                              FCREATE(), or predefined by DOS.

          <cBufferVar>        is the name  of an  existing and  initialized
                              character variable  used to  store data  read
                              from the specified file.  The length of  this
                              variable must  be greater  than or  equal  to
                              <nBytes>.  <cBufferVar>  must  be  passed  by
                              reference and, therefore, must be prefaced by
                              the pass-by-reference operator (@).

          <nBytes>            is the  number  of  bytes to  read  into  the
                              buffer.

          FREAD() tries  to  read <nBytes>  of  the binary  file  <nHandle>
          inside <cBufferVar>. It returns the number of bytes  successfully
          read as  an  integer numeric  value.  A return  value  less  than
          <nBytes> or zero indicates end of file or some other read error.





          ##FREADSTR()##
          ----------------------------------------------------------------


          File READ STRing

          FREADSTR(<nHandle>, <nBytes>) --> cString

          <nHandle>           is the  file  handle obtained  from  FOPEN(),
                              FCREATE(), or predefined by DOS.

          <nBytes>            is the number of bytes to read, beginning  at
                              the current DOS file pointer position.

          FREADSTR() returns a character string up to 65,535 (64K) bytes. A
          null return  value  ("")  indicates an  error  or  end  of  file.
          FREADSTR() is  a low-level  file function  that reads  characters
          from an  open binary  file beginning  with the  current DOS  file
          pointer position. Characters are read up  to <nBytes> or until  a
          null character (CHR(0)) is  encountered. All characters are  read
          including control characters except for CHR(0). The file  pointer
          is then moved forward <nBytes>. If  <nBytes> is greater than  the
          number of bytes from the pointer position to the end of the file,
          the file pointer is positioned to the last byte in the file.






          ##FRENAME()##
          ----------------------------------------------------------------


          File RENANE

          FRENAME(<cOldFile>, <cNewFile>) --> nSuccess

          <cOldFile>          is the name of the file to rename,  including
                              the file  extension.  A drive  letter  and/or
                              path name may also be included as part of the
                              filename.
          <cNewFile>          is the new  name of the  file, including  the
                              file extension.  A drive  letter and/or  path
                              name may  also be  included  as part  of  the
                              name.

          FRENAME() returns  -1  if the  operation  fails and  zero  if  it
          succeeds.






          ##FSEEK()##
          ----------------------------------------------------------------


          File SEEK

          FSEEK(<nHandle>, <nOffset>, [<nOrigin>]) --> nPosition

          <nHandle>           is the  file  handle obtained  from  FOPEN(),
                              FCREATE(), or predefined by DOS.

          <nOffset>           is the  number  of  bytes to  move  the  file
                              pointer  from   the   position   defined   by
                              <nOrigin>. It can be  a positive or  negative
                              number. A positive  number moves the  pointer
                              forward, and  a  negative  number  moves  the
                              pointer backward in the file.

          <nOrigin>           defines the  starting  location of  the  file
                              pointer  before  FSEEK()  is  executed.   The
                              default  value  is  zero,  representing   the
                              beginning of file. If <nOrigin> is the end of
                              file, <nOffset> must be zero or negative.
                              <nOrigin> = 0  Seek from beginning of file
                              <nOrigin> = 1  Seek from the current
                                             pointer position
                              <nOrigin> = 2  Seek from end of file

          FSEEK() returns the new position of the file pointer relative  to
          the beginning of file (position 0)  as an integer numeric  value.
          This value is without regard to the original position of the file
          pointer. FSEEK() is a low-level file function that moves the file
          pointer forward  or  backward  in an  open  binary  file  without
          actually  reading  the  contents  of  the  specified  file.   The
          beginning  position  and   offset  are   specified  as   function
          arguments, and the new file position is returned.





          ##FWRITE()##
          ----------------------------------------------------------------


          File WRITE

          FWRITE(<nHandle>, <cBuffer>, [<nBytes>]) --> nBytesWritten

          <nHandle> is the file handle obtained from FOPEN(), FCREATE(), or
                    predefined by DOS.

          <cBuffer> is the character string to write to the specified file.

          <nBytes>  indicates the number of bytes to write beginning at the
                    current file pointer position.  If omitted, the  entire
                    content of <cBuffer> is written.

          FWRITE() returns  the  number  of bytes  written  as  an  integer
          numeric value. If the  value returned is  equal to <nBytes>,  the
          operation was  successful.  If  the return  value  is  less  than
          <nBytes> or zero, either  the disk is full  or another error  has
          occurred.






          ##GETENV()##
          ----------------------------------------------------------------


          GET ENVironment

          GETENV(<cEnvironmentVariable>) --> cString

          <cEnvironmentVariable>        is the name of the DOS  environment
                                        variable.  When   specifying   this
                                        argument,   you    can   use    any
                                        combination of upper and  lowercase
                                        letters;    GETENV()     is     not
                                        case-sensitive.
          GETENV() returns the  contents of the  specified DOS  environment
          variable as a character string. If the variable cannot be  found,
          GETENV() returns a null string ("").






          ##HARDCR()##
          ----------------------------------------------------------------


          HARD Carriage Return

          HARDCR(<cString>) --> cConvertedString

          <cString>           is the  character  string or  memo  field  to
                              convert.

          HARDCR() is  a  memo function  that  replaces all  soft  carriage
          returns (CHR(141)) with  hard carriage returns  (CHR(13)). It  is
          used to display long character strings and memo fields containing
          soft carriage returns with console commands.






          ##HEADER()##
          ----------------------------------------------------------------


          HEADER() --> nBytes

          HEADER() returns the number of bytes in the header of the current
          database file as an integer numeric value. If no database file is
          in use, HEADER() returns a zero (0).





          ##I2BIN()##
          ----------------------------------------------------------------


          Integer to BINary

          I2BIN(<nInteger>) --> cBinaryInteger

          <nInteger>     is an integer  numeric value  to convert.  Decimal
                         digits are truncated.

          I2BIN() returns a two-byte  character string containing a  16-bit
          binary integer.






          ##IF()##
          ----------------------------------------------------------------


          [I]IF(<lCondition>, <expTrue>, <expFalse>) --> Value

          <lCondition>   is a logical expression to be evaluated.

          <expTrue>      is the value, a condition-expression, of any  data
                         type, returned if <lCondition> is true (.T.).

          <expFalse>     is the  value,  of  any  date  type,  returned  if
                         <lCondition> is  false (.F.).  This argument  need
                         not be the same data type as <expTrue>.

          IF()  returns  the  evaluation   of  <expTrue>  if   <lCondition>
          evaluates to true (.T.) and <expFalse>  if it evaluates to  false
          (.F.).





          ##INDEXEXT()##
          ----------------------------------------------------------------


          INDEX EXTention

          INDEXEXT() --> cExtension

          INDEXEXT()  returns   the  default   index  file   extension   by
          determining which database driver is currently linked.






          ##INDEXKEY()##
          ----------------------------------------------------------------


          INDEXKEY(<nOrder>) --> cKeyExp

          <nOrder>       is the ordinal position of  the index in the  list
                         of index files opened  by the last USE...INDEX  or
                         SET INDEX TO command for the current work area.  A
                         zero  value  specifies   the  controlling   index,
                         without regard to its actual position in the list.

          INDEXKEY() returns the key expression of the specified index as a
          character string. If  there is no  corresponding index  or if  no
          database file is open, INDEXKEY() returns a null string ("").





          ##INDEXORD()##
          ----------------------------------------------------------------


          INDEX ORDer

          INDEXORD() --> nOrder

          INDEXORD() returns an integer  numeric value. The value  returned
          is equal to the position of the controlling index in the list  of
          open indexes for the current work area. A value of zero indicates
          that there is no controlling index and records are being accessed
          in natural order. If  no database file  is open, INDEXORD()  will
          also return a zero.






          ##INKEY()##
          ----------------------------------------------------------------


          INput KEY

          INKEY([<nSeconds>]) --> nInkeyCode

          <nSeconds>     specifies the number of seconds INKEY() waits  for
                         a  keypress.  You   can  specify   the  value   in
                         increments as  small  as one-tenth  of  a  second.
                         Specifying zero halts the  program until a key  is
                         pressed. If  <nSeconds> is  omitted, INKEY()  does
                         not wait for a keypress.

          INKEY() returns  an  integer  numeric  value  from  -39  to  386,
          identifying the key  extracted from the  keyboard buffer. If  the
          keyboard buffer is empty,  INKEY() returns zero. INKEY()  returns
          values  for   all  ASCII   characters,  function,   Alt-function,
          Ctrl-function, Alt-letter, and Ctrl-letter key combinations.
          <nInkeyCode> =   5     [Up arrow], [Ctrl]+E
          <nInkeyCode> =  24     [Down arrow], [Ctrl]+X
          <nInkeyCode> =  19     [Left arrow], [Ctrl]+S
          <nInkeyCode> =   4     [Right arrow], [Ctrl]+D
          <nInkeyCode> =   1     [Home], [Ctrl]+A
          <nInkeyCode> =   6     [End], [Ctrl]+F
          <nInkeyCode> =  18     [PgUp], [Ctrl]+R
          <nInkeyCode> =   3     [PgDn], [Ctrl]+C
          <nInkeyCode> = 397     [Ctrl]+[Up arrow]
          <nInkeyCode> = 401     [Ctrl]+[Down arrow]
          <nInkeyCode> =  26     [Ctrl]+[Left arrow], [Ctrl]+Z
          <nInkeyCode> =   2     [Ctrl]+[Right arrow], [Ctrl]+B
          <nInkeyCode> =  29     [Ctrl]+[Home], [Ctrl]+]
          <nInkeyCode> =  23     [Ctrl]+[End], [Ctrl]+W
          <nInkeyCode> =  31     [Ctrl]+[PgUp], [Ctrl]+Hyphen
          <nInkeyCode> =  30     [Ctrl]+[PgDn], [Ctrl]+^
          <nInkeyCode> = 408     [Alt]+[Up arrow]
          <nInkeyCode> = 416     [Alt]+[Down arrow]
          <nInkeyCode> = 411     [Alt]+[Left arrow]
          <nInkeyCode> = 413     [Alt]+[Right arrow]
          <nInkeyCode> = 407     [Alt]+[Home]
          <nInkeyCode> = 415     [Alt]+[End]
          <nInkeyCode> = 409     [Alt]+[PgUp]
          <nInkeyCode> = 417     [Alt]+[PgDn]
          <nInkeyCode> =  13     [Enter], [Ctrl]+M
          <nInkeyCode> =  32     Space bar
          <nInkeyCode> =  27     Esc, [Ctrl]+[
          <nInkeyCode> =  10     [Ctrl]+[Enter]
          <nInkeyCode> = 379     [Ctrl]+Print Screen
          <nInkeyCode> = 309     [Ctrl]+?
          <nInkeyCode> = 284     [Alt]+[Enter]
          <nInkeyCode> = 387     [Alt]+Equals
          <nInkeyCode> = 257     [Alt]+Esc
          <nInkeyCode> = 422     Keypad [Alt]+[Enter]
          <nInkeyCode> = 399     Keypad [Ctrl]+5
          <nInkeyCode> = 405     Keypad [Ctrl]+/
          <nInkeyCode> = 406     Keypad [Ctrl]+*
          <nInkeyCode> = 398     Keypad [Ctrl]+-
          <nInkeyCode> = 400     Keypad [Ctrl]++
          <nInkeyCode> =   5     Keypad [Alt]+5
          <nInkeyCode> = 420     Keypad [Alt]+/
          <nInkeyCode> = 311     Keypad [Alt]+*
          <nInkeyCode> = 330     Keypad [Alt]+-
          <nInkeyCode> = 334     Keypad [Alt]++
          <nInkeyCode> =  22     [Ins], [Ctrl]+V
          <nInkeyCode> =   7     [Del], [Ctrl]+G
          <nInkeyCode> =   8     [Backspace], [Ctrl]+H
          <nInkeyCode> =   9     [Tab], [Ctrl]+I
          <nInkeyCode> = 271     [Shift]+[Tab]
          <nInkeyCode> = 402     [Ctrl]+[Ins]
          <nInkeyCode> = 403     [Ctrl]+[Del]
          <nInkeyCode> = 127     [Ctrl]+[Backspace]
          <nInkeyCode> = 404     [Ctrl]+[Tab]
          <nInkeyCode> = 418     [Alt]+[Ins]
          <nInkeyCode> = 419     [Alt]+[Del]
          <nInkeyCode> = 270     [Alt]+[Backspace]
          <nInkeyCode> = 421     [Alt]+[Tab]
          <nInkeyCode> =   1     [Ctrl]+A, [Home]
          <nInkeyCode> =   2     [Ctrl]+B, [Ctrl]+[Right arrow]
          <nInkeyCode> =   3     [Ctrl]+C, [PgDn], [Ctrl]+[ScrollLock]
          <nInkeyCode> =   4     [Ctrl]+D, [Right arrow]
          <nInkeyCode> =   5     [Ctrl]+E, [Up arrow]
          <nInkeyCode> =   6     [Ctrl]+F, [End]
          <nInkeyCode> =   7     [Ctrl]+G, [Del]
          <nInkeyCode> =   8     [Ctrl]+H, [Backspace]
          <nInkeyCode> =   9     [Ctrl]+I, [Tab]
          <nInkeyCode> =  10     [Ctrl]+J
          <nInkeyCode> =  11     [Ctrl]+K
          <nInkeyCode> =  12     [Ctrl]+L
          <nInkeyCode> =  13     [Ctrl]+M, Return
          <nInkeyCode> =  14     [Ctrl]+N
          <nInkeyCode> =  15     [Ctrl]+O
          <nInkeyCode> =  16     [Ctrl]+P
          <nInkeyCode> =  17     [Ctrl]+Q
          <nInkeyCode> =  18     [Ctrl]+R, [PgUp]
          <nInkeyCode> =  19     [Ctrl]+S, [Left arrow]
          <nInkeyCode> =  20     [Ctrl]+T
          <nInkeyCode> =  21     [Ctrl]+U
          <nInkeyCode> =  22     [Ctrl]+V, [Ins]
          <nInkeyCode> =  23     [Ctrl]+W, [Ctrl]+[End]
          <nInkeyCode> =  24     [Ctrl]+X, [Down arrow]
          <nInkeyCode> =  25     [Ctrl]+Y
          <nInkeyCode> =  26     [Ctrl]+Z, [Ctrl]+[Left arrow]
          <nInkeyCode> = 286     [Alt]+A
          <nInkeyCode> = 304     [Alt]+B
          <nInkeyCode> = 302     [Alt]+C
          <nInkeyCode> = 288     [Alt]+D
          <nInkeyCode> = 274     [Alt]+E
          <nInkeyCode> = 289     [Alt]+F
          <nInkeyCode> = 290     [Alt]+G
          <nInkeyCode> = 291     [Alt]+H
          <nInkeyCode> = 279     [Alt]+I
          <nInkeyCode> = 292     [Alt]+J
          <nInkeyCode> = 293     [Alt]+K
          <nInkeyCode> = 294     [Alt]+L
          <nInkeyCode> = 306     [Alt]+M
          <nInkeyCode> = 305     [Alt]+N
          <nInkeyCode> = 280     [Alt]+O
          <nInkeyCode> = 281     [Alt]+P
          <nInkeyCode> = 272     [Alt]+Q
          <nInkeyCode> = 275     [Alt]+R
          <nInkeyCode> = 287     [Alt]+S
          <nInkeyCode> = 276     [Alt]+T
          <nInkeyCode> = 278     [Alt]+U
          <nInkeyCode> = 303     [Alt]+V
          <nInkeyCode> = 273     [Alt]+W
          <nInkeyCode> = 301     [Alt]+X
          <nInkeyCode> = 277     [Alt]+Y
          <nInkeyCode> = 300     [Alt]+Z
          <nInkeyCode> = 376     [Alt]+1
          <nInkeyCode> = 377     [Alt]+2
          <nInkeyCode> = 378     [Alt]+3
          <nInkeyCode> = 379     [Alt]+4
          <nInkeyCode> = 380     [Alt]+5
          <nInkeyCode> = 381     [Alt]+6
          <nInkeyCode> = 382     [Alt]+7
          <nInkeyCode> = 383     [Alt]+8
          <nInkeyCode> = 384     [Alt]+9
          <nInkeyCode> = 385     [Alt]+0
          <nInkeyCode> =  28     F1, [Ctrl]+[Backslash]
          <nInkeyCode> =  -1     F2
          <nInkeyCode> =  -2     F3
          <nInkeyCode> =  -3     F4
          <nInkeyCode> =  -4     F5
          <nInkeyCode> =  -5     F6
          <nInkeyCode> =  -6     F7
          <nInkeyCode> =  -7     F8
          <nInkeyCode> =  -8     F9
          <nInkeyCode> =  -9     F10
          <nInkeyCode> = -40     F11
          <nInkeyCode> = -41     F12
          <nInkeyCode> = -20     [Ctrl]+F1
          <nInkeyCode> = -21     [Ctrl]+F2
          <nInkeyCode> = -22     [Ctrl]+F4
          <nInkeyCode> = -23     [Ctrl]+F3
          <nInkeyCode> = -24     [Ctrl]+F5
          <nInkeyCode> = -25     [Ctrl]+F6
          <nInkeyCode> = -26     [Ctrl]+F7
          <nInkeyCode> = -27     [Ctrl]+F8
          <nInkeyCode> = -28     [Ctrl]+F9
          <nInkeyCode> = -29     [Ctrl]+F10
          <nInkeyCode> = -44     [Ctrl]+F11
          <nInkeyCode> = -45     [Ctrl]+F12
          <nInkeyCode> = -30     [Alt]+F1
          <nInkeyCode> = -31     [Alt]+F2
          <nInkeyCode> = -32     [Alt]+F3
          <nInkeyCode> = -33     [Alt]+F4
          <nInkeyCode> = -34     [Alt]+F5
          <nInkeyCode> = -35     [Alt]+F6
          <nInkeyCode> = -36     [Alt]+F7
          <nInkeyCode> = -37     [Alt]+F8
          <nInkeyCode> = -38     [Alt]+F9
          <nInkeyCode> = -39     [Alt]+F10
          <nInkeyCode> = -46     [Alt]+F11
          <nInkeyCode> = -47     [Alt]+F12
          <nInkeyCode> = -10     [Shift]+F1
          <nInkeyCode> = -11     [Shift]+F2
          <nInkeyCode> = -12     [Shift]+F3
          <nInkeyCode> = -13     [Shift]+F4
          <nInkeyCode> = -14     [Shift]+F5
          <nInkeyCode> = -15     [Shift]+F6
          <nInkeyCode> = -16     [Shift]+F7
          <nInkeyCode> = -17     [Shift]+F8
          <nInkeyCode> = -18     [Shift]+F9
          <nInkeyCode> = -19     [Shift]+F10
          <nInkeyCode> = -42     [Shift]+F11
          <nInkeyCode> = -43     [Shift]+F12






          ##INT()##
          ----------------------------------------------------------------


          INTeger

          INT(<nExp>) --> nInteger

          <nExp>         is a numeric expression to convert to an integer.

          INT() is a numeric function that  converts a numeric value to  an
          integer by  truncating all  digits to  the right  of the  decimal
          point. INT() is useful in operations where the decimal portion of
          a number is not needed.






          ##ISALPHA()##
          ----------------------------------------------------------------


          ISALPHA(<cString>) --> lBoolean

          <cString>      is the character string to examine.
          ISALPHA() returns true (.T.) if the first character in  <cString>
          is alphabetic; otherwise, it returns false (.F.).






          ##ISCOLOR()##
          ----------------------------------------------------------------


          ISCOLOR() | ISCOLOUR() --> lBoolean

          ISCOLOR() returns true (.T.)  if there is  a color graphics  card
          installed; otherwise, it returns false (.F.).






          ##ISDIGIT()##
          ----------------------------------------------------------------


          ISDIGIT(<cString>) --> lBoolean

          <cString>      is the character string to examine.

          ISDIGIT() returns  true  (.T.)  if the  first  character  of  the
          character string is a digit between zero and nine; otherwise,  it
          returns false (.F.).






          ##ISLOWER()##
          ----------------------------------------------------------------


          ISLOWER(<cString>) --> lBoolean

          <cString>      is the character string to examine.

          ISLOWER() returns  true  (.T.)  if the  first  character  of  the
          character string  is a  lowercase letter;  otherwise, it  returns
          false (.F.).





          ##ISPRINTER()##
          ----------------------------------------------------------------


          ISPRINTER() --> lReady

          ISPRINTER() returns true  (.T.) if LPT1  is ready; otherwise,  it
          returns false (.F.).






          ##ISUPPER()##
          ----------------------------------------------------------------


          ISUPPER(<cString>) --> lBoolean

          <cString>      is the character string to examine.

          ISUPPER() returns  true  (.T.)  if  the  first  character  is  an
          uppercase letter; otherwise, it returns false (.F.).






          ##L2BIN()##
          ----------------------------------------------------------------


          Long to BINary

          L2BIN(<nExp>) --> cBinaryInteger

          <nExp>         is the numeric  value to  convert. Decimal  digits
                         are truncated.

          L2BIN() returns  a  four-byte  character string  formatted  as  a
          32-bit binary integer.





          ##LASTKEY()##
          ----------------------------------------------------------------


          LASTKEY() --> nInkeyCode

          LASTKEY() is a keyboard function  that reports the INKEY()  value
          of the last key fetched from  the keyboard buffer by the  INKEY()
          function, or a  wait state. LASTKEY()  retains its current  value
          until another key is fetched from the keyboard buffer.

          See also:      <inkey()>






          ##LASTREC()##
          ----------------------------------------------------------------


          LAST RECord

          LASTREC() --> nRecords

          LASTREC() returns the  number of physical  records in the  active
          Alias as an integer numeric value.






          ##LEFT()##
          ----------------------------------------------------------------


          LEFT(<cString>, <nCount>) --> cSubString

          <cString>      is  a  character  string  from  which  to  extract
                         characters.

          <nCount>       is the number of characters to extract.
          LEFT() returns the leftmost <nCount> characters of <cString> as a
          character string. If <nCount> is negative or zero, LEFT() returns
          a null string (""). If <nCount> is larger than the length of  the
          character string, LEFT() returns the entire string.






          ##LEN()##
          ----------------------------------------------------------------


          LENgth

          LEN(<cString> | <aTarget>) --> nCount

          <cString>      is the character string to count.

          <aTarget>      is the array to count.

          LEN() returns the length of a  character string or the number  of
          elements in an array as an integer numeric value.






          ##LOG()##
          ----------------------------------------------------------------


          LOG(<nExp>) --> nNaturalLog

          <nExp>         is a numeric value greater than zero to convert to
                         its natural logarithm.

          LOG() returns the natural logarithm as a numeric value. If <nExp>
          is less than or equal to  zero, LOG() returns a numeric  overflow
          (displayed as a row of asterisks).





          ##LOWER()##
          ----------------------------------------------------------------


          LOWER(<cString>) --> cLowerString

          <cString>      is a character string to convert to lowercase.

          LOWER()        returns a copy  of <cString>  with all  alphabetic
                         characters converted to lowercase.






          ##LTRIM()##
          ----------------------------------------------------------------


          Left TRIM

          LTRIM(<cString>) --> cTrimString

          <cString>      is the character  string to  copy without  leading
                         spaces.

          LTRIM() returns  a  copy of  <cString>  with the  leading  spaces
          removed.






          ##LUPDATE()##
          ----------------------------------------------------------------


          Last UPDATE

          LUPDATE() --> dModification

          LUPDATE() returns the date  of last change  to the open  database
          file in the current work area.





          ##MAX()##
          ----------------------------------------------------------------


          MAX(<nExp1>, <nExp2>) --> nLarger

          MAX(<dExp1>, <dExp2>) --> dLarger

          <nExp1>, nExp2>     are the numeric values to compare.

          <dExp1>,<dExp2>     are the date values to compare.

          MAX() returns the larger of the two arguments. The value returned
          is the same type as the arguments.






          ##MAXCOL()##
          ----------------------------------------------------------------


          MAX COLumn

          MAXCOL() --> nColumn

          MAXCOL() returns  the  column  number of  the  rightmost  visible
          column for display purposes.






          ##MAXROW()##
          ----------------------------------------------------------------


          MAXROW() --> nRow

          MAXROW() returns the row number of the bottommost visible row for
          display purposes.





          ##MEMOEDIT()##
          ----------------------------------------------------------------


          MEMOEDIT([<cString>],
               [<nTop>], [<nLeft>],
               [<nBottom>], [<nRight>],
               [<lEditMode>],
               [<cUserFunction>],
               [<nLineLength>],
               [<nTabSize>],
               [<nTextBufferRow>],
               [<nTextBufferColumn>],
               [<nWindowRow>],
               [<nWindowColumn>]) --> cTextBuffer

          <cString>                     is the  character  string  or  memo
                                        field to  copy  to  the  MEMOEDIT()
                                        text buffer.

          <nTop>, <nLeft>, <nBottom>, <nRight>
                                        are window coordinates. The default
                                        coordinates are 0, 0, MAXROW(), and
                                        MAXCOL().

          <lEditMode>                   determines whether the text  buffer
                                        can be edited or merely  displayed.
                                        If not specified, the default value
                                        is true (.T.).

          <cUserFunction>               is  the  name  of  a   user-defined
                                        function  that  executes  when  the
                                        user presses a  key not  recognized
                                        by MEMOEDIT() and when no keys  are
                                        pending in the keyboard buffer.

          <nLineLength>                 determines  the  length  of   lines
                                        displayed in the MEMOEDIT() window.
                                        If   a   line   is   greater   than
                                        <nLineLength>, it  is word  wrapped
                                        to the next line in the  MEMOEDIT()
                                        window. The default line length  is
                                        (<nRight> - <nLeft>).
          <nTabSize>                    determines  the  size   of  a   tab
                                        character to insert  when the  user
                                        presses Tab. The default is four.

          <nTextBufferRow>, <nTextBufferColumn>
                                        define the display position of  the
                                        cursor within the text buffer  when
                                        MEMOEDIT()       is        invoked.
                                        <nTextBufferRow>  begins  with  one
                                        and <nTextBufferColumn> begins with
                                        zero. Default is  the beginning  of
                                        MEMOEDIT() window.

          <nWindowRow>, <nWindowColumn> define the initial position of  the
                                        cursor   within   the    MEMOEDIT()
                                        window. Row  and  column  positions
                                        begin with zero. If these arguments
                                        are  not  specified,  the   initial
                                        window position is row zero and the
                                        current cursor column position.

          MEMOEDIT() is a user interface  and general purpose text  editing
          function that  edits  memo  fields and  long  character  strings.
          Editing occurs within a  specified window region placed  anywhere
          on the screen.
          [Uparrow]/[Ctrl]+E            Move up one line
          [Dnarrow]/[Ctrl]+X            Move down one line
          [Leftarrow]/[Ctrl]+S          Move left one character
          [Rightarrow]/[Ctrl]+D         Move right one character
          [Ctrl]-[Leftarrow]/[Ctrl]+A   Move left one word
          [Ctrl]-[Rightarrow]/[Ctrl]+F  Move right one word
          [Home]                        Move to beginning of current line
          [End]                         Move to end of current line
          [Ctrl]+[Home]                 Move to beginning
                                        of current window
          [Ctrl]+[End]                  Move to end of current window
          [PgUp]                        Move to previous edit window
          [PgDn]                        Move to next edit window
          [Ctrl]+[PgUp]                 Move to beginning of memo
          [Ctrl]+[PgDn]                 Move to end of memo
          [Return]                      Move to beginning of next line
          [Delete]                      Delete character at cursor
          [Backspace]                   Delete character to left of cursor
          [Tab]                         Insert tab character or spaces
          Printable characters          Insert character
          [Ctrl]+Y                      Delete the current line
          [Ctrl]+T                      Delete word right
          [Ctrl]+B                      Reform paragraph
          [Ctrl]+V/[Ins]                Toggle insert mode
          [Ctrl]+W                      Finish editing with save
          [Esc]                         Abort edit and return original






          ##MEMOLINE()##
          ----------------------------------------------------------------


          MEMOLINE(<cString>,
               [<nLineLength>],
               [<nLineNumber>],
               [<nTabSize>],
               [<lWrap>]) --> cLine

          <cString>           is the memo  field or  character string  from
                              which to extract a line of text.

          <nLineLength>       specifies the number  of characters per  line
                              and can  be  between  four and  254.  If  not
                              specified, the default line length is 79.
          <nLineNumber>       is  the  line  number  to  extract.  If   not
                              specified, the default value is one.

          <nTabSize>          defines the tab size.  If not specified,  the
                              default value is four.

          <lWrap>             toggles word wrap on and off. Specifying true
                              (.T.)  toggles  word  wrap  on;  false  (.F.)
                              toggles it off. If not specified, the default
                              value is true (.T.).

          MEMOLINE() returns the line of text specified by <nLineNumber> in
          <cString> as a character string. If the line has fewer characters
          than the  indicated  length,  the return  value  is  padded  with
          blanks. If the line  number is greater than  the total number  of
          lines in <cString>,  MEMOLINE() returns  a null  string ("").  If
          <lWrap> is true (.T.)  and the indicated  line length breaks  the
          line in the middle of a word,  that word is not included as  part
          of the return  value but shows  up at the  beginning of the  next
          line extracted  with  MEMOLINE().  If  <lWrap>  is  false  (.F.),
          MEMOLINE() returns only the number of characters specified by the
          line length. The  next line extracted  by MEMOLINE() begins  with
          the character following  the next hard  carriage return, and  all
          intervening characters are not processed.






          ##MEMOREAD()##
          ----------------------------------------------------------------


          MEMOREAD(<cFile>) --> cString

          <cFile>        is the name of the file to read from disk. It must
                         include an  extension if  there  is one,  and  can
                         optionally include a path.

          MEMOREAD() returns the  contents of a  text file  as a  character
          string.





          ##MEMORY()##
          ----------------------------------------------------------------


          MEMORY(<nExp>) --> nKbytes

          <nExp>    is a numeric  value that determines  the type of  value
                    MEMORY() returns.

          MEMORY() returns an integer numeric value representing the amount
          of memory available.

          MEMORY(0) -->  Estimated  total  space  available  for  character
                         values

          MEMORY(1) -->  Largest contiguous block  available for  character
                         values

          MEMORY(2) -->  Area available for RUN commands






          ##MEMOTRAN()##
          ----------------------------------------------------------------


          MEMO TRANslate

          MEMOTRAN(<cString>,
               [<cReplaceHardCR>],
               [<cReplaceSoftCR>]) --> cNewString

          <cString>           is the  character  string or  memo  field  to
                              search.

          <cReplaceHardCR>    is the character to  replace a hard  carriage
                              return/linefeed pair with. If not  specified,
                              the default value is a semicolon (;).

          <cReplaceSoftCR>    is the character to  replace a soft  carriage
                              return/linefeed pair with. If not  specified,
                              the default value is a space.
          MEMOTRAN()  returns  a  copy  of  <cString>  with  the  specified
          carriage return/linefeed pairs replaced.






          ##MEMOWRIT()##
          ----------------------------------------------------------------


          MEMO WRITe

          MEMOWRIT(<cFile>, <cString>) --> lSuccess

          <cFile>        is the name of the target disk file including  the
                         file  extension  and   optional  path  and   drive
                         designator.

          <cString>      is the character string or memo field to write  to
                         <cFile>.

          MEMOWRIT() is a memo function that  writes a character string  or
          memo field to a disk file. If a path is not specified, MEMOWRIT()
          writes <cFile> to the current DOS  directory and not the  current
          DEFAULT directory. If <cFile> already exists, it is  overwritten.
          MEMOWRIT()  returns  true  (.T.)  if  the  writing  operation  is
          successful; otherwise, it returns false (.F.).






          ##MEMVARBLOCK()##
          ----------------------------------------------------------------


          MEMVARBLOCK(<cMemvarName>) --> bMemvarBlock

          <cMemvarName>       is the name  of the variable  referred to  by
                              the set-get block,  specified as a  character
                              string.

          MEMVARBLOCK() returns  a  code  block that  when  evaluated  sets
          (assigns) or  gets  (retrieves) the  value  of the  given  memory
          variable. If <cMemvarName> does not exist, MEMVARBLOCK()  returns
          NIL.





          ##MIN()##
          ----------------------------------------------------------------


          MIN(<nExp1>, <nExp2>) --> nSmaller

          MIN(<dExp1>, <dExp2>) --> dSmaller

          <nExp1>, <nExp2>    are the numeric values to compare.

          <dExp1>, <dExp2>    are the date values to compare.

          MIN() returns  the  smaller  of  the  two  arguments.  The  value
          returned is the same data type as the arguments.






          ##MLCOUNT()##
          ----------------------------------------------------------------


          Memo Line COUNT

          MLCOUNT(<cString>, [<nLineLength>],
               [<nTabSize>], [<lWrap>]) --> nLines

          <cString>      is the character string or memo field to count.

          <nLineLength>  specifies the number  of characters  per line  and
                         can range from four to 254. If not specified,  the
                         default line length is 79.

          <nTabSize>     defines  the  tab  size.  If  not  specified,  the
                         default value is four.

          <lWrap>        toggles word  wrap  on and  off.  Specifying  true
                         (.T.) toggles word wrap on; false (.F.) toggles it
                         off. If not specified,  the default value is  true
                         (.T.).
          MLCOUNT() returns the number of  lines in <cString> depending  on
          the <nLineLength>, the <nTabSize>,  and whether word wrapping  is
          on or off.






          ##MLCTOPOS()##
          ----------------------------------------------------------------


          Memo Line Column TO POSition

          MLCTOPOS(<cText>, <nWidth>, <nLine>,
               <nCol>, [<nTabSize>], [<lWrap>]) --> nPosition

          <cText>        is the text string to scan.

          <nWidth>       is the line length formatting width.

          <nLine>        is the line number counting from 1.

          <nCol>         is the column number counting from 0.

          <nTabSize>     is the number of columns between tab stops. If not
                         specified, the default is 4.

          <lWrap>        is the  word  wrap  flag. If  not  specified,  the
                         default is true (.T.).

          MLCTOPOS() returns the byte position within <cText> counting from
          1.






          ##MLPOS()##
          ----------------------------------------------------------------


          Memo Line POSition

          MLPOS(<cString>, <nLineLength>,
               <nLine>, [<nTabSize>], [<lWrap>]) --> nPosition

          <cString>           is a character string or memo field.
          <nLineLength>       specifies the number of characters per line.

          <nLine>             specifies the line number.

          <nTabSize>          defines the tab size. The default is four.

          <lWrap>             toggles word wrap on and off. Specifying true
                              (.T.) toggles word wrap  on, and false  (.F.)
                              toggles it off. The default is true (.T.).

          MLPOS() returns the character position of <nLine> in <cString> as
          an integer numeric value. If <nLine>  is greater than the  number
          of lines in <cString>, MLPOS() returns the length of <cString>.






          ##MONTH()##
          ----------------------------------------------------------------


          MONTH(<dDate>) --> nMonth

          <dDate>        is the date value to convert.

          MONTH() returns an integer numeric value in the range of zero  to
          12. Specifying a null date (CTOD("")) returns zero.






          ##MPOSTOLC()##
          ----------------------------------------------------------------


          Memo POSition TO Line Column

          MPOSTOLC(<cText>, <nWidth>, <nPos>,
               [<nTabSize>], [<lWrap>]) --> aLineColumn

          <cText>        is a text string.

          <nWidth>       is the length of the formatted line.

          <nPos>         is the  byte position  within text  counting  from
                         one.
          <nTabSize>     is the number of columns between tab stops. If not
                         specified, the default is four.

          <lWrap>        is the  word  wrap  flag. If  not  specified,  the
                         default is true (.T.).

          MPOSTOLC() returns an  array containing the  line and the  column
          values for the specified byte  position, <nPos>. MPOSTOLC() is  a
          memo function  that  determines  the formatted  line  and  column
          corresponding to a particular byte position within <cText>.  Note
          that the line number returned is one-relative, the column  number
          is zero-relative. This is  compatible with MEMOEDIT(). <nPos>  is
          one-relative, compatible  with  AT(),  RAT(),  and  other  string
          functions.






          ##NETERR()##
          ----------------------------------------------------------------


          NRT ERRor

          NETERR([<lNewError>]) --> lError

          <lNewError>    if specified sets the  value returned by  NETERR()
                         to the specified status. <lNewError> can be either
                         true (.T.) or false  (.F.). Setting NETERR() to  a
                         specified value allows  the runtime error  handler
                         to  control  the  way  certain  file  errors   are
                         handled.

          NETERR() returns true (.T.) if a  USE or APPEND BLANK fails.  The
          initial value of NETERR() is false (.F.). If the current  process
          is not running under a network operating system, NETERR()  always
          returns false (.F.).





          ##NETNAME()##
          ----------------------------------------------------------------


          NETNAME() --> cWorkstationName

          NETNAME() returns the workstation  identification as a  character
          string  up  to  15  characters  in  length.  If  the  workstation
          identification was never set or the application is not  operating
          under the IBM PC Network, it returns a null string ("").






          ##NEXTKEY()##
          ----------------------------------------------------------------


          NEXTKEY() --> nInkeyCode

          NEXTKEY() returns an  integer numeric value  ranging from -39  to
          386. If the keyboard buffer is empty, NEXTKEY() returns zero.  If
          SET TYPEAHEAD is zero,  NEXTKEY() always returns zero.  NEXTKEY()
          is like  the INKEY()  function, but  differs in  one  fundamental
          respect. INKEY() removes the pending key from the keyboard buffer
          and updates LASTKEY() with  the value of  the key. NEXTKEY(),  by
          contrast, reads, but does  not remove the  key from the  keyboard
          buffer and does not update LASTKEY().

          See also:      <inkey()>





          ##NOSNOW()##
          ----------------------------------------------------------------


          NOSNOW(<lToggle>) --> NIL

          <lToggle>      is a logical value that toggles the current  state
                         of snow suppression. A value of true (.T.) enables
                         the snow suppression  on, while a  value of  false
                         (.F.) disables snow suppression.

          NOSNOW() is used to suppress snow on CGA monitors.






          ##ORDBAGEXT()##
          ----------------------------------------------------------------


          ORDBAGEXT() --> cBagExt

          ORDBAGEXT() returns a  character expression that  is the  default
          Order  Bag  extension  of  the  current  work  area.  cBagExt  is
          determined by the RDD active in the current work area.






          ##ORDBAGNAME()##
          ----------------------------------------------------------------


          ORDBAGNAME(<nOrder> | <cOrderName>) --> cOrderBagName

          <nOrder>       is an integer that identifies the position in  the
                         Order List  of the  target Order  whose Order  Bag
                         name is sought.

          <cOrderName>   is a character string that represents the name  of
                         the target Order whose Order Bag name is sought.
          ORDBAGNAME() returns a  character string, the  Order Bag name  of
          the specific Order.






          ##ORDCREATE()##
          ----------------------------------------------------------------


          ORDCREATE(<cOrderBagName>,[<cOrderName>], <cExpKey>, [<bExpKey>],
               [<lUnique>]) --> NIL

          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.

          <cOrderName>        is the name of the Order to be created.

          <cExpKey>           is an expression that  returns the key  value
                              to place in the Order for each record in  the
                              current work area. The maximum length of  the
                              index key  expression  is determined  by  the
                              database driver.

          <bExpKey>           is a code block that evaluates to a key value
                              that is placed in  the Order for each  record
                              in the current work area.

          <lUnique>           specifies whether  a unique  Order is  to  be
                              created.  Default  is   the  current   global
                              _SET_UNIQUE setting.

          ORDCREATE() is an Order management function that creates an Order
          in the current  work area. It  works like DBCREATEINDEX()  except
          that  it  lets   you  create  Orders   in  RDDs  that   recognize
          multiple-Order Bags.





          ##ORDDESTROY()##
          ----------------------------------------------------------------


          ORDDESTROY(<cOrderName> [, <cOrderBagName> ]) --> NIL

          <cOrderName>        is the name of the  Order to be removed  from
                              the current or specified work area.

          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.

          ORDDESTROY() is  an  Order  management function  that  removes  a
          specified Order  from multiple-Order  Bags. ORDDESTROY()  is  not
          supported for DBFNDX and DBFNTX.






          ##ORDFOR()##
          ----------------------------------------------------------------


          ORDFOR(<cOrderName> | <nOrder> [, <cOrderBagName>]) --> cForExp

          <cOrderName>        is  the  name  of  the  target  Order,  whose
                              cForExp is sought.

          <nOrder>            is an integer that identifies the position in
                              the Order  List  of the  target  Order  whose
                              cForExp is sought.

          <cOrderBagName>     is the name of an Order Bag containing one or
                              more Orders.

          ORDFOR() returns a character expression, cForExp, that represents
          the FOR condition of  the specified Order. If  the Order was  not
          created using the FOR  clause the return value  will be an  empty
          string ("").  If the  database driver  does not  support the  FOR
          condition, it may either return an empty string ("") or raise  an
          "unsupported function" error, depending on the driver.





          ##ORDKEY()##
          ----------------------------------------------------------------


          ORDKEY(<cOrderName> | <nOrder> [, <cOrderBagName>]) --> cExpKey

          <cOrderName>        is the name of  an Order, a logical  ordering
                              of a database.

          <nOrder>            is an integer that identifies the position in
                              the Order  List  of the  target  Order  whose
                              cExpKey is sought.

          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.

          ORDKEY() is an Order management function that returns a character
          expression, cExpKey, that  represents the key  expression of  the
          specified Order.






          ##ORDLISTADD()##
          ----------------------------------------------------------------


          ORDLISTADD(<cOrderBagName> [, <cOrderName>]) --> NIL

          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.

          <cOrderName>        the name of the specific Order from the Order
                              Bag to  be added  to the  Order List  of  the
                              current work  area.  If you  do  not  specify
                              <cOrderName>, all orders in the Order Bag are
                              added to the Order  List of the current  work
                              area.
          ORDLISTADD() is  an  Order  management  function  that  adds  the
          contents of an Order Bag , or a single Order in an Order Bag,  to
          the Order List. Any Orders already associated with the work  area
          continue to be active. If the newly opened Order Bag contains the
          only  Order  associated  with  the  work  area,  it  becomes  the
          controlling  Order;  otherwise,  the  controlling  Order  remains
          unchanged.






          ##ORDLISTCLEAR()##
          ----------------------------------------------------------------


          ORDLISTCLEAR() --> NIL

          ORDLISTCLEAR() is an Order  management function that removes  all
          Orders from the Order List for the current work area.






          ##ORDLISTREBUILD()##
          ----------------------------------------------------------------


          ORDLISTREBUILD() --> NIL

          ORDLISTREBUILD() is an  Order management  function that  rebuilds
          all the orders in the current Order List.






          ##ORDNAME()##
          ----------------------------------------------------------------


          ORDNAME(<nOrder>[,<cOrderBagName>]) --> cOrderName

          <nOrder>            is an integer that identifies the position in
                              the Order  List  of the  target  Order  whose
                              database name is sought.
          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.

          ORDNAME() returns the name of the specified Order in the  current
          Order List or the  specified Order Bag if  opened in the  Current
          Order list.






          ##ORDNUMBER()##
          ----------------------------------------------------------------


          ORDNUMBER(<cOrderName> [, <cOrderBagName>]) --> nOrderNo

          <cOrderName>        the name of the specific Order whose position
                              in the Order List is sought.

          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.

          ORDNUMBER() returns  nOrderNo,  an integer  that  represents  the
          position of the specified Order in the Order List.






          ##ORDSETFOCUS()##
          ----------------------------------------------------------------


          ORDSETFOCUS([<cOrderName> | <nOrder>] [,<cOrderBagName>])
               --> cPrevOrderNameInFocus

          <cOrderName>        is the name of the selected Order, a  logical
                              ordering of a database.

          <nOrder>            is a number representing the position in  the
                              Order List of the selected Order.

          <cOrderBagName>     is the name of a disk file containing one  or
                              more Orders.
          ORDSETFOCUS() is an  Order management function  that returns  the
          Order Name of the previous controlling Order and optionally  sets
          the focus to an new Order.






          ##OS()##
          ----------------------------------------------------------------


          OS() --> cOsName

          OS() returns the operating system name as a character string.






          ##OUTERR()##
          ----------------------------------------------------------------


          OUTput ERRor

          OUTERR(<exp list>) --> NIL

          <exp list>     is a list of values to display and can consist  of
                         any combination of data types including memo.

          OUTERR() is identical to  OUTSTD() except that  it writes to  the
          standard error  device rather  than the  standard output  device.
          Output sent to the standard error device bypasses the console and
          output devices as well  as any DOS  redirection. It is  typically
          used to log error  messages in a manner  that will not  interfere
          with the standard screen or printer output.





          ##OUTSTD()##
          ----------------------------------------------------------------


          OUTput STanDard

          OUTSTD(<exp list>) --> NIL

          <exp list>     is a list of values to display and can consist  of
                         any combination of data types including memo.

          OUTSTD() is a  simple output function  similar to QOUT(),  except
          that it writes to  the STDOUT device (instead  of to the  console
          output stream).






          ##PAD?()##
          ----------------------------------------------------------------





          PADL(<exp>, <nLength>, [<cFillChar>]) --> cPaddedString
          PADC(<exp>, <nLength>, [<cFillChar>]) --> cPaddedString
          PADR(<exp>, <nLength>, [<cFillChar>]) --> cPaddedString

          <exp>          is a character, numeric, or date value to pad with
                         a fill character.

          <nLength>      is the length of the character string to return.

          <cFillChar>    is  the  character  to  pad  <exp>  with.  If  not
                         specified, the default is a space character.

          PADC(), PADL(),  and  PADR()  are character  functions  that  pad
          character, date,  and numeric  values with  a fill  character  to
          create a  new  character string  of  a specified  length.  PADC()
          centers <exp> within <nLength> adding fill characters to the left
          and right sides; PADL()  adds fill characters  on the left  side;
          and PADR() adds fill characters on the right side.





          ##PCOL()##
          ----------------------------------------------------------------


          Printed COLumn

          PCOL() --> nColumn

          PCOL() returns  an integer  numeric value  representing the  last
          printed column position, plus one. The beginning column  position
          is zero.






          ##PROW()##
          ----------------------------------------------------------------


          Printed ROW

          PROW() --> nRow

          PROW() returns  an  integer  numeric value  that  represents  the
          number of the current line sent to the printer. The beginning row
          position is zero.





          ##QOUT()##
          ----------------------------------------------------------------


          QOUT([<exp list>]) --> NIL

          QQOUT([<exp list>]) --> NIL

          <exp list>     is a comma-separated list  of expressions (of  any
                         data type other than array or block) to display to
                         the console.  If  no  argument  is  specified  and
                         QOUT() is  specified, a  carriage  return/linefeed
                         pair is displayed. If QQOUT() is specified without
                         arguments, nothing displays.

          QOUT() and  QQOUT()  are  console  functions.  They  display  the
          results of one or more expressions to the console. QOUT() outputs
          carriage return  and linefeed  characters before  displaying  the
          results of <exp list>. QQOUT() displays the results of <exp list>
          at the current ROW() and COL() position. When QOUT() and  QQOUT()
          display to the console, ROW() and COL() are updated.






          ##RAT()##
          ----------------------------------------------------------------


          Right AT

          RAT(<cSearch>, <cTarget>) --> nPosition

          <cSearch>      is the character string to locate.

          <cTarget>      is the character string to search.

          RAT() returns the  position of <cSearch>  within <cTarget> as  an
          integer numeric value,  starting the  search from  the right.  If
          <cSearch> is not found, RAT() returns zero.





          ##RDDLIST()##
          ----------------------------------------------------------------


          RDDLIST([<nRDDType>]) --> aRDDList

          <nRDDType>     is an integer that represents the type of the  RDD
                         you wish to list.
                         <nRDDType> = 1   Full RDD implementation
                         <nRDDType> = 2   Import/Export only driver.

          RDDLIST() returns  a  one-dimensional  array  of  the  RDD  names
          registered with the application as <nRDDType>.






          ##RDDNAME()##
          ----------------------------------------------------------------


          RDDNAME() --> cRDDName

          RDDNAME() returns a  character string,  cRDDName, the  registered
          name of the active RDD in the current or specified work area.






          ##RDDSETDEFAULT()##
          ----------------------------------------------------------------


          RDDSETDEFAULT([<cNewDefaultRDD>]) --> cPreviousDefaultRDD

          <cNewDefaultRDD>    is a character  string, the name  of the  RDD
                              that is to be made the new default RDD in the
                              application.
          RDDSETDEFAULT() is an RDD function that sets or returns the  name
          of the  previous default  RDD driver  and, optionally,  sets  the
          current driver to the new RDD driver specified by cNewDefaultRDD.






          ##READEXIT()##
          ----------------------------------------------------------------


          READEXIT([<lToggle>]) --> lCurrentState

          <lToggle>      toggles the  use of  Uparrow and  Dnarrow as  READ
                         exit keys. Specifying true  (.T.) enables them  as
                         exit keys, and false (.F.) disables them.

          READEXIT() returns the current setting as a logical value.






          ##READINSERT()##
          ----------------------------------------------------------------


          READINSERT([<lToggle>]) --> lCurrentMode

          <lToggle>      toggles the  insert mode  on  or off.  True  (.T.)
                         turns insert on,  while false  (.F.) turns  insert
                         off. The  default  is  false  (.F.)  or  the  last
                         user-selected mode in READ or MEMOEDIT().

          READINSERT() returns the current insert  mode state as a  logical
          value.





          ##READMODAL()##
          ----------------------------------------------------------------


          READMODAL(<aGetList>) --> NIL

          <aGetList>     is an array  containing a list  of Get objects  to
                         edit.

          READMODAL() is like the READ command,  but takes a GetList  array
          as an argument and does not  reinitialize the GetList array  when
          it terminates. The GET system is implemented using a public array
          called GetList. Each time an @...GET command executes, it creates
          a Get object and adds to the currently visible GetList array. The
          standard READ command is preprocessed into a call to  READMODAL()
          using the GetList array as its argument.






          ##READVAR()##
          ----------------------------------------------------------------


          READVAR() --> cVarName

          READVAR() returns the  name of the  variable associated with  the
          current Get object or the variable being assigned by the  current
          MENU TO command as an uppercase character string.





          ##RECNO()##
          ----------------------------------------------------------------


          RECord Number

          RECNO() --> nRecord

          RECNO() returns the current record  number as an integer  numeric
          value. If  the  work area  contains  a database  file  with  zero
          records, RECNO() returns  one, BOF() and  EOF() both return  true
          (.T.), and LASTREC() returns zero. If the record pointer is moved
          past the last  record, RECNO() returns  LASTREC() +  1 and  EOF()
          returns true (.T.).  If an  attempt is  made to  move before  the
          first record,  RECNO() returns  the record  number of  the  first
          logical record in the database file and BOF() returns true (.T.).
          If no database file is open, RECNO() will return a zero.






          ##RECSIZE()##
          ----------------------------------------------------------------


          RECord SIZE

          RECSIZE() --> nBytes

          RECSIZE() returns,  as a  numeric value,  the record  length,  in
          bytes, of  the  database file  open  in the  current  work  area.
          RECSIZE() returns zero if no database file is open.





          ##REPLICATE()##
          ----------------------------------------------------------------


          REPLICATE(<cString>, <nCount>) --> cRepeatedString

          <cString>      is the character string to repeat.

          <nCount>       is the number of times to repeat <cString>.

          REPLICATE() returns a character string. Specifying a zero as  the
          <nCount> argument returns a null string ("").






          ##RESTSCREEN()##
          ----------------------------------------------------------------


          RESTore SCREEN

          RESTSCREEN([<nTop>], [<nLeft>],
               [<nBottom>], [<nRight>], <cScreen>) --> NIL

          <nTop>, <nLeft>, <nBottom>, <nRight>
                                        define  the   coordinates  of   the
                                        screen  information  contained   in
                                        <cScreen>.  If  the  <cScreen>  was
                                        saved   without   coordinates    to
                                        preserve  the  entire  screen,   no
                                        screen  coordinates  are  necessary
                                        with RESTSCREEN().

          <cScreen>                     is a  character  string  containing
                                        the saved screen region.

          RESTSCREEN() is a screen function that redisplays a screen region
          saved with SAVESCREEN().  The target screen  location may be  the
          same as or different than the  original location when the  screen
          region was saved.





          ##RIGHT()##
          ----------------------------------------------------------------


          RIGHT(<cString>, <nCount>) --> cSubString

          <cString>      is the  character  string from  which  to  extract
                         characters.

          <nCount>       is the number of characters to extract.

          RIGHT() returns the rightmost  <nCount> characters of  <cString>.
          If <nCount>  is zero,  RIGHT() returns  a  null string  ("").  If
          <nCount> is negative or larger than  the length of the  character
          string, RIGHT() returns <cString>.






          ##RLOCK()##
          ----------------------------------------------------------------


          Record LOCK

          RLOCK() --> lSuccess

          RLOCK() is  a network  function that  locks the  current  record,
          preventing other users from updating the record until the lock is
          released. RLOCK() provides  a shared lock,  allowing other  users
          read-only access to  the locked  record while  allowing only  the
          current user to modify  it. A record  lock remains until  another
          record is locked,  an UNLOCK  is executed,  the current  database
          file is  closed,  or an  FLOCK()  is  obtained   on  the  current
          database file.





          ##ROUND()##
          ----------------------------------------------------------------


          ROUND(<nNumber>, <nDecimals>) --> nRounded

          <nNumber>      is the numeric value to round.

          <nDecimals>    defines the number  of decimal  places to  retain.
                         Specifying a  negative  <nDecimals>  value  rounds
                         whole number digits.

          ROUND() is a numeric function that rounds <nNumber> to the number
          of places specified by <nDecimals>. Specifying a zero or negative
          value  for  <nDecimals>  allows  rounding  of  whole  numbers.  A
          negative <nDecimals> indicates the number  of digits to the  left
          of the  decimal point  to round.  Digits  between five  to  nine,
          inclusive, are rounded up. Digits below five are rounded down.






          ##ROW()##
          ----------------------------------------------------------------


          ROW() --> nRow

          ROW() returns  the  cursor row  position  as an  integer  numeric
          value. The range of the return value is zero to MAXROW().





          ##RTRIM()##
          ----------------------------------------------------------------


          Right TRIM

          [R]TRIM(<cString>) --> cTrimString

          <cString>      is the character string  to copy without  trailing
                         spaces.

          RTRIM() returns  a copy  of <cString>  with the  trailing  spaces
          removed. If  <cString>  is a  null  string ("")  or  all  spaces,
          RTRIM() returns a null string ("").






          ##SAVESCREEN()##
          ----------------------------------------------------------------


          SAVESCREEN([<nTop>], [<nLeft>],
               [<nBottom>], [<nRight>]) --> cScreen

          <nTop>, <nLeft>, <nBottom>, <nRight>
                                        define  the   coordinates  of   the
                                        screen region to  save. Default  is
                                        the entire screen.

          SAVESCREEN() returns the specified  screen region as a  character
          string.





          ##SCROLL()##
          ----------------------------------------------------------------


          SCROLL([<nTop>], [<nLeft>],
               [<nBottom>], [<nRight>], [<nVert>] [<nHoriz>]) --> NIL

          <nTop>, <nLeft>, <nBottom>, <nRight>
                              define the scroll region coordinates.

          <nVert>             defines  the  number   of  rows  to   scroll,
                              vertically. A positive  value scrolls up  the
                              specified number  of rows.  A negative  value
                              scrolls down the specified number of rows.  A
                              value of zero disables vertical scrolling. If
                              <nVert> is not specified, zero is assumed.

          <nHoriz>            defines  the   number  of   rows  to   scroll
                              horizontally. A positive  value scrolls  left
                              the specified number  of columns. A  negative
                              value scrolls right  the specified number  of
                              columns. A value of zero disables  horizontal
                              scrolling. If <nHoriz> is not specified, zero
                              is assumed. If you supply neither <nVert>  or
                              <nHoriz> parameters  to  SCROLL(),  the  area
                              specified by the  first four parameters  will
                              be blanked.

          SCROLL() is a screen function that scrolls a screen region up  or
          down a specified number  of rows. When a  screen scrolls up,  the
          first line of the region is erased, all other lines are moved up,
          and a blank line  is displayed in the  current standard color  on
          the bottom line of  the specified region.  If the region  scrolls
          down, the operation is reversed. If the screen region is scrolled
          more than one line, this process is repeated.





          ##SECONDS()##
          ----------------------------------------------------------------


          SECONDS() --> nSeconds

          SECONDS() returns the system time as a numeric value in the  form
          seconds.hundredths. The numeric value  returned is the number  of
          seconds elapsed since  midnight, and  is based  on a  twenty-four
          hour clock in a range from zero to 86399.






          ##SELECT()##
          ----------------------------------------------------------------


          SELECT([<cAlias>]) --> nWorkArea

          <cAlias>       is the target work area alias name.

          SELECT() returns  the  work area  of  the specified  alias  as  a
          integer numeric value.






          ##SET()##
          ----------------------------------------------------------------


          SET(<nSpecifier>, [<expNewSetting>], [<lOpenMode>])
               --> CurrentSetting

          <nSpecifier>        is  a  numeric  value  that  identifies   the
                              setting to be inspected or changed.

          <expNewSetting>     is an optional argument that specifies a  new
                              value  for  the  <nSpecifier>.  The  type  of
                              <expNewSetting> depends on <nSpecifier>.
          <lOpenMode>         is a logical value that indicates whether  or
                              not files  are opened  for some  settings.  A
                              value of false (.F.) means the file should be
                              truncated. A value  of true  (.T.) means  the
                              file should  be  opened in  append  mode.  In
                              either case, if the  file does not exist,  it
                              is  created.   If   this  argument   is   not
                              specified, the default is append mode.

          SET() returns the current value of the specified setting.






          ##SETBLINK()##
          ----------------------------------------------------------------


          SETBLINK([<lToggle>]) --> lCurrentSetting

          <lToggle>      changes the meaning of the asterisk (*)  character
                         when it  is encountered  in a  SETCOLOR()  string.
                         Specifying true (.T.)  sets character blinking  on
                         and false  (.F.)  sets background  intensity.  The
                         default is true (.T.).

          SETBLINK() returns the current setting as a logical value.






          ##SETCANCEL()##
          ----------------------------------------------------------------


          SETCANCEL([<lToggle>]) --> lCurrentSetting

          <lToggle>      changes the availability  of Alt-C and  Ctrl-Break
                         as termination keys. Specifying true (.T.)  allows
                         either of these keys  to terminate an  application
                         and false (.F.) disables both keys. The default is
                         true (.T.).

          SETCANCEL() returns the current setting as a logical value.





          ##SETCOLOR()##
          ----------------------------------------------------------------


          SETCOLOR([<cColorString>]) --> cColorString

          <cColorString>      is a character  string containing  a list  of
                              color  attribute   settings  for   subsequent
                              screen painting.






          ##SETCURSOR()##
          ----------------------------------------------------------------


          SETCURSOR([<nCursorShape>]) --> nCurrentSetting

          <nCursorShape>      is a  number  indicating  the  shape  of  the
                              cursor.
                              <nCursorShape> = 0  None
                              <nCursorShape> = 1  Underline
                              <nCursorShape> = 2  Lower half block
                              <nCursorShape> = 3  Full block
                              <nCursorShape> = 4  Upper half block

          SETCURSOR() returns the current cursor shape as a numeric value.






          ##SETKEY()##
          ----------------------------------------------------------------


          SETKEY(<nInkeyCode>, [<bAction>]) --> bCurrentAction

          <nInkeyCode>   is the INKEY() value of  the key to be  associated
                         or queried.
          <bAction>      specifies  a  code  block  that  is  automatically
                         executed whenever  the  specified key  is  pressed
                         during a wait state.

          SETKEY() returns the action  block currently associated with  the
          specified key,  or NIL  if the  specified  key is  not  currently
          associated with a block.






          ##SETMODE()##
          ----------------------------------------------------------------


          SETMODE(<nRows>, <nCols>) --> lSuccess

          <nRows>        is the number of rows in the desired display mode.

          <nCols>        is the number  of columns in  the desired  display
                         mode.

          SETMODE() is an environment function that attempts to change  the
          mode of the  display hardware  to match  the number  of rows  and
          columns specified. The change in screen size is reflected in  the
          values returned by MAXROW() and MAXCOL().






          ##SETPOS()##
          ----------------------------------------------------------------


          SET POSition

          SETPOS(<nRow>, <nCol>) --> NIL

          <nRow>, <nCol>      define the new screen position of the cursor.
                              These values may range from 0, 0 to MAXROW(),
                              MAXCOL().

          SETPOS() is an environment  function that moves  the cursor to  a
          new position on the screen. After the cursor is positioned, ROW()
          and COL() are updated accordingly.





          ##SETPRC()##
          ----------------------------------------------------------------


          SET Printer Row Column

          SETPRC(<nRow>, <nCol>) --> NIL

          <nRow>         is the new PROW() value.

          <nCol>         is the new PCOL() value.

          SETPRC()  is a printer function that  sends control codes to  the
          printer without changing the tracking of the printhead position.






          ##SOUNDEX()##
          ----------------------------------------------------------------


          SOUNDEX(<cString>) --> cSoundexString

          <cString>      is the character string to convert.

          SOUNDEX() returns a four-digit character string in the form A999.






          ##SPACE()##
          ----------------------------------------------------------------


          SPACE(<nCount>) --> cSpaces

          <nCount>       is the number of spaces to return.

          SPACE() returns a character string. If <nCount> is zero,  SPACE()
          returns a null string ("").





          ##SQRT()##
          ----------------------------------------------------------------


          SQRT(<nNumber>) --> nRoot

          <nNumber>      is a positive number to take the square root of.

          SQRT() returns a  numeric value calculated  to double  precision.
          The number of  decimal places displayed  is determined solely  by
          SET DECIMALS  regardless  of  SET  FIXED.  A  negative  <nNumber>
          returns zero.






          ##STR()##
          ----------------------------------------------------------------


          STRing

          STR(<nNumber>, [<nLength>], [<nDecimals>]) --> cNumber

          <nNumber>      is  the  numeric  expression   to  convert  to   a
                         character string.

          <nLength>      is the length of  the character string to  return,
                         including decimal digits, decimal point, and sign.

          <nDecimals>    is the number of decimal places to return.

          STR() returns <nNumber> formatted as a character string.





          ##STRTRAN()##
          ----------------------------------------------------------------


          STRTRAN(<cString>, <cSearch>,
               [<cReplace>], [<nStart>], [<nCount>]) --> cNewString

          <cString>      is the character string or memo field to search.

          <cSearch>      is the sequence of characters to locate.

          <cReplace>     is  the  sequence  of  characters  with  which  to
                         replace  <cSearch>.  If   this  argument  is   not
                         specified, the specified  instances of the  search
                         argument are replaced with a null string ("").

          <nStart>       is the first occurrence that will be replaced.  If
                         this argument is omitted, the default is one.

          <nCount>       is the number of  occurrences to replace. If  this
                         argument is not specified, the default is all.

          STRTRAN() returns  a  new  character string  with  the  specified
          instances of <cSearch> replaced with <cReplace>.






          ##STUFF()##
          ----------------------------------------------------------------


          STUFF(<cString>, <nStart>,
               <nDelete>, <cInsert>) --> cNewString

          <cString>      is  the   target  character   string  into   which
                         characters are inserted and deleted.

          <nStart>       is the  starting  position in  the  target  string
                         where the insertion/deletion occurs.

          <nDelete>      is the number of characters to delete.
          <cInsert>      is the string to insert.

          STUFF() returns a copy of <cString> with the specified characters
          deleted and with <cInsert> inserted.






          ##SUBSTR()##
          ----------------------------------------------------------------


          SUB STRing

          SUBSTR(<cString>, <nStart>, [<nCount>]) --> cSubstring

          <cString>      is the character  string from which  to extract  a
                         substring.

          <nStart>       is the starting position in <cString>. If <nStart>
                         is  positive,  it  is  relative  to  the  leftmost
                         character in <cString>.  If <nStart> is  negative,
                         it is relative to  the rightmost character in  the
                         <cString>.

          <nCount>       is  the  number  of  characters  to  extract.   If
                         omitted, the  substring  begins  at  <nStart>  and
                         continues to the end of the string. If <nCount> is
                         greater  than  the   number  of  characters   from
                         <nStart> to  the end  of <cString>,  the extra  is
                         ignored.

          SUBSTR() is a character function  that extracts a substring  from
          another character string or memo field.





          ##TIME()##
          ----------------------------------------------------------------


          TIME() --> cTimeString

          TIME() returns the system time as a character string in the  form
          hh:mm:ss. hh is hours in 24-hour format, mm is minutes, and ss is
          seconds.

          TIME() is a time  function that displays the  system time on  the
          screen or prints it on a report.






          ##TONE()##
          ----------------------------------------------------------------


          TONE(<nFrequency>, <nDuration>) --> NIL

          <nFrequency>   is  a  positive   numeric  value  indicating   the
                         frequency of the tone to sound.

          <nDuration>    is  a  positive   numeric  value  indicating   the
                         duration of  the tone  measured in  increments  of
                         1/18 of  a  second. For  example,  an  <nDuration>
                         value of 18 represents one second.

          For both arguments, noninteger values are truncated (not rounded)
          to their integer portion.





          ##TRANSFORM()##
          ----------------------------------------------------------------


          TRANSFORM(<exp>, <cSayPicture>) --> cFormatString

          <exp>          is the value to format. This expression can be any
                         valid data type except array, code block, and NIL.

          <cSayPicture>  is a  string of  picture and  template  characters
                         that  describes   the  format   of  the   returned
                         character string.

          TRANSFORM() converts  <exp> to  a formatted  character string  as
          defined by <cSayPicture>.






          ##TYPE()##
          ----------------------------------------------------------------


          TYPE(<cExp>) --> cType

          <cExp>         is a  character expression  whose  type is  to  be
                         determined. <cExp> can be a field, with or without
                         the alias,  a private  or public  variable, or  an
                         expression of any type.

          TYPE() returns one of the following characters:
               A    Array
               B    Block
               C    Character
               D    Date
               L    Logical
               M    Memo
               N    Numeric
               O    Object
               U    NIL, local, or static
               UE   Error syntactical
               UI   Error indeterminate
          TYPE() is  a  system  function  that  returns  the  type  of  the
          specified expression. TYPE() is like VALTYPE() but uses the macro
          operator (&) to determine the type of the argument. VALTYPE(), by
          contrast, evaluates an expression and determines the data type of
          the return value.






          ##UPDATED()##
          ----------------------------------------------------------------


          UPDATED() --> lChange

          UPDATED() returns  true  (.T.) if  data  in  a GET  is  added  or
          changed; otherwise, it returns false (.F.).






          ##UPPER()##
          ----------------------------------------------------------------


          UPPER(<cString>) --> cUpperString

          <cString>      is the character string to convert.

          UPPER()  returns  a  copy  of  <cString>  with  all  alphabetical
          characters converted to  uppercase. All  other characters  remain
          the same as in the original string.






          ##USED()##
          ----------------------------------------------------------------


          USED() --> lDbfOpen

          USED() returns true (.T.) if there  is a database file in USE  in
          the current work area; otherwise, it returns false (.F.).





          ##VAL()##
          ----------------------------------------------------------------


          VALue

          VAL(<cNumber>) --> nNumber

          <cNumber>      is the character expression to convert.

          VAL()  is  a  character  conversion  function  that  converts   a
          character string containing  numeric digits to  a numeric  value.
          When VAL() is  executed, it  evaluates <cNumber>  until a  second
          decimal point, the first non-numeric character, or the end of the
          expression is encountered.






          ##VALTYPE()##
          ----------------------------------------------------------------


          VALue TYPE

          VALTYPE(<exp>) --> cType

          <exp>          is an expression of any type.

          VALTYPE() returns a single  character representing the data  type
          returned  by  <exp>.  VALTYPE()  returns  one  of  the  following
          characters:
               A    Array
               B    Block
               C    Character
               D    Date
               L    Logical
               M    Memo
               N    Numeric
               O    Object
               U    NIL
          VALTYPE() is  a system  function that  takes a  single  argument,
          evaluates it, and returns a  one character string describing  the
          data type of the return value.






          ##YEAR()##
          ----------------------------------------------------------------


          YEAR(<dDate>) --> nYear

          <dDate>   is the date value to convert.

          YEAR() returns the year of the specified date value including the
          century digits as a four-digit numeric value. The value  returned
          is not affected by the current DATE or CENTURY format. Specifying
          a null date (CTOD("")) returns zero.






          ##nB FUNCTIONS##
          ================================================================


          Some functions made into nB are available for macro use. Not  all
          available functions are here documented.






          ##ACCEPT()##
          ----------------------------------------------------------------


          ACCEPT( <Field>, [<cMessage>], [<cHeader>] ) --> updatedField|NIL

          It is  a prompt  function that  shows <cMessage>  asking to  type
          something into <Field>.  It returns the  updated data  or NIL  if
          [Esc] was pressed. The string <cHeader> is showed centered at the
          top window.





          ##BCOMPILE()##
          ----------------------------------------------------------------


          BCOMPILE( <cString> ) --> bBlock

          Compiles the string <cString> and returns the code block <bBlock>






          ##DBCLOSE()##
          ----------------------------------------------------------------


          DBCLOSE() --> NIL

          It is  a  substitution function  of  DBCLOSEALL() to  use  inside
          "compiled" macros, as  a true DBCLOSEALL()  will close the  macro
          file too.






          ##DIR()##
          ----------------------------------------------------------------


          DIR( [<cFileSpec>], [<lDrives>], [<lDirs>], [<lFiles>],
               [<cBottomMessage>], [<nSortColumn>] ) --> cPathname

          <cFileSpec>         the   filename   or   Pathname,   also   with
                              wildcards, to be searched.

          <lDrives>           true (.t.) means: include drives letters.

          <lDirs>             true (.t.) means: include directory names.

          <lFiles>            true (.t.) means: include file names.
          <lNoRirReturn>      true (.t.)  means: do  not return  the  shown
                              directory if [Esc] is used to exit.

          <nSortColumn>       the column number  to use to  sort the  list.
                              The columns are:
                                   Name = 1,
                                   Size = 2,
                                   Date = 3,
                                   Time = 4,
                                   Attribute = 5.
                              It is not possible to sort for extention.

          It is a window function usefull to search a file or a  directory.
          The complete pathname of the selected file is returned.






          ##DOC()##
          ----------------------------------------------------------------


          DOC( [<cTextFileName> ) --> NIL

          <cTextFileName>     can contain the text  file to open and  edit;
                              if empty,  the editing  of UNTITLED.TXT  will
                              start.

          It is the nB Text editor usefull for small text files (less  then
          64K) and contains a complete menu that can be started with [F10].

               ATTENTION: doc() should not be used inside macros.






          ##DOTLINE()##
          ----------------------------------------------------------------


          dotLine( [<cColorTop>], [<cColorBody>] ) --> NIL

          <cColorTop>         The  color  to  use  for  window  header  and
                              footer.
          <cColorBody>        The  color  to  use  for  the  body  of   the
                              calculator.

          This function is  a "dot" command  line usefull for  calculations
          resolution. The dot-line  content may be  passed to the  keyboard
          buffer.






          ##DTEMONTH()##
          ----------------------------------------------------------------


          dteMonth( <nMonth>, <cLanguage> ) --> cMonth

          <nMonth>            the month number.

          <cLanguage>         the language name.

          This function translates the <nMonth> number into the month  name
          translated using the <cLanguage> language.






          ##DTEWEEK()##
          ----------------------------------------------------------------


          DTEWEEK( <nWeek>, <cLanguage> ) --> cWeek

          <nWeek>             is  the  week  number  (1  is  sunday,  7  is
                              saturday) to be translated into text.

          <cLanguage>         is the  language name  into whitch  the  week
                              must be  expressed. At  the moment  it  works
                              only for  italian,  so <cLanguage>  can  only
                              contain "ITALIANO".

          This function  translates  the week  number  into the  week  name
          translated using the <cLanguage> language.





          ##EX()##
          ----------------------------------------------------------------


          EX( <cFileMacro> ) --> nExitCode

          Executes the  macro  file  <cFileName>.  The  extention  must  be
          specified.






          ##HTF()##
          ----------------------------------------------------------------


          HTF( [<nInitialRecord>] ) --> NIL

          <nInitialRecord>              is the record number where to start
                                        the Help Text File browse.  Default
                                        is the actual record pointer.

          This function browse a Help Text File that must be already opened
          and be the active Alias.






          ##ISFILE()##
          ----------------------------------------------------------------


          ISFILE( <cName> ) --> lFileExists

          <cName>                       is the file  name (with or  without
                                        path) to be checked for existance.

          This function returns true (.T.) if the file <cName> exists.  The
          difference between this function and the standard FILE() function
          is that ISFILE() checks for wildcards before. If <cName> contains
          wildcards, the result is false (.F.).





          ##ISWILD()##
          ----------------------------------------------------------------


          ISWILD( <cName> ) --> lIsWild

          <cName>                       is the file  name (with or  without
                                        path) to be  checked for  wildcards
                                        presence.

          This function returns true (.T.) if <cName> contains wildcards.






          ##ISMEMVAR()##
          ----------------------------------------------------------------


          ISMEMVAR( <cName> ) --> lIsMemvar

          <cName>                       is the name of a possible memvar.

          This function returns  true (.T.) if  the <cName>  is a  declared
          Memvar.






          ##ISCONSOLEON()##
          ----------------------------------------------------------------


          ISCONSOLEON() --> lConsoleIsOn

          This function returns  true (.T.) if  the console  will show  the
          result of QOUT() and QQOUT().





          ##ISPRINTERON()##
          ----------------------------------------------------------------


          ISPRINTERON() --> lPrinterIsOn

          This function  returns true  (.T.) if  the default  printer  will
          report the the result of QOUT() and QQOUT().

          The default  printer is  PRN  or LPT1.  If  SET ALTERNATE  TO  is
          configured to  send  outputs  to LPT2  or  another  printer,  the
          function will report false (.F.).






          ##LISTWINDOW()##
          ----------------------------------------------------------------


          listWindow( <acMenuItem>, [<cDescription>],
               [<nTop>], [<nLeft>], [<nBottom>], [<nRight>],
               [<cColorTop>], [<cColorBody>] ) --> nPosition

          <acMenuItem>        is the character array containing the list of
                              choices.

          <cDescription>      is the header to be shown at the top window.

           <nTop>, <nLeft>, <nBottom>, <nRight>   are      the       window
                              coordinates.

          <cColorTop>         is the  color to  use for  window header  and
                              footer.

          <cColorBody>        is the color to use for the window body  that
                              is the space where the text appears.

          This function is an similar to  achoice(), but it shows a  header
          and footer, and it saves the screen, acting like a window.





          ##MEMOWINDOW()##
          ----------------------------------------------------------------


          memoWindow( <cVar>, [<cDescription>], [<nTop>], [<nLeft>],
               [<nBottom>], [<nRight>], [<cColorTop>], [<cColorBody>],
               [<lEditMode>], [<nLineLength>], [<nTabSize>] ) --> cVar

          <cVar>              is  the  character  field  (variable)  to  be
                              edited.

          <cDescription>      is the header to be shown at the top window.

          <nTop>, <nLeft>, <nBottom>, <nRight>    are      the       window
                              coordinates.

          <cColorTop>         is the  color to  use for  window header  and
                              footer.

          <cColorBody>        is the color to use for the window body  that
                              is the space where the text appears.

          <lEditMode>         is equivalent to memoedit().

          <nLineLenght>       is equivalent to memoedit().

          <nTabSize>          is equivalent to memoedit().

          This function lets you easyly edit a long character field  (memo)
          defining automatically  a simple  window and  providing a  simple
          help.





          ##RF()##
          ----------------------------------------------------------------


          RF( <cFRMName>,
               [<bForCondition>], [<bWhileCondition>],
               [<nNext>], [<nRecord>], [<lRest>], [<lPlain>],
               [<cbHeading>], [<lBeforeEject>], [<lSummary>],
               [<lDate>], [<acExtra>] ) --> NIL

          <cFRMName>          the form  (.FRM) file  to  use to  print  the
                              active Alias.

          <bForCondition>     code block for the FOR condition.

          <bWhileCondition>   code block for the WHILE condition.

          <nNext>             see REPORT FORM.

          <nRecord>           see REPORT FORM

          <lRest>             see REPORT FORM

          <lPlain>            if true (.T.),  force the print  in a  simple
                              way.

          <cbHeading>         additional header in character or code  block
                              form. If  a code  block  is sent,  the  final
                              result must be a character string.

          <lBeforeEject>      if true (.T.), force  a form feed before  the
                              print.

          <lSummary>          if true (.T.), force a summary print only.

          <lDate>             if false (.F.), force the print without  date
                              at the top of page.
          <acExtra>           a  character  array  that  may  be  used  for
                              translating  standard  printed  report   form
                              words and  to  add  vertical  and  horizontal
                              separations. The  default  value  of  acExtra
                              is:
                              acExtra[1]     "Page No."
                              acExtra[2]     "** Subtotal **"
                              acExtra[3]     "* Subsubtotal *"
                              acExtra[4]     "*** Total ***"
                              acExtra[5]     " "   vertical column
                                                   separation
                              axExtra[6]     ""    horizontal
                                                   separation: no
                                                   separation.

          This function does the same work  of REPORT FORM or  __ReportForm
          or dbReportForm, but it prints where qout() and qqout() print.






          ##RPT()##
          ----------------------------------------------------------------


          RPT( <cText> ) --> NIL

          This function prints the text contained into <cText> using  print
          commands.  This  function  accepts  other  parameters  here   not
          described, as they  are not  to be  used for  macro purpose.  The
          printing is  made  using  QOUT() and  QQOUT(),  this  way  it  is
          sensible to the "alternate" file definition.






          ##RPTMANY()##
          ----------------------------------------------------------------


          RPTMANY( <cText>, [<bWhileCondition>], [<bForCondition>] )
               --> NIL

          This function prints the text contained into <cText> many  times:
          one for every record contained into the active Alias.
          <cText>             is the text to be printed.

          <bWhileCondition>   is a  code block  for  a WHILE  condition  to
                              respect for the records to print.

          <bForCondition>     is a  code  block  for  a  FOR  condition  to
                              respect for the records to print.






          ##RPTTRANSLATE()##
          ----------------------------------------------------------------


          RPTTRANSLATE( <cText> ) --> cTranslatedText

          This function translates  once <cText>  replacing variables  with
          memvars or Fields.






          ##SETRPTEJECT()##
          ----------------------------------------------------------------


          SETRPTEJECT( [<lbEject>] ) --> lPreviousEjectMode

          This function is  used to  set the  eject mode  after every  page
          print  for  RPT().   If  single   sheet  paper   is  used,   then
          SETRPTEJECT(.T.)   must   be    set;   for   continuous    paper,
          SETRPTEJECT(.F.) is correct. The default value is .F..

          <lbEject>           logical or codeblock,  is the  eject mode  to
                              set. Default is no change, the starting value
                              is .F.





          ##SETOUTPUT()##
          ----------------------------------------------------------------


          SETOUTPUT( [<cPeriperal>|<aPeripheral>] )
               --> aPrevious_Output_Peripherals

          <cPeripheral>       is the new output  peripheral for qout()  and
                              qqout() functions.

          <aPeripheral>       are the new output peripherals configurations
                              for qout() and qqout() functions.

          nB is organised in the way to have only one output peripheral  at
          the time. This function  help to make  order inside SET  CONSOLE,
          SET PRINTER and SET ALTERNATE.

          If <cPeripheral> contains:

          "CON"               SET CONSOLE is set to ON,
                              SET PRINTER is set to OFF,
                              SET ALTERNATE is set to OFF;

          "PRN"               SET CONSOLE is set to OFF,
                              SET PRINTER is set to ON,
                              SET ALTERNATE is set to OFF;

          "LPT1"              same as "PRN"

          otherwise           SET CONSOLE is set to OFF,
                              SET PRINTER is set to OFF,
                              SET ALTERNATE is set to ON,
                              SET ALTERNATE TO is set to <cPeripheral>.

          <aPeripheral> is organised this way:

          aPeripheral[1] = _SET_CONSOLE

          aPeripheral[2] = _SET_PRINTER

          aPeripheral[3] = _SET_ALTERNATE

          aPeripheral[4] = _SET_ALTFILE

          aPeripheral[5] = _SET_EXTRA
          aPeripheral[6] = _SET_EXTRAFILE

          This function  is necessary  becase SET  ALTERNATE alone  is  not
          enough to print on the screen  when the peripheral name is  "CON"
          or to print on the printer  when the peripheral name is "PRN"  or
          "LPT1". In fact, in the first  case, ROW() and COL() will not  be
          updated, in  the  second case,  PROW()  and PCOL()  will  not  be
          updated.

          This function  returns an  array organised  in  the same  way  as
          <aPeripheral> is, that shows the active output configuration.






          ##STRADDEXTENTION()##
          ----------------------------------------------------------------


          STRADDEXTENTION( <cName>, <cExt> ) --> cCompleteName

          <cName>        the file  name  (with  or without  path)  that  is
                         probably without extention.

          <cExt>         the extention that must be added to <cName> if  it
                         has not one.

          This function check <cName> for the presence of an extention.  It
          it has not one, <cExt> will be added.






          ##STRCUTEXTENTION()##
          ----------------------------------------------------------------


          STRCUTEXTENTION( <cName> ) --> cName

          <cName>        the file  name  (with  or without  path)  that  is
                         probably with extention.

          This function check <cName> for the presence of an extention.  It
          it has one, the extention is removed.





          ##STRDRIVE()##
          ----------------------------------------------------------------


          STRDRIVE( <cName> ) --> cDrive

          <cName>        the file name (with or without path) that contains
                         the drive letter.

          This function tries to extract the drive letter information  from
          <cName>.






          ##STREXTENTION()##
          ----------------------------------------------------------------


          STREXTENTION( <cName> ) --> cExtention

          <cName>        the file name (with or without path) that contains
                         an extention.

          This function  tries to  extract the  extention information  from
          <cName>.






          ##STRFILE()##
          ----------------------------------------------------------------


          STRFILE( <cName> ) --> cFileName

          <cName>        the file name with or without path.

          This function tries to  extract the file  name without path  from
          <cName>.





          ##STROCCURS()##
          ----------------------------------------------------------------


          STROCCURS( <cSearch>, <cTarget> ) --> nOccurrence

          <cSearch>      the search string to find inside <cTarget>.

          <cTarget>      the string  to be  searched  for the  presence  of
                         <cSearch>.

          This function returns the number of occurrence that <cSearch>  is
          contained inside <cTarget>.






          ##STRPARENT()##
          ----------------------------------------------------------------


          STRPARENT( <cName> ) --> cParentPath

          <cName>        the pathname.

          This function tries to return a parent path from <cName>.






          ##STRPATH()##
          ----------------------------------------------------------------


          STRPATH( <cName> ) --> cPath

          <cName>        the pathname.

          This function tries to extract the path from <cName>.





          ##STRTEMPPATH()##
          ----------------------------------------------------------------


          STRTEMPPATH() --> cTempPath

          This function  returns a  temporary path  searching for  possible
          definitions inside the environmental variables.






          ##STRXTOSTRING()##
          ----------------------------------------------------------------


          STRXTOSTRING( <xVar>, [<cType>] ) --> cTrasformed_to_string

          <xVar>         is the  data  of any  type  to be  converted  into
                         string.

          <cType>        is the type of the data contained inside <xVar>.

          This function returns <xVar> transformed into a character string.





          ##TB()##
          ----------------------------------------------------------------


          TB( [<nTop>], [<nLeft>], [<nBottom>], [<nRight>],
               [<acCol>], [<acColSayPic>],
               [<acColHead>], [<acColFoot>],
               [<alColCalc>], [<abColValid>], [<abColMsg>],
               [<nFreeze>],
               [<lModify>], [<lAppend>],
               [<lDelete>], [<lAutosort>] ) --> NIL

          <nTop>, <nLeft>, <nBottom>, <nRight>
                                        defines  the   screen  area   where
                                        browse have to take place.

          <acCol>                       is the columns array to be included
                                        into the browse.

          <acColSayPic>                 is the picture array.

          <acColHead>                   is  the  header  array  for   every
                                        column.

          <acColFoot>                   is  the  footer  array  for   every
                                        column.

          <alColCalc>                   is  the  array  that  identify  the
                                        calculated column  (not  editable).
                                        True (.T.) means calculated.

          <abColValid>                  is  the   validation   array   that
                                        specify when  a field  is  properly
                                        filled.  The   condition  must   be
                                        specifyed in code block format.

          <abColMsg>                    is the message  array that  permits
                                        to show information  at the  bottom
                                        of browse area.  The array must  be
                                        composed with  code  blocks  whitch
                                        result with a character string.

          <nFreeze>                     indicates the number of columens to
                                        be left frozen on the left side.
          <lModify>                     indicates whether  the  browse  can
                                        modify data.

          <lDelete>                     indicates whether  the  browse  can
                                        delete and recall records.

          <lAutosort>                   indicates whether  the browse  have
                                        to be automatically  sorted, if  an
                                        index   is    opened,   when    key
                                        modifications are made.

          This function, called  without parameters, starts  the browse  of
          the active Alias,  and if relations  are established, the  browse
          includes also related data.






          ##TEXT()##
          ----------------------------------------------------------------


          TEXT( <cText> ) --> NIL

          Shows the text contained into <cText>.






          ##WAITFILEEVAL()##
          ----------------------------------------------------------------


          WAITFILEEVAL( <lClose> ) --> .T.

          Shows a wait bar calling WAITPROGRESS() for operation on  records
          of a database.

          If  there   is   no   index   active,   it   is   equivalent   to
          WAITPROGRES(RECNO()/LASTREC()).

          if an index is active, this cannot work, so an increment for each
          call is made: WAITPROGRES((nIncrement++)/LASTREC()).
          This function  must  be  closed  calling  it  with  the  <lClose>
          parameter to true (.T.). This  way, internal counters are  closed
          and WAITPROGRESS() is closed too.






          ##WAITFOR()##
          ----------------------------------------------------------------


          WAITFOR( [<cMessage>] ) --> NIL

          Shows <cMessage> until  it is called  again. The  wait window  is
          closed when called without parameter or with NIL.






          ##WAITPROGRESS()##
          ----------------------------------------------------------------


          WAITPROGRESS( [<nPercent>] ) --> .T.

          Shows a  wait  bar on  the  screen  top depending  on  the  value
          contained into <nPercent>. <nPercent> starts form 0 and ends to 1
          (100%). If a value  of one or  more, or NIL  is passed, the  wait
          window is closed.






          ##NORMAL COMMAND SUBSTITUTION##
          ================================================================


          CA-Clipper works only with  functions and commands are  converted
          into fuction using  the STD.CH. Here  are described some  command
          replacement that can be used also with nB macroes.





          ##?##
          ----------------------------------------------------------------


          ? [<exp list>]

          qout([<exp list>])




          ?? [<exp list>]

          qqout([<exp list>])






          ##@BOX##
          ----------------------------------------------------------------


          @ <nTop>, <nLeft>, <nBottom>, <nRight> BOX <cnBoxString>
               [COLOR <cColorString>]

          dispbox(<nTop>, <nLeft>, <nBottom>, <nRight>,
               [<cnBoxString>], [<cColorString>])






          ##@TO##
          ----------------------------------------------------------------


          @ <nTop>, <nLeft> TO <nBottom>, <nRight>
               DOUBLE
               [COLOR <cColorString>]

          dispbox(<nTop>, <nLeft>, <nBottom>, <nRight>,
               2 [,<cColorString>])



          @ <nTop>, <nLeft> TO <nBottom>, <nRight>
               [COLOR <cColorString>]

          dispbox(<nTop>, <nLeft>, <nBottom>, <nRight>,
               1 [,<cColorString>])




          @ <nTop>, <nLeft>
               [CLEAR [TO <nBottom>, <nRight>]]

          scroll([<nTop>], [<nLeft>],
               [<nBottom>, <nRight>])
               setpos(<nRow>], <nCol>)






          ##@GET##
          ----------------------------------------------------------------


          @ <nTop>, <nLeft> GET <Var>
               [PICTURE <cGetPicture>]
               [COLOR <cColorString>]
               [WHEN <lPreExpression>]
               [VALID <lPostExpression>]

          setpos(<nTop>, <nLeft>)
               aadd( GetList, _GET_( <Var>, "<Var>", <cGetPicture>,
                    [{|| <lPostExpression>}],
                    [{|| <lPreExpression>}] ):display() )
               atail(GetList):colorDisp(<cColorString>)






          ##@SAY##
          ----------------------------------------------------------------
          @ <nTop>, <nLeft> SAY <exp>
               [COLOR <cColorString>]

          devpos(<nTop>, <nLeft>)

          devout(<exp> [, <cColorString>])




          @ <nTop>, <nLeft> SAY <exp>
               PICTURE <cSayPicture>
               [COLOR <cColorString>]

          devpos(<nTop>, <nLeft>)

          devoutpic(<exp>, <cSayPicture>, [<cColorString>])






          ##APPEND##
          ----------------------------------------------------------------


          APPEND BLANK

          dbappend()






          ##CLEAR##
          ----------------------------------------------------------------


          CLEAR GETS

          ReadKill(.T.)

          GetList := {}




          CLEAR SCREEN | CLS
          Scroll()

          SetPos(0,0)




          CLEAR

          Scroll()

          SetPos(0,0)

          ReadKill(.T.)

          GetList := {}






          ##CLOSE##
          ----------------------------------------------------------------


          CLOSE

          dbCloseArea()




          CLOSE <idAlias>

          <idAlias>->( dbCloseArea() )




          CLOSE ALTERNATE

          Set(19, "")



          CLOSE DATABASES

          dbCloseAll()




          CLOSE INDEXES

          dbClearIndex()






          ##COMMIT##
          ----------------------------------------------------------------


          COMMIT

          dbCommitAll()





          ##COUNT##
          ----------------------------------------------------------------


          COUNT TO <idVar>
               [FOR <lForCondition>]
               [WHILE <lWhileCondition>]
               [NEXT <nNextRecords>]
               [RECORD <nRecord>]
               [REST]
               [ALL]

          dbeval( {|| <idVar> := <idVar> +1 },
               {|| <lForCondition> },
               {|| <lWhileCondition> },
               <nNextRecords>, <nRecord>, <lRest> )






          ##DELETE##
          ----------------------------------------------------------------


          DELETE

          dbDelete()



          DELETE
               [FOR <lForCondition>]
               [WHILE <lWhileCondition>]
               [NEXT <nNextRecords>]
               [RECORD <nRecord>]
               [REST]
               [ALL]

          dbeval( {|| dbDelete()},
               {|| <lForCondition> },
               {|| <lWhileCondition> },
               <nNextRecords>, <nRecord>, <lRest> )




          DELETE FILE <xcFile>

          ferase( <cFile> )






          ##EJECT##
          ----------------------------------------------------------------


          EJECT

          qqout( chr(13) )






          ##ERASE##
          ----------------------------------------------------------------


          ERASE <xcFile>

          ferase( <cFile> )





          ##FIND##
          ----------------------------------------------------------------


          FIND <xcSearchString>

          dbSeek( <cSearchString> )






          ##GO##
          ----------------------------------------------------------------


          GO[TO] <nRecord>

          dbgoto(nRecord)




          GO[TO] BOTTOM

          dbGoBottom()




          GO[TO] TOP

          dbgotop()





          ##INDEX ON##
          ----------------------------------------------------------------


          INDEX ON <expKey> TO <xcIndexName> [UNIQUE]
               [FOR <lForCondition>]
               [WHILE <lWhileCondition>]
               [[EVAL <lEvalCondition>] [EVERY <nRecords>]]
               [ASCENDING|DESCENDING]

          ordCondSet( [<cForCondition>],
               [<bForCondition>],, [<bWhileCondition>],
               [<bEvalCondition>], [<nRecords>],
               RECNO(),,,, <lDescending> )

          ordCreate( <cIndexName>,, <cExpKey>, <bExpKey>, <lUnique> )






          ##READ##
          ----------------------------------------------------------------


          READ

          ReadModal(GetList)

          GetList := {}




          READ SAVE

          ReadModal(GetList)





          ##RECALL##
          ----------------------------------------------------------------


          RECALL

          dbRecall()



          RECALL
               [FOR <lForCondition>]
               [WHILE <lWhileCondition>]
               [NEXT <nNextRecords>]
               [RECORD <nRecord>]
               [REST]
               [ALL]

          dbeval( {|| dbRecall()},
               {|| <lForCondition> },
               {|| <lWhileCondition> },
               <nNextRecords>, <nRecord>, <lRest> )






          ##REINDEX##
          ----------------------------------------------------------------


          REINDEX
               [EVAL <lEvalCondition>]
               [EVERY <nRecords>]

          ordCondSet(,,,, [<bEvalCondition>], [<nRecords>],,,,,,,)

          ordListRebuild()






          ##RENAME##
          ----------------------------------------------------------------


          RENAME <xcOldFile> TO <xcNewFile>

          frename( <cOldFile>, <cNewFile> )





          ##REPLACE##
          ----------------------------------------------------------------


          REPLACE <idField1> WITH <exp1>
               [, <idField2> WITH <exp2>...]
               [FOR <lForCondition>]
               [WHILE <lWhileCondition>]
               [NEXT <nNextRecords>]
               [RECORD <nRecord>]
               [REST]
               [ALL]

          dbeval( {|| <idField1> := <exp1>
               [, <idField2> := <exp2>...]},
               {|| <lForCondition> },
               {|| <lWhileCondition> },
               <nNextRecords>, <nRecord>, <lRest> )




          REPLACE <idField1> WITH <exp1>

          <idField1> := <exp1>






          ##RESTORE##
          ----------------------------------------------------------------


          RESTORE SCREEN FROM <cScreen>

          restscreen( 0, 0, Maxrow(), Maxcol(), <cScreen> )





          ##SAVE##
          ----------------------------------------------------------------


          SAVE SCREEN TO <cScreen>

          <cScreen> := savescreen( 0, 0, maxrow(), maxcol() )






          ##SEEK##
          ----------------------------------------------------------------


          SEEK <expSearch> [SOFTSEEK]

          dbSeek( <expSearch> [, <lSoftSeek>] )






          ##SELECT##
          ----------------------------------------------------------------


          SELECT <xnWorkArea> | <idAlias>

          dbSelectArea( <nWorkArea> | <cIdAlias> )






          ##SET##
          ----------------------------------------------------------------


          SET ALTERNATE TO <xcFile> [ADDITIVE]
          Set( 19, <cFile>, lAdditive )




          SET ALTERNATE ON | OFF | <xlToggle>

          Set( 18, "ON" | "OFF" | <lToggle> )




          SET BELL  ON | OFF | <xlToggle>

          Set( 26, "ON" | "OFF" | <lToggle> )




          SET COLOR | COLOUR TO (cColorString)

          SetColor( cColorString )




          SET CONFIRM ON | OFF | <xlToggle>

          Set( 27, "ON" | "OFF" | <lToggle> )




          SET CONSOLE ON | OFF | <xlToggle>

          Set( 17, "ON" | "OFF" | <lToggle> )




          SET CURSOR ON | OFF | <xlToggle>

          SetCursor( 1 | 0 | iif( <lToggle>, 1, 0 ) )




          SET DATE FORMAT [TO] <cDateFormat>

          Set( 4, <cDateFormat> )



          SET DECIMALS TO

          Set( 3, 0 )




          SET DECIMALS TO <nDecimals>

          Set( 3, <nDecimals> )




          SET DEFAULT TO

          Set( 7, "" )




          SET DEFAULT TO <xcPathspec>

          Set( 7, <cPathspec> )




          SET DELETED ON | OFF | <xlToggle>

          Set( 11, "ON" | "OFF" | <lToggle> )




          SET DELIMITERS ON | OFF | <xlToggle>

          Set( 33, "ON" | "OFF" | <lToggle> )




          SET DELIMITERS TO [DEFAULT]

          Set( 34, "::" )



          SET DELIMITERS TO <cDelimiters>

          Set( 34, <cDelimiters> )




          SET DEVICE TO SCREEN | PRINTER

          Set( 20, "SCREEN" | "PRINTER" )




          SET EPOCH TO <nYear>

          Set( 5, <nYear> )




          SET ESCAPE ON | OFF | <xlToggle>

          Set( 28, "ON" | "OFF" | <lToggle> )




          SET EXACT ON | OFF | <xlToggle>

          Set( 1, "ON" | "OFF" | <lToggle> )




          SET EXCLUSIVE ON | OFF | <xlToggle>

          Set( 8, "ON" | "OFF" | <lToggle> )




          SET FILTER TO

          dbclearfilter()



          SET FILTER TO <lCondition>

          dbsetfilter( <bCondition>, <cCondition> )




          SET FIXED ON | OFF | <xlToggle>

          Set( 2, "ON" | "OFF" | <lToggle> )




          SET INDEX TO [<xcIndex> [, <xcIndex1>... ] ]

          ordListClear()

          ordListAdd( cIndex )

          ordListAdd( cIndex1 )

          ...




          SET INTENSITY ON | OFF | xlToggle

          Set( 31, "ON" | "OFF" | lToggle )




          SET KEY <nInkeyCode> [TO]

          SetKey( <nInkeyCode>, NIL )




          SET KEY <nInkeyCode> TO [<idProcedure>]

          SetKey( <nInkeyCode>, { |p, l, v| idProcedure(p, l, v)} )



          SET MARGIN TO

          Set( 25, 0 )




          SET MARGIN TO [<nPageOffset>]

          Set( 25, <nPageOffset> )




          SET MESSAGE TO

          Set( 36, 0 )

          Set( 37, .F. )




          SET MESSAGE TO [<nRow> [CENTER | CENTRE]]

          Set( 36, nRow )

          Set( 37, lCenter )




          SET ORDER TO [<nIndex>]

          ordSetFocus( <nIndex> )




          SET PATH TO

          Set( 6, "" )



          SET PATH TO [<xcPathspec> [, <cPathspec1>... ] ]

          Set( 6, <cPathspec> [, <cPathspec1>... ] )




          SET PRINTER ON | OFF | xlToggle

          Set( 23, "ON" | "OFF" | lToggle )




          SET PRINTER TO

          Set( 24, "" )




          SET PRINTER TO [<xcDevice>|<xcFile> [ADDITIVE]]

          Set( 24, <cDevice>|<cFile>, lAdditive )




          SET RELATION TO

          dbclearrelation()




          SET RELATION TO [<expKey1> INTO <xcAlias1>]
               [, [TO] <expKey2> INTO <xcAlias2>...]
               [ADDITIVE]

          if !lAdditive
               dbClearRel()
          end

          dbSetRelation( <cAlias1>, <{|| expKey1}, ["<expKey1>"] )

          dbSetRelation( <cAlias2>, <{|| expKey2}, ["<expKey1>"] )



          SET SCOREBOARD ON | OFF | xlToggle

          Set( 32, "ON" | "OFF" | lToggle )




          SET SOFTSEEK ON | OFF | xlToggle

          Set( 9, "ON" | "OFF" | lToggle )




          SET TYPEAHEAD TO <nKeyboardSise>

          Set( 14, <nKeyboardSise> )




          SET UNIQUE ON | OFF | xlToggle

          Set( 10, "ON" | "OFF" | lToggle )




          SET WRAP ON | OFF | xlToggle

          Set( 35, "ON" | "OFF" | lToggle )






          ##SKIP##
          ----------------------------------------------------------------


          SKIP [<nRecords> [ALIAS <idAlias>|<nWorkArea>]

          [<idAlias>|<nWorkArea> -> ]( dbSkip([<nRecords>]) )





          ##STORE##
          ----------------------------------------------------------------


          STORE <value> TO <variable>

          <variable> := <value>






          ##SUM##
          ----------------------------------------------------------------


          SUM <nExp1> [, <nExp2>...]
               TO <idVar1> [, <idVar2>...]
               [FOR <lForCondition>]
               [WHILE <lWhileCondition>]
               [NEXT <nNextRecords>]
               [RECORD <nRecord>]
               [REST]
               [ALL]

          dbeval( {|| <idVar1> := <idVar1> + <nExp1>
               [, <idVar2> := <idVar2> + <nExp2>...] },
               {|| <lForCondition> },
               {|| <lWhileCondition> },
               <nNextRecords>, <nRecord>, <lRest> )






          ##UNLOCK##
          ----------------------------------------------------------------


          UNLOCK

          dbUnlock()



          UNLOCK ALL

          dbUnlockAll()






          ##USE##
          ----------------------------------------------------------------


          USE

          dbclosearea()



          USE [<xcDatabase>
               [INDEX <xcIndex1> [, <xcIndex2>...]
               [ALIAS <xcAlias>]
               [EXCLUSIVE|SHARED]
               [NEW] [READONLY]
               [VIA <cDriver>]]

          dbUseArea( [<lNewArea>], [<cDriver>],
               <cDatabase>, [<cAlias>],
               [<lShared>], [<lReadOnly>] )

          [dbSetIndex( <cIndex1> )]

          [dbSetIndex( <cIndex2> )]

          ...






          ##nB COMMAND SUBSTITUTION FUNCTIONS##
          ================================================================


          Inside nB there are many functions  made only in substitution  to
          other CA-Clipper commands.





          ##GET##
          ----------------------------------------------------------------


          @ <nTop>, <nLeft> GET <Var>
               [PICTURE <cGetPicture>]
               [COLOR <cColorString>]
               [WHEN <lPreExpression>]
               [VALID <lPostExpression>]

          Get( <nTop>, <nLeft>, <cVarName>,
               [<cGetPicture>], [<cColorString>],
               [<bPreExpression>], [<bValid>] )






          ##SAY##
          ----------------------------------------------------------------


          @ <nTop>, <nLeft> SAY <exp>
               PICTURE <cSayPicture>
               [COLOR <cColorString>]

          Say( <nTop>, <nLeft>, <cVar>, [<cSayPicture>], [<cColorString>] )






          ##APPEND FROM##
          ----------------------------------------------------------------


          APPEND FROM <xcFile>
               [FIELDS <idField list>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               [VIA <xcDriver>]
          dbApp( <cFileName>, [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>],
               [<nRecord>],
               [<lRest>],
               [<cDriver>] )




          APPEND FROM <xcFile>
               [FIELDS <idField list>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               DELIMITED <xcDelimiter>

          dbDelim( .f., <cFileName>, [<cDelimiter>], [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>] )




          APPEND FROM <xcFile>
               [FIELDS <idField list>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               SDF

          dbSDF( .f., <cFileName>, [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>] )






          ##CONTINUE##
          ----------------------------------------------------------------


          CONTINUE

          dbContinue()





          ##COPY##
          ----------------------------------------------------------------


          COPY FILE <xcSourceFile> TO <xcTargetFile>|<xcDevice>

          CopyFile( <cSourceFile>, <cTargetFile>|<cDevice> )




          COPY STRUCTURE [FIELDS <idField list>]
               TO <xcDatabase>

          dbCopyStruct( <cDatabase>, [<acFields>] )




          COPY STRUCTURE EXTENDED
               TO <xcExtendedDatabase>

          dbCopyXStruct( <cExtendedDatabase> )



          COPY TO <xcFile>
               [FIELDS <idField list>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               [VIA <xcDriver>]

          dbCopy( <cFileName>, [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>],
               [<nRecord>],
               [<lRest>],
               [<cDriver>] )




          COPY TO <xcFile>
               [FIELDS <idField list>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               DELIMITED <xcDelimiter>

          dbDelim( .t., <cFileName>, [<cDelimiter>], [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>] )




          COPY TO <xcFile>
               [FIELDS <idField list>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               SDF

          dbSDF( .t., <cFileName>, [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>] )





          ##CREATE##
          ----------------------------------------------------------------


          CREATE <xcDatabase>
               FROM <xcExtendedDatabase>
               [NEW]
               [ALIAS <cAlias>]
               [VIA <cDriver>]

          dbOldCreate( <cDatabase>, <cExtendedDatabase>,
               [<cDriver>], [<lNew>], [<cAlias>] )






          ##JOIN##
          ----------------------------------------------------------------


          JOIN WITH <xcAlias> TO <xcDatabase>
               [FOR <lCondition>] [FIELDS <idField list>]

          dbJoin( <cAlias>, <cDatabase>,
               [<acFields>], [<bForCondition>] )






          ##KEYBOARD##
          ----------------------------------------------------------------


          KEYBOARD <cString>

          Keyboard( [<cString>] )





          ##LABEL FORM##
          ----------------------------------------------------------------


          LABEL FORM <xcLabel>
               [TO PRINTER]
               [TO FILE <xcFile>]
               [NOCONSOLE]
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               [SAMPLE]

          dbLabelForm( <cLabel>, [<lToPrinter>], [<cFile>],
               [<lNoConsole>], [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>], [<lSample>] )






          ##LIST##
          ----------------------------------------------------------------


          LIST <exp list>
               [TO PRINTER]
               [TO FILE <xcFile>]
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               [OFF]

          dbList( [<lToDisplay>], <abListColumns>,
               [<lAll>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>],
               [<lToPrinter>], [<cFileName>] )





          ##LOCATE##
          ----------------------------------------------------------------


          LOCATE [<scope>] FOR <lCondition>
               [WHILE <lCondition>

          dbLocate( [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>] )






          ##PACK##
          ----------------------------------------------------------------


          PACK

          dbPack()






          ##PUBLIC##
          ----------------------------------------------------------------


          PUBLIC <idMemvar>

          MemPublic( <cMemvarName>|<acMemvarNames> )





          ##QUIT##
          ----------------------------------------------------------------


          QUIT

          Quit()






          ##RELEASE##
          ----------------------------------------------------------------


          RELEASE <idMemvar>

          MemRelease( <cMemvarName>|<acMemvarNames> )





          ##REPORT FORM##
          ----------------------------------------------------------------


          REPORT FORM <xcReport>
               [TO PRINTER]
               [TO FILE <xcFile>]
               [NOCONSOLE]
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]
               [PLAIN | HEADING <cHeading>]
               [NOEJECT] [SUMMARY]

          dbReportForm( <cForm>, [<lToPrinter>], [<cFile>],
               [<lNoConsole>], [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>],
               [<lPlain>], [<cHeading>], [<lNoEject>], [<lSummary>] )






          ##RESTORE##
          ----------------------------------------------------------------


          RESTORE FROM <xcMemFile> [ADDITIVE]

          MemRestore( <cMemFileName>, [<lAdditive> )






          ##RUN##
          ----------------------------------------------------------------


          RUN <xcCommandLine>

          Run( <cCommand> )





          ##SAVE TO##
          ----------------------------------------------------------------


          SAVE TO <xcMemFile>
               [ALL [LIKE|EXCEPT <skeleton>]]

          MemSave( <cMemFileName>, [<cSkeleton>], [<lLike>] )






          ##SET FUNCTION##
          ----------------------------------------------------------------


          SET FUNCTION <nFunctionKey> TO <cString>

          SetFunction( <nFunctionKey>, <cString> )





          ##SORT##
          ----------------------------------------------------------------


          SORT TO <xcDatabase>
               ON <idField1> [/[A|D][C]]
               [, <idField2> [/[A|D][C]] ...]
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]

          dbSort( <cDatabase>, [<acFields>],
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest>] )






          ##TOTAL##
          ----------------------------------------------------------------


          TOTAL ON <expKey>
               [FIELDS <idField list>] TO <xcDatabase>
               [<scope>]
               [WHILE <lCondition>]
               [FOR <lCondition>]

          dbTotal( <cDatabase>, <bKey>, [<acFields>,
               [<bForCondition>], [<bWhileCondition>],
               [<nNextRecords>], [<nRecord>], [<lRest> )






          ##UPDATE##
          ----------------------------------------------------------------
          UPDATE FROM <xcAlias>
               ON <expKey> [RANDOM]
               REPLACE <idField1> WITH <exp>
               [, <idField2> WITH <exp> ...]

          dbUpdate( <cAlias>, <bKey>, [<lRandom>], [<bReplacement>] )

          Example:
               dbUpdate( "INVOICE", {|| LAST}, .T.,;
                    {|| FIELD->TOTAL1 := INVOICE->SUM1,;
                    FIELD->TOTAL2 := INVOICE->SUM2 } )






          ##ZAP##
          ----------------------------------------------------------------


          ZAP

          dbZap()






          ##RPT - THE nB PRINT FUNCTION##
          ================================================================


          The function RPT() helps to print ASCII file containing  Memvars,
          Fields and print  commands. RPT()  is accessible  from the  DOC()
          menu.






          ##RPT - MEMVARS AND FIELDS##
          ----------------------------------------------------------------


          As usual  with standard  word processors,  variables are  written
          delimited with "<" (Alt+174) and ">" (Alt+175).
          Inside  these  delimiters  can  find  place  character   Memvars,
          character Fields and functions giving a character result.

          The RPT()  function  generates  a public  variable  n_Lines  that
          contains the available lines inside the actual sheet. Every  time
          a line is  written, this value  is reduced, until  a new page  is
          reached and then it will start  again from the maximum value.  It
          is usefull  to read  this variable  to  determinate if  there  is
          enough space or it is better to change page.






          ##RPT - COMMANDS##
          ================================================================


          The function RPT() recognise some print commands. These  commands
          starts with the  asterisk (*) simbol.  This means that  "*" is  a
          print command prefix.

          It follows the command sintax.






          ##*COMMAND##
          ----------------------------------------------------------------


          *COMMAND
               <cStatement>
               <cStatement>
               .........
          *END

          The lines contained inside *COMMAND - *END are executed with the
          nB macro interpreter.





          ##*DBSKIP##
          ----------------------------------------------------------------


          *DBSKIP [<nSkip>]

          It Executes a dbskip() on the active Alias.






          ##*FOOT##
          ----------------------------------------------------------------


          *FOOT
               <cFooter>
               <cFooter>
               ......
          *END

          The lines contained inside *FOOT - *END are printed each time  at
          the bottom of pages.






          ##*HEAD##
          ----------------------------------------------------------------


          *HEAD
               <cHeader>
               <cHeader>
               ......
          *END

          The lines contained inside *HEAD - *END are printed each time at
          the top of pages.





          ##*IF##
          ----------------------------------------------------------------


          *IF <lCondition>
               ........
               ........
          *END

          If the condition <lCondition> is true, the lines contained inside
          *IF - *END are printed.






          ##*INSERT##
          ----------------------------------------------------------------


          *INSERT <cFileName>

          Includes the text contained into the file <cFileName>.






          ##*LEFT##
          ----------------------------------------------------------------


          *LEFT <nLeftBorder>

          The <nLeftBorder> is the number of  column to be left blank as  a
          left border.





          ##*LPP##
          ----------------------------------------------------------------


          *LPP <nLinesPerPage>

          It  determinates  the  page  length  expressed  in  lines.  After
          printing the <nLinesPerPage>th line, a form feed is sent.






          ##*NEED##
          ----------------------------------------------------------------


          *NEED <nLinesNeeded>

          If the available lines are less then <nLinesNeeded>, the follwing
          text will be printed on the next page.






          ##*PA##
          ----------------------------------------------------------------


          *PA

          Jumps to a new page.





          ##*REM##
          ----------------------------------------------------------------


          *REM | *COMMENT [<comment_line>]

          It adds a comment that will not be printed.






          ##*WHILE##
          ----------------------------------------------------------------


          *WHILE <lCondition>
               ......
               ......
          *END

          The lines contained inside *WHILE - *END are printed as long as
          <lCondition> is true.






          ##RPT - EXAMPLES##
          ================================================================


          It follows some  example of  text to  be printed  with the  RPT()
          function. Example's lines are numbered. Line numbers must not  be
          part of a real RPT text files.





          ##PAGE DEFINITION##
          ----------------------------------------------------------------


          Margins are defined with *HEAD, *FOOT and *LEFT commands. In  the
          following example is defined:

               Top            2 lines;

               Bottom         2 lines;

               Left           10 characters.

          The right margin is not defined as it depends on the lines length
          that will be printed.

          The only considered page dimention is the height, *LPP (lines per
          page):

               Page height    66 lines.

          Here starts the example:

               001  *lpp 66
               002  *head
               003
               004
               005  *end
               006  *foot
               007
               008
               009  *end
               010  *left 10
               011  ... text text text
               012  ... test text text
               ...

          At line 001 is defined the page  height in lines. At line 002  is
          defined the header;  it contains two  empty lines  (003 and  004)
          whitch will be  printed at  the top of  every page.  At line  006
          starts the footer definition that  contains two empty lines  (007
          and 008) that will be printed at  the end of every page. At  line
          010 is defined the space on the left that will be added to  every
          line printed. From line 011 starts the normal text.





          ##HEADER AND FOOTER##
          ----------------------------------------------------------------


          The commands  *HEAD and  *FOOT are  used to  define the  top  and
          bottom border if they  contains empty lines,  it these lines  are
          not empty, they became real head and foot.

          The dimentions are as it follows:

               Top            6 lines (should be one inch);

               Bottom         6 lines;

               Left           10 characters (should be an inch).

               Page height    66 lines (should be 11 inch).

          At position 0.5 inch (after 3 lines) a one line header appears.

               001  *lpp 66
               002  *head
               003
               004
               005
               006  ------------------- MYFILE.TXT -------------------
               007
               008
               009  *end
               010  *foot
               011
               012
               013
               014
               015
               016
               017  *end
               018  *left 10
               019  ... text text text
               020  ... test text text
               ...

          At line 006 (the fourth header  line) a text appears. It will  be
          printed on every page at the absolute fourth page line.





          ##CODE INSERTION##
          ----------------------------------------------------------------


          Peaces of code can be inserted inside *COMMAND - *END. It can  be
          usefull to make complicated reports.

          The following example declares a  public variable used to  number
          pages.

               001  *command
               002  mempublic("PageNo")
               003  PageNo := 0
               004  *end
               005  *lpp 66
               006  *head
               007  *command
               008  PageNo := PageNo +1
               009  *end
               010
               011
               012  *end
               013  *foot
               014
               015                                Page <PageNo>
               016
               017  *end
               018  *left 10
               019  ... text text text
               020  ... test text text
               ...

          At line 001 starts a *COMMAND definition: lines 002 and 003  will
          be interpreted from the funtion  EX(), the nB interpreter.  These
          lines define  a public  variable and  initialize  it at  0.  This
          variable will be use to count pages.

          At line 007, inside the  header (nested), start another  *COMMAND
          definition that contains an increment for the "PageNo"  variable.
          As the header is read and "executed" for every new page, and that
          before the footer, the variable  "PageNo" will contain the  right
          page number.

          At line 015, inside the footer, a reference to "PageNo"  appears.
          Here will be printed the page number.
          A more complicated example  can be found  in ADDRESS.TXT the  RPT
          text file used for the ADDRESS.& macro examples.






          ##THE SOURCE FILES##
          ================================================================


          The nB source is  composed of two  files: NB.PRG and  NB_REQ.PRG.
          The first one contains the most of the entire program, the second
          contains  only  a  link  (REQUEST)  to  all  CA-Clipper  standard
          functions.

          As not all CA-Clipper standard functions are directly called from
          nB, a Warning message will appear  when the linker tries to  link
          the object generated fron NB_REQ. Don't warry about that  warning
          message.

          Different  .RMK  (rmake)  files   are  included  to  compile   nB
          differently, including/exluding some  program parts, for  example
          to obtain a runtime executor.






          ##AKNOLEDGMENTS##
          ================================================================


          nB is  written  in  CA-Clipper 5.2.  CA-Clipper  is  produced  by
          Computer Associates and Computer Associates has no  resposibility
          on nB.

          Some peaces of the CA-Clipper standard functions description  are
          taken from the CA-Clipper documentation.

          The function RF() is a modification of the source of the original
          __ReportForm() used by CA-Clipper.





          ##KNOWN PROBLEMS##
          ================================================================


          There are some known unresolved problems inside nB. I am sorry.

          *    nB  Macros  may  be  contained  inside  ascii  files  or   a
               "compiled" .dbf file. In the  second case, when nB  executes
               the macro, a work area (the last available one) is used,  so
               it should  not be  closed or  the  macro execution  will  be
               stopped. A dbcloseall() will stop execution of the macro. In
               substitution of dbcloseall(), DBCLOSE() should be used.

          *    To simplify the macro interpretation, lines such as this:
               qqout( "You can't do that // you can't do that!" )
               will generate an error as the interpreter will read only:
               qqout( "You can't do that






          ##nB HISTORY##
          ================================================================


          z.exe 1995.03.18 to 1996.02.01

               The result of an hobby project to create a .DBF, .NTX,  .LBL
               and .FRM  utility  with  a simplified  macro  ability.  This
               program was distributed only in Italy.


          nBase 1996.01.15

               The first version of a new  hobby project to create a  macro
               interpreter


          nB 1996.02.28

               This is the first release of  nB. nB is the result of  nBase
               and z.exe.

          nB 1996.06.16

               Changed the  licence  to  GNU General  Public  Licence.  The
               source is now included.

               Added a macro recorder/editor.

               Added HTP, the Help Text File system.

               Added a Status line at the top of the screen.

               Added the PROCEDURE - ENDPROCEDURE statement for macroes.

               More functions are availables for macro use.

               TB() function is changend: more parameters added.

               DIR() function is  changed: returned  data is  a little  bit
               different.

               The wait bar  is now at  the screen top  to avoid  conflicts
               with the natural display scroll

               Corrected a bug inside RPT() with large lines.

               Other minor changes.

               Other minor bug corrections.






          ##HOW TO CONTACT THE AUTHOR##
          ================================================================


          If you like the program, I will be happy to know it, for  example
          receiving a e-mail.

          Will you tell me if you like this work?

          Comments, suggestions, bug reports  and english text  corrections
          are welcome (and needed) to make a better nB.
          Write to:                     Daniele Giacomini
                                        Via Turati, 15
                                        I-31100 Treviso
                                        Italy

          Send your e-mail to:          daniele@system.abacom.it

