Chapter 371.   nanoBase 1997 user manual

• 371.1   Dos xBase

• 371.2   Composition

• 371.3   How to use nB

• 371.4   Status line

• 371.5   The dot line

• 371.6   The menu system

• 371.7   The text editor DOC()

• 371.8   The help text file

• 371.9   Macro

• 371.10   Data types

• 371.11   Operators

• 371.12   Delimiters

• 371.13   Code blocks

• 371.14   Standard functions

• 371.15   nB functions

• 371.16   Normal command substitution

• 371.17   nB command substitution functions

• 371.18   RPT: the nB print function

• 371.19   How can I...

• 371.20   The source files

nB (``nano Base'': ``n'' = ``nano'' = 10**(-9) = ``very little'') is a little Dos xBase written in Clipper 5.2 that can help to access .DBF file created with different standards.

nB is:

• a dot command interpreter,

• a menu driven xBase,

• a xBase program interpreter.

371.1   Dos xBase

This section is a brief description of the functionality of a typical Dos xBase.

The first purpose of a xBase program is to handle data inside a .DBF file. These files may be indexed with the help of index files and more .DBF files may be linked with a relation to obtain something like a relational database.

371.1.1   .DBF files

.DBF files are files organised in a table structure:

----------------------------
| field1 | field2 | field3 |  record1
----------------------------
|        |        |        |  record2
----------------------------
|        |        |        |  record3
----------------------------
|        |        |        |  record4
----------------------------
|        |        |        |  record5
----------------------------
|        |        |        |  record6
----------------------------

The lines of this table are records and the columns are fields. Records are numbered starting from the first that is number 1.

Columns are defined as fields and fields are distinguished by name and these names are saved inside the .DBF file.

Every field (column) can contain only one specified kind of data with a specified dimension:

• C, character, originally the maximum dimension was 254 characters, minimum is 1;

• N, numeric, a numeric field that can contain also sign and decimal values;

• D, date, a field dedicated to date information;

• L, logic, a filed that may contain only T for True or F for False used as a boolean variable;

• M, memo, a character field with no predefined dimension, not allocated directly inside the .DBF, but inside a .DBT file, automatically linked.

No other field type is available for a typical xBase .DBF file.

To access the data contained inside a .DBF file the following list of action may be followed:

• Open a .DBF file inside the current area, where these areas are something like file handlers.

• After the .DBF file is opened, it referenced only by the alias name that usually correspond to the original filename without extention.

• Move the record pointer to the desired location.

• Lock the current record to avoid access from other users.

• Do some editing with the data contained inside the current record using the field names like they were variables.

• Release the lock.

• Move the record pointer to another desired location.

• Lock the current record to avoid access from other users.

• ...

• Close the alias.

Before you go further, you have to understand that:

• A .DBF file is opened using a free WORK AREA that may be associated to the concept of the file handler.

• The .DBF file is opened with a alias name that permit to open the same .DBF file more times when using different alias names.

• After the .DBF file is opened, we don't speak any more of file, but alias.

• If the work area "n" is used from the alias "myAlias", speaking of work area "n" or of alias "myAlias" is the same thing.

371.1.2   Index files

.DBF files are organised with record number, that is, you can reach a specific record and not a specific information unless that you scan record by record.

To obtain to "see" a .DBF file somehow logically ordered (when physically it is not), index files are used.

A index file, also called INDEX BAG, is a file that contains one or more indexes

Indexes are rules by which a .DBF file may be seen ordered.

A typical index file may contain only one index.

A index file may have the following extention:

• .NDX, single index, dBase III and dBase III plus;

• .NTX, single index, Clipper;

• .MBX, multiple index, dBase IV;

• .CDX, multiple index, FoxPro.

To access the data contained inside a .DBF file the following list of action may be followed:

• Open a .DBF file.

• Open a index file.

• Select a particular order.

• Search for a key or move the record pointer on a different way.

• Lock the current record to avoid access from other users.

• Do some editing with the data contained inside the current record using the field names like they were variables.

• Release the lock.

• Move the record pointer to another desired location.

• Lock the current record to avoid access from other users.

• ...

• Close the alias.

Before you go further, you have to understand that:

• As orders are contained inside a INDEX BAG file physically distinguished form the .DBF file, it may happen that a .DBF file is wrongly opened and edited without the index. In this case, the INDEX BAG is not updated and when the INDEX BAG will be opened, the records contained inside the .DBF file may not correspond.

• For the same reason, an improper program termination may result in an incomplete data update. That is: .DBF file may be all right, INDEX BAG not.

• This is why xBase programs are "weak" relational databases or they are not relational databases at all.

• When troubles occurs, indexes must be rebuild.

371.1.3   Relations

Many .DBF files with indexes may be opened simultaneously. Data contained inside more .DBF files may be somehow connected together. See the example.

