%-*-mode:latex-*-
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Copyright (C) 1996-2004 Jason Evans <jasone@canonware.com>.
% All rights reserved.
% 
% Redistribution and use in source and binary forms, with or without
% modification, are permitted provided that the following conditions
% are met:
% 1. Redistributions of source code must retain the above copyright
%    notice(s), this list of conditions and the following disclaimer
%    unmodified other than the allowable addition of one or more
%    copyright notices.
% 2. Redistributions in binary form must reproduce the above copyright
%    notice(s), this list of conditions and the following disclaimer in
%    the documentation and/or other materials provided with the
%    distribution.
% 
% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
% EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
% PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
% LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
% CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
% SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
% BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
% WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
% OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
% EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Version: Onyx 5.1.1
%
% systemdict reference portion of Onyx Manual.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\subsection{systemdict}
\label{sec:systemdict}
\index{systemdict@\onyxop{}{systemdict}{}}

The systemdict dictionary contains most of the operators that are of general
use.  Although there are no mechanisms that prevent modification of systemdict,
programs should not normally need to modify systemdict, since globaldict
provides a place for storing globally shared objects.  All threads share the
same systemdict, which is implicitly locked.

Table~\ref{tab:systemdict} summarizes the contents of systemdict, and is broken
into the following categories:
\begin{itemize}
	\item{\htmlref{Operand stack operators}{subsec:systemdict:ostack}}
	\item{\htmlref{Execution, control, and execution stack
		operators}{subsec:systemdict:estack}}
	\item{\htmlref{Stack operators}{subsec:systemdict:stack}}
	\item{\htmlref{Number (integer, real) and math
		operators}{subsec:systemdict:math}}
	\item{\htmlref{String operators}{subsec:systemdict:string}}
	\item{\htmlref{Name operators}{subsec:systemdict:name}}
	\item{\htmlref{Array operators}{subsec:systemdict:array}}
	\item{\htmlref{Dictionary and dictionary stack
		operators}{subsec:systemdict:dict}}
	\item{\htmlref{Class, instance, and handle
		operators}{subsec:systemdict:class}}
	\item{\htmlref{File and filesystem operators}{subsec:systemdict:file}}
	\item{\htmlref{Socket and networking
		operators}{subsec:systemdict:socket}}
	\item{\htmlref{Logical and bitwise operators}{subsec:systemdict:logic}}
	\item{\htmlref{Type, conversion, and attribute
		operators}{subsec:systemdict:type_attr}}
	\item{\htmlref{Threading and synchronization
		operators}{subsec:systemdict:thread}}
	\item{\htmlref{Regular expression operators}{subsec:systemdict:regex}}
	\item{\htmlref{Miscellaneous operators}{subsec:systemdict:misc}}
\end{itemize}

\begin{longtable}{\optableformat{4.10}}
\caption{\label{tab:systemdict}systemdict summary} \\
\hline
\optableent
	{Input(s)}
	{Op/Proc/Var}
	{Output(s)}
	{Description}
\hline \hline
%begin{latexonly}
\endfirsthead
\caption[]{\emph{continued}} \\
\hline
\optableent
	{Input(s)}
	{Op/Proc/Var}
	{Output(s)}
	{Description}
\hline \hline \endhead
\multicolumn{2}{r}{\emph{Continued on next page...}} \endfoot
\hline \endlastfoot
%end{latexonly}
\multicolumn{2}{|l|}{\label{subsec:systemdict:ostack}Operand stack operators} \\
\hline \hline
\optableent
	{--}
	{{\bf \htmlref{mark}{systemdict:mark}}}
	{mark}
	{Create a mark.}
\hline
\optableent
	{\commas obj}
	{{\bf \htmlref{aup}{systemdict:aup}}}
	{obj \commas}
	{Rotate stack up one position.}
\hline
\optableent
	{obj \commas}
	{{\bf \htmlref{adn}{systemdict:adn}}}
	{\commas obj}
	{Rotate stack down one position.}
\hline
\optableent
	{--}
	{{\bf \htmlref{count}{systemdict:count}}}
	{count}
	{Get the number of objects on ostack.}
\hline
\optableent
	{mark \dots}
	{{\bf \htmlref{counttomark}{systemdict:counttomark}}}
	{mark \dots count}
	{Get the depth of the topmost mark on ostack.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{dup}{systemdict:dup}}}
	{obj dup}
	{Duplicate an object.}
\hline
\optableent
	{obj \commas}
	{{\bf \htmlref{bdup}{systemdict:bdup}}}
	{obj \commas dup}
	{Duplicate bottom object.}
\hline
\optableent
	{objects count}
	{{\bf \htmlref{ndup}{systemdict:ndup}}}
	{objects objects}
	{Duplicate objects.}
\hline
\optableent
	{obj \dots index}
	{{\bf \htmlref{idup}{systemdict:idup}}}
	{obj \dots dup}
	{Duplicate object on ostack at index.}
\hline
\optableent
	{\dots obj \commas index}
	{{\bf \htmlref{ibdup}{systemdict:ibdup}}}
	{\dots obj \commas dup}
	{Duplicate object on ostack at index from bottom.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{tuck}{systemdict:tuck}}}
	{b a b}
	{Tuck duplicate of top object under second object.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{under}{systemdict:under}}}
	{a a b}
	{Duplicate second object.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{over}{systemdict:over}}}
	{a b a}
	{Duplicate second object.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{exch}{systemdict:exch}}}
	{b a}
	{Exchange top two objects.}
\hline
\optableent
	{a b c}
	{{\bf \htmlref{up}{systemdict:up}}}
	{c a b}
	{Roll top three objects up one.}
\hline
\optableent
	{a \dots b count}
	{{\bf \htmlref{nup}{systemdict:nup}}}
	{b a \dots}
	{Roll count objects up one.}
\hline
\optableent
	{a b c}
	{{\bf \htmlref{dn}{systemdict:dn}}}
	{b c a}
	{Roll top three objects down one.}
\hline
\optableent
	{a \dots b count}
	{{\bf \htmlref{ndn}{systemdict:ndn}}}
	{\dots b a}
	{Roll count objects down one.}
\hline
\optableent
	{\dots amount}
	{{\bf \htmlref{rot}{systemdict:rot}}}
	{\dots}
	{Rotate stack up by \oparg{amount}.}
\hline
\optableent
	{region count amount}
	{{\bf \htmlref{roll}{systemdict:roll}}}
	{rolled}
	{Roll \oparg{count} objects up by \oparg{amount}.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{pop}{systemdict:pop}}}
	{--}
	{Remove object.}
\hline
\optableent
	{obj \commas}
	{{\bf \htmlref{bpop}{systemdict:bpop}}}
	{\commas}
	{Remove bottom object.}
\hline
\optableent
	{objects count}
	{{\bf \htmlref{npop}{systemdict:npop}}}
	{--}
	{Remove count objects.}
\hline
\optableent
	{objects \dots count}
	{{\bf \htmlref{nbpop}{systemdict:nbpop}}}
	{\dots}
	{Remove count objects from bottom.}
\hline
\optableent
	{obj \dots index}
	{{\bf \htmlref{ipop}{systemdict:ipop}}}
	{\dots}
	{Remove object at index.}
\hline
\optableent
	{\dots obj \commas index}
	{{\bf \htmlref{ibpop}{systemdict:ibpop}}}
	{\dots \commas}
	{Remove object at index from bottom.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{nip}{systemdict:nip}}}
	{b}
	{Remove second object.}
\hline
\optableent
	{objects}
	{{\bf \htmlref{clear}{systemdict:clear}}}
	{--}
	{Pop all objects off ostack.}
\hline
\optableent
	{mark \dots}
	{{\bf \htmlref{cleartomark}{systemdict:cleartomark}}}
	{--}
	{Remove objects from ostack through topmost mark.}
\hline
\optableent
	{--}
	{{\bf \htmlref{ostack}{systemdict:ostack}}}
	{stack}
	{Get a current ostack snapshot.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{threadostack}{systemdict:threadostack}}}
	{stack}
	{Get a reference to thread's ostack.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:estack}Execution, control, and
execution stack operators} \\
\hline \hline
\optableent
	{obj}
	{{\bf \htmlref{eval}{systemdict:eval}}}
	{--}
	{Evaluate object.}
\hline
\optableent
	{boolean obj}
	{{\bf \htmlref{if}{systemdict:if}}}
	{--}
	{Conditionally evaluate object.}
\hline
\optableent
	{boolean obj}
	{{\bf \htmlref{unless}{systemdict:unless}}}
	{--}
	{Conditionally evaluate object.}
\hline
\optableent
	{boolean a b}
	{{\bf \htmlref{ifelse}{systemdict:ifelse}}}
	{--}
	{Conditionally evaluate one of two objects.}
\hline
\optableent
	{init inc limit proc}
	{{\bf \htmlref{for}{systemdict:for}}}
	{--}
	{Iterate with a control variable.}
\hline
\optableent
	{count proc}
	{{\bf \htmlref{repeat}{systemdict:repeat}}}
	{--}
	{Iterate a set number of times.}
\hline
\optableent
	{cond proc}
	{{\bf \htmlref{while}{systemdict:while}}}
	{--}
	{ Loop while cond is true.}
\hline
\optableent
	{proc cond}
	{{\bf \htmlref{until}{systemdict:until}}}
	{--}
	{ Loop until cond is false.}
\hline
\optableent
	{proc}
	{{\bf \htmlref{loop}{systemdict:loop}}}
	{--}
	{ Loop indefinitely.}
\hline
\optableent
	{array proc}
	{{\bf \htmlref{foreach}{systemdict:foreach}}}
	{--}
	{Iterate on array elements.}
\optableent
	{dict proc}
	{{\bf \htmlref{foreach}{systemdict:foreach}}}
	{--}
	{Iterate on dictionary key/value pairs.}
\optableent
	{stack proc}
	{{\bf \htmlref{foreach}{systemdict:foreach}}}
	{--}
	{Iterate on stack elements.}
\optableent
	{string proc}
	{{\bf \htmlref{foreach}{systemdict:foreach}}}
	{--}
	{Iterate on string elements.}
\hline
\optableent
	{--}
	{{\bf \htmlref{continue}{systemdict:continue}}}
	{--}
	{Skip to next iteration of innermost looping context.}
\hline
\optableent
	{--}
	{{\bf \htmlref{exit}{systemdict:exit}}}
	{--}
	{Terminate innermost looping context.}
\hline
\optableent
	{file/string}
	{{\bf \htmlref{token}{systemdict:token}}}
	{false}
	{Unsuccessfully scan for a token.}
\optableent
	{file/string}
	{{\bf \htmlref{token}{systemdict:token}}}
	{rem obj true}
	{Successfully scan for a token}
\hline
\optableent
	{obj}
	{{\bf \htmlref{start}{systemdict:start}}}
	{--}
	{Evaluate object.}
\hline
\optableent
	{--}
	{{\bf \htmlref{quit}{systemdict:quit}}}
	{--}
	{Unwind to innermost start context.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{stopped}{systemdict:stopped}}}
	{boolean}
	{Evaluate object.}
\hline
\optableent
	{--}
	{{\bf \htmlref{stop}{systemdict:stop}}}
	{--}
	{Unwind to innermost stopped or start context.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{trapped}{systemdict:trapped}}}
	{false}
	{Snapshot stacks and evaluate object.}
\optableent
	{obj}
	{{\bf \htmlref{trapped}{systemdict:trapped}}}
	{arg true}
	{Snapshot stacks, evaluate object, catch \onyxop{}{escape}{}, restore
	snapshot.}
\hline
\optableent
	{arg}
	{{\bf \htmlref{escape}{systemdict:escape}}}
	{--}
	{Unwind to innermost trapped or start context.}
\hline
\optableent
	{name}
	{{\bf \htmlref{throw}{systemdict:throw}}}
	{obj}
	{Throw an error.}
\hline
\optableent
	{--}
	{{\bf \htmlref{maxestack}{systemdict:maxestack}}}
	{count}
	{Get maximum allowable estack depth.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gmaxestack}{systemdict:gmaxestack}}}
	{count}
	{Get default maximum allowable estack depth.}
\hline
\optableent
	{count}
	{{\bf \htmlref{setmaxestack}{systemdict:setmaxestack}}}
	{--}
	{Set maximum allowable estack depth.}
\hline
\optableent
	{count}
	{{\bf \htmlref{setgmaxestack}{systemdict:setgmaxestack}}}
	{--}
	{Set default maximum allowable estack depth.}
\hline
\optableent
	{--}
	{{\bf \htmlref{tailopt}{systemdict:tailopt}}}
	{boolean}
	{Get whether tail optimization is in effect.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gtailopt}{systemdict:gtailopt}}}
	{boolean}
	{Get default tail optimization setting.}
\hline
\optableent
	{boolean}
	{{\bf \htmlref{settailopt}{systemdict:settailopt}}}
	{--}
	{Set whether to use tail optimization.}
\hline
\optableent
	{boolean}
	{{\bf \htmlref{setgtailopt}{systemdict:setgtailopt}}}
	{--}
	{Set default tail optimization setting.}
\hline
\optableent
	{--}
	{{\bf \htmlref{estack}{systemdict:estack}}}
	{stack}
	{Get a current estack snapshot.}
\hline
\optableent
	{--}
	{{\bf \htmlref{estack}{systemdict:estack}}}
	{stack}
	{Get a current estack snapshot.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{threadestack}{systemdict:threadestack}}}
	{stack}
	{Get a reference to thread's estack.}
\hline
\optableent
	{--}
	{{\bf \htmlref{countestack}{systemdict:countestack}}}
	{count}
	{Get current estack depth.}
\hline
\optableent
	{--}
	{{\bf \htmlref{istack}{systemdict:istack}}}
	{stack}
	{Get a current istack snapshot.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{threadistack}{systemdict:threadistack}}}
	{stack}
	{Get a reference to thread's istack.}
\hline
\optableent
	{status}
	{{\bf \htmlref{die}{systemdict:die}}}
	{--}
	{Exit program.}
\hline
\optableent
	{path symbol}
	{{\bf \htmlref{modload}{systemdict:modload}}}
	{--}
	{Load a module.}
\hline
\optableent
	{file symbol}
	{{\bf \htmlref{mrequire}{systemdict:mrequire}}}
	{--}
	{Search for and load a module.}
\hline
\optableent
	{file}
	{{\bf \htmlref{require}{systemdict:require}}}
	{--}
	{Search for and evaluate a source file.}
\hline
\optableent
	{prog}
	{{\bf \htmlref{path}{systemdict:path}}}
	{path/null}
	{Search PATH for prog.}
\hline
\optableent
	{args}
	{{\bf \htmlref{exec}{systemdict:exec}}}
	{--}
	{Overlay a new program and execute it.}
\hline
\optableent
	{args}
	{{\bf \htmlref{forkexec}{systemdict:forkexec}}}
	{pid}
	{Fork and exec a new process.}
\hline
\optableent
	{args redirects}
	{{\bf \htmlref{forkexec}{systemdict:forkexec}}}
	{pid}
	{Fork and exec a new process.}
\hline
\optableent
	{pid}
	{{\bf \htmlref{waitpid}{systemdict:waitpid}}}
	{status}
	{Wait for a program to terminate.}
\hline
\optableent
	{args}
	{{\bf \htmlref{system}{systemdict:system}}}
	{status}
	{Execute a program.}
\hline
\optableent
	{pid sig}
	{{\bf \htmlref{kill}{systemdict:kill}}}
	{--}
	{Send a signal to a process.}
\hline
\optableent
	{\$SIG\_GETMASK oset}
	{{\bf \htmlref{sigmask}{systemdict:sigmask}}}
	{oset}
	{Get signal mask.}
\optableent
	{how set}
	{{\bf \htmlref{sigmask}{systemdict:sigmask}}}
	{--}
	{Modify signal mask.}
\optableent
	{how set oset}
	{{\bf \htmlref{sigmask}{systemdict:sigmask}}}
	{oset}
	{Modify signal mask.}
\hline
\optableent
	{set}
	{{\bf \htmlref{sigpending}{systemdict:sigpending}}}
	{set}
	{Get pending signals.}
\hline
\optableent
	{set}
	{{\bf \htmlref{sigsuspend}{systemdict:sigsuspend}}}
	{--}
	{Suspend until interrupted by a signal.}
\hline
\optableent
	{set}
	{{\bf \htmlref{sigwait}{systemdict:sigwait}}}
	{sig}
	{Wait for a signal.}
\hline
\optableent
	{--}
	{{\bf \htmlref{pid}{systemdict:pid}}}
	{pid}
	{Get process ID.}
\hline
\optableent
	{--}
	{{\bf \htmlref{ppid}{systemdict:ppid}}}
	{pid}
	{Get parent's process ID.}
\hline
\optableent
	{--}
	{{\bf \htmlref{uid}{systemdict:uid}}}
	{uid}
	{Get the process's user ID.}
\hline
\optableent
	{uid}
	{{\bf \htmlref{setuid}{systemdict:setuid}}}
	{boolean}
	{Set the process's user ID.}
\hline
\optableent
	{--}
	{{\bf \htmlref{euid}{systemdict:euid}}}
	{uid}
	{Get the process's effective user ID.}
\hline
\optableent
	{uid}
	{{\bf \htmlref{seteuid}{systemdict:seteuid}}}
	{boolean}
	{Set the process's effective user ID.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gid}{systemdict:gid}}}
	{gid}
	{Get the process's group ID.}
\hline
\optableent
	{gid}
	{{\bf \htmlref{setgid}{systemdict:setgid}}}
	{boolean}
	{Set the process's group ID.}
\hline
\optableent
	{--}
	{{\bf \htmlref{egid}{systemdict:egid}}}
	{gid}
	{Get the process's effective group ID.}
\hline
\optableent
	{gid}
	{{\bf \htmlref{setegid}{systemdict:setegid}}}
	{boolean}
	{Set the process's effective group ID.}
\hline
\optableent
	{pid}
	{{\bf \htmlref{getpgid}{systemdict:getpgid}}}
	{pgid}
	{Get process group ID.}
\hline
\optableent
	{pid pgid}
	{{\bf \htmlref{setpgid}{systemdict:setpgid}}}
	{--}
	{Set process group ID.}
\hline
\optableent
	{pid}
	{{\bf \htmlref{getsid}{systemdict:getsid}}}
	{sid}
	{Get session ID.}
\hline
\optableent
	{--}
	{{\bf \htmlref{setsid}{systemdict:setsid}}}
	{sid}
	{Create new session.}
\hline
\optableent
	{--}
	{{\bf \htmlref{realtime}{systemdict:realtime}}}
	{nsecs}
	{Get the number of nanoseconds since the epoch.}
\hline
\optableent
	{nsecs}
	{{\bf \htmlref{localtime}{systemdict:localtime}}}
	{dict}
	{Get a dict with local time definitions.}
\hline
\optableent
	{nanoseconds}
	{{\bf \htmlref{nsleep}{systemdict:nsleep}}}
	{--}
	{Nanosleep.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:stack}Stack operators} \\
\hline \hline
\optableent
	{--}
	{{\bf \htmlref{(}{systemdict:sym_lp}}}
	{fino}
	{Begin a stack declaration.}
\hline
\optableent
	{fino objects}
	{{\bf \htmlref{)}{systemdict:sym_rp}}}
	{stack}
	{Create a stack.}
\hline
\optableent
	{--}
	{{\bf \htmlref{stack}{systemdict:stack}}}
	{stack}
	{Create a stack.}
\hline
\optableent
	{stack obj}
	{{\bf \htmlref{spush}{systemdict:spush}}}
	{--}
	{Push object onto stack.}
\hline
\optableent
	{stack obj}
	{{\bf \htmlref{sbpush}{systemdict:sbpush}}}
	{--}
	{Push object onto bottom of stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{scount}{systemdict:scount}}}
	{count}
	{Get the number of objects on a stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{scounttomark}{systemdict:scounttomark}}}
	{count}
	{Get the depth of the topmost mark on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sdup}{systemdict:sdup}}}
	{--}
	{Duplicate an object.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sbdup}{systemdict:sbdup}}}
	{--}
	{Duplicate bottom object.}
\hline
\optableent
	{stack count}
	{{\bf \htmlref{sndup}{systemdict:sndup}}}
	{--}
	{Duplicate objects on stack.}
\hline
\optableent
	{stack index}
	{{\bf \htmlref{sidup}{systemdict:sidup}}}
	{--}
	{Duplicate object on stack at index.}
\hline
\optableent
	{stack index}
	{{\bf \htmlref{sibdup}{systemdict:sibdup}}}
	{--}
	{Duplicate object on stack at index from bottom.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{stuck}{systemdict:stuck}}}
	{--}
	{Tuck duplicate of top object on stack under next object on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sunder}{systemdict:sunder}}}
	{--}
	{Duplicate second object on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sover}{systemdict:sover}}}
	{--}
	{Duplicate second object on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sexch}{systemdict:sexch}}}
	{--}
	{Exchange top objects on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sup}{systemdict:sup}}}
	{--}
	{Roll top three objects on stack up one.}
\hline
\optableent
	{stack count}
	{{\bf \htmlref{snup}{systemdict:snup}}}
	{--}
	{Roll count objects on stack up one.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{saup}{systemdict:saup}}}
	{--}
	{Roll objects on stack up one.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sdn}{systemdict:sdn}}}
	{--}
	{Roll top three objects on stack down one.}
\hline
\optableent
	{stack count}
	{{\bf \htmlref{sndn}{systemdict:sndn}}}
	{--}
	{Roll count objects on stack down one.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sadn}{systemdict:sadn}}}
	{--}
	{Roll objects on stack down one.}
\hline
\optableent
	{stack amount}
	{{\bf \htmlref{srot}{systemdict:srot}}}
	{--}
	{Rotate objects on stack up by \oparg{amount}.}
\hline
\optableent
	{stack count amount}
	{{\bf \htmlref{sroll}{systemdict:sroll}}}
	{--}
	{Roll objects on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{spop}{systemdict:spop}}}
	{obj}
	{Pop object off stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sbpop}{systemdict:sbpop}}}
	{obj}
	{Pop object off bottom of stack.}
\hline
\optableent
	{stack count}
	{{\bf \htmlref{snpop}{systemdict:snpop}}}
	{array}
	{Pop count objects off stack.}
\hline
\optableent
	{stack count}
	{{\bf \htmlref{snbpop}{systemdict:snbpop}}}
	{array}
	{Pop count objects off bottom of stack.}
\hline
\optableent
	{stack index}
	{{\bf \htmlref{sipop}{systemdict:sipop}}}
	{obj}
	{Remove object on stack at index.}
\hline
\optableent
	{stack index}
	{{\bf \htmlref{sibpop}{systemdict:sibpop}}}
	{obj}
	{Remove object on stack at index from bottom.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{snip}{systemdict:snip}}}
	{obj}
	{Remove second object on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{sclear}{systemdict:sclear}}}
	{--}
	{Remove all objects on stack.}
\hline
\optableent
	{stack}
	{{\bf \htmlref{scleartomark}{systemdict:scleartomark}}}
	{--}
	{Remove objects from stack down through topmost mark.}
\hline
\optableent
	{(a) (b)}
	{{\bf \htmlref{cat}{systemdict:cat}}}
	{(a b)}
	{Catenate two stacks.}
\hline
\optableent
	{stacks count}
	{{\bf \htmlref{ncat}{systemdict:ncat}}}
	{stack}
	{Catenate stacks.}
\hline
\optableent
	{srcstack dststack}
	{{\bf \htmlref{copy}{systemdict:copy}}}
	{dststack}
	{Copy stack contents.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:math}Number (integer, real) and
math operators} \\
\hline \hline
\optableent
	{a b}
	{{\bf \htmlref{add}{systemdict:add}}}
	{r}
	{Add a and b.}
\hline
\optableent
	{a}
	{{\bf \htmlref{inc}{systemdict:inc}}}
	{r}
	{Add 1 to a.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{sub}{systemdict:sub}}}
	{r}
	{Subtract b from a.}
\hline
\optableent
	{a}
	{{\bf \htmlref{dec}{systemdict:dec}}}
	{r}
	{Subtract 1 from a.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{mul}{systemdict:mul}}}
	{r}
	{Multiply a and b.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{div}{systemdict:div}}}
	{r}
	{Divide a by b.}
\hline
\optableent
	{a b}
	{{\bf \htmlref{idiv}{systemdict:idiv}}}
	{r}
	{Divide a by b (integers).}
\hline
\optableent
	{a b}
	{{\bf \htmlref{mod}{systemdict:mod}}}
	{r}
	{Mod a by b (integers and reals).}
\hline
\optableent
	{a b}
	{{\bf \htmlref{pow}{systemdict:pow}}}
	{r}
	{Raise a to the power of b.}
\hline
\optableent
	{x}
	{{\bf \htmlref{exp}{systemdict:exp}}}
	{r}
	{$e$ (base of natural logarithm) raised to x.}
\hline
\optableent
	{a}
	{{\bf \htmlref{sqrt}{systemdict:sqrt}}}
	{r}
	{Square root.}
\hline
\optableent
	{a}
	{{\bf \htmlref{ln}{systemdict:ln}}}
	{r}
	{Natural log.}
\hline
\optableent
	{a}
	{{\bf \htmlref{log}{systemdict:log}}}
	{r}
	{Base 10 log.}
\hline
\optableent
	{a}
	{{\bf \htmlref{abs}{systemdict:abs}}}
	{r}
	{Get the absolute value of a.}
\hline
\optableent
	{a}
	{{\bf \htmlref{neg}{systemdict:neg}}}
	{r}
	{Get the negative of a.}
\hline
\optableent
	{a}
	{{\bf \htmlref{ceiling}{systemdict:ceiling}}}
	{r}
	{Integer ceiling of a real.}
\hline
\optableent
	{a}
	{{\bf \htmlref{floor}{systemdict:floor}}}
	{r}
	{Integer floor of a real.}
\hline
\optableent
	{a}
	{{\bf \htmlref{round}{systemdict:round}}}
	{r}
	{Real rounded to integer.}
\hline
\optableent
	{a}
	{{\bf \htmlref{trunc}{systemdict:trunc}}}
	{r}
	{Integer from real with truncated fractional.}
\hline
\optableent
	{a}
	{{\bf \htmlref{sin}{systemdict:sin}}}
	{r}
	{Sine in radians.}
\hline
\optableent
	{a}
	{{\bf \htmlref{sinh}{systemdict:sinh}}}
	{r}
	{Hyperbolic sine.}
\hline
\optableent
	{a}
	{{\bf \htmlref{asin}{systemdict:asin}}}
	{r}
	{Arcsine.}
\hline
\optableent
	{a}
	{{\bf \htmlref{asinh}{systemdict:asinh}}}
	{r}
	{Hyperbolic arcsine.}
\hline
\optableent
	{a}
	{{\bf \htmlref{cos}{systemdict:cos}}}
	{r}
	{Cosine in radians.}
\hline
\optableent
	{a}
	{{\bf \htmlref{cosh}{systemdict:cosh}}}
	{r}
	{Hyperbolic cosine.}
\hline
\optableent
	{a}
	{{\bf \htmlref{acos}{systemdict:acos}}}
	{r}
	{Arc cosine.}
\hline
\optableent
	{a}
	{{\bf \htmlref{acosh}{systemdict:acosh}}}
	{r}
	{Hyperbolic arc cosine.}
\hline
\optableent
	{x}
	{{\bf \htmlref{tan}{systemdict:tan}}}
	{r}
	{Tangent of x in radians.}
\hline
\optableent
	{x}
	{{\bf \htmlref{tanh}{systemdict:tanh}}}
	{r}
	{Hyperbolic tangent.}
\hline
\optableent
	{x}
	{{\bf \htmlref{atan}{systemdict:atan}}}
	{r}
	{Arctangent.}
\hline
\optableent
	{y x}
	{{\bf \htmlref{atan2}{systemdict:atan2}}}
	{r}
	{Arctangent in radians of $\frac{y}{x}$.}
\hline
\optableent
	{x}
	{{\bf \htmlref{atanh}{systemdict:atanh}}}
	{r}
	{Hyperbolic arctangent.}
\hline
\optableent
	{seed}
	{{\bf \htmlref{srand}{systemdict:srand}}}
	{--}
	{Seed pseudo-random number generator.}
\hline
\optableent
	{--}
	{{\bf \htmlref{rand}{systemdict:rand}}}
	{integer}
	{Get a pseudo-random number.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:string}String operators} \\
\hline \hline
\optableent
	{length}
	{{\bf \htmlref{string}{systemdict:string}}}
	{string}
	{Create a string.}
\hline
\optableent
	{string}
	{{\bf \htmlref{length}{systemdict:length}}}
	{count}
	{Get string length.}
\hline
\optableent
	{string index}
	{{\bf \htmlref{get}{systemdict:get}}}
	{integer}
	{Get string element.}
\hline
\optableent
	{string index integer}
	{{\bf \htmlref{put}{systemdict:put}}}
	{--}
	{Set string element.}
\hline
\optableent
	{string index length}
	{{\bf \htmlref{getinterval}{systemdict:getinterval}}}
	{substring}
	{Get a string interval.}
\hline
\optableent
	{string index substring}
	{{\bf \htmlref{putinterval}{systemdict:putinterval}}}
	{--}
	{Copy substring into string.}
