read macros:

                '<expr>         == (quote <expr>)
                #'<expr>        == (function <expr>)
                #(<expr>...)    == an array of the specified expressions
                #x<hdigits>     == a hexadecimal number
                #\<char> 	== the ASCII code of the character
                `<expr>         == (backquote <expr>)
                ,<expr>         == (comma <expr>)
                ,@<expr>        == (comma-at <expr>)
Functions
(* <expr>...)	multiply a list of numbers
(+ <expr>...)	add a list of numbers
(- <expr>...)	subtract a list of numbers or negate a single number
(/ <expr>...)	divide a list of numbers
(/= <e1> <e2>)	test for not equal to
(1+ <expr>)	add one to a number
(1- <expr>)	subtract one from a number
(< <e1> <e2>)	test for less than
(<= <e1> <e2>)	test for less than or equal to
(= <e1> <e2>)	test for equal to
(> <e1> <e2>)	test for greater than
(>= <e1> <e2>)	test for greater than or equal to
(abs <expr>)	the absolute value of a number
(address-of <expr>)	get the address of an xlisp node
(alloc <num>)	change number of nodes to allocate in each segment
(and [<expr>]...)	the logical and of a list of expressions(shortcircuited)
(append [<expr>]...)	append lists
(apply <fun> <args>)	apply a function to a list of arguments
(aref <array> <n>)	get the nth element of an array
(assoc <expr> <alist> [<key> <test>])	find an expression in an a-list
(atom <expr>)	is this an atom?
(backquote <expr>)	fill in a template - Macro arguments prefixed by comma
(baktrace [<n>])	print n levels of trace back information
(boundp <sym>)	is this a bound symbol?
(break [<bmsg> [<arg>]])	enter a break loop
(car <expr>)	return the car of a list node
(case <expr> [<case>]...)	select by case <case>::=(<value> [<expr>]...)
(catch <sym> [<expr>]...)	evaluate expressions and catch throws
(cdr <expr>)	return the cdr of a list node
(cerror <cmsg> <emsg> [<arg>])	signal a correctable error
(char <string> <index>)	extract a character from a string
(clean-up)	clean-up after an error
(close <fp>)	close a file
(comma <argument>)	evaluate argument in a backquoted macro body(?)
(comma_at <argument>)	evaluate argument in a backquoted macro body and splice
(cond [<case>]...)	evaluate conditionally <case> ::= (<pred> [<expr>]...)
(cons <expr1> <expr2>)	construct a new list node
(consp <expr>)	is this a non-empty list?
(continue)	continue from a correctable error
(cos <expr>)	compute the cosine of a number
(cxxr <expr>)	all cxxr combinations
(cxxxr <expr>)	all cxxxr combinations
(cxxxxr <expr>)	all cxxxxr combinations
(define (<sym> <fargs>) [<expr>]...)     Scheme-like definition
(defmacro <sym> <fargs> [<expr>]...)	define a macro
(defun <sym> <fargs> [<expr>]...)	define a function
(delete <expr> <list> [<key> <test>])	delete an expression from a list
(do ([<binding>]...) (<texpr> [<rexpr>]...) [<expr>]...)
(do* ([<binding>]...) (<texpr> [<rexpr>]...) [<expr>]...)
(dolist (<sym> <expr> [<rexpr>]) [<expr>]...)	loop through a list
(dotimes (<sym> <expr> [<rexpr>]) [<expr>]...)	loop from zero to n-1
(eq <expr1> <expr2>)	are the expressions identical?
(eql <expr1> <expr2>)	are the expressions identical?
(equal <expr1> <expr2>)	are the expressions equal?
(error <emsg> [<arg>])	signal a non-correctable error
(errset <expr> [<pflag>])	trap errors
(eval <expr>)	evaluate an xlisp expression
(evalhook <expr> <ehook> <ahook> [<env>])	evaluate with hooks
(evenp <expr>)	is this number even?
(exit)	exit xlisp
(exp <x-expr>)	compute e to the x power
(expand <num>)	expand memory by adding segments
(expt <x-expr> <y-expr>)	compute x to the y power
(flatc <expr>)	length of printed representation using princ
(flatsize <expr>)	length of printed representation using prin1
(float <expr>)	converts an integer to a floating point number
(funcall <fun> [<arg>]...)	call a function with arguments
(function <expr>)	quote a function
(gc)	force garbage collection
(gensym [<tag>])	generate a symbol
(get <sym> <prop>)	get the value of a property
(go <sym>)	go to a tag within a prog construct
(hash <sym> <n>)	compute the hash index for a symbol
(help <sym>)	Scan functions.lsp for function named <sym>
(if <texpr> <expr1> [<expr2>])	if texpr then expr1 else expr2
(intern <pname>)	make an interned symbol
(lambda <args> [<expr>]...)	make a function closure
(last <list>)	return the last list node of a list
(length <expr>)	find the length of a list or string
(let ([<binding>]...) [<expr>]...)	create local bindings
(let* ([<binding>]...) [<expr>]...)	let with sequential binding
(list [<expr>]...)	create a list of values
(listp <expr>)	is this a list?
(load <fname> [<vflag> [<pflag>]])	load an xlisp source file
(logand <expr>...)	the bitwise and of a list of numbers
(logior <expr>...)	the bitwise inclusive or of a list of numbers
(lognot <expr>)	the bitwise not of a number
(logxor <expr>...)	the bitwise exclusive or of a list of numbers
(make-array <size>)	make a new array
(make-symbol <pname>)	make an uninterned symbol
(man)	Display the manual pages
(mapc <fcn> <list1> [<list>]...)	apply function to successive cars
(mapcar <fcn> <list1> [<list>]...)	apply function to successive cars
(mapl <fcn> <list1> [<list>]...)	apply function to successive cdrs
(maplist <fcn> <list1> [<list>]...)	apply function to successive cdrs
(max <expr>...)	the largest of a list of numbers
(mem)	show memory allocation statistics
(member <expr> <list> [<key> <test>])	find an expression in a list
(min <expr>...)	the smallest of a list of numbers
(minusp <expr>)	is this number negative?
(nconc [<list>]...)	destructively concatenate lists
(not <expr>)	is this false?
(nth <n> <list>)	return the nth element of a list
(nthcdr <n> <list>)	return the nth cdr of a list
(null <expr>)	is this an empty list?
(numberp <expr>)	is this a number?
(oddp <expr>)	is this number odd?
(open <fname> <modestring>)	open a file, returns stream for I/O
(or [<expr>]...)	the logical or of a list of expressions
(peek <addrs>)	peek at a location in memory
(peek-char [<flag> [<source>]])	peek at the next character
(plusp <expr>)	is this number positive?
(poke <addrs> <value>)	poke a value into memory
(prin1 <expr> [<sink>])	print a list of values
(princ <expr> [<sink>])	print a list of values without quoting
(print <expr> [<sink>])	print a list of values on a new line
(prog ([<binding>]...) [<expr>]...)	the program feature
(prog* ([<binding>]...) [<expr>]...)	prog with sequential binding
(prog1 <expr1> [<expr>]...)	execute expressions sequentially
(prog2 <expr1> <expr2> [<expr>]...)	execute expressions sequentially
(progn [<expr>]...)	execute expressions sequentially
(putprop <sym> <val> <prop>)	put a property onto a property list
(quote <expr>)	return an expression unevaluated
(random <n>)	compute a random number between 1 and n-1
(read [<source> [<eof> [<rflag>]]])	read an xlisp expression
(read-char [<source>])	read a character from a file or stream
(read-line [<source>])	read a line from a file or stream
(rem <expr>...)	remainder of a list of numbers
(remove <expr> <list> [<key> <test>])	remove an expression
(remprop <sym> <prop>)	remove a property
(return [<expr>])	cause a prog construct to return a value
(reverse <expr>)	reverse a list
(rplaca <list> <expr>)	replace the car of a list node
(rplacd <list> <expr>)	replace the cdr of a list node
(set <sym> <expr>)	set the value of a symbol
(setf [<place> <expr>]...)	set the value of a field
(setq [<sym> <expr>]...)	set the value of a symbol
(sin <expr>)	compute the sine of a number
(sqrt <expr>)	compute the square root of a number
(strcat [<expr>]...)	concatenate strings
(string <expr>)	make a string from an integer ascii value
(sublis <alist> <expr> [<key> <test>])	substitute with an a-list
(subst <to> <from> <expr> [<key> <test>])	substitute expressions
(subseq <expr> <sexpr> [<lexpr>]) extract a substring
(symbol-name <sym>)	get the print name of a symbol
(symbol-plist <sym>)	get the property list of a symbol
(symbol-value <sym>)	get the value of a symbol
(symbolp <expr>)	is this a symbol?
(system string)		send string as command to operating system.
(tan <expr>)	compute the tangent of a number
(terpri [<sink>])	terminate the current print line
(throw <sym> [<expr>])	throw to a catch
(top-level)	clean-up after an error and return to the top level
(transcript [<fname>])	create a file with a transcript of a session
(truncate <expr>)	truncates a floating point number to an integer
(type-of <expr>)	returns the type of the expression
(write-char <ch> [<sink>])	write a character to a file or stream
(zerop <expr>)	is this number zero?