ToC | DocOverview | CGDoc | RelNotes | FAQ | Index | PermutedIndex
| Allegro CL version 11.0

# aclssl-load-error

class, excl package

This simple-condition instance is signalled if an error is detected when the aclssl shared library is loaded. This error is included in the `format-arguments` slot. The error most likely indicates an Allegro CL installation problem.

OpenSLL is described in The Allegro CL SSL API in socket.html.

# annotation-output-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::string-output-with-encapsulated-annotation-stream` (note that the symbol naming the Gray stream is unexported). A subclass of string-output-simple-stream.

See streams.html for general information on simple-streams in Allegro CL.

# asynchronous-operating-system-signal

Class, excl package

This is the class of condition signaled when an asynchronous operating system signal (such as a Control-C) is caught.

See errors.html for general information on errors in Allegro CL.

# autoload-file-does-not-exist-error

Class, excl package

This condition, a subclass of the file-does-not-exist-error condition, is signaled when the system attempts to autoload a file which does not exist. Autoloading is triggered by the system, typically when a function or macro or package is referenced but the necessary module supporting the operator or package has not yet been loaded. (Thus users and programs typically only cause autoloads indirectly.) See Autoloading in implementation.html for more details on autoloading.

# basic-lock

class, excl package

This is a simple extension of synchronizing-structure, adding a name slot. Instances can be allocated and used as standalone locks in the with-locked-structure macro.

## Example usage

         (defvar xlock (make-basic-lock :name "xwidget lock"))
         ...
         (with-locked-structure (xlock)
            ...)

See smp.html and multiprocessing.html for more information on this macro and on multiprocessing.

# bidirectional-binary-socket-stream

Class, excl package

An instantiable stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# bidirectional-character-encapsulating-stream

Class, excl package

A simple-stream class which allows for easy encapsulation of other streams. This stream is based on string streams, and has an input and an output side, though only one base-stream can be given.

The option for creating a stream of this class is `:base-stream`.

See the rot13 example in streams.html for an example of how to use this class.

# bidirectional-terminal-stream

Class, excl package

An instantiable stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# break-condition

Class, excl package

This non-instantiable class is the superclass of simple-break.

See errors.html for general information on errors in Allegro CL.

# buffer-input-simple-stream

Class, excl package

This class is a subclass of direct-simple-stream. This class describes a stream which reads from an octet buffer, in a similar manner to a string-input-simple-stream, which reads from a lisp string.

The options when creating an instance of this class are: buffer, external-format, start and end. A buffer is a vector which is a simple-array with element type `(unsigned-byte 8)` or `(signed-byte 8)`.

See streams.html for general information on simple-streams in Allegro CL. See also make-buffer-input-stream.

# buffer-output-simple-stream

Class, excl package

This class is a subclass of direct-simple-stream. This class describes a stream which writes from an octet buffer, in a similar manner to a string-output-simple-stream, which writes from a lisp string.

The options when creating an instance of this class are buffer and external-format. The buffer option can either be an octet buffer (a vector which is a simple-array with element type `(unsigned-byte 8)` or `(signed-byte 8)`), or `nil`. If it is `nil`, the stream acts like a counting bit-bucket; no output is generated, and so no overflow can occur, but the file-position of the stream can be queried at the end of the write. See with-output-to-buffer.

See streams.html for general information on simple-streams in Allegro CL. See also make-buffer-output-stream.

# case-failure

Class, excl package

This is the class of condition signaled when a call to ecase or ccase fails because no case satisfied the test. See case-failure-name and case-failure-possibilities.

See errors.html for general information on errors in Allegro CL.

# compiler-free-reference-warning

class, excl package

