bs(1)

The expression is executed for its side effects (value, assignment, or function call). The details of expressions follow the description of statement types below.

break exits from the innermost for/while loop.

Clears the symbol table and compiled statements. clear is executed immediately.

Succeeding statements are compiled (overrides the immediate execution default). The optional expression is evaluated and used as a file name for further input. A clear is associated with this latter case. compile is executed immediately.

continue transfers to the loop-continuation of the current for/while loop.

The name and current value of every non-local variable is printed. Optionally, only the named variable is reported. After an error or interrupt, the number of the last statement is displayed. The user-function trace is displayed after an error or stop that occurred in a function.

A call is made to the editor selected by the EDITOR environment variable if it is present, or ed(1) if EDITOR is undefined or null. If the file argument is present on the command line, file is passed to the editor as the file to edit (otherwise no file name is used). Upon exiting the editor, a compile statement (and associated clear) is executed giving that file name as its argument.

Return to system level. The expression is returned as process status.

Change to immediate execution mode (an interrupt has a similar effect). This statement does not cause stored statements to execute (see run below).

The for statement repetitively executes a statement (first form) or a group of statements (second form) under control of a named variable. The variable takes on the value of the first expression, then is incremented by one on each loop, not to exceed the value of the second expression. The third and fourth forms require three expressions separated by commas. The first of these is the initialization, the second is the test (true to continue), and the third is the loop-continuation action (normally an increment).

fun defines the function name, arguments, and local variables for a user-written function. Up to ten arguments and local variables are allowed. Such names cannot be arrays, nor can they be I/O associated. Function definitions cannot be nested. Calling an undefined function is permissible; see function calls below.

A way to signal the failure of a user-written function. See the interrogation operator (?) below. If interrogation is not present, freturn merely returns zero. When interrogation is active, freturn transfers to that expression (possibly by-passing intermediate function returns).

Control is passed to the internally stored statement with the matching label.

ibase sets the input base (radix) to n. The only supported values for n are the constants 8, 10 (the default), and 16. Hexadecimal values 10-15 are entered as a-f. A leading digit is required (i.e., f0a must be entered as 0f0a). ibase (and obase discussed below) are executed immediately.

The statement (first form) or group of statements (second form) is executed if the expression evaluates to non-zero. The strings 0 and "" (null) evaluate as zero. In the second form, an optional else provides for a second group of statements to be executed when the first group is not. The only statement permitted on the same line with an else is an if; only other fis can be on the same line with a fi. The concatenation of else and if into an elif is supported. Only a single fi is required to close an if ... elif ... [ else ... ] sequence.

expression must evaluate to a file name. The file must contain bs source statements. Such statements become part of the program being compiled. include statements cannot be nested.

obase sets the output base to n (see ibase above).

onintr provides program control of interrupts. In the first form, control passes to the label given, just as if a goto had been executed at the time onintr was executed. The effect of the statement is cleared after each interrupt. In the second form, an interrupt causes bs to terminate.

The expression is evaluated and the result is passed back as the value of a function call. If no expression is given, zero is returned.

The random number generator is reset. Control is passed to the first internal statement. If the run statement is contained in a file, it should be the last statement.

Execution of internal statements is stopped. bs reverts to immediate mode.

The trace statement controls function tracing. If the expression is null (or evaluates to zero), tracing is turned off. Otherwise, a record of user-function calls/returns is printed. Each return decrements the trace expression value.

while is similar to for except that only the conditional expression for loop-continuation is given.

An immediate escape to the shell.

This statement is ignored (treated as a comment).

A name is used to specify a variable. Names are composed of a letter (uppercase or lowercase) optionally followed by letters and digits. Only the first six characters of a name are significant. Except for names declared in fun statements, all names are global to the program. Names can take on numeric (double float) values, string values, or can be associated with input/output (see the built-in function open() below).

Functions can be called by a name followed by the arguments in parentheses separated by commas. Except for built-in functions (listed below), the name must be defined with a fun statement. Arguments to functions are passed by value. If the function is undefined, the call history to the call of that function is printed, and a request for a return value (as an expression) is made. The result of that expression is taken to be the result of the undefined function. This permits debugging programs where not all the functions are yet defined. The value is read from the current input file.

This syntax is used to reference either arrays or tables (see built-in table functions below). For arrays, each expression is truncated to an integer and used as a specifier for the name. The resulting array reference is syntactically identical to a name; a[1,2] is the same as a[1][2]. The truncated expressions are restricted to values between 0 and 32767.

A number is used to represent a constant value. A number is written in Fortran style, and contains digits, an optional decimal point, and possibly a scale factor consisting of an e followed by a possibly signed exponent.

Character strings are delimited by " characters. The \ escape character allows the double quote (\ "), new-line (\n), carriage return (\r), backspace (\b), and tab (\t) characters to appear in a string. Otherwise, \ stands for itself.

Parentheses are used to alter the normal order of evaluation.

The bracketed expression is used as a subscript to select a comma-separated expression from the parenthesized list. List elements are numbered from the left, starting at zero.

The expression:

has the value True if the comparison is true.

The interrogation operator tests for the success of the expression rather than its value. At the moment, it is useful for testing end-of-file (see examples in the Programming Tips section below), the result of the eval built-in function, and for checking the return from user-written functions (see freturn). An interrogation ``trap'' (end-of-file, etc.) causes an immediate transfer to the most recent interrogation, possibly skipping assignment statements or intervening function levels.

The result is the negation of the expression.

Increments the value of the variable (or array reference). The result is the new value.

Decrements the value of the variable. The result is the new value.

The logical negation of the expression. Watch out for the shell escape command.

operator expression Common functions of two arguments are abbreviated by the two arguments separated by an operator denoting the function. Except for the assignment, concatenation, and relational operators, both operands are converted to numeric form before the function is applied.

= is the assignment operator. The left operand must be a name or an array element. The result is the right operand. Assignment binds right to left, all other operators bind left to right.

_ (underscore) is the concatenation operator.

& (logical AND) has result zero if either of its arguments are zero. It has result one if both of its arguments are non-zero; | (logical OR) has result zero if both of its arguments are zero. It has result one if either of its arguments is non-zero. Both operators treat a null string as a zero.

The relational operators (<: less than, <=: less than or equal, >: greater than, >=: greater than or equal, ==: equal to, !=: not equal to) return one if their arguments are in the specified relation, or return zero otherwise. Relational operators at the same level extend as follows: a>b>c is equivalent to a>b & b>c. A string comparison is made if both operands are strings.

Add and subtract.

Multiply, divide, and remainder.

Exponentiation.

A table in bs is an associatively accessed, single-dimension array. ``Subscripts'' (called keys) are strings (numbers are converted). The name argument must be a bs variable name (passed as a string). The size argument sets the minimum number of elements to be allocated. bs prints an error message and stops on table overflow. The result of table is name.

The item function accesses table elements sequentially (in normal use, there is no orderly progression of key values). Where the item function accesses values, the key function accesses the ``subscript'' of the previous item call. It fails (or in the absence of an interrogate operator, returns null) if there was no valid subscript for the previous item call. The name argument should not be quoted. Since exact table sizes are not defined, the interrogation operator should be used to detect end-of-table; for example:

If the interrogation operator is not used, the result of item is null if there are no further elements in the table. Null is, however, a legal ``subscript''.

iskey tests whether the key word exists in the table name and returns one for true, zero for false.