COMTERP(1)

NAME
comterp - distributed command interpreter demonstrator

SYNOPSIS
comterp
comterp remote
comterp server "portnum"
comterp logger "portnum"
comterp client "host" "portnum" ["file"]
comterp telcat "host" "portnum" ["file"]
comterp run "file"
comterp "expr"

DESCRIPTION
comterp demonstrates the command interpreter incorporated into ivtools. A user (or client program) can interact with comterp via stdin and stdout or telnet (when ACE is built in). The command syntax is a semi-colon separated list of commands with arbitrary number of parameters enclosed in parenthesis, with support for optional parameters and keyword arguments, i.e:

       command2(arg1 arg2 arg3 :key1 val1 :key2 val2);
       command1(arg1 arg2 arg3 :key1 val1 :key2 val2)

C-like binary expressions can be embedded anywhere in the command language, using the operators in the table below. Variables can be created on the fly with an assignment operator (i.e "ball=1" creates a integer "ball" variable set to 1). Unterminated expressions cause an automatic command line extension (until the parser determines the expression is complete). "(), "{}", and "[]" can all be used interchangeably.

COMMAND OPTIONS

comterp

Invoke a single command interpreter to interact with via stdin and stdout.

comterp remote

Invoke a single command interpreter, like the default, and include a remote command for accessing other comterp's in server mode.

comterp server "portnum"

Listens for and accept connections on portnum, then setup a command interpreter to wait for and process commands from that connection.

comterp logger "portnum"

Listens for and accept connections on portnum, then simply forward the incoming messages to stdout, while ack'ing back with newlines. For debugging purposes, not really a use of the interpreter.

comterp client "host" "portnum" ["file"]

Connect to a portnum on a host and send/receive new-line terminated text buffers. For debugging purposes, not really a use of the interpreter.

comterp telcat "host" "portnum" ["file"]

Connect to a portnum on a host, cat the file, then close the connection. Not really a use of the interpreter either.

comterp run "file"

Run contents of file then exit.

comterp "expr"

Evaluate single expression then exit.

