BASIC statements

The ! statement indicates that the text following the ! is a comment. This works the same as the remark statement.

The * (asterisk) statement is used as a remark. Text after this statement is ignored.

The abort statement immediately stops program execution and unconditionally returns to the TCL command prompt.

The aux statement enables or disables spooling to the auxiliary port.

The begin case statement starts a case construct.

The begin work statement starts a transaction.

Basic provides facilities for converting between variable length data structures and fixed length data structures.

The break statement enables or disables the BREAK key.

The call statement transfers control to an external FlashBASIC or BASIC subroutine and optionally passes a list of arguments to it.

The capturing statement resumes the capturing effect from the previous execute...capturing statements in a FlashBASIC or BASIC program.

The case statement delineates a conditional case construct.

The casing statement toggles case sensitivity relative to input data and string comparisons in the current program and any called subroutines.

The cfunction statement provides access to C libraries from BASIC.

The chain statement transfers processing control to TCL, which interprets and executes the statement defined in the expression.

The clear statement sets all local and common variables to 0 in a main program.

The cleardata statement clears the data stack.

The clearfile statement deletes all items in the specified file variable previously opened with an open statement.

The clearselect statement clears the active select-list specified by the list.var and releases all overflow associated with that list. Any external select-list is also cleared if the list variable is not specified.

The close statement closes the file identified by file.var. If file.var is not specified, the file referenced by the default file.var is closed.

The commit work operation commits a transaction.

The common statement declares data elements to share among different FlashBASIC or BASIC modules.

The compare statement compares two dynamic arrays.

The continue statement restarts a loop that is under for...next or loop...repeat control.

The convert statement searches a given variable and replaces each occurrence of a character by another.

The crt statement outputs unconditionally to the terminal display, regardless of whether or not the printer on condition is in effect.

The data statement queues responses for use by subsequent input requests initiated from chain, enter, execute, or input statements. The data is taken from the queue in the order in which it was added.

The debug statement temporarily suspends execution of a FlashBASIC or BASIC program and invokes the FlashBASIC or BASIC debugger.

Use the deffun statement to define a user-written external function (for example, an external sub-routine invoked using CALL).

The del statement provides an alternate to the delete() function for deleting a location from a dynamic array.

The delete statement removes a specific item from a file.

The dimension statement establishes a specific number of storage locations for a matrix of variables.

The echo statement toggles terminal echo on or off.

The end statement indicates both the end of a series of statements executed conditionally from a then or else condition or the physical end of the program.

The end case statement terminates case construct.

The enter statement transfers control to another cataloged FlashBASIC or BASIC program.

The equate statement is a compiler directive that declares a constant at compile time or a synonym of another variable or array element.

The error statement displays the error message from the messages file and continues execution of the program.

The execute statement temporarily pushes a level and performs any valid TCL expression, and then continues execution of the FlashBASIC or BASIC program.

The execute statement executes a UNIX command from within a FlashBASIC or BASIC program.

The exit statement forces an early exit from a loop that is under for...next or loop...repeat control.

The file statement is a compiler directive that allows the use of attribute definition items in the file’s dictionary while compiling a program.

The filelock statement sets an exclusive lock on an entire file.

The fileunlock statement releases an exclusive lock set by the filelock statement on an entire file.

The footing statement designates a text string composed of literals and special options to output at the bottom of each page.

The for...next statement is an iterative, incremental loop statement used to repeat a sequence of statements for a specific number of occurrences.

User-defined functions can be defined within a program. They can be used like sub-routines invoked with gosub or called externally like sub-routines invoked with call.

The get statement gets raw characters from the specified port.

The getx statement receives input from an attached line in ASCII hexadecimal format. The statement returns an exploded ASCII hexadecimal string that allows binary data to contain a decimal 255 (x’ff’)

The gosub statement transfers control to a local subroutine identified by a statement label within the program. Control returns to the next statement after the gosub statement when the return statement is encountered.

The goto statement transfers control to the location in the FlashBASIC or BASIC program that begins with the given statement label.

The heading statement designates a text string composed of literals and special options to output at the top of each page.

The if statement tests the result of a logical expression. Depending on whether the expression evaluates to either true or false, the statements following the then or else clauses, respectively, are executed.

