A B C D E
F G H I
J K L
M N O P
Q R S T
U V W X
Y Z
| numeric = ABS( numeric ) Return the absolute value of any simple numeric type. The return type is the same as the argument. a = +23 |
|
| See SELECT CASE . | |
| integers = integers AND integers Bitwise AND two integer operands to produce an integer result. a = 0x05F0 |
|
| integer = ASC( string ) integer = ASC( string, position ) Return one byte from a string. The first argument is the string to extract the byte from. The second argument is the position of the byte to extract, or 1 if no second argument is given. a$ = "abcde" |
|
| ATTACH arrayNode TO arrayNode Move an array from source node to destination node. If the destination node is not empty a runtime error occurs. After the array is moved to the destination node, the source node is zeroed. ATTACH a[] TO b[] ' attach array to array |
|
| AUTO [typename] variables AUTOX [typename] variables Declare variables with AUTO and AUTOX scope. AUTO a, b$, c[] |
|
| string = BIN$( integers ) string = BINB$( integers ) string = BIN$( integers, digits ) string = BINB$( integers, digits ) Return the binary string representation of an integer. The return string has as many characters as necessary to represent the integer, or the number specified by the second argument, whichever is larger. a = 0xF0F5 |
|
| bitspec = BITFIELD( width, offset ) Return a bitfield specification appropriate for bitfield extract and bitfield intrinsics. The first argument is the width of the bitfield. The second argument is the offset of the bitfield from the least significant bit. Valid widths are 1 to 31, and valid offsets are 0 to 31. Works in prolog given two integer constants, and elsewhere in programs with integer values. $$BYTE0 = BITFIELD(8, 0) ' bits 00-07 : low byte |
|
| See SELECT CASE . | |
| See FUNCTION . | |
| string = CHR$( integer ) string = CHR$( integer, count ) Return a string of 1 or more copies of a character. The first argument is the value of the character. The second argument is the number of copies of the character, which defaults to 1 when not given. a$ = CHR$(32) ' a$ = " " ( 1 space character ) |
|
| string = CJUST$( string, length ) string = LJUST$( string, length ) string = RJUST$( string, length ) Return a string center-justified, left-justified, or right-justified in a field of space characters. The first argument is the string to justify. The second argument is the field width. The return string is always the specified width. If a string cannot be exactly centered, the extra space follows the string. If the string is longer than the field, the string is left justified and clipped at the end of the field. a$ = "cat" |
|
| integer = CLOSE( fileNumber ) Close an open file and return 0 to indicate success. The argument is the filenumber assigned to the file when it was opened. If the argument is not the filenumber of an open file, -1 is returned. err = CLOSE (ifile) ' test for close error |
|
| integer = CLR( integer, bitspec ) integer = CLR( integer, width, offset ) integer = CLR( integer, bitspec ) integer = CLR( integer, width, offset ) integer = SET( integer, bitspec ) integer = SET( integer, width, offset ) integer = SET( integer, bitspec ) integer = SET( integer, width, offset ) Clear or set a field of bits. The first argument is the integer value in which the bits are cleared or set. In the two argument version, the second argument is a bitspec that contains the width and offset of the bitfield to clear or set. In the three argument version the second and third arguments are the width and offset of the bitfield to clear or set. $$TYPE = BITFIELD(5,16) ' in PROLOG |
|
| integer = CSIZE( string ) Return the number of bytes in a string before the first zero byte. a$ = "" |
|
| string = CSIZE$( string ) Return a copy of a zero terminated string. The end of the string is the byte before the first zero byte. a$ = "" |
|
| string = CSTRING$( address ) Return a copy of a string at a memory address. The end of the string is the byte before the first zero byte. This intrinsic converts C style strings into native strings. The string at the specified address is not altered or freed. cstr = cfunc() |
|
| [scope] DCOMPLEX variables Declare double precision complex variables. DCOMPLEX ii, jj, kk |
|
DECLARE FUNCTION |
DECLARE FUNCTION [type] Func ( [parameters] ) EXTERNAL FUNCTION [type] Func ( [parameters] ) INTERNAL FUNCTION [type] Func ( [parameters] ) Declare a function: DECLARE - function in current program, visible to all programs. The optional return type is any built-in or user-defined data type. parameters is an optional comma-separated list of up to 16 built-in or user-defined type names or symbols from which the kind and type of each function argument can be determined. DECLARE FUNCTION Twist () |
| integer = DHIGH( double ) integer = DLOW( double ) Return the high or low 32-bits of a double precision floating point number. The high 32-bits of a double precision floating point number contains the sign bit, exponent, and high part of the mantissa, while the low 32-bits contains the low part of the mantissa. a# = 0d40010802DEADCODE ' a# = double variable |
|
| DIM array [ subscripts ] REDIM array [ subscripts ] Dimension or redimension an array. 0 to 8 comma-separated integer subscripts give the upper bounds for 0 to 8 dimensions. The lower bound of all arrays is 0. When an array is dimensioned, the existing contents are first freed, then memory space
for the array is allocated and filled with zeros. DIM a[] ' a[] becomes an empty array |
|
| See DHIGH() . | |
| double = DMAKE( high32, low32 ) Return a 64-bit double precision floating point number assembled from two 32-bit integer parts. hi = 0x40008000 ' high 32-bits of desired DOUBLE |
|
DO |
DO DO WHILE numString DO UNTIL numString DO DO [level] DO LOOP [level] EXIT DO [level] LOOP LOOP WHILE numString LOOP UNTIL numString DO...LOOP blocks. DO begins a loop, and execution continues on the next line. DO WHILE continues execution on the next line if the numeric or string value is TRUE , otherwise execution continues after the matching LOOP statement. DO UNTIL continues execution on the next line if the numeric or string value is FALSE , otherwise execution continues after the matching LOOP statement. DO DO jumps directly to the DO statement at the beginning of a loop block from anywhere inside the block. DO LOOP jumps directly to the LOOP statement at the end of a loop block from anywhere inside the block. EXIT DO jumps directly past the LOOP statement at the end of the loop block, from anywhere inside the block. LOOP jumps to the matching DO statement. LOOP WHILE jumps to the matching DO statement if the numeric or string expression is TRUE . LOOP UNTIL jumps to the matching DO if the numeric or string expression is FALSE . hash = 0 |
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| See IF . | |
| END FUNCTION [expression] End a function and return a value. If no return expression is given, a zero or empty string is returned. |
|
| See IF . | |
| See SELECT CASE . | |
| See SUB . | |
| See TYPE . | |
| integer = EOF( fileNumber ) Return TRUE if filepointer points beyond the end of a file. a = EOF(ifile) |
|
| error = ERROR( newError ) Return ##ERROR error number and assign a new error number unless newError = -1 . IF ERROR(-1) THEN ' test ##ERROR without clearing it |
|
| error$ = ERROR$( error ) Convert an error number into an error string. error = ERROR(0) ' get error number |
|
| EXIT DO [level] Exit a DO loop. Jump past the n th LOOP statement, where n=1 or level. DO |
|
| EXIT FOR [level] Exit a FOR loop. Jump past the n th NEXT statement, where n=1 or level. FOR i = 0 TO 1000 |
|
| See RETURN . | |
| EXIT IF [level] Exit an IF block. Jump past the n th END IF statement, where n=1 or level. IF enabled THEN |
|
| EXIT SELECT [level] Exit a SELECT CASE block. Jump past the n th END SELECT statement, where n=1 or level. SELECT CASE a |
|
EXIT SUB |
See SUB . |
| EXPORT Begin exporting type and shared constant definitions and function declarations from a program being compiled as a function library. All source lines between EXPORT and END EXPORT statements are put in " filename .dec" . EXPORT |
|
| See Declarations after the alphabetical listing. | |
| EXTERNAL FUNCTION | See DECLARE FUNCTION . |
| integer = EXTS( integer, bitspec ) integer = EXTS( integer, width, offset ) integer = EXTU( integer, bitspec ) integer = EXTU( integer, width, offset ) Extract a signed or unsigned field of bits. The first argument is the integer value from which the bits are extracted. In the two argument version, the second argument is a bitspec that contains the width and offset of the bitfield to extract. In the three argument version the second and third arguments are the width and offset of the bitfield to extract. The extracted bitfield is returned in the low bits of the result, either sign-extended or zero-extended to fill the 32-bit integer result. $$TYPE = BITFIELD(4,16) ' in PROLOG |
|
| See SELECT CASE . | |
| See INT() . | |
| FOR var = numeric TO numeric [ STEP numeric] DO FOR [level] DO NEXT [level] EXIT FOR [level] NEXT [var] Begin and end a FOR ... NEXT loop. DO FOR jumps directly to the FOR statement. DO NEXT jumps directly to the NEXT statement. EXIT FOR jumps directly past the NEXT statement. FOR i = 0 TO last |
|
| string = FORMAT$( format$, argument ) Return a string formatted per a format spec string and argument. FORMAT$() creates and returns a string representation of up a numeric or string argument, formatted according to a format$ string. The following are valid format fields for string arguments: & Print string exactly, no upper or lower length limit The following are valid character sequences for numeric arguments: ### digit positions ###### 54321 x = 23 |
|
| [scope] FUNCADDR [type] variable ( [parameters] ) [scope] FUNCADDR [type] array []( [parameters] ) Declare a FUNCADDR variable or array. STATIC FUNCADDR a ( STRING, XLONG, XLONG, XLONG ) |
|
| See Type Conversion after the alphabetical listing. | |
| funcaddr = FUNCADDRESS( FuncName ()) Return the address of a function. Same as &Func() . process[GetColor] = FUNCADDRESS (XuiGetColor()) |
|
| FUNCTION [type] FuncName ( arguments ) [defaultType] SFUNCTION [type] FuncName ( arguments ) [defaultType] CFUNCTION [type] FuncName ( arguments ) [defaultType] Begin the body of a function. The return type defaults to XLONG unless specified otherwise. The arguments are a comma-separated list of variables receiving input values from calling functions. The type of variables in the function not declared otherwise defaults to XLONG unless a defaultType is specified. FUNCTION denotes a normal function. SFUNCTION denotes operating system functions with standard operating system function protocol, or native functions to be called by the operating system expecting standard operating system protocol (STDCALL) . CFUNCTION denotes C functions or native functions to be called by functions expecting standard C function protocol (CDECL) . FUNCTION Blivit ( a, b, c$, d[] ) |
|
| integer = GHIGH( giant ) Return the high or low 32-bits of a 64-bit signed integer. a$$ = 0x40010802DEADCODE ' a$$ = giant variable |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| See GHIGH() . | |
| giant = GMAKE( high32, low32 ) Return a 64-bit signed integer assembled from two 32-bit integers. hi = 0x40008000 ' hi 32-bits of desired GIANT |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| goaddr = GOADDRESS( label ) Return the address of a GOTO label. g = GOADDRESS (label) |
|
| GOSUB SubName GOSUB @ subVar GOSUB @ subArray [ indices ] Call a subroutine directly, through a variable, or through an array. GOSUB subroutine |
|
| GOTO label Jump to a label directly, through a variable, or through an array. GOTO label |
|
| string = HEX$( integers ) string = HEXX$( integers ) string = HEX$( integers, digits ) string = HEXX$( integers, digits ) Return the hexadecimal string representation of an integer. The return string has as many characters as necessary to represent the integer in hexadecimal, or the number specified by the second argument, whichever is larger. a = 0xDEADC0DE |
|
| integer = HIGH0( integer ) integer = HIGH1( integer ) Return the bit number of the most significant 0 or 1 bit. a = 0x00C03333 |
|
| IF expression THEN statements IF expression THEN statements ELSE statements IF expression THEN statements END IF IF expression THEN statements ELSE statements END IF Execute statements conditionally. IF a THEN PRINT "a is non-zero" |
|
| IMPORT "libname" Import function library libname to make its exported types, constants and functions visible to this program. " libname .dec" is read and compiled, and if it exists, " libname .dll" is loaded, linked to the program, and its entry function is called to initialize the library. IMPORT "xma" |
|
| INC variable DEC variable Add one to a variable or subtract one from a variable. INC a |
|
| integer = INCHR( searchMe$, searchFor$ ) integer = INCHR( searchMe$, searchFor$, start ) integer = INCHRI( searchMe$, searchFor$ ) integer = INCHRI( searchMe$, searchFor$, start ) integer = RINCHR( searchMe$, searchFor$ ) integer = RINCHR( searchMe$, searchFor$, start ) integer = RINCHRI( searchMe$, searchFor$ ) integer = RINCHRI( searchMe$, searchFor$, start ) Search a string for any of the characters in another string. Return the position of the first match. INCHR() = forward search, case sensitive a$ = "Help me please!" |
|
| string = INFILE$( fileNumber ) Return the next line from an open file. FUNCTION FindStringInFile (test$, fileName$) |
|
| string = INLINE$( prompt$ ) Return a line from the standard input device (the keyboard). a$ = INLINE$ ("Enter your name here ===>> ") |
|
| integer = INSTR( searchMe$, searchFor$ ) integer = INSTR( searchMe$, searchFor$, start ) integer = INSTRI( searchMe$, searchFor$ ) integer = INSTRI( searchMe$, searchFor$, start ) integer = RINSTR( searchMe$, searchFor$ ) integer = RINSTR( searchMe$, searchFor$, start ) integer = RINSTRI( searchMe$, searchFor$ ) integer = RINSTRI( searchMe$, searchFor$, start ) Search a string for another string. Return the position of the match. INSTR() = forward search, case sensitive a$ = "HEALTHY, wealthy, and wise!" |
|
| float = INT( float ) float = FIX( float ) Return argument rounded toward nearest integer or toward zero. b# = 2.552 |
|
| INTERNAL FUNCTION | See DECLARE FUNCTION . |
| string = LCASE$( string ) string = UCASE$( string ) Convert all characters in a string to lower case or upper case. a$ = LCASE$ ("THE big LIE") ' a$ = "the big lie" |
|
| string = LCLIP$( string ) string = LCLIP$( string, count ) string = RCLIP$( string ) string = RCLIP$( string, count ) Clip characters off the left or right end of a string. a$ = LCLIP$ ("This old man", 5) ' a$ = "old man" |
|
| string = LEFT$( string ) string = LEFT$( string, length ) string = RIGHT$( string ) string = RIGHT$( string, length ) Copy the first or last characters from a string. The first argument is the string to copy characters from. The second argument is the desired length of the result string, or 1 if no second argument is given. If the string has fewer characters than the desired length, the result string is a copy of the argument string. x$ = "This old man" |
|
| integer = LEN( string ) Return the number of characters in a string. x$ = "" |
|
| integer = LIBRARY( integer ) Return $$TRUE if program is compiled as library. FUNCTION Entry () |
|
| See CJUST$() . | |
| integer = LOF( fileNumber ) Return the length of a disk file. The argument is the filenumber. FUNCTION GimmeFile (filename$) |
|
| See DO . | |
| See TRIM$() . | |
| integer = MAKE( integer, bitspec ) integer = MAKE( integer, width, offset ) Shift a field of bits up from the least significant bits. The first argument contains the source bitfield in its least significant bits. In the two argument version, the second argument is a bitspec that contains the width and offset of the bitfield to create. In the three argument version the second and third arguments are the width and offset of the bitfield to create. The bitfield of the specified width is shifted left from the least significant bits by offset bits. All bits outside the bitfield are cleared. i = 0xAAAAAAAA ' i = 0b10101010101010101010101010101010 |
|
| numeric = MAX( numeric, numeric ) numeric = MIN( numeric, numeric ) Return the maximum or minimum of two values. Maximum means closest to positive infinity and negative means closest to negative infinity. Both values must be the same data type, and the result is the same type as the arguments. a = 23 |
|
| string = MID$( string, start ) string = MID$( string, start, length ) Copy part of a string. The first argument is the string to copy from. The second argument is the position of the first character to copy. The third argument is the number of characters to copy. If no third argument is given, the rest of the characters in the string are copied. x$ = "This old man" |
|
| See MAX() | |
| integers = numeric MOD numeric Return the integer modulus, which is the remainder from a division. Floating point operands are converted to XLONG before the modulus operation is performed. a = 23 : b = 5 : c = 9 : d = 2 |
|
| See FOR . | |
| integer = NOT integer Return an integer with all bits inverted. a = 0xAAAAFF00 |
|
| string = NULL$( length ) Create a string of null characters. The argument is the number of null characters in the result string. The string returned has the specified number of null characters, plus the additional null character that serves as a terminator. The null terminator is not part of the string and must not be changed. FUNCTION GimmeFile (filename$) |
|
| string = OCT$( integers ) string = OCTO$( integers ) string = OCT( integers, digits ) string = OCTO$( integers, digits ) Return the octal string representation of an integer. The return string has as many characters as necessary to represent the integer in octal, or the number specified by the second argument, whichever is larger. a = 0o00007643210 |
|
| integer = OPEN( fileName$, mode ) Open a disk file. The first argument is the filename. The second argument contains an integer value that determines how the file will be open as follows (values from xst.dec ): 0x00 = $$RD = Open existing file for reading only. Opening an existing file prepares the existing file for reading and/or writing, or if no file yet exists, creates a new file. Opening a new file deletes any existing file with the same name before it creates the new, empty file. The filenumber of the opened file is returned. FUNCTION UpperFile (filename$, newname$) |
|
| integers = integers OR integers Bitwise OR two integer operands to produce an integer result. a = 0x05F5 |
|
| integer = POF( fileNumber ) Return the position of the file pointer for an open diskfile. The argument is the filenumber of the open file. ifile = OPEN (filename$, $$RD) ' open a file to read |
|
| PRINT [ [fileNumber , ] ] [ arguments ] [ , | ; ] Print numeric and/or string arguments to display screen or disk file. No space is printed between arguments separated by a semi-colon, though each subsequent semi-colon prints one space. Arguments preceded by a comma are spaced to the next tab position before they are printed. A semi-colon at the end of the argument list suppresses the newline character ( "\n" ) that is otherwise printed. age = 25 |
|
| PROGRAM " name " Begin and name a program. Argument must be a literal string. PROGRAM statements are required when compiling libraries. PROGRAM "xma" |
|
| string = PROGRAM$( integer ) Return program name defined in PROGRAM statement. program$ = PROGRAM$(0) |
|
| [integer = ] QUIT( integer ) Quit a program and return to program that ran this one, which usually is the operating system. The return value is lost since the program is terminated before it can return from the call. The argument is passed to the program that ran the current program. IF #terminate THEN |
|
| See LCLIP$() . | |
| READ [ fileNumber ] , variables Read data from a disk file into variables. The first argument is the filenumber of the file to read from. The variables can be any combination of numeric variables, string variables, composite variables, composite variable components, or one dimensional arrays of any type except strings. The number of bytes read into each variable equals the data size of the variable. For example, one byte is read into SBYTE and UBYTE variables, two bytes into SSHORT and USHORT variables, etc. This is true even though simple variables shorter than 32-bit are held in memory as 32-bit or 64-bit values. In cases where the data size and storage size are not equal, the data size is read, zero or sign-extended to 32-bits or 64-bits, then saved in the storage variable. When data is read into a string variable, the number of bytes needed to fill the string are read directly into the string, overwriting the previous contents. When data is read into an array variable, the number of bytes needed to fill the array are read directly into the array, overwriting the previous contents. READ and WRITE are complementary statements. DIM a[31] |
|
| See DIM . | |
| RETURN [expression] EXIT FUNCTION [expression] Return from the currently executing function to the one that called it. The value of the expression is returned to the calling function. If no expression is given, a zero or empty string is returned. RETURN ' return zero or empty string |
|
| See LEFT$() . | |
| See INCHR() . | |
| See INCHR() . | |
| See INSTR() . | |
| See INSTR() . | |
| See CJUST$() . | |
| integer = ROTATER( integer, count ) Closed rotate bits right any number of bits. Bits shifted out the least significant bit are recirculated back into the most significant bit. x = 0xDEADC0DE |
|
| See TRIM$() . | |
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| [scope] SCOMPLEX variables Declare single precision complex variables. Also see Declarations after the alphabetical listing. SCOMPLEX ii, jj, kk |
|
| [filePointer = ] SEEK( fileNumber, filePointer ) Move the file pointer of a file to a new position. The new position can be beyond the end of the file. SEEK (dataFile, recordNumber * recordSize) |
|
| SELECT CASE TRUE SELECT CASE FALSE SELECT CASE expression SELECT CASE ALL TRUE SELECT CASE ALL FALSE SELECT CASE ALL expression END SELECT Begin a multi-way decision block and establish the test expression that subsequent CASE statements test against. The test expression can be TRUE, FALSE, or a numeric or string expression. Each expression in the subsequent CASE statements is tested against the test expression. If any expression matches the test expression, the statements following the CASE statement are executed, up to the next CASE or END SELECT statement. To match TRUE requires a non-zero number or a non-empty string. To match FALSE requires a zero number or an empty string. To match expression requires an equal numeric value or string. Normal SELECT CASE blocks are called one-of-many decision blocks because at most one CASE statement block is executed. This occurs because an invisible jump past the matching END SELECT is inserted before every CASE statement except the first. SELECT CASE ALL blocks are called n-of-many decision blocks because all CASE statements are tested for matches. Whether or not the code in the preceding block was executed, tests are performed for each successive CASE statement. END SELECT marks the end of every SELECT CASE block. SELECT CASE a ' test against the contents of a |
|
| See CLR() . | |
| See FUNCTION . | |
| integer = SGN( numeric ) integer = SIGN( numeric ) Return the sign of a number. If the argument is negative, return -1 . If the argument is positive, return +1 . If the argument is zero, SGN() returns 0 while SIGN() returns +1 . i = -23 |
|
| See Declarations after the alphabetical listing. | |
| [integer = ] SHELL( command$ ) Execute a program. The command string executes as it would at an operating system prompt except the full program name including extent must be specified. Control then returns control to the program. Some operating systems support concurrent execution of both processes, meaning the program does not wait until the newly started program completes. SHELL ("xb.exe acircle.x -bc") ' wait for xb.exe to complete |
|
| See SGN() . | |
| See STRING() . | |
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| integer = SIZE( typename ) integer = SIZE( variable ) integer = SIZE( array []) integer = SIZE( array [ n ]) integer = SIZE( array [ n ,]) integer = SIZE( composite ) integer = SIZE( composite.component ) integer = SIZE( composite.component []) integer = SIZE( composite.component [ n ]) integer = SIZE( composite.componentString ) Return the size of data in bytes. The argument can be a built-in or user-defined typename, a numeric or string variable, the highest dimension of an array [] , an array [ n ] element, an intermediate dimension of an array [ n ,] , a composite variable, a component of a composite variable, a component [] array, a component [ n ] array element, or a componentString. name$ = "John Galt" |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| single = SMAKE( integer ) Change the type of a 32-bit integer to SINGLE . The bit pattern of the return value is the same as the integer argument, but the return type is SINGLE . x = 0x48000000 ' x = 0x48000000 ( a large integer number) |
|
| string = SPACE$( length ) Create a string of space characters. The length of the return string is given by the argument. a$ = SPACE$(4) ' a$ = " " |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| See Declarations after the alphabetical listing. | |
| See FOR . | |
| string = STRING( numeric ) string = STRING$( numeric ) string = SIGNED$( numeric ) string = STR$( numeric ) Convert a numeric argument into a string. The only difference between these intrinsics is the form the sign takes in the returned string. STRING() and STRING$() puts a leading "-" on negative numbers and nothing on positive numbers. SIGNED$() puts a leading "+" or "-" on all numbers, including "+0" . STR$() puts a leading "-" on negative numbers and a leading space character " " on positive numbers. a# = -23.456 |
|
| string = STUFF( stringInto$, stringFrom$, start ) string = STUFF( stringInto$, stringFrom$, start, length ) Stuff one string into another. Stuff stringFrom$ into stringInto$ starting at start. Stuff no more than length characters. x$ = "This lazy man" |
|
| SUB SubroutineName SUB - Begin subroutine. A subroutine is a portion of a function that can be called only from within the same function by GOSUB SubroutineName. END SUB returns to the statement following the GOSUB . SUB Sandwitch |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| subaddr = SUBADDRESS( label ) Return the address of a subroutine. g = SUBADDRESS (SubName) ' g = address of subroutine SubName |
|
| SWAP string, string SWAP variable, variable SWAP arrayNode, arrayNode Swap the contents of: SWAP a, b ' swap XLONG variables |
|
| TAB( integer ) Append spaces to PRINT string to reach a horizontal character position. TAB() is valid only in PRINT statements. PRINT a; TAB(10); b; TAB(24); c; TAB(40); d$; TAB(60); e |
|
| See IF . | |
| See FOR . | |
| string = TRIM$( string ) string = LTRIM$( string ) string = RTRIM$( string ) Trim whitespace and non-printable characters from both ends of a string, the left end of a string, or the right end of a string. All characters from 0x00 to 0x20 and 0x80 to 0xFF are removed. x$ = "\n\nXXX\t\0\1\2 " |
|
| See SELECT CASE . | |
| TYPE TypeName UNION END TYPE END UNION Declare user-defined composite types and begin/end union overlays. UNION statements are valid only within TYPE declaration blocks. TYPE COLOR |
|
| integer = TYPE( typeName ) integer = TYPE( typeName.component ) integer = TYPE( variable ) integer = TYPE( variable.component ) integer = TYPE( array []) integer = TYPE( array [ subscripts ,]) Return the type number of a built-in type, composite type, composite type component, variable, component of a composite variable, array, or array node. Shared constants are defined for the built-in types. User-defined types are assigned during compilation. A given user-defined type is not necessarily assigned the same type number on subsequent compilations, or from library to library. Don't make any assumptions about the assignment of type numbers in function libraries or other external modules. a = TYPE(SLONG) ' a = type number of SLONG ($$SLONG) |
|
| integer = UBOUND( string ) integer = UBOUND( array []) integer = UBOUND( array [ subscripts ,]) Return the upper bound of a string or array dimension. x$ = "" |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| See LCASE$() . | |
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| See TYPE . | |
| See DO . | |
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| VERSION " number " Give the program a version number. Argument must be literal string. VERSION "0.1234" |
|
| string = VERSION$( integer ) Return version number string defined in VERSION statement. version$ = VERSION$(0) |
|
| See DECLARE and FUNCTION . | |
| See DO . | |
| WRITE [ fileNumber ] , variables Write variables to a disk file. The first argument is the filenumber of the file to write to. The remaining arguments are any combination of numeric variables, string variables, composite variables, composite variable components, or one dimensional arrays of any type except strings. The number of byte written from each variable equals the data size of the variable. For example, one byte is written from SBYTE and UBYTE variables, two bytes from SSHORT and USHORT variables, four bytes from SLONG and SINGLE variables, etc. This is true even though simple variables shorter than 32-bits are held in memory as 32-bit or 64-bit values. In cases where the data size and storage size are not equal, the least significant part of the variable is written. When a string variable is written, the number of bytes written is the number of bytes in the string.. When an array variable is written, the number of bytes written is the number of bytes in the array. Only one dimension can be written. DIM a[31] ' a[] contains 32 XLONG values |
|
| See Declarations after the alphabetical listing. | |
| See Type Conversions after the alphabetical listing. | |
| See Direct Memory Access after the alphabetical listing. | |
| xlong = XMAKE( integer ) xlong = XMAKE( single ) Make an XLONG value from an integer or single argument. x! = 2.000 |