------------------------------------------
| Date | Time IN | Time OUT | Employee # |
------------------------------------------
| xxxx | xxxxxxx | xxxxxxxx |      01    | -------->|
------------------------------------------          |
| yyyy | yyyyyyy | yyyyyyyy |      02    |          |
------------------------------------------          |
| zzzz | zzzzzzz | zzzzzzzz |      01    | -------->|
------------------------------------------          |
[...]                                               |
                                                    |
         |<-----------------------------------------|
         |
         |
         |        ----------------------------------------
         |        | Employee # | Name    | Address |.....|
         |        ----------------------------------------
         |------->|   01       | aaaaaaa | aaaaaaa |.....|
                  ----------------------------------------
                  |   02       | bbbbbbb | bbbbbbb |.....|
                  ----------------------------------------
                  |   03       | ccccccc | ccccccc |.....|
                  ----------------------------------------

The first .DBF file contains some data that refers to an Employee number that may appear repeated on more records.

Employee informations are stored inside another .DBF file that contains only one record for every employee.

Establishing a relation from the first .DBF file to the second, moving the record pointer of the first .DBF file, that is the first alias, the record pointer of the second, the child alias, is moved automatically to the record containing the right data.

The relation is an expression that should result in a number if the child alias is opened without index, or in a valid index key if the child alias is opened with an index.

To relate two .DBF files the following list of action may be followed:

• Open the first .DBF file.

• Open a index file for the first alias.

• Select a particular order.

• Open the second .DBF file.

• Open a index file for the second alias.

• Select a particular order.

• Select the first alias.

• Define a relation form the first alias and the second alias: the child alias.

