SD Basic Commands and Functions

------------------------------------------------------------------------------------------
RETAINED COMMANDS - Usage is usually the same as in OpenQM 2.6.6. However some commands may have been modified to remove features that are not supported in SD. Removed Commands and New Commands Unique to SD are listed at bottom of this page.
------------------------------------------------------------------------------------------

@ (col {, row}) or (mode {, arg})
ABORT {print.list}
ABS(expr)
ABSS(expr)
ACCEPT.SOCKET.CONNECTION(srvr.skt, timeout)
ACOS(expr)
ALPHA(string)
ANDS(expr1, expr2))
ARG(n)
ARG.COUNT()
ASCII(expr)
ASIN(expr)
ASSIGNED(varname)
ATAN(expr)
BEGIN CASE
CASE expr statement(s)
END CASE
BEGIN TRANSACTION
COMMIT / ROLLBACK
END TRANSACTION
BINDKEY(key.string, action)
BITAND(expr1, expr2)
BITNOT(expr)
BITOR(expr1, expr2)
BITRESET(expr, bit)
BITSET(expr, bit)
BITTEST(expr, bit)
BITXOR(expr1, expr2)
BREAK
CALL
CATALOGUED(name)

CATS(string1, string2)
CHAIN expr
CHANGE(string, old, new{, occurrence{, start}})
CHAR(seq)
CLEAR
CLEARCOMMON or CLEAR COMMON
CLEARDATA
CLEARFILE file.var {ON ERROR statement(s)}
CLEARINPUT or CLEAR INPUT
CLEARSELECT {list.no}
CLEARSELECT ALL
CLOSE file.var
{ON ERROR statement(s)}
CLOSE.SOCKET skt
CLOSESEQ file.var
{ON ERROR statement(s)}
COL1()
COL2()
COMMIT
COMMON {/name/} var1 {,var2...}
COMPARE(string1, string2 {, justification})
CONFIG(param)
CONTINUE
CONVERT from.string TO to.string IN source.string
CONVERT(from.string, to.string, source.string)
COS(expr)
COUNT(string, substring)
COUNTS(string, substring)
CREATE file.var {ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
CREATE.FILE path {DIRECTORY | DYNAMIC}
{GROUP.SIZE grpsz} {BIG.REC.SIZE bigrec}
{MIN.MODULUS minmod} {SPLIT.LOAD split}
{MERGE.LOAD merge} {VERSION ver}
{ONERROR statement(s)}
CREATE.SERVER.SOCKET(addr, port)
CROP(string)
CRT {print.list}
CSVDQ(string {, delimiter})
DATA expr{, expr...}
DATE()
DCOUNT(string, delimiter)
DEBUG
DEFFUN name {(arg1 {,arg2 ...})}
{CALLING "subr" | LOCAL}
{VAR.ARGS} {KEY key}
DEL dyn.array<field {, value {, subvalue}}>
DELETE file.var, record.id
{ON ERROR statement(s)}
DELETE(dyn.array, field {, value {, subvalue}})
DELETELIST name
DELETESEQ file.name, id
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
DELETESEQ pathname
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
DELETEU file.var, record.id
{ON ERROR statement(s)}
DIM mat(rows {, cols})
DIMENSION mat(rows {, cols})
DIR(pathname)
DISINHERIT object
DISPLAY {print.list}
DIV(dividend, divisor)
DOWNCASE(string)
DPARSE string, delimiter, var1, var2,...
DPARSE.CSV string, delimiter, var1, var2,...
DQUOTE(expr)
DTX(expr {, min.width})
EBCDIC(expr)
ECHO OFF
ECHO ON
ECHO expr
END
ENTER @var
ENTER @var {(arg.list)}
ENTER name
ENTER name {(arg.list)}
ENV(var.name)
EQS(expr1, expr2)
EQUATE name TO CHAR(seq)
EQUATE name TO value
EQUATE name TO variable
EXECUTE expr
{TRAPPING ABORTS} {CAPTURING var} {PASSLIST {var}}
{RTNLIST var} {SETTING status.var} or {RETURNING status.var}
EXIT
EXP(expr)
EXTRACT(dyn.array, field {, value {, subvalue}})
FIELD(string, delimiter, occurrence {, count})
FIELDS(string, delimiter, occurrence {, count})
FIELDSTORE(string, delimiter, i, n, rep.string)
FILE name, ...
FILEINFO(file.var, key)
FILELOCK file.var
{ON ERROR statement(s)} {LOCKED statement(s)}
FILEUNLOCK file.var
{ON ERROR statement(s)}
FIND string IN dyn.array {, occurrence}
SETTING field{, value {, subvalue}}
{THEN statement(s)} {ELSE statement(s)}
FIND string IN dyn.array {, occurrence}
SETTING field{, value {, subvalue}}
{THEN statement(s)} {ELSE statement(s)}
FLUSH file.var
{THEN statement(s)} {ELSE statement(s)}
FMT(expr, fmt.spec)
FMTS(expr, fmt.spec)
FOLD(string, width {, delim})
FOLDS(string, width {, delim})
FOOTING {ON print.unit} text
FOR var = start.expr TO limit.expr
{STEP step.expr} NEXT {var}
FORMLIST dyn.array {TO list.no}
FUNCTION name{(arg1 {, arg2...}) {VAR.ARGS}}
GES(expr1, expr2)
GET name{(args)} {VAR.ARGS}
GET.MESSAGES()
GET.PORT.PARAMS(fvar)
GETLIST name {TO list.no}
{THEN statement(s)} {ELSE statement(s)}
GETNLS(key)
GETPU(key, unit)
GETREM(string)
GOSUB label{:}
GOSUB label{:}(args)
GOTO label{:} or GO {TO} label{:}
GTS(expr1, expr2)
HEADING { NO.EJECT } { ON print.unit } text
ICONV(expr, conv.spec)
ICONVS(dynarray, conv.spec)
IDIV(dividend, divisor)
IF expr THEN {END ELSE} END
IF expr THEN statement {ELSE statement}
IFS(control.array, true.array, false.array)
IN var {FOR timeout}
{THEN statement(s)} {ELSE statement(s)}
INDEX(string, substring, occurrence)
INDEXS(string, substring, occurrence)
INDICES(file.var, index.name)
INDICES(file.var)
INHERIT object
INMAT()
INMAT()
INMAT({mat})
INPUT @(col,row) {:} var {, length} {_} {:}
{APPEND} {EDIT} {HIDDEN} {OVERLAY}
{PANNING} {TIMEOUT wait} {UPCASE}
{THEN statements} { ELSE statements}
INPUT var {, length} {_} {:}
{TIMEOUT wait} {HIDDEN} {UPCASE}
{THEN statements} { ELSE statements}
INPUTCLEAR
INPUTCSV var1, var2, ...
INPUTERR expr
INPUTFIELD @(x, y) {,} {:} var, length {_} {:} {format}
{APPEND} {EDIT} {HIDDEN}
{OVERLAY} {PANNING} {TIMEOUT wait} {UPCASE}
{THEN statements} { ELSE statements}
INS string BEFORE dyn.array<field {, value {, subvalue}}>
INSERT(dyn.array, field {, value {, subvalue}} , string)
INT(expr)
ITYPE(itype)
KEYCODE({timeout})
KEYEDIT (action, key), (action, key), ...
KEYEXIT (action, key), (action, key), ...
KEYIN({timeout})
KEYINC({timeout})
KEYINR({timeout})
KEYREADY()
KEYTRAP (action, key), (action, key), ...
LEN(string)
LENS(string)
LES(expr1, expr2)
LISTINDEX(list, delimiter, item)
LN(expr)
LOCAL FUNCTION name{(args)}
LOCAL SUBROUTINE name{(args)}
LOCATE string IN dyn.array<field {,value {, subvalue}}>
{BY order} SETTING var
{THEN statement(s)} {ELSE statement(s)}
LOCATE string IN dyn.array<field {,value }> {, start}
{BY order} SETTING var
{THEN statement(s)} {ELSE statement(s)}
LOCATE(string, dyn.array, field {,value {, subvalue}} {; order})
LOCATE(string, dyn.array{,field {,value }}; var {; order})
{THEN statement(s)} {ELSE statement(s)}
LOCK lock.num
{THEN statement(s)} {ELSE statement(s)}
LOGMSG text
LOOP
REPEAT
UNTIL and EXIT.
LOWER(string)
LTS(expr1, expr2)
MARK.MAPPING file.var, OFF
MARK.MAPPING file.var, ON
MARK.MAPPING file.var, expr
MAT matrix = expr
MAT matrix = MAT src.matrix
MATBUILD var FROM mat {, start.expr {, end.expr} {USING delimiter}
MATCHFIELD(string, pattern, element)
MATPARSE
MATPARSE mat FROM string, delimiter
MATREAD
MATREAD{L|U} mat FROM file.var, record.id
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
MATREADCSV matrix FROM file.var
{THEN statement(s)} {ELSE statement(s)}
MATREADL
MATREADU
MATWRITE{U} mat TO file.var, record.id {ON ERROR statement(s)}
MAX (a, b)
MAXIMUM(dyn.array)
MIN (a, b)
MINIMUM(dyn.array)
MOD(dividend, divisor)
MODS(dividend, divisor)
NAP time
NEG(expr)
NEGS(dynarray)
NES(expr1, expr2)
NOBUF file.var
{THEN statement(s)} {ELSE statement(s)}
NOT(expr)
NOTS(dynarray)
NULL
NUM(string)
NUMS(dynarray)
OBJECT(cat.name {, args})
OBJINFO(var , key)
OCONV(expr, conv.spec)
OCONVS(dynarray, conv.spec)
ON expr GO {TO} label1{:}, label2{:}, label3{:}
ON expr GOSUB label1{:}, label2{:}, label3{:}
ON expr GOTO label1{:}, label2{:}, label3{:}
OPEN
OPEN {dict.expr,} filename.expr {READONLY} TO file.var
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
OPEN.SOCKET(addr, port, flags)
OPENPATH pathname {READONLY} TO file.var
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
OPENSEQ file.name, id {APPEND | OVERWRITE | READONLY} TO file.var
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
OPENSEQ pathname {APPEND | OVERWRITE | READONLY} TO file.var
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
ORS(expr1, expr2)
OS.ERROR()
OS.EXECUTE expr {CAPTURING var}
OUTERJOIN({DICT} file.name, field.name, value)
PAGE {ON print.unit} {page.no}
PAUSE {timeout}
PRECISION expr
PRINT {ON print.unit} {print.list}
PRINTCSV {ON print.unit} var1, var2, ... {:}
PRINTER CLOSE {ON print.unit}
PRINTER DISPLAY {ON print.unit} {ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
PRINTER FILE {ON print.unit} file.name, record.name
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
PRINTER NAME {ON print.unit} printer.name
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
PRINTER ON
PRINTER OFF
PRINTER RESET
PRINTERR expr
PRIVATE var, ...
PROGRAM name
PROMPT expr
PUBLIC FUNCTION name{(args)} {VAR.ARGS}
PUBLIC SUBROUTINE name{(args)} {VAR.ARGS}
PUBLIC var {READONLY}, ...
PWR(expr, pwr.expr)
QUOTE(expr)
RAISE(string)
RANDOMIZE expr
RDIV(dividend, divisor)
READ var FROM file.var, record.id
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READ.SOCKET(skt, max.len, flags, timeout)
READBLK var FROM file.var, bytes
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READCSV FROM file.var TO var1, var2, ...
{THEN statement(s)} {ELSE statement(s)}
READL var FROM file.var, record.id
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READLIST var {FROM list.no}
{THEN statement(s)} {ELSE statement(s)}
READNEXT var {FROM list.no} {ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READNEXT var, valpos, subvalpos {FROM list.no}
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READSEQ var FROM file.var {ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READU var FROM file.var, record.id
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READV var FROM file.var, record.id, field.expr
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READVL var FROM file.var, record.id, field.expr
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
READVU var FROM file.var, record.id, field.expr
{ON ERROR statement(s)} {LOCKED statement(s)}
{THEN statement(s)} {ELSE statement(s)}
RECORDLOCKED(file.var, record.id)
RECORDLOCKL file.var, record.id
{ON ERROR statement(s)} {LOCKED statement(s)}
RECORDLOCKU file.var, record.id
{ON ERROR statement(s)} {LOCKED statement(s)}
RELEASE {file.var{, record.id}} {ON ERROR statement(s)}
REM(dividend, divisor)
REMARK text or REM text
REMOVE string FROM dyn.array SETTING var
REMOVE(dyn.array, var)
REPLACE(dyn.array, field {, value {, subvalue}} , string)
RESTORE.SCREEN image, restore.state
RETURN
RETURN expr
RETURN TO label{:}
REUSE(num.array)
RND(expr)
ROLLBACK
RQM {time}
RTRANS({DICT} file.name, record.id, field, action)
SAVE.SCREEN().
SAVE.SCREEN(col, line, width, height)
SAVELIST name {FROM list.no}
SEEK file.var {, offset{, relto }}
{THEN statement(s)} {ELSE statement(s)}
SELECT file.var {TO list.no} {ON ERROR statement(s)}
SELECTE TO list.var
SELECTINDEX index.name {, value} FROM file.var {TO list.no}
SELECTINFO(list.no, key)
SELECTLEFT index.name FROM file.var
{SETTING key} {TO list.no}
SELECTN file.var {TO list.no}
{ON ERROR statement(s)}
SELECTRIGHT index.name FROM file.var
{SETTING key} {TO list.no}
SELECTV file.var TO list.no
{ON ERROR statement(s)}
SENTENCE()
SEQ(char)
SERVER.ADDR(server.name)
SET name{(args)} {VAR.ARGS}
SET.EXIT.STATUS value
SET.PORT.PARAMS(fvar, params)
SET.SOCKET.MODE(skt, key, value)
SETLEFT index.name FROM file.var
SETNLS key, value
SETREM offset ON string
SETRIGHT index.name FROM file.var
SHIFT(value, shift.len)
SIN(expr)
SLEEP {time}
SOCKET.INFO(skt, key)
SOUNDEX(string)
SOUNDEXS(string)
SPACE(count)
SPACES(dynarray)
SPLICE(array1, string, array2)
SQRT(expr)
SQUOTE(expr)
SSELECT file.var {TO list.no}
{ON ERROR statement(s)}
STATUS var FROM file.var
{THEN statement(s)} {ELSE statement(s)}
STATUS()
STOP {expr}
STR(string, count)
STRS(dynarray, count)
SUBR(name {,arg1 {, arg2...})
SUBROUTINE name{(arg1 {, arg2...}) {VAR.ARGS}}
SUBSTITUTE(dyn.array, old.list, new.list {, delimiter})
SUBSTRINGS(dyn.array, start, length)
SUM(expr)
SUMMATION(expr)
SWAP(string, old, new{, occurrence{, start}})
SWAPCASE(string)
SYSTEM(key)
TAN(expr)
TCLREAD var
TERMINFO()
TERMINFO(cap.name)
TIME()
TIMEDATE()
TIMEOUT fvar, interval
TOTAL(expr)
TRANS({DICT} file.name, record.id, field, action)
TRANSACTION ABORT
TRANSACTION COMMIT
{THEN statements} {ELSE statements}
TRANSACTION START
{THEN statements} {ELSE statements}
TRIM(string)
TRIMB(string)
TRIMBS(dynarray)
TRIMF(string)
TRIMFS(dynarray)
TRIMS(dynarray)
UNASSIGNED(var)
UNLOCK lock.num
{THEN statement(s)} {ELSE statement(s)}
UNTIL expr
UPCASE(string)
VOID expr
VSLICE(string, value)
WAKE user.no
WEOFSEQ file.var
{ON ERROR statement(s)}
WHILE expr
WRITE var TO file.var, record.id
{ON ERROR statement(s)}
WRITE.SOCKET(skt, data, flags, timeout)
WRITEBLK var TO file.var
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
WRITECSV var1, var2, ... TO file.var
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
WRITESEQ var TO file.var
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
WRITESEQF var TO file.var
{ON ERROR statement(s)}
{THEN statement(s)} {ELSE statement(s)}
WRITEU var TO file.var, record.id
{ON ERROR statement(s)}
WRITEV var TO file.var, record.id, field.expr
{ON ERROR statement(s)}
WRITEVU var TO file.var, record.id, field.expr
{ON ERROR statement(s)}
XLATE({DICT} file.name, record.id, field, action)
XTD(expr)

------------------------------------------------------------------------------------------
ADDED BASIC COMMANDS (as of SD version 1.0-0)
(Unique to SD, never in OpenQM 2.6.6
------------------------------------------------------------------------------------------

SDDECRYPT (uses libsodium)
SDENCRYPT (uses libsodium)
SDEXT(Arg, IsArgMV, Function_id)

------------------------------------------------------------------------------------------
REMOVED BASIC COMMANDS
(Compared to OpenQM 2.6.6 - some were never supported in the GPL version of OpenQM)
------------------------------------------------------------------------------------------

ABORTE {error #}
ABORTM {msg.text}
CONNECT.PORT(port, baud, parity, bits, stop)
DECRYPT(data, key)
ENCRYPT(data, key)
ENTER.PACKAGE
EXIT.PACKAGE
ERRMSG msg.id {, arg...}
PACKAGE
PICK.ERRMSG option
PROCREAD var {THEN statement(s)} {ELSE statement(s)}
PROCWRITE expr
TRACE
TTYGET()
TTYSET var
STOPE {expr}
STOPM {print.list}

U

SD - The Open Source, Multivalue, String, Database

SDBasic Language Commands and Functions