The ifr statement tests the result of a logical expression.

The in statement accepts a single raw character of input from the keyboard, without displaying a prompt character or requiring pressing ENTER following the input.

The input statement temporarily suspends execution of the program until a response is provided from the keyboard, and then assigns that response to a specified variable.

The inputclear statement clears the keyboard type-ahead buffer.

The inputctrl statement is used to enable or suppress control characters in BASIC input statements.

The inputerr statement displays a message on the status (bottom) line of the terminal. it meant to be used with the input@ statement.

When run from a trigger, from the D3 File Manager, or from a Visual Basic rule module, the inputerr statement displays a dialog box (allowing the user to specify the title, text, and buttons), then waits for input. Upon return, the system(0) function returns a numeric code indicating the user choice.

The inputif statement captures input from the type-ahead buffer and assigns the input to a variable.

The inputnull statement is used with the input @ statement to define the character used to indicate a null input on subsequent input statements.

The inputparity statement enables or disables the extended character set (xcs) for the current process.

The inputtrap...gosub statement, using the str.exp, sets up an automatic computed gosub based on the next input @ statement data. The position of the character in the string expression corresponds to the position of the statement label in the list. This acts as a trap that causes a gosub on all subsequent input @ statements.

The inputtrap...goto statement, using the str.exp, sets up an automatic computed goto based on the next input @ statement’s data. The position of each character in the string expression corresponds to the position of the statement label in the list. This acts as a trap that causes a goto on all subsequent input @ statements and branches to a label in the current program.

The inputtrap off statement cancels the previous inputtrap statement.

The ins statement is an alternative to the insert() function for inserting a string expression into a dynamic array.

The key statement locates an item using a B-tree index key and returns the item in a variable. This provides the ability to sequentially search the items in the file based on the index.

The let statement assigns the value of an expression to a variable.

The locate statement searches for the location of a specific string expression and returns the location in position.var.

The lock statement sets one of 992 execution locks. This prevents re-entry to the program, allowing only one process to run the program at any given time.

The loop statement repetitively executes (loops) until an ending condition is met. The first set of statements, if present, is executed at least once.

The mat statement assigns data to each element of a dimensioned array variable to a specific value in one operation.

The matbuild statement converts a dimensioned array into a dynamic array.

The matparse statement converts a dynamic array into a dimensioned array.

The matread statement reads the specified item from the optionally specified file.var, or if not specified, the default file.var, and stores one attribute per element in the dimensioned array.

The matreadu form of the matread statement tests if an item is already locked and locks the item if it is not. The item lock set by matreadu prevents the item from being read using the matreadu statement or updated by other processes while the lock is set.

The matwrite statement writes an item into the specified file.var.

The matwriteu statement is identical to the matwrite statement, except the item remains locked. The matwriteu form keeps the item locked if it was previously locked by a readu, readvu, or matwriteu statement within the same program.

The next statement occurs at the end of a for...next construct and causes the iteration counter to increment and branches to the corresponding for statement to decide whether to terminate.

The nxtkey statement scans forward through a key file along a key path.

The null statement performs no operation, other than to provide an instruction where one is required. This is usually used for program readability.

The on... gosub statement transfers control to a local subroutine designated by a specific statement label according to the positional value returned by the expression. The syntax can also be specified as on...go sub...(allowing a space between go and sub).

The on...goto statement transfers control to the line within the FlashBASIC or BASIC program that begins with the specified statement label, according to the positional value of the expression referenced by exp. The syntax can also be specified as on...go to...(allowing a space between go and to).

The open statement opens a specified file name and associates the file with the optional file.var.

The out statement outputs a single ASCII character derived from a numeric expression in the range of 0 through 255, which indicates its corresponding position in the ASCII table.

The page statement terminates the current page of output, prints the optional footing, positions to the top of the form, and prints the optional heading.

The precision statement defines the number of fractional decimal places that a numerical value can hold.

The print statement directs output of an expression to the current output device.

The print on statement directs output to one of 32,767 open print files.

The printchar statement prints the first character of the string expression to the screen or to the printer.

The printer statement controls the output from subsequent print, heading, footing, or page statements.

The printerr statement allows BASIC programs to produce output messages using the Error Message Processor and the errmsg file.

