doc.data

/*******************************************************************
 *
 * A Common Lisp compiler/interpretor, written in Prolog
 *
 * (xxxxx.pl)
 *
 *
 * Douglas'' Notes:
 *
 * (c) Douglas Miles, 2017
 *
 * The program is a *HUGE* common-lisp compiler/interpreter. It is written for YAP/SWI-Prolog (YAP 4x faster).
 *
 *******************************************************************/
:- module(doc, []).
:- set_module(class(library)).
:- include('header.pro').

:- style_check(-discontiguous).

doc_string('%eql', 'sb-kernel', function, "Return T if OBJ1 and OBJ2 represent the same object, otherwise NIL.").
doc_string('%instancep', 'sb-kernel', function, "Return true if OBJECT is a INSTANCE, and NIL otherwise.").
doc_string('%make-sequence-like', 'sb-impl', function, "Return a sequence of the same type as SEQUENCE and the given LENGTH.").
doc_string('%make-slot-definition', system, function, "Argument must be a subclass of standard-slot-definition").
doc_string('%other-pointer-p', 'sb-kernel', function, "Return true if OBJECT is a OTHER-POINTER, and NIL otherwise.").
doc_string('%put', 'sb-kernel', function, "The VALUE is added as a property of SYMBOL under the specified INDICATOR.\n  Returns VALUE.").
doc_string('%set-fdefinition', 'sb-kernel', function, "Set NAME's global function definition.").
doc_string('%setelt', 'sb-kernel', function, "Store NEWVAL as the component of SEQUENCE specified by INDEX.").
doc_string('%standard-char-p', 'sb-sys', function, "Return T if and only if THING is a standard-char. Differs from\nSTANDARD-CHAR-P in that THING doesn't have to be a character.").
doc_string('%wild-pathname-p', system, function, "Predicate for determing whether PATHNAME contains wild components.\r\nKEYWORD, if non-nil, should be one of :directory, :host, :device,\r\n:name, :type, or :version indicating that only the specified component\r\nshould be checked for wildness.").
doc_string('**saetp-bits-per-length**', 'sb-fasl', variable, "255 means bad entry.").
doc_string('*abbreviation-happened*', xp, variable, "t if current thing being printed has been abbreviated.").
doc_string('*active-processes*', 'sb-impl', variable, "List of process structures for all active processes.").
doc_string('*after-gc-hooks*', pkg_sys, variable, "Called after each garbage collection, except for garbage collections\ntriggered during thread exits. In a multithreaded environment these hooks may\nrun in any thread.").
doc_string('*alien-callback-info*', 'sb-alien', variable, "Maps SAPs to corresponding CALLBACK-INFO structures: contains all the\ninformation we need to manipulate callbacks after their creation. Used for\nchanging the lisp-side function they point to, invalidation, etc.").
doc_string('*alien-callback-trampolines*', 'sb-alien', variable, "Lisp trampoline store: assembler wrappers contain indexes to this, and\nENTER-ALIEN-CALLBACK pulls the corresponding trampoline out and calls it.").
doc_string('*alien-callback-wrappers*', 'sb-alien', variable, "Cache of existing lisp wrappers, indexed with SPECIFER. Used for memoization:\nwe don't create new wrappers if one for the same specifier already exists.").
doc_string('*alien-callbacks*', 'sb-alien', variable, "Cache of existing callback SAPs, indexed with (SPECIFER . FUNCTION). Used for\nmemoization: we don't create new callbacks if one pointing to the correct\nfunction with the same specifier already exists.").
doc_string('*alien-type-matches*', 'sb-alien', variable, "A hashtable used to detect cycles while comparing record types.").
doc_string('*apropos-do-more*', custom, variable, "\r\nPrint values of the symbols in `apropos'.\r\nIt can be a list of :FUNCTION, :VARIABLE, :TYPE, :CLASS\r\nto print the corresponding values, or T for all of them.").
doc_string('*apropos-matcher*', custom, variable, "\r\nA function of one argument, a pattern (a string),\r\nreturning a new function of one argument, a symbol name (also a string),\r\nwhich returns non-NIL when the symbol name matches the pattern\r\nfor the purposes of APROPOS.\r\nWhen this variable is NIL, SEARCH is used.").
doc_string('*args*', 'sb-c', variable, "This variable is bound to the format arguments when an error is signalled\nby BARF or BURP.").
doc_string('*auto-eval-in-frame*', 'sb-debug', variable, "When set (the default), evaluations in the debugger's command loop occur\nrelative to the current frame's environment without the need of debugger\nforms that explicitly control this kind of evaluation.").
doc_string('*available-buffers*', 'sb-impl', variable, "List of available buffers.").
doc_string('*available-buffers-lock*', 'sb-impl', variable, "Mutex for access to *AVAILABLE-BUFFERS*.").
doc_string('*backquote-depth*', 'sb-impl', variable, "how deep we are into backquotes").
doc_string('*backtrace-frame-count*', 'sb-debug', variable, "Default number of frames to backtrace. Defaults to 1000.").
doc_string('*break-on-signals*', 'common-lisp', variable, "When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will\n   enter the debugger prior to signalling that condition.").
doc_string('*browser*', custom, variable, "The default browser - a key in `*browsers*' or a list of strings.").
doc_string('*browsers*', custom, variable, "\r\nAlist of browsers and commands that invoke them.\r\n`~a' will be replaced with the URL to view.").
doc_string('*burp-action*', 'sb-c', variable, "Action taken by the BURP function when a possible compiler bug is detected.\nOne of :WARN, :ERROR or :NONE.").
doc_string('*cmd-number*', 'top-level', variable, "Number of the next command").
doc_string('*cmov-ptype-representation-vop*', 'sb-vm', variable, "Alist of primitive type -> (storage-class-name VOP-name)\n   if values of such a type should be cmoved, and NIL otherwise.\n\n   storage-class-name is the name of the storage class to use for\n   the values, and VOP-name the name of the VOP that will be used\n   to execute the conditional move.").
doc_string('*compile-file-pathname*', 'common-lisp', variable, "The defaulted pathname of the file currently being compiled, or NIL if not\n  compiling.").
doc_string('*compile-file-truename*', 'common-lisp', variable, "The TRUENAME of the file currently being compiled, or NIL if not\n  compiling.").
doc_string('*compile-print*', 'common-lisp', variable, "The default for the :PRINT argument to COMPILE-FILE.").
doc_string('*compile-progress*', pkg_sys, variable, "When this is true, the compiler prints to *STANDARD-OUTPUT* progress\n  information about the phases of compilation of each function. (This\n  is useful mainly in large block compilations.)").
doc_string('*compile-verbose*', 'common-lisp', variable, "The default for the :VERBOSE argument to COMPILE-FILE.").
doc_string('*compiler-print-variable-alist*', pkg_sys, variable, "an association list describing new bindings for special variables\nto be used by the compiler for error-reporting, etc. Eg.\n\n ((*PRINT-LENGTH* . 10) (*PRINT-LEVEL* . 6) (*PRINT-PRETTY* . NIL))\n\nThe variables in the CAR positions are bound to the values in the CDR\nduring the execution of some debug commands. When evaluating arbitrary\nexpressions in the debugger, the normal values of the printer control\nvariables are in effect.\n\nInitially empty, *COMPILER-PRINT-VARIABLE-ALIST* is Typically used to\nspecify bindings for printer control variables.").
doc_string('*core-pathname*', pkg_sys, variable, "The absolute pathname of the running SBCL core.").
doc_string('*current-level*', xp, variable, "current depth in logical blocks.").
doc_string('*current-thread*', 'sb-thread', variable, "Bound in each thread to the thread itself.").
doc_string('*debug-beginner-help-p*', 'sb-debug', variable, "Should the debugger display beginner-oriented help messages?").
doc_string('*debug-io*', 'common-lisp', variable, "interactive debugging stream").
doc_string('*debug-io*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe stream used by the WAM-CL debugger.  The initial value is a synonym stream to\n*TERMINAL-IO*.\n").
doc_string('*debug-loop-fun*', 'sb-debug', variable, "A function taking no parameters that starts the low-level debug loop.").
doc_string('*debug-print-variable-alist*', pkg_sys, variable, "an association list describing new bindings for special variables\nto be used within the debugger. Eg.\n\n ((*PRINT-LENGTH* . 10) (*PRINT-LEVEL* . 6) (*PRINT-PRETTY* . NIL))\n\nThe variables in the CAR positions are bound to the values in the CDR\nduring the execution of some debug commands. When evaluating arbitrary\nexpressions in the debugger, the normal values of the printer control\nvariables are in effect.\n\nInitially empty, *DEBUG-PRINT-VARIABLE-ALIST* is typically used to\nprovide bindings for printer control variables.").
doc_string('*debug-readtable*', 'sb-debug', variable, "*READTABLE* for the debugger").
doc_string('*debugger-hook*', 'common-lisp', variable, "This is either NIL or a function of two arguments, a condition and the value\n   of *DEBUGGER-HOOK*. This function can either handle the condition or return\n   which causes the standard debugger to execute. The system passes the value\n   of this variable to the function because it binds *DEBUGGER-HOOK* to NIL\n   around the invocation.").
doc_string('*debugger-hook*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThis is either NIL or a function of two arguments, a condition and the value\nof *DEBUGGER-HOOK*. This function can either handle the condition or return\nwhich causes the standard debugger to execute. The system passes the value\nof this variable to the function because it binds *DEBUGGER-HOOK* to NIL\naround the invocation.\n").
doc_string('*default-pathname-defaults*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe default pathname used by some pathname-handling functions such as ENOUGH-\nNAMESTRING.\n").
doc_string('*default-right-margin*', xp, variable, "controls default line length; must be a non-negative integer").
doc_string('*derive-function-types*', pkg_sys, variable, "Should the compiler assume that function types will never change,\n  so that it can use type information inferred from current definitions\n  to optimize code which uses those definitions? Setting this true\n  gives non-ANSI, early-CMU-CL behavior. It can be useful for improving\n  the efficiency of stable code.").
doc_string('*descriptor-handlers*', 'sb-impl', variable, "List of all the currently active handlers for file descriptors").
doc_string('*disassem-inst-column-width*', 'sb-disassem', variable, "The width of instruction bytes.").
doc_string('*disassem-note-column*', 'sb-disassem', variable, "The column in which end-of-line comments for notes are started.").
doc_string('*disassemble-annotate*', pkg_sys, variable, "Annotate DISASSEMBLE output with source code.").
doc_string('*ed-functions*', pkg_sys, variable, "See function documentation for ED.").
doc_string('*editor*', custom, variable, "The name of the editor.").
doc_string('*efficiency-note-cost-threshold*', pkg_sys, variable, "This is the minimum cost difference between the chosen implementation and\n  the next alternative that justifies an efficiency note.").
doc_string('*efficiency-note-limit*', pkg_sys, variable, "This is the maximum number of possible optimization alternatives will be\n  mentioned in a particular efficiency note. NIL means no limit.").
doc_string('*enclosing-source-cutoff*', pkg_sys, variable, "The maximum number of enclosing non-original source forms (i.e. from\n  macroexpansion) that we print in full. For additional enclosing forms, we\n  print only the CAR.").
doc_string('*error-output*', 'common-lisp', variable, "error output stream").
doc_string('*error-output*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe output stream to which error messages are output.  The initial value is an\nsynonym stream to *TERMINAL-IO*.\n").
doc_string('*evaluator-mode*', pkg_sys, variable, "Toggle between different evaluator implementations. If set to :COMPILE,\nan implementation of EVAL that calls the compiler will be used. If set\nto :INTERPRET, an interpreter will be used.").
doc_string('*exit-hooks*', pkg_sys, variable, "This is a list of functions which are called in an unspecified\norder when SBCL process exits. Unused by SBCL itself: reserved for\nuser and applications. Using (SB-EXT:EXIT :ABORT T), or calling\nexit(3) directly will circumvent these hooks.").
doc_string('*exit-timeout*', pkg_sys, variable, "Default amount of seconds, if any, EXIT should wait for other\nthreads to finish after terminating them. Default value is 60. NIL\nmeans to wait indefinitely.").
doc_string('*external-formats*', 'sb-impl', variable, "Hashtable of all available external formats. The table maps from\n  external-format names to EXTERNAL-FORMAT structures.").
doc_string('*features*', 'common-lisp', variable, "a list of symbols that describe features provided by the\n   implementation").
doc_string('*features*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nList of symbols that name features of the current version of WAM-CL.  These\nfeatures are used in connection with the read macros #+ and #-.  When the\nreader encounters\n        #+ feature-spec form\nit reads FORM in the usual manner if FEATURE-SPEC is satisfied.  Otherwise,\nthe reader just skips FORM.\n        #- feature-spec form\nis equivalent to\n        #- (not feature-spec) form\nA feature-spec may be a symbol, in which case the spec is satisfied iff the\nsymbol is an element of *FEATURES*.  Or else, a feature-spec must be one of\nthe following forms.\n        (and {feature-spec}*)\n                Satisfied iff all FEATURE-SPECs are satisfied\n        (or {feature-spec}*)\n                Satisfied iff at least one of FEATURE-SPECs is satisfied\n        (not feature-spec)\n                Satisfied iff FEATURE-SPEC is not satisfied\n").
doc_string('*fill-indent-sexp*', custom, variable, "\r\nThe default indentation of new FILL-STREAMs inside SEXPs.\r\nThis should be a number (the actual indentation),\r\na function of one argument (the text indentation),\r\nNIL (no indentation) or\r\nT (same indentation as the text, i.e., the same effect as #'IDENTITY).").
doc_string('*flush-debug-errors*', 'sb-debug', variable, "When set, avoid calling INVOKE-DEBUGGER recursively when errors occur while\n   executing in the debugger.").
doc_string('*gc-run-time*', pkg_sys, variable, "Total CPU time spent doing garbage collection (as reported by\nGET-INTERNAL-RUN-TIME.) Initialized to zero on startup. It is safe to bind\nthis to zero in order to measure GC time inside a certain section of code, but\ndoing so may interfere with results reported by eg. TIME.").
doc_string('*gensym-counter*', 'common-lisp', variable, "counter for generating unique GENSYM symbols").
doc_string('*gf-allocate-instance*', mop, variable, "Cached value of the ALLOCATE-INSTANCE generic function.\r\nInitialized with the true value near the end of the file.").
doc_string('*gf-initialize-instance*', mop, variable, "Cached value of the INITIALIZE-INSTANCE generic function.\r\nInitialized with the true value near the end of the file.").
doc_string('*gf-reinitialize-instance*', mop, variable, "Cached value of the REINITIALIZE-INSTANCE generic function.\r\nInitialized with the true value near the end of the file.").
doc_string('*gf-shared-initialize*', mop, variable, "Cached value of the SHARED-INITIALIZE generic function.\r\nInitialized with the true value near the end of the file.").
doc_string('*help-message*', extensions, variable, "Prints a help message about command line arguments of WAM-CL").
doc_string('*http-proxy*', custom, variable, "\r\nA list of 3 elements (user:password host port), parsed from $http_proxy\r\n[http://]proxy-user:proxy-password@proxy-host:proxy-port[/]\r\nby HTTP-PROXY.").
doc_string('*ignore-eof-on-terminal-io*', si, variable, "Variable in SI package:\nECL specific.\nIf the value of this variable is non-NIL, WAM-CL ignores the EOF-character\n(usually ^D) on the terminal.  The initial value is NIL.\n").
doc_string('*in-the-debugger*', 'sb-debug', variable, "This is T while in the debugger.").
doc_string('*indent-formatted-output*', si, variable, "Variable in SI package:\nECL specific.\nThe FORMAT directive ~~% indents the next line, if the value of this variable\nis non-NIL.  If NIL, ~~% simply does Newline.\n").
doc_string('*init-hooks*', pkg_sys, variable, "This is a list of functions which are called in an unspecified\norder when a saved core image starts up, after the system itself has\nbeen initialized. Unused by SBCL itself: reserved for user and\napplications.").
doc_string('*inline-expansion-limit*', pkg_sys, variable, "an upper limit on the number of inline function calls that will be expanded\n   in any given code object (single function or block compilation)").
doc_string('*inspect-fun*', 'sb-impl', variable, "A function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector.").
doc_string('*inspected*', pkg_sys, variable, "the value currently being inspected in CL:INSPECT").
doc_string('*invoke-debugger-hook*', pkg_sys, variable, "This is either NIL or a designator for a function of two arguments,\n   to be run when the debugger is about to be entered.  The function is\n   run with *INVOKE-DEBUGGER-HOOK* bound to NIL to minimize recursive\n   errors, and receives as arguments the condition that triggered\n   debugger entry and the previous value of *INVOKE-DEBUGGER-HOOK*\n\n   This mechanism is an SBCL extension similar to the standard *DEBUGGER-HOOK*.\n   In contrast to *DEBUGGER-HOOK*, it is observed by INVOKE-DEBUGGER even when\n   called by BREAK.").
doc_string('*invoke-debugger-hook*', extensions, variable, "Variable in EXT package:\nECL specific.\nThis is either NIL or a designator for a function of two arguments,\nto be run when the debugger is about to be entered.  The function is\nrun with *INVOKE-DEBUGGER-HOOK* bound to NIL to minimize recursive\nerrors, and receives as arguments the condition that triggered\ndebugger entry and the previous value of *INVOKE-DEBUGGER-HOOK*\n\nThis mechanism is an extension similar to the standard *DEBUGGER-HOOK*.\nIn contrast to *DEBUGGER-HOOK*, it is observed by INVOKE-DEBUGGER even when\ncalled by BREAK.\n").
doc_string('*invoke-debugger-hook*', system, variable, "Like *DEBUGGER-HOOK* but observed by INVOKE-DEBUGGER even when\r\ncalled by BREAK. This hook is run before *DEBUGGER-HOOK*.").
doc_string('*ipd*', xp, variable, "initial print dispatch table.").
doc_string('*lisp-init-file-list*', extensions, variable, "List of files automatically loaded when WAM-CL is invoked.").
doc_string('*load-depth*', 'sb-fasl', variable, "the current number of recursive LOADs").
doc_string('*load-pathname*', 'common-lisp', variable, "the defaulted pathname that LOAD is currently loading").
doc_string('*load-paths*', custom, variable, "The list of directories where programs are searched on LOAD etc.").
doc_string('*load-print*', 'common-lisp', variable, "the default for the :PRINT argument to LOAD").
doc_string('*load-source-default-type*', 'sb-int', variable, "The source file types which LOAD looks for by default.").
doc_string('*load-truename*', 'common-lisp', variable, "the TRUENAME of the file that LOAD is currently loading").
doc_string('*load-verbose*', 'common-lisp', variable, "the default for the :VERBOSE argument to LOAD").
doc_string('*load-verbose*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe default value for the :VERBOSE parameter of LOAD.\nIt initial value is T.\n").
doc_string('*locating-circularities*', xp, variable, "Integer if making a first pass over things to identify circularities.\r\n   Integer used as counter for #n= syntax.").
doc_string('*long-site-name*', 'sb-sys', variable, "the value of LONG-SITE-NAME").
doc_string('*loop-destructuring-hooks*', si, variable, "If not NIL, this must be a list of two things:\na LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.").
doc_string('*macroexpand-hook*', 'common-lisp', variable, "The value of this variable must be a designator for a function that can\n  take three arguments, a macro expander function, the macro form to be\n  expanded, and the lexical environment to expand in. The function should\n  return the expanded form. This function is called by MACROEXPAND-1\n  whenever a runtime expansion is needed. Initially this is set to\n  FUNCALL.").
doc_string('*macroexpand-hook*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe value of this variable must be a three-argument function object.\nEach time a macro form is expanded, WAM-CL calls that function with\n        1. the macro expansion function (see MACRO-FUNCTION)\n        2. the macro form to expand\n        3. an environment (NIL in most case)\nas three arguments, and uses the returned value as the expanded form.\nThe initial value of this variable is the function FUNCALL.\n").
doc_string('*make-constant', si, function, "Function in SI package:\nArgs: (SYMBOL VALUE)\n\nECL specific.\nDeclares that the global variable named by SYMBOL is a constant with VALUE as\nits constant value.\n").
doc_string('*make-instance-initargs-cache*', mop, variable, "Cached sets of allowable initargs, keyed on the class they belong to.").
doc_string('*make-special', si, function, "Function in SI package:\nArgs: (SYMBOL)\n\nECL specific.\nDeclares the variable named by NAME as a special variable.\n").
doc_string('*max-optimize-iterations*', 'sb-c', variable, "The upper limit on the number of times that we will consecutively do IR1\noptimization that doesn't introduce any new code. A finite limit is\nnecessary, since type inference may take arbitrarily long to converge.").
doc_string('*max-trace-indentation*', 'sb-debug', variable, "If the trace indentation exceeds this value, then indentation restarts at\n   0.").
doc_string('*method-frame-style*', 'sb-debug', variable, "Determines how frames corresponding to method functions are represented in\nbacktraces. Possible values are :MINIMAL, :NORMAL, and :FULL.\n\n  :MINIMAL represents them as\n\n    (<gf-name> ...args...)\n\n    if all arguments are available, and only a single method is applicable to\n    the arguments -- otherwise behaves as :NORMAL.\n\n  :NORMAL represents them as\n\n    ((:method <gf-name> [<qualifier>*] (<specializer>*)) ...args...)\n\n    The frame is then followed by either [fast-method] or [slow-method],\n    designating the kind of method function. (See below.)\n\n  :FULL represents them using the actual funcallable method function name:\n\n    ((sb-pcl:fast-method <gf-name> [<qualifier>*] (<specializer>*)) ...args...)\n\n   or\n\n    ((sb-pcl:slow-method <gf-name> [<qualifier>*] (<specializer>*)) ...args...)\n\n   In the this case arguments may include values internal to SBCL's method\n   dispatch machinery.").
doc_string('*module-provider-functions*', pkg_sys, variable, "See function documentation for REQUIRE.").
doc_string('*module-provider-functions*', extensions, variable, "See function documentation for REQUIRE").
doc_string('*modules*', 'common-lisp', variable, "This is a list of module names that have been loaded into Lisp so far.\n   It is used by PROVIDE and REQUIRE.").
doc_string('*modules*', 'common-lisp', variable, "This is a list of module names that have been loaded into Lisp so far.\nIt is used by PROVIDE and REQUIRE.").
doc_string('*muffled-warnings*', pkg_sys, variable, "A type that ought to specify a subtype of WARNING.  Whenever a\nwarning is signaled, if the warning if of this type and is not\nhandled by any other handler, it will be muffled.").
doc_string('*on-package-variance*', pkg_sys, variable, "Specifies behavior when redefining a package using DEFPACKAGE and the\ndefinition is in variance with the current state of the package.\n\nThe value should be of the form:\n\n  (:WARN [T | packages-names] :ERROR [T | package-names])\n\nspecifying which packages get which behaviour -- with T signifying the default unless\notherwise specified. If default is not specified, :WARN is used.\n\n:WARN keeps as much state as possible and causes SBCL to signal a full warning.\n\n:ERROR causes SBCL to signal an error when the variant DEFPACKAGE form is executed,\nwith restarts provided for user to specify what action should be taken.\n\nExample:\n\n  (setf *on-package-variance* '(:warn (:swank :swank-backend) :error t))\n\nspecifies to signal a warning if SWANK package is in variance, and an error otherwise.").
doc_string('*output-routines*', 'sb-impl', variable, "List of all available output routines. Each element is a list of the\n  element-type output, the kind of buffering, the function name, and the number\n  of bytes per element.").
doc_string('*package*', 'common-lisp', variable, "the current package").
doc_string('*package*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe current package.  The initial value is the USER package.\n").
doc_string('*package-tasks-treat-specially*', custom, variable, "Treat package-related operations the same way at compile and load time.").
doc_string('*periodic-polling-function*', 'sb-sys', variable, "Either NIL, or a designator for a function callable without any\narguments. Called when the system has been waiting for input for\nlonger then *PERIODIC-POLLING-PERIOD* seconds. Shared between all\nthreads, unless locally bound. EXPERIMENTAL.").
doc_string('*periodic-polling-period*', 'sb-sys', variable, "A real number designating the number of seconds to wait for input\nat maximum, before calling the *PERIODIC-POLLING-FUNCTION* (if any.)\nShared between all threads, unless locally bound. EXPERIMENTAL.").
doc_string('*print-array*', 'common-lisp', variable, "Should the contents of arrays be printed?").
doc_string('*print-array*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies whether WAM-CL should print elements when it prints arrays other than\nstrings.  WAM-CL uses the following abbreviation notations.\n        #<bit-vector n>         for bit-vectors\n        #<vector n>             for vectors other than strings and bit-vectors\n        #<array n>              for arrays other than vectors\nwhere N is a number that identifies the array.\n").
doc_string('*print-base*', 'common-lisp', variable, "The output base for RATIONALs (including integers).").
doc_string('*print-base*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe radix used to print integers and ratios.  The value must be an integer\nfrom 2 to 36, inclusive.  The initial value is 10.\n").
doc_string('*print-case*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies how to print ordinary symbols.  Possible values are:\n        :UPCASE         in upper case\n        :DOWNCASE       in lower case\n        :CAPITALIZE     the first character in upper case, the rest in lower\nThe initial value is :UPCASE.\n").
doc_string('*print-case*', 'common-lisp', variable, "What case should the printer should use default?").
doc_string('*print-circle*', 'common-lisp', variable, "Should we use #n= and #n# notation to preserve uniqueness in general (and\n  circularity in particular) when printing?").
doc_string('*print-circle*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies whether the WAM-CL printer should take care of circular lists.\n").
doc_string('*print-escape*', 'common-lisp', variable, "Should we print in a reasonably machine-readable way? (possibly\n  overridden by *PRINT-READABLY*)").
doc_string('*print-escape*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies whether the WAM-CL printer should output objects in the way that they\ncan be reread later if possible.\n").
doc_string('*print-gensym*', 'common-lisp', variable, "Should #: prefixes be used when printing symbols with null SYMBOL-PACKAGE?").
doc_string('*print-gensym*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies whether the WAM-CL printer should prefix uninterned symbols with \"#:\".\n").
doc_string('*print-length*', 'common-lisp', variable, "How many elements at any level should be printed before abbreviating\n  with \"...\"?").
doc_string('*print-length*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies how many elements the WAM-CL printer should print when it prints a\nlist.  WAM-CL printer prints all elements if the value of this variable is NIL.\n").
doc_string('*print-level*', 'common-lisp', variable, "How many levels should be printed before abbreviating with \"#\"?").
doc_string('*print-level*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies how many levels of depth the WAM-CL printer should print when it prints\na list.  WAM-CL printer prints all levels if the value of this variable is NIL.\n").
doc_string('*print-lines*', 'common-lisp', variable, "The maximum number of lines to print per object.").
doc_string('*print-miser-width*', 'common-lisp', variable, "If the remaining space between the current column and the right margin\n   is less than this, then print using ``miser-style'' output. Miser\n   style conditional newlines are turned on, and all indentations are\n   turned off. If NIL, never use miser mode.").
doc_string('*print-pprint-dispatch*', 'common-lisp', variable, "The pprint-dispatch-table that controls how to pretty-print objects.").
doc_string('*print-pretty*', 'common-lisp', variable, "Should pretty printing be used?").
doc_string('*print-pretty*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies whether the WAM-CL printer should pretty-print.  See PPRINT for more\ninformation about pretty-printing.\n").
doc_string('*print-radix*', 'common-lisp', variable, "Should base be verified when printing RATIONALs?").
doc_string('*print-radix*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nSpecifies whether the WAM-CL printer should print the radix when it prints\nintegers and ratios.\n").
doc_string('*print-readably*', 'common-lisp', variable, "If true, all objects will be printed readably. If readable printing\n  is impossible, an error will be signalled. This overrides the value of\n  *PRINT-ESCAPE*.").
doc_string('*print-right-margin*', 'common-lisp', variable, "The position of the right margin in ems (for pretty-printing).").
doc_string('*prompt-body*', custom, variable, "The main top level prompt.").
doc_string('*prompt-break*', custom, variable, "The break level part of the prompt, may use `EXT:BREAK-LEVEL'.").
doc_string('*prompt-finish*', custom, variable, "The final part of the prompt").
doc_string('*prompt-start*', custom, variable, "The initial part of the prompt, defaults to an empty string.").
doc_string('*prompt-step*', custom, variable, "The stepper part of the prompt, may use `EXT:STEP-LEVEL'.").
doc_string('*query-io*', 'common-lisp', variable, "query I/O stream").
doc_string('*query-io*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe query I/O stream. The initial value is a synonym stream to *TERMINAL-IO*.\n").
doc_string('*random-state*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe default random-state object used by RANDOM.\n").
doc_string('*read-base*', 'common-lisp', variable, "the radix that Lisp reads numbers in").
doc_string('*read-base*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe radix used to read numbers.  The initial value is 10.\n").
doc_string('*read-default-float-format*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe default float format the WAM-CL reader uses when reading floats.  Must be one\nof the symbols SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, and LONG-FLOAT.\n").
doc_string('*read-eval*', 'common-lisp', variable, "If false, then the #. read macro is disabled.").
doc_string('*read-suppress*', 'common-lisp', variable, "Suppress most interpreting in the reader when T.").
doc_string('*read-suppress*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nWhen the value of this variable is non-NIL, the WAM-CL reader parses input\ncharacters without most of the ordinary processings such as interning.  Used\nto skip over forms.\n").
doc_string('*readline-input-stream*', readline, variable, "Use this input stream to allow readline editing.").
doc_string('*readtable*', 'common-lisp', variable, "Variable bound to current readtable.").
doc_string('*readtable*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe current readtable.\n").
doc_string('*reinitialize-instance-initargs-cache*', mop, variable, "Cached sets of allowable initargs, keyed on the class they belong to.").
doc_string('*repl-fun-generator*', 'sb-impl', variable, "A function of no arguments returning a function of one argument NOPRINT\nthat provides the REPL for the system. Assumes that *STANDARD-INPUT* and\n*STANDARD-OUTPUT* are set up.").
doc_string('*repl-prompt-fun*', 'sb-int', variable, "A function of one argument STREAM for the toplevel REPL to call: Prompt\nthe user for input.").
doc_string('*repl-read-form-fun*', 'sb-int', variable, "A function of two stream arguments IN and OUT for the toplevel REPL to\ncall: Return the next Lisp form to evaluate (possibly handling other magic --\nlike ACL-style keyword commands -- which precede the next Lisp form). The OUT\nstream is there to support magic which requires issuing new prompts.").
doc_string('*result*', xp, variable, "used to pass back a value").
doc_string('*runtime-pathname*', pkg_sys, variable, "The absolute pathname of the running SBCL runtime.").
doc_string('*save-hooks*', pkg_sys, variable, "This is a list of functions which are called in an unspecified\norder before creating a saved core image. Unused by SBCL itself:\nreserved for user and applications.").
doc_string('*saveinitmem-verbose*', custom, variable, "The default value for the :VERBOSE argument of SAVEINITMEM.").
doc_string('*setf-fdefinition-hook*', 'sb-int', variable, "A list of functions that (SETF FDEFINITION) invokes before storing the\n   new value. The functions take the function name and the new value.").
doc_string('*short-site-name*', 'sb-sys', variable, "The value of SHORT-SITE-NAME.").
doc_string('*show-entry-point-details*', 'sb-debug', variable, "The variable SB-DEBUG:*SHOW-ENTRY-POINT-DETAILS* has been deprecated as of SBCL version 1.1.4.9.").
doc_string('*stack-allocate-dynamic-extent*', pkg_sys, variable, "If true (the default), the compiler respects DYNAMIC-EXTENT declarations\nand stack allocates otherwise inaccessible parts of the object whenever\npossible. Potentially long (over one page in size) vectors are, however, not\nstack allocated except in zero SAFETY code, as such a vector could overflow\nthe stack without triggering overflow protection.").
doc_string('*standard-input*', 'common-lisp', variable, "default input stream").
doc_string('*standard-input*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe default input stream used by the WAM-CL reader.  The initial value is a\nsynonym stream to *TERMINAL-IO*.\n").
doc_string('*standard-output*', 'common-lisp', variable, "default output stream").
doc_string('*standard-output*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe default output stream used by the WAM-CL printer.  The initial value is a\nsynonym stream to *TERMINAL-IO*.\n").
doc_string('*step-level*', system, variable, "current Step-depth").
doc_string('*step-quit*', system, variable, "critical Step-depth").
doc_string('*stepper-hook*', pkg_sys, variable, "Customization hook for alternative single-steppers.\n*STEPPER-HOOK* is bound to NIL prior to calling the bound function\nwith the STEP-CONDITION as argument.").
doc_string('*suppress-print-errors*', pkg_sys, variable, "Suppress printer errors when the condition is of the type designated by this\nvariable: an unreadable object representing the error is printed instead.").
doc_string('*suppress-similar-constant-redefinition-warning*', custom, variable, "\r\nWhen non-NIL, no warning is issued when a constant is redefined\r\nto a new value which is visually similar (prints identically) to the old one.").
doc_string('*suppress-values-declaration*', 'sb-c', variable, "If true, processing of the VALUES declaration is inhibited.").
doc_string('*sysinit-pathname-function*', pkg_sys, variable, "Designator for a function of zero arguments called to obtain a\npathname designator for the default sysinit file, or NIL. If the\nfunction returns NIL, no sysinit file is used unless one has been\nspecified on the command-line.").
doc_string('*system-package-list*', custom, variable, "\r\nThe list of packages that will be locked by SAVEINITMEM.\r\nAlso the default packages to unlock by WITHOUT-PACKAGE-LOCK.").
doc_string('*terminal-io*', 'common-lisp', variable, "terminal I/O stream").
doc_string('*terminal-io*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe terminal I/O stream.\n").
doc_string('*trace-encapsulate-default*', 'sb-debug', variable, "the default value for the :ENCAPSULATE option to TRACE").
doc_string('*trace-indent*', custom, variable, "Use indentation in addition to numbering to indicate the trace level.").
doc_string('*trace-indentation-step*', 'sb-debug', variable, "the increase in trace indentation at each call level").
doc_string('*trace-output*', 'common-lisp', variable, "trace output stream").
doc_string('*trace-output*', 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe stream used for trace output.  The initial value is a synonym stream to\n*TERMINAL-IO*.\n").
doc_string('*undefined-warning-limit*', pkg_sys, variable, "If non-null, then an upper limit on the number of unknown function or type\n  warnings that the compiler will print for any given name in a single\n  compilation. This prevents excessive amounts of output when the real\n  problem is a missing definition (as opposed to a typo in the use.)").
doc_string('*unprocessed-ecl-command-args*', extensions, variable, "As part of WAM-CL's command line rules, this variable stores all arguments which\nappeared after a '--'.").
doc_string('*user-commands*', custom, variable, "\r\nThe list of functions, each of which should return a list of bindings.\r\nA `binding' is either a doc string (printed by `Help' or `:h')\r\nor a pair (STRING . FUNCTION) so that typing STRING will call FUNCTION.").
doc_string('*user-lib-directory*', custom, variable, "The location of user-installed modules.").
doc_string('*userinit-pathname-function*', pkg_sys, variable, "Designator for a function of zero arguments called to obtain a\npathname designator or a stream for the default userinit file, or NIL.\nIf the function returns NIL, no userinit file is used unless one has\nbeen specified on the command-line.").
doc_string('+bytes-per-buffer+', 'sb-impl', variable, "Default number of bytes per buffer.").
doc_string('+slot-unbound+', 'sb-pcl', variable, "SBCL specific extensions to MOP: if this value is read from an\ninstance using STANDARD-INSTANCE-ACCESS, the slot is unbound.\nSimilarly, an :INSTANCE allocated slot can be made unbound by\nassigning this to it using (SETF STANDARD-INSTANCE-ACCESS).\n\nValue of +SLOT-UNBOUND+ is unspecified, and should not be relied to be\nof any particular type, but it is guaranteed to be suitable for EQ\ncomparison.").
doc_string('+the-standard-method-combination+', mop, variable, "The standard method combination.\r\nDo not use this object for identity since it changes between\r\ncompile-time and run-time.  To detect the standard method combination,\r\ncompare the method combination name to the symbol 'standard.").
doc_string('1+', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns NUMBER plus one.\n").
doc_string('1+', 'common-lisp', function, "Return NUMBER + 1.").
doc_string('1-', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns NUMBER minus one.\n").
doc_string('1-', 'common-lisp', function, "Return NUMBER - 1.").
doc_string('abort-on-error', sys, function, "(ABORT-ON-ERROR {form}*) executes the forms and aborts all errors.").
doc_string('abort-thread', 'sb-thread', function, "Unwinds from and terminates the current thread abnormally, causing\nJOIN-THREAD on current thread to signal an error unless a\ndefault-value is provided.\n\nIf current thread is the main thread of the process (see\nMAIN-THREAD-P), signals an error unless ALLOW-EXIT is true, as\nterminating the main thread would terminate the entire process. If\nALLOW-EXIT is true, aborting the main thread is equivalent to calling\nSB-EXT:EXIT code 1 and :ABORT NIL.\n\nInvoking the initial ABORT restart established by MAKE-THREAD is\nequivalent to calling ABORT-THREAD in other than main threads.\nHowever, whereas ABORT restart may be rebound, ABORT-THREAD always\nunwinds the entire thread. (Behaviour of the initial ABORT restart for\nmain thread depends on the :TOPLEVEL argument to\nSB-EXT:SAVE-LISP-AND-DIE.)\n\nSee also: RETURN-FROM-THREAD and SB-EXT:EXIT.").
doc_string('add-defun', readline, function, "\r\nBind function to a name and key. You can use\r\nname in ~/.inputrc. This is preferred way of adding new functions.").
doc_string('add-fd-handler', 'sb-sys', function, "Arrange to call FUNCTION whenever FD is usable. DIRECTION should be\n  either :INPUT or :OUTPUT. The value returned should be passed to\n  SYSTEM:REMOVE-FD-HANDLER when it is no longer needed.").
doc_string('add-funmap-entry', readline, function, "Bind function to a name known to readline.").
doc_string('add-implementation-package', pkg_sys, function, "Adds PACKAGES-TO-ADD as implementation packages of PACKAGE. Signals\nan error if PACKAGE or any of the PACKAGES-TO-ADD is not a valid\npackage designator.").
doc_string('add-package-local-nickname', pkg_sys, function, "Adds LOCAL-NICKNAME for ACTUAL-PACKAGE in the designated package, defaulting\nto current package. LOCAL-NICKNAME must be a string designator, and\nACTUAL-PACKAGE must be a package designator.\n\nReturns the designated package.\n\nSignals a continuable error if LOCAL-NICKNAME is already a package local\nnickname for a different package, or if LOCAL-NICKNAME is one of \"CL\",\n\"COMMON-LISP\", or, \"KEYWORD\", or if LOCAL-NICKNAME is a global name or\nnickname for the package to which the nickname would be added.\n\nWhen in the designated package, calls to FIND-PACKAGE with the LOCAL-NICKNAME\nwill return the package the designated ACTUAL-PACKAGE instead. This also\naffects all implied calls to FIND-PACKAGE, including those performed by the\nreader.\n\nWhen printing a package prefix for a symbol with a package local nickname,\nlocal nickname is used instead of the real name in order to preserve\nprint-read consistency.\n\nSee also: PACKAGE-LOCAL-NICKNAMES, PACKAGE-LOCALLY-NICKNAMED-BY-LIST,\nREMOVE-PACKAGE-LOCAL-NICKNAME, and the DEFPACKAGE option :LOCAL-NICKNAMES.\n\nExperimental: interface subject to change.").
doc_string('adjust-array', 'common-lisp', function, "Adjust ARRAY's dimensions to the given DIMENSIONS and stuff.").
doc_string('adjust-array', 'common-lisp', function, "Args: (array dimensions\n       &key (element-type (array-element-type array))\n            initial-element (initial-contents nil) (fill-pointer nil)\n            (displaced-to nil) (displaced-index-offset 0))\nAdjusts the dimensions of ARRAY to the given DIMENSIONS.  ARRAY must be an\nadjustable array.").
doc_string('adjust-sequence', 'sb-sequence', function, "Return destructively modified SEQUENCE or a freshly allocated\n   sequence of the same class as SEQUENCE of length LENGTH. Elements\n   of the returned sequence are initialized to INITIAL-ELEMENT, if\n   supplied, initialized to INITIAL-CONTENTS if supplied, or identical\n   to the elements of SEQUENCE if neither is supplied. Signals a\n   PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not\n   implemented for the class of SEQUENCE.").
doc_string('adjustable-array-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY)\n\nReturns T if ARRAY is adjustable; NIL otherwise.\n").
doc_string('adjustable-array-p', 'common-lisp', function, "Return T if (ADJUST-ARRAY ARRAY...) would return an array identical\n   to the argument, this happens for complex arrays.").
doc_string('alien-callback', 'sb-alien-internals', function, "Returns an alien-value with of alien ftype SPECIFIER, that can be passed to\nan alien function as a pointer to the FUNCTION. If a callback for the given\nSPECIFIER and FUNCTION already exists, it is returned instead of consing a new\none.").
doc_string('alien-callback-function', 'sb-alien', function, "Returns the lisp function designator associated with the callback.").
doc_string('alien-callback-p', 'sb-alien', function, "Returns true if the alien is associated with a lisp-side callback,\nand a secondary return value of true if the callback is still valid.").
doc_string('alien-funcall', 'sb-alien', function, "Call the foreign function ALIEN with the specified arguments. ALIEN's\ntype specifies the argument and result types.").
doc_string('alien-sap', 'sb-alien', function, "Return a System-Area-Pointer pointing to Alien's data.").
doc_string('alien-size', 'sb-alien', function, "Return the size of the alien type TYPE. UNITS specifies the units to\n   use and can be either :BITS, :BYTES, or :WORDS.").
doc_string('alien-subtype-p', 'sb-alien-internals', function, "Return T iff the alien type TYPE1 is a subtype of TYPE2. Currently, the\n   only supported subtype relationships are is that any pointer type is a\n   subtype of (* t), and any array type first dimension will match\n   (array <eltype> nil ...). Otherwise, the two types have to be\n   ALIEN-TYPE-=.").
doc_string('alien-type-=', 'sb-alien-internals', function, "Return T iff TYPE1 and TYPE2 describe equivalent alien types.").
doc_string('alien-typep', 'sb-alien-internals', function, "Return T iff OBJECT is an alien of type TYPE.").
doc_string('alien-value', 'sb-alien-internals', function, "Returns the value of the alien variable bound to SYMBOL. Signals an\nerror if SYMBOL is not bound to an alien variable, or if the alien\nvariable is undefined.").
doc_string('allocate-instance', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CLASS LENGTH)\n\nECL/CLOS specific.\nAllocates an istance of CLASS with LENGTH slots.\n").
doc_string('alpha-char-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is alphabetic; NIL otherwise.\n").
doc_string('alpha-char-p', 'common-lisp', function, "The argument must be a character object. ALPHA-CHAR-P returns T if the\nargument is an alphabetic character, A-Z or a-z; otherwise NIL.").
doc_string('alphabetic-p', 'sb-unicode', function, "Returns T if CHARACTER is Alphabetic according to the Unicode standard\nand NIL otherwise").
doc_string('ambiguous-var-name-frame', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('ambiguous-var-name-name', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('appease-cerrors', sys, function, "\r\n(APPEASE-CERRORS {form}*) executes the forms, but turns continuable errors\r\ninto warnings. A continuable error is signalled again as a warning, then\r\nits CONTINUE restart is invoked.").
doc_string('append-segment', 'sb-assem', function, "Append OTHER-SEGMENT to the end of SEGMENT. Don't use OTHER-SEGMENT\n   for anything after this.").
doc_string('apropos-list', 'common-lisp', function, "Args: (string &optional (package nil))\nReturns a list of all symbols whose print-names contain STRING as substring.\nIf PACKAGE is non-NIL, then only the specified PACKAGE is searched.").
doc_string('apropos-list', 'common-lisp', function, "Like APROPOS, except that it returns a list of the symbols found instead\n  of describing them.").
doc_string('arg-count-error-args', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('arg-count-error-lambda-list', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('arg-count-error-maximum', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('arg-count-error-minimum', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('arithmetic-error-operands', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('arithmetic-error-operation', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('array-dimension', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY N)\n\nReturns the length of the N-th dimension of ARRAY.\n").
doc_string('array-dimension', 'common-lisp', function, "Return the length of dimension AXIS-NUMBER of ARRAY.").
doc_string('array-dimension-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound of the length of an array dimension.\n").
doc_string('array-dimension-limit', 'common-lisp', variable, "the exclusive upper bound on any given dimension of an array").
doc_string('array-dimensions', 'common-lisp', function, "Args: (array)\nReturns a list whose N-th element is the length of the N-th dimension of ARRAY.").
doc_string('array-dimensions', 'common-lisp', function, "Return a list whose elements are the dimensions of the array").
doc_string('array-displacement', 'common-lisp', function, "Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset\n   options to MAKE-ARRAY, or NIL and 0 if not a displaced array.").
doc_string('array-element-type', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY)\n\nReturns the element type ARRAY.\n").
doc_string('array-element-type', 'common-lisp', function, "Return the type of the elements of the array").
doc_string('array-has-fill-pointer-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY)\n\nReturns T if ARRAY has a fill-pointer; NIL otherwise.\n").
doc_string('array-has-fill-pointer-p', 'common-lisp', function, "Return T if the given ARRAY has a fill pointer, or NIL otherwise.").
doc_string('array-header-p', 'sb-kernel', function, "Return true if OBJECT is an ARRAY-HEADER, and NIL otherwise.").
doc_string('array-in-bounds-p', 'common-lisp', function, "Args: (array &rest indexes)\nReturns T if INDEXes are valid indexes of ARRAY; NIL otherwise.  The number of\nINDEXes must be equal to the rank of ARRAY.").
doc_string('array-in-bounds-p', 'common-lisp', function, "Return T if the SUBSCRIPTS are in bounds for the ARRAY, NIL otherwise.").
doc_string('array-rank', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY)\n\nReturns the rank of ARRAY.\n").
doc_string('array-rank', 'common-lisp', function, "Return the number of dimensions of ARRAY.").
doc_string('array-rank-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound of the rank of an array.\n").
doc_string('array-rank-limit', 'common-lisp', variable, "the exclusive upper bound on the rank of an array").
doc_string('array-row-major-index', 'common-lisp', function, "Args: (array &rest indexes)\nReturns the non-negative integer that represents the location of the element\nof ARRAY specified by INDEXes, assuming all elements of ARRAY are aligned in\nrow-major order.").
doc_string('array-storage-vector', pkg_sys, function, "Returns the underlying storage vector of ARRAY, which must be a non-displaced array.\n\nIn SBCL, if ARRAY is a of type (SIMPLE-ARRAY * (*)), it is its own storage\nvector. Multidimensional arrays, arrays with fill pointers, and adjustable\narrays have an underlying storage vector with the same ARRAY-ELEMENT-TYPE as\nARRAY, which this function returns.\n\nImportant note: the underlying vector is an implementation detail. Even though\nthis function exposes it, changes in the implementation may cause this\nfunction to be removed without further warning.").
doc_string('array-total-size', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY)\n\nReturns the total number of elements of ARRAY.\n").
doc_string('array-total-size', 'common-lisp', function, "Return the total number of elements in the Array.").
doc_string('array-total-size-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound of the total number of elements of an array.\n").
doc_string('array-total-size-limit', 'common-lisp', variable, "the exclusive upper bound on the total number of elements in an array").
doc_string('assert-version->=', pkg_sys, function, "Asserts that the current SBCL is of version equal to or greater than\nthe version specified in the arguments.  A continuable error is signaled\notherwise.\n\nThe arguments specify a sequence of subversion numbers in big endian order.\nThey are compared lexicographically with the runtime version, and versions\nare treated as though trailed by an unbounded number of 0s.\n\nFor example, (assert-version->= 1 1 4) asserts that the current SBCL is\nversion 1.1.4[.0.0...] or greater, and (assert-version->= 1) that it is\nversion 1[.0.0...] or greater.").
doc_string('assoc-if', 'common-lisp', function, "Return the first cons in ALIST whose CAR satisfies PREDICATE. If\n   KEY is supplied, apply it to the CAR of each cons before testing.").
doc_string('assoc-if', 'common-lisp', function, "Returns the first pair in ALIST whose car satisfies TEST.  Returns NIL if no\nsuch pair exists.").
doc_string('assoc-if-not', 'common-lisp', function, "Return the first cons in ALIST whose CAR does not satisfy PREDICATE.\n  If KEY is supplied, apply it to the CAR of each cons before testing.").
doc_string('assoc-if-not', 'common-lisp', function, "Returns the first pair in ALIST whose car does not satisfy TEST.  Returns NIL\nif no such pair exists.").
doc_string('atomic-decf', pkg_sys, function, "Atomically decrements PLACE by DIFF, and returns the value of PLACE before\nthe decrement.\n\nPLACE must access one of the following:\n - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 64)\n   or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))\n   The type SB-EXT:WORD can be used for these purposes.\n - CAR or CDR (respectively FIRST or REST) of a CONS.\n - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM.\nMacroexpansion is performed on PLACE before expanding ATOMIC-DECF.\n\nDecrementing is done using modular arithmetic,\nwhich is well-defined over two different domains:\n - For structures and arrays, the operation accepts and produces\n   an (UNSIGNED-BYTE 64), and DIFF must be of type (SIGNED-BYTE 64).\n   ATOMIC-DECF of #x0 by one results in #xFFFFFFFFFFFFFFFF being stored in PLACE.\n - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM.\n   ATOMIC-DECF of #x-4000000000000000 by one results in #x3FFFFFFFFFFFFFFF\n   being stored in PLACE.\n\nDIFF defaults to 1.\n\nEXPERIMENTAL: Interface subject to change.").
doc_string('atomic-defgeneric', mop, function, "Macro to define a generic function and 'swap it into place' after\r\nit's been fully defined with all its methods.\r\n\r\nNote: the user should really use the (:method ..) method description\r\nway of defining methods; there's not much use in atomically defining\r\ngeneric functions without providing sensible behaviour.").
doc_string('atomic-incf', pkg_sys, function, "Atomically increments PLACE by DIFF, and returns the value of PLACE before\nthe increment.\n\nPLACE must access one of the following:\n - a DEFSTRUCT slot with declared type (UNSIGNED-BYTE 64)\n   or AREF of a (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))\n   The type SB-EXT:WORD can be used for these purposes.\n - CAR or CDR (respectively FIRST or REST) of a CONS.\n - a variable defined using DEFGLOBAL with a proclaimed type of FIXNUM.\nMacroexpansion is performed on PLACE before expanding ATOMIC-INCF.\n\nIncrementing is done using modular arithmetic,\nwhich is well-defined over two different domains:\n - For structures and arrays, the operation accepts and produces\n   an (UNSIGNED-BYTE 64), and DIFF must be of type (SIGNED-BYTE 64).\n   ATOMIC-INCF of #xFFFFFFFFFFFFFFFF by one results in #x0 being stored in PLACE.\n - For other places, the domain is FIXNUM, and DIFF must be a FIXNUM.\n   ATOMIC-INCF of #x3FFFFFFFFFFFFFFF by one results in #x-4000000000000000\n   being stored in PLACE.\n\nDIFF defaults to 1.\n\nEXPERIMENTAL: Interface subject to change.").
doc_string('atomic-pop', pkg_sys, function, "Like POP, but atomic. PLACE may be read multiple times before\nthe operation completes -- the write does not occur until such time\nthat no other thread modified PLACE between the read and the write.\n\nWorks on all CASable places.").
doc_string('atomic-push', pkg_sys, function, "Like PUSH, but atomic. PLACE may be read multiple times before\nthe operation completes -- the write does not occur until such time\nthat no other thread modified PLACE between the read and the write.\n\nWorks on all CASable places.").
doc_string('atomic-update', pkg_sys, function, "Updates PLACE atomically to the value returned by calling function\ndesignated by UPDATE-FN with ARGUMENTS and the previous value of PLACE.\n\nPLACE may be read and UPDATE-FN evaluated and called multiple times before the\nupdate succeeds: atomicity in this context means that value of place did not\nchange between the time it was read, and the time it was replaced with the\ncomputed value.\n\nPLACE can be any place supported by SB-EXT:COMPARE-AND-SWAP.\n\nExamples:\n\n  ;;; Conses T to the head of FOO-LIST.\n  (defstruct foo list)\n  (defvar *foo* (make-foo))\n  (atomic-update (foo-list *foo*) #'cons t)\n\n  (let ((x (cons :count 0)))\n     (mapc #'sb-thread:join-thread\n           (loop repeat 1000\n                 collect (sb-thread:make-thread\n                          (lambda ()\n                            (loop repeat 1000\n                                  do (atomic-update (cdr x) #'1+)\n                                     (sleep 0.00001))))))\n     ;; Guaranteed to be (:COUNT . 1000000) -- if you replace\n     ;; atomic update with (INCF (CDR X)) above, the result becomes\n     ;; unpredictable.\n     x)\n").
doc_string('autoload-ref-p', extensions, function, "Boolean predicate for whether SYMBOL has generalized reference functions which need to be resolved.").
doc_string('autoload-setf-expander', extensions, function, "Setup the autoload for SYMBOL-OR-SYMBOLS on the setf-expander from FILENAME.").
doc_string('autoload-setf-function', extensions, function, "Setup the autoload for SYMBOL-OR-SYMBOLS on the setf-function from FILENAME.").
doc_string('available-encodings', system, function, "Returns all charset encodings suitable for passing to a stream constructor available at runtime.").
doc_string('backtrace-as-list', 'sb-debug', function, "The function SB-DEBUG:BACKTRACE-AS-LIST has been deprecated as of SBCL version 1.2.15.\n\nUse SB-DEBUG:LIST-BACKTRACE instead.").
doc_string('backtrace-as-list', system, function, "Return BACKTRACE with each element converted to a list.").
doc_string('base-char-p', 'sb-kernel', function, "Return true if OBJECT is a BASE-CHAR, and NIL otherwise.").
doc_string('base-string-p', 'sb-kernel', function, "Return true if OBJECT is a BASE-STRING, and NIL otherwise.").
doc_string('bds-val', si, function, "Function in SI package:\nArgs: (N)\n\nECL specific.\nReturns the value of the N-th entity in the bind stack.\n").
doc_string('bds-var', si, function, "Function in SI package:\nArgs: (N)\n\nECL specific.\nReturns the symbol of the N-th entity in the bind stack.\n").
doc_string('bidi-class', 'sb-unicode', function, "Returns the bidirectional class of CHARACTER").
doc_string('bidi-mirroring-glyph', 'sb-unicode', function, "Returns the mirror image of CHARACTER if it exists.\nOtherwise, returns NIL.").
doc_string('bit-and', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise AND of BIT-ARRAY1 and BIT-ARRAY2.  Puts the results\ninto a new bit-array if RESULT is NIL, into BIT-ARRAY1 if RESULT is T, or into\nRESULT if RESULT is a bit-array.").
doc_string('bit-and', 'common-lisp', function, "Perform a bit-wise LOGAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-andc1', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise AND of {the element-wise NOT of BIT-ARRAY1} and BIT-\nARRAY2.  Puts the results into a new bit-array if RESULT is NIL, into BIT-\nARRAY1 if RESULT is T, or into RESULT if RESULT is a bit-array.").
doc_string('bit-andc1', 'common-lisp', function, "Perform a bit-wise LOGANDC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-andc2', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise AND of BIT-ARRAY1 and {the element-wise NOT of BIT-\nARRAY2}.  Puts the results into a new bit-array if RESULT is NIL, into BIT-\nARRAY1 if RESULT is T, or into RESULT if RESULT is a bit-array.").
doc_string('bit-andc2', 'common-lisp', function, "Perform a bit-wise LOGANDC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-eqv', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise EQUIVALENCE of BIT-ARRAY1 and BIT-ARRAY2.  Puts the\nresults into a new bit-array if RESULT is NIL, into BIT-ARRAY1 if RESULT is T,\nor into RESULT if RESULT is a bit-array.").
doc_string('bit-eqv', 'common-lisp', function, "Perform a bit-wise LOGEQV on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-ior', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise INCLUSIVE OR of BIT-ARRAY1 and BIT-ARRAY2.  Puts the\nresults into a new bit-array if RESULT is NIL, into BIT-ARRAY1 if RESULT is T,\nor into RESULT if RESULT is a bit-array.").
doc_string('bit-ior', 'common-lisp', function, "Perform a bit-wise LOGIOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-nand', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise NOT of {the element-wise AND of BIT-ARRAY1 and BIT-\nARRAY2}.  Puts the results into a new bit-array if RESULT is NIL, into BIT-\nARRAY1 if RESULT is T, or into RESULT if RESULT is a bit-array.").
doc_string('bit-nand', 'common-lisp', function, "Perform a bit-wise LOGNAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-nor', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise NOT of {the element-wise INCLUSIVE OR of BIT-ARRAY1\nand BIT-ARRAY2}.  Puts the results into a new bit-array if RESULT is NIL, into\nBIT-ARRAY1 if RESULT is T, or into RESULT if RESULT is a bit-array.").
doc_string('bit-nor', 'common-lisp', function, "Perform a bit-wise LOGNOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-not', 'common-lisp', function, "Args: (bit-array &optional (result nil))\nReturns the element-wise NOT of BIT-ARRAY.  Puts the results into a new bit-\narray if RESULT is NIL, into BIT-ARRAY if RESULT is T, or into RESULT if\nRESULT is a bit-array.").
doc_string('bit-not', 'common-lisp', function, "Performs a bit-wise logical NOT on the elements of BIT-ARRAY,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. Both arrays must have the same rank and dimensions.").
doc_string('bit-orc1', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise INCLUSIVE OR of {the element-wise NOT of BIT-ARRAY1}\nand BIT-ARRAY2.  Puts the results into a new bit-array if RESULT is NIL, into\nBIT-ARRAY1 if RESULT is T, or into RESULT if RESULT is a bit-array.").
doc_string('bit-orc1', 'common-lisp', function, "Perform a bit-wise LOGORC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-orc2', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise INCLUSIVE OR of BIT-ARRAY1 and {the element-wise NOT\nof BIT-ARRAY2}.  Puts the results into a new bit-array if RESULT is NIL, into\nBIT-ARRAY1 if RESULT is T, or into RESULT if RESULT is a bit-array.").
doc_string('bit-orc2', 'common-lisp', function, "Perform a bit-wise LOGORC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('bit-vector-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a bit-vector; NIL otherwise.\n").
doc_string('bit-vector-p', 'common-lisp', function, "Return true if OBJECT is a BIT-VECTOR, and NIL otherwise.").
doc_string('bit-xor', 'common-lisp', function, "Args: (bit-array1 bit-array2 &optional (result nil))\nReturns the element-wise EXCLUSIVE OR of BIT-ARRAY1 and BIT-ARRAY2.  Puts the\nresults into a new bit-array if RESULT is NIL, into BIT-ARRAY1 if RESULT is T,\nor into RESULT if RESULT is a bit-array.").
doc_string('bit-xor', 'common-lisp', function, "Perform a bit-wise LOGXOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,\n  putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,\n  BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is\n  created. All the arrays must have the same rank and dimensions.").
doc_string('block-attributep', 'sb-c', function, "Automagically generated boolean attribute test function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('block-attributes', 'sb-c', function, "Automagically generated boolean attribute creation function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('boole-1', 'common-lisp', variable, "Boole function op, makes BOOLE return integer1.").
doc_string('boole-1', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return INTEGER1.\n").
doc_string('boole-2', 'common-lisp', variable, "Boole function op, makes BOOLE return integer2.").
doc_string('boole-2', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return INTEGER2.\n").
doc_string('boole-and', 'common-lisp', variable, "Boole function op, makes BOOLE return logand of integer1 and integer2.").
doc_string('boole-and', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the AND of INTEGER1 and INTEGER2.\n").
doc_string('boole-andc1', 'common-lisp', variable, "Boole function op, makes BOOLE return logandc1 of integer1 and integer2.").
doc_string('boole-andc1', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the AND of {the NOT of INTEGER1} and INTEGER2.\n").
doc_string('boole-andc2', 'common-lisp', variable, "Boole function op, makes BOOLE return logandc2 of integer1 and integer2.").
doc_string('boole-andc2', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the AND of INTEGER1 and {the NOT of INTEGER2}.\n").
doc_string('boole-c1', 'common-lisp', variable, "Boole function op, makes BOOLE return complement of integer1.").
doc_string('boole-c1', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the NOT of INTEGER1.\n").
doc_string('boole-c2', 'common-lisp', variable, "Boole function op, makes BOOLE return complement of integer2.").
doc_string('boole-c2', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the NOT of INTEGER2.\n").
doc_string('boole-clr', 'common-lisp', variable, "Boole function op, makes BOOLE return 0.").
doc_string('boole-clr', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return 0.\n").
doc_string('boole-eqv', 'common-lisp', variable, "Boole function op, makes BOOLE return logeqv of integer1 and integer2.").
doc_string('boole-eqv', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the EQUIVALENCE of INTEGER1 and INTEGER2.\n").
doc_string('boole-ior', 'common-lisp', variable, "Boole function op, makes BOOLE return logior of integer1 and integer2.").
doc_string('boole-ior', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the INCLUSIVE OR of INTEGER1 and INTEGER2.\n").
doc_string('boole-nand', 'common-lisp', variable, "Boole function op, makes BOOLE return log nand of integer1 and integer2.").
doc_string('boole-nand', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the NOT of {the AND of INTEGER1 and INTEGER2}.\n").
doc_string('boole-nor', 'common-lisp', variable, "Boole function op, makes BOOLE return lognor of integer1 and integer2.").
doc_string('boole-nor', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the NOT of {the INCLUSIVE OR of INTEGER1 and INTEGER2}.\n").
doc_string('boole-orc1', 'common-lisp', variable, "Boole function op, makes BOOLE return logorc1 of integer1 and integer2.").
doc_string('boole-orc1', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the INCLUSIVE OR of {the NOT of INTEGER1} and INTEGER2.\n").
doc_string('boole-orc2', 'common-lisp', variable, "Boole function op, makes BOOLE return logorc2 of integer1 and integer2.").
doc_string('boole-orc2', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the INCLUSIVE OR of INTEGER1 and {the NOT of INTEGER2}.\n").
doc_string('boole-set', 'common-lisp', variable, "Boole function op, makes BOOLE return -1.").
doc_string('boole-set', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return -1.\n").
doc_string('boole-xor', 'common-lisp', variable, "Boole function op, makes BOOLE return logxor of integer1 and integer2.").
doc_string('boole-xor', 'common-lisp', variable, "Constant in COMMON-LISP package:\nMakes BOOLE return the EXCLUSIVE OR of INTEGER1 and INTEGER2.\n").
doc_string('bootstrap-package-name', 'sb-int', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('both-case-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is an alphabetic character; NIL otherwise.  Equivalent to\nALPHA-CHAR-P.\n").
doc_string('both-case-p', 'common-lisp', function, "The argument must be a character object. BOTH-CASE-P returns T if the\nargument is an alphabetic character and if the character exists in both upper\nand lower case. For ASCII, this is the same as ALPHA-CHAR-P.").
doc_string('bounding-indices-bad-object', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('byte-position', 'common-lisp', function, "Args: (byte)\nReturns the position part (in WAM-CL, the cdr part) of the byte specifier BYTE.").
doc_string('byte-position', 'common-lisp', function, "Return the position part of the byte specifier bytespec.").
doc_string('byte-size', 'common-lisp', function, "Args: (byte)\nReturns the size part (in WAM-CL, the car part) of the byte specifier BYTE.").
doc_string('byte-size', 'common-lisp', function, "Return the size part of the byte specifier bytespec.").
doc_string('bytes-consed-between-gcs', pkg_sys, function, "The amount of memory that will be allocated before the next garbage\ncollection is initiated. This can be set with SETF.\n\nOn GENCGC platforms this is the nursery size, and defaults to 5% of dynamic\nspace size.\n\nNote: currently changes to this value are lost when saving core.").
doc_string('call-arguments-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound of the number of arguments to a function.  Ignore this value\nsince there is no such logical upper bound in WAM-CL.\n").
doc_string('call-arguments-limit', 'common-lisp', variable, "The exclusive upper bound on the number of arguments which may be passed\n  to a function, including &REST args.").
doc_string('call-with-timing', pkg_sys, function, "Calls FUNCTION with ARGUMENTS, and gathers timing information about it.\nThen calls TIMER with keyword arguments describing the information collected.\nCalls TIMER even if FUNCTION performs a non-local transfer of control. Finally\nreturns values returned by FUNCTION.\n\n  :USER-RUN-TIME-US\n      User run time in microseconds.\n\n  :SYSTEM-RUN-TIME-US\n      System run time in microseconds.\n\n  :REAL-TIME-MS\n      Real time in milliseconds.\n\n  :GC-RUN-TIME-MS\n      GC run time in milliseconds (included in user and system run time.)\n\n  :PROCESSOR-CYCLES\n      Approximate number of processor cycles used. (Omitted  if not supported on\n      the platform -- currently available on x86 and x86-64 only.)\n\n  :EVAL-CALLS\n      Number of calls to EVAL. (Omitted if zero.)\n\n  :LAMBDAS-CONVERTED\n      Number of lambdas converted. (Omitted if zero.)\n\n  :PAGE-FAULTS\n      Number of page faults. (Omitted if zero.)\n\n  :BYTES-CONSED\n      Approximate number of bytes consed.\n\n  :ABORTED\n      True if FUNCTION caused a non-local transfer of control. (Omitted if\n      NIL.)\n\nEXPERIMENTAL: Interface subject to change.").
doc_string('cancel-deadline', 'sb-sys', function, "Find and invoke the CANCEL-DEADLINE restart associated with\nCONDITION, or return NIL if the restart is not found.").
doc_string('cancel-finalization', pkg_sys, function, "Cancel any finalization for OBJECT.").
doc_string('case-failure-name', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('case-failure-possibilities', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('case-ignorable-p', 'sb-unicode', function, "Returns T if CHARACTER is Case Ignorable as defined in Unicode 6.3, Chapter\n3").
doc_string('case-warning-case-kind', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('case-warning-key', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('cased-p', 'sb-unicode', function, "Returns T if CHARACTER has a (Unicode) case, and NIL otherwise").
doc_string('cell-error-name', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('char-block', 'sb-unicode', function, "Returns the Unicode block in which CHARACTER resides as a keyword.\nIf CHARACTER does not have a known block, returns :NO-BLOCK").
doc_string('char-code', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns the character code of CHAR as a fixnum.\n").
doc_string('char-code', 'common-lisp', function, "Return the integer code of CHAR.").
doc_string('char-code-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound of values returned by CHAR-CODE.\n").
doc_string('char-code-limit', 'common-lisp', variable, "the upper exclusive bound on values produced by CHAR-CODE").
doc_string('char-downcase', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns the lower-case character corresponding to CHAR, if CHAR is upper-case.\nOtherwise, returns CHAR.\n").
doc_string('char-downcase', 'common-lisp', function, "Return CHAR converted to lower-case if that is possible.").
doc_string('char-equal', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if all CHARs are the same; NIL otherwise.  Lower-case characters are\nregarded the same as the corresponding upper-case characters.\n").
doc_string('char-equal', 'common-lisp', function, "Return T if all of the arguments are the same character.\nCase is ignored.").
doc_string('char-greaterp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in decreasing order; NIL\notherwise.  For lower-case characters, codes of corresponding upper-case\ncharacters are used.\n").
doc_string('char-greaterp', 'common-lisp', function, "Return T if the arguments are in strictly decreasing alphabetic order.\nCase is ignored.").
doc_string('char-int', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns the font, bits, and code attributes as an integer.  Equivalent to\nCHAR-CODE in WAM-CL.\n").
doc_string('char-int', 'common-lisp', function, "Return the integer code of CHAR. (In SBCL this is the same as CHAR-CODE, as\nthere are no character bits or fonts.)").
doc_string('char-lessp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in increasing order; NIL\notherwise.  For lower-case characters, codes of corresponding upper-case\ncharacters are used.\n").
doc_string('char-lessp', 'common-lisp', function, "Return T if the arguments are in strictly increasing alphabetic order.\nCase is ignored.").
doc_string('char-name', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns the 'character name' of CHAR as a string; NIL if CHAR has no character\nname.  Only #\\Backspace, #\\Tab, #\\Newline (or #\\Linefeed), #\\Page,\n#\\Return, and #\\Rubout have character names in WAM-CL.\n").
doc_string('char-name', 'common-lisp', function, "Return the name (a STRING) for a CHARACTER object.").
doc_string('char-not-equal', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if no two of CHARs are the same; NIL otherwise.  Lower-case\ncharacters are regarded the same as the corresponding upper-case characters.\n").
doc_string('char-not-equal', 'common-lisp', function, "Return T if no two of the arguments are the same character.\nCase is ignored.").
doc_string('char-not-greaterp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in non-decreasing order; NIL\notherwise.  For lower-case characters, codes of corresponding upper-case\ncharacters are used.\n").
doc_string('char-not-greaterp', 'common-lisp', function, "Return T if the arguments are in strictly non-decreasing alphabetic order.\nCase is ignored.").
doc_string('char-not-lessp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in non-increasing order; NIL\notherwise.  For lower-case characters, codes of corresponding upper-case\ncharacters are used.\n").
doc_string('char-not-lessp', 'common-lisp', function, "Return T if the arguments are in strictly non-increasing alphabetic order.\nCase is ignored.").
doc_string('char-upcase', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns the upper-case character of CHAR, if CHAR is lower-case.  Otherwise,\nreturns CHAR.\n").
doc_string('char-upcase', 'common-lisp', function, "Return CHAR converted to upper-case if that is possible. Don't convert\nlowercase eszet (U+DF).").
doc_string('char/=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if no two of CHARs are the same; NIL otherwise.\n").
doc_string('char/=', 'common-lisp', function, "Return T if no two of the arguments are the same character.").
doc_string('char<', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in increasing order; NIL\notherwise.\n").
doc_string('char<', 'common-lisp', function, "Return T if the arguments are in strictly increasing alphabetic order.").
doc_string('char<=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in non-decreasing order; NIL\notherwise.\n").
doc_string('char<=', 'common-lisp', function, "Return T if the arguments are in strictly non-decreasing alphabetic order.").
doc_string('char=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if all CHARs are the same; NIL otherwise.\n").
doc_string('char=', 'common-lisp', function, "Return T if all of the arguments are the same character.").
doc_string('char>', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in decreasing order; NIL\notherwise.\n").
doc_string('char>', 'common-lisp', function, "Return T if the arguments are in strictly decreasing alphabetic order.").
doc_string('char>=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &REST MORE-CHARS)\n\nReturns T if the character codes of CHARs are in non-increasing order; NIL\notherwise.\n").
doc_string('char>=', 'common-lisp', function, "Return T if the arguments are in strictly non-increasing alphabetic order.").
doc_string('character-coding-error-external-format', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('character-decoding-error-in-macro-char-comment-char', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('character-decoding-error-in-macro-char-comment-disp-char', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('character-decoding-error-in-macro-char-comment-sub-char', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('character-decoding-error-octets', 'sb-int', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('character-encoding-error-code', 'sb-int', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('character-string-p', 'sb-kernel', function, "Return true if OBJECT is a CHARACTER-STRING, and NIL otherwise.").
doc_string('check-initargs', mop, function, "Checks the validity of `initargs' for the generic functions in `gf-list'\r\nwhen called with `args' by calculating the applicable methods for each gf.\r\nThe applicable methods for SHARED-INITIALIZE based on `instance',\r\n`shared-initialize-param' and `initargs' are added to the list of\r\napplicable methods.").
doc_string('check-type', 'common-lisp', function, "Args: (check-type place typespec [string-form])\nSignals a continuable error, if the value of PLACE is not of the specified\ntype.  Before continuing, receives a new value of PLACE from the user and\nchecks the type again.  Repeats this process until the value of PLACE becomes\nof the specified type.  STRING-FORM, if given, is evaluated only once and the\nvalue is used to indicate the expected type in the error message.").
doc_string('check-type', 'common-lisp', function, "Signal a restartable error of type TYPE-ERROR if the value of PLACE\nis not of the specified type. If an error is signalled and the restart\nis used to return, this can only return if the STORE-VALUE restart is\ninvoked. In that case it will store into PLACE and start over.").
doc_string('classoid-of', 'sb-kernel', function, "Return the class of the supplied object, which may be any Lisp object, not\n   just a CLOS STANDARD-OBJECT.").
doc_string('clear-input', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*))\n\nClears the input buffer of STREAM and returns NIL.  Contents of the buffer are\ndiscarded.\n").
doc_string('clear-output', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nClears the output buffer of STREAM and returns NIL.  Contents of the buffer\nare discarded.\n").
doc_string('clear-semaphore-notification', 'sb-thread', function, "Resets the SEMAPHORE-NOTIFICATION object for use with another call to\nWAIT-ON-SEMAPHORE or TRY-SEMAPHORE.").
doc_string('clhs-root', custom, function, "\r\nThis returns the root URL for the Common Lisp HyperSpec.\r\nYou can set the environment variable `CLHSROOT' or redefine this function\r\nin ~/.clisprc.  On win32 you can also use the Registry.").
doc_string('code-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CODE &OPTIONAL (BITS 0) (FONT 0))\n\nReturns a character with the specified character code, if any.  Returns NIL\nif no such character exists.  BITS and FONT specify the bits and font\nattributes of the returned character but are both ignored in WAM-CL.\n").
doc_string('code-char', 'common-lisp', function, "Return the character with the code CODE.").
doc_string('code-component-p', 'sb-kernel', function, "Return true if OBJECT is a CODE-COMPONENT, and NIL otherwise.").
doc_string('combining-class', 'sb-unicode', function, "Returns the canonical combining class (CCC) of CHARACTER").
doc_string('command-args', extensions, function, "Returns the original command line arguments as list. First argument is\nthe WAM-CL program itself.").
doc_string('compare-and-swap', pkg_sys, function, "Atomically stores NEW in PLACE if OLD matches the current value of PLACE.\nTwo values are considered to match if they are EQ. Returns the previous value\nof PLACE: if the returned value is EQ to OLD, the swap was carried out.\n\nPLACE must be an CAS-able place. Built-in CAS-able places are accessor forms\nwhose CAR is one of the following:\n\n CAR, CDR, FIRST, REST, SVREF, SYMBOL-PLIST, SYMBOL-VALUE, SVREF, SLOT-VALUE\n SB-MOP:STANDARD-INSTANCE-ACCESS, SB-MOP:FUNCALLABLE-STANDARD-INSTANCE-ACCESS,\n\nor the name of a DEFSTRUCT created accessor for a slot whose declared type is\neither FIXNUM or T. Results are unspecified if the slot has a declared type\nother then FIXNUM or T.\n\nIn case of SLOT-VALUE, if the slot is unbound, SLOT-UNBOUND is called unless\nOLD is EQ to SB-PCL:+SLOT-UNBOUND+ in which case SB-PCL:+SLOT-UNBOUND+ is\nreturned and NEW is assigned to the slot. Additionally, the results are\nunspecified if there is an applicable method on either\nSB-MOP:SLOT-VALUE-USING-CLASS, (SETF SB-MOP:SLOT-VALUE-USING-CLASS), or\nSB-MOP:SLOT-BOUNDP-USING-CLASS.\n\nAdditionally, the PLACE can be a anything for which a CAS-expansion has been\nspecified using DEFCAS, DEFINE-CAS-EXPANDER, or for which a CAS-function has\nbeen defined. (See SB-EXT:CAS for more information.)\n").
doc_string('compile-file', 'common-lisp', function, "Compile INPUT-FILE, producing a corresponding fasl file and\nreturning its filename.\n\n  :PRINT\n     If true, a message per non-macroexpanded top level form is printed\n     to *STANDARD-OUTPUT*. Top level forms that whose subforms are\n     processed as top level forms (eg. EVAL-WHEN, MACROLET, PROGN) receive\n     no such message, but their subforms do.\n\n     As an extension to ANSI, if :PRINT is :top-level-forms, a message\n     per top level form after macroexpansion is printed to *STANDARD-OUTPUT*.\n     For example, compiling an IN-PACKAGE form will result in a message about\n     a top level SETQ in addition to the message about the IN-PACKAGE form'\n     itself.\n\n     Both forms of reporting obey the SB-EXT:*COMPILER-PRINT-VARIABLE-ALIST*.\n\n  :BLOCK-COMPILE\n     Though COMPILE-FILE accepts an additional :BLOCK-COMPILE\n     argument, it is not currently supported. (non-standard)\n\n  :TRACE-FILE\n     If given, internal data structures are dumped to the specified\n     file, or if a value of T is given, to a file of *.trace type\n     derived from the input file name. (non-standard)\n\n  :EMIT-CFASL\n     (Experimental). If true, outputs the toplevel compile-time effects\n     of this file into a separate .cfasl file.").
doc_string('compile-file-line', pkg_sys, function, "Return line# and column# of this macro invocation as multiple values.").
doc_string('compile-file-pathname', 'common-lisp', function, "Return a pathname describing what file COMPILE-FILE would write to given\n   these arguments.").
doc_string('compile-file-position', pkg_sys, function, "Return character position of this macro invocation or NIL if unavailable.").
doc_string('compile-time-value', sys, function, "Evaluate the EXPRESSION at compile time, writing the value into the FAS file.").
doc_string('compiled-function-name', extensions, function, "Function in EXT package:\nArgs: (COMPILED-FUNCTION)\n\nECL specific.\nReturns the function name associated with COMPILED-FUNCTION.\n").
doc_string('compiled-function-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a compiled function object; NIL otherwise.\n").
doc_string('compiled-function-p', 'common-lisp', function, "Return true if OBJECT is a COMPILED-FUNCTION, and NIL otherwise.").
doc_string('compiler-let', extensions, function, "Special Form in EXT package:\nSyntax: (compiler-let ({var | (var [value])}*) {form}*)\n\nWhen interpreted, this form works just like a LET form with all VARs declared\nspecial.  When compiled, FORMs are processed with the VARs bound at compile\ntime, but no bindings occur when the compiled code is executed.\n").
doc_string('compiler-macro-application-missed-warning-count', 'sb-c', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('compiler-macro-application-missed-warning-function', 'sb-c', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('compiler-macro-function', 'common-lisp', function, "If NAME names a compiler-macro in ENV, return the expansion function, else\nreturn NIL. Can be set with SETF when ENV is NIL.").
doc_string('compiler-macro-keyword-argument', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('complex-double-float-p', 'sb-kernel', function, "Return true if OBJECT is a COMPLEX-DOUBLE-FLOAT, and NIL otherwise.").
doc_string('complex-float-p', 'sb-kernel', function, "Return true if OBJECT is a COMPLEX-FLOAT, and NIL otherwise.").
doc_string('complex-rational-p', 'sb-kernel', function, "Return true if OBJECT is a COMPLEX-RATIONAL, and NIL otherwise.").
doc_string('complex-single-float-p', 'sb-kernel', function, "Return true if OBJECT is a COMPLEX-SINGLE-FLOAT, and NIL otherwise.").
doc_string('compute-restarts', 'common-lisp', function, "Return a list of all the currently active restarts ordered from most recently\nestablished to less recently established. If CONDITION is specified, then only\nrestarts associated with CONDITION (or with no condition) will be returned.").
doc_string('condition-broadcast', 'sb-thread', function, "Notify all threads waiting on QUEUE.\n\nIMPORTANT: The same mutex that is used in the corresponding CONDITION-WAIT\nmust be held by this thread during this call.").
doc_string('condition-notify', 'sb-thread', function, "Notify N threads waiting on QUEUE.\n\nIMPORTANT: The same mutex that is used in the corresponding CONDITION-WAIT\nmust be held by this thread during this call.").
doc_string('condition-wait', 'sb-thread', function, "Atomically release MUTEX and start waiting on QUEUE for till another thread\nwakes us up using either CONDITION-NOTIFY or CONDITION-BROADCAST on that\nqueue, at which point we re-acquire MUTEX and return T.\n\nSpurious wakeups are possible.\n\nIf TIMEOUT is given, it is the maximum number of seconds to wait, including\nboth waiting for the wakeup and the time to re-acquire MUTEX. Unless both\nwakeup and re-acquisition do not occur within the given time, returns NIL\nwithout re-acquiring the mutex.\n\nIf CONDITION-WAIT unwinds, it may do so with or without the mutex being held.\n\nImportant: Since CONDITION-WAIT may return without CONDITION-NOTIFY having\noccurred the correct way to write code that uses CONDITION-WAIT is to loop\naround the call, checking the the associated data:\n\n  (defvar *data* nil)\n  (defvar *queue* (make-waitqueue))\n  (defvar *lock* (make-mutex))\n\n  ;; Consumer\n  (defun pop-data (&optional timeout)\n    (with-mutex (*lock*)\n      (loop until *data*\n            do (or (condition-wait *queue* *lock* :timeout timeout)\n                   ;; Lock not held, must unwind without touching *data*.\n                   (return-from pop-data nil)))\n      (pop *data*)))\n\n  ;; Producer\n  (defun push-data (data)\n    (with-mutex (*lock*)\n      (push data *data*)\n      (condition-notify *queue*)))\n").
doc_string('confusable-p', 'sb-unicode', function, "Determines whether STRING1 and STRING2 could be visually confusable\naccording to the IDNA confusableSummary.txt table").
doc_string('constant-form-value', 'sb-int', function, "Returns the value of the constant FORM in ENVIRONMENT. Behaviour\nis undefined unless CONSTANTP has been first used to determine the\nconstantness of the FORM in ENVIRONMENT.").
doc_string('constant-modified-fun-name', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('copy-alist', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ALIST)\n\nReturns a new list consisting of copies of all pairs in ALIST.\n").
doc_string('copy-alist', 'common-lisp', function, "Return a new association list which is EQUAL to ALIST.").
doc_string('copy-list', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST)\n\nReturns a new list consisting of all elements in LIST.\n").
doc_string('copy-list', 'common-lisp', function, "Return a new list which is EQUAL to LIST. LIST may be improper.").
doc_string('copy-readtable', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (READTABLE *READTABLE*) (TO-READTABLE NIL))\n\nReturns a new copy of READTABLE.  If TO-READTABLE is non-NIL, then copies the\ncontents of READTABLE into TO-READTABLE and returns TO-READTABLE.\n").
doc_string('copy-seq', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE)\n\nReturns a new copy of SEQUENCE.\n").
doc_string('copy-seq', 'common-lisp', function, "Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.").
doc_string('copy-structure', 'common-lisp', function, "Return a copy of STRUCTURE with the same (EQL) slot values.").
doc_string('copy-symbol', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (FLAG NIL))\n\nReturns a new uninterned symbol with the same print name as SYMBOL.  If FLAG\nis NIL, the symbol property of the new symbol is empty.  Otherwise, the new\nsymbol gets a copy of the property list of SYMBOL.\n").
doc_string('copy-symbol', 'common-lisp', function, "Make and return a new uninterned symbol with the same print name\n  as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound\n  nor fbound and has no properties, else it has a copy of SYMBOL's\n  function, value and property list.").
doc_string('copy-tree', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TREE)\n\nReturns a copy of TREE.  Defined as:\n        (defun copy-tree (tree)\n          (if (atom tree)\n              tree\n              (cons (copy-tree (car tree)) (copy-tree (cdr tree)))))\n").
doc_string('copy-tree', 'common-lisp', function, "Recursively copy trees of conses.").
doc_string('count-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the number of elements in SEQUENCE satisfying TEST.\n").
doc_string('count-if', 'common-lisp', function, "Return the number of elements in SEQUENCE satisfying PRED(el).").
doc_string('count-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the number of elements in SEQUENCE not satisfying TEST.\n").
doc_string('count-if-not', 'common-lisp', function, "Return the number of elements in SEQUENCE not satisfying TEST(el).").
doc_string('cpl-protocol-violation-class', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('cpl-protocol-violation-cpl', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('current-thread', threads, function, "Returns a reference to invoking thread.").
doc_string('current-time', sys, function, "Print the current time to the stream (defaults to T).").
doc_string('debug-block-elsewhere-p', 'sb-di', function, "Return whether debug-block represents elsewhere code.").
doc_string('debug-var-id', 'sb-di', function, "Return the integer that makes DEBUG-VAR's name and package unique\n   with respect to other DEBUG-VARs in the same function.").
doc_string('debugger-wait-until-foreground-thread', 'sb-thread', function, "Returns T if thread had been running in background, NIL if it was\ninteractive.").
doc_string('decf-complex', system, function, "The first argument is some location holding a number.  This number is\r\n   decremented by the second argument, DELTA, which defaults to 1.").
doc_string('decimal-value', 'sb-unicode', function, "Returns the decimal digit value associated with CHARACTER or NIL if\nthere is no such value.\n\nThe only characters in Unicode with a decimal digit value are those\nthat are part of a range of characters that encode the digits 0-9.\nBecause of this, `(decimal-digit c) <=> (digit-char-p c 10)` in\n#+sb-unicode builds").
doc_string('decode-float', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT)\n\nReturns the significand F, the exponent E, and the sign S of FLOAT.  These\nvalues satisfy\n        1/B <= F < 1\nand                      E\n        FLOAT = S * F * B\nwhere B is the radix used to represent FLOAT.  S and F are floats of the same\nfloat format as FLOAT, and E is an integer.\n").
doc_string('decode-float', 'common-lisp', function, "Return three values:\n   1) a floating-point number representing the significand. This is always\n      between 0.5 (inclusive) and 1.0 (exclusive).\n   2) an integer representing the exponent.\n   3) -1.0 or 1.0 (i.e. the sign of the argument.)").
doc_string('decode-internal-time', 'sb-sys', function, "Returns internal time value TIME decoded into seconds and microseconds.").
doc_string('decode-timeout', 'sb-sys', function, "Decodes a relative timeout in SECONDS into five values, taking any\nglobal deadlines into account: TO-SEC, TO-USEC, STOP-SEC, STOP-USEC,\nDEADLINEP.\n\nTO-SEC and TO-USEC indicate the relative timeout in seconds and microseconds.\nSTOP-SEC and STOP-USEC indicate the absolute timeout in seconds and\nmicroseconds. DEADLINEP is true if the returned values reflect a global\ndeadline instead of the local timeout indicated by SECONDS.\n\nIf SECONDS is null and there is no global timeout all returned values will be\nnull. If a global deadline has already passed when DECODE-TIMEOUT is called,\nit will signal a timeout condition.").
doc_string('decode-universal-time', 'common-lisp', function, "Args: (integer &optional (timezone (si::get-local-time-zone)))\nReturns as nine values the day-and-time represented by INTEGER.  See GET-\nDECODED-TIME.").
doc_string('decode-universal-time', 'common-lisp', function, "Converts a universal-time to decoded time format returning the following\n   nine values: second, minute, hour, date, month, year, day of week (0 =\n   Monday), T (daylight savings time) or NIL (standard time), and timezone.\n   Completely ignores daylight-savings-time when time-zone is supplied.").
doc_string('decoding-error-in-comment-position', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('decoding-error-in-comment-stream', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('def-constant', ffi, function, "Macro to define a constant and to export it").
doc_string('default-ignorable-p', 'sb-unicode', function, "Returns T if CHARACTER is a Default_Ignorable_Code_Point").
doc_string('defconstant-uneql-name', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('defconstant-uneql-new-value', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('defconstant-uneql-old-value', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('defer-deadline', 'sb-sys', function, "Find the DEFER-DEADLINE restart associated with CONDITION, and\ninvoke it with SECONDS as argument (deferring the deadline by that many\nseconds.) Otherwise return NIL if the restart is not found.").
doc_string('define-alien-callback', 'sb-alien', function, "Defines #'NAME as a function with the given body and lambda-list, and NAME as\nthe alien callback for that function with the given alien type.").
doc_string('define-alien-routine', 'sb-alien', function, "DEFINE-ALIEN-ROUTINE Name Result-Type {(Arg-Name Arg-Type [Style])}*\n\nDefine a foreign interface function for the routine with the specified NAME.\nAlso automatically DECLAIM the FTYPE of the defined function.\n\nNAME may be either a string, a symbol, or a list of the form (string symbol).\n\nRETURN-TYPE is the alien type for the function return value. VOID may be\nused to specify a function with no result.\n\nThe remaining forms specify individual arguments that are passed to the\nroutine. ARG-NAME is a symbol that names the argument, primarily for\ndocumentation. ARG-TYPE is the C type of the argument. STYLE specifies the\nway that the argument is passed.\n\n:IN\n      An :IN argument is simply passed by value. The value to be passed is\n      obtained from argument(s) to the interface function. No values are\n      returned for :In arguments. This is the default mode.\n\n:OUT\n      The specified argument type must be a pointer to a fixed sized object.\n      A pointer to a preallocated object is passed to the routine, and the\n      the object is accessed on return, with the value being returned from\n      the interface function. :OUT and :IN-OUT cannot be used with pointers\n      to arrays, records or functions.\n\n:COPY\n      This is similar to :IN, except that the argument values are stored\n      on the stack, and a pointer to the object is passed instead of\n      the value itself.\n\n:IN-OUT\n      This is a combination of :OUT and :COPY. A pointer to the argument is\n      passed, with the object being initialized from the supplied argument\n      and the return value being determined by accessing the object on\n      return.").
doc_string('define-alien-type', 'sb-alien', function, "Define the alien type NAME to be equivalent to TYPE. Name may be NIL for\n   STRUCT and UNION types, in which case the name is taken from the type\n   specifier.").
doc_string('define-alien-variable', 'sb-alien', function, "Define NAME as an external alien variable of type TYPE. NAME should\nbe a list of a string holding the alien name and a symbol to use as\nthe Lisp name. If NAME is just a symbol or string, then the other name\nis guessed from the one supplied.").
doc_string('define-cas-expander', pkg_sys, function, "Analogous to DEFINE-SETF-EXPANDER. Defines a CAS-expansion for ACCESSOR.\nBODY must return six values as specified in GET-CAS-EXPANSION.\n\nNote that the system provides no automatic atomicity for CAS expansion, nor\ncan it verify that they are atomic: it is up to the implementor of a CAS\nexpansion to ensure its atomicity.\n\nEXPERIMENTAL: Interface subject to change.").
doc_string('define-compiler-macro', 'common-lisp', function, "Define a compiler-macro for NAME.").
doc_string('define-condition', 'common-lisp', function, "DEFINE-CONDITION Name (Parent-Type*) (Slot-Spec*) Option*\n   Define NAME as a condition type. This new type inherits slots and its\n   report function from the specified PARENT-TYPEs. A slot spec is a list of:\n     (slot-name :reader <rname> :initarg <iname> {Option Value}*\n\n   The DEFINE-CLASS slot options :ALLOCATION, :INITFORM, [slot] :DOCUMENTATION\n   and :TYPE and the overall options :DEFAULT-INITARGS and\n   [type] :DOCUMENTATION are also allowed.\n\n   The :REPORT option is peculiar to DEFINE-CONDITION. Its argument is either\n   a string or a two-argument lambda or function name. If a function, the\n   function is called with the condition and stream to report the condition.\n   If a string, the string is printed.\n\n   Condition types are classes, but (as allowed by ANSI and not as described in\n   CLtL2) are neither STANDARD-OBJECTs nor STRUCTURE-OBJECTs. WITH-SLOTS and\n   SLOT-VALUE may not be used on condition objects.").
doc_string('define-funcallable-primordial-class', mop, function, "Primitive funcallable class definition tool.\r\nNo non-standard metaclasses, accessor methods, duplicate slots,\r\nnon-existent superclasses, default initargs, or other complicated stuff.\r\nHandle with care.\r\nWill not modify existing classes to avoid breaking std-generic-function-p.").
doc_string('define-function-name-syntax', 'sb-int', function, "Define function names of the form of a list headed by SYMBOL to be\na legal function name, subject to restrictions imposed by BODY.  BODY\nis evaluated with VAR bound to the form required to check, and should\nreturn two values: the first value is a generalized boolean indicating\nlegality, and the second a symbol for use as a BLOCK name or similar\nsituations.").
doc_string('define-hash-table-test', pkg_sys, function, "Defines NAME as a new kind of hash table test for use with the :TEST\nargument to MAKE-HASH-TABLE, and associates a default HASH-FUNCTION with it.\n\nNAME must be a symbol naming a global two argument equivalence predicate.\nAfterwards both 'NAME and #'NAME can be used with :TEST argument. In both\ncases HASH-TABLE-TEST will return the symbol NAME.\n\nHASH-FUNCTION must be a symbol naming a global hash function consistent with\nthe predicate, or be a LAMBDA form implementing one in the current lexical\nenvironment. The hash function must compute the same hash code for any two\nobjects for which NAME returns true, and subsequent calls with already hashed\nobjects must always return the same hash code.\n\nNote: The :HASH-FUNCTION keyword argument to MAKE-HASH-TABLE can be used to\noverride the specified default hash-function.\n\nAttempting to define NAME in a locked package as hash-table test causes a\npackage lock violation.\n\nExamples:\n\n  ;;; 1.\n\n  ;; We want to use objects of type FOO as keys (by their\n  ;; names.) EQUALP would work, but would make the names\n  ;; case-insensitive -- which we don't want.\n  (defstruct foo (name nil :type (or null string)))\n\n  ;; Define an equivalence test function and a hash function.\n  (defun foo-name= (f1 f2) (equal (foo-name f1) (foo-name f2)))\n  (defun sxhash-foo-name (f) (sxhash (foo-name f)))\n\n  (define-hash-table-test foo-name= sxhash-foo-name)\n\n  ;; #'foo-name would work too.\n  (defun make-foo-table () (make-hash-table :test 'foo-name=))\n\n  ;;; 2.\n\n  (defun == (x y) (= x y))\n\n  (define-hash-table-test ==\n    (lambda (x)\n      ;; Hash codes must be consistent with test, so\n      ;; not (SXHASH X), since\n      ;;   (= 1 1.0)                   => T\n      ;;   (= (SXHASH 1) (SXHASH 1.0)) => NIL\n      ;; Note: this doesn't deal with complex numbers or\n      ;; bignums too large to represent as double floats.\n      (sxhash (coerce x 'double-float))))\n\n  ;; #'== would work too\n  (defun make-number-table () (make-hash-table :test '==))\n").
doc_string('define-instruction-format', 'sb-disassem', function, "DEFINE-INSTRUCTION-FORMAT (Name Length {Format-Key Value}*) Arg-Def*\n  Define an instruction format NAME for the disassembler's use. LENGTH is\n  the length of the format in bits.\n  Possible FORMAT-KEYs:\n\n  :INCLUDE other-format-name\n      Inherit all arguments and properties of the given format. Any\n      arguments defined in the current format definition will either modify\n      the copy of an existing argument (keeping in the same order with\n      respect to when prefilters are called), if it has the same name as\n      one, or be added to the end.\n  :DEFAULT-PRINTER printer-list\n      Use the given PRINTER-LIST as a format to print any instructions of\n      this format when they don't specify something else.\n\n  Each ARG-DEF defines one argument in the format, and is of the form\n    (Arg-Name {Arg-Key Value}*)\n\n  Possible ARG-KEYs (the values are evaluated unless otherwise specified):\n\n  :FIELDS byte-spec-list\n      The argument takes values from these fields in the instruction. If\n      the list is of length one, then the corresponding value is supplied by\n      itself; otherwise it is a list of the values. The list may be NIL.\n  :FIELD byte-spec\n      The same as :FIELDS (list byte-spec).\n\n  :VALUE value\n      If the argument only has one field, this is the value it should have,\n      otherwise it's a list of the values of the individual fields. This can\n      be overridden in an instruction-definition or a format definition\n      including this one by specifying another, or NIL to indicate that it's\n      variable.\n\n  :SIGN-EXTEND boolean\n      If non-NIL, the raw value of this argument is sign-extended,\n      immediately after being extracted from the instruction (before any\n      prefilters are run, for instance). If the argument has multiple\n      fields, they are all sign-extended.\n\n  :TYPE arg-type-name\n      Inherit any properties of the given argument type.\n\n  :PREFILTER function\n      A function which is called (along with all other prefilters, in the\n      order that their arguments appear in the instruction-format) before\n      any printing is done, to filter the raw value. Any uses of READ-SUFFIX\n      must be done inside a prefilter.\n\n  :PRINTER function-string-or-vector\n      A function, string, or vector which is used to print this argument.\n\n  :USE-LABEL\n      If non-NIL, the value of this argument is used as an address, and if\n      that address occurs inside the disassembled code, it is replaced by a\n      label. If this is a function, it is called to filter the value.").
doc_string('define-load-time-global', pkg_sys, function, "Defines NAME as a global variable that is always bound. VALUE is evaluated\nand assigned to NAME at load-time, but only if NAME is not already bound.\n\nAttempts to read NAME at compile-time will signal an UNBOUND-VARIABLE error\nunless it has otherwise been assigned a value.\n\nSee also DEFGLOBAL which assigns the VALUE at compile-time too.").
doc_string('define-method-combination', clos, function, "\r\nThe macro define-method-combination defines a new method combination.\r\nShort-form options are :documentation, :identity-with-one-argument,\r\n and :operator.\r\nLong-form options are a list of method-group specifiers,\r\n each of which comprises a sequence of qualifier patterns\r\n followed by respective :description, :order, :required options,\r\n and optional :generic-function, and :arguments options preceeding\r\n the definition body.").
doc_string('define-modify-macro', 'common-lisp', function, "Creates a new read-modify-write macro like PUSH or INCF.").
doc_string('define-modify-macro', 'common-lisp', function, "Syntax: (define-modify-macro symbol lambda-list function-name [doc])\nDefines a read-modify-write macro like INCF.  The defined macro will expand\na form (SYMBOL place form1 ... formn) into a form that in effect SETFs the\nvalue of (FUNCTION-NAME place arg1 ... argm) into PLACE, where ARG1 ... ARGm\nare parameters in LAMBDA-LIST which are bound to FORM1 ... FORMn.  For\nexample, INCF could be defined as\n        (define-modify-macro incf (&optional (x 1)) +)\nThe doc-string DOC, if supplied, is saved as a FUNCTION doc and can be\nretrieved by (DOCUMENTATION 'SYMBOL 'FUNCTION).").
doc_string('define-primordial-class', mop, function, "Primitive class definition tool.\r\nNo non-standard metaclasses, accessor methods, duplicate slots,\r\nnon-existent superclasses, default initargs, or other complicated stuff.\r\nHandle with care.").
doc_string('define-setf-expander', 'common-lisp', function, "Syntax like DEFMACRO, but creates a setf expander function. The body\n  of the definition must be a form that returns five appropriate values.").
doc_string('define-setf-expander', 'common-lisp', function, "Syntax: (define-setf-expander symbol defmacro-lambda-list {decl | doc}*\n          {form}*)\nDefines the SETF-method for generalized-variables (SYMBOL ...).\nWhen a form (setf (SYMBOL arg1 ... argn) value-form) is evaluated, the FORMs\ngiven in the DEFINE-SETF-EXPANDER are evaluated in order with the parameters in\nDEFMACRO-LAMBDA-LIST bound to ARG1 ... ARGn.  The last FORM must return five\nvalues\n        (var1 ... vark)\n        (form1 ... formk)\n        (value-var)\n        storing-form\n        access-form\nin order.  These values are collectively called the five gangs of the\ngeneralized variable (SYMBOL arg1 ... argn).  The whole SETF form is then\nexpanded into\n        (let* ((var1 from1) ... (vark formk)\n               (value-var value-form))\n          storing-form)\nThe doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved\nby (DOCUMENTATION 'SYMBOL 'SETF).").
doc_string('define-source-context', pkg_sys, function, "DEFINE-SOURCE-CONTEXT Name Lambda-List Form*\n   This macro defines how to extract an abbreviated source context from the\n   Named form when it appears in the compiler input. Lambda-List is a DEFMACRO\n   style lambda-list used to parse the arguments. The Body should return a\n   list of subforms suitable for a \"~{~S ~}\" format string.").
doc_string('defined-type-name-p', pkg_sys, function, "Returns T if NAME is known to name a type specifier, otherwise NIL.").
doc_string('defmacro-lambda-list-bind-error-kind', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('defmacro-lambda-list-bind-error-name', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('defmacro-lambda-list-broken-key-list-error-info', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('defmacro-lambda-list-broken-key-list-error-problem', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('delete-directory', pkg_sys, function, "Deletes the directory designated by PATHSPEC (a pathname designator).\nReturns the truename of the directory deleted.\n\nIf RECURSIVE is false (the default), signals an error unless the directory is\nempty. If RECURSIVE is true, first deletes all files and subdirectories. If\nRECURSIVE is true and the directory contains symbolic links, the links are\ndeleted, not the files and directories they point to.\n\nSignals an error if PATHSPEC designates a file or a symbolic link instead of a\ndirectory, or if the directory could not be deleted for any reason.\n\nBoth\n\n   (DELETE-DIRECTORY \"/tmp/foo\")\n   (DELETE-DIRECTORY \"/tmp/foo/\")\n\ndelete the \"foo\" subdirectory of \"/tmp\", or signal an error if it does not\nexist or if is a file or a symbolic link.").
doc_string('delete-duplicates', 'common-lisp', function, "Args: (sequence &key key\n                     (test '#'eql) test-not\n                     (start 0) (end (length sequence)) (from-end nil))\nDestructive REMOVE-DUPLICATES.  SEQUENCE may be destroyed.").
doc_string('delete-duplicates', 'common-lisp', function, "The elements of SEQUENCE are examined, and if any two match, one is\n   discarded. The resulting sequence, which may be formed by destroying the\n   given sequence, is returned.\n\n   The :TEST-NOT argument is deprecated.").
doc_string('delete-file', 'common-lisp', function, "Delete the specified FILE.\n\nIf FILE is a stream, on Windows the stream is closed immediately. On Unix\nplatforms the stream remains open, allowing IO to continue: the OS resources\nassociated with the deleted file remain available till the stream is closed as\nper standard Unix unlink() behaviour.").
doc_string('delete-file', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nDeletes the specified file.  FILESPEC may be a symbol, a string, a pathname,\nor a file stream.\n").
doc_string('delete-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nDestructive REMOVE-IF.  SEQUENCE may be destroyed\n").
doc_string('delete-if', 'common-lisp', function, "Return a sequence formed by destructively removing the elements satisfying\n  the specified PREDICATE from the given SEQUENCE.").
doc_string('delete-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nDestructive REMOVE-IF-NOT.  SEQUENCE may be destroyed\n").
doc_string('delete-if-not', 'common-lisp', function, "Return a sequence formed by destructively removing the elements not\n  satisfying the specified PREDICATE from the given SEQUENCE.").
doc_string('delete-package', 'common-lisp', function, "Delete the package designated by PACKAGE-DESIGNATOR from the package\n  system data structures.").
doc_string('deposit-field', 'common-lisp', function, "Args: (integer1 bytespec integer2)\nReturns an integer represented by the bit sequence obtained by replacing the\nspecified bits of INTEGER2 with the specified bits of INTEGER1.").
doc_string('deposit-field', 'common-lisp', function, "Return new integer with newbyte in specified position, newbyte is not right justified.").
doc_string('deprecated-eval-when-situations-situations', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('deprecation-condition-name', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('deprecation-condition-namespace', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('deprecation-condition-replacements', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('deprecation-condition-runtime-error', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('deprecation-condition-software', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('deprecation-condition-version', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('describe-compiler-policy', pkg_sys, function, "Print all global optimization settings, augmented by SPEC.").
doc_string('destroy-thread', 'sb-thread', function, "The function SB-THREAD:DESTROY-THREAD has been deprecated as of SBCL version 1.2.15.\n\nUse SB-THREAD:TERMINATE-THREAD instead.").
doc_string('destructuring-bind', 'common-lisp', function, "Bind the variables in LAMBDA-LIST to the corresponding values in the\ntree structure resulting from the evaluation of EXPRESSION.").
doc_string('digit-char', 'common-lisp', function, "All arguments must be integers. Returns a character object that represents\na digit of the given weight in the specified radix. Returns NIL if no such\ncharacter exists.").
doc_string('digit-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (DIGIT &OPTIONAL (N 10) (FONT 0))\n\nReturns a character that represents the DIGIT in radix N.  Returns NIL if no\nsuch character exists.\n").
doc_string('digit-char-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &OPTIONAL (N 10))\n\nIf CHAR represents a digit in radix N, then returns an integer represented by\nthat digit.  Otherwise, returns NIL.\n").
doc_string('digit-char-p', 'common-lisp', function, "If char is a digit in the specified radix, returns the fixnum for which\nthat digit stands, else returns NIL.").
doc_string('digit-value', 'sb-unicode', function, "Returns the Unicode digit value of CHARACTER or NIL if it doesn't exist.\n\nDigit values are guaranteed to be integers between 0 and 9 inclusive.\nAll characters with decimal digit values have the same digit value,\nbut there are characters (such as digits of number systems without a 0 value)\nthat have a digit value but no decimal digit value").
doc_string('directory-namestring', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns as a string the directory part of the pathname specified by FILESPEC.\nFILESPEC may be a symbol, a string, a pathname, or a file stream.\n").
doc_string('directory-namestring', 'common-lisp', function, "Return a string representation of the directories used in the pathname.").
doc_string('directory-namestring', 'common-lisp', function, "Returns the NAMESTRING of directory porition of PATHNAME if it has one.").
doc_string('disable-debugger', pkg_sys, function, "When invoked, this function will turn off both the SBCL debugger\nand LDB (the low-level debugger).  See also ENABLE-DEBUGGER.").
doc_string('disable-zip-cache', system, function, "Disable all caching of ABCL FASLs and ZIPs.").
doc_string('discard-keymap', readline, function, "Discard allocated keymap.").
doc_string('do*', 'common-lisp', function, "DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form*\n  Iteration construct. Each Var is initialized sequentially (like LET*) to the\n  value of the specified Init form. On subsequent iterations, the Vars are\n  sequentially assigned the value of the Step form (if any). The Test is\n  evaluated before each evaluation of the body Forms. When the Test is true,\n  the Exit-Forms are evaluated as a PROGN, with the result being the value\n  of the DO. A block named NIL is established around the entire expansion,\n  allowing RETURN to be used as an alternate exit mechanism.").
doc_string('do*', 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (do* ({(var [init [step]])}*) (test {result}*)\n          {decl}* {tag | statement}*)\n\nSimilar to DO, but performs variable bindings and assignments in serial, just\nas LET* and SETQ do.\n").
doc_string('do-all-symbols', 'common-lisp', function, "DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}*\n   Executes the FORMs once for each symbol in every package with VAR bound\n   to the current symbol.").
doc_string('do-all-symbols', 'common-lisp', function, "Syntax: (do-all-symbols (var [result]) {decl}* {tag | statement}*)\nEstablishes a NIL block and executes STATEMENTs once for each symbol in each\npackage, with VAR bound to the symbol.  Then evaluates RESULT (which defaults\nto NIL) and returns all values.").
doc_string('do-external-symbols', 'common-lisp', function, "DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}*\n   Executes the FORMs once for each external symbol in the given PACKAGE with\n   VAR bound to the current symbol.").
doc_string('do-external-symbols', 'common-lisp', function, "Syntax: (do-external-symbols (var [package [result]])\n          {decl}* {tag | statement}*)\nEstablishes a NIL block and executes STATEMENTs once for each external symbol\nin PACKAGE (which defaults to the current package), with VAR bound to the\nvariable.  Then evaluates RESULT (which defaults to NIL) and returns all\nvalues.").
doc_string('do-symbols', 'common-lisp', function, "DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}*\n   Executes the FORMs at least once for each symbol accessible in the given\n   PACKAGE with VAR bound to the current symbol.").
doc_string('do-symbols', 'common-lisp', function, "Syntax: (do-symbols (var [package [result]])\n          {decl}* {tag | statement}*)\nExecutes STATEMENTs once for each symbol in PACKAGE (which defaults to the\ncurrent package), with VAR bound to the symbol.  Then evaluates RESULT (which\ndefaults to NIL) and returns all values.").
doc_string('double-float-epsilon', 'common-lisp', variable, "The smallest postive double-float E that satisfies\n        (not (= (float 1 E) (+ (float 1 E) E)))").
doc_string('double-float-negative-epsilon', 'common-lisp', variable, "The smallest positive double-float E that satisfies\n        (not (= (float 1 E) (- (float 1 E) E)))").
doc_string('double-float-p', 'sb-int', function, "Return true if OBJECT is a DOUBLE-FLOAT, and NIL otherwise.").
doc_string('duplicate-case-key-warning-occurrences', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('duplicate-definition-name', 'sb-int', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('dynamic-space-size', pkg_sys, function, "Size of the dynamic space in bytes.").
doc_string('east-asian-width', 'sb-unicode', function, "Returns the East Asian Width property of CHARACTER as\none of the keywords :N (Narrow), :A (Ambiguous), :H (Halfwidth),\n:W (Wide), :F (Fullwidth), or :NA (Not applicable)").
doc_string('edit-file', sys, function, "(edit-file file) edits a file.").
doc_string('editor-tempfile', sys, function, "The temporary file LISP creates for editing.").
doc_string('emit-alignment', 'sb-assem', function, "Emit an alignment restriction to the current segment.").
doc_string('emit-label', 'sb-assem', function, "Emit LABEL at this location in the current segment.").
doc_string('enable-debugger', pkg_sys, function, "Restore the debugger if it has been turned off by DISABLE-DEBUGGER.").
doc_string('encapsulated-condition', 'sb-int', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('encode-universal-time', 'common-lisp', function, "Args: (second minute hour date month year\n       &optional (timezone (si::get-local-time-zone)))\nReturns an integer that represents the given day-and-time.  See\nGET-DECODED-TIME.").
doc_string('encode-universal-time', 'common-lisp', function, "The time values specified in decoded format are converted to\n   universal time, which is returned.").
doc_string('enough-namestring', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))\n\nReturns a string which uniquely identifies the file specified by FILESPEC,\nwith respect to DEFAULTS.  FILESPEC and DEFAULTS may be a symbol, a string, a\npathname, or a file stream.\n").
doc_string('enough-namestring', 'common-lisp', function, "Return an abbreviated pathname sufficient to identify the pathname relative\n   to the defaults.").
doc_string('ensure-directories-exist', 'common-lisp', function, "Args: (ensure-directories pathname &key :verbose)\nCreates tree of directories specified by the given pathname. Outputs\n        (VALUES pathname created)\nwhere CREATED is true only if we succeeded on creating all directories.").
doc_string('ensure-directories-exist', 'common-lisp', function, "Test whether the directories containing the specified file\n  actually exist, and attempt to create them if they do not.\n  The MODE argument is a CMUCL/SBCL-specific extension to control\n  the Unix permission bits.").
doc_string('ensure-dynamic-foreign-symbol-address', 'sb-sys', function, "Returns the address of the foreign symbol as an integer. On linkage-table\nports if the symbols isn't found a special guard address is returned instead,\naccesses to which will result in an UNDEFINED-ALIEN-ERROR. On other ports an\nerror is immediately signalled if the symbol isn't found. The returned address\nis never in the linkage-table.").
doc_string('ensure-input-stream', system, function, "Returns a java.io.InputStream for resource denoted by PATHNAME.").
doc_string('error-call', 'sb-vm', function, "Cause an error. ERROR-CODE is the error to cause.").
doc_string('eval-in-frame', 'sb-di', function, "Evaluate FORM in the lexical context of FRAME's current code location,\n   returning the results of the evaluation.").
doc_string('eval-when', 'common-lisp', function, "EVAL-WHEN (situation*) form*\n\nEvaluate the FORMS in the specified SITUATIONS (any of :COMPILE-TOPLEVEL,\n:LOAD-TOPLEVEL, or :EXECUTE, or (deprecated) COMPILE, LOAD, or EVAL).").
doc_string('eval-when', 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: ((&REST SITUATION) &BODY FORMS)\n\nSpecifies when to evaluate FORMs.  Each SITUATION must be one of the following\nsymbols.\n        COMPILE (compile-time)\n        LOAD    (load-time of the fasl file)\n        EVAL    (load-time of the source file)\n").
doc_string('every*', si, function, "Args: (predicate sequence &rest more-sequences)\nReturns T if every elements of SEQUENCEs satisfy PREDICATE and all sequences\nhave the same length; NIL otherwise.").
doc_string('exit-on-error', sys, function, "\r\n(EXIT-ON-ERROR {form}*) executes the forms, but exits Lisp if a\r\nnon-continuable error or a Ctrl-C interrupt occurs.").
doc_string('extended-char-p', 'sb-kernel', function, "Return true if OBJECT is an EXTENDED-CHAR, and NIL otherwise.").
doc_string('extern-alien', 'sb-alien', function, "Access the alien variable named NAME, assuming it is of type TYPE.\nThis is SETFable.").
doc_string('extract-lambda-list-keywords', mop, function, "Returns a list of keywords acceptable as keyword arguments,\r\nor T when any keyword is acceptable due to presence of\r\n&allow-other-keys.").
doc_string('fdefn-p', 'sb-kernel', function, "Return true if OBJECT is a FDEFN, and NIL otherwise.").
doc_string('file-author', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the author of the specified file, as a string.  Returns NIL if the\nauthor is unknown.  FILESPEC may be a symbol, a string, a pathname, or a file\nstream.\n").
doc_string('file-author', 'common-lisp', function, "Return the author of the file specified by PATHSPEC. Signal an\nerror of type FILE-ERROR if no such file exists, or if PATHSPEC\nis a wild pathname.").
doc_string('file-error-pathname', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('file-length', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILE-STREAM)\n\nReturns the length of the specified FILE-STREAM.  Returns NIL if the length is\nunknown.\n").
doc_string('file-namestring', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns as a string the name, type, and version parts of the specified\npathname.  FILESPEC may be a symbol, a string, a pathname, or a file stream.\n").
doc_string('file-namestring', 'common-lisp', function, "Return a string representation of the name used in the pathname.").
doc_string('file-namestring', 'common-lisp', function, "Returns just the name, type, and version components of PATHNAME.").
doc_string('file-position', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILE-STREAM &OPTIONAL FILE-POSITION)\n\nWith one arg, returns the current position of FILE-STREAM's file pointer as a\nnon-negative integer.  Returns NIL if the position is unknown.  With two args,\nresets the file pointer and returns T.  Returns NIL if the file pointer cannot\nbe reset.  FILE-POSITION may be a non-negative integer, :START, or :END.\n").
doc_string('file-write-date', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns an integer that represents the last write day-and-time of the\nspecified file (See GET-DECODED-TIME).   Returns NIL if the last write day-\nand-time is unknown.  FILESPEC may be a symbol, a string, a pathname, or a\nfile stream.\n").
doc_string('file-write-date', 'common-lisp', function, "Return the write date of the file specified by PATHSPEC.\nAn error of type FILE-ERROR is signaled if no such file exists,\nor if PATHSPEC is a wild pathname.").
doc_string('fill-pointer', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (VECTOR)\n\nReturns the fill-pointer of VECTOR as an integer.  VECTOR must have a fill-\npointer.\n").
doc_string('fill-pointer', 'common-lisp', function, "Return the FILL-POINTER of the given VECTOR.").
doc_string('finalize-segment', 'sb-assem', function, "Do any final processing of SEGMENT and return the total number of bytes\n   covered by this segment.").
doc_string('find-all-symbols', 'common-lisp', function, "Args: (string-designator)\nReturns a list of all symbols that have the specified print name.\nSTRING-DESIGNATOR may be a symbol, in which case the print name of the symbol\nis used.").
doc_string('find-all-symbols', 'common-lisp', function, "Return a list of all symbols in the system having the specified name.").
doc_string('find-foreign-symbol-address', 'sb-sys', function, "Returns the address of the foreign symbol NAME, or NIL. Does not enter the\nsymbol in the linkage table, and never returns an address in the linkage-table.").
doc_string('find-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the index of the first element in SEQUENCE that satisfies TEST.\nReturns NIL if no such element exists.\n").
doc_string('find-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the index of the first element in SEQUENCE that does not satisfy TEST.\nReturns NIL if no such element exists.\n").
doc_string('find-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NAME)\n\nReturns the package whose package name or nickname is NAME.  Returns NIL if no\nsuch package exists.  NAME may be a string or a symbol.\n").
doc_string('find-package', 'common-lisp', function, "If PACKAGE-DESIGNATOR is a package, it is returned. Otherwise PACKAGE-DESIGNATOR\nmust be a string designator, in which case the package it names is located and returned.\n\nAs an SBCL extension, the current package may affect the way a package name is\nresolved: if the current package has local nicknames specified, package names\nmatching those are resolved to the packages associated with them instead.\n\nExample:\n\n  (defpackage :a)\n  (defpackage :example (:use :cl) (:local-nicknames (:x :a)))\n  (let ((*package* (find-package :example)))\n    (find-package :x)) => #<PACKAGE A>\n\nSee also: ADD-PACKAGE-LOCAL-NICKNAME, PACKAGE-LOCAL-NICKNAMES,\nREMOVE-PACKAGE-LOCAL-NICKNAME, and the DEFPACKAGE option :LOCAL-NICKNAMES.").
doc_string('find-restart', 'common-lisp', function, "Return the first restart identified by IDENTIFIER. If IDENTIFIER is a symbol,\nthen the innermost applicable restart with that name is returned. If IDENTIFIER\nis a restart, it is returned if it is currently active. Otherwise NIL is\nreturned. If CONDITION is specified and not NIL, then only restarts associated\nwith that condition (or with no condition) will be returned.").
doc_string('find-symbol', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &OPTIONAL (PACKAGE *PACKAGE*))\n\nSearches PACKAGE for a symbol whose print name is NAME.  If such a symbol is\nfound, then returns the symbol as the first value and returns one of the\nfollowing symbols as the second value.\n        :INTERNAL (internal symbol in PACKAGE)\n        :EXTERNAL (external symbol in PACKAGE)\n        :INHERITED (external symbol of a package that PACKAGE is using)\nIf no such symbol is found, returns NIL as the first and second values.\n").
doc_string('find-symbol', 'common-lisp', function, "Return the symbol named STRING in PACKAGE. If such a symbol is found\n  then the second value is :INTERNAL, :EXTERNAL or :INHERITED to indicate\n  how the symbol is accessible. If no symbol is found then both values\n  are NIL.").
doc_string('finish-output', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nSends the contents of the output buffer for STREAM to the destination.  Waits\nuntil the buffer becomes empty and then returns NIL.\n").
doc_string('float-denormalized-p', pkg_sys, function, "Return true if the float X is denormalized.").
doc_string('float-denormalized-p', system, function, "Return true if the double-float X is denormalized.").
doc_string('float-digits', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT)\n\nReturns the number of radix-B digits used to represent the significand of\nFLOAT, where B is the base number used in the representation of FLOAT.\n").
doc_string('float-infinity-p', pkg_sys, function, "Return true if the float X is an infinity (+ or -).").
doc_string('float-nan-p', pkg_sys, function, "Return true if the float X is a NaN (Not a Number).").
doc_string('float-precision', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT)\n\nReturns the number of effective radix-B digits in the representation of the\nsignificand of FLOAT, where B is the base number used in the representation\nof FLOAT.\n").
doc_string('float-precision', 'common-lisp', function, "Return a non-negative number of significant digits in its float argument.\n  Will be less than FLOAT-DIGITS if denormalized or zero.").
doc_string('float-radix', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT)\n\nReturns the base number used in the representation of FLOAT.\n").
doc_string('float-radix', 'common-lisp', function, "Return (as an integer) the radix b of its floating-point argument.").
doc_string('float-sign', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT1 &OPTIONAL (FLOAT2 (FLOAT 1 FLOAT1)))\n\nReturns a float with the same sign as FLOAT1 and with the same absolute value\nas FLOAT2.\n").
doc_string('float-sign', 'common-lisp', function, "Return a floating-point number that has the same sign as\n   FLOAT1 and, if FLOAT2 is given, has the same absolute value\n   as FLOAT2.").
doc_string('float-trapping-nan-p', pkg_sys, function, "Return true if the float X is a trapping NaN (Not a Number).").
doc_string('floating-point-exception-traps', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('force-output', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nSends the contents of the output buffer for STREAM to the destination.\nReturns NIL without waiting until the buffer becomes empty.\n").
doc_string('foreground-thread', 'sb-thread', function, "Return the foreground thread of SESSION defaulting to the current\nsession.").
doc_string('foreign-symbol-address', 'sb-sys', function, "Returns the address of the foreign symbol NAME. DATAP must be true if the\nsymbol designates a variable (used only on linkage-table platforms). Returns a\nsecondary value that is true if DATAP was true and the symbol is a dynamic\nforeign symbol.\n\nOn linkage-table ports the returned address is always static: either direct\naddress of a static symbol, or the linkage-table address of a dynamic one.\nDynamic symbols are entered into the linkage-table if they aren't there already.\n\nOn non-linkage-table ports signals an error if the symbol isn't found.").
doc_string('foreign-symbol-sap', 'sb-sys', function, "Returns a SAP corresponding to the foreign symbol. DATAP must be true if the\nsymbol designates a variable (used only on linkage-table platforms). May enter\nthe symbol into the linkage-table. On non-linkage-table ports signals an error\nif the symbol isn't found.").
doc_string('form-1+', ffi, function, "if form is a number, return a number, otherwise return `(1+ ,form)").
doc_string('format-decoded-time', 'sb-int', function, "FORMAT-DECODED-TIME formats a string containing decoded time\n   expressed in a humanly-readable manner. The destination is any\n   destination which can be accepted by the FORMAT function. The\n   timezone keyword is an integer specifying hours west of Greenwich.\n   The style keyword can be :SHORT (numeric date), :LONG (months and\n   weekdays expressed as words), or :ABBREVIATED (like :LONG but words are\n   abbreviated). The keyword DATE-FIRST, if NIL, will cause the time\n   to be printed first instead of the date (the default). The PRINT-\n   keywords, if nil, inhibit the printing of certain semi-obvious\n   parts of the string.").
doc_string('format-error-args', 'sb-format', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('format-error-complaint', 'sb-format', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('format-error-control-string', 'sb-format', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('format-error-offset', 'sb-format', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('format-error-print-banner', 'sb-format', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('format-error-second-relative', 'sb-format', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('format-universal-time', 'sb-int', function, "Format-Universal-Time formats a string containing the time and date\n   given by universal-time in a common manner. The destination is any\n   destination which can be accepted by the Format function. The\n   timezone keyword is an integer specifying hours west of Greenwich.\n   The style keyword can be :SHORT (numeric date), :LONG (months and\n   weekdays expressed as words), :ABBREVIATED (like :LONG but words are\n   abbreviated), or :GOVERNMENT (of the form \"XX Month XXXX XX:XX:XX\")\n   The &KEY argument :DATE-FIRST, if NIL, will print the time first instead\n   of the date (the default). The PRINT- keywords, if NIL, inhibit\n   the printing of the obvious part of the time/date.").
doc_string('frame-call', 'sb-debug', function, "Returns as multiple values a descriptive name for the function responsible\nfor FRAME, arguments that that function, and a list providing additional\ninformation about the frame.\n\nUnavailable arguments are represented using dummy-objects printing as\n#<unavailable argument>.\n\nMETHOD-FRAME-STYLE (defaulting to *METHOD-FRAME-STYLE*), determines how frames\ncorresponding to method functions are printed. Possible values\nare :MINIMAL, :NORMAL, and :FULL. See *METHOD-FRAME-STYLE* for more\ninformation.\n\nIf REPLACE-DYNAMIC-EXTENT-OBJECTS is true, objects allocated on the stack of\nthe current thread are replaced with dummy objects which can safely escape.").
doc_string('frame-fun-mismatch-code-location', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('frame-fun-mismatch-form', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('frame-fun-mismatch-frame', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('frame-to-string', system, function, "Convert stack FRAME to a (potentially) readable string.").
doc_string('free-alien', 'sb-alien', function, "Dispose of the storage pointed to by ALIEN. The ALIEN must have been\nallocated by MAKE-ALIEN, MAKE-ALIEN-STRING or malloc(3).").
doc_string('fresh-line', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nOutputs a newline character only if the current position of STREAM is not at\nthe beginning of a line.  Returns T if it outputs a newline; NIL otherwise.\n").
doc_string('frs-bds', si, function, "Function in SI package:\nArgs: (N)\n\nECL specific.\nReturns the bind stack index of the N-th entity in the frame stack.\n").
doc_string('frs-ihs', si, function, "Function in SI package:\nArgs: (N)\n\nECL specific.\nReturns the invocation history stack index of the N-th entity in the frame\nstack.\n").
doc_string('function-lambda-expression', 'common-lisp', function, "Return (VALUES DEFINING-LAMBDA-EXPRESSION CLOSURE-P NAME), where\n  DEFINING-LAMBDA-EXPRESSION is NIL if unknown, or a suitable argument\n  to COMPILE otherwise, CLOSURE-P is non-NIL if the function's definition\n  might have been enclosed in some non-null lexical environment, and\n  NAME is some name (for debugging only) or NIL if there is no name.").
doc_string('function-redefinition-warning-new-function', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('gc-logfile', pkg_sys, function, "Return the pathname used to log garbage collections. Can be SETF.\nDefault is NIL, meaning collections are not logged. If non-null, the\ndesignated file is opened before and after each collection, and generation\nstatistics are appended to it.").
doc_string('general-category', 'sb-unicode', function, "Returns the general category of CHARACTER as it appears in UnicodeData.txt").
doc_string('generate-error-code', 'sb-vm', function, "Generate-Error-Code Error-code Value*\n  Emit code for an error with the specified Error-Code and context Values.").
doc_string('generate-fixnum-test', 'sb-vm', function, "Set the Z flag if VALUE is fixnum").
doc_string('generation-average-age', pkg_sys, function, "Average age of memory allocated to GENERATION: average number of times\nobjects allocated to the generation have seen younger objects promoted to it.\nAvailable on GENCGC platforms only.\n\nExperimental: interface subject to change.").
doc_string('generation-bytes-allocated', pkg_sys, function, "Number of bytes allocated to GENERATION currently. Available on GENCGC\nplatforms only.\n\nExperimental: interface subject to change.").
doc_string('generation-bytes-consed-between-gcs', pkg_sys, function, "Number of bytes that can be allocated to GENERATION before that\ngeneration is considered for garbage collection. This value is meaningless for\ngeneration 0 (the nursery): see BYTES-CONSED-BETWEEN-GCS instead. Default is\n5% of the dynamic space size divided by the number of non-nursery generations.\nCan be assigned to using SETF. Available on GENCGC platforms only.\n\nExperimental: interface subject to change.").
doc_string('generation-minimum-age-before-gc', pkg_sys, function, "Minimum average age of objects allocated to GENERATION before that\ngeneration is may be garbage collected. Default is 0.75. See also\nGENERATION-AVERAGE-AGE. Can be assigned to using SETF. Available on GENCGC\nplatforms only.\n\nExperimental: interface subject to change.").
doc_string('generation-number-of-gcs', pkg_sys, function, "Number of times garbage collection has been done on GENERATION without\npromotion. Available on GENCGC platforms only.\n\nExperimental: interface subject to change.").
doc_string('generation-number-of-gcs-before-promotion', pkg_sys, function, "Number of times garbage collection is done on GENERATION before\nautomatic promotion to the next generation is triggered. Default is 1. Can be\nassigned to using SETF. Available on GENCGC platforms only.\n\nExperimental: interface subject to change.").
doc_string('get-bytes-consed', pkg_sys, function, "Return the number of bytes consed since the program began. Typically\nthis result will be a consed bignum, so if you have an application (e.g.\nprofiling) which can't tolerate the overhead of consing bignums, you'll\nprobably want either to hack in at a lower level (as the code in the\nSB-PROFILE package does), or to design a more microefficient interface\nand submit it as a patch.").
doc_string('get-cas-expansion', pkg_sys, function, "Analogous to GET-SETF-EXPANSION. Returns the following six values:\n\n * list of temporary variables\n\n * list of value-forms whose results those variable must be bound\n\n * temporary variable for the old value of PLACE\n\n * temporary variable for the new value of PLACE\n\n * form using the aforementioned temporaries which performs the\n   compare-and-swap operation on PLACE\n\n * form using the aforementioned temporaries with which to perform a volatile\n   read of PLACE\n\nExample:\n\n  (get-cas-expansion '(car x))\n  ; => (#:CONS871), (X), #:OLD872, #:NEW873,\n  ;    (SB-KERNEL:%COMPARE-AND-SWAP-CAR #:CONS871 #:OLD872 :NEW873).\n  ;    (CAR #:CONS871)\n\n  (defmacro my-atomic-incf (place &optional (delta 1) &environment env)\n    (multiple-value-bind (vars vals old new cas-form read-form)\n        (get-cas-expansion place env)\n     (let ((delta-value (gensym \"DELTA\")))\n       `(let* (,@(mapcar 'list vars vals)\n               (,old ,read-form)\n               (,delta-value ,delta)\n               (,new (+ ,old ,delta-value)))\n          (loop until (eq ,old (setf ,old ,cas-form))\n                do (setf ,new (+ ,old ,delta-value)))\n          ,new))))\n\nEXPERIMENTAL: Interface subject to change.").
doc_string('get-decoded-time', 'common-lisp', function, "Args: ()\nReturns the current day-and-time as nine values:\n        second (0 - 59)\n        minute (0 - 59)\n        hour (0 - 23)\n        date (1 - 31)\n        month (1 - 12)\n        year (Christian, not Japanese long-live-Emperor)\n        day of week (0 for Mon, .. 6 for Sun)\n        summer time or not (T or NIL)\n        time zone (-9 in Japan)\nSunday is the *last* day of the week!!").
doc_string('get-decoded-time', 'common-lisp', function, "Return nine values specifying the current time as follows:\n   second, minute, hour, date, month, year, day of week (0 = Monday), T\n   (daylight savings times) or NIL (standard time), and timezone.").
doc_string('get-dispatch-macro-character', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR SUBCHAR &OPTIONAL (READTABLE *READTABLE*))\n\nReturns the read macro for SUBCHAR associated with the dispatch macro\ncharacter CHAR in READTABLE.\n").
doc_string('get-dispatch-macro-character', 'common-lisp', function, "Return the macro character function for SUB-CHAR under DISP-CHAR\n   or NIL if there is no associated function.").
doc_string('get-errno', 'sb-alien', function, "Return the value of the C library pseudo-variable named \"errno\".").
doc_string('get-floating-point-modes', 'sb-int', function, "This function returns a list representing the state of the floating\npoint modes. The list is in the same format as the &KEY arguments to\nSET-FLOATING-POINT-MODES, i.e.\n\n  (apply #'set-floating-point-modes (get-floating-point-modes))\n\nsets the floating point modes to their current values (and thus is a no-op).").
doc_string('get-internal-real-time', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: NIL\n\nReturns the time (in 1/100 seconds) since the invocation of WAM-CL.\n").
doc_string('get-internal-real-time', 'common-lisp', function, "Return the real time (\"wallclock time\") since startup in the internal\ntime format. (See INTERNAL-TIME-UNITS-PER-SECOND.)").
doc_string('get-internal-run-time', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: NIL\n\nReturns the CPU time (in 1/100 seconds) since the invocation of WAM-CL.\n").
doc_string('get-internal-run-time', 'common-lisp', function, "Return the run time used by the process in the internal time format. (See\nINTERNAL-TIME-UNITS-PER-SECOND.) This is useful for finding CPU usage.\nIncludes both \"system\" and \"user\" time.").
doc_string('get-keymap', readline, function, "Return current keymap").
doc_string('get-keymap-by-name', readline, function, "Get keymap with given name (e.g., emacs, vi)").
doc_string('get-macro-character', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &OPTIONAL (READTABLE *READTABLE*))\n\nReturns the read macro associated with the macro character CHAR in READTABLE.\nReturns the non-terminating-p flag (see READTABLE) as the second value.\nReturns NIL if CHAR is not a macro character.\n").
doc_string('get-macro-character', 'common-lisp', function, "Return the function associated with the specified CHAR which is a macro\n  character, or NIL if there is no such function. As a second value, return\n  T if CHAR is a macro character which is non-terminating, i.e. which can\n  be embedded in a symbol name.").
doc_string('get-mutex', 'sb-thread', function, "The function SB-THREAD:GET-MUTEX has been deprecated as of SBCL version 1.0.37.33.\n\nUse SB-THREAD:GRAB-MUTEX instead.").
doc_string('get-output-stream-string', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING-OUTPUT-STREAM)\n\nReturns as a string all outputs to STRING-OUTPUT-STREAM since the last call of\nGET-OUTPUT-STREAM-STRING for the same stream.\n").
doc_string('get-properties', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PLIST LIST)\n\nSearches PLIST for a property that is EQ to one of the members of LIST.\nReturns three values.  If such a property if found, returns the property, the\nvalue of the property, and the rest of LIST.  If not, returns three NILs.\n").
doc_string('get-properties', 'common-lisp', function, "Like GETF, except that INDICATOR-LIST is a list of indicators which will\n  be looked for in the property list stored in PLACE. Three values are\n  returned, see manual for details.").
doc_string('get-setf-expansion', 'common-lisp', function, "Args: (form)\nReturns the 'five gangs' (see DEFINE-SETF-EXPANDER) for PLACE as five values.\nDoes not check if the third gang is a single-element list.").
doc_string('get-setf-expansion', 'common-lisp', function, "Return five values needed by the SETF machinery: a list of temporary\n   variables, a list of values with which to fill them, a list of temporaries\n   for the new values, the setting function, and the accessing function.").
doc_string('get-spinlock', 'sb-thread', function, "The function SB-THREAD::GET-SPINLOCK has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:GRAB-MUTEX instead.").
doc_string('get-time-of-day', pkg_sys, function, "Return the number of seconds and microseconds since the beginning of\nthe UNIX epoch (January 1st 1970.)").
doc_string('get-universal-time', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: NIL\n\nReturns the current day-and-time as an integer.  See DECODE-UNIVERSAL-TIME.\n").
doc_string('get-universal-time', 'common-lisp', function, "Return a single integer for the current time of day in universal time\nformat.").
doc_string('getenv-all', extensions, function, "Returns all environment variables as an alist containing (name . value)").
doc_string('global-handler', system, function, "the global error handler, methods should not return").
doc_string('grab-mutex', 'sb-thread', function, "Acquire MUTEX for the current thread. If WAITP is true (the default) and\nthe mutex is not immediately available, sleep until it is available.\n\nIf TIMEOUT is given, it specifies a relative timeout, in seconds, on how long\nGRAB-MUTEX should try to acquire the lock in the contested case.\n\nIf GRAB-MUTEX returns T, the lock acquisition was successful. In case of WAITP\nbeing NIL, or an expired TIMEOUT, GRAB-MUTEX may also return NIL which denotes\nthat GRAB-MUTEX did -not- acquire the lock.\n\nNotes:\n\n  - GRAB-MUTEX is not interrupt safe. The correct way to call it is:\n\n      (WITHOUT-INTERRUPTS\n        ...\n        (ALLOW-WITH-INTERRUPTS (GRAB-MUTEX ...))\n        ...)\n\n    WITHOUT-INTERRUPTS is necessary to avoid an interrupt unwinding the call\n    while the mutex is in an inconsistent state while ALLOW-WITH-INTERRUPTS\n    allows the call to be interrupted from sleep.\n\n  - (GRAB-MUTEX <mutex> :timeout 0.0) differs from\n    (GRAB-MUTEX <mutex> :waitp nil) in that the former may signal a\n    DEADLINE-TIMEOUT if the global deadline was due already on entering\n    GRAB-MUTEX.\n\n    The exact interplay of GRAB-MUTEX and deadlines are reserved to change in\n    future versions.\n\n  - It is recommended that you use WITH-MUTEX instead of calling GRAB-MUTEX\n    directly.\n").
doc_string('grapheme-break-class', 'sb-unicode', function, "Returns the grapheme breaking class of CHARACTER, as specified in UAX #29.").
doc_string('graphic-char-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is a printing character, i.e., a standard character other\nthan #\\Newline.  Returns NIL otherwise.\n").
doc_string('graphic-char-p', 'common-lisp', function, "The argument must be a character object. GRAPHIC-CHAR-P returns T if the\nargument is a printing character (space through ~ in ASCII), otherwise returns\nNIL.").
doc_string('handler-bind', 'common-lisp', function, "(HANDLER-BIND ( {(type handler)}* ) body)\n\nExecutes body in a dynamic context where the given handler bindings are in\neffect. Each handler must take the condition being signalled as an argument.\nThe bindings are searched first to last in the event of a signalled\ncondition.").
doc_string('handler-case', 'common-lisp', function, "(HANDLER-CASE form { (type ([var]) body) }* )\n\nExecute FORM in a context with handlers established for the condition types. A\npeculiar property allows type to be :NO-ERROR. If such a clause occurs, and\nform returns normally, all its values are passed to this clause as if by\nMULTIPLE-VALUE-CALL. The :NO-ERROR clause accepts more than one var\nspecification.").
doc_string('hangul-syllable-type', 'sb-unicode', function, "Returns the Hangul syllable type of CHARACTER.\nThe syllable type can be one of :L, :V, :T, :LV, or :LVT.\nIf the character is not a Hangul syllable or Jamo, returns NIL").
doc_string('hash-table-count', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (HASH-TABLE)\n\nReturns the number of entries in HASH-TABLE.\n").
doc_string('hash-table-count', 'common-lisp', function, "Return the number of entries in the given HASH-TABLE.").
doc_string('hash-table-count', 'common-lisp', function, "Returns the number of entries in HASH-TABLE.").
doc_string('hash-table-entries', system, function, "Returns a list of all key/values pairs in HASH-TABLE.").
doc_string('hash-table-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a hash-table object; NIL otherwise.\n").
doc_string('hash-table-p', 'common-lisp', function, "Whether OBJECT is an instance of a hash-table.").
doc_string('hash-table-rehash-size', 'common-lisp', function, "Return the rehash-size HASH-TABLE was created with.").
doc_string('hash-table-rehash-threshold', 'common-lisp', function, "Return the rehash-threshold HASH-TABLE was created with.").
doc_string('hash-table-size', 'common-lisp', function, "Return a size that can be used with MAKE-HASH-TABLE to create a hash\n   table that can hold however many entries HASH-TABLE can hold without\n   having to be grown.").
doc_string('hash-table-size', 'common-lisp', function, "Returns the number of storage buckets in HASH-TABLE.").
doc_string('hash-table-synchronized-p', pkg_sys, function, "Returns T if HASH-TABLE is synchronized.").
doc_string('hash-table-test', 'common-lisp', function, "Return the test HASH-TABLE was created with.").
doc_string('hash-table-test', 'common-lisp', function, "Return the test used for the keys of HASH-TABLE.").
doc_string('hash-table-weakness', pkg_sys, function, "Return the WEAKNESS of HASH-TABLE which is one of NIL, :KEY,\n:VALUE, :KEY-AND-VALUE, :KEY-OR-VALUE.").
doc_string('hash-table-weakness', system, function, "Return weakness property of HASH-TABLE, or NIL if it has none.").
doc_string('help*', si, function, "Args: (string &optional (package-spec 'lisp))\nECL specific.\nPrints the documentation associated with those symbols in the specified\npackage whose print names contain STRING as substring.  STRING may be a\nsymbol, in which case the print-name of that symbol is used.  If PACKAGE is\nNIL, then all packages are searched.").
doc_string('hex-digit-p', 'sb-unicode', function, "Returns T if CHARACTER is a hexadecimal digit and NIL otherwise.\nIf :ASCII is non-NIL, fullwidth equivalents of the Latin letters A through F\nare excluded.").
doc_string('holding-mutex-p', 'sb-thread', function, "Test whether the current thread is holding MUTEX.").
doc_string('host-namestring', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns as a string the host part of the pathname specified by FILESPEC.\nFILESPEC may be a symbol, a string, a pathname, or a file stream.\n").
doc_string('host-namestring', 'common-lisp', function, "Return a string representation of the name of the host in the pathname.").
doc_string('host-namestring', 'common-lisp', function, "Returns the host name of PATHNAME.").
doc_string('http-proxy', sys, function, "\r\nWhen the argument is supplied or *HTTP-PROXY* is NIL, parse the argument,\r\nset *HTTP-PROXY*, and return it; otherwise just return *HTTP-PROXY*.").
doc_string('ideographic-p', 'sb-unicode', function, "Returns T if CHARACTER has the Unicode property Ideographic,\nwhich loosely corresponds to the set of \"Chinese characters\"").
doc_string('ignore-errors', 'common-lisp', function, "Execute FORMS handling ERROR conditions, returning the result of the last\n  form, or (VALUES NIL the-ERROR-that-was-caught) if an ERROR was handled.").
doc_string('ihs-fun', si, function, "Function in SI package:\nArgs: (N)\n\nECL specific.\nReturns the function value of the N-th entity in the invocation history stack.\n").
doc_string('implicit-generic-function-name', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('impnotes-root', custom, function, "\r\nThis returns the root URL for the CLISP implementation notes.\r\nYou can set the environment variable `IMPNOTES' or redefine this function\r\nin ~/.clisprc.  On win32 you can also use the Registry.").
doc_string('in-interruption', 'sb-sys', function, "Convenience macro on top of INVOKE-INTERRUPTION.").
doc_string('in-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE-NAME &KEY (NICKNAMES NIL) (USE '(LISP)))\n\nMakes the package named PACKAGE-NAME as the current package.  If such a\npackage does not exist, then creates one by passing all args to MAKE-PACKAGE.\nOtherwise, adds the specified nicknames and packages to the nickname list and\nuse list of the package.  NICKNAMES must be a list consisting of strings and\nsymbols.  USE must be a list consisting of package objects and package names\n(either string or symbol).\n").
doc_string('incf-complex', system, function, "The first argument is some location holding a number.  This number is\r\n   incremented by the second argument, DELTA, which defaults to 1.").
doc_string('initarg-error-class', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('initarg-error-initargs', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('input-error-in-compile-file-invoker', 'sb-c', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('input-error-in-compile-file-line/col', 'sb-c', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('input-error-in-compile-file-position', 'sb-c', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('input-stream-p', 'common-lisp', function, "Can STREAM perform input operations?").
doc_string('input-stream-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM)\n\nReturns T if STREAM can handle input operations; NIL otherwise.\n").
doc_string('input-stream-p', gray, function, "Can STREAM perform input operations?").
doc_string('instance-class', si, function, "Function in SI package:\nArgs: (INSTANCE)\n\nECL/CLOS specific.\nReturns the class of which the given INSTANCE is an instance.\n").
doc_string('instance-class-set', si, function, "Function in SI package:\nArgs: (INSTANCE CLASS)\n\nECL/CLOS specific.\nMakes INSTANCE an instance of CLASS class.\n").
doc_string('instance-ref', si, function, "Function in SI package:\nArgs: (INSTANCE INDEX)\n\nECL/CLOS specific.\nReturns the value of the INDEX-th slot of INSTANCE. The first slot has\nINDEX equal to zero.\n").
doc_string('instance-set', si, function, "Function in SI package:\nArgs: (INSTANCE INDEX VALUE)\n\nECL/CLOS specific.\nSets to VALUE the value of INDEX-th slot of INSTANCE. The first slot has\nINDEX equal to zero.\n").
doc_string('instance-structure-protocol-error-fun', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('instance-structure-protocol-error-slotd', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('instruction-attributep', 'sb-assem', function, "Automagically generated boolean attribute test function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('instruction-attributes', 'sb-assem', function, "Automagically generated boolean attribute creation function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('integer-decode-float', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT)\n\nReturns, as three values, the integer interpretation of significand F, the\nexponent E, and the sign S of FLOAT, such that\n        FLOAT = S * F * B^E\nwhere B = (float-radix FLOAT).  F is a non-negative integer, E is an integer,\nand S is either 1 or -1.\n").
doc_string('integer-decode-float', 'common-lisp', function, "Return three values:\n   1) an integer representation of the significand.\n   2) the exponent for the power of 2 that the significand must be multiplied\n      by to get the actual value. This differs from the DECODE-FLOAT exponent\n      by FLOAT-DIGITS, since the significand has been scaled to have all its\n      digits before the radix point.\n   3) -1 or 1 (i.e. the sign of the argument.)").
doc_string('integer-length', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER)\n\nReturns the number of \"significant bits\" in the representation of INTEGER.\nWith positive arg, returns one plus the position of the most significant bit\nthat is 'on'.  With negative arg other than -1, returns one plus the position\nof the most significant bit that is 'off'.  For 0 and -1, returns 0.\n").
doc_string('integer-length', 'common-lisp', function, "Return the number of non-sign bits in the twos-complement representation\n  of INTEGER.").
doc_string('interactive-eval', pkg_sys, function, "Evaluate FORM, returning whatever it returns and adjusting ***, **, *,\n+++, ++, +, ///, //, /, and -.").
doc_string('interactive-stream-p', 'common-lisp', function, "Is STREAM an interactive stream?").
doc_string('interactive-threads', 'sb-thread', function, "Return the interactive threads of SESSION defaulting to the current\nsession.").
doc_string('internal-time-units-per-second', 'common-lisp', variable, "Constant in COMMON-LISP package:\nGives the time unit used by GET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME.\n1000 in WAM-CL.\n").
doc_string('internal-time-units-per-second', 'common-lisp', variable, "The number of internal time units that fit into a second. See\nGET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME.").
doc_string('interrupt-thread', 'sb-thread', function, "Interrupt THREAD and make it run FUNCTION.\n\nThe interrupt is asynchronous, and can occur anywhere with the exception of\nsections protected using SB-SYS:WITHOUT-INTERRUPTS.\n\nFUNCTION is called with interrupts disabled, under\nSB-SYS:ALLOW-WITH-INTERRUPTS. Since functions such as GRAB-MUTEX may try to\nenable interrupts internally, in most cases FUNCTION should either enter\nSB-SYS:WITH-INTERRUPTS to allow nested interrupts, or\nSB-SYS:WITHOUT-INTERRUPTS to prevent them completely.\n\nWhen a thread receives multiple interrupts, they are executed in the order\nthey were sent -- first in, first out.\n\nThis means that a great degree of care is required to use INTERRUPT-THREAD\nsafely and sanely in a production environment. The general recommendation is\nto limit uses of INTERRUPT-THREAD for interactive debugging, banning it\nentirely from production environments -- it is simply exceedingly hard to use\ncorrectly.\n\nWith those caveats in mind, what you need to know when using it:\n\n * If calling FUNCTION causes a non-local transfer of control (ie. an\n   unwind), all normal cleanup forms will be executed.\n\n   However, if the interrupt occurs during cleanup forms of an UNWIND-PROTECT,\n   it is just as if that had happened due to a regular GO, THROW, or\n   RETURN-FROM: the interrupted cleanup form and those following it in the\n   same UNWIND-PROTECT do not get executed.\n\n   SBCL tries to keep its own internals asynch-unwind-safe, but this is\n   frankly an unreasonable expectation for third party libraries, especially\n   given that asynch-unwind-safety does not compose: a function calling\n   only asynch-unwind-safe function isn't automatically asynch-unwind-safe.\n\n   This means that in order for an asynch unwind to be safe, the entire\n   callstack at the point of interruption needs to be asynch-unwind-safe.\n\n * In addition to asynch-unwind-safety you must consider the issue of\n   reentrancy. INTERRUPT-THREAD can cause function that are never normally\n   called recursively to be re-entered during their dynamic contour,\n   which may cause them to misbehave. (Consider binding of special variables,\n   values of global variables, etc.)\n\nTake together, these two restrict the \"safe\" things to do using\nINTERRUPT-THREAD to a fairly minimal set. One useful one -- exclusively for\ninteractive development use is using it to force entry to debugger to inspect\nthe state of a thread:\n\n  (interrupt-thread thread #'break)\n\nShort version: be careful out there.").
doc_string('interrupt-thread', threads, function, "Interrupts THREAD and forces it to apply FUNCTION to ARGS.\r\nWhen the function returns, the thread's original computation continues. If  multiple interrupts are queued for a thread, they are all run, but the order is not guaranteed.").
doc_string('interrupt-thread-error-thread', 'sb-thread', function, "The function SB-THREAD:INTERRUPT-THREAD-ERROR-THREAD has been deprecated as of SBCL version 1.0.29.17.\n\nUse SB-THREAD:THREAD-ERROR-THREAD instead.").
doc_string('invalid-array-index-error-array', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-array-index-error-axis', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-byte', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-byte-nr', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-expected', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-features', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-fhsss', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-implementation', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-potential-features', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-stream', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-fasl-version', 'sb-fasl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-method-initarg-method', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-superclass-class', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-superclass-superclass', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-value-debug-var', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalid-value-frame', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('invalidate-alien-callback', 'sb-alien', function, "Invalidates the callback designated by the alien, if any, allowing the\nassociated lisp function to be GC'd, and causing further calls to the same\ncallback signal an error.").
doc_string('invalidate-descriptor', 'sb-sys', function, "Remove any handlers referring to FD. This should only be used when attempting\n  to recover from a detected inconsistency.").
doc_string('invoke-debugger', 'common-lisp', function, "Enter the debugger.").
doc_string('invoke-restart', 'common-lisp', function, "Calls the function associated with the given restart, passing any given\n   arguments. If the argument restart is not a restart or a currently active\n   non-nil restart name, then a CONTROL-ERROR is signalled.").
doc_string('invoke-restart-interactively', 'common-lisp', function, "Calls the function associated with the given restart, prompting for any\n   necessary arguments. If the argument restart is not a restart or a\n   currently active non-NIL restart name, then a CONTROL-ERROR is signalled.").
doc_string('io-timeout-direction', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('ir1-attributep', 'sb-c', function, "Automagically generated boolean attribute test function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('ir1-attributes', 'sb-c', function, "Automagically generated boolean attribute creation function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('iterator-copy', 'sb-sequence', function, "Returns a copy of ITERATOR which also traverses SEQUENCE but can\n   be mutated independently of ITERATOR.").
doc_string('iterator-element', 'sb-sequence', function, "Returns the element of SEQUENCE associated to the position of\n   ITERATOR.").
doc_string('iterator-endp', 'sb-sequence', function, "Returns non-NIL when ITERATOR has reached LIMIT (which may\n   correspond to the end of SEQUENCE) with respect to the iteration\n   direction encoded in FROM-END.").
doc_string('iterator-index', 'sb-sequence', function, "Returns the position of ITERATOR in SEQUENCE.").
doc_string('iterator-step', 'sb-sequence', function, "Moves ITERATOR one position forward or backward in SEQUENCE\n   depending on the iteration direction encoded in FROM-END.").
doc_string('join-thread', 'sb-thread', function, "Suspend current thread until THREAD exits. Return the result values\nof the thread function.\n\nIf THREAD does not exit within TIMEOUT seconds and DEFAULT is\nsupplied, return two values: 1) DEFAULT 2) :TIMEOUT. If DEFAULT is not\nsupplied, signal a JOIN-THREAD-ERROR with JOIN-THREAD-PROBLEM equal\nto :TIMEOUT.\n\nIf THREAD did not exit normally (i.e. aborted) and DEFAULT is\nsupplied, return two values: 1) DEFAULT 2) :ABORT. If DEFAULT is not\nsupplied, signal a JOIN-THREAD-ERROR with JOIN-THREAD-PROBLEM equal\nto :ABORT.\n\nIf THREAD is the current thread, signal a JOIN-THREAD-ERROR with\nJOIN-THREAD-PROBLEM equal to :SELF-JOIN.\n\nTrying to join the main thread will cause JOIN-THREAD to block until\nTIMEOUT occurs or the process exits: when main thread exits, the\nentire process exits.\n\nNOTE: Return convention in case of a timeout is experimental and\nsubject to change.").
doc_string('join-thread-error-thread', 'sb-thread', function, "The function SB-THREAD:JOIN-THREAD-ERROR-THREAD has been deprecated as of SBCL version 1.0.29.17.\n\nUse SB-THREAD:THREAD-ERROR-THREAD instead.").
doc_string('join-thread-problem', 'sb-thread', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('label-position', 'sb-assem', function, "Return the current position for LABEL. Chooser maybe-shrink functions\n   should supply IF-AFTER and DELTA in order to ensure correct results.").
doc_string('lambda-list-keywords', 'common-lisp', variable, "A list of symbols used as lambda list keywords in SBCL.").
doc_string('lambda-list-keywords', 'common-lisp', variable, "Constant in COMMON-LISP package:\nList of all lambda-list keywords, including\n        &optional       &rest           &key\n        &allow-other-keys               &aux\n        &whole          &environment    &body\n").
doc_string('lambda-list-unavailable-debug-fun', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('lambda-parameters-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound of the number of parameters specified by a lambda list.\nIgnore this number; there is no such upper bound in WAM-CL.\n").
doc_string('lambda-parameters-limit', 'common-lisp', variable, "The exclusive upper bound on the number of parameters which may be specified\n  in a given lambda list. This is actually the limit on required and &OPTIONAL\n  parameters. With &KEY and &AUX you can get more.").
doc_string('lambda-var-attributep', 'sb-c', function, "Automagically generated boolean attribute test function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('lambda-var-attributes', 'sb-c', function, "Automagically generated boolean attribute creation function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('layout-clos-hash-limit', 'sb-kernel', variable, "the exclusive upper bound on LAYOUT-CLOS-HASH values").
doc_string('ldb-test', 'common-lisp', function, "Args: (bytespec integer)\nReturns T if at least one bit of the specified byte is 1; NIL otherwise.").
doc_string('ldb-test', 'common-lisp', function, "Return T if any of the specified bits in integer are 1's.").
doc_string('least-negative-double-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as LEAST-NEGATIVE-LONG-FLOAT.\n").
doc_string('least-negative-long-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe negative long-float with the smallest absolute value.\n").
doc_string('least-negative-short-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe negative short-float with the smallest absolute value.\n").
doc_string('least-negative-single-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as LEAST-NEGATIVE-LONG-FLOAT.\n").
doc_string('least-positive-double-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as LEAST-POSITIVE-LONG-FLOAT.\n").
doc_string('least-positive-long-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe smallest positive long-float.\n").
doc_string('least-positive-short-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe smallest positive short-float.\n").
doc_string('least-positive-single-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as LEAST-POSITIVE-LONG-FLOAT.\n").
doc_string('let*', 'common-lisp', function, "LET* ({(var [value]) | var}*) declaration* form*\n\nSimilar to LET, but the variables are bound sequentially, allowing each VALUE\nform to reference any of the previous VARS.").
doc_string('let*', 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: ((&REST BINDINGS) &BODY BODY)\n\nEvaluates INIT (which defaults to NIL) and binds the value to the\ncorresponding VAR, one by one for each pair of VAR and INIT.  Then evaluates\nFORMs and returns all values of the last FORM.  Returns NIL if no FORM is\ngiven.\n").
doc_string('lexical-environment-too-complex-form', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('lexical-environment-too-complex-lexenv', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('line-break-class', 'sb-unicode', function, "Returns the line breaking class of CHARACTER, as specified in UAX #14.\nIf :RESOLVE is NIL, returns the character class found in the property file.\nIf :RESOLVE is non-NIL, centain line-breaking classes will be mapped to othec\nclasses as specified in the applicable standards. Addinionally, if :RESOLVE\nis :EAST-ASIAN, Ambigious (class :AI) characters will be mapped to the\nIdeographic (:ID) class instead of Alphabetic (:AL).").
doc_string('lisp-implementation-type', 'common-lisp', function, "Args: ()\nReturns the string \"WAM-CL\".").
doc_string('lisp-implementation-version', 'common-lisp', function, "Args:()\nReturns the version of your WAM-CL as a string.").
doc_string('list*', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARG &REST MORE-ARGS)\n\nWith one arg, simply returns it.  With n args (n > 1), conses the first arg to\nthe LIST* of the rest of args.\n").
doc_string('list*', 'common-lisp', function, "Return a list of the arguments with last cons a dotted pair.").
doc_string('list*', 'sb-impl', function, "Return a list of the arguments with last cons a dotted pair.").
doc_string('list-all-packages', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: NIL\n\nReturns a list of all packages.\n").
doc_string('list-all-packages', 'common-lisp', function, "Return a list of all existing packages.").
doc_string('list-all-threads', 'sb-thread', function, "Return a list of the live threads. Note that the return value is\npotentially stale even before the function returns, as new threads may be\ncreated and old ones may exit at any time.").
doc_string('list-all-timers', pkg_sys, function, "Return a list of all timers in the system.").
doc_string('list-backtrace', 'sb-debug', function, "Returns a list describing the call stack. Each frame is represented\nby a sublist:\n\n  (<name> ...args...)\n\nwhere the name describes the function responsible for the frame. The name\nmight not be bound to the actual function object. Unavailable arguments are\nrepresented by dummy objects that print as #<unavailable argument>. Objects\nwith dynamic-extent allocation by the current thread are represented by\nsubstitutes to avoid references to them from leaking outside their legal\nextent.\n\nCOUNT is the number of frames to backtrace, defaulting to\n*BACKTRACE-FRAME-COUNT*.\n\nSTART is the number of the frame the backtrace should start from.\n\nFROM specifies the frame relative to which the frames are numbered. Possible\nvalues are an explicit SB-DI:FRAME object, and the\nkeywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default\nis :DEBUGGER-FRAME.\n\n  :CURRENT-FRAME\n    specifies the caller of LIST-BACKTRACE.\n\n  :INTERRUPTED-FRAME\n    specifies the first interrupted frame on the stack (typically the frame\n    where the error occured, as opposed to error handling frames) if any,\n    otherwise behaving as :CURRENT-FRAME.\n\n  :DEBUGGER-FRAME\n    specifies the currently debugged frame when inside the debugger, and\n    behaves as :INTERRUPTED-FRAME outside the debugger.\n\nMETHOD-FRAME-STYLE (defaulting to *METHOD-FRAME-STYLE*), determines how frames\ncorresponding to method functions are printed. Possible values\nare :MINIMAL, :NORMAL, and :FULL. See *METHOD-FRAME-STYLE* for more\ninformation.").
doc_string('list-directory', system, function, "Lists the contents of DIRECTORY, optionally resolving symbolic links.").
doc_string('list-length', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST)\n\nReturns the length of LIST.  Returns NIL if LIST is circular.\n").
doc_string('list-length', 'common-lisp', function, "Return the length of the given List, or Nil if the List is circular.").
doc_string('load-1-foreign', 'sb-alien', function, "Unsupported as of SBCL 0.8.13. Please use LOAD-SHARED-OBJECT.").
doc_string('load-foreign', 'sb-alien', function, "Unsupported as of SBCL 0.8.13. See LOAD-SHARED-OBJECT.").
doc_string('load-logical-pathname-translations', 'common-lisp', function, "Reads logical pathname translations from SYS:SITE;HOST.TRANSLATIONS.NEWEST,\nwith HOST replaced by the supplied parameter. Returns T on success.\n\nIf HOST is already defined as logical pathname host, no file is loaded and NIL\nis returned.\n\nThe file should contain a single form, suitable for use with\n(SETF LOGICAL-PATHNAME-TRANSLATIONS).\n\nNote: behaviour of this function is highly implementation dependent, and\nhistorically it used to be a no-op in SBCL -- the current approach is somewhat\nexperimental and subject to change.").
doc_string('load-logical-pathname-translations', 'common-lisp', function, "Search for a logical pathname named host, if not already defined. If already\ndefined no attempt to find or load a definition is attempted and NIL is\nreturned. If host is not already defined, but definition is found and loaded\nsuccessfully, T is returned, else error.").
doc_string('load-shared-object', 'sb-alien', function, "Load a shared library / dynamic shared object file / similar foreign\ncontainer specified by designated PATHNAME, such as a .so on an ELF platform.\n\nLocating the shared object follows standard rules of the platform, consult the\nmanual page for dlopen(3) for details. Typically paths specified by\nenvironment variables such as LD_LIBRARY_PATH are searched if the PATHNAME has\nno directory, but on some systems (eg. Mac OS X) search may happen even if\nPATHNAME is absolute. (On Windows LoadLibrary is used instead of dlopen(3).)\n\nOn non-Windows platforms calling LOAD-SHARED-OBJECT again with a PATHNAME\nEQUAL to the designated pathname of a previous call will replace the old\ndefinitions; if a symbol was previously referenced through the object and\nis not present in the reloaded version an error will be signalled. Reloading\nmay not work as expected if user or library-code has called dlopen(3) on the\nsame shared object.\n\nLOAD-SHARED-OBJECT interacts with SB-EXT:SAVE-LISP-AND-DIE:\n\n1. If DONT-SAVE is true (default is NIL), the shared object will be dropped\nwhen SAVE-LISP-AND-DIE is called -- otherwise shared objects are reloaded\nautomatically when a saved core starts up. Specifying DONT-SAVE can be useful\nwhen the location of the shared object on startup is uncertain.\n\n2. On most platforms references in compiled code to foreign symbols in shared\nobjects (such as those generated by DEFINE-ALIEN-ROUTINE) remain valid across\nSAVE-LISP-AND-DIE. On those platforms where this is not supported, a WARNING\nwill be signalled when the core is saved -- this is orthogonal from DONT-SAVE.").
doc_string('load-time-value', 'common-lisp', function, "Arrange for FORM to be evaluated at load-time and use the value produced as\nif it were a constant. If READ-ONLY-P is non-NIL, then the resultant object is\nguaranteed to never be modified, so it can be put in read-only storage.").
doc_string('load-type', 'sb-vm', function, "Loads the type bits of a pointer into target independent of\n   byte-ordering issues.").
doc_string('lock-package', pkg_sys, function, "Locks PACKAGE and returns T. Has no effect if PACKAGE was already\nlocked. Signals an error if PACKAGE is not a valid package designator").
doc_string('logical-pathname', 'common-lisp', function, "Converts the pathspec argument to a logical-pathname and returns it.").
doc_string('logical-pathname-p', system, function, "Returns true if OBJECT is of type logical-pathname; otherwise, returns false.").
doc_string('logical-pathname-translations', 'common-lisp', function, "Return the (logical) host object argument's list of translations.").
doc_string('long-float-epsilon', 'common-lisp', variable, "The smallest postive long-float E that satisfies\n        (not (= (float 1 E) (+ (float 1 E) E)))").
doc_string('long-float-negative-epsilon', 'common-lisp', variable, "The smallest positive long-float E that satisfies\n        (not (= (float 1 E) (- (float 1 E) E)))").
doc_string('long-float-p', 'sb-int', function, "Return true if OBJECT is a LONG-FLOAT, and NIL otherwise.").
doc_string('long-site-name', 'common-lisp', function, "Args: ()\nReturns, as a string, the location of the machine on which WAM-CL runs.").
doc_string('long-site-name', 'common-lisp', function, "Return a string with the long form of the site name, or NIL if not known.").
doc_string('loop-finish', 'common-lisp', function, "Cause the iteration to terminate \"normally\", the same as implicit\ntermination by an iteration driving clause, or by use of WHILE or\nUNTIL -- the epilogue code (if any) will be run, and any implicitly\ncollected result will be returned as the value of the LOOP.").
doc_string('loop-finish', 'common-lisp', function, "Causes the iteration to terminate \"normally\", the same as implicit\ntermination by an iteration driving clause, or by use of WHILE or\nUNTIL -- the epilogue code (if any) will be run, and any implicitly\ncollected result will be returned as the value of the LOOP.").
doc_string('lower-case-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is a lower-case character; NIL otherwise.\n").
doc_string('lower-case-p', 'common-lisp', function, "The argument must be a character object; LOWER-CASE-P returns T if the\nargument is a lower-case character, NIL otherwise.").
doc_string('lowercase-p', 'sb-unicode', function, "Returns T if CHARACTER has the Unicode property Lowercase and NIL otherwise").
doc_string('lra-p', 'sb-kernel', function, "Return true if OBJECT is a LRA, and NIL otherwise.").
doc_string('machine-instance', 'common-lisp', function, "Args: ()\nReturns, as a string, the identifier of the machine on which WAM-CL runs.").
doc_string('machine-instance', 'common-lisp', function, "Return a string giving the name of the local machine.").
doc_string('machine-type', 'common-lisp', function, "Args: ()\nReturns, as a string, the type of the machine on which WAM-CL runs.").
doc_string('machine-type', 'common-lisp', function, "Return a string describing the type of the local machine.").
doc_string('machine-version', 'common-lisp', function, "Args: ()\nReturns, as a string, the version of the machine on which WAM-CL runs. Obtained from\nuname(2) where available.").
doc_string('machine-version', 'common-lisp', function, "Return a string describing the version of the computer hardware we\nare running on, or NIL if we can't find any useful information.").
doc_string('macro-function', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns the expansion function of the global macro named SYMBOL.  Returns NIL\nif no such macro exists.  The expansion function receives a macro form and an\nenvironment, and returns the expanded form.\n").
doc_string('macro-function', 'common-lisp', function, "If SYMBOL names a macro in ENV, returns the expansion function,\nelse returns NIL. If ENV is unspecified or NIL, use the global environment\nonly.").
doc_string('macroexpand-1', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FORM &OPTIONAL (ENV NIL))\n\nIf FORM is a macro form, then expands it once and returns the result as the\nfirst value and T as the second value.  Otherwise, returns FORM and NIL as two\nvalues.\n").
doc_string('macroexpand-1', 'common-lisp', function, "If form is a macro (or symbol macro), expand it once. Return two values,\n   the expanded form and a T-or-NIL flag indicating whether the form was, in\n   fact, a macro. ENV is the lexical environment to expand in, which defaults\n   to the null environment.").
doc_string('main-thread', 'sb-thread', function, "Returns the main thread of the process.").
doc_string('main-thread-p', 'sb-thread', function, "True if THREAD, defaulting to current thread, is the main thread of the process.").
doc_string('make-alien', 'sb-alien', function, "Allocate an alien of type TYPE in foreign heap, and return an alien\npointer to it. The allocated memory is not initialized, and may\ncontain garbage. The memory is allocated using malloc(3), so it can be\npassed to foreign functions which use free(3), or released using\nFREE-ALIEN.\n\nFor alien stack allocation, see macro WITH-ALIEN.\n\nThe TYPE argument is not evaluated. If SIZE is supplied, how it is\ninterpreted depends on TYPE:\n\n  * When TYPE is a foreign array type, an array of that type is\n    allocated, and a pointer to it is returned. Note that you\n    must use DEREF to first access the array through the pointer.\n\n    If supplied, SIZE is used as the first dimension for the array.\n\n  * When TYPE is any other foreign type, then an object for that\n    type is allocated, and a pointer to it is returned. So\n    (make-alien int) returns a (* int).\n\n    If SIZE is specified, then a block of that many objects is\n    allocated, with the result pointing to the first one.\n\nExamples:\n\n  (defvar *foo* (make-alien (array char 10)))\n  (type-of *foo*)                 ; => (alien (* (array (signed 8) 10)))\n  (setf (deref (deref foo) 0) 10) ; => 10\n\n  (make-alien char 12)            ; => (alien (* (signed 8)))").
doc_string('make-alien-string', 'sb-alien', function, "Copy part of STRING delimited by START and END into freshly\nallocated foreign memory, freeable using free(3) or FREE-ALIEN.\nReturns the allocated string as a (* CHAR) alien, and the number of\nbytes allocated as secondary value.\n\nThe string is encoded using EXTERNAL-FORMAT. If NULL-TERMINATE is\ntrue (the default), the alien string is terminated by an additional\nnull byte.").
doc_string('make-array', 'common-lisp', function, "Args: (dimensions &key (element-type t) initial-element (initial-contents nil)\n                    (adjustable nil) (fill-pointer nil) (displaced-to nil)\n                    (displaced-index-offset 0) (static nil))\nCreates an array of the specified DIMENSIONS.  DIMENSIONS is a list of\nnon-negative integers each representing the length of the corresponding\ndimension.  It may be an integer for vectors, i.e., one-dimensional arrays.\nELEMENT-TYPE specifies the type of array elements.  INITIAL-ELEMENT specifies\nthe initial value for all elements.  Its default value depends on ELEMENT-\nTYPE.  INITIAL-CONTENTS specifies each element in terms of sequences.\nADJUSTABLE specifies whether or not the array is adjustable (see ADJUST-\nARRAY).  FILL-POINTER is meaningful only for vectors.  It specifies whether\nthe vector has fill-pointer or not, and if it has, the initial value of the\nfill-pointer.  Possible values are NIL (no fill-pointer), T (the length of the\nvector), or an integer.  See VECTOR-PUSH and VECTOR-POP.  DISPLACED-TO, if\nnon-NIL, must be an array and specifies that the new array is displaced to the\ngiven array.  DISPLACED-INDEX-OFFSET is meaningful only when DISPLACED-TO is\nnon-NIL and specifies that the reference to the I-th element of the new array\nin raw-major indexing is actually the reference to the (I + DISPLACED-INDEX-\nOFFSET)th element of the given array.If the STATIC argument is supplied\nwith a non-nil value, then the body of the array is allocated as a\ncontiguous block.").
doc_string('make-bare-keymap', readline, function, "Make empty keymap.").
doc_string('make-broadcast-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST STREAMS)\n\nCreates and returns a broadcast stream.  Outputs to this stream are output to\nall STREAMs.  A broadcast stream is notated as\n        #<broadcast stream n>\nwhere N is a number that identify the stream.\n").
doc_string('make-case-frob-stream', 'sb-int', function, "Return a stream that sends all output to the stream TARGET, but modifies\n   the case of letters, depending on KIND, which should be one of:\n     :UPCASE - convert to upper case.\n     :DOWNCASE - convert to lower case.\n     :CAPITALIZE - convert the first letter of words to upper case and the\n        rest of the word to lower case.\n     :CAPITALIZE-FIRST - convert the first letter of the first word to upper\n        case and everything else to lower case.").
doc_string('make-concatenated-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST STREAMS)\n\nCreates and returns a concatenated stream.  Inputs from this stream are first\nobtained from the first STREAM.  When the end of the first STREAM is reached,\nthen inputs are obtained from the second STREAM.  And so forth.\nA concatenated stream is notated as\n        #<concatenated stream n>\nwhere N is a number that identifies the stream.\n").
doc_string('make-concatenated-stream', 'common-lisp', function, "Return a stream which takes its input from each of the streams in turn,\n   going on to the next at EOF.").
doc_string('make-condition', 'common-lisp', function, "Make an instance of a condition object using the specified initargs.").
doc_string('make-dispatch-macro-character', 'common-lisp', function, "Cause CHAR to become a dispatching macro character in readtable (which\n   defaults to the current readtable). If NON-TERMINATING-P, the char will\n   be non-terminating.").
doc_string('make-dispatch-macro-character', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &OPTIONAL (NON-TERMINATING-P NIL) (READTABLE *READTABLE*))\n\nRegister CHAR as a dispatch macro character in READTABLE.  NON-TERMINATING-P\nspecifies whether CHAR is non-terminating (see READTABLE).\n").
doc_string('make-echo-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM1 STREAM2)\n\nCreates and returns an echo stream.  Inputs from this stream are obtained from\nSTREAM1 and outputs to this stream are output to STREAM2.  In addition, all\ninputs from STREAM1 are output to STREAM2.\nAn echo stream is notated as\n        #<echo stream n>\nwhere N is a number that identifies the stream.\n").
doc_string('make-echo-stream', 'common-lisp', function, "Return a bidirectional stream which gets its input from INPUT-STREAM and\n   sends its output to OUTPUT-STREAM. In addition, all input is echoed to\n   the output stream.").
doc_string('make-hash-table', 'common-lisp', function, "Create and return a new hash table. The keywords are as follows:\n\n  :TEST\n    Determines how keys are compared. Must a designator for one of the\n    standard hash table tests, or a hash table test defined using\n    SB-EXT:DEFINE-HASH-TABLE-TEST. Additionally, when an explicit\n    HASH-FUNCTION is provided (see below), any two argument equivalence\n    predicate can be used as the TEST.\n\n  :SIZE\n    A hint as to how many elements will be put in this hash table.\n\n  :REHASH-SIZE\n    Indicates how to expand the table when it fills up. If an integer, add\n    space for that many elements. If a floating point number (which must be\n    greater than 1.0), multiply the size by that amount.\n\n  :REHASH-THRESHOLD\n    Indicates how dense the table can become before forcing a rehash. Can be\n    any positive number <=1, with density approaching zero as the threshold\n    approaches 0. Density 1 means an average of one entry per bucket.\n\n  :HASH-FUNCTION\n    If NIL (the default), a hash function based on the TEST argument is used,\n    which then must be one of the standardized hash table test functions, or\n    one for which a default hash function has been defined using\n    SB-EXT:DEFINE-HASH-TABLE-TEST. If HASH-FUNCTION is specified, the TEST\n    argument can be any two argument predicate consistent with it. The\n    HASH-FUNCTION is expected to return a non-negative fixnum hash code.\n\n  :WEAKNESS\n    When :WEAKNESS is not NIL, garbage collection may remove entries from the\n    hash table. The value of :WEAKNESS specifies how the presence of a key or\n    value in the hash table preserves their entries from garbage collection.\n\n    Valid values are:\n\n      :KEY means that the key of an entry must be live to guarantee that the\n        entry is preserved.\n\n      :VALUE means that the value of an entry must be live to guarantee that\n        the entry is preserved.\n\n      :KEY-AND-VALUE means that both the key and the value must be live to\n        guarantee that the entry is preserved.\n\n      :KEY-OR-VALUE means that either the key or the value must be live to\n        guarantee that the entry is preserved.\n\n      NIL (the default) means that entries are always preserved.\n\n  :SYNCHRONIZED\n    If NIL (the default), the hash-table may have multiple concurrent readers,\n    but results are undefined if a thread writes to the hash-table\n    concurrently with another reader or writer. If T, all concurrent accesses\n    are safe, but note that CLHS 3.6 (Traversal Rules and Side Effects)\n    remains in force. See also: SB-EXT:WITH-LOCKED-HASH-TABLE. This keyword\n    argument is experimental, and may change incompatibly or be removed in the\n    future.").
doc_string('make-hash-table', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&KEY (TEST 'EQL) (SIZE 1024) (REHASH-SIZE 1.5) (REHASH-THRESHOLD 0.7))\n\nCreates and returns a hash-table.\nTEST specifies which predicate should be used to access hash-table entries.\nIt must be EQ, EQL, or EQUAL.  SIZE specifies the number of entries in the\nhash-table.  REHASH-SIZE, if an integer, specifies how many entries should be\nadded when the hash-table becomes 'almost full'.  REHASH-SIZE, if a float,\nspecifies the ratio of the new size and the old size.  REHASH-THRESHOLD\nspecifies when to expand the hash-table.  If an integer, the hash-table is\nexpanded when REHASH-THRESHOLD / REHASH-SIZE entries have been used.  If a\nfloat, the hash-table is expanded when REHASH-THRESHOLD times the whole\nentries have been used.\n").
doc_string('make-integer', 'sb-impl', function, "Minimizes bignum-fixnum multiplies by reading a 'safe' number of digits,\n  then multiplying by a power of the base and adding.").
doc_string('make-keymap', readline, function, "Make simple keymap - chars bound to self-insert etc.").
doc_string('make-list', 'common-lisp', function, "Constructs a list with size elements each set to value").
doc_string('make-list', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LENGTH &KEY (INITIAL-ELEMENT NIL))\n\nCreates and returns a list of the specified LENGTH, whose elements are all the\nvalue of INITIAL-ELEMENT.\n").
doc_string('make-mutex', 'sb-thread', function, "Create a mutex.").
doc_string('make-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE-NAME &KEY (NICKNAMES NIL) (USE '(LISP)))\n\nCreates and returns a new package named PACKAGE-NAME.  PACKAGE-NAME must be a\nstring or a symbol.  The print name is used if PACKAGE-NAME is a symbol.\nNICKNAMES gives the nicknames of the package.  It must be a list of strings\nand symbols.  USE specifies the packages used by the created package.  It must\nbe a list of package objects, strings, and symbols.\n").
doc_string('make-package', 'common-lisp', function, "Make a new package having the specified NAME, NICKNAMES, and USE\nlist. :INTERNAL-SYMBOLS and :EXTERNAL-SYMBOLS are estimates for the number of\ninternal and external symbols which will ultimately be present in the package.\nThe default value of USE is implementation-dependent, and in this\nimplementation it is NIL.").
doc_string('make-pathname', 'common-lisp', function, "Constructs and returns a pathname from the supplied keyword arguments.").
doc_string('make-pathname', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&KEY (DEFAULTS (PARSE-NAMESTRING \"\" (PATHNAME-HOST *DEFAULT-PATHNAME-DEFAULTS*))) (HOST (PATHNAME-HOST DEFAULTS)) (DEVICE (PATHNAME-DEVICE DEFAULTS)) (DIRECTORY (PATHNAME-DIRECTORY DEFAULTS)) (NAME (PATHNAME-NAME DEFAULTS)) (TYPE (PATHNAME-TYPE DEFAULTS)) (VERSION (PATHNAME-VERSION DEFAULTS)))\n\nCreates a pathname object with the slot values specified by HOST, DEVICE,\nDIRECTORY, NAME, TYPE, and VERSION.\n").
doc_string('make-pathname', 'common-lisp', function, "Makes a new pathname from the component arguments. Note that host is\na host-structure or string.").
doc_string('make-pipe', extensions, function, "Function in EXT package:\nArgs: NIL\nCreates a pipe in the form of a two-way stream that can be used for\ninterprocess and interthread communication.\n").
doc_string('make-random-state', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (RANDOM-STATE NIL))\n\nCreates and returns a random-state object.  If RANDOM-STATE is NIL, copies the\nvalue of *RANDOM-STATE*.  If RANDOM-STATE is a random-state, copies it.  If\nRANDOM-STATE is T, creates a random-state randomly.\n").
doc_string('make-random-state', 'common-lisp', function, "Make a random state object. The optional STATE argument specifies a seed\nfor deterministic pseudo-random number generation.\n\nAs per the Common Lisp standard,\n- If STATE is NIL or not supplied, return a copy of the default\n  *RANDOM-STATE*.\n- If STATE is a random state, return a copy of it.\n- If STATE is T, return a randomly initialized state (using operating-system\n  provided randomness where available, otherwise a poor substitute based on\n  internal time and PID).\n\nSee SB-EXT:SEED-RANDOM-STATE for a SBCL extension to this functionality.").
doc_string('make-semaphore', 'sb-thread', function, "Create a semaphore with the supplied COUNT and NAME.").
doc_string('make-semaphore-notification', 'sb-thread', function, "Constructor for SEMAPHORE-NOTIFICATION objects. SEMAPHORE-NOTIFICATION-STATUS\nis initially NIL.").
doc_string('make-sequence', 'common-lisp', function, "Args: (type length &key initial-element)\nCreates and returns a sequence of the given TYPE and LENGTH.  If INITIAL-\nELEMENT is given, then it becomes the elements of the created sequence.  The\ndefault value of INITIAL-ELEMENT depends on TYPE.").
doc_string('make-sequence', 'common-lisp', function, "Return a sequence of the given TYPE and LENGTH, with elements initialized\n  to INITIAL-ELEMENT.").
doc_string('make-sequence-iterator', 'sb-sequence', function, "Returns a sequence iterator for SEQUENCE or, if START and/or END\n   are supplied, the subsequence bounded by START and END as nine\n   values:\n\n   1. iterator state\n   2. limit\n   3. from-end\n   4. step function\n   5. endp function\n   6. element function\n   7. setf element function\n   8. index function\n   9. copy state function\n\n   If FROM-END is NIL, the constructed iterator visits the specified\n   elements in the order in which they appear in SEQUENCE. Otherwise,\n   the elements are visited in the opposite order.").
doc_string('make-sequence-like', 'sb-sequence', function, "Returns a freshly allocated sequence of length LENGTH and of the\n   same class as SEQUENCE. Elements of the new sequence are\n   initialized to INITIAL-ELEMENT, if supplied, initialized to\n   INITIAL-CONTENTS if supplied, or identical to the elements of\n   SEQUENCE if neither is supplied. Signals a PROTOCOL-UNIMPLEMENTED\n   error if the sequence protocol is not implemented for the class of\n   SEQUENCE.").
doc_string('make-sequence-like', system, function, "Return a sequence of the same type as SEQUENCE and the given LENGTH.").
doc_string('make-simple-sequence-iterator', 'sb-sequence', function, "Returns a sequence iterator for SEQUENCE, START, END and FROM-END\n   as three values:\n\n   1. iterator state\n   2. limit\n   3. from-end\n\n   The returned iterator can be used with the generic iterator\n   functions ITERATOR-STEP, ITERATOR-ENDP, ITERATOR-ELEMENT, (SETF\n   ITERATOR-ELEMENT), ITERATOR-INDEX and ITERATOR-COPY.").
doc_string('make-spinlock', 'sb-thread', function, "The function SB-THREAD::MAKE-SPINLOCK has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:MAKE-MUTEX instead.").
doc_string('make-static-vector', 'sb-int', function, "Allocate vector of LENGTH elements in static space. Only allocation\nof specialized arrays is supported.").
doc_string('make-string', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LENGTH &KEY (INITIAL-ELEMENT  ))\n\nCreates and returns a new string of the given LENGTH, whose elements are all\nINITIAL-ELEMENT.\n").
doc_string('make-string', 'common-lisp', function, "Given a character count and an optional fill character, makes and returns a\nnew string COUNT long filled with the fill character.").
doc_string('make-string-input-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &OPTIONAL (START 0) (END (LENGTH STRING)))\n\nCreates and returns a string-input stream.  Inputs from this stream are\nobtained form STRING.  A string-input stream is notated as\n        #<string-input stream from s>\nwhere S is a string.\n").
doc_string('make-string-input-stream', 'common-lisp', function, "Return an input stream which will supply the characters of STRING between\n  START and END in order.").
doc_string('make-string-output-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: NIL\n\nCreates and returns a string-output stream.  Outputs to this stream are\nobtained as a string by GET-OUTPUT-STREAM-STRING.  A string-output stream\nis notated as\n        #<string-output stream n>\nwhere N is a number that identifies the stream.\n").
doc_string('make-string-output-stream', 'common-lisp', function, "Return an output stream which will accumulate all output given it for the\nbenefit of the function GET-OUTPUT-STREAM-STRING.").
doc_string('make-string-output-stream-from-string', si, function, "Function in SI package:\nArgs: (STRING)\n\nECL specific.\nCreates and returns a string-output-stream to STRING.  STRING must have a\nfill-pointer.\n").
doc_string('make-symbol', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING)\n\nCreates and returns a new uninterned symbol whose print name is STRING.\n").
doc_string('make-symbol', 'common-lisp', function, "Make and return a new symbol with the STRING as its print name.").
doc_string('make-synonym-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nCreates and returns a synonym stream to SYMBOL.  Inputs from this stream are\nobtained from, and outputs to this stream are sent to the stream that is the\nvalue of the global variable named SYMBOL.  A synonym stream is notated as\n        #<synonym stream to s>\nwhere S is a symbol.\n").
doc_string('make-temp-directory', extensions, function, "Create and return the pathname of a previously non-existent directory.").
doc_string('make-temp-file', extensions, function, "Create and return the pathname of a previously non-existent file.").
doc_string('make-thread', 'sb-thread', function, "Create a new thread of NAME that runs FUNCTION with the argument\nlist designator provided (defaults to no argument). Thread exits when\nthe function returns. The return values of FUNCTION are kept around\nand can be retrieved by JOIN-THREAD.\n\nInvoking the initial ABORT restart established by MAKE-THREAD\nterminates the thread.\n\nSee also: RETURN-FROM-THREAD, ABORT-THREAD.").
doc_string('make-timer', pkg_sys, function, "Create a timer that runs FUNCTION when triggered.\n\nIf a THREAD is supplied, FUNCTION is run in that thread. If THREAD is\nT, a new thread is created for FUNCTION each time the timer is\ntriggered. If THREAD is NIL, FUNCTION is run in an unspecified thread.\n\nWhen THREAD is not T, INTERRUPT-THREAD is used to run FUNCTION and the\nordering guarantees of INTERRUPT-THREAD apply. In that case, FUNCTION\nruns with interrupts disabled but WITH-INTERRUPTS is allowed.").
doc_string('make-two-way-stream', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM1 STREAM2)\n\nCreates and returns a two-way stream.  Inputs from this stream are obtained\nfrom STREAM1 and outputs to this stream are sent to STREAM2.  A two-way stream\nis notated as\n        #<two-way stream n>\nwhere N is a number that identifies the stream.\n").
doc_string('make-two-way-stream', 'common-lisp', function, "Return a bidirectional stream which gets its input from INPUT-STREAM and\n   sends its output to OUTPUT-STREAM.").
doc_string('make-waitqueue', 'sb-thread', function, "Create a waitqueue.").
doc_string('make-weak-pointer', pkg_sys, function, "Allocate and return a weak pointer which points to OBJECT.").
doc_string('map-backtrace', 'sb-debug', function, "Calls the designated FUNCTION with each frame on the call stack.\nReturns the last value returned by FUNCTION.\n\nCOUNT is the number of frames to backtrace, defaulting to\n*BACKTRACE-FRAME-COUNT*.\n\nSTART is the number of the frame the backtrace should start from.\n\nFROM specifies the frame relative to which the frames are numbered. Possible\nvalues are an explicit SB-DI:FRAME object, and the\nkeywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default\nis :DEBUGGER-FRAME.\n\n  :CURRENT-FRAME\n    specifies the caller of MAP-BACKTRACE.\n\n  :INTERRUPTED-FRAME\n    specifies the first interrupted frame on the stack (typically the frame\n    where the error occurred, as opposed to error handling frames) if any,\n    otherwise behaving as :CURRENT-FRAME.\n\n  :DEBUGGER-FRAME\n    specifies the currently debugged frame when inside the debugger, and\n    behaves as :INTERRUPTED-FRAME outside the debugger.\n").
doc_string('map-directory', pkg_sys, function, "Map over entries in DIRECTORY. Keyword arguments specify which entries to\nmap over, and how:\n\n :FILES\n    If true, call FUNCTION with the pathname of each file in DIRECTORY.\n    Defaults to T.\n\n :DIRECTORIES\n   If true, call FUNCTION with a pathname for each subdirectory of DIRECTORY.\n   If :AS-FILES, the pathname used is a pathname designating the subdirectory\n   as a file in DIRECTORY. Otherwise the pathname used is a directory\n   pathname. Defaults to T.\n\n :CLASSIFY-SYMLINKS\n   If true, the decision to call FUNCTION with the pathname of a symbolic link\n   depends on the resolution of the link: if it points to a directory, it is\n   considered a directory entry, otherwise a file entry. If false, all\n   symbolic links are considered file entries. In both cases the pathname used\n   for the symbolic link is not fully resolved, but names it as an immediate\n   child of DIRECTORY. Defaults to T.\n\n :ERRORP\n   If true, signal an error if DIRECTORY does not exist, cannot be read, etc.\n   Defaults to T.\n\nExperimental: interface subject to change.").
doc_string('map-into', 'common-lisp', function, "Fills the output sequence with the values returned by applying FUNCTION to the\nelements of the given sequences. The i-th element of RESULT-SEQUENCE is the output\nof applying FUNCTION to the i-th element of each of the sequences. The map routine\nstops when it reaches the end of one of the given sequences.").
doc_string('mask-field', 'common-lisp', function, "Args: (bytespec integer)\nExtracts the specified byte from INTEGER and returns the result as an integer.").
doc_string('mask-field', 'common-lisp', function, "Extract the specified byte from integer,  but do not right justify result.").
doc_string('mask-signed-field', 'sb-c', function, "Extract SIZE lower bits from INTEGER, considering them as a\n2-complement SIZE-bits representation of a signed integer.").
doc_string('math-p', 'sb-unicode', function, "Returns T if CHARACTER is a mathematical symbol according to Unicode and\nNIL otherwise").
doc_string('member-if', 'common-lisp', function, "Return tail of LIST beginning with first element satisfying TEST.").
doc_string('member-if', 'common-lisp', function, "Searches LIST for an element that satisfies TEST.  If found, returns the\nsublist of LIST that begins with the element.  If not found, returns NIL.").
doc_string('member-if-not', 'common-lisp', function, "Return tail of LIST beginning with first element not satisfying TEST.").
doc_string('member-if-not', 'common-lisp', function, "Searches LIST for an element that does not satisfy TEST.  If found, returns\nthe sublist of LIST that begins with the element.  If not found, returns NIL.").
doc_string('merge-pathnames', 'common-lisp', function, "Construct a filled in pathname by completing the unspecified components\n   from the defaults.").
doc_string('merge-pathnames', 'common-lisp', function, "Constructs a pathname from PATHNAME by filling in any unsupplied components\r\nwith the corresponding values from DEFAULT-PATHNAME and DEFAULT-VERSION.").
doc_string('merge-pathnames', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC &OPTIONAL (DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) DEFAULT-VERSION)\n\nFills in unspecified slots of the pathname specified by FILESPEC from the\npathname specified by DEFAULTS, and returns the result pathname.  DEFAULT-\nVERSION is simply ignored in WAM-CL.  FILESPEC and DEFAULTS may be a symbol, a\nstring, a pathname, or a file stream.\n").
doc_string('mirrored-p', 'sb-unicode', function, "Returns T if CHARACTER needs to be mirrored in bidirectional text.\nOtherwise, returns NIL.").
doc_string('module-provide-contrib', 'sb-impl', function, "Stringify and downcase NAME, then attempt to load the file\n   $SBCL_HOME/name/name").
doc_string('most-negative-double-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as MOST-NEGATIVE-LONG-FLOAT.\n").
doc_string('most-negative-fixnum', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe negative fixnum with the largest absolute value.  - 2^29 in WAM-CL.\n").
doc_string('most-negative-fixnum', 'common-lisp', variable, "the fixnum closest in value to negative infinity").
doc_string('most-negative-long-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe long-float with the largest absolute value.\n").
doc_string('most-negative-short-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe short-float with the largest absolute value.\n").
doc_string('most-negative-single-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as MOST-NEGATIVE-LONG-FLOAT.\n").
doc_string('most-positive-double-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as MOST-POSITIVE-LONG-FLOAT.\n").
doc_string('most-positive-fixnum', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe largest positive fixnum.  2^29 - 1 in WAM-CL.\n").
doc_string('most-positive-fixnum', 'common-lisp', variable, "the fixnum closest in value to positive infinity").
doc_string('most-positive-long-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe largest positive long-float.\n").
doc_string('most-positive-short-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe largest positive short-float.\n").
doc_string('most-positive-single-float', 'common-lisp', variable, "Constant in COMMON-LISP package:\nSame as MOST-POSITIVE-LONG-FLOAT.\n").
doc_string('most-positive-word', pkg_sys, variable, "The most positive integer that is of type SB-EXT:WORD.").
doc_string('muffle-cerrors', sys, function, "\r\n(MUFFLE-CERRORS {form}*) executes the forms, but when a continuable\r\nerror occurs, the CONTINUE restart is silently invoked.").
doc_string('muffle-warning', 'common-lisp', function, "Transfer control to a restart named MUFFLE-WARNING, signalling a\n   CONTROL-ERROR if none exists.").
doc_string('multiple-value-bind', 'common-lisp', function, "Syntax: (multiple-value-bind ({var}*) init {decl}* {form}*)\n\nEvaluates INIT and binds the N-th VAR to the N-th value of INIT or, if INIT\nreturns less than N values, to NIL.  Then evaluates FORMs, and returns all\nvalues of the last FORM.  If no FORM is given, returns NIL.").
doc_string('multiple-value-call', 'common-lisp', function, "MULTIPLE-VALUE-CALL function values-form*\n\nCall FUNCTION, passing all the values of each VALUES-FORM as arguments,\nvalues from the first VALUES-FORM making up the first argument, etc.").
doc_string('multiple-value-call', 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (FUNCTION-FORM &REST FORMS)\n\nEvaluates FUNCTION-FORM, whose value must be a function.  Then evaluates FORMs\nand applies the function to all values of FORMs.  Unlike FUNCALL, all values\nof each FORM are used as arguments.  Returns all values of the function.\n").
doc_string('multiple-value-list', 'common-lisp', function, "Evaluates FORM and returns a list of all values FORM returns.").
doc_string('multiple-value-prog1', 'common-lisp', function, "MULTIPLE-VALUE-PROG1 values-form form*\n\nEvaluate VALUES-FORM and then the FORMS, but return all the values of\nVALUES-FORM.").
doc_string('multiple-value-prog1', 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (FIRST-FORM &REST FORMS)\n\nEvaluates FIRST-FORM, saves all values it returns, and then evaluates FORMs.\nReturns all the saved values of FIRST-FORM.\n").
doc_string('multiple-value-setq', 'common-lisp', function, "Syntax: (multiple-value-setq {var}* form)\n\nEvaluates FORM and binds the N-th VAR to the N-th value of FORM or, if FORM\nreturns less than N values, to NIL.  Returns the first value of FORM or, if\nFORM returns no value, NIL.").
doc_string('multiple-values-limit', 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe upper bound on the number of values that a function can return.  Actually,\nhowever, there is no such upper bound in WAM-CL.\n").
doc_string('multiple-values-limit', 'common-lisp', variable, "The exclusive upper bound on the number of multiple VALUES that you can\n  return.").
doc_string('mutex-name', 'sb-thread', function, "The name of the mutex. Setfable.").
doc_string('mutex-owner', 'sb-thread', function, "Current owner of the mutex, NIL if the mutex is free. Naturally,\nthis is racy by design (another thread may acquire the mutex after\nthis function returns), it is intended for informative purposes. For\ntesting whether the current thread is holding a mutex see\nHOLDING-MUTEX-P.").
doc_string('mutex-value', 'sb-thread', function, "Current owner of the mutex, NIL if the mutex is free. May return a\nstale value, use MUTEX-OWNER instead.").
doc_string('name-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NAME)\n\nGiven an argument acceptable to string,\nReturns a character object with the specified character name (see CHARACTER).\nReturns NIL if no such character object exists.  NAME is typically a string\nbut may be any object that can be coerced to string.\n").
doc_string('name-char', 'common-lisp', function, "Given an argument acceptable to STRING, NAME-CHAR returns a character whose\nname is that string, if one exists. Otherwise, NIL is returned.").
doc_string('name-conflict-datum', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('name-conflict-function', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('name-conflict-symbols', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('namestring-parse-error-args', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('namestring-parse-error-complaint', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('namestring-parse-error-namestring', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('namestring-parse-error-offset', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('native-namestring', pkg_sys, function, "Construct the full native (name)string form of PATHNAME.  For\nfile systems whose native conventions allow directories to be\nindicated as files, if AS-FILE is true and the name, type, and\nversion components of PATHNAME are all NIL or :UNSPECIFIC,\nconstruct a string that names the directory according to the file\nsystem's syntax for files.").
doc_string('native-pathname', pkg_sys, function, "Convert PATHSPEC (a pathname designator) into a pathname, assuming\nthe operating system native pathname conventions.").
doc_string('need-to-make-load-form-p', clos, function, "Return T if the object cannot be externalized using the lisp\nprinter and we should rather use MAKE-LOAD-FORM.").
doc_string('new-value-specialization-method', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('no-debug-blocks-debug-fun', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('no-debug-fun-returns-debug-fun', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('no-debug-vars-debug-fun', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('no-primary-method-args', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('no-primary-method-generic-function', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('normalize-string', 'sb-unicode', function, "Normalize STRING to the Unicode normalization form form.\nAcceptable values for form are :NFD, :NFC, :NFKD, and :NFKC.\nIf FILTER is a function it is called on each decomposed character and\nonly characters for which it returns T are collected.").
doc_string('normalized-p', 'sb-unicode', function, "Tests if STRING is normalized to FORM").
doc_string('note-next-instruction', 'sb-c', function, "NOTE-NEXT-INSTRUCTION VOP Kind\n   Similar to NOTE-THIS-LOCATION, except the use the location of the next\n   instruction for the code location, wherever the scheduler decided to put\n   it.").
doc_string('note-this-location', 'sb-c', function, "NOTE-THIS-LOCATION VOP Kind\n  Note that the current code location is an interesting (to the debugger)\n  location of the specified Kind. VOP is the VOP responsible for this code.\n  This VOP must specify some non-null :SAVE-P value (perhaps :COMPUTE-ONLY) so\n  that the live set is computed.").
doc_string('nset-difference', 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nDestructive SET-DIFFERENCE.  Only LIST1 may be destroyed.").
doc_string('nset-difference', 'common-lisp', function, "Destructively return the elements of LIST1 which are not in LIST2.").
doc_string('nset-exclusive-or', 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nDestructive SET-EXCLUSIVE-OR.  Both LIST1 and LIST2 may be destroyed.").
doc_string('nset-exclusive-or', 'common-lisp', function, "Destructively return a list with elements which appear but once in LIST1\n   and LIST2.").
doc_string('nstring-capitalize', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)))\n\nDestructive STRING-CAPITALIZE.  STRING may be destroyed.\n").
doc_string('nstring-downcase', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)))\n\nDestructive STRING-DOWNCASE.  STRING may be destroyed.\n").
doc_string('nstring-upcase', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)))\n\nDestructive STRING-UPCASE.  STRING may be destroyed.\n").
doc_string('nsubst-if', 'common-lisp', function, "Destructive SUBST-IF. TREE may be modified.").
doc_string('nsubst-if', 'common-lisp', function, "Substitute NEW for subtrees of TREE for which TEST is true.").
doc_string('nsubst-if-not', 'common-lisp', function, "Destructive SUBST-IF-NOT. TREE may be modified.").
doc_string('nsubst-if-not', 'common-lisp', function, "Substitute NEW for subtrees of TREE for which TEST is false.").
doc_string('nsubstitute-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nDestructive SUBSTITUTE-IF.  SEQUENCE may be destroyed.\n").
doc_string('nsubstitute-if', 'common-lisp', function, "Return a sequence of the same kind as SEQUENCE with the same elements\n   except that all elements satisfying PREDICATE are replaced with NEW.\n   SEQUENCE may be destructively modified.").
doc_string('nsubstitute-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nDestructive SUBSTITUTE-IF-NOT.  SEQUENCE may be destroyed.\n").
doc_string('nsubstitute-if-not', 'common-lisp', function, "Return a sequence of the same kind as SEQUENCE with the same elements\n   except that all elements not satisfying PREDICATE are replaced with NEW.\n   SEQUENCE may be destructively modified.").
doc_string('nth-value', 'common-lisp', function, "Evaluate FORM and return the Nth value (zero based)\n without consing a temporary list of values.").
doc_string('nth-vop', 'sb-c', function, "Return the Nth VOP in the IR2-BLOCK pointed to by THING.").
doc_string('null-alien', 'sb-alien', function, "Return true if X (which must be an ALIEN pointer) is null, false otherwise.").
doc_string('null-pointer-p', si, function, "Function in SI package:\nArgs: (PTR)\n\nReturn true if PTR is a null pointer.\n").
doc_string('numeric-value', 'sb-unicode', function, "Returns the numeric value of CHARACTER or NIL if there is no such value.\nNumeric value is the most general of the Unicode numeric properties.\nThe only constraint on the numeric value is that it be a rational number.").
doc_string('object-notify', threads, function, "Wakes up a single thread that is waiting on OBJECT's monitor.\r\nIf any threads are waiting on this object, one of them is chosen to be awakened. The choice is arbitrary and occurs at the discretion of the implementation. A thread waits on an object's monitor by calling one of the wait methods.").
doc_string('object-notify-all', threads, function, "Wakes up all threads that are waiting on this OBJECT's monitor.\r\nA thread waits on an object's monitor by calling one of the wait methods.").
doc_string('object-wait', threads, function, "Causes the current thread to block until object-notify or object-notify-all is called on OBJECT.\r\nOptionally unblock execution after TIMEOUT seconds.  A TIMEOUT of zero\r\nmeans to wait indefinitely.\r\nA non-zero TIMEOUT of less than a nanosecond is interpolated as a nanosecond wait.\r\nSee the documentation of java.lang.Object.wait() for further\r\ninformation.\r\n").
doc_string('obsolete-structure-datum', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octet-decoding-bad-byte-position', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octet-decoding-error-array', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octet-decoding-error-end', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octet-decoding-error-external-format', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octet-decoding-error-start', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octets-encoding-error-external-format', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octets-encoding-error-position', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('octets-encoding-error-string', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('open-stream-p', 'common-lisp', function, "Return true if STREAM is not closed. A default method is provided\n  by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been\n  called on the stream.").
doc_string('open-stream-p', gray, function, "Return true if STREAM is not closed. A default method is provided\n  by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been\n  called on the stream.").
doc_string('ordinal-ones', si, variable, "Table of ordinal ones-place digits in English").
doc_string('ordinal-tens', si, variable, "Table of ordinal tens-place digits in English").
doc_string('os-exit', 'sb-sys', function, "Exit the process with CODE. If ABORT is true, exit is performed using _exit(2),\navoiding atexit(3) hooks, etc. Otherwise exit(2) is called.").
doc_string('os-genera-p', extensions, function, "Is the underlying operating system Genera (running on a Symbolics Lisp Machine)?").
doc_string('os-haiku-p', extensions, function, "Is the underlying operating system Haiku?").
doc_string('os-macosx-p', extensions, function, "Is the underlying operating system MacOS X?").
doc_string('os-oldmac-p', extensions, function, "Is the underlying operating system an (emulated?) MacOS 9 or earlier?").
doc_string('os-unix-p', extensions, function, "Is the underlying operating system some Unix variant?").
doc_string('os-windows-p', extensions, function, "Is the underlying operating system Microsoft Windows?").
doc_string('output-raw-bytes', 'sb-sys', function, "The function SB-SYS:OUTPUT-RAW-BYTES has been deprecated as of SBCL version 1.0.8.16.\n\nUse COMMON-LISP:WRITE-SEQUENCE instead.").
doc_string('output-stream-p', 'common-lisp', function, "Can STREAM perform output operations?").
doc_string('output-stream-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM)\n\nReturns T if STREAM can handle output operations; NIL otherwise.\n").
doc_string('output-stream-p', gray, function, "Can STREAM perform output operations?").
doc_string('package-error-package', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('package-implemented-by-list', pkg_sys, function, "Returns a list containing the implementation packages of\nPACKAGE. Signals an error if PACKAGE is not a valid package designator.").
doc_string('package-implements-list', pkg_sys, function, "Returns the packages that PACKAGE is an implementation package\nof. Signals an error if PACKAGE is not a valid package designator.").
doc_string('package-local-nicknames', pkg_sys, function, "Returns an alist of (local-nickname . actual-package) describing the\nnicknames local to the designated package.\n\nWhen in the designated package, calls to FIND-PACKAGE with the any of the\nlocal-nicknames will return the corresponding actual-package instead. This\nalso affects all implied calls to FIND-PACKAGE, including those performed by\nthe reader.\n\nWhen printing a package prefix for a symbol with a package local nickname, the\nlocal nickname is used instead of the real name in order to preserve\nprint-read consistency.\n\nSee also: ADD-PACKAGE-LOCAL-NICKNAME, PACKAGE-LOCALLY-NICKNAMED-BY-LIST,\nREMOVE-PACKAGE-LOCAL-NICKNAME, and the DEFPACKAGE option :LOCAL-NICKNAMES.\n\nExperimental: interface subject to change.").
doc_string('package-locally-nicknamed-by-list', pkg_sys, function, "Returns a list of packages which have a local nickname for the designated\npackage.\n\nSee also: ADD-PACKAGE-LOCAL-NICKNAME, PACKAGE-LOCAL-NICKNAMES,\nREMOVE-PACKAGE-LOCAL-NICKNAME, and the DEFPACKAGE option :LOCAL-NICKNAMES.\n\nExperimental: interface subject to change.").
doc_string('package-lock-violation-in-package', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('package-locked-error-symbol', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('package-locked-p', pkg_sys, function, "Returns T when PACKAGE is locked, NIL otherwise. Signals an error\nif PACKAGE doesn't designate a valid package.").
doc_string('package-name', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE)\n\nReturns the name of PACKAGE as a string.\n").
doc_string('package-nicknames', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE)\n\nReturns the nicknames of PACKAGE as a list of strings.\n").
doc_string('package-shadowing-symbols', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE)\n\nReturns, as a list, those symbols in PACKAGE that are shadowing symbols in\nother packages.\n").
doc_string('package-use-list', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE)\n\nReturns, as a list, those packages that PACKAGE uses.\n").
doc_string('package-used-by-list', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE)\n\nReturns, as a list, those packages that use PACKAGE.\n").
doc_string('parse-deprecated-type-specifier', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('parse-integer', 'common-lisp', function, "Examine the substring of string delimited by start and end\n  (default to the beginning and end of the string)  It skips over\n  whitespace characters and then tries to parse an integer. The\n  radix parameter must be between 2 and 36.").
doc_string('parse-integer', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)) (RADIX 10) (JUNK-ALLOWED NIL))\n\nParses STRING for an integer and returns it.  As the second value, returns the\nindex to the character next to the last character that is parsed.  If JUNK-\nALLOWED is non-NIL, ignores white spaces before and after the number\nrepresentation in STRING and returns NIL even if STRING is not parsed\nsuccessfully.\n").
doc_string('parse-namestring', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &OPTIONAL HOST DEFAULTS &KEY (START 0) END (JUNK-ALLOWED NIL))\n\nParses STRING and returns a pathname.  As the second value, returns the index\nto the character next to the last character that has been parsed.  STRING is\nusually a string object but it may be a symbol, a pathname, or a file stream.\nSTART and END are meaningful only when STRING is a string or a symbol.  They\ndefault to 0 and (length (string FILESPEC)) respectively.  When the parsing is\nfailed, signals an error (if JUNK-ALLOWED is NIL) or simply returns NIL.  HOST\nand DEFAULTS are simply ignored in WAM-CL.\n").
doc_string('parse-native-namestring', pkg_sys, function, "Convert THING into a pathname, using the native conventions\nappropriate for the pathname host HOST, or if not specified the\nhost of DEFAULTS.  If THING is a string, the parse is bounded by\nSTART and END, and error behaviour is controlled by JUNK-ALLOWED,\nas with PARSE-NAMESTRING.  For file systems whose native\nconventions allow directories to be indicated as files, if\nAS-DIRECTORY is true, return a pathname denoting THING as a\ndirectory.").
doc_string('parse-unknown-type-specifier', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('pathname-device', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the device slot of the pathname specified by FILESPEC.  FILESPEC may\nbe a symbol, a string, a pathname, or a file stream.\n").
doc_string('pathname-device', 'common-lisp', function, "Return PATHNAME's device.").
doc_string('pathname-directory', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the directory slot of the pathname specified by FILESPEC.  FILESPEC\nmay be a symbol, a string, a pathname, or a file stream.\n").
doc_string('pathname-directory', 'common-lisp', function, "Return PATHNAME's directory.").
doc_string('pathname-host', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the host slot of the pathname specified by FILESPEC.  FILESPEC may be\na symbol, a string, a pathname, or a file stream.\n").
doc_string('pathname-host', 'common-lisp', function, "Return PATHNAME's host.").
doc_string('pathname-match-p', 'common-lisp', function, "Pathname matches the wildname template?").
doc_string('pathname-name', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the name slot of the pathname specified by FILESPEC.  FILESPEC may be\na symbol, a string, a pathname, or a file stream.\n").
doc_string('pathname-name', 'common-lisp', function, "Return PATHNAME's name.").
doc_string('pathname-type', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the type slot of the pathname specified by FILESPEC.  FILESPEC may be\na symbol, a string, a pathname, or a file stream.\n").
doc_string('pathname-type', 'common-lisp', function, "Return PATHNAME's type.").
doc_string('pathname-url-p', extensions, function, "Predicate for whether PATHNAME references a URL.").
doc_string('pathname-version', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the version slot of the pathname specified by FILESPEC.  FILESPEC may\nbe a symbol, a string, a pathname, or a file stream.\n").
doc_string('pathname-version', 'common-lisp', function, "Return PATHNAME's version.").
doc_string('pathname-version', 'common-lisp', function, "Return the version component of PATHNAME.").
doc_string('pcl-close', 'sb-gray', function, "Close the given STREAM. No more I/O may be performed, but\n  inquiries may still be made. If :ABORT is true, an attempt is made\n  to clean up the side effects of having created the stream.").
doc_string('pcl-open-stream-p', 'sb-gray', function, "Return true if STREAM is not closed. A default method is provided\n  by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been\n  called on the stream.").
doc_string('peek-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (CHAR-SPEC NIL) (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))\n\nReads characters from STREAM until the specified character is read.  Returns\nthe last character but leaves it in STREAM.  CHAR-SPEC may be a character\nobject, T (specifies non-whitespace characters), or NIL (specifies all\ncharacters).\n").
doc_string('physical-memory', posix, function, "Return 2 values: TOTAL and AVAILABLE physical memory.").
doc_string('position-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the index to the first element in SEQUENCE that satisfies TEST.\nReturns NIL if no such element exists.\n").
doc_string('position-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the index to the first element in SEQUENCE that does not satisfy TEST.\nReturns NIL if no such element exists.\n").
doc_string('posix-environ', pkg_sys, function, "Return the Unix environment (\"man environ\") as a list of SIMPLE-STRINGs.").
doc_string('posix-getenv', pkg_sys, function, "Return the \"value\" part of the environment string \"name=value\" which\ncorresponds to NAME, or NIL if there is none.").
doc_string('pprint-exit-if-list-exhausted', 'common-lisp', function, "Cause the closest enclosing use of PPRINT-LOGICAL-BLOCK to return\n   if it's list argument is exhausted.  Can only be used inside\n   PPRINT-LOGICAL-BLOCK, and only when the LIST argument to\n   PPRINT-LOGICAL-BLOCK is supplied.").
doc_string('pprint-exit-if-list-exhausted', 'common-lisp', function, "Cause the closest enclosing use of PPRINT-LOGICAL-BLOCK to return\n   if its list argument is exhausted. Can only be used inside\n   PPRINT-LOGICAL-BLOCK, and only when the LIST argument to\n   PPRINT-LOGICAL-BLOCK is supplied.").
doc_string('pprint-fill', 'common-lisp', function, "Output LIST to STREAM putting :FILL conditional newlines between each\n   element.  If COLON? is NIL (defaults to T), then no parens are printed\n   around the output.  ATSIGN? is ignored (but allowed so that PPRINT-FILL\n   can be used with the ~/.../ format directive.").
doc_string('pprint-fill', 'common-lisp', function, "Output LIST to STREAM putting :FILL conditional newlines between each\n   element. If COLON? is NIL (defaults to T), then no parens are printed\n   around the output. ATSIGN? is ignored (but allowed so that PPRINT-FILL\n   can be used with the ~/.../ format directive.").
doc_string('pprint-indent', 'common-lisp', function, "Specify the indentation to use in the current logical block if STREAM\n   (which defaults to *STANDARD-OUTPUT*) is it is a pretty-printing stream\n   and do nothing if not.  (See PPRINT-LOGICAL-BLOCK.)  N is the indention\n   to use (in ems, the width of an ``m'') and RELATIVE-TO can be either:\n     :BLOCK - Indent relative to the column the current logical block\n        started on.\n     :CURRENT - Indent relative to the current column.\n   The new indention value does not take effect until the following line\n   break.").
doc_string('pprint-indent', 'common-lisp', function, "Specify the indentation to use in the current logical block if\nSTREAM (which defaults to *STANDARD-OUTPUT*) is a pretty-printing\nstream and do nothing if not. (See PPRINT-LOGICAL-BLOCK.) N is the\nindentation to use (in ems, the width of an ``m'') and RELATIVE-TO can\nbe either:\n\n     :BLOCK - Indent relative to the column the current logical block\n        started on.\n\n     :CURRENT - Indent relative to the current column.\n\nThe new indentation value does not take effect until the following\nline break.").
doc_string('pprint-linear', 'common-lisp', function, "Output LIST to STREAM putting :LINEAR conditional newlines between each\n   element.  If COLON? is NIL (defaults to T), then no parens are printed\n   around the output.  ATSIGN? is ignored (but allowed so that PPRINT-LINEAR\n   can be used with the ~/.../ format directive.").
doc_string('pprint-linear', 'common-lisp', function, "Output LIST to STREAM putting :LINEAR conditional newlines between each\n   element. If COLON? is NIL (defaults to T), then no parens are printed\n   around the output. ATSIGN? is ignored (but allowed so that PPRINT-LINEAR\n   can be used with the ~/.../ format directive.").
doc_string('pprint-logical-block', 'common-lisp', function, "Group some output into a logical block.  STREAM-SYMBOL should be either a\n   stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*).  The printer\n   control variable *PRINT-LEVEL* is automatically handled.").
doc_string('pprint-logical-block', 'common-lisp', function, "Group some output into a logical block. STREAM-SYMBOL should be either a\n   stream, T (for *TERMINAL-IO*), or NIL (for *STANDARD-OUTPUT*). The printer\n   control variable *PRINT-LEVEL* is automatically handled.").
doc_string('pprint-newline', 'common-lisp', function, "Output a conditional newline to STREAM (which defaults to\n   *STANDARD-OUTPUT*) if it is a pretty-printing stream, and do\n   nothing if not.  KIND can be one of:\n     :LINEAR - A line break is inserted if and only if the immediatly\n        containing section cannot be printed on one line.\n     :MISER - Same as LINEAR, but only if ``miser-style'' is in effect.\n        (See *PRINT-MISER-WIDTH*.)\n     :FILL - A line break is inserted if and only if either:\n       (a) the following section cannot be printed on the end of the\n           current line,\n       (b) the preceding section was not printed on a single line, or\n       (c) the immediately containing section cannot be printed on one\n           line and miser-style is in effect.\n     :MANDATORY - A line break is always inserted.\n   When a line break is inserted by any type of conditional newline, any\n   blanks that immediately precede the conditional newline are ommitted\n   from the output and indentation is introduced at the beginning of the\n   next line.  (See PPRINT-INDENT.)").
doc_string('pprint-newline', 'common-lisp', function, "Output a conditional newline to STREAM (which defaults to\n   *STANDARD-OUTPUT*) if it is a pretty-printing stream, and do\n   nothing if not. KIND can be one of:\n     :LINEAR - A line break is inserted if and only if the immediately\n        containing section cannot be printed on one line.\n     :MISER - Same as LINEAR, but only if ``miser-style'' is in effect.\n        (See *PRINT-MISER-WIDTH*.)\n     :FILL - A line break is inserted if and only if either:\n       (a) the following section cannot be printed on the end of the\n           current line,\n       (b) the preceding section was not printed on a single line, or\n       (c) the immediately containing section cannot be printed on one\n           line and miser-style is in effect.\n     :MANDATORY - A line break is always inserted.\n   When a line break is inserted by any type of conditional newline, any\n   blanks that immediately precede the conditional newline are omitted\n   from the output and indentation is introduced at the beginning of the\n   next line. (See PPRINT-INDENT.)").
doc_string('pprint-pop', 'common-lisp', function, "Return the next element from LIST argument to the closest enclosing\n   use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH*\n   and *PRINT-CIRCLE*.  Can only be used inside PPRINT-LOGICAL-BLOCK.\n   If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing\n   is poped, but the *PRINT-LENGTH* testing still happens.").
doc_string('pprint-pop', 'common-lisp', function, "Return the next element from LIST argument to the closest enclosing\n   use of PPRINT-LOGICAL-BLOCK, automatically handling *PRINT-LENGTH*\n   and *PRINT-CIRCLE*. Can only be used inside PPRINT-LOGICAL-BLOCK.\n   If the LIST argument to PPRINT-LOGICAL-BLOCK was NIL, then nothing\n   is popped, but the *PRINT-LENGTH* testing still happens.").
doc_string('pprint-tab', 'common-lisp', function, "If STREAM (which defaults to *STANDARD-OUTPUT*) is a pretty-printing\n   stream, perform tabbing based on KIND, otherwise do nothing.  KIND can\n   be one of:\n     :LINE - Tab to column COLNUM.  If already past COLNUM tab to the next\n       multiple of COLINC.\n     :SECTION - Same as :LINE, but count from the start of the current\n       section, not the start of the line.\n     :LINE-RELATIVE - Output COLNUM spaces, then tab to the next multiple of\n       COLINC.\n     :SECTION-RELATIVE - Same as :LINE-RELATIVE, but count from the start\n       of the current section, not the start of the line.").
doc_string('pprint-tab', 'common-lisp', function, "If STREAM (which defaults to *STANDARD-OUTPUT*) is a pretty-printing\n   stream, perform tabbing based on KIND, otherwise do nothing. KIND can\n   be one of:\n     :LINE - Tab to column COLNUM. If already past COLNUM tab to the next\n       multiple of COLINC.\n     :SECTION - Same as :LINE, but count from the start of the current\n       section, not the start of the line.\n     :LINE-RELATIVE - Output COLNUM spaces, then tab to the next multiple of\n       COLINC.\n     :SECTION-RELATIVE - Same as :LINE-RELATIVE, but count from the start\n       of the current section, not the start of the line.").
doc_string('pprint-tabular', 'common-lisp', function, "Output LIST to STREAM tabbing to the next column that is an even multiple\n   of TABSIZE (which defaults to 16) between each element.  :FILL style\n   conditional newlines are also output between each element.  If COLON? is\n   NIL (defaults to T), then no parens are printed around the output.\n   ATSIGN? is ignored (but allowed so that PPRINT-TABULAR can be used with\n   the ~/.../ format directive.").
doc_string('pprint-tabular', 'common-lisp', function, "Output LIST to STREAM tabbing to the next column that is an even multiple\n   of TABSIZE (which defaults to 16) between each element. :FILL style\n   conditional newlines are also output between each element. If COLON? is\n   NIL (defaults to T), then no parens are printed around the output.\n   ATSIGN? is ignored (but allowed so that PPRINT-TABULAR can be used with\n   the ~/.../ format directive.").
doc_string('prin1-to-string', 'common-lisp', function, "Args: (object)\nPRIN1s OBJECT to a new string and returns the result.  Equivalent to\n(WRITE-TO-STRING OBJECT :ESCAPE T).").
doc_string('prin1-to-string', 'common-lisp', function, "Return the printed representation of OBJECT as a string with\n   slashification on.").
doc_string('princ-to-string', 'common-lisp', function, "Args: (object)\nPRINCs OBJECT to a new string and returns the result.  Equivalent to\n(WRITE-TO-STRING OBJECT :ESCAPE NIL).").
doc_string('princ-to-string', 'common-lisp', function, "Return the printed representation of OBJECT as a string with\n  slashification off.").
doc_string('print-backtrace', 'sb-debug', function, "Print a listing of the call stack to STREAM, defaulting to *DEBUG-IO*.\n\nCOUNT is the number of frames to backtrace, defaulting to\n*BACKTRACE-FRAME-COUNT*.\n\nSTART is the number of the frame the backtrace should start from.\n\nFROM specifies the frame relative to which the frames are numbered. Possible\nvalues are an explicit SB-DI:FRAME object, and the\nkeywords :CURRENT-FRAME, :INTERRUPTED-FRAME, and :DEBUGGER-FRAME. Default\nis :DEBUGGER-FRAME.\n\n  :CURRENT-FRAME\n    specifies the caller of PRINT-BACKTRACE.\n\n  :INTERRUPTED-FRAME\n    specifies the first interrupted frame on the stack (typically the frame\n    where the error occured, as opposed to error handling frames) if any,\n    otherwise behaving as :CURRENT-FRAME.\n\n  :DEBUGGER-FRAME\n    specifies the currently debugged frame when inside the debugger, and\n    behaves as :INTERRUPTED-FRAME outside the debugger.\n\nIf PRINT-THREAD is true (default), backtrace is preceded by printing the\nthread object the backtrace is from.\n\nIf PRINT-FRAME-SOURCE is true (default is false), each frame is followed by\nprinting the currently executing source form in the function responsible for\nthat frame, when available. Requires the function to have been compiled at\nDEBUG 2 or higher. If PRINT-FRAME-SOURCE is :ALWAYS, it also reports \"no\nsource available\" for frames for which were compiled at lower debug settings.\n\nMETHOD-FRAME-STYLE (defaulting to *METHOD-FRAME-STYLE*), determines how frames\ncorresponding to method functions are printed. Possible values\nare :MINIMAL, :NORMAL, and :FULL. See *METHOD-FRAME-STYLE* for more\ninformation.").
doc_string('print-not-readable-object', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('print-symbol-with-prefix', pkg_sys, function, "For use with ~/: Write SYMBOL to STREAM as if it is not accessible from\n  the current package.").
doc_string('print-unreadable-object', 'common-lisp', function, "Output OBJECT to STREAM with \"#<\" prefix, \">\" suffix, optionally\n  with object-type prefix and object-identity suffix, and executing the\n  code in BODY to provide possible further output.").
doc_string('print-unreadably', pkg_sys, function, "Transfer control to a restart named SB-EXT:PRINT-UNREADABLY, or\nreturn NIL if none exists.").
doc_string('priority-queue-extract-maximum', 'sb-impl', function, "Remove and return the item in PRIORITY-QUEUE with the largest key.").
doc_string('priority-queue-insert', 'sb-impl', function, "Add NEW-ITEM to PRIORITY-QUEUE.").
doc_string('priority-queue-maximum', 'sb-impl', function, "Return the item in PRIORITY-QUEUE with the largest key.").
doc_string('priority-queue-remove', 'sb-impl', function, "Remove and return ITEM from PRIORITY-QUEUE.").
doc_string('probe-file', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the full pathname of the specified file if it exists.  Returns NIL\notherwise.  FILESPEC may be a symbol, a string, a pathname, or a file stream.\n").
doc_string('probe-file', 'common-lisp', function, "Return the truename of PATHSPEC if the truename can be found,\nor NIL otherwise.  See TRUENAME for more information.").
doc_string('process-alive-p', pkg_sys, function, "Return T if PROCESS is still alive, NIL otherwise.").
doc_string('process-close', pkg_sys, function, "Close all streams connected to PROCESS and stop maintaining the\nstatus slot.").
doc_string('process-command-args', extensions, function, "PROCESS-COMMAND-ARGS takes a list of arguments and processes according\nto a set of rules. These rules are of the format\n\n        (option-name nargs template [ :stop | :noloadrc | :loadrc ] )\n\nOPTION-NAME is a string containing the command line option. NARGS is\nthe number of arguments that this option takes. TEMPLATE is a lisp\nform where numbers from 0 to NARGS will be substituted by the\narguments, and which will be evaluated afterwards. The flags :STOP,\n:NOLOADRC and :LOADRC denote whether to stop processing the command\nline after this option and whether the initialization file will be\nloaded before evaluating all forms.\n\nAn excerpt of the rules used by WAM-CL:\n'((\"--help\" 0 #0=(progn (princ *help-message* *standard-output*) (quit))\n               :noloadrc)\n  (\"-?\" 0 #0# :noloadrc)\n  (\"-h\" 0 #0# :noloadrc)\n  (\"-norc\" 0 nil :noloadrc)\n  (\"--\" 0 nil :stop)\n  (\"-eval\" 1 (eval (read-from-string 1))))\n").
doc_string('process-core-dumped', pkg_sys, function, "T if a core image was dumped by the process.").
doc_string('process-error', pkg_sys, function, "The error stream of the process or NIL.").
doc_string('process-exit-code', pkg_sys, function, "The exit code or the signal of a stopped process.").
doc_string('process-input', pkg_sys, function, "The input stream of the process or NIL.").
doc_string('process-kill', pkg_sys, function, "Hand SIGNAL to PROCESS. If WHOM is :PID, use the kill Unix system call. If\n   WHOM is :PROCESS-GROUP, use the killpg Unix system call. If WHOM is\n   :PTY-PROCESS-GROUP deliver the signal to whichever process group is\n   currently in the foreground.").
doc_string('process-output', pkg_sys, function, "The output stream of the process or NIL.").
doc_string('process-p', pkg_sys, function, "T if OBJECT is a PROCESS, NIL otherwise.").
doc_string('process-pid', pkg_sys, function, "The pid of the child process.").
doc_string('process-plist', pkg_sys, function, "A place for clients to stash things.").
doc_string('process-pty', pkg_sys, function, "The pty stream of the process or NIL.").
doc_string('process-status', pkg_sys, function, "Return the current status of PROCESS.  The result is one of :RUNNING,\n   :STOPPED, :EXITED, or :SIGNALED.").
doc_string('process-status-hook', pkg_sys, function, "A function that is called when PROCESS changes its status.\nThe function is called with PROCESS as its only argument.").
doc_string('process-wait', pkg_sys, function, "Wait for PROCESS to quit running for some reason. When\nCHECK-FOR-STOPPED is T, also returns when PROCESS is stopped. Returns\nPROCESS.").
doc_string('proclamation-mismatch-description', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('proclamation-mismatch-kind', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('proclamation-mismatch-name', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('proclamation-mismatch-new', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('proclamation-mismatch-old', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('prog*', 'common-lisp', function, "Syntax: (prog* ({var | (var [init])}*) {decl}* {tag | statement}*)\nEstablishes a NIL block, binds each VAR to the value of INIT (which defaults\nto NIL) sequentially, and executes STATEMENTs.  Returns NIL.").
doc_string('program-error-form', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('program-error-message', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('program-error-source', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('proplist-p', 'sb-unicode', function, "Returns T if CHARACTER has the specified PROPERTY.\nPROPERTY is a keyword representing one of the properties from PropList.txt,\nwith underscores replaced by dashes.").
doc_string('random-state-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a random-state object; NIL otherwise.\n").
doc_string('rassoc-if', 'common-lisp', function, "Return the first cons in ALIST whose CDR satisfies PREDICATE. If KEY\n  is supplied, apply it to the CDR of each cons before testing.").
doc_string('rassoc-if', 'common-lisp', function, "Returns the first pair in ALIST whose cdr satisfies TEST. Returns NIL if no\nsuch pair exists.").
doc_string('rassoc-if-not', 'common-lisp', function, "Return the first cons in ALIST whose CDR does not satisfy PREDICATE.\n  If KEY is supplied, apply it to the CDR of each cons before testing.").
doc_string('rassoc-if-not', 'common-lisp', function, "Returns the first pair in ALIST whose cdr does not satisfy TEST.  Returns NIL\nif no such pair exists.").
doc_string('read-byte', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM &OPTIONAL (EOF-ERROR-P T) (EOF-VALUE NIL))\n\nReads one byte from STREAM and returns it as an integer.\n").
doc_string('read-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))\n\nReads a character from STREAM and returns it.\n").
doc_string('read-char-no-hang', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))\n\nReturns the next character from STREAM if one is available; NIL otherwise.\n").
doc_string('read-delimited-list', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &OPTIONAL (STREAM *STANDARD-INPUT*) (RECURSIVE-P NIL))\n\nReads objects from STREAM until the next character after an object's\nrepresentation is CHAR.  Returns all objects read, as a list.\n").
doc_string('read-delimited-list', 'common-lisp', function, "Read Lisp values from INPUT-STREAM until the next character after a\n   value's representation is ENDCHAR, and return the objects as a list.").
doc_string('read-from-string', 'common-lisp', function, "Args: (string &optional (eof-error-p t) (eof-value nil)\n              &key (start 0) (end (length string)) (preserve-whitespace nil))\nReads an object from STRING and returns the object.  As the second value,\nreturns the index to the character next to the object's representation.\nPRESERVE-WHITESPACE specifies whether to leave the character next to the\nobject's representation.").
doc_string('read-from-string', 'common-lisp', function, "The characters of string are successively given to the lisp reader\n   and the lisp object built by the reader is returned. Macro chars\n   will take effect.").
doc_string('read-line', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))\n\nReads a line of characters from STREAM and returns them as a string.  The\nnewline character at the end of the line will be discarded.\n").
doc_string('read-preserving-whitespace', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVE-P NIL))\n\nReads an object from STREAM and returns the object.  Unlike READ, always\nleaves the character next to the object's representation.\n").
doc_string('read-preserving-whitespace', 'common-lisp', function, "Read from STREAM and return the value read, preserving any whitespace\n   that followed the object.").
doc_string('read-sequence', 'common-lisp', function, "Destructively modify SEQ by reading elements from STREAM.\n  That part of SEQ bounded by START and END is destructively modified by\n  copying successive elements into it from STREAM. If the end of file\n  for STREAM is reached before copying all elements of the subsequence,\n  then the extra elements near the end of sequence are not updated, and\n  the index of the next element is returned.").
doc_string('read-token', 'sb-impl', function, "Default readmacro function. Handles numbers, symbols, and SBCL's\nextended <package-name>::<form-in-package> syntax.").
doc_string('reader-eof-error-context', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('reader-impossible-number-error-error', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('readline-reader', readline, function, "Read a single line using GNU readline with the standard CLISP prompt.").
doc_string('readline-version-major', readline, variable, "Readline major version.").
doc_string('readline-version-minor', readline, variable, "Readline minor version.").
doc_string('readline-version-number', readline, variable, "Readline numeric version, see also `readline-version'.").
doc_string('readtable-normalization', pkg_sys, function, "Returns T if READTABLE normalizes strings to NFKC, and NIL otherwise.\nThe READTABLE-NORMALIZATION of the standard readtable is T.").
doc_string('record-source-information-for-type', system, function, "Record source information on the SYS:SOURCE property for symbol with NAME\r\n\r\nTYPE is either a symbol or list.\r\n\r\nSource information for functions, methods, and generic functions are\r\nrepresented as lists of the following form:\r\n\r\n    (:generic-function function-name)\r\n    (:function function-name)\r\n    (:method method-name qualifiers specializers)\r\n\r\nWhere FUNCTION-NAME or METHOD-NAME can be a either be of the form\r\n'symbol or '(setf symbol).\r\n\r\nSource information for all other forms have a symbol for TYPE which is\r\none of the following:\r\n\r\n:class, :variable, :condition, :constant, :compiler-macro, :macro\r\n:package, :structure, :type, :setf-expander, :source-transform\r\n\r\nThese values follow SBCL'S implemenation in SLIME\r\nc.f. <https://github.com/slime/slime/blob/bad2acf672c33b913aabc1a7facb9c3c16a4afe9/swank/sbcl.lisp#L748>\r\n\r\n").
doc_string('redefine-cl-functions', gray, function, "Some functions in CL package are expected to be generic. We make them so.").
doc_string('redefine-class-forwarder', mop, function, "Define a generic function on a temporary symbol as an accessor\r\nfor the slot `slot'. Then, when definition is complete (including\r\nallocation of methods), swap the definition in place.\r\n\r\n`body-alist' can be used to override the default method bodies for given\r\nmetaclasses.  In substitute method bodies, `class' names the class\r\ninstance and, for setters, `new-value' the new value.").
doc_string('redefinition-warning-name', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('redefinition-warning-new-location', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('redefinition-with-defmethod-new-location', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('redefinition-with-defmethod-old-method', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('redefinition-with-defmethod-qualifiers', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('redefinition-with-defmethod-specializers', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('redefinition-with-deftransform-transform', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('reference-condition-references', 'sb-int', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('regexp-matcher', regexp, function, "A valid value for *APROPOS-MATCHER* in the UTF-8 locale.").
doc_string('regexp-split', regexp, function, "\r\nSplit the STRING by the regexp PATTERN.\r\nReturn a list of substrings of STRINGS.").
doc_string('relative-decoded-times', 'sb-impl', function, "Returns relative decoded time as two values: difference between\nABS-SEC and ABS-USEC and current real time.\n\nIf ABS-SEC and ABS-USEC are in the past, 0 0 is returned.").
doc_string('release-foreground', 'sb-thread', function, "Background this thread.  If NEXT is supplied, arrange for it to\nhave the foreground next.").
doc_string('release-mutex', 'sb-thread', function, "Release MUTEX by setting it to NIL. Wake up threads waiting for\nthis mutex.\n\nRELEASE-MUTEX is not interrupt safe: interrupts should be disabled\naround calls to it.\n\nIf the current thread is not the owner of the mutex then it silently\nreturns without doing anything (if IF-NOT-OWNER is :PUNT), signals a\nWARNING (if IF-NOT-OWNER is :WARN), or releases the mutex anyway (if\nIF-NOT-OWNER is :FORCE).").
doc_string('release-spinlock', 'sb-thread', function, "The function SB-THREAD::RELEASE-SPINLOCK has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:RELEASE-MUTEX instead.").
doc_string('remove-duplicates', 'common-lisp', function, "Args: (sequence\n       &key key (test '#'eql) test-not\n            (start 0) (end (length sequence)) (from-end nil))\nReturns a copy of SEQUENCE without duplicated elements.").
doc_string('remove-duplicates', 'common-lisp', function, "The elements of SEQUENCE are compared pairwise, and if any two match,\n   the one occurring earlier is discarded, unless FROM-END is true, in\n   which case the one later in the sequence is discarded. The resulting\n   sequence is returned.\n\n   The :TEST-NOT argument is deprecated.").
doc_string('remove-escape-characters', 'sb-impl', function, "Remove any occurrences of escape characters from the string\n   because we've already checked for whatever they may have\n   protected.").
doc_string('remove-fd-handler', 'sb-sys', function, "Removes HANDLER from the list of active handlers.").
doc_string('remove-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nReturns a copy of SEQUENCE with elements satisfying TEST removed.\n").
doc_string('remove-if', 'common-lisp', function, "Return a copy of sequence with elements satisfying PREDICATE removed.").
doc_string('remove-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nReturns a copy of SEQUENCE with elements not satisfying TEST removed.\n").
doc_string('remove-if-not', 'common-lisp', function, "Return a copy of sequence with elements not satisfying PREDICATE removed.").
doc_string('remove-implementation-package', pkg_sys, function, "Removes PACKAGES-TO-REMOVE from the implementation packages of\nPACKAGE. Signals an error if PACKAGE or any of the PACKAGES-TO-REMOVE\nis not a valid package designator.").
doc_string('remove-package-local-nickname', pkg_sys, function, "If the designated package had OLD-NICKNAME as a local nickname for\nanother package, it is removed. Returns true if the nickname existed and was\nremoved, and NIL otherwise.\n\nSee also: ADD-PACKAGE-LOCAL-NICKNAME, PACKAGE-LOCAL-NICKNAMES,\nPACKAGE-LOCALLY-NICKNAMED-BY-LIST, and the DEFPACKAGE option :LOCAL-NICKNAMES.\n\nExperimental: interface subject to change.").
doc_string('rename-file', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC NEW-FILESPEC &KEY (IF-EXISTS ERROR))\n\nRenames the file specified by FILESPEC as specified by NEW-FILESPEC.  Returns\nas three values the new pathname, the old full pathname, and the new full\npathname.  FILESPEC and NEW-FILESPEC may be a symbol, a string, a pathname, or\na file stream.\n\n:IF-EXISTS is an WAM-CL-specific extension that modifies the behavior of rename-file\nif new-filespec already exists. It may be :ERROR (the default), NIL, :SUPERSEDE,\nor T.\n").
doc_string('rename-file', 'common-lisp', function, "Modifies the file system in such a way that the file indicated by FILESPEC is renamed to DEFAULTED-NEW-NAME.\r\n\r\nReturns three values if successful. The primary value, DEFAULTED-NEW-NAME, is\r\nthe resulting name which is composed of NEW-NAME with any missing components filled in by\r\nperforming a merge-pathnames operation using filespec as the defaults. The secondary\r\nvalue, OLD-TRUENAME, is the truename of the file before it was renamed. The tertiary\r\nvalue, NEW-TRUENAME, is the truename of the file after it was renamed.\r\n").
doc_string('rename-file', 'common-lisp', function, "Rename FILE to have the specified NEW-NAME. If FILE is a stream open to a\nfile, then the associated file is renamed.").
doc_string('rename-package', 'common-lisp', function, "Changes the name and nicknames for a package.").
doc_string('rename-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE NEW-NAME &OPTIONAL (NEW-NICKNAMES NIL))\n\nRenames PACKAGE to NEW-NAME and replaces the nicknames with NEW-NICKNAMES.\nSee MAKE-PACKAGE.\n").
doc_string('restart-bind', 'common-lisp', function, "(RESTART-BIND ({(case-name function {keyword value}*)}*) forms)\n   Executes forms in a dynamic context where the given bindings are in\n   effect. Users probably want to use RESTART-CASE. A case-name of NIL\n   indicates an anonymous restart. When bindings contain the same\n   restart name, FIND-RESTART will find the first such binding.").
doc_string('restart-case', 'common-lisp', function, "(RESTART-CASE form {(case-name arg-list {keyword value}* body)}*)\n   The form is evaluated in a dynamic context where the clauses have\n   special meanings as points to which control may be transferred (see\n   INVOKE-RESTART).  When clauses contain the same case-name,\n   FIND-RESTART will find the first such clause. If form is a call to\n   SIGNAL, ERROR, CERROR or WARN (or macroexpands into such) then the\n   signalled condition will be associated with the new restarts.").
doc_string('restart-name', 'common-lisp', function, "Return the name of the given restart object.").
doc_string('restrict-compiler-policy', pkg_sys, function, "Assign a minimum value to an optimization quality. QUALITY is the name of\nthe optimization quality to restrict, and MIN (defaulting to zero) is the\nminimum allowed value.\n\nReturns the alist describing the current policy restrictions.\n\nIf QUALITY is NIL or not given, nothing is done.\n\nOtherwise, if MIN is zero or not given, any existing restrictions of QUALITY\nare removed. If MIN is between one and three inclusive, it becomes the new\nminimum value for the optimization quality: any future proclamations or\ndeclarations of the quality with a value less then MIN behave as if the value\nwas MIN instead.\n\nThis is intended to be used interactively, to facilitate recompiling large\nbodies of code with eg. a known minimum safety.\n\nSee also :POLICY option in WITH-COMPILATION-UNIT.\n\nEXPERIMENTAL INTERFACE: Subject to change.").
doc_string('return-from', 'common-lisp', function, "RETURN-FROM block-name value-form\n\nEvaluate the VALUE-FORM, returning its values from the lexically enclosing\nblock BLOCK-NAME. This is constrained to be used only within the dynamic\nextent of the block.").
doc_string('return-from', 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (SYMBOL &OPTIONAL RESULT)\n\nTerminates execution of the lexically surrounding block named SYMBOL and\nreturns all values of RESULT (which defaults to NIL) as the values of the\nterminated block.\n").
doc_string('return-from-thread', 'sb-thread', function, "Unwinds from and terminates the current thread, with values from\nVALUES-FORM as the results visible to JOIN-THREAD.\n\nIf current thread is the main thread of the process (see\nMAIN-THREAD-P), signals an error unless ALLOW-EXIT is true, as\nterminating the main thread would terminate the entire process. If\nALLOW-EXIT is true, returning from the main thread is equivalent to\ncalling SB-EXT:EXIT with :CODE 0 and :ABORT NIL.\n\nSee also: ABORT-THREAD and SB-EXT:EXIT.").
doc_string('row-major-aref', 'common-lisp', function, "Return the element of array corresponding to the row-major index. This is\n   SETFable.").
doc_string('run-program', pkg_sys, function, "RUN-PROGRAM creates a new process specified by the PROGRAM\nargument. ARGS are the standard arguments that can be passed to a\nprogram. For no arguments, use NIL (which means that just the\nname of the program is passed as arg 0).\n\nThe program arguments and the environment are encoded using the\ndefault external format for streams.\n\nRUN-PROGRAM will return a PROCESS structure. See the CMU Common Lisp\nUsers Manual for details about the PROCESS structure.\n\n   Notes about Unix environments (as in the :ENVIRONMENT and :ENV args):\n\n   - The SBCL implementation of RUN-PROGRAM, like Perl and many other\n     programs, but unlike the original CMU CL implementation, copies\n     the Unix environment by default.\n   - Running Unix programs from a setuid process, or in any other\n     situation where the Unix environment is under the control of someone\n     else, is a mother lode of security problems. If you are contemplating\n     doing this, read about it first. (The Perl community has a lot of good\n     documentation about this and other security issues in script-like\n     programs.)\n\n   The &KEY arguments have the following meanings:\n   :ENVIRONMENT\n      a list of STRINGs describing the new Unix environment\n      (as in \"man environ\"). The default is to copy the environment of\n      the current process.\n   :ENV\n      an alternative lossy representation of the new Unix environment,\n      for compatibility with CMU CL\n   :SEARCH\n      Look for PROGRAM in each of the directories in the child's $PATH\n      environment variable.  Otherwise an absolute pathname is required.\n   :WAIT\n      If non-NIL (default), wait until the created process finishes.  If\n      NIL, continue running Lisp until the program finishes.\n   :PTY\n      Either T, NIL, or a stream.  Unless NIL, the subprocess is established\n      under a PTY.  If :pty is a stream, all output to this pty is sent to\n      this stream, otherwise the PROCESS-PTY slot is filled in with a stream\n      connected to pty that can read output and write input.\n   :INPUT\n      Either T, NIL, a pathname, a stream, or :STREAM.  If T, the standard\n      input for the current process is inherited.  If NIL, /dev/null\n      is used.  If a pathname, the file so specified is used.  If a stream,\n      all the input is read from that stream and sent to the subprocess.  If\n      :STREAM, the PROCESS-INPUT slot is filled in with a stream that sends\n      its output to the process. Defaults to NIL.\n   :IF-INPUT-DOES-NOT-EXIST (when :INPUT is the name of a file)\n      can be one of:\n         :ERROR to generate an error\n         :CREATE to create an empty file\n         NIL (the default) to return NIL from RUN-PROGRAM\n   :OUTPUT\n      Either T, NIL, a pathname, a stream, or :STREAM.  If T, the standard\n      output for the current process is inherited.  If NIL, /dev/null\n      is used.  If a pathname, the file so specified is used.  If a stream,\n      all the output from the process is written to this stream. If\n      :STREAM, the PROCESS-OUTPUT slot is filled in with a stream that can\n      be read to get the output. Defaults to NIL.\n   :IF-OUTPUT-EXISTS (when :OUTPUT is the name of a file)\n      can be one of:\n         :ERROR (the default) to generate an error\n         :SUPERSEDE to supersede the file with output from the program\n         :APPEND to append output from the program to the file\n         NIL to return NIL from RUN-PROGRAM, without doing anything\n   :ERROR and :IF-ERROR-EXISTS\n      Same as :OUTPUT and :IF-OUTPUT-EXISTS, except that :ERROR can also be\n      specified as :OUTPUT in which case all error output is routed to the\n      same place as normal output.\n   :STATUS-HOOK\n      This is a function the system calls whenever the status of the\n      process changes.  The function takes the process as an argument.\n   :EXTERNAL-FORMAT\n      The external-format to use for :INPUT, :OUTPUT, and :ERROR :STREAMs.\n   :DIRECTORY\n      Specifies the directory in which the program should be run.\n      NIL (the default) means the directory is unchanged.").
doc_string('safe-eval', extensions, function, "Args: (FORM ENV &optional ERR-VALUE)\nEvaluates FORM in the given environment, which may be NIL. If the form\nsignals an error, or tries to jump to an outer point, the function has two\nchoices: by default, it will invoke a debugger, but if a third value is\nsupplied, then SAFE-EVAL will not use a debugger but rather return that\nvalue.").
doc_string('sap-alien', 'sb-alien', function, "Convert the system area pointer SAP to an ALIEN of the specified TYPE (not\n   evaluated.) TYPE must be pointer-like.").
doc_string('save-lisp-and-die', pkg_sys, function, "Save a \"core image\", i.e. enough information to restart a Lisp\nprocess later in the same state, in the file of the specified name.\nOnly global state is preserved: the stack is unwound in the process.\n\nThe following &KEY arguments are defined:\n\n  :TOPLEVEL\n     The function to run when the created core file is resumed. The\n     default function handles command line toplevel option processing\n     and runs the top level read-eval-print loop. This function returning\n     is equivalent to (SB-EXT:EXIT :CODE 0) being called.\n\n     TOPLEVEL functions should always provide an ABORT restart: otherwise\n     code they call will run without one.\n\n  :EXECUTABLE\n     If true, arrange to combine the SBCL runtime and the core image\n     to create a standalone executable.  If false (the default), the\n     core image will not be executable on its own. Executable images\n     always behave as if they were passed the --noinform runtime option.\n\n  :SAVE-RUNTIME-OPTIONS\n     If true, values of runtime options --dynamic-space-size and\n     --control-stack-size that were used to start SBCL are stored in\n     the standalone executable, and restored when the executable is\n     run. This also inhibits normal runtime option processing, causing\n     all command line arguments to be passed to the toplevel.\n     Meaningless if :EXECUTABLE is NIL.\n\n  :PURIFY\n     If true (the default on cheneygc), do a purifying GC which moves all\n     dynamically allocated objects into static space. This takes\n     somewhat longer than the normal GC which is otherwise done, but\n     it's only done once, and subsequent GC's will be done less often\n     and will take less time in the resulting core file. See the PURIFY\n     function. This parameter has no effect on platforms using the\n     generational garbage collector.\n\n  :ROOT-STRUCTURES\n     This should be a list of the main entry points in any newly loaded\n     systems. This need not be supplied, but locality and/or GC performance\n     may be better if they are. Meaningless if :PURIFY is NIL. See the\n     PURIFY function.\n\n  :ENVIRONMENT-NAME\n     This is also passed to the PURIFY function when :PURIFY is T.\n     (rarely used)\n\n  :COMPRESSION\n     This is only meaningful if the runtime was built with the :SB-CORE-COMPRESSION\n     feature enabled. If NIL (the default), saves to uncompressed core files. If\n     :SB-CORE-COMPRESSION was enabled at build-time, the argument may also be\n     an integer from -1 to 9, corresponding to zlib compression levels, or T\n     (which is equivalent to the default compression level, -1).\n\n  :APPLICATION-TYPE\n     Present only on Windows and is meaningful only with :EXECUTABLE T.\n     Specifies the subsystem of the executable, :CONSOLE or :GUI.\n     The notable difference is that :GUI doesn't automatically create a console\n     window. The default is :CONSOLE.\n\nThe save/load process changes the values of some global variables:\n\n  *STANDARD-OUTPUT*, *DEBUG-IO*, etc.\n    Everything related to open streams is necessarily changed, since\n    the OS won't let us preserve a stream across save and load.\n\n  *DEFAULT-PATHNAME-DEFAULTS*\n    This is reinitialized to reflect the working directory where the\n    saved core is loaded.\n\nSAVE-LISP-AND-DIE interacts with SB-ALIEN:LOAD-SHARED-OBJECT: see its\ndocumentation for details.\n\nOn threaded platforms only a single thread may remain running after\nSB-EXT:*SAVE-HOOKS* have run. Applications using multiple threads can\nbe SAVE-LISP-AND-DIE friendly by registering a save-hook that quits\nany additional threads, and an init-hook that restarts them.\n\nThis implementation is not as polished and painless as you might like:\n  * It corrupts the current Lisp image enough that the current process\n    needs to be killed afterwards. This can be worked around by forking\n    another process that saves the core.\n  * There is absolutely no binary compatibility of core images between\n    different runtime support programs. Even runtimes built from the same\n    sources at different times are treated as incompatible for this\n    purpose.\nThis isn't because we like it this way, but just because there don't\nseem to be good quick fixes for either limitation and no one has been\nsufficiently motivated to do lengthy fixes.").
doc_string('save-with-multiple-threads-error-interactive-threads', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('save-with-multiple-threads-error-other-threads', 'sb-impl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('scale-float', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FLOAT INTEGER)\n\nReturns the value of (* FLOAT (expt (float-radix FLOAT) INTEGER)).\n").
doc_string('scale-float', 'common-lisp', function, "Return the value (* f (expt (float 2 f) ex)), but with no unnecessary loss\n  of precision or overflow.").
doc_string('schedule-timer', pkg_sys, function, "Schedule TIMER to be triggered at TIME. If ABSOLUTE-P then TIME is\nuniversal time, but non-integral values are also allowed, else TIME is\nmeasured as the number of seconds from the current time.\n\nIf REPEAT-INTERVAL is given, TIMER is automatically rescheduled upon\nexpiry.\n\nIf REPEAT-INTERVAL is non-NIL, the Boolean CATCH-UP controls whether\nTIMER will \"catch up\" by repeatedly calling its function without\ndelay in case calls are missed because of a clock discontinuity such\nas a suspend and resume cycle of the computer. The default is NIL,\ni.e. do not catch up.").
doc_string('seed-random-state', pkg_sys, function, "Make a random state object. The optional STATE argument specifies a seed\nfor deterministic pseudo-random number generation.\n\nAs per the Common Lisp standard for MAKE-RANDOM-STATE,\n- If STATE is NIL or not supplied, return a copy of the default\n  *RANDOM-STATE*.\n- If STATE is a random state, return a copy of it.\n- If STATE is T, return a randomly initialized state (using operating-system\n  provided randomness where available, otherwise a poor substitute based on\n  internal time and pid).\n\nAs a supported SBCL extension, we also support receiving as a seed an object\nof the following types:\n- (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))\n- UNSIGNED-BYTE\nWhile we support arguments of any size and will mix the provided bits into\nthe random state, it is probably overkill to provide more than 256 bits worth\nof actual information.\n\nThis particular SBCL version also accepts an argument of the following type:\n(SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))\n\nThis particular SBCL version uses the popular MT19937 PRNG algorithm, and its\ninternal state only effectively contains about 19937 bits of information.\nhttp://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html\n").
doc_string('semaphore-count', 'sb-thread', function, "Returns the current count of the semaphore INSTANCE.").
doc_string('semaphore-name', 'sb-thread', function, "The name of the semaphore INSTANCE. Setfable.").
doc_string('semaphore-notification-status', 'sb-thread', function, "Returns T if a WAIT-ON-SEMAPHORE or TRY-SEMAPHORE using\nSEMAPHORE-NOTIFICATION has succeeded since the notification object was created\nor cleared.").
doc_string('sentence-break-class', 'sb-unicode', function, "Returns the sentence breaking class of CHARACTER, as specified in UAX #29.").
doc_string('sentence-prebreak', 'sb-unicode', function, "Pre-combines some sequences of characters to make the sentence-break\nalgorithm simpler..\nSpecifically,\n- Combines any character with the following extend of format characters\n- Combines CR + LF into '(CR LF)\n- Combines any run of :cp*:close* into one character").
doc_string('serve-all-events', 'sb-sys', function, "SERVE-ALL-EVENTS calls SERVE-EVENT with the specified timeout. If\nSERVE-EVENT does something (returns T) it loops over SERVE-EVENT with a\ntimeout of 0 until there are no more events to serve. SERVE-ALL-EVENTS returns\nT if SERVE-EVENT did something and NIL if not.").
doc_string('serve-event', 'sb-sys', function, "Receive pending events on all FD-STREAMS and dispatch to the appropriate\nhandler functions. If timeout is specified, server will wait the specified\ntime (in seconds) and then return, otherwise it will wait until something\nhappens. Server returns T if something happened and NIL otherwise. Timeout\n0 means polling without waiting.").
doc_string('set-difference', 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nReturns, as a list, those elements of LIST1 that are not elements of LIST2.").
doc_string('set-difference', 'common-lisp', function, "Return the elements of LIST1 which are not in LIST2.").
doc_string('set-dispatch-macro-character', 'common-lisp', function, "Cause FUNCTION to be called whenever the reader reads DISP-CHAR\n   followed by SUB-CHAR.").
doc_string('set-dispatch-macro-character', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR SUBCHAR FUNCTION &OPTIONAL (READTABLE *READTABLE*))\n\nReplaces FUNCTION for the read macro of SUBCHAR associated with the dispatch\nmacro character CHAR in READTABLE.  When the WAM-CL reader reads an object that\nbegins with CHAR followed by SUBCHAR, it calls FUNCTION with the input stream,\nSUBCHAR, and NIL as arguments.  When the WAM-CL reader reads an object that\nbegins with CHAR, followed by a decimal representation of a number N, followed\nby SUB-CHAR, it calls FUNCTION with N as the third argument.  In both cases,\nif FUNCTION returns a single value, then that value is returned as the value\nof the reader.  If FUNCTION returns no value, then the reader tries to read an\nobject again.  See MAKE-DISPATCH-MACRO-CHARACTER and GET-DISPATCH-MACRO-\nCHARACTER.\n").
doc_string('set-exclusive-or', 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nReturns, as a list, those elements of LIST1 that are not elements of LIST2 and\nthose elements of LIST2 that are not elements of LIST1.").
doc_string('set-exclusive-or', 'common-lisp', function, "Return new list of elements appearing exactly once in LIST1 and LIST2.").
doc_string('set-floating-point-modes', 'sb-int', function, "This function sets options controlling the floating-point\nhardware. If a keyword is not supplied, then the current value is\npreserved. Possible keywords:\n\n :TRAPS\n   A list of the exception conditions that should cause traps.\n   Possible exceptions are :UNDERFLOW, :OVERFLOW, :INEXACT, :INVALID,\n  :DIVIDE-BY-ZERO, and on the X86 :DENORMALIZED-OPERAND.\n\n:ROUNDING-MODE\n   The rounding mode to use when the result is not exact. Possible\n   values are :NEAREST, :POSITIVE-INFINITY, :NEGATIVE-INFINITY and\n   :ZERO.  Setting this away from :NEAREST is liable to upset SBCL's\n   maths routines which depend on it.\n\n:CURRENT-EXCEPTIONS\n:ACCRUED-EXCEPTIONS\n   These arguments allow setting of the exception flags. The main\n   use is setting the accrued exceptions to NIL to clear them.\n\n:FAST-MODE\n   Set the hardware's \"fast mode\" flag, if any. When set, IEEE\n   conformance or debuggability may be impaired. Some machines don't\n   have this feature, and some SBCL ports don't implement it anyway\n   -- in such cases the value is always NIL.\n\n:PRECISION (x86 only)\n  :24-bit, :53-bit and :64-bit, for the internal precision of the mantissa.\n\nGET-FLOATING-POINT-MODES may be used to find the floating point modes\ncurrently in effect. SAVE-LISP-AND-DIE preserves the floating point modes\nin effect.").
doc_string('set-fun-name', 'sb-pcl', function, "Set the name of a compiled function object. Return the function.").
doc_string('set-keymap', readline, function, "Set keymap as current").
doc_string('set-macro-character', 'common-lisp', function, "Causes CHAR to be a macro character which invokes FUNCTION when seen\n   by the reader. The NON-TERMINATINGP flag can be used to make the macro\n   character non-terminating, i.e. embeddable in a symbol name.").
doc_string('set-macro-character', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR FUNCTION &OPTIONAL (NON-TERMINATING-P NIL) (READTABLE *READTABLE*))\n\nRegisters CHAR as a macro character in READTABLE and makes FUNCTION the read\nmacro associated with CHAR.  When the WAM-CL reader reads an object that begins\nwith CHAR, it calls FUNCTION with the input stream and CHAR as arguments.  If\nFUNCTION returns a single value, it is returned as the value of the reader.\nIf FUNCTION returns no value, then the reader tries to read an object again.\nNON-TERMINATING-P specifies whether CHAR is non-terminating or not (see\nREADTABLE).\nUse GET-MACRO-CHARACTER to get the read macro associated with a character.\n").
doc_string('set-mutex-value', 'sb-thread', function, "The function SB-THREAD::SET-MUTEX-VALUE has been deprecated as of SBCL version 1.2.15.").
doc_string('set-sbcl-source-location', pkg_sys, function, "Initialize the SYS logical host based on PATHNAME, which should be\nthe top-level directory of the SBCL sources. This will replace any\nexisting translations for \"SYS:SRC;\", \"SYS:CONTRIB;\", and\n\"SYS:OUTPUT;\". Other \"SYS:\" translations are preserved.").
doc_string('set-syntax-from-char', 'common-lisp', function, "Causes the syntax of TO-CHAR to be the same as FROM-CHAR in the optional\nreadtable (defaults to the current readtable). The FROM-TABLE defaults to the\nstandard Lisp readtable when NIL.").
doc_string('set-syntax-from-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (TO-CHAR FROM-CHAR &OPTIONAL (TO-READTABLE *READTABLE*) (FROM-READTABLE NIL))\n\nReplaces the information for TO-CHAR in TO-READTABLE with the information for\nFROM-CHAR in FROM-READTABLE.  If FROM-READTABLE is NIL, then the standard\nreadtable is used.  TO-CHAR belongs to the same syntactic class as FROM-CHAR,\nand if FROM-CHAR is a macro character, TO-CHAR inherits the read macro and\nnon-terminating-p flag of FROM-CHAR.  See READTABLE.\n").
doc_string('shadowing-import', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (PACKAGE *PACKAGE*))\n\nRegisters SYMBOL as an internal symbol of PACKAGE.  Does nothing if SYMBOL is\nalready registered in PACKAGE.  If there exists already a symbol in PACKAGE\nwith the same name, then uninterns the symbol first.  SYMBOL shadows external\nsymbols of the same name in those packages that PACKAGE uses.  SYMBOL may be a\nlist of symbols.\n").
doc_string('shadowing-import', 'common-lisp', function, "Import SYMBOLS into package, disregarding any name conflict. If\n  a symbol of the same name is present, then it is uninterned.").
doc_string('sharing-cons', 'sb-disassem', function, "If CAR is eq to the car of OLD-CONS and CDR is eq to the CDR, return\n  OLD-CONS, otherwise return (cons CAR CDR).").
doc_string('sharing-mapcar', 'sb-disassem', function, "A simple (one list arg) mapcar that avoids consing up a new list\n  as long as the results of calling FUN on the elements of LIST are\n  eq to the original.").
doc_string('short-float-epsilon', 'common-lisp', variable, "The smallest postive short-float E that satisfies\n        (not (= (float 1 E) (+ (float 1 E) E)))").
doc_string('short-float-negative-epsilon', 'common-lisp', variable, "The smallest positive short-float E that satisfies\n        (not (= (float 1 E) (- (float 1 E) E)))").
doc_string('short-float-p', 'sb-int', function, "Return true if OBJECT is a SHORT-FLOAT, and NIL otherwise.").
doc_string('short-site-name', 'common-lisp', function, "Args: ()\nReturns, as a string, the location of the machine on which WAM-CL runs.").
doc_string('short-site-name', 'common-lisp', function, "Return a string with the abbreviated site name, or NIL if not known.").
doc_string('shrink-vector', si, function, "Shrinks a vector.").
doc_string('signal-cold-init-or-reinit', 'sb-kernel', function, "Enable all the default signals that Lisp knows how to deal with.").
doc_string('signal-deadline', 'sb-sys', function, "Signal a DEADLINE-TIMEOUT condition, and associate a DEFER-DEADLINE\nrestart with it. Implementors of blocking functions are responsible\nfor calling this when a deadline is reached.").
doc_string('signal-semaphore', 'sb-thread', function, "Increment the count of SEMAPHORE by N. If there are threads waiting\non this semaphore, then N of them is woken up.").
doc_string('signal-timeout', 'sb-impl', function, "Signals a timeout condition while inhibiting further timeouts due to\ndeadlines while the condition is being handled.").
doc_string('signed-byte-64-p', 'sb-kernel', function, "Return true if OBJECT is a SIGNED-BYTE-64, and NIL otherwise.").
doc_string('simd-pack-p', pkg_sys, function, "Return true if OBJECT is a SIMD-PACK, and NIL otherwise.").
doc_string('simple-array-complex-double-float-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT, and NIL otherwise.").
doc_string('simple-array-complex-single-float-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT, and NIL otherwise.").
doc_string('simple-array-double-float-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-DOUBLE-FLOAT, and NIL otherwise.").
doc_string('simple-array-fixnum-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-FIXNUM, and NIL otherwise.").
doc_string('simple-array-nil-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-NIL, and NIL otherwise.").
doc_string('simple-array-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY, and NIL otherwise.").
doc_string('simple-array-signed-byte-16-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-SIGNED-BYTE-16, and NIL otherwise.").
doc_string('simple-array-signed-byte-32-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-SIGNED-BYTE-32, and NIL otherwise.").
doc_string('simple-array-signed-byte-64-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-SIGNED-BYTE-64, and NIL otherwise.").
doc_string('simple-array-signed-byte-8-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-SIGNED-BYTE-8, and NIL otherwise.").
doc_string('simple-array-single-float-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-SINGLE-FLOAT, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-15-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-15, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-16-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-16, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-2-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-2, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-31-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-31, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-32-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-32, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-4-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-4, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-63-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-63, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-64-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-64, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-7-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-7, and NIL otherwise.").
doc_string('simple-array-unsigned-byte-8-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-BYTE-8, and NIL otherwise.").
doc_string('simple-array-unsigned-fixnum-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-ARRAY-UNSIGNED-FIXNUM, and NIL otherwise.").
doc_string('simple-base-string-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-BASE-STRING, and NIL otherwise.").
doc_string('simple-bit-vector-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a simple-bit-vector; NIL otherwise.\n").
doc_string('simple-bit-vector-p', 'common-lisp', function, "Return true if OBJECT is a SIMPLE-BIT-VECTOR, and NIL otherwise.").
doc_string('simple-character-string-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-CHARACTER-STRING, and NIL otherwise.").
doc_string('simple-condition-format-arguments', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('simple-condition-format-control', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('simple-rank-1-array-*-p', 'sb-kernel', function, "Return true if OBJECT is a SIMPLE-RANK-1-ARRAY-*, and NIL otherwise.").
doc_string('simple-string-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a simple-string; NIL otherwise.\n").
doc_string('simple-string-p', 'common-lisp', function, "Return true if OBJECT is a SIMPLE-STRING, and NIL otherwise.").
doc_string('simple-vector-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a simple-vector; NIL otherwise.\n").
doc_string('simple-vector-p', 'common-lisp', function, "Return true if OBJECT is a SIMPLE-VECTOR, and NIL otherwise.").
doc_string('single-float-epsilon', 'common-lisp', variable, "The smallest postive single-float E that satisfies\n        (not (= (float 1 E) (+ (float 1 E) E)))").
doc_string('single-float-negative-epsilon', 'common-lisp', variable, "The smallest positive single-float E that satisfies\n        (not (= (float 1 E) (- (float 1 E) E)))").
doc_string('single-float-p', 'sb-int', function, "Return true if OBJECT is a SINGLE-FLOAT, and NIL otherwise.").
doc_string('sl-boundp', si, function, "Function in SI package:\nArgs: (OBJECT)\n\nECL/CLOS specific.\nReturns nil if the OBJECT is not null.\n").
doc_string('sl-makunbound', si, function, "Function in SI package:\nArgs: (INSTANCE INDEX)\n\nECL/CLOS specific.\nRemoves the value associated with the INDEX-th slot of INSTANCE.\n").
doc_string('slot-index', clos, function, "Function in COMMON-LISP package:\nArgs: (KEY HASH-TABLE &OPTIONAL (DEFAULT NIL))\n\nSearches HASH-TABLE for the entry of KEY.  If found, returns the value of the\nentry and T, as two values.  If not, returns DEFAULT and NIL.\n").
doc_string('slotd-initialization-error-initarg', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('slotd-initialization-error-kind', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('slotd-initialization-error-value', 'sb-pcl', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('soft-dotted-p', 'sb-unicode', function, "Returns T if CHARACTER has a soft dot (such as the dots on i and j) which\ndisappears when accents are placed on top of it. and NIL otherwise").
doc_string('software-type', 'common-lisp', function, "Args: ()\nReturns, as a string, the type of the software under which WAM-CL runs.").
doc_string('software-type', 'common-lisp', function, "Return a string describing the supporting software.").
doc_string('software-version', 'common-lisp', function, "Args: ()\nReturns, as a string, the version of the software under which WAM-CL runs.").
doc_string('software-version', 'common-lisp', function, "Return a string describing version of the supporting software, or NIL\n  if not available.").
doc_string('source-pathname', extensions, function, "Returns either the pathname corresponding to the file from which this symbol was compiled,or the keyword :TOP-LEVEL.").
doc_string('special-operator-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns T if SYMBOL names a special form; NIL otherwise.\nThe special forms defined in Common Lisp are:\n        block           if                      progv\n        catch           labels                  quote\n        compiler-let    let                     return-from\n        declare         let*                    setq\n        eval-when       macrolet                tagbody\n        flet            multiple-value-call     the\n        function        multiple-value-prog1    throw\n        go              progn                   unwind-protect\nIn addition, WAM-CL implements the following macros as special forms, though of\ncourse macro-expanding functions such as MACROEXPAND work correctly for these\nmacros.\n        and             incf                    prog1\n        case            locally                 prog2\n        cond            loop                    psetq\n        decf            multiple-value-bind     push\n        defmacro        multiple-value-list     return\n        defun           multiple-value-set      setf\n        do              or                      unless\n        do*             pop                     when\n        dolist          prog\n        dotimes         prog*\n").
doc_string('special-operator-p', 'common-lisp', function, "If the symbol globally names a special form, return T, otherwise NIL.").
doc_string('spin-loop-hint', pkg_sys, function, "Hints the processor that the current thread is spin-looping.").
doc_string('spinlock-name', 'sb-thread', function, "The function SB-THREAD::SPINLOCK-NAME has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:MUTEX-NAME instead.").
doc_string('spinlock-value', 'sb-thread', function, "The function SB-THREAD::SPINLOCK-VALUE has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:MUTEX-OWNER instead.").
doc_string('splice-fun-args', 'sb-c', function, "If LVAR is a call to FUN with NUM-ARGS args, change those arguments to feed\ndirectly to the LVAR-DEST of LVAR, which must be a combination. If FUN\nis :ANY, the function name is not checked.").
doc_string('stable-sort', 'common-lisp', function, "Args: (sequence test &key key)\nDestructively sorts SEQUENCE and returns the result.  TEST should return non-\nNIL if its first argument is to precede its second argument.  For two elements\nX and Y, if both\n        (FUNCALL TEST X Y)\n        (FUNCALL TEST Y X)\nevaluates to NIL, then the order of X and Y are the same as in the original\nSEQUENCE.  See SORT.").
doc_string('stable-sort', 'common-lisp', function, "Destructively sort SEQUENCE. PREDICATE should return non-NIL if\n   ARG1 is to precede ARG2.").
doc_string('stack-allocated-p', 'sb-debug', function, "Returns T if OBJ is allocated on the stack of the current\nthread, NIL otherwise.").
doc_string('standard-char-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is a standard-char; NIL otherwise.\n").
doc_string('standard-char-p', 'common-lisp', function, "The argument must be a character object. STANDARD-CHAR-P returns T if the\nargument is a standard character -- one of the 95 ASCII printing characters or\n<return>.").
doc_string('standard-pprint-dispatch-table-modified-operation', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('standard-readtable-modified-operation', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('state-callback', readline, variable, "using the callback interface").
doc_string('state-completing', readline, variable, "doing completion").
doc_string('state-dispatching', readline, variable, "dispatching to a command").
doc_string('state-done', readline, variable, "done; accepted line").
doc_string('state-initialized', readline, variable, "initialization done").
doc_string('state-initializing', readline, variable, "initializing").
doc_string('state-inputpending', readline, variable, "rl_execute_next called").
doc_string('state-isearch', readline, variable, "doing incremental search").
doc_string('state-macrodef', readline, variable, "defining keyboard macro").
doc_string('state-macroinput', readline, variable, "getting input from a macro").
doc_string('state-metanext', readline, variable, "reading input after ESC").
doc_string('state-moreinput', readline, variable, "reading more input in a command function").
doc_string('state-multikey', readline, variable, "reading multiple-key command").
doc_string('state-none', readline, variable, "no state; before first call").
doc_string('state-nsearch', readline, variable, "doing non-inc search").
doc_string('state-numericarg', readline, variable, "reading numeric argument").
doc_string('state-overwrite', readline, variable, "overwrite mode").
doc_string('state-readcmd', readline, variable, "reading a command key").
doc_string('state-search', readline, variable, "doing a history search").
doc_string('state-sighandler', readline, variable, "in readline sighandler").
doc_string('state-termprepped', readline, variable, "terminal is prepped").
doc_string('state-ttycsaved', readline, variable, "tty special chars saved").
doc_string('state-undoing', readline, variable, "doing an undo").
doc_string('state-vicmdonce', readline, variable, "entered vi command mode at least once").
doc_string('state-vimotion', readline, variable, "reading vi motion arg").
doc_string('step-condition-args', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('step-condition-form', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('step-condition-result', pkg_sys, function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('step-continue', pkg_sys, function, "Transfers control to the STEP-CONTINUE restart associated with\nthe condition, continuing execution without stepping. Signals a\nCONTROL-ERROR if the restart does not exist.").
doc_string('step-into', pkg_sys, function, "Transfers control to the STEP-INTO restart associated with the\ncondition, stepping into the current form. Signals a CONTROL-ERROR is\nthe restart does not exist.").
doc_string('step-next', pkg_sys, function, "Transfers control to the STEP-NEXT restart associated with the\ncondition, executing the current form without stepping and continuing\nstepping with the next form. Signals CONTROL-ERROR is the restart does\nnot exists.").
doc_string('store-value', 'common-lisp', function, "Transfer control and VALUE to a restart named STORE-VALUE, or\nreturn NIL if none exists.").
doc_string('stream-advance-to-column', 'sb-gray', function, "Write enough blank space so that the next character will be\n  written at the specified column. Returns true if the operation is\n  successful, or NIL if it is not supported for this stream. This is\n  intended for use by by PPRINT and FORMAT ~T. The default method uses\n  STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a\n  #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL.").
doc_string('stream-advance-to-column', gray, function, "Write enough blank space so that the next character will be\n  written at the specified column. Returns true if the operation is\n  successful, or NIL if it is not supported for this stream. This is\n  intended for use by by PPRINT and FORMAT ~T. The default method uses\n  STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a\n  #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL.").
doc_string('stream-associated-with-file-p', 'sb-impl', function, "Test for the ANSI concept \"stream associated with a file\".").
doc_string('stream-clear-input', 'sb-gray', function, "This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL.\n  The default method does nothing.").
doc_string('stream-clear-input', gray, function, "This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL.\n  The default method does nothing.").
doc_string('stream-clear-output', 'sb-gray', function, "This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given\n  output STREAM. The default method does nothing.").
doc_string('stream-clear-output', gray, function, "This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given\n  output STREAM. The default method does nothing.").
doc_string('stream-element-type', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM)\n\nReturns the type specifier for the io unit of STREAM.\n").
doc_string('stream-element-type', 'common-lisp', function, "Return a type specifier for the kind of object returned by the\n  STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method\n  which returns CHARACTER.").
doc_string('stream-element-type', gray, function, "Return a type specifier for the kind of object returned by the\n  STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method\n  which returns CHARACTER.").
doc_string('stream-error-stream', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('stream-external-format', 'common-lisp', function, "Returns the external format of STREAM.").
doc_string('stream-file-descriptor', gray, function, "Return the file-descriptor underlaying STREAM, or NIL if not\n   available. DIRECTION must be either :INPUT, or :OUTPUT and is\n   supposed to discriminate in case STREAM is a bidirectional\n   stream. DIRECTION is supposed to default to :INPUT.\n\n   An error is signaled if DIRECTION is :INPUT (:OUTPUT), and STREAM\n   is not an input (output) stream. A system-provided :BEFORE method\n   handles this case; user methods do not need to take care of it.\n\n   In case STREAM-FILE-DESCRIPTOR is not implemented for STREAM, an\n   error is signaled. That is, users must add methods to explicitly\n   decline by returning NIL.").
doc_string('stream-file-position', 'sb-gray', function, "Used by FILE-POSITION. Returns or changes the current position within STREAM.").
doc_string('stream-file-position', gray, function, "This is like CL:FILE-POSITION, but for Gray streams.").
doc_string('stream-finish-output', 'sb-gray', function, "Attempts to ensure that all output sent to the Stream has reached\n  its destination, and only then returns false. Implements\n  FINISH-OUTPUT. The default method does nothing.").
doc_string('stream-finish-output', gray, function, "Attempts to ensure that all output sent to the Stream has reached\n  its destination, and only then returns false. Implements\n  FINISH-OUTPUT. The default method does nothing.").
doc_string('stream-force-output', 'sb-gray', function, "Attempts to force any buffered output to be sent. Implements\n  FORCE-OUTPUT. The default method does nothing.").
doc_string('stream-force-output', gray, function, "Attempts to force any buffered output to be sent. Implements\n  FORCE-OUTPUT. The default method does nothing.").
doc_string('stream-fresh-line', 'sb-gray', function, "Outputs a new line to the Stream if it is not positioned at the\n  beginning of a line. Returns T if it output a new line, nil\n  otherwise. Used by FRESH-LINE. The default method uses\n  STREAM-START-LINE-P and STREAM-TERPRI.").
doc_string('stream-fresh-line', gray, function, "Outputs a new line to the Stream if it is not positioned at the\n  beginning of a line. Returns T if it output a new line, nil\n  otherwise. Used by FRESH-LINE. The default method uses\n  STREAM-START-LINE-P and STREAM-TERPRI.").
doc_string('stream-interactive-p', gray, function, "Is stream interactive (For instance, a tty)?").
doc_string('stream-line-column', 'sb-gray', function, "Return the column number where the next character\n  will be written, or NIL if that is not meaningful for this stream.\n  The first column on a line is numbered 0. This function is used in\n  the implementation of PPRINT and the FORMAT ~T directive. For every\n  character output stream class that is defined, a method must be\n  defined for this function, although it is permissible for it to\n  always return NIL.").
doc_string('stream-line-column', gray, function, "Return the column number where the next character\n  will be written, or NIL if that is not meaningful for this stream.\n  The first column on a line is numbered 0. This function is used in\n  the implementation of PPRINT and the FORMAT ~T directive. For every\n  character output stream class that is defined, a method must be\n  defined for this function, although it is permissible for it to\n  always return NIL.").
doc_string('stream-line-length', 'sb-gray', function, "Return the stream line length or NIL.").
doc_string('stream-listen', 'sb-gray', function, "This is used by LISTEN. It returns true or false. The default method uses\n  STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should\n  define their own method since it will usually be trivial and will\n  always be more efficient than the default method.").
doc_string('stream-p', gray, function, "Is this object a STREAM?").
doc_string('stream-peek-char', 'sb-gray', function, "This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL.\n  It returns either a character or :EOF. The default method calls\n  STREAM-READ-CHAR and STREAM-UNREAD-CHAR.").
doc_string('stream-peek-char', gray, function, "This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL.\n  It returns either a character or :EOF. The default method calls\n  STREAM-READ-CHAR and STREAM-UNREAD-CHAR.").
doc_string('stream-read-byte', 'sb-gray', function, "Used by READ-BYTE; returns either an integer, or the symbol :EOF\n  if the stream is at end-of-file.").
doc_string('stream-read-byte', gray, function, "Used by READ-BYTE; returns either an integer, or the symbol :EOF\n  if the stream is at end-of-file.").
doc_string('stream-read-char', 'sb-gray', function, "Read one character from the stream. Return either a\n  character object, or the symbol :EOF if the stream is at end-of-file.\n  Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a\n  method for this function.").
doc_string('stream-read-char', gray, function, "Read one character from the stream. Return either a\n  character object, or the symbol :EOF if the stream is at end-of-file.\n  Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a\n  method for this function.").
doc_string('stream-read-char-no-hang', 'sb-gray', function, "This is used to implement READ-CHAR-NO-HANG. It returns either a\n  character, or NIL if no input is currently available, or :EOF if\n  end-of-file is reached. The default method provided by\n  FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this\n  is sufficient for file streams, but interactive streams should define\n  their own method.").
doc_string('stream-read-char-no-hang', gray, function, "This is used to implement READ-CHAR-NO-HANG. It returns either a\n  character, or NIL if no input is currently available, or :EOF if\n  end-of-file is reached. The default method provided by\n  FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this\n  is sufficient for file streams, but interactive streams should define\n  their own method.").
doc_string('stream-read-line', 'sb-gray', function, "This is used by READ-LINE. A string is returned as the first value. The\n  second value is true if the string was terminated by end-of-file\n  instead of the end of a line. The default method uses repeated\n  calls to STREAM-READ-CHAR.").
doc_string('stream-read-line', gray, function, "This is used by READ-LINE. A string is returned as the first value. The\n  second value is true if the string was terminated by end-of-file\n  instead of the end of a line. The default method uses repeated\n  calls to STREAM-READ-CHAR.").
doc_string('stream-read-sequence', 'sb-gray', function, "This is like CL:READ-SEQUENCE, but for Gray streams.").
doc_string('stream-read-sequence', gray, function, "This is like CL:READ-SEQUENCE, but for Gray streams.").
doc_string('stream-start-line-p', 'sb-gray', function, "Is STREAM known to be positioned at the beginning of a line?\n  It is permissible for an implementation to always return\n  NIL. This is used in the implementation of FRESH-LINE. Note that\n  while a value of 0 from STREAM-LINE-COLUMN also indicates the\n  beginning of a line, there are cases where STREAM-START-LINE-P can be\n  meaningfully implemented although STREAM-LINE-COLUMN can't be. For\n  example, for a window using variable-width characters, the column\n  number isn't very meaningful, but the beginning of the line does have\n  a clear meaning. The default method for STREAM-START-LINE-P on class\n  FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if\n  that is defined to return NIL, then a method should be provided for\n  either STREAM-START-LINE-P or STREAM-FRESH-LINE.").
doc_string('stream-start-line-p', gray, function, "Is STREAM known to be positioned at the beginning of a line?\n  It is permissible for an implementation to always return\n  NIL. This is used in the implementation of FRESH-LINE. Note that\n  while a value of 0 from STREAM-LINE-COLUMN also indicates the\n  beginning of a line, there are cases where STREAM-START-LINE-P can be\n  meaningfully implemented although STREAM-LINE-COLUMN can't be. For\n  example, for a window using variable-width characters, the column\n  number isn't very meaningful, but the beginning of the line does have\n  a clear meaning. The default method for STREAM-START-LINE-P on class\n  FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if\n  that is defined to return NIL, then a method should be provided for\n  either STREAM-START-LINE-P or STREAM-FRESH-LINE.").
doc_string('stream-start-s-expression', system, function, "Return the new binding for *PRINT-RIGHT-MARGIN*.").
doc_string('stream-terpri', 'sb-gray', function, "Writes an end of line, as for TERPRI. Returns NIL. The default\n  method does (STREAM-WRITE-CHAR stream #NEWLINE).").
doc_string('stream-terpri', gray, function, "Writes an end of line, as for TERPRI. Returns NIL. The default\n  method does (STREAM-WRITE-CHAR stream #NEWLINE).").
doc_string('stream-unread-char', 'sb-gray', function, "Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR.\n  Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM\n  must define a method for this function.").
doc_string('stream-unread-char', gray, function, "Un-do the last call to STREAM-READ-CHAR, as in UNREAD-CHAR.\n  Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM\n  must define a method for this function.").
doc_string('stream-write-byte', 'sb-gray', function, "Implements WRITE-BYTE; writes the integer to the stream and\n  returns the integer as the result.").
doc_string('stream-write-byte', gray, function, "Implements WRITE-BYTE; writes the integer to the stream and\n  returns the integer as the result.").
doc_string('stream-write-char', 'sb-gray', function, "Write CHARACTER to STREAM and return CHARACTER. Every\n  subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method\n  defined for this function.").
doc_string('stream-write-char', gray, function, "Write CHARACTER to STREAM and return CHARACTER. Every\n  subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method\n  defined for this function.").
doc_string('stream-write-sequence', 'sb-gray', function, "This is like CL:WRITE-SEQUENCE, but for Gray streams.").
doc_string('stream-write-sequence', gray, function, "This is like CL:WRITE-SEQUENCE, but for Gray streams.").
doc_string('stream-write-string', 'sb-gray', function, "This is used by WRITE-STRING. It writes the string to the stream,\n  optionally delimited by start and end, which default to 0 and NIL.\n  The string argument is returned. The default method provided by\n  FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to\n  STREAM-WRITE-CHAR.").
doc_string('stream-write-string', gray, function, "This is used by WRITE-STRING. It writes the string to the stream,\n  optionally delimited by start and end, which default to 0 and NIL.\n  The string argument is returned. The default method provided by\n  FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to\n  STREAM-WRITE-CHAR.").
doc_string('string-capitalize', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)))\n\nReturns a copy of STRING with the first character of each word converted to\nupper case, and remaining characters converted to lower case.  Its destructive\nversion is NSTRING-CAPITALIZE.\n").
doc_string('string-downcase', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)))\n\nReturns a copy of STRING with all upper case characters converted to lower\ncase.  Its destructive version is NSTRING-DOWNCASE.\n").
doc_string('string-equal', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nReturns T if STRING1 and STRING2 are character-wise CHAR-EQUAL; NIL otherwise.\n").
doc_string('string-equal', 'common-lisp', function, "Given two strings (string1 and string2), and optional integers start1,\n  start2, end1 and end2, compares characters in string1 to characters in\n  string2 (using char-equal).").
doc_string('string-greaterp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nSimilar to STRING>, but ignores cases.\n").
doc_string('string-greaterp', 'common-lisp', function, "Given two strings, if the first string is lexicographically greater than\n  the second string, returns the longest common prefix (using char-equal)\n  of the two strings. Otherwise, returns ().").
doc_string('string-left-trim', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR-BAG STRING)\n\nReturns a copy of STRING with the specified characters removed from the left\nend.  CHAR-SPEC must be a sequence of characters.\n").
doc_string('string-left-trim', 'common-lisp', function, "Given a set of characters (a list or string) and a string, returns\r\n   a copy of the string with the characters in the set removed from the\r\n   left end.").
doc_string('string-lessp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nSimilar to STRING<, but ignores cases.\n").
doc_string('string-lessp', 'common-lisp', function, "Given two strings, if the first string is lexicographically less than\n  the second string, returns the longest common prefix (using char-equal)\n  of the two strings. Otherwise, returns ().").
doc_string('string-not-equal', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nReturns NIL if the strings are character-wise CHAR-EQUAL.  Otherwise, returns\nthe number of characters in the longest common prefix of the strings.\n").
doc_string('string-not-equal', 'common-lisp', function, "Given two strings, if the first string is not lexicographically equal\n  to the second string, returns the longest common prefix (using char-equal)\n  of the two strings. Otherwise, returns ().").
doc_string('string-not-greaterp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nSimilar to STRING<=, but ignores cases.\n").
doc_string('string-not-greaterp', 'common-lisp', function, "Given two strings, if the first string is lexicographically less than\n  or equal to the second string, returns the longest common prefix\n  (using char-equal) of the two strings. Otherwise, returns ().").
doc_string('string-not-lessp', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nSimilar to STRING>=, but ignores cases.\n").
doc_string('string-not-lessp', 'common-lisp', function, "Given two strings, if the first string is lexicographically greater\n  than or equal to the second string, returns the longest common prefix\n  (using char-equal) of the two strings. Otherwise, returns ().").
doc_string('string-right-trim', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR-BAG STRING)\n\nReturns a copy of STRING with the specified characters removed from the right\nend.  CHAR-SPEC must be a sequence of characters.\n").
doc_string('string-right-trim', 'common-lisp', function, "Given a set of characters (a list or string) and a string, returns\r\n   a copy of the string with the characters in the set removed from the\r\n   right end.").
doc_string('string-to-object', si, function, "Function in SI package:\nArgs: (STRING)\n\nECL specific.\nEquivalent to (READ-FROM-STRING STRING), but is much faster.\n").
doc_string('string-trim', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR-SPEC STRING)\n\nReturns a copy of STRING with the specified characters removed from both ends.\nCHAR-SPEC must be a sequence of characters.\n").
doc_string('string-trim', 'common-lisp', function, "Given a set of characters (a list or string) and a string, returns a\r\n   copy of the string with the characters in the set removed from both\r\n   ends.").
doc_string('string-upcase', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &KEY (START 0) (END (LENGTH STRING)))\n\nReturns a copy of STRING with all lower case characters converted to upper\ncases.  Its destructive version is NSTRING-UPCASE.\n").
doc_string('string/=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nReturns NIL if the strings are character-wise CHAR=.  Otherwise, returns the\nnumber of characters in the longest common prefix of the strings.\n").
doc_string('string/=', 'common-lisp', function, "Given two strings, if the first string is not lexicographically equal\n  to the second string, returns the longest common prefix (using char=)\n  of the two strings. Otherwise, returns ().").
doc_string('string<', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nIf STRING1 comes before STRING2 in lexicographic order, then returns the\nnumber of characters in the longest common prefix of the strings.  Otherwise,\nreturns NIL.\n").
doc_string('string<', 'common-lisp', function, "Given two strings, if the first string is lexicographically less than\n  the second string, returns the longest common prefix (using char=)\n  of the two strings. Otherwise, returns ().").
doc_string('string<=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nIf STRING1 comes before STRING2 in lexicographic order or if the strings are\ncharacter-wise CHAR=, then returns the number of characters in the longest\ncommon prefix of the strings.  Otherwise, returns NIL.\n").
doc_string('string<=', 'common-lisp', function, "Given two strings, if the first string is lexicographically less than\n  or equal to the second string, returns the longest common prefix\n  (using char=) of the two strings. Otherwise, returns ().").
doc_string('string=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nReturns T if STRING1 and STRING2 are character-wise CHAR=; NIL otherwise.\n").
doc_string('string=', 'common-lisp', function, "Given two strings (string1 and string2), and optional integers start1,\n  start2, end1 and end2, compares characters in string1 to characters in\n  string2 (using char=).").
doc_string('string>', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nIf STRING1 comes after STRING2 in lexicographic order or if the strings are\ncharacter-wise CHAR=, then returns the number of characters in the longest\ncommon prefix of the strings.  Otherwise, returns NIL.\n").
doc_string('string>', 'common-lisp', function, "Given two strings, if the first string is lexicographically greater than\n  the second string, returns the longest common prefix (using char=)\n  of the two strings. Otherwise, returns ().").
doc_string('string>=', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING1 STRING2 &KEY (START1 0) (END1 (LENGTH STRING1)) (START2 0) (END2 (LENGTH STRING2)))\n\nIf STRING1 comes after STRING2 in lexicographic order or if the strings are\ncharacter-wise CHAR=, then returns the number of characters in the longest\ncommon prefix of the strings.  Otherwise, returns NIL.\n").
doc_string('string>=', 'common-lisp', function, "Given two strings, if the first string is lexicographically greater\n  than or equal to the second string, returns the longest common prefix\n  (using char=) of the two strings. Otherwise, returns ().").
doc_string('subst-if', 'common-lisp', function, "Substitutes new for subtrees for which test is true.").
doc_string('subst-if', 'common-lisp', function, "Substitutes NEW for subtrees of TREE that satisfy TEST and returns the result.\nThe original TREE is not destroyed.").
doc_string('subst-if-not', 'common-lisp', function, "Substitutes new for subtrees for which test is false.").
doc_string('subst-if-not', 'common-lisp', function, "Substitutes NEW for subtrees of TREE that do not satisfy TEST and returns the\nresult.  The original TREE is not destroyed.").
doc_string('substitute-if', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nReturns a copy of SEQUENCE with all elements that satisfy TEST replaced by\nNEW.  The original SEQUENCE is not destroyed.\n").
doc_string('substitute-if', 'common-lisp', function, "Return a sequence of the same kind as SEQUENCE with the same elements\n  except that all elements satisfying the PRED are replaced with NEW.").
doc_string('substitute-if-not', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW TEST SEQUENCE &KEY (KEY '#'IDENTITY) (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nReturns a copy of SEQUENCE with all elements that do not satisfy TEST replaced\nby NEW.  The original SEQUENCE is not destroyed.\n").
doc_string('substitute-if-not', 'common-lisp', function, "Return a sequence of the same kind as SEQUENCE with the same elements\n  except that all elements not satisfying the PRED are replaced with NEW.").
doc_string('symbol-function', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns the global function definition named SYMBOL.\n").
doc_string('symbol-function', 'common-lisp', function, "Return SYMBOL's current function definition. Settable with SETF.").
doc_string('symbol-global-value', pkg_sys, function, "Return the SYMBOL's current global value. Identical to SYMBOL-VALUE,\nin single-threaded builds: in multithreaded builds bound values are\ndistinct from the global value. Can also be SETF.").
doc_string('symbol-macrolet', 'common-lisp', function, "SYMBOL-MACROLET ({(name expansion)}*) decl* form*\n\nDefine the NAMES as symbol macros with the given EXPANSIONS. Within the\nbody, references to a NAME will effectively be replaced with the EXPANSION.").
doc_string('symbol-name', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns the print name of SYMBOL.\n").
doc_string('symbol-name', 'common-lisp', function, "Return SYMBOL's name as a string.").
doc_string('symbol-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns the home package of SYMBOL.  Returns NIL if SYMBOL is not interned.\n").
doc_string('symbol-package', 'common-lisp', function, "Return the package SYMBOL was interned in, or NIL if none.").
doc_string('symbol-plist', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns the property list of SYMBOL.\n").
doc_string('symbol-plist', 'common-lisp', function, "Return SYMBOL's property list.").
doc_string('symbol-value', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns the value of the global variable named SYMBOL.\n").
doc_string('symbol-value', 'common-lisp', function, "Return SYMBOL's current bound value.").
doc_string('symbol-value-in-thread', 'sb-thread', function, "Return the local value of SYMBOL in THREAD, and a secondary value of T\non success.\n\nIf the value cannot be retrieved (because the thread has exited or because it\nhas no local binding for NAME) and ERRORP is true signals an error of type\nSYMBOL-VALUE-IN-THREAD-ERROR; if ERRORP is false returns a primary value of\nNIL, and a secondary value of NIL.\n\nCan also be used with SETF to change the thread-local value of SYMBOL.\n\nSYMBOL-VALUE-IN-THREAD is primarily intended as a debugging tool, and not as a\nmechanism for inter-thread communication.").
doc_string('symbol-value-in-thread-error-info', 'sb-thread', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('system-area-pointer-p', 'sb-sys', function, "Return true if OBJECT is a SYSTEM-AREA-POINTER, and NIL otherwise.").
doc_string('system-condition-address', 'sb-sys', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('system-condition-context', 'sb-sys', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('terminate-session', 'sb-thread', function, "Kill all threads in session except for this one.  Does nothing if current\nthread is not the foreground thread.").
doc_string('terminate-thread', 'sb-thread', function, "Terminate the thread identified by THREAD, by interrupting it and\ncausing it to call SB-EXT:ABORT-THREAD with :ALLOW-EXIT T.\n\nThe unwind caused by TERMINATE-THREAD is asynchronous, meaning that\neg. thread executing\n\n  (let (foo)\n     (unwind-protect\n         (progn\n            (setf foo (get-foo))\n            (work-on-foo foo))\n       (when foo\n         ;; An interrupt occurring inside the cleanup clause\n         ;; will cause cleanups from the current UNWIND-PROTECT\n         ;; to be dropped.\n         (release-foo foo))))\n\nmight miss calling RELEASE-FOO despite GET-FOO having returned true if\nthe interrupt occurs inside the cleanup clause, eg. during execution\nof RELEASE-FOO.\n\nThus, in order to write an asynch unwind safe UNWIND-PROTECT you need\nto use WITHOUT-INTERRUPTS:\n\n  (let (foo)\n    (sb-sys:without-interrupts\n      (unwind-protect\n          (progn\n            (setf foo (sb-sys:allow-with-interrupts\n                        (get-foo)))\n            (sb-sys:with-local-interrupts\n              (work-on-foo foo)))\n       (when foo\n         (release-foo foo)))))\n\nSince most libraries using UNWIND-PROTECT do not do this, you should never\nassume that unknown code can safely be terminated using TERMINATE-THREAD.").
doc_string('thread-alive-p', 'sb-thread', function, "Return T if THREAD is still alive. Note that the return value is\npotentially stale even before the function returns, as the thread may exit at\nany time.").
doc_string('thread-alive-p', threads, function, "Boolean predicate whether THREAD is alive.").
doc_string('thread-deadlock-cycle', 'sb-thread', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('thread-ephemeral-p', 'sb-thread', function, "Return T if THREAD is `ephemeral', which indicates that this thread is\nused by SBCL for internal purposes, and specifically that it knows how to\nto terminate this thread cleanly prior to core file saving without signalling\nan error in that case.").
doc_string('thread-error-thread', 'sb-thread', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('thread-join', threads, function, "Waits for thread to finish.").
doc_string('thread-name', 'sb-thread', function, "Name of the thread. Can be assigned to using SETF. Thread names can be\narbitrary printable objects, and need not be unique.").
doc_string('thread-yield', 'sb-thread', function, "Yield the processor to other threads.").
doc_string('timeout-seconds', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('timer-name', pkg_sys, function, "Return the name of TIMER.").
doc_string('timer-scheduled-p', pkg_sys, function, "See if TIMER will still need to be triggered after DELTA seconds\nfrom now. For timers with a repeat interval it returns true.").
doc_string('top-level', si, function, "Args: ()\nECL specific.\nThe top-level loop of WAM-CL. It is called by default when WAM-CL is invoked.").
doc_string('translate-logical-pathname', 'common-lisp', function, "Translate PATHNAME to a physical pathname, which is returned.").
doc_string('translate-pathname', 'common-lisp', function, "Use the source pathname to translate the from-wildname's wild and\nunspecified elements into a completed to-pathname based on the to-wildname.").
doc_string('tree-equal', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y &KEY (TEST '#'EQL) TEST-NOT)\n\nReturns T if X and Y have the same tree structures and corresponding leaves\nare all the same in the sense of TEST.  Returns NIL otherwise.\n").
doc_string('tree-equal', 'common-lisp', function, "Return T if X and Y are isomorphic trees with identical leaves.").
doc_string('truly-the', pkg_sys, function, "Specifies that the values returned by FORM conform to the\nVALUE-TYPE, and causes the compiler to trust this information\nunconditionally.\n\nConsequences are undefined if any result is not of the declared type\n-- typical symptoms including memory corruptions. Use with great\ncare.").
doc_string('truncate-exponent', 'sb-impl', function, "Truncate exponent if it's too large for a float").
doc_string('try-semaphore', 'sb-thread', function, "Try to decrement the count of SEMAPHORE by N. If the count were to\nbecome negative, punt and return NIL, otherwise return the new count of\nSEMAPHORE.\n\nIf NOTIFICATION is given it must be a semaphore notification object\nwith SEMAPHORE-NOTIFICATION-STATUS of NIL. If the count is decremented,\nthe status is set to T.").
doc_string('type-error-datum', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('type-error-expected-type', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('type-of', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns a type specifier of the type to which X belongs.\n").
doc_string('type-of', 'common-lisp', function, "Return the type of OBJECT.").
doc_string('typexpand-1', pkg_sys, function, "Takes and expands a type specifier once like MACROEXPAND-1.\nReturns two values: the expansion, and a boolean that is true when\nexpansion happened.").
doc_string('typexpand-all', pkg_sys, function, "Takes and expands a type specifier recursively like MACROEXPAND-ALL.").
doc_string('unbound-slot-instance', 'common-lisp', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('undefined-alien-symbol', 'sb-kernel', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('unhandled-debug-condition-condition', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('unicode-1-name', 'sb-unicode', function, "Returns the name assigned to CHARACTER in Unicode 1.0 if it is distinct\nfrom the name currently assigned to CHARACTER. Otherwise, returns NIL.\nThis property has been officially obsoleted by the Unicode standard, and\nis only included for backwards compatibility.").
doc_string('unicode-equal', 'sb-unicode', function, "Determines whether STRING1 and STRING2 are canonically equivalent after\ncasefoldin8 (that is, ignoring case differences) according to Unicode. The\nSTART and END arguments behave like the arguments to STRING=. If :STRICT is\nNIL, UNICODE= tests compatibility equavalence instead.").
doc_string('unicode<', 'sb-unicode', function, "Determines whether STRING1 sorts before STRING2 using the Unicode Collation\nAlgorithm, The function uses an untailored Default Unicode Collation Element Table\nto produce the sort keys. The function uses the Shifted method for dealing\nwith variable-weight characters, as described in UTS #10").
doc_string('unicode<=', 'sb-unicode', function, "Tests if STRING1 and STRING2 are either UNICODE< or UNICODE=").
doc_string('unicode=', 'sb-unicode', function, "Determines whether STRING1 and STRING2 are canonically equivalent according\nto Unicode. The START and END arguments behave like the arguments to STRING=.\nIf :STRICT is NIL, UNICODE= tests compatibility equavalence instead.").
doc_string('unicode>', 'sb-unicode', function, "Tests if STRING2 is UNICODE< STRING1.").
doc_string('unicode>=', 'sb-unicode', function, "Tests if STRING1 and STRING2 are either UNICODE= or UNICODE>").
doc_string('unique-id', si, function, "Generates a unique integer ID for its argument.").
doc_string('universal-error-handler', si, function, "Args: (error-name continuable-p function-name\n       continue-format-string error-format-string\n       &rest args)\nECL specific.\nStarts the error handler of WAM-CL.\nWhen an error is detected, WAM-CL calls this function with the specified\narguments.  To change the error handler of WAM-CL, redefine this function.\nERROR-NAME is the name of the error.  CONTINUABLE-P is T for a continuable\nerror and NIL for a fatal error.  FUNCTION-NAME is the name of the function\nthat caused the error.  CONTINUE-FORMAT-STRING and ERROR-FORMAT-STRING are the\nformat strings of the error message.  ARGS are the arguments to the format\nstrings.").
doc_string('unix-exit', 'sb-unix', function, "The function SB-UNIX:UNIX-EXIT has been deprecated as of SBCL version 1.0.56.55.\n\nUse SB-SYS:OS-EXIT instead.").
doc_string('unix-getitimer', 'sb-unix', function, "UNIX-GETITIMER returns the INTERVAL and VALUE slots of one of\n   three system timers (:real :virtual or :profile). On success,\n   unix-getitimer returns 5 values,\n   T, it-interval-secs, it-interval-usec, it-value-secs, it-value-usec.").
doc_string('unix-lseek', 'sb-unix', function, "Unix-lseek accepts a file descriptor and moves the file pointer by\n   OFFSET octets.  Whence can be any of the following:\n\n   L_SET        Set the file pointer.\n   L_INCR       Increment the file pointer.\n   L_XTND       Extend the file size.\n  ").
doc_string('unix-setitimer', 'sb-unix', function, "UNIX-SETITIMER sets the INTERVAL and VALUE slots of one of\n   three system timers (:real :virtual or :profile). A SIGALRM signal\n   will be delivered VALUE <seconds+microseconds> from now. INTERVAL,\n   when non-zero, is <seconds+microseconds> to be loaded each time\n   the timer expires. Setting INTERVAL and VALUE to zero disables\n   the timer. See the Unix man page for more details. On success,\n   unix-setitimer returns the old contents of the INTERVAL and VALUE\n   slots as in unix-getitimer.").
doc_string('unknown-code-location-code-location', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('unknown-debug-var-debug-fun', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('unknown-debug-var-debug-var', 'sb-di', function, "Return the offending thread that the THREAD-ERROR pertains to.").
doc_string('unload-shared-object', 'sb-alien', function, "Unloads the shared object loaded earlier using the designated PATHNAME with\nLOAD-SHARED-OBJECT, to the degree supported on the platform.\n\nExperimental.").
doc_string('unlock-package', pkg_sys, function, "Unlocks PACKAGE and returns T. Has no effect if PACKAGE was already\nunlocked. Signals an error if PACKAGE is not a valid package designator.").
doc_string('unparse-alien-type', 'sb-alien-internals', function, "Convert the alien-type structure TYPE back into a list specification of\n   the type.").
doc_string('unread-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &OPTIONAL (STREAM *STANDARD-INPUT*))\n\nPuts CHAR back on the front of the input stream STREAM.\n").
doc_string('unschedule-timer', pkg_sys, function, "Cancel TIMER. Once this function returns it is guaranteed that\nTIMER shall not be triggered again and there are no unfinished\ntriggers.").
doc_string('unsigned-byte-64-p', 'sb-kernel', function, "Return true if OBJECT is an UNSIGNED-BYTE-64, and NIL otherwise.").
doc_string('unuse-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE-SPEC &OPTIONAL (PACKAGE *PACKAGE*))\n\nCauses PACKAGE not to use packages specified by PACKAGE-SPEC.  PACKAGE-SPEC\nmay be a package object, a string, a symbol, or a list consisting of package\nobjects, strings, and, symbols.\n").
doc_string('unuse-package', 'common-lisp', function, "Remove PACKAGES-TO-UNUSE from the USE list for PACKAGE.").
doc_string('unwind-protect', 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (FORM &BODY CLEANUP-FORMS)\n\nEvaluates FORM and returns all its values.  Before returning, evaluates\nCLEANUP-FORMs in order, whether FORM returns normally or abnormally by a non-\nlocal exit.\n").
doc_string('unwind-protect', 'common-lisp', function, "UNWIND-PROTECT protected cleanup*\n\nEvaluate the form PROTECTED, returning its values. The CLEANUP forms are\nevaluated whenever the dynamic scope of the PROTECTED form is exited (either\ndue to normal completion or a non-local exit such as THROW).").
doc_string('upgraded-array-element-type', 'common-lisp', function, "Return the element type that will actually be used to implement an array\n   with the specifier :ELEMENT-TYPE Spec.").
doc_string('upgraded-complex-part-type', 'common-lisp', function, "Return the element type of the most specialized COMPLEX number type that\n   can hold parts of type SPEC.").
doc_string('upper-case-p', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is an upper-case character; NIL otherwise.\n").
doc_string('upper-case-p', 'common-lisp', function, "The argument must be a character object; UPPER-CASE-P returns T if the\nargument is an upper-case character, NIL otherwise.").
doc_string('uppercase-p', 'sb-unicode', function, "Returns T if CHARACTER has the Unicode property Uppercase and NIL otherwise").
doc_string('use-package', 'common-lisp', function, "Add all the PACKAGES-TO-USE to the use list for PACKAGE so that the\nexternal symbols of the used packages are accessible as internal symbols in\nPACKAGE.").
doc_string('use-package', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PACKAGE-SPEC &OPTIONAL (PACKAGE *PACKAGE*))\n\nCauses PACKAGE to use packages specified by PACKAGE-SPEC, in addition to those\npackages that PACKAGE already uses.  PACKAGE-SPEC may be a package object, a\nstring, a symbol, or a list consisting of package objects, strings, and\nsymbols.\n").
doc_string('use-value', 'common-lisp', function, "Transfer control and VALUE to a restart named USE-VALUE, or\nreturn NIL if none exists.").
doc_string('user-homedir-pathname', 'common-lisp', function, "Determines the pathname that corresponds to the user's home directory.\r\nThe value returned is obtained from the JVM system propoerty 'user.home'.\r\nIf HOST is specified, returns NIL.").
doc_string('user-homedir-pathname', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL HOST)\n\nReturns a pathname the represents the user's home directory.  HOST is simply\nignored in WAM-CL.\n").
doc_string('user-homedir-pathname', 'common-lisp', function, "Return the home directory of the user as a pathname. If the HOME\nenvironment variable has been specified, the directory it designates\nis returned; otherwise obtains the home directory from the operating\nsystem. HOST argument is ignored by SBCL.").
doc_string('valid-function-name-p', 'sb-int', function, "The primary return value indicates whether NAME is a valid function\nname; if it is, the second return value will be a symbol suitable for\nuse as a BLOCK name in the function in question.").
doc_string('valid-type-specifier-p', pkg_sys, function, "Returns T if TYPE-SPECIFIER is a valid type specifier, otherwise NIL.\n\nThere may be different metrics on what constitutes a \"valid type\nspecifier\" depending on context. If this function does not suit your\nexact need, you may be able to craft a particular solution using a\ncombination of DEFINED-TYPE-NAME-P and the TYPEXPAND functions.\n\nThe definition of \"valid type specifier\" employed by this function\nis based on the following mnemonic:\n\n          \"Would TYPEP accept it as second argument?\"\n\nExcept that unlike TYPEP, this function fully supports compound\nFUNCTION type specifiers, and the VALUES type specifier, too.\n\nIn particular, VALID-TYPE-SPECIFIER-P will return NIL if\nTYPE-SPECIFIER is not a class, not a symbol that is known to name a\ntype specifier, and not a cons that represents a known compound type\nspecifier in a syntactically and recursively correct way.\n\nExamples:\n\n  (valid-type-specifier-p '(cons * *))     => T\n  (valid-type-specifier-p '#:foo)          => NIL\n  (valid-type-specifier-p '(cons * #:foo)) => NIL\n  (valid-type-specifier-p '(cons 1 *)      => NIL\n\nExperimental.").
doc_string('validate-superclass', mop, function, "This generic function is called to determine whether the class\r\n  superclass is suitable for use as a superclass of class.").
doc_string('values-list', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST)\n\nReturns all elements of LIST as multiple values, the N-th element of LIST\nbeing the N-th value.\n").
doc_string('values-list', 'common-lisp', function, "Return all of the elements of LIST, in order, as values.").
doc_string('vector-nil-p', 'sb-kernel', function, "Return true if OBJECT is a VECTOR-NIL, and NIL otherwise.").
doc_string('vector-pop', 'common-lisp', function, "Args: (vector)\nDecrements the fill-pointer of VECTOR by one and returns the element pointed\nto by the new fill-pointer.  Signals an error if the old value of the fill-\npointer is 0 already.").
doc_string('vector-pop', 'common-lisp', function, "Decrease the fill pointer by 1 and return the element pointed to by the\n  new fill pointer.").
doc_string('vector-push', 'common-lisp', function, "Attempt to set the element of ARRAY designated by its fill pointer\n   to NEW-ELEMENT, and increment the fill pointer by one. If the fill pointer is\n   too large, NIL is returned, otherwise the index of the pushed element is\n   returned.").
doc_string('vector-push', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW-ELEMENT VECTOR)\n\nReplaces ITEM for the element of VECTOR that is pointed to by the fill-pointer\nof VECTOR and then increments the fill-pointer by one.  Returns NIL if the new\nvalue of the fill-pointer becomes too large.  Otherwise, returns the new fill-\npointer as the value.\n").
doc_string('vector-push-extend', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW-ELEMENT VECTOR &OPTIONAL (EXTENSION 1))\n\nReplaces ITEM for the element of VECTOR that is pointed to by the fill-pointer\nof VECTOR and then increments the fill-pointer by one.  If the new value of\nthe fill-pointer becomes too large, extends VECTOR for N more elements.\nReturns the new value of the fill-pointer.\n").
doc_string('vop-attributep', 'sb-c', function, "Automagically generated boolean attribute test function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('vop-attributes', 'sb-c', function, "Automagically generated boolean attribute creation function.\n  See !DEF-BOOLEAN-ATTRIBUTE.").
doc_string('wait-for', pkg_sys, function, "Wait until TEST-FORM evaluates to true, then return its primary value.\nIf TIMEOUT is provided, waits at most approximately TIMEOUT seconds before\nreturning NIL.\n\nIf WITH-DEADLINE has been used to provide a global deadline, signals a\nDEADLINE-TIMEOUT if TEST-FORM doesn't evaluate to true before the\ndeadline.\n\nExperimental: subject to change without prior notice.").
doc_string('wait-on-semaphore', 'sb-thread', function, "Decrement the count of SEMAPHORE by N if the count would not be negative.\n\nElse blocks until the semaphore can be decremented. Returns the new count of\nSEMAPHORE on success.\n\nIf TIMEOUT is given, it is the maximum number of seconds to wait. If the count\ncannot be decremented in that time, returns NIL without decrementing the\ncount.\n\nIf NOTIFICATION is given, it must be a SEMAPHORE-NOTIFICATION object whose\nSEMAPHORE-NOTIFICATION-STATUS is NIL. If WAIT-ON-SEMAPHORE succeeds and\ndecrements the count, the status is set to T.").
doc_string('wait-until-fd-usable', 'sb-sys', function, "Wait until FD is usable for DIRECTION. DIRECTION should be either :INPUT or\n:OUTPUT. TIMEOUT, if supplied, is the number of seconds to wait before giving\nup. Returns true once the FD is usable, NIL return indicates timeout.\n\nIf SERVE-EVENTS is true (the default), events on other FDs are served while\nwaiting.").
doc_string('waitqueue-name', 'sb-thread', function, "The name of the waitqueue. Setfable.").
doc_string('weak-pointer-p', pkg_sys, function, "Return true if OBJECT is a WEAK-POINTER, and NIL otherwise.").
doc_string('weak-pointer-value', pkg_sys, function, "If WEAK-POINTER is valid, return the value of WEAK-POINTER and T.\nIf the referent of WEAK-POINTER has been garbage collected,\nreturns the values NIL and NIL.").
doc_string('whitespace-p', 'sb-unicode', function, "Returns T if CHARACTER is whitespace according to Unicode\nand NIL otherwise").
doc_string('wild-pathname-p', 'common-lisp', function, "Predicate for determining whether pathname contains any wildcards.").
doc_string('with-alien', 'sb-alien', function, "Establish some local alien variables. Each BINDING is of the form:\n     VAR TYPE [ ALLOCATION ] [ INITIAL-VALUE | EXTERNAL-NAME ]\n   ALLOCATION should be one of:\n     :LOCAL (the default)\n       The alien is allocated on the stack, and has dynamic extent.\n     :EXTERN\n       No alien is allocated, but VAR is established as a local name for\n       the external alien given by EXTERNAL-NAME.").
doc_string('with-cas-lock', 'sb-thread', function, "Runs BODY with interrupts disabled and *CURRENT-THREAD* compare-and-swapped\ninto PLACE instead of NIL. PLACE must be a place acceptable to\nCOMPARE-AND-SWAP, and must initially hold NIL.\n\nWITH-CAS-LOCK is suitable mostly when the critical section needing protection\nis very small, and cost of allocating a separate lock object would be\nprohibitive. While it is the most lightweight locking constructed offered by\nSBCL, it is also the least scalable if the section is heavily contested or\nlong.\n\nWITH-CAS-LOCK can be entered recursively.").
doc_string('with-collect', sys, function, "\r\nEvaluate forms, collecting objects into lists.\r\nWithin the FORMS, you can use local macros listed among collectors,\r\nthey are returned as multiple values.\r\nE.g., (with-collect (c1 c2) (dotimes (i 10) (if (oddp i) (c1 i) (c2 i))))\r\n ==> (1 3 5 7 9); (0 2 4 6 8) [2 values]\r\nIn CLISP, push/nreverse is about 1.25 times as fast as pushing into the\r\ntail, so this macro uses push/nreverse on CLISP and push into the tail\r\non other lisps (which is 1.5-2 times as fast as push/nreverse there).").
doc_string('with-compilation-unit', 'common-lisp', function, "Affects compilations that take place within its dynamic extent. It is\nintended to be eg. wrapped around the compilation of all files in the same system.\n\nFollowing options are defined:\n\n  :OVERRIDE Boolean-Form\n      One of the effects of this form is to delay undefined warnings until the\n      end of the form, instead of giving them at the end of each compilation.\n      If OVERRIDE is NIL (the default), then the outermost\n      WITH-COMPILATION-UNIT form grabs the undefined warnings. Specifying\n      OVERRIDE true causes that form to grab any enclosed warnings, even if it\n      is enclosed by another WITH-COMPILATION-UNIT.\n\n  :POLICY Optimize-Declaration-Form\n      Provides dynamic scoping for global compiler optimization qualities and\n      restrictions, limiting effects of subsequent OPTIMIZE proclamations and\n      calls to SB-EXT:RESTRICT-COMPILER-POLICY to the dynamic scope of BODY.\n\n      If OVERRIDE is false, specified POLICY is merged with current global\n      policy. If OVERRIDE is true, current global policy, including any\n      restrictions, is discarded in favor of the specified POLICY.\n\n      Supplying POLICY NIL is equivalent to the option not being supplied at\n      all, ie. dynamic scoping of policy does not take place.\n\n      This option is an SBCL-specific experimental extension: Interface\n      subject to change.\n\n  :SOURCE-NAMESTRING Namestring-Form\n      Attaches the value returned by the Namestring-Form to the internal\n      debug-source information as the namestring of the source file. Normally\n      the namestring of the input-file for COMPILE-FILE is used: this option\n      can be used to provide source-file information for functions compiled\n      using COMPILE, or to override the input-file of COMPILE-FILE.\n\n      If both an outer and an inner WITH-COMPILATION-UNIT provide a\n      SOURCE-NAMESTRING, the inner one takes precedence. Unaffected\n      by :OVERRIDE.\n\n      This is an SBCL-specific extension.\n\n  :SOURCE-PLIST Plist-Form\n      Attaches the value returned by the Plist-Form to internal debug-source\n      information of functions compiled in within the dynamic extent of BODY.\n\n      Primarily for use by development environments, in order to eg. associate\n      function definitions with editor-buffers. Can be accessed using\n      SB-INTROSPECT:DEFINITION-SOURCE-PLIST.\n\n      If an outer WITH-COMPILATION-UNIT form also provide a SOURCE-PLIST, it\n      is appended to the end of the provided SOURCE-PLIST. Unaffected\n      by :OVERRIDE.\n\n      This is an SBCL-specific extension.\n\nExamples:\n\n  ;; Prevent proclamations from the file leaking, and restrict\n  ;; SAFETY to 3 -- otherwise uses the current global policy.\n  (with-compilation-unit (:policy '(optimize))\n    (restrict-compiler-policy 'safety 3)\n    (load \"foo.lisp\"))\n\n  ;; Using default policy instead of the current global one,\n  ;; except for DEBUG 3.\n  (with-compilation-unit (:policy '(optimize debug)\n                          :override t)\n    (load \"foo.lisp\"))\n\n  ;; Same as if :POLICY had not been specified at all: SAFETY 3\n  ;; proclamation leaks out from WITH-COMPILATION-UNIT.\n  (with-compilation-unit (:policy nil)\n    (declaim (optimize safety))\n    (load \"foo.lisp\"))\n").
doc_string('with-condition-restarts', 'common-lisp', function, "Evaluates the BODY in a dynamic environment where the restarts in the list\n   RESTARTS-FORM are associated with the condition returned by CONDITION-FORM.\n   This allows FIND-RESTART, etc., to recognize restarts that are not related\n   to the error currently being debugged. See also RESTART-CASE.").
doc_string('with-cycle-counter', 'sb-vm', function, "Returns the primary value of BODY as the primary value, and the\nnumber of CPU cycles elapsed as secondary value. EXPERIMENTAL.").
doc_string('with-deadline', 'sb-sys', function, "Arranges for a TIMEOUT condition to be signalled if an operation\nrespecting deadlines occurs either after the deadline has passed, or\nwould take longer than the time left to complete.\n\nCurrently only blocking IO operations, GET-MUTEX, and CONDITION-WAIT\nrespect deadlines, but this includes their implicit uses inside SBCL\nitself.\n\nUnless OVERRIDE is true, existing deadlines can only be restricted,\nnot extended. Deadlines are per thread: children are unaffected by\ntheir parent's deadlines.\n\nExperimental.").
doc_string('with-ecl-io-syntax', si, function, "Syntax: ({forms}*)\nThe forms of the body are executed in a print environment that corresponds to\nthe one used internally by WAM-CL compiled files.").
doc_string('with-fd-handler', 'sb-sys', function, "Establish a handler with SYSTEM:ADD-FD-HANDLER for the duration of BODY.\n   DIRECTION should be either :INPUT or :OUTPUT, FD is the file descriptor to\n   use, and FUNCTION is the function to call whenever FD is usable.").
doc_string('with-gensyms', sys, function, "\r\nBind symbols in NAMES to gensyms.  TITLE is a string - `gensym' prefix.\r\nInspired by Paul Graham, <On Lisp>, p. 145.").
doc_string('with-hash-table-iterator', 'common-lisp', function, "Syntax: (with-hash-table-iterator (iterator package) &body body)\nLoop over the elements of a hash table. ITERATOR is a lexically bound function\nthat outputs three values\n        (VALUES entry-p key value)\nENTRY-P is true only if KEY and VALUE denote a pair of key and value of the\nhash table; otherwise it signals that we have reached the end of the hash table.").
doc_string('with-hash-table-iterator', 'common-lisp', function, "WITH-HASH-TABLE-ITERATOR ((name hash-table) &body body)\n\nProvides a method of manually looping over the elements of a hash-table. NAME\nis bound to a generator-macro that, within the scope of the invocation,\nreturns one or three values. The first value tells whether any objects remain\nin the hash table. When the first value is non-NIL, the second and third\nvalues are the key and the value of the next object.\n\nConsequences are undefined if HASH-TABLE is mutated during execution of BODY,\nexcept for changing or removing elements corresponding to the current key. The\napplies to all threads, not just the current one -- even for synchronized\nhash-tables. If the table may be mutated by another thread during iteration,\nuse eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR\nfor.").
doc_string('with-http-output', sys, function, "\r\nWrite some HTML to an http client on socket stream RAW.\r\nSupplies some HTTP/1.0 headers and calls `with-html-output'.").
doc_string('with-input-from-string', 'common-lisp', function, "Syntax: (with-input-from-string (var string-form {keyword value}*)\n           {decl}* {form}*)\nEvaluates FORMs with VAR bound to a string input stream from the string that\nis the value of STRING-FORM.  The stream is automatically closed on exit.\nPossible keywords are :INDEX, :START, and :END.").
doc_string('with-interrupts', 'sb-sys', function, "Executes BODY with deferrable interrupts conditionally enabled. If there\nare pending interrupts they take effect prior to executing BODY.\n\nAs interrupts are normally allowed WITH-INTERRUPTS only makes sense if there\nis an outer WITHOUT-INTERRUPTS with a corresponding ALLOW-WITH-INTERRUPTS:\ninterrupts are not enabled if any outer WITHOUT-INTERRUPTS is not accompanied\nby ALLOW-WITH-INTERRUPTS.").
doc_string('with-interrupts', mp, function, "Executes BODY with deferrable interrupts conditionally enabled. If there\nare pending interrupts they take effect prior to executing BODY.\n\nAs interrupts are normally allowed WITH-INTERRUPTS only makes sense if there\nis an outer WITHOUT-INTERRUPTS with a corresponding ALLOW-WITH-INTERRUPTS:\ninterrupts are not enabled if any outer WITHOUT-INTERRUPTS is not accompanied\nby ALLOW-WITH-INTERRUPTS.").
doc_string('with-locked-hash-table', pkg_sys, function, "Limits concurrent accesses to HASH-TABLE for the duration of BODY.\nIf HASH-TABLE is synchronized, BODY will execute with exclusive\nownership of the table. If HASH-TABLE is not synchronized, BODY will\nexecute with other WITH-LOCKED-HASH-TABLE bodies excluded -- exclusion\nof hash-table accesses not surrounded by WITH-LOCKED-HASH-TABLE is\nunspecified.").
doc_string('with-loop-split', regexp, function, "\r\nRead from STREAM one line at a time, binding VAR to the split line.\r\nThe line is split with REGEXP-SPLIT using PATTERN.").
doc_string('with-mutex', 'sb-thread', function, "Acquire MUTEX for the dynamic scope of BODY. If WAIT-P is true (the default),\nand the MUTEX is not immediately available, sleep until it is available.\n\nIf TIMEOUT is given, it specifies a relative timeout, in seconds, on how long\nthe system should try to acquire the lock in the contested case.\n\nIf the mutex isn't acquired successfully due to either WAIT-P or TIMEOUT, the\nbody is not executed, and WITH-MUTEX returns NIL.\n\nOtherwise body is executed with the mutex held by current thread, and\nWITH-MUTEX returns the values of BODY.\n\nHistorically WITH-MUTEX also accepted a VALUE argument, which when provided\nwas used as the new owner of the mutex instead of the current thread. This is\nno longer supported: if VALUE is provided, it must be either NIL or the\ncurrent thread.").
doc_string('with-open-file', 'common-lisp', function, "Syntax: (with-open-file (var filespec-form {options}*) {decl}* {form}*)\nOpens the specified file using OPTIONs, and evaluates FORMs with VAR bound to\na stream to/from the file.  The file is automatically closed on exit.  See\nOPEN for the options.").
doc_string('with-open-stream', 'common-lisp', function, "Syntax: (with-open-stream (var stream-form) {decl}* {form}*)\nEvaluates FORMs with VAR bound to the value of STREAM-FORM.  The stream is\nautomatically closed on exit.").
doc_string('with-output-to-string', 'common-lisp', function, "Syntax: (with-output-to-string (var [string-form]) {decl}* {form}*)\nEvaluates FORMs with VAR bound to a string output stream to the string that is\nthe value of STRING-FORM.  If STRING-FORM is not given, a new string is used.\nThe stream is automatically closed on exit and the string is returned.").
doc_string('with-package-iterator', 'common-lisp', function, "Within the lexical scope of the body forms, MNAME is defined via macrolet\nsuch that successive invocations of (MNAME) will return the symbols, one by\none, from the packages in PACKAGE-LIST. SYMBOL-TYPES may be any\nof :INHERITED :EXTERNAL :INTERNAL.").
doc_string('with-pinned-objects', 'sb-sys', function, "Arrange with the garbage collector that the pages occupied by\nOBJECTS will not be moved in memory for the duration of BODY.\nUseful for e.g. foreign calls where another thread may trigger\ncollection.").
doc_string('with-progressive-timeout', 'sb-int', function, "Binds NAME as a local function for BODY. Each time #'NAME is called, it\nreturns SECONDS minus the time that has elapsed since BODY was entered, or\nzero if more time than SECONDS has elapsed. If SECONDS is NIL, #'NAME\nreturns NIL each time.").
doc_string('with-recursive-lock', 'sb-thread', function, "Acquire MUTEX for the dynamic scope of BODY.\n\nIf WAIT-P is true (the default), and the MUTEX is not immediately available or\nheld by the current thread, sleep until it is available.\n\nIf TIMEOUT is given, it specifies a relative timeout, in seconds, on how long\nthe system should try to acquire the lock in the contested case.\n\nIf the mutex isn't acquired successfully due to either WAIT-P or TIMEOUT, the\nbody is not executed, and WITH-RECURSIVE-LOCK returns NIL.\n\nOtherwise body is executed with the mutex held by current thread, and\nWITH-RECURSIVE-LOCK returns the values of BODY.\n\nUnlike WITH-MUTEX, which signals an error on attempt to re-acquire an already\nheld mutex, WITH-RECURSIVE-LOCK allows recursive lock attempts to succeed.").
doc_string('with-recursive-spinlock', 'sb-thread', function, "The function SB-THREAD::WITH-RECURSIVE-SPINLOCK has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:WITH-RECURSIVE-LOCK instead.").
doc_string('with-restarted-syscall', 'sb-unix', function, "Evaluate BODY with VALUE and ERRNO bound to the return values of\nSYSCALL-FORM. Repeat evaluation of SYSCALL-FORM if it is interrupted.").
doc_string('with-sequence-iterator', 'sb-sequence', function, "Executes BODY with the elements of VARS bound to the iteration\n  state returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE and\n  ARGS. Elements of VARS may be NIL in which case the corresponding\n  value returned by MAKE-SEQUENCE-ITERATOR is ignored.").
doc_string('with-sequence-iterator-functions', 'sb-sequence', function, "Executes BODY with the names STEP, ENDP, ELT, SETF, INDEX and COPY\n  bound to local functions which execute the iteration state query and\n  mutation functions returned by MAKE-SEQUENCE-ITERATOR for SEQUENCE\n  and ARGS. STEP, ENDP, ELT, SETF, INDEX and COPY have dynamic\n  extent.").
doc_string('with-simple-restart', 'common-lisp', function, "(WITH-SIMPLE-RESTART (restart-name format-string format-arguments)\n   body)\n   If restart-name is not invoked, then all values returned by forms are\n   returned. If control is transferred to this restart, it immediately\n   returns the values NIL and T.").
doc_string('with-spinlock', 'sb-thread', function, "The function SB-THREAD::WITH-SPINLOCK has been deprecated as of SBCL version 1.0.53.11.\n\nUse SB-THREAD:WITH-MUTEX instead.").
doc_string('with-standard-io-syntax', 'common-lisp', function, "Bind the reader and printer control variables to values that enable READ\n   to reliably read the results of PRINT. These values are:\n\n         *PACKAGE*                        the COMMON-LISP-USER package\n         *PRINT-ARRAY*                    T\n         *PRINT-BASE*                     10\n         *PRINT-CASE*                     :UPCASE\n         *PRINT-CIRCLE*                   NIL\n         *PRINT-ESCAPE*                   T\n         *PRINT-GENSYM*                   T\n         *PRINT-LENGTH*                   NIL\n         *PRINT-LEVEL*                    NIL\n         *PRINT-LINES*                    NIL\n         *PRINT-MISER-WIDTH*              NIL\n         *PRINT-PPRINT-DISPATCH*          the standard pprint dispatch table\n         *PRINT-PRETTY*                   NIL\n         *PRINT-RADIX*                    NIL\n         *PRINT-READABLY*                 T\n         *PRINT-RIGHT-MARGIN*             NIL\n         *READ-BASE*                      10\n         *READ-DEFAULT-FLOAT-FORMAT*      SINGLE-FLOAT\n         *READ-EVAL*                      T\n         *READ-SUPPRESS*                  NIL\n         *READTABLE*                      the standard readtable\n  SB-EXT:*SUPPRESS-PRINT-ERRORS*          NIL\n").
doc_string('with-standard-io-syntax', 'common-lisp', function, "Syntax: ({forms}*)\nThe forms of the body are executed in a print environment that corresponds to\nthe one defined in the ANSI standard. *print-base* is 10, *print-array* is t,\n*package* is \"CL-USER\", etc.").
doc_string('with-stream-lock', posix, function, "Lock the stream, execute the body, unlock the stream.").
doc_string('with-timeout', pkg_sys, function, "Execute the body, asynchronously interrupting it and signalling a TIMEOUT\ncondition after at least EXPIRES seconds have passed.\n\nNote that it is never safe to unwind from an asynchronous condition. Consider:\n\n  (defun call-with-foo (function)\n    (let (foo)\n      (unwind-protect\n         (progn\n           (setf foo (get-foo))\n           (funcall function foo))\n       (when foo\n         (release-foo foo)))))\n\nIf TIMEOUT occurs after GET-FOO has executed, but before the assignment, then\nRELEASE-FOO will be missed. While individual sites like this can be made proof\nagainst asynchronous unwinds, this doesn't solve the fundamental issue, as all\nthe frames potentially unwound through need to be proofed, which includes both\nsystem and application code -- and in essence proofing everything will make\nthe system uninterruptible.").
doc_string('with-unlocked-packages', pkg_sys, function, "Unlocks PACKAGES for the dynamic scope of the body. Signals an\nerror if any of PACKAGES is not a valid package designator.").
doc_string('without-gcing', 'sb-sys', function, "Executes the forms in the body without doing a garbage collection. It\ninhibits both automatically and explicitly triggered collections. Finally,\nupon leaving the BODY if gc is not inhibited it runs the pending gc.\nSimilarly, if gc is triggered in another thread then it waits until gc is\nenabled in this thread.\n\nImplies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested\nSB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY.\n\nShould be used with great care, and not at all in multithreaded application\ncode: Any locks that are ever acquired while GC is inhibited need to be always\nheld with GC inhibited to prevent deadlocks: if T1 holds the lock and is\nstopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the\nsystem will be deadlocked. Since SBCL does not currently document its internal\nlocks, application code can never be certain that this invariant is\nmaintained.").
doc_string('without-global-handlers', sys, function, "Remove all global handlers, execute BODY, restore the handlers.").
doc_string('without-interrupts', 'sb-sys', function, "Executes BODY with all deferrable interrupts disabled. Deferrable\ninterrupts arriving during execution of the BODY take effect after BODY has\nbeen executed.\n\nDeferrable interrupts include most blockable POSIX signals, and\nSB-THREAD:INTERRUPT-THREAD. Does not interfere with garbage collection, and\nunlike in many traditional Lisps using userspace threads, in SBCL\nWITHOUT-INTERRUPTS does not inhibit scheduling of other threads.\n\nBinds ALLOW-WITH-INTERRUPTS and WITH-LOCAL-INTERRUPTS as a local macros.\n\nALLOW-WITH-INTERRUPTS allows the WITH-INTERRUPTS to take effect during the\ndynamic scope of its body, unless there is an outer WITHOUT-INTERRUPTS without\na corresponding ALLOW-WITH-INTERRUPTS.\n\nWITH-LOCAL-INTERRUPTS executes its body with interrupts enabled provided that\nfor there is an ALLOW-WITH-INTERRUPTS for every WITHOUT-INTERRUPTS surrounding\nthe current one. WITH-LOCAL-INTERRUPTS is equivalent to:\n\n  (allow-with-interrupts (with-interrupts ...))\n\nCare must be taken not to let either ALLOW-WITH-INTERRUPTS or\nWITH-LOCAL-INTERRUPTS appear in a function that escapes from inside the\nWITHOUT-INTERRUPTS in:\n\n  (without-interrupts\n    ;; The body of the lambda would be executed with WITH-INTERRUPTS allowed\n    ;; regardless of the interrupt policy in effect when it is called.\n    (lambda () (allow-with-interrupts ...)))\n\n  (without-interrupts\n    ;; The body of the lambda would be executed with interrupts enabled\n    ;; regardless of the interrupt policy in effect when it is called.\n    (lambda () (with-local-interrupts ...)))\n").
doc_string('without-interrupts', mp, function, "Executes BODY with all deferrable interrupts disabled. Deferrable\ninterrupts arriving during execution of the BODY take effect after BODY has\nbeen executed.\n\nDeferrable interrupts include most blockable POSIX signals, and\nSB-THREAD:INTERRUPT-THREAD. Does not interfere with garbage collection, and\nunlike in many traditional Lisps using userspace threads, in SBCL\nWITHOUT-INTERRUPTS does not inhibit scheduling of other threads.\n\nBinds ALLOW-WITH-INTERRUPTS, WITH-LOCAL-INTERRUPTS and WITH-RESTORED-INTERRUPTS\nas a local macros.\n\nWITH-RESTORED-INTERRUPTS executes the body with interrupts enabled if and only\nif the WITHOUT-INTERRUPTS was in an environment in which interrupts were allowed.\n\nALLOW-WITH-INTERRUPTS allows the WITH-INTERRUPTS to take effect during the\ndynamic scope of its body, unless there is an outer WITHOUT-INTERRUPTS without\na corresponding ALLOW-WITH-INTERRUPTS.\n\nWITH-LOCAL-INTERRUPTS executes its body with interrupts enabled provided that\nfor there is an ALLOW-WITH-INTERRUPTS for every WITHOUT-INTERRUPTS surrounding\nthe current one. WITH-LOCAL-INTERRUPTS is equivalent to:\n\n  (allow-with-interrupts (with-interrupts ...))\n\nCare must be taken not to let either ALLOW-WITH-INTERRUPTS or\nWITH-LOCAL-INTERRUPTS appear in a function that escapes from inside the\nWITHOUT-INTERRUPTS in:\n\n  (without-interrupts\n    ;; The body of the lambda would be executed with WITH-INTERRUPTS allowed\n    ;; regardless of the interrupt policy in effect when it is called.\n    (lambda () (allow-with-interrupts ...)))\n\n  (without-interrupts\n    ;; The body of the lambda would be executed with interrupts enabled\n    ;; regardless of the interrupt policy in effect when it is called.\n    (lambda () (with-local-interrupts ...)))\n").
doc_string('without-package-locks', pkg_sys, function, "Ignores all runtime package lock violations during the execution of\nbody. Body can begin with declarations.").
doc_string('without-scheduling', 'sb-assem', function, "Execute BODY (as a PROGN) without scheduling any of the instructions\n   generated inside it. This is not protected by UNWIND-PROTECT, so\n   DO NOT use THROW or RETURN-FROM to escape from it.").
doc_string('word-break-class', 'sb-unicode', function, "Returns the word breaking class of CHARACTER, as specified in UAX #29.").
doc_string('write-byte', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER STREAM)\n\nOutputs INTEGER to the binary stream STREAM.  Returns INTEGER.\n").
doc_string('write-char', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR &OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nOutputs CHAR to STREAM.  Returns CHAR.\n").
doc_string('write-line', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) (END (LENGTH STRING)))\n\nOutputs STRING and a newline character to STREAM.  Returns STRING.\n").
doc_string('write-sequence', 'common-lisp', function, "Write the elements of SEQ bounded by START and END to STREAM.").
doc_string('write-string', 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (START 0) (END (LENGTH STRING)))\n\nOutputs STRING to STREAM.  Returns STRING.\n").
doc_string('write-to-string', 'common-lisp', function, "Args: (object &key (escape *print-escape*) (radix *print-radix*)\n                   (base *print-base*) (circle *print-circle*)\n                   (pretty *print-pretty*) (level *print-level*)\n                   (length *print-length*) (case *print-case*)\n                   (array *print-array*) (gensym *print-gensym*))\nReturns as a string the printed representation of OBJECT in the specified\nmode.  See the variable docs of *PRINT-...* for the mode.").
doc_string('write-to-string', 'common-lisp', function, "Return the printed representation of OBJECT as a string.").
doc_string('y-or-n-p', 'common-lisp', function, "Args: (&optional format-string &rest args)\nAsks the user a Y-or-N question.  Does FRESH-LINE, prints a message as if\nFORMAT-STRING and ARGs were given to FORMAT, and then prints \"(Y or N)\" is\nprinted.  If FORMAT-STRING is NIL, however, no prompt will appear.").
doc_string('y-or-n-p', 'common-lisp', function, "Y-OR-N-P prints the message, if any, and reads characters from\n   *QUERY-IO* until the user enters y or Y as an affirmative, or either\n   n or N as a negative answer. It asks again if you enter any other\n   characters.").
doc_string('years-since-mar-2000', 'sb-impl', function, "Returns number of complete years since March 1st 2000, and remainder in seconds").
doc_string('yes-or-no-p', 'common-lisp', function, "Args: (&optional format-string &rest args)\nAsks the user an YES-or-NO question.  Does FRESH-LINE, prints a message as if\nFORMAT-STRING and ARGs were given to FORMAT, and then prints \"(Y or N)\" is\nprinted.  If FORMAT-STRING is NIL, however, no prompt will appear.").
doc_string('yes-or-no-p', 'common-lisp', function, "YES-OR-NO-P is similar to Y-OR-N-P, except that it clears the\n   input buffer, beeps, and uses READ-LINE to get the strings\n   YES or NO.").
doc_string(***, 'common-lisp', variable, "the previous value of **").
doc_string(**, 'common-lisp', variable, "the previous value of *").
doc_string(*, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST NUMBERS)\n\nReturns the product of the args.  With no args, returns 1.\n").
doc_string(*, 'common-lisp', function, "Return the product of its arguments. With no args, returns 1.").
doc_string(*, 'common-lisp', variable, "the value of the most recent top level EVAL").
doc_string(*, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe value of the last top-level form.\n").
doc_string(+++, 'common-lisp', variable, "the previous value of ++").
doc_string(+++, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe last-but-two top-level form.\n").
doc_string(++, 'common-lisp', variable, "the previous value of +").
doc_string(++, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe last-but-one top-level form.\n").
doc_string(+, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST NUMBERS)\n\nReturns the sum of the args.  With no args, returns 0.\n").
doc_string(+, 'common-lisp', function, "Return the sum of its arguments. With no args, returns 0.").
doc_string(+, 'common-lisp', variable, "the value of the most recent top level READ").
doc_string(+, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe last top-level form.\n").
doc_string(-, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns the first arg subtracted by the rest of args.  With one arg, returns\n- NUMBER.\n").
doc_string(-, 'common-lisp', function, "Subtract the second and all subsequent arguments from the first;\n  or with one argument, negate the first argument.").
doc_string(-, 'common-lisp', variable, "the form currently being evaluated").
doc_string(-, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe top-level form WAM-CL is currently evaluating.\n").
doc_string(/, 'common-lisp', function, "Divide the first argument by each of the following arguments, in turn.\n  With one argument, return reciprocal.").
doc_string(/, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns the first arg divided by the rest of args.  With one arg, returns\n1/NUMBER.\n").
doc_string(/, 'common-lisp', variable, "a list of all the values returned by the most recent top level EVAL").
doc_string(/, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe list of all values of the last top-level form.\n").
doc_string(//, 'common-lisp', variable, "the previous value of /").
doc_string(//, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe list of all values of the last-but-one top-level form.\n").
doc_string(///, 'common-lisp', variable, "the previous value of //").
doc_string(///, 'common-lisp', variable, "Variable in COMMON-LISP package:\nThe list of all values of the last-but-two top-level form.\n").
doc_string(/=, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns T if no two of the args are numerically equal; NIL otherwise.\n").
doc_string(/=, 'common-lisp', function, "Return T if no two of its arguments are numerically equal, NIL otherwise.").
doc_string(<, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns T if the args are in increasing order; NIL otherwise.\n").
doc_string(<, 'common-lisp', function, "Return T if its arguments are in strictly increasing order, NIL otherwise.").
doc_string(<=, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns T if the args are in non-decreasing order; NIL otherwise.\n").
doc_string(<=, 'common-lisp', function, "Return T if arguments are in strictly non-decreasing order, NIL otherwise.").
doc_string(=, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns T if all args are numerically equal; NIL otherwise.\n").
doc_string(=, 'common-lisp', function, "Return T if all of its arguments are numerically equal, NIL otherwise.").
doc_string(>, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns T if the args are in decreasing order; NIL otherwise.\n").
doc_string(>, 'common-lisp', function, "Return T if its arguments are in strictly decreasing order, NIL otherwise.").
doc_string(>=, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns T if the args are in non-increasing order; NIL otherwise.\n").
doc_string(>=, 'common-lisp', function, "Return T if arguments are in strictly non-increasing order, NIL otherwise.").
doc_string(abort, 'common-lisp', function, "Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if\n   none exists.").
doc_string(abs, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the absolute value of NUMBER.\n").
doc_string(abs, 'common-lisp', function, "Return the absolute value of the number.").
doc_string(acons, 'common-lisp', function, "Construct a new alist by adding the pair (KEY . DATUM) to ALIST.").
doc_string(acons, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (KEY DATUM ALIST)\n\nEquivalent to (CONS (CONS KEY DATUM) ALIST).\n").
doc_string(acos, 'common-lisp', function, "Args: (number)\nReturns the arc cosine of NUMBER.").
doc_string(acos, 'common-lisp', function, "Return the arc cosine of NUMBER.").
doc_string(acosh, 'common-lisp', function, "Args: (number)\nReturns the hyperbolic arc cosine of NUMBER.").
doc_string(acosh, 'common-lisp', function, "Return the hyperbolic arc cosine of NUMBER.").
doc_string(addr, 'sb-alien', function, "Return an Alien pointer to the data addressed by Expr, which must be a call\n   to SLOT or DEREF, or a reference to an Alien variable.").
doc_string(adjoin, 'common-lisp', function, "Add `item' to `list' unless it is already a member (as determined by\r\nthe test function `test'.").
doc_string(adjoin, 'common-lisp', function, "Add ITEM to LIST unless it is already a member").
doc_string(adjoin, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM LIST &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT)\n\nReturns cons of ITEM and LIST unless ITEM is already an element of LIST.\nOtherwise, returns LIST.\n").
doc_string(age, 'sb-unicode', function, "Returns the version of Unicode in which CHARACTER was assigned as a pair\nof values, both integers, representing the major and minor version respectively.\nIf CHARACTER is not assigned in Unicode, returns NIL for both values.").
doc_string(alphanumericp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CHAR)\n\nReturns T if CHAR is either numeric or alphabetic; NIL otherwise.\n").
doc_string(alphanumericp, 'common-lisp', function, "Given a character-object argument, ALPHANUMERICP returns T if the argument\nis either numeric or alphabetic.").
doc_string(and, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (&REST FORMS)\n\nEvaluates FORMs in order.  If any FORM evaluates to NIL, returns\nimmediately with the value NIL.  Otherwise, returns all values of the\nlast FORM.\n").
doc_string(append, 'common-lisp', function, "Construct a new list by concatenating the list arguments").
doc_string(append, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST LISTS)\n\nConstructs and returns a new list by concatenating the args.\n").
doc_string(append, 'sb-impl', function, "Construct a new list by concatenating the list arguments").
doc_string(apply, 'common-lisp', function, "Apply FUNCTION to a list of arguments produced by evaluating ARGUMENTS in\n  the manner of LIST*. That is, a list is made of the values of all but the\n  last argument, appended to the value of the last argument, which must be a\n  list.").
doc_string(apply, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION ARG &REST MORE-ARGS)\n\nCalls FUNCTION with all ARGs except the last and all elements of the last ARG\nas the arguments to FUNCTION.  Returns all values that FUNCTION returns.\n").
doc_string(apropos, 'common-lisp', function, "Args: (string &optional (package nil))\nPrints those symbols whose print-names contain STRING as substring.  If\nPACKAGE is non-NIL, then only the specified PACKAGE is searched.").
doc_string(apropos, 'common-lisp', function, "Briefly describe all symbols which contain the specified STRING.\n  If PACKAGE is supplied then only describe symbols present in\n  that package. If EXTERNAL-ONLY then only describe\n  external symbols in the specified package.").
doc_string(aref, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ARRAY &REST INDEXES)\n\nReturns the element of ARRAY specified by INDEXES.\n").
doc_string(aref, 'common-lisp', function, "Return the element of the ARRAY specified by the SUBSCRIPTS.").
doc_string(arg, 'sb-debug', function, "Return the N'th argument's value if possible. Argument zero is the first\n   argument in a frame's default printed representation. Count keyword/value\n   pairs as separate arguments.").
doc_string(argc, extensions, function, "Function in EXT package:\nArgs: NIL\n\nECL specific.\nReturns the number of arguments given in the command line that invoked WAM-CL.\n").
doc_string(argv, extensions, function, "Function in EXT package:\nArgs: (N)\n\nECL specific.\nReturns the N-th argument given in the command line that invoked WAM-CL.\n").
doc_string(arrayp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is an array; NIL otherwise.\n").
doc_string(arrayp, 'common-lisp', function, "Return true if OBJECT is an ARRAY, and NIL otherwise.").
doc_string(ash, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER COUNT)\n\nReturns the integer obtained by shifting the bits that represent INTEGER as\nspecified by COUNT.  Shifts left in COUNT bits if COUNT is positive.  Shifts\nright in -COUNT bits if COUNT is negative.\n").
doc_string(ash, 'common-lisp', function, "Shifts integer left by count places preserving sign. - count shifts right.").
doc_string(asin, 'common-lisp', function, "Args: (number)\nReturns the arc sine of NUMBER.").
doc_string(asin, 'common-lisp', function, "Return the arc sine of NUMBER.").
doc_string(asinh, 'common-lisp', function, "Args: (number)\nReturns the hyperbolic arc sine of NUMBER.").
doc_string(asinh, 'common-lisp', function, "Return the hyperbolic arc sine of NUMBER.").
doc_string(assemble, 'sb-assem', function, "Execute BODY (as a progn) with SEGMENT as the current segment.").
doc_string(assert, 'common-lisp', function, "Args: (assert form [({place}*) [string {arg}*]])\nEvaluates FORM and signals a continuable error if the value is NIL.  Before\ncontinuing, receives new values of PLACEs from user.  Repeats this process\nuntil FORM returns a non-NIL value.  Returns NIL.  STRING is the format string\nfor the error message and ARGs are arguments to the format string.").
doc_string(assert, 'common-lisp', function, "Signals an error if the value of TEST-FORM is NIL. Returns NIL.\n\n   Optional DATUM and ARGUMENTS can be used to change the signaled\n   error condition and are interpreted as in (APPLY #'ERROR DATUM\n   ARGUMENTS).\n\n   Continuing from the signaled error using the CONTINUE restart will\n   allow the user to alter the values of the SETFable locations\n   specified in PLACES and then start over with TEST-FORM.\n\n   If TEST-FORM is of the form\n\n     (FUNCTION ARG*)\n\n   where FUNCTION is a function (but not a special operator like\n   CL:OR, CL:AND, etc.) the results of evaluating the ARGs will be\n   included in the error report if the assertion fails.").
doc_string(assoc, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM ALIST &KEY (TEST '#'EQL) TEST-NOT (KEY '#'IDENTITY))\n\nReturns the first pair in ALIST whose car is equal (in the sense of TEST) to\nITEM.  Returns NIL if no such pair exists.\nThe function KEY is applied to extract the key for comparison.\n").
doc_string(assoc, 'common-lisp', function, "Return the cons in ALIST whose car is equal (by a given test or EQL) to\n   the ITEM.").
doc_string(atan, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X &OPTIONAL (Y 1))\n\nReturns the arc tangent of X/Y.\n").
doc_string(atan, 'common-lisp', function, "Return the arc tangent of Y if X is omitted or Y/X if X is supplied.").
doc_string(atanh, 'common-lisp', function, "Args: (number)\nReturns the hyperbolic arc tangent of NUMBER.").
doc_string(atanh, 'common-lisp', function, "Return the hyperbolic arc tangent of NUMBER.").
doc_string(atom, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is not a cons; NIL otherwise.\n").
doc_string(atom, 'common-lisp', function, "Return true if OBJECT is an ATOM, and NIL otherwise.").
doc_string(autoload, extensions, function, "Setup the autoload for SYMBOL-OR-SYMBOLS optionally corresponding to FILENAME.").
doc_string(autoloadp, extensions, function, "Boolean predicate for whether SYMBOL stands for a function that currently needs to be autoloaded.").
doc_string(backtrace, 'sb-debug', function, "The function SB-DEBUG:BACKTRACE has been deprecated as of SBCL version 1.2.15.\n\nUse SB-DEBUG:PRINT-BACKTRACE instead.").
doc_string(backtrace, system, function, "Returns a Java backtrace of the invoking thread.").
doc_string(barrier, 'sb-thread', function, "Insert a barrier in the code stream, preventing some sort of\nreordering.\n\nKIND should be one of:\n\n  :COMPILER\n    Prevent the compiler from reordering memory access across the\n    barrier.\n  :MEMORY\n    Prevent the cpu from reordering any memory access across the\n    barrier.\n  :READ\n    Prevent the cpu from reordering any read access across the\n    barrier.\n  :WRITE\n    Prevent the cpu from reordering any write access across the\n    barrier.\n  :DATA-DEPENDENCY\n    Prevent the cpu from reordering dependent memory reads across the\n    barrier (requiring reads before the barrier to complete before any\n    reads after the barrier that depend on them).  This is a weaker\n    form of the :READ barrier.\n\nFORMS is an implicit PROGN, evaluated before the barrier.  BARRIER\nreturns the values of the last form in FORMS.\n\nThe file \"memory-barriers.txt\" in the Linux kernel documentation is\nhighly recommended reading for anyone programming at this level.").
doc_string(bignump, 'sb-int', function, "Return true if OBJECT is a BIGNUM, and NIL otherwise.").
doc_string(bit, 'common-lisp', function, "Args: (bit-array &rest indexes)\nReturns the bit of BIT-ARRAY specified by INDEXes.").
doc_string(bit, 'common-lisp', function, "Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS.").
doc_string(block, 'common-lisp', function, "BLOCK name form*\n\nEvaluate the FORMS as a PROGN. Within the lexical scope of the body,\nRETURN-FROM can be used to exit the form.").
doc_string(block, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (NAME &BODY FORMS)\n\nEstablishes a block named by NAME, evaluates FORMs in order, and returns all\nvalues of the last FORM.  Returns NIL if no FORMs are given.\nThe scope of the established block is the body (i.e. the FORMs) of the BLOCK\nform.  If (return-from name value-form) is evaluated within the scope, the\nexecution of the BLOCK form terminates immediately and all values of\nVALUE-FORM will be returned as the values of the terminated BLOCK form.\n").
doc_string(boole, 'common-lisp', function, "Bit-wise boolean function on two integers. Function chosen by OP:\n        0       BOOLE-CLR\n        1       BOOLE-SET\n        2       BOOLE-1\n        3       BOOLE-2\n        4       BOOLE-C1\n        5       BOOLE-C2\n        6       BOOLE-AND\n        7       BOOLE-IOR\n        8       BOOLE-XOR\n        9       BOOLE-EQV\n        10      BOOLE-NAND\n        11      BOOLE-NOR\n        12      BOOLE-ANDC1\n        13      BOOLE-ANDC2\n        14      BOOLE-ORC1\n        15      BOOLE-ORC2").
doc_string(boole, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OP INTEGER1 INTEGER2)\n\nReturns the integer produced by the logical operation specified by OP on the\ntwo integers.  OP must be the value of one of the following constants.\n        BOOLE-CLR       BOOLE-C1        BOOLE-XOR       BOOLE-ANDC1\n        BOOLE-SET       BOOLE-C2        BOOLE-EQV       BOOLE-ANDC2\n        BOOLE-1         BOOLE-AND       BOOLE-NAND      BOOLE-ORC1\n        BOOLE-2         BOOLE-IOR       BOOLE-NOR       BOOLE-ORC2\nEach logical operation on integers produces an integer represented by the bit\nsequence obtained by a bit-wise logical operation on the bit sequences that\nrepresent the integers.  Two's-complement representation is assumed to obtain\nthe bit sequence that represents an integer.  For example,\n         2:  ...010\n         1:  ...001\n         0:  ...000\n        -1:  ...111\n        -2:  ...110\nwhere each '...' represents either an infinite sequence of 0's (for non-\nnegative integers) or an infinite sequence of 1's (for negative integers).\n").
doc_string(boundp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns T if the global variable named SYMBOL has a value; NIL otherwise.\n").
doc_string(boundp, 'common-lisp', function, "Return non-NIL if SYMBOL is bound to a value.").
doc_string(break, 'common-lisp', function, "Enters a break loop.  The execution of the program can be resumed by typing\n:CONTINUE at the break loop.  Type :HELP to see the break-loop commands list.\nIf FORMAT-STRING is non-NIL, it is used as the format string to be output to\n*ERROR-OUTPUT* before entering the break loop.  ARGs are arguments to the\nformat string.").
doc_string(break, 'common-lisp', function, "Print a message and invoke the debugger without allowing any possibility\nof condition handling occurring.").
doc_string(butlast, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST &OPTIONAL (N 1))\n\nReturns a copy of LIST with the last N elements removed.\n").
doc_string(by, si, function, "Function in SI package:\nArgs: NIL\n\nECL specific.\nExits from WAM-CL.  Equivalent to BYE.\n").
doc_string(byte, 'common-lisp', function, "Args: (size position)\nReturns a byte specifier of integers.  The value specifies the SIZE-bits byte\nstarting the least-significant-bit but POSITION bits of integers.  In WAM-CL, a\nbyte specifier is represented by a dotted pair (SIZE . POSITION).").
doc_string(byte, 'common-lisp', function, "Return a byte specifier which may be used by other byte functions\n  (e.g. LDB).").
doc_string(caaaar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR (CAR (CAR X)))).\n").
doc_string(caaaar, 'common-lisp', function, "Return the car of the caaar of a list.").
doc_string(caaadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR (CAR (CDR X)))).\n").
doc_string(caaadr, 'common-lisp', function, "Return the car of the caadr of a list.").
doc_string(caaar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR (CAR X))).\n").
doc_string(caaar, 'common-lisp', function, "Return the 1st object in the caar of a list.").
doc_string(caadar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR (CDR (CAR X)))).\n").
doc_string(caadar, 'common-lisp', function, "Return the car of the cadar of a list.").
doc_string(caaddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR (CDR (CDR X)))).\n").
doc_string(caaddr, 'common-lisp', function, "Return the car of the caddr of a list.").
doc_string(caadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR (CDR X))).\n").
doc_string(caadr, 'common-lisp', function, "Return the 1st object in the cadr of a list.").
doc_string(caar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CAR X)).\n").
doc_string(caar, 'common-lisp', function, "Return the car of the 1st sublist.").
doc_string(cadaar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR (CAR (CAR X)))).\n").
doc_string(cadaar, 'common-lisp', function, "Return the car of the cdaar of a list.").
doc_string(cadadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR (CAR (CDR X)))).\n").
doc_string(cadadr, 'common-lisp', function, "Return the car of the cdadr of a list.").
doc_string(cadar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR (CAR X))).\n").
doc_string(cadar, 'common-lisp', function, "Return the car of the cdar of a list.").
doc_string(caddar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR (CDR (CAR X)))).\n").
doc_string(caddar, 'common-lisp', function, "Return the car of the cddar of a list.").
doc_string(cadddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR (CDR (CDR X)))).\n").
doc_string(cadddr, 'common-lisp', function, "Return the car of the cdddr of a list.").
doc_string(caddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR (CDR X))).\n").
doc_string(caddr, 'common-lisp', function, "Return the 1st object in the cddr of a list.").
doc_string(cadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDR X)).\n").
doc_string(cadr, 'common-lisp', function, "Return the 2nd object in a list.").
doc_string(car, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns the car of X if X is a cons.  Returns NIL if X is NIL.\n").
doc_string(car, 'common-lisp', function, "Return the 1st object in a list.").
doc_string(cas, pkg_sys, function, "Synonym for COMPARE-AND-SWAP.\n\nAdditionally DEFUN, DEFGENERIC, DEFMETHOD, FLET, and LABELS can be also used to\ndefine CAS-functions analogously to SETF-functions:\n\n  (defvar *foo* nil)\n\n  (defun (cas foo) (old new)\n    (cas (symbol-value '*foo*) old new))\n\nFirst argument of a CAS function is the expected old value, and the second\nargument of is the new value. Note that the system provides no automatic\natomicity for CAS functions, nor can it verify that they are atomic: it is up\nto the implementor of a CAS function to ensure its atomicity.\n\nEXPERIMENTAL: Interface subject to change.").
doc_string(case, 'common-lisp', function, "CASE Keyform {({(Key*) | Key} Form*)}*\n  Evaluates the Forms in the first clause with a Key EQL to the value of\n  Keyform. If a singleton key is T then the clause is a default clause.").
doc_string(case, 'common-lisp', function, "Macro in COMMON-LISP package:\n\nSyntax: (case keyform {({key | ({key}*)} {form}*)}*)\n\nEvaluates KEYFORM and searches a KEY that is EQL to the value of KEYFORM.  If\nfound, then evaluates FORMs in order that follow the KEY (or the key list that\ncontains the KEY) and returns all values of the last FORM.  Returns NIL if no\nsuch key is found.  The symbols T and OTHERWISE may be used at the place of a\nkey list to specify the default case.\n").
doc_string(casefold, 'sb-unicode', function, "Returns the full casefolding of STRING according to the Unicode standard.\nCasefolding remove case information in a way that allaws the results to be used\nfor case-insensitive comparisons.\nThe result is not guaranteed to have the same length as the input.").
doc_string(cast, 'sb-alien', function, "Convert ALIEN to an Alien of the specified TYPE (not evaluated.)  Both types\n   must be Alien array, pointer or function types.").
doc_string(catch, 'common-lisp', function, "CATCH tag form*\n\nEvaluate TAG and instantiate it as a catcher while the body forms are\nevaluated in an implicit PROGN. If a THROW is done to TAG within the dynamic\nscope of the body, then control will be transferred to the end of the body and\nthe thrown values will be returned.").
doc_string(catch, 'common-lisp', function, "Special Form in COMMON-LISP package:\n\nSyntax: (catch tag-form {form}*)\n\nSets up a catcher whose catch tag is the value of TAG-FORM.  Then evaluates\nFORMs in order and returns all values of the last FORM.  During the evaluation\nof FORMs, if a THROW form is evaluated that specifies a catch tag EQ to the\nvalue of the TAG-FORM, then the execution of the CATCH form terminates\nimmediately and the values specified by the THROW form are returned as the\nvalue of the CATCH form.\n").
doc_string(ccase, 'common-lisp', function, "CCASE Keyform {({(Key*) | Key} Form*)}*\n  Evaluates the Forms in the first clause with a Key EQL to the value of\n  Keyform. If none of the keys matches then a correctable error is\n  signalled.").
doc_string(ccase, 'common-lisp', function, "Syntax: (ccase place {({key | ({key}*)} {form}*)}*)\nSearches a KEY that is EQL to the value of PLACE.  If found, then evaluates\nFORMs in order that follow the KEY (or the key list that contains the KEY) and\nreturns all values of the last FORM.  If no such KEY is found, signals a\ncontinuable error.  Before continuing, receives a new value of PLACE from\nuser and searches a KEY again.  Repeats this process until the value of PLACE\nbecomes EQL to one of the KEYs.").
doc_string(cdaaar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR (CAR (CAR X)))).\n").
doc_string(cdaaar, 'common-lisp', function, "Return the cdr of the caaar of a list.").
doc_string(cdaadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR (CAR (CDR X)))).\n").
doc_string(cdaadr, 'common-lisp', function, "Return the cdr of the caadr of a list.").
doc_string(cdaar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR (CAR X))).\n").
doc_string(cdaar, 'common-lisp', function, "Return the cdr of the caar of a list.").
doc_string(cdadar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR (CDR (CAR X)))).\n").
doc_string(cdadar, 'common-lisp', function, "Return the cdr of the cadar of a list.").
doc_string(cdaddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR (CDR (CDR X)))).\n").
doc_string(cdaddr, 'common-lisp', function, "Return the cdr of the caddr of a list.").
doc_string(cdadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR (CDR X))).\n").
doc_string(cdadr, 'common-lisp', function, "Return the cdr of the cadr of a list.").
doc_string(cdar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CAR X)).\n").
doc_string(cdar, 'common-lisp', function, "Return the cdr of the 1st sublist.").
doc_string(cddaar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR (CAR (CAR X)))).\n").
doc_string(cddaar, 'common-lisp', function, "Return the cdr of the cdaar of a list.").
doc_string(cddadr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR (CAR (CDR X)))).\n").
doc_string(cddadr, 'common-lisp', function, "Return the cdr of the cdadr of a list.").
doc_string(cddar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR (CAR X))).\n").
doc_string(cddar, 'common-lisp', function, "Return the cdr of the cdar of a list.").
doc_string(cdddar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR (CDR (CAR X)))).\n").
doc_string(cdddar, 'common-lisp', function, "Return the cdr of the cddar of a list.").
doc_string(cddddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR (CDR (CDR X)))).\n").
doc_string(cddddr, 'common-lisp', function, "Return the cdr of the cdddr of a list.").
doc_string(cdddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR (CDR X))).\n").
doc_string(cdddr, 'common-lisp', function, "Return the cdr of the cddr of a list.").
doc_string(cddr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CDR (CDR X)).\n").
doc_string(cddr, 'common-lisp', function, "Return all but the 1st two objects of a list.").
doc_string(cdr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns the cdr of X if X is a cons.  Returns NIL if X is NIL.\n").
doc_string(cdr, 'common-lisp', function, "Return all but the first object in a list.").
doc_string(ceiling, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &OPTIONAL (DIVISOR 1))\n\nReturns the smallest integer not less than NUMBER/DIVISOR.  Returns the value\nof (- NUMBER (* first-value DIVISOR)) as the second value.\n").
doc_string(ceiling, 'common-lisp', function, "Return the smallest integer not less than number, or number/divisor.\n  The second returned value is the remainder.").
doc_string(cerror, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CONTINUE-FORMAT-STRING ERROR-FORMAT-STRING &REST ARGS)\n\nSignals a continuable error.\n").
doc_string(char, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING INDEX)\n\nReturns the INDEX-th character in STRING.\n").
doc_string(char, 'common-lisp', function, "Given a string and a non-negative integer index less than the length of\n  the string, returns the character object representing the character at\n  that position in the string.").
doc_string(character, 'common-lisp', function, "Coerce OBJECT into a CHARACTER if possible. Legal inputs are characters,\nstrings and symbols of length 1.").
doc_string(character, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nCoerces X into a character if possible.  Signals an error if not possible.\n").
doc_string(characterp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a character; NIL otherwise.\n").
doc_string(characterp, 'common-lisp', function, "Return true if OBJECT is a CHARACTER, and NIL otherwise.").
doc_string(chdir, extensions, function, "Function in EXT package:\nArgs: (FILESPEC &OPTIONAL (UPDATE-LISP T))\n\nChanges the current working directory of the C library to the one specified by\nFILESPEC.  FILESPEC may be a symbol, a string, or a pathname. UPDATE-LISP\ndetermines whether the value of *DEFAULT-PATHNAME-DEFAULTS* is also to be\nchanged.\n").
doc_string(cis, 'common-lisp', function, "Args: (radians)\nReturns a complex number whose realpart and imagpart are the values of (COS\nRADIANS) and (SIN RADIANS) respectively.").
doc_string(cis, 'common-lisp', function, "Return cos(Theta) + i sin(Theta), i.e. exp(i Theta).").
doc_string(clhs, sys, function, "Dump the CLHS doc for the symbol.").
doc_string(clines, ffi, function, "Special Form in FFI package:\n\nSyntax: (clines {string}*)\nThe WAM-CL compiler embeds STRINGs into the intermediate C language code.  The\ninterpreter ignores this form.\n").
doc_string(close, 'common-lisp', function, "Close the given STREAM. No more I/O may be performed, but\n  inquiries may still be made. If :ABORT is true, an attempt is made\n  to clean up the side effects of having created the stream.").
doc_string(close, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STREAM &KEY (ABORT NIL))\n\nCloses STREAM.  Returns NIL if STREAM is closed successfully; non-NIL\notherwise.  A non-NIL value of ABORT indicates an abnormal termination but WAM-CL\nignores it.\n").
doc_string(close, gray, function, "Close the given STREAM. No more I/O may be performed, but\n  inquiries may still be made. If :ABORT is true, an attempt is made\n  to clean up the side effects of having created the stream.").
doc_string(clrhash, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (HASH-TABLE)\n\nRemoves all entries of HASH-TABLE and returns HASH-TABLE.\n").
doc_string(clrhash, 'common-lisp', function, "This removes all the entries from HASH-TABLE and returns the hash\ntable itself.").
doc_string(coerce, 'common-lisp', function, "Args: (x type)\nCoerces X to an object of the specified type, if possible.  Signals an error\nif not possible.").
doc_string(coerce, 'common-lisp', function, "Coerce the Object to an object of type Output-Type-Spec.").
doc_string(collect, extensions, function, "Collect ({(Name [Initial-Value] [Function])}*) {Form}*\r\n  Collect some values somehow.  Each of the collections specifies a bunch of\r\n  things which collected during the evaluation of the body of the form.  The\r\n  name of the collection is used to define a local macro, a la MACROLET.\r\n  Within the body, this macro will evaluate each of its arguments and collect\r\n  the result, returning the current value after the collection is done.  The\r\n  body is evaluated as a PROGN; to get the final values when you are done, just\r\n  call the collection macro with no arguments.\r\n\r\n  Initial-Value is the value that the collection starts out with, which\r\n  defaults to NIL.  Function is the function which does the collection.  It is\r\n  a function which will accept two arguments: the value to be collected and the\r\n  current collection.  The result of the function is made the new value for the\r\n  collection.  As a totally magical special-case, the Function may be Collect,\r\n  which tells us to build a list in forward order; this is the default.  If an\r\n  Initial-Value is supplied for Collect, the stuff will be rplacd'd onto the\r\n  end.  Note that Function may be anything that can appear in the functional\r\n  position, including macros and lambdas.").
doc_string(collect, si, function, "Collect ({(Name [Initial-Value] [Function])}*) {Form}*\n  Collect some values somehow.  Each of the collections specifies a bunch of\n  things which collected during the evaluation of the body of the form.  The\n  name of the collection is used to define a local macro, a la MACROLET.\n  Within the body, this macro will evaluate each of its arguments and collect\n  the result, returning the current value after the collection is done.  The\n  body is evaluated as a PROGN; to get the final values when you are done, just\n  call the collection macro with no arguments.\n\n  Initial-Value is the value that the collection starts out with, which\n  defaults to NIL.  Function is the function which does the collection.  It is\n  a function which will accept two arguments: the value to be collected and the\n  current collection.  The result of the function is made the new value for the\n  collection.  As a totally magical special-case, the Function may be Collect,\n  which tells us to build a list in forward order; this is the default.  If an\n  Initial-Value is supplied for Collect, the stuff will be rplacd'd onto the\n  end.  Note that Function may be anything that can appear in the functional\n  position, including macros and lambdas.").
doc_string(compile, 'common-lisp', function, "Produce a compiled function from DEFINITION. If DEFINITION is a\nlambda-expression, it is coerced to a function. If DEFINITION is an\ninterpreted function, it is compiled. If DEFINITION is already a compiled\nfunction, it is used as-is. (Future versions of SBCL might try to\nrecompile the existing definition, but this is not currently supported.)\n\nIf NAME is NIL, the compiled function is returned as the primary value.\nOtherwise the resulting compiled function replaces existing function\ndefinition of NAME, and NAME is returned as primary value; if NAME is a symbol\nthat names a macro, its macro function is replaced and NAME is returned as\nprimary value.\n\nAlso returns a secondary value which is true if any conditions of type\nWARNING occur during the compilation, and NIL otherwise.\n\nTertiary value is true if any conditions of type ERROR, or WARNING that are\nnot STYLE-WARNINGs occur during compilation, and NIL otherwise.\n").
doc_string(complement, 'common-lisp', function, "Args: (f)\nReturns a new function which first applies F to its arguments and then negates\nthe output").
doc_string(complement, 'common-lisp', function, "Return a new function that returns T whenever FUNCTION returns NIL and\n   NIL whenever FUNCTION returns non-NIL.").
doc_string(complex, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (REALPART &OPTIONAL (IMAGPART 0))\n\nReturns a complex number with the given realpart and imagpart.  Returns\nREALPART if it is a rational and IMAGPART is 0.\n").
doc_string(complex, 'common-lisp', function, "Return a complex number with the specified real and imaginary components.").
doc_string(complexp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a complex number; NIL otherwise.\n").
doc_string(complexp, 'common-lisp', function, "Return true if OBJECT is a COMPLEX, and NIL otherwise.").
doc_string(concatenate, 'common-lisp', function, "Args: (type &rest sequences)\nReturns a new sequence of the specified type, consisting of all elements of\nSEQUENCEs.").
doc_string(concatenate, 'common-lisp', function, "Return a new sequence of all the argument sequences concatenated together\n  which shares no structure with the original argument sequences of the\n  specified OUTPUT-TYPE-SPEC.").
doc_string(concatenate, 'sb-sequence', function, "Implements CL:CONCATENATE for extended sequences.\n\n    RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:CONCATENATE\n    but receives a prototype instance of an extended sequence class\n    instead of a type specifier. By dispatching on RESULT-PROTOTYPE,\n    methods on this generic function specify how extended sequence\n    classes act when they are specified as the result type in a\n    CL:CONCATENATE call. RESULT-PROTOTYPE may not be fully initialized\n    and thus should only be used for dispatch and to determine its\n    class.").
doc_string(cond, 'common-lisp', function, "Syntax: (cond {(test {form}*)}*)\nEvaluates TESTs in order until one evaluates to non-NIL.  Then evaluates FORMs\nin order that follow the TEST and returns all values of the last FORM.  If no\nforms follow the TEST, then returns the value of the TEST.  Returns NIL, if no\nTESTs evaluates to non-NIL.").
doc_string(conjugate, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the complex conjugate of NUMBER.  Returns NUMBER if it is not a\ncomplex number.\n").
doc_string(conjugate, 'common-lisp', function, "Return the complex conjugate of NUMBER. For non-complex numbers, this is\n  an identity.").
doc_string(cons, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nReturns a new cons whose car and cdr are X and Y respectively.\n").
doc_string(cons, 'common-lisp', function, "Return a list with SE1 as the CAR and SE2 as the CDR.").
doc_string(consp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a cons; NIL otherwise.\n").
doc_string(consp, 'common-lisp', function, "Return true if OBJECT is a CONS, and NIL otherwise.").
doc_string(constantly, 'common-lisp', function, "Args: (n)\nBuilds a new function which accepts any number of arguments but always outputs N.").
doc_string(constantly, 'common-lisp', function, "Return a function that always returns VALUE.").
doc_string(constantp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if WAM-CL is sure that X, when given as a form, always evaluates to a\nsame value.  Returns NIL otherwise.  Typically used to check whether a symbol\nnames a constant variable.\n").
doc_string(constantp, 'common-lisp', function, "True of any FORM that has a constant value: self-evaluating objects,\nkeywords, defined constants, quote forms. Additionally the\nconstant-foldability of some function calls special forms is recognized. If\nENVIRONMENT is provided the FORM is first macroexpanded in it.").
doc_string(continue, 'common-lisp', function, "Transfer control to a restart named CONTINUE, or return NIL if none exists.").
doc_string(cos, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (RADIANS)\n\nReturns the cosine of RADIANS.\n").
doc_string(cos, 'common-lisp', function, "Return the cosine of NUMBER.").
doc_string(cosh, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the hyperbolic cosine of NUMBER.\n").
doc_string(cosh, 'common-lisp', function, "Return the hyperbolic cosine of NUMBER.").
doc_string(count, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the number of elements in SEQUENCE satisfying TEST with ITEM as the\nfirst argument.\n").
doc_string(count, 'common-lisp', function, "Return the number of elements in SEQUENCE satisfying a test with ITEM,\n   which defaults to EQL.").
doc_string(ctypecase, 'common-lisp', function, "CTYPECASE Keyform {(Type Form*)}*\n  Evaluates the Forms in the first clause for which TYPEP of Keyform and Type\n  is true. If no form is satisfied then a correctable error is signalled.").
doc_string(ctypecase, 'common-lisp', function, "Syntax: (ctypecase place {(type {form}*)}*)\nSearches a TYPE to which the value of PLACE belongs.  If found, then evaluates\nFORMs that follow the TYPE and returns all values of the last FORM.  If no\nsuch TYPE is found, signals a continuable error.  Before continuing, receives\na new value of PLACE from the user and searches an appropriate TYPE again.\nRepeats this process until the value of PLACE becomes of one of the TYPEs.").
doc_string(decf, 'common-lisp', function, "Syntax: (decf place [form])\nDecrements the value of PLACE by the value of FORM.  FORM defaults to 1.").
doc_string(decf, 'common-lisp', function, "The first argument is some location holding a number. This number is\n  decremented by the second argument, DELTA, which defaults to 1.").
doc_string(declaim, 'common-lisp', function, "DECLAIM Declaration*\n  Do a declaration or declarations for the global environment.").
doc_string(declare, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (declare {decl-spec}*)\n\nGives declarations.  Possible DECL-SPECs are:\n  (SPECIAL {var}*)\n  (TYPE type {var}*)\n  (type {var}*) where 'type' is one of the following symbols\n        array           fixnum          package         simple-string\n        atom            float           pathname        simple-vector\n        bignum          function        random-state    single-float\n        bit             hash-table      ratio           standard-char\n        bit-vector      integer         rational        stream\n        character       keyword         readtable       string\n        common          list            sequence        string-char\n        compiled-function  long-float   short-float     symbol\n        complex         nil             signed-byte     t\n        cons            null            simple-array    unsigned-byte\n        double-float    number          simple-bit-vector  vector\n  (OBJECT {var}*)\n  (FTYPE type {function-name}*)\n  (FUNCTION function-name ({arg-type}*) {return-type}*)\n  (INLINE {function-name}*)\n  (NOTINLINE {function-name}*)\n  (IGNORE {var}*)\n  (OPTIMIZE {({SPEED | SPACE | SAFETY | COMPILATION-SPEED} {0 | 1 | 2 | 3})}*)\n  (DECLARATION {non-standard-decl-name}*)\n  (:READ-ONLY {variable-name}*).\n").
doc_string(defcas, pkg_sys, function, "Analogous to short-form DEFSETF. Defines FUNCTION as responsible\nfor compare-and-swap on places accessed using ACCESSOR. LAMBDA-LIST\nmust correspond to the lambda-list of the accessor.\n\nNote that the system provides no automatic atomicity for CAS expansions\nresulting from DEFCAS, nor can it verify that they are atomic: it is up to the\nuser of DEFCAS to ensure that the function specified is atomic.\n\nEXPERIMENTAL: Interface subject to change.").
doc_string(defcbody, ffi, function, "Syntax: (defcbody symbol (&rest arg-types) result-type &body body)").
doc_string(defconstant, 'common-lisp', function, "Define a global constant, saying that the value is constant and may be\n  compiled into code. If the variable already has a value, and this is not\n  EQL to the new value, the code is not portable (undefined behavior). The\n  third argument is an optional documentation string for the variable.").
doc_string(defconstant, 'common-lisp', function, "Syntax: (defconstant symbol form [doc])\n\nDeclares that the global variable named by SYMBOL is a constant with the value\nof FORM as its constant value.  The doc-string DOC, if supplied, is saved as a\nVARIABLE doc and can be retrieved by (DOCUMENTATION 'SYMBOL 'VARIABLE).").
doc_string(defentry, ffi, function, "Syntax: (defentry symbol (&rest arg-types*) (result-type function-name))\n\nThe compiler defines a Lisp function named by SYMBOL whose body consists of a\ncalling sequence to the C language function named by FUNCTION-NAME.  The\ninterpreter ignores this form.  ARG-TYPEs are argument types of the C function\nand VALUE-TYPE is the return type of the C function.  Symbols OBJECT, INT,\nCHAR, CHAR*, FLOAT, DOUBLE are allowed for these types.").
doc_string(defglobal, pkg_sys, function, "Defines NAME as a global variable that is always bound. VALUE is evaluated\nand assigned to NAME both at compile- and load-time, but only if NAME is not\nalready bound.\n\nGlobal variables share their values between all threads, and cannot be\nlocally bound, declared special, defined as constants, and neither bound\nnor defined as symbol macros.\n\nSee also the declarations SB-EXT:GLOBAL and SB-EXT:ALWAYS-BOUND.").
doc_string(definline, ffi, function, "Syntax: (definline symbol (&rest arg-types) result-type &body body) ").
doc_string(defla, ffi, function, "Syntax: (defla name lambda-list &body body)").
doc_string(defmacro, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (defmacro name defmacro-lambda-list {decl | doc}* {form}*)\nDefines a global macro named by NAME.  The complete syntax of DEFMACRO-LAMBDA-\nLIST is:\n        ( [&whole var] [&environment var] . pvar )\nwhere PVAR may be a symbol,\n        ( {pvar}* [&optional {var | (pvar [init [pvar]])}*] . var )\nor\n        ( {pvar}*\n          [&optional {var | (pvar [init [pvar]])}*]\n          [{&rest | &body} pvar]\n          [&key {var | ({var | (keyword pvar)} [init [pvar]])}*\n                [&allow-other-keys]]\n          [&aux {var | (pvar [init])}*] )\nThe doc-string DOC, if supplied, is saved as a FUNCTION doc and can be\nretrieved by (documentation 'NAME 'function).  See LIST for the backquote\nmacro useful for defining macros.\n").
doc_string(defpackage, 'common-lisp', function, "Defines a new package called PACKAGE. Each of OPTIONS should be one of the\n   following:\n    (USE {package-name}*)\n    (EXPORT {symbol-name}*)\n    (IMPORT-FROM <package-name> {symbol-name}*)\n    (SHADOW {symbol-name}*)\n    (SHADOWING-IMPORT-FROM <package-name> {symbol-name}*)\n    (LOCAL-NICKNAMES {local-nickname actual-package-name}*)\n    (LOCK boolean)\n    (IMPLEMENT {package-name}*)\n    (DOCUMENTATION doc-string)\n    (INTERN {symbol-name}*)\n    (SIZE <integer>)\n    (NICKNAMES {package-name}*)\n   All options except SIZE, LOCK, and :DOCUMENTATION can be used multiple\n   times.").
doc_string(defpackage, 'common-lisp', function, "DEFPACKAGE - DEFINED-PACKAGE-NAME {OPTION}*                     [Macro]\n\n   This creates a new package, or modifies an existing one, whose name is\n   DEFINED-PACKAGE-NAME.  The DEFINED-PACKAGE-NAME may be a string or a\n   symbol; if it is a symbol, only its print name matters, and not what\n   package, if any, the symbol happens to be in.  The newly created or\n   modified package is returned as the value of the DEFPACKAGE form.\n\n   Each standard OPTION is a list of keyword (the name of the option)\n   and associated arguments.  No part of a DEFPACKAGE form is evaluated.\n   Except for the :SIZE and :DOCUMENTATION options, more than one option\n   of the same kind may occur within the same DEFPACKAGE form.\n\n  Valid Options:\n        (:documentation         string)\n        (:size                  integer)\n        (:nicknames             {package-name}*)\n        (:shadow                {symbol-name}*)\n        (:shadowing-import-from package-name {symbol-name}*)\n        (:use                   {package-name}*)\n        (:import-from           package-name {symbol-name}*)\n        (:intern                {symbol-name}*)\n        (:export                {symbol-name}*)\n        (:export-from           {package-name}*)\n\n  [Note: :EXPORT-FROM is an extension to DEFPACKAGE.\n         If a symbol is interned in the package being created and\n         if a symbol with the same print name appears as an external\n         symbol of one of the packages in the :EXPORT-FROM option,\n         then the symbol is exported from the package being created.\n\n         :DOCUMENTATION is an extension to DEFPACKAGE.\n\n         :SIZE is used only in Genera and Allegro.]").
doc_string(defparameter, 'common-lisp', function, "Define a parameter that is not normally changed by the program,\n  but that may be changed without causing an error. Declare the\n  variable special and sets its value to VAL, overwriting any\n  previous value. The third argument is an optional documentation\n  string for the parameter.").
doc_string(defparameter, 'common-lisp', function, "Syntax: (defparameter name form [doc])\nDeclares the global variable named by NAME as a special variable and assigns\nthe value of FORM to the variable.  The doc-string DOC, if supplied, is saved\nas a VARIABLE doc and can be retrieved by (documentation 'NAME 'variable).").
doc_string(defsetf, 'common-lisp', function, "Associates a SETF update function or macro with the specified access\n  function or macro. The format is complex. See the manual for details.").
doc_string(defsetf, 'common-lisp', function, "Syntax: (defsetf symbol update-fun [doc])\n        or\n        (defsetf symbol lambda-list (store-var) {decl | doc}* {form}*)\nDefines an expansion\n        (setf (SYMBOL arg1 ... argn) value)\n        => (UPDATE-FUN arg1 ... argn value)\n           or\n           (let* ((temp1 ARG1) ... (tempn ARGn) (temp0 value)) rest)\nwhere REST is the value of the last FORM with parameters in LAMBDA-LIST bound\nto the symbols TEMP1 ... TEMPn and with STORE-VAR bound to the symbol TEMP0.\nThe doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved\nby (documentation 'SYMBOL 'setf).").
doc_string(defstruct, 'common-lisp', function, "DEFSTRUCT {Name | (Name Option*)} [Documentation] {Slot | (Slot [Default] {Key Value}*)}\n   Define the structure type Name. Instances are created by MAKE-<name>,\n   which takes &KEY arguments allowing initial slot values to the specified.\n   A SETF'able function <name>-<slot> is defined for each slot to read and\n   write slot values. <name>-p is a type predicate.\n\n   Popular DEFSTRUCT options (see manual for others):\n\n   (:CONSTRUCTOR Name)\n   (:PREDICATE Name)\n       Specify the name for the constructor or predicate.\n\n   (:CONSTRUCTOR Name Lambda-List)\n       Specify the name and arguments for a BOA constructor\n       (which is more efficient when keyword syntax isn't necessary.)\n\n   (:INCLUDE Supertype Slot-Spec*)\n       Make this type a subtype of the structure type Supertype. The optional\n       Slot-Specs override inherited slot options.\n\n   Slot options:\n\n   :TYPE Type-Spec\n       Asserts that the value of this slot is always of the specified type.\n\n   :READ-ONLY {T | NIL}\n       If true, no setter function is defined for this slot.").
doc_string(defstruct, 'common-lisp', function, "Syntax: (defstruct\n         {name | (name {:conc-name | (:conc-name prefix-string) |\n                        :constructor | (:constructor symbol [lambda-list]) |\n                        :copier | (:copier symbol) |\n                        :predicate | (:predicate symbol) |\n                        (:include symbol) |\n                        (:print-function function) |\n                        (:print-object function) |\n                        (:type {vector | (vector type) | list}) |\n                        :named |\n                        (:initial-offset number)}*)}\n         [doc]\n         {slot-name |\n          (slot-name [default-value-form] {:type type | :read-only flag}*) }*\n         )\nDefines a structure named by NAME.  The doc-string DOC, if supplied, is saved\nas a STRUCTURE doc and can be retrieved by (documentation 'NAME 'structure).").
doc_string(deftype, 'common-lisp', function, "Define a new type, with syntax like DEFMACRO.").
doc_string(deftype, 'common-lisp', function, "Syntax: (deftype name lambda-list {decl | doc}* {form}*)\nDefines a new type-specifier abbreviation in terms of an 'expansion' function\n        (lambda lambda-list1 {DECL}* {FORM}*)\nwhere LAMBDA-LIST1 is identical to LAMBDA-LIST except that all optional\nparameters with no default value specified in LAMBDA-LIST defaults to the\nsymbol '*', but not to NIL.  When the type system of WAM-CL encounters a type\nspecifier (NAME arg1 ... argn), it calls the expansion function with the\narguments ARG1 ... ARGn, and uses the returned value instead of the original\ntype specifier.  When the symbol NAME is used as a type specifier, the\nexpansion function is called with no argument.\nThe doc-string DOC, if supplied, is saved as a TYPE doc and can be retrieved\nby (documentation 'NAME 'type).").
doc_string(defun, 'common-lisp', function, "Define a function at top level.").
doc_string(defun, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (defun name lambda-list {decl | doc}* {form}*)\nDefines a global function named by NAME.\nThe complete syntax of a lambda-list is:\n        ({var}*\n         [&optional {var | (var [init [svar]])}*]\n         [&rest var]\n         [&key {var | ({var | (keyword var)} [init [svar]])}*\n               [&allow-other-keys]]\n         [&aux {var | (var [init])}*])\nThe doc-string DOC, if supplied, is saved as a FUNCTION doc and can be\nretrieved by (documentation 'NAME 'function).\n").
doc_string(defvar, 'common-lisp', function, "Define a special variable at top level. Declare the variable\n  SPECIAL and, optionally, initialize it. If the variable already has a\n  value, the old value is not clobbered. The third argument is an optional\n  documentation string for the variable.").
doc_string(defvar, 'common-lisp', function, "Syntax: (defvar name [form [doc]])\nDeclares the variable named by NAME as a special variable.  If the variable\ndoes not have a value, then evaluates FORM and assigns the value to the\nvariable.  FORM defaults to NIL.  The doc-string DOC, if supplied, is saved\nas a VARIABLE doc and can be retrieved by (documentation 'NAME 'variable).").
doc_string(delete, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nDestructive REMOVE.  SEQUENCE may be destroyed.\n").
doc_string(delete, 'common-lisp', function, "Return a sequence formed by destructively removing the specified ITEM from\n  the given SEQUENCE.").
doc_string(denominator, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (RATIONAL)\n\nReturns the denominator of RATIONAL as a positive integer, if RATIONAL is a\nratio.  Returns RATIONAL if it is an integer.\n").
doc_string(denominator, 'common-lisp', function, "Return the denominator of NUMBER, which must be rational.").
doc_string(deref, 'sb-alien', function, "Dereference an Alien pointer or array. If an array, the indices are used\n   as the indices of the array element to access. If a pointer, one index can\n   optionally be specified, giving the equivalent of C pointer arithmetic.").
doc_string(describe, 'common-lisp', function, "Args: (object &optional (stream *standard-output*))\nPrints information about OBJECT to STREAM.").
doc_string(describe, 'common-lisp', function, "Print a description of OBJECT to STREAM-DESIGNATOR.").
doc_string(directory, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns a list of full pathnames of all those files that match FILESPEC.\nFILESPEC may be a symbol, a string, a pathname, or a file stream.\n").
doc_string(directory, 'common-lisp', function, "Return a list of PATHNAMEs, each the TRUENAME of a file that matched the\ngiven pathname. Note that the interaction between this ANSI-specified\nTRUENAMEing and the semantics of the Unix filesystem (symbolic links..) means\nthis function can sometimes return files which don't have the same directory\nas PATHNAME. If :RESOLVE-SYMLINKS is NIL, don't resolve symbolic links in\nmatching filenames.").
doc_string(disassemble, 'common-lisp', function, "\r\ndisassemble the OBJECT, which should be a function.\r\nif QUALIFIERS or SPECIALIZERS is given, OBJECT should be a generic function.").
doc_string(disassemble, 'common-lisp', function, "Disassemble the compiled code associated with OBJECT, which can be a\n  function, a lambda expression, or a symbol with a function definition. If\n  it is not already compiled, the compiler is called to produce something to\n  disassemble.").
doc_string(do, 'common-lisp', function, "DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form*\n  Iteration construct. Each Var is initialized in parallel to the value of the\n  specified Init form. On subsequent iterations, the Vars are assigned the\n  value of the Step form (if any) in parallel. The Test is evaluated before\n  each evaluation of the body Forms. When the Test is true, the Exit-Forms\n  are evaluated as a PROGN, with the result being the value of the DO. A block\n  named NIL is established around the entire expansion, allowing RETURN to be\n  used as an alternate exit mechanism.").
doc_string(do, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (do ({(var [init [step]])}*) (test {result}*)\n          {decl}* {tag | statement}*)\n\nEstablishes a NIL block, binds each VAR to the value of the corresponding INIT\n(which defaults to NIL), and then executes STATEMENTs repeatedly until TEST is\nsatisfied.  After each iteration, evaluates STEP and assigns the value to the\ncorresponding VAR.  No assignment occurs for those VARs to which STEP is not\ngiven.  When TEST is satisfied, evaluates RESULTs as a PROGN and returns all\nvalues of the last RESULT.  Performs variable bindings and assignments in\nparallel, just as LET and PSETQ do.\n").
doc_string(documentation, 'common-lisp', function, "Return the documentation string of Doc-Type for X, or NIL if none\nexists. System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T.\n\nFunction documentation is stored separately for function names and objects:\nDEFUN, LAMBDA, &co create function objects with the specified documentation\nstrings.\n\n (SETF (DOCUMENTATION NAME 'FUNCTION) STRING)\n\nsets the documentation string stored under the specified name, and\n\n (SETF (DOCUMENTATION FUNC T) STRING)\n\nsets the documentation string stored in the function object.\n\n (DOCUMENTATION NAME 'FUNCTION)\n\nreturns the documentation stored under the function name if any, and\nfalls back on the documentation in the function object if necessary.").
doc_string(dolist, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: ((VAR FORM &OPTIONAL RESULT) &BODY FORMS)\nEstablishes a NIL block and executes STATEMENTs once for each member of the\nlist value of FORM, with VAR bound to the member.  Then evaluates RESULT\n(which defaults to NIL) and returns all values.\n").
doc_string(dosequence, 'sb-sequence', function, "Executes BODY with ELEMENT subsequently bound to each element of\n  SEQUENCE, then returns RETURN.").
doc_string(dotimes, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: ((VAR FORM &OPTIONAL RESULT) &BODY FORMS)\nEstablishes a NIL block and executes STATEMENTs once for each integer between\n0 (inclusive) and the value of FORM (exclusive), with VAR bound to the\ninteger.  Then evaluates RESULT (which defaults to NIL) and returns all\nvalues.\n").
doc_string(dpb, 'common-lisp', function, "Args: (newbyte bytespec integer)\nReplaces the specified byte of INTEGER with NEWBYTE (an integer) and returns\nthe result.").
doc_string(dpb, 'common-lisp', function, "Return new integer with newbyte in specified position, newbyte is right justified.").
doc_string(dribble, 'common-lisp', function, "Args: (&optional filespec)\nIf FILESPEC is given, starts recording the interaction to the specified file.\nFILESPEC may be a symbol, a string, a pathname, or a file stream.  If FILESPEC\nis not given, ends the recording.").
doc_string(dribble, 'common-lisp', function, "With a file name as an argument, dribble opens the file and sends a\n  record of further I/O to that file. Without an argument, it closes\n  the dribble file, and quits logging.").
doc_string(ecase, 'common-lisp', function, "ECASE Keyform {({(Key*) | Key} Form*)}*\n  Evaluates the Forms in the first clause with a Key EQL to the value of\n  Keyform. If none of the keys matches then an error is signalled.").
doc_string(ecase, 'common-lisp', function, "Syntax: (ecase keyform {({key | ({key}*)} {form}*)}*)\nEvaluates KEYFORM and tries to find the KEY that is EQL to the value of\nKEYFORM.  If found, then evaluates FORMs that follow the KEY (or the key list\nthat contains the KEY) and returns all values of the last FORM.  If not,\nsignals an error.").
doc_string(ed, 'common-lisp', function, "Args: (&optional filename)\nInvokes the editor.  The action depends on the version of WAM-CL.  See the WAM-CL\nReport for details.").
doc_string(ed, 'common-lisp', function, "Starts the editor (on a file or a function if named).  Functions\nfrom the list *ED-FUNCTIONS* are called in order with X as an argument\nuntil one of them returns non-NIL; these functions are responsible for\nsignalling a FILE-ERROR to indicate failure to perform an operation on\nthe file system.").
doc_string(eighth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CADDDR (CDDDDR X)).\n").
doc_string(eighth, 'common-lisp', function, "Return the 8th object in a list or NIL if there is no 8th object.").
doc_string(elt, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE N)\n\nReturns the N-th element of SEQUENCE.\n").
doc_string(elt, 'common-lisp', function, "Return the element of SEQUENCE specified by INDEX.").
doc_string(elt, 'sb-sequence', function, "Returns the element at position INDEX of SEQUENCE or signals a\n   PROTOCOL-UNIMPLEMENTED error if the sequence protocol is not\n   implemented for the class of SEQUENCE.").
doc_string(emptyp, 'sb-impl', function, "Returns T if SEQUENCE is an empty sequence and NIL\n   otherwise. Signals an error if SEQUENCE is not a sequence.").
doc_string(emptyp, 'sb-sequence', function, "Returns T if SEQUENCE is an empty sequence and NIL\n   otherwise. Signals an error if SEQUENCE is not a sequence.").
doc_string(endp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is NIL.  Returns NIL if X is a cons.  Otherwise, signals an\nerror.\n").
doc_string(endp, 'common-lisp', function, "This is the recommended way to test for the end of a proper list. It\n   returns true if OBJECT is NIL, false if OBJECT is a CONS, and an error\n   for any other type of OBJECT.").
doc_string(eq, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nReturns T if the args are identical; NIL otherwise.\n").
doc_string(eq, 'common-lisp', function, "Return T if OBJ1 and OBJ2 are the same object, otherwise NIL.").
doc_string(eql, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nReturns T if the args satisfy one of the following conditions.\n        1. identical\n        2. are numbers of the same type with the same value\n        3. are characters that represent the same character\nReturns NIL otherwise.\n").
doc_string(equal, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nReturns T if the args satisfy one of the following conditions.\n        1. EQL\n        2. are conses with EQUAL cars and EQUAL cdrs\n        3. are strings of the same length and element-wise EQL\n        4. are bit-vectors of the same length and element-wise EQL\n        5. are pathnames with EQUAL slots\nReturns NIL otherwise.\n").
doc_string(equal, 'common-lisp', function, "Return T if X and Y are EQL or if they are structured components whose\nelements are EQUAL. Strings and bit-vectors are EQUAL if they are the same\nlength and have identical components. Other arrays must be EQ to be EQUAL.").
doc_string(equalp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nReturns T if the args satisfy one of the following conditions.\n        1. EQUAL\n        2. are characters that satisfy CHARACTER-EQUAL\n        3. are numbers that satisfy =\n        4. are conses with EQUALP cars and EQUALP cdrs\n        5. are arrays of the same dimensions and element-wise EQUALP\nReturns NIL otherwise.\n").
doc_string(error, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FORMAT-STRING &REST ARGS)\n\nSignals an error.  The args are FORMATed to *error-output*.\n").
doc_string(error, 'common-lisp', function, "Invoke the signal facility on a condition formed from DATUM and ARGUMENTS.\n  If the condition is not handled, the debugger is invoked.").
doc_string(etypecase, 'common-lisp', function, "ETYPECASE Keyform {(Type Form*)}*\n  Evaluates the Forms in the first clause for which TYPEP of Keyform and Type\n  is true. If no form is satisfied then an error is signalled.").
doc_string(etypecase, 'common-lisp', function, "Syntax: (etypecase keyform {(type {form}*)}*)\nEvaluates KEYFORM and searches a TYPE to which the value of KEYFORM belongs.\nIf found, then evaluates FORMs that follow the TYPE and returns all values of\nthe last FORM.  If not, signals an error.").
doc_string(eval, 'common-lisp', function, "Evaluate the argument in a null lexical environment, returning the\n   result or results.").
doc_string(eval, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FORM)\n\nEvaluates FORM and returns all values.\n").
doc_string(evenp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER)\n\nReturns T if INTEGER is an even number; NIL otherwise.\n").
doc_string(evenp, 'common-lisp', function, "Is this integer even?").
doc_string(every, 'common-lisp', function, "Apply PREDICATE to the 0-indexed elements of the sequences, then\n   possibly to those with index 1, and so on. Return NIL as soon\n   as any invocation of PREDICATE returns NIL, or T if every invocation\n   is non-NIL.").
doc_string(every, 'common-lisp', function, "Args: (predicate sequence &rest more-sequences)\nReturns T if every elements of SEQUENCEs satisfy PREDICATE; NIL otherwise.").
doc_string(exit, pkg_sys, function, "Terminates the process, causing SBCL to exit with CODE. CODE\ndefaults to 0 when ABORT is false, and 1 when it is true.\n\nWhen ABORT is false (the default), current thread is first unwound,\n*EXIT-HOOKS* are run, other threads are terminated, and standard\noutput streams are flushed before SBCL calls exit(3) -- at which point\natexit(3) functions will run. If multiple threads call EXIT with ABORT\nbeing false, the first one to call it will complete the protocol.\n\nWhen ABORT is true, SBCL exits immediately by calling _exit(2) without\nunwinding stack, or calling exit hooks. Note that _exit(2) does not\ncall atexit(3) functions unlike exit(3).\n\nRecursive calls to EXIT cause EXIT to behave as it ABORT was true.\n\nTIMEOUT controls waiting for other threads to terminate when ABORT is\nNIL. Once current thread has been unwound and *EXIT-HOOKS* have been\nrun, spawning new threads is prevented and all other threads are\nterminated by calling TERMINATE-THREAD on them. The system then waits\nfor them to finish using JOIN-THREAD, waiting at most a total TIMEOUT\nseconds for all threads to join. Those threads that do not finish\nin time are simply ignored while the exit protocol continues. TIMEOUT\ndefaults to *EXIT-TIMEOUT*, which in turn defaults to 60. TIMEOUT NIL\nmeans to wait indefinitely.\n\nNote that TIMEOUT applies only to JOIN-THREAD, not *EXIT-HOOKS*. Since\nTERMINATE-THREAD is asynchronous, getting multithreaded application\ntermination with complex cleanups right using it can be tricky. To\nperform an orderly synchronous shutdown use an exit hook instead of\nrelying on implicit thread termination.\n\nConsequences are unspecified if serious conditions occur during EXIT\nexcepting errors from *EXIT-HOOKS*, which cause warnings and stop\nexecution of the hook that signaled, but otherwise allow the exit\nprocess to continue normally.").
doc_string(exp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns E raised to the power NUMBER, where E is the base of natural\nlogarithms.\n").
doc_string(exp, 'common-lisp', function, "Return e raised to the power NUMBER.").
doc_string(export, 'common-lisp', function, "Exports SYMBOLS from PACKAGE, checking that no name conflicts result.").
doc_string(export, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (PACKAGE *PACKAGE*))\n\nRegister SYMBOL as an external symbol of PACKAGE.  SYMBOL may be a list of\nsymbols.\n").
doc_string(expt, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER1 NUMBER2)\n\nReturns NUMBER1 raised to the power NUMBER2.\n").
doc_string(expt, 'common-lisp', function, "Return BASE raised to the POWER.").
doc_string(fboundp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nReturns T if SYMBOL names a special form, a global macro, or a global\nfunction.  Returns NIL otherwise.\n").
doc_string(fboundp, 'common-lisp', function, "Return true if name has a global function definition.").
doc_string(fceiling, 'common-lisp', function, "Args: (number &optional (divisor 1))\nSame as CEILING, but returns a float as the first value.").
doc_string(fceiling, 'common-lisp', function, "Same as CEILING, but returns first value as a float.").
doc_string(fdefinition, 'common-lisp', function, "Return name's global function definition taking care to respect any\n   encapsulations and to return the innermost encapsulated definition.\n   This is SETF'able.").
doc_string(ffloor, 'common-lisp', function, "Args: (number &optional (divisor 1))\nSame as FLOOR, but returns a float as the first value.").
doc_string(ffloor, 'common-lisp', function, "Same as FLOOR, but returns first value as a float.").
doc_string(fifth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDDDDR X)).\n").
doc_string(fifth, 'common-lisp', function, "Return the 5th object in a list or NIL if there is no 5th object.").
doc_string(fill, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE ITEM &KEY (START 0) (END (LENGTH SEQUENCE)))\n\nReplaces the specified elements of SEQUENCE with ITEM.\n").
doc_string(fill, 'common-lisp', function, "Replace the specified elements of SEQUENCE with ITEM.").
doc_string(finalize, pkg_sys, function, "Arrange for the designated FUNCTION to be called when there\nare no more references to OBJECT, including references in\nFUNCTION itself.\n\nIf DONT-SAVE is true, the finalizer will be cancelled when\nSAVE-LISP-AND-DIE is called: this is useful for finalizers\ndeallocating system memory, which might otherwise be called\nwith addresses from the old image.\n\nIn a multithreaded environment FUNCTION may be called in any\nthread. In both single and multithreaded environments FUNCTION\nmay be called in any dynamic scope: consequences are unspecified\nif FUNCTION is not fully re-entrant.\n\nErrors from FUNCTION are handled and cause a WARNING to be\nsignalled in whichever thread the FUNCTION was called in.\n\nExamples:\n\n  ;;; GOOD, assuming RELEASE-HANDLE is re-entrant.\n  (let* ((handle (get-handle))\n         (object (make-object handle)))\n   (finalize object (lambda () (release-handle handle)))\n   object)\n\n  ;;; BAD, finalizer refers to object being finalized, causing\n  ;;; it to be retained indefinitely!\n  (let* ((handle (get-handle))\n         (object (make-object handle)))\n    (finalize object\n              (lambda ()\n                (release-handle (object-handle object)))))\n\n  ;;; BAD, not re-entrant!\n  (defvar *rec* nil)\n\n  (defun oops ()\n   (when *rec*\n     (error \"recursive OOPS\"))\n   (let ((*rec* t))\n     (gc))) ; or just cons enough to cause one\n\n  (progn\n    (finalize \"oops\" #'oops)\n    (oops)) ; GC causes re-entry to #'oops due to the finalizer\n            ; -> ERROR, caught, WARNING signalled").
doc_string(find, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the first element in SEQUENCE satisfying TEST with ITEM.  Returns NIL\nif no such element exists.\n").
doc_string(first, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to CAR.\n").
doc_string(first, 'common-lisp', function, "Return the 1st object in a list or NIL if the list is empty.").
doc_string(fixnump, 'sb-int', function, "Return true if OBJECT is a FIXNUM, and NIL otherwise.").
doc_string(fixnump, extensions, function, "Function in EXT package:\nArgs: (X)\n\nECL specific.\nReturns T if the X is a fixnum; NIL otherwise.\n").
doc_string(flet, 'common-lisp', function, "FLET ({(name lambda-list declaration* form*)}*) declaration* body-form*\n\nEvaluate the BODY-FORMS with local function definitions. The bindings do\nnot enclose the definitions; any use of NAME in the FORMS will refer to the\nlexically apparent function definition in the enclosing environment.").
doc_string(flet, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: ((&REST FUNCTIONS) &BODY FORMS)\n\nIntroduces local functions and evaluates BODY as a PROGN.  BODY is the scope\nof each local function but the local function definitions are not.  Thus each\nlocal function can reference externally defined functions of the same name as\nlocal functions.  Doc-strings for local functions are simply ignored.\n").
doc_string(float, 'common-lisp', function, "Converts any REAL to a float. If OTHER is not provided, it returns a\n  SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the\n  result is the same float format as OTHER.").
doc_string(float, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &OPTIONAL FLOAT)\n\nWith one arg, converts NUMBER to a single-float.  With two args, converts\nNUMBER to a float of the same float format as FLOAT.\n").
doc_string(floatp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a float; NIL otherwise.\n").
doc_string(floatp, 'common-lisp', function, "Return true if OBJECT is a FLOAT, and NIL otherwise.").
doc_string(floor, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &OPTIONAL (DIVISOR 1))\n\nReturns the largest integer not larger than the NUMBER divided by DIVISOR.\nReturns the value of (- NUMBER (* first-value DIVISOR)) as the second value.\n").
doc_string(floor, 'common-lisp', function, "Return the greatest integer not greater than number, or number/divisor.\n  The second returned value is (mod number divisor).").
doc_string(fmakunbound, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nRemoves the global function definition associated with SYMBOL.  Returns SYMBOL.\n").
doc_string(fmakunbound, 'common-lisp', function, "Make NAME have no global function definition.").
doc_string(format, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (DESTINATION FORMAT-STRING &REST ARGS)\n\nOutputs ARGs to DESTINATION in the format specified by FORMAT-STRING.  FORMAT-\nSTRING is a string consisting of characters to output and format directives\nwhich begin with '~~'.  Outputs to DESTINATION if it is a stream and to the\nstandard output if DESTINATION is T.  If DESTINATION is NIL, does not output\nactually but returns the output as a string.  Here are some format directives:\n        ~~A     PRINCs one arg\n        ~~S     PRIN1s one arg\n        ~~D     Prints one integer in decimal\n        ~~B     Prints one integer in binary\n        ~~O     Prints one integer in octal\n        ~~X     Prints one integer in hexa\n        ~~%     Does TERPRI\n        ~~&     Does FRESH-LINE\n        ~~|     Outputs #\\Page\n        ~~~~    Outputs '~~'\n").
doc_string(format, 'common-lisp', function, "Provides various facilities for formatting output.\n  CONTROL-STRING contains a string to be output, possibly with embedded\n  directives, which are flagged with the escape character \"~\". Directives\n  generally expand into additional text to be output, usually consuming one\n  or more of the FORMAT-ARGUMENTS in the process. A few useful directives\n  are:\n        ~A or ~nA   Prints one argument as if by PRINC\n        ~S or ~nS   Prints one argument as if by PRIN1\n        ~D or ~nD   Prints one argument as a decimal integer\n        ~%          Does a TERPRI\n        ~&          Does a FRESH-LINE\n  where n is the width of the field in which the object is printed.\n\n  DESTINATION controls where the result will go. If DESTINATION is T, then\n  the output is sent to the standard output stream. If it is NIL, then the\n  output is returned in a string as the value of the call. Otherwise,\n  DESTINATION must be a stream to which the output will be sent.\n\n  Example:   (FORMAT NIL \"The answer is ~D.\" 10) => \"The answer is 10.\"\n\n  FORMAT has many additional capabilities not described here. Consult the\n  manual for details.").
doc_string(fourth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to CADDDR.\n").
doc_string(fourth, 'common-lisp', function, "Return the 4th object in a list or NIL if there is no 4th object.").
doc_string(fround, 'common-lisp', function, "Args: (number &optional (divisor 1))\nSame as ROUND, but returns a float as the first value.").
doc_string(fround, 'common-lisp', function, "Same as ROUND, but returns first value as a float.").
doc_string(ftruncate, 'common-lisp', function, "Args: (number &optional (divisor 1))\nSame as TRUNCATE, but returns a float as the first value.").
doc_string(ftruncate, 'common-lisp', function, "Same as TRUNCATE, but returns first value as a float.").
doc_string(funcall, 'common-lisp', function, "Call FUNCTION with the given ARGUMENTS.").
doc_string(funcall, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION &REST ARGS)\n\nCalls FUNCTION with the ARGs as the arguments and returns all values that the\ncall returns.\n").
doc_string(function, 'common-lisp', function, "FUNCTION name\n\nReturn the lexically apparent definition of the function NAME. NAME may also\nbe a lambda expression.").
doc_string(function, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (FUNCTION-NAME)\n\nIf X is a lambda expression, (function x) creates and returns a lexical closure\nof X in the current lexical environment.  If X is a symbol that names a function,\nreturns that function definition.\n").
doc_string(functionp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is an object that can be used to specify a function to be\ninvoked by function-calling functions such as FUNCALL or APPLY.  Returns NIL\notherwise.\n").
doc_string(functionp, 'common-lisp', function, "Return true if OBJECT is a FUNCTION, and NIL otherwise.").
doc_string(gc, pkg_sys, function, "Initiate a garbage collection.\n\nThe default is to initiate a nursery collection, which may in turn\ntrigger a collection of one or more older generations as well. If FULL\nis true, all generations are collected. If GEN is provided, it can be\nused to specify the oldest generation guaranteed to be collected.\n\nOn CheneyGC platforms arguments FULL and GEN take no effect: a full\ncollection is always performed.").
doc_string(gc, extensions, function, "Function in EXT package:\nArgs: (X)\n\nECL specific.\nStarts garbage collection with the specified collection level.  If X is NIL,\ncollects only cells.  If X is T, collects everything.\n").
doc_string(gcd, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST INTEGERS)\n\nReturns the greatest common divisor of the args.\n").
doc_string(gcd, 'common-lisp', function, "Return the greatest common divisor of the arguments, which must be\n  integers. GCD with no arguments is defined to be 0.").
doc_string(gensym, 'common-lisp', function, "Creates a new uninterned symbol whose name is a prefix string (defaults\n   to \"G\"), followed by a decimal number. Thing, when supplied, will\n   alter the prefix if it is a string, or be used for the decimal number\n   if it is a number, of this symbol. The default value of the number is\n   the current value of *gensym-counter* which is incremented each time\n   it is used.").
doc_string(gensym, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (X NIL))\n\nCreates and returns a new uninterned symbol whose print name begins with some\nprefix (initially \"G\"), followed by a generation number.  The generation\nnumber is incremented by one at each call to GENSYM.  If X is an integer, it\nbecomes the new generation number.  If X is a string, it becomes the new\nprefix.\n").
doc_string(gentemp, 'common-lisp', function, "Creates a new symbol interned in package PACKAGE with the given PREFIX.").
doc_string(gentemp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STRING \"T\") (PACKAGE *PACKAGE*))\n\nCreates a new symbol interned in PACKAGE with PREFIX and returns the symbol.\nThe symbol is given a print name beginning with PREFIX followed by some\ngeneration number.\n").
doc_string(get, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL PROPERTY &OPTIONAL (DEFAULT NIL))\n\nSearches the symbol property of SYMBOL for a property that is EQ to PROPERTY.\nIf found, returns the value of the property.  Otherwise, returns DEFAULT.\n").
doc_string(get, 'common-lisp', function, "Look on the property list of SYMBOL for the specified INDICATOR. If this\n  is found, return the associated value, else return DEFAULT.").
doc_string(getcwd, extensions, function, "Function in EXT package:\nArgs: (&OPTIONAL (UPDATE-LISP T))\n\nReturns the current working directory of the C library. When UPDATE-LISP is\ntrue, *DEFAULT-PATHNAME-DEFAULTS* is set to this value.\n").
doc_string(getenv, extensions, function, "Function in EXT package:\nArgs: (STRING)\n\nECL/UNIX specific.\nReturns the environment with the name STRING as a string.  Returns NIL, if the\nspecified environment is not found.\n").
doc_string(getenv, extensions, function, "Return the value of the environment VARIABLE if it exists, otherwise return NIL.").
doc_string(getf, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (PLIST PROPERTY &OPTIONAL (DEFAULT NIL))\n\nSearches PLIST for a property that is EQ to PROPERTY.  If one is found,\nreturns the value of the property.  If not, returns DEFAULT.\nThe SETF form\n        (setf (getf place property-form) value-form)\nreplaces the property value of the plist stored in PLACE, or adds a new\nproperty if the plist does not have the property yet.\n").
doc_string(getf, 'common-lisp', function, "Search the property list stored in PLACE for an indicator EQ to INDICATOR.\n  If one is found, return the corresponding value, else return DEFAULT.").
doc_string(gethash, 'common-lisp', function, "Finds the entry in HASH-TABLE whose key is KEY and returns the\nassociated value and T as multiple values, or returns DEFAULT and NIL\nif there is no such entry. Entries can be added using SETF.").
doc_string(gethash, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (KEY HASH-TABLE &OPTIONAL (DEFAULT NIL))\n\nSearches HASH-TABLE for the entry of KEY.  If found, returns the value of the\nentry and T, as two values.  If not, returns DEFAULT and NIL.\n").
doc_string(gethash, 'common-lisp', function, "Returns the value associated with KEY in HASH-TABLE.").
doc_string(go, 'common-lisp', function, "GO tag\n\nTransfer control to the named TAG in the lexically enclosing TAGBODY. This is\nconstrained to be used only within the dynamic extent of the TAGBODY.").
doc_string(go, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (TAG)\n\nJumps to TAG.  See TAGBODY.\n").
doc_string(graphemes, 'sb-unicode', function, "Breaks STRING into graphemes acording to the default\ngrapheme breaking rules specified in UAX #29, returning a list of strings.").
doc_string(help, si, function, "Args: (&optional symbol)\nECL specific.\nPrints the documentation associated with SYMBOL.  With no args, prints the\ngreeting message to WAM-CL beginners.\n\nWelcome to WAM-CL. Here are the few functions you should learn first.\n\n        (HELP symbol) prints the online documentation associated with the\n        symbol.  For example, (HELP 'CONS) will print the useful information\n        about the CONS function, the CONS data type, and so on.\n\n        (HELP* string) prints the online documentation associated with those\n        symbols whose print-names have the string as substring.  For example,\n        (HELP* \"PROG\") will print the documentation of the symbols such as\n        PROG, PROGN, and MULTIPLE-VALUE-PROG1.\n\n        (QUIT) ends the current WAM-CL session.\n\nFor the precise language specification, refer to Guy Steele's \"Common Lisp,\nthe Language\" and our \"WAM-CL Manual\".  \"WAM-CL Dictionary\", the hard-copied\nversion of WAM-CL online documentation, will be useful as a handbook.\n\nGood luck!\n").
doc_string(identity, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns X.\n").
doc_string(identity, 'common-lisp', function, "This function simply returns what was passed to it.").
doc_string(if, 'common-lisp', function, "IF predicate then [else]\n\nIf PREDICATE evaluates to true, evaluate THEN and return its values,\notherwise evaluate ELSE and return its values. ELSE defaults to NIL.").
doc_string(if, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (TEST TRUE-FORM &OPTIONAL FALSE-FORM)\n\nIf TEST evaluates to non-NIL, then evaluates FORM1 and returns all values.\nOtherwise, evaluates FORM2 (which defaults to NIL) and returns all values.\n").
doc_string(imagpart, 'common-lisp', function, "Extract the imaginary part of a number.").
doc_string(imagpart, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the imagpart of NUMBER if it is a complex.  Otherwise, returns zero of\nthe same type as NUMBER.\n").
doc_string(import, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (PACKAGE *PACKAGE*))\n\nRegisters SYMBOL to PACKAGE as an internal symbol.  Does nothing if SYMBOL is\nalready registered in PACKAGE.  SYMBOL may be a list of symbols.\n").
doc_string(import, 'common-lisp', function, "Make SYMBOLS accessible as internal symbols in PACKAGE. If a symbol is\nalready accessible then it has no effect. If a name conflict would result from\nthe importation, then a correctable error is signalled.").
doc_string(incf, 'common-lisp', function, "Syntax: (incf place [form])\nIncrements the value of PLACE by the value of FORM.  FORM defaults to 1.").
doc_string(incf, 'common-lisp', function, "The first argument is some location holding a number. This number is\n  incremented by the second argument, DELTA, which defaults to 1.").
doc_string(inst, 'sb-assem', function, "Emit the specified instruction to the current segment.").
doc_string(instancep, si, function, "Function in SI package:\nArgs: (OBJECT)\n\nECL/CLOS specific.\nReturns T if OBJECT is of instance type.\n").
doc_string(integerp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is an integer; NIL otherwise.\n").
doc_string(integerp, 'common-lisp', function, "Return true if OBJECT is an INTEGER, and NIL otherwise.").
doc_string(intern, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (STRING &OPTIONAL (PACKAGE *PACKAGE*))\n\nSearches PACKAGE for a symbol whose print name is STRING.  If such a symbol is\nfound, returns the symbol and, as the second value, one of the keywords\n:INTERNAL, :EXTERNAL, and :INHERITED.  Otherwise, creates and returns a new\nsymbol and, as the second value, returns NIL.\n").
doc_string(intern, 'common-lisp', function, "Return a symbol in PACKAGE having the specified NAME, creating it\n  if necessary.").
doc_string(intersection, 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nReturns a list consisting of those objects that are elements of both LIST1 and\nLIST2.").
doc_string(intersection, 'common-lisp', function, "Return the intersection of LIST1 and LIST2.").
doc_string(isqrt, 'common-lisp', function, "Args: (integer)\nReturns the integer square root of INTEGER.").
doc_string(isqrt, 'common-lisp', function, "Return the greatest integer less than or equal to the square root of N.").
doc_string(keywordp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a symbol that belongs to the KEYWORD package; NIL otherwise.\n").
doc_string(keywordp, 'common-lisp', function, "Return true if Object is a symbol in the \"KEYWORD\" package.").
doc_string(labels, 'common-lisp', function, "LABELS ({(name lambda-list declaration* form*)}*) declaration* body-form*\n\nEvaluate the BODY-FORMS with local function definitions. The bindings enclose\nthe new definitions, so the defined functions can call themselves or each\nother.").
doc_string(labels, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: ((&REST FUNCTIONS) &BODY FORMS)\n\nIntroduces local functions and evaluates BODY as a PROGN.  The scope of each\nlocal function include the local function definitions.  Thus self- and mutual-\nrecursive local functions can be defined.  Doc-strings for local functions are\nsimply ignored.\n").
doc_string(last, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST)\n\nReturns the last cons that constitute LIST.  Returns NIL if LIST is NIL.\n").
doc_string(last, 'common-lisp', function, "Return the last N conses (not the last element!) of a list.").
doc_string(lcm, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER &REST MORE-INTEGERS)\n\nReturns the least common multiple of the args.  Returns 0 if at least one of\nthe args is 0.\n").
doc_string(lcm, 'common-lisp', function, "Return the least common multiple of one or more integers. LCM of no\n  arguments is defined to be 1.").
doc_string(ldb, 'common-lisp', function, "Args: (bytespec integer)\nExtracts a byte from INTEGER at the specified byte position, right-justifies\nthe byte, and returns the result as an integer.").
doc_string(ldb, 'common-lisp', function, "Extract the specified byte from integer, and right justify result.").
doc_string(ldiff, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST X)\n\nIf X is a cons that constitutes LIST, then returns a new list consisting of\nthose elements of LIST that appear before X.  Otherwise, returns a copy of\nLIST.\n").
doc_string(ldiff, 'common-lisp', function, "Return a new list, whose elements are those of LIST that appear before\n   OBJECT. If OBJECT is not a tail of LIST, a copy of LIST is returned.\n   LIST must be a proper list or a dotted list.").
doc_string(length, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE)\n\nReturns the length of SEQUENCE.\n").
doc_string(length, 'common-lisp', function, "Return an integer that is the length of SEQUENCE.").
doc_string(length, 'sb-sequence', function, "Returns the length of SEQUENCE or signals a PROTOCOL-UNIMPLEMENTED\n   error if the sequence protocol is not implemented for the class of\n   SEQUENCE.").
doc_string(let, 'common-lisp', function, "LET ({(var [value]) | var}*) declaration* form*\n\nDuring evaluation of the FORMS, bind the VARS to the result of evaluating the\nVALUE forms. The variables are bound in parallel after all of the VALUES forms\nhave been evaluated.").
doc_string(let, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: ((&REST BINDINGS) &BODY BODY)\n\nEvaluates all INITs (which defaults to NIL), binds the value of each INIT to\nthe corresponding VAR, evaluates FORMs, and returns all values of the last\nFORM.  Returns NIL if no FORM is given.\n").
doc_string(lines, 'sb-unicode', function, "Breaks STRING into lines that are no wider than :MARGIN according to the\nline breaking rules outlined in UAX #14. Combining marks will awsays be kept\ntogether with their base characters, and spaces (but not other types of\nwhitespace) will be removed from the end of lines. If :MARGIN is unspecified,\nit defaults to 80 characters").
doc_string(list, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST ARGS)\n\nReturns a list of the args.\n").
doc_string(list, 'common-lisp', function, "Return constructs and returns a list of its arguments.").
doc_string(list, 'sb-impl', function, "Return constructs and returns a list of its arguments.").
doc_string(listen, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*))\n\nReturns T if STREAM is ready to input a character from; NIL otherwise.  In\nsome versions of WAM-CL, this function does not work correctly because the\nunderlying OS does not support such a mechanism.\n").
doc_string(listp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is either a cons or NIL.  Otherwise, returns NIL.\n").
doc_string(listp, 'common-lisp', function, "Return true if OBJECT is a LIST, and NIL otherwise.").
doc_string(load, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC &KEY (VERBOSE *LOAD-VERBOSE*) (PRINT NIL) (IF-DOES-NOT-EXIST ERROR))\n\nLoads the contents of the specified file into WAM-CL.\nIf the filetype is not specified, WAM-CL first tries to load the fasl file with\nfiletype \".fasl\", then tries to load the source file with filetype \".lsp\",\nand then tries to load the source file with no filetype.\nFILESPEC may be a symbol, a string, a pathname, or a file stream.  VERBOSE\nspecifies whether or not the loader prints a loading message.  PRINT specifies\nwhether or not the loader prints the values of the top-level forms.\nIF-DOES-NOT-EXIST specifies the behavior of the loader when the specified file\nis not found.  It may be :ERROR or NIL.\nIf the file was loaded successfully, returns the pathname of the file actually\nloaded\n").
doc_string(load, 'common-lisp', function, "Load the file given by FILESPEC into the Lisp environment, returning\n   T on success.").
doc_string(local, sys, function, "\r\nReturn the closure defined locally with LABELS or FLET.\r\nSPEC is a list of (CLOSURE SUB-CLOSURE SUB-SUB-CLOSURE ...)\r\nCLOSURE must be compiled.").
doc_string(locally, 'common-lisp', function, "LOCALLY declaration* form*\n\nSequentially evaluate the FORMS in a lexical environment where the\nDECLARATIONS have effect. If LOCALLY is a top level form, then the FORMS are\nalso processed as top level forms.").
doc_string(locally, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (&BODY FORMS)\n\nGives DECLs locally while evaluating FORMs, and returns all values of the last\nFORM.  Returns NIL if no FORM is given.\n").
doc_string(log, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER1 &OPTIONAL NUMBER2)\n\nWith two args, returns the logarithm of NUMBER1 in base NUMBER2.  With one\narg, returns the natural logarithm of the arg.\n").
doc_string(log, 'common-lisp', function, "Return the logarithm of NUMBER in the base BASE, which defaults to e.").
doc_string(logand, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST INTEGERS)\n\nReturns the bit-wise AND of the args.\n").
doc_string(logand, 'common-lisp', function, "Return the bit-wise and of its arguments. Args must be integers.").
doc_string(logandc1, 'common-lisp', function, "Bitwise AND (LOGNOT INTEGER1) with INTEGER2.").
doc_string(logandc1, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER1 INTEGER2)\n\nEquivalent to (LOGAND (LOGNOT INTEGER1) INTEGER2).\n").
doc_string(logandc2, 'common-lisp', function, "Bitwise AND INTEGER1 with (LOGNOT INTEGER2).").
doc_string(logandc2, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER1 INTEGER2)\n\nEquivalent to (LOGAND INTEGER1 (LOGNOT INTEGER2)).\n").
doc_string(logbitp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (BIT-POSITION INTEGER)\n\nReturns T if the specified bit of INTEGER is 1; NIL otherwise.  BIT-POSITION\nmust be a non-negative integer, with 0 representing the least significant bit.\n").
doc_string(logbitp, 'common-lisp', function, "Predicate returns T if bit index of integer is a 1.").
doc_string(logcount, 'common-lisp', function, "Count the number of 1 bits if INTEGER is non-negative,\nand the number of 0 bits if INTEGER is negative.").
doc_string(logcount, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER)\n\nIf INTEGER is negative, returns the number of 0 bits.  Otherwise, returns the\nnumber of 1 bits.\n").
doc_string(logeqv, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST INTEGERS)\n\nReturns the bit-wise EQUIVALENCE of the args.\n").
doc_string(logeqv, 'common-lisp', function, "Return the bit-wise equivalence of its arguments. Args must be integers.").
doc_string(logior, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST INTEGERS)\n\nReturns the bit-wise INCLUSIVE OR of the args.\n").
doc_string(logior, 'common-lisp', function, "Return the bit-wise or of its arguments. Args must be integers.").
doc_string(lognand, 'common-lisp', function, "Complement the logical AND of INTEGER1 and INTEGER2.").
doc_string(lognand, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER1 INTEGER2)\n\nEquivalent to (LOGNOT (LOGAND INTEGER1 INTEGER2)).\n").
doc_string(lognor, 'common-lisp', function, "Complement the logical AND of INTEGER1 and INTEGER2.").
doc_string(lognor, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER1 INTEGER2)\n\nEquivalent to (LOGNOT (LOGIOR INTEGER1 INTEGER2)).\n").
doc_string(lognot, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER)\n\nReturns the bit-wise logical NOT of the arg.\n").
doc_string(lognot, 'common-lisp', function, "Return the bit-wise logical not of integer.").
doc_string(logorc1, 'common-lisp', function, "Bitwise OR (LOGNOT INTEGER1) with INTEGER2.").
doc_string(logorc1, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER1 INTEGER2)\n\nEquivalent to (LOGIOR (LOGNOT INTEGER1) INTEGER2).\n").
doc_string(logorc2, 'common-lisp', function, "Bitwise OR INTEGER1 with (LOGNOT INTEGER2).").
doc_string(logorc2, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER1 INTEGER2)\n\nEquivalent to (LOGIOR INTEGER1 (LOGNOT INTEGER2)).\n").
doc_string(logtest, 'common-lisp', function, "Args: (integer1 integer2)\nEquivalent to (NOT (ZEROP (LOGAND INTEGER1 INTEGER2))).").
doc_string(logtest, 'common-lisp', function, "Predicate which returns T if logand of integer1 and integer2 is not zero.").
doc_string(logxor, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST INTEGERS)\n\nReturns the bit-wise EXCLUSIVE OR of the args.\n").
doc_string(logxor, 'common-lisp', function, "Return the bit-wise exclusive or of its arguments. Args must be integers.").
doc_string(loop, 'common-lisp', function, "Syntax: (loop {form}*)\nEstablishes a NIL block and executes FORMs repeatedly.  The loop is normally\nterminated by a non-local exit.").
doc_string(lowercase, 'sb-unicode', function, "Returns the full lowercase of STRING according to the Unicode standard.\nThe result is not guaranteed to have the same length as the input.\n:LOCALE has the same semantics as the :LOCALE argument to UPPERCASE.").
doc_string(macroexpand, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FORM &OPTIONAL (ENV NIL))\n\nIf FORM is a macro form, then expands it repeatedly until the result is not a\nmacro any more, and returns the result as the first value and T as the second\nvalue.  Otherwise, returns FORM and NIL as two values.\n").
doc_string(macroexpand, 'common-lisp', function, "Repetitively call MACROEXPAND-1 until the form can no longer be expanded.\n   Returns the final resultant form, and T if it was expanded. ENV is the\n   lexical environment to expand in, or NIL (the default) for the null\n   environment.").
doc_string(macrolet, 'common-lisp', function, "MACROLET ({(name lambda-list form*)}*) body-form*\n\nEvaluate the BODY-FORMS in an environment with the specified local macros\ndefined. NAME is the local macro name, LAMBDA-LIST is a DEFMACRO style\ndestructuring lambda list, and the FORMS evaluate to the expansion.").
doc_string(macrolet, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (macrolet ({(name defmacro-lambda-list {decl | doc}* {form}*)}*)\n          . body)\nIntroduces local macros and evaluates BODY as a PROGN.  See DEFMACRO for the\ncomplete syntax of defmacro-lambda-list.  Doc-strings for local macros are\nsimply ignored.\n").
doc_string(makunbound, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL)\n\nMakes the global variable named SYMBOL have no value.  Returns SYMBOL.\n").
doc_string(makunbound, 'common-lisp', function, "Make SYMBOL unbound, removing any value it may currently have.").
doc_string(map, 'common-lisp', function, "Args: (type function sequence &rest more-sequences)\nCreates and returns a sequence of TYPE with K elements, with the N-th element\nbeing the value of applying FUNCTION to the N-th elements of the given\nSEQUENCEs, where K is the minimum length of the given SEQUENCEs.").
doc_string(map, 'sb-sequence', function, "Implements CL:MAP for extended sequences.\n\n    RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:MAP but\n    receives a prototype instance of an extended sequence class\n    instead of a type specifier. By dispatching on RESULT-PROTOTYPE,\n    methods on this generic function specify how extended sequence\n    classes act when they are specified as the result type in a CL:MAP\n    call. RESULT-PROTOTYPE may not be fully initialized and thus\n    should only be used for dispatch and to determine its class.\n\n    Another difference to CL:MAP is that FUNCTION is a function, not a\n    function designator.").
doc_string(mapc, 'common-lisp', function, "Apply FUNCTION to successive elements of lists. Return the second argument.").
doc_string(mapc, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION LIST &REST MORE-LISTS)\n\nFor each N (0 <= N < K), applies FUNCTION to the N-th elements of the given\nLISTs, where K is the minimum length of the given LISTs.  Returns the first\nLIST.\n").
doc_string(mapcan, 'common-lisp', function, "Apply FUNCTION to successive elements of LIST. Return NCONC of FUNCTION\n   results.").
doc_string(mapcan, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION LIST &REST MORE-LISTS)\n\nFor each N (0 <= N < K), applies FUNCTION to the N-th elements of the given\nLISTs, where K is the minimum length of the given LISTs.  Nconcs the values,\none for each call to FUNCTION, and returns the result.\n").
doc_string(mapcar, 'common-lisp', function, "Apply FUNCTION to successive elements of LIST. Return list of FUNCTION\n   return values.").
doc_string(mapcar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION LIST &REST MORE-LISTS)\n\nCreates and returns a list of K elements, with the N-th element being the\nvalue of applying FUNCTION to the N-th elements of the given LISTs, where K\nis the minimum length of the given LISTs.\n").
doc_string(mapcon, 'common-lisp', function, "Apply FUNCTION to successive CDRs of lists. Return NCONC of results.").
doc_string(mapcon, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION LIST &REST MORE-LISTS)\n\nFor each N (0 <= N < K), applies FUNCTION to the N-th cdrs of the given LISTs,\nwhere K is the minimum length of the given LISTs.  Nconcs the values, one for\neach call to FUNCTION, and returns the result.\n").
doc_string(maphash, 'common-lisp', function, "For each entry in HASH-TABLE, call the designated two-argument function on\nthe key and value of the entry. Return NIL.\n\nConsequences are undefined if HASH-TABLE is mutated during the call to\nMAPHASH, except for changing or removing elements corresponding to the\ncurrent key. The applies to all threads, not just the current one --\neven for synchronized hash-tables. If the table may be mutated by\nanother thread during iteration, use eg. SB-EXT:WITH-LOCKED-HASH-TABLE\nto protect the MAPHASH call.").
doc_string(maphash, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: #'HASH-TABLE\n\nFor each entry of HASH-TABLE, applies FUNCTION to the key and the value of the\nentry.  Returns NIL.\n").
doc_string(maphash, 'common-lisp', function, "Iterates over all entries in the hash-table. For each entry, the function is called with two arguments--the key and the value of that entry.").
doc_string(mapl, 'common-lisp', function, "Apply FUNCTION to successive CDRs of list. Return NIL.").
doc_string(mapl, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION LIST &REST MORE-LISTS)\n\nFor each N (0 <= N < K), applies FUNCTION to the N-th cdrs of the given LISTs,\nwhere K is the minimum length of the given LISTs.  Returns the first LIST.\n").
doc_string(maplist, 'common-lisp', function, "Apply FUNCTION to successive CDRs of list. Return list of results.").
doc_string(maplist, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION LIST &REST MORE-LISTS)\n\nCreates and returns a list of K elements, with the N-th element being the\nvalue of applying FUNCTION to the N-th cdrs of the given LISTs, where K is the\nminimum length of the given LISTs.\n").
doc_string(max, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns the largest arg.  The args must be non-complex numbers.\n").
doc_string(max, 'common-lisp', function, "Return the greatest of its arguments; among EQUALP greatest, return\nthe first.").
doc_string(member, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM LIST &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT)\n\nSearches LIST for an element that is equal to ITEM in the sense of the TEST.\nIf found, returns the sublist of LIST that begins with the element.\nOtherwise, returns NIL.\n").
doc_string(member, 'common-lisp', function, "Return the tail of LIST beginning with first element satisfying EQLity,\n   :TEST, or :TEST-NOT with the given ITEM.").
doc_string(memoized, sys, function, "(MEMOIZED form) memoizes the result of FORM from its first evaluation.").
doc_string(memq, 'sb-int', function, "Return tail of LIST beginning with first element EQ to ITEM.").
doc_string(merge, 'common-lisp', function, "Args: (type sequence1 sequence2 test &key key)\nMerges two sequences in the way specified by TEST and returns the result as a\nsequence of TYPE.  Both SEQUENCEs may be destroyed.  If both SEQUENCE1 and\nSEQUENCE2 are sorted in the sense of TEST, then the result is also sorted in\nthe sense of TEST.").
doc_string(merge, 'common-lisp', function, "Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a\n   sequence of type RESULT-TYPE using PREDICATE to order the elements.").
doc_string(merge, 'sb-sequence', function, "Implements CL:MERGE for extended sequences.\n\n    RESULT-PROTOTYPE corresponds to the RESULT-TYPE of CL:MERGE but\n    receives a prototype instance of an extended sequence class\n    instead of a type specifier. By dispatching on RESULT-PROTOTYPE,\n    methods on this generic function specify how extended sequence\n    classes act when they are specified as the result type in a\n    CL:MERGE call. RESULT-PROTOTYPE may not be fully initialized and\n    thus should only be used for dispatch and to determine its class.\n\n    Another difference to CL:MERGE is that PREDICATE is a function,\n    not a function designator.").
doc_string(message, readline, function, "Prints message (given as a format string - beware of %) in message area.").
doc_string(min, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &REST MORE-NUMBERS)\n\nReturns the smallest arg.  The args must be non-complex numbers.\n").
doc_string(min, 'common-lisp', function, "Return the least of its arguments; among EQUALP least, return\nthe first.").
doc_string(minusp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns T if NUMBER is negative; NIL otherwise.\n").
doc_string(minusp, 'common-lisp', function, "Is this real number strictly negative?").
doc_string(mismatch, 'common-lisp', function, "Args: (sequence1 sequence2\n       &key key (test '#'eql) test-not\n            (start1 0) (end1 (length sequence1))\n            (start2 0) (end2 (length sequence2))\n            (from-end nil))\nCompares element-wise the specified subsequences of SEQUENCE1 and SEQUENCE2.\nReturns NIL if they are of the same length and they have the same elements in\nthe sense of TEST.  Otherwise, returns the index of SEQUENCE1 to the first\nelement that does not match.").
doc_string(mismatch, 'common-lisp', function, "The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared\n   element-wise. If they are of equal length and match in every element, the\n   result is NIL. Otherwise, the result is a non-negative integer, the index\n   within SEQUENCE1 of the leftmost position at which they fail to match; or,\n   if one is shorter than and a matching prefix of the other, the index within\n   SEQUENCE1 beyond the last position tested is returned. If a non-NIL\n   :FROM-END argument is given, then one plus the index of the rightmost\n   position in which the sequences differ is returned.").
doc_string(mkdir, system, function, "Attempts to create directory at PATHNAME returning the success or failure.").
doc_string(mod, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER DIVISOR)\n\nReturns the second result of (FLOOR NUMBER DIVISOR), i.e. the value of\n        (- NUMBER (* (FLOOR NUMBER DIVISOR) DIVISOR))\n").
doc_string(mod, 'common-lisp', function, "Return second result of FLOOR.").
doc_string(move, 'sb-c', function, "Move SRC into DST unless they are location=.").
doc_string(namestring, 'common-lisp', function, "Construct the full (name)string form of the pathname.").
doc_string(namestring, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns as a string all slots of the pathname specified by FILESPEC.  FILESPEC\nmay be a symbol, a string, a pathname, or a file stream.\n").
doc_string(namestring, 'common-lisp', function, "Returns the NAMESTRING of PATHNAME if it has one.\r\n\r\nIf PATHNAME is of type url-pathname or jar-pathname the NAMESTRING is encoded\r\naccording to the uri percent escape rules.\r\n\r\nSignals an error if PATHNAME lacks a printable NAMESTRING representation.\r\n").
doc_string(nbutlast, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (LIST &OPTIONAL (N 1))\n\nDestructive BUTLAST.  LIST may be destroyed.\n").
doc_string(nconc, 'common-lisp', function, "Concatenates the lists given as arguments (by changing them)").
doc_string(nconc, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST LISTS)\n\nDestructive APPEND.  The args except for the last may be destroyed.\n").
doc_string(nil, 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe value of NIL is NIL.\n").
doc_string(nintersection, 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nDestructive INTERSECTION.  Only LIST1 may be destroyed.").
doc_string(nintersection, 'common-lisp', function, "Destructively return the intersection of LIST1 and LIST2.").
doc_string(ninth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CAR (CDDDDR (CDDDDR X))).\n").
doc_string(ninth, 'common-lisp', function, "Return the 9th object in a list or NIL if there is no 9th object.").
doc_string(not, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is NIL; NIL otherwise.\n").
doc_string(not, 'common-lisp', function, "Return T if X is NIL, otherwise return NIL.").
doc_string(notany, 'common-lisp', function, "Apply PREDICATE to the 0-indexed elements of the sequences, then\n   possibly to those with index 1, and so on. Return NIL as soon\n   as any invocation of PREDICATE returns a non-NIL value, or T if the end\n   of any sequence is reached.").
doc_string(notany, 'common-lisp', function, "Args: (predicate sequence &rest more-sequences)\nReturns T if none of the elements in SEQUENCEs satisfies PREDICATE; NIL\notherwise.").
doc_string(notevery, 'common-lisp', function, "Apply PREDICATE to 0-indexed elements of the sequences, then\n   possibly to those with index 1, and so on. Return T as soon\n   as any invocation of PREDICATE returns NIL, or NIL if every invocation\n   is non-NIL.").
doc_string(notevery, 'common-lisp', function, "Args: (predicate sequence &rest more-sequences)\nReturns T if at least one of the elements in SEQUENCEs does not satisfy\nPREDICATE; NIL otherwise.").
doc_string(nreconc, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nEquivalent to (NCONC (NREVERSE X) Y).\n").
doc_string(nreconc, 'common-lisp', function, "Return (NCONC (NREVERSE X) Y).").
doc_string(nreverse, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE)\n\nDestructive REVERSE.  The arg may be destroyed.\n").
doc_string(nreverse, 'common-lisp', function, "Return a sequence of the same elements in reverse order; the argument\n   is destroyed.").
doc_string(nsublis, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ALIST TREE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT)\n\nDestructive SUBLIS.  TREE may be destroyed.\n").
doc_string(nsublis, 'common-lisp', function, "Substitute from ALIST into TRUE destructively.").
doc_string(nsubst, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW OLD TREE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT)\n\nDestructive SUBST.  TREE may be destroyed.\n").
doc_string(nsubst, 'common-lisp', function, "Substitute NEW for subtrees matching OLD.").
doc_string(nsubstitute, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW OLD SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nDestructive SUBSTITUTE.  SEQUENCE may be destroyed.\n").
doc_string(nsubstitute, 'common-lisp', function, "Return a sequence of the same kind as SEQUENCE with the same elements\n  except that all elements equal to OLD are replaced with NEW. SEQUENCE\n  may be destructively modified.").
doc_string(nth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (N LIST)\n\nReturns the N-th element of LIST, the first element of LIST being the zeroth.\nReturns NIL if the length of LIST is less than N.  N must be a non-negative\ninteger.\n").
doc_string(nth, 'common-lisp', function, "Return the nth object in a list where the car is the zero-th element.").
doc_string(nthcdr, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (N LIST)\n\nReturns the N-th cdr of LIST.  N must be a non-negative integer.\n").
doc_string(nthcdr, 'common-lisp', function, "Performs the cdr function n times on a list.").
doc_string(null, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is NIL; NIL otherwise.\n").
doc_string(null, 'common-lisp', function, "Return true if OBJECT is a NULL, and NIL otherwise.").
doc_string(numberp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a number; NIL otherwise.\n").
doc_string(numberp, 'common-lisp', function, "Return true if OBJECT is a NUMBER, and NIL otherwise.").
doc_string(numerator, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (RATIONAL)\n\nReturns the numerator of RATIONAL as an integer, if RATIONAL is a ratio.\nReturns RATIONAL if it is an integer.\n").
doc_string(numerator, 'common-lisp', function, "Return the numerator of NUMBER, which must be rational.").
doc_string(nunion, 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nDestructive UNION.  Both LIST1 and LIST2 may be destroyed.").
doc_string(nunion, 'common-lisp', function, "Destructively return the union of LIST1 and LIST2.").
doc_string(oddp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (INTEGER)\n\nReturns T if INTEGER is an odd number; NIL otherwise.\n").
doc_string(oddp, 'common-lisp', function, "Is this integer odd?").
doc_string(open, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC &KEY (DIRECTION INPUT) ELEMENT-TYPE IF-EXISTS IF-DOES-NOT-EXIST)\n\nOpens the specified file and returns a file stream to/from the file.  FILESPEC\nmay be a symbol, a string, a pathname, or a file stream.  DIRECTION may be\n:INPUT, :OUTPUT, :IO, or :PROBE.  ELEMENT-TYPE is simply ignored in WAM-CL.  IF-\nEXISTS specifies what to do when DIRECTION is either :OUTPUT or :IO and the\nspecified file exists already.  It may be :ERROR (the default), :NEW-VERSION,\n:RENAME, :RENAME-AND-DELETE, :OVERWRITE, :APPEND, :SUPERSEDE, or NIL.  IF-\nDOES-NOT-EXIST specifies what to do when the specified file does not exists.\nIt may be :ERROR (the default when DIRECTION is :INPUT), :CREATE (the default\nwhen DIRECTION is either :OUTPUT or :IO), or NIL.\nFile streams are notated in one of the following ways:\n        #<input stream f>\n        #<output stream f>\n        #<io stream f>\n        #<probe stream f>\nwhere F is the file name.\n").
doc_string(open, 'common-lisp', function, "Return a stream which reads from or writes to FILENAME.\n  Defined keywords:\n   :DIRECTION - one of :INPUT, :OUTPUT, :IO, or :PROBE\n   :ELEMENT-TYPE - the type of object to read or write, default BASE-CHAR\n   :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE,\n                       :OVERWRITE, :APPEND, :SUPERSEDE or NIL\n   :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL\n  See the manual for details.").
doc_string(or, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (&REST FORMS)\n\nEvaluates FORMs in order from left to right.  If any FORM evaluates to non-\nNIL, quits and returns that (single) value.  If the last FORM is reached,\nreturns whatever values it returns.\n").
doc_string(packagep, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a package object; NIL otherwise.\n").
doc_string(pairlis, 'common-lisp', function, "Construct an association list from KEYS and DATA (adding to ALIST).").
doc_string(pairlis, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (KEYS ITEMS &OPTIONAL (ALIST NIL))\n\nConses each KEY and the corresponding ITEM, adds them to ALIST, and returns\nthe result.  KEYS and ITEMS must be of the same length.\n").
doc_string(pathname, 'common-lisp', function, "Convert PATHSPEC (a pathname designator) into a pathname.").
doc_string(pathname, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns a pathname specified by FILESPEC.  FILESPEC may be a symbol, a string,\na pathname, or a file stream.\n").
doc_string(pathname, 'common-lisp', function, "Returns the PATHNAME denoted by PATHSPEC.").
doc_string(pathnamep, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a pathname object; NIL otherwise.\n").
doc_string(pathnamep, 'common-lisp', function, "Returns true if OBJECT is of type pathname; otherwise, returns false.").
doc_string(phase, 'common-lisp', function, "Args: (number)\nReturns the angle part (in radians) of the polar representation of NUMBER.\nReturns zero for non-complex numbers.").
doc_string(phase, 'common-lisp', function, "Return the angle part of the polar representation of a complex number.\n  For complex numbers, this is (atan (imagpart number) (realpart number)).\n  For non-complex positive numbers, this is 0. For non-complex negative\n  numbers this is PI.").
doc_string(pi, 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe float that is approximately equal to the ratio of the circumference of the\ncircle to the diameter.\n").
doc_string(plusp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns T if NUMBER is positive; NIL otherwise.\n").
doc_string(plusp, 'common-lisp', function, "Is this real number strictly positive?").
doc_string(pointer, si, function, "Function in SI package:\nArgs: (OBJECT)\n\nECL specific.\nReturns the address of the OBJECT as a fixnum.\n").
doc_string(pop, 'common-lisp', function, "Syntax: (pop place)\nGets the cdr of the value stored in PLACE and makes it the new value of PLACE.\nReturns the car of the old value in PLACE.").
doc_string(pop, 'common-lisp', function, "The argument is a location holding a list. Pops one item off the front\n  of the list and returns it.").
doc_string(position, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (FROM-END NIL))\n\nReturns the index to the first element in SEQUENCE that is equal to ITEM in\nthe sense of TEST.  Returns NIL if no such element exists.\n").
doc_string(pprint, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nPretty-prints OBJECT.  Returns no values.  Equivalent to\n        (PROGN (WRITE OBJECT :STREAM STREAM :PRETTY T :ESCAPE T)\n               (VALUES))\nThe SI::PRETTY-PRINT-FORMAT property N (which must be a non-negative integer)\nof a symbol SYMBOL controls the pretty-printing of form\n        (SYMBOL f1 ... fN fN+1 ... fM)\nin such a way that the subforms fN+1, ..., fM are regarded as the 'body' of\nthe entire form.  For instance, the property value of 2 is initially given to\nthe symbol DO.\n").
doc_string(pprint, 'common-lisp', function, "Prettily output OBJECT preceded by a newline.").
doc_string(prin1, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nPrints OBJECT in the way that the output can be reread later if possible.\nReturns OBJECT.  Equivalent to (WRITE OBJECT :STREAM STREAM :ESCAPE T).\n").
doc_string(prin1, 'common-lisp', function, "Output a mostly READable printed representation of OBJECT on the specified\n  STREAM.").
doc_string(princ, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nPrints OBJECT without escape characters.  Returns OBJECT.  Equivalent to\n(WRITE OBJECT :STREAM STREAM :ESCAPE NIL).\n").
doc_string(princ, 'common-lisp', function, "Output an aesthetic but not necessarily READable printed representation\n  of OBJECT on the specified STREAM.").
doc_string(print, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nOutputs a newline character, and then PRIN1s OBJECT.  Returns OBJECT.\nEquivalent to\n        (PROGN (TERPRI STREAM)\n               (WRITE OBJECT :STREAM STREAM :ESCAPE T))\n").
doc_string(print, 'common-lisp', function, "Output a newline, the mostly READable printed representation of OBJECT, and\n  space to the specified STREAM.").
doc_string(proclaim, 'common-lisp', function, "Args: (decl-spec)\nGives a global declaration.  See DECLARE for possible DECL-SPECs.").
doc_string(profile, 'sb-profile', function, "PROFILE Name*\n\n   If no names are supplied, return the list of profiled functions.\n\n   If names are supplied, wrap profiling code around the named functions.\n   As in TRACE, the names are not evaluated. A symbol names a function.\n   A string names all the functions named by symbols in the named\n   package. If a function is already profiled, then unprofile and\n   reprofile (useful to notice function redefinition.)  If a name is\n   undefined, then we give a warning and ignore it. See also\n   UNPROFILE, REPORT and RESET.").
doc_string(prog, 'common-lisp', function, "Syntax: (prog ({var | (var [init])}*) {decl}* {tag | statement}*)\nEstablishes a NIL block, binds each VAR to the value of INIT (which defaults\nto NIL) in parallel, and executes STATEMENTs.  Returns NIL.").
doc_string(prog1, 'common-lisp', function, "Syntax: (prog1 first-form {form}*)\nEvaluates FIRST-FORM and FORMs in order.  Returns the value of FIRST-FORM.").
doc_string(prog2, 'common-lisp', function, "Syntax: (prog2 first-form second-form {forms}*)\nEvaluates FIRST-FORM, SECOND-FORM, and FORMs in order.  Returns the value of\nSECOND-FORM.").
doc_string(progn, 'common-lisp', function, "PROGN form*\n\nEvaluates each FORM in order, returning the values of the last form. With no\nforms, returns NIL.").
doc_string(progn, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (&BODY FORMS)\n\nEvaluates FORMs in order, and returns all values of the last FORM.  Returns\nNIL if no FORM is given.\n").
doc_string(progv, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (SYMBOLS-FORM VALUES-FORM &BODY FORMS)\n\nEvaluates SYMBOLS-FORM and VALUES-FORM.  The value of SYMBOLS-FORM must be a\nlist of symbols (S1 ... Sn) and the value of VALUES-FORM must be a list\n(V1 ... Vm).  Binds each Si to Vi or to NIL if i > m.  Then evaluates FORMs\nand returns all values of the last FORM.  Returns NIL if no FORM is given.\n").
doc_string(provide, 'common-lisp', function, "Adds a new module name to *MODULES* indicating that it has been loaded.\n   Module-name is a string designator").
doc_string(provide, 'common-lisp', function, "Adds a new module name to *MODULES* indicating that it has been loaded.\nModule-name is a string designator").
doc_string(psetf, 'common-lisp', function, "Syntax: (psetf {place form}*)\nSimilar to SETF, but evaluates all FORMs first, and then assigns each value to\nthe corresponding PLACE.  Returns NIL.").
doc_string(psetf, 'common-lisp', function, "This is to SETF as PSETQ is to SETQ. Args are alternating place\n  expressions and values to go into those places. All of the subforms and\n  values are determined, left to right, and only then are the locations\n  updated. Returns NIL.").
doc_string(psetq, 'common-lisp', function, "PSETQ {var value}*\n   Set the variables to the values, like SETQ, except that assignments\n   happen in parallel, i.e. no assignments take place until all the\n   forms have been evaluated.").
doc_string(psetq, 'common-lisp', function, "Syntax: (psetq {var form}*)\nSimilar to SETQ, but evaluates all FORMs first, and then assigns each value to\nthe corresponding VAR.  Returns NIL.").
doc_string(purify, pkg_sys, function, "This function optimizes garbage collection by moving all currently live\n   objects into non-collected storage. ROOT-STRUCTURES is an optional list of\n   objects which should be copied first to maximize locality.\n\n   DEFSTRUCT structures defined with the (:PURE T) option are moved into\n   read-only storage, further reducing GC cost. List and vector slots of pure\n   structures are also moved into read-only storage.\n\n   ENVIRONMENT-NAME is unused.\n\n   This function is a no-op on platforms using the generational garbage\n   collector (x86, x86-64, ppc, arm, arm64).").
doc_string(push, 'common-lisp', function, "Syntax: (push form place)\nEvaluates FORM, conses the value of FORM to the value stored in PLACE, and\nmakes it the new value of PLACE.  Returns the new value of PLACE.").
doc_string(push, 'common-lisp', function, "Takes an object and a location holding a list. Conses the object onto\n  the list, returning the modified list. OBJ is evaluated before PLACE.").
doc_string(pushnew, 'common-lisp', function, "Syntax: (pushnew form place {keyword-form value-form}*)\nEvaluates FORM first.  If the value is already in the list stored in PLACE,\ndoes nothing.  Else, conses the value onto the list and makes the result the\nnew value of PLACE.  Returns NIL.  KEYWORD-FORMs and VALUE-FORMs are used to\ncheck if the value of FORM is already in PLACE as if their values are passed\nto MEMBER.").
doc_string(pushnew, 'common-lisp', function, "Takes an object and a location holding a list. If the object is\n  already in the list, does nothing; otherwise, conses the object onto\n  the list. Keyword arguments are accepted as per the ADJOIN function.").
doc_string(quit, pkg_sys, function, "The function SB-EXT:QUIT has been deprecated as of SBCL version 1.0.56.55.\n\nUse SB-EXT:EXIT or SB-THREAD:ABORT-THREAD instead.").
doc_string(quote, 'common-lisp', function, "QUOTE value\n\nReturn VALUE without evaluating it.").
doc_string(quote, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (X)\n\nSimply returns X without evaluating it.\n").
doc_string(random, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &OPTIONAL (RANDOM-STATE *RANDOM-STATE*))\n\nCreates and returns a random number by using RANDOM-STATE.  NUMBER must be\neither a positive integer or a positive float.  If NUMBER is a positive\ninteger, returns a positive integer less than NUMBER.  If NUMBER is a positive\nfloat, returns a positive float less than NUMBER in the same float format as\nNUMBER.\n").
doc_string(rassoc, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM ALIST &KEY (TEST '#'EQL) TEST-NOT (KEY '#'IDENTITY))\n\nReturns the first pair in ALIST whose cdr is equal (in the sense of TEST) to\nITEM.  Returns NIL if no such pair exists.\nThe function KEY is applied to extract the key for comparison.\n").
doc_string(rassoc, 'common-lisp', function, "Return the cons in ALIST whose CDR is equal (by a given test or EQL) to\n   the ITEM.").
doc_string(rational, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (REAL)\n\nConverts REAL into rational accurately and returns the result.\n").
doc_string(rational, 'common-lisp', function, "RATIONAL produces a rational number for any real numeric argument. This is\n  more efficient than RATIONALIZE, but it assumes that floating-point is\n  completely accurate, giving a result that isn't as pretty.").
doc_string(rationalize, 'common-lisp', function, "Converts any REAL to a RATIONAL.  Floats are converted to a simple rational\n  representation exploiting the assumption that floats are only accurate to\n  their precision.  RATIONALIZE (and also RATIONAL) preserve the invariant:\n      (= x (float (rationalize x) x))").
doc_string(rationalize, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (REAL)\n\nConverts REAL into rational approximately and returns the result.\n").
doc_string(rationalp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is an integer or a ratio; NIL otherwise.\n").
doc_string(rationalp, 'common-lisp', function, "Return true if OBJECT is a RATIONAL, and NIL otherwise.").
doc_string(ratiop, 'sb-int', function, "Return true if OBJECT is a RATIO, and NIL otherwise.").
doc_string(read, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-INPUT*) (EOF-ERROR-P T) (EOF-VALUE NIL) (RECURSIVEP NIL))\n\nReads an object from STREAM and returns the object.\n").
doc_string(read, 'common-lisp', function, "Read the next Lisp value from STREAM, and return it.").
doc_string(readerr, readline, variable, "\r\n Input error; can be returned by (*rl_getc_function)\r\nif readline is reading a top-level command (RL_ISSTATE (RL_STATE_READCMD)).").
doc_string(readline, readline, function, "Prompt and return string read from readline library or nil as eof.").
doc_string(readtablep, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a readtable object; NIL otherwise.\n").
doc_string(realp, 'common-lisp', function, "Return true if OBJECT is a REAL, and NIL otherwise.").
doc_string(realpart, 'common-lisp', function, "Extract the real part of a number.").
doc_string(realpart, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the realpart of NUMBER if it is a complex.  Otherwise, returns NUMBER.\n").
doc_string(reduce, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FUNCTION SEQUENCE &KEY (FROM-END NIL) (START 0) (END (LENGTH SEQUENCE)) INITIAL-VALUE)\n\nCombines all the elements of SEQUENCE using the binary operation FUNCTION.\n").
doc_string(rem, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER DIVISOR)\n\nReturns the second value of (TRUNCATE NUMBER DIVISOR), i.e. the value of\n        (- NUMBER (* (TRUNCATE NUMBER DIVISOR) DIVISOR))\n").
doc_string(rem, 'common-lisp', function, "Return second result of TRUNCATE.").
doc_string(remf, 'common-lisp', function, "Place may be any place expression acceptable to SETF, and is expected\n  to hold a property list or (). This list is destructively altered to\n  remove the property specified by the indicator. Returns T if such a\n  property was present, NIL if not.").
doc_string(remf, 'common-lisp', function, "Syntax: (remf place form)\nRemoves the property specified by FORM from the property list stored in PLACE.\nReturns T if the property list had the specified property; NIL otherwise.").
doc_string(remhash, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (KEY HASH-TABLE)\n\nRemoves the entry for KEY in HASH-TABLE.  Returns T if such an entry existed;\nNIL otherwise.\n").
doc_string(remhash, 'common-lisp', function, "Remove the entry in HASH-TABLE associated with KEY. Return T if\nthere was such an entry, or NIL if not.").
doc_string(remhash, 'common-lisp', function, "Removes the value for KEY in HASH-TABLE, if any.").
doc_string(remove, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ITEM SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nReturns a copy of SEQUENCE with those elements equal to ITEM (in the sense of\nTEST) removed.\n").
doc_string(remove, 'common-lisp', function, "Return a copy of SEQUENCE with elements satisfying the test (default is\n   EQL) with ITEM removed.").
doc_string(remprop, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL INDICATOR)\n\nRemoves the specified property from the property list associated with SYMBOL.\nReturns T if the property list had the specified property; NIL otherwise.\n").
doc_string(remprop, 'common-lisp', function, "Look on property list of SYMBOL for property with specified\n  INDICATOR. If found, splice this indicator and its value out of\n  the plist, and return the tail of the original list starting with\n  INDICATOR. If not found, return () with no side effects.\n\n  NOTE: The ANSI specification requires REMPROP to return true (not false)\n  or false (the symbol NIL). Portable code should not rely on any other value.").
doc_string(replace, 'common-lisp', function, "Destructively modifies SEQUENCE1 by copying successive elements\ninto it from the SEQUENCE2.\n\nElements are copied to the subseqeuence bounded by START1 and END1,\nfrom the subsequence bounded by START2 and END2. If these subsequences\nare not of the same length, then the shorter length determines how\nmany elements are copied.").
doc_string(replace, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE1 SEQUENCE2 &KEY (START1 0) (END1 (LENGTH SEQUENCE1)) (START2 0) (END2 (LENGTH SEQUENCE2)))\n\nReplaces elements of SEQUENCE1 with the corresponding elements of SEQUENCE2.\nSEQUENCE1 may be destroyed and is returned.\n").
doc_string(report, 'sb-profile', function, "Report results from profiling. The results are approximately\nadjusted for profiling overhead. The compensation may be rather\ninaccurate when bignums are involved in runtime calculation, as in a\nvery-long-running Lisp process.\n\nIf LIMIT is set to an integer, only the top LIMIT results are\nreported. If PRINT-NO-CALL-LIST is T (the default) then a list of\nuncalled profiled functions are listed.").
doc_string(require, 'common-lisp', function, "Loads a module, unless it already has been loaded. PATHNAMES, if supplied,\n   is a designator for a list of pathnames to be loaded if the module\n   needs to be. If PATHNAMES is not supplied, functions from the list\n   *MODULE-PROVIDER-FUNCTIONS* are called in order with MODULE-NAME\n   as an argument, until one of them returns non-NIL.  User code is\n   responsible for calling PROVIDE to indicate a successful load of the\n   module.").
doc_string(require, 'common-lisp', function, "Loads a module, unless it already has been loaded. PATHNAMES, if supplied,\nis a designator for a list of pathnames to be loaded if the module\nneeds to be. If PATHNAMES is not supplied, functions from the list\n*MODULE-PROVIDER-FUNCTIONS* are called in order with MODULE-NAME\nas an argument, until one of them returns non-NIL.  User code is\nresponsible for calling PROVIDE to indicate a successful load of the\nmodule.").
doc_string(reset, 'sb-profile', function, "Reset the counters for all profiled functions.").
doc_string(resolve, extensions, function, "Resolve the function named by SYMBOL via the autoloader mechanism.\r\nReturns either the function or NIL if no resolution was possible.").
doc_string(rest, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to CDR.\n").
doc_string(rest, 'common-lisp', function, "Means the same as the cdr of a list.").
doc_string(return, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (&OPTIONAL RESULT)\n\nTerminates execution of the lexically surrounding NIL block and returns all\nvalues of RESULT (which defaults to NIL) as the values of the terminated\nblock.\n").
doc_string(revappend, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X Y)\n\nEquivalent to (APPEND (REVERSE X) Y)\n").
doc_string(revappend, 'common-lisp', function, "Return (append (reverse x) y).").
doc_string(reverse, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE)\n\nReturns a new sequence containing the same elements as SEQUENCE but in the\nreverse order.\n").
doc_string(reverse, 'common-lisp', function, "Return a new sequence containing the same elements but in reverse order.").
doc_string(room, 'common-lisp', function, "Args: (&optional (x t))\nDisplays information about storage allocation in the following format.\n        * for each type class\n                * number of pages so-far allocated for the type class\n                * maximum number of pages for the type class\n                * percentage of used cells to cells so-far allocated\n                * number of times the garbage collector has been called to\n                  collect cells of the type class\n                * implementation types that belongs to the type class\n        * number of pages actually allocated for contiguous blocks\n        * maximum number of pages for contiguous blocks\n        * number of times the garbage collector has been called to collect\n          contiguous blocks\n        * number of pages in the hole\n        * total number of pages allocated for cells\n        * total number of pages allocated\n        * number of available pages\n        * number of pages WAM-CL can use.\nThe number of times the garbage collector has been called is not shown, if the\nnumber is zero.  The optional X is simply ignored.").
doc_string(room, 'common-lisp', function, "Print to *STANDARD-OUTPUT* information about the state of internal\n  storage and its management. The optional argument controls the\n  verbosity of output. If it is T, ROOM prints out a maximal amount of\n  information. If it is NIL, ROOM prints out a minimal amount of\n  information. If it is :DEFAULT or it is not supplied, ROOM prints out\n  an intermediate amount of information.").
doc_string(rotatef, 'common-lisp', function, "Syntax: (rotatef {place}*)\nSaves the values of PLACEs, and then assigns to each PLACE the saved value of\nthe PLACE to its right.  The rightmost PLACE gets the value of the leftmost\nPLACE.  Returns NIL.").
doc_string(rotatef, 'common-lisp', function, "Takes any number of SETF-style place expressions. Evaluates all of the\n   expressions in turn, then assigns to each place the value of the form to\n   its right. The rightmost form gets the value of the leftmost.\n   Returns NIL.").
doc_string(round, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &OPTIONAL (DIVISOR 1))\n\nReturns the integer nearest to NUMBER/DIVISOR.  Returns the value of (- NUMBER\n(* first-value DIVISOR)) as the second value.\n").
doc_string(round, 'common-lisp', function, "Rounds number (or number/divisor) to nearest integer.\n  The second returned value is the remainder.").
doc_string(rplaca, 'common-lisp', function, "Change the CAR of CONS to X and return the CONS.").
doc_string(rplaca, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CONS X)\n\nReplaces the car of CONS with X, and returns the modified CONS.\n").
doc_string(rplacd, 'common-lisp', function, "Change the CDR of CONS to X and return the CONS.").
doc_string(rplacd, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (CONS X)\n\nReplaces the cdr of CONS with X, and returns the modified CONS.\n").
doc_string(sbit, 'common-lisp', function, "Args: (simple-bit-array &rest subscripts)\nReturns the specified bit in SIMPLE-BIT-ARRAY.").
doc_string(sbit, 'common-lisp', function, "Return the bit from SIMPLE-BIT-ARRAY at the specified SUBSCRIPTS.").
doc_string(schar, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SIMPLE-STRING N)\n\nReturns the character object representing the N-th character in SIMPLE-STRING.\nThis is faster than CHAR.\n").
doc_string(schar, 'common-lisp', function, "SCHAR returns the character object at an indexed position in a string\n   just as CHAR does, except the string must be a simple-string.").
doc_string(script, 'sb-unicode', function, "Returns the Script property of CHARACTER as a keyword.\nIf CHARACTER does not have a known script, returns :UNKNOWN").
doc_string(search, 'common-lisp', function, "Args: (sequence1 sequence2\n       &key key (test '#'eql) test-not\n            (start1 0) (end1 (length sequence1))\n            (start2 0) (end2 (length sequence2))\n            (from-end nil))\nSearches SEQUENCE2 for a subsequence that element-wise matches SEQUENCE1.\nReturns the index to the first element of the subsequence if such a\nsubsequence is found.  Returns NIL otherwise.").
doc_string(second, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to CADR.\n").
doc_string(second, 'common-lisp', function, "Return the 2nd object in a list or NIL if there is no 2nd object.").
doc_string(sentences, 'sb-unicode', function, "Breaks STRING into sentences acording to the default\nsentence breaking rules specified in UAX #29").
doc_string(set, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL OBJECT)\n\nAssigns OBJECT to the global variable named SYMBOL.  Returns OBJECT.\n").
doc_string(set, 'common-lisp', function, "Set SYMBOL's value cell to NEW-VALUE.").
doc_string(setf, 'common-lisp', function, "Syntax: (setf {place form}*)\nEvaluates each FORM and assigns the value to the corresponding PLACE in order.\nReturns the value of the last FORM.\nEach PLACE may be any one of the following:\n  * A symbol that names a variable.\n  * A function call form whose first element is the name of the following\n    functions:\n        nth     elt     subseq  rest    first ... tenth\n        c?r     c??r    c???r   c????r\n        aref    svref   char    schar   bit     sbit    fill-pointer\n        get     getf    documentation   symbol-value    symbol-function\n        symbol-plist    macro-function  gethash         fdefinition\n        char-bit        ldb     mask-field\n        apply   slot-value\n    where '?' stands for either 'a' or 'd'.\n  * A function call form whose first element is:\n        1. an access function for a structure slot\n        1. an accessor method for a CLOS object\n  * the form (THE type place) with PLACE being a place recognized by SETF.\n  * a macro call which expands to a place recognized by SETF.\n  * any form for which a DEFSETF or DEFINE-SETF-EXPANDER declaration has been\n    made.").
doc_string(setf, 'common-lisp', function, "Takes pairs of arguments like SETQ. The first is a place and the second\n  is the value that is supposed to go into that place. Returns the last\n  value. The place argument may be any of the access forms for which SETF\n  knows a corresponding setting form.").
doc_string(setq, 'common-lisp', function, "Special Form in COMMON-LISP package:\n\nSyntax: (setq {var form}*)\n\nEvaluates each FORM and assigns the value to VAR in order.  Returns the value\nof the last FORM.\n").
doc_string(seventh, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CADDR (CDDDDR X)).\n").
doc_string(seventh, 'common-lisp', function, "Return the 7th object in a list or NIL if there is no 7th object.").
doc_string(shadow, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (PACKAGE *PACKAGE*))\n\nIf no symbol is registered in PACKAGE with the same name as SYMBOL, then\ncreates an internal symbol with the same name and registers it into PACKAGE.\nThe created symbol shadows external symbols of the same name in those packages\nthat PACKAGE uses.  SYMBOL may be a list of symbols.\n").
doc_string(shadow, 'common-lisp', function, "Make an internal symbol in PACKAGE with the same name as each of the\nspecified SYMBOLS. If a symbol with the given name is already present in\nPACKAGE, then the existing symbol is placed in the shadowing symbols list if\nit is not already present.").
doc_string(shiftf, 'common-lisp', function, "One or more SETF-style place expressions, followed by a single\n   value expression. Evaluates all of the expressions in turn, then\n   assigns the value of each expression to the place on its left,\n   returning the value of the leftmost.").
doc_string(shiftf, 'common-lisp', function, "Syntax: (shiftf {place}+ form)\nSaves the values of PLACE and FORM, and then assigns the value of each PLACE\nto the PLACE on its left.  The rightmost PLACE gets the value of FORM.\nReturns the original value of the leftmost PLACE.").
doc_string(signal, 'common-lisp', function, "Invokes the signal facility on a condition formed from DATUM and\n   ARGUMENTS. If the condition is not handled, NIL is returned. If\n   (TYPEP condition *BREAK-ON-SIGNALS*) is true, the debugger is invoked\n   before any signalling is done.").
doc_string(signum, 'common-lisp', function, "Args: (number)\nReturns a number that represents the sign of NUMBER.  Returns NUMBER If it is\nzero.  Otherwise, returns the value of (/ NUMBER (ABS NUMBER))").
doc_string(signum, 'common-lisp', function, "If NUMBER is zero, return NUMBER, else return (/ NUMBER (ABS NUMBER)).").
doc_string(sin, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (RADIANS)\n\nReturns the sine of RADIANS.\n").
doc_string(sin, 'common-lisp', function, "Return the sine of NUMBER.").
doc_string(sinh, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the hyperbolic sine of NUMBER.\n").
doc_string(sinh, 'common-lisp', function, "Return the hyperbolic sine of NUMBER.").
doc_string(sixth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CADR (CDDDDR X)).\n").
doc_string(sixth, 'common-lisp', function, "Return the 6th object in a list or NIL if there is no 6th object.").
doc_string(sleep, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (N)\n\nSuspends execution for N seconds.  N may be any non-negative, non-complex\nnumber.\n").
doc_string(sleep, 'common-lisp', function, "This function causes execution to be suspended for SECONDS. SECONDS may be\nany non-negative real number.").
doc_string(slot, 'sb-alien', function, "Extract SLOT from the Alien STRUCT or UNION ALIEN. May be set with SETF.").
doc_string(some, 'common-lisp', function, "Apply PREDICATE to the 0-indexed elements of the sequences, then\n   possibly to those with index 1, and so on. Return the first\n   non-NIL value encountered, or NIL if the end of any sequence is reached.").
doc_string(some, 'common-lisp', function, "Args: (predicate sequence &rest more-sequences)\nReturns T if at least one of the elements in SEQUENCEs satisfies PREDICATE;\nNIL otherwise.").
doc_string(sort, 'common-lisp', function, "Args: (sequence test &key key)\nDestructively sorts SEQUENCE and returns the result.  TEST should return non-\nNIL if its first argument is to precede its second argument.  The order of two\nelements X and Y is arbitrary if both\n        (FUNCALL TEST X Y)\n        (FUNCALL TEST Y X)\nevaluates to NIL.  See STABLE-SORT.").
doc_string(sort, 'common-lisp', function, "Destructively sort SEQUENCE. PREDICATE should return non-NIL if\n   ARG1 is to precede ARG2.").
doc_string(specialp, si, function, "Function in SI package:\nArgs: (SYMBOL)\n\nECL specific.\nReturns T if the SYMBOL names a globally special variable; NIL otherwise.\n").
doc_string(sqrt, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the square root of the arg.\n").
doc_string(sqrt, 'common-lisp', function, "Return the square root of NUMBER.").
doc_string(step, 'common-lisp', function, "(STEP form), CLTL p. 441").
doc_string(step, 'common-lisp', function, "Syntax: (step form)\nEvaluates FORM in the Stepper mode and returns all its values.  See WAM-CL Report\nfor Stepper mode commands.").
doc_string(step, 'common-lisp', function, "The form is evaluated with single stepping enabled. Function calls\noutside the lexical scope of the form can be stepped into only if the\nfunctions in question have been compiled with sufficient DEBUG policy\nto be at least partially steppable.").
doc_string(streamp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a stream object; NIL otherwise.\n").
doc_string(string, 'common-lisp', function, "Coerces X into a string. If X is a string, X is returned. If X is a\n   symbol, its name is returned. If X is a character then a one element\n   string containing that character is returned. If X cannot be coerced\n   into a string, an error occurs.").
doc_string(string, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nCoerces X into a string.  If X is a string, then returns X itself.  If X is a\nsymbol, then returns its print name.  If X is a character, then returns a one\nelement string containing that character.  Signals an error if X cannot be\ncoerced into a string.\n").
doc_string(stringp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a string object; NIL otherwise.\n").
doc_string(stringp, 'common-lisp', function, "Return true if OBJECT is a STRING, and NIL otherwise.").
doc_string(structurep, si, function, "Function in SI package:\nArgs: (X)\n\nECL specific.\nReturns T if X is a structure object defined by DEFSTRUCT; NIL otherwise.\n").
doc_string(sublis, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (ALIST TREE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT)\n\nSubstitutes subtrees of TREE by using ALIST and returns the result.  The\noriginal TREE is not destroyed.\n").
doc_string(sublis, 'common-lisp', function, "Substitute from ALIST into TREE nondestructively.").
doc_string(subseq, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SEQUENCE START &OPTIONAL (END (LENGTH SEQUENCE)))\n\nReturns a copy of the subsequence of SEQUENCE between START (inclusive) and\nEND (exclusive).\n").
doc_string(subseq, 'common-lisp', function, "Return a copy of a subsequence of SEQUENCE starting with element number\n   START and continuing to the end of SEQUENCE or the optional END.").
doc_string(subsetp, 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nReturns T if every element of LIST1 is also an element of LIST2.  Returns NIL\notherwise.").
doc_string(subsetp, 'common-lisp', function, "Return T if every element in LIST1 is also in LIST2.").
doc_string(subst, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW OLD TREE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT)\n\nSubstitutes NEW for subtrees of TREE that match OLD and returns the result.\nThe original TREE is not destroyed.\n").
doc_string(subst, 'common-lisp', function, "Substitutes new for subtrees matching old.").
doc_string(substitute, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NEW OLD SEQUENCE &KEY (KEY '#'IDENTITY) (TEST '#'EQL) TEST-NOT (START 0) (END (LENGTH SEQUENCE)) (COUNT MOST-POSITIVE-FIXNUM) (FROM-END NIL))\n\nReturns a copy of SEQUENCE with all elements that match OLD replaced by NEW.\nThe original SEQUENCE is not destroyed.\n").
doc_string(substitute, 'common-lisp', function, "Return a sequence of the same kind as SEQUENCE with the same elements,\n  except that all elements equal to OLD are replaced with NEW.").
doc_string(subtypep, 'common-lisp', function, "Return two values indicating the relationship between type1 and type2.\n  If values are T and T, type1 definitely is a subtype of type2.\n  If values are NIL and T, type1 definitely is not a subtype of type2.\n  If values are NIL and NIL, it couldn't be determined.").
doc_string(svref, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SIMPLE-VECTOR N)\n\nReturns the N-th element of SIMPLE-VECTOR.\n").
doc_string(svref, 'common-lisp', function, "Return the INDEXth element of the given Simple-Vector.").
doc_string(sxhash, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OBJECT)\n\nReturns the hash code for OBJECT as an integer.\n").
doc_string(symbolp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a symbol; NIL otherwise.\n").
doc_string(symbolp, 'common-lisp', function, "Return true if OBJECT is a SYMBOL, and NIL otherwise.").
doc_string(system, extensions, function, "Function in EXT package:\nArgs: (STRING)\n\nExecutes a Shell command as if STRING is an input to the Shell.\n").
doc_string(t, 'common-lisp', variable, "Constant in COMMON-LISP package:\nThe value of T is T.\n").
doc_string(tagbody, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (tagbody {tag | statement}*)\n\nExecutes STATEMENTs in order and returns NIL after the execution of the last\nSTATEMENT.  But, if a GO form causes a jump to one of the TAGs, then execution\ncontinues at the point right after the TAG.  Lists are regarded as STATEMENTs\nand other objects are regarded as TAGs.\n").
doc_string(tagbody, 'common-lisp', function, "TAGBODY {tag | statement}*\n\nDefine tags for use with GO. The STATEMENTS are evaluated in order, skipping\nTAGS, and NIL is returned. If a statement contains a GO to a defined TAG\nwithin the lexical scope of the form, then control is transferred to the next\nstatement following that tag. A TAG must be an integer or a symbol. A\nSTATEMENT must be a list. Other objects are illegal within the body.").
doc_string(tailp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X LIST)\n\nReturns T if X is identical to one of the conses that constitute LIST.\nReturns NIL otherwise.\n").
doc_string(tailp, 'common-lisp', function, "Return true if OBJECT is the same as some tail of LIST, otherwise\n   returns false. LIST must be a proper list or a dotted list.").
doc_string(tan, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (RADIANS)\n\nReturns the tangent of RADIANS.\n").
doc_string(tan, 'common-lisp', function, "Return the tangent of NUMBER.").
doc_string(tanh, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns the hyperbolic tangent of NUMBER.\n").
doc_string(tanh, 'common-lisp', function, "Return the hyperbolic tangent of NUMBER.").
doc_string(tenth, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to (CADR (CDDDDR (CDDDDR X))).\n").
doc_string(tenth, 'common-lisp', function, "Return the 10th object in a list or NIL if there is no 10th object.").
doc_string(terpri, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&OPTIONAL (STREAM *STANDARD-OUTPUT*))\n\nOutputs a newline character.\n").
doc_string(the, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (TYPE FORM)\n\nDeclares that FORM evaluates to a value of TYPE.  Evaluates FORM and checks if\nthe value belongs to TYPE.  If it does, returns the value.  Otherwise, signals\nan error.\n").
doc_string(the, 'common-lisp', function, "Specifies that the values returned by FORM conform to the VALUE-TYPE.\n\nCLHS specifies that the consequences are undefined if any result is\nnot of the declared type, but SBCL treats declarations as assertions\nas long as SAFETY is at least 2, in which case incorrect type\ninformation will result in a runtime type-error instead of leading to\neg. heap corruption. This is however expressly non-portable: use\nCHECK-TYPE instead of THE to catch type-errors at runtime. THE is best\nconsidered an optimization tool to inform the compiler about types it\nis unable to derive from other declared types.").
doc_string(third, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nEquivalent to CADDR.\n").
doc_string(third, 'common-lisp', function, "Return the 3rd object in a list or NIL if there is no 3rd object.").
doc_string(throw, 'common-lisp', function, "Special Form in COMMON-LISP package:\nSyntax: (TAG FORM)\n\nEvaluates TAG and aborts the execution of the most recent CATCH form that\nestablishes a catcher with the same catch tag.  Returns all values of FORM as\nthe values of the CATCH form.\n").
doc_string(throw, 'common-lisp', function, "THROW tag form\n\nDo a non-local exit, return the values of FORM from the CATCH whose tag is EQ\nto TAG.").
doc_string(time, 'common-lisp', function, "Execute FORM and print timing information on *TRACE-OUTPUT*.\n\nOn some hardware platforms estimated processor cycle counts are\nincluded in this output; this number is slightly inflated, since it\nincludes the pipeline involved in reading the cycle counter --\nexecuting (TIME NIL) a few times will give you an idea of the\noverhead, and its variance. The cycle counters are also per processor,\nnot per thread: if multiple threads are running on the same processor,\nthe reported counts will include cycles taken up by all threads\nrunning on the processor where TIME was executed. Furthermore, if the\noperating system migrates the thread to another processor between\nreads of the cycle counter, the results will be completely bogus.\nFinally, the counter is cycle counter, incremented by the hardware\neven when the process is halted -- which is to say that cycles pass\nnormally during operations like SLEEP.").
doc_string(time, 'common-lisp', function, "Syntax: (time form)\nEvaluates FORM, outputs the realtime and runtime used for the evaluation to\n*TRACE-OUTPUT*, and then returns all values of FORM.").
doc_string(titlecase, 'sb-unicode', function, "Returns the titlecase of STRING. The resulting string can\nbe longer than the input.\n:LOCALE has the same semantics as the :LOCALE argument to UPPERCASE.").
doc_string(trace, 'common-lisp', function, "\r\nTrace function execution.\r\n(TRACE) returns the list of all traced functions.\r\n(TRACE fun ...) additionally traces the functions fun, ... .\r\nFormat for fun:\r\n Either a function name\r\n or a list made of a function-cell and a few keyword arguments (pairwise!)\r\n  (function-name\r\n   [:suppress-if form]   ; no Trace-Output, as long as form is true\r\n   [:max-depth form]     ; no trace output, as long as (> *trace-level* form)\r\n   [:step-if form]       ; Trace moves into the Stepper, if form is true\r\n   [:bindings ((variable form)...)] ; binds variables around the following forms\r\n   [:pre form]           ; executes form before function call\r\n   [:post form]          ; executes form after  function call\r\n   [:pre-break-if form]  ; Trace moves into break-loop before function call,\r\n                         ; if form is true\r\n   [:post-break-if form] ; Trace moves into break-loop after  function call,\r\n                         ; if form is true\r\n   [:pre-print form]     ; prints the values of form before function call\r\n   [:post-print form]    ; prints the values of form after  function call\r\n   [:print form]         ; prints the values of form before\r\n                         ; and after the function call\r\n  )\r\nIn all these forms *TRACE-FUNCTION* (the function itself),\r\n  *TRACE-ARGS* (the function arguments),\r\n  *TRACE-FORM* (the function-/macro-call as form),\r\n  and after function call also *TRACE-VALUES* (the list of values\r\n  of the function call) can be accessed,\r\n  and the function can be left with RETURN with given values.\r\nTRACE and UNTRACE are also applicable to functions (SETF symbol) and macros,\r\n however not applicable to locally defined functions and macros.").
doc_string(trace, 'common-lisp', function, "Syntax: (trace ({function-name | ({function-name}+)} {keyword [form]}*)\nBegins tracing the specified functions.  With no FUNCTION-NAMEs, returns a\nlist of functions currently being traced. The printed information consists of\nthe name of function followed at entry by its arguments and on exit by its\nreturn values.\nThe keywords allow to control when and how tracing is performed.\nThe possible keywords are:\n\n :BREAK         a breakpoint is entered after printing the entry trace\n                information, but before applying the traced function to its\n                arguments, if form evaluates to non-nil\n :BREAK-AFTER   like :BREAK but the breakpoint is entered after the function\n                has been executed and the exit trace information has been\n                printed and before control returns\n :COND-BEFORE   information is printed upon entry if form evaluates to non-nil\n :COND-AFTER    information is printed upon exit if form evaluates to non-nil\n :COND          specifies a single condition for both entry and exit\n :PRINT         prints the values of the forms in the list upon entry.\n                They are preceeded by a backslash (\\)\n :PRINT-AFTER   prints the values of the forms in the list upon exit from the\n                function. They are preceeded by a backslash (\\)\n :STEP          turns on the stepping facility\n\nForms can refer to the list of arguments of the function through the variable\nSI::ARGS.").
doc_string(trace, 'common-lisp', function, "TRACE {Option Global-Value}* {Name {Option Value}*}*\n\nTRACE is a debugging tool that provides information when specified\nfunctions are called. In its simplest form:\n\n       (TRACE NAME-1 NAME-2 ...)\n\nThe NAMEs are not evaluated. Each may be a symbol, denoting an\nindividual function, or a string, denoting all functions fbound to\nsymbols whose home package is the package with the given name.\n\nOptions allow modification of the default behavior. Each option is a\npair of an option keyword and a value form. Global options are\nspecified before the first name, and affect all functions traced by a\ngiven use of TRACE. Options may also be interspersed with function\nnames, in which case they act as local options, only affecting tracing\nof the immediately preceding function name. Local options override\nglobal options.\n\nBy default, TRACE causes a printout on *TRACE-OUTPUT* each time that\none of the named functions is entered or returns. (This is the basic,\nANSI Common Lisp behavior of TRACE.) As an SBCL extension, the\n:REPORT SB-EXT:PROFILE option can be used to instead cause information\nto be silently recorded to be inspected later using the SB-EXT:PROFILE\nfunction.\n\nThe following options are defined:\n\n   :REPORT Report-Type\n       If Report-Type is TRACE (the default) then information is reported\n       by printing immediately. If Report-Type is SB-EXT:PROFILE, information\n       is recorded for later summary by calls to SB-EXT:PROFILE. If\n       Report-Type is NIL, then the only effect of the trace is to execute\n       other options (e.g. PRINT or BREAK).\n\n   :CONDITION Form\n   :CONDITION-AFTER Form\n   :CONDITION-ALL Form\n       If :CONDITION is specified, then TRACE does nothing unless Form\n       evaluates to true at the time of the call. :CONDITION-AFTER is\n       similar, but suppresses the initial printout, and is tested when the\n       function returns. :CONDITION-ALL tries both before and after.\n       This option is not supported with :REPORT PROFILE.\n\n   :BREAK Form\n   :BREAK-AFTER Form\n   :BREAK-ALL Form\n       If specified, and Form evaluates to true, then the debugger is invoked\n       at the start of the function, at the end of the function, or both,\n       according to the respective option.\n\n   :PRINT Form\n   :PRINT-AFTER Form\n   :PRINT-ALL Form\n       In addition to the usual printout, the result of evaluating Form is\n       printed at the start of the function, at the end of the function, or\n       both, according to the respective option. Multiple print options cause\n       multiple values to be printed.\n\n   :WHEREIN Names\n       If specified, Names is a function name or list of names. TRACE does\n       nothing unless a call to one of those functions encloses the call to\n       this function (i.e. it would appear in a backtrace.)  Anonymous\n       functions have string names like \"DEFUN FOO\". This option is not\n       supported with :REPORT PROFILE.\n\n   :ENCAPSULATE {:DEFAULT | T | NIL}\n       If T, the tracing is done via encapsulation (redefining the function\n       name) rather than by modifying the function. :DEFAULT is the default,\n       and means to use encapsulation for interpreted functions and funcallable\n       instances, breakpoints otherwise. When encapsulation is used, forms are\n       *not* evaluated in the function's lexical environment, but SB-DEBUG:ARG\n       can still be used.\n\n   :METHODS {T | NIL}\n       If T, any function argument naming a generic function will have its\n       methods traced in addition to the generic function itself.\n\n   :FUNCTION Function-Form\n       This is a not really an option, but rather another way of specifying\n       what function to trace. The Function-Form is evaluated immediately,\n       and the resulting function is instrumented, i.e. traced or profiled\n       as specified in REPORT.\n\n:CONDITION, :BREAK and :PRINT forms are evaluated in a context which\nmocks up the lexical environment of the called function, so that\nSB-DEBUG:VAR and SB-DEBUG:ARG can be used.\nThe -AFTER and -ALL forms can use SB-DEBUG:ARG.").
doc_string(truename, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (FILESPEC)\n\nReturns the full pathname of the file specified by FILESPEC.  FILESPEC may be\na symbol, a string, a pathname, or a file stream.\n").
doc_string(truename, 'common-lisp', function, "If PATHSPEC is a pathname that names an existing file, return\na pathname that denotes a canonicalized name for the file.  If\npathspec is a stream associated with a file, return a pathname\nthat denotes a canonicalized name for the file associated with\nthe stream.\n\nAn error of type FILE-ERROR is signalled if no such file exists\nor if the file system is such that a canonicalized file name\ncannot be determined or if the pathname is wild.\n\nUnder Unix, the TRUENAME of a symlink that links to itself or to\na file that doesn't exist is considered to be the name of the\nbroken symlink itself.").
doc_string(truncate, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER &OPTIONAL (DIVISOR 1))\n\nReturns the integer obtained by truncating NUMBER/DIVISOR.  Returns the value\nof (- NUMBER (* first-value DIVISOR)) as the second value.\n").
doc_string(truncate, 'common-lisp', function, "Return number (or number/divisor) as an integer, rounded toward 0.\n  The second returned value is the remainder.").
doc_string(typecase, 'common-lisp', function, "Syntax: (typecase keyform {(type {form}*)}*)\nEvaluates KEYFORM and searches a TYPE to which the value of KEYFORM belongs.\nIf found, then evaluates FORMs that follow the TYPE and returns all values of\nthe last FORM.  If not, simply returns NIL.  The symbols T and OTHERWISE may\nbe used as a TYPE to specify the default case.").
doc_string(typecase, 'common-lisp', function, "TYPECASE Keyform {(Type Form*)}*\n  Evaluates the Forms in the first clause for which TYPEP of Keyform and Type\n  is true.").
doc_string(typep, 'common-lisp', function, "Args: (object type)\nReturns T if X belongs to TYPE; NIL otherwise.").
doc_string(typep, 'common-lisp', function, "Is OBJECT of type TYPE?").
doc_string(typexpand, pkg_sys, function, "Takes and expands a type specifier repeatedly like MACROEXPAND.\nReturns two values: the expansion, and a boolean that is true when\nexpansion happened.").
doc_string(unencapsulate, 'sb-int', function, "Removes NAME's most recent encapsulation of the specified TYPE.").
doc_string(unexport, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (PACKAGE *PACKAGE*))\n\nUndoes the registration of SYMBOL as an external symbol of PACKAGE and makes\nSYMBOL internal to PACKAGE.  SYMBOL may be a list of symbols.\n").
doc_string(unexport, 'common-lisp', function, "Makes SYMBOLS no longer exported from PACKAGE.").
doc_string(unintern, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (SYMBOL &OPTIONAL (PACKAGE *PACKAGE*))\n\nRemoves SYMBOL from PACKAGE.  If PACKAGE is the home package of SYMBOL, then\nmakes SYMBOL uninterned.  Returns T if SYMBOL is actually registered in\nPACKAGE; NIL otherwise.\n").
doc_string(unintern, 'common-lisp', function, "Makes SYMBOL no longer present in PACKAGE. If SYMBOL was present then T is\nreturned, otherwise NIL. If PACKAGE is SYMBOL's home package, then it is made\nuninterned.").
doc_string(union, 'common-lisp', function, "Args: (list1 list2 &key (key #'identity) (test #'eql) test-not)\nReturns, as a list, the union of elements in LIST1 and in LIST2.").
doc_string(union, 'common-lisp', function, "Return the union of LIST1 and LIST2.").
doc_string(unless, 'common-lisp', function, "If the first argument is not true, the rest of the forms are\nevaluated as a PROGN.").
doc_string(unprofile, 'sb-profile', function, "Unwrap any profiling code around the named functions, or if no names\n  are given, unprofile all profiled functions. A symbol names\n  a function. A string names all the functions named by symbols in the\n  named package. NAMES defaults to the list of names of all currently\n  profiled functions.").
doc_string(untrace, 'common-lisp', function, "\r\n(UNTRACE) returns the list of traced functions, stops tracing all of them.\r\n(UNTRACE symbol ...) removes symbol, ... from the list of traced functions.").
doc_string(untrace, 'common-lisp', function, "Remove tracing from the specified functions. Untraces all\nfunctions when called with no arguments.").
doc_string(untrace, 'common-lisp', function, "Syntax: (untrace {function-name}*)\n\nEnds tracing the specified functions.  With no FUNCTION-NAMEs, ends tracing\nall functions.").
doc_string(uppercase, 'sb-unicode', function, "Returns the full uppercase of STRING according to the Unicode standard.\nThe result is not guaranteed to have the same length as the input. If :LOCALE\nis NIL, no language-specific case transformations are applied. If :LOCALE is a\nkeyword representing a two-letter ISO country code, the case transforms of that\nlocale are used. If :LOCALE is T, the user's current locale is used (Unix and\nWin32 only).").
doc_string(values, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (&REST ARGS)\n\nReturns ARGs as multiple values, the N-th ARG being the N-th value.\n").
doc_string(values, 'common-lisp', function, "Return all arguments, in order, as values.").
doc_string(var, 'sb-debug', function, "Return a variable's value if possible. NAME is a simple-string or symbol.\n   If it is a simple-string, it is an initial substring of the variable's name.\n   If name is a symbol, it has the same name and package as the variable whose\n   value this function returns. If the symbol is uninterned, then the variable\n   has the same name as the symbol, but it has no package.\n\n   If name is the initial substring of variables with different names, then\n   this return no values after displaying the ambiguous names. If name\n   determines multiple variables with the same name, then you must use the\n   optional id argument to specify which one you want. If you left id\n   unspecified, then this returns no values after displaying the distinguishing\n   id values.\n\n   The result of this function is limited to the availability of variable\n   information. This is SETF'able.").
doc_string(vector, 'common-lisp', function, "Args: (&rest objects)\nCreates and returns a simple-vector, with the N-th OBJECT being the N-th\nelement.").
doc_string(vector, 'common-lisp', function, "Construct a SIMPLE-VECTOR from the given objects.").
doc_string(vector, 'sb-impl', function, "Construct a SIMPLE-VECTOR from the given objects.").
doc_string(vectorp, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (X)\n\nReturns T if X is a vector; NIL otherwise.\n").
doc_string(vectorp, 'common-lisp', function, "Return true if OBJECT is a VECTOR, and NIL otherwise.").
doc_string(waitpid, 'sb-impl', function, "Return any available status information on child process with PID.").
doc_string(warn, 'common-lisp', function, "Args: (format-string &rest args)\nFormats FORMAT-STRING and ARGs to *ERROR-OUTPUT* as a warning message.  Enters\na break level if the value of *BREAK-ON-WARNINGS* is non-NIL.  Otherwise,\nreturns with NIL.").
doc_string(warn, 'common-lisp', function, "Warn about a situation by signalling a condition formed by DATUM and\n   ARGUMENTS. While the condition is being signaled, a MUFFLE-WARNING restart\n   exists that causes WARN to immediately return NIL.").
doc_string(when, 'common-lisp', function, "If the first argument is true, the rest of the forms are\nevaluated as a PROGN.").
doc_string(when, 'common-lisp', function, "Macro in COMMON-LISP package:\nSyntax: (TEST &BODY FORMS)\n\nIf TEST evaluates to non-NIL, then evaluates FORMs and returns all values of\nthe last FORM.  If not, simply returns NIL.\n").
doc_string(words, 'sb-unicode', function, "Breaks STRING into words acording to the default\nword breaking rules specified in UAX #29. Returns a list of strings").
doc_string(write, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (OBJECT &KEY (STREAM *STANDARD-OUTPUT*) (ESCAPE *PRINT-ESCAPE*) (RADIX *PRINT-RADIX*) (BASE *PRINT-BASE*) (CIRCLE *PRINT-CIRCLE*) (PRETTY *PRINT-PRETTY*) (LEVEL *PRINT-LEVEL*) (LENGTH *PRINT-LENGTH*) (CASE *PRINT-CASE*) (ARRAY *PRINT-ARRAY*) (GENSYM *PRINT-GENSYM*))\n\nPrints OBJECT in the specified mode.  See the variable docs of *PRINT-...* for\nthe mode.\n").
doc_string(write, 'common-lisp', function, "Output OBJECT to the specified stream, defaulting to *STANDARD-OUTPUT*.").
doc_string(zerop, 'common-lisp', function, "Function in COMMON-LISP package:\nArgs: (NUMBER)\n\nReturns T if the arg is zero; NIL otherwise.\n").
doc_string(zerop, 'common-lisp', function, "Is this number zero?").

:- fixup_exports.