This is a list of Micro-Lisp 2.5 built in functions as published in the article by Nicholas Vrtis in the Transactor vol.8 no.6.
ABORT (ABORT msg)
Stops current processing, displays the message that msg evaluates to, and returns to the top level of processing. This function can be used to define additional error processing.
ABS (ABS n)
Returns the absolute valaue of n.
ADD (ADD n1 ... nn)
Returns the sum of the numbers n1 through nn.
AND (AND x1 ... xn)
Evaluates x1 and, if it is not nil, proceeds to evaluate the following arguments until nil is returned, or the end of the argument List is encountered. Not that AND does not evaluate the following arguments if nil is returned from any argument.
APPEND (APPEND l1 l2)
Returns the List created by appending l2 to the end of l1.
APURGE (APURGE atm)
Purges the Atom atm from memory and frees the space for re-use. Any references to atm in Lists are changed to reference nil. APURGE removes the value, definition, and property Lists of built-in functions, but does not remove the built-in definition or free the space.
ATOM (ATOM x)
Returns t (true) if x evaluates to an Atom; returns nil otherwise.
BAKTRACK (BAKTRACK n)
Displays the last n functions that were executed. Only valid if debug has been previously activated (see setdebug).
CAR (CAR list)
Returns the first part of list.
CDR (CDR list)
Returns the rest of list after the first part (the car) is skipped.
COLD (COLD)
Restarts Micro-Lisp from the beginning. All options and parameters are reset to the way they were when RUN was issued.
COND (COND (t1 r1)(t2 r2))
Evaluates t1 and executes r1. If t1 returns non-nil, cond proceeds to evaluate t2. Note that t2 will not be evaluated if t1 does not evaluate to nil. An error is issued if all tests evaluate to nil.
CONS (CONS x1 x2)
Returns a List that has x1 as its first part (car) and x2 as its rest part (cdr). If x1 and x2 evaluate to Atoms, a special List called a 'Dotted Pair' is returned.
DECIMAL (DECIMAL)
Sets the current number base to decimal and returns the number 10.
DEFINE (DEFINE fn arg x)
Create a function called fn that has arguments specified in the list arg. The body of the function is specified in the list x. In define, fn, arg, and x are evaluated. A defined function has an implied progn before the body.
DEFUN (DEFUN fn arg x)
Same as define, except that fn, arg, and x are not evaluated. It is a more convenient form when entering a function since quotes are not needed.
DISKCMD (DISKCMD msg)
Issues the disk command msg. This function opens and closes the disk command channel.
DISKST (DISKST)
Reads the disk status via the command channel. The function opens and closes the command channel.
DISK$ (DISK$)
Reads the disk directory and returns a List of Lists about the disk. Each entry is a List of 3 Atoms. The first Atom is the number of blocks, the second is the file name, and the third is the file type. The first entry is the disk name, and the last entry is the number of blocks.
DIVIDE (DIVIDE n1 n2)
Returns the integer result of n1 divided by n2.
DOUNTIL (DOUNTIL t x1 ... xn)
A looping function. The test t is evaluated and, until it is true (non-nil), the expressions x1 through xn are evaluated (using an implied progn). DOUNTIL returns the non-nil value returned from the expression t.
DOWHILE (DOWHILE t x1 ... xn)
A looping function. The test t is evaluated and, while it is still true (non-nil), the expressions x1 through xn are evaluated (using an implied progn). DOWHILE returns nil always.
EDIT (EDIT)
Exits Lisp to the BASIC screen editor. You may enter a Lisp program as you would a BASIC program. The only keywords that will function are LOAD, SAVE, LIST, NEW, and END. END returns you back to Micro-Lisp, the others operate as expected.
EQ (EQ x1 x2)
Returns t if x1 is identical to x2. Not very useful if comparing Lists.
EQUAL (EQUAL x1 x2)
Returns t if x1 is the same as x2, otherwise returns nil. This will properly test Lists.
EVAL (EVAL x)
Evaluates the List that x evaluates to. (Eval'(car'(a b))) will produce the same results as (car'(a b)).
EXIT (EXIT)
Leaves Lisp and returns to BASIC.
EXPLODE (EXPLODE a)
Returns a List of numbers that represent the ASCII value of thename of the Atom a. If a evaluates to a number, it is converted according to the current base and the ASCII values of the digits are returned.
GC (GC)
Forces a garbage collection to take place. Returns t.
GETDEF (GETDEF a)
Returns the definition of the function specified by a. Returns nil if a has not been previously defined.
GETPROP (GETPROP a pn)
Returns the property value stored under the property name pn under the atom a. Returns nil if pn is not defined under a.
GREATERP (GREATERP n1 ... nn)
Returns t if the numbers n1 through nn are in descending order. Note that equal is not considered descending.
HEX (HEX)
Set the current number conversion base to 16 (hexadecimal). Returns the value 10 hex (decimal 16).
IMPLODE (IMPLODE l)
Takes a List of numbers representing ASCII characters and returns an Atom whose print name is that series of ASCII characters. If any number is greater than 256, the ASCII character is taken from the MOD 256 value. If the print name resulting from imploding the List results in a valid number, then it will be converted to a number.
LAMBDA ((LAMBDA (x) (b)) y)
A method of executing a function without defining it. The current value of x is saved, then it is assigned the value of y and the body b is evaluated (with an implied progn). After b is evaluated, x is restored to its previous value. Note that there may be more than one Atom specified in the argument list, and that there must be a one to one correspondence between the number of arguments and the number of values supplied.
LENGTH (LENGTH x)
Returns the number of elements in the List x.
LESSP (LESSP n1 ... nn)
Returns t if the numbers n1 through nn are in ascending order. Note that equal is not considered ascending.
LIST (LIST x1 ... xn)
Returns a List containing x1 through xn.
LISTP (LISTP x)
Returns t if x evaluates to List, nil if x evaluates to an Atom.
LOAD (LOAD fn)
Loads a previously saved environment from file fn. This must be executed from the first level.
LPAREN (LPAREN)
Outputs the left parenthesis character.
MEM (MEM)
Prints out the number of the object entries, the number of free List entries and the amount of unallocated memory (in bytes). Returns the amount of unallocated memory.
MULTIPLY (MULTIPLY n1 ... nn)
Returns the product of n1 times n2 ... times nn. Note that no check is made for overflow.
NEW (NEW)
Clears memory of any user defined Atoms, Lists, and functions without changing settings such as pretty print, echo or number base.
NIL NIL, (NIL), or ()
This is the Lisp specification of 'nothing'. As a value it returns nil; as a function is also returns nil. It is also considered both an Atom and a List.
NTH (NTH n l)
Returns the nth element in List l.
NULL (NULL x)
Returns t if x evaluates to nil, returns nil otherwise (performs a logical NOT function).
NUMBERP (NUMBERP x)
Returns t if x evaluates to a number, nil otherwise.
OR (OR x1 ... xn)
Evaluates x1 and if it is nil, OR proceeds to evaluate the following arguments until a non-nil value is returned, or the end of the argument list is encountered. Note that OR does not evaluate the following arguments if non-nil is returned from any argument.
PATOM (PATOM a)
Prints the Atom a.
PRINT (PRINT x)
Prints the expression x evaluates to, followed by a carriage return. PRINT returns the value t. If the pretty print flag is set, each parenthesis level will be started on a new line, and will be indented.
PROGN (PROGN (x1) ... (xn))
Successively evaluates the specified function expressions, x1 through xn.
PUTPROP (PUTPROP a pn pv)
Puts the property value pv as the property pn of Atom a. If the property already exists, the old value is replaced by the new value.
QUOTE (QUOTE x)
Returns the unevaluated expression x.
RATOM (RATOM)
Waits for a single Atom to be entered from the terminal.
READ (READ)
Reads an expression from the terminal.
RPAREN (RPAREN)
Outputs a right parenthesis to the terminal.
SAVE (SAVE fn)
Saves the current environment (including all objects and Lists to file fn.
SET (SET a x)
Causes the value of x to be assigned to the Atom a.
SETBASE (SETBASE n)
Sets the number base used for conversion for both input and output. Note that n is converted and evaluated with the current base before the new number base is set.
SETDEBUG (SETDEBUG x)
If x evaluates to nil, debug mode is turned off; if it evaluates to non-nil, debug mode is turned on. Debug mode is useful for problem determination. If debug mode is son, Micro-Lisp will track up to the last 128 functions. This tracking can be reviewed using the BAKTRACK function. Unlike TRACE, which displays the actual input arguments to a function, DEBUG only tracks the unevaluated arguments. Debug mode also gives you an opportunity to print any Atom values before LAMBDA and function arguments are restored in error processing. This is sometimes useful in determining what caused an error condition to occur.
SETECHO (SETECHO x)
Used to control the echo of source input to the terminal. (SETECHO t) will cause all source input to be echoed (this is the default setting). (SETECHO nil) will eliminate the echo.
SETPRETTY (SETPRETTY x)
Used to set the pretty print flag. If x is non-nil, pretty printing will be turned on and expressions will be printed with each parenthesis on a new line and indented for easier reading. If x is nil, the flag is turned off.
SETQ (SETQ a x)
Causes the value of x to be assigned to Atom a (similar to SET, except that for SETQ, a is not evaluated).
SOURCE (SOURCE fn)
Directs that input is to come from the disk file fn instead of the keyboard. Input is obtained from there until the end of the source file. The source file may contain another SOURCE statement. This will close the current source file and open the new source file for input.
SUBTRACT (SUBTRACT n1 n2)
Returns the value of n1 - n2.
SYS (SYS adr x y a f)
Invokes a machine language routine at address adr. The values for the x, y, a and f (flag) registers are optional and specified by the corresponding arguments. This function will not allow the IRQ flag to be set, but any other processor flags can be set with the f argument. This function returns a List of numbers consisting of the values of the X, Y, A and FLAG registers after the return from the machine code call.
T T, (T)
T is one method of specifying a non-nil value. As a function, T returns t.
TERPRI (TERPRI)
Causes a carriage return to be output.
TRACE (TRACE x)
Causes each function level and its arguments to be output to the terminal as it is evaluated. Note that the actual evaluated arguments are output.
UNDEF (UNDEF a)
Removes the function definition from the Atom a. If a was a native function that had been redefined, the native definition will be restored.
ZEROP (ZEROP n)
Returns t if n is equal to zero; returns nil if it is not.
+ (+ n1 ... nn)
Shorthand for ADD.
- (- n1 n2)
Shorthand for SUBTRACT.
* (* n1 ... nn)
Shorthand for MULTIPLY.
/ (/ n1 n2)
Shorthand for DIVIDE.
Special Input Characters
------------------------
^ - Used to start and end a comment. All characters between the first and second ^ are ignored. (Note: this character prints on your C64 screen as an up arrow).
' - Used as shorthand for (quote ...). (quote x) can be shortened to 'x. Note the dropping of the word QUOTE and a set of parentheses. 'X will print out as (quote x).
" - Used to allow special characters and spaces to be included in an Atom name. Any characters between the double-quotes will become part of the Atom name. The double-quotes themselves will not become part of the name.
$ - Used to specify a base 16 (hex) number regardless of the current setting of base. Must precede any digits.
. - Used to specify a base 10 (decimal) number regardless of the current setting of base. Must precede any digits.
% - Used to specify a base 8 (octal) number regardless of the current setting of base. Must precede any digits.
Additional Notes
----------------
All numbers are stored as 24-bit signed integers. This allows a range of +8,388,607 to -8,388,608.