• Search for a key or move the record pointer of the first alias (don't care about the Child alias).

• Lock the current record to avoid access from other users.

• If data contained inside the Child alias should be edited (usually it doesn't happen), lock the current record of the Child alias.

• Do some editing with the data contained inside the current record using the field names like they were variables.

• Release the lock (also with the Child alias if a lock was made).

• Move the record pointer to another desired location.

• Lock the current record to avoid access from other users.

• [...]

• Release the relation.

• Close the Child alias.

• Close the first alias.

As may be seen, relations are not saved inside files, but are obtained with lines of code.

371.2   Composition

nB is composed from the following files, where xx is the the version code.

Every archive file contains:

The file NBASExx1.ZIP contains also the following files.

The file NBASExx2.ZIP contains also the following files.

The file NBASExx3.ZIP contains also the following files.

The file NBASExx4.ZIP contains also the following files.

The file NBASExx5.ZIP contains also the following files.

The file NBASExx6.ZIP contains also the following files: source code for the version 96.06.16.

The file NBASExx7.ZIP contains also the following files: source code for the current version.

371.3   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:

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.

371.4   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 appearance (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; & blinking means that the macro recorder is ON; & fixed 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.

371.5   The dot line

Starting nB without parameters, the dot line appears. This is the place where commands in form of functions may be written and executed like a old xBase.

The functions written inside the command line that don't result in an error, are saved inside a history list. This history list may be recalled with [F2] and then the selected history line may be reused (eventually edited). Key [up]/[down] may be used to scroll inside the history list without showing the all list with [F2].

[Enter] is used to tell nB to execute the written function.

As the dot line is not an easy way to use such a program, a menu is available pressing [F10] or [Alt+M]. The [F10] key starts the ASSIST() menu. This menu may be started also entering the name of the function: "ASSIST()".

nB includes a simple built-in text editor: DOC(). It may be started from the dot line entering "DOT()". No special key is dedicated to start this function.

371.6   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].

The Menu system is organised into horizontal menu, vertical menu, and pop-up menu.

The horizontal menu contains selectable items organised horizontally:

     One Two Three Four Five

The cursor may be moved on a different position using arrow keys [Left]/[Right]; [Esc] terminates the menu; [Enter] opens a vertical menu.

The vertical menu contains selectable items organised vertically:

      One Two Three Four Five
     ------------
     |First     |
     |Second    |
     |Third     |
     ------------

The cursor may be moved on a different position using arrow keys [Up]/[Down]; the arrow keys [Left]/[Right] change the vertical menu; [Esc] closes the vertical the menu; [Enter] starts the selected menu function.

The vertical menu contains selectable items organised vertically:

      One Two Three Four Five
     ------------
     |First     |
     |Second   >|---------------
     |Third     |Sub function 1|
     -----------|Sub function 2|
                ----------------

The cursor may be moved on a different position using arrow keys [Up]/[Down]; [Esc] closes the pop-up the menu; [Enter] starts the selected menu function.

The following sections describe the menu system.

371.6.1   Menu File

The menu File contains important function on .DBF file, indexes, relations and Replaceable database drivers.

For database files are considered two aspects: the physical aspect, and the logical alias. When a .DBF file is opened, it becomes a alias.

Indexes are considered as index files and index orders.

It follows a brief menu function description.

Change directory

Changes the actual drive and directory.

File .DBF

Contains a pop-up menu for .DBF operations.

New .DBF

A .DBF file is a table where columns, called Fields, must be specified and lines, called records, are added, edited and deleted by the program.

Field characteristics are:

NAME	the field name must be unique inside the same file, it is composed of letters, number and underscore (_), but it must start with a letter and it is not case sensitive.
TYPE	the field type determinates the type of data it can hold.
LENGTH	is the field total length in characters; it doesn't matter of the type of data.
DECIMAL	is the length of positions after decimal point. This information is used normally for numeric fields. In this case, take note that the DECIMAL length, together with the decimal point, will subtract space for the integer part of the number from the total LENGTH of the filed.

Field Types:

C Character	it is a text field long LENGTH characters.
N Numeric	it is a numeric field long LENGTH characters with DECIMAL characters for decimal positions. Note that if LENGTH is 4 and DECIMAL is 0 (zero), the field may contain integers from -999 to 9999; but if LENGTH is 4 and DECIMAL 1, the field may contain numbers from -9.9 to 99.9: two position for the integer part, one position for the decimal point and one position for decimal.
D Date	it is a date field: it contains only dates; the length should not be specified as it is automatically 8.
L Logic	it is a logical (boolean) field: it contains only TRUE, represented by "Y" or "T", or FALSE, represented by "N" or "F". The length should not be specified as it is automatically 1.
M Memo	it is a character field with unknown dimension. It is recorded into a parallel file with .DBT extention. The original .DBF file holds a space for a pointer inside the .DBT file. The length of a Memo field is automatically 10 and is referred to the memo pointer.

After the function "NEW .DBF" is selected, a table for the field specifications appears.

+--------------------------------+ | Database file structure | | | | Field Name Type Length Decimal | |--------------------------------| | | | 0| 0 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

To navigate and to edit the table use the following keys:

[Up]/[Down]/[Left][Right]	move the cursor one position (up, down, left or right);
[PgUp]	move to previous screen page;
[PgDn]	move to next screen page;
[Ctrl+PgUp]	move to top of table;
[Ctrl+PgDn]	move to bottom of table;
[Ctrl+Home]	move to first column;
[Ctrl+End]	move to last column;
[Ctrl+Enter]	append a new empty line;
[Ctrl+F1]	delete (cut) the current line and save a copy into the "clipboard";
[Ctrl+F2]	copy current line into the table "clipboard";
[Ctrl+F3]	insert (paste) the content of the "clipboard" in the current position;
[Enter]	start editing in the current position;
[Esc]	terminate;
[x]	any other key will be written in the current position.

When the editing is terminated, press [Esc] and a dialog box will ask for the file name and the RDD.

xBase files (.DBF) are not all equal, this way, when a new .DBF file si created, the RDD (Replaceable Database Driver) is asked. The normal RDD is DBFNTX, the one used by Clipper.

Modify .DBF structure

The modification of a .DBF file structure is a delicate matter if it contains data.

In fact, it is a data transfer from a source .DBF file to a destination .DBF file with a different structure. This way, the destination .DBF will be updated only for the fields with the same name of the source one. The position may be different, but names cannot be changed (not so easily).

Mistakes may be dangerous, so, before doing it, it is recommended a backup copy of the original .DBF file.

Open .DBF

When a .DBF file is opened, it becomes a alias, a logical file, placed inside a work area. The same .DBF file may be opened inside different areas with different alias names.

The required information to open the file are:

FILENAME	the physical file name.
ALIAS	the alias name. If not assigned, it becomes automatically the same of FILENAME without extention.
RDD	the Replaceable Database Driver to use to access to this file.
SHARED	a logical value: TRUE means that the file will be accessible to other users, FALSE means use exclusive.
READ ONLY	a logical value: TRUE means that the file will be only readable and no modification will be allowed, FALSE means that no restriction on editing will be made.

File .NTX

Contains a pop-up menu for physical indexes operations.

New .NTX / new tag

If the active area is used we have an active alias. In this case a index may be created. The index is a way to see the active alias ordered without changing the physical position of records.

There are two words to understand: ORDER and INDEX-BAG. The index bag is the file that contains the information on the record ordering, the order is the rule followed to order the records. A index bag may contains one or more orders depending on the Replaceable Database Driver in use.

Typical .NTX file are index bag containing only one order.

Depending on the RDD in use the following field may be filled.

INDEX FILENAME	this is the name of the index bag.
KEY EXPRESSION	the expression that defines the rule for the record ordering.
ORDER NAME	this is the name to give to the order (tag) when the RDD permits to have a index bag containing more than one order. In the other case, the index bag name correspond to the order name.
FOR EXPRESSION	a FOR condition to filter records before indexing.

Open index

If a index file already exists, it can be associated to the active alias simply opening it.

Take note that the system is not able to verify if the index belong the active alias and if it is not so a error will result.

INDEX NAME

is the name of the index bag file to open.

Alias

Contains a pop-up menu for logical databases (alias) operations.

Select

Only one may be the active alias and with this function the active alias may be changed choosing from the list of used areas.

Selecting the area number zero, no alias is active.

Display structure

With this function the active alias structure may be viewed.

Close active alias

Selecting this function the active alias is closed. That is: the .DBF file and eventual indexes are closed.

Close all aliases

With this function all Aliases are closed.

Order

Contains a pop-up menu for logical indexes (orders).

Order list rebuild

This function rebuild the indexes opened and associated to the active alias.

Order set focus

This function permits to change the active order selecting form the ones opened and associated to the active alias.

Order list clear

This function closes all orders associated to the active alias.

Relation

Contains a pop-up menu for relations (links with other Aliases).

Set relation

This function permits to establish a relation between a alias and a Child alias showing as a result a unique database.

CHILD	is the alias name to connect to the active alias.
EXPRESSION	is the relation expression that specify the rule for the relation. The value of this expression is the key to access the Child alias: if this Child alias is accessed without index, it must be the record number, if this Child alias is accessed via index, it must be a valid index key.

Clear relation

This function eliminates any relation that originate form the active alias.

RDD default

Contains a pop-up menu for Replaceable Database Driver defaults.

Show actual RDD default

It simply shows the actual Replaceable Database Driver.

Set default RDD

Select a new default Replaceable Database Driver.

371.6.2   Menu Edit

The menu Edit contains functions to access data from the active alias (the actual area).

View

This function permits you to view the active alias with eventual relations as a table.

No edit is allowed.

To navigate the table use the following keys.

[Enter]	start field editing.
[PgUp]	show previous screen page.
[PgDn]	show next screen page.
[Ctrl+PgUp]	show top of alias.
[Ctrl+PgDn]	show bottom of file.
[Ctrl+Home]	show the first column.
[Ctrl+End]	show last column.

Edit/browse

This function permits you to edit the active alias with eventual relations as a table.

To navigate and edit the table use the following keys.

[Enter]	start field editing.
[PgUp]	show previous screen page.
[PgDn]	show next screen page.
[Ctrl+PgUp]	show top of alias.
[Ctrl+PgDn]	show bottom of file.
[Ctrl+Home]	show the first column.
[Ctrl+End]	show last column.
[Ctrl+Enter]	append a new empty record.
[Ctrl+F2]	copy the current record.
[Ctrl+F3]	append and paste a record.
[Ctrl+F4]	paste a previously copied record, overwriting the content of the current one.
[Ctrl+Y]	delete or recall the current record.
[Ctrl+Del]	delete or recall the current record.

When a memo field is edited:

[Esc]	cancel and close the memo window.
[Ctrl+Y]	line delete.
[Ctrl+W]	save and close the memo window.

Replace

The content of a Field of the active alias may be replaced with an expression.

The required data is:

FIELD TO REPLACE	the Field name to be replaced.
NEW VALUE EXPRESSION	the expression that obtain the new value for the selected Field.
WHILE EXPRESSION	the WHILE condition expression: the replacement continue until this expression results True. The constant .T. is ever True and is the default.
FOR EXPRESSION	the FOR condition expression: the replacement is made for all records that satisfy the condition. The constant .T. is ever True and is the default.

Recall

The records signed for deletion (deleted but still there), may be recalled (undeleted).

The required data is:

WHILE EXPRESSION	the WHILE condition expression: the record recall continue until this expression results True. The constant .T. is ever True and is the default.
FOR EXPRESSION	the FOR condition expression: the record recall is made for all records that satisfy the condition. The constant .T. is ever True and is the default.

Delete

Deletes (sign for deletion) a group of record depending on the required conditions.

The required data is:

WHILE EXPRESSION	the WHILE condition expression: the record deletion continue until this expression results True. The constant .T. is ever True and is the default.
FOR EXPRESSION	the FOR condition expression: the record deletion is made for all records that satisfy the condition. The constant .T. is ever True and is the default.

Pack

This function eliminates definitely records previously deleted (signed for deletion).

It may work only if the active alias was opened in exclusive mode.

371.6.3   Menu Report

The menu Report contains functions for data report (print). In particular, label files .LBL and report file .RPT may be created and used for printing. There is also another way to print, with the RPT() system that is available inside the nB internal editor DOC().

DBGOTOP()

Moves the record pointer for the active alias at the first logical record.

New label

With this function can be created a standard label file (.LBL under the dBaseIII standard).

Labels may be printed in more than one column and can contain 16 lines maximum.

The label data is the following.

REMARK	a label remark that will not be printed.
HEIGHT	the label vertical dimension.
WIDTH	the label horizontal dimension.
MARGIN	the left margin in characters.
LINES	the vertical spacing between labels.
SPACES	the horizontal spacing between labels in characters.
ACROSS	the number of label columns.
LINE 1	The first line inside labels.
LINE n	The n-th line inside labels.
LINE 16	The 16th line inside labels.

The number of lines inside the labels depend on the HEIGHT and the maximum value is 16.

The label lines can contain constant string and/or string expressions.

See the example below.

Margin <--> XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXX Height XXXX <--- Width ----> XXXXXXXXXXXXXXXX XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXX|XXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX | | Lines <--> | Spaces XX Line 1 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XX Line 2 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XX Line 3 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XX Line 4 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XX Line 5 XXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX | | | | | | | | | +---------------- Across ---------------+

Modify label

This function permits you to modify a label file.

Label form

This function permits you to print labels with the data provided by the active alias: one label each record.

The following data is required.

LABEL FILENAME	the label filename.
WHILE	the WHILE condition: the label printing goes on as long as this condition remain True.
FOR	the FOR condition: only the records from the active alias that satisfy the condition are used for the label print.

New report

This function permits you to create a standard report form file (.FRM under the dBaseIII standard).

The informations to create a .FRM file are divided into two parts: the head and groups; the columns.

The first part: head and groups, requires the folliwing informations:

PAGE WIDTH	the page width in characters.
LINES PER PAGE	the usable lines per per page.
LEFT MARGIN	the left margin in characters.
DOUBLE SPACED?	double spaced print, yes or no.
PAGE EJECT BEFORE PRINT?	form feed before print, yes or no.
PAGE EJECT AFTER PRINT?	form feed after print, yes or no.
PLAIN PAGE?	plain page, yes or no.
PAGE HEADER	the page header, max 4 lines (the separation between one line and the other is obtained writing a semicolon, ";").
GROUP HEADER	the group title.
GROUP EXPRESSION	the group expression (when it changes, the group changes)
SUMMARY REPORT ONLY?	only totals and no columns, yes or no.
PAGE EJECT AFTER GROUP?	form feed when the group changes, yes or no.
SUB GROUP HEADER	sub group title.
SUB GROUP EXPRESSION	the sub group expression.

The second part: columns, requires the following informations structured in table form:

COLUMN HEADER	column head description (it can contain 4 lines separated with a semicolon).
CONTENT	the column expression.
WIDTH	the column width.
DEC.	the decimal length for numeric columns.
TOTALS	totals to be calculated, yes or no (usefull only for numeric columns).

To navigate and to edit the table use the following keys:

[Up]/[Down]/[Left][Right]	move the cursor one position (up, down, left or right);
[PgUp]	move to previous screen page;
[PgDn]	move to next screen page;
[Ctrl+PgUp]	move to top of table;
[Ctrl+PgDn]	move to bottom of table;
[Ctrl+Home]	move to first column;
[Ctrl+End]	move to last column;
[Ctrl+Enter]	append a new empty line;
[Ctrl+F1]	delete (cut) the current line and save a copy into the "clipboard";
[Ctrl+F2]	copy current line into the table "clipboard";
[Ctrl+F3]	insert (paste) the content of the "clipboard" in the current position;
[Enter]	start editing in the current position;
[Esc]	terminate;
[x]	any other key will be written in the current position.

When the editing is terminated, press [Esc] and a dialog box will ask for the name to give to the report form file.

Modify report

This function permits you to modify a standard report form file (.FRM under the dBaseIII standard).

Report form

This function permits you to print a report form with the data provided by the active alias.

The following data is required.

REPORT FORM FILENAME	the label filename.
WHILE	the WHILE condition: the form printing goes on as long as this condition remain True.
FOR	the FOR condition: only the records from the active alias that satisfy the condition are used for the report form print.

Create/modify/print text

This function activates the text editor.

371.6.4   Menu HTF

The menu Htf helps on creating and accessing the "Help Text Files". This name, help text file, is just the name given to it.

A text (Ascii) file prepared like this manual may be transformed into a "Help Text File" that is a simple text with pointers.

Open help text file

This function permits to open a Help Text File and browse it. The Help Text File name is required.

New help text file

This function permits to create a new "Help Text File" that is a help file under the nB style.

The source is an Ascii file where three kind of information are available: Normal text, Indexes and pointers.

Indexes and Pointers are word or phrases delimited with user defined delimiters; indexes are placed inside the text to indicate an argument, pointers are placed inside the text to indicate a reference to indexes.

Inside this manual, indexes are delimited with ## and ##, so the titles are here indexes; pointers are delimited with < and >.

Only one index per line is allowed, only one pointer per line is allowed.

The Delimiters used do identify indexes and pointers are user defined; the _start_ identifier symbol can be equal to the _end_ identifier symbol. The symbols used for indexes cannot be used for the pointers.

So, the informations required are:

SOURCE TEXT FILENAME	the filename of the text source file.
DESTINATION FILENAME	the filename of the destination Help Text File (suggested .HLP extention).
INDEX START CODE	the index start symbol; suggested ##.
INDEX END CODE	the index end symbol; suggested ##.
POINTER START CODE	the pointer start symbol; suggested <.
POINTER END CODE	the pointer end symbol; suggested >.

New HTML file

This function permits to create a new HTML file form a text file formatted to obtain a HTF file.

The informations required are:

SOURCE TEXT FILENAME	the filename of the text source file.
DESTINATION FILENAME	the filename of the destination Help Text File (suggested .HLP extention).
INDEX START CODE	the index start symbol; suggested ##.
INDEX END CODE	the index end symbol; suggested ##.
POINTER START CODE	the pointer start symbol; suggested <.
POINTER END CODE	the pointer end symbol; suggested >.
HTML TITLE	the title for the html page.

371.6.5   Menu Macro

The menu Macro helps on creating macros (programs) with a macro recorder, a macro "compiler" and a macro executor.

Start recording

This function simply starts or pause the macro recording. The menu items that end with "&", may be recorded by this macro recorder.

Save recording

A recorded macro may be saved into a ASCII file that may be later modified or simply used as it is. The filename is requested.

Erase recording

While recording or when the macro recorder is paused, it is possible to erase all previous recording with this function.

Edit recording

While recording or when the macro recorder is paused, it is possible to edit all previous recording, for example adding more comments or simply to see what the recorder does.

Macro compilation

A macro file (a program) contained inside a ASCII file, may be compiled into a different file format to speed up execution. The source filename and the destination filename are requested.

Load + execute macro

A macro file (a program) in ASCII form or compiled, may be executed.

A macro file may require some parameters.

This function asks for the macro filename to start and the possible parameter to pass to it.

371.6.6   Menu Info

The menu Info is the information menu.

371.6.7   Menu Doc

This menu actually appears only inside the DOC() function, the nB text editor.

New

It starts the editing of a new empty text.

Open

It opens for editing a new textfile.

Save

It saves the text file under editing.

Save as

It saves the text file under editing asking for a new name.

Set output to

It permits to change the default output peripheral: the default is the screen.

Print as it is

It prints on the output peripheral the content of the text as it is.

Print with RPT() once

It prints on the output peripheral the content of the text only once replacing possible text variables.

Print with RPT() std

It prints on the output peripheral the content of the text repeating this print for every record contained inside the archive alias.

Exit DOC()

Terminates the use of DOC() the text/document editing/print function.

371.7   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.

DOC() may handle text files of a teorical maximum of 64K.

DOC() may be particularly useful to create formatted text with variables identified by CHR(174) and CHR(175) delimiters: when an active alias exists, [F2] gives a list of insertable fields.

371.8   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 terminate 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:

371.9   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 Clipper and linked).

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

EXE macro files are the fastest.

371.9.1   Macro statements

The statements recognised from nB are very similar to Clipper, with some restrictions.

Note that: the FOR statement is not included; there is no function declaration; procedure calls cannot transfer variables; only public variables are allowed.

PROCEDURE

Procedures are the basic building blocks of a nB macro.

Procedures are visible only inside the current macro file.

The procedure structure is as follows:

PROCEDURE procedure_name
     statements...
     [RETURN]
     statements...
ENDPROCEDURE

A procedure definition begins with a PROCEDURE declaration followed with the procedure_name and ends with ENDPROCEDURE.

Inside the PROCEDURE - ENDPROCEDURE declaration are placed the executable statements which are executed when the procedure is called.

Inside the PROCEDURE - ENDPROCEDURE declaration, the RETURN statement may appear. In this case, encountering this RETURN statement, the procedure execution is immediately terminated and control is passed to the statement following the calling one.

The procedure definition do not permit to receive parameters from the calling statement.

DO PROCEDURE

There is only one way to call a procedure:

DO PROCEDURE procedure_name

When the statement DO PROCEDURE is encountered, the control is passed to the begin of the called PROCEDURE. After the PROCEDURE execution, the control is returned to the statement following DO PROCEDURE.

The procedure call do not permit to send parameters to the procedure.

BEGIN SEQUENCE

The BEGIN SEQUENCE - END structure permits to define a sequence of operation that may be broken.

Inside nB, this control structure is useful only because there is the possibility to break the execution and pass control over the end of it.

This way, encountering BREAK means: "go to end".

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

Inside nB, error exception handling is not supported.

DO CASE

This is a control structure where only the statements following a True CASE condition are executed.

When the DO CASE statement is encountered, the following CASE statements are tested. The first time that a condition returns True, the CASE's statements are executed and then control is passed over the END case.

That is: only one CASE is taken into consideration.

If no condition is True, the statements following OTHERWISE are executed.

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

WHILE

The structure WHILE - END defines a loop based on a condition: the loop is repeated until the condition is True.

The loop execution may be broken with the EXIT statement: it transfer control after the END while.

The LOOP statement may be use to repeat the loop: it transfer the control to the beginning of the loop.

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

IF

The IF - END control structure executes a section of code if a specified condition is True. The structure can also specify alternative code to execute if the condition is False.

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

371.9.2   Variable declaration

Inside nB, variables are created using a specific function:

MEMPUBLIC( "cVarName" )

For example,

MEMPUBLIC( "Name" )

creates the variable Name.

The scope of the created variable is global and there is no way to restrict the visibility of it.

When a variable is no more needed or desired, it can be released:

MEMRELEASE( "cVarName" )

The variable declaration do not defines the variable type. Every variable may receive any kind of data; that is that the type depends on the type of data contained.

371.9.3   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_name_1
          statements...
          [RETURN]
          statements...
     ENDPROCEDURE
     PROCEDURE procedure_name_2
          statements...
          [RETURN]
          statements...
     ENDPROCEDURE
     ...
     ...
     DO PROCEDURE procedure_name_n

Macro without procedures:

    statements...
    statements...
    statements...
    statements...
    statements...

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

     #INCLUDE MACRO.CH

     DO PROCEDURE procedure_name_nth
     ...
     PROCEDURE procedure_name_1
          statements...
          [RETURN]
          statements...
     ENDPROCEDURE
     PROCEDURE procedure_name_2
          statements...
          [RETURN]
          statements...
     ENDPROCEDURE
     ...
     ...

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

     RTLINK MACRO.RMK [Enter]

should be started.

371.9.4   Macro comments

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

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

371.9.5   Macro long lines split

Inside a nB macro, long lines may be splitted using ";" (semicolon). Please note that: lines can only be splitted and not joined; a resulting command line cannot be longer then 254 characters.

371.9.6   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 possible) 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).

