mvbasic.json

{
  "ABORT": {
    "prefix": "ABORT",
    "body": ["ABORT $1"],
    "description": "Use the ABORT statement to terminate execution of a BASIC program and return to the UniVerse prompt."
  },
  "ABS": {
    "prefix": "ABS",
    "body": ["ABS($1)"],
    "description": "Use the ABS function to return the absolute value of any numeric expression."
  },
  "ABSS": {
    "prefix": "ABSS",
    "body": ["ABSS($1)"],
    "description": "Use the ABSS function to return the absolute values of all the elements in a dynamic array."
  },
  "ACOS": {
    "prefix": "ACOS",
    "body": ["ACOS($1)"],
    "description": "Use the ACOS function to return the trigonometric arc-cosine of expression."
  },
  "ACTIVATEKEY": {
    "prefix": "ACTIVATEKEY",
    "body": ["ACTIVATEKEY <key.id>, <password> [ON <hostname>]"],
    "description": "Use the ACTIVATEKEY statement to activate a key."
  },
  "ADDS": {
    "prefix": "ADDS",
    "body": ["ADDS(array1, array2)"],
    "description": "Use the ADDS function to create a dynamic array of the element-by-element addition of two dynamic arrays."
  },
  "ALPHA": {
    "prefix": "ALPHA",
    "body": ["ALPHA(expression)"],
    "description": "Use the ALPHA function to determine whether expression is an alphabetic or non-alphabetic string."
  },
  "ANDS": {
    "prefix": "ANDS",
    "body": ["ANDS(array1, array2)"],
    "description": "Use the ANDS function to create a dynamic array of the logical AND of corresponding elements of two dynamic arrays."
  },
  "ASCII": {
    "prefix": "ASCII",
    "body": ["ASCII(expression)"],
    "description": "Use the ASCII function to convert each character of expression from its EBCDIC representation value to its ASCII representation value."
  },
  "ASIN": {
    "prefix": "ASIN",
    "body": ["ASIN(expression)"],
    "description": "Use the ASIN function to return the trigonometric arc-sine of expression."
  },
  "ASSIGNED": {
    "prefix": "ASSIGNED",
    "body": ["ASSIGNED(variable)"],
    "description": "Use the ASSIGNED function to determine if variable is assigned a value."
  },
  "ATAN": {
    "prefix": "ATAN",
    "body": ["ATAN(expression)"],
    "description": "Use the ATAN function to return the trigonometric arc-tangent of expression."
  },
  "AUTHORIZATION": {
    "prefix": "AUTHORIZATION",
    "body": ["AUTHORIZATION \"username\""],
    "description": "Use the AUTHORIZATION statement to specify or change the effective runtime user of a program."
  },
  "AUXMAP": {
    "prefix": "AUXMAP",
    "body": ["AUXMAP { ON | OFF | expression }"],
    "description": "In NLS mode, use the AUXMAP statement to associate an auxiliary device with a terminal."
  },
  "BITAND": {
    "prefix": "BITAND",
    "body": ["BITAND(expression1, expression2)"],
    "description": "Use the BITAND function to perform the bitwise AND comparison of two integers specified by numeric expressions."
  },
  "BITNOT": {
    "prefix": "BITNOT",
    "body": ["BITNOT(expression [,bit#])"],
    "description": "Use the BITNOT function to return the bitwise negation of an integer specified by any numeric expression."
  },
  "BITOR": {
    "prefix": "BITOR",
    "body": ["BITOR(expression1, expression2)"],
    "description": "Use the BITOR function to perform the bitwise OR comparison of two integers specified by numeric expressions."
  },
  "BITRESET": {
    "prefix": "BITRESET",
    "body": ["BITRESET(expression, bit#)"],
    "description": "Use the BITRESET function to reset to 0 the bit number of the integer specified by expression."
  },
  "BITSET": {
    "prefix": "BITSET",
    "body": ["BITSET(expression, bit#)"],
    "description": "Use the BITSET function to set to 1 the bit number of the integer specified by expression."
  },
  "BITTEST": {
    "prefix": "BITTEST",
    "body": ["BITTEST(expression, bit#)"],
    "description": "Use the BITTEST function to test the bit number of the integer specified by expression."
  },
  "BITXOR": {
    "prefix": "BITXOR",
    "body": ["BITXOR(expression1, expression2)"],
    "description": "Use the BITXOR function to perform the bitwise XOR comparison of two integers specified by numeric expressions."
  },
  "BREAK": {
    "prefix": "BREAK",
    "body": ["BREAK [KEY] { ON | OFF | expression }"],
    "description": "Use the BREAK statement to enable or disable the Intr, Quit, and Susp keys on the keyboard."
  },
  "BSCAN": {
    "prefix": "BSCAN",
    "body": [
      "BSCAN ID.variable [, rec.variable] [FROM file.variable [, record]]"
    ],
    "description": "Use the BSCAN statement to scan the leaf nodes of a B-tree file (type 25) or of a secondary index."
  },
  "BYTE": {
    "prefix": "BYTE",
    "body": ["BYTE(expression)"],
    "description": "In NLS mode, use the BYTE function to generate a byte from the numeric value of expression."
  },
  "BYTELEN": {
    "prefix": "BYTELEN",
    "body": ["BYTELEN(expression)"],
    "description": "In NLS mode, use the BYTELEN function to generate the number of bytes contained in the ASCII string value in expression."
  },
  "BYTETYPE": {
    "prefix": "BYTETYPE",
    "body": ["BYTETYPE(value)"],
    "description": "In NLS mode, use the BYTETYPE function to determine the function of a byte in value."
  },
  "BYTEVAL": {
    "prefix": "BYTEVAL",
    "body": ["BYTEVAL(expression [, n] )"],
    "description": "In NLS mode, use the BYTEVAL function to examine the bytes contained in the internal string value of expression."
  },
  "CALL": {
    "prefix": "CALL",
    "body": ["CALL name [([MAT] argument [, [MAT] argument ])]"],
    "description": "Use the CALL statement to transfer program control from the calling program to an external subroutine or program that has been compiled and cataloged."
  },
  "CASE": {
    "prefix": "CASE",
    "body": ["BEGIN CASE"],
    "description": "Use the CASE statement to alter the sequence of instruction execution based on the value of one or more expressions."
  },
  "CATS": {
    "prefix": "CATS",
    "body": ["CATS(array1, array2)"],
    "description": "Use the CATS function to create a dynamic array of the element-by-element concatenation of two dynamic arrays."
  },
  "CHAIN": {
    "prefix": "CHAIN",
    "body": ["CHAIN command"],
    "description": "Use the CHAIN statement to terminate execution of a UniVerse BASIC program and to execute the value of command."
  },
  "CHANGE": {
    "prefix": "CHANGE",
    "body": [
      "CHANGE(expression, substring, replacement [,occurrence [,begin]] )"
    ],
    "description": "Use the CHANGE function to replace a substring in expression with another substring."
  },
  "CHAR": {
    "prefix": "CHAR",
    "body": ["CHAR(expression)"],
    "description": "Use the CHAR function to generate an ASCII character from the numeric value of expression."
  },
  "CHARS": {
    "prefix": "CHARS",
    "body": ["CHARS(dynamic.array)"],
    "description": "Use the CHARS function to generate a dynamic array of ASCII characters from the decimal numeric value of each element of dynamic."
  },
  "CHECKSUM": {
    "prefix": "CHECKSUM",
    "body": ["CHECKSUM(string)"],
    "description": "Use the CHECKSUM function to return a cyclical redundancy code (a checksum value)."
  },
  "CLEAR": {
    "prefix": "CLEAR",
    "body": ["CLEAR [COMMON]"],
    "description": "Use the CLEAR statement at the beginning of a program to set all assigned and unassigned values of variables outside of the common area of the program to 0."
  },
  "CLEARDATA": {
    "prefix": "CLEARDATA",
    "body": ["CLEARDATA"],
    "description": "Use the CLEARDATA statement to flush all data that has been loaded in the input stack by the DATA statement."
  },
  "CLEARFILE": {
    "prefix": "CLEARFILE",
    "body": [
      "CLEARFILE [file.variable] [ON ERROR statements] [LOCKED statements]"
    ],
    "description": "Use the CLEARFILE statement to delete all records in an open dictionary or data file."
  },
  "CLEARPROMPTS": {
    "prefix": "CLEARPROMPTS",
    "body": ["CLEARPROMPTS"],
    "description": "Use the CLEARPROMPTS statement to clear the value of the inline prompt."
  },
  "CLEARSELECT": {
    "prefix": "CLEARSELECT",
    "body": ["CLEARSELECT [ALL | list.number]"],
    "description": "Use the CLEARSELECT statement to clear an active select list."
  },
  "CLOSE": {
    "prefix": "CLOSE",
    "body": ["CLOSE [file.variable] [ON ERROR statements]"],
    "description": "Use the CLOSE statement after opening and processing a file."
  },
  "CLOSESEQ": {
    "prefix": "CLOSESEQ",
    "body": ["CLOSESEQ file.variable [ON ERROR statements]"],
    "description": "Use the CLOSESEQ statement after opening and processing a file opened for sequential processing."
  },
  "COMMIT": {
    "prefix": "COMMIT",
    "body": ["COMMIT [WORK] [THEN statements] [ELSE statements ]"],
    "description": "Use the COMMIT statement to commit all file I/O changes made during a transaction."
  },
  "COMMON": {
    "prefix": "COMMON",
    "body": ["COM[MON] [/name/] variable [,variable ]"],
    "description": "Use the COMMON statement to provide a storage area for variables."
  },
  "COMPARE": {
    "prefix": "COMPARE",
    "body": ["COMPARE(string1, string2 [, justification])"],
    "description": "Use the COMPARE function to compare two strings and return a numeric value indicating the result."
  },
  "CONVERT": {
    "prefix": "CONVERT",
    "body": ["CONVERT expression1 TO expression2 IN variable"],
    "description": "Use the CONVERT statement to replace every occurrence of specific characters in a string with other characters."
  },
  "COS": {
    "prefix": "COS",
    "body": ["COS(expression)"],
    "description": "Use the COS function to return the trigonometric cosine of an angle."
  },
  "COSH": {
    "prefix": "COSH",
    "body": ["COSH(expression)"],
    "description": "Use the COSH function to return the hyperbolic cosine of expression."
  },
  "COUNT": {
    "prefix": "COUNT",
    "body": ["COUNT(string, substring)"],
    "description": "Use the COUNT function to return the number of times a substring is repeated in a string value."
  },
  "COUNTS": {
    "prefix": "COUNTS",
    "body": ["COUNTS(dynamic.array, substring)"],
    "description": "Use the COUNTS function to count the number of times a substring is repeated in each element of a dynamic array."
  },
  "CREATE": {
    "prefix": "CREATE",
    "body": ["CREATE file.variable {THEN statements [ELSE statements] | ELSE"],
    "description": "Use the CREATE statement after an OPENSEQ statement to create a record in a type 1 or type statement fails."
  },
  "CRT": {
    "prefix": "CRT",
    "body": ["CRT [print.list]"],
    "description": "Use the CRT statement to print data on the screen, regardless of whether a PRINTER ON statement has been executed."
  },
  "DATA": {
    "prefix": "DATA",
    "body": ["DATA expression [,expression ]"],
    "description": "Use the DATA statement to place values in an input stack."
  },
  "DATE": {
    "prefix": "DATE",
    "body": ["DATE()"],
    "description": "Use the DATE function to return the numeric value of the internal system date."
  },
  "DBTOXML": {
    "prefix": "DBTOXML",
    "body": [
      "DBTOXML(xml_document, doc_location, u2xmap_file, u2xmap_location,"
    ],
    "description": "To create an XML document from the UniVerse database using UniVerse BASIC, use the DBTOXML function."
  },
  "DCOUNT": {
    "prefix": "DCOUNT",
    "body": ["DCOUNT(string, delimiter)"],
    "description": "Use the DCOUNT function to return the number of delimited fields in a data string."
  },
  "DEACTIVATEKEY": {
    "prefix": "DEACTIVATEKEY",
    "body": ["DEACTIVATEKEY <key.id>, <password> [ON <hostname>]"],
    "description": "Use the DEACTIVATEKEY command to deactivate one or more encryption keys."
  },
  "DEBUG": {
    "prefix": "DEBUG",
    "body": ["DEBUG"],
    "description": "Use the DEBUG statement to invoke RAID, the interactive UniVerse BASIC debugger."
  },
  "DEFFUN": {
    "prefix": "DEFFUN",
    "body": [
      "DEFFUN function [([MAT] argument [, [MAT] argument ] )] [CALLING"
    ],
    "description": "Use the DEFFUN statement to define a user-written function."
  },
  "DEL": {
    "prefix": "DEL",
    "body": ["DEL dynamic.array < field# [,value# [,subvalue#]] >"],
    "description": "Use the DEL statement to delete a field, value, or subvalue from a dynamic array."
  },
  "DELETE": {
    "prefix": "DELETE",
    "body": [
      "DELETE [file.variable ,] record.ID [ON ERROR statements] [LOCKED"
    ],
    "description": "Use the DELETE statements to delete a record from a UniVerse file."
  },
  "DELETELIST": {
    "prefix": "DELETELIST",
    "body": ["DELETELIST listname"],
    "description": "Use the DELETELIST statement to delete a select list saved in the &SAVEDLISTS& file."
  },
  "DESCRINFO": {
    "prefix": "DESCRINFO",
    "body": ["DESCRINFO(key, variable)"],
    "description": "The DESCRINFO function returns requested information (key) about a variable."
  },
  "DIGEST": {
    "prefix": "DIGEST",
    "body": ["DIGEST(algorithm, data, dataLoc, result)"],
    "description": "The DIGEST() function generates a message digest of supplied data."
  },
  "DIMENSION": {
    "prefix": "DIMENSION",
    "body": ["DIM[ENSION] matrix(rows, columns) [, matrix(rows, columns) ]"],
    "description": "Use the DIMENSION statement to define the dimensions of an array variable before referencing the array in the program."
  },
  "DISABLEDEC": {
    "prefix": "DISABLEDEC",
    "body": [
      "DISABLEDEC <filename> [, <multilevel-filename>], {ALL |<field_list>}"
    ],
    "description": "Use the DISABLEDEC command to turn off decryption on a field or fields you specify."
  },
  "DISPLAY": {
    "prefix": "DISPLAY",
    "body": ["DISPLAY [print.list]"],
    "description": "Use the DISPLAY statement to print data on the screen, regardless of whether a PRINTER ON statement has been executed."
  },
  "DIV": {
    "prefix": "DIV",
    "body": ["DIV(dividend, divisor)"],
    "description": "Use the DIV function to calculate the value of the quotient after dividend is divided by divisor."
  },
  "DIVS": {
    "prefix": "DIVS",
    "body": ["DIVS(array1, array2)"],
    "description": "Use the DIVS function to create a dynamic array containing the result of the element-by-element division of two dynamic arrays."
  },
  "DOWNCASE": {
    "prefix": "DOWNCASE",
    "body": ["DOWNCASE(expression)"],
    "description": "Use the DOWNCASE function to change all uppercase letters in expression to lowercase."
  },
  "DQUOTE": {
    "prefix": "DQUOTE",
    "body": ["DQUOTE(expression)"],
    "description": "Use the DQUOTE function to enclose an expression in double quotation marks."
  },
  "DTX": {
    "prefix": "DTX",
    "body": ["DTX(number [,size] )"],
    "description": "Use the DTX function to convert a decimal integer to its hexadecimal equivalent."
  },
  "EBCDIC": {
    "prefix": "EBCDIC",
    "body": ["EBCDIC(expression)"],
    "description": "Use the EBCDIC function to convert each character of expression from its ASCII representation value to its EBCDIC representation value."
  },
  "ECHO": {
    "prefix": "ECHO",
    "body": ["ECHO {ON | OFF | expression}"],
    "description": "Use the ECHO statement to control the display of input characters on the screen."
  },
  "ENABLEDEC": {
    "prefix": "ENABLEDEC",
    "body": [
      "ENABLEDEC <filename> [, <multilevel-filename>], { ALL |<field_list>}"
    ],
    "description": "Use the ENABLEDEC command to activate decryption on a file or fields you specify."
  },
  "ENCODE": {
    "prefix": "ENCODE",
    "body": ["ENCODE(algorithm, action, data, dataLoc, result, resultLoc)"],
    "description": "The ENCODE() function performs data encoding on input data."
  },
  "ENCRYPT": {
    "prefix": "ENCRYPT",
    "body": [
      "ENCRYPT(algorithm, action, data, dataLoc,key, keyLoc, keyAction, salt,"
    ],
    "description": "The ENCRYPT() function performs symmetric encryption operations."
  },
  "END": {
    "prefix": "END",
    "body": ["END"],
    "description": "Use the END statement to terminate a BASIC program or a section of an IF statement, READ statement, or OPEN statement."
  },
  "ENTER": {
    "prefix": "ENTER",
    "body": ["ENTER subroutine"],
    "description": "Use the ENTER statement to transfer program control from the calling program to an external subroutine without returning to the calling program."
  },
  "EQS": {
    "prefix": "EQS",
    "body": ["EQS(array1, array2)"],
    "description": "Use the EQS function to test if elements of one dynamic array are equal to the elements of another dynamic array."
  },
  "EQUATE": {
    "prefix": "EQUATE",
    "body": ["EQU[ATE] symbol TO expression [,symbol TO expression ]"],
    "description": "In an EQUATE statement, symbol represents the value of expression or string."
  },
  "EREPLACE": {
    "prefix": "EREPLACE",
    "body": [
      "EREPLACE(expression, substring, replacement [,occurrence [,begin]] )"
    ],
    "description": "Use the EREPLACE function to replace substring in expression with another substring."
  },
  "ERRMSG": {
    "prefix": "ERRMSG",
    "body": ["ERRMSG message.ID [,message.ID ]"],
    "description": "Use the ERRMSG statement to print a formatted error message from the ERRMSG file."
  },
  "EXCHANGE": {
    "prefix": "EXCHANGE",
    "body": ["EXCHANGE(string, xx, yy)"],
    "description": "Use the EXCHANGE function to replace one character with another or to delete all occurrences of the specified character."
  },
  "EXECUTE": {
    "prefix": "EXECUTE",
    "body": ["EXECUTE $1 CAPTURING RESULTS"],
    "description": "Use the EXECUTE statement to execute UniVerse commands from within the BASIC program and then return execution to the statement following the EXECUTE statement."
  },
  "EXIT": {
    "prefix": "EXIT",
    "body": ["EXIT"],
    "description": "Use the EXIT statement to quit execution of a FOR."
  },
  "EXP": {
    "prefix": "EXP",
    "body": ["EXP(expression)"],
    "description": "Use the EXP function to return the value of e raised to the power designated by expression."
  },
  "EXTRACT": {
    "prefix": "EXTRACT",
    "body": ["EXTRACT(dynamic.array, field#[,value# [,subvalue#]] )"],
    "description": "Use the EXTRACT function to access the data contents of a specified field, value, or subvalue from a dynamic array."
  },
  "FADD": {
    "prefix": "FADD",
    "body": ["CALL !FADD(return.array, number1, number2)"],
    "description": "Use the FADD function to perform floating-point addition on two numeric values."
  },
  "FDIV": {
    "prefix": "FDIV",
    "body": ["FDIV(number1, number2)"],
    "description": "Use the FDIV function to perform floating-point division on two numeric values."
  },
  "FFIX": {
    "prefix": "FFIX",
    "body": ["FFIX(number)"],
    "description": "Use the FFIX function to convert a floating-point number to a numeric string with fixed precision."
  },
  "FFLT": {
    "prefix": "FFLT",
    "body": ["FFLT(number)"],
    "description": "Use the FFLT function to round a number to a string with a precision of 13."
  },
  "FIELD": {
    "prefix": "FIELD",
    "body": ["FIELD(string, delimiter, occurrence [,num.substr] )"],
    "description": "Use the FIELD function to return one or more substrings located between specified delimiters in string."
  },
  "FIELDS": {
    "prefix": "FIELDS",
    "body": ["FIELDS(dynamic.array, delimiter, occurrence [ ,num.substr] )"],
    "description": "Use the FIELDS function to return a dynamic array of substrings located between specified delimiters in each element of dynamic."
  },
  "FIELDSTORE": {
    "prefix": "FIELDSTORE",
    "body": ["FIELDSTORE(string, delimiter, start, n, new.string)"],
    "description": "Use the FIELDSTORE function to modify character strings by inserting, deleting, or replacing fields separated by specified delimiters."
  },
  "FIELDWRITE": {
    "prefix": "FIELDWRITE",
    "body": ["FIELDWRITE[U] expression {ON | TO} [file.variable,] record.ID,"],
    "description": "The FIELDWRITE statement allows you to update the specified fields in an existing record and releases locks set by the same process."
  },
  "FILEINFO": {
    "prefix": "FILEINFO",
    "body": ["FILEINFO(file.variable , key )"],
    "description": "Use the FILEINFO function to return information about the specified files configuration, such as the specified files parameters, its modulus and load, its operating system file name, and its VOC name."
  },
  "FILELOCK": {
    "prefix": "FILELOCK",
    "body": [
      "FILELOCK [file.variable] [, lock.type] [ON ERROR statements] [LOCKED"
    ],
    "description": "Use the FILELOCK statement to acquire a lock on an entire file."
  },
  "FILEUNLOCK": {
    "prefix": "FILEUNLOCK",
    "body": ["FILEUNLOCK [file.variable] [ON ERROR statements]"],
    "description": "Use the FILEUNLOCK statement to release a file lock set by the FILELOCK statement."
  },
  "FIND": {
    "prefix": "FIND",
    "body": [
      "FINDelement IN dynamic.array [,occurrence] SETTING fmc [,vmc [,smc]]"
    ],
    "description": "Use the FIND statement to locate an element in dynamic."
  },
  "FINDSTR": {
    "prefix": "FINDSTR",
    "body": [
      "FINDSTRsubstring IN dynamic.array [,occurrence] SETTING fmc [,vmc"
    ],
    "description": "Use the FINDSTR statement to locate substring in dynamic."
  },
  "FIX": {
    "prefix": "FIX",
    "body": ["FIX(number [,precision [,mode]] )"],
    "description": "Use the FIX function to convert a numeric value to a floating-point number with a specified precision."
  },
  "FLUSH": {
    "prefix": "FLUSH",
    "body": ["FLUSH file.variable {THEN statements [ELSE statements] | ELSE"],
    "description": "The FLUSH statement causes all the buffers for a sequential I/O file to be written immediately."
  },
  "FMT": {
    "prefix": "FMT",
    "body": ["FMT(expression, format)expressionformat"],
    "description": "Use the FMT function or a format expression to format data for output."
  },
  "FMTDP": {
    "prefix": "FMTDP",
    "body": ["FMTDP(expression, format [, mapname ] )"],
    "description": "In NLS mode, use the FMTDP function to format data for output in display positions rather than character lengths."
  },
  "FMTS": {
    "prefix": "FMTS",
    "body": ["FMTS(dynamic.array, format)"],
    "description": "Use the FMTS function to format elements of dynamic."
  },
  "FMTSDP": {
    "prefix": "FMTSDP",
    "body": ["FMTSDP(dynamic.array, format [, mapname] )"],
    "description": "In NLS mode, use the FMTSDP function to format elements of dynamic."
  },
  "FMUL": {
    "prefix": "FMUL",
    "body": ["FMUL(number1, number2)"],
    "description": "Use the FMUL function to perform floating-point multiplication on two numeric values."
  },
  "FOLD": {
    "prefix": "FOLD",
    "body": ["FOLD(string, length )"],
    "description": "Use the FOLD function to divide a string into a number of substrings separated by field marks."
  },
  "FOLDDP": {
    "prefix": "FOLDDP",
    "body": ["FOLDDP(string, length [, mapname ] )"],
    "description": "In NLS mode, use the FOLDDP function to divide a string into a number of substrings separated by field marks."
  },
  "FOOTING": {
    "prefix": "FOOTING",
    "body": ["FOOTING [ON print.channel] footing"],
    "description": "Use the FOOTING statement to specify the text and format of the footing to print at the bottom of each page of output."
  },
  "FOR": {
    "prefix": "FOR",
    "body": ["FOR I = 1 TO DCOUNT($1,@VM)", "NEXT I"],
    "description": "Use the FOR statement to create a FORNEXT program loop."
  },
  "FORMLIST": {
    "prefix": "FORMLIST",
    "body": ["FORMLIST $1"],
    "description": "The FORMLIST statement is the same as the SELECT statements."
  },
  "FSUB": {
    "prefix": "FSUB",
    "body": ["FSUB($1, )"],
    "description": "Use the FSUB function to perform floating-point subtraction on two numeric values."
  },
  "FUNCTION": {
    "prefix": "FUNCTION",
    "body": ["FUNCTION [name] [( [MAT] variable [, [MAT] variable ] )]"],
    "description": "Use the FUNCTION statement to identify a user-written function and to specify the number and names of the arguments to be passed to it."
  },
  "GES": {
    "prefix": "GES",
    "body": ["GES(array1, array2)"],
    "description": "Use the GES function to test if elements of one dynamic array are greater than or equal to corresponding elements of another dynamic array."
  },
  "GET": {
    "prefix": "GET",
    "body": [
      "GET[X]read.var[, length] [SETTING read.count] FROM device [UNTIL"
    ],
    "description": "Use GET statements to read a block of data from an input stream associated with a device, such as a serial line or terminal."
  },
  "GETX": {
    "prefix": "GETX",
    "body": ["GET(ARG. [,arg#] ) variable [THEN statements] [ELSE statements]"],
    "description": "Use the GETX statement to read a block of data from an input stream and return the characters in ASCII hexadecimal format."
  },
  "GETLIST": {
    "prefix": "GETLIST",
    "body": [
      "GETLIST listname [IN start, end] [TO list.number] [SETTING variable]"
    ],
    "description": "Use the GETLIST statement to activate a saved select list so that a READNEXT statement can use it."
  },
  "GETLOCALE": {
    "prefix": "GETLOCALE",
    "body": ["GETLOCALE(category)"],
    "description": "In NLS mode use the GETLOCALE function to return the names of specified categories of the current locale."
  },
  "GETREM": {
    "prefix": "GETREM",
    "body": ["GETREM(dynamic.array)"],
    "description": "Use the GETREM function after the execution of a REMOVE statement, a REMOVE function, or a REVREMOVE statement, to return the numeric value for the character position of the pointer associated with dynamic."
  },
  "GOSUB": {
    "prefix": "GOSUB",
    "body": ["GOSUB $1"],
    "description": "Use the GOSUB statement to transfer program control to an internal subroutine referenced by statement."
  },
  "GOTO": {
    "prefix": "GOTO",
    "body": ["GO[TO] statement.label [:]"],
    "description": "Use the GOTO statement to transfer program control to the statement specified by statement."
  },
  "GROUP": {
    "prefix": "GROUP",
    "body": ["GROUP(string, delimiter, occurrence [,num.substr] )"],
    "description": "Use the GROUP function to return one or more substrings located between specified delimiters in string."
  },
  "GROUPSTORE": {
    "prefix": "GROUPSTORE",
    "body": ["GROUPSTORE new.string IN string USING start, n [ ,delimiter]"],
    "description": "Use the GROUPSTORE statement to modify character strings by inserting, deleting, or replacing fields separated by specified delimiters."
  },
  "GTS": {
    "prefix": "GTS",
    "body": ["GTS(array1, array2)"],
    "description": "Use the GTS function to test if elements of one dynamic array are greater than elements of another dynamic array."
  },
  "HEADING": {
    "prefix": "HEADING",
    "body": ["HEADING [ON print.channel] heading"],
    "description": "Use the HEADING statement to specify the text and format of the heading to print at the top of each page of output."
  },
  "HMAC": {
    "prefix": "HMAC",
    "body": ["hmac= HMAC(hmacAlg, hmacKey, hmacData, [outFormat])"],
    "description": "HMAC (keyed-Hash Message Authentication Code) is a specific construction for calculating a message authentication code (MAC) involving a cryptographic hash function in combination with a secret key."
  },
  "HUSH": {
    "prefix": "HUSH",
    "body": ["HUSH { ON | OFF | expression} [SETTING status ]"],
    "description": "Use the HUSH statement to suppress the display of all output normally sent to a terminal during processing."
  },
  "ICHECK": {
    "prefix": "ICHECK",
    "body": ["ICHECK(dynamic.array [, file.variable] , key [, column#] )"],
    "description": "Use the ICHECK function to check if data you intend to write to an SQL table violates any SQL integrity constraints."
  },
  "ICONV": {
    "prefix": "ICONV",
    "body": ["ICONV($1, \"\")"],
    "description": "Use the ICONV function to convert string to a specified internal storage format."
  },
  "ICONVS": {
    "prefix": "ICONVS",
    "body": ["ICONVS($1, \"\")"],
    "description": "Use the ICONVS function to convert each element of dynamic."
  },
  "IF": {
    "prefix": "IF",
    "body": ["IF $1 THEN", "END"],
    "description": "Use the IF statement to determine program flow based on the evaluation of expression."
  },
  "IFS": {
    "prefix": "IFS",
    "body": ["IFS(dynamic.array, true.array, false.array)"],
    "description": "Use the IFS function to return a dynamic array whose elements are chosen individually from one of two dynamic arrays based on the contents of a third dynamic array."
  },
  "ILPROMPT": {
    "prefix": "ILPROMPT",
    "body": ["ILPROMPT(in.line.prompt)"],
    "description": "Use the ILPROMPT function to evaluate a string containing UniVerse in-line prompts."
  },
  "INCLUDE": {
    "prefix": "INCLUDE",
    "body": ["INCLUDE [filename] program"],
    "description": "Use the INCLUDE statement to direct the compiler to insert the source code in the record program and compile it along with the main program."
  },
  "INDEX": {
    "prefix": "INDEX",
    "body": ["INDEX(string, substring, occurrence)"],
    "description": "Use the INDEX function to return the starting character position for the specified occurrence of substring in string."
  },
  "INDEXS": {
    "prefix": "INDEXS",
    "body": ["INDEXS(dynamic.array, substring, occurrence)"],
    "description": "Use the INDEXS function to return a dynamic array of the starting column positions for a specified occurrence of a substring in each element of dynamic."
  },
  "INDICES": {
    "prefix": "INDICES",
    "body": ["INDICES(file.variable [,indexname])"],
    "description": "Use the INDICES function to return information about the secondary key indexes in a file."
  },
  "INMAT": {
    "prefix": "INMAT",
    "body": ["INMAT([array] )"],
    "description": "Use the INMAT function to return the number of array elements that have been loaded after the execution of MATREAD statements, MATREADL statement, MATREADU statement, or MATPARSE statement, or to return the modulo of a file after the execution of an OPEN statement."
  },
  "INPUT": {
    "prefix": "INPUT",
    "body": ["INPUT variable [,length] [:] [_] [{WAITING} time.expr]"],
    "description": "Use the INPUT statement to halt program execution and prompt the user to enter a response."
  },
  "INPUTCLEAR": {
    "prefix": "INPUTCLEAR",
    "body": ["INPUTCLEAR"],
    "description": "Use the INPUTCLEAR statement to clear the type-ahead buffer."
  },
  "INPUTDISP": {
    "prefix": "INPUTDISP",
    "body": ["INPUTDISP [@(col, row) [, | :]] variable [format]"],
    "description": "Use the INPUTDISP statement with an @ expression to position the cursor at a specified location and define a format for the variable to print."
  },
  "INPUTDP": {
    "prefix": "INPUTDP",
    "body": [
      "INPUTDP variable [, length] [:] [_] [THEN statements] [ELSE statements]"
    ],
    "description": "In NLS mode, use the INPUTDP statement to let the user enter data."
  },
  "INPUTERR": {
    "prefix": "INPUTERR",
    "body": ["INPUTERR [error.message]"],
    "description": "Use the INPUTERR statement to print a formatted error message on the bottom line of the terminal."
  },
  "INPUTNULL": {
    "prefix": "INPUTNULL",
    "body": ["INPUTNULL character"],
    "description": "Use the INPUTNULL statement to define a character to be recognized as an empty string when it is input in response to an INPUT statement."
  },
  "INPUTTRAP": {
    "prefix": "INPUTTRAP",
    "body": ["INPUTTRAP [trap.chars] {GOTO | GOSUB} label [ ,label ]"],
    "description": "Use the INPUTTRAP statement to branch to a program label or subroutine when a trap character is input."
  },
  "INS": {
    "prefix": "INS",
    "body": [
      "INS expression BEFORE dynamic.array < field# [,value# [ ,subvalue#]] >"
    ],
    "description": "Use the INS statement to insert a new field, value, or subvalue into the specified dynamic."
  },
  "INSERT": {
    "prefix": "INSERT",
    "body": ["INSERT(dynamic.array, field#, value#, subvalue#, expression)"],
    "description": "Use the INSERT function to return a dynamic array that has a new field, value, or subvalue inserted into the specified dynamic array."
  },
  "INT": {
    "prefix": "INT",
    "body": ["INT(expression)"],
    "description": "Use the INT function to return the integer portion of an expression."
  },
  "ISNULL": {
    "prefix": "ISNULL",
    "body": ["ISNULL(variable)"],
    "description": "Use the ISNULL function to test whether a variable is the null value."
  },
  "ISNULLS": {
    "prefix": "ISNULLS",
    "body": ["ISNULLS(dynamic.array)"],
    "description": "Use the ISNULLS function to test whether any element of dynamic."
  },
  "ITYPE": {
    "prefix": "ITYPE",
    "body": ["ITYPE(item)"],
    "description": "The ITYPE function leverages the object code stored within a compiled i."
  },
  "KEYEDIT": {
    "prefix": "KEYEDIT",
    "body": ["KEYEDIT(function, key) [,(function, key)]"],
    "description": "Use the KEYEDIT statement to assign specific keyboard keys to the editing functions of the INPUT @ statement, and to the !EDIT."
  },
  "KEYEXIT": {
    "prefix": "KEYEXIT",
    "body": ["KEYEXIT(value, key) [,(value, key)]"],
    "description": "Use the KEYEXIT statement to specify exit traps for the keys assigned specific functions by the KEYEDIT statement."
  },
  "KEYIN": {
    "prefix": "KEYIN",
    "body": ["KEYIN()"],
    "description": "Use the KEYIN function to read a single character from the input buffer and return it."
  },
  "KEYTRAP": {
    "prefix": "KEYTRAP",
    "body": ["KEYTRAP(value, key) [,(value, key)]"],
    "description": "Use the KEYTRAP statement to specify traps for the keys assigned specific functions by the KEYEDIT statement."
  },
  "LEFT": {
    "prefix": "LEFT",
    "body": ["LEFT(string, n)"],
    "description": "Use the LEFT function to extract a substring comprising the first n characters of a string, without specifying the starting character position."
  },
  "LEN": {
    "prefix": "LEN",
    "body": ["LEN(string)"],
    "description": "Use the LEN function to return the number of characters in string."
  },
  "LENDP": {
    "prefix": "LENDP",
    "body": ["LENDP(string [,mapname] )"],
    "description": "In NLS mode, use the LENDP function to return the number of display positions occupied by string when using the specified map."
  },
  "LENS": {
    "prefix": "LENS",
    "body": ["LENS(dynamic.array)"],
    "description": "Use the LENS function to return a dynamic array of the number of display positions in each element of dynamic."
  },
  "LENSDP": {
    "prefix": "LENSDP",
    "body": ["LENSDP(dynamic.array [, mapname] )"],
    "description": "In NLS mode, use the LENSDP function to return a dynamic array of the number of display positions occupied by each element of dynamic."
  },
  "LES": {
    "prefix": "LES",
    "body": ["LES(array1, array2)"],
    "description": "Use the LES function to test if elements of one dynamic array are less than or equal to the elements of another dynamic array."
  },
  "LET": {
    "prefix": "LET",
    "body": ["[LET] variable = expression"],
    "description": "Use the LET statement to assign the value of expression to variable."
  },
  "LN": {
    "prefix": "LN",
    "body": ["LN(expression)"],
    "description": "Use the LN function to calculate the natural logarithm of the value of an expression, using base e."
  },
  "LOCATE": {
    "prefix": "LOCATE",
    "body": ["LOCATE(NEEDLE,HAYSTACK;ANYPOS) ELSE POS = 0"],
    "description": "Find in dynamic array"
  },
  "LOCALEINFO": {
    "prefix": "LOCALEINFO",
    "body": ["LOCALEINFO(category)"],
    "description": "In NLS mode, use the LOCALEINFO function to retrieve the settings of the current locale."
  },
  "LOCK": {
    "prefix": "LOCK",
    "body": ["LOCK expression [THEN statements] [ELSE statements]"],
    "description": "Use the LOCK statement to protect specified user-defined resources or events against unauthorized use or simultaneous data file access by different users."
  },
  "LOOP": {
    "prefix": "LOOP",
    "body": ["LOOP", "READNEXT $1 ELSE $1 = ''", "UNTIL $1 = '' DO", "REPEAT"],
    "description": "Use the LOOP statement to start a LOOPREPEAT program loop."
  },
  "LOWER": {
    "prefix": "LOWER",
    "body": ["LOWER($1)"],
    "description": "Use the LOWER function to return a value equal to expression, except that system delimiters which appear in expression are converted to the next lower-level delimiter: field marks are changed to value marks, value marks are changed to subvalue marks, and so on."
  },
  "LTS": {
    "prefix": "LTS",
    "body": ["LTS(array1, array2)"],
    "description": "Use the LTS function to test if elements of one dynamic array are less than elements of another dynamic array."
  },
  "MAT": {
    "prefix": "MAT",
    "body": ["MAT $1 = ''"],
    "description": "Use the MAT statement to assign one value to all of the elements in the array or to assign all the values of one array to the values of another array."
  },
  "MATBUILD": {
    "prefix": "MATBUILD",
    "body": [
      "MATBUILD dynamic.array FROM array [,start [,end]] [USING delimiter]"
    ],
    "description": "Use the MATBUILD statement to build a dynamic array from a dimensioned array."
  },
  "MATCHFIELD": {
    "prefix": "MATCHFIELD",
    "body": ["MATCHFIELD(string, pattern, field)"],
    "description": "Use the MATCHFIELD function to check a string against a match pattern."
  },
  "MATPARSE": {
    "prefix": "MATPARSE",
    "body": ["MATPARSE array FROM dynamic.array [,delimiter]"],
    "description": "Use the MATPARSE statement to separate the fields of dynamic."
  },
  "MATREAD": {
    "prefix": "MATREAD",
    "body": ["MATREAD $1 FROM .FILE, .ID ELSE MAT $1 = ''"],
    "description": "Use the MATREAD statement to assign the contents of the fields of a record from a UniVerse file to consecutive elements of array."
  },
  "MATWRITE": {
    "prefix": "MATWRITE",
    "body": ["MATWRITE $1.ITEM ON $1.FILE,$1.ID"],
    "description": "Use the MATWRITE statement to write data from the elements of a dimensioned array to a record in a UniVerse file."
  },
  "MAXIMUM": {
    "prefix": "MAXIMUM",
    "body": ["MAXIMUM(dynamic.array)"],
    "description": "Use the MAXIMUM function to return the element with the highest numeric value in dynamic."
  },
  "MINIMUM": {
    "prefix": "MINIMUM",
    "body": ["MINIMUM(dynamic.array)"],
    "description": "Use the MINIMUM function to return the element with the lowest numeric value in dynamic."
  },
  "MOD": {
    "prefix": "MOD",
    "body": ["MOD(dividend, divisor)"],
    "description": "Use the MOD function to calculate the value of the remainder after integer division is performed on the dividend expression by the divisor expression."
  },
  "MODS": {
    "prefix": "MODS",
    "body": ["MODS(array1, array2)"],
    "description": "Use the MODS function to create a dynamic array of the remainder after the integer division of corresponding elements of two dynamic arrays."
  },
  "MQCLOSE": {
    "prefix": "MQCLOSE",
    "body": ["status=MQCLOSE(hConn, hObj, options)"],
    "description": "Use the MQCLOSE() function to close access to a queue or other object."
  },
  "MQCONN": {
    "prefix": "MQCONN",
    "body": ["status=MQCONN(qManager, hConn)"],
    "description": "The MQCONN() function connects an application to a WebSphere MQ queue manager."
  },
  "MQDISC": {
    "prefix": "MQDISC",
    "body": ["status=MQDISC(hConn)"],
    "description": "The MQDISC function terminates connections to the queue manager that were create using the MQCONN function."
  },
  "MULS": {
    "prefix": "MULS",
    "body": ["MULS(array1, array2)"],
    "description": "Use the MULS function to create a dynamic array of the element-by-element multiplication of two dynamic arrays."
  },
  "NAP": {
    "prefix": "NAP",
    "body": ["NAP [milliseconds]"],
    "description": "Use the NAP statement to suspend the execution of a BASIC program, pausing for a specified number of milliseconds."
  },
  "NEG": {
    "prefix": "NEG",
    "body": ["NEG(number)"],
    "description": "Use the NEG function to return the arithmetic inverse of the value of the argument."
  },
  "NEGS": {
    "prefix": "NEGS",
    "body": ["NEGS(dynamic.array)"],
    "description": "Use the NEGS function to return the negative values of all the elements in a dynamic array."
  },
  "NES": {
    "prefix": "NES",
    "body": ["NES(array1, array2)"],
    "description": "Use the NES function to test if elements of one dynamic array are equal to the elements of another dynamic array."
  },
  "NEXT": {
    "prefix": "NEXT",
    "body": ["NEXT [variable]"],
    "description": "Use the NEXT statement to end a FORNEXT loop, causing the program to branch back to the FOR statement and execute the statements that follow it."
  },
  "NOBUF": {
    "prefix": "NOBUF",
    "body": ["NOBUF file.variable {THEN statements [ELSE statements] | ELSE"],
    "description": "Use the NOBUF statement to turn off buffering for a file previously opened for sequential processing."
  },
  "NOT": {
    "prefix": "NOT",
    "body": ["NOT(expression)"],
    "description": "Use the NOT function to return the logical complement of the value of expression."
  },
  "NOTS": {
    "prefix": "NOTS",
    "body": ["NOTS(dynamic.array)"],
    "description": "Use the NOTS function to return a dynamic array of the logical complements of each element of dynamic."
  },
  "NULL": {
    "prefix": "NULL",
    "body": ["NULL"],
    "description": "Use the NULL statement when a statement is required but no operation is to be performed."
  },
  "NUM": {
    "prefix": "NUM",
    "body": ["NUM(expression)"],
    "description": "Use the NUM function to determine whether expression is a numeric or nonnumeric string."
  },
  "NUMS": {
    "prefix": "NUMS",
    "body": ["NUMS(dynamic.array)"],
    "description": "Use the NUMS function to determine whether the elements of a dynamic array are numeric or nonnumeric strings."
  },
  "OCONV": {
    "prefix": "OCONV",
    "body": ["OCONV($1, '')"],
    "description": "Use the OCONV function to convert string to a specified format for external output."
  },
  "OCONVS": {
    "prefix": "OCONVS",
    "body": ["OCONVS(dynamic.array, conversion)"],
    "description": "Use the OCONVS function to convert the elements of dynamic."
  },
  "ON": {
    "prefix": "ON",
    "body": ["ON expression GOSUB statement.label [:] [,statement.label [:] ]"],
    "description": "Use the ON statement to transfer program control to one of the internal subroutines named in the GOSUB clause or to one of the statements named in the GOTO clause."
  },
  "OPEN": {
    "prefix": "OPEN",
    "body": [
      "OPEN '','$1' TO .FILE ELSE",
      "PRINT 'Unable to open file: $1 - Press RETURN':",
      "INPUT ANYTHING",
      "STOP",
      "END"
    ],
    "description": "Use the OPEN statement to open a UniVerse file for use by BASIC programs."
  },
  "OPENCHECK": {
    "prefix": "OPENCHECK",
    "body": [
      "OPENCHECK [dict,] filename [TO file.variable] {THEN statements [ELSE"
    ],
    "description": "Use the OPENCHECK statement to open an SQL table for use by BASIC programs, enforcing SQL integrity checking."
  },
  "OPENDEV": {
    "prefix": "OPENDEV",
    "body": [
      "OPENDEV device TO file.variable [LOCKED statements] {THEN statements"
    ],
    "description": "Use the OPENDEV statement to open a device for sequential processing."
  },
  "OPENPATH": {
    "prefix": "OPENPATH",
    "body": [
      "OPENPATH pathname [TO file.variable] [ON ERROR statements] {THEN"
    ],
    "description": "The OPENPATH statement is similar to the OPEN statement, except that the pathname of the file is specified."
  },
  "OPENSEQ": {
    "prefix": "OPENSEQ",
    "body": [
      "OPENSEQ filename, record.ID TO file.variable [USING dynamic.array]"
    ],
    "description": "Use the OPENSEQ statement to open a file for sequential processing."
  },
  "ORS": {
    "prefix": "ORS",
    "body": ["ORS(array1, array2)"],
    "description": "Use the ORS function to create a dynamic array of the logical OR of corresponding elements of two dynamic arrays."
  },
  "PAGE": {
    "prefix": "PAGE",
    "body": ["PAGE [ON print.channel] [page#]"],
    "description": "Use the PAGE statement to print headings, footings, and page advances at the appropriate places on the specified output device."
  },
  "PERFORM": {
    "prefix": "PERFORM",
    "body": ["PERFORM $1"],
    "description": "Use the PERFORM statement to execute a UniVerse sentence, paragraph, menu, or command from within the BASIC program, then return execution to the statement following the PERFORM statement."
  },
  "PRECISION": {
    "prefix": "PRECISION",
    "body": ["PRECISION $1"],
    "description": "Use the PRECISION statement to control the maximum number of decimal places that are output when the system converts a numeric value from internal binary format to an ASCII character string value."
  },
  "PRINT": {
    "prefix": "PRINT",
    "body": ["PRINT $1"],
    "description": "Use the PRINT statement to send data to the screen, a line printer, or another print file."
  },
  "PRINTER": {
    "prefix": "PRINTER",
    "body": ["PRINTER $1"],
    "description": "Use the PRINTER statement to direct output either to the screen or to a printer."
  },
  "PRINTERR": {
    "prefix": "PRINTERR",
    "body": ["PRINTERR $1"],
    "description": "Use the PRINTERR statement to print a formatted error message on the bottom line of the terminal."
  },
  "PROCREAD": {
    "prefix": "PROCREAD",
    "body": ["PROCREAD $1 ELSE $1 = ''"],
    "description": "Use the PROCREAD statement to assign the contents of the primary input buffer to a variable."
  },
  "PROCWRITE": {
    "prefix": "PROCWRITE",
    "body": ["PROCWRITE $1"],
    "description": "Use the PROCWRITE statement to write string to the primary input buffer."
  },
  "PROGRAM": {
    "prefix": "PROGRAM",
    "body": ["PROG[RAM] [name]"],
    "description": "Use the PROGRAM statement to identify a program."
  },
  "PROMPT": {
    "prefix": "PROMPT",
    "body": ["PROMPT $1"],
    "description": "Use the PROMPT statement to specify the character to be displayed on the screen when user input is required."
  },
  "PWR": {
    "prefix": "PWR",
    "body": ["PWR($1, )"],
    "description": "Use the PWR function to return the value of expression raised to the power specified by power."
  },
  "QUOTE": {
    "prefix": "QUOTE",
    "body": ["QUOTE($1)"],
    "description": "Use the QUOTE function to enclose an expression in double quotation marks."
  },
  "RAISE": {
    "prefix": "RAISE",
    "body": ["RAISE($1)"],
    "description": "Use the RAISE function to return a value equal to expression, except that system delimiters in expression are converted to the next higher-level delimiter: value marks are changed to field marks, subvalue marks are changed to value marks, and so on."
  },
  "RANDOMIZE": {
    "prefix": "RANDOMIZE",
    "body": ["RANDOMIZE [(expression)]"],
    "description": "Use the RANDOMIZE statement with an expression to make the RND function generate the same sequence of random numbers each time the program is run."
  },
  "READ": {
    "prefix": "READ",
    "body": ["READ $1 FROM , ITEM.ID ELSE = ''"],
    "description": "Use READ statements to assign the contents of a record from a UniVerse file to dynamic."
  },
  "READBLK": {
    "prefix": "READBLK",
    "body": [
      "READBLK variable FROM file.variable, blocksize THEN statements [ELSE"
    ],
    "description": "Use the READBLK statement to read a block of data of a specified length from a file opened for sequential processing and assign it to a variable."
  },
  "READLIST": {
    "prefix": "READLIST",
    "body": [
      "READLIST dynamic.array [FROM list.number] { THEN statements [ELSE"
    ],
    "description": "Use the READLIST statement to read the remainder of an active select list into a dynamic array."
  },
  "READNEXT": {
    "prefix": "READNEXT",
    "body": ["READNEXT $1 ELSE $1 = ''"],
    "description": "Use the READNEXT statement to assign the next record ID from an active select list to dynamic."
  },
  "READSEQ": {
    "prefix": "READSEQ",
    "body": ["READSEQ variable FROM file.variable [ON ERROR statements] {THEN"],
    "description": "Use the READSEQ statement to read a line of data from a file opened for sequential processing."
  },
  "READT": {
    "prefix": "READT",
    "body": [
      "READT [UNIT(mtu)] variable {THEN statements [ELSE statements] | ELSE"
    ],
    "description": "Use the READT statement to read the next tape record from a magnetic tape unit and assign its contents to a variable."
  },
  "READVU": {
    "prefix": "READVU",
    "body": ["Status=ReadXMLData(xml_data_handle, rec)"],
    "description": "Use the READVU statement to set an update record lock and read the contents of a specified field of a record in a UniVerse file."
  },
  "REAL": {
    "prefix": "REAL",
    "body": ["REAL(number)"],
    "description": "Use the REAL function to convert number into a floating-point number without loss of accuracy."
  },
  "RECORDLOCK": {
    "prefix": "RECORDLOCK",
    "body": [
      "RECORDLOCKL file.variable , record.ID [ON ERROR statements] [LOCKED"
    ],
    "description": "Use RECORDLOCK statements to acquire a record lock on a record without reading the record."
  },
  "RECORDLOCKED": {
    "prefix": "RECORDLOCKED",
    "body": ["RECORDLOCKED(file.variable , record.ID )"],
    "description": "Use the RECORDLOCKED function to return the status of a record lock."
  },
  "RELEASE": {
    "prefix": "RELEASE",
    "body": ["RELEASE [file.variable [,record.ID]] [ON ERROR statements]"],
    "description": "Use the RELEASE statement to unlock, or release, locks set by a FILELOCK statement, MATREADL statement, MATREADU statement, READL statement, READU statement, READVL statement, READVU statement, and OPENSEQ statement."
  },
  "REM": {
    "prefix": "REM",
    "body": ["REM [comment.text]"],
    "description": "Use the REM statement to insert a comment in a BASIC program."
  },
  "REMOVE": {
    "prefix": "REMOVE",
    "body": ["REMOVE element FROM dynamic.array SETTING variable"],
    "description": "Use the REMOVE statement to successively extract dynamic array elements that are separated by system delimiters."
  },
  "REPLACE": {
    "prefix": "REPLACE",
    "body": [
      "REPLACE(expression, field#, value#, subvalue# { , | ; } replacement)"
    ],
    "description": "Use the REPLACE function to return a copy of a dynamic array with the specified field, value, or subvalue replaced with new data."
  },
  "RETURN": {
    "prefix": "RETURN",
    "body": ["RETURN"],
    "description": "Use the RETURN statement to terminate a subroutine and return control to the calling program or statement."
  },
  "REUSE": {
    "prefix": "REUSE",
    "body": ["REUSE(expression)"],
    "description": "Use the REUSE function to specify that the value of the last field, value, or subvalue be reused in a dynamic array operation."
  },
  "REVREMOVE": {
    "prefix": "REVREMOVE",
    "body": ["REVREMOVE element FROM dynamic.array SETTING variable"],
    "description": "Use the REVREMOVE statement to successively extract dynamic array elements that are separated by system delimiters."
  },
  "REWIND": {
    "prefix": "REWIND",
    "body": ["REWIND [UNIT(mtu)] {THEN statements [ELSE statements] | ELSE"],
    "description": "Use the REWIND statement to rewind a magnetic tape to the beginning-of-tape position."
  },
  "RIGHT": {
    "prefix": "RIGHT",
    "body": ["RIGHT(string, n)"],
    "description": "Use the RIGHT function to extract a substring comprising the last n characters of a string."
  },
  "RND": {
    "prefix": "RND",
    "body": ["RND(expression)"],
    "description": "Use the RND function to generate any positive or negative random integer or 0."
  },
  "ROLLBACK": {
    "prefix": "ROLLBACK",
    "body": ["ROLLBACK [WORK] [THEN statements] [ELSE statements ]"],
    "description": "Use the ROLLBACK statement to cancel all file I/O changes made during a transaction."
  },
  "ROUND": {
    "prefix": "ROUND",
    "body": ["ROUND(number,places)"],
    "description": "Use the ROUND function to round a numeric value to the specified number of decimal places."
  },
  "SADD": {
    "prefix": "SADD",
    "body": ["SADD(string.number.1, string.number.2)"],
    "description": "Use the SADD function to add two string numbers and return the result as a string number."
  },
  "SCMP": {
    "prefix": "SCMP",
    "body": ["SCMP(string.number.1, string.number.2)"],
    "description": "Use the SCMP function to compare two string numbers and return one of the following three numbers: can use this function in any expression where a string or string number is valid."
  },
  "SDIV": {
    "prefix": "SDIV",
    "body": ["SDIV(string.number.1, string.number.2 [,precision])"],
    "description": "Use the SDIV function to divide string."
  },
  "SEEK": {
    "prefix": "SEEK",
    "body": ["SEEK file.variable [, offset [, relto]] {THEN statements [ELSE"],
    "description": "Use the SEEK statement to move the file pointer by an offset specified in bytes, relative to the current position, the beginning of the file, or the end of the file."
  },
  "SELECT": {
    "prefix": "SELECT",
    "body": ["SELECT $1"],
    "description": "Use a SELECT statement to create a numbered select list of record IDs from a UniVerse file or a dynamic array."
  },
  "SELECTE": {
    "prefix": "SELECTE",
    "body": ["SELECTE TO list.variable"],
    "description": "Use the SELECTE statement to assign the contents of select list 0 to list."
  },
  "SELECTINDEX": {
    "prefix": "SELECTINDEX",
    "body": [
      "SELECTINDEX index [, alt.key] FROM file.variable [TO list.number]"
    ],
    "description": "Use the SELECTINDEX statement to create select lists from secondary indexes."
  },
  "SELECTINFO": {
    "prefix": "SELECTINFO",
    "body": ["SELECTINFO(list, key)"],
    "description": "Use the SELECTINFO function to determine whether a select list is active, or to determine the number of items it contains."
  },
  "SEND": {
    "prefix": "SEND",
    "body": [
      "SEND output [:] TO device { THEN statements [ELSE statements] | ELSE"
    ],
    "description": "Use the SEND statement to write a block of data to a device."
  },
  "SENTENCE": {
    "prefix": "SENTENCE",
    "body": ["SENTENCE()"],
    "description": "Use the SENTENCE function to return the stored sentence that invoked the current process."
  },
  "SEQ": {
    "prefix": "SEQ",
    "body": ["SEQ(expression)"],
    "description": "Use the SEQ function to convert an ASCII character to its numeric string equivalent."
  },
  "SEQS": {
    "prefix": "SEQS",
    "body": ["SEQS(dynamic.array)"],
    "description": "Use the SEQS function to convert a dynamic array of ASCII characters to their numeric string equivalents."
  },
  "SETLOCALE": {
    "prefix": "SETLOCALE",
    "body": ["SETLOCALE(category, value)"],
    "description": "In NLS mode, use the SETLOCALE function to enable or disable a locale for a specified category or change its setting."
  },
  "SETREM": {
    "prefix": "SETREM",
    "body": ["SETREM position ON dynamic.array"],
    "description": "Use the SETREM statement to set the remove pointer in dynamic."
  },
  "SIGNATURE": {
    "prefix": "SIGNATURE",
    "body": [
      "SIGNATURE(algorithm, action, data, dataLoc, key, keyLoc, keyFmt, pass,"
    ],
    "description": "The SIGNATURE() function generates a digital signature or verifies a signature using the supplied key."
  },
  "SIN": {
    "prefix": "SIN",
    "body": ["SIN(expression)"],
    "description": "Use the SIN function to return the trigonometric sine of an expression."
  },
  "SINH": {
    "prefix": "SINH",
    "body": ["SINH(expression)"],
    "description": "Use the SINH function to return the hyperbolic sine of expression."
  },
  "SLEEP": {
    "prefix": "SLEEP",
    "body": ["SLEEP [seconds]"],
    "description": "Use the SLEEP statement to suspend execution of a BASIC program, pausing for a specified number of seconds."
  },
  "SMUL": {
    "prefix": "SMUL",
    "body": ["SMUL(string.number.1, string.number.2)"],
    "description": "Use the SMUL function to multiply two string numbers and return the result as a string number."
  },
  "SOUNDEX": {
    "prefix": "SOUNDEX",
    "body": ["SOUNDEX(expression)"],
    "description": "The SOUNDEX function evaluates expression and returns the most significant letter in the input string followed by a phonetic code."
  },
  "SPACE": {
    "prefix": "SPACE",
    "body": ["SPACE(expression)"],
    "description": "Use the SPACE function to return a string composed of blank spaces."
  },
  "SPACES": {
    "prefix": "SPACES",
    "body": ["SPACES(dynamic.array)"],
    "description": "Use the SPACES function to return a dynamic array with elements composed of blank spaces."
  },
  "SPLICE": {
    "prefix": "SPLICE",
    "body": ["SPLICE(array1, expression, array2)"],
    "description": "Use the SPLICE function to create a dynamic array of the element-by-element concatenation of two dynamic arrays, separating concatenated elements by the value of expression."
  },
  "SQUOTE": {
    "prefix": "SQUOTE",
    "body": ["SQUOTE(expression)"],
    "description": "Use the SQUOTE function to enclose an expression in single quotation marks."
  },
  "SSELECT": {
    "prefix": "SSELECT",
    "body": ["SSELECT [variable] [TO list.number] [ON ERROR statements]"],
    "description": "Use an SSELECT statement to create:   A numbered select list of record IDs in sorted order from a UniVerse file  A numbered select list of record IDs from a dynamic array."
  },
  "SSUB": {
    "prefix": "SSUB",
    "body": ["SSUB(string.number.1, string.number.2)"],
    "description": "Use the SSUB function to subtract string."
  },
  "STATUS": {
    "prefix": "STATUS",
    "body": ["STATUS dynamic.array FROM file.variable {THEN statements [ELSE"],
    "description": "Use the STATUS statement to determine the status of an open file."
  },
  "STOP": {
    "prefix": "STOP",
    "body": ["STOP [expression]"],
    "description": "Use the STOP statement to terminate program execution and return system control to the invoking process."
  },
  "STORAGE": {
    "prefix": "STORAGE",
    "body": ["STORAGE arg1arg2arg3"],
    "description": "The STORAGE statement performs no function."
  },
  "STR": {
    "prefix": "STR",
    "body": ["STR(string, repeat)"],
    "description": "Use the STR function to produce a specified number of repetitions of a particular character string."
  },
  "STRS": {
    "prefix": "STRS",
    "body": ["STRS(dynamic.array, repeat)"],
    "description": "Use the STRS function to produce a dynamic array containing the specified number of repetitions of each element of dynamic."
  },
  "SUBR": {
    "prefix": "SUBR",
    "body": ["SUBR(name, [argument [,argument ]] )"],
    "description": "Use the SUBR function to return the value of an external subroutine."
  },
  "SUBROUTINE": {
    "prefix": "SUBROUTINE",
    "body": ["SUBROUTINE $1()"],
    "description": "Use the SUBROUTINE statement to identify an external subroutine."
  },
  "SUBS": {
    "prefix": "SUBS",
    "body": ["SUBS(array1, array2)"],
    "description": "Use the SUBS function to create a dynamic array of the element-by-element subtraction of two dynamic arrays."
  },
  "SUBSTRINGS": {
    "prefix": "SUBSTRINGS",
    "body": ["SUBSTRINGS(dynamic.array, start, length)"],
    "description": "Use the SUBSTRINGS function to create a dynamic array each of whose elements are substrings of the corresponding elements of dynamic."
  },
  "SUM": {
    "prefix": "SUM",
    "body": ["SUM(dynamic.array)"],
    "description": "Use the SUM function to calculate the sum of numeric data."
  },
  "SUMMATION": {
    "prefix": "SUMMATION",
    "body": ["SUMMATION(dynamic.array)"],
    "description": "Use the SUMMATION function to return the sum of all the elements in dynamic."
  },
  "SWAP": {
    "prefix": "SWAP",
    "body": ["For variables: SWAP variable1, variable2"],
    "description": "The SWAP statement interchanges the values in the variables you specify."
  },
  "SYSTEM": {
    "prefix": "SYSTEM",
    "body": ["SYSTEM(expression)"],
    "description": "Use the SYSTEM function to check on the status of a system function."
  },
  "TABSTOP": {
    "prefix": "TABSTOP",
    "body": ["TABSTOP expression"],
    "description": "Use the TABSTOP statement to set the current tabstop width for PRINT statement."
  },
  "TAN": {
    "prefix": "TAN",
    "body": ["TAN(expression)"],
    "description": "Use the TAN function to return the trigonometric tangent of expression."
  },
  "TANH": {
    "prefix": "TANH",
    "body": ["TANH(expression)"],
    "description": "Use the TANH function to return the hyperbolic tangent of expression."
  },
  "TERMINFO": {
    "prefix": "TERMINFO",
    "body": ["TERMINFO(argument)"],
    "description": "Use the TERMINFO function to access the device-independent terminal handler string defined for the current terminal type."
  },
  "TIME": {
    "prefix": "TIME",
    "body": ["TIME()"],
    "description": "Use the TIME function to return a string value expressing the internal time of day."
  },
  "TIMEDATE": {
    "prefix": "TIMEDATE",
    "body": ["TIMEDATE()"],
    "description": "Use the TIMEDATE function to return the current system time and date."
  },
  "TIMEOUT": {
    "prefix": "TIMEOUT",
    "body": ["TIMEOUT {file.variable | link.number}, time"],
    "description": "Use the TIMEOUT statement to terminate a READSEQ statement or READBLK statement if no data is read in the specified time."
  },
  "TPARM": {
    "prefix": "TPARM",
    "body": [
      "TPARM(terminfo.string, [arg1], [arg2], [arg3], [arg4], [arg5], [arg6],"
    ],
    "description": "Use the TPARM function to evaluate a parameterized terminfo string."
  },
  "TPRINT": {
    "prefix": "TPRINT",
    "body": ["TPRINT [ON print.channel] [print.list]"],
    "description": "Use the TPRINT statement to send data to the screen, a line printer, or another print file."
  },
  "TRANS": {
    "prefix": "TRANS",
    "body": ["TRANS([DICT] filename, record.ID, field#, control.code)"],
    "description": "Use the TRANS function to return the contents of a field or a record in a UniVerse file."
  },
  "TRIM": {
    "prefix": "TRIM",
    "body": ["TRIM(expression [,character [,option]] )"],
    "description": "Use the TRIM function to remove unwanted characters in expression."
  },
  "TRIMB": {
    "prefix": "TRIMB",
    "body": ["TRIMB(expression)"],
    "description": "Use the TRIMB function to remove all trailing spaces and tabs from expression."
  },
  "TRIMBS": {
    "prefix": "TRIMBS",
    "body": ["TRIMBS(dynamic.array)"],
    "description": "Use the TRIMBS function to remove all trailing spaces and tabs from each element of dynamic."
  },
  "TRIMF": {
    "prefix": "TRIMF",
    "body": ["TRIMF(expression)"],
    "description": "Use the TRIMF function to remove all leading spaces and tabs from expression."
  },
  "TRIMFS": {
    "prefix": "TRIMFS",
    "body": ["TRIMFS(dynamic.array)"],
    "description": "Use the TRIMFS function to remove all leading spaces and tabs from each element of dynamic."
  },
  "TRIMS": {
    "prefix": "TRIMS",
    "body": ["TRIMS(dynamic.array)"],
    "description": "Use the TRIMS function to remove unwanted spaces and tabs from each element of dynamic."
  },
  "TRUNC": {
    "prefix": "TRUNC",
    "body": ["TRUNC(number,places)"],
    "description": "Use the TRUNC function to truncate a numeric variable or string to a specified number of decimal places."
  },
  "TTYCTL": {
    "prefix": "TTYCTL",
    "body": [
      "TTYCTL file.variable, code# {THEN statements [ELSE statements] | ELSE"
    ],
    "description": "Use the TTYCTL statement to set terminal device characteristics on Berkeley terminal drivers."
  },
  "TTYGET": {
    "prefix": "TTYGET",
    "body": [
      "TTYGET variable [FROM {file.variable | LPTR [n] | MTU [n] }] THEN"
    ],
    "description": "Use the TTYGET statement to assign the characteristics of a terminal, line printer channel, or tape unit as a dynamic array to variable."
  },
  "TTYSET": {
    "prefix": "TTYSET",
    "body": [
      "TTYSET dynamic.array [ON {file.variable | LPTR [n] | MTU [n] }] {THEN"
    ],
    "description": "Use the TTYSET statement to set the characteristics of a terminal, line printer channel, or tape unit."
  },
  "UNASSIGNED": {
    "prefix": "UNASSIGNED",
    "body": ["UNASSIGNED(variable)"],
    "description": "Use the UNASSIGNED function to determine if variable is unassigned."
  },
  "UNICHAR": {
    "prefix": "UNICHAR",
    "body": ["UNICHAR(unicode)"],
    "description": "Use the UNICHAR function to generate a single character from a Unicode value."
  },
  "UNICHARS": {
    "prefix": "UNICHARS",
    "body": ["UNICHARS(dynamic.array)"],
    "description": "Use the UNICHARS function to generate a dynamic array of characters from a dynamic array of Unicode values."
  },
  "UNISEQ": {
    "prefix": "UNISEQ",
    "body": ["UNISEQ(expression)"],
    "description": "Use the UNISEQ function to generate a Unicode value from expression."
  },
  "UNISEQS": {
    "prefix": "UNISEQS",
    "body": ["UNISEQS(dynamic.array)"],
    "description": "Use the UNISEQS function to generate an array of Unicode values from a dynamic array of characters."
  },
  "UNLOCK": {
    "prefix": "UNLOCK",
    "body": ["UNLOCK [expression]"],
    "description": "Use the UNLOCK statement to release a process lock set by the LOCK statement."
  },
  "UPCASE": {
    "prefix": "UPCASE",
    "body": ["UPCASE(expression)"],
    "description": "Use the UPCASE function to change all lowercase letters in expression to uppercase."
  },
  "UPRINT": {
    "prefix": "UPRINT",
    "body": ["UPRINT [ON print.channel] [print.list ]"],
    "description": "In NLS mode, use the UPRINT statement to print data that was mapped to an external format using OCONV mapname."
  },
  "USERINFO": {
    "prefix": "USERINFO",
    "body": ["USERINFO(code, value, userinfo)"],
    "description": "Use the USERINFO function to get the pid, user number, and more for the pid or user number specified."
  },
  "WEOF": {
    "prefix": "WEOF",
    "body": [
      "WEOF [UNIT(mtu)] {THEN statements [ELSE statements] | ELSE statements}"
    ],
    "description": "Use the WEOF statement to write an end-of-file (EOF) mark to tape."
  },
  "WEOFSEQ": {
    "prefix": "WEOFSEQ",
    "body": ["WEOFSEQfile.variable [ON ERROR statements]"],
    "description": "Use the WEOFSEQ statement to write an end-of-file (EOF) mark in a file opened for sequential access."
  },
  "WRITE": {
    "prefix": "WRITE",
    "body": ["WRITE $1 ON .FILE, .ID"],
    "description": "Use WRITE statements to write new data to a record in a UniVerse file."
  },
  "WRITEBLK": {
    "prefix": "WRITEBLK",
    "body": [
      "WRITEBLK expression ON file.variable {THEN statements [ELSE statements]"
    ],
    "description": "Use the WRITEBLK statement to write a block of data to a file opened for sequential processing."
  },
  "WRITELIST": {
    "prefix": "WRITELIST",
    "body": ["WRITELIST dynamic.array ON listname"],
    "description": "Use the WRITELIST statement to save a list as a record in the &SAVEDLISTS& file."
  },
  "WRITESEQ": {
    "prefix": "WRITESEQ",
    "body": [
      "WRITESEQ expression {ON | TO} file.variable [ON ERROR statements] {THEN"
    ],
    "description": "Use the WRITESEQ statement to write new lines to a file opened for sequential processing."
  },
  "WRITESEQF": {
    "prefix": "WRITESEQF",
    "body": [
      "WRITESEQF expression {ON | TO} file.variable [ON ERROR statements]"
    ],
    "description": "Use the WRITESEQF statement to write new lines to a file opened for sequential processing, and to ensure that data is physically written to disk (that is, not buffered) before the next statement in the program is executed."
  },
  "WRITET": {
    "prefix": "WRITET",
    "body": [
      "WRITET [UNIT(mtu)] variable {THEN statements [ELSE statements] | ELSE"
    ],
    "description": "Use the WRITET statement to write a tape record to tape."
  },
  "WRITEVU": {
    "prefix": "WRITEVU",
    "body": ["XDOMAddChild(xmlHandle, xpathString, nsMap, nodeHandle,"],
    "description": "Use the WRITEVU statement to maintain an update record lock while writing on the contents of a specified field of a record of a UniVerse file."
  },
  "XLATE": {
    "prefix": "XLATE",
    "body": ["XLATE([DICT] filename, record.ID, field#, control.code)"],
    "description": "Use the XLATE function to return the contents of a field or a record in a UniVerse file."
  },
  "XMLTODB": {
    "prefix": "XMLTODB",
    "body": [
      "XMLTODB(xml_document, doc_flag, u2xmapping_rules, u2xmap_ flag, status)"
    ],
    "description": "You can also populate the UniVerse database by calling the UniVerse BASIC XMLTODB function."
  },
  "XTD": {
    "prefix": "XTD",
    "body": ["XTD(string)"],
    "description": "Use the XTD function to convert a string of hexadecimal characters to an integer."
  }
}