OPERATOR TABLE
    Operators  Command Name   Priority    Order       Type
    ---------  ------------   --------    -----       ----
    .          dot            130         R-to-L      binary
    `          bquote         125         R-to-L      unary-prefix
    !          negate         110         R-to-L      unary-prefix
    ~          bit_not        110         R-to-L      unary-prefix
    ++         incr           110         R-to-L      unary-prefix
    ++         incr_after     110         R-to-L      unary-postfix
    -          minus          110         R-to-L      unary-prefix
    --         decr           110         R-to-L      unary-prefix
    --         decr_after     110         R-to-L      unary-postfix
    **         repeat         90          L-to-R      binary
    ..         iterate        80          L-to-R      binary
    %          mod            70          L-to-R      binary
    *          mpy            70          L-to-R      binary
    /          div            70          L-to-R      binary
    +          add            60          L-to-R      binary
    -          sub            60          L-to-R      binary
    <<         lshift         55          L-to-R      binary
    >>         rshift         55          L-to-R      binary
    <          lt             50          L-to-R      binary
    <=         lt_or_eq       50          L-to-R      binary
    >          gt             50          L-to-R      binary
    >=         gt_or_eq       50          L-to-R      binary
    !=         not_eq         45          L-to-R      binary
    ==         eq             45          L-to-R      binary
    &          bit_and        44          L-to-R      binary
    ^          bit_xor        43          L-to-R      binary
    |          bit_or         42          L-to-R      binary
    &&         and            41          L-to-R      binary
    ||         or             40          L-to-R      binary
    ,          tuple          35          L-to-R      binary
    ,,         stream concat  33          L-to-R      binary
    $          stream         32          R-to-L      unary-prefix
    $$         list           32          R-to-L      unary-prefix
    %=         mod_assign     30          R-to-L      binary
    *=         mpy_assign     30          R-to-L      binary
    +=         add_assign     30          R-to-L      binary
    -=         sub_assign     30          R-to-L      binary
    /=         div_assign     30          R-to-L      binary
    =          assign         30          R-to-L      binary
    ;          seq            10          L-to-R      binary

MATHEMATICAL COMMANDS:

 n=min(a b) -- return minimum of a and b

 n=max(a b) -- return maximum of a and b

 n=abs(a) -- return absolute value of a

 dbl=exp(x) -- returns the value e raised to the power of x

 dbl=log(x) -- returns the natural logarithm of x

 dbl=log10(x) -- returns the base-10 logarithm of x

 dbl=log2(x) -- returns the base-2 logarithm of x

 dbl=pow(x y) -- returns the value of x raised to the power of y

 dbl=acos(x) -- returns the arc cosine of x in radians

 dbl=asin(x) -- returns the arc sine of x in radians

 dbl=atan(x) -- returns the arc tangent of x in radians

 dbl=atan2(y x) -- returns the arc tangent of y over x

 dbl=cos(x) -- returns the cosine of x radians

 dbl=sin(x) -- returns the sine of x radians

 dbl=tan(x) -- returns the tangent of x radians

 dbl=sqrt(x) -- returns square root of x

 dbl=pi() -- returns the value of pi

 dbl=radtodeg(dbl) -- convert radians to degrees

 dbl=degtorad(dbl) -- convert degrees to radians

 num=floor(num) -- return closest integer value less than or equal to argument

 num=ceil(num) -- return closest integer value greater than or equal to argument

 num=round(num) -- return closest integer value

AFFINE TRANSFORM AND MATRIX COMMANDS:

 point=xform(x,y a00,a01,a10,a11,a20,a21) -- affine transform of x,y coordinates

 affine=invert(a00,a01,a10,a11,a20,a21) -- invert affine transform

 matrix=xpose(matrix) -- transpose an arbitrary matrix

 matrix=matrix*matrix -- matrix multiplication

STATISTICAL/RANDOM COMMANDS:

 sum(val1[,val2[,...,valn]]) -- return sum of values

 mean(val1[,val2[,...,valn]]) -- return mean of values

 var(val1[,val2[,...,valn]]) -- return variance of values

 stddev(val1[,val2[,...,valn]]) -- return standard deviation of values

 rand([minval,maxval]) -- return random number between 0 and 1 or minval,maxval

 srand(seedval) -- seed random number generator

LIST COMMANDS:

 lst=list([lst|strm|val|fileobj|pipeobj) :strmlst :attr :size n) -- create list, copy list, or convert stream

 val=at(lst|attrlst|str n :set val :ins val) -- return (or set or insert after) nth item in a list or string

 num=size(lst|attrlst|str) -- return size of a list (or string)

 val=index(lst|str val|char|str :last :all :substr) -- return index of value (or char or string) in list (or string), nil if not found.

STREAM COMMANDS:

 strm=stream(strm|lst|attrlst|val|fileobj|pipeobj) -- copy stream or convert list (unary $)

 val=next(stream :skim) -- return next value from stream, don't recurse if :skim

 cnt=each(strm) -- traverse stream returning its length

 comp=filter(comps classid) -- filter stream of comps for matching classid

CONTROL COMMANDS (using post evaluation):

 val=cond(testexpr trueexpr falseexpr) -- evaluate testexpr, and if true, evaluate and return trueexpr, otherwise evaluate and return falseexpr

 val=if(testexpr :then expr :else expr) -- evaluate testexpr and execute the :then expression if true, the :else expression if false.

 val=for(initexpr whileexpr [nextexpr [bodyexpr]] :body expr) -- for loop

 val=while([testexpr [bodyexpr]] :nilchk :until :body expr ) -- while loop

 val=switch(val key-body-pairs) -- switch statement (:casen for pos., :case_n for neg., otherwise :symbol)

 continue -- skip to next iteration of for or while loop

 break([retval]) -- break out of for or while loop

SYMBOL COMMANDS

 val=global(sym)|global(sym)=val|global(sym :clear)|global(:cnt) -- make symbol global

 int|lst=symid([sym [sym ...]] :max :cnt) -- return integer id(s) associated with symbol(s)

 sym|lst=symbol(symid [symid ...]) -- return symbol(s) associated with integer id(s)

 val|lst=symval(symv [symv ...]) -- return value(s) associated with symbol variables(s)

 symv|lst=symadd(sym|str [sym|str ...]) -- create symbol(s) and return without lookup.

 sym=symvar(symv) -- return symbol of symbol variable without lookup, for use on left hand side of assignment

 str=symstr(symv) -- return string version of symbol in symbol variable

 sym=bquote(sym) -- LISP-like backquote operator, returns symbol without lookup

 n=strref(str|symid) -- return string reference count

 bool=eq(sym1 sym2 :sym) -- symbol comparison

FILE COMMANDS

 fileobj|pipeobj=open([filename [modestr]] :pipe :in :out :err) -- open file command

 close(fileobj|pipeobj) -- close file command

 [str]=print([fmtstr] [val [val1 [... valn]]] :string|:str :out :err :file fileobj|pipeobj :prefix str) -- print value with optional format string

 str=gets(fileobj|pipeobj|sockobj) -- gets a new-line terminated string from a file

STRING COMMANDS

 lst=split(sym|str :tokstr [delim] :tokval [delim] :keep :reverse) -- split symbol or string into list of characters (or tokens).

 str=join(lst :sym) -- join list of characters into string

 str=substr(str n|str :after :nonil) -- extract characters from a string (:nonil returns string if no match)

 bool=eq(str1 str2 :n len) -- partial string comparison

ATTRIBUTE COMMANDS

 sym=attrname(attribute) -- return name field of dotted pair

 val=attrval(attribute) -- return value field of dotted pair

 dotlst=dot(name) -- construct empty dotted pair list

INFO COMMANDS

 help(cmdname [cmdname ...] :all :posteval) -- help for commands

 optable(:bypri :byopr :bycom) -- print contents of operator table

DEBUG COMMANDS

 val=trace([flag] :get) -- toggle or set trace mode

 pause([msgstr]) -- pause script execution until C/R

 step() -- toggle stepwise script execution

 mute([flag]) -- set or toggle mute flag

 postfix(arg1 [arg2 [arg3 ... [argn]]]) -- echo unevaluated postfix arguments (with [narg|nkey] after defined commands, {narg|nkey} after undefined commands, (narg) after keys, and a * following post-evaluation commands)

 parse(fileobj) -- parse a single expression from a file

CONTROL COMMANDS

 arr=posteval(arg1 [arg2 [arg3 ... [argn]]]) -- post-evaluate every fixed argument (until nil) and return array

 quit() -- quit the interpreter

 exit() -- exit entire application

 empty() -- empty statement

 val=run(filename :str :popen) -- run commands from file (or string)

 sockobj=%s(hoststr portnum ) -- create and open socket object

 val=remote(hoststr|sockobj [portnum] cmdstr :nowait :str) -- remotely evaluate command string then locally evaluate result string

 val=eval(cmdstr|funcobj [cmdstr|funcobj ...] :symret ) -- evaluate string (or funcobj) as commands, optionally return symbol instead of nil

 funcobj=func(body :echo) -- encapsulate a body of commands into an executable object

 val=shell(cmdstr) -- evaluate command in shell

 usleep(msec) -- sleep microseconds

UTILITY COMMANDS

 nil([...]) -- accept any arguments and return nil

 true([...]) -- accept any arguments and return true

 false([...]) -- accept any arguments and return false

 c=char(num :u) -- convert any numeric to a char

 s=short(num :u) -- convert any numeric to a short

 i=int(num :u) -- convert any numeric to an int

 l=long(num :u) -- convert any numeric to a long

 f=float(num) -- convert any numeric to a float

 d=double(num) -- convert any numeric to a double

 sym|lst=type(val [val ...]) -- return type symbol(s) for value(s)

 sym|lst=class(val [val ...]) -- return class symbol(s) for value(s) of object type

 int=ctoi(char) -- convert character to integer

 flag=isspace(char) -- return true if character is whitespace

 flag=isdigit(char) -- return true if character is a numeric digit

 flag=isspace(char) -- return true if character is alphabetical

 str=arg(n) -- return command line argument

 n=narg(n) -- return number of command line arguments

 num=nand(a b) -- bitwise NAND(negated AND)

 num=nor(a b) -- bitwise NOR (negated OR)

 num=xnor(a b) -- bitwise XNOR (negated XOR)

 dateobj|int = date([num|str|dateobj] :day :month :year :daymo :weekday) -- create date from days since 1/1/1901 or string

ONLY IN SERVER MODE

 str=timeexpr(comstr :sec n) -- command string to execute at intervals

SEE ALSO
    comdraw

WEB PAGES
     http://www.ivtools.org/ivtools/comterp.html