371.10   Data types

The data types supported in the nB macro language are the same as Clipper:

Array

Character

Code Block

Numeric

Date

Logical

Memo

NIL

371.10.1   Character

The character data type identifies character strings of a fixed length. The character set corresponds to: CHR(32) through CHR(255) and the null character, CHR(0).

Valid character strings consist of zero or more characters with a theoretical maximum of 65 535 characters. The real maximum dimension depends on the available memory.

Character string constants are formed by enclosing a valid string of characters within a designed pair of delimiters. There are three possible delimiter pairs:

two single quotes like 'string_constant';

two double quotes like "string_constant";

left and right square brackets like [string_constant].

These three different kind of delimiters are available to resolve some possible problems:

I don't want it -> "I don't want it"

She said, "I love hin" -> 'She said, "I love hin"'

He said, "I don't want it" -> [He said, "I don't want it"]

The following table shows all operations available inside nB for character data types. These operations act on one or more character expressions and the result is not necessarily a character data type.

371.10.2   Memo

The memo data type is used to represent variable length character data that can only exist in the form of a database field.

Memo fields are not stored inside the main database file (.DBF) but inside a separate file (.DBT).

A memo field can contain up to 65 535 characters, that is the same maximum dimension of character fields. In fact, originally xBases, couldn't have character string longer than 254 characters.