\hline
\optableent
	{`a' `b'}
	{{\bf \htmlref{cat}{systemdict:cat}}}
	{`ab'}
	{Catenate two strings.}
\hline
\optableent
	{strings count}
	{{\bf \htmlref{ncat}{systemdict:ncat}}}
	{string}
	{Catenate strings.}
\hline
\optableent
	{srcstring dststring}
	{{\bf \htmlref{copy}{systemdict:copy}}}
	{dstsubstring}
	{Copy string.}
\hline
\optableent
	{obj depth}
	{{\bf \htmlref{sprints}{systemdict:sprints}}}
	{string}
	{Create syntactical string from object.}
\hline
\optableent
	{obj flags}
	{{\bf \htmlref{outputs}{systemdict:outputs}}}
	{string}
	{Create formatted string from object.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:name}Name operators} \\
\hline \hline
\optableent
	{name}
	{{\bf \htmlref{length}{systemdict:length}}}
	{count}
	{Get name length.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:array}Array operators} \\
\hline \hline
\optableent
	{--}
	{{\bf \htmlref{[}{systemdict:sym_lb}}}
	{mark}
	{Begin an array declaration.}
\hline
\optableent
	{mark objects}
	{{\bf \htmlref{]}{systemdict:sym_rb}}}
	{array}
	{Construct an array.}
\hline
\optableent
	{length}
	{{\bf \htmlref{array}{systemdict:array}}}
	{array}
	{Create an array.}
\hline
\optableent
	{array}
	{{\bf \htmlref{length}{systemdict:length}}}
	{count}
	{Get array length.}
\hline
\optableent
	{array index}
	{{\bf \htmlref{get}{systemdict:get}}}
	{obj}
	{Get array element.}
\hline
\optableent
	{array index obj}
	{{\bf \htmlref{put}{systemdict:put}}}
	{--}
	{Set array element.}
\hline
\optableent
	{array index length}
	{{\bf \htmlref{getinterval}{systemdict:getinterval}}}
	{subarray}
	{Get an array interval.}
\hline
\optableent
	{array index subarray}
	{{\bf \htmlref{putinterval}{systemdict:putinterval}}}
	{--}
	{Copy subarray into array.}
\hline
\optableent
	{[a] [b]}
	{{\bf \htmlref{cat}{systemdict:cat}}}
	{[a b]}
	{Catenate two arrays.}
\hline
\optableent
	{arrays count}
	{{\bf \htmlref{ncat}{systemdict:ncat}}}
	{array}
	{Catenate arrays.}
\hline
\optableent
	{srcarray dstarray}
	{{\bf \htmlref{copy}{systemdict:copy}}}
	{dstsubarray}
	{Copy array.}
\hline
\optableent
	{--}
	{{\bf \htmlref{argv}{systemdict:argv}}}
	{args}
	{Get program arguments.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:dict}Dictionary and dictionary
stack operators} \\
\hline \hline
\optableent
	{--}
	{{\bf \htmlref{{\lt}}{systemdict:sym_lt}}}
	{mark}
	{Begin a dictionary declaration.}
\hline
\optableent
	{mark kvpairs}
	{{\bf \htmlref{{\gt}}{systemdict:sym_gt}}}
	{dict}
	{Construct a dictionary.}
\hline
\optableent
	{--}
	{{\bf \htmlref{dict}{systemdict:dict}}}
	{dict}
	{Create a dictionary.}
\hline
\optableent
	{dict}
	{{\bf \htmlref{begin}{systemdict:begin}}}
	{--}
	{Pust dict onto dstack.}
\hline
\optableent
	{--}
	{{\bf \htmlref{end}{systemdict:end}}}
	{--}
	{Pop a dictionary off dstack.}
\hline
\optableent
	{key val}
	{{\bf \htmlref{def}{systemdict:def}}}
	{--}
	{Define key/value pair.}
\hline
\optableent
	{dict key}
	{{\bf \htmlref{undef}{systemdict:undef}}}
	{--}
	{Undefine key in dict.}
\hline
\optableent
	{key}
	{{\bf \htmlref{load}{systemdict:load}}}
	{val}
	{Look up a key's value.}
\hline
\optableent
	{dict key}
	{{\bf \htmlref{known}{systemdict:known}}}
	{boolean}
	{Check for key in dict.}
\hline
\optableent
	{key}
	{{\bf \htmlref{where}{systemdict:where}}}
	{false}
	{Unsuccessfully get topmost dstack dictionary that defines key.}
\hline
\optableent
	{key}
	{{\bf \htmlref{where}{systemdict:where}}}
	{dict true}
	{Successfully get topmost dstack dictionary that defines key.}
\hline
\optableent
	{dict}
	{{\bf \htmlref{length}{systemdict:length}}}
	{count}
	{Get number of dictionary key/value pairs.}
\hline
\optableent
	{dict key}
	{{\bf \htmlref{get}{systemdict:get}}}
	{value}
	{Get dict value associate with key.}
\hline
\optableent
	{dict key value}
	{{\bf \htmlref{put}{systemdict:put}}}
	{--}
	{Set dict key/value pair.}
\hline
\optableent
	{srcdict dstdict}
	{{\bf \htmlref{copy}{systemdict:copy}}}
	{dstdict}
	{Copy dictionary contents.}
\hline
\optableent
	{--}
	{{\bf \htmlref{currentdict}{systemdict:currentdict}}}
	{dict}
	{Get topmost dstack dictionary.}
\hline
\optableent
	{--}
	{{\bf \htmlref{dstack}{systemdict:dstack}}}
	{stack}
	{Get dstack snapshot.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{threaddstack}{systemdict:threaddstack}}}
	{stack}
	{Get a reference to thread's dstack.}
\hline
\optableent
	{--}
	{{\bf \htmlref{countdstack}{systemdict:countdstack}}}
	{count}
	{Get number of stacks on dstack.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gcdict}{systemdict:gcdict}}}
	{dict}
	{Get gcdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{userdict}{systemdict:userdict}}}
	{dict}
	{Get userdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{globaldict}{systemdict:globaldict}}}
	{dict}
	{Get globaldict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{systemdict}{systemdict:systemdict}}}
	{dict}
	{Get systemdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{onyxdict}{systemdict:onyxdict}}}
	{dict}
	{Get onyxdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{sprintsdict}{systemdict:sprintsdict}}}
	{dict}
	{Get sprintsdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{outputsdict}{systemdict:outputsdict}}}
	{dict}
	{Get outputsdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{envdict}{systemdict:envdict}}}
	{dict}
	{Get envdict.}
\hline
\optableent
	{--}
	{{\bf \htmlref{threadsdict}{systemdict:threadsdict}}}
	{dict}
	{Get threadsdict.}
\hline
\optableent
	{key val}
	{{\bf \htmlref{setenv}{systemdict:setenv}}}
	{--}
	{Set environment variable.}
\hline
\optableent
	{key}
	{{\bf \htmlref{unsetenv}{systemdict:unsetenv}}}
	{--}
	{Unset environment variable.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:class}Class, instance, and handle
operators} \\
\hline \hline
\optableent
	{--}
	{{\bf \htmlref{class}{systemdict:class}}}
	{class}
	{Create class.}
\hline
\optableent
	{class name}
	{{\bf \htmlref{implementor}{systemdict:implementor}}}
	{class/null}
	{Get class that implements name.}
\hline
\optableent
	{class name}
	{{\bf \htmlref{implements}{systemdict:implements}}}
	{boolean}
	{Does class implement name?}
\hline
\optableent
	{class name}
	{{\bf \htmlref{method}{systemdict:method}}}
	{method}
	{Get class method by name.}
\hline
\optableent
	{class}
	{{\bf \htmlref{classname}{systemdict:classname}}}
	{class/null}
	{Get class's name.}
\hline
\optableent
	{class name/null}
	{{\bf \htmlref{setclassname}{systemdict:setclassname}}}
	{--}
	{Set class's name.}
\hline
\optableent
	{class}
	{{\bf \htmlref{super}{systemdict:super}}}
	{super/null}
	{Get class's superclass.}
\hline
\optableent
	{class super/null}
	{{\bf \htmlref{setsuper}{systemdict:setsuper}}}
	{--}
	{Set class's superclass.}
\hline
\optableent
	{class}
	{{\bf \htmlref{methods}{systemdict:methods}}}
	{dict/null}
	{Get methods dict for class.}
\hline
\optableent
	{class dict/null}
	{{\bf \htmlref{setmethods}{systemdict:setmethods}}}
	{--}
	{Set methods dict for class.}
\hline
\optableent
	{class/instance}
	{{\bf \htmlref{data}{systemdict:data}}}
	{dict/null}
	{Get data for class/instance.}
\hline
\optableent
	{class/instance dict/null}
	{{\bf \htmlref{setdata}{systemdict:setdata}}}
	{--}
	{Set data for class/instance.}
\hline
\optableent
	{--}
	{{\bf \htmlref{instance}{systemdict:instance}}}
	{instance}
	{Create an instance.}
\hline
\optableent
	{instance}
	{{\bf \htmlref{isa}{systemdict:isa}}}
	{class/null}
	{Get class for instance.}
\hline
\optableent
	{instance class/null}
	{{\bf \htmlref{setisa}{systemdict:setisa}}}
	{--}
	{Set class for instance.}
\hline
\optableent
	{instance class}
	{{\bf \htmlref{kind}{systemdict:kind}}}
	{boolean}
	{Is class in instance's inheritance hierarchy?}
\hline
\optableent
	{name super data methods}
	{{\bf \htmlref{cdef}{systemdict:cdef}}}
	{--}
	{Create and define a class.}
\hline
\optableent
	{--}
	{{\bf \htmlref{this}{systemdict:this}}}
	{method/instance}
	{Get topmost object on cstack.}
\hline
\optableent
	{--}
	{{\bf \htmlref{cstack}{systemdict:cstack}}}
	{stack}
	{Get cstack snapshot.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{threadcstack}{systemdict:threadcstack}}}
	{stack}
	{Get a reference to thread's cstack.}
\hline
\optableent
	{handle}
	{{\bf \htmlref{handletag}{systemdict:handletag}}}
	{tag}
	{Get handle tag.}
\hline
\optableent
	{--}
	{{\bf \htmlref{vclass}{systemdict:vclass}}}
	{class}
	{Get vclass.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:file}File and filesystem
operators} \\
\hline \hline
\optableent
	{filename flags}
	{{\bf \htmlref{open}{systemdict:open}}}
	{file}
	{Open a file.}
\optableent
	{filename flags mode}
	{{\bf \htmlref{open}{systemdict:open}}}
	{file}
	{Open a file, creation mode specified.}
\hline
\optableent
	{--}
	{{\bf \htmlref{pipe}{systemdict:pipe}}}
	{rfile wfile}
	{Create a pipe.}
\hline
\optableent
	{file}
	{{\bf \htmlref{close}{systemdict:close}}}
	{--}
	{Close file.}
\hline
\optableent
	{file}
	{{\bf \htmlref{read}{systemdict:read}}}
	{integer boolean}
	{Read from file.}
\optableent
	{file string}
	{{\bf \htmlref{read}{systemdict:read}}}
	{substring boolean}
	{Read from file.}
\optableent
	{file}
	{{\bf \htmlref{readline}{systemdict:readline}}}
	{string boolean}
	{Read a line from file.}
\hline
\optableent
	{{\lt}file dict \dots{\gt} timeout}
	{{\bf \htmlref{poll}{systemdict:poll}}}
	{{\lb}file \dots{\rb}}
	{Wait for file(s) to change status.}
\hline
\optableent
	{file}
	{{\bf \htmlref{bytesavailable}{systemdict:bytesavailable}}}
	{count}
	{Get number of buffered readable bytes.}
\hline
\optableent
	{file}
	{{\bf \htmlref{iobuf}{systemdict:iobuf}}}
	{count}
	{Get size of I/O buffer.}
\hline
\optableent
	{file count}
	{{\bf \htmlref{setiobuf}{systemdict:setiobuf}}}
	{--}
	{Set size of I/O buffer.}
\hline
\optableent
	{file}
	{{\bf \htmlref{nonblocking}{systemdict:nonblocking}}}
	{boolean}
	{Get non-blocking mode.}
\hline
\optableent
	{file boolean}
	{{\bf \htmlref{setnonblocking}{systemdict:setnonblocking}}}
	{--}
	{Set non-blocking mode.}
\hline
\optableent
	{file integer/string}
	{{\bf \htmlref{write}{systemdict:write}}}
	{false}
	{Write to file.}
\optableent
	{file integer/string}
	{{\bf \htmlref{write}{systemdict:write}}}
	{integer/substring true}
	{Write to file.}
\hline
\optableent
	{string}
	{{\bf \htmlref{print}{systemdict:print}}}
	{--}
	{Print string to stdout.}
\hline
\optableent
	{obj depth}
	{{\bf \htmlref{sprint}{systemdict:sprint}}}
	{--}
	{Syntactically print object to stdout.}
\hline
\optableent
	{obj flags}
	{{\bf \htmlref{output}{systemdict:output}}}
	{--}
	{Formatted print to stdout.}
\hline
\optableent
	{--}
	{{\bf \htmlref{pstack}{systemdict:pstack}}}
	{--}
	{Syntactically print ostack elements.}
\hline
\optableent
	{file}
	{{\bf \htmlref{flushfile}{systemdict:flushfile}}}
	{--}
	{Flush file buffer.}
\hline
\optableent
	{--}
	{{\bf \htmlref{flush}{systemdict:flush}}}
	{--}
	{Flush stdout buffer.}
\hline
\optableent
	{file length}
	{{\bf \htmlref{truncate}{systemdict:truncate}}}
	{--}
	{Truncate file.}
\hline
\optableent
	{file offset}
	{{\bf \htmlref{seek}{systemdict:seek}}}
	{--}
	{Move file position pointer.}
\hline
\optableent
	{file}
	{{\bf \htmlref{tell}{systemdict:tell}}}
	{offset}
	{Get file position pointer offset.}
\hline
\optableent
	{path}
	{{\bf \htmlref{mkdir}{systemdict:mkdir}}}
	{--}
	{Create a directory.}
\optableent
	{path mode}
	{{\bf \htmlref{mkdir}{systemdict:mkdir}}}
	{--}
	{Create a directory, mode specified.}
\hline
\optableent
	{path}
	{{\bf \htmlref{mkfifo}{systemdict:mkfifo}}}
	{--}
	{Create a named pipe.}
\optableent
	{path mode}
	{{\bf \htmlref{mkfifo}{systemdict:mkfifo}}}
	{--}
	{Create a named pipe, mode specified.}
\hline
\optableent
	{old new}
	{{\bf \htmlref{rename}{systemdict:rename}}}
	{--}
	{Rename a file or directory.}
\hline
\optableent
	{file/filename mode}
	{{\bf \htmlref{chmod}{systemdict:chmod}}}
	{--}
	{Change file permissions.}
\hline
\optableent
	{file/filename uid gid}
	{{\bf \htmlref{chown}{systemdict:chown}}}
	{--}
	{Change file owner and group.}
\hline
\optableent
	{filename linkname}
	{{\bf \htmlref{link}{systemdict:link}}}
	{--}
	{Create a hard link.}
\hline
\optableent
	{filename linkname}
	{{\bf \htmlref{symlink}{systemdict:symlink}}}
	{--}
	{Create a symbolic link.}
\hline
\optableent
	{filename}
	{{\bf \htmlref{unlink}{systemdict:unlink}}}
	{--}
	{Unlink a file.}
\hline
\optableent
	{path}
	{{\bf \htmlref{rmdir}{systemdict:rmdir}}}
	{--}
	{Remove an empty directory.}
\hline
\optableent
	{file/filename flag}
	{{\bf \htmlref{test}{systemdict:test}}}
	{boolean}
	{Test a file.}
\hline
\optableent
	{file/filename}
	{{\bf \htmlref{status}{systemdict:status}}}
	{dict}
	{Get file information.}
\hline
\optableent
	{linkname}
	{{\bf \htmlref{readlink}{systemdict:readlink}}}
	{string}
	{Get symbolic link data.}
\hline
\optableent
	{path proc}
	{{\bf \htmlref{dirforeach}{systemdict:dirforeach}}}
	{--}
	{Iterate on directory entries.}
\hline
\optableent
	{--}
	{{\bf \htmlref{pwd}{systemdict:pwd}}}
	{path}
	{Get present working directory.}
\hline
\optableent
	{path}
	{{\bf \htmlref{cd}{systemdict:cd}}}
	{--}
	{Change present working directory.}
\hline
\optableent
	{path}
	{{\bf \htmlref{chroot}{systemdict:chroot}}}
	{--}
	{Change root directory.}
\hline
\optableent
	{--}
	{{\bf \htmlref{stdin}{systemdict:stdin}}}
	{file}
	{Get thread's stdin.}
\hline
\optableent
	{--}
	{{\bf \htmlref{stdout}{systemdict:stdout}}}
	{file}
	{Get thread's stdout.}
\hline
\optableent
	{--}
	{{\bf \htmlref{stderr}{systemdict:stderr}}}
	{file}
	{Get thread's stderr.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gstdin}{systemdict:gstdin}}}
	{file}
	{Get global stdin.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gstdout}{systemdict:gstdout}}}
	{file}
	{Get global stdout.}
\hline
\optableent
	{--}
	{{\bf \htmlref{gstderr}{systemdict:gstderr}}}
	{file}
	{Get global stderr.}
\hline
\optableent
	{file}
	{{\bf \htmlref{setstdin}{systemdict:setstdin}}}
	{--}
	{Set thread's stdin.}
\hline
\optableent
	{file}
	{{\bf \htmlref{setstdout}{systemdict:setstdout}}}
	{--}
	{Set thread's stdout.}
\hline
\optableent
	{file}
	{{\bf \htmlref{setstderr}{systemdict:setstderr}}}
	{--}
	{Set thread's stderr.}
\hline
\optableent
	{file}
	{{\bf \htmlref{setgstdin}{systemdict:setgstdin}}}
	{--}
	{Set global stdin.}
\hline
\optableent
	{file}
	{{\bf \htmlref{setgstdout}{systemdict:setgstdout}}}
	{--}
	{Set global stdout.}
\hline
\optableent
	{file}
	{{\bf \htmlref{setgstderr}{systemdict:setgstderr}}}
	{--}
	{Set global stderr.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:socket}Socket and networking
operators} \\
\hline \hline
\optableent
	{family type proto}
	{{\bf \htmlref{socket}{systemdict:socket}}}
	{sock}
	{Create a socket.}
\optableent
	{family type}
	{{\bf \htmlref{socket}{systemdict:socket}}}
	{sock}
	{Create a socket.}
\hline
\optableent
	{sock addr port}
	{{\bf \htmlref{bindsocket}{systemdict:bindsocket}}}
	{--}
	{Bind socket to address/port.}
\optableent
	{sock addr}
	{{\bf \htmlref{bindsocket}{systemdict:bindsocket}}}
	{--}
	{Bind socket to address.}
\optableent
	{sock path}
	{{\bf \htmlref{bindsocket}{systemdict:bindsocket}}}
	{--}
	{Bind socket to port.}
\hline
\optableent
	{sock backlog}
	{{\bf \htmlref{listen}{systemdict:listen}}}
	{--}
	{Listen for socket connections.}
\optableent
	{sock}
	{{\bf \htmlref{listen}{systemdict:listen}}}
	{--}
	{Listen for socket connections.}
\hline
\optableent
	{sock}
	{{\bf \htmlref{accept}{systemdict:accept}}}
	{sock}
	{Accept a socket connection.}
\hline
\optableent
	{sock addr port}
	{{\bf \htmlref{connect}{systemdict:connect}}}
	{--}
	{Connect a socket.}
\optableent
	{sock path}
	{{\bf \htmlref{connect}{systemdict:connect}}}
	{--}
	{Connect a socket.}
\hline
\optableent
	{service}
	{{\bf \htmlref{serviceport}{systemdict:serviceport}}}
	{port}
	{Get port number for service name.}
\hline
\optableent
	{sock}
	{{\bf \htmlref{sockname}{systemdict:sockname}}}
	{dict}
	{Get socket information.}
\hline
\optableent
	{sock level optname}
	{{\bf \htmlref{sockopt}{systemdict:sockopt}}}
	{optval}
	{Get socket option.}
\optableent
	{sock optname}
	{{\bf \htmlref{sockopt}{systemdict:sockopt}}}
	{optval}
	{Get socket option.}
\hline
\optableent
	{sock level optname optval}
	{{\bf \htmlref{setsockopt}{systemdict:setsockopt}}}
	{--}
	{Set socket option.}
\optableent
	{sock optname optval}
	{{\bf \htmlref{setsockopt}{systemdict:setsockopt}}}
	{--}
	{Set socket option.}
\hline
\optableent
	{sock}
	{{\bf \htmlref{peername}{systemdict:peername}}}
	{dict}
	{Get peer socket information.}
\hline
\optableent
	{sock mesg flags}
	{{\bf \htmlref{send}{systemdict:send}}}
	{nsend}
	{Send a message.}
\optableent
	{sock mesg}
	{{\bf \htmlref{send}{systemdict:send}}}
	{count}
	{Send a message.}
\hline
\optableent
	{sock string flags}
	{{\bf \htmlref{recv}{systemdict:recv}}}
	{substring}
	{Receive a message.}
\optableent
	{sock string}
	{{\bf \htmlref{recv}{systemdict:recv}}}
	{substring}
	{Receive a message.}
\hline
\optableent
	{family type proto}
	{{\bf \htmlref{socketpair}{systemdict:socketpair}}}
	{sock sock}
	{Create a socket pair.}
\optableent
	{family type}
	{{\bf \htmlref{socketpair}{systemdict:socketpair}}}
	{sock sock}
	{Create a socket pair.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:logic}Logical and bitwise
operators} \\
\hline \hline
\optableent
	{a b}
	{{\bf \htmlref{lt}{systemdict:lt}}}
	{boolean}
	{a less than b? (integer/real, string)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{le}{systemdict:le}}}
	{boolean}
	{a less than or equal to b? (integer/real, string)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{eq}{systemdict:eq}}}
	{boolean}
	{a equal to b? (any type)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{ne}{systemdict:ne}}}
	{boolean}
	{a not equal to b? (any type)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{ge}{systemdict:ge}}}
	{boolean}
	{a greater than or equal to b? (integer/real, string)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{gt}{systemdict:gt}}}
	{boolean}
	{a greater than b? (integer/real, string)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{and}{systemdict:and}}}
	{r}
	{Logical/bitwise and. (boolean/integer) }
\hline
\optableent
	{a b}
	{{\bf \htmlref{or}{systemdict:or}}}
	{r}
	{Logical/bitwise or. (boolean/integer)}
\hline
\optableent
	{a b}
	{{\bf \htmlref{xor}{systemdict:xor}}}
	{r}
	{Logical/bitwise exclusive or. (boolean/integer)}
\hline
\optableent
	{a}
	{{\bf \htmlref{not}{systemdict:not}}}
	{r}
	{Logical/bitwise not. (boolean/integer)}
\hline
\optableent
	{a shift}
	{{\bf \htmlref{shift}{systemdict:shift}}}
	{integer}
	{Bitwise shift.}
\hline
\optableent
	{--}
	{{\bf \htmlref{false}{systemdict:false}}}
	{false}
	{Return true.}
\hline
\optableent
	{--}
	{{\bf \htmlref{true}{systemdict:true}}}
	{true}
	{Return false.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:type_attr}Type, conversion, and
attribute operators} \\
\hline \hline
\optableent
	{obj}
	{{\bf \htmlref{type}{systemdict:type}}}
	{name}
	{Get object type.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{lcheck}{systemdict:lcheck}}}
	{boolean}
	{Literal?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{xcheck}{systemdict:xcheck}}}
	{boolean}
	{Executable?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{echeck}{systemdict:echeck}}}
	{boolean}
	{Evaluable?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{xecheck}{systemdict:xecheck}}}
	{boolean}
	{Executable or evaluable?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{ccheck}{systemdict:ccheck}}}
	{boolean}
	{Callable?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{icheck}{systemdict:icheck}}}
	{boolean}
	{Invokable?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{fcheck}{systemdict:fcheck}}}
	{boolean}
	{Fetchable?}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cvl}{systemdict:cvl}}}
	{obj}
	{Set literal attribute.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cve}{systemdict:cve}}}
	{obj}
	{Set evaluable attribute.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cvx}{systemdict:cvx}}}
	{obj}
	{Set executable attribute.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cvc}{systemdict:cvc}}}
	{obj}
	{Set callable attribute.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cvi}{systemdict:cvi}}}
	{obj}
	{Set invokable attribute.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cvf}{systemdict:cvf}}}
	{obj}
	{Set fetchable attribute.}
\hline
\optableent
	{string}
	{{\bf \htmlref{cvn}{systemdict:cvn}}}
	{name}
	{Convert string to name.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{cvs}{systemdict:cvs}}}
	{string}
	{Convert object to string.}
\hline
\optableent
	{integer radix}
	{{\bf \htmlref{cvrs}{systemdict:cvrs}}}
	{string}
	{Convert integer to radix string.}
\hline
\optableent
	{real precision}
	{{\bf \htmlref{cvds}{systemdict:cvds}}}
	{string}
	{Convert real to decimal string.}
\hline
\optableent
	{real precision}
	{{\bf \htmlref{cves}{systemdict:cves}}}
	{string}
	{Convert real to exponential string.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:thread}Threading and
synchronization operators} \\
\hline \hline
\optableent
	{stack entry}
	{{\bf \htmlref{thread}{systemdict:thread}}}
	{thread}
	{Create and run a thread.}
\hline
\optableent
	{--}
	{{\bf \htmlref{self}{systemdict:self}}}
	{thread}
	{Get a thread object for the running thread.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{join}{systemdict:join}}}
	{--}
	{Wait for thread to exit.}
\hline
\optableent
	{thread}
	{{\bf \htmlref{detach}{systemdict:detach}}}
	{--}
	{Detach thread.}
\hline
\optableent
	{--}
	{{\bf \htmlref{yield}{systemdict:yield}}}
	{--}
	{Voluntarily yield the processor.}
\hline
\optableent
	{--}
	{{\bf \htmlref{mutex}{systemdict:mutex}}}
	{mutex}
	{Create a mutex.}
\hline
\optableent
	{mutex proc}
	{{\bf \htmlref{monitor}{systemdict:mutex}}}
	{--}
	{Evaluate an object under the protection of a mutex.}
\hline
\optableent
	{mutex}
	{{\bf \htmlref{lock}{systemdict:lock}}}
	{--}
	{Acquire mutex.}
\hline
\optableent
	{mutex}
	{{\bf \htmlref{trylock}{systemdict:trylock}}}
	{boolean}
	{Try to acquire mutex.}
\hline
\optableent
	{mutex}
	{{\bf \htmlref{unlock}{systemdict:unlock}}}
	{--}
	{Release mutex.}
\hline
\optableent
	{--}
	{{\bf \htmlref{condition}{systemdict:condition}}}
	{condition}
	{Create a condition variable.}
\hline
\optableent
	{condition mutex}
	{{\bf \htmlref{wait}{systemdict:wait}}}
	{--}
	{Wait on condition.}
\hline
\optableent
	{condition mutex timeout}
	{{\bf \htmlref{timedwait}{systemdict:timedwait}}}
	{boolean}
	{Wait on condition with timeout.}
\hline
\optableent
	{condition}
	{{\bf \htmlref{signal}{systemdict:signal}}}
	{--}
	{Signal a condition waiter.}
\hline
\optableent
	{condition}
	{{\bf \htmlref{broadcast}{systemdict:broadcast}}}
	{--}
	{Signal all condition waiters.}
\hline
\optableent
	{--}
	{{\bf \htmlref{currentlocking}{systemdict:currentlocking}}}
	{boolean}
	{Get implicit locking mode.}
\hline
\optableent
	{boolean}
	{{\bf \htmlref{setlocking}{systemdict:setlocking}}}
	{--}
	{Set implicit locking mode.}
\hline
\optableent
	{obj}
	{{\bf \htmlref{ilocked}{systemdict:ilocked}}}
	{boolean}
	{Implicitly locked?}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:regex}Regular expression
operators} \\
\hline \hline
\optableent
	{string flags}
	{{\bf \htmlref{regex}{systemdict:regex}}}
	{regex}
	{Create a regex object.}
\optableent
	{string}
	{{\bf \htmlref{regex}{systemdict:regex}}}
	{regex}
	{Create a regex object.}
\hline
\optableent
	{input pattern flags}
	{{\bf \htmlref{match}{systemdict:match}}}
	{boolean}
	{Find pattern matches in input string.}
\optableent
	{input pattern}
	{{\bf \htmlref{match}{systemdict:match}}}
	{boolean}
	{Find pattern matches in input string.}
\optableent
	{input regex}
	{{\bf \htmlref{match}{systemdict:match}}}
	{boolean}
	{Find regex matches in input string.}
\hline
\optableent
	{input pattern flags limit}
	{{\bf \htmlref{split}{systemdict:split}}}
	{array}
	{Split input into an array of substrings.}
\optableent
	{input pattern flags}
	{{\bf \htmlref{split}{systemdict:split}}}
	{array}
	{Split input into an array of substrings.}
\optableent
	{input pattern limit}
	{{\bf \htmlref{split}{systemdict:split}}}
	{array}
	{Split input into an array of substrings.}
\optableent
	{input pattern}
	{{\bf \htmlref{split}{systemdict:split}}}
	{array}
	{Split input into an array of substrings.}
\optableent
	{input regex limit}
	{{\bf \htmlref{split}{systemdict:split}}}
	{array}
	{Split input into an array of substrings.}
\optableent
	{input regex}
	{{\bf \htmlref{split}{systemdict:split}}}
	{array}
	{Split input into an array of substrings.}
\hline
\optableent
	{integer}
	{{\bf \htmlref{submatch}{systemdict:submatch}}}
	{substring}
	{Get capturing subpattern match.}
\hline
\optableent
	{input submatch}
	{{\bf \htmlref{offset}{systemdict:offset}}}
	{offset}
	{Get submatch offset from beginning of input.}
\hline
\optableent
	{pattern template flags}
	{{\bf \htmlref{regsub}{systemdict:regsub}}}
	{regsub}
	{Create a regsub object.}
\optableent
	{pattern template}
	{{\bf \htmlref{regsub}{systemdict:regsub}}}
	{regsub}
	{Create a regsub object.}
\hline
\optableent
	{input pattern template flags}
	{{\bf \htmlref{subst}{systemdict:subst}}}
	{output count}
	{Substitute template for pattern matches.}
\optableent
	{input pattern template}
	{{\bf \htmlref{subst}{systemdict:subst}}}
	{output count}
	{Substitute template for pattern matches.}
\optableent
	{input regsub}
	{{\bf \htmlref{subst}{systemdict:subst}}}
	{output count}
	{Substitute.}
\hline \hline
\multicolumn{2}{|l|}{\label{subsec:systemdict:misc}Miscellaneous operators} \\
\hline \hline
\optableent
	{--}
	{{\bf \htmlref{product}{systemdict:product}}}
	{string}
	{Get the product string.}
\hline
\optableent
	{--}
	{{\bf \htmlref{version}{systemdict:version}}}
	{string}
	{Get the version string.}
\hline
\optableent
	{proc}
	{{\bf \htmlref{bind}{systemdict:bind}}}
	{proc}
	{Bind names to operators.}
\hline
\optableent
	{--}
	{{\bf \htmlref{null}{systemdict:null}}}
	{null}
	{Create a null object.}
\end{longtable}

%% \label{systemdict:OPNAME}
%% \index{OPNAME@\onyxop{}{OPNAME}{}}
%% \item[{\onyxop{OPARGS}{OPNAME}{OPOUTS}}: ]
%% 	\begin{description}\item[]
%% 	\item[Input(s): ]
%% 		\begin{description}\item[]
%% 		\item[: ]
%% 		\end{description}
%% 	\item[Output(s): ]
%% 		\begin{description}\item[]
%% 		\item[: ]
%% 		\end{description}
%% 	\item[Error(s): ]
%% 		\begin{description}\item[]
%% 		\item[\htmlref{stackunderflow}{stackunderflow}.]
%% 		\item[\htmlref{typecheck}{typecheck}.]
%% 		\end{description}
%% 	\item[Description: ]
%% 	\item[Example(s): ]\begin{verbatim}

%% 		\end{verbatim}
%% 	\end{description}

\begin{description}
\label{systemdict:sym_lp}
\index{(@\onyxop{}{(}{}}
\item[{\onyxop{--}{(}{fino}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[fino: ]
			A fino object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Push a fino object onto ostack to denote the bottom of a stack
		that has not yet been constructed.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (
onyx:1> pstack
-fino-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sym_rp}
\index{)@\onyxop{}{)}{}}
\item[{\onyxop{fino objects}{)}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[fino: ]
			A fino object, usually created by the \onyxop{}{)}{}
			operator.
		\item[objects: ]
			0 or more objects.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{unmatchedfino}{unmatchedfino}.]
		\end{description}
	\item[Description: ]
		Create a stack object and move all objects from ostack down to
		the first fino object to the new stack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> ()
onyx:1> 1 sprint
()
onyx:0> (1 2
onyx:3> pstack
2
1
-fino-
onyx:3> )
onyx:1> 1 sprint
(1 2)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sym_lt}
\index{<@\onyxop{}{{\lt}}{}}
\item[{\onyxop{--}{{\lt}}{mark}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[mark: ]
			A mark object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Begin a dictionary declaration.  See the
		\htmlref{\onyxop{}{>}{}}{systemdict:sym_gt} operator
		documentation for more details on dictionary construction.
	\item[Example(s): ]\begin{verbatim}

onyx:0> < 1 sprint
-mark-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sym_gt}
\index{>@\onyxop{}{{\gt}}{}}
\item[{\onyxop{mark kvpairs}{{\gt}}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[mark: ]
			A mark object.
		\item[kvpairs: ]
			Zero or more pairs of non-mark objects, where the first
			is a key and the second is an associated value.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary that contains \oparg{kvpairs}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{unmatchedmark}{unmatchedmark}.]
		\end{description}
	\item[Description: ]
		Construct a dictionary that contains \oparg{kvpairs}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <
onyx:1> $foo `foo'
onyx:3> $bar `bar'
onyx:5> $biz `biz'
onyx:7> $pop ~pop
onyx:9> >
onyx:1> pstack
<$pop --pop-- $biz `biz' $bar `bar' $foo `foo'>
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sym_lb}
\index{[@\onyxop{}{{\lb}}{}}
\item[{\onyxop{--}{{\lb}}{mark}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[mark: ]
			A mark object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Begin an array declaration.  See the
		\htmlref{\onyxop{}{]}{}}{systemdict:sym_rb} operator
		documentation for more details on array construction.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [ 1 sprint
-mark-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sym_rb}
\index{]@\onyxop{}{{\rb}}{}}
\item[{\onyxop{mark objects}{{\rb}}{array}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[mark: ]
			A mark object.
		\item[objects: ]
			Zero or more non-mark objects.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array that contains \oparg{objects}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{unmatchedmark}{unmatchedmark}.]
		\end{description}
	\item[Description: ]
		Construct an array that contains all \oparg{objects} on ostack
		down to the first \oparg{mark}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> mark 1 2 3 ] 1 sprint
[1 2 3]
		\end{verbatim}
	\end{description}
\label{systemdict:abs}
\index{abs@\onyxop{}{abs}{}}
\item[{\onyxop{a}{abs}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Absolute value of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the absolute value of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 5 abs 1 sprint
5
onyx:0> -5 abs 1 sprint
5
onyx:0> 3.14 abs 1 sprint
3.140000e+00
onyx:0> -3.14 abs 1 sprint
3.140000e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:accept}
\index{accept@\onyxop{}{accept}{}}
\item[{\onyxop{sock}{accept}{sock}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A listening socket.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket that is connected to a client.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Accept a connection and create a socket that is connected to a
		client.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup `localhost' 7777 bindsocket
onyx:1> dup listen
onyx:1> dup accept
onyx:2> dup peername 1 sprint
<$family $AF_INET $address 2130706433 $port 33742>
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:acos}
\index{acos@\onyxop{}{acos}{}}
\item[{\onyxop{a}{acos}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Arc cosine of \oparg{a} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the arc cosine of \oparg{a} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 acos 1 sprint
0.000000e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:acosh}
\index{acosh@\onyxop{}{acosh}{}}
\item[{\onyxop{a}{acosh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Hyperbolic arc cosine of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the hyperbolic arc cosine of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 10 acosh 1 sprint
2.993223e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:add}
\index{add@\onyxop{}{add}{}}
\item[{\onyxop{a b}{add}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\item[b: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The sum of \oparg{a} and \oparg{b}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the sum of \oparg{a} and \oparg{b}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 2 2 add 1 sprint
4
onyx:0> -1 3 add 1 sprint
2
onyx:0> 2.0 3.1 add 1 sprint
5.100000e+00
onyx:0> -1.5 +3e1 add 1 sprint
2.850000e+01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:adn}
\index{adn@\onyxop{}{adn}{}}
\item[{\onyxop{obj \commas}{adn}{\commas obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\commas: ]
			Zero or more objects.
		\item[obj: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Rotate stack down one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 3 adn pstack
1
3
2
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:and}
\index{and@\onyxop{}{and}{}}
\item[{\onyxop{a b}{and}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or boolean.
		\item[b: ]
			The same type as \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			If \oparg{a} and \oparg{b} are integers, their bitwise
			and, otherwise their logical and.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the bitwise and of two integers, or the logical and of
		two booleans.
	\item[Example(s): ]\begin{verbatim}

onyx:0> false true and 1 sprint
false
onyx:0> true true and 1 sprint
true
onyx:0> 5 3 and 1 sprint
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:argv}
\index{argv@\onyxop{}{argv}{}}
\item[{\onyxop{--}{argv}{args}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[args: ]
			An array of strings.  The first string in \oparg{args}
			is the path of this program, and any additional
			array elements are the arguments that were passed during
			invocation.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the argument vector that was used to invoke this program.
	\item[Example(s): ]\begin{verbatim}

onyx:0> argv 1 sprint
[`/usr/local/bin/onyx']
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:array}
\index{array@\onyxop{}{array}{}}
\item[{\onyxop{length}{array}{array}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[length: ]
			Non-negative number of array elements.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array of \oparg{length} elements.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create an array of \oparg{length} elements.  The elements are
		initialized to null objects.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 array 1 sprint
[null null null]
onyx:0> 0 array 1 sprint
[]
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:asin}
\index{asin@\onyxop{}{asin}{}}
\item[{\onyxop{a}{asin}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Arc sine of \oparg{a} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the arc sine of \oparg{a} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> -1 asin 1 sprint
-1.570796e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:asinh}
\index{asinh@\onyxop{}{asinh}{}}
\item[{\onyxop{a}{asinh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Hyperbolic arc sine of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the hyperbolic arc sine of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 10 asinh 1 sprint
2.998223e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:atan}
\index{atan@\onyxop{}{atan}{}}
\item[{\onyxop{x}{atan}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[x: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Arctangent of \oparg{x} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the arctangent of \oparg{x} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 atan 1 sprint
7.853982e-01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:atan2}
\index{atan2@\onyxop{}{atan2}{}}
\item[{\onyxop{y x}{atan2}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[y: ]
			An integer or real.
		\item[x: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Arctangent of $\frac{y}{x}$ in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the arctangent of $\frac{y}{x}$ in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 1 atan2 1 sprint
7.853982e-01
onyx:0> 0 1 atan2 1 sprint
0.000000e+00
onyx:0> -1.0 0 atan2 1 sprint
-1.570796e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:atanh}
\index{atanh@\onyxop{}{atanh}{}}
\item[{\onyxop{x}{atanh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[x: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Hyperbolic arctangent of \oparg{x}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\end{description}
	\item[Description: ]
		Return the hyperbolic arctangent of \oparg{x}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0.5 atanh 1 sprint
5.493061e-01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:aup}
\index{aup@\onyxop{}{aup}{}}
\item[{\onyxop{\commas obj}{aup}{obj \commas}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\commas: ]
			Zero or more objects.
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Rotate stack up one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 3 aup pstack
2
1
3
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:bdup}
\index{bdup@\onyxop{}{bdup}{}}
\item[{\onyxop{obj \commas}{bdup}{obj \commas dup}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\item[dup: ]
			A duplicate of \oparg{obj}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the bottom object on ostack and put it on
		top of ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 3
onyx:3> bdup pstack
1
3
2
1
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:begin}
\index{begin@\onyxop{}{begin}{}}
\item[{\onyxop{dict}{begin}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Push \oparg{dict} onto dstack, thereby adding its keys to the
		namespace.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <$foo `foo'> begin
onyx:0> foo 1 sprint
`foo'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:bind}
\index{bind@\onyxop{}{bind}{}}
\item[{\onyxop{proc}{bind}{proc}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[proc: ]
			A procedure (array).  \oparg{proc} will be bound even if
			it is literal, but contained literal arrays will not be
			recursively bound.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[proc: ]
			The same procedure as was passed in.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Recursively bind unbound procedures.  Executable names within a
		procedure are replaced with their values if defined in dstack,
		in any of the following cases:
		\begin{itemize}
		\item{The value is a literal object.}
		\item{The value is an executable or evaluable operator.}
		\item{The value is an executable or evaluable handle.}
		\item{The value is an executable or evaluable array.}
		\end{itemize}

		Binding has a large positive impact on performance, since name
		lookups are thereafter avoided.  However, binding is not done by
		default because there are situations where it is useful to leave
		procedures unbound:
		\begin{itemize}
		\item{Debugging is easier, since the names associated with
		objects are still available.}
		\item{Behavior is more dynamic.  It is possible to replace a
		definition on dstack and have it immediately take effect on
		unbound procedures.  Note however that care must be taken
		when relying on this, since binding is recursive, and a lack of
		complete understanding of what procedures reference each other
		can result in undesired bound procedures.  For this reason, it
		is generally best to make dynamic behavior explicit by using
		evaluable names.}
		\item{There are situations where a program needs to do some
		setup before binding a procedure, and providing manual control
		over when binding happens allows more sophisticated use of
		binding.}
		\end{itemize}
	\item[Example(s): ]\begin{verbatim}

onyx:0> {pop sprint {pop sprint}}
onyx:1> dup 2 sprint
{pop sprint {pop sprint}}
onyx:1> bind
onyx:1> dup 2 sprint
{--pop-- _{sprints --print-- `\n' --print-- --flush--}_ {--pop-- -array-}}
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:bindsocket}
\index{bindsocket@\onyxop{}{bindsocket}{}}
\item[{\onyxop{sock addr port}{bindsocket}{--}}: ]
\item[{\onyxop{sock addr}{bindsocket}{--}}: ]
\item[{\onyxop{sock path}{bindsocket}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[addr: ]
			An IPv4 address or DNS hostname.
		\item[port: ]
			An IPv4 port number.  If not specified, the OS chooses a
			port number.
		\item[path: ]
			A filesystem path for a Unix-domain socket.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Bind an address/port to an IPv4 socket, or a filesystem path to
		a Unix-domain socket.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup `localhost' 7777 bindsocket
onyx:1> dup sockname 1 sprint
<$family $AF_INET $address 2130706433 $port 7777>
onyx:1> close
onyx:0> $AF_LOCAL $SOCK_STREAM socket
onyx:1> dup `/tmp/socket' bindsocket
onyx:1> dup sockname 1 sprint
<$family $AF_LOCAL $path `/tmp/socket'>
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:bpop}
\index{bpop@\onyxop{}{bpop}{}}
\item[{\onyxop{obj \commas}{bpop}{\commas}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\commas: ]
			Zero or more objects.
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\commas: ]
			Zero or more objects.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Remove the bottom object from ostack and discard it.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2
onyx:2> bpop pstack
2
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:broadcast}
\index{broadcast@\onyxop{}{broadcast}{}}
\item[{\onyxop{condition}{broadcast}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[condition: ]
			A condition object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Signal all threads that are waiting on \oparg{condition}.  If
		there are no waiters, this operator has no effect.
	\item[Example(s): ]\begin{verbatim}

onyx:0> condition mutex dup lock ostack
onyx:3> {dup lock exch broadcast unlock}
onyx:4> thread 3 1 roll
onyx:3> dup 3 1 roll
onyx:4> wait unlock join
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:bytesavailable}
\index{bytesavailable@\onyxop{}{bytesavailable}{}}
\item[{\onyxop{file}{bytesavailable}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			Number of buffered readable bytes.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the number of buffered readable bytes that can be read
		without the possibility of blocking.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup `Hello\n' write
onyx:1> dup `Goodbye\n' write
onyx:1> dup 0 seek
onyx:1> dup readline 1 sprint 1 sprint
false
`Hello'
onyx:1> dup bytesavailable 1 sprint
8
onyx:1>
	\end{verbatim}
	\end{description}
\label{systemdict:cat}
\index{cat@\onyxop{}{cat}{}}
\item[{\onyxop{[a] [b]}{cat}{[a b]}}: ]
\item[{\onyxop{(a) (b)}{cat}{(a b)}}: ]
\item[{\onyxop{`a' `b'}{cat}{`ab'}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An array, stack, or string.
		\item[b: ]
			An array, stack, or string.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[ab: ]
			The catenation of \oparg{a} and \oparg{b}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Catenate two arrays, strings, or stacks.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`a'] [`b'] cat
onyx:1> 1 sprint
[`a' `b']
onyx:0> (`a') (`b') cat
onyx:1> 1 sprint
(`a' `b')
onyx:0> `a' `b' cat
onyx:1> 1 sprint
`ab'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ccheck}
\index{ccheck@\onyxop{}{ccheck}{}}
\item[{\onyxop{obj}{ccheck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the callable attribute, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for callable attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $name ccheck 1 sprint
false
onyx:0> $name cvc ccheck 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cd}
\index{cd@\onyxop{}{cd}{}}
\item[{\onyxop{path}{cd}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string that represents a filesystem path.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Change the present working directory to \oparg{path}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pwd 1 sprint
`/usr/local'
onyx:0> `bin' cd
onyx:0> pwd 1 sprint
`/usr/local/bin'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cdef}
\index{cdef@\onyxop{}{cdef}{}}
\item[{\onyxop{name super data methods}{cdef}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[name: ]
			An object (usually a name) to set the class's name
			to and associate the class with.
		\item[super: ]
			A superclass, or null.
		\item[data: ]
			A dictionary of data definitions, or null.
		\item[methods: ]
			A dictionary of method definitions, or null.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a new class with \oparg{name} as its name, \oparg{super}
		as its superclass, \oparg{data} as its data definitions, and
		\oparg{methods} as its method definitions.  Define \oparg{name}
		in \htmlref{\onyxop{}{currentdict}{}}{systemdict:currentdict} to
		be the class.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $fooclass vclass <$foodata `foo'> <$foomethod {`hi' 1 sprint}> cdef
onyx:0> fooclass 1 sprint
-class-
onyx:0> fooclass:foomethod
`hi'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ceiling}
\index{ceiling@\onyxop{}{ceiling}{}}
\item[{\onyxop{a}{ceiling}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Integer ceiling of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the integer ceiling of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> -1.51 ceiling 1 sprint
-1
onyx:0> -1.49 ceiling 1 sprint
-1
onyx:0> 0 ceiling 1 sprint
0
onyx:0> 1.49 ceiling 1 sprint
2
onyx:0> 1.51 ceiling 1 sprint
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:chmod}
\index{chmod@\onyxop{}{chmod}{}}
\item[{\onyxop{file/filename mode}{chmod}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[filename: ]
			A string that represents a filename.
		\item[mode: ]
			An integer that represents a Unix file mode.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/tdir' 8@755 mkdir
onyx:0> `/tmp/tdir' status $mode get 1 sprint
16877
onyx:0> `/tmp/tdir' `r' open
onyx:1> dup 8@555 chmod
onyx:1> `/tmp/tdir' status $mode get 1 sprint
16749
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:chown}
\index{chown@\onyxop{}{chown}{}}
\item[{\onyxop{file/filename uid gid}{chown}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[filename: ]
			A string that represents a filename.
		\item[uid: ]
			An integer that represents a user ID.
		\item[gid: ]
			An integer that represents a group ID.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Change the owner and group of a file.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/tdir' 8@755 mkdir
onyx:0> `/tmp/tdir' status
onyx:1> dup $uid get 1 sprint
1001
onyx:1> $gid get 1 sprint
0
onyx:0> `/tmp/tdir' 1001 1001 chown
onyx:0> `/tmp/tdir' status
onyx:1> dup $uid get 1 sprint
1001
onyx:1> $gid get 1 sprint
1001
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:chroot}
\index{chroot@\onyxop{}{chroot}{}}
\item[{\onyxop{path}{chroot}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string that represents a filesystem path.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Change the root directory to \oparg{path}.  This operator
		requires super-user priviledges.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pwd 1 sprint
`/home/jasone/cw/devroot'
onyx:0> `/home/jasone' chroot
onyx:0> pwd 1 sprint
`/cw/devroot'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:class}
\index{class@\onyxop{}{class}{}}
\item[{\onyxop{--}{class}{class}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create a class object.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class 1 sprint
-class-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:classname}
\index{classname@\onyxop{}{classname}{}}
\item[{\onyxop{class}{classname}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[name/null: ]
			A name or null object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get \oparg{class}'s name.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class classname 1 sprint
null
onyx:0> vclass classname 1 sprint
$vclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:clear}
\index{clear@\onyxop{}{clear}{}}
\item[{\onyxop{objects}{clear}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[objects: ]
			All objects on ostack.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ] None.
	\item[Description: ]
		Pop all objects off of ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 3 pstack
3
2
1
onyx:3> clear pstack
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cleartomark}
\index{cleartomark@\onyxop{}{cleartomark}{}}
\item[{\onyxop{mark \dots}{cleartomark}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			Zero or more objects.
		\item[mark: ]
			A mark object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{unmatchedmark}{unmatchedmark}.]
		\end{description}
	\item[Description: ]
		Remove objects from ostack down to and including the topmost
		mark.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 mark 1 0 pstack
0
1
-mark-
3
onyx:4> cleartomark pstack
3
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:close}
\index{close@\onyxop{}{close}{}}
\item[{\onyxop{file}{close}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Close a file.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open
onyx:1> close
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:condition}
\index{condition@\onyxop{}{condition}{}}
\item[{\onyxop{--}{condition}{condition}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[condition: ]
			A condition object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create a condition object.
	\item[Example(s): ]\begin{verbatim}

onyx:0> condition 1 sprint
-condition-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:connect}
\index{connect@\onyxop{}{connect}{}}
\item[{\onyxop{sock addr port}{connect}{--}}: ]
\item[{\onyxop{sock path}{connect}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[addr: ]
			An IPv4 address or DNS hostname.
		\item[port: ]
			An IPv4 port number.  If not specified, the OS chooses a
			port number.
		\item[path: ]
			A filesystem path for a Unix-domain socket.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Connect \oparg{sock}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup `localhost' 7777 connect
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:continue}
\index{continue@\onyxop{}{continue}{}}
\item[{\onyxop{--}{continue}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ] None.
	\item[Description: ]
		Terminate the current iteration of the innermost enclosing
		context, and start at the beginning of the next iteration.
		This operator can be called within the looping context of
		\htmlref{\onyxop{}{for}{}}{systemdict:for},
		\htmlref{\onyxop{}{repeat}{}}{systemdict:repeat},
		\htmlref{\onyxop{}{while}{}}{systemdict:while},
		\htmlref{\onyxop{}{until}{}}{systemdict:until},
		\htmlref{\onyxop{}{loop}{}}{systemdict:loop},
		\htmlref{\onyxop{}{foreach}{}}{systemdict:foreach}, and
		\htmlref{\onyxop{}{dirforeach}{}}{systemdict:dirforeach}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 1 5 {1 sprint continue bang} for
1
2
3
4
5
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:copy}
\index{copy@\onyxop{}{copy}{}}
\item[{\onyxop{srcarray dstarray}{copy}{dstsubarray}}: ]
\item[{\onyxop{srcdict dstdict}{copy}{dstdict}}: ]
\item[{\onyxop{srcstack dststack}{copy}{dststack}}: ]
\item[{\onyxop{srcstring dststring}{copy}{dstsubstring}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[srcarray: ]
			An array object.
		\item[srcdict: ]
			A dict object.
		\item[srcstack: ]
			A stack object.
		\item[srcstring: ]
			A string object.
		\item[dstarray: ]
			An array object, at least as long as \oparg{srcarray}.
		\item[dstdict: ]
			A dict object.
		\item[dststack: ]
			A stack object.
		\item[dststring: ]
			A string object, at least as long as \oparg{srcstring}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dstsubarray: ]
			A subarray of \oparg{dstarray}, with the same contents
			as \oparg{srcarray}.
		\item[dstdict: ]
			The same object as the input \oparg{dstdict}, but with
			the contents of \oparg{srcdict} inserted.
		\item[dststack: ]
			The same object as the input \oparg{dststack}, but with
			the contents of \oparg{srcstack} pushed.
		\item[dstsubstring: ]
			A substring of \oparg{dststring}, with the same contents
			as \oparg{srcstring}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Copy from one object to another.  Array and string copying are
		destructive; dictionary and stack copying are not.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`a'] [`b' `c'] copy 1 sprint
[`a']
onyx:0> <$foo `foo'> <$bar `bar'> copy 1 sprint
<$bar `bar' $foo `foo'>
onyx:1> (1 2) (3 4) copy 1 sprint
(3 4 1 2)
onyx:1> `a' `bc' copy 1 sprint
`a'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:cos}
\index{cos@\onyxop{}{cos}{}}
\item[{\onyxop{a}{cos}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Cosine of \oparg{a} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the cosine of \oparg{a} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 cos 1 sprint
1.000000e+00
onyx:0> 3.14 cos 1 sprint
-9.999987e-01
onyx:0> 3.1415927 cos 1 sprint
-1.000000e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cosh}
\index{cosh@\onyxop{}{cosh}{}}
\item[{\onyxop{a}{cosh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Hyperbolic cosine of \oparg{a} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the hyperbolic cosine of \oparg{a} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 cosh 1 sprint
1.006766e+01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:count}
\index{count@\onyxop{}{count}{}}
\item[{\onyxop{--}{count}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			The number of objects on ostack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the number of objects on ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 2 1 0 count pstack
3
0
1
2
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:countdstack}
\index{countdstack@\onyxop{}{countdstack}{}}
\item[{\onyxop{--}{countdstack}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			Number of dictionaries on dstack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the number of dictionaries on dstack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> countdstack 1 sprint
4
onyx:0> dict begin
onyx:0> countdstack 1 sprint
5
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:countestack}
\index{countestack@\onyxop{}{countestack}{}}
\item[{\onyxop{--}{countestack}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			The number of objects currently on the execution stack
			(recursion depth).
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the current number of objects on the execution stack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> countestack 1 sprint
3
onyx:0> estack 1 sprint
(--start-- -file- --estack--)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:counttomark}
\index{counttomark@\onyxop{}{counttomark}{}}
\item[{\onyxop{mark \dots}{counttomark}{mark \dots count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			Zero or more objects.
		\item[mark: ]
			A mark object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			\oparg{count} objects.
		\item[mark: ]
			The same mark that was passed in.
		\item[count: ]
			The depth of \oparg{mark} on ostack.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{unmatchedmark}{unmatchedmark}.]
		\end{description}
	\item[Description: ]
		Get the depth of the topmost mark on ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 mark 2 1 0 counttomark 1 sprint
3
onyx:5>
		\end{verbatim}
	\end{description}
\label{systemdict:cstack}
\index{cstack@\onyxop{}{cstack}{}}
\item[{\onyxop{--}{cstack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A snapshot of cstack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a snapshot of cstack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> cstack 1 sprint
()
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:currentdict}
\index{currentdict@\onyxop{}{currentdict}{}}
\item[{\onyxop{--}{currentdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			Topmost stack on dstack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the topmost dictionary on dstack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <$foo `foo'> begin
onyx:0> currentdict 1 sprint
<$foo `foo'>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:currentlocking}
\index{currentlocking@\onyxop{}{currentlocking}{}}
\item[{\onyxop{--}{currentlocking}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, new objects are created with implicit locking
			disabled.  Otherwise, new objects are created with
			implicit locking enabled.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the current implicit locking mode.  See
		Section~\ref{sec:onyx_implicit_synchronization} for implicit
		synchronization details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> currentlocking 1 sprint
false
onyx:0> true setlocking
onyx:0> currentlocking 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvc}
\index{cvc@\onyxop{}{cvc}{}}
\item[{\onyxop{obj}{cvc}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in, but with the
			callable attribute set.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Set the callable attribute for \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo cvc 1 sprint
:foo
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvds}
\index{cvds@\onyxop{}{cvds}{}}
\item[{\onyxop{real precision}{cvds}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[real: ]
			A real.
		\item[precision: ]
			Number of digits after the decimal point to show.  If
			negative, do not show trailing zeros.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string representation of \oparg{real} in decimal form
			with \oparg{precision} digits of decimal precision.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Convert \oparg{real} to a string representation in decimal
		notation, with \oparg{precision} digits of decimal precision.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 42.3 0 cvds 1 sprint
`42'
onyx:0> 42.3 1 cvds 1 sprint
`42.3'
onyx:0> -42.3 4 cvds 1 sprint
`-42.3000'
onyx:0> -43.3 -4 cvds 1 sprint
`-42.3'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cve}
\index{cve@\onyxop{}{cve}{}}
\item[{\onyxop{obj}{cve}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in, but with the
			evaluable attribute set.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Set the evaluable attribute for \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 2 3] cve 1 sprint
_{1 2 3}_
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cves}
\index{cves@\onyxop{}{cves}{}}
\item[{\onyxop{real precision}{cves}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[real: ]
			A real.
		\item[precision: ]
			Number of digits after the decimal point to show.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string representation of \oparg{real} in exponential
			form with \oparg{precision} digits of decimal precision.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Convert \oparg{real} to a string representation in exponential
		notation, with \oparg{precision} digits of decimal precision.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 42.3 0 cves 1 sprint
`4e+01'
onyx:0> 42.3 1 cves 1 sprint
`4.2e+01'
onyx:0> 42.3 2 cves 1 sprint
`4.23e+01'
onyx:0> -42.3 5 cves 1 sprint
`-4.23000e+01'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvf}
\index{cvf@\onyxop{}{cvf}{}}
\item[{\onyxop{obj}{cvf}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in, but with the
			fetchable attribute set.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Set the fetchable attribute for \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo cvf 1 sprint
,foo
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvi}
\index{cvi@\onyxop{}{cvi}{}}
\item[{\onyxop{obj}{cvi}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in, but with the
			invokable attribute set.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Set the invokable attribute for \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo cvi 1 sprint
;foo
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvl}
\index{cvl@\onyxop{}{cvl}{}}
\item[{\onyxop{obj}{cvl}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in, but with the literal
			attribute set.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Set the literal attribute for \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {1 2 3} cvl 1 sprint
[1 2 3]
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvn}
\index{cvn@\onyxop{}{cvn}{}}
\item[{\onyxop{string}{cvn}{name}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[name: ]
			A literal name that corresponds to \oparg{string}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Convert \oparg{string} to a literal name.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `foo' cvn 1 sprint
$foo
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvrs}
\index{cvrs@\onyxop{}{cvrs}{}}
\item[{\onyxop{integer radix}{cvrs}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[integer: ]
			An integer.
		\item[radix: ]
			A numerical base, from 2 to 36, inclusive.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string representation of \oparg{integer} in base
			\oparg{radix}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Convert \oparg{integer} to a string representation in base
		\oparg{radix}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 42 2 cvrs 1 sprint
`101010'
onyx:0> 42 16 cvrs 1 sprint
`2a'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvs}
\index{cvs@\onyxop{}{cvs}{}}
\item[{\onyxop{obj}{cvs}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string representation of \oparg{obj}.  The string
			depends on the type of \oparg{obj}:
			\begin{description}
			\item[boolean: ] {\tt `true'} or  {\tt `false'}.
			\item[name: ] The string representation of the name.
			\item[integer: ] The integer in base 10.
			\item[operator: ] The string representation of the
			operator name or {\tt `-operator-'}.
			\item[real: ] The real in exponential notation.
			\item[string: ] A printable representation of
			\oparg{obj}.  The result can be evaluated to produce
			the original string.
			\item[Other types: ] {\tt `--nostringval--'}.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Convert \oparg{obj} to a string representation.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true cvs 1 sprint
`true'
onyx:0> $foo cvs 1 sprint
`foo'
onyx:0> 42 cvs 1 sprint
`42'
onyx:0> ~pop cvs 1 sprint
`pop'
onyx:0> 42.0 cvs 1 sprint
`4.200000e+01'
onyx:0> `foo\nbar\\biz\`baz' cvs 1 sprint
`\`foo\\nbar\\\\biz\\\`baz\''
onyx:0> mutex cvs 1 sprint
`--nostringval--'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:cvx}
\index{cvx@\onyxop{}{cvx}{}}
\item[{\onyxop{obj}{cvx}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in, but with the
			executable attribute set.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Set the executable attribute for \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 2 3] cvx 1 sprint
{1 2 3}
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:data}
\index{data@\onyxop{}{data}{}}
\item[{\onyxop{class/instance}{data}{dict/null}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class/instance: ]
			A class or instance object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict/null: ]
			A dict or null object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the data associated with \oparg{class} or \oparg{instance}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> vclass data 1 sprint
<>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:dec}
\index{dec@\onyxop{}{dec}{}}
\item[{\onyxop{a}{dec}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			$a - 1$.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Subtract one from \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 dec 1 sprint
0
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:def}
\index{def@\onyxop{}{def}{}}
\item[{\onyxop{key val}{def}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[key: ]
			An object.
		\item[val: ]
			A value associated with \oparg{key}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Define \oparg{key} with associated value \oparg{val} in the
		topmost dictionary on dstack.  If \oparg{key} is already defined
		in that dictionary, the old definition is replaced.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo `foo' def
onyx:0> foo 1 sprint
`foo'
onyx:0> $foo `FOO' def
onyx:0> foo 1 sprint
`FOO'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:detach}
\index{detach@\onyxop{}{detach}{}}
\item[{\onyxop{thread}{detach}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Detach \oparg{thread} so that its resources will be
		automatically reclaimed after it exits.  A thread may only be
		detached or joined once; any attempt to do so more than once
		results in undefined behavior (likely crash).
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2) {add 1 sprint self detach} thread
3
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:dict}
\index{dict@\onyxop{}{dict}{}}
\item[{\onyxop{--}{dict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			An empty dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create an empty dictionary.
	\item[Example(s): ]\begin{verbatim}

onyx:0> dict 1 sprint
<>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:die}
\index{die@\onyxop{}{die}{}}
\item[{\onyxop{status}{die}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[status: ]
			A integer from 0 to 255 that is used as the program exit
			code.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Exit the program with exit code \oparg{status}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 die
		\end{verbatim}
	\end{description}
\label{systemdict:dirforeach}
\index{dirforeach@\onyxop{}{dirforeach}{}}
\item[{\onyxop{path proc}{dirforeach}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string that represents a filesystem path.
		\item[proc: ]
			An object to be executed.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		For each entry in the directory represented by \oparg{path}
		except for ``.'' and ``..'', push a string that represents the
		entry onto ostack and execute \oparg{proc}.  This operator
		supports the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pwd {1 sprint} dirforeach
`CVS'
`.cvsignore'
`Cookfile'
`Cookfile.inc'
`latex'
`Cookfile.inc.in'
onyx:0> pwd {`Cookfile.inc' match
     {pop `Yes: ' print 1 sprint pop exit}
     {`Not: ' print 1 sprint} ifelse
} dirforeach
Not: `CVS'
Not: `.cvsignore'
Not: `Cookfile'
Yes: `Cookfile.inc'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:div}
\index{div@\onyxop{}{div}{}}
\item[{\onyxop{a b}{div}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\item[b: ]
			A non-zero integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The quotient of \oparg{a} divided by \oparg{b}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedresult}{undefinedresult}.]
		\end{description}
	\item[Description: ]
		Return the quotient of \oparg{a} divided by \oparg{b}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 2 div 1 sprint
2.000000e+00
onyx:0> 5 2.0 div 1 sprint
2.500000e+00
onyx:0> 5.0 0 div
Error $undefinedresult
ostack: (5.000000e+00 0)
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..2):
0:      --div--
1:      -file-
2:      --start--
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:dn}
\index{dn@\onyxop{}{dn}{}}
\item[{\onyxop{a b c}{dn}{b c a}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\item[c: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[b: ]
			An object.
		\item[c: ]
			An object.
		\item[a: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Rotate the top three objects on ostack down one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' `d' dn pstack
`b'
`d'
`c'
`a'
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:dstack}
\index{dstack@\onyxop{}{dstack}{}}
\item[{\onyxop{--}{dstack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A snapshot of dstack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a snapshot of dstack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> dstack 1 sprint
(-dict- -dict- -dict- -dict-)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:dup}
\index{dup@\onyxop{}{dup}{}}
\item[{\onyxop{obj}{dup}{obj dup}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in.
		\item[dup: ]
			A duplicate of \oparg{obj}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the top object on ostack.  For composite
		objects, the new object is a reference to the same composite
		object.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 dup pstack
1
1
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:echeck}
\index{echeck@\onyxop{}{echeck}{}}
\item[{\onyxop{obj}{echeck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the evaluable attribute,
			false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for evaluable attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {1 2 3} cve
onyx:1> dup 1 sprint
_{1 2 3}_
onyx:1> echeck 1 sprint
true
onyx:0> {1 2 3} echeck 1 sprint
false
onyx:0> [1 2 3] echeck 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:egid}
\index{egid@\onyxop{}{egid}{}}
\item[{\onyxop{--}{egid}{gid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[gid: ]
			Process's effective group ID.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the process's effective group ID.
	\item[Example(s): ]\begin{verbatim}

onyx:0> egid 1 sprint
1001
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:end}
\index{end@\onyxop{}{end}{}}
\item[{\onyxop{--}{end}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Pop the topmost dictionary off dstack, thereby removing its
		contents from the namespace.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <$foo `foo'> begin
onyx:0> foo 1 sprint
`foo'
onyx:0> end
onyx:0> foo 1 sprint
Error $undefined
ostack: ()
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..2):
0:      foo
1:      -file-
2:      --start--
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:envdict}
\index{envdict@\onyxop{}{envdict}{}}
\item[{\onyxop{--}{envdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get envdict.  See Section~\ref{sec:envdict} for details on
		envdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> envdict 0 sprint
-dict-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:escape}
\index{escape@\onyxop{}{escape}{}}
\item[{\onyxop{arg}{escape}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[arg: ]
			Argument to be returned by the
			\htmlref{\onyxop{}{trapped}{}}{systemdict:trapped}
			operator invocation that traps this \onyxop{}{escape}{}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Unwind the execution stack to the innermost
		\htmlref{\onyxop{}{trapped}{}}{systemdict:trapped} or
		\htmlref{\onyxop{}{start}{}}{systemdict:start} context.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {$arg escape} trapped {1 sprint} if
$arg
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:eq}
\index{eq@\onyxop{}{eq}{}}
\item[{\onyxop{a b}{eq}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{a} is equal to \oparg{b}, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Compare two objects for equality.  Equality has the following
		meaning, depending on the types of \oparg{a} and \oparg{b}:
		\begin{description}
		\item[array, condition, dict, file, handle, mutex, stack,
		thread: ] \oparg{a} and \oparg{b} are equal iff they refer to
		the same memory.
		\item[operator: ] \oparg{a} and \oparg{b} are equal iff they
		refer to the same function.
		\item[name, string: ] \oparg{a} and \oparg{b} are equal iff they
		are lexically equivalent.  A name can be equal to a string.
		\item[boolean: ] \oparg{a} and \oparg{b} are equal iff they
		are the same value.
		\item[integer, real: ] \oparg{a} and \oparg{b} are equal iff
		they are the same value.
		\end{description}
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex mutex eq 1 sprint
false
onyx:0> mutex dup eq 1 sprint
true
onyx:0> $foo `foo' eq 1 sprint
true
onyx:0> true true eq 1 sprint
true
onyx:0> true false eq 1 sprint
false
onyx:0> 1 1 eq 1 sprint
true
onyx:0> 1 2 eq 1 sprint
false
onyx:0> 1.0 1 eq 1 sprint
true
onyx:0> 1.0 1.1 eq 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:estack}
\index{estack@\onyxop{}{estack}{}}
\item[{\onyxop{--}{estack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A current snapshot (copy) of the execution stack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a current snapshot of the execution stack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> estack 1 sprint
(--start-- -file- --estack--)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:euid}
\index{euid@\onyxop{}{euid}{}}
\item[{\onyxop{--}{euid}{uid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[uid: ]
			Process's effective user ID.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the process's effective user ID.
	\item[Example(s): ]\begin{verbatim}

onyx:0> euid 1 sprint
1001
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:eval}
\index{eval@\onyxop{}{eval}{}}
\item[{\onyxop{obj}{eval}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Evaluate object.  See Section~\ref{sec:onyx_objects} for
		details on object evaluation.
	\item[Example(s): ]\begin{verbatim}

onyx:0> ``hi' 1 sprint' cvx eval
`hi'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:exch}
\index{exch@\onyxop{}{exch}{}}
\item[{\onyxop{a b}{exch}{b a}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[b: ]
			The same object that was passed in.
		\item[a: ]
			The same object that was passed in.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Exchange the top two objects on ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 pstack
2
1
onyx:2> exch pstack
1
2
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:exec}
\index{exec@\onyxop{}{exec}{}}
\item[{\onyxop{args}{exec}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[args: ]
			An array of strings.  The first string in \oparg{args}
			is the path of the program to invoke, and any additional
			array elements are passed as command line arguments to
			the invoked program.
		\end{description}
	\item[Output(s): ] None (this operator does not return).
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Overlay a new program and execute it.  The current contents of
		envdict are used to construct the new program's environment.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `Old program'
onyx:1> [`/usr/local/bin/onyx'] exec
Canonware Onyx, version 1.0.0.
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:exit}
\index{exit@\onyxop{}{exit}{}}
\item[{\onyxop{--}{exit}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ] None.
	\item[Description: ]
		Exit the innermost enclosing looping context immediately.
		This operator can be called within the looping context of
		\htmlref{\onyxop{}{for}{}}{systemdict:for},
		\htmlref{\onyxop{}{repeat}{}}{systemdict:repeat},
		\htmlref{\onyxop{}{while}{}}{systemdict:while},
		\htmlref{\onyxop{}{until}{}}{systemdict:until},
		\htmlref{\onyxop{}{loop}{}}{systemdict:loop},
		\htmlref{\onyxop{}{foreach}{}}{systemdict:foreach}, and
		\htmlref{\onyxop{}{dirforeach}{}}{systemdict:dirforeach}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {`hi' 1 sprint exit `bye' 1 sprint} loop
`hi'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:exp}
\index{exp@\onyxop{}{exp}{}}
\item[{\onyxop{b}{exp}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			$e$ raised to the \oparg{b} power.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return $e$ (the base of natural logarithm) raised to the
		\oparg{b} power.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 exp 1 sprint
2.008554e+01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:false}
\index{false@\onyxop{}{false}{}}
\item[{\onyxop{--}{false}{false}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[false: ]
			The boolean value false.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Return false.
	\item[Example(s): ]\begin{verbatim}

onyx:0> false 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:fcheck}
\index{fcheck@\onyxop{}{fcheck}{}}
\item[{\onyxop{obj}{fcheck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the fetchable attribute, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for fetchable attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $name fcheck 1 sprint
false
onyx:0> $name cvf fcheck 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:floor}
\index{floor@\onyxop{}{floor}{}}
\item[{\onyxop{a}{floor}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Integer floor of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the integer floor of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> -1.51 floor 1 sprint
-2
onyx:0> -1.49 floor 1 sprint
-2
onyx:0> 0 floor 1 sprint
0
onyx:0> 1.49 floor 1 sprint
1
onyx:0> 1.51 floor 1 sprint
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:flush}
\index{flush@\onyxop{}{flush}{}}
\item[{\onyxop{--}{flush}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\end{description}
	\item[Description: ]
		Flush any buffered data associated with stdout.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `Hi\n' print
onyx:0> flush
Hi
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:flushfile}
\index{flushfile@\onyxop{}{flushfile}{}}
\item[{\onyxop{file}{flushfile}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Flush any buffered data associated with \oparg{file}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `Hi\n' print
onyx:0> stdout flushfile
Hi
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:for}
\index{for@\onyxop{}{for}{}}
\item[{\onyxop{init inc limit proc}{for}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[init: ]
			Initial value of control variable.
		\item[inc: ]
			Amount to increment control variable by at the end of
			each iteration.
		\item[limit: ]
			Inclusive upper bound for control variable if less than
			or equal to \oparg{init}, otherwise inclusive lower
			bound for control variable.
		\item[proc: ]
			An object.
		\end{description}
	\item[Output(s): ]  At the beginning of each iteration, the current
		value of the control variable is pushed onto ostack.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Iteratively evaluate \oparg{proc}, pushing a control variable
		onto ostack at the beginning of each iteration, until the
		control variable has exceeded \oparg{limit}.  This operator
		supports the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue}
		and\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 1 3 {1 sprint} for
0
1
2
3
onyx:0> 0 -1 -3 {1 sprint} for
0
-1
-2
-3
onyx:0> 0 2 7 {1 sprint} for
0
2
4
6
onyx:0> 0 1 1000 {dup 1 sprint 3 eq {exit} if} for
0
1
2
3
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:foreach}
\index{foreach@\onyxop{}{foreach}{}}
\item[{\onyxop{array proc}{foreach}{--}}: ]
\item[{\onyxop{dict proc}{foreach}{--}}: ]
\item[{\onyxop{stack proc}{foreach}{--}}: ]
\item[{\onyxop{string proc}{foreach}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array object.
		\item[dict: ]
			A dict object.
		\item[stack: ]
			A stack object.
		\item[string: ]
			A string object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		For each entry in the first input argument (\oparg{array},
		\oparg{dict}, \oparg{stack}, or \oparg{string}), push the entry
		onto ostack and execute \oparg{proc}.  This operator supports
		the \htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.

		The object being iterated over can be modified during iteration,
		with the expectation of no ill consequences, and in most cases
		the modifications are immediately apparent.  However, there are
		some cases in which behavior does not follow this guideline:
		\begin{itemize}\item[]
		\item{Objects inserted into a dictionary during iteration may or
			may not be iterated over.}
		\item{In the case of stack iteration, a snapshot is taken before
			iteration begins, so any changes to the stack during
			iteration will not affect iteration in any way.}
		\end{itemize}
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 2] {1 sprint} foreach
1
2
onyx:0> <$foo `foo' $bar `bar'> {pstack clear} foreach
`bar'
$bar
`foo'
$foo
onyx:0> (1 2) {pstack clear} foreach
2
1
onyx:0> `ab' {pstack clear} foreach
97
98
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:forkexec}
\index{forkexec@\onyxop{}{forkexec}{}}
\item[{\onyxop{args}{forkexec}{pid}}: ]
\item[{\onyxop{args redirects}{forkexec}{pid}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\item[args: ]
			An array of strings.  The first string in \oparg{args}
			is the path of the program to invoke, and any additional
			array elements are passed as command line arguments to
			the invoked program.
		\item[redirects: ]
			A dictionary of file redirections.  Each key/value pair
			specifies that the file descriptor associated with the
			key should be replaced by the file descriptor associated
			with the value.  The file descriptor associated with the
			key is kept open across the exec.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process identifier for the new process, or 0 if the
			child process.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{limitcheck}{limitcheck}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Fork and exec a new process.  The current contents of envdict
		are used to construct the new program's environment.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`/bin/date'] forkexec dup 1 sprint waitpid 1 sprint
6516
Sat Jul 13 20:47:54 PDT 2002
0
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:gcdict}
\index{gcdict@\onyxop{}{gcdict}{}}
\item[{\onyxop{--}{gcdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get gcdict.  See Section~\ref{sec:gcdict} for details on
		gcdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gcdict 0 sprint
-dict-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ge}
\index{ge@\onyxop{}{ge}{}}
\item[{\onyxop{a b}{ge}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			A number (integer or real) or string.
		\item[b: ]
			An object of a type compatible with \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{a} is greater than or equal to \oparg{b},
			false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Compare two numbers or strings.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 ge 1 sprint
false
onyx:0> 1 1 ge 1 sprint
true
onyx:0> 2 1 ge 1 sprint
true
onyx:0> 1 1.1 ge 1 sprint
false
onyx:0> 1.1 1.1 ge 1 sprint
true
onyx:0> 1.1 1 ge 1 sprint
true
onyx:0> `a' `b' ge 1 sprint
false
onyx:0> `a' `a' ge 1 sprint
true
onyx:0> `b' `a' ge 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:get}
\index{get@\onyxop{}{get}{}}
\item[{\onyxop{array index}{get}{obj}}: ]
\item[{\onyxop{dict key}{get}{value}}: ]
\item[{\onyxop{string index}{get}{integer}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array object.
		\item[dict: ]
			A dict object.
		\item[string: ]
			A string object.
		\item[index: ] Offset of \oparg{array} element or \oparg{string}
		element.
		\item[key: ]
			A key in \oparg{dict}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The object in \oparg{array} at offset \oparg{index}.
		\item[value: ]
			The value in \oparg{dict} corresponding to \oparg{key}.
		\item[integer: ]
			The ascii value of the character in \oparg{string} at
			offset \oparg{index}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\end{description}
	\item[Description: ]
		Get an element of \oparg{array}, a value in \oparg{dict}, or an
		element of \oparg{string}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`a' `b' `c'] 1 get 1 sprint
`b'
onyx:0> <$foo `foo' $bar `bar'> $bar get 1 sprint
`bar'
onyx:0> `abc' 1 get 1 sprint
98
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:getinterval}
\index{getinterval@\onyxop{}{getinterval}{}}
\item[{\onyxop{array index length}{getinterval}{subarray}}: ]
\item[{\onyxop{string index length}{getinterval}{substring}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array object.
		\item[string: ]
			A string object.
		\item[index: ]
			The offset into \oparg{array} or \oparg{string} to get
			the interval from.
		\item[length: ]
			The length of the interval in \oparg{array} or
			\oparg{string} to get.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[subarray: ]
			A subarray of \oparg{array} at offset \oparg{index} and
			of length \oparg{length}.
		\item[substring: ]
			A substring of \oparg{string} at offset \oparg{index}
			and of length \oparg{length}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get an interval of \oparg{array} or \oparg{string}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [0 1 2 3] 1 2 getinterval 1 sprint
[1 2]
onyx:0> `abcd' 1 2 getinterval 1 sprint
`bc'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:getpgid}
\index{getpgid@\onyxop{}{getpgid}{}}
\item[{\onyxop{pid}{getpgid}{pgid}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process ID, or 0 (same as specifying the calling
			process's ID).
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[pgid: ] Process group ID.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the process group ID for the process with ID \oparg{pid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 getpgid 1 sprint
15864
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:getsid}
\index{getsid@\onyxop{}{getsid}{}}
\item[{\onyxop{pid}{getsid}{sid}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process ID, or 0 (same as specifying the calling
			process's ID).
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[sid: ] Session ID.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the session ID for the process with ID \oparg{pid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 getsid 1 sprint
1120
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:gid}
\index{gid@\onyxop{}{gid}{}}
\item[{\onyxop{--}{gid}{gid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[gid: ]
			Process's group ID.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the process's group ID.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gid 1 sprint
1001
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:globaldict}
\index{globaldict@\onyxop{}{globaldict}{}}
\item[{\onyxop{--}{globaldict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get globaldict.  See Section~\ref{sec:globaldict} for details on
		globaldict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> globaldict 1 sprint
<>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:gmaxestack}
\index{gmaxestack@\onyxop{}{gmaxestack}{}}
\item[{\onyxop{--}{gmaxestack}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			Default maximum allowable estack depth.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the default maximum allowable estack depth.  This value is
		used when creating new threads.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gmaxestack 1 sprint
256
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:gstderr}
\index{gstderr@\onyxop{}{gstderr}{}}
\item[{\onyxop{--}{gstderr}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object corresponding to the global stderr.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the global stderr that is inherited by new threads.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gstderr pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:gstdin}
\index{gstdin@\onyxop{}{gstdin}{}}
\item[{\onyxop{--}{gstdin}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object corresponding to the global stdin.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the global stdin that is inherited by new threads.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gstdin pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:gstdout}
\index{gstdout@\onyxop{}{gstdout}{}}
\item[{\onyxop{--}{gstdout}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object corresponding to the global stdout.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the global stdout that is inherited by new threads.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gstdout pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:gt}
\index{gt@\onyxop{}{gt}{}}
\item[{\onyxop{a b}{gt}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			A number (integer or real) or string.
		\item[b: ]
			An object of a type compatible with \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{a} is greater than \oparg{b}, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Compare two numbers or strings.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 1 gt 1 sprint
false
onyx:0> 2 1 gt 1 sprint
true
onyx:0> 1.1 1.1 gt 1 sprint
false
onyx:0> 1.1 1 gt 1 sprint
true
onyx:0> `a' `a' gt 1 sprint
false
onyx:0> `b' `a' gt 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:gtailopt}
\index{gtailopt@\onyxop{}{gtailopt}{}}
\item[{\onyxop{--}{gtailopt}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if tail call optimization is enabled by default for
			new threads, false otherwise.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get whether tail call optimization is enabled by default for new
		threads.
	\item[Example(s): ]\begin{verbatim}

onyx:0> gtailopt 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:handletag}
\index{handletag@\onyxop{}{handletag}{}}
\item[{\onyxop{handle}{handletag}{tag}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[handle: ]
			A handle object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[tag: ]
			The tag associated with \oparg{handle}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the tag associated with \oparg{handle}.
%% 	\item[Example(s): ]\begin{verbatim}

%% 		\end{verbatim}
	\end{description}
\label{systemdict:ibdup}
\index{ibdup@\onyxop{}{ibdup}{}}
\item[{\onyxop{\dots obj \commas index}{ibdup}{\dots obj \commas dup}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			\oparg{index} objects.
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\item[index: ]
			Offset from bottom of ostack, counting from 0.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			\oparg{index} objects.
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\item[dup: ]
			Duplicate of \oparg{obj}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the object on ostack that is at
		offset \oparg{index} from the bottom of ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:4> 2 ibdup pstack
2
3
2
1
0
onyx:5>
		\end{verbatim}
	\end{description}
\label{systemdict:ibpop}
\index{ibpop@\onyxop{}{ibpop}{}}
\item[{\onyxop{\dots obj \commas index}{ibpop}{\dots \commas}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			\oparg{index} objects.
		\item[obj: ]
			An object.
		\item[\commas: ]
			Zero or more objects.
		\item[index: ]
			Offset from bottom of ostack, counting from 0.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			\oparg{index} objects.
		\item[\commas: ]
			Zero or more objects.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the object from ostack that is at offset
		\oparg{index} from the bottom of ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 1 2 3
onyx:4> 2 ibpop pstack
3
1
0
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:icheck}
\index{icheck@\onyxop{}{icheck}{}}
\item[{\onyxop{obj}{icheck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the invokable attribute, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for invokable attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $name icheck 1 sprint
false
onyx:0> $name cvi icheck 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:idiv}
\index{idiv@\onyxop{}{idiv}{}}
\item[{\onyxop{a b}{idiv}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer.
		\item[b: ]
			A non-zero integer.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The integer quotient of \oparg{a} divided by \oparg{b}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedresult}{undefinedresult}.]
		\end{description}
	\item[Description: ]
		Return the integer quotient of \oparg{a} divided by \oparg{b}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 2 idiv 1 sprint
2
onyx:0> 5 2 idiv 1 sprint
2
onyx:0> 5 0 idiv
Error $undefinedresult
ostack: (5 0)
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..2):
0:      --idiv--
1:      -file-
2:      --start--
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:idup}
\index{idup@\onyxop{}{idup}{}}
\item[{\onyxop{obj \dots index}{idup}{obj \dots dup}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\item[index: ]
			Offset from top of ostack, counting from 0, not counting
			\oparg{index}), of the object to duplicate on ostack.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The same object that was passed in.
		\item[dup: ]
			A duplicate of \oparg{obj}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the object on ostack at \oparg{index}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 2 1 0 2 idup pstack
2
0
1
2
3
onyx:5>
		\end{verbatim}
	\end{description}
\label{systemdict:if}
\index{if@\onyxop{}{if}{}}
\item[{\onyxop{boolean obj}{if}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			A boolean.
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{obj} if \oparg{boolean} is true.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true {`yes' 1 sprint} if
`yes'
onyx:0> false {`yes' 1 sprint} if
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ifelse}
\index{ifelse@\onyxop{}{ifelse}{}}
\item[{\onyxop{boolean a b}{ifelse}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			A boolean.
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{a} if \oparg{boolean} is true, evaluate
		\oparg{b} otherwise.  See Section~\ref{sec:onyx_objects} for
		details on object evaluation.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true {`yes'}{`no'} ifelse 1 sprint
`yes'
onyx:0> false {`yes'}{`no'} ifelse 1 sprint
`no'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ilocked}
\index{ilocked@\onyxop{}{ilocked}{}}
\item[{\onyxop{obj}{ilocked}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An array, dict, file, or string.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} is implicitly locked, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Check if \oparg{obj} is implicitly locked.
	\item[Example(s): ]\begin{verbatim}

onyx:0> false setlocking
onyx:0> [1 2 3] ilocked 1 sprint
false
onyx:0> true setlocking
onyx:0> [1 2 3] ilocked 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:implementor}
\index{implementor@\onyxop{}{implementor}{}}
\item[{\onyxop{class name}{implementor}{class/null}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\item[name: ]
			An object of any type, usually a name object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[class/null: ]
			A class or null object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Search up \oparg{class}'s inheritance hierarchy and return the
		first class that implements \oparg{name}, or a null object if
		\oparg{name} is not implemented.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class dup vclass setsuper
onyx:1> $new implementor classname 1 sprint
$vclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:implements}
\index{implements@\onyxop{}{implements}{}}
\item[{\onyxop{class name}{implements}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\item[name: ]
			An object of any type, usually a name object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{name} is implemented by \oparg{class},
			false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return true if \oparg{name} is implemented by \oparg{class};
		return false otherwise.
	\item[Example(s): ]\begin{verbatim}

onyx:1> vclass $new implements 1 sprint
true
onyx:1> vclass $foo implements 1 sprint
false
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:inc}
\index{inc@\onyxop{}{inc}{}}
\item[{\onyxop{a}{inc}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			$a + 1$.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Add one to \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 inc 1 sprint
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:instance}
\index{instance@\onyxop{}{instance}{}}
\item[{\onyxop{--}{instance}{instance}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[instance: ]
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create an instance object.
	\item[Example(s): ]\begin{verbatim}

onyx:0> instance 1 sprint
-instance-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:iobuf}
\index{iobuf@\onyxop{}{iobuf}{}}
\item[{\onyxop{file}{iobuf}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			The size in bytes of the I/O buffer associated with
			\oparg{file}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the size of the I/O buffer associated with \oparg{file}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stdout iobuf 1 sprint
512
onyx:0> stderr iobuf 1 sprint
0
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ipop}
\index{ipop@\onyxop{}{ipop}{}}
\item[{\onyxop{obj \dots index}{ipop}{\dots}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\item[index: ]
			Offset from top of ostack, counting from 0, not counting
			\oparg{index}), of the object to remove from ostack.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the \oparg{obj} at \oparg{index} from ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 2 1 0
onyx:3> 1 ipop pstack
0
2
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:isa}
\index{isa@\onyxop{}{isa}{}}
\item[{\onyxop{instance}{isa}{class/null}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[instance: ]
			An instance object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[class/null: ]
			A class or null object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the class \oparg{object} that \oparg{instance} is an
		instance of.
	\item[Example(s): ]\begin{verbatim}

onyx:0> instance isa 1 sprint
null
onyx:0> instance dup vclass setisa
onyx:1> isa classname 1 sprint
$vclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:istack}
\index{istack@\onyxop{}{istack}{}}
\item[{\onyxop{--}{istack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A current snapshot (copy) of the index stack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a current snapshot of the index stack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> istack 1 sprint
(0 0 0)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:join}
\index{join@\onyxop{}{join}{}}
\item[{\onyxop{thread}{join}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Wait for \oparg{thread} to exit.  A thread may only be detached
		or joined once; any attempt to do so more than once results in
		undefined behavior (likely crash).
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2) {add 1 sprint} thread join `Done\n' print flush
3
Done
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:kill}
\index{kill@\onyxop{}{kill}{}}
\item[{\onyxop{pid sig}{kill}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[pid: ]
			An integer.  If \oparg{pid} is greater than 0, it
			specifies a process ID.  If \oparg{pid} is 0, it
			specifies the calling program's process group.  If
			\oparg{pid} is -1, the signal is sent to all non-system
			processes with ID 1.  If \oparg{pid} is less than -1,
			its absolute value specifies a process group.
		\item[sig: ]
			An integer, or one of the following names:
			\begin{itemize}
 			\item{\$SIGABRT}
 			\item{\$SIGALRM}
 			\item{\$SIGBUS}
 			\item{\$SIGCHLD}
 			\item{\$SIGCONT}
 			\item{\$SIGFPE}
 			\item{\$SIGHUP}
 			\item{\$SIGILL}
 			\item{\$SIGINT}
 			\item{\$SIGKILL}
 			\item{\$SIGPIPE}
 			\item{\$SIGQUIT}
 			\item{\$SIGSEGV}
 			\item{\$SIGSTOP}
 			\item{\$SIGTERM}
 			\item{\$SIGTSTP}
 			\item{\$SIGTTIN}
 			\item{\$SIGTTOU}
 			\item{\$SIGUSR1}
 			\item{\$SIGUSR2}
 			\item{\$SIGPOLL (may not be present)}
 			\item{\$SIGPROF}
 			\item{\$SIGSYS}
 			\item{\$SIGTRAP}
 			\item{\$SIGURG}
 			\item{\$SIGVTALRM (may not be present)}
 			\item{\$SIGXCPU}
 			\item{\$SIGXFSZ}
			\end{itemize}
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{limitcheck}{limitcheck}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Send the signal specified by \oparg{sig} to the process or
		process group specified by \oparg{pid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pid $SIGCONT kill
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:kind}
\index{kind@\onyxop{}{kind}{}}
\item[{\onyxop{instance class}{kind}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[instance: ]
			An instance object.
		\item[class: ]
			A class object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{class} is in \oparg{instance}'s
			inheritance hierarchy, false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Determine whether \oparg{class} is in \oparg{instance}'s
		inheritance hierarchy.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $fooclass class dup vclass setsuper def
onyx:0> instance dup fooclass setisa
onyx:1> dup fooclass kind 1 sprint
true
onyx:1> dup vclass kind 1 sprint
true
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:known}
\index{known@\onyxop{}{known}{}}
\item[{\onyxop{dict key}{known}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\item[key: ]
			A key to look for in \oparg{dict}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{key} is defined in \oparg{dict}, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Check whether \oparg{key} is defined in \oparg{dict}.
	\item[Example(s): ]\begin{verbatim}

onyx:1> <$foo `foo'> $foo known 1 sprint
true
onyx:1> <$foo `foo'> $bar known 1 sprint
false
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:lcheck}
\index{lcheck@\onyxop{}{lcheck}{}}
\item[{\onyxop{obj}{lcheck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the literal attribute, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for literal attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {1 2 3} lcheck 1 sprint
false
onyx:0> [1 2 3] lcheck 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:le}
\index{le@\onyxop{}{le}{}}
\item[{\onyxop{a b}{le}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			A number (integer or real) or string.
		\item[b: ]
			An object of a type compatible with \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{a} is less than or equal to \oparg{b},
			false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Compare two numbers or strings.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 le 1 sprint
true
onyx:0> 1 1 le 1 sprint
true
onyx:0> 2 1 le 1 sprint
false
onyx:0> 1 1.1 le 1 sprint
true
onyx:0> 1.1 1.1 le 1 sprint
true
onyx:0> 1.1 1 le 1 sprint
false
onyx:0> `a' `b' le 1 sprint
true
onyx:0> `a' `a' le 1 sprint
true
onyx:0> `b' `a' le 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:length}
\index{length@\onyxop{}{length}{}}
\item[{\onyxop{array}{length}{count}}: ]
\item[{\onyxop{dict}{length}{count}}: ]
\item[{\onyxop{name}{length}{count}}: ]
\item[{\onyxop{string}{length}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array object.
		\item[dict: ]
			A dict object.
		\item[name: ]
			A name object.
		\item[string: ]
			A string object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			Number of elements in \oparg{array}, number of entries
			in \oparg{dict}, number of characters in \oparg{name},
			or number of characters in \oparg{string}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the umber of elements in \oparg{array}, number of entries in
		\oparg{dict}, number of characters in \oparg{name}, or number of
		characters in \oparg{string}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 2 3] length 1 sprint
3
onyx:0> <$foo `foo' $bar `bar'> length 1 sprint
2
onyx:0> $foo length 1 sprint
3
onyx:0> `foo' length 1 sprint
3
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:link}
\index{link@\onyxop{}{link}{}}
\item[{\onyxop{filename linkname}{link}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[filename: ]
			A string that represents a filename.
		\item[linkname: ]
			A string that represents a filename.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a hard link from \oparg{linkname} to \oparg{filename}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open
onyx:1> dup `Hello\n' write
onyx:1> dup flushfile
onyx:1> close
onyx:0> `/tmp/foo' `/tmp/bar' link
onyx:0> `/tmp/bar' `r' open
onyx:1> readline
onyx:2> pstack
false
`Hello'
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:listen}
\index{listen@\onyxop{}{listen}{}}
\item[{\onyxop{sock backlog}{listen}{--}}: ]
\item[{\onyxop{sock}{listen}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[backlog: ]
			Maximum backlog of connections to listen for.  If not
			specified, the maximum backlog is used.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Listen for connections on a socket.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup `localhost' 7777 bindsocket
onyx:1> dup listen
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:ln}
\index{ln@\onyxop{}{ln}{}}
\item[{\onyxop{a}{ln}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Natural logarithm of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the natural logarithm of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 5 ln 1 sprint
1.609438e+00
onyx:0> 8.5 ln 1 sprint
2.140066e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:load}
\index{load@\onyxop{}{load}{}}
\item[{\onyxop{key}{load}{val}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[key: ]
			A key to look up in dstack.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[val: ]
			The value associated with the topmost definition of
			\oparg{key} in dstack.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{undefined}{undefined}.]
		\end{description}
	\item[Description: ]
		Get the topmost definition of \oparg{key} in dstack.
	\item[Example(s): ]\begin{verbatim}

onyx:1> <$foo `foo'> begin
onyx:1> <$foo `FOO'> begin
onyx:1> $foo load 1 sprint
`FOO'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:localtime}
\index{localtime@\onyxop{}{localtime}{}}
\item[{\onyxop{nsecs}{localtime}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[nsecs: ]
			Number of nanoseconds since the epoch.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary that contains the following entries:
			\begin{description}\item[]
			\item[sec: ]
				Seconds (0-59).
			\item[min: ]
				Minutes (0-59).
			\item[hour: ]
				Hours (0-23).
			\item[mday: ]
				Month day (1-31).
			\item[mon: ]
				Month (0-11).
			\item[year: ]
				Year.
			\item[wday: ]
				Week day (0-6, Sunday is 0).
			\item[yday: ]
				Year day (0-365).
			\item[isdst: ]
				Is daylight savings time (true or false).
			\item[zone: ]
				Time zone (string).
			\item[gmtoff: ]
				Offset from UTC in seconds.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Convert a time, as returned by
		\htmlref{realtime}{systemdict:realtime}, to a dictionary that
		contains time information in a more human-usable format.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $date {
    realtime localtime

    [`Sunday' `Monday' `Tuesday' `Wednesday' `Thursday' `Friday' `Saturday']
    over $wday get
    get
    ` ' cat

    over $year get cvs
    `/' 3 ncat

    over $mon get inc <$w 2 $p `0'> outputs
    `/' 3 ncat

    over $mday get <$w 2 $p `0'> outputs
    ` ' 3 ncat

    over $hour get <$w 2 $p `0'> outputs
    `:' 3 ncat

    over $min get <$w 2 $p `0'> outputs
    `:' 3 ncat

    over $sec get <$w 2 $p `0'> outputs
    ` (' 3 ncat

    exch $zone get
    `)\n' 3 ncat

    print flush
} def
onyx:0> date
Monday 2003/03/17 01:31:49 (PST)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:lock}
\index{lock@\onyxop{}{lock}{}}
\item[{\onyxop{mutex}{lock}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[mutex: ]
			A mutex object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Acquire \oparg{mutex}, waiting if necessary.  Attempting to
		acquire \oparg{mutex} recursively will result in undefined
		behavior (likely deadlock or crash).
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex dup lock unlock
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:log}
\index{log@\onyxop{}{log}{}}
\item[{\onyxop{a}{log}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Base 10 logarithm of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the base 10 logarithm of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 5 log 1 sprint
6.989700e-01
onyx:0> 8.5 log 1 sprint
9.294189e-01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:loop}
\index{loop@\onyxop{}{loop}{}}
\item[{\onyxop{proc}{loop}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[proc: ]
			An object to evaluate.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Repeatedly evaluate \oparg{proc} indefinitely.  This operator
		supports the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 {1 add dup 1 sprint dup 3 eq {pop exit} if} loop
1
2
3
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:lt}
\index{lt@\onyxop{}{lt}{}}
\item[{\onyxop{a b}{lt}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			A number (integer or real) or string.
		\item[b: ]
			An object of a type compatible with \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{a} is less than \oparg{b}, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Compare two numbers or strings.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 lt 1 sprint
true
onyx:0> 1 1 lt 1 sprint
false
onyx:0> 1 1.1 lt 1 sprint
true
onyx:0> 1.1 1.1 lt 1 sprint
false
onyx:0> 1.1 1 lt 1 sprint
false
onyx:0> `a' `b' lt 1 sprint
true
onyx:0> `a' `a' lt 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:mark}
\index{mark@\onyxop{}{mark}{}}
\item[{\onyxop{--}{mark}{mark}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[mark: ]
			A mark object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Push a mark onto ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> mark pstack
-mark-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:maxestack}
\index{maxestack@\onyxop{}{maxestack}{}}
\item[{\onyxop{--}{maxestack}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			Maximum allowable estack depth.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the maximum allowable estack depth.
	\item[Example(s): ]\begin{verbatim}

onyx:0> maxestack 1 sprint
256
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:match}
\index{match@\onyxop{}{match}{}}
\item[{\onyxop{input pattern flags}{match}{boolean}}: ]
\item[{\onyxop{input pattern}{match}{boolean}}: ]
\item[{\onyxop{input regex}{match}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[input: ]
			An input string to find matches in.
		\item[pattern: ]
			A string that specifies a regular expression.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[flags: ]
			A dictionary of optional flags:
			\begin{description}%\item[]
			\item[\$c: ]
				Continue where previous match ended.  Don't
				update the offset to start the next match from
				unless this match is successful.  Defaults to
				false.
			\item[\$g: ]
				Continue where previous match ended.  If the
				match is unsuccessful, update the offset to
				start the next match from to the beginning of
				\oparg{input}.  Defaults to false.
			\item[\$i: ] Case insensitive.  Defaults to false.
			\item[\$m: ] Treat input as a multi-line string.
				Defaults to false.
			\item[\$s: ] Treat input as a single line, so that
				the dot metacharacter matches any character,
				including a newline.  Defaults to false.
			\end{description}
		\item[regex: ]
			A regex object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			\begin{description}\item[]
			\item[true: ] Match successful.
			\item[false: ] No match found.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{regexerror}{regexerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Look in \oparg{input} for a match to the regular expression
		specified by \oparg{regex}/\oparg{pattern}/\oparg{flags}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `input' `I' <$i true> match {0 submatch 1 sprint} if
`i'
onyx:0> `input' `I' <$i true> regex match {0 submatch 1 sprint} if
`i'
onyx:0> `input' `I' match {0 submatch 1 sprint} if
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:method}
\index{method@\onyxop{}{method}{}}
\item[{\onyxop{class name}{method}{method}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\item[name: ]
			An object of any type, usually a name object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[method: ]
			The bottommost method associated with \oparg{name} in
			\oparg{class}'s inheritance hierarchy.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\end{description}
	\item[Description: ]
		Get the bottommost method associated with \oparg{name} in
		\oparg{class}'s inheritance hierarchy.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $fooclass class dup vclass setsuper def
onyx:0> fooclass $new method 1 sprint
{--instance-- --dup-- --dn-- --setisa-- --dup-- --dict-- --setdata--}
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:methods}
\index{methods@\onyxop{}{methods}{}}
\item[{\onyxop{class}{methods}{dict/null}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict/null: ]
			A dict or null object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the methods associated with \oparg{class}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> vclass methods 0 sprint
-dict-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:mkdir}
\index{mkdir@\onyxop{}{mkdir}{}}
\item[{\onyxop{path}{mkdir}{--}}: ]
\item[{\onyxop{path mode}{mkdir}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string object that represents a directory path.
		\item[mode: ]
			An integer that represents a Unix file mode.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a directory.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/tdir' 8@755 mkdir
onyx:0> `/tmp/tdir' {1 sprint} dirforeach
`.'
`..'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:mkfifo}
\index{mkfifo@\onyxop{}{mkfifo}{}}
\item[{\onyxop{path}{mkfifo}{--}}: ]
\item[{\onyxop{path mode}{mkfifo}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string object that represents a directory path.
		\item[mode: ]
			An integer that represents a Unix file mode.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a named pipe.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/fifo' mkfifo
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:mod}
\index{mod@\onyxop{}{mod}{}}
\item[{\onyxop{a b}{mod}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\item[b: ]
			A non-zero integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The modulus of \oparg{a} and \oparg{b}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedresult}{undefinedresult}.]
		\end{description}
	\item[Description: ]
			Return the modulus of \oparg{a} and \oparg{b}.  Note
			that \oparg{a} and \oparg{b} can be any combination of
			integers and reals.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 2 mod 1 sprint
0
onyx:0> 5 2 mod 1 sprint
1
onyx:0> 5 0 mod
Error $undefinedresult
ostack: (5 0)
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..2):
0:      --mod--
1:      -file-
2:      --start--
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:modload}
\index{modload@\onyxop{}{modload}{}}
\item[{\onyxop{path symbol}{modload}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string that represents a module filename.
		\item[symbol: ]
			A string that represents the symbol name of a
			module initialization function to be executed.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\end{description}
	\item[Description: ]
		Dynamically load a module, create a handle object that
		encapsulates the handle returned by dlopen(3) (handle data
		pointer) and the module initialization function (handle
		evaluation function), and evaluate the handle.

		All objects that refer to code and/or data that are part of the
		module must directly and/or indirectly maintain a reference to
		the handle that is evaluated by this operator, since failing to
		do so would allow the garbage collector to unload the module,
		which could result in dangling pointers to unmapped memory
		regions.

		Loadable modules present a problem for the garbage collector
		during the sweep phase.  All objects that refer to memory that
		is dynamically mapped as part of the module must be destroyed
		before the module is unloaded.  Destruction ordering constraints
		show up in other situations as well, but in the case of loadable
		modules, there is no reasonable solution except to explicitly
		order the destruction of objects.  Therefore, by default, the
		handle that is evaluated by modload is destroyed during the
		second sweep pass (count starts at 0).  It is possible for a
		module to override what sweep pass the handle is destroyed on,
		in cases where there are additional ordering constraints for the
		objects created by a module.  This isn't important from the Onyx
		language perspective, but is important to understand when
		implementing modules.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/usr/local/share/onyx/nxm/modprompt.nxm' `modprompt_init'
onyx:2> modload
onyx:0>
	\end{verbatim}
	\end{description}
\label{systemdict:monitor}
\index{monitor@\onyxop{}{monitor}{}}
\item[{\onyxop{mutex proc}{monitor}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[mutex: ]
			A mutex.
		\item[proc: ]
			Any object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Execute \oparg{proc} while holding \oparg{mutex}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex {`hello\n' print} monitor flush
hello
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:mrequire}
\index{mrequire@\onyxop{}{mrequire}{}}
\item[{\onyxop{file symbol}{mrequire}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A string that represents a module filename.
		\item[symbol: ]
			A string that represents the symbol name of a
			module initialization function to be executed.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\end{description}
	\item[Description: ]
		Search for and load a module.  The module is searched for by
		catenating a prefix, a ``/'', and \oparg{file} to form a file
		path.  Prefixes are tried in the following order:
		\begin{enumerate}
			\item{The ordered elements of the
			\htmlref{mpath\_pre}{onyxdict:mpath_pre} array, which is
			defined in \htmlref{onyxdict}{sec:onyxdict}.}
			\item{If defined, the ordered elements of the
			ONYX\_MPATH environment variable, which is a
			colon-separated list.}
			\item{The ordered elements of the
			\htmlref{mpath\_post}{onyxdict:mpath_post} array, which
			is defined in \htmlref{onyxdict}{sec:onyxdict}.}
		\end{enumerate}
	\item[Example(s): ]\begin{verbatim}

onyx:0> `modgtk.nxm' `modgtk_init' mrequire
onyx:0>
	\end{verbatim}
	\end{description}
\label{systemdict:mul}
\index{mul@\onyxop{}{mul}{}}
\item[{\onyxop{a b}{mul}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\item[b: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The product of \oparg{a} and \oparg{b}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the product of \oparg{a} and \oparg{b}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 17 mul 1 sprint
51
onyx:0> -5 -6 mul 1 sprint
30
onyx:0> 3.5 4.0 mul 1 sprint
1.400000e+01
onyx:0> -1.5 3 mul 1 sprint
-4.500000e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:mutex}
\index{mutex@\onyxop{}{mutex}{}}
\item[{\onyxop{--}{mutex}{mutex}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[mutex: ]
			A mutex object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create a mutex.
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex 1 sprint
-mutex-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:nbpop}
\index{nbpop@\onyxop{}{nbpop}{}}
\item[{\onyxop{objects \dots count}{nbpop}{\dots}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[objects: ]
			Zero or more objects.
		\item[count: ]
			Number of \oparg{objects} to pop.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the bottom \oparg{count} \oparg{objects} from ostack and
		discard them.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' 2 nbpop pstack
`c'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:ncat}
\index{ncat@\onyxop{}{ncat}{}}
\item[{\onyxop{arrays count}{ncat}{array}}: ]
\item[{\onyxop{stacks count}{ncat}{stack}}: ]
\item[{\onyxop{strings count}{ncat}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[arrays: ]
			\oparg{count} arrays.
		\item[stacks: ]
			\oparg{count} stacks.
		\item[strings: ]
			\oparg{count} strings.
		\item[count: ]
			Number of \oparg{arrays}, \oparg{stacks}, or
			\oparg{strings} to catenate.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The catenation of \oparg{arrays}, \oparg{stacks}, or
			\oparg{strings}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Catenate \oparg{count} \oparg{arrays}, \oparg{stacks}, or
		\oparg{strings}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`a'] [`b'] [`c'] 3 ncat 1 sprint
[`a' `b' `c']
onyx:0> (`a') (`b') (`c') 3 ncat 1 sprint
(`a' `b' `c')
onyx:0> `a' `b' `c' 3 ncat 1 sprint
`abc'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ndn}
\index{ndn@\onyxop{}{ndn}{}}
\item[{\onyxop{a \dots b count}{ndn}{\dots b a}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[\dots: ]
			$count - 2$ objects.
		\item[b: ]
			An object.
		\item[count: ]
			Number of objects to rotate downward.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			$count - 2$ objects.
		\item[b: ]
			An object.
		\item[a: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate \oparg{count} objects on ostack down one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' `d' `e' 4 ndn pstack
`b'
`e'
`d'
`c'
`a'
onyx:5>
		\end{verbatim}
	\end{description}
\label{systemdict:ndup}
\index{ndup@\onyxop{}{ndup}{}}
\item[{\onyxop{objects count}{ndup}{objects objects}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[objects: ]
			Zero or more objects.
		\item[count: ]
			The number of \oparg{objects} do duplicate.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[objects: ]
			The same objects that were passed in.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create duplicates of the top \oparg{count} objects on ostack.
		For composite objects, the new object is a reference to the same
		composite object.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' 2 ndup pstack
`c'
`b'
`c'
`b'
`a'
onyx:5>
		\end{verbatim}
	\end{description}
\label{systemdict:ne}
\index{ne@\onyxop{}{ne}{}}
\item[{\onyxop{a b}{ne}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{a} is not equal to \oparg{b}, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Compare two objects for inequality.  Inequality has the
		following meaning, depending on the types of \oparg{a} and
		\oparg{b}:
		\begin{description}
		\item[array, condition, dict, file, handle, mutex, stack,
		thread: ] \oparg{a} and \oparg{b} are not equal unless they
		refer to the same memory.
		\item[operator: ] \oparg{a} and \oparg{b} are not equal unless
		they refer to the same function.
		\item[name, string: ] \oparg{a} and \oparg{b} are not equal iff
		they are lexically equivalent.  A name can be equal to a string.
		\item[boolean: ] \oparg{a} and \oparg{b} are not equal unless
		they are the same value.
		\item[integer, real: ] \oparg{a} and \oparg{b} are not equal
		unless they are the same value.
		\end{description}
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex mutex ne 1 sprint
true
onyx:0> mutex dup ne 1 sprint
false
onyx:0> $foo `foo' ne 1 sprint
false
onyx:0> $foo $bar ne 1 sprint
true
onyx:0> true false ne 1 sprint
true
onyx:0> true true ne 1 sprint
false
onyx:0> 1 1 ne 1 sprint
false
onyx:0> 1 2 ne 1 sprint
true
onyx:0> 1.0 1 ne 1 sprint
false
onyx:0> 1.0 1.1 ne 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:neg}
\index{neg@\onyxop{}{neg}{}}
\item[{\onyxop{a}{neg}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The negative of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the negative of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 neg 1 sprint
0
onyx:0> 5 neg 1 sprint
-5
onyx:0> -5 neg 1 sprint
5
onyx:0> 3.14 neg 1 sprint
-3.140000e+00
onyx:0> -3.14 neg 1 sprint
3.140000e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:nip}
\index{nip@\onyxop{}{nip}{}}
\item[{\onyxop{a b}{nip}{b}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[b: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Remove the second to top object from ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c'
onyx:3> nip pstack
`c'
`a'
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:nonblocking}
\index{nonblocking@\onyxop{}{nonblocking}{}}
\item[{\onyxop{file}{nonblocking}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			Nonb-blocking mode for \oparg{file}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get non-blocking mode for \oparg{file}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open
onyx:1> dup nonblocking 1 sprint
false
onyx:1> dup true setnonblocking
onyx:1> dup nonblocking 1 sprint
true
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:not}
\index{not@\onyxop{}{not}{}}
\item[{\onyxop{a}{not}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or boolean.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			If \oparg{a} is an integer, the bitwise negation of
			\oparg{a}, otherwise the logical negation of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the bitwise negation of an integer, or the logical
		negation of a boolean.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true not 1 sprint
false
onyx:0> false not 1 sprint
true
onyx:0> 1 not 1 sprint
-2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:npop}
\index{npop@\onyxop{}{npop}{}}
\item[{\onyxop{objects count}{npop}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[objects: ]
			Zero or more objects.
		\item[count: ]
			Number of \oparg{objects} to pop.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the top \oparg{count} \oparg{objects} from ostack and
		discard them.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' 2 npop pstack
`a'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:nsleep}
\index{nsleep@\onyxop{}{nsleep}{}}
\item[{\onyxop{nanoseconds}{nsleep}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[nanoseconds: ]
			Minimum number of nanoseconds to sleep.  Must be greater
			than 0.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Sleep for at least \oparg{nanoseconds} nanonseconds.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1000 nsleep
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:null}
\index{null@\onyxop{}{null}{}}
\item[{\onyxop{--}{null}{null}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[null: ]
			A null object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create a null object.
	\item[Example(s): ]\begin{verbatim}

onyx:0> null pstack
null
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:nup}
\index{nup@\onyxop{}{nup}{}}
\item[{\onyxop{a \dots b count}{nup}{b a \dots}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[\dots: ]
			$count - 2$ objects.
		\item[b: ]
			An object.
		\item[count: ]
			Number of objects to rotate upward.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[b: ]
			An object.
		\item[a: ]
			An object.
		\item[\dots: ]
			$count - 2$ objects.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate \oparg{count} objects on ostack up one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' `d' `e' 4 nup pstack
`d'
`c'
`b'
`e'
`a'
onyx:5>
		\end{verbatim}
	\end{description}
\label{systemdict:offset}
\index{offset@\onyxop{}{offset}{}}
\item[{\onyxop{input submatch}{offset}{offset}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[input: ]
			A string.
		\item[submatch: ]
			A substring of \oparg{input}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[offset: ]
			The integer offset of \oparg{submatch}, relative to the
			beginning of \oparg{input}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the offset of \oparg{submatch}, relative to the beginning of
		\oparg{input}.  \oparg{submatch} must be a substring of
		\oparg{input}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `input' dup `n(p)u' match {1 submatch offset 1 sprint} if
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:onyxdict}
\index{onyxdict@\onyxop{}{onyxdict}{}}
\item[{\onyxop{--}{onyxdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get onyxdict.  See Section~\ref{sec:onyxdict} for details on
		onyxdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> onyxdict 1 sprint
<$rpath_pre -array- $rpath_post -array- $mpath_pre -array- $mpath_post -array->
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:open}
\index{open@\onyxop{}{open}{}}
\item[{\onyxop{filename flags}{open}{file}}: ]
\item[{\onyxop{filename flags mode}{open}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[filename: ]
			A string that represents a filename.
		\item[flags: ]
			A string that represents a file mode:
			\begin{description}%\item[]
			\item[`r': ]
				Read only.
			\item[`r+': ]
				Read/write, starting at offset 0.
			\item[`w': ]
				Write only.  Create file if necessary.  Truncate
				file if non-zero length.
			\item[`w+': ]
				Read/write, starting at offset 0.  Create
				file if necessary.
			\item[`a': ]
				Write only, starting at end of file.
			\item[`a+': ]
				Read/write, starting at end of file.
			\end{description}
		\item[mode: ]
			Mode to use when creating a new file (defaults to 0777).
			Note that the process's umask also affects creation
			mode.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{limitcheck}{limitcheck}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Open a file.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:or}
\index{or@\onyxop{}{or}{}}
\item[{\onyxop{a b}{or}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or boolean.
		\item[b: ]
			The same type as \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			If \oparg{a} and \oparg{b} are integers, their bitwise
			or, otherwise their logical or.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the bitwise or of two integers, or the logical or of
		two booleans.
	\item[Example(s): ]\begin{verbatim}

onyx:0> false false or 1 sprint
false
onyx:0> true false or 1 sprint
true
onyx:0> 5 3 or 1 sprint
7
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:origin}
\index{origin@\onyxop{}{origin}{}}
\item[{\onyxop{array}{origin}{false}}: ]
\item[{\onyxop{array}{origin}{string line true}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string (typically a filename) that tells what the
			origin of \oparg{array} was.
		\item[line: ]
			An integer that represents the line within
			\oparg{string} that \oparg{array} started at.
		\item[false/true: ]
			If false, no origin is recorded for \oparg{array}.  If
			true, the origin is recorded for \oparg{array}, and
			\oparg{string} and \oparg{line} are also returned.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		If the origin of \oparg{array} is recorded, return the
		\oparg{string} and \oparg{line} that represent the origin.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {} origin {exch 1 sprint 1 sprint} if
`*stdin*'
1
onyx:0> [] origin {exch 1 sprint 1 sprint} if
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ostack}
\index{ostack@\onyxop{}{ostack}{}}
\item[{\onyxop{--}{ostack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A current snapshot (copy) of ostack.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a current snapshot of ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 3 ostack pstack
(1 2 3)
3
2
1
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:output}
\index{output@\onyxop{}{output}{}}
\item[{\onyxop{obj depth}{output}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object to print syntactically.
		\item[depth: ]
			Maximum recursion depth.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Syntactically print \oparg{obj}.  See
		Section~\ref{sec:outputsdict} for format specifier details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 [2 3] 4] <$w 20 $p `_' $j $c $r 1> output `\n' print flush
___[1 -array- 4]____
onyx:0> [1 [2 3] 4] <$w 20 $p `_' $j $c $r 2> output `\n' print flush
____[1 [2 3] 4]_____
onyx:0> 4242 <$s $+> output `\n' print flush
+4242
onyx:0> `0x' print 4242 <$b 16> output `\n' print flush
0x1092
onyx:0> `0x' 4242 <$b 16> outputs cat <$w 10 $p `.'>
onyx:2>  output `\n' print flush
....0x1092
onyx:0> `0x' print 4242 <$w 8 $p `0' $b 16> output `\n' print flush
0x00001092
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:outputs}
\index{outputs@\onyxop{}{outputs}{}}
\item[{\onyxop{obj flags}{outputs}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object to print syntactically.
		\item[depth: ]
			Formatting flags.  See Section~\ref{sec:outputsdict} for
			details on the supported flags.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A formatted string representation of \oparg{obj}.
			See Section~\ref{sec:outputsdict} for format specifier
			details.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a formatted string representation of \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 [2 3] 4] <$w 20 $p `_' $j $c $r 1> outputs print `\n' print flush
___[1 -array- 4]____
onyx:0> [1 [2 3] 4] <$w 20 $p `_' $j $c $r 2> outputs print `\n' print flush
____[1 [2 3] 4]_____
onyx:0> 4242 <$s $+> outputs print `\n' print flush
+4242
onyx:0> `0x' print 4242 <$b 16> outputs print `\n' print flush
0x1092
onyx:0> `0x' 4242 <$b 16> outputs cat <$w 10 $p `.'> outputs
onyx:1> print `\n' print flush
....0x1092
onyx:0> `0x' print 4242 <$w 8 $p `0' $b 16> outputs print `\n' print flush
0x00001092
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:outputsdict}
\index{outputsdict@\onyxop{}{outputsdict}{}}
\item[{\onyxop{--}{outputsdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get outputsdict.  See Section~\ref{sec:outputsdict} for details
		on outputsdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> outputsdict 0 sprint
-dict-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:over}
\index{over@\onyxop{}{over}{}}
\item[{\onyxop{a b}{over}{a b a}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the second object on ostack and push it
		onto ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 1 2 over pstack
1
2
1
0
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:path}
\index{path@\onyxop{}{path}{}}
\item[{\onyxop{prog}{path}{path/null}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[prog: ]
			A string that specifies a program to search for in the
			PATH environment variable.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string that specifies the path to \oparg{prog}.
		\item[null: ]
			\oparg{prog} was not found.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Search for \oparg{prog} in the PATH, and return a string that is
		suitable for subsequent calls to operators such as
		\htmlref{\onyxop{}{exec}{}}{systemdict:exec},
		\htmlref{\onyxop{}{forkexec}{}}{systemdict:forkexec}, and
		\htmlref{\onyxop{}{system}{}}{systemdict:system}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `cat' path 1 sprint
`/bin/cat'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:peername}
\index{peername@\onyxop{}{peername}{}}
\item[{\onyxop{sock}{peername}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary of information about the peer end of
			\oparg{sock}.  Depending on the socket family, the
			following entries may exist:
			\begin{description}%\item[]
			\item[family: ] Socket family.
			\item[address: ] IPv4 address.
			\item[port: ] IPv4 port.
			\item[path: ] Unix-domain socket path.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Get information about the peer end of \oparg{sock}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup `localhost' 7777 bindsocket
onyx:1> dup listen
onyx:1> dup accept
onyx:2> dup peername 1 sprint
<$family $AF_INET $address 2130706433 $port 33746>
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:pid}
\index{pid@\onyxop{}{pid}{}}
\item[{\onyxop{--}{pid}{pid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process identifier.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the process ID of the running process.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pid 1 sprint
80624
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:pipe}
\index{pipe@\onyxop{}{pipe}{}}
\item[{\onyxop{--}{pipe}{rfile wfile}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[rfile: ]
			A readable file object.  Data read from \oparg{rfile}
			were previously written to \oparg{wfile}.
		\item[wfile: ]
			A writeable file object.  Data written to \oparg{wfile}
			can subsequently be read from \oparg{rfile}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a pipe.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pipe
onyx:2> $wfile exch def
onyx:1> $rfile exch def
onyx:0> wfile `foo\n' write
onyx:0> wfile flushfile
onyx:0> rfile readline pop 1 sprint
`foo'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:poll}
\index{poll@\onyxop{}{poll}{}}
\item[{\onyxop{{\lt}file flags \dots{\gt} timeout}{poll}{{\lb}file
      \dots{\rb}}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[{\lt}\dots{\gt}: ]
			A dictionary of \oparg{file}/\oparg{flags} key/value
			pairs.
			\begin{description}%\item[]
			\item[file: ]
				A file object.
			\item[flags: ]
				A dictionary that contains keys corresponding to
				file status attributes to poll.  The following
				keys are heeded:
				\begin{description}%\item[]
				\item[\$POLLIN: ]
					Normal or priority data are available
					for reading.
				\item[\$POLLRDNORM: ]
					Normal data are available for reading.
				\item[\$POLLRDBAND: ]
					Priority data are available for reading.
				\item[\$POLLPRI: ]
					High-priority data are available for
					reading.
				\item[\$POLLOUT: ]
					Normal data can be written.
				\item[\$POLLWRNORM: ]
					Normal data can be written.
				\item[\$POLLWRBAND: ]
					Priority data can be written.
				\end{description}
				The values associated with the keys are
				disregarded, but are set appropriately before
				\onyxop{}{poll}{} returns (true/false).
			\end{description}
		\item[timeout: ]
			Timeout, in milliseconds (maximum $2^{31} - 1$).  -1 is
			treated specially to mean infinite timeout.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[{\lb}\dots{\rb}: ]
			An array containing a reference to each \oparg{file} in
			\oparg{{\lt}\dots{\gt}} for which a non-zero number of
			status attributes is set to true.  A zero-length array
			indicates that the poll timed out.
			\begin{description}%\item[]
			\item[file: ]
				A reference to a file object passed in that has
				one or more attributes set to true.
			\end{description}
		\end{description}
		Although \oparg{{\lt}\dots{\gt}} is not returned, its contents
		are modified.
		\begin{description}\item[]
		\item[flags: ]
			The dictionary passed in.  For recognized key that is
			defined, the associated value is set to true or false,
			depending on the status of \oparg{file}.  In addition,
			the following keys may defined (if not already defined)
			with a value of true in the case of errors:
			\begin{description}%\item[]
			\item[\$POLLERR: ]
				An error has occurred.
			\item[\$POLLHUP: ]
				Hangup has occurred.
			\item[\$POLLNVAL: ]
				\oparg{file} is not an open file.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Wait for any of the \oparg{flags} associated with a \oparg{file}
		in \oparg{{\lt}\dots{\gt}} to be true.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <stdout <$POLLOUT null> stderr <$POLLWRNORM null>> dup 0 poll
onyx:2> 2 sprint 2 sprint
[-file- -file-]
<-file- <$POLLWRNORM true> -file- <$POLLOUT true>>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:pop}
\index{pop@\onyxop{}{pop}{}}
\item[{\onyxop{obj}{pop}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Remove the top object from ostack and discard it.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2
onyx:2> pstack
2
1
onyx:2> pop
onyx:1> pstack
1
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:pow}
\index{pow@\onyxop{}{pow}{}}
\item[{\onyxop{a b}{pow}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\item[b: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			\oparg{a} to the \oparg{b} power.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return \oparg{a} to the \oparg{b} power.  If a negative exponent
		is specified, the result will always be a real, even if both
		arguments are integers.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 5 0 pow 1 sprint
1
onyx:0> 5 1 pow 1 sprint
5
onyx:0> 5 2 pow 1 sprint
25
onyx:0> -5 3 pow 1 sprint
-125
onyx:0> 5 -3 pow 1 sprint
8.000000e-03
onyx:0> 2.1 3.5 pow 1 sprint
1.342046e+01
onyx:0> 100 .01 pow 1 sprint
1.000000e+02
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:ppid}
\index{ppid@\onyxop{}{ppid}{}}
\item[{\onyxop{--}{ppid}{pid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process identifier.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the process ID of the running process's parent.
	\item[Example(s): ]\begin{verbatim}

onyx:0> ppid 1 sprint
352
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:print}
\index{print@\onyxop{}{print}{}}
\item[{\onyxop{string}{print}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Print \oparg{string} to stdout.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `Hi\n' print flush
Hi
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:product}
\index{product@\onyxop{}{product}{}}
\item[{\onyxop{--}{product}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string that contains the product name, normally
			`Canonware Onyx'.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the product string.  The string returned is a reference to
		the original product string.
	\item[Example(s): ]\begin{verbatim}

onyx:0> product pstack
`Canonware Onyx'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:pstack}
\index{pstack@\onyxop{}{pstack}{}}
\item[{\onyxop{--}{pstack}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\end{description}
	\item[Description: ]
		Syntactically print the elements of ostack, one per line.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' 1 mark $foo [1 2 3] (4 5 6)
onyx:6> pstack
(4 5 6)
[1 2 3]
$foo
-mark-
1
`a'
onyx:6>
		\end{verbatim}
	\end{description}
\label{systemdict:put}
\index{put@\onyxop{}{put}{}}
\item[{\onyxop{array index obj}{put}{--}}: ]
\item[{\onyxop{dict key value}{put}{--}}: ]
\item[{\onyxop{string index integer}{put}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array object.
		\item[dict: ]
			A dict object.
		\item[string: ]
			A string object.
		\item[index: ]
			Offset in \oparg{array} or \oparg{string} to put
			\oparg{obj} or \oparg{integer}, respectively.
		\item[key: ]
			An object to use as a key in \oparg{dict}.
		\item[obj: ]
			An object to insert into \oparg{array} at offset
			\oparg{index}.
		\item[value: ]
			An object to associate with \oparg{key} in \oparg{dict}.
		\item[integer: ]
			The ascii value of a character to insert into
			\oparg{string} at offset \oparg{index}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Insert into \oparg{array}, \oparg{dict}, or \oparg{string}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 array dup 1 `a' put 1 sprint
[null `a' null]
onyx:0> dict dup $foo `foo' put 1 sprint
<$foo `foo'>
onyx:0> 3 string dup 1 97 put 1 sprint
`\x00a\x00'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:putinterval}
\index{putinterval@\onyxop{}{putinterval}{}}
\item[{\onyxop{array index subarray}{putinterval}{--}}: ]
\item[{\onyxop{string index substring}{putinterval}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array object.
		\item[string: ]
			A string object.
		\item[index: ]
			Offset into \oparg{array} or \oparg{string} to put
			\oparg{subarray} or \oparg{substring}, respectively.
		\item[subarray: ]
			An array object to put into \oparg{array} at offset
			\oparg{index}.  When inserted \oparg{subarray} must not
			extend past the end of \oparg{array}.
		\item[substring: ]
			A string object to put into \oparg{string} at offset
			\oparg{index}.  When inserted \oparg{substring} must not
			extend past the end of \oparg{string}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Replace a portion of \oparg{array} or \oparg{string}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 array dup 1 [`a' `b'] putinterval 1 sprint
[null `a' `b' null]
onyx:0> 4 string dup 1 `ab' putinterval 1 sprint
`\x00ab\x00'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:pwd}
\index{pwd@\onyxop{}{pwd}{}}
\item[{\onyxop{--}{pwd}{path}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string that represents the present working directory.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\end{description}
	\item[Description: ]
		Push a string onto ostack that represents the present working
		directory.
	\item[Example(s): ]\begin{verbatim}

onyx:0> pwd
onyx:1> pstack
`/usr/local/bin'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:quit}
\index{quit@\onyxop{}{quit}{}}
\item[{\onyxop{--}{quit}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ] None.
	\item[Description: ]
		Unwind the execution stack to the innermost
		\htmlref{\onyxop{}{start}{}}{systemdict:start} context.  Under
		normal circumstances, there is always at least one such context.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stdin cvx start
onyx:0> estack 1 sprint
(--start-- -file- --start-- -file- --estack--)
onyx:0> quit
onyx:0> estack 1 sprint
(--start-- -file- --estack--)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:rand}
\index{rand@\onyxop{}{rand}{}}
\item[{\onyxop{--}{rand}{integer}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[integer: ]
			A pseudo-random non-negative integer, with 63 bits of
			psuedo-randomness.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Return a pseudo-random integer.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 srand
onyx:0> rand 1 sprint
9018578418316157091
onyx:0> rand 1 sprint
8979240987855095636
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:read}
\index{read@\onyxop{}{read}{}}
\item[{\onyxop{file}{read}{integer boolean}}: ]
\item[{\onyxop{file string}{read}{substring boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[string: ]
			A string object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[integer: ]
			An integer that represents the ascii value of a
			character that was read from \oparg{file}.
		\item[substring: ]
			A substring of \oparg{string} that contains data
			read from \oparg{file}.
		\item[boolean: ]
			If true, end of file reached during read.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Read from \oparg{file}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup `Hello\n' write
onyx:1> dup flushfile
onyx:1> dup 0 seek
onyx:1> dup 10 string read
onyx:3> pop 1 sprint
`Hello\n'
		\end{verbatim}
	\end{description}
\label{systemdict:readline}
\index{readline@\onyxop{}{readline}{}}
\item[{\onyxop{file}{readline}{string boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string that contains a line of text from \oparg{file}.
		\item[boolean: ]
			If true, end of file reached during read.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Read a line of text from \oparg{file}.  Lines are separated
		by ``{\bs}n'' or ``{\bs}r{\bs}n'', which is removed.  The
		last line in a file may not have a newline at the end.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup `Hello\n' write
onyx:1> dup `Goodbye\n' write
onyx:1> dup 0 seek
onyx:1> dup readline 1 sprint 1 sprint
false
`Hello'
onyx:1> dup readline 1 sprint 1 sprint
false
`Goodbye'
onyx:1> dup readline 1 sprint 1 sprint
true
`'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:readlink}
\index{readlink@\onyxop{}{readlink}{}}
\item[{\onyxop{linkname}{readlink}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[linkname: ]
			A string that represents the path of a symbolic link.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string that represents the link data associated with
			\oparg{linkname}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Get the data for the symbolic link at \oparg{linkname}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `bar' `foo' symlink
onyx:0> `foo' readlink 1 sprint
`bar'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:realtime}
\index{realtime@\onyxop{}{realtime}{}}
\item[{\onyxop{--}{realtime}{nsecs}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[nsecs: ]
			Number of nanoseconds since the epoch (midnight on 1
			January 1970).
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the number of nanoseconds since the epoch.
	\item[Example(s): ]\begin{verbatim}

onyx:0> realtime 1 sprint
993539837806479000
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:recv}
\index{recv@\onyxop{}{recv}{}}
\item[{\onyxop{sock string flags}{recv}{substring}}: ]
\item[{\onyxop{sock string}{recv}{substring}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[string: ]
			A string to use as a buffer for the message being
			received.
		\item[flags: ]
			An array of flag names.  The following flags are
			supported:
			\begin{description}%\item[]
			\item[\$MSG\_OOB]
			\item[\$MSG\_PEEK]
			\item[\$MSG\_WAITALL]
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[substring: ]
			A substring of \oparg{string} that contains message
			data.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_DGRAM socket
onyx:1> dup `localhost' 7777 bindsocket
onyx:1> dup true setnonblocking
onyx:1> dup 10 string recv
onyx:2> 1 sprint
`hello'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:regex}
\index{regex@\onyxop{}{regex}{}}
\item[{\onyxop{string flags}{regex}{regex}}: ]
\item[{\onyxop{string}{regex}{regex}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string that specifies a regular expression.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[flags: ]
			A dictionary of optional flags:
			\begin{description}%\item[]
			\item[\$c: ]
				Continue where previous match ended.  Don't
				update the offset to start the next match from
				unless this match is successful.  Defaults to
				false.
			\item[\$g: ]
				Continue where previous match ended.  If the
				match is unsuccessful, update the offset to
				start the next match from to the beginning of
				\oparg{input}.  Defaults to false.
			\item[\$i: ] Case insensitive.  Defaults to false.
			\item[\$m: ] Treat input as a multi-line string.
				Defaults to false.
			\item[\$s: ] Treat input as a single line, so that
				the dot metacharacter matches any character,
				including a newline.  Defaults to false.
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[regex: ]
			A regex object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{regexerror}{regexerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a regex object, according to \oparg{string} and
		\oparg{flags}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `pattern' regex 1 sprint
-regex-
onyx:0> `pattern' <$g true> regex 1 sprint
-regex-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:regsub}
\index{regsub@\onyxop{}{regsub}{}}
\item[{\onyxop{pattern template flags}{regsub}{regsub}}: ]
\item[{\onyxop{pattern template}{regsub}{regsub}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[pattern: ]
			A string that specifies a regular expression.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[template: ]
			A string that specifies a substitution template.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[flags: ]
			A dictionary of optional flags:
			\begin{description}%\item[]
			\item[\$g: ]
				Substitute all matches, if true, rather than
				just the first match.  Defaults to false.
			\item[\$i: ] Case insensitive.  Defaults to false.
			\item[\$m: ] Treat input as a multi-line string.
				Defaults to false.
			\item[\$s: ] Treat input as a single line, so that
				the dot metacharacter matches any character,
				including a newline.  Defaults to false.
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[regsub: ]
			A regsub object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{regexerror}{regexerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a regsub object, according to \oparg{pattern},
		\oparg{template}, and \oparg{flags}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `([a-z]+)' `<\1>' <$g true> regsub
onyx:1> 1 sprint
-regsub-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:rename}
\index{rename@\onyxop{}{rename}{}}
\item[{\onyxop{old new}{rename}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[old: ]
			A string object that represents a file path.
		\item[new: ]
			A string object that represents a file path.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{limitcheck}{limitcheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\end{description}
	\item[Description: ]
		Rename a file or directory from \oparg{old} to \oparg{new}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/tdir' 8@755 mkdir
onyx:0> `/tmp/tdir' `/tmp/ndir' rename
onyx:0> `/tmp/ndir' {1 sprint} dirforeach
`.'
`..'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:repeat}
\index{repeat@\onyxop{}{repeat}{}}
\item[{\onyxop{count proc}{repeat}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[count: ]
			Number of times to evaluate \oparg{proc} (non-negative).
		\item[proc: ]
			An object to evaluate.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{proc} \oparg{count} times.  This operator
		supports the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 {`hi' 1 sprint} repeat
`hi'
`hi'
`hi'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:require}
\index{require@\onyxop{}{require}{}}
\item[{\onyxop{file}{require}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A string that represents a module filename.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\end{description}
	\item[Description: ]
		Search for and evaluate an Onyx source file.  The file is
		searched for by catenating a prefix, a ``/'', and \oparg{file}
		to form a file path.  Prefixes are tried in the following order:
		\begin{enumerate}
			\item{The ordered elements of the
			\htmlref{rpath\_pre}{onyxdict:rpath_pre} array, which is
			defined in \htmlref{onyxdict}{sec:onyxdict}.}
			\item{If defined, the ordered elements of the
			ONYX\_RPATH environment variable, which is a
			colon-separated list.}
			\item{The ordered elements of the
			\htmlref{rpath\_post}{onyxdict:rpath_post} array, which
			is defined in \htmlref{onyxdict}{sec:onyxdict}.}
		\end{enumerate}
	\item[Example(s): ]\begin{verbatim}

onyx:0> `modgtk/modgtk_defs.nx' require
onyx:0>
	\end{verbatim}
	\end{description}
\label{systemdict:rmdir}
\index{rmdir@\onyxop{}{rmdir}{}}
\item[{\onyxop{path}{rmdir}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[path: ]
			A string object that represents a directory path.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Remove an empty directory.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/tdir' 8@755 mkdir
onyx:0> `/tmp/tdir' rmdir
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:roll}
\index{roll@\onyxop{}{roll}{}}
\item[{\onyxop{region count amount}{roll}{rolled}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[region: ]
			0 or more objects to be rolled.
		\item[count: ]
			Number of objects in \oparg{region}.
		\item[amount: ]
			Amount by which to roll.  If positive, roll
			upward.  If negative, roll downward.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[rolled: ]
			Rolled version of \oparg{region}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Roll the top \oparg{count} objects on ostack (not counting
		\oparg{count} and \oparg{amount}) by \oparg{amount} positions.
		A positive \oparg{amount} indicates an upward roll, whereas a
		negative \oparg{amount} indicates a downward roll.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 2 1 0
onyx:4> pstack
0
1
2
3
onyx:4> 3 1 roll
onyx:4> pstack
1
2
0
3
onyx:4> 3 -2 roll
onyx:4> pstack
2
0
1
3
onyx:4> 4 0 roll
onyx:4> pstack
2
0
1
3
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:round}
\index{round@\onyxop{}{round}{}}
\item[{\onyxop{a}{round}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Integer round of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Round \oparg{a} to the nearest integer and return the result.
	\item[Example(s): ]\begin{verbatim}

onyx:0> -1.51 round 1 sprint
-2
onyx:0> -1.49 round 1 sprint
-1
onyx:0> 0 round 1 sprint
0
onyx:0> 1.49 round 1 sprint
1
onyx:0> 1.51 round 1 sprint
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:rot}
\index{rot@\onyxop{}{rot}{}}
\item[{\onyxop{\dots amount}{rot}{\dots}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			One or more objects.
		\item[amount: ]
			Number of positions to rotate the stack upward.  A
			negative value causes downward rotation.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[\dots: ]
			One or more objects.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate the stack contents up \oparg{amount} positions.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1 2 3 4 5 2 rot pstack clear
3
2
1
5
4
onyx:0> 1 2 3 4 5 -2 rot pstack clear
2
1
5
4
3
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sadn}
\index{sadn@\onyxop{}{sadn}{}}
\item[{\onyxop{stack}{sadn}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate the contents of \oparg{stack} down one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3 4) dup sadn 1 sprint
(2 3 4 1)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:saup}
\index{saup@\onyxop{}{saup}{}}
\item[{\onyxop{stack}{saup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate the contents of \oparg{stack} up one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3 4) dup saup 1 sprint
(4 1 2 3)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sbdup}
\index{sbdup@\onyxop{}{sbdup}{}}
\item[{\onyxop{stack}{sbdup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Duplicate the bottom object on \oparg{stack} and push it onto
		\oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (2 1 0) dup sbdup pstack
(2 1 0 2)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sbpop}
\index{sbpop@\onyxop{}{sbpop}{}}
\item[{\onyxop{stack}{sbpop}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Pop \oparg{obj} off the bottom of \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3) dup sbpop pstack
1
(2 3)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:sbpush}
\index{sbpush@\onyxop{}{sbpush}{}}
\item[{\onyxop{stack obj}{sbpush}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Push \oparg{obj} onto the bottom of \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (0) dup 1 sbpush
onyx:1> pstack
(1 0)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sclear}
\index{sclear@\onyxop{}{sclear}{}}
\item[{\onyxop{stack}{sclear}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove all objects on \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3 4) dup sclear pstack
()
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:scleartomark}
\index{scleartomark@\onyxop{}{scleartomark}{}}
\item[{\onyxop{stack}{scleartomark}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unmatchedmark}{unmatchedmark}.]
		\end{description}
	\item[Description: ]
		Remove objects from \oparg{stack} down to and including the
		topmost mark.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 mark 1 0) dup scleartomark pstack
(3)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:scount}
\index{scount@\onyxop{}{scount}{}}
\item[{\onyxop{stack}{scount}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			The number of objects on \oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the number of objects on \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2) scount 1 sprint
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:scounttomark}
\index{scounttomark@\onyxop{}{scounttomark}{}}
\item[{\onyxop{stack}{scounttomark}{count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[count: ]
			The depth of the topmost mark on \oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unmatchedmark}{unmatchedmark}.]
		\end{description}
	\item[Description: ]
		Get the depth of the topmost mark on \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 mark 1 0) scounttomark 1 sprint
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sdn}
\index{sdn@\onyxop{}{sdn}{}}
\item[{\onyxop{stack}{sdn}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate the top three objects on \oparg{stack} down one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0) dup sdn pstack
(3 1 0 2)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sdup}
\index{sdup@\onyxop{}{sdup}{}}
\item[{\onyxop{stack}{sdup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Duplicate the top object on \oparg{stack} and push it onto
		\oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1) dup sdup 1 sprint
(1 1)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:seek}
\index{seek@\onyxop{}{seek}{}}
\item[{\onyxop{file offset}{seek}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[offset: ]
			Offset in bytes from the beginning of \oparg{file}
			to move the file position pointer to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Move the file position pointer for \oparg{file} to
		\oparg{offset}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup `Hello\n' write
onyx:1> dup 0 seek
onyx:1> readline pstack
false
`Hello'
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:self}
\index{self@\onyxop{}{self}{}}
\item[{\onyxop{--}{self}{thread}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object that corresponds to the running thread.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a thread object for the running thread.
	\item[Example(s): ]\begin{verbatim}

onyx:0> self 1 sprint
-thread-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:send}
\index{send@\onyxop{}{send}{}}
\item[{\onyxop{sock mesg flags}{send}{nsend}}: ]
\item[{\onyxop{sock mesg}{send}{nsend}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[mesg: ]
			A message string.
		\item[flags: ]
			An array of flag names.  The following flags are
			supported:
			\begin{description}%\item[]
			\item[\$MSG\_OOB]
			\item[\$MSG\_PEEK]
			\item[\$MSG\_WAITALL]
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[nsend: ]
			Number of bytes of \oparg{mesg} actually sent.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Send a message.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_DGRAM socket
onyx:1> dup `localhost' 7777 connect
onyx:1> dup `hello' send
onyx:2> 1 sprint
5
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:serviceport}
\index{serviceport@\onyxop{}{serviceport}{}}
\item[{\onyxop{service}{serviceport}{port}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[service: ]
			A string that represents a network service name.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[port: ]
			The port number corresponding to \oparg{service}, or 0
			if the service is unknown.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
	\item[Example(s): ]\begin{verbatim}

onyx:0> `ftp' serviceport 1 sprint
21
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setclassname}
\index{setclassname@\onyxop{}{setclassname}{}}
\item[{\onyxop{class name/null}{setclassname}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\item[name/null: ]
			A name or null object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set \oparg{class}'s name.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class dup $foo setclassname
onyx:1> classname 1 sprint
$foo
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setdata}
\index{setdata@\onyxop{}{setdata}{}}
\item[{\onyxop{class/instance dict/null}{setdata}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class/instance: ]
			A class or instance object.
		\item[dict/null: ]
			A dict or null object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the data associated with \oparg{class} or \oparg{instance}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class dup <$foo `foo'> setdata
onyx:1> data 1 sprint
<$foo `foo'>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setegid}
\index{setegid@\onyxop{}{setegid}{}}
\item[{\onyxop{gid}{setegid}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[gid: ]
			A group ID.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, success, otherwise failure.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the process's effective group ID to \oparg{gid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1001 setegid 1 sprint
false
onyx:0> 0 setegid 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setenv}
\index{setenv@\onyxop{}{setenv}{}}
\item[{\onyxop{key val}{setenv}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[key: ]
			A name object.
		\item[val: ]
			A value to associate with \oparg{key}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set an environment variable named \oparg{key} and associate
		\oparg{val} with it.  If \oparg{val} is not a string, it is
		converted to a string using the
		\htmlref{\onyxop{}{cvs}{}}{systemdict:cvs} operator before the
		environment variable is set.  A corresponding entry is also
		created in the envdict dictionary.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo `foo' setenv
onyx:0> envdict $foo known 1 sprint
true
onyx:0> envdict $foo get 1 sprint
`foo'
onyx:0> $foo unsetenv
onyx:0> envdict $foo known 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:seteuid}
\index{seteuid@\onyxop{}{seteuid}{}}
\item[{\onyxop{uid}{seteuid}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[uid: ]
			A user ID.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, success, otherwise failure.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the process's effective user ID to \oparg{uid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1001 seteuid 1 sprint
false
onyx:0> 0 seteuid 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setgid}
\index{setgid@\onyxop{}{setgid}{}}
\item[{\onyxop{gid}{setgid}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[gid: ]
			A group ID.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, success, otherwise failure.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the process's group ID to \oparg{gid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1001 setgid 1 sprint
false
onyx:0> 0 setgid 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setgmaxestack}
\index{setgmaxestack@\onyxop{}{setgmaxestack}{}}
\item[{\onyxop{count}{setgmaxestack}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[count: ]
			Default maximum allowable estack depth.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the default maximum allowable estack depth to \oparg{count}.
		This value is used when creating new threads.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 128 setgmaxestack
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setgstderr}
\index{setgstderr@\onyxop{}{setgstderr}{}}
\item[{\onyxop{file}{setgstderr}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file to set the global stderr to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the global stderr to \oparg{file}.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/stderr' `w' open dup 0 setiobuf setgstderr
onyx:0> () {stderr `Some text\n' write} thread join
onyx:0> `/tmp/stderr' `r' open readline pop 1 sprint
`Some text'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setgstdin}
\index{setgstdin@\onyxop{}{setgstdin}{}}
\item[{\onyxop{file}{setgstdin}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file to set the global stdin to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the global stdin to \oparg{file}.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]
		Under normal interactive operation, stdin is pushed onto estack
		during interpreter initialization and evaluated until EOF is
		reached.  Therefore, changing stdin has no effect on the file
		descriptor already on estack.  The following example recursively
		evaluates stdin after redefining it.
\begin{verbatim}

lawine:~> cat /tmp/stdin
1 2 3 pstack
lawine:~> onyx
onyx:0> `/tmp/stdin' `r' open cvx setgstdin
onyx:0> () {stdin eval} thread join
3
2
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setgstdout}
\index{setgstdout@\onyxop{}{setgstdout}{}}
\item[{\onyxop{file}{setgstdout}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file to set the global stdout to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the global stdout to \oparg{file}.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]
		In the following example, the prompt continues to be printed,
		even though stdout has been redefined, because the prompt module
		was initialized to print to file descriptor 1.  This
		demonstrates the only known exception in the stock Onyx
		interpreter where redefining stdout will not redirect output.
\begin{verbatim}

onyx:0> `/tmp/stdout' `w' open dup 0 setiobuf setgstdout
onyx:0> () {`Some text\n' print} thread join
onyx:0> `/tmp/stdout' `r' open readline pop 1 sprint
`Some text'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setgtailopt}
\index{setgtailopt@\onyxop{}{setgtailopt}{}}
\item[{\onyxop{boolean}{setgtailopt}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If true, enable tail call optimization by default for
			new threads.  Otherwise, do not enable tail call
			optimization by default for new threads.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set whether to enable tail call optimization for new threads.
	\item[Example(s): ]\begin{verbatim}

onyx:0> false setgtailopt
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setiobuf}
\index{setiobuf@\onyxop{}{setiobuf}{}}
\item[{\onyxop{file count}{setiobuf}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[count: ]
			The size in bytes to set the I/O buffer associated with
			\oparg{file} to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the size of the I/O buffer associated with \oparg{file}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stdout iobuf 1 sprint
512
onyx:0> stdout 0 setiobuf
onyx:0> stdout iobuf 1 sprint
0
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setisa}
\index{setisa@\onyxop{}{setisa}{}}
\item[{\onyxop{instance class/null}{setisa}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[instance: ]
			An instance object.
		\item[class/null: ]
			A class or null object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the class associated with \oparg{instance}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> instance dup vclass setisa
onyx:1> isa classname 1 sprint
$vclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setlocking}
\index{setlocking@\onyxop{}{setlocking}{}}
\item[{\onyxop{boolean}{setlocking}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			A boolean to set the implicit locking mode to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the current implicit locking mode.  See
		Section~\ref{sec:onyx_implicit_synchronization} for implicit
		synchronization details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> currentlocking 1 sprint
false
onyx:0> true setlocking
onyx:0> currentlocking 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setmaxestack}
\index{setmaxestack@\onyxop{}{setmaxestack}{}}
\item[{\onyxop{count}{setmaxestack}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[count: ]
			Maximum allowable estack depth.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the maximum allowable estack depth to \oparg{count}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 128 setmaxestack
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setmethods}
\index{setmethods@\onyxop{}{setmethods}{}}
\item[{\onyxop{class dict/null}{setmethods}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\item[dict/null: ]
			A dict or null object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the methods associated with \oparg{class}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class dup <$foo `foo'> setmethods
onyx:1> methods 1 sprint
<$foo `foo'>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setnonblocking}
\index{setnonblocking@\onyxop{}{setnonblocking}{}}
\item[{\onyxop{file boolean}{setnonblocking}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[boolean: ]
			Non-blocking mode to set \oparg{file} to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set non-blocking mode for \oparg{file} to \oparg{boolean}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open
onyx:1> dup nonblocking 1 sprint
false
onyx:1> dup true setnonblocking
onyx:1> dup nonblocking 1 sprint
true
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:setpgid}
\index{setpgid@\onyxop{}{setpgid}{}}
\item[{\onyxop{pid pgid}{setpgid}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process ID, or 0 (same as specifying the calling
			process's ID).
		\item[pgid: ] Process group ID.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{limitcheck}{limitcheck}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
	\item[Example(s): ]\begin{verbatim}

onyx:0> pid pid setpgid
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setsid}
\index{setsid@\onyxop{}{setsid}{}}
\item[{\onyxop{--}{setsid}{sid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[sid: ] Session ID.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a new session.
	\item[Example(s): ]\begin{verbatim}

onyx:0> setsid
Error $invalidaccess
ostack: ()
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..2):
0:      --setsid--
1:      -file-
2:      --start--
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:setsockopt}
\index{setsockopt@\onyxop{}{setsockopt}{}}
\item[{\onyxop{sock level optname optval}{setsockopt}{--}}: ]
\item[{\onyxop{sock optname optval}{setsockopt}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[level: ]
			Level at which to set the socket option.  If not
			specified, \$SOL\_SOCKET is used.
		\item[optname: ]
			Name of option to set the value of.  The following
			option names are supported:
			\begin{description}%\item[]
			\item[\$SO\_DEBUG]
			\item[\$SO\_REUSEADDR]
			\item[\$SO\_REUSEPORT]
			\item[\$SO\_KEEPALIVE]
			\item[\$SO\_DONTROUTE]
			\item[\$SO\_BROADCAST]
			\item[\$SO\_OOBINLINE]
			\item[\$SO\_SNDBUF]
			\item[\$SO\_RCVBUF]
			\item[\$SO\_SNDLOWAT]
			\item[\$SO\_RCVLOWAT]
			\item[\$SO\_TYPE]
			\item[\$SO\_ERROR: ]
				\oparg{optval} is an integer.
			\item[\$SO\_LINGER: ]
				\oparg{optval} is a dictionary, and the
				following entries are defined:
				\begin{description}%\item[]
				\item[\$on: ]
					Boolean.
				\item[\$time: ]
					Linger time in seconds.
				\end{description}
			\item[\$SO\_SNDTIMEO]
			\item[\$SO\_RCVTIMEO: ]
				\oparg{optval} is an integer, in nanoseconds.
			\end{description}
		\item[optval: ]
			Value to associate with \oparg{optname}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Set a socket option.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup $SO_OOBINLINE sockopt 1 sprint
0
onyx:1> dup $SO_OOBINLINE 1 setsockopt
onyx:1> dup $SO_OOBINLINE sockopt 1 sprint
1
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:setstderr}
\index{setstderr@\onyxop{}{setstderr}{}}
\item[{\onyxop{file}{setstderr}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file to set the calling thread's stderr to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the thread's stderr to \oparg{file}.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/stderr' `w' open dup 0 setiobuf setstderr
onyx:0> stderr `Some text\n' write
onyx:0> `/tmp/stderr' `r' open readline pop 1 sprint
`Some text'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setstdin}
\index{setstdin@\onyxop{}{setstdin}{}}
\item[{\onyxop{file}{setstdin}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file to set the calling thread's stdin to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the thread's stdin to \oparg{file}.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]
		Under normal interactive operation, stdin is pushed onto estack
		during interpreter initialization and evaluated until EOF is
		reached.  Therefore, changing stdin has no effect on the file
		descriptor already on estack.  The following example recursively
		evaluates stdin after redefining it.
\begin{verbatim}

lawine:~> cat /tmp/stdin
1 2 3 pstack
lawine:~> onyx
onyx:0> `/tmp/stdin' `r' open cvx setstdin
onyx:0> stdin eval
3
2
1
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:setstdout}
\index{setstdout@\onyxop{}{setstdout}{}}
\item[{\onyxop{file}{setstdout}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file to set the calling thread's stdout to.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the thread's stdout to \oparg{file}.  See
		Section~\ref{sec:onyx_standard_io} for standard I/O details.
	\item[Example(s): ]
		In the following example, the prompt continues to be printed,
		even though stdout has been redefined, because the prompt module
		was initialized to print to file descriptor 1.  This
		demonstrates the only known exception in the stock Onyx
		interpreter where redefining stdout will not redirect output.
\begin{verbatim}

onyx:0> `/tmp/stdout' `w' open dup 0 setiobuf setstdout
onyx:0> `Some text\n' print
onyx:0> gstdout setstdout
onyx:0> `/tmp/stdout' `r' open readline pop 1 sprint
`Some text'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setsuper}
\index{setsuper@\onyxop{}{setsuper}{}}
\item[{\onyxop{class super/null}{setsuper}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\item[super/null: ]
			A class or null object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set \oparg{class}'s superclass.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class dup vclass setsuper
onyx:1> super classname 1 sprint
$vclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:settailopt}
\index{settailopt@\onyxop{}{settailopt}{}}
\item[{\onyxop{boolean}{settailopt}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If true, enable tail call optimization for this thread.
			Otherwise, disable tail call optimization for this
			thread.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
	\item[Example(s): ]\begin{verbatim}

onyx:0> $bar {estack 2 sprint} def
onyx:0> $foo {bar} def
onyx:0> foo
(--start-- -file- {estack 2 sprint} --estack--)
onyx:0> false settailopt
onyx:0> foo
(--start-- -file- {bar} {estack 2 sprint} --estack--)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:setuid}
\index{setuid@\onyxop{}{setuid}{}}
\item[{\onyxop{uid}{setuid}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[uid: ]
			A user ID.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, success, otherwise failure.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the process's user ID to \oparg{uid}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 1001 setuid 1 sprint
false
onyx:0> 0 setuid 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sexch}
\index{sexch@\onyxop{}{sexch}{}}
\item[{\onyxop{stack}{sexch}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Exchange the top two objects on \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3) dup sexch pstack
(1 3 2)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:shift}
\index{shift@\onyxop{}{shift}{}}
\item[{\onyxop{--}{shift}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer.
		\item[shift: ]
			An integer that represents a bitwise shift amount.
			Negative means right shift, and positive means left
			shift.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			\oparg{a} shifted by \oparg{shift} bits.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Shift an integer bitwise.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 1 shift 1 sprint
8
onyx:0> 4 -1 shift 1 sprint
2
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sibdup}
\index{sibdup@\onyxop{}{sibdup}{}}
\item[{\onyxop{stack index}{sibdup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[index: ]
			Offset from bottom of \oparg{stack}, counting from 0, of
			the object to duplicate.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the object on \oparg{stack} that is at
		offset \oparg{index} from the bottom of \oparg{stack} and push
		it onto \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0) dup 2 sibdup pstack
(3 2 1 0 1)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sibpop}
\index{sibpop@\onyxop{}{sibpop}{}}
\item[{\onyxop{stack index}{sibpop}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[index: ]
			Offset from bottom of \oparg{stack}, counting from 0, of
			the object to remove from \oparg{stack}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object removed from \oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the \oparg{obj} from \oparg{stack} that is at offset
		\oparg{index} from the bottom of \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (0 1 2 3) dup 2 sibpop pstack
2
(0 1 3)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:sidup}
\index{sidup@\onyxop{}{sidup}{}}
\item[{\onyxop{stack index}{sidup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[index: ]
			Depth (count starts at 0) of the object to duplicate in
			\oparg{stack}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the object on \oparg{stack} at depth
		\oparg{index} and push it onto \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0) dup 2 sidup
onyx:1> 1 sprint
(3 2 1 0 2)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sigmask}
\index{sigmask@\onyxop{}{sigmask}{}}
\item[{\onyxop{\$SIG\_GETMASK oset}{sigmask}{oset}}: ]
\item[{\onyxop{how set}{sigmask}{--}}: ]
\item[{\onyxop{how set oset}{sigmask}{oset}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[how: ] A name object:
			\begin{description}\item[]
			\item[\$SIG\_BLOCK: ]
				Mask the union of the old mask set and the
				signals in \oparg{set} whose values are set to
				true.
			\item[\$SIG\_UNBLOCK: ]
				Unmask the signals in \oparg{set} whose values
				are set to true.
			\item[\$SIG\_GETMASK: ]
				Get the current signal mask.
			\item[\$SIG\_SETMASK: ]
				Set the signal mask to the signals in
				\oparg{set} whose values are set to true.
			\end{description}
		\item[set: ]
			A dictionary of signal name and/or integers keys, with
			associated true/false values.  A value of true indicates
			set membership.  The recognized names are:
			\begin{itemize}
			\item{\$SIGABRT}
			\item{\$SIGALRM}
			\item{\$SIGBUS}
			\item{\$SIGCHLD}
			\item{\$SIGCONT}
			\item{\$SIGFPE}
			\item{\$SIGHUP}
			\item{\$SIGILL}
			\item{\$SIGINT}
			\item{\$SIGKILL}
			\item{\$SIGPIPE}
			\item{\$SIGQUIT}
			\item{\$SIGSEGV}
			\item{\$SIGSTOP}
			\item{\$SIGTERM}
			\item{\$SIGTSTP}
			\item{\$SIGTTIN}
			\item{\$SIGTTOU}
			\item{\$SIGUSR1}
			\item{\$SIGUSR2}
			\item{\$SIGPOLL (may not be present)}
			\item{\$SIGPROF}
			\item{\$SIGSYS}
			\item{\$SIGTRAP}
			\item{\$SIGURG}
			\item{\$SIGVTALRM (may not be present)}
			\item{\$SIGXCPU}
			\item{\$SIGXFSZ}
			\end{itemize}
		\item[oset: ]
			A dictionary of signal name keys, with associated
			true/false values.  This dictionary contains the signal
			mask as it was prior to execution of this operator.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[oset: ]
			The same dictionary as was passed in as \oparg{oset}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get or set the calling thread's current signal mask.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $SIG_GETMASK <> sigmask 1 sprint
<$SIGHUP true $SIGINT true $SIGQUIT true $SIGTERM true>
onyx:0> $SIG_BLOCK <$SIGPIPE true> <> sigmask 1 sprint
<$SIGHUP true $SIGINT true $SIGQUIT true $SIGTERM true>
onyx:0> $SIG_GETMASK <> sigmask 1 sprint
<$SIGHUP true $SIGINT true $SIGPIPE true $SIGQUIT true $SIGTERM true>
onyx:0> $SIG_UNBLOCK <$SIGPIPE true> <> sigmask 1 sprint
<$SIGHUP true $SIGINT true $SIGPIPE true $SIGQUIT true $SIGTERM true>
onyx:0> $SIG_GETMASK <> sigmask 1 sprint
<$SIGHUP true $SIGINT true $SIGQUIT true $SIGTERM true>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:signal}
\index{signal@\onyxop{}{signal}{}}
\item[{\onyxop{condition}{signal}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[condition: ]
			A condition object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Signal a thread that is waiting on \oparg{condition}.  If there
		are no waiters, this operator has no effect.
	\item[Example(s): ]\begin{verbatim}

onyx:0> condition mutex dup lock ostack
onyx:3> {dup lock exch signal unlock}
onyx:4> thread 3 1 roll
onyx:3> dup 3 1 roll
onyx:4> wait unlock join
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sigpending}
\index{sigpending@\onyxop{}{sigpending}{}}
\item[{\onyxop{set}{sigpending}{set}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[set: ] A dictionary.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[set: ]
			The same dictionary as the input \oparg{set}.  A
			dictionary of signal name keys, with associated true
			values.  A value of true indicates set membership.  The
			supported names are:
			\begin{itemize}
			\item{\$SIGABRT}
			\item{\$SIGALRM}
			\item{\$SIGBUS}
			\item{\$SIGCHLD}
			\item{\$SIGCONT}
			\item{\$SIGFPE}
			\item{\$SIGHUP}
			\item{\$SIGILL}
			\item{\$SIGINT}
			\item{\$SIGKILL}
			\item{\$SIGPIPE}
			\item{\$SIGQUIT}
			\item{\$SIGSEGV}
			\item{\$SIGSTOP}
			\item{\$SIGTERM}
			\item{\$SIGTSTP}
			\item{\$SIGTTIN}
			\item{\$SIGTTOU}
			\item{\$SIGUSR1}
			\item{\$SIGUSR2}
			\item{\$SIGPOLL (may not be present)}
			\item{\$SIGPROF}
			\item{\$SIGSYS}
			\item{\$SIGTRAP}
			\item{\$SIGURG}
			\item{\$SIGVTALRM (may not be present)}
			\item{\$SIGXCPU}
			\item{\$SIGXFSZ}
			\end{itemize}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get pending signals.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <> sigpending 1 sprint
<>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sigsuspend}
\index{sigsuspend@\onyxop{}{sigsuspend}{}}
\item[{\onyxop{set}{sigsuspend}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[set: ]
			A dictionary of signal name and/or integers keys, with
			associated true/false values.  A value of true indicates
			set membership.  The recognized names are:
			\begin{itemize}
			\item{\$SIGABRT}
			\item{\$SIGALRM}
			\item{\$SIGBUS}
			\item{\$SIGCHLD}
			\item{\$SIGCONT}
			\item{\$SIGFPE}
			\item{\$SIGHUP}
			\item{\$SIGILL}
			\item{\$SIGINT}
			\item{\$SIGKILL}
			\item{\$SIGPIPE}
			\item{\$SIGQUIT}
			\item{\$SIGSEGV}
			\item{\$SIGSTOP}
			\item{\$SIGTERM}
			\item{\$SIGTSTP}
			\item{\$SIGTTIN}
			\item{\$SIGTTOU}
			\item{\$SIGUSR1}
			\item{\$SIGUSR2}
			\item{\$SIGPOLL (may not be present)}
			\item{\$SIGPROF}
			\item{\$SIGSYS}
			\item{\$SIGTRAP}
			\item{\$SIGURG}
			\item{\$SIGVTALRM (may not be present)}
			\item{\$SIGXCPU}
			\item{\$SIGXFSZ}
			\end{itemize}
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Suspend the calling thread until one of the signals in
		\oparg{set} is caught.
	\item[Example(s): ]\begin{verbatim}

onyx:0> <> sigsuspend
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sigwait}
\index{sigwait@\onyxop{}{sigwait}{}}
\item[{\onyxop{set}{sigwait}{sig}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[set: ]
			A dictionary of signal name and/or integers keys, with
			associated true/false values.  A value of true indicates
			set membership.  The recognized names are:
			\begin{itemize}
			\item{\$SIGABRT}
			\item{\$SIGALRM}
			\item{\$SIGBUS}
			\item{\$SIGCHLD}
			\item{\$SIGCONT}
			\item{\$SIGFPE}
			\item{\$SIGHUP}
			\item{\$SIGILL}
			\item{\$SIGINT}
			\item{\$SIGKILL}
			\item{\$SIGPIPE}
			\item{\$SIGQUIT}
			\item{\$SIGSEGV}
			\item{\$SIGSTOP}
			\item{\$SIGTERM}
			\item{\$SIGTSTP}
			\item{\$SIGTTIN}
			\item{\$SIGTTOU}
			\item{\$SIGUSR1}
			\item{\$SIGUSR2}
			\item{\$SIGPOLL (may not be present)}
			\item{\$SIGPROF}
			\item{\$SIGSYS}
			\item{\$SIGTRAP}
			\item{\$SIGURG}
			\item{\$SIGVTALRM (may not be present)}
			\item{\$SIGXCPU}
			\item{\$SIGXFSZ}
			\end{itemize}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[sig: ]
			One of the signal names that was specified in
			\oparg{set}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Wait for one of the signals in \oparg{set}, and return the name
		of the signal that was caught.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $SIG_BLOCK <$SIGXCPU true> sigmask
onyx:0> <$SIGXCPU true> sigwait
onyx:1> 1 sprint
$SIGXCPU
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sin}
\index{sin@\onyxop{}{sin}{}}
\item[{\onyxop{a}{sin}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Sine of \oparg{a} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the sine of \oparg{a} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 sin 1 sprint
0.000000e+00
onyx:0> 1.570796 sin 1 sprint
1.000000e+00
onyx:0> 0.7853982 sin 1 sprint
7.071068e-01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sinh}
\index{sinh@\onyxop{}{sinh}{}}
\item[{\onyxop{a}{sinh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Hyperbolic sine of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the hyperbolic sine of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 sinh 1 sprint
1.001787e+01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sipop}
\index{sipop@\onyxop{}{sipop}{}}
\item[{\onyxop{stack index}{sipop}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[index: ]
			Offset from top of \oparg{stack}, counting from 0, of
			the object to remove from \oparg{stack}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object removed from \oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the \oparg{obj} at \oparg{index} from \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0) dup 2 sipop pstack
2
(3 1 0)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:snbpop}
\index{snbpop@\onyxop{}{snbpop}{}}
\item[{\onyxop{stack count}{snbpop}{array}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[count: ]
			Number of objects to pop off the bottom of
			\oparg{stack}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array of objects popped off the bottom of
			\oparg{stack}, with the same object ordering as when on
			\oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Pop \oparg{count} objects off the bottom of \oparg{stack} and
		put them into an array.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3 4) dup 2 snbpop pstack
[1 2]
(3 4)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:sndn}
\index{sndn@\onyxop{}{sndn}{}}
\item[{\onyxop{stack count}{sndn}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[count: ]
			Number of objects on \oparg{stack} to rotate down one
			position.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate \oparg{count} objects on \oparg{stack} down one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (5 4 3 2 1 0) dup 4 sndn pstack
(5 4 2 1 0 3)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sndup}
\index{sndup@\onyxop{}{sndup}{}}
\item[{\onyxop{stack count}{sndup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[count: ]
			Number of objects on \oparg{stack} to duplicate.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create duplicates of the top \oparg{count} objects on
		\oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0) dup 2 sndup pstack
(3 2 1 0 1 0)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:snip}
\index{snip@\onyxop{}{snip}{}}
\item[{\onyxop{stack}{snip}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The object that was the second to top object on
			\oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Remove the second to top object from \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (2 1 0) dup snip pstack
1
(2 0)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:snpop}
\index{snpop@\onyxop{}{snpop}{}}
\item[{\onyxop{stack count}{snpop}{array}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[count: ]
			Number of objects to pop off of \oparg{stack}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array of objects popped off of \oparg{stack}, with
			the same object ordering as when on \oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Pop \oparg{count} objects off of \oparg{stack} and put them into
		an array.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3 4) dup 2 snpop pstack
[3 4]
(1 2)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:snup}
\index{snup@\onyxop{}{snup}{}}
\item[{\onyxop{stack count}{snup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[count: ]
			Number of objects on \oparg{stack} to rotate up one
			position.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate \oparg{count} objects on \oparg{stack} up one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (5 4 3 2 1 0) dup 4 snup pstack
(5 4 0 3 2 1)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:socket}
\index{socket@\onyxop{}{socket}{}}
\item[{\onyxop{family type proto}{socket}{sock}}: ]
\item[{\onyxop{family type}{socket}{sock}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[family: ]
			The name of a socket address family, either \$AF\_INET
			or \$AF\_LOCAL.
		\item[type: ]
			The name of a socket type, either \$SOCK\_STREAM or
			\$SOCK\_DGRAM.
		\item[proto: ]
			The name of a socket protocol.  This argument is not
			useful, given the current limited choice of address
			families.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a socket.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> $AF_LOCAL $SOCK_DGRAM socket
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:socketpair}
\index{socketpair@\onyxop{}{socketpair}{}}
\item[{\onyxop{family type proto}{socketpair}{sock sock}}: ]
\item[{\onyxop{family type}{socketpair}{sock sock}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[family: ]
			The name of a socket address family, either \$AF\_INET
			or \$AF\_LOCAL.
		\item[type: ]
			The name of a socket type, either \$SOCK\_STREAM or
			\$SOCK\_DGRAM.
		\item[proto: ]
			The name of a socket protocol.  This argument is not
			useful, given the current limited choice of address
			families.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A connected socket.  There are no functional differences
			between the two sockets that are returned.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{invalidaccess}{invalidaccess}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a pair of sockets that are connected to each other.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_LOCAL $SOCK_STREAM socketpair
onyx:2> pstack
-file-
-file-
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:sockname}
\index{sockname@\onyxop{}{sockname}{}}
\item[{\onyxop{sock}{sockname}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary of information about \oparg{sock}.
			Depending on the socket family, the following entries
			may exist:
			\begin{description}%\item[]
			\item[family: ] Socket family.
			\item[address: ] IPv4 address.
			\item[port: ] IPv4 port.
			\item[path: ] Unix-domain socket path.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{neterror}{neterror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Get information about \oparg{sock}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup `localhost' bindsocket
onyx:1> dup sockname 1 sprint
<$family $AF_INET $address 2130706433 $port 33745>
onyx:1> close
onyx:0> $AF_LOCAL $SOCK_STREAM socket
onyx:1> dup `/tmp/socket' bindsocket
onyx:1> dup sockname 1 sprint
<$family $AF_LOCAL $path `/tmp/socket'>
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sockopt}
\index{sockopt@\onyxop{}{sockopt}{}}
\item[{\onyxop{sock level optname}{sockopt}{optval}}: ]
\item[{\onyxop{sock optname}{sockopt}{optval}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[sock: ]
			A socket.
		\item[level: ]
			Level at which to get the socket option.  If not
			specified, \$SOL\_SOCKET is used.
		\item[optname: ]
			Name of option to get the value of.  The following
			option names are supported:
			\begin{description}%\item[]
			\item[\$SO\_DEBUG]
			\item[\$SO\_REUSEADDR]
			\item[\$SO\_REUSEPORT]
			\item[\$SO\_KEEPALIVE]
			\item[\$SO\_DONTROUTE]
			\item[\$SO\_BROADCAST]
			\item[\$SO\_OOBINLINE]
			\item[\$SO\_SNDBUF]
			\item[\$SO\_RCVBUF]
			\item[\$SO\_SNDLOWAT]
			\item[\$SO\_RCVLOWAT]
			\item[\$SO\_TYPE]
			\item[\$SO\_ERROR: ]
				\oparg{optval} is an integer.
			\item[\$SO\_LINGER: ]
				\oparg{optval} is a dictionary, and the
				following entries are defined:
				\begin{description}%\item
				\item[\$on: ]
					Boolean.
				\item[\$time: ]
					Linger time in seconds.
				\end{description}
			\item[\$SO\_SNDTIMEO]
			\item[\$SO\_RCVTIMEO: ]
				\oparg{optval} is an integer, in nanoseconds.
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[optval: ]
			Value associated with \oparg{optname}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{argcheck}{argcheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Get a socket option.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $AF_INET $SOCK_STREAM socket
onyx:1> dup $SO_SNDBUF sockopt 1 sprint
16384
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sover}
\index{sover@\onyxop{}{sover}{}}
\item[{\onyxop{stack}{sover}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the second object on \oparg{stack} and
		push it onto \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (2 1 0) dup sover pstack
(2 1 0 1)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:split}
\index{split@\onyxop{}{split}{}}
\item[{\onyxop{input pattern flags limit}{split}{array}}: ]
\item[{\onyxop{input pattern flags}{split}{array}}: ]
\item[{\onyxop{input pattern limit}{split}{array}}: ]
\item[{\onyxop{input pattern}{split}{array}}: ]
\item[{\onyxop{input regex limit}{split}{array}}: ]
\item[{\onyxop{input regex}{split}{array}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[input: ]
			An input string to find matches in.
		\item[pattern: ]
			A string that specifies a regular expression.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[flags: ]
			A dictionary of optional flags:
			\begin{description}%\item[]
			\item[\$i: ] Case insensitive.  Defaults to false.
			\item[\$m: ] Treat input as a multi-line string.
				Defaults to false.
			\item[\$s: ] Treat input as a single line, so that
				the dot metacharacter matches any character,
				including a newline.  Defaults to false.
			\end{description}
		\item[regex: ]
			A regex object.
		\item[limit: ]
			Split \oparg{input} into no more than \oparg{limit}
			substrings.  0 is treated as infinity.  Defaults to 0.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[array: ]
			An array of substrings containing the text between
			pattern matches.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{regexerror}{regexerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create an array of substrings from \oparg{input} that are
		separated by portions of \oparg{input} that match a regular
		expression.

		If there are capturing subpatterns in the regular expression,
		also create substrings for those capturing subpatterns and
		insert them into the substring array.

		As a special case, if the regular expression matches the empty
		string, split a single character.  This avoids an infinite
		loop.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a:b:c' `:' split 1 sprint
[`a' `b' `c']
onyx:0> `a:b:c' `:' 2 split 1 sprint
[`a' `b:c']
onyx:0> `a:b:c' `(:)' split 1 sprint
[`a' `:' `b' `:' `c']
onyx:0> `a:b:c' `' split 1 sprint
[`a' `:' `b' `:' `c']
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:spop}
\index{spop@\onyxop{}{spop}{}}
\item[{\onyxop{stack}{spop}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The object that was popped off of \oparg{stack}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Pop an object off of \oparg{stack} and push it onto ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2) dup spop
onyx:2> pstack
2
(1)
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:sprint}
\index{sprint@\onyxop{}{sprint}{}}
\item[{\onyxop{obj depth}{sprint}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object to print syntactically.
		\item[depth: ]
			Maximum recursion depth.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Syntactically print \oparg{obj}.  See
		Section~\ref{sec:sprintsdict} for printing details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 [2 3] 4]
onyx:1> dup 0 sprint
-array-
onyx:1> dup 1 sprint
[1 -array- 4]
onyx:1> dup 2 sprint
[1 [2 3] 4]
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sprints}
\index{sprints@\onyxop{}{sprints}{}}
\item[{\onyxop{obj depth}{sprints}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object to print syntactically.
		\item[depth: ]
			Maximum recursion depth.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A syntactical string representation of \oparg{obj}.
			See Section~\ref{sec:sprintsdict} for printing details.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a syntactical string representation of \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [1 [2 3] 4]
onyx:1> dup 0 sprints print `\n' print flush
-array-
onyx:1> dup 1 sprints print `\n' print flush
[1 -array- 4]
onyx:1> dup 2 sprints print `\n' print flush
[1 [2 3] 4]
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sprintsdict}
\index{sprintsdict@\onyxop{}{sprintsdict}{}}
\item[{\onyxop{--}{sprintsdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get sprintsdict.  See Section~\ref{sec:sprintsdict} for details
		on sprintsdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> sprintsdict 0 sprint
-dict-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:spush}
\index{spush@\onyxop{}{spush}{}}
\item[{\onyxop{stack obj}{spush}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Push \oparg{obj} onto \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (0) dup 1 spush
onyx:1> pstack
(0 1)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sqrt}
\index{sqrt@\onyxop{}{sqrt}{}}
\item[{\onyxop{a}{sqrt}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			A non-negative integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Square root of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the square root of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 4 sqrt 1 sprint
2.000000e+00
onyx:0> 2.0 sqrt 1 sprint
1.414214e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:srand}
\index{srand@\onyxop{}{srand}{}}
\item[{\onyxop{seed}{srand}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[seed: ]
			A non-negative integer.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Seed the pseudo-random number generator with \oparg{seed}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 5 srand
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:sroll}
\index{sroll@\onyxop{}{sroll}{}}
\item[{\onyxop{stack count amount}{sroll}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\item[count: ]
			Number of objects to roll in \oparg{stack}.
		\item[amount: ]
			Amount by which to roll.  If positive, roll
			upward.  If negative, roll downward.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Roll the top \oparg{count} objects on \oparg{stack} by
		\oparg{amount} positions.  A positive \oparg{amount}
		indicates an upward roll, whereas a negative \oparg{amount}
		indicates a downward roll.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0)
onyx:1> dup 3 1 sroll pstack
(3 0 2 1)
onyx:1> dup 3 -2 sroll pstack
(3 1 0 2)
onyx:1> dup 4 0 sroll pstack
(3 1 0 2)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:srot}
\index{srot@\onyxop{}{srot}{}}
\item[{\onyxop{stack amount}{srot}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			One or more objects.
		\item[amount: ]
			Number of positions to rotate \oparg{stack} upward.  A
			negative value causes downward rotation.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate \oparg{stack} up \oparg{count} positions.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2 3 4 5) dup 2 srot 1 sprint
(4 5 1 2 3)
onyx:0> (1 2 3 4 5) dup -2 srot 1 sprint
(3 4 5 1 2)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:stack}
\index{stack@\onyxop{}{stack}{}}
\item[{\onyxop{--}{stack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			An empty stack object.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Create a new stack object and push it onto ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stack
onyx:1> pstack
()
		\end{verbatim}
	\end{description}
\label{systemdict:start}
\index{start@\onyxop{}{start}{}}
\item[{\onyxop{obj}{start}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{obj}.  This operator provides a context that
		silently terminates execution stack unwinding due to the
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit},
		\htmlref{\onyxop{}{quit}{}}{systemdict:quit}, and
		\htmlref{\onyxop{}{stop}{}}{systemdict:stop} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stdin cvx start
onyx:0> quit
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:status}
\index{status@\onyxop{}{status}{}}
\item[{\onyxop{file/filename}{status}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[filename: ]
			A string that represents a filename.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary that contains the following entries:
			\begin{description}%\item[]
			\item[dev: ]
				Inode's device.
			\item[ino: ]
				Inode's number.
			\item[mode: ]
				Inode permissions.
			\item[nlink: ]
				Number of hard links.
			\item[uid: ]
				User ID of the file owner.
			\item[gid: ]
				Group ID of the file owner.
			\item[rdev: ]
				Device type.
			\item[size: ]
				File size in bytes.
			\item[atime: ]
				Time of last access, in nanoseconds since the
				epoch.
			\item[mtime: ]
				Time of last modification, in nanoseconds since
				the epoch.
			\item[ctime: ]
				Time of last file status change, in nanoseconds
				since the epoch.
			\item[blksize: ]
				Optimal block size for I/O.
			\item[blocks: ]
				Number of blocks allocated.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Get status information about a file.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp' status 1 sprint
<$dev 134405 $ino 2 $mode 17407 $nlink 5 $uid 0 $gid 0 $rdev 952 $size 3584
$atime 994883041000000000 $mtime 994883041000000000 $ctime 994883041000000000
$blksize 0 $blocks 8>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:stderr}
\index{stderr@\onyxop{}{stderr}{}}
\item[{\onyxop{--}{stderr}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object corresponding to the calling thread's
			stderr.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the thread's stderr.  See Section~\ref{sec:onyx_standard_io}
		for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stderr pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:stdin}
\index{stdin@\onyxop{}{stdin}{}}
\item[{\onyxop{--}{stdin}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object corresponding to the calling thread's
			stdin.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the thread's stdin.  See Section~\ref{sec:onyx_standard_io}
		for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stdin pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:stdout}
\index{stdout@\onyxop{}{stdout}{}}
\item[{\onyxop{--}{stdout}{file}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object corresponding to the calling thread's
			stdout.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the thread's stdout.  See Section~\ref{sec:onyx_standard_io}
		for standard I/O details.
	\item[Example(s): ]\begin{verbatim}

onyx:0> stdout pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:stop}
\index{stop@\onyxop{}{stop}{}}
\item[{\onyxop{--}{stop}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ] None.
	\item[Description: ]
		Unwind the execution stack to the innermost
		\htmlref{\onyxop{}{stopped}{}}{systemdict:stopped} or
		\htmlref{\onyxop{}{start}{}}{systemdict:start} context.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {stop} stopped 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:stopped}
\index{stopped@\onyxop{}{stopped}{}}
\item[{\onyxop{obj}{stopped}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object to evaluate.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \htmlref{\onyxop{}{stop}{}}{systemdict:stop}
			operator was executed, false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidcontinue}{invalidcontinue}.]
		\item[\htmlref{invalidexit}{invalidexit}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{obj}.  This operator provides a context that
		terminates execution stack unwinding due to the
		\htmlref{\onyxop{}{stop}{}}{systemdict:stop} operator.  It will
		also terminate execution stack unwinding due to the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators, but will
		throw an \htmlref{invalidcontinue}{invalidcontinue} or
		\htmlref{invalidexit}{invalidexit} error, respectively, then do
		the equivalent of calling
		\htmlref{\onyxop{}{quit}{}}{systemdict:quit}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {stop} stopped 1 sprint
true
onyx:0> {} stopped 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:string}
\index{string@\onyxop{}{string}{}}
\item[{\onyxop{length}{string}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[length: ]
			Non-negative number of bytes.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string of \oparg{length} bytes.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a string of \oparg{length} bytes.  The bytes are
		initialized to 0.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 string 1 sprint
`\x00\x00\x00'
onyx:0>
onyx:0> 0 string 1 sprint
`'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:stuck}
\index{stuck@\onyxop{}{stuck}{}}
\item[{\onyxop{stack}{stuck}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Tuck duplicate of top object on \oparg{stack} under second
		object on \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (2 1 0) dup stuck pstack
(2 0 1 0)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sub}
\index{sub@\onyxop{}{sub}{}}
\item[{\onyxop{a b}{sub}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\item[b: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			The value of \oparg{b} subtracted from \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Subtract \oparg{b} from \oparg{a} and return the result.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 5 3 sub 1 sprint
2
onyx:0> -3 4 sub 1 sprint
-7
onyx:0> 5.1 1.1 sub 1 sprint
4.000000e+00
onyx:0> 5 1.0 sub 1 sprint
4.000000e+00
onyx:0> -3.0 4.1 sub 1 sprint
-7.100000e+00
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:submatch}
\index{submatch@\onyxop{}{submatch}{}}
\item[{\onyxop{integer}{submatch}{substring}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[integer: ]
			\begin{description}\item[]
			\item[0: ]
				Get substring of text that matched the regular
				expression.
			\item[{\gt}0: ]
				Get substring of text that matched the specified
				capturing subpattern.
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[substring: ]
			A substring of the string that was most recently matched
			by the
			\htmlref{\onyxop{}{match}{}}{systemdict:match},
			\htmlref{\onyxop{}{split}{}}{systemdict:split}, or
			\htmlref{\onyxop{}{subst}{}}{systemdict:subst}
			operators.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get a substring of the input string that was most recently
		matched against.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `input' `n(p)u' match {0 submatch 1 sprint 1 submatch 1 sprint} if
`npu'
`p'
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:subst}
\index{subst@\onyxop{}{subst}{}}
\item[{\onyxop{input pattern template flags}{subst}{output count}}: ]
\item[{\onyxop{input pattern template}{subst}{output count}}: ]
\item[{\onyxop{input regsub}{subst}{output count}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[input: ]
			An input string.
		\item[pattern: ]
			A string that specifies a regular expression.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[template: ]
			A string that specifies a substitution template.  See
			Section~\ref{sec:onyx_regular_expressions} for syntax.
		\item[flags: ]
			A dictionary of optional flags:
			\begin{description}%\item[]
			\item[\$g: ]
				Substitute all matches, if true, rather than
				just the first match.  Defaults to false.
			\item[\$i: ] Case insensitive.  Defaults to false.
			\item[\$m: ] Treat input as a multi-line string.
				Defaults to false.
			\item[\$s: ] Treat input as a single line, so that
				the dot metacharacter matches any character,
				including a newline.  Defaults to false.
			\end{description}
		\item[regsub: ]
			A regsub object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[output: ]
			A string that is created by substituting substrings
			within \oparg{input} that match a regular expression.
		\item[count: ]
			Number of substitutions made.  If 0 substitutions were
			made, then \oparg{output} is a duplicate of
			\oparg{input}, rather than a copy.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{regexerror}{regexerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a string by substituting according to a template for each
		substring within \oparg{input} that matches a regular
		expression.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `Input String' `([a-r])' `[\1]' <$g true> subst pstack
6
`I[n][p]ut St[r][i][n][g]'
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:sunder}
\index{sunder@\onyxop{}{sunder}{}}
\item[{\onyxop{stack}{sunder}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the second object on \oparg{stack} and put
		it under the top object on \oparg{stack}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (2 1 0) dup sunder pstack
(2 1 1 0)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:sup}
\index{sup@\onyxop{}{sup}{}}
\item[{\onyxop{stack}{sup}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Rotate the top three objects on \oparg{stack} up one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (3 2 1 0) dup sup pstack
(3 0 2 1)
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:super}
\index{super@\onyxop{}{super}{}}
\item[{\onyxop{class}{super}{super/null}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[class: ]
			A class object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[super/null: ]
			A class or null object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the superclass of \oparg{class}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> class super 1 sprint
null
onyx:0> class dup vclass setsuper
onyx:1> super classname 1 sprint
$vclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:symlink}
\index{symlink@\onyxop{}{symlink}{}}
\item[{\onyxop{filename linkname}{symlink}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[filename: ]
			A string that represents a filename.
		\item[linkname: ]
			A string that represents a filename.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Create a symbolic link from \oparg{linkname} to
		\oparg{filename}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open
onyx:1> dup `Hello\n' write
onyx:1> dup flushfile
onyx:1> close
onyx:0> `/tmp/foo' `/tmp/bar' symlink
onyx:0> `/tmp/bar' `r' open
onyx:1> readline
onyx:2> pstack
false
`Hello'
onyx:2>
		\end{verbatim}
	\end{description}
\label{systemdict:tailopt}
\index{tailopt@\onyxop{}{tailopt}{}}
\item[{\onyxop{--}{tailopt}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if tail call optimization is enabled for this
			thread; false otherwise.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get whether tail call optimization is enabled for this thread.
	\item[Example(s): ]\begin{verbatim}

onyx:0> tailopt 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:system}
\index{system@\onyxop{}{system}{}}
\item[{\onyxop{args}{system}{status}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[args: ]
			An array of strings.  The first string in \oparg{args}
			is the path of the program to invoke, and any additional
			array elements are passed as command line arguments to
			the invoked program.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[status: ]
			Exit code of terminated process.  A negative value
			indicates that the process was terminated by a signal
			(use the \htmlref{\onyxop{}{neg}{}}{systemdict:neg}
			operator to get the signal number), and a non-negative
			value is the exit code of a program that terminated
			normally.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Execute a program as a child process and wait for it to
		terminate.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`/usr/bin/which' `onyx'] system
/usr/local/bin/onyx
onyx:1> 1 sprint
0
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:systemdict}
\index{systemdict@\onyxop{}{systemdict}{}}
\item[{\onyxop{--}{systemdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get systemdict.  See Section~\ref{sec:systemdict} for details on
		systemdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> systemdict 0 sprint
-dict-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:tan}
\index{tan@\onyxop{}{tan}{}}
\item[{\onyxop{a}{sinh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Tangent of \oparg{a} in radians.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the tangent of \oparg{a} in radians.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0.785 tan 1 sprint
9.992040e-01
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:tanh}
\index{tanh@\onyxop{}{tanh}{}}
\item[{\onyxop{a}{tanh}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Hyperbolic tangent of \oparg{a}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the hyperbolic tangent of \oparg{a}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 3 tanh 1 sprint
9.950548e-01
onyx:0>
		\end{verbatim}
 	\end{description}
\label{systemdict:tell}
\index{tell@\onyxop{}{tell}{}}
\item[{\onyxop{file}{tell}{offset}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[fil: ]
			A file object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[offset: ]
			Offset of the file position pointer for \oparg{file}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get the file position pointer offset for \oparg{file}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup tell 1 sprint
0
onyx:1> dup `Hello\n' write
onyx:1> dup tell 1 sprint
6
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:test}
\index{test@\onyxop{}{test}{}}
\item[{\onyxop{file/filename flag}{test}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[filename: ]
			A string that represents a filename.
		\item[flag: ]
			A single-character string that represents the test to do
			on \oparg{file} or \oparg{filename}:
			\begin{description}%\item[]
			\item[`b': ]
				Block special device?
			\item[`c': ]
				Character special device?
			\item[`d': ]
				Directory?
			\item[`e': ]
				Exists?
			\item[`f': ]
				Regular file?
			\item[`g': ]
				Setgid?
			\item[`k': ]
				Sticky?
			\item[`p': ]
				Named pipe?
			\item[`r': ]
				Readable?
			\item[`s': ]
				Size greater than 0?
			\item[`t': ]
				tty?
			\item[`u': ]
				Setuid?
			\item[`w': ]
				Write bit set?
			\item[`x': ]
				Executable bit set?
			\item[`L': ]
				Symbolic link?
			\item[`O': ]
				Owner matches effective uid?
			\item[`G': ]
				Group matches effective gid?
			\item[`S': ]
				Socket?
			\end{description}
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If true, the test evaluated to true; false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Test a file for an attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/blah' `e' test 1 sprint
false
onyx:0> `/tmp' `e' test 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:this}
\index{this@\onyxop{}{this}{}}
\item[{\onyxop{--}{this}{class/instance}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[class: ] A class object.
		\item[instance: ] An instance object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Get the topmost object on cstack, which provides the context for
		execution of invokable and fetchable objects.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $fooclass vclass <> <$foomethod {this:classname 1 sprint}> cdef
onyx:0> fooclass:foomethod
$fooclass
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:thread}
\index{thread@\onyxop{}{thread}{}}
\item[{\onyxop{stack entry}{thread}{thread}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[stack: ]
			A stack that contains the contents for the new thread's
			ostack.
		\item[entry: ]
			An initial object to execute in the new thread.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object that corresponds to the new thread.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create and run a new thread.
	\item[Example(s): ]\begin{verbatim}

onyx:0> (1 2) {add 1 sprint} thread join `Done\n' print flush
3
Done
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:threadcstack}
\index{threadcstack@\onyxop{}{threadcstack}{}}
\item[{\onyxop{thread}{threadcstack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			The context stack belonging to \oparg{thread}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get a reference to the context stack belonging to
		\oparg{thread}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> self threacdstack 1 sprint
()
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:threaddstack}
\index{threaddstack@\onyxop{}{threaddstack}{}}
\item[{\onyxop{thread}{threaddstack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			The dictionary stack belonging to \oparg{thread}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get a reference to the dictionary stack belonging to
		\oparg{thread}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> self threaddstack 1 sprint
(-dict- -dict- -dict- -dict-)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:threadestack}
\index{threadestack@\onyxop{}{threadestack}{}}
\item[{\onyxop{thread}{threadestack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			The execution stack belonging to \oparg{thread}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get a reference to the execution stack belonging to
		\oparg{thread}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> self threadestack 1 sprint
(-file- -array- --eval-- --ifelse-- -array- --for-- -array-)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:threadistack}
\index{threadistack@\onyxop{}{threadistack}{}}
\item[{\onyxop{thread}{threadistack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			The index stack belonging to \oparg{thread}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get a reference to the index stack belonging to \oparg{thread}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> self threadistack 1 sprint
(0 0 0 0 7 0 3)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:threadostack}
\index{threadostack@\onyxop{}{threadostack}{}}
\item[{\onyxop{thread}{threadostack}{stack}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[thread: ]
			A thread object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[stack: ]
			The operand stack belonging to \oparg{thread}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Get a reference to the operand stack belonging to
		\oparg{thread}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> self threadostack 1 sprint
(-stack- -stack- -stack- -stack-)
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:threadsdict}
\index{threadsdict@\onyxop{}{threadsdict}{}}
\item[{\onyxop{--}{threadsdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.  Each key is a thread reference.  By
			default, each value is null, but this need not be so,
			and the value can be redefined for debugging purposes.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get a dictionary containing references to all threads.
	\item[Example(s): ]\begin{verbatim}

onyx:0> threadsdict 1 sprint
<-thread- null>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:throw}
\index{throw@\onyxop{}{throw}{}}
\item[{\onyxop{name}{throw}{obj}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[name: ] The name of an error.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[obj: ]
			The object that was being executed when the error was
			thrown.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\end{description}
	\item[Description: ]
		Throw an error, using the following steps:
		\begin{enumerate}
		\item{Set newerror in the currenterror dictionary to true.}
		\item{Set errorname in the currenterror dictionary to
		\oparg{name}.}
		\item{Set ostack, dstack, estack, and istack in the currenterror
		dictionary to be current stack snapshots.}
		\item{Push the object that was being executed before throw was
		called onto ostack.}
		\item{If there is an error handler in the errordict dictionary
		that corresponds to \oparg{name}, evaluate it.  Otherwise,
		evaluate errordict's
		\htmlref{\onyxop{}{handleerror}{}}{errordict:handleerror} and
		\htmlref{\onyxop{}{stop}{}}{errordict:stop} operators.}
		\end{enumerate}
	\item[Example(s): ]\begin{verbatim}

onyx:0> $unregistered throw
Error $unregistered
ostack: ()
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..1):
0:      -file-
1:      --start--
onyx:1> pstack
-file-
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:timedwait}
\index{timedwait@\onyxop{}{timedwait}{}}
\item[{\onyxop{condition mutex timeout}{timedwait}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[condition: ]
			A condition object.
		\item[mutex: ]
			A mutex object that this thread currently owns.
		\item[timeout: ]
			Minimum number of nanoseconds to wait for
			\oparg{condition}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, success, otherwise timeout.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Wait on \oparg{condition} for at least \oparg{timeout}
		nanoseconds.  \oparg{mutex} is atomically released when the
		current thread blocks, then acquired again before the current
		thread runs again.  Using a mutex that the current thread does
		not own will result in undefined behavior (likely crash).
	\item[Example(s): ]\begin{verbatim}

onyx:0> condition mutex dup lock ostack
onyx:3> {dup lock exch signal unlock}
onyx:4> thread 3 1 roll
onyx:3> dup 3 1 roll
onyx:4> 1000000000 timedwait 1 sprint unlock join
false
onyx:0> mutex condition 1 idup dup lock 1000000000 timedwait 1 sprint unlock
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:token}
\index{token@\onyxop{}{token}{}}
\item[{\onyxop{file/string}{token}{false}}: ]
\item[{\onyxop{file/string}{token}{file/substring obj true}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file that is used as onyx source code to scan a token
			from.
		\item[string: ]
			A string that is used as onyx source code to scan a
			token from.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[file: ]
			The same file object that was passed in.
		\item[substring: ]
			The remainder of \oparg{string} after scanning a token.
		\item[obj: ]
			An object that was constructed by scanning a token.
		\item[false/true: ]
			If true, a token was successfully scanned, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{syntaxerror}{syntaxerror}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefined}{undefined}.]
		\end{description}
	\item[Description: ]
		Scan a token from a file or string, using onyx syntax rules.  If
		a token is followed by whitespace, one character of whitespace
		is consumed when the token is scanned.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `1 2' token pstack clear
true
1
`2'
onyx:0> `foo' token pstack clear
true
foo
`'
onyx:0> `foo ' token pstack clear
true
foo
`'
onyx:0> `foo  ' token pstack clear
true
foo
` '
onyx:0> `foo$bar' token pstack clear
true
foo
`$bar'
onyx:0> `foo{}' token pstack clear
true
foo
`{}'
onyx:0> ` ' token pstack clear
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:trapped}
\index{trapped@\onyxop{}{trapped}{}}
\item[{\onyxop{obj}{trapped}{false}}: ]
\item[{\onyxop{obj}{trapped}{arg true}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object to evaluate.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[arg: ]
			The argument that was passed to the
			\htmlref{\onyxop{}{escape}{}}{systemdict:escape}
			operator that caused unwinding to this
			\onyxop{}{trapped}{} context.
		\item[false: ]
			The \htmlref{\onyxop{}{escape}{}}{systemdict:escape}
			operator was not executed.
		\item[true: ]
			The \htmlref{\onyxop{}{escape}{}}{systemdict:escape}
			operator was executed.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidcontinue}{invalidcontinue}.]
		\item[\htmlref{invalidexit}{invalidexit}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{obj}.  This operator provides a context that
		snapshots the state of ostack, dstack, and cstack, then restores
		those snapshotted states if the
		\htmlref{\onyxop{}{escape}{}}{systemdict:escape} operator causes
		the execution stack to unwind to the point where
		\onyxop{}{trapped}{} was called.  It will also terminate
		execution stack unwinding due to the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators, but will
		throw an \htmlref{invalidcontinue}{invalidcontinue} or
		\htmlref{invalidexit}{invalidexit} error, respectively, then do
		the equivalent of calling
		\htmlref{\onyxop{}{quit}{}}{systemdict:quit}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {1 2 3 $arg escape} trapped {1 sprint} if
$arg
onyx:0> {1 2 3} trapped {1 sprint}{pstack clear} ifelse
3
2
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:trunc}
\index{trunc@\onyxop{}{trunc}{}}
\item[{\onyxop{a}{trunc}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or real.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			Integer created from \oparg{a} by discarding the
			fractional portion.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Discard the fractional portion of \oparg{a} to create an
		integer, and return the result.
	\item[Example(s): ]\begin{verbatim}

onyx:0> -1.51 trunc 1 sprint
-1
onyx:0> -1.49 trunc 1 sprint
-1
onyx:0> 0 trunc 1 sprint
0
onyx:0> 1.49 trunc 1 sprint
1
onyx:0> 1.51 trunc 1 sprint
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:truncate}
\index{truncate@\onyxop{}{truncate}{}}
\item[{\onyxop{file length}{truncate}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[length: ]
			New length for \oparg{file}.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{rangecheck}{rangecheck}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the length of \oparg{file} to \oparg{length}.  If this
		causes the file to grow, the appended bytes will have the
		value zero.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup `Hello\n' write
onyx:1> dup flushfile
onyx:1> dup 0 seek
onyx:1> dup 10 string read
onyx:3> pop 1 sprint
`Hello\n'
onyx:1> dup 3 truncate
onyx:1> dup 0 seek
onyx:1> dup 10 string read
onyx:3> pop 1 sprint
`Hel'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:true}
\index{true@\onyxop{}{true}{}}
\item[{\onyxop{--}{true}{true}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[true: ]
			The boolean value true.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Return true.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:trylock}
\index{trylock@\onyxop{}{trylock}{}}
\item[{\onyxop{mutex}{trylock}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[mutex: ]
			A mutex object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			If false, \oparg{mutex} was successfully acquired.
			Otherwise the mutex acquisition failed.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Try to acquire \oparg{mutex}, but return a failure immediately
		if \oparg{mutex} cannot be acquired, rather than blocking.
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex dup
onyx:2> trylock 1 sprint
false
onyx:1> trylock 1 sprint
true
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:tuck}
\index{tuck@\onyxop{}{tuck}{}}
\item[{\onyxop{a b}{tuck}{b a b}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[: ]
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the top object on ostack and put it under
		the second object on ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c'
oonyx:3> tuck pstack
`c'
`b'
`c'
`a'
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:type}
\index{type@\onyxop{}{type}{}}
\item[{\onyxop{obj}{type}{name}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[name: ]
			An executable name that corresponds to the type of
			\oparg{obj}:
			\begin{description}
			\item[array: ] arraytype.
			\item[boolean: ] booleantype.
			\item[condition: ] conditiontype.
			\item[dict: ] dicttype.
			\item[file: ] filetype.
			\item[fino: ] finotype.
			\item[handle: ] handletype.
			\item[integer: ] integertype.
			\item[mark: ] marktype.
			\item[mutex: ] mutextype.
			\item[name: ] nametype.
			\item[null: ] nulltype.
			\item[operator: ] operatortype.
			\item[pmark: ] pmarktype.
			\item[stack: ] stacktype.
			\item[string: ] stringtype.
			\item[thread: ] threadtype.
			\end{description}
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Get a name that represent the type of \oparg{obj}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true type 1 sprint
booleantype
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:uid}
\index{uid@\onyxop{}{uid}{}}
\item[{\onyxop{--}{uid}{uid}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[uid: ]
			Process's user ID.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the process's user ID.
	\item[Example(s): ]\begin{verbatim}

onyx:0> uid 1 sprint
1001
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:umask}
\index{umask@\onyxop{}{umask}{}}
\item[{\onyxop{nmask}{umask}{omask}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[nmask: ]
			Value to set umask to.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[omask: ]
			Old umask.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Set the process's umask to \oparg{nmask} and return the old
		umask.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 8@777 umask <$b 8 $w 3 $p `0'> output `\n' print flush
022
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:undef}
\index{undef@\onyxop{}{undef}{}}
\item[{\onyxop{dict key}{undef}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\item[val: ]
			A key in \oparg{dict} to undefine.
		\end{description}
	\item[Output(s): ] None
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		If \oparg{key} is defined in \oparg{dict}, undefine it.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo `foo' def
onyx:0> currentdict $foo undef
onyx:0> currentdict $foo undef
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:under}
\index{under@\onyxop{}{under}{}}
\item[{\onyxop{a b}{under}{a a b}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Create a duplicate of the second object on ostack and put it
		under the top object on ostack.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 1 2 under pstack
2
1
1
0
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:unless}
\index{unless@\onyxop{}{unless}{}}
\item[{\onyxop{boolean obj}{unless}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			A boolean.
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Evaluate \oparg{obj} unless \oparg{boolean} is true.
	\item[Example(s): ]\begin{verbatim}

onyx:0> false {`yes' 1 sprint} unless
`yes'
onyx:0> true {`yes' 1 sprint} unless
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:unlink}
\index{unlink@\onyxop{}{unlink}{}}
\item[{\onyxop{filename}{unlink}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[filename: ]
			A string that represents a filename.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{invalidfileaccess}{invalidfileaccess}.]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\item[\htmlref{undefinedfilename}{undefinedfilename}.]
		\item[\htmlref{unregistered}{unregistered}.]
		\end{description}
	\item[Description: ]
		Unlink \oparg{filename}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w' open
onyx:1> dup `Hello\n' write
onyx:1> dup flushfile
onyx:1> close
onyx:0> `/tmp/foo' unlink
onyx:0> `/tmp/foo' `r' open
Error $invalidfileaccess
ostack: (`/tmp/foo' `r')
dstack: (-dict- -dict- -dict- -dict-)
cstack: ()
estack/istack trace (0..2):
0:      --open--
1:      -file-
2:      --start--
onyx:3>
		\end{verbatim}
	\end{description}
\label{systemdict:unlock}
\index{unlock@\onyxop{}{unlock}{}}
\item[{\onyxop{mutex}{unlock}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[mutex: ]
			A mutex object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Unlock \oparg{mutex}.  Unlocking a mutex that the running thread
		does not own will result in undefined behavior (likely crash).
	\item[Example(s): ]\begin{verbatim}

onyx:0> mutex dup lock unlock
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:unsetenv}
\index{unsetenv@\onyxop{}{unsetenv}{}}
\item[{\onyxop{key}{unsetenv}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[key: ]
			A name object.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Unset \oparg{key} in the environment and in the envdict
		dictionary, if \oparg{key} is defined.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo `foo' setenv
onyx:0> envdict $foo known 1 sprint
true
onyx:0> envdict $foo get 1 sprint
`foo'
onyx:0> $foo unsetenv
onyx:0> envdict $foo known 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:until}
\index{until@\onyxop{}{until}{}}
\item[{\onyxop{proc cond}{until}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[proc: ]
			An object to be repeatedly evaluated.
		\item[cond: ]
			An object that, when evaluated, places a boolean on
			ostack.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Repeatedly evaluate \oparg{proc} and \oparg{cond}, terminating
		the first time that \oparg{cond} places false on ostack.  This
		operator supports the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 {inc dup 1 sprint}{dup 3 lt} until pop
1
2
3
onyx:0> 0 {inc dup 1 sprint exit}{dup 3 lt} until pop
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:up}
\index{up@\onyxop{}{up}{}}
\item[{\onyxop{a b c}{up}{c a b}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\item[c: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[c: ]
			An object.
		\item[a: ]
			An object.
		\item[b: ]
			An object.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Rotate the top three objects on ostack up one position.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `a' `b' `c' `d' up pstack
`c'
`b'
`d'
`a'
onyx:4>
		\end{verbatim}
	\end{description}
\label{systemdict:userdict}
\index{userdict@\onyxop{}{userdict}{}}
\item[{\onyxop{--}{userdict}{dict}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A dictionary.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get userdict.  See Section~\ref{sec:userdict} for details on
		userdict.
	\item[Example(s): ]\begin{verbatim}

onyx:0> userdict 1 sprint
<>
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:vclass}
\index{vclass@\onyxop{}{vclass}{}}
\item[{\onyxop{--}{vclass}{class}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			A class.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get vclass.  See Section~\ref{sec:vclass} for details on vclass.
	\item[Example(s): ]\begin{verbatim}

onyx:0> vclass 1 sprint
-class-
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:version}
\index{version@\onyxop{}{version}{}}
\item[{\onyxop{--}{version}{string}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ]
		\begin{description}\item[]
		\item[string: ]
			A string that contains the version name.
		\end{description}
	\item[Error(s): ] None.
	\item[Description: ]
		Get the version string.  The string returned is a reference to
		the original version string.
	\item[Example(s): ]\begin{verbatim}

onyx:0> version pstack
`1.0.0'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:wait}
\index{wait@\onyxop{}{wait}{}}
\item[{\onyxop{condition mutex}{wait}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[condition: ]
			A condition object.
		\item[mutex: ]
			A mutex object that this thread currently owns.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Wait on \oparg{condition}.  \oparg{mutex} is atomically released
		when the current thread blocks, then acquired again before the
		current thread runs again.  Using a mutex that the current
		thread does not own will result in undefined behavior (likely
		crash).
	\item[Example(s): ]\begin{verbatim}

onyx:0> condition mutex dup lock ostack
onyx:3> {dup lock exch signal unlock}
onyx:4> thread 3 1 roll
onyx:3> dup 3 1 roll
onyx:4> wait unlock join
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:waitpid}
\index{waitpid@\onyxop{}{waitpid}{}}
\item[{\onyxop{pid}{waitpid}{status}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[pid: ]
			Process identifier.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[status: ]
			Exit code of terminated process.  A negative value
			indicates that the process was terminated by a signal
			(use the \htmlref{\onyxop{}{neg}{}}{systemdict:neg}
			operator to get the signal number), and a non-negative
			value is the exit code of a program that terminated
			normally.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Wait for the process with process ID \oparg{pid} to exit.
	\item[Example(s): ]\begin{verbatim}

onyx:0> [`/bin/date'] forkexec dup 1 sprint waitpid 1 sprint
6516
Sat Jul 13 20:47:54 PDT 2002
0
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:where}
\index{where@\onyxop{}{where}{}}
\item[{\onyxop{key}{where}{false}}: ]
\item[{\onyxop{key}{where}{dict true}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[key: ]
			A key to search for in dstack.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[dict: ]
			The topmost dictionary in dstack that contains a
			definition for \oparg{key}.
		\item[false/true: ]
			If false, no definition of \oparg{key} was found in
			dstack.  Otherwise \oparg{dict} is the topmost
			dictionary in dstack that contains a definition for
			\oparg{key}.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Get the topmost dictionary in dstack that defines \oparg{key}.
	\item[Example(s): ]\begin{verbatim}

onyx:0> $foo where pstack clear
false
onyx:0> $threaddict where pstack clear
true
<$threaddict -dict- $userdict -dict- $currenterror -dict- $errordict -dict-
$resume -array->
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:while}
\index{while@\onyxop{}{while}{}}
\item[{\onyxop{cond proc}{while}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[cond: ]
			An object that, when evaluated, places a boolean on
			ostack.
		\item[proc: ]
			An object to be repeatedly evaluated.
		\end{description}
	\item[Output(s): ] None.
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Repeatedly evaluate \oparg{cond} and \oparg{proc}, terminating
		the first time that \oparg{cond} places false on ostack.  This
		operator supports the
		\htmlref{\onyxop{}{continue}{}}{systemdict:continue} and
		\htmlref{\onyxop{}{exit}{}}{systemdict:exit} operators.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 {dup 3 lt}{inc dup 1 sprint} while pop
1
2
3
onyx:0> 0 {dup 3 lt}{inc dup 1 sprint exit} while pop
1
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:write}
\index{write@\onyxop{}{write}{}}
\item[{\onyxop{file integer/string}{write}{false}}: ]
\item[{\onyxop{file integer/string}{write}{integer/substring true}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[file: ]
			A file object.
		\item[integer: ]
			An integer that represents an ascii character value.
		\item[string: ]
			A string object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[false: ]
			Successful complete write.
		\item[integer: ]
			The \oparg{integer} that was passed in.
		\item[substring: ]
			The substring of \oparg{string} that was not written.
		\item[true: ]
			Successful partial write.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{ioerror}{ioerror}.]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Write \oparg{integer} or \oparg{string} to \oparg{file}.
		Partial writes can only happen for non-blocking files.
	\item[Example(s): ]\begin{verbatim}

onyx:0> `/tmp/foo' `w+' open
onyx:1> dup `Hello\n' write pop
onyx:1> dup 0 seek
onyx:1> dup readline 1 sprint 1 sprint
false
`Hello'
onyx:1>
		\end{verbatim}
	\end{description}
\label{systemdict:xcheck}
\index{xcheck@\onyxop{}{xcheck}{}}
\item[{\onyxop{obj}{xcheck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the executable attribute, false
			otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for executable attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {1 2 3} xcheck 1 sprint
true
onyx:0> [1 2 3] xcheck 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:xecheck}
\index{xecheck@\onyxop{}{xecheck}{}}
\item[{\onyxop{obj}{xecheck}{boolean}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[obj: ]
			An object.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[boolean: ]
			True if \oparg{obj} has the executable or evaluable
			attribute, false otherwise.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\end{description}
	\item[Description: ]
		Check \oparg{obj} for executable or evaluable attribute.
	\item[Example(s): ]\begin{verbatim}

onyx:0> {1 2 3} xecheck 1 sprint
true
onyx:0> {1 2 3} cve xecheck 1 sprint
true
onyx:0> [1 2 3] xecheck 1 sprint
false
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:xor}
\index{xor@\onyxop{}{xor}{}}
\item[{\onyxop{a b}{xor}{r}}: ]
	\begin{description}\item[]
	\item[Input(s): ]
		\begin{description}\item[]
		\item[a: ]
			An integer or boolean.
		\item[b: ]
			The same type as \oparg{a}.
		\end{description}
	\item[Output(s): ]
		\begin{description}\item[]
		\item[r: ]
			If \oparg{a} and \oparg{b} are integers, their bitwise
			exclusive or, otherwise their logical exclusive or.
		\end{description}
	\item[Error(s): ]
		\begin{description}\item[]
		\item[\htmlref{stackunderflow}{stackunderflow}.]
		\item[\htmlref{typecheck}{typecheck}.]
		\end{description}
	\item[Description: ]
		Return the bitwise exclusive or of two integers, or the logical
		exclusive or of two booleans.
	\item[Example(s): ]\begin{verbatim}

onyx:0> true false xor 1 sprint
true
onyx:0> true true xor 1 sprint
false
onyx:0> 5 3 xor 1 sprint
6
onyx:0>
		\end{verbatim}
	\end{description}
\label{systemdict:yield}
\index{yield@\onyxop{}{yield}{}}
\item[{\onyxop{--}{yield}{--}}: ]
	\begin{description}\item[]
	\item[Input(s): ] None.
	\item[Output(s): ] None.
	\item[Error(s): ] None.
	\item[Description: ]
		Vuluntarily yield the processor, so that another thread or
		process may be run.
	\item[Example(s): ]\begin{verbatim}

onyx:0> 0 100000 {1 add yield} repeat 1 sprint
100000
onyx:0>
		\end{verbatim}
	\end{description}
\end{description}
