Gamma™ : Version 6.4
	Appendix A. Function List

Appendix A. Function List

`absolute_path`	returns the absolute path of the given file.
`access`	checks a file for various permissions.
`acos`	finds the arc cosine of a number.
`add_echo_function`	assigns functions for echoes on a point.
`add_exception_function`	assigns functions for exceptions on a point.
`add_hook`	hooks a function to an event.
`add_set_function`	sets an expression to be evaluated when a given symbol changes value.
`after`	performs an action after a period of time.
`alist_p`	tests for association lists.
`allocated_cells`	gives the number of allocated and free cells.
`and`	is the same as the corresponding logical operator (&&).
`append`	concatenates several lists into a single new list.
`apropos`	finds all defined symbols in the current interpreter environment.
`aref`	returns an expression at a given index.
`array`	constructs an array.
`array_p`	tests for arrays.
`array_to_list`	converts an array to a list.
`aset`	sets an array element to a value at a given index.
`asin`	finds the arc sine of a number.
`assoc`	searches an association list for a sublist, using eq.
`assoc_equal`	searches an association list for a sublist, using equal.
`at`	performs an action at a given time, or regularly.
`atan`	finds the arc tangent of a number.
`atan2`	finds the arc tangent with two arguments.
`atexit`	evaluates code before exiting a program.
`AutoLoad`	allows for run-time symbol lookup.
`autoload_undefined_symbol`	checks undefined symbols for AutoLoad.
`AutoMapFunction`	maps a C function to a Gamma function.
`autotrace_p`	is for internal use only.
`backquote`	corresponds to a quote operator.
`band`	performs bitwise and operations.
`basename`	gives the base of a filename.
`bdelete`	deletes a single character from a buffer.
`bin`	converts numbers into binary form.
`binsert`	inserts a value into a buffer.
`block_signal`	starts signal blocking.
`block_timers`	blocks timer firing.
`bnot`	performs bitwise not operations.
`bor`	performs bitwise inclusive or operations.
`breakpoint_p`	is for internal use only.
`bsearch`	searches an array or list for a element.
`buffer`	constructs a buffer.
`buffer_p`	tests for buffers.
`buffer_to_string`	converts a buffer to a string.
`builtin_p`	is for internal use only.
`bxor`	perform bitwise exclusive or operations.
`caaar`	returns that element of a list.
`caadr`	returns that element of a list.
`caar`	returns that element of a list.
`cadar`	returns that element of a list.
`caddr`	returns that element of a list.
`cadr`	returns that element of a list.
`call`	calls a class method for a given instance.
`cancel`	removes a timer from the set of pending timers.
`car`	returns that element of a list.
`cd`	changes the working directory.
`cdaar`	returns that element of a list.
`cdadr`	returns that element of a list.
`cdar`	returns that element of a list.
`cddar`	returns that element of a list.
`cdddr`	returns that element of a list.
`cddr`	returns that element of a list.
`cdr`	returns that element of a list.
`ceil`	rounds a real number up to the next integer.
`cfand`	performs and operations with a confidence factor.
`cfor`	performs or operations with a confidence factor.
`char`	generates an ASCII character from a number.
`char_val`	generates a character's numeric value.
`chars_waiting`	checks for characters waiting to be read on a file.
`class_add_cvar`	adds new class variables.
`class_add_ivar`	adds an instance variable to a class.
`class_name`	gives the name of the class.
`class_of`	gives the class definition of a given instance.
`class_p`	tests for classes.
`ClearAutoLoad`	removes all `AutoLoad` rules.
`clock`	gets the OS time.
`close`	closes an open file.
`close_task`	closes a task opened by `locate_task`.
`conf`	queries confidence factors.
`cons`	constructs a cons cell.
`cons_p`	tests for cons cells.
`constant_p`	tests for constants.
`copy`	makes a copy of the top list level of a list.
`copy_tree`	copies the entire tree structure and elements of a list.
`cos`	returns the cosine of a number.
`create_state`	is part of the SCADALisp exception-driven state machine mechanism.
`date`	gets the OS date and time; translates seconds into dates.
`date_of`	is obsolete, see date
`dec`	converts numbers into base-10 form.
`defclass`	is the function equivalent of the statement: `class`.
`defmacro`	is a Lisp equivalent of the function: `macro`.
`defmacroe`	is a Lisp equivalent of the function: `macro`.
`defmethod`	is the function equivalent of the function: `method`.
`defun`	is a function equivalent of the statement: `function`.
`defune`	is a function equivalent of the statement: `function`.
`defvar`	defines a global variable with an initial value.
`delete`	removes an element from an array.
`destroy`	destroys a class instance.
`destroyed_p`	tests for destroyed instances.
`_destroy_task`	should never be used.
`dev_read`	is a modification of QNX 4 `dev_read`.
`dev_setup`	is obsolete, see `ser_setup`.
`difference`	constructs a list of the differences between two lists.
`directory`	returns the contents of a directory.
`dirname`	returns the directory path of a file.
`div`	divides two numbers, giving an integer result.
`dlclose`	closes an open dynamic library.
`dlerror`	reports errors in dl functions.
`dlfunc`	reserved for future use.
`DllLoad`	loads dynamic libraries.
`dlmethod`	reserved for future use.
`dlopen`	loads a dynamic library from a file.
`drain`	modifies end-of-file detection.
`enter_state`	is part of the SCADALisp exception-driven state machine mechanism.
`eq`	compares for identity and equivalence.
`equal`	compares for identity and equivalence.
`errno`	detects and numbers errors.
`error`	redirects the interpreter.
`eval`	evaluates an argument.
`eval_count`	counts evaluations made since a program started.
`eval_list`	evaluates each element of a list.
`eval_string`	evaluates a string.
`every`	performs an action every number of seconds.
`exec`	executes a program.
`exit_program`	terminates the interpreter.
`exit_state`	is part of the SCADALisp exception-driven state machine mechanism.
`exp`	calculates an exponent of the logarithmic base (e).
`fd_close`	closes a open file identified by a file descriptor.
`fd_data_function`	attaches a write-activated callback to a file.
`fd_eof_function`	attaches an `_eof_`-activated callback to a file.
`fd_open`	opens a file or device and assigns it a file descriptor.
`fd_read`	reads a buffer or string from an open file identified by a file descriptor.
`fd_to_file`	creates a file pointer from a descriptor.
`fd_write`	writes a buffer or string to an open file identified by a file descriptor.
`file_date`	gives the file modification date.
`file_p`	tests for files.
`file_size`	gives the file size.
`fileno`	creates a file descriptor from a pointer.
`find`	searches a list using the function: `eq`.
`find_equal`	searches a list using the function: `equal`.
`fixed_point_p`	tests for fixed-point reals.
`floor`	rounds a real number down to its integer value.
`flush`	flushes any pending output on a file or string.
`flush_events`	handles all pending events, then exits.
`fork`	duplicates a process.
`format`	generates a formatted string.
`free_cells`	returns the number of available memory cells.
`funcall`	provides compatibility with other Lisp dialects.
`function_args`	lists the arguments of a function.
`function_body`	gives the body of a user-defined function.
`function_calls`	tells how often a function was called during profiling.
`function_name`	gives the name of a function.
`function_p`	tests for functions.
`function_runtime`	gives the time a function has run during profiling.
`gc`	runs the garbage collector.
`gc_blocksize`	is for internal use only.
`gc_enable`	is for internal use only.
`gc_newblock`	is for internal use only.
`gc_trace`	controls the tracing of garbage collection.
`gensym`	generates a unique symbol.
`getcwd`	gets the current working directory.
`getenv`	retrieves the value of an environment variable.
`gethostname`	gets the computer's host name.
`getnid`	returns the local node number.
`getpid`	returns the program ID.
`getprop`	returns a property value for a symbol.
`getsockopt`	gets a socket option.
`has_cvar`	queries for the existence of a class variable.
`has_ivar`	queries for the existence of an instance variable.
`hex`	converts numbers into hexadecimal form.
`init_async_ipc`	requests queue information from a task.
`init_ipc`	sets up necessary data structures for IPC.
`inp`	queries hardware ports (by byte).
`inpw`	queries hardware ports (by word).
`insert`	inserts a value at a given position.
`instance_p`	tests for instances.
`instance_vars`	finds all the instance variables of a class or instance.
`int`	converts numbers to integer form.
`int_p`	tests for integers.
`intersection`	constructs a list of all the elements found in both of two lists.
`ioctl`	performs control functions on a file descriptor.
`is_busy`	determines if a file is busy.
`is_class_member`	checks if an instance or class is a member of a class.
`is_dir`	determines if a file is a directory.
`is_file`	determines if a file exists.
`is_readable`	determines if a file is readable.
`is_writable`	determines if a file is writable.
`isend`	sends a synchronous message and doesn't wait for the result.
`ivar_type`	returns the type of a given instance variable.
`kill`	sends a signal to a process.
`length`	counts the number of elements in a list or array.
`list`	creates lists, evaluating the arguments.
`list_p`	tests for lists.
`list_to_array`	converts a list to an array.
`listq`	creates lists without evaluating the arguments.
`load`	loads files.
`load_lisp`	loads Lisp files.
`locate_task`	finds and connects to tasks by name.
`locate_task_id`	finds and connects to tasks by task ID and network node.
`lock_point`	locks or unlocks points.
`log`	calculates natural logarithms.
`log10`	calculates base 10 logarithms.
`logn`	calculates logarithms of a given base.
`long_p`	tests for long integers.
`macro`	helps generate custom functions.
`macro_p`	tests for macros.
`make_array`	creates an empty array.
`make_buffer`	creates a new, empty buffer.
`method_p`	tests for methods.
`mkdir`	creates a new sub-directory.
`mmap`	implements the C function call `mmap`.
`modules`	is obsolete, and returns nothing of value.
`name_attach`	attaches a name to a task.
`nanoclock`	gets the OS time, including nanoseconds.
`nanosleep`	pauses the interpreter for seconds and nanoseconds.
`nappend`	appends one or more lists, destructively modifying them.
`neg`	negates a number.
`new`	creates a new instance of a class.
`next_event`	blocks waiting for an event, and calls the event handling function.
`next_event_nb`	is the same as next_event, but doesn't block.
`nil_p`	tests for `nil` values.
`NoAutoLoad`	removes selected AutoLoad rules.
`not`	is the same as the corresponding logical operator (`!`).
`notrace`	turns tracing off.
`nremove`	removes list items, destructively altering the list.
`nreplace`	replaces elements in a list, using `eq`.
`nreplace_equal`	replaces elements in a list, using `equal`.
`nserve_query`	puts information from `nserve` into an array.
`nth_car`	iteratively applies the car functions to a list.
`nth_cdr`	iteratively applies the cdr functions to a list.
`number`	attempts to convert an expression to a number.
`number_p`	tests for numbers.
`oct`	converts numbers into octal form.
`open`	attempts to open a file.
`open_string`	allows a string to be used as a file.
`or`	is the same as the corresponding logical operator (\|\|).
`outp`	writes values to hardware ports (by byte).
`outpw`	writes values to hardware ports (by word).
`parent_class`	returns the closest parent (base) of a class or instance.
`parse_string`	parses an input string.
`path_node`	gives the node number of a path in a QNX 2 path definition.
`pipe`	creates a pipe.
`point_locked`	indicates if a point is locked.
`point_nanoseconds`	gives the nanoseconds from point_seconds that a point value changed.
`point_seconds`	gives the time the point value changed.
`point_security`	gives the security level of a point.
`pow`	raises a base to the power of an exponent.
`pretty_princ`	writes to the standard output file, with formatting.
`pretty_print`	writes Lisp-readable output to the standard output file, with formatting.
`pretty_write`	writes an expression to a file, applying formatting.
`pretty_writec`	writes an expression to a file, applying formatting.
`princ`	writes to the standard output file.
`print`	writes Lisp-readable output to the standard output file.
`print_stack`	prints a Gamma stack.
`profile`	collects statistics on function usage and run time.
`prog1`	groups several statements into one expression.
`progn`	groups several statements into one expression.
`properties`	should never be used.
`pty`	runs programs in a pseudo-tty.
`ptytio`	runs programs in a pseudo-tty, using a termios structure argument.
`qnx_name_attach`	registers a local or global name.
`qnx_name_detach`	detaches a name.
`qnx_name_locate`	is an implementation of the C function `qnx_name_locate`.
`qnx_osinfo`	returns a class very similar to QNX 4 `struct_osinfo`.
`qnx_osstat`	lists processor loads and number of READY processes at each priority level.
`qnx_proxy_attach`	creates a proxy message for a process.
`qnx_proxy_detach`	removes a proxy.
`qnx_proxy_rem_attach`	creates a remote proxy message for a task.
`qnx_proxy_rem_detach`	removes a remote proxy.
`qnx_receive`	performs a QNX 4 `Receive`.
`qnx_reply`	replies to messages of type: `qnx_receive`.
`qnx_send`	implements QNX 4 `Send`.
`qnx_spawn_process`	is an implementation of the C function `qnx_spawn`.
`qnx_trigger`	tells a proxy to send its message.
`qnx_vc_attach`	establishes a virtual circuit between two processes on two computers.
`qnx_vc_detach`	detaches a virtual circuit.
`qnx_vc_name_attach`	attaches a virtual circuit with a name instead of a process ID number.
`quote`	corresponds to a quote operator.
`random`	generates random numbers from 0 to 1.
`raw_memory`	tells the amount of memory in use.
`read`	reads a Lisp expression from a file.
`read_char`	reads the next character from the input file.
`read_double`	reads the next double from the input file.
`read_eval_file`	reads a file, evaluating and counting expressions.
`read_existing_point`	retrieves points.
`read_float`	reads the next float from the input file.
`read_line`	reads a single line of text.
`read_long`	reads the next long value from the input file.
`read_n_chars`	reads and stores characters.
`read_point`	creates and/or retrieves points.
`read_short`	reads the next short value from the input file.
`read_until`	reads characters, constructing a string as it goes.
`real_p`	tests for reals.
`register_all_points`	registers an application to receive exceptions for all points.
`register_exception`	is not yet documented.
`register_existing_point`	registers an application to receive exceptions for a single existing point.
`register_point`	creates and/or registers an application to receive exceptions for a single point.
`registered_p`	tests for registered points.
`remove`	removes list items without altering the list.
`remove_echo_function`	removes an echo function from a symbol.
`remove_exception_function`	removes an exception function from a symbol.
`remove_hook`	removes a hooked function.
`remove_set_function`	removes a set function from a symbol.
`rename`	renames a file.
`require`	requires/loads files.
`require_lisp`	requires/loads Lisp files.
`required_file`	determines which files would be loaded.
`reverse`	reverses the order of list elements.
`root_path`	strips the final file or directory name from a path.
`round`	rounds a real number up or down to the nearest integer.
`rplaca`	replaces the car of a list.
`rplacd`	replaces the cdr of a list.
`run_hooks`	runs a hooked function.
`secure_point`	alters the security level on a point.
`seek`	sets the file position for reading or writing.
`send`	transmits expressions for evaluation.
`send_async`	transmits expressions asynchronously.
`send_string`	transmits strings for evaluation.
`send_string_async`	transmits a string asynchronously.
`ser_setup`	sets parameters for a serial port device.
`set`	assigns a value to a symbol, evaluating both arguments.
`set_autotrace`	is reserved for future use.
`set_breakpoint`	is reserved for future use.
`set_conf`	sets confidence factors.
`set_domain`	sets the default domain for future calls.
`set_random`	starts random at a different initial number.
`set_security`	changes the security level for the current process.
`setenv`	sets an environment variable for the current process.
`setprop`	sets a property value for a symbol.
`setprops`	lists the most recent property value settings.
`setq`	assigns a value to a symbol, evaluating the second argument.
`setqq`	assigns a value to a symbol, not evaluating any arguments.
`setsockopt`	sets a socket option.
`shell_match`	compares string text to a pattern.
`shm_open`	opens shared memory objects.
`shm_unlink`	removes shared memory objects.
`shorten_array`	reduces or expands the size of an array.
`shorten_buffer`	reduces the size of a buffer.
`signal`	defines an expression to be evaluated at an OS-generated signal.
`sin`	returns the sine of a number.
`sleep`	suspends execution for seconds.
`sort`	sorts a list or array, destructively modifying the order.
`sqr`	finds the square of a number.
`sqrt`	finds the square root of a number.
`stack`	lists all functions called so far.
`strchr`	searches a string for a character, returning the first location.
`strcmp`	compares strings, case-sensitive.
`strerror`	retrieves an error message.
`stricmp`	compares strings, case-insensitive.
`string`	constructs a string.
`string_file_buffer`	queries a string file for its internal buffer.
`string_p`	tests for strings.
`string_split`	breaks a string into individual words.
`string_to_buffer`	creates a buffer object from a string.
`stringc`	constructs a string in Lisp-readable form,
`strlen`	counts the number of characters in a string.
`strncmp`	compares two strings and return a numeric result, case-sensitive.
`strnicmp`	compares two strings and return a numeric result, case-insensitive.
`strrchr`	searches a string for a character, returning the last location.
`strrev`	reverses the order of characters in a string.
`strstr`	finds the location of a given substring.
`substr`	returns a substring for a given location.
`sym_alist_p`	tests for symbolic association lists.
`symbol`	constructs a symbol from a string.
`symbol_p`	tests for symbols.
`system`	treats its argument as a system command.
`tan`	returns the tangent of a number.
`taskdied`	calls a function when a task stops.
`task_info`	gets information from a task descriptor.
`taskstarted`	calls a function when a task starts.
`tell`	indicates file position.
`terpri`	prints a newline to an open file.
`time`	gives command execution times.
`timer_is_proxy`	controls timer handling in Gamma.
`tmpfile`	generates temporary output file names.
`tolower`	converts upper case letters to lower case.
`toupper`	converts lower case letters to upper case.
`trace`	turns tracing on.
`trap_error`	traps errors in the body code.
`true_p`	tests for truth value.
`unblock_signal`	ends signal blocking.
`unblock_timers`	unblocks timer firing.
`unbuffer_file`	causes a file to be treated as unbuffered on both input and output.
`undefined_p`	tests for undefined values.
`undefined_symbol_p`	tests for undefined symbols.
`union`	constructs a list containing all the elements of two lists.
`unlink`	deletes a file.
`unread_char`	attempts to replace a character to a file for subsequent reading.
`unregister_point`	stops echo and exception message sending.
`unwind_protect`	ensures code will be evaluated, despite errors in the body code.
`usleep`	suspends execution for microseconds.
`wait`	waits for process exit status.
`when_echo_fns`	indicates the functions for echos on a point.
`when_exception_fns`	indicates the functions for exceptions on a point.
`when_set_fns`	returns all functions set for a symbol.
`whence`	gives input information.
`write`	writes an expression to a file.
`write_existing_point`	writes values to existing points.
`write_n_chars`	writes characters from a buffer to a file.
`write_point`	writes point values, creating points if necessary.
`writec`	writes a Lisp expression to a file.


13.3. Cogent IPC		Appendix B. GNU Lesser General Public License