As here memo fields are very similar to long character strings, you may forget that there is a difference.

All the operations that may be applied to character strings, may be used with memo fields; the following functions may be use especially for memo fields or long character strings.

371.10.3   Date

The date data type is used to represent calendar dates.

Supported dates are from 0100.01.01 to 2999.12.31 and null or blank date.

The appearance of a date is controlled from SETVERB("DATEFORMAT"). The default is "dd/mm/yyyy" and it may easily changed for example with SETVERB("DATEFORMAT", "MM/DD/YYYY") to the US standard.

There is no way to represent date constants; these must be replaced with the CTOD() function. For example if the date 11/11/1995 is to be written, the right way is:

CTOD( "11/11/1995" )

The character string "11/11/1995" must respect the date format defined as before explained.

The function CTOD() will accept only valid dates, and null dates:

CTOD( "" )

A null date is ever less than any other valid date.

The following table shows all operations available inside nB for date data types. These operations act on one or more date expressions and the result is not necessarily a character data type.

371.10.4   Numeric

The numeric data type identifies real number. The theoretical range is form 10^-308 to 10^308 but the numeric precision is guaranteed up to 16 significant digits, and formatting a numeric value for display is guaranteed up to a length of 32 (30 digits, a sign, and a decimal point). That is: numbers longer than 32 bytes may be displayed as asterisks, and digits other then most 16 significant ones are displayed as zeroes.