This style warning is signaled when the compiler sees a variable it does not recognize (and thus treats as a special variable).

    cl-user(12): (setq *break-on-signals* t)
    t
    cl-user(13): (defun foo () (+ x 10))
    foo
    cl-user(14): (compile 'foo)
    ; While compiling #'foo at top level:
    Break: Free reference to undeclared variable x assumed special.
    break entered because of *break-on-signals*.

    Restart actions (select using :continue):
     0: return from break.
     1: skip warning.
     2: continue processing.
     3: Return to Top Level (an "abort" restart).
     4: Abort entirely from this (lisp) process.
    [1c] cl-user(15): :zo
    Evaluation stack:

       (break "~a~%break entered because of *break-on-signals*."
              #<compiler-free-reference-warning @ #x20d52a52>)
     ->(signal #<compiler-free-reference-warning @ #x20d52a52>)
       (warn compiler-free-reference-warning :format-control ...)

# compiler-inconsistent-name-usage-warning

Class, excl package

This condition class is a subclass of style-warning. Conditions of this class are signaled by the compiler whenever variable or tag names are used in a manner inconsistent with their possibly intended usage. Typical situations that trigger this condition are:

- A tag is unused.

- A variable is unused and not declared `ignore` or `ignorable`.

- A variable is declared `ignore` and yet is used.

# compiler-no-in-package-warning

Class, excl package

In previous releases, this condition was signaled when a file without an in-package form was compiled. This condition is no longer signaled under any circumstances, but the class is still defined for backward compatibility (since handlers will error if they are defined with non-existent condition classes).

# compiler-not-available-error

Class, excl package

This is the class of condition signaled when compile (or a related function) is called directly in an image without the compiler. This error may also be signaled when building a new image without the compiler with build-lisp-image. See also runtime.html.

See errors.html for general information on errors in Allegro CL.

# compiler-not-available-warning

Class, excl package

This is the class of condition signaled when compile (or a related function) is called indirectly in an image without the compiler. This warning may also be signaled when building a new image without the compiler with build-lisp-image. See also runtime.html.

See errors.html for general information on errors in Allegro CL.

# compiler-undefined-functions-called-warning

Class, excl package

This is the class of condition signaled if during the compilation of a file, the compiler notices a call to a function not defined (previously or in the file), it prints a warning that the function is called but not yet defined. (It is not an error to compile a function that calls a not-yet-defined function, of course. The warning is often useful, however, when the function name is typed incorrectly or the user believes a function is defined when it is not.)

This condition will also be signaled when an operator defined at the top-level calling undefined functions is compiled.

Here is an example:

    ;; The file foo.cl contains the following. Note the call to BAR.
    (in-package :user)
    (defun foo (x) (bar x))

    ;; Here is what happens when we compile the file:
    USER(1): (compile-file "foo.cl")
     ; --- Compiling file /net/rubix/usr/tech/dm/foo.cl ---
     ; Compiling FOO
     ; Writing fasl file "/net/rubix/usr/tech/dm/foo.fasl"
     ; Fasl write complete
     Warning: The following undefined functions were referenced in the compilation:
     (BAR)
    #p"/net/rubix/usr/tech/dm/foo.fasl"
    NIL
    NIL
    USER(2):

If multiple calls to compile-file are part of the body of a with-compilation-unit form, no undefined function warning will be signaled when a function called in one file is defined in a later file.

See compiling.html for general information on the Allegro CL compiler.

# compiler-unreachable-code-warning

Class, excl package

This condition class is a subclass of style-warning. Conditions of this class are signaled by the compiler whenever a cond clause or a ecase clause cannot be reached, presumably because of the presence of a `t` or `otherwise` clause before the unreachable clause.

Starting with version 11.0, these warnings are generated more often, including constantly `nil` predicates with non-trivial consequents (where those consequents become unreachable). These warnings can be suppressed when code is wrapped with the with-unreachable-code-allowed macro.

# composing-stream

Class, excl package

This kind of stream enables composing of external formats and ligatures using Java-style encapsulations. An open composing-stream is connected either to another composing-stream or to a base stream (either a single-channel-simple-stream or a dual-channel-simple-stream).

A composing-stream has no buffer of its own, but instead relies on state and on the buffering of the base stream it is connected to. Read/write operations on composing-streams are always done with respect to the next lower level stream it is encapsulating.

Like its superclass string-simple-stream, a composing-stream transfers characters instead of octets. However, unlike other string-simple-streams, external-format processing is performed to translate one or more characters into one or more characters, both while reading and while writing.

# damaged-system-constant-error

Class, excl package

This condition is a subclass of cell-error, and is raised when check-system-constants finds (and fixes) a bad value. Slots specific to this condition are:

- name: This slot is accessed using cell-error-name, and it contains the object whose contents are trashed.

- code: This slot is accessed using damaged-system-constant-error-code, and it contains a positive integer which represents the trashed value found. The actual description of the failure is embedded in a `~[ ~]` format control in the `:format-control` slot of the condition. The current code values and their meanings are:

  1. `nil`'s car

  2. `nil`'s cdr

  3. `nil`'s symbol-value

  4. `t`'s symbol-value

# defclass-embellisher-class

class, excl package

This class metaobject is an abstract class that serves as the superclass of all defclass-embelisher metaobjects.
defclass-embellisher classes are described in the section Metaclasses for embellishing class definitions in implementation.html.

This class should not be instantiated itself, but may be subclassed by other class metaobjects intending to provide the embellishments on the macroexpanded result of a defclass form. If the defclass form uses one of this class's subclasses as its `:metaclass` argument, then provision will be made by defclass to add extra forms at the end of the macroexpanded code. That class metaobject's class-prototype will be instantiated once at macroexpand time, in order to provide discrimination for normalize-direct-slots. Such a subclass must be finalized before it can be used as the `:metaclass` argument to defclass, because defclass will try to access the class's prototype, and it must be finalized in order for that to happen.

Two embellishers classes are defined in Allegro CL: excl:fixed-index-class and excl:fixed-index-filling-class. Examples in Metaclasses for embellishing class definitions in implementation.html show how to defined additional embellisher subclasses.

# direct-simple-stream

Class, excl package

This class is a subclass of single-channel-simple-stream and describes streams whose single workspace is really the final source or destination object. It is similar to string-stream, but different in the sense that it always works with workspaces that are octet-oriented.

Subclasses of this class include mapped-file-simple-stream, buffer-input-simple-stream, and buffer-output-simple-stream

See streams.html for general information on simple-streams in Allegro CL.

# dual-channel-simple-stream

Class, excl package

This kind of stream has two octet buffers, and they do not interact with each other. Terminals and sockets are dual-channel streams.

A dual-channel stream has two buffers, one for the input direction and one for the output direction. Reads will grab data from the input buffer until empty, when device-read is called to fill it up again. Writes place data into the output-buffer until it is full, at which time device-write is called to empty it again.

# errno-stream-error

Class, excl package

A subclass of stream-error (see More on cl:stream-error in errors.html). This condition has five slots. The first four are inherited from the Allegro CL implementation of stream-error:

- `stream`: the stream which got the error. This is the standard CL slot and is accessed by stream-error.

- `action`: the action that was being attempted at the time of the error, accessed by stream-error-action.

- `code`: the errno code returned from the system, nil if none. Accessed by stream-error-code.

- `identifier`: symbolic identification of the code, or nil if unknown. Accessed by stream-error-identifier.

The fifth slot is `string` and is accessed by stream-error-string.

# external-format

Class, excl package

The class of external-format objects. See iacl.html.

# fasl-casemode-mismatch

Class, excl package

This is the class of condition signaled when an attempt is made to load a file compiled in case-insensitive-upper (ansi) into a case-sensitive-lower (modern) mode image. The blocking is done to avoid multiple symbols (uppercase and lowercase) intended to be identical from being created. A restart allows users to load the file anyway if desired.

The following illustrates what can happen when the condition is ignored and a file is loaded:

    [Source File x.cl]

     (in-package :user)

     (eval-when (load)
       (defparameter My-foo "compiled"))

     (eval-when (eval)
       (defparameter My-foo "interpreted"))

    [In ANSI Lisp]

    CL-USER(1): (load "x.cl")
    T
    CL-USER(2): My-foo
    "interpreted"

    CL-USER(3): (compile-file "x.cl")
    CL-USER(4): (load "x.fasl")
    T
    CL-USER(5): My-foo
    "compiled"

    [In Modern Lisp]

    cl-user(1): (load "x.cl")
    t
    cl-user(2): My-foo
    "interpreted"

    cl-user(3): (load "x.fasl")
    Error: #p"[...]/x.fasl" was compiled in
           case-insensitive-upper mode.  Continuing to load this file may result
           in symbol-name mismatches.
     [condition type: fasl-casemode-mismatch]

    Restart actions (select using :continue):
     0: Continue loading /air/cox/work/acl/src/cl/src/x.fasl
     1: retry the load of x.fasl
     2: skip loading x.fasl
     3: Return to Top Level (an "abort" restart)
     4: Abort #<process Initial Lisp Listener>
    [1] cl-user(4): :cont
    t

    cl-user(5): My-foo
    "interpreted"        ;;; Occurs because fasl file drops case-sensitivity

    cl-user(6): my-foo
    "compiled"

See case,html for general information on case in Allegro CL.

# file-does-not-exist-error

Class, excl package

This condition, a subclass of the `file-error` condition, is signaled when an attempt is made to load a file that does not exist, when the `:if-does-not-exist` keyword argument to load is true, which is the default. (Trying to open a file that does not exist but is expected to with open does not signal this condition; it signals `file-error`.)

### Example

    (load "nosuchfile.cl")
      Error: "nosuchfile.cl" does not exist, cannot load
      [condition type: file-does-not-exist-error]

    ;; But
    (load "nosuchfile.cl" :if-does-not-exist nil)
      RETURNS nil

# file-incompatible-fasl-error

Class, excl package

This is the class of condition signaled when an attempt is made to load an incompatible fasl file into a running Lisp. This can happen in two ways:

1. The internal version of the fasl file is incompatible with the lisp that is loading it. The version number is set when an Allegro CL release is made. The actual number is not the same as the release number (thus the fasl version number for Allegro CL release 8.1 is not "8.1"), but the fasl version is usually incremented with each release and all files must be recompiled when moving from one release to a later release (from release 8.0 to release 8.1, for example).

   The internal fasl version number is stored in the fasl file but not in a way that can be read by humans. If you want to find out in gross terms if your file foo.fasl is compatibe with your lisp, type head -4 foo.fasl into most UNIX shells, or into cygwin on Windows (some versions of head might require a different style of specifying only 4 lines). The first 4 lines of the fasl file are (mostly) human readable starting with "" (if such a string doesn't appear on the first line, then it is likely either a corrupted file or a fasl generated by another Lisp implementation).

   The second line will contain the string identifying the lisp which compiled it. It will include a Lisp version, an architecture, and a date. If the first two items don't match what startup information is printed on your Lisp, then it is the likely cause of the error.

2. Certain architectures (e.g. x86, x86-64) are the underlying architecture for several operating systems. Fasl files produced on one might be loadable on another. In general, the non-windows Lisps of the same architecture allow their fasl files to be loaded into each other's Lisps, so the file-incompatible-fasl-error condition cannot be counted on to distinguish different Lisps. However this error will be generated whenever an attempt is made to load a Windows fasl file into a non-Windows Lisp, or to load a non-Windows fasl file into a Windows Lisp.

This is not the error signaled when trying to load a fasl file generated on one architecture into a Lisp running on another architecture.

See errors.html for general information on errors in Allegro CL.

# file-simple-stream

Class, excl package

A simple-stream subclass. A subclass of file-stream.

The options when creating an instance of this class are: filename (required), direction (defaults to :input), if-exists, if-does-not-exist, external-format (defaults to :default), input-handle, output-handle, mapped, fn-in (another name for the input-handle, for compatibility only, do not specify both) and fn-out (another name for the output handle, for compatibility only, do not specify both).

See device-open for a description of the input-handle, output-handle, and mapped options.

See streams.html for general information on simple-streams in Allegro CL.

# fill-pointer-output-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::string-output-simple-stream`. Created with make-string-output-stream when the string argument has a fill-pointer.

See streams.html for general information on simple-streams in Allegro CL.

# fixed-index-class

class, excl package

A defclass-embellisher class metaobject - a subclass of defclass-embellisher-class. defclass-embellisher classes are described in the section Metaclasses for embellishing class definitions in implementation.html.

Adding `:metaclass fixed-index-class` to a defclass form causes fixed-index assignments to be made to every direct slot in the class, starting with the first available index after any explicitly assigned fixed-indexes specified in either the class being defined or in any of its superclass structure. (Class instances have vectors of slot values and the indices referred to are into that vector. See Optimizing slot-value calls with fixed indices in implementation.html.) This is known as the appending style of fixed-index assignment. If explicit fixed-index assignments are not sequential, then there will be holes in the slots vector. See also excl:fixed-index-filling-class which fills in index holes. If there are no explicitly assigned fixed-index slots, then the behavior is no different between this class and excl:fixed-index-filling-class.

Further, accessor compiler macros are defined which cause compilation of accessors to use the slot-value-using-class-name macro (which is faster than a standard accessor function) to obtain slot values.

    ;; Here is an example. We define a class FOO with two fixed index slots
    ;; using indices 1 and 3:

    (defclass foo ()
      ((a :initarg :a excl:fixed-index 1 :reader foo-a)
       (b :initarg :b excl:fixed-index 3 :reader foo-b)))

    ;; Now we define a subclass BAZ with metaclass FIXED-INDEX-CLASS
    (defclass baz (foo)
      ((x :initarg :x :reader bar-x)
       (y :initarg :y :reader bar-y)
       (z :initarg :z :reader bar-z))
       (:metaclass excl:fixed-index-class))

    ;; When we look at the macroexpansion of the DEFCLASS form for BAZ, we
    ;; see it uses indices 4, 5, and 6, leaving 0 and 2 unused:

    cl-user(82): (pprint (macroexpand '(defclass baz (foo)
      ((x :initarg :x :reader bar-x)
       (y :initarg :y :reader bar-y)
       (z :initarg :z :reader bar-z))
       (:metaclass excl:fixed-index-class))))

    (progn nil
           (eval-when (compile)
             (excl::check-lock-definitions-compile-time 'baz :type 'defclass
               (find-class 'baz nil)))
           (record-source-file 'baz :type :type)
           (excl::ensure-class-1 'baz :direct-superclasses '(foo) :direct-slots
                                 (list (list ':name 'x ':initargs '(:x) ':readers
                                             '(bar-x) 'fixed-index '4)
                                       (list ':name 'y ':initargs '(:y) ':readers
                                             '(bar-y) 'fixed-index '5)
                                       (list ':name 'z ':initargs '(:z) ':readers
                                             '(bar-z) 'fixed-index '6))
                                 :metaclass 'fixed-index-class)
           (define-compiler-macro bar-x (excl::instance)
             (excl::bq-list `slot-value-using-class-name
                            (excl::bq-list `quote 'baz) excl::instance
                            (excl::bq-list `quote 'x)))
           ...)

    ;; Other accessors also have compiler macros.

### Warning: code containing accessor calls may ignore :before, :around, and :after methods

The compiler macros defined for slot accessors when the fixed-index-class metaclass is specified cause, under the right compiler settings, forms like `(foo-a <foo-inst>)` to be transformed to `(svref slot-vector slot-fixed-index)`. This can very significantly speed up slot accesses but part of the speedup results from discarding the usual method processes: if the compiler macro kicks in, :around, :before, and :after methods on the slot accessors are ignored. Here is an example:

    ;;------------------- file bar-class.cl -----------------------

    (in-package :user)

    (defclass bar ()
      ((x :initarg :x :reader bar-x)
       (y :initarg :y :reader bar-y)
       (z :initarg :z :reader bar-z))
      (:metaclass excl:fixed-index-class))

    (defmethod bar-x :before ((x bar)) (print "BEFORE!"))
    (defmethod bar-x :after ((x bar)) (print "AFTER!"))
    (defmethod bar-x :around ((x bar)) (print "AROUND!")
           (call-next-method))

    (defvar *bar-inst* (make-instance 'bar :x "VALUE OF X SLOT"))

    (defun bbb (x) (bar-x x))

    ;; ---------------------- bar-class.cl end -------------

    ;; We load bar-class.cl without compiling:
    cl-user(2): :ld bar-class.cl
    ; Loading /net/gemini/home/dm/bar-class.cl

    ;; We call the function BBB. As expected, the :AROUND, :BEFORE
    ;; and :AFTER methods run and then the slot value is returned:
    cl-user(3): (bbb *bar-inst*)

    "AROUND!"
    "BEFORE!"
    "AFTER!"
    "VALUE OF X SLOT"

    ;; We set the compiler optimization values to high speed, low
    ;; safety and debug:
    cl-user(4): :opt

    A response of ? gets help on possible answers.

    compiler optimize safety setting (0 is fastest): [1]
    compiler optimize space setting: [1]
    compiler optimize speed setting (3 is fastest): [1] 3
    compiler optimize debug setting (3 is maximum): [2] 0
    compiler optimize compilation-speed setting: [1] 0

    Compiler optimize setting is
         (declaim (optimize (safety 1) (space 1) (speed 3) (debug 0)
                   (compilation-speed 0)))
    cl-user(5): :cf bar-class.cl
    ;;; Compiling file bar-class.cl
    ;;; Writing fasl file bar-class.fasl
    ;;; Fasl write complete
    cl-user(6): :ld bar-class.fasl
    ; Fast loading /net/gemini/home/dm/bar-class.fasl
    cl-user(7): (bbb *bar-inst*)
    "VALUE OF X SLOT"

    ;; The :AROUND, :BEFORE and :AFTER methods DO NOT RUN.
    ;; Just the slot value is returned.

    ;; There are workarounds. You can declare the accessors on
    ;; which you want :AROUND, :BEFORE or :AFTER methods NOTINLINE:
    cl-user(10): (proclaim '(notinline bar-x))
    t
    cl-user(11): :cf bar-class.cl
    ;;; Compiling file bar-class.cl
    ;;; Writing fasl file bar-class.fasl
    ;;; Fasl write complete
    cl-user(12): :ld bar-class-fasl
    ; Fast loading /net/gemini/home/dm/bar-class.fasl
    cl-user(13): (bbb *bar-inst*)

    "AROUND!"
    "BEFORE!"
    "AFTER!"
    "VALUE OF X SLOT"
    cl-user(14):

    ;; You can also get generic function semantics with one level of
    ;; indirection. If you define this additional accessor:

    (defmethod generic-bar-a ((obj bar))
       (bar-a obj))

    ;; :around, :before, and :after specializers on GENERIC-BAR-A will
    ;; work as expected. This will not be as fast as embellished and
    ;; compiled BAR-A, but will generally be faster than an
    ;; unembellished BAR-A.

The fixed index option is designed to allow very fast slot access. Users who need to write additional methods on slot accessors should not use the fixed index embellisher classes because they should not use the compiler macros (using fixed indices is okay and itself provides some speedup).

# fixed-index-filling-class

class, excl package

A defclass-embellisher class metaobject - a subclass of fixed-index-class and defclass-embellisher-class. defclass-embellisher classes are described in the section Metaclasses for embellishing class definitions in implementation.html.

Adding `:metaclass fixed-index-filling-class` to a defclass form causes fixed-index assignments to be made to every direct slot in the class, starting with the lowest available index not yet assigned. (Class instances have vectors of slot values and the indices referred to are into that vector. See Optimizing slot-value calls with fixed indices in implementation.html.) This is known as the filling style of fixed-index assignment, because it fills holes. If there are no explicitly assigned fixed-index slots, then the behavior is no different between this class and excl:fixed-index-class.

Further, accessor compiler macros are defined which cause compilation of accessors to use the slot-value-using-class-name macro (which is faster than a standard accessor function) to obtain slot values.

    ;; Here is an example. We define a class FOO with two fixed index slots
    ;; using indices 1 and 3:

    (defclass foo ()
      ((a :initarg :a excl:fixed-index 1 :reader foo-a)
       (b :initarg :b excl:fixed-index 3 :reader foo-b)))

    ;; Now we define a subclass bar with metaclass FIXED-INDEX-FILLING-CLASS
    (defclass bar (foo)
      ((x :initarg :x :reader bar-x)
       (y :initarg :y :reader bar-y)
       (z :initarg :z :reader bar-z))
       (:metaclass excl:fixed-index-filling-class))

    ;; When we look at the macroexpansion of the DEFCLASS form for BAR, we
    ;; see it uses indices 0, 2, and 4, which are free as FOO used 1 and 3:

    cl-user(80): (pprint (macroexpand '(defclass bar (foo)
      ((x :initarg :x :reader bar-x)
       (y :initarg :y :reader bar-y)
       (z :initarg :z :reader bar-z))
       (:metaclass excl:fixed-index-filling-class))))

    (progn nil
           (eval-when (compile)
             (excl::check-lock-definitions-compile-time 'bar :type 'defclass
               (find-class 'bar nil)))
           (record-source-file 'bar :type :type)
           (excl::ensure-class-1 'bar :direct-superclasses '(foo) :direct-slots
                                 (list (list ':name 'x ':initargs '(:x) ':readers
                                             '(bar-x) 'fixed-index '0)
                                       (list ':name 'y ':initargs '(:y) ':readers
                                             '(bar-y) 'fixed-index '2)
                                       (list ':name 'z ':initargs '(:z) ':readers
                                             '(bar-z) 'fixed-index '4))
                                 :metaclass 'fixed-index-filling-class)
           (define-compiler-macro bar-x (excl::instance)
             (excl::bq-list `slot-value-using-class-name
                            (excl::bq-list `quote 'bar) excl::instance
                            (excl::bq-list `quote 'x)))
           ...)
    ;; Other accessors also have compiler macros.

### Warning: code containing accessor calls may ignore :before, :around, and :after methods

The compiler macros defined for slot accessors when the fixed-index-filling-class metaclass is specified cause, under the right compiler settings, forms like `(foo-a <foo-inst>)` to be transformed to `(svref slot-vector slot-fixed-index)`. This can very significantly speed up slot accesses but part of the speedup results from discarding the usual method processes: if the compiler macro kicks in, :around, :before, and :after methods on the slot accessors are ignored. Here is an example:

    ;;------------------- file bar-class.cl -----------------------

    (in-package :user)

    (defclass bar ()
      ((x :initarg :x :reader bar-x)
       (y :initarg :y :reader bar-y)
       (z :initarg :z :reader bar-z))
      (:metaclass excl:fixed-index-filling-class))

    (defmethod bar-x :before ((x bar)) (print "BEFORE!"))
    (defmethod bar-x :after ((x bar)) (print "AFTER!"))
    (defmethod bar-x :around ((x bar)) (print "AROUND!")
           (call-next-method))

    (defvar *bar-inst* (make-instance 'bar :x "VALUE OF X SLOT"))

    (defun bbb (x) (bar-x x))

    ;; ---------------------- bar-class.cl end -------------

    ;; We load bar-class.cl without compiling:
    cl-user(2): :ld bar-class.cl
    ; Loading /net/gemini/home/dm/bar-class.cl

    ;; We call the function BBB. As expected, the :AROUND, :BEFORE
    ;; and :AFTER methods run and then the slot value is returned:
    cl-user(3): (bbb *bar-inst*)

    "AROUND!"
    "BEFORE!"
    "AFTER!"
    "VALUE OF X SLOT"

    ;; We set the compiler optimization values to high speed, low
    ;; safety and debug:
    cl-user(4): :opt

    A response of ? gets help on possible answers.

    compiler optimize safety setting (0 is fastest): [1]
    compiler optimize space setting: [1]
    compiler optimize speed setting (3 is fastest): [1] 3
    compiler optimize debug setting (3 is maximum): [2] 0
    compiler optimize compilation-speed setting: [1] 0

    Compiler optimize setting is
         (declaim (optimize (safety 1) (space 1) (speed 3) (debug 0)
                   (compilation-speed 0)))
    cl-user(5): :cf bar-class.cl
    ;;; Compiling file bar-class.cl
    ;;; Writing fasl file bar-class.fasl
    ;;; Fasl write complete
    cl-user(6): :ld bar-class.fasl
    ; Fast loading /net/gemini/home/dm/bar-class.fasl
    cl-user(7): (bbb *bar-inst*)
    "VALUE OF X SLOT"

    ;; The :AROUND, :BEFORE and :AFTER methods DO NOT RUN.
    ;; Just the slot value is returned.

    ;; There are workarounds. You can declare the accessors on
    ;; which you want :AROUND, :BEFORE or :AFTER methods NOTINLINE:
    cl-user(10): (proclaim '(notinline bar-x))
    t
    cl-user(11): :cf bar-class.cl
    ;;; Compiling file bar-class.cl
    ;;; Writing fasl file bar-class.fasl
    ;;; Fasl write complete
    cl-user(12): :ld bar-class.fasl
    ; Fast loading /net/gemini/home/dm/bar-class.fasl
    cl-user(13): (bbb *bar-inst*)

    "AROUND!"
    "BEFORE!"
    "AFTER!"
    "VALUE OF X SLOT"
    cl-user(14):

    ;; You can get also generic function semantics with one level of
    ;; indirection. If you define this additional accessor:

    (defmethod generic-bar-a ((obj bar))
       (bar-a obj))

    ;; :around, :before, and :after specializers on GENERIC-BAR-A will
    ;; work as expected. This will not be as fast as embellished and
    ;; compiled BAR-A, but will generally be faster than an
    ;; unembellished BAR-A.

The fixed index option is designed to allow very fast slot access. Users who need to write additional methods on slot accessors should not use the fixed index embellisher classes because they should not use the compiler macros (using fixed indices is okay and itself provides some speedup).

See excl:fixed-index-class, which start indexing at the first available index after any explicitly assigned fixed-indexes specified in either the class being defined or in any of its superclass structure. In the example above, it would use indices 4, 5, and 6, leaving 0 and 2 unused.

# float-declaration-used-warning

Class, excl package

This symbol, and the condition class it named, are no longer supported. In earlier releases, a warning was signaled when a variable was declared a float, rather than a single-float or a double-float. Because Allegro CL supports two floating-point types, declaring a variable to be a `float` could result in less than optimal code, because inlining of mathematical routines was not possible.

However, there are other reasons to declare a variable to be a float, for example when methods are written on the float class and the program is telling the compiler that those methods apply to a variable. Warnings are inappropriate in that case, but (except for inconvenient additional programming) cannot be avoided.

For that and other reasons, the warning is no longer signaled and the condition class has been removed. The `:explain` declaration can be used to ensure floating-point code is properly optimized. See Help with declarations in compiling.html for further details on optimizing floating-point code.

# fundamental-binary-input-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-binary-output-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-binary-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-character-input-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-character-output-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-character-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-input-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-output-stream

Class, excl package

A non-instantiable, mixin stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# fundamental-stream

Class, excl package

This class is a subclass of `stream` and of `standard-object`. streamp will return true for an instance of any class that includes this. This is one of various stream "mixin" classes intended to be used as super classes of user-defined stream classes. It is not intended to be directly instantiated; these classes primarily provide places to hang default methods.

See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# gb-18030-transcoding-error

class, excl package

This class names the condition that is signaled when a transcoding error is encountered by the `:gb118030` external-format (when the action which is the value of *gb-18030-transcoding-error-action* is specified as `:error` or a value other than `nil`, `:warn`, `:count`, `:collect`, and integer, or a cons).

See Strict external formats which do not allow improper characters in iacl.html for more information on the `:vb-18030` external format, international characters and external formats in general.

# gb-18030-transcoding-warning

class, excl package

This is the class of the condition that is signaled when a transcoding error is encountered by the `:gb118030` external-format (when the action which is the value of *gb-18030-transcoding-error-action* is specified as `:warn`).

See Strict external formats which do not allow improper characters in iacl.html for more information on the `:gb-18030` external format, international characters and external formats in general.

# incompatible-conformance-change-warning

Class, excl package

This warning (a subclass of warning) is signaled when the compiler encounters code containing calls to functions named by the symbols cl:single-float, cl:double-float, or cl:simple-string. These functions are no longer defined. It was always improper to define functions not specified in the Common Lisp standard on symbols in the common-lisp package.

In addition to signaling this warning, the usual warning about a call to an undefined function will be signaled by the compiler. The new warning is intended to make clear why previously defined functions are now undefined. Note that this warning is not signaled when a call is actually made (rather than code containing such a call is compiled).

The warning will not occur if new functions have been defined. Defining such a function requires suppressing the package lock restriction, see Package locking and package definition locking and its subsections in packages.html. The warning can also be suppressed in the usual way by the condition system (see, for example, handler-case and handler-bind.

Here is a trancript showing the warning being signaled:

    cl-user(1): (shell "cat warn.cl")

    (defun foo (x)
      (double-float x)
      (bar x))
    0
    cl-user(2): :cf warn
    ;;; Compiling file warn.cl
    ; While compiling foo:
    Warning: Call to double-float was removed from Allegro CL for conformance to
             the ANSI spec.  Please use "(coerce ... 'double-float)" instead.  See
             also a description of the conformance issue for double-float in the
             Release Notes.
    ;;; Writing fasl file warn.fasl
    ;;; Fasl write complete
    Warning: While compiling these undefined functions were referenced:
             bar from position 2 in warn.cl
             double-float from position 2 in warn.cl
    cl-user(3): (setq excl::*break-on-warnings* t)
    t
    cl-user(4): :cf
    ;;; Compiling file warn.cl
    Break: Call to double-float was removed from Allegro CL for conformance to the
           ANSI spec.  Please use "(coerce ... 'double-float)" instead.  See also
           a description of the conformance issue for double-float in the Release
           Notes.

    Restart actions (select using :continue):
     0: return from break.
     1: retry the compilation of warn.cl
     2: continue compiling warn.cl but generate no output file
     3: Return to Top Level (an "abort" restart).
     4: Abort entirely from this (lisp) process.
    [1c] cl-user(5): :up
    Evaluation stack:

     ->(break "~a" #<incompatible-conformance-change-warning @ #x10b8a8b2>)
       (warn incompatible-conformance-change-warning :format-control ...)
       ((flet comp::qc-do-a-function-call comp::note-undefined-function)
          double-float)
       (comp::qc-do-a-function-call #<call double-float @ #x10b8a42a> nil ...)
       (comp::qc-compile #<call double-float @ #x10b8a42a> nil)

    ... more older frames ...
    [1c] cl-user(6):

# ineffective-declaration-warning

Class, excl package

This is the class of condition that may be signaled when compile notices a declaration which it does not understand or which cannot be effective. See compiling.html for information on the compiler.

See errors.html for general information on errors in Allegro CL.

# input-binary-socket-stream

Class, excl package

An instantiable stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# input-terminal-stream

Class, excl package

An instantiable stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# interrupt-signal

Class, excl package

This is the class of condition signaled when an interrupt signal is received.

See errors.html for general information on errors in Allegro CL.

# lockable-object

class, excl package

This is a mixin class that allows subclasses to be used in the with-locked-object macro.

See smp.html and multiprocessing.html for more information on this macro and on multiprocessing.

# mapped-file-simple-stream

Class, excl package

This simple-stream subclass is a subclass of both file-simple-stream and direct-simple-stream. Similar to file-simple-stream but opening a mapped file allows for much faster access to the file, with much less kernel overhead. Note: most operating systems do not allow the automatic extension of mapped files, so this class does not allow the extending operation either. Writes beyond the end of the file may cause an error.

A mapped file must be a simple-stream which has `:mapped t` specified to the operator (like to open) which creates the stream. Recall that a simple stream is created when the :element-type is not specified (see the beginning of streams.html). The direction argument to open should be `:input` or `:io`. The file should have permissions consistent with the value specified to direction: if `:input` is specified, the file must be readable; if `:io` is specified, it must be both readable and writable.

The handle of a mapped file can be released at stream creation time if the option `:release-handle t` is specified. open will then return a stream which has been mapped to a file but for which the file number (the handle) has been closed. The mapping is not removed, but the file handle is made available for use in other file stream situations. The mapping is removed when close is called on the stream.

After a mapped-file-simple-stream is opened, the value returned by calling mapped-file-simple-stream-buffer on the stream is an aligned pointer (see the section Aligned pointers in ftype.html) which can be used with any accessors that support aligned pointers, e.g. fslot-value-typed with an `:aligned` allocation.

The options when creating an instance of this class are:

- filename (required)

- direction (defaults to `:input`)

- if-exists

- if-does-not-exist

- external-format (defaults to `:default`)

- input-handle

- output-handle

- release-handle: releases the handle of a mapped file. The mapping is not removed, but the file handle is made available for use in other file stream situations.

- mapped

- length (the length of the mapping)

- offset (the number of bytes beyond the start of the file where the mapping begins)

- fn-in (another name for the input-handle, for compatibility only, do not specify both)

- fn-out (another name for the output handle, for compatibility only, do not specify both)

See device-open for a description of the input-handle, output-handle, and mapped options.

For the offset and length arguments, no attempt is made to validate their values; they are passed to the underlying mapping implementation. For offset the system is likely to require a page alignment; the mapping may fail if the offset is not some multiple of a page size, typically 4096. For length page alignment may be needed here as well but that is less likely. Often the length argument is more lax, because the system simply rounds that argument up to the next page boundary. If the length is not page aligned, however, it would be dangerous to use any memory between the length and the page boundary.

Starting with the 11.0 version (and available as a patch on 10.1) if the if-exists keyword is specified to be `:append` then the file-position is set to the end of the file, rather than at the start of the file. Even though this is not useful with the basic mapped-file-simple-stream, it is more consistent with the use of `:if-exists :append` without the `:mapped` option; it also sets up for the first read after the file is opened to initiate end-of-file processing.

Example:

    cl-user(1): (shell "cat xx1")
    hello
    0
    cl-user(2): (setq xxx (open "xx1" :direction :io :if-exists :append))
    #<file-simple-stream #P"xx1" pos 6 @ #x10003d713f2>
    cl-user(3): (read xxx)
    Error: eof encountered on stream
           #<file-simple-stream #P"xx1" pos 6 @ #x10003d713f2>
      [condition type: end-of-file]

    Restart actions (select using :continue):
     0: Return to Top Level (an "abort" restart).
     1: Abort entirely from this (lisp) process.
    [1] cl-user(4): :res
    cl-user(5): (close xxx)
    t
    cl-user(6): (setq xxx (open "xx1" :direction :io :if-exists :append :mapped t))
    #<mapped-file-simple-stream #P"xx1" mapped pos 6 @ #x10003d787b2>
    cl-user(7): (read xxx)
    Error: eof encountered on stream
           #<mapped-file-simple-stream #P"xx1" mapped pos 6 @ #x10003d787b2>
      [condition type: end-of-file]

    Restart actions (select using :continue):
     0: Return to Top Level (an "abort" restart).
     1: Abort entirely from this (lisp) process.
    [1] cl-user(8): :res
    cl-user(9): (close xxx)
    t
    cl-user(10):

See streams.html for general information on simple-streams in Allegro CL.

# no-external-format-error

Class, excl package

This is the class of condition signaled by find-external-format when the function is unable to return the queried external-format.

# null-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::null-stream` and a subclass of single-channel-simple-stream. Reads from this stream always return EOF. Writes to this stream always succeed and go nowhere.

The option when creating an instance of this class is external-format.

See streams.html for general information on simple-streams in Allegro CL.

# openssl-load-error

class, excl package

This simple-condition instance is signaled if an error is detected when the OpenSSL shared libraries are loaded. This error is inclued in the `format-arguments` slot. The `format-control` string is different on different platforms but the message is always about the location of the shared libraries.

OpenSLL is described in The Allegro CL SSL API in socket.html.

# operating-system-signal

Class, excl package

This is the superclass of conditions signaled when an unhandled operating system signal is received.

See errors.html for general information on errors in Allegro CL.

# output-binary-socket-stream

Class, excl package

An instantiable stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# output-terminal-stream

Class, excl package

An instantiable stream class. See Stream classes in gray-streams.html for information.

See gray-streams.html for general information on the Gray streams implementation in Allegro CL. See streams.html for a description of the simple-stream stream implementation.

# package-locked-error

Class, excl package

This is the class of condition signaled when an attempt is made to modify a locked package or modify the definition of an object named by a symbol in a locked package.

See Package locking and package definition locking in packages.html for information.

See errors.html for general information on errors in Allegro CL.

# portable-fasl-file-version-warning

Class, excl package

Fasl (i.e. compiled Lisp) files are generally strict about how they match up with the Lisp that created them. Differences in version, SMP-ness, word-size, endianness or case-mode will normally cause the load of a fasl file to abort.

However, if a fasl file is built with no native instruction-level code in it, it is then considered a Portable fasl file. Portable fasl files generated in one version of Allegro CL will be generally loadable into Lisps with newer versions. However, a warning of type `excl:portable-fasl-file-version-warning` will be generated. The warning can also be suppressed in the usual way by the condition system (see, for example, handler-case and handler-bind.

See Portable fasl files in compiling.html for more info and caveats about loading Portable fasl files.

# probe-simple-stream

Class, excl package

A simple-stream subclass. This stream is returned from a probe-file for an existing file. It has little use other than to identify that the file exists, plus to possibly give it a name. The option when creating an instance is filename, which names the file to be probed.

See streams.html for general information on simple-streams in Allegro CL.

# purespace-write-error

class, excl package

Lisp can have a pll file where constant strings and codevectors can be stored, thus saving space in the Lisp heap and avoiding duplicate strings and codevectors. See Creating and using pll files in miscellaneous.html for details. Constant strings stored in a pll cannot be modified. Doing so signals an error of condition type purespace-write-error, as the following example shows (run in a modern Lisp where Common Lisp symbols are named with lowercase strings -- see case.html:

    cl-user(1): (pll-file)
    #P"/usr/fi/dcl.pll"
    cl-user(2): (nstring-upcase (symbol-name 'car))
    Error: Attempt to store into purespace address #x2d7865e8.
      [condition type: purespace-write-error]

# simple-break

Class, excl package

This is the class of condition signaled by a call to break.

See errors.html for general information on errors in Allegro CL.

# simple-stream

Class, excl package

The class of simple-stream.

See streams.html for general information on simple-streams in Allegro CL.

# single-channel-simple-stream

Class, excl package

This class has a single octet buffer and allows read-modify-write operations. File streams are single-channel streams.

A single-channel stream has one buffer and a directional state to specify whether the buffer and stream is in read, write, or read-modify mode. Flushes (device-writes) are performed when switching from write or read-modify to read mode if the buffer is dirty, and may involve a call to device-file-position. single-channel-simple-streams tend to support file-position and file-length, though this is not required.

A subclass of single-channel-simple-stream, namely direct-simple-stream, allows input from or output to a buffer directly. Subclasses of direct-simple-stream allow buffers to be read from or written to, in a similar manner as string-input or string-output streams.

A subclass of file-simple-stream and of direct-simple-stream allows the opening of mapped files. Instead of a buffer, a mapped file provides a direct mapping to the file within memory.

This kind of stream is useful for files and other devices which must allow random write/read access.

See streams.html for a description of the simple-stream stream implementation.

# socket-base-simple-stream

Class, excl package

A simple-stream class. This stream is encapsulated by socket-simple-stream when the first chunking-input request is processed. The socket-base-simple-stream acts as a device to the socket-simple-stream, feeding it bytes after de-chunking the input.

The options when creating an instance of this class are: filename, direction (defaults to :input), if-exists, if-does-not-exist, external-format (defaults to :default), input-handle, output-handle, mapped, fn-in (another name for the input-handle, for compatibility only, do not specify both) and fn-out (another name for the output handle, for compatibility only, do not specify both).

See device-open for a description of the input-handle, output-handle, and mapped options.

See streams.html for a description of the simple-stream stream implementation.

# socket-chunking-end-of-file

Class, excl package

A condition of this class is signaled when reading from a socket in chunking mode and the zero length chunk is encountered. This condition is not an error so it can be ignored. However without using this signal you can't distinguish a chunking end of file from an actual end of file.

Sockets are discussed in socket.html.

# socket-error

Class, excl package

A subclass of stream-error. `socket-error` inherits four slots from `stream-error`. See More on cl:stream-error in errors.html for a discussion of the Allegro CL implementation of `stream-error` and see Errors in socket.html for more information on this condition.

The four slots inherited from `stream-error` are:

- `stream`: the stream which got the error. This is the standard CL slot and is accessed by stream-error.

- `action`: the action that was being attempted at the time of the error, accessed by stream-error-action.

- `code`: the errno code returned from the system, `nil` if none. Accessed by stream-error-code.

- `identifier`: symbolic identification of the code, or nil if unknown. Accessed by stream-error-identifier.

# socket-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::bdbv-socket-stream`. The stream reads/writes both characters and bytes of any width. This stream class is a subclass of dual-channel-simple-stream.

The options when creating an instance of this class are: filename, direction (defaults to :input), if-exists, if-does-not-exist, external-format (defaults to :default), input-handle, output-handle, mapped, fn-in (another name for the input-handle, for compatibility only, do not specify both) and fn-out (another name for the output handle, for compatibility only, do not specify both).

See device-open for a description of the input-handle, output-handle, and mapped options.

See streams.html for general information on simple-streams in Allegro CL.

# stream-closed-error

Class, excl package

This class is deprecated and largely unused but still exists for backward compatibility. Generally trying to access a closed stream signals some sort of type error.

This is the class of condition signaled when an attempt is made to access (read from, write to) a stream which has been closed.

See errors.html for general information on errors in Allegro CL.

# string-input-simple-stream

Class, excl package

The simple-stream subclas equivalent to the Gray stream `excl::string-input-stream`. Created with make-string-input-stream.

The options when creating an instance of this class are: string, start, and end.

See streams.html for general information on simple-streams in Allegro CL.

# string-output-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::string-output-stream`. Created with make-string-output-stream.

See streams.html for general information on simple-streams in Allegro CL.

# string-simple-stream

Class, excl package

This kind of stream allows for the moving and possible translation of characters.

One subclass of string-simple-stream, composing-stream, allows composing of external-formats and ligatures using Java-style encapsulations.

Other subclasses of string-simple-stream have a single buffer which is in fact a string. It is available as an optimization to allow read and format at a high level to be used on strings. For resourcing, the string for the stream may be specified by a `:string` option to make-instance, which is then passed to device-open as an options flag, or the string for a string-output-simple-stream may be reused if it already exists in the stream.

A string stream that is not a composing-stream incorporates a major exception in the CL requirements for the streams system: there is no external connection; everything that lisp is reading from or writing to the stream is within the lisp heap, and thus there are no reconnect or shutdown problems with these streams; they continue to work across a dumped lisp image that has been restarted.

### Specific exceptions to non-composing string-simple-streams operations:

- The basic unit of transfer is the character, not the octet.

- read-byte and write-byte will signal an error if given a string-simple-stream.

- No external-format processing is performed on the characters read or written, since the characters do not become external, but remain within the lisp during the round trip through the stream.

- Because CL specifies only input and output string streams (the classes `string-input-simple-stream` and `string-output-simple-stream` and perhaps further subclasses), but not bidirectional, it is not necessary to implement mode switching internally for the single string buffer. Implementations are free to define such a bidirectional string stream (or to emulate such a stream - see note just below).

Note: something similar to string streams could be implemented, with less efficient operation, by simulating an external-connection at the device level of either a single-channel or dual-channel stream. The "final destination" (or source) of the device would in that case be a string, and the extra octet buffering would require extra copying at the device level when transferring data out (or in). This technique would allow external-format processing on the strings either during input or output.

# synchronizing-structure

class, excl package

This structure class is used as a base structure when instances of a structure class are to be locked with the with-locked-structure macro.

## Example usage

         (defstruct (my-lockable-thing
                      (:include synchronizing-structure)
                  ...)
           ...)
         ...
         (setq thing (make-my-lockable-thing ...))
         ...
         (with-locked-structure (thing)
               ...)

See smp.html and multiprocessing.html for more information on this macro and on multiprocessing.

# synchronous-operating-system-signal

Class, excl package

This is the class of condition signaled when a synchronous operating system error occurs.

See errors.html for general information on errors in Allegro CL.

# syscall-error

Class, excl package

This condition class is a subclass of error. It has one slot, `errno`, with reader syscall-error-errno.

A syscall-error is signaled when there is a UNIX/Linux system error and occasionally on Windows when there is a C library error. The condition winapi-error is signaled when there is a Windows API error.

The home package of the symbol `syscall-error` is `excl.osi`. However, it is also exported from the `excl` package and so is available when the `osi` module is not loaded.

# terminal-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::terminal-stream` and a subclass of dual-channel-simple-stream. This is similar to a socket-simple-stream, but a Control-D, which is seen as an EOF, does not latch the stream into an EOF state.

The options when creating an instance of this class are: filename, direction (defaults to :input), if-exists, if-does-not-exist, external-format (defaults to :default), input-handle, output-handle, mapped, fn-in (another name for the input-handle, for compatibility only, do not specify both) and fn-out (another name for the output handle, for compatibility only, do not specify both).

See device-open for a description of the input-handle, output-handle, and mapped options.

See streams.html for general information on simple-streams in Allegro CL.

# utf-8s-transcoding-error

class, excl package

This class names the condition that is signaled when a transcoding error is encountered by the `:utf-8s` external-format (when the action which is the value of *utf-8s-transcoding-error-action* is specified as `:error` or a value other than `nil`, `:warn`, `:count`, `:collect`, and integer, or a cons).

See Strict external formats which do not allow improper characters in iacl.html for more information on the `:utf-8s` external format, international characters and external formats in general.

# utf-8s-transcoding-warning

class, excl package

This is the class of a condition that is signaled when a transcoding error is encountered by the `:utf-8s` external-format (when the action which is the value of *utf-8s-transcoding-error-action* is specified as `:warn`).

See Strict external formats which do not allow improper characters in iacl.html for more information on the `:utf-8s` external format, international characters and external formats in general.

# utf8-generating-surrogate-pair

class, excl package

This class names a condition which is signaled by a stream using external formats `:utf8`, `:utf-8`, `:utf-8s`, or `:utf-8nb` when each component of a surrogate pair is generated by the stream. See the discussion of surrogate pairs in Unicode Surrogate Character Pairs in Allegro CL in iacl.html.

# void-external-format

Class, excl package

This condition is signaled when attempting to use the `:void` external format. It usually means that character I/O was attempted on a stream specified for binary I/O.

See Basic External-Format Types in iacl.html for information on the `:void` external format.

# winapi-error

Class, excl package

This condition class is a subclass of error. It has one slot, `code`, with reader winapi-error-code.

A winapi-error is signaled on Windows when there is a Windows API error. The related syscall-error is signaled on UNIX/Linux systems when there is a system error and occasionally on Windows when there is a C library error.

You might see this error, for example, when there is a problem loading a DLL:

    cl-user(17): (load "foo.dll")
    ; Foreign loading foo.dll.
    Error: loading "foo.dll" resulted in error (code 193)
      "%1 is not a valid Win32 application.".
      [condition type: winapi-error]
      ...

# xp-simple-stream

Class, excl package

The simple-stream subclass equivalent to the Gray stream `excl::xp-stream`. This is the simple-stream equivalent of the extended-pretty-presenting stream. It is a subclass of string-output-simple-stream. It encapsulates its base stream and outputs to that stream only when it knows enough about where to place output.

See streams.html for general information on simple-streams in Allegro CL.

Copyright (c) Franz Inc. Lafayette, CA., USA. All rights reserved.

ToC | DocOverview | CGDoc | RelNotes | FAQ | Index | PermutedIndex
| Allegro CL version 11.0