The procread statement reads the calling Proc’s primary input buffer and assigns its contents to a specified variable.

The procwrite statement writes a string expression variable to the calling Proc’s primary input buffer.

The program statement is optionally used on the first line of a program to indicate that this is a program.

The prompt statement indicates the single character to display during subsequent input statements that prompt for input from the keyboard.

The prvkey statement operates in the same manner as the nxtkey statement with the exception that the keys returned are those previous to the beginning key value key.

The read statement reads an item as a dynamic array and stores the item as a string. Each attribute is automatically an element of the dynamic array variable and can be referenced with the appropriate intrinsic functions.

The readf statement reads the specified number of characters from a normal item.

The readnext statement retrieves the next item-ID from an active list and assigns it to a specified variable.

The readt statement reads a tape record and assigns the value returned to a specified variable.

The readtx statement reads a tape record, converts the tape record to hexadecimal, and assigns the resulting hexadecimal value to a specified variable.

The readv statement reads an item from the optionally-specified file variable and assigns the value contained in the attribute number referenced in the attribute expression to the specified variable.

The release statement clears locks on items locked with a previous matreadu, readu, or readvu statement.

The rem statement designates that all text that follows the statement on the same line is ignored by the compiler.

The remove statement retrieves a substring delimited by a system delimiter from a dynamic array.

The repeat statement defines the end of a loop. See loop statement for more information.

The replace statement maintains referential integrity between items that contain bidirectional bridges used by the Update processor by eliminating duplicate item-IDs.

The return statement terminates an internal or external subroutine, and returns execution control to the statement following the invoking call or gosub statement.

The rewind statement rewinds the currently attached magnetic tape unit to the beginning of the tape.

The rollback work statement rolls back (or undoes) a transaction.

The root statement provides an interface to the B-tree indexes for subsequent references with the key statement.

The rqm statement suspends processing for a specific number of seconds, or until a specific time.

The select statement creates an active list of item-IDs, allowing sequential access to each item in the file by use of the readnext statement.

The send statement sends output to a specified port.

The sendx statement converts the exploded ASCII hexadecimal string results of str.exp to its binary equivalent and then transmits it to the specified port. The conversion process terminates when the first nonhexadecimal character is encountered. sendx suppresses the output of a CR/LF pair. sendx does not allow the : to exist as part of the statement.

The sleep statement places a process to sleep for a specific number of seconds, or, until a specific time.

The spoolq statement enables or disables the spooler entry number message.

The stop statement stops program execution and returns to the invoking the process.

The subroutine statement defines a program as an external subroutine.

The ta statement toggles or resets the type-ahead buffer.

The tcl statement executes any valid TCL command as a subroutine.

The tclread statement loads the TCL command used to activate the program into a variable.

mvBase Only: The timeout statement specifies the number of seconds the operating environment waits for terminal input before a timeout condition occurs.

The transaction statement enables or disables participation in a transaction.

transaction abort statement

The transaction cache statement enables or disables the transaction read cache.

transaction commit statement

The transaction flush statement enables or disables the transaction flush mechanism.

transaction rollback function

transaction start function

The unlock statement resets an execution lock, in the range 0 to 991, previously set with a lock statement.

The wakeup statement is used for BASIC programs to wake up a different process that is either sleeping or waiting for input at an INPUT statement (which has an associated ELSE clause).

The weof statement writes an eof (end of file) mark to the currently attached magnetic media.

The write statement writes the item specified in dyn.array.var into the specified file, using the item-ID specified in the ID.exp.

The writet statement writes a tape record to the attached magnetic media from the specified variable.

The writetx statement writes a tape record, converts the string from ASCII hex to binary, and copies the string to the tape buffer.

The writeu form of the write statement writes a dynamic array into the specified file variable and keeps items locked that were locked by a previous readu or readvu statement.

The writev statement writes the value of an expression into the attribute designated in the attribute expression parameter, using the item-ID specified in ID.exp.

The writevu form of this statement is identical to writev, except that it keeps items locked that were locked by a previous readu or readvu statement.

The writex statement writes the item specified in dyn.array.var into the specified file, using the item-ID specified in the ID.exp. The writex statement will wait until the actual disk update takes place before continuing execution of the program. This is used for "critical" write-through, such as error-logging.