Numeric constants are written without delimiters. The following are valid constant numbers:

12345

12345.678

-156

+1256.789

-.789

If a numeric constant is delimited like character strings, it becomes a character string.

The following table shows all operations available inside nB for numeric data types. These operations act on one or more numeric expressions and the result is not necessarily a numeric data type.

Number appearence may be affected by SETVERB("FIXED") and consequently by SETVERB("DECIMALS"). If SETVERB("FIXED") is True, numbers are displayed with a fixed decimal position. The number of decimal positions is defined by SETVERB("DECIMALS"). For that reason, the default is SETVERB("FIXED", .F.) and SETVERB("DECIMALS", 2), that is, no fixed decimal position, but if they will be activated, the default is two decimal digits.

371.10.5   Logical

The logical data type identifies Boolean values.

Logical constants are:

When editing a logical field, inputs may be:

The following table shows all operations available inside nB for logical data types. These operations act on one or more logical expressions and the result is not necessarily a logical data type.

Comparing two logical values, False (.F.) is always less than True (.T.).

371.10.6   NIL

NIL is not properly a data type, it represent the value of an uninitialised variable.

Inside nB (like what it happens inside Clipper), variables are not declared with the data type that they will contain. This means that a variable can contain any kind of data. In fact, nB variables are pointer to data and a pointer to "nothing" is NIL.

NIL may be used as constant for assignment or comparing purpose:

NIL

Fields (database fields) cannot contain NIL.

The following table shows all operations available inside nB for the NIL data type. Except for these operations, attempting to operate on a NIL results in a runtime error.

For the purpose of comparison, NIL is the only value that is equal to NIL. All other values are greater than NIL.

Variables are created inside nB with MEMPUBLIC(). This function creates variables which will be automatically initialised to NIL.

371.10.7   Array

The array data type identifies a collection of related data items that share the same name. Each value in an array is referred to as an element.

Array elements can be of any data type except memo (memo is available only inside database fields). For example the first element can be a character string, the second a number, the third a date and so on. Arrays can contain other arrays and code blocks as elements.

The variable containing the array does not contains the entire array, but the reference to it.

If arrays are to be duplicated, the ACLONE() function is to be used.

An array constant may be expressed using curly brackets {}. See the examples below.

A := { "first_element", "second_element", "third_element" }

With this example, the variable A contain the reference to an array with three element containing character string.

A[1] == "first_element"

A[2] == "second_element"

A[3] == "third_element"

Arrays may contain also no element: empty array and may be expressed as:

{}

The array element is identified by a number enclosed with square brackets, following the variable name containing the reference to the array. The first array element is one.

If an array contains arrays, we obtain a multidimensional array. For example:

A := { { 1, 2 }, { 3, 4 }, { 5, 6 } }

is equivalent to the following table.

1         2

3         4

5         6

With this example, the variable A contain the reference to a bidimensional array containing numbers.

A[1,1] or A[1][1] contains 1

A[1,2] or A[1][2] contains 2

A[2,1] or A[2][1] contains 3

and so on.

As arrays may contain mixed data, it is the user who have to handle correctly the element numbers. For example:

A := { "hello", { 3, 4 }, 1234 }

A[1] == "hello"

A[2] == reference to { 3, 4 }

A[3] == 1234

A[2,1] or A[2][1] contains 3

A[2,2] or A[2][2] contains 4

A[1,1] is an error!

The following table shows all operations available inside nB for arrays.

371.10.8   Code block

The code block data type identifies a small piece of executable program code.

A code block is something like a little user defined function where only a sequence of functions or assignments may appear: no loops, no IF ELSE END.

A code block may receive argument and return a value after execution, just like a function.

The syntax is:

{ | [argument_list] | exp_list }

That is: the argument_list is optional; the exp_list may contain one or more expressions separated with a comma.

For example, calling the following code block will give the string "hello world" as result.

{ || "hello world" }

The following code block require a numeric argument an returns the number passed as argument incremented:

{ | n | n+1 }

The following code block requires two numeric arguments and returns the sum of the two square radix:

{ | nFirst, nSecond | SQRT(nFirst) + SQRT(nSecond) }

But code blocks may contains more expressions and the result of the execution of the code block is the result of the last expression.

The following code block executes in sequence some functions and give ever "hello world" as a result.

{ | a, b | functionOne(a), functionTwo(b), "hello world" }

To start the execution of a code block a function is used: EVAL()

For example, a code block is assigned to a variable and then executed.

B := { || "hello world" }

EVAL( B ) == "hello world"

Another example with a parameter.

B := { | n | n+1 }

EVAL( B, 1 ) == 2

Another example with two parameters.

B := { | nFirst, nSecond | SQRT(nFirst) + SQRT(nSecond) }

EVAL( B, 2, 4 ) == 20

And so on.

The following table shows some operations available inside nB for code blocks: many functions use code blocks as argument.

371.11   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 a string beginning with the content of 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.

371.12   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.

371.13   Code blocks

A code block is a sequence of function, assignments and constant like the following:

     sqrt(10)
     nResult := 10 * nIndex

Suppose that the above sequence of operations has a meaning for you. We want to create a box containing this sequence of operation. This box is contained inside a variable:

     bBlackBox := { || sqrt(10), nResult := 10 * nIndex }

Note the comma used as separator.

Now bBlackBox contains the small sequence seen before. To execute this sequence, the function EVAL() is used:

     EVAL(bBlackBox)

The execution of the code block gives a result: the value of the last operation contained inside the code block. In this case it is the result of 10*nIndex. For that reason, if the execution of the code block must give a fixed result, it can terminate with a constant.

A code block may receive parameters working like a function. Try to imagine that we need to do the following.

     function multiply( nVar1, nVar2 )
          return nVar * nVar2
     endfunction

A code block that does the same is:

     bMultiply := { | nVar1, nVar2 | nVar1 * nVar2 }

To evaluate it, for example trying to multiply 10 * 5:

     nResult := EVAL( bMultiply, 10, 5 )

and nResult will contain 50.

371.14   Standard functions

With nB all 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.

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 long

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 ordinal 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 active 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()

DB relation unlock

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()

Date 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()

Date 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.).

EVAL()

Code block evaluation

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 value	Meaning
0	Successful
2	File not found
3	Path not found
4	Too many files open
5	Access denied
6	Invalid handle
8	Insufficient memory
15	Invalid drive specified
19	Attempted to write to a write-protected disk
21	Drive not ready
23	Data CRC error
29	Write fault
30	Read fault
32	Sharing violation
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 rename

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

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()

Net 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().

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 old 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.

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.

Inside nB, the function SET() is not so easy to use as inside the Clipper environment. This because nB cannot support manifest constants and a numeric specifier nSpecifier is not easy to manage. Instead of SET() you can use SETVERB().

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 haracter 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.