/* -*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*- */
/* vim: set filetype=c tabstop=8 shiftwidth=4 expandtab: */

#ifdef ECL_CMU_FORMAT
# define ECL_NAME_PPRINT(x) ECL_NAME(x)
#else
# define ECL_NAME_PPRINT(x) NULL
#endif
#ifdef ECL_FINAL
# define ECL_NAME(x) x
#else
# define ECL_NAME(x) NULL
#endif
#ifdef DPP
#define CLOS_ "CLOS::"
#define EXT_ "EXT::"
#define SYS_ "SI::"
#define MP_ "MP::"
#define KEY_ ":"
#define GRAY_ "GRAY::"
#define FFI_ "FFI::"
typedef struct {
        const char *name, *translation;
        /* narg >= 0: function takes exactly narg arguments */
        /* narg < 0: function takes -narg-1 required arguments */
        int narg;
} cl_symbol_initializer;
#else
#include "ecl_constants.h"
#define CLOS_
#define EXT_
#define SYS_
#define MP_
#define KEY_
#define GRAY_
#define FFI_
#endif
/*
 * Conditional addition of functions and symbols. The list of symbols can
 * not depend on the features, because otherwise the sources will and we will
 * not be able to cross-compile.
 */
#ifdef ECL_THREADS
# define IF_MP(x) x
#else
# define IF_MP(x) NULL
#endif
#ifdef TCP
# define IF_TCP(x) x
#else
# define IF_TCP(x) NULL
#endif
#ifdef PROFILE
# define IF_PROFILE(x) x
#else
# define IF_PROFILE(x) NULL
#endif
#ifndef ECL_CLOS_STREAMS
# undef GRAY_
# define GRAY_ SYS_
#endif
#ifdef ECL_EXTERNALIZABLE
# define IF_EXTERNALIZABLE(x) x
#else
# define IF_EXTERNALIZABLE(x) NULL
#endif
#ifdef ECL_SSE2
# define IF_SSE2(x) x
#else
# define IF_SSE2(x) NULL
#endif
#if defined(HAVE_LIBFFI)
# define IF_DFFI(x) x
#else
# define IF_DFFI(x) NULL
#endif
#ifdef ECL_COMPLEX_FLOAT
# define IF_COMPLEX_FLOAT(x) x
#else
# define IF_COMPLEX_FLOAT(x) NULL
#endif

/* XXX When the symbol has the associated function its name must
   follow the naming convention, otherwise si:mangle-name will
   miscompile the symbol reference. See #534. -- jd 2019-12-04*/

cl_symbol_initializer
cl_symbols[] = {

{"NIL", CL_ORDINARY, NULL, -1, OBJNULL},
{"T", CL_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNBOUND", SI_CONSTANT, si_unbound, 0, ECL_UNBOUND},
{SYS_ "PROTECT-TAG", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "DUMMY-TAG", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "*RESTART-CLUSTERS*", SI_SPECIAL, NULL, -1, Cnil},
{SYS_ "*HANDLER-CLUSTERS*", SI_SPECIAL, NULL, -1, Cnil},
{EXT_ "*INTERRUPTS-ENABLED*", EXT_SPECIAL, NULL, 1, ECL_T},

/* LISP PACKAGE */
{"&ALLOW-OTHER-KEYS", CL_ORDINARY, NULL, -1, OBJNULL},
{"&AUX", CL_ORDINARY, NULL, -1, OBJNULL},
{"&BODY", CL_ORDINARY, NULL, -1, OBJNULL},
{"&ENVIRONMENT", CL_ORDINARY, NULL, -1, OBJNULL},
{"&KEY", CL_ORDINARY, NULL, -1, OBJNULL},
{"&OPTIONAL", CL_ORDINARY, NULL, -1, OBJNULL},
{"&REST", CL_ORDINARY, NULL, -1, OBJNULL},
{"&WHOLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"+", CL_SPECIAL, cl_P, -1, ECL_NIL},
{"++", CL_SPECIAL, NULL, -1, ECL_NIL},
{"+++", CL_SPECIAL, NULL, -1, ECL_NIL},
{"-", CL_SPECIAL, cl_M, -2, ECL_NIL},
{"*", CL_SPECIAL, cl_X, -1, ECL_NIL},
{"**", CL_SPECIAL, NULL, -1, ECL_NIL},
{"***", CL_SPECIAL, NULL, -1, ECL_NIL},
{"/", CL_SPECIAL, cl_N, -2, ECL_NIL},
{"//", CL_SPECIAL, NULL, -1, ECL_NIL},
{"///", CL_SPECIAL, NULL, -1, ECL_NIL},
{"/=", CL_ORDINARY, cl_NE, -1, OBJNULL},
{"*BREAK-ON-SIGNALS*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*COMPILE-FILE-PATHNAME*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*COMPILE-FILE-TRUENAME*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*COMPILE-PRINT*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*COMPILE-VERBOSE*", CL_SPECIAL, NULL, -1, ECL_T},
{"*DEBUG-IO*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*DEBUGGER-HOOK*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*DEFAULT-PATHNAME-DEFAULTS*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*ERROR-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*FEATURES*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*GENSYM-COUNTER*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(0)},
{"*LOAD-PATHNAME*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*LOAD-PRINT*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*LOAD-TRUENAME*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*LOAD-VERBOSE*", CL_SPECIAL, NULL, -1, ECL_T},
{"*MACROEXPAND-HOOK*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*MODULES*", CL_SPECIAL, NULL, -1, OBJNULL},
{EXT_ "*MODULE-PROVIDER-FUNCTIONS*", EXT_SPECIAL, NULL, -1, OBJNULL},
{"*PACKAGE*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*PRINT-ARRAY*", CL_SPECIAL, NULL, -1, ECL_T},
{"*PRINT-BASE*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(10)},
{"*PRINT-CASE*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*PRINT-CIRCLE*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-ESCAPE*", CL_SPECIAL, NULL, -1, ECL_T},
{"*PRINT-GENSYM*", CL_SPECIAL, NULL, -1, ECL_T},
{"*PRINT-LENGTH*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-LEVEL*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-LINES*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-MISER-WIDTH*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-PPRINT-DISPATCH*", CL_SPECIAL, NULL, -1, ECL_NIL},
#if defined(ECL_CMU_FORMAT)
{"*PRINT-PRETTY*", CL_SPECIAL, NULL, -1, ECL_NIL},
#else
{"*PRINT-PRETTY*", CL_SPECIAL, NULL, -1, ECL_T},
#endif
{"*PRINT-RADIX*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-READABLY*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*PRINT-RIGHT-MARGIN*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*QUERY-IO*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*RANDOM-STATE*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*READ-BASE*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(10)},
{"*READ-DEFAULT-FLOAT-FORMAT*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*READ-EVAL*", CL_SPECIAL, NULL, -1, ECL_T},
{"*READ-SUPPRESS*", CL_SPECIAL, NULL, -1, ECL_NIL},
{"*READTABLE*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*STANDARD-INPUT*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*STANDARD-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*TERMINAL-IO*", CL_SPECIAL, NULL, -1, OBJNULL},
{"*TRACE-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL},
{"1+", CL_ORDINARY, cl_1P, 1, OBJNULL},
{"1-", CL_ORDINARY, cl_1M, 1, OBJNULL},
{"<", CL_ORDINARY, cl_L, -1, OBJNULL},
{"<=", CL_ORDINARY, cl_LE, -1, OBJNULL},
{"=", CL_ORDINARY, cl_E, -2, OBJNULL},
{">", CL_ORDINARY, cl_G, -1, OBJNULL},
{">=", CL_ORDINARY, cl_GE, -1, OBJNULL},
{"ABORT", CL_ORDINARY, ECL_NAME(cl_abort), -1, OBJNULL},
{"ABS", CL_ORDINARY, cl_abs, 1, OBJNULL},
{"ACONS", CL_ORDINARY, cl_acons, 3, OBJNULL},
{"ACOS", CL_ORDINARY, ECL_NAME(cl_acos), 1, OBJNULL},
{"ACOSH", CL_ORDINARY, ECL_NAME(cl_acosh), 1, OBJNULL},
{"ADJOIN", CL_ORDINARY, cl_adjoin, -3, OBJNULL},
{"ADJUST-ARRAY", CL_ORDINARY, ECL_NAME(cl_adjust_array), -3, OBJNULL},
{"ADJUSTABLE-ARRAY-P", CL_ORDINARY, cl_adjustable_array_p, 1, OBJNULL},
{"ALPHA-CHAR-P", CL_ORDINARY, cl_alpha_char_p, 1, OBJNULL},
{"ALPHANUMERICP", CL_ORDINARY, cl_alphanumericp, 1, OBJNULL},
{"AND", CL_ORDINARY, NULL, -1, OBJNULL},
{"APPEND", CL_ORDINARY, cl_append, -1, OBJNULL},
{"APPLY", CL_ORDINARY, cl_apply, -3, OBJNULL},
{"APROPOS", CL_ORDINARY, ECL_NAME(cl_apropos), -2, OBJNULL},
{"APROPOS-LIST", CL_ORDINARY, ECL_NAME(cl_apropos_list), -2, OBJNULL},
{"AREF", CL_ORDINARY, cl_aref, -2, OBJNULL},
{"ARITHMETIC-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"ARITHMETIC-ERROR-OPERANDS", CL_ORDINARY, NULL, -1, OBJNULL},
{"ARITHMETIC-ERROR-OPERATION", CL_ORDINARY, NULL, -1, OBJNULL},
{"ARRAY", CL_ORDINARY, NULL, -1, OBJNULL},
{"ARRAY-DIMENSION", CL_ORDINARY, cl_array_dimension, 2, OBJNULL},
{"ARRAY-DIMENSION-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_ARRAY_DIMENSION_LIMIT)},
{"ARRAY-DIMENSIONS", CL_ORDINARY, ECL_NAME(cl_array_dimensions), 1, OBJNULL},
{"ARRAY-DISPLACEMENT", CL_ORDINARY, cl_array_displacement, 1, OBJNULL},
{"ARRAY-ELEMENT-TYPE", CL_ORDINARY, cl_array_element_type, 1, OBJNULL},
{"ARRAY-HAS-FILL-POINTER-P", CL_ORDINARY, cl_array_has_fill_pointer_p, 1, OBJNULL},
{"ARRAY-IN-BOUNDS-P", CL_ORDINARY, ECL_NAME(cl_array_in_bounds_p), -2, OBJNULL},
{"ARRAY-RANK", CL_ORDINARY, cl_array_rank, 1, OBJNULL},
{"ARRAY-RANK-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_ARRAY_RANK_LIMIT)},
{"ARRAY-ROW-MAJOR-INDEX", CL_ORDINARY, ECL_NAME(cl_array_row_major_index), -2, OBJNULL},
{"ARRAY-TOTAL-SIZE", CL_ORDINARY, cl_array_total_size, 1, OBJNULL},
{"ARRAY-TOTAL-SIZE-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_ARRAY_TOTAL_LIMIT)},
{"ARRAYP", CL_ORDINARY, cl_arrayp, 1, OBJNULL},
{"ASH", CL_ORDINARY, cl_ash, 2, OBJNULL},
{"ASIN", CL_ORDINARY, ECL_NAME(cl_asin), 1, OBJNULL},
{"ASINH", CL_ORDINARY, ECL_NAME(cl_asinh), 1, OBJNULL},
{"ASSERT", CL_ORDINARY, NULL, -1, OBJNULL},
{"ASSOC", CL_ORDINARY, cl_assoc, -3, OBJNULL},
{"ASSOC-IF", CL_ORDINARY, ECL_NAME(cl_assoc_if), -3, OBJNULL},
{"ASSOC-IF-NOT", CL_ORDINARY, ECL_NAME(cl_assoc_if_not), -3, OBJNULL},
{"ATAN", CL_ORDINARY, cl_atan, -2, OBJNULL},
{"ATANH", CL_ORDINARY, ECL_NAME(cl_atanh), 1, OBJNULL},
{"ATOM", CL_ORDINARY, cl_atom, 1, OBJNULL},
{"BASE-CHAR", CL_ORDINARY, NULL, -1, OBJNULL},
{"BASE-STRING", CL_ORDINARY, NULL, -1, OBJNULL},
{"BIGNUM", CL_ORDINARY, NULL, -1, OBJNULL},
{"BIT", CL_ORDINARY, ECL_NAME(cl_bit), -2, OBJNULL},
{"BIT-AND", CL_ORDINARY, ECL_NAME(cl_bit_and), -3, OBJNULL},
{"BIT-ANDC1", CL_ORDINARY, ECL_NAME(cl_bit_andc1), -3, OBJNULL},
{"BIT-ANDC2", CL_ORDINARY, ECL_NAME(cl_bit_andc2), -3, OBJNULL},
{"BIT-EQV", CL_ORDINARY, ECL_NAME(cl_bit_eqv), -3, OBJNULL},
{"BIT-IOR", CL_ORDINARY, ECL_NAME(cl_bit_ior), -3, OBJNULL},
{"BIT-NAND", CL_ORDINARY, ECL_NAME(cl_bit_nand), -3, OBJNULL},
{"BIT-NOR", CL_ORDINARY, ECL_NAME(cl_bit_nor), -3, OBJNULL},
{"BIT-NOT", CL_ORDINARY, ECL_NAME(cl_bit_not), -2, OBJNULL},
{"BIT-ORC1", CL_ORDINARY, ECL_NAME(cl_bit_orc1), -3, OBJNULL},
{"BIT-ORC2", CL_ORDINARY, ECL_NAME(cl_bit_orc2), -3, OBJNULL},
{"BIT-VECTOR", CL_ORDINARY, NULL, -1, OBJNULL},
{"BIT-VECTOR-P", CL_ORDINARY, cl_bit_vector_p, 1, OBJNULL},
{"BIT-XOR", CL_ORDINARY, ECL_NAME(cl_bit_xor), -3, OBJNULL},
{"BLOCK", CL_FORM, NULL, -1, OBJNULL},
{"BOOLE", CL_ORDINARY, cl_boole, 3, OBJNULL},
{"BOOLE-1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOL1)},
{"BOOLE-2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOL2)},
{"BOOLE-AND", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLAND)},
{"BOOLE-ANDC1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLANDC1)},
{"BOOLE-ANDC2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLANDC2)},
{"BOOLE-C1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLC1)},
{"BOOLE-C2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLC2)},
{"BOOLE-CLR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLCLR)},
{"BOOLE-EQV", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLEQV)},
{"BOOLE-IOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLIOR)},
{"BOOLE-NAND", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLNAND)},
{"BOOLE-NOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLNOR)},
{"BOOLE-ORC1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLORC1)},
{"BOOLE-ORC2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLORC2)},
{"BOOLE-SET", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLSET)},
{"BOOLE-XOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLXOR)},
{"BOOLEAN", CL_ORDINARY, NULL, -1, OBJNULL},
{"BOTH-CASE-P", CL_ORDINARY, cl_both_case_p, 1, OBJNULL},
{"BOUNDP", CL_ORDINARY, cl_boundp, 1, OBJNULL},
{"BREAK", CL_ORDINARY, NULL, -1, OBJNULL},
{"BROADCAST-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"BROADCAST-STREAM-STREAMS", CL_ORDINARY, cl_broadcast_stream_streams, 1, OBJNULL},
{"BUTLAST", CL_ORDINARY, cl_butlast, -2, OBJNULL},
{"BYTE", CL_ORDINARY, ECL_NAME(cl_byte), 2, OBJNULL},
{"BYTE-POSITION", CL_ORDINARY, ECL_NAME(cl_byte_position), 1, OBJNULL},
{"BYTE-SIZE", CL_ORDINARY, ECL_NAME(cl_byte_size), 1, OBJNULL},
{"CAAAAR", CL_ORDINARY, cl_caaaar, 1, OBJNULL},
{"CAAADR", CL_ORDINARY, cl_caaadr, 1, OBJNULL},
{"CAAAR", CL_ORDINARY, cl_caaar, 1, OBJNULL},
{"CAADAR", CL_ORDINARY, cl_caadar, 1, OBJNULL},
{"CAADDR", CL_ORDINARY, cl_caaddr, 1, OBJNULL},
{"CAADR", CL_ORDINARY, cl_caadr, 1, OBJNULL},
{"CAAR", CL_ORDINARY, cl_caar, 1, OBJNULL},
{"CADAAR", CL_ORDINARY, cl_cadaar, 1, OBJNULL},
{"CADADR", CL_ORDINARY, cl_cadadr, 1, OBJNULL},
{"CADAR", CL_ORDINARY, cl_cadar, 1, OBJNULL},
{"CADDAR", CL_ORDINARY, cl_caddar, 1, OBJNULL},
{"CADDDR", CL_ORDINARY, cl_cadddr, 1, OBJNULL},
{"CADDR", CL_ORDINARY, cl_caddr, 1, OBJNULL},
{"CADR", CL_ORDINARY, cl_cadr, 1, OBJNULL},
{"CALL-ARGUMENTS-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_CALL_ARGUMENTS_LIMIT)},
{"CAR", CL_ORDINARY, cl_car, 1, OBJNULL},
{"CASE", CL_FORM, NULL, -1, OBJNULL},
{"CATCH", CL_FORM, NULL, -1, OBJNULL},
{"CCASE", CL_ORDINARY, NULL, -1, OBJNULL},
{"CDAAAR", CL_ORDINARY, cl_cdaaar, 1, OBJNULL},
{"CDAADR", CL_ORDINARY, cl_cdaadr, 1, OBJNULL},
{"CDAAR", CL_ORDINARY, cl_cdaar, 1, OBJNULL},
{"CDADAR", CL_ORDINARY, cl_cdadar, 1, OBJNULL},
{"CDADDR", CL_ORDINARY, cl_cdaddr, 1, OBJNULL},
{"CDADR", CL_ORDINARY, cl_cdadr, 1, OBJNULL},
{"CDAR", CL_ORDINARY, cl_cdar, 1, OBJNULL},
{"CDDAAR", CL_ORDINARY, cl_cddaar, 1, OBJNULL},
{"CDDADR", CL_ORDINARY, cl_cddadr, 1, OBJNULL},
{"CDDAR", CL_ORDINARY, cl_cddar, 1, OBJNULL},
{"CDDDAR", CL_ORDINARY, cl_cdddar, 1, OBJNULL},
{"CDDDDR", CL_ORDINARY, cl_cddddr, 1, OBJNULL},
{"CDDDR", CL_ORDINARY, cl_cdddr, 1, OBJNULL},
{"CDDR", CL_ORDINARY, cl_cddr, 1, OBJNULL},
{"CDR", CL_ORDINARY, cl_cdr, 1, OBJNULL},
{"CEILING", CL_ORDINARY, cl_ceiling, -2, OBJNULL},
{"CELL-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"CELL-ERROR-NAME", CL_ORDINARY, NULL, -1, OBJNULL},
{"CERROR", CL_ORDINARY, cl_cerror, -3, OBJNULL},
{"CHAR", CL_ORDINARY, cl_char, 2, OBJNULL},
{"CHAR-CODE", CL_ORDINARY, cl_char_code, 1, OBJNULL},
{"CHAR-CODE-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_CHAR_CODE_LIMIT)},
{"CHAR-DOWNCASE", CL_ORDINARY, cl_char_downcase, 1, OBJNULL},
{"CHAR-EQUAL", CL_ORDINARY, cl_char_equal, -2, OBJNULL},
{"CHAR-GREATERP", CL_ORDINARY, cl_char_greaterp, -1, OBJNULL},
{"CHAR-INT", CL_ORDINARY, cl_char_int, 1, OBJNULL},
{"CHAR-LESSP", CL_ORDINARY, cl_char_lessp, -1, OBJNULL},
{"CHAR-NAME", CL_ORDINARY, cl_char_name, 1, OBJNULL},
{"CHAR-NOT-EQUAL", CL_ORDINARY, cl_char_not_equal, -1, OBJNULL},
{"CHAR-NOT-GREATERP", CL_ORDINARY, cl_char_not_greaterp, -1, OBJNULL},
{"CHAR-NOT-LESSP", CL_ORDINARY, cl_char_not_lessp, -1, OBJNULL},
{"CHAR-UPCASE", CL_ORDINARY, cl_char_upcase, 1, OBJNULL},
{"CHAR/=", CL_ORDINARY, cl_charNE, -1, OBJNULL},
{"CHAR<", CL_ORDINARY, cl_charL, -1, OBJNULL},
{"CHAR<=", CL_ORDINARY, cl_charLE, -1, OBJNULL},
{"CHAR=", CL_ORDINARY, cl_charE, -2, OBJNULL},
{"CHAR>", CL_ORDINARY, cl_charG, -1, OBJNULL},
{"CHAR>=", CL_ORDINARY, cl_charGE, -1, OBJNULL},
{"CHARACTER", CL_ORDINARY, cl_character, 1, OBJNULL},
{"CHARACTERP", CL_ORDINARY, cl_characterp, 1, OBJNULL},
{"CHECK-TYPE", CL_ORDINARY, NULL, -1, OBJNULL},
{"CIS", CL_ORDINARY, ECL_NAME(cl_cis), 1, OBJNULL},
{"CLEAR-INPUT", CL_ORDINARY, cl_clear_input, -1, OBJNULL},
{"CLEAR-OUTPUT", CL_ORDINARY, cl_clear_output, -1, OBJNULL},
{"CLOSE", CL_ORDINARY, cl_close, -2, OBJNULL},
{"CLRHASH", CL_ORDINARY, cl_clrhash, 1, OBJNULL},
{"CODE-CHAR", CL_ORDINARY, cl_code_char, 1, OBJNULL},
{"COERCE", CL_ORDINARY, ECL_NAME(cl_coerce), 2, OBJNULL},
{"COMPILATION-SPEED", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPILE", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPILE-FILE", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPILE-FILE-PATHNAME", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPILED-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPILED-FUNCTION-P", CL_ORDINARY, cl_compiled_function_p, 1, OBJNULL},
{"COMPILER-MACRO", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPILER-MACRO-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL},
{"COMPLEMENT", CL_ORDINARY, ECL_NAME(cl_complement), 1, OBJNULL},
{"COMPLEX", CL_ORDINARY, cl_complex, -2, OBJNULL},
{"COMPLEXP", CL_ORDINARY, cl_complexp, 1, OBJNULL},
{"COMPUTE-RESTARTS", CL_ORDINARY, ECL_NAME(cl_compute_restarts), -1, OBJNULL},
{"CONCATENATE", CL_ORDINARY, ECL_NAME(cl_concatenate), -2, OBJNULL},
{"CONCATENATED-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"CONCATENATED-STREAM-STREAMS", CL_ORDINARY, cl_concatenated_stream_streams, 1, OBJNULL},
{"COND", CL_FORM, NULL, -1, OBJNULL},
{"CONDITION", CL_ORDINARY, NULL, -1, OBJNULL},
{"CONJUGATE", CL_ORDINARY, cl_conjugate, 1, OBJNULL},
{"CONTINUE", CL_ORDINARY, ECL_NAME(cl_continue), -1, OBJNULL},
{"CONS", CL_ORDINARY, cl_cons, 2, OBJNULL},
{"CONSP", CL_ORDINARY, cl_consp, 1, OBJNULL},
{"CONSTANTLY", CL_ORDINARY, ECL_NAME(cl_constantly), 1, OBJNULL},
{"CONSTANTP", CL_ORDINARY, cl_constantp, -2, OBJNULL},
{"CONTROL-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"COPY-ALIST", CL_ORDINARY, cl_copy_alist, 1, OBJNULL},
{"COPY-LIST", CL_ORDINARY, cl_copy_list, 1, OBJNULL},
{"COPY-PPRINT-DISPATCH", CL_ORDINARY, ECL_NAME_PPRINT(cl_copy_pprint_dispatch), -1, OBJNULL},
{"COPY-READTABLE", CL_ORDINARY, cl_copy_readtable, -1, OBJNULL},
{"COPY-SEQ", CL_ORDINARY, cl_copy_seq, 1, OBJNULL},
{"COPY-STRUCTURE", CL_ORDINARY, cl_copy_structure, 1, OBJNULL},
{"COPY-SYMBOL", CL_ORDINARY, cl_copy_symbol, -2, OBJNULL},
{"COPY-TREE", CL_ORDINARY, cl_copy_tree, 1, OBJNULL},
{"COS", CL_ORDINARY, cl_cos, 1, OBJNULL},
{"COSH", CL_ORDINARY, cl_cosh, 1, OBJNULL},
{"COUNT", CL_ORDINARY, ECL_NAME(cl_count), -3, OBJNULL},
{"COUNT-IF", CL_ORDINARY, ECL_NAME(cl_count_if), -3, OBJNULL},
{"COUNT-IF-NOT", CL_ORDINARY, ECL_NAME(cl_count_if_not), -3, OBJNULL},
{"CTYPECASE", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEBUG", CL_ORDINARY, NULL, -1, OBJNULL},
{"DECF", CL_ORDINARY, NULL, -1, OBJNULL},
{"DECLAIM", CL_ORDINARY, NULL, -1, OBJNULL},
{"DECLARATION", CL_ORDINARY, NULL, -1, OBJNULL},
{"DECLARE", CL_ORDINARY, NULL, -1, OBJNULL},
{"DECODE-FLOAT", CL_ORDINARY, cl_decode_float, 1, OBJNULL},
{"DECODE-UNIVERSAL-TIME", CL_ORDINARY, ECL_NAME(cl_decode_universal_time), -2, OBJNULL},
{"DEFCONSTANT", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFINE-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFINE-COMPILER-MACRO", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFINE-MODIFY-MACRO", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFINE-SETF-EXPANDER", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFINE-SYMBOL-MACRO", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFMACRO", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFPACKAGE", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFPARAMETER", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFSETF", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFSTRUCT", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFTYPE", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFUN", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFVAR", CL_ORDINARY, NULL, -1, OBJNULL},
{"DELETE", CL_ORDINARY, ECL_NAME(cl_delete), -3, OBJNULL},
{"DELETE-DUPLICATES", CL_ORDINARY, ECL_NAME(cl_delete_duplicates), -2, OBJNULL},
{"DELETE-FILE", CL_ORDINARY, cl_delete_file, 1, OBJNULL},
{"DELETE-IF", CL_ORDINARY, ECL_NAME(cl_delete_if), -3, OBJNULL},
{"DELETE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_delete_if_not), -3, OBJNULL},
{"DELETE-PACKAGE", CL_ORDINARY, cl_delete_package, 1, OBJNULL},
{"DENOMINATOR", CL_ORDINARY, cl_denominator, 1, OBJNULL},
{"DEPOSIT-FIELD", CL_ORDINARY, ECL_NAME(cl_deposit_field), 3, OBJNULL},
{"DESCRIBE", CL_ORDINARY, ECL_NAME(cl_describe), -2, OBJNULL},
{"DESTRUCTURING-BIND", CL_ORDINARY, NULL, -1, OBJNULL},
{"DIGIT-CHAR", CL_ORDINARY, cl_digit_char, -2, OBJNULL},
{"DIGIT-CHAR-P", CL_ORDINARY, cl_digit_char_p, -2, OBJNULL},
{"DIRECTORY", CL_ORDINARY, cl_directory, -2, OBJNULL},
{"DIRECTORY-NAMESTRING", CL_ORDINARY, cl_directory_namestring, 1, OBJNULL},
{"DISASSEMBLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"DIVISION-BY-ZERO", CL_ORDINARY, NULL, -1, OBJNULL},
{"DO", CL_FORM, NULL, -1, OBJNULL},
{"DO*", CL_FORM, NULL, -1, OBJNULL},
{"DO-ALL-SYMBOLS", CL_ORDINARY, NULL, -1, OBJNULL},
{"DO-EXTERNAL-SYMBOLS", CL_ORDINARY, NULL, -1, OBJNULL},
{"DO-SYMBOLS", CL_ORDINARY, NULL, -1, OBJNULL},
{"DOCUMENTATION", CL_ORDINARY, NULL, -1, OBJNULL},
{"DOLIST", CL_FORM, NULL, -1, OBJNULL},
{"DOTIMES", CL_FORM, NULL, -1, OBJNULL},
{"DOUBLE-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL},
{"DOUBLE-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"DOUBLE-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"DPB", CL_ORDINARY, ECL_NAME(cl_dpb), 3, OBJNULL},
{"DRIBBLE", CL_ORDINARY, ECL_NAME(cl_dribble), -1, OBJNULL},
{"DYNAMIC-EXTENT", CL_ORDINARY, NULL, -1, OBJNULL},
{"ECASE", CL_ORDINARY, NULL, -1, OBJNULL},
{"ECHO-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"ECHO-STREAM-INPUT-STREAM", CL_ORDINARY, cl_echo_stream_input_stream, 1, OBJNULL},
{"ECHO-STREAM-OUTPUT-STREAM", CL_ORDINARY, cl_echo_stream_output_stream, 1, OBJNULL},
{"ED", CL_ORDINARY, NULL, -1, OBJNULL},
{"EIGHTH", CL_ORDINARY, cl_eighth, 1, OBJNULL},
{"ELT", CL_ORDINARY, cl_elt, 2, OBJNULL},
{"ENCODE-UNIVERSAL-TIME", CL_ORDINARY, ECL_NAME(cl_encode_universal_time), -7, OBJNULL},
{"END-OF-FILE", CL_ORDINARY, NULL, -1, OBJNULL},
{"ENDP", CL_ORDINARY, cl_endp, 1, OBJNULL},
{"ENOUGH-NAMESTRING", CL_ORDINARY, cl_enough_namestring, -2, OBJNULL},
{"ENSURE-DIRECTORIES-EXIST", CL_ORDINARY, ECL_NAME(cl_ensure_directories_exist), -2, OBJNULL},
{"EQ", CL_ORDINARY, cl_eq, 2, OBJNULL},
{"EQL", CL_ORDINARY, cl_eql, 2, OBJNULL},
{"EQUAL", CL_ORDINARY, cl_equal, 2, OBJNULL},
{"EQUALP", CL_ORDINARY, cl_equalp, 2, OBJNULL},
{"ERROR", CL_ORDINARY, cl_error, -2, OBJNULL},
{"ETYPECASE", CL_ORDINARY, NULL, -1, OBJNULL},
{"EVAL", CL_ORDINARY, cl_eval, 1, OBJNULL},
{"EVAL-WHEN", CL_FORM, NULL, -1, OBJNULL},
{"EVENP", CL_ORDINARY, cl_evenp, 1, OBJNULL},
{"EVERY", CL_ORDINARY, ECL_NAME(cl_every), -3, OBJNULL},
{"EXP", CL_ORDINARY, cl_exp, 1, OBJNULL},
{"EXPORT", CL_ORDINARY, cl_export, -2, OBJNULL},
{"EXPT", CL_ORDINARY, cl_expt, 2, OBJNULL},
{"EXTENDED-CHAR", CL_ORDINARY, NULL, -1, OBJNULL},
{"FBOUNDP", CL_ORDINARY, cl_fboundp, 1, OBJNULL},
{"FCEILING", CL_ORDINARY, ECL_NAME(cl_fceiling), -2, OBJNULL},
{"FDEFINITION", CL_ORDINARY, cl_fdefinition, 1, OBJNULL},
{"FFLOOR", CL_ORDINARY, ECL_NAME(cl_ffloor), -2, OBJNULL},
{"FIFTH", CL_ORDINARY, cl_fifth, 1, OBJNULL},
{"FILE-AUTHOR", CL_ORDINARY, cl_file_author, 1, OBJNULL},
{"FILE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"FILE-ERROR-PATHNAME", CL_ORDINARY, NULL, -1, OBJNULL},
{"FILE-LENGTH", CL_ORDINARY, cl_file_length, 1, OBJNULL},
{"FILE-NAMESTRING", CL_ORDINARY, cl_file_namestring, 1, OBJNULL},
{"FILE-POSITION", CL_ORDINARY, cl_file_position, -2, OBJNULL},
{"FILE-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"FILE-STRING-LENGTH", CL_ORDINARY, cl_file_string_length, 2, OBJNULL},
{"FILE-WRITE-DATE", CL_ORDINARY, cl_file_write_date, 1, OBJNULL},
{"FILL", CL_ORDINARY, ECL_NAME(cl_fill), -3, OBJNULL},
{"FILL-POINTER", CL_ORDINARY, cl_fill_pointer, 1, OBJNULL},
{"FIND", CL_ORDINARY, ECL_NAME(cl_find), -3, OBJNULL},
{"FIND-ALL-SYMBOLS", CL_ORDINARY, ECL_NAME(cl_find_all_symbols), 1, OBJNULL},
{"FIND-IF", CL_ORDINARY, ECL_NAME(cl_find_if), -3, OBJNULL},
{"FIND-IF-NOT", CL_ORDINARY, ECL_NAME(cl_find_if_not), -3, OBJNULL},
{"FIND-PACKAGE", CL_ORDINARY, cl_find_package, 1, OBJNULL},
{"FIND-RESTART", CL_ORDINARY, ECL_NAME(cl_find_restart), -2, OBJNULL},
{"FIND-SYMBOL", CL_ORDINARY, cl_find_symbol, -2, OBJNULL},
{"FINISH-OUTPUT", CL_ORDINARY, cl_finish_output, -1, OBJNULL},
{"FIRST", CL_ORDINARY, cl_car, 1, OBJNULL},
{"FIXNUM", CL_ORDINARY, NULL, -1, OBJNULL},
{"FLET", CL_FORM, NULL, -1, OBJNULL},
{"FLOAT", CL_ORDINARY, cl_float, -2, OBJNULL},
{"FLOAT-DIGITS", CL_ORDINARY, cl_float_digits, 1, OBJNULL},
{"FLOAT-PRECISION", CL_ORDINARY, cl_float_precision, 1, OBJNULL},
{"FLOAT-RADIX", CL_ORDINARY, cl_float_radix, 1, OBJNULL},
{"FLOAT-SIGN", CL_ORDINARY, cl_float_sign, -2, OBJNULL},
{"FLOATING-POINT-INEXACT", CL_ORDINARY, NULL, -1, OBJNULL},
{"FLOATING-POINT-INVALID-OPERATION", CL_ORDINARY, NULL, -1, OBJNULL},
{"FLOATING-POINT-OVERFLOW", CL_ORDINARY, NULL, -1, OBJNULL},
{"FLOATING-POINT-UNDERFLOW", CL_ORDINARY, NULL, -1, OBJNULL},
{"FLOATP", CL_ORDINARY, cl_floatp, 1, OBJNULL},
{"FLOOR", CL_ORDINARY, cl_floor, -2, OBJNULL},
{"FMAKUNBOUND", CL_ORDINARY, cl_fmakunbound, 1, OBJNULL},
{"FORCE-OUTPUT", CL_ORDINARY, cl_force_output, -1, OBJNULL},
{"FORMAT", CL_ORDINARY, cl_format, -3, OBJNULL},
{"FORMATTER", CL_ORDINARY, NULL, -1, OBJNULL},
{"FOURTH", CL_ORDINARY, cl_cadddr, 1, OBJNULL},
{"FRESH-LINE", CL_ORDINARY, cl_fresh_line, -1, OBJNULL},
{"FROUND", CL_ORDINARY, ECL_NAME(cl_fround), -2, OBJNULL},
{"FTRUNCATE", CL_ORDINARY, ECL_NAME(cl_ftruncate), -2, OBJNULL},
{"FTYPE", CL_ORDINARY, NULL, -1, OBJNULL},
{"FUNCALL", CL_ORDINARY, cl_funcall, -2, OBJNULL},
{"FUNCTION-LAMBDA-EXPRESSION", CL_ORDINARY, cl_function_lambda_expression, 1, OBJNULL},
{"FUNCTION", CL_FORM, NULL, -1, OBJNULL},
{"FUNCTION-KEYWORDS", CL_ORDINARY, NULL, -1, OBJNULL},
{"FUNCTIONP", CL_ORDINARY, cl_functionp, 1, OBJNULL},
{"GCD", CL_ORDINARY, cl_gcd, -1, OBJNULL},
{"GENSYM", CL_ORDINARY, cl_gensym, -1, OBJNULL},
{"GENTEMP", CL_ORDINARY, cl_gentemp, -1, OBJNULL},
{"GET", CL_ORDINARY, cl_get, -3, OBJNULL},
{"GET-DECODED-TIME", CL_ORDINARY, ECL_NAME(cl_get_decoded_time), 0, OBJNULL},
{"GET-DISPATCH-MACRO-CHARACTER", CL_ORDINARY, cl_get_dispatch_macro_character, -3, OBJNULL},
{"GET-INTERNAL-REAL-TIME", CL_ORDINARY, cl_get_internal_real_time, 0, OBJNULL},
{"GET-INTERNAL-RUN-TIME", CL_ORDINARY, cl_get_internal_run_time, 0, OBJNULL},
{"GET-MACRO-CHARACTER", CL_ORDINARY, cl_get_macro_character, -2, OBJNULL},
{"GET-OUTPUT-STREAM-STRING", CL_ORDINARY, cl_get_output_stream_string, 1, OBJNULL},
{"GET-PROPERTIES", CL_ORDINARY, cl_get_properties, 2, OBJNULL},
{"GET-SETF-EXPANSION", CL_ORDINARY, NULL, -1, OBJNULL},
{"GET-UNIVERSAL-TIME", CL_ORDINARY, cl_get_universal_time, 0, OBJNULL},
{"GETF", CL_ORDINARY, cl_getf, -3, OBJNULL},
{"GETHASH", CL_ORDINARY, cl_gethash, -3, OBJNULL},
{"GO", CL_FORM, NULL, -1, OBJNULL},
{"GRAPHIC-CHAR-P", CL_ORDINARY, cl_graphic_char_p, 1, OBJNULL},
{"HANDLER-CASE", CL_ORDINARY, NULL, -1, OBJNULL},
{"HANDLER-BIND", CL_ORDINARY, NULL, -1, OBJNULL},
{"HASH-TABLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"HASH-TABLE-COUNT", CL_ORDINARY, cl_hash_table_count, 1, OBJNULL},
{"HASH-TABLE-P", CL_ORDINARY, cl_hash_table_p, 1, OBJNULL},
{"HASH-TABLE-REHASH-SIZE", CL_ORDINARY, cl_hash_table_rehash_size, 1, OBJNULL},
{"HASH-TABLE-REHASH-THRESHOLD", CL_ORDINARY, cl_hash_table_rehash_threshold, 1, OBJNULL},
{"HASH-TABLE-SIZE", CL_ORDINARY, cl_hash_table_size, 1, OBJNULL},
{"HASH-TABLE-TEST", CL_ORDINARY, cl_hash_table_test, 1, OBJNULL},
{"HOST-NAMESTRING", CL_ORDINARY, cl_host_namestring, 1, OBJNULL},
{"IDENTITY", CL_ORDINARY, cl_identity, 1, OBJNULL},
{"IGNORABLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"IGNORE", CL_ORDINARY, NULL, -1, OBJNULL},
{"IGNORE-ERRORS", CL_ORDINARY, NULL, -1, OBJNULL},
{"IMAGPART", CL_ORDINARY, cl_imagpart, 1, OBJNULL},
{"IMPORT", CL_ORDINARY, cl_import, -2, OBJNULL},
{"IN-PACKAGE", CL_ORDINARY, NULL, -1, OBJNULL},
{"INCF", CL_ORDINARY, NULL, -1, OBJNULL},
{"INLINE", CL_ORDINARY, NULL, -1, OBJNULL},
{"INPUT-STREAM-P", CL_ORDINARY, cl_input_stream_p, 1, OBJNULL},
{"INSPECT", CL_ORDINARY, ECL_NAME(cl_inspect), 1, OBJNULL},
{"INTEGER", CL_ORDINARY, NULL, -1, OBJNULL},
{"INTEGER-DECODE-FLOAT", CL_ORDINARY, cl_integer_decode_float, 1, OBJNULL},
{"INTEGER-LENGTH", CL_ORDINARY, cl_integer_length, 1, OBJNULL},
{"INTEGERP", CL_ORDINARY, cl_integerp, 1, OBJNULL},
{"INTERACTIVE-STREAM-P", CL_ORDINARY, cl_interactive_stream_p, 1, OBJNULL},
{"INTERN", CL_ORDINARY, cl_intern, -2, OBJNULL},
{"INTERNAL-TIME-UNITS-PER-SECOND", CL_CONSTANT, NULL, -1, OBJNULL},
{"INTERSECTION", CL_ORDINARY, ECL_NAME(cl_intersection), -3, OBJNULL},
{"INVOKE-DEBUGGER", CL_ORDINARY, NULL, -1, OBJNULL},
{"INVOKE-RESTART", CL_ORDINARY, ECL_NAME(cl_invoke_restart), -2, OBJNULL},
{"INVOKE-RESTART-INTERACTIVELY", CL_ORDINARY, ECL_NAME(cl_invoke_restart_interactively), 1, OBJNULL},
{"ISQRT", CL_ORDINARY, ECL_NAME(cl_isqrt), 1, OBJNULL},
{"KEYWORD", CL_ORDINARY, NULL, -1, OBJNULL},
{"KEYWORDP", CL_ORDINARY, cl_keywordp, 1, OBJNULL},
{"LABELS", CL_FORM, NULL, -1, OBJNULL},
{"LAMBDA", CL_FORM, NULL, -1, OBJNULL},
{"LAMBDA-LIST-KEYWORDS", CL_CONSTANT, NULL, -1, OBJNULL},
{"LAMBDA-PARAMETERS-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_LAMBDA_PARAMETERS_LIMIT)},
{"LAST", CL_ORDINARY, cl_last, -2, OBJNULL},
{"LCM", CL_ORDINARY, cl_lcm, -1, OBJNULL},
{"LDB", CL_ORDINARY, ECL_NAME(cl_ldb), 2, OBJNULL},
{"LDB-TEST", CL_ORDINARY, ECL_NAME(cl_ldb_test), 2, OBJNULL},
{"LDIFF", CL_ORDINARY, cl_ldiff, 2, OBJNULL},
{"LEAST-NEGATIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_DOUBLE_FLOAT},
{"LEAST-NEGATIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1,  ECL_LEAST_NEGATIVE_LONG_FLOAT},
{"LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT},
{"LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT},
{"LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT},
{"LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT},
{"LEAST-NEGATIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_SHORT_FLOAT},
{"LEAST-NEGATIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_NEGATIVE_SINGLE_FLOAT},
{"LEAST-POSITIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_DOUBLE_FLOAT},
{"LEAST-POSITIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_LONG_FLOAT},
{"LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT},
{"LEAST-POSITIVE-NORMALIZED-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_NORMALIZED_LONG_FLOAT},
{"LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT},
{"LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT},
{"LEAST-POSITIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_SHORT_FLOAT},
{"LEAST-POSITIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_LEAST_POSITIVE_SINGLE_FLOAT},
{"LENGTH", CL_ORDINARY, cl_length, 1, OBJNULL},
{"LET", CL_FORM, NULL, -1, OBJNULL},
{"LET*", CL_FORM, NULL, -1, OBJNULL},
{"LISP-IMPLEMENTATION-TYPE", CL_ORDINARY, ECL_NAME(cl_lisp_implementation_type), 0, OBJNULL},
{"LISP-IMPLEMENTATION-VERSION", CL_ORDINARY, ECL_NAME(cl_lisp_implementation_version), 0, OBJNULL},
{"LIST", CL_ORDINARY, cl_list, -1, OBJNULL},
{"LIST*", CL_ORDINARY, cl_listX, -1, OBJNULL},
{"LIST-ALL-PACKAGES", CL_ORDINARY, cl_list_all_packages, 0, OBJNULL},
{"LIST-LENGTH", CL_ORDINARY, cl_list_length, 1, OBJNULL},
{"LISTEN", CL_ORDINARY, cl_listen, -1, OBJNULL},
{"LISTP", CL_ORDINARY, cl_listp, 1, OBJNULL},
{"LOAD", CL_ORDINARY, cl_load, -2, OBJNULL},
{"LOAD-LOGICAL-PATHNAME-TRANSLATIONS", CL_ORDINARY, ECL_NAME(cl_load_logical_pathname_translations), 1, OBJNULL},
{"LOAD-TIME-VALUE", CL_FORM, NULL, -1, OBJNULL},
{"LOCALLY", CL_FORM, NULL, -1, OBJNULL},
{"LOG", CL_ORDINARY, cl_log, -2, OBJNULL},
{"LOGAND", CL_ORDINARY, cl_logand, -1, OBJNULL},
{"LOGANDC1", CL_ORDINARY, cl_logandc1, 2, OBJNULL},
{"LOGANDC2", CL_ORDINARY, cl_logandc2, 2, OBJNULL},
{"LOGBITP", CL_ORDINARY, cl_logbitp, 2, OBJNULL},
{"LOGCOUNT", CL_ORDINARY, cl_logcount, 1, OBJNULL},
{"LOGEQV", CL_ORDINARY, cl_logeqv, -1, OBJNULL},
{"LOGICAL-PATHNAME", CL_ORDINARY, cl_logical_pathname, 1, OBJNULL},
{"LOGICAL-PATHNAME-TRANSLATIONS", CL_ORDINARY, ECL_NAME(cl_logical_pathname_translations), 1, OBJNULL},
{"LOGIOR", CL_ORDINARY, cl_logior, -1, OBJNULL},
{"LOGNAND", CL_ORDINARY, cl_lognand, 2, OBJNULL},
{"LOGNOR", CL_ORDINARY, cl_lognor, 2, OBJNULL},
{"LOGNOT", CL_ORDINARY, cl_lognot, 1, OBJNULL},
{"LOGORC1", CL_ORDINARY, cl_logorc1, 2, OBJNULL},
{"LOGORC2", CL_ORDINARY, cl_logorc2, 2, OBJNULL},
{"LOGTEST", CL_ORDINARY, ECL_NAME(cl_logtest), 2, OBJNULL},
{"LOGXOR", CL_ORDINARY, cl_logxor, -1, OBJNULL},
{"LONG-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL},
{"LONG-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"LONG-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"LONG-SITE-NAME", CL_ORDINARY, ECL_NAME(cl_long_site_name), 0, OBJNULL},
{"LOOP", CL_ORDINARY, NULL, -1, OBJNULL},
{"LOOP-FINISH", CL_ORDINARY, NULL, -1, OBJNULL},
{"LOWER-CASE-P", CL_ORDINARY, cl_lower_case_p, 1, OBJNULL},
{"MACHINE-INSTANCE", CL_ORDINARY, ECL_NAME(cl_machine_instance), 0, OBJNULL},
{"MACHINE-TYPE", CL_ORDINARY, ECL_NAME(cl_machine_type), 0, OBJNULL},
{"MACHINE-VERSION", CL_ORDINARY, ECL_NAME(cl_machine_version), 0, OBJNULL},
{"MACRO-FUNCTION", CL_ORDINARY, cl_macro_function, -2, OBJNULL},
{"MACROEXPAND", CL_ORDINARY, cl_macroexpand, -2, OBJNULL},
{"MACROEXPAND-1", CL_ORDINARY, cl_macroexpand_1, -2, OBJNULL},
{"MACROLET", CL_FORM, NULL, -1, OBJNULL},
{"MAKE-ARRAY", CL_ORDINARY, ECL_NAME(cl_make_array), -2, OBJNULL},
{"MAKE-BROADCAST-STREAM", CL_ORDINARY, cl_make_broadcast_stream, -1, OBJNULL},
{"MAKE-CONDITION", CL_ORDINARY, ECL_NAME(cl_make_condition), -2, OBJNULL},
{"MAKE-CONCATENATED-STREAM", CL_ORDINARY, cl_make_concatenated_stream, -1, OBJNULL},
{"MAKE-DISPATCH-MACRO-CHARACTER", CL_ORDINARY, cl_make_dispatch_macro_character, -2, OBJNULL},
{"MAKE-ECHO-STREAM", CL_ORDINARY, cl_make_echo_stream, 2, OBJNULL},
{"MAKE-HASH-TABLE", CL_ORDINARY, cl_make_hash_table, -1, OBJNULL},
{"MAKE-LIST", CL_ORDINARY, cl_make_list, -2, OBJNULL},
{"MAKE-PACKAGE", CL_ORDINARY, cl_make_package, -2, OBJNULL},
{"MAKE-PATHNAME", CL_ORDINARY, cl_make_pathname, -1, OBJNULL},
{"MAKE-RANDOM-STATE", CL_ORDINARY, cl_make_random_state, -1, OBJNULL},
{"MAKE-SEQUENCE", CL_ORDINARY, ECL_NAME(cl_make_sequence), -3, OBJNULL},
{"MAKE-STRING", CL_ORDINARY, cl_make_string, -2, OBJNULL},
{"MAKE-STRING-INPUT-STREAM", CL_ORDINARY, cl_make_string_input_stream, -2, OBJNULL},
{"MAKE-STRING-OUTPUT-STREAM", CL_ORDINARY, cl_make_string_output_stream, -1, OBJNULL},
{"MAKE-SYMBOL", CL_ORDINARY, cl_make_symbol, 1, OBJNULL},
{"MAKE-SYNONYM-STREAM", CL_ORDINARY, cl_make_synonym_stream, 1, OBJNULL},
{"MAKE-TWO-WAY-STREAM", CL_ORDINARY, cl_make_two_way_stream, 2, OBJNULL},
{"MAKUNBOUND", CL_ORDINARY, cl_makunbound, 1, OBJNULL},
{"MAP", CL_ORDINARY, ECL_NAME(cl_map), -4, OBJNULL},
{"MAP-INTO", CL_ORDINARY, ECL_NAME(cl_map_into), -3, OBJNULL},
{"MAPC", CL_ORDINARY, cl_mapc, -2, OBJNULL},
{"MAPCAN", CL_ORDINARY, cl_mapcan, -2, OBJNULL},
{"MAPCAR", CL_ORDINARY, cl_mapcar, -2, OBJNULL},
{"MAPCON", CL_ORDINARY, cl_mapcon, -2, OBJNULL},
{"MAPHASH", CL_ORDINARY, cl_maphash, 2, OBJNULL},
{"MAPL", CL_ORDINARY, cl_mapl, -2, OBJNULL},
{"MAPLIST", CL_ORDINARY, cl_maplist, -2, OBJNULL},
{"MASK-FIELD", CL_ORDINARY, ECL_NAME(cl_mask_field), 2, OBJNULL},
{"MAX", CL_ORDINARY, cl_max, -2, OBJNULL},
{"MEMBER", CL_ORDINARY, cl_member, -3, OBJNULL},
{"MEMBER-IF", CL_ORDINARY, ECL_NAME(cl_member_if), -3, OBJNULL},
{"MEMBER-IF-NOT", CL_ORDINARY, ECL_NAME(cl_member_if_not), -3, OBJNULL},
{"MERGE", CL_ORDINARY, ECL_NAME(cl_merge), -5, OBJNULL},
{"MERGE-PATHNAMES", CL_ORDINARY, cl_merge_pathnames, -2, OBJNULL},
{"MIN", CL_ORDINARY, cl_min, -2, OBJNULL},
{"MINUSP", CL_ORDINARY, cl_minusp, 1, OBJNULL},
{"MISMATCH", CL_ORDINARY, ECL_NAME(cl_mismatch), -3, OBJNULL},
{"MOD", CL_ORDINARY, cl_mod, 2, OBJNULL},
{"MOST-NEGATIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_DOUBLE_FLOAT},
{"MOST-NEGATIVE-FIXNUM", CL_CONSTANT, NULL, -1, ecl_make_fixnum(MOST_NEGATIVE_FIXNUM)},
{"MOST-NEGATIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_LONG_FLOAT},
{"MOST-NEGATIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_SHORT_FLOAT},
{"MOST-NEGATIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_SINGLE_FLOAT},
{"MOST-POSITIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_DOUBLE_FLOAT},
{"MOST-POSITIVE-FIXNUM", CL_CONSTANT, NULL, -1, ecl_make_fixnum(MOST_POSITIVE_FIXNUM)},
{"MOST-POSITIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_LONG_FLOAT},
{"MOST-POSITIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_SHORT_FLOAT},
{"MOST-POSITIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_SINGLE_FLOAT},
{"MUFFLE-WARNING", CL_ORDINARY, ECL_NAME(cl_muffle_warning), -1, OBJNULL},
{"MULTIPLE-VALUE-BIND", CL_FORM, NULL, -1, OBJNULL},
{"MULTIPLE-VALUE-CALL", CL_FORM, NULL, -1, OBJNULL},
{"MULTIPLE-VALUE-LIST", CL_FORM, NULL, -1, OBJNULL},
{"MULTIPLE-VALUE-PROG1", CL_FORM, NULL, -1, OBJNULL},
{"MULTIPLE-VALUE-SETQ", CL_FORM, NULL, -1, OBJNULL},
{"MULTIPLE-VALUES-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_MULTIPLE_VALUES_LIMIT)},
{"NAME-CHAR", CL_ORDINARY, cl_name_char, 1, OBJNULL},
{"NAMESTRING", CL_ORDINARY, cl_namestring, 1, OBJNULL},
{"NBUTLAST", CL_ORDINARY, cl_nbutlast, -2, OBJNULL},
{"NCONC", CL_ORDINARY, cl_nconc, -1, OBJNULL},
{"NINTERSECTION", CL_ORDINARY, ECL_NAME(cl_nintersection), -3, OBJNULL},
{"NINTH", CL_ORDINARY, cl_ninth, 1, OBJNULL},
{"NOT", CL_ORDINARY, cl_not, 1, OBJNULL},
{"NOTANY", CL_ORDINARY, ECL_NAME(cl_notany), -3, OBJNULL},
{"NOTEVERY", CL_ORDINARY, ECL_NAME(cl_notevery), -3, OBJNULL},
{"NOTINLINE", CL_ORDINARY, NULL, -1, OBJNULL},
{"NRECONC", CL_ORDINARY, cl_nreconc, 2, OBJNULL},
{"NREVERSE", CL_ORDINARY, cl_nreverse, 1, OBJNULL},
{"NSET-DIFFERENCE", CL_ORDINARY, ECL_NAME(cl_nset_difference), -3, OBJNULL},
{"NSET-EXCLUSIVE-OR", CL_ORDINARY, ECL_NAME(cl_nset_exclusive_or), -3, OBJNULL},
{"NSTRING-CAPITALIZE", CL_ORDINARY, cl_nstring_capitalize, -1, OBJNULL},
{"NSTRING-DOWNCASE", CL_ORDINARY, cl_nstring_downcase, -1, OBJNULL},
{"NSTRING-UPCASE", CL_ORDINARY, cl_nstring_upcase, -1, OBJNULL},
{"NSUBLIS", CL_ORDINARY, cl_nsublis, -3, OBJNULL},
{"NSUBST", CL_ORDINARY, cl_nsubst, -4, OBJNULL},
{"NSUBST-IF", CL_ORDINARY, ECL_NAME(cl_nsubst_if), -4, OBJNULL},
{"NSUBST-IF-NOT", CL_ORDINARY, ECL_NAME(cl_nsubst_if_not), -4, OBJNULL},
{"NSUBSTITUTE", CL_ORDINARY, ECL_NAME(cl_nsubstitute), -4, OBJNULL},
{"NSUBSTITUTE-IF", CL_ORDINARY, ECL_NAME(cl_nsubstitute_if), -4, OBJNULL},
{"NSUBSTITUTE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_nsubstitute_if_not), -4, OBJNULL},
{"NTH", CL_ORDINARY, cl_nth, 2, OBJNULL},
{"NTH-VALUE", CL_FORM, NULL, -1, OBJNULL},
{"NTHCDR", CL_ORDINARY, cl_nthcdr, 2, OBJNULL},
{"NULL", CL_ORDINARY, cl_null, 1, OBJNULL},
{"NUMBER", CL_ORDINARY, NULL, -1, OBJNULL},
{"NUMBERP", CL_ORDINARY, cl_numberp, 1, OBJNULL},
{"NUMERATOR", CL_ORDINARY, cl_numerator, 1, OBJNULL},
{"NUNION", CL_ORDINARY, ECL_NAME(cl_nunion), -3, OBJNULL},
{"ODDP", CL_ORDINARY, cl_oddp, 1, OBJNULL},
{"OPEN", CL_ORDINARY, cl_open, -2, OBJNULL},
{"OPEN-STREAM-P", CL_ORDINARY, cl_open_stream_p, 1, OBJNULL},
{"OPTIMIZE", CL_ORDINARY, NULL, -1, OBJNULL},
{"OR", CL_ORDINARY, NULL, -1, OBJNULL},
{"OTHERWISE", CL_ORDINARY, NULL, -1, OBJNULL},
{"OUTPUT-STREAM-P", CL_ORDINARY, cl_output_stream_p, 1, OBJNULL},
{"PACKAGE", CL_ORDINARY, NULL, -1, OBJNULL},
{"PACKAGE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"PACKAGE-ERROR-PACKAGE", CL_ORDINARY, NULL, -1, OBJNULL},
{"PACKAGE-NAME", CL_ORDINARY, cl_package_name, 1, OBJNULL},
{"PACKAGE-NICKNAMES", CL_ORDINARY, cl_package_nicknames, 1, OBJNULL},
{"PACKAGE-SHADOWING-SYMBOLS", CL_ORDINARY, cl_package_shadowing_symbols, 1, OBJNULL},
{"PACKAGE-USE-LIST", CL_ORDINARY, cl_package_use_list, 1, OBJNULL},
{"PACKAGE-USED-BY-LIST", CL_ORDINARY, cl_package_used_by_list, 1, OBJNULL},
{"PACKAGEP", CL_ORDINARY, cl_packagep, 1, OBJNULL},
{"PAIRLIS", CL_ORDINARY, cl_pairlis, -3, OBJNULL},
{"PARSE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"PARSE-INTEGER", CL_ORDINARY, cl_parse_integer, -2, OBJNULL},
{"PARSE-NAMESTRING", CL_ORDINARY, cl_parse_namestring, -2, OBJNULL},
{"PATHNAME", CL_ORDINARY, cl_pathname, 1, OBJNULL},
{"PATHNAME-DEVICE", CL_ORDINARY, cl_pathname_device, -2, OBJNULL},
{"PATHNAME-DIRECTORY", CL_ORDINARY, cl_pathname_directory, -2, OBJNULL},
{"PATHNAME-HOST", CL_ORDINARY, cl_pathname_host, -2, OBJNULL},
{"PATHNAME-MATCH-P", CL_ORDINARY, cl_pathname_match_p, 2, OBJNULL},
{"PATHNAME-NAME", CL_ORDINARY, cl_pathname_name, -2, OBJNULL},
{"PATHNAME-TYPE", CL_ORDINARY, cl_pathname_type, -2, OBJNULL},
{"PATHNAME-VERSION", CL_ORDINARY, cl_pathname_version, 1, OBJNULL},
{"PATHNAMEP", CL_ORDINARY, cl_pathnamep, 1, OBJNULL},
{"PEEK-CHAR", CL_ORDINARY, cl_peek_char, -1, OBJNULL},
{"PHASE", CL_ORDINARY, ECL_NAME(cl_phase), 1, OBJNULL},
{"PI", CL_CONSTANT, NULL, -1, ECL_PI},
{"PLUSP", CL_ORDINARY, cl_plusp, 1, OBJNULL},
{"POP", CL_ORDINARY, NULL, -1, OBJNULL},
{"POSITION", CL_ORDINARY, ECL_NAME(cl_position), -3, OBJNULL},
{"POSITION-IF", CL_ORDINARY, ECL_NAME(cl_position_if), -3, OBJNULL},
{"POSITION-IF-NOT", CL_ORDINARY, ECL_NAME(cl_position_if_not), -3, OBJNULL},
{"PPRINT", CL_ORDINARY, cl_pprint, -2, OBJNULL},
{"PPRINT-DISPATCH", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_dispatch), -2, OBJNULL},
{"PPRINT-EXIT-IF-LIST-EXHAUSTED", CL_ORDINARY, NULL, -1, OBJNULL},
{"PPRINT-FILL", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_fill), -3, OBJNULL},
{"PPRINT-INDENT", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_indent), -3, OBJNULL},
{"PPRINT-LINEAR", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_linear), -3, OBJNULL},
{"PPRINT-LOGICAL-BLOCK", CL_ORDINARY, NULL, -1, OBJNULL},
{"PPRINT-NEWLINE", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_newline), -2, OBJNULL},
{"PPRINT-POP", CL_ORDINARY, NULL, -1, OBJNULL},
{"PPRINT-TAB", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_tab), -4, OBJNULL},
{"PPRINT-TABULAR", CL_ORDINARY, ECL_NAME_PPRINT(cl_pprint_tabular), -3, OBJNULL},
{"PRIN1", CL_ORDINARY, cl_prin1, -2, OBJNULL},
{"PRIN1-TO-STRING", CL_ORDINARY, ECL_NAME(cl_prin1_to_string), 1, OBJNULL},
{"PRINC", CL_ORDINARY, cl_princ, -2, OBJNULL},
{"PRINC-TO-STRING", CL_ORDINARY, ECL_NAME(cl_princ_to_string), 1, OBJNULL},
{"PRINT", CL_ORDINARY, cl_print, -2, OBJNULL},
{"PRINT-NOT-READABLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"PRINT-NOT-READABLE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL},
{"PROBE-FILE", CL_ORDINARY, cl_probe_file, 1, OBJNULL},
{"PROCLAIM", CL_ORDINARY, NULL, -1, OBJNULL},
{"PROG", CL_FORM, NULL, -1, OBJNULL},
{"PROG*", CL_FORM, NULL, -1, OBJNULL},
{"PROG1", CL_FORM, NULL, -1, OBJNULL},
{"PROG2", CL_FORM, NULL, -1, OBJNULL},
{"PROGN", CL_FORM, NULL, -1, OBJNULL},
{"PROGRAM-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"PROGV", CL_FORM, NULL, -1, OBJNULL},
{"PROVIDE", CL_ORDINARY, ECL_NAME(cl_provide), 1, OBJNULL},
{"PSETF", CL_ORDINARY, NULL, -1, OBJNULL},
{"PSETQ", CL_FORM, NULL, -1, OBJNULL},
{"PUSH", CL_ORDINARY, NULL, -1, OBJNULL},
{"PUSHNEW", CL_ORDINARY, NULL, -1, OBJNULL},
{"QUOTE", CL_FORM, NULL, -1, OBJNULL},
{"RANDOM", CL_ORDINARY, cl_random, -2, OBJNULL},
{"RANDOM-STATE", CL_ORDINARY, NULL, -1, OBJNULL},
{"RANDOM-STATE-P", CL_ORDINARY, cl_random_state_p, 1, OBJNULL},
{"RASSOC", CL_ORDINARY, cl_rassoc, -3, OBJNULL},
{"RASSOC-IF", CL_ORDINARY, ECL_NAME(cl_rassoc_if), -3, OBJNULL},
{"RASSOC-IF-NOT", CL_ORDINARY, ECL_NAME(cl_rassoc_if_not), -3, OBJNULL},
{"RATIO", CL_ORDINARY, NULL, -1, OBJNULL},
{"RATIONAL", CL_ORDINARY, cl_rational, 1, OBJNULL},
{"RATIONALIZE", CL_ORDINARY, cl_rationalize, 1, OBJNULL},
{"RATIONALP", CL_ORDINARY, cl_rationalp, 1, OBJNULL},
{"READ", CL_ORDINARY, cl_read, -1, OBJNULL},
{"READ-BYTE", CL_ORDINARY, cl_read_byte, -2, OBJNULL},
{"READ-CHAR", CL_ORDINARY, cl_read_char, -1, OBJNULL},
{"READ-CHAR-NO-HANG", CL_ORDINARY, cl_read_char_no_hang, -1, OBJNULL},
{"READ-DELIMITED-LIST", CL_ORDINARY, cl_read_delimited_list, -2, OBJNULL},
{"READ-FROM-STRING", CL_ORDINARY, ECL_NAME(cl_read_from_string), -2, OBJNULL},
{"READ-LINE", CL_ORDINARY, cl_read_line, -1, OBJNULL},
{"READ-PRESERVING-WHITESPACE", CL_ORDINARY, cl_read_preserving_whitespace, -1, OBJNULL},
{"READ-SEQUENCE", CL_ORDINARY, cl_read_sequence, -3, OBJNULL},
{"READER-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"READTABLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"READTABLE-CASE", CL_ORDINARY, cl_readtable_case, 1, OBJNULL},
{"READTABLEP", CL_ORDINARY, cl_readtablep, 1, OBJNULL},
{"REAL", CL_ORDINARY, NULL, -1, OBJNULL},
{"REALP", CL_ORDINARY, cl_realp, 1, OBJNULL},
{"REALPART", CL_ORDINARY, cl_realpart, 1, OBJNULL},
{"REDUCE", CL_ORDINARY, ECL_NAME(cl_reduce), -3, OBJNULL},
{"REM", CL_ORDINARY, cl_rem, 2, OBJNULL},
{"REMF", CL_ORDINARY, NULL, -1, OBJNULL},
{"REMHASH", CL_ORDINARY, cl_remhash, 2, OBJNULL},
{"REMOVE", CL_ORDINARY, ECL_NAME(cl_remove), -3, OBJNULL},
{"REMOVE-DUPLICATES", CL_ORDINARY, ECL_NAME(cl_remove_duplicates), -2, OBJNULL},
{"REMOVE-IF", CL_ORDINARY, ECL_NAME(cl_remove_if), -3, OBJNULL},
{"REMOVE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_remove_if_not), -3, OBJNULL},
{"REMPROP", CL_ORDINARY, cl_remprop, 2, OBJNULL},
{"RENAME-FILE", CL_ORDINARY, cl_rename_file, -3, OBJNULL},
{"RENAME-PACKAGE", CL_ORDINARY, cl_rename_package, -3, OBJNULL},
{"REPLACE", CL_ORDINARY, ECL_NAME(cl_replace), -3, OBJNULL},
{"REQUIRE", CL_ORDINARY, ECL_NAME(cl_require), -2, OBJNULL},
{"REST", CL_ORDINARY, cl_cdr, 1, OBJNULL},
{"RESTART", CL_ORDINARY, NULL, 1, OBJNULL},
{"RESTART-BIND", CL_ORDINARY, NULL, 1, OBJNULL},
{"RESTART-CASE", CL_ORDINARY, NULL, 1, OBJNULL},
{"RESTART-NAME", CL_ORDINARY, NULL, 1, OBJNULL},
{"RETURN", CL_FORM, NULL, -1, OBJNULL},
{"RETURN-FROM", CL_FORM, NULL, -1, OBJNULL},
{"REVAPPEND", CL_ORDINARY, cl_revappend, 2, OBJNULL},
{"REVERSE", CL_ORDINARY, cl_reverse, 1, OBJNULL},
{"ROOM", CL_ORDINARY, NULL, -1, OBJNULL},
{"ROTATEF", CL_ORDINARY, NULL, -1, OBJNULL},
{"ROUND", CL_ORDINARY, cl_round, -2, OBJNULL},
{"ROW-MAJOR-AREF", CL_ORDINARY, cl_row_major_aref, 2, OBJNULL},
{"RPLACA", CL_ORDINARY, cl_rplaca, 2, OBJNULL},
{"RPLACD", CL_ORDINARY, cl_rplacd, 2, OBJNULL},
{"SAFETY", CL_ORDINARY, NULL, -1, OBJNULL},
{"SATISFIES", CL_ORDINARY, NULL, -1, OBJNULL},
{"SBIT", CL_ORDINARY, ECL_NAME(cl_sbit), -2, OBJNULL},
{"SCALE-FLOAT", CL_ORDINARY, cl_scale_float, 2, OBJNULL},
{"SCHAR", CL_ORDINARY, cl_char, 2, OBJNULL},
{"SEARCH", CL_ORDINARY, ECL_NAME(cl_search), -3, OBJNULL},
{"SECOND", CL_ORDINARY, cl_cadr, 1, OBJNULL},
{"SEQUENCE", CL_ORDINARY, NULL, -1, OBJNULL},
{"SERIOUS-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL},
{"SET", CL_ORDINARY, cl_set, 2, OBJNULL},
{"SET-DIFFERENCE", CL_ORDINARY, ECL_NAME(cl_set_difference), -3, OBJNULL},
{"SET-DISPATCH-MACRO-CHARACTER", CL_ORDINARY, cl_set_dispatch_macro_character, -4, OBJNULL},
{"SET-EXCLUSIVE-OR", CL_ORDINARY, ECL_NAME(cl_set_exclusive_or), -3, OBJNULL},
{"SET-MACRO-CHARACTER", CL_ORDINARY, cl_set_macro_character, -3, OBJNULL},
{"SET-PPRINT-DISPATCH", CL_ORDINARY, ECL_NAME_PPRINT(cl_set_pprint_dispatch), -3, OBJNULL},
{"SET-SYNTAX-FROM-CHAR", CL_ORDINARY, cl_set_syntax_from_char, -3, OBJNULL},
{"SETF", CL_ORDINARY, NULL, -1, OBJNULL},
{"SETQ", CL_FORM, NULL, -1, OBJNULL},
{"SEVENTH", CL_ORDINARY, cl_seventh, 1, OBJNULL},
{"SHADOW", CL_ORDINARY, cl_shadow, -2, OBJNULL},
{"SHADOWING-IMPORT", CL_ORDINARY, cl_shadowing_import, -2, OBJNULL},
{"SHIFTF", CL_ORDINARY, NULL, -1, OBJNULL},
{"SHORT-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL},
{"SHORT-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"SHORT-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"SHORT-SITE-NAME", CL_ORDINARY, ECL_NAME(cl_short_site_name), 0, OBJNULL},
{"SIGNAL", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIGNED-BYTE", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIGNUM", CL_ORDINARY, ECL_NAME(cl_signum), 1, OBJNULL},
{"SIMPLE-ARRAY", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-BASE-STRING", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-BIT-VECTOR", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-BIT-VECTOR-P", CL_ORDINARY, cl_simple_bit_vector_p, 1, OBJNULL},
{"SIMPLE-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-CONDITION-FORMAT-CONTROL", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-CONDITION-FORMAT-ARGUMENTS", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-STRING", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-STRING-P", CL_ORDINARY, cl_simple_string_p, 1, OBJNULL},
{"SIMPLE-TYPE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-VECTOR", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIMPLE-VECTOR-P", CL_ORDINARY, cl_simple_vector_p, 1, OBJNULL},
{"SIMPLE-WARNING", CL_ORDINARY, NULL, -1, OBJNULL},
{"SIN", CL_ORDINARY, cl_sin, 1, OBJNULL},
{"SINGLE-FLOAT", CL_ORDINARY, NULL, -1, OBJNULL},
{"SINGLE-FLOAT-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"SINGLE-FLOAT-NEGATIVE-EPSILON", CL_CONSTANT, NULL, -1, OBJNULL},
{"SINH", CL_ORDINARY, cl_sinh, 1, OBJNULL},
{"SIXTH", CL_ORDINARY, cl_sixth, 1, OBJNULL},
{"SLEEP", CL_ORDINARY, cl_sleep, 1, OBJNULL},
{"SOFTWARE-TYPE", CL_ORDINARY, ECL_NAME(cl_software_type), 0, OBJNULL},
{"SOFTWARE-VERSION", CL_ORDINARY, ECL_NAME(cl_software_version), 0, OBJNULL},
{"SOME", CL_ORDINARY, ECL_NAME(cl_some), -3, OBJNULL},
{"SORT", CL_ORDINARY, ECL_NAME(cl_sort), -3, OBJNULL},
{"SPACE", CL_ORDINARY, NULL, -1, OBJNULL},
{"SPECIAL", CL_ORDINARY, NULL, -1, OBJNULL},
{"SPECIAL-OPERATOR-P", CL_ORDINARY, cl_special_operator_p, 1, OBJNULL},
{"SPEED", CL_ORDINARY, NULL, -1, OBJNULL},
{"SQRT", CL_ORDINARY, cl_sqrt, 1, OBJNULL},
{"STABLE-SORT", CL_ORDINARY, ECL_NAME(cl_stable_sort), -3, OBJNULL},
{"STANDARD-CHAR", CL_ORDINARY, NULL, -1, OBJNULL},
{"STANDARD-CHAR-P", CL_ORDINARY, cl_standard_char_p, 1, OBJNULL},
{"STEP", CL_ORDINARY, NULL, -1, OBJNULL},
{"STORAGE-CONDITION", CL_ORDINARY, NULL, -1, OBJNULL},
{"STORE-VALUE", CL_ORDINARY, ECL_NAME(cl_store_value), -2, OBJNULL},
{"STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"STREAM-ELEMENT-TYPE", CL_ORDINARY, cl_stream_element_type, 1, OBJNULL},
{"STREAM-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"STREAM-ERROR-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"STREAM-EXTERNAL-FORMAT", CL_ORDINARY, cl_stream_external_format, 1, OBJNULL},
{"STREAMP", CL_ORDINARY, cl_streamp, 1, OBJNULL},
{"STRING", CL_ORDINARY, cl_string, 1, OBJNULL},
{"STRING-DOWNCASE", CL_ORDINARY, cl_string_downcase, -1, OBJNULL},
{"STRING-CAPITALIZE", CL_ORDINARY, cl_string_capitalize, -1, OBJNULL},
{"STRING-EQUAL", CL_ORDINARY, cl_string_equal, -3, OBJNULL},
{"STRING-GREATERP", CL_ORDINARY, cl_string_greaterp, -1, OBJNULL},
{"STRING-LEFT-TRIM", CL_ORDINARY, cl_string_left_trim, 2, OBJNULL},
{"STRING-LESSP", CL_ORDINARY, cl_string_lessp, -1, OBJNULL},
{"STRING-NOT-EQUAL", CL_ORDINARY, cl_string_not_equal, -1, OBJNULL},
{"STRING-NOT-GREATERP", CL_ORDINARY, cl_string_not_greaterp, -1, OBJNULL},
{"STRING-NOT-LESSP", CL_ORDINARY, cl_string_not_lessp, -1, OBJNULL},
{"STRING-RIGHT-TRIM", CL_ORDINARY, cl_string_right_trim, 2, OBJNULL},
{"STRING-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"STRING-TRIM", CL_ORDINARY, cl_string_trim, 2, OBJNULL},
{"STRING-UPCASE", CL_ORDINARY, cl_string_upcase, -1, OBJNULL},
{"STRING/=", CL_ORDINARY, cl_stringNE, -1, OBJNULL},
{"STRING<", CL_ORDINARY, cl_stringL, -1, OBJNULL},
{"STRING<=", CL_ORDINARY, cl_stringLE, -1, OBJNULL},
{"STRING=", CL_ORDINARY, cl_stringE, -3, OBJNULL},
{"STRING>", CL_ORDINARY, cl_stringG, -1, OBJNULL},
{"STRING>=", CL_ORDINARY, cl_stringGE, -1, OBJNULL},
{"STRINGP", CL_ORDINARY, cl_stringp, 1, OBJNULL},
{"STRUCTURE", CL_ORDINARY, NULL, -1, OBJNULL},
{"STYLE-WARNING", CL_ORDINARY, NULL, -1, OBJNULL},
{"SUBLIS", CL_ORDINARY, cl_sublis, -3, OBJNULL},
{"SUBSEQ", CL_ORDINARY, cl_subseq, -3, OBJNULL},
{"SUBSETP", CL_ORDINARY, ECL_NAME(cl_subsetp), -3, OBJNULL},
{"SUBST", CL_ORDINARY, cl_subst, -4, OBJNULL},
{"SUBST-IF", CL_ORDINARY, ECL_NAME(cl_subst_if), -4, OBJNULL},
{"SUBST-IF-NOT", CL_ORDINARY, ECL_NAME(cl_subst_if_not), -4, OBJNULL},
{"SUBSTITUTE", CL_ORDINARY, ECL_NAME(cl_substitute), -4, OBJNULL},
{"SUBSTITUTE-IF", CL_ORDINARY, ECL_NAME(cl_substitute_if), -4, OBJNULL},
{"SUBSTITUTE-IF-NOT", CL_ORDINARY, ECL_NAME(cl_substitute_if_not), -4, OBJNULL},
{"SUBTYPEP", CL_ORDINARY, ECL_NAME(cl_subtypep), -3, OBJNULL},
{"SVREF", CL_ORDINARY, cl_svref, 2, OBJNULL},
{"SXHASH", CL_ORDINARY, cl_sxhash, 1, OBJNULL},
{"SYMBOL", CL_ORDINARY, NULL, -1, OBJNULL},
{"SYMBOL-FUNCTION", CL_ORDINARY, cl_symbol_function, 1, OBJNULL},
{"SYMBOL-MACROLET", CL_FORM, NULL, -1, OBJNULL},
{"SYMBOL-NAME", CL_ORDINARY, cl_symbol_name, 1, OBJNULL},
{"SYMBOL-PACKAGE", CL_ORDINARY, cl_symbol_package, 1, OBJNULL},
{"SYMBOL-PLIST", CL_ORDINARY, cl_symbol_plist, 1, OBJNULL},
{"SYMBOL-VALUE", CL_ORDINARY, cl_symbol_value, 1, OBJNULL},
{"SYMBOLP", CL_ORDINARY, cl_symbolp, 1, OBJNULL},
{"SYNONYM-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"SYNONYM-STREAM-SYMBOL", CL_ORDINARY, cl_synonym_stream_symbol, 1, OBJNULL},
{"TAGBODY", CL_FORM, NULL, -1, OBJNULL},
{"TAILP", CL_ORDINARY, cl_tailp, 2, OBJNULL},
{"TAN", CL_ORDINARY, cl_tan, 1, OBJNULL},
{"TANH", CL_ORDINARY, cl_tanh, 1, OBJNULL},
{"TENTH", CL_ORDINARY, cl_tenth, 1, OBJNULL},
{"TERPRI", CL_ORDINARY, cl_terpri, -1, OBJNULL},
{"THE", CL_FORM, NULL, -1, OBJNULL},
{"THIRD", CL_ORDINARY, cl_caddr, 1, OBJNULL},
{"THROW", CL_FORM, NULL, -1, OBJNULL},
{"TIME", CL_ORDINARY, NULL, -1, OBJNULL},
{"TRACE", CL_ORDINARY, NULL, -1, OBJNULL},
{"TRANSLATE-LOGICAL-PATHNAME", CL_ORDINARY, cl_translate_logical_pathname, -2, OBJNULL},
{"TRANSLATE-PATHNAME", CL_ORDINARY, cl_translate_pathname, -4, OBJNULL},
{"TREE-EQUAL", CL_ORDINARY, cl_tree_equal, -3, OBJNULL},
{"TRUENAME", CL_ORDINARY, cl_truename, 1, OBJNULL},
{"TRUNCATE", CL_ORDINARY, cl_truncate, -2, OBJNULL},
{"TWO-WAY-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"TWO-WAY-STREAM-INPUT-STREAM", CL_ORDINARY, cl_two_way_stream_input_stream, 1, OBJNULL},
{"TWO-WAY-STREAM-OUTPUT-STREAM", CL_ORDINARY, cl_two_way_stream_output_stream, 1, OBJNULL},
{"TYPE", CL_ORDINARY, NULL, -1, OBJNULL},
{"TYPE-ERROR", CL_ORDINARY, NULL, -1, OBJNULL},
{"TYPE-ERROR-DATUM", CL_ORDINARY, NULL, -1, OBJNULL},
{"TYPE-ERROR-EXPECTED-TYPE", CL_ORDINARY, NULL, -1, OBJNULL},
{"TYPE-OF", CL_ORDINARY, cl_type_of, 1, OBJNULL},
{"TYPECASE", CL_ORDINARY, NULL, -1, OBJNULL},
{"TYPEP", CL_ORDINARY, ECL_NAME(cl_typep), -3, OBJNULL},
{"UNBOUND-SLOT", CL_ORDINARY, NULL, -1, OBJNULL},
{"UNBOUND-SLOT-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL},
{"UNBOUND-VARIABLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"UNDEFINED-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL},
{"UNEXPORT", CL_ORDINARY, cl_unexport, -2, OBJNULL},
{"UNINTERN", CL_ORDINARY, cl_unintern, -2, OBJNULL},
{"UNION", CL_ORDINARY, ECL_NAME(cl_union), -3, OBJNULL},
{"UNLESS", CL_FORM, NULL, -1, OBJNULL},
{"UNREAD-CHAR", CL_ORDINARY, cl_unread_char, -2, OBJNULL},
{"UNSIGNED-BYTE", CL_ORDINARY, NULL, -1, OBJNULL},
{"UNTRACE", CL_ORDINARY, NULL, -1, OBJNULL},
{"UNUSE-PACKAGE", CL_ORDINARY, cl_unuse_package, -2, OBJNULL},
{"UNWIND-PROTECT", CL_FORM, NULL, -1, OBJNULL},
{"UPGRADED-ARRAY-ELEMENT-TYPE", CL_ORDINARY, ECL_NAME(cl_upgraded_array_element_type), -2, OBJNULL},
{"UPGRADED-COMPLEX-PART-TYPE", CL_ORDINARY, ECL_NAME(cl_upgraded_complex_part_type), -2, OBJNULL},
{"UPPER-CASE-P", CL_ORDINARY, cl_upper_case_p, 1, OBJNULL},
{"USE-PACKAGE", CL_ORDINARY, cl_use_package, -2, OBJNULL},
{"USE-VALUE", CL_ORDINARY, ECL_NAME(cl_use_value), -2, OBJNULL},
{"USER-HOMEDIR-PATHNAME", CL_ORDINARY, cl_user_homedir_pathname, -1, OBJNULL},
{"VALUES", CL_ORDINARY, cl_values, -1, OBJNULL},
{"VALUES-LIST", CL_ORDINARY, cl_values_list, 1, OBJNULL},
{"VARIABLE", CL_ORDINARY, NULL, -1, OBJNULL},
{"VECTOR", CL_ORDINARY, ECL_NAME(cl_vector), -1, OBJNULL},
{"VECTOR-POP", CL_ORDINARY, ECL_NAME(cl_vector_pop), 1, OBJNULL},
{"VECTOR-PUSH", CL_ORDINARY, cl_vector_push, 2, OBJNULL},
{"VECTOR-PUSH-EXTEND", CL_ORDINARY, cl_vector_push_extend, -3, OBJNULL},
{"VECTORP", CL_ORDINARY, cl_vectorp, 1, OBJNULL},
{"WARN", CL_ORDINARY, NULL, -1, OBJNULL},
{"WARNING", CL_ORDINARY, NULL, -1, OBJNULL},
{"WHEN", CL_FORM, NULL, -1, OBJNULL},
{"WILD-PATHNAME-P", CL_ORDINARY, cl_wild_pathname_p, -2, OBJNULL},
{"WITH-COMPILATION-UNIT", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-CONDITION-RESTARTS", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-HASH-TABLE-ITERATOR", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-INPUT-FROM-STRING", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-OPEN-FILE", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-OPEN-STREAM", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-OUTPUT-TO-STRING", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-PACKAGE-ITERATOR", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-SIMPLE-RESTART", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-STANDARD-IO-SYNTAX", CL_ORDINARY, NULL, -1, OBJNULL},
{"WRITE", CL_ORDINARY, cl_write, -2, OBJNULL},
{"WRITE-BYTE", CL_ORDINARY, cl_write_byte, 2, OBJNULL},
{"WRITE-CHAR", CL_ORDINARY, cl_write_char, -2, OBJNULL},
{"WRITE-LINE", CL_ORDINARY, cl_write_line, -2, OBJNULL},
{"WRITE-SEQUENCE", CL_ORDINARY, cl_write_sequence, -3, OBJNULL},
{"WRITE-STRING", CL_ORDINARY, cl_write_string, -2, OBJNULL},
{"WRITE-TO-STRING", CL_ORDINARY, ECL_NAME(cl_write_to_string), -2, OBJNULL},
{"Y-OR-N-P", CL_ORDINARY, ECL_NAME(cl_y_or_n_p), -1, OBJNULL},
{"YES-OR-NO-P", CL_ORDINARY, ECL_NAME(cl_yes_or_no_p), -1, OBJNULL},
{"ZEROP", CL_ORDINARY, cl_zerop, 1, OBJNULL},
{"ALLOCATE-INSTANCE", CL_ORDINARY, NULL, 2, OBJNULL},
{"ADD-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"BUILT-IN-CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"CALL-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"CALL-NEXT-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"CHANGE-CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"CLASS-NAME", CL_ORDINARY, NULL, -1, OBJNULL},
{"CLASS-OF", CL_ORDINARY, cl_class_of, 1, OBJNULL},
{"COMPUTE-APPLICABLE-METHODS", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFCLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFGENERIC", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFINE-METHOD-COMBINATION", CL_ORDINARY, NULL, -1, OBJNULL},
{"DEFMETHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"DESCRIBE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL},
{"ENSURE-GENERIC-FUNCTION", CL_ORDINARY, NULL, -2, OBJNULL},
{"FIND-CLASS", CL_ORDINARY, cl_find_class, -2, OBJNULL},
{"FIND-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"GENERIC-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL},
{"IF", CL_FORM, NULL, -1, OBJNULL},
{"INITIALIZE-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL},
{"INVALID-METHOD-ERROR", CL_ORDINARY, ECL_NAME(cl_invalid_method_error), -3, OBJNULL},
{"MAKE-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL},
{"MAKE-INSTANCES-OBSOLETE", CL_ORDINARY, NULL, -1, OBJNULL},
{"MAKE-LOAD-FORM", CL_ORDINARY, NULL, -1, OBJNULL},
{"MAKE-LOAD-FORM-SAVING-SLOTS", CL_ORDINARY, NULL, -1, OBJNULL},
{"MAKE-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"METHOD-COMBINATION-ERROR", CL_ORDINARY, ECL_NAME(cl_method_combination_error), -2, OBJNULL},
{"METHOD-COMBINATION", CL_ORDINARY, NULL, -1, OBJNULL},
{"METHOD-QUALIFIERS", CL_ORDINARY, NULL, -1, OBJNULL},
{"NEXT-METHOD-P", CL_ORDINARY, NULL, -1, OBJNULL},
{"NO-APPLICABLE-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"NO-NEXT-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"PRINT-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL},
{"PRINT-UNREADABLE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL},
{"REINITIALIZE-INSTANCE", CL_ORDINARY, NULL, -1, OBJNULL},
{"REMOVE-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"SHARED-INITIALIZE", CL_ORDINARY, NULL, -1, OBJNULL},
{"SLOT-BOUNDP", CL_ORDINARY, ECL_NAME(cl_slot_boundp), 2, OBJNULL},
{"SLOT-EXISTS-P", CL_ORDINARY, ECL_NAME(cl_slot_exists_p), 2, OBJNULL},
{"SLOT-MAKUNBOUND", CL_ORDINARY, ECL_NAME(cl_slot_makunbound), 2, OBJNULL},
{"SLOT-MISSING", CL_ORDINARY, NULL, -1, OBJNULL},
{"SLOT-UNBOUND", CL_ORDINARY, NULL, -1, OBJNULL},
{"SLOT-VALUE", CL_ORDINARY, cl_slot_value, 2, OBJNULL},
{"STANDARD", CL_ORDINARY, NULL, -1, OBJNULL},
{"STANDARD-CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"STANDARD-GENERIC-FUNCTION", CL_ORDINARY, NULL, -1, OBJNULL},
{"STANDARD-METHOD", CL_ORDINARY, NULL, -1, OBJNULL},
{"STANDARD-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL},
{"STRUCTURE-CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"STRUCTURE-OBJECT", CL_ORDINARY, NULL, -1, OBJNULL},
{"UPDATE-INSTANCE-FOR-DIFFERENT-CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"UPDATE-INSTANCE-FOR-REDEFINED-CLASS", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-ACCESSORS", CL_ORDINARY, NULL, -1, OBJNULL},
{"WITH-SLOTS", CL_ORDINARY, NULL, -1, OBJNULL},
{KEY_ "ACCESSOR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ARGUMENT-PRECEDENCE-ORDER", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ALLOCATION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DECLARE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DEFAULT-INITARGS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DESCRIPTION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DIRECT-DEFAULT-INITARGS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DIRECT-SLOTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DIRECT-SUPERCLASSES", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "GENERIC-FUNCTION-CLASS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IDENTITY-WITH-ONE-ARGUMENT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITARG", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITARGS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITFORM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITFUNCTION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LAMBDA-LIST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LOCATION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "METACLASS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "METHOD", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "METHOD-CLASS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "METHOD-COMBINATION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OPERATOR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ORDER", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "READER", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "READERS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "REQUIRED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WRITER", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WRITERS", KEYWORD, NULL, -1, OBJNULL},

/* SYSTEM PACKAGE */
{SYS_ "#!", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "*BACKQ-LEVEL*", SI_SPECIAL, NULL, -1, ecl_make_fixnum(0)},
{SYS_ "*CBLOCK*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*CIRCLE-COUNTER*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*CIRCLE-STACK*", SI_SPECIAL, NULL, -1, OBJNULL},
{SYS_ "*CLASS-NAME-HASH-TABLE*", SI_SPECIAL, NULL, -1, OBJNULL},
{SYS_ "*COMPILER-CONSTANTS*", SI_SPECIAL, NULL, -1, OBJNULL},
{SYS_ "*GC-MESSAGE*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*GC-VERBOSE*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*IGNORE-EOF-ON-TERMINAL-IO*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*INDENT-FORMATTED-OUTPUT*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*INIT-FUNCTION-PREFIX*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*KEEP-DEFINITIONS*", SI_SPECIAL, NULL, -1, ECL_T},
{EXT_ "*LOAD-HOOKS*", EXT_SPECIAL, NULL, -1, OBJNULL},
{SYS_ "*LOAD-SEARCH-LIST*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*MAKE-CONSTANT", SI_ORDINARY, si_Xmake_constant, 2, OBJNULL},
{SYS_ "*MAKE-SPECIAL", SI_ORDINARY, si_Xmake_special, 1, OBJNULL},
{SYS_ "*PRINT-PACKAGE*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*PRINT-STRUCTURE*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*SHARP-EQ-CONTEXT*", SI_SPECIAL, NULL, -1, ECL_NIL},
{SYS_ "*STEP-LEVEL*", SI_SPECIAL, OBJNULL, -1, ecl_make_fixnum(0)},
{SYS_ "*STEP-ACTION*", SI_SPECIAL, OBJNULL, -1, ECL_NIL},
{SYS_ ".", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNQUOTE", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNQUOTE-NSPLICE", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNQUOTE-SPLICE", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "ALLOCATE-RAW-INSTANCE", SI_ORDINARY, si_allocate_raw_instance, 3, OBJNULL},
{EXT_ "ARGC", EXT_ORDINARY, si_argc, 0, OBJNULL},
{EXT_ "ARGV", EXT_ORDINARY, si_argv, 1, OBJNULL},
{SYS_ "ASET", SI_ORDINARY, si_aset, -2, OBJNULL},
{SYS_ "BASE-CHAR-P", SI_ORDINARY, si_base_char_p, 1, OBJNULL},
{SYS_ "BASE-STRING-P", SI_ORDINARY, si_base_string_p, 1, OBJNULL},
{SYS_ "BC-DISASSEMBLE", SI_ORDINARY, si_bc_disassemble, 1, OBJNULL},
{SYS_ "BC-SPLIT", SI_ORDINARY, si_bc_split, 1, OBJNULL},
{SYS_ "BC-JOIN", SI_ORDINARY, si_bc_join, 4, OBJNULL},
{SYS_ "BDS-TOP", SI_ORDINARY, si_bds_top, 0, OBJNULL},
{SYS_ "BDS-VAL", SI_ORDINARY, si_bds_val, 1, OBJNULL},
{SYS_ "BDS-VAR", SI_ORDINARY, si_bds_var, 1, OBJNULL},
{SYS_ "BIT-ARRAY-OP", SI_ORDINARY, si_bit_array_op, 4, OBJNULL},
{SYS_ "C-ARGUMENTS-LIMIT", SI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_C_ARGUMENTS_LIMIT)},
{SYS_ "CHAR-SET", SI_ORDINARY, si_char_set, 3, OBJNULL},
{EXT_ "CHDIR", EXT_ORDINARY, si_chdir, -2, OBJNULL},
{SYS_ "CLEAR-COMPILER-PROPERTIES", SI_ORDINARY, cl_identity, 1, OBJNULL},
{SYS_ "COERCE-TO-BASE-STRING", SI_ORDINARY, si_coerce_to_base_string, 1, OBJNULL},
{SYS_ "COERCE-TO-EXTENDED-STRING", SI_ORDINARY, si_coerce_to_extended_string, 1, OBJNULL},
{SYS_ "COERCE-TO-FILENAME", SI_ORDINARY, si_coerce_to_filename, 1, OBJNULL},
{SYS_ "COERCE-TO-FUNCTION", SI_ORDINARY, si_coerce_to_function, 1, OBJNULL},
{SYS_ "COERCE-TO-PACKAGE", SI_ORDINARY, si_coerce_to_package, 1, OBJNULL},
{SYS_ "COPY-TO-SIMPLE-BASE-STRING", SI_ORDINARY, si_copy_to_simple_base_string, 1, OBJNULL},
{SYS_ "COMPILED-FUNCTION-BLOCK", SI_ORDINARY, si_compiled_function_block, 1, OBJNULL},
{EXT_ "COMPILED-FUNCTION-NAME", EXT_ORDINARY, si_compiled_function_name, 1, OBJNULL},
{SYS_ "COPY-STREAM", SI_ORDINARY, si_copy_stream, 3, OBJNULL},
{SYS_ "DESTRUCTURE", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "DO-READ-SEQUENCE", SI_ORDINARY, si_do_read_sequence, 4, OBJNULL},
{SYS_ "DO-WRITE-SEQUENCE", SI_ORDINARY, si_do_write_sequence, 4, OBJNULL},
{SYS_ "ELT-SET", SI_ORDINARY, si_elt_set, 3, OBJNULL},
{SYS_ "EVAL-WITH-ENV", SI_ORDINARY, si_eval_with_env, -2, OBJNULL},
{SYS_ "EXPAND-DEFMACRO", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "FILE-COLUMN", SI_ORDINARY, si_file_column, 1, OBJNULL},
{EXT_ "FILE-KIND", EXT_ORDINARY, si_file_kind, 2, OBJNULL},
{SYS_ "FILL-POINTER-SET", SI_ORDINARY, si_fill_pointer_set, 2, OBJNULL},
{EXT_ "FILE-STREAM-FD", EXT_ORDINARY, si_file_stream_fd, 1, OBJNULL},
{EXT_ "MAKE-STREAM-FROM-FD", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "FIXNUMP", EXT_ORDINARY, si_fixnump, 1, OBJNULL},
{SYS_ "FORMAT-ERROR", SI_ORDINARY, NULL, -1, OBJNULL},
#ifdef ECL_CMU_FORMAT
{SYS_ "FORMATTER-AUX", SI_ORDINARY, NULL, -3, OBJNULL},
#else
{SYS_ "FORMATTER-AUX", SI_ORDINARY, si_formatter_aux, -3, OBJNULL},
#endif
{SYS_ "FRS-BDS", SI_ORDINARY, si_frs_bds, 1, OBJNULL},
{SYS_ "FRS-IHS", SI_ORDINARY, si_frs_ihs, 1, OBJNULL},
{SYS_ "FRS-TAG", SI_ORDINARY, si_frs_tag, 1, OBJNULL},
{SYS_ "FRS-TOP", SI_ORDINARY, si_frs_top, 0, OBJNULL},
{SYS_ "FSET", SI_ORDINARY, si_fset, -3, OBJNULL},
{SYS_ "FUNCTION-BLOCK-NAME", SI_ORDINARY, si_function_block_name, 1, OBJNULL},
{SYS_ "GET-LIBRARY-PATHNAME", SI_ORDINARY, si_get_library_pathname, 0, OBJNULL},
{SYS_ "GET-SYSPROP", SI_ORDINARY, si_get_sysprop, 2, OBJNULL},
{EXT_ "GETENV", EXT_ORDINARY, si_getenv, 1, OBJNULL},
{EXT_ "GETCWD", EXT_ORDINARY, si_getcwd, -1, OBJNULL},
{EXT_ "GETPID", EXT_ORDINARY, si_getpid, 0, OBJNULL},
{EXT_ "GETUID", EXT_ORDINARY, si_getuid, 0, OBJNULL},
{SYS_ "HASH-SET", SI_ORDINARY, si_hash_set, 3, OBJNULL},
{SYS_ "HASH-TABLE-ITERATOR", SI_ORDINARY, si_hash_table_iterator, 1, OBJNULL},
{SYS_ "IHS-BDS", SI_ORDINARY, si_ihs_bds, 1, OBJNULL},
{SYS_ "IHS-ENV", SI_ORDINARY, si_ihs_env, 1, OBJNULL},
{SYS_ "IHS-FUN", SI_ORDINARY, si_ihs_fun, 1, OBJNULL},
{SYS_ "IHS-NEXT", SI_ORDINARY, si_ihs_next, 1, OBJNULL},
{SYS_ "IHS-PREV", SI_ORDINARY, si_ihs_prev, 1, OBJNULL},
{SYS_ "IHS-TOP", SI_ORDINARY, si_ihs_top, 0, OBJNULL},
{SYS_ "INTERPRETER-STACK", SI_ORDINARY, si_interpreter_stack, -1, OBJNULL},
{SYS_ "LINK-FROM", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "LINK-TO", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "LOAD-SOURCE", SI_ORDINARY, si_load_source, 4, OBJNULL},
{SYS_ "LOGICAL-PATHNAME-P", SI_ORDINARY, si_logical_pathname_p, 1, OBJNULL},
{SYS_ "MACRO", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "MAKE-LAMBDA", SI_ORDINARY, si_make_lambda, 2, OBJNULL},
{SYS_ "MAKE-PURE-ARRAY", SI_ORDINARY, si_make_pure_array, 6, OBJNULL},
{SYS_ "MAKE-STRING-OUTPUT-STREAM-FROM-STRING", SI_ORDINARY, si_make_string_output_stream_from_string, 1, OBJNULL},
{SYS_ "MAKE-STRUCTURE", SI_ORDINARY, si_make_structure, -2, OBJNULL},
{SYS_ "MAKE-VECTOR", SI_ORDINARY, si_make_vector, 6, OBJNULL},
{SYS_ "MANGLE-NAME", SI_ORDINARY, si_mangle_name, -2, OBJNULL},
{SYS_ "MEMBER1", SI_ORDINARY, si_member1, 5, OBJNULL},
{SYS_ "MEMQ", SI_ORDINARY, si_memq, 2, OBJNULL},
{SYS_ "MKDIR", SI_ORDINARY, si_mkdir, 2, OBJNULL},
{EXT_ "MKSTEMP", EXT_ORDINARY, si_mkstemp, 1, OBJNULL},
{SYS_ "NEED-TO-MAKE-LOAD-FORM-P", SI_ORDINARY, si_need_to_make_load_form_p, 1, OBJNULL},
{SYS_ "RMDIR", SI_ORDINARY, si_rmdir, 1, OBJNULL},
{EXT_ "MAKE-PIPE", EXT_ORDINARY, si_make_pipe, 0, OBJNULL},
/* package extensions */
{SYS_ "*IGNORE-PACKAGE-LOCKS*", SI_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "PACKAGE-LOCK", EXT_ORDINARY, si_package_lock, 2, OBJNULL},
{EXT_ "PACKAGE-LOCKED-P", EXT_ORDINARY, si_package_locked_p, 1, OBJNULL},
{SYS_ "LOCK-PACKAGE", EXT_ORDINARY, NULL, 1, OBJNULL},
{SYS_ "UNLOCK-PACKAGE", EXT_ORDINARY, NULL, 1, OBJNULL},
{SYS_ "WITHOUT-PACKAGE-LOCKS", EXT_ORDINARY, NULL, 1, OBJNULL},
{SYS_ "WITH-UNLOCKED-PACKAGES", EXT_ORDINARY, NULL, 1, OBJNULL},
{EXT_ "PACKAGE-LOCAL-NICKNAMES", EXT_ORDINARY, si_package_local_nicknames, 1, OBJNULL},
{EXT_ "PACKAGE-LOCALLY-NICKNAMED-BY-LIST", EXT_ORDINARY, si_package_locally_nicknamed_by_list, 1, OBJNULL},
{EXT_ "ADD-PACKAGE-LOCAL-NICKNAME", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "REMOVE-PACKAGE-LOCAL-NICKNAME", EXT_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "%ADD-PACKAGE-LOCAL-NICKNAME", EXT_ORDINARY, si_add_package_local_nickname, 3, OBJNULL},
{SYS_ "%REMOVE-PACKAGE-LOCAL-NICKNAME", EXT_ORDINARY, si_remove_package_local_nickname, 2, OBJNULL},
{SYS_ "PACKAGE-HASH-TABLES", SI_ORDINARY, si_package_hash_tables, 1, OBJNULL},
{SYS_ "PATHNAME-TRANSLATIONS", SI_ORDINARY, si_pathname_translations, -2, OBJNULL},
{SYS_ "POINTER", SI_ORDINARY, si_pointer, 1, OBJNULL},
{SYS_ "PRETTY-PRINT-FORMAT", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "PROCESS-DECLARATIONS", SI_ORDINARY, si_process_declarations, -2, OBJNULL},
{SYS_ "PROCESS-LAMBDA", SI_ORDINARY, si_process_lambda, 1, OBJNULL},
{SYS_ "PROCESS-LAMBDA-LIST", SI_ORDINARY, si_process_lambda_list, 2, OBJNULL},
{SYS_ "PUT-F", SI_ORDINARY, si_put_f, 3, OBJNULL},
{SYS_ "PUT-PROPERTIES", SI_ORDINARY, si_put_properties, -2, OBJNULL},
{SYS_ "PUT-SYSPROP", SI_ORDINARY, si_put_sysprop, 3, OBJNULL},
{SYS_ "PUTPROP", SI_ORDINARY, si_putprop, 3, OBJNULL},
{SYS_ "READTABLE-CASE-SET", SI_ORDINARY, si_readtable_case_set, 2, OBJNULL},
{SYS_ "REM-F", SI_ORDINARY, si_rem_f, 2, OBJNULL},
{SYS_ "REM-SYSPROP", SI_ORDINARY, si_rem_sysprop, 2, OBJNULL},
{SYS_ "REPLACE-ARRAY", SI_ORDINARY, si_replace_array, 2, OBJNULL},
{SYS_ "ROW-MAJOR-ASET", SI_ORDINARY, si_row_major_aset, 3, OBJNULL},
{EXT_ "SAFE-EVAL", EXT_ORDINARY, ECL_NAME(si_safe_eval), -3, OBJNULL},
{SYS_ "SCH-FRS-BASE", SI_ORDINARY, si_sch_frs_base, 2, OBJNULL},
{SYS_ "SCHAR-SET", SI_ORDINARY, si_char_set, 3, OBJNULL},
{SYS_ "SERROR", SI_ORDINARY, si_serror, -3, OBJNULL},
{SYS_ "SHARP-A-READER", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "SHARP-S-READER", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "SELECT-PACKAGE", SI_ORDINARY, si_select_package, 1, OBJNULL},
{SYS_ "SET-SYMBOL-PLIST", SI_ORDINARY, si_set_symbol_plist, 2, OBJNULL},
#if defined(HAVE_PUTENV) || defined(HAVE_SETENV)
{EXT_ "SETENV", EXT_ORDINARY, si_setenv, 2, OBJNULL},
#else
{EXT_ "SETENV", EXT_ORDINARY, NULL, -1, OBJNULL},
#endif
{SYS_ "SETF-METHOD", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "SETF-NAMEP", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "SIMPLE-PROGRAM-ERROR", SI_ORDINARY,  ECL_NAME(si_simple_program_error), -2, OBJNULL},
{SYS_ "SIGNAL-SIMPLE-ERROR", SI_ORDINARY, si_signal_simple_error, -5, OBJNULL},
{SYS_ "SIGNAL-TYPE-ERROR", SI_ORDINARY, si_signal_type_error, 2, OBJNULL},
{SYS_ "SPECIALP", SI_ORDINARY, si_specialp, 1, OBJNULL},
{SYS_ "STANDARD-READTABLE", SI_ORDINARY, si_standard_readtable, 0, OBJNULL},
{SYS_ "STEPPER", SI_ORDINARY, OBJNULL, -1, OBJNULL},
{SYS_ "BASE-STRING-CONCATENATE", SI_ORDINARY, si_base_string_concatenate, -1, OBJNULL},
{SYS_ "STRING-TO-OBJECT", SI_ORDINARY, ECL_NAME(si_string_to_object), -2, OBJNULL},
{SYS_ "STRUCTURE-NAME", SI_ORDINARY, si_structure_name, 1, OBJNULL},
{SYS_ "STRUCTURE-PRINT-FUNCTION", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "STRUCTURE-REF", SI_ORDINARY, si_structure_ref, 3, OBJNULL},
{SYS_ "STRUCTURE-SET", SI_ORDINARY, si_structure_set, 4, OBJNULL},
{SYS_ "STRUCTURE-SLOT-DESCRIPTIONS", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "STRUCTURE-SUBTYPE-P", SI_ORDINARY, si_structure_subtype_p, 2, OBJNULL},
{SYS_ "STRUCTUREP", SI_ORDINARY, si_structurep, 1, OBJNULL},
{SYS_ "SVSET", SI_ORDINARY, si_svset, 3, OBJNULL},
{SYS_ "SYMBOL-MACRO", SI_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "SYSTEM", EXT_ORDINARY, si_system, 1, OBJNULL},
{SYS_ "TERMINAL-INTERRUPT", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "TOP-LEVEL", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNIVERSAL-ERROR-HANDLER", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "STACK-ERROR-HANDLER", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "VALID-FUNCTION-NAME-P", SI_ORDINARY, si_valid_function_name_p, 1, OBJNULL},
{SYS_ "SEARCH-PRINT-CIRCLE", SI_SPECIAL, si_search_print_circle, 1, OBJNULL},
{SYS_ "WRITE-OBJECT-WITH-CIRCLE", SI_SPECIAL, si_write_object_with_circle, 3, OBJNULL},
{SYS_ "WRITE-OBJECT", SI_SPECIAL, si_write_object, 2, OBJNULL},
{SYS_ "WRITE-UGLY-OBJECT", SI_SPECIAL, si_write_ugly_object, 2, OBJNULL},

{SYS_ "COPY-INSTANCE", SI_ORDINARY, si_copy_instance, 1, OBJNULL},
{SYS_ "GENERIC-FUNCTION-P", SI_ORDINARY, si_generic_function_p, 1, OBJNULL},
{SYS_ "INSTANCE-REF", SI_ORDINARY, si_instance_ref, 2, OBJNULL},
{SYS_ "INSTANCE-SET", SI_ORDINARY, si_instance_set, 3, OBJNULL},
{SYS_ "INSTANCE-OBSOLETE-P", SI_ORDINARY, si_instance_obsolete_p, 1, OBJNULL},
{SYS_ "INSTANCE-NEW-STAMP", SI_ORDINARY, si_instance_new_stamp, 1, OBJNULL},
{SYS_ "INSTANCE-GET-STAMP", SI_ORDINARY, si_instance_get_stamp, 1, OBJNULL},
{SYS_ "INSTANCE-SLOTDS", SI_ORDINARY, si_instance_slotds, 1, OBJNULL},
{SYS_ "INSTANCE-SIG-SET", SI_ORDINARY, si_instance_sig_set, 1, OBJNULL},
{SYS_ "INSTANCE-CLASS", SI_ORDINARY, si_instance_class, 1, OBJNULL},
{SYS_ "INSTANCE-CLASS-SET", SI_ORDINARY, si_instance_class_set, 2, OBJNULL},
{SYS_ "INSTANCEP", SI_ORDINARY, si_instancep, 1, OBJNULL},
{SYS_ "SL-BOUNDP", SI_ORDINARY, si_sl_boundp, 1, OBJNULL},
{SYS_ "SL-MAKUNBOUND", SI_ORDINARY, si_sl_makunbound, 2, OBJNULL},
{SYS_ "SUBCLASSP", SI_ORDINARY, ECL_NAME(si_subclassp), -3, OBJNULL},
{SYS_ "OF-CLASS-P", SI_ORDINARY, ECL_NAME(si_of_class_p), -3, OBJNULL},
/*{SYS_ "UNBOUND", SI_ORDINARY, si_unbound, 0, OBJNULL}, */

{EXT_ "*SOURCE-LOCATION*", EXT_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "*REGISTER-WITH-PDE-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "REGISTER-WITH-PDE", EXT_ORDINARY, NULL, -1, OBJNULL},

/* #ifdef PROFILE */
{SYS_ "PROFILE", SI_ORDINARY, IF_PROFILE(si_profile), -3, OBJNULL},
{SYS_ "CLEAR-PROFILE", SI_ORDINARY, IF_PROFILE(si_clear_profile), -1, OBJNULL},
{SYS_ "DISPLAY-PROFILE", SI_ORDINARY, IF_PROFILE(si_display_profile), -1, OBJNULL},
/* #endif PROFILE */

/* #ifdef TCP */
{SYS_ "*PROFILE-ARRAY*", SI_SPECIAL, NULL, -1, OBJNULL},
{SYS_ "OPEN-CLIENT-STREAM", SI_ORDINARY, IF_TCP(si_open_client_stream), 2, OBJNULL},
{SYS_ "OPEN-SERVER-STREAM", SI_ORDINARY, IF_TCP(si_open_server_stream), 1, OBJNULL},
{SYS_ "OPEN-UNIX-SOCKET-STREAM", SI_ORDINARY, IF_TCP(si_open_unix_socket_stream), 1, OBJNULL},
{SYS_ "LOOKUP-HOST-ENTRY", SI_ORDINARY, IF_TCP(si_lookup_host_entry), 1, OBJNULL},
/* #endif TCP */

{EXT_ "CATCH-SIGNAL", EXT_ORDINARY, si_catch_signal, -3, OBJNULL},
{EXT_ "GET-SIGNAL-HANDLER", EXT_ORDINARY, si_get_signal_handler, 1, OBJNULL},
{EXT_ "SET-SIGNAL-HANDLER", EXT_ORDINARY, si_set_signal_handler, 2, OBJNULL},

/* KEYWORD PACKAGE */
{KEY_ "ADJUSTABLE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ABORT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ABSOLUTE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ALLOW-OTHER-KEYS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "APPEND", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ARRAY", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "BACK", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "BASE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "BLOCK", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CAPITALIZE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CATCH", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CASE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CIRCLE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "COMPILE-TOPLEVEL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "COMMON",KEYWORD,NULL,-1,OBJNULL},
{KEY_ "CONC-NAME", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CONSTRUCTOR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CONTROL-STRING", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "COPIER", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CREATE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DATUM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DEFAULT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DEFAULTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DEVICE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DIRECTION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DIRECTORY", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DISPLACED-INDEX-OFFSET", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DISPLACED-TO", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DOCUMENTATION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DOWNCASE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ELEMENT-TYPE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "END", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "END1", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "END2", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EOF", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ERROR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ESCAPE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXECUTE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXPECTED-TYPE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXPORT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXPORT-FROM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXTERNAL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXTERNAL-FORMAT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FIFO", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FILE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FILL-POINTER", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FORMAT-ARGUMENTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FORMAT-CONTROL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FUNCTION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "GENSYM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "HASH-FUNCTION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "HOST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IF-DOES-NOT-EXIST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IF-ERROR-EXISTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IF-EXISTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IF-INPUT-DOES-NOT-EXIST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IF-OUTPUT-EXISTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IGNORE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IMPORT-FROM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INCLUDE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INHERITED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITIAL-ELEMENT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITIAL-CONTENTS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INITIAL-OFFSET", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INPUT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INTERACTIVE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INSTANCE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INTERN", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INTERNAL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INVERT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "IO", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "JUNK-ALLOWED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "KEY", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LENGTH", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LEVEL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LINES", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LINK", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LIST-ALL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LOCAL",KEYWORD,NULL,-1,OBJNULL},
{KEY_ "LOCAL-NICKNAMES",KEYWORD,NULL,-1,OBJNULL},
{KEY_ "LOCKABLE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LOAD-TOPLEVEL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "MASK", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "MISER-WIDTH", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "NAME", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "NAMED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "NEW-VERSION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "NEWEST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "NICKNAMES", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OBJECT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OFFSET", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OPERATION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OPERANDS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OUTPUT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "OVERWRITE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PACKAGE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PATHNAME", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PPRINT-DISPATCH", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PREDICATE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PRESERVE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PRETTY", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PRINT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PRINT-FUNCTION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PRINT-OBJECT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PROBE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PROCESS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RADIX", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "READABLY", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "REHASH-SIZE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "REHASH-THRESHOLD", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RELATIVE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RENAME", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RENAME-AND-DELETE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "REPORT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RIGHT-MARGIN", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SET-DEFAULT-PATHNAME", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SEARCH-LIST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SHADOW", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SHADOWING-IMPORT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SIZE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SPECIAL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "START", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "START1", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "START2", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "STREAM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SUPERSEDE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "TAG", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "TEST", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "TEST-NOT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "TRUNCATE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "TYPE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSPECIFIC", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNMASK", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UP", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UPCASE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "USE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CSTREAM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "VERBOSE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "VERSION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WILD", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WILD-INFERIORS", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WAIT", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "BYTE8", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "BYTE16", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "BYTE32", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "BYTE64", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "COMPILER-LET", EXT_FORM, NULL, -1, OBJNULL},
{EXT_ "INTEGER8", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INTEGER16", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INTEGER32", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INTEGER64", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "LAMBDA-BLOCK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "QUIT", EXT_ORDINARY, si_quit, -1, OBJNULL},
{EXT_ "GET-METHOD", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INSTANCE", EXT_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "ALLOCATE-FOREIGN-DATA", SI_ORDINARY, si_allocate_foreign_data, 2, OBJNULL},
{SYS_ "FIND-FOREIGN-SYMBOL", SI_ORDINARY, si_find_foreign_symbol, 4, OBJNULL},
{SYS_ "FOREIGN-DATA", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "FOREIGN-DATA-ADDRESS", SI_ORDINARY, si_foreign_data_address, 1, OBJNULL},
{SYS_ "FOREIGN-DATA-EQUAL", SI_ORDINARY, si_foreign_data_equal, 2, OBJNULL},
{SYS_ "FOREIGN-DATA-P", SI_ORDINARY, si_foreign_data_p, 1, OBJNULL},
{SYS_ "FOREIGN-DATA-POINTER", SI_ORDINARY, si_foreign_data_pointer, 4, OBJNULL},
{SYS_ "FOREIGN-DATA-RECAST", SI_ORDINARY, si_foreign_data_recast, 3, OBJNULL},
{SYS_ "FOREIGN-DATA-REF", SI_ORDINARY, si_foreign_data_ref, 4, OBJNULL},
{SYS_ "FOREIGN-DATA-REF-ELT", SI_ORDINARY, si_foreign_data_ref_elt, 3, OBJNULL},
{SYS_ "FOREIGN-DATA-SET", SI_ORDINARY, si_foreign_data_set, 3, OBJNULL},
{SYS_ "FOREIGN-DATA-SET-ELT", SI_ORDINARY, si_foreign_data_set_elt, 4, OBJNULL},
{SYS_ "FOREIGN-DATA-TAG", SI_ORDINARY, si_foreign_data_tag, 1, OBJNULL},
{SYS_ "FOREIGN-ELT-TYPE-P", SI_ORDINARY, si_foreign_elt_type_p, 1, OBJNULL},
{SYS_ "FREE-FOREIGN-DATA", SI_ORDINARY, si_free_foreign_data, 1, OBJNULL},
{SYS_ "MAKE-FOREIGN-DATA-FROM-ARRAY", SI_ORDINARY, si_make_foreign_data_from_array, 1, OBJNULL},
{SYS_ "LOAD-FOREIGN-MODULE", SI_ORDINARY, si_load_foreign_module, 1, OBJNULL},
{SYS_ "UNLOAD-FOREIGN-MODULE", SI_ORDINARY, si_unload_foreign_module, 1, OBJNULL},
{SYS_ "NULL-POINTER-P", SI_ORDINARY, si_null_pointer_p, 1, OBJNULL},
{SYS_ "SIZE-OF-FOREIGN-ELT-TYPE", SI_ORDINARY, si_size_of_foreign_elt_type, 1, OBJNULL},
{SYS_ "ALIGNMENT-OF-FOREIGN-ELT-TYPE", SI_ORDINARY, si_alignment_of_foreign_elt_type, 1, OBJNULL},
{KEY_ "BYTE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CHAR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CSFLOAT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CDFLOAT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CLFLOAT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CSTRING", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "DOUBLE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FIXNUM", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FLOAT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INT8-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INT16-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INT32-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "INT64-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LONG", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LONG-DOUBLE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LONG-LONG", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "POINTER-SELF", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "POINTER-VOID", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SHORT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "STRUCT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNION", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "VOID", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UINT8-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UINT16-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UINT32-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UINT64-T", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSIGNED-BYTE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSIGNED-CHAR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSIGNED-INT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSIGNED-LONG", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSIGNED-LONG-LONG", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNSIGNED-SHORT", KEYWORD, NULL, -1, OBJNULL},

#ifdef GBC_BOEHM
{EXT_ "GC", EXT_ORDINARY, si_gc, -1, OBJNULL},
{SYS_ "GC-DUMP", SI_ORDINARY, si_gc_dump, 0, OBJNULL},
{SYS_ "GC-STATS", SI_ORDINARY, si_gc_stats, 1, OBJNULL},
#else
{EXT_ "GC", EXT_ORDINARY, si_gc, -2, OBJNULL},
{SYS_ "ALLOCATE", SI_ORDINARY, si_allocate, -3, OBJNULL},
{SYS_ "ALLOCATED-PAGES", SI_ORDINARY, si_allocated_pages, -2, OBJNULL},
{SYS_ "MAXIMUM-ALLOCATABLE-PAGES", SI_ORDINARY, si_maximum_allocatable_pages, -2, OBJNULL},
{SYS_ "ALLOCATE-CONTIGUOUS-PAGES", SI_ORDINARY, si_allocate_contiguous_pages, -2, OBJNULL},
{SYS_ "ALLOCATED-CONTIGUOUS-PAGES", SI_ORDINARY, si_allocated_contiguous_pages, -1, OBJNULL},
{SYS_ "MAXIMUM-CONTIGUOUS-PAGES", SI_ORDINARY, si_maximum_contiguous_pages, -1, OBJNULL},
{SYS_ "GC-TIME", SI_ORDINARY, si_gc_time, -1, OBJNULL},
{SYS_ "GET-HOLE-SIZE", SI_ORDINARY, si_get_hole_size, -1, OBJNULL},
{SYS_ "SET-HOLE-SIZE", SI_ORDINARY, si_set_hole_size, -2, OBJNULL},
{SYS_ "IGNORE-MAXIMUM-PAGES", SI_ORDINARY, si_ignore_maximum_pages, -1, OBJNULL},
{SYS_ "ROOM-REPORT", SI_ORDINARY, si_room_report, -1, OBJNULL},
{SYS_ "RESET-GC-COUNT", SI_ORDINARY, si_reset_gc_count, -1, OBJNULL},
#endif /* !GBC_BOEHM */

/* #ifdef ECL_THREADS */
{MP_ "PROCESS", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "LOCK", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "CONDITION-VARIABLE", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "*CURRENT-PROCESS*", MP_SPECIAL, NULL, -1, OBJNULL},
{MP_ "ALL-PROCESSES", MP_ORDINARY, IF_MP(mp_all_processes), 0, OBJNULL},
{MP_ "EXIT-PROCESS", MP_ORDINARY, IF_MP(mp_exit_process), 0, OBJNULL},
{MP_ "MAKE-PROCESS", MP_ORDINARY, IF_MP(mp_make_process), -1, OBJNULL},
{MP_ "PROCESS-ACTIVE-P", MP_ORDINARY, IF_MP(mp_process_active_p), 1, OBJNULL},
{MP_ "PROCESS-ENABLE", MP_ORDINARY, IF_MP(mp_process_enable), 1, OBJNULL},
{MP_ "PROCESS-YIELD", MP_ORDINARY, IF_MP(mp_process_yield), 0, OBJNULL},
{MP_ "PROCESS-KILL", MP_ORDINARY, IF_MP(mp_process_kill), 1, OBJNULL},
{MP_ "PROCESS-NAME", MP_ORDINARY, IF_MP(mp_process_name), 1, OBJNULL},
{MP_ "PROCESS-PRESET", MP_ORDINARY, IF_MP(mp_process_preset), -3, OBJNULL},
{MP_ "PROCESS-RUN-FUNCTION", MP_ORDINARY, IF_MP(mp_process_run_function), -3, OBJNULL},
{MP_ "PROCESS-WHOSTATE", MP_ORDINARY, IF_MP(mp_process_whostate), 1, OBJNULL},
{MP_ "PROCESS-JOIN", MP_ORDINARY, IF_MP(mp_process_join), 1, OBJNULL},
{MP_ "MAKE-LOCK", MP_ORDINARY, IF_MP(mp_make_lock), -1, OBJNULL},
{KEY_ "RECURSIVE", KEYWORD, NULL, -1, OBJNULL},
{MP_ "RECURSIVE-LOCK-P", MP_ORDINARY, IF_MP(mp_recursive_lock_p), 1, OBJNULL},
{MP_ "HOLDING-LOCK-P", MP_ORDINARY, IF_MP(mp_holding_lock_p), 1, OBJNULL},
{MP_ "LOCK-NAME", MP_ORDINARY, IF_MP(mp_lock_name), 1, OBJNULL},
{MP_ "LOCK-OWNER", MP_ORDINARY, IF_MP(mp_lock_owner), 1, OBJNULL},
{MP_ "LOCK-COUNT", MP_ORDINARY, IF_MP(mp_lock_count), 1, OBJNULL},
{MP_ "GET-LOCK", MP_ORDINARY, IF_MP(mp_get_lock), -2, OBJNULL},
{MP_ "GIVEUP-LOCK", MP_ORDINARY, IF_MP(mp_giveup_lock), 1, OBJNULL},
{MP_ "MAKE-CONDITION-VARIABLE", MP_ORDINARY, IF_MP(mp_make_condition_variable), 0, OBJNULL},
{MP_ "CONDITION-VARIABLE-WAIT", MP_ORDINARY, IF_MP(mp_condition_variable_wait), 2, OBJNULL},
{MP_ "CONDITION-VARIABLE-TIMEDWAIT", MP_ORDINARY, IF_MP(mp_condition_variable_timedwait), 3, OBJNULL},
{MP_ "CONDITION-VARIABLE-SIGNAL", MP_ORDINARY, IF_MP(mp_condition_variable_signal), 1, OBJNULL},
{MP_ "CONDITION-VARIABLE-BROADCAST", MP_ORDINARY, IF_MP(mp_condition_variable_broadcast), 1, OBJNULL},
{KEY_ "INITIAL-BINDINGS", KEYWORD, NULL, -1, OBJNULL},
{MP_ "INTERRUPT-PROCESS", MP_ORDINARY, IF_MP(mp_interrupt_process), 2, OBJNULL},
{MP_ "+LOAD-COMPILE-LOCK+", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "WITH-LOCK", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "WITH-RWLOCK", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "BLOCK-SIGNALS", MP_ORDINARY, IF_MP(mp_block_signals), 0, OBJNULL},
{MP_ "RESTORE-SIGNALS", MP_ORDINARY, IF_MP(mp_restore_signals), 1, OBJNULL},
{MP_ "PROCESS-SUSPEND", MP_ORDINARY, IF_MP(mp_process_suspend), 1, OBJNULL},
{MP_ "PROCESS-RESUME", MP_ORDINARY, IF_MP(mp_process_resume), 1, OBJNULL},
{MP_ "SUSPEND-LOOP", MP_ORDINARY, IF_MP(mp_suspend_loop), 0, OBJNULL},
{MP_ "BREAK-SUSPEND-LOOP", MP_ORDINARY, IF_MP(mp_break_suspend_loop), 0, OBJNULL},
{MP_ "MAKE-RWLOCK", MP_ORDINARY, IF_MP(mp_make_rwlock), -1, OBJNULL},
{MP_ "RWLOCK", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "RWLOCK-NAME", MP_ORDINARY, IF_MP(mp_rwlock_name), 1, OBJNULL},
{MP_ "GET-RWLOCK-READ", MP_ORDINARY, IF_MP(mp_get_rwlock_read), -2, OBJNULL},
{MP_ "GET-RWLOCK-WRITE", MP_ORDINARY, IF_MP(mp_get_rwlock_write), -2, OBJNULL},
{MP_ "GIVEUP-RWLOCK-READ", MP_ORDINARY, IF_MP(mp_giveup_rwlock_read), 1, OBJNULL},
{MP_ "GIVEUP-RWLOCK-WRITE", MP_ORDINARY, IF_MP(mp_giveup_rwlock_write), 1, OBJNULL},
{MP_ "GLOBAL-LOCK", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "ERROR-LOCK", MP_ORDINARY, NULL, -1, OBJNULL},

{MP_ "SEMAPHORE", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "MAKE-SEMAPHORE", MP_ORDINARY, IF_MP(mp_make_semaphore), -1, OBJNULL},
{MP_ "SIGNAL-SEMAPHORE", MP_ORDINARY, IF_MP(mp_signal_semaphore), -2, OBJNULL},
{MP_ "WAIT-ON-SEMAPHORE", MP_ORDINARY, IF_MP(mp_wait_on_semaphore), 1, OBJNULL},
{MP_ "TRY-GET-SEMAPHORE", MP_ORDINARY, IF_MP(mp_try_get_semaphore), 1, OBJNULL},
{MP_ "SEMAPHORE-COUNT", MP_ORDINARY, IF_MP(mp_semaphore_count), 1, OBJNULL},
{MP_ "SEMAPHORE-NAME", MP_ORDINARY, IF_MP(mp_semaphore_name), 1, OBJNULL},
{MP_ "SEMAPHORE-WAIT-COUNT", MP_ORDINARY, IF_MP(mp_semaphore_wait_count), 1, OBJNULL},
{KEY_ "COUNT", KEYWORD, NULL, -1, OBJNULL},

{MP_ "BARRIER", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "MAKE-BARRIER", MP_ORDINARY, IF_MP(mp_make_barrier), -2, OBJNULL},
{MP_ "BARRIER-UNBLOCK", MP_ORDINARY, IF_MP(mp_barrier_unblock), -2, OBJNULL},
{MP_ "BARRIER-WAIT", MP_ORDINARY, IF_MP(mp_barrier_wait), 1, OBJNULL},
{MP_ "BARRIER-COUNT", MP_ORDINARY, IF_MP(mp_barrier_count), 1, OBJNULL},
{MP_ "BARRIER-NAME", MP_ORDINARY, IF_MP(mp_barrier_name), 1, OBJNULL},
{MP_ "BARRIER-ARRIVERS-COUNT", MP_ORDINARY, IF_MP(mp_barrier_arrivers_count), 1, OBJNULL},
{KEY_ "DISABLE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RESET-COUNT", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "KILL-WAITING", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNBLOCKED", KEYWORD, NULL, -1, OBJNULL},

{MP_ "MAILBOX", MP_ORDINARY, NULL, -1, OBJNULL},
{MP_ "MAKE-MAILBOX", MP_ORDINARY, IF_MP(mp_make_mailbox), -1, OBJNULL},
{MP_ "MAILBOX-NAME", MP_ORDINARY, IF_MP(mp_mailbox_name), 1, OBJNULL},
{MP_ "MAILBOX-COUNT", MP_ORDINARY, IF_MP(mp_mailbox_count), 1, OBJNULL},
{MP_ "MAILBOX-EMPTY-P", MP_ORDINARY, IF_MP(mp_mailbox_empty_p), 1, OBJNULL},
{MP_ "MAILBOX-READ", MP_ORDINARY, IF_MP(mp_mailbox_read), 1, OBJNULL},
{MP_ "MAILBOX-TRY-READ", MP_ORDINARY, IF_MP(mp_mailbox_try_read), 1, OBJNULL},
{MP_ "MAILBOX-SEND", MP_ORDINARY, IF_MP(mp_mailbox_send), 2, OBJNULL},
{MP_ "MAILBOX-TRY-SEND", MP_ORDINARY, IF_MP(mp_mailbox_try_send), 2, OBJNULL},
{MP_ "COMPARE-AND-SWAP-CAR", MP_ORDINARY, IF_MP(mp_compare_and_swap_car), 3, OBJNULL},
{MP_ "COMPARE-AND-SWAP-CDR", MP_ORDINARY, IF_MP(mp_compare_and_swap_cdr), 3, OBJNULL},
{MP_ "COMPARE-AND-SWAP-SYMBOL-PLIST", MP_ORDINARY, IF_MP(mp_compare_and_swap_symbol_plist), 3, OBJNULL},
{MP_ "COMPARE-AND-SWAP-SYMBOL-VALUE", MP_ORDINARY, IF_MP(mp_compare_and_swap_symbol_value), 3, OBJNULL},
{MP_ "COMPARE-AND-SWAP-SVREF", MP_ORDINARY, IF_MP(mp_compare_and_swap_svref), 4, OBJNULL},
{MP_ "COMPARE-AND-SWAP-INSTANCE", MP_ORDINARY, IF_MP(mp_compare_and_swap_instance), 4, OBJNULL},
{MP_ "COMPARE-AND-SWAP-STRUCTURE", MP_ORDINARY, IF_MP(mp_compare_and_swap_structure), 5, OBJNULL},
{MP_ "ATOMIC-INCF-CAR", MP_ORDINARY, IF_MP(mp_atomic_incf_car), 2, OBJNULL},
{MP_ "ATOMIC-INCF-CDR", MP_ORDINARY, IF_MP(mp_atomic_incf_cdr), 2, OBJNULL},
{MP_ "ATOMIC-INCF-SYMBOL-VALUE", MP_ORDINARY, IF_MP(mp_atomic_incf_symbol_value), 2, OBJNULL},
{MP_ "ATOMIC-INCF-SVREF", MP_ORDINARY, IF_MP(mp_atomic_incf_svref), 3, OBJNULL},
{MP_ "ATOMIC-INCF-INSTANCE", MP_ORDINARY, IF_MP(mp_atomic_incf_instance), 3, OBJNULL},
{MP_ "DEFINE-CAS-EXPANDER", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "DEFCAS", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "REMCAS", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "GET-CAS-EXPANSION", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "COMPARE-AND-SWAP", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "ATOMIC-UPDATE", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "ATOMIC-PUSH", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "ATOMIC-POP", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "ATOMIC-INCF", MP_CONSTANT, NULL, -1, OBJNULL},
{MP_ "ATOMIC-DECF", MP_CONSTANT, NULL, -1, OBJNULL},
/* #endif defined(ECL_THREADS) */

{SYS_ "WHILE", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNTIL", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "QUASIQUOTE", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "*EXIT-HOOKS*", SI_SPECIAL, NULL, -1, ECL_NIL},

{CLOS_ ".COMBINED-METHOD-ARGS.", CLOS_SPECIAL, NULL, -1, ECL_NIL},
{CLOS_ "+BUILTIN-CLASSES+", CLOS_ORDINARY, NULL, -1, ECL_NIL},
{CLOS_ "*NEXT-METHODS*", CLOS_SPECIAL, NULL, -1, ECL_NIL},
{CLOS_ "*OPTIMIZE-SLOT-ACCESS*", CLOS_SPECIAL, NULL, -1, ECL_T},
{CLOS_ "+THE-T-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL},
{CLOS_ "+THE-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL},
{CLOS_ "+THE-STD-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL},
{CLOS_ "+THE-STANDARD-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL},
{CLOS_ "+THE-FUNCALLABLE-STANDARD-CLASS+", CLOS_ORDINARY, NULL, -1, ECL_NIL},
{CLOS_ "ACCESSOR-METHOD-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "ADD-DEPENDENT", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "ADD-DIRECT-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "ADD-DIRECT-SUBCLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-DEFAULT-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-DIRECT-DEFAULT-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-DIRECT-SLOTS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-DIRECT-SUBCLASSES", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-DIRECT-SUPERCLASSES", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-FINALIZED-P", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-PRECEDENCE-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-PROTOTYPE", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "CLASS-SLOTS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-APPLICABLE-METHODS-USING-CLASSES", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-CLASS-PRECEDENCE-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-DEFAULT-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-DISCRIMINATING-FUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-EFFECTIVE-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-EFFECTIVE-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "COMPUTE-SLOTS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "DIRECT-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "DIRECT-SLOT-DEFINITION-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "EFFECTIVE-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "EFFECTIVE-SLOT-DEFINITION-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "ENSURE-CLASS", CLOS_ORDINARY, ECL_NAME(clos_ensure_class), -2, OBJNULL},
{CLOS_ "ENSURE-CLASS-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "ENSURE-GENERIC-FUNCTION-USING-CLASS", CLOS_ORDINARY, NULL, -3, OBJNULL},
{CLOS_ "EQL-SPECIALIZER", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "EQL-SPECIALIZER-OBJECT", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "EXTRACT-LAMBDA-LIST", CLOS_ORDINARY, ECL_NAME(clos_extract_lambda_list), 1, OBJNULL},
{CLOS_ "EXTRACT-SPECIALIZER-NAMES", CLOS_ORDINARY, ECL_NAME(clos_extract_specializer_names), 1, OBJNULL},
{CLOS_ "FINALIZE-INHERITANCE", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "FIND-METHOD-COMBINATION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "FORWARD-REFERENCED-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "FUNCALLABLE-STANDARD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "FUNCALLABLE-STANDARD-INSTANCE-ACCESS", CLOS_ORDINARY, ECL_NAME(clos_funcallable_standard_instance_access), 2, OBJNULL},
{CLOS_ "FUNCALLABLE-STANDARD-OBJECT", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-DECLARATIONS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-LAMBDA-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-METHOD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-METHOD-COMBINATION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-METHODS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "GENERIC-FUNCTION-NAME", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "INTERN-EQL-SPECIALIZER", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "LOCATION-TABLE", CLOS_ORDINARY | PRIVATE, NULL, -1, OBJNULL},
{CLOS_ "MAKE-METHOD-LAMBDA", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "MAP-DEPENDENTS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "METAOBJECT", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "METHOD-FUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "METHOD-GENERIC-FUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "METHOD-LAMBDA-LIST", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "METHOD-SPECIALIZERS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "NAME", CLOS_ORDINARY | PRIVATE, NULL, -1, OBJNULL},
{CLOS_ "READER-METHOD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "REMOVE-DEPENDENT", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "REMOVE-DIRECT-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "REMOVE-DIRECT-SUBCLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SET-FUNCALLABLE-INSTANCE-FUNCTION", CLOS_ORDINARY, clos_set_funcallable_instance_function, 2, OBJNULL},
{CLOS_ "SLOT-BOUNDP-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-ALLOCATION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-INITARGS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-INITFORM", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-INITFUNCTION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-LOCATION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-NAME", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-READERS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-TYPE", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-DEFINITION-WRITERS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-MAKUNBOUND-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-VALUE-USING-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SLOT-VALUE-SET", CLOS_ORDINARY, clos_slot_value_set, 3, OBJNULL},
{CLOS_ "SLOT-TABLE", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SPECIALIZER", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SPECIALIZER-DIRECT-METHODS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-ACCESSOR-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-DIRECT-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-EFFECTIVE-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-INSTANCE-ACCESS", CLOS_ORDINARY, ECL_NAME(clos_standard_instance_access), 2, OBJNULL},
{CLOS_ "STANDARD-INSTANCE-SET", CLOS_ORDINARY, ECL_NAME(clos_standard_instance_set), 3, OBJNULL},
{CLOS_ "STANDARD-READER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-SLOT-DEFINITION", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-WRITER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-OPTIMIZED-READER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STANDARD-OPTIMIZED-WRITER-METHOD", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "STD-COMPUTE-APPLICABLE-METHODS", CLOS_ORDINARY, ECL_NAME(clos_std_compute_applicable_methods), 2, OBJNULL},
{CLOS_ "STD-COMPUTE-APPLICABLE-METHODS-USING-CLASSES", CLOS_ORDINARY, NULL, 2, OBJNULL},
{CLOS_ "STD-COMPUTE-EFFECTIVE-METHOD", CLOS_ORDINARY, ECL_NAME(clos_std_compute_effective_method), 3, OBJNULL},
{CLOS_ "COMPUTE-EFFECTIVE-METHOD-FUNCTION", CLOS_ORDINARY, ECL_NAME(clos_compute_effective_method_function), 3, OBJNULL},
{CLOS_ "UPDATE-DEPENDENT", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "UPDATE-INSTANCE", CLOS_ORDINARY, NULL, 1, OBJNULL},
{CLOS_ "VALIDATE-SUPERCLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "WRITER-METHOD-CLASS", CLOS_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "CLEAR-GFUN-HASH", SI_ORDINARY, si_clear_gfun_hash, 1, OBJNULL},
{CLOS_ "LOAD-DEFCLASS", CLOS_ORDINARY, ECL_NAME(clos_load_defclass), 4, OBJNULL},
{CLOS_ "DOCSTRING", CLOS_ORDINARY, NULL, -1, OBJNULL},
{CLOS_ "SAFE-INSTANCE-REF", CLOS_ORDINARY, clos_safe_instance_ref, 2, OBJNULL},

{SYS_ "CL-FIXNUM-BITS", SI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_FIXNUM_BITS)},
{EXT_ "CL-FIXNUM", EXT_ORDINARY, NULL, -1, NULL},
{EXT_ "CL-INDEX", EXT_ORDINARY, NULL, -1, NULL},

{SYS_ "DO-DEFTYPE", SI_ORDINARY, ECL_NAME(si_do_deftype), -4, OBJNULL},
{SYS_ "CREATE-TYPE-NAME", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "*ALIEN-DECLARATIONS*", SI_SPECIAL, NULL, -1, ECL_NIL},

#ifdef ENABLE_DLOPEN
{SYS_ "LOAD-BINARY", SI_ORDINARY, si_load_binary, 4, OBJNULL},
#else
{SYS_ "LOAD-BINARY", SI_ORDINARY, NULL, -1, OBJNULL},
#endif

{SYS_ "*CODE-WALKER*", SI_SPECIAL, NULL, -1, OBJNULL},

/* #if defined(HAVE_LIBFFI) */
{SYS_ "CALL-CFUN", SI_ORDINARY, IF_DFFI(si_call_cfun), -5, OBJNULL},
{KEY_ "CALLBACK", KEYWORD, NULL, -1, OBJNULL},
{SYS_ "MAKE-DYNAMIC-CALLBACK", SI_ORDINARY, IF_DFFI(si_make_dynamic_callback), -5, OBJNULL},
{SYS_ "FREE-FFI-CLOSURE", SI_ORDINARY, IF_DFFI(si_free_ffi_closure), 1, OBJNULL},
/* #endif defined(HAVE_LIBFFI) */

{EXT_ "TRAP-FPE", EXT_ORDINARY, si_trap_fpe, 2, OBJNULL},

{EXT_ "*ACTION-ON-UNDEFINED-VARIABLE*", EXT_SPECIAL, NULL, -1, ECL_NIL},

{EXT_ "SET-BUFFERING-MODE", EXT_ORDINARY, si_set_buffering_mode, 2, OBJNULL},
{KEY_ "NONE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LINE-BUFFERED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FULLY-BUFFERED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LINE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "FULL", KEYWORD, NULL, -1, OBJNULL},

{SYS_ "CMP-ENV-REGISTER-MACROLET", SI_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "GET-FINALIZER", EXT_ORDINARY, si_get_finalizer, 1, OBJNULL},
{EXT_ "SET-FINALIZER", EXT_ORDINARY, si_set_finalizer, 2, OBJNULL},

{SYS_ "WRONG-TYPE-ARGUMENT", SI_ORDINARY, si_wrong_type_argument, -3, OBJNULL},

{SYS_ "*CURRENT-FORM*", SI_SPECIAL, NULL, -1, OBJNULL},

{SYS_ "CODE-BLOCK", SI_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "FRAME", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "APPLY-FROM-STACK-FRAME", SI_ORDINARY, si_apply_from_stack_frame, 2, OBJNULL},

#ifdef ECL_CLOS_STREAMS
{GRAY_ "CLOSE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAMP", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "INPUT-STREAM-P", GRAY_ORDINARY, NULL, 1, OBJNULL},
{GRAY_ "OUTPUT-STREAM-P", GRAY_ORDINARY, NULL, 1, OBJNULL},
{GRAY_ "OPEN-STREAM-P", GRAY_ORDINARY, NULL, 1, OBJNULL},
{GRAY_ "STREAM-ADVANCE-TO-COLUMN", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-CLEAR-INPUT", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-CLEAR-OUTPUT", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-ELEMENT-TYPE", GRAY_ORDINARY, NULL, 1, OBJNULL},
{GRAY_ "STREAM-FILE-DESCRIPTOR", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-FILE-POSITION", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-FINISH-OUTPUT", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-FORCE-OUTPUT", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-FRESH-LINE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-INTERACTIVE-P", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-LINE-COLUMN", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-LISTEN", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-PEEK-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-READ-BYTE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-READ-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-READ-CHAR-NO-HANG", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-READ-LINE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-READ-SEQUENCE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-START-LINE-P", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-TERPRI", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-UNREAD-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-WRITE-BYTE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-WRITE-CHAR", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-WRITE-SEQUENCE", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "STREAM-WRITE-STRING", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-INPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-OUTPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-CHARACTER-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-BINARY-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-CHARACTER-INPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-CHARACTER-OUTPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-BINARY-INPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
{GRAY_ "FUNDAMENTAL-BINARY-OUTPUT-STREAM", GRAY_ORDINARY, NULL, -1, OBJNULL},
#endif /* ECL_CLOS_STREAMS */

{SYS_ "LOG1P", SI_ORDINARY, si_log1p, 1, OBJNULL},

{EXT_ "BC-FILE", EXT_ORDINARY, si_compiled_function_file, 1, ECL_NIL},
{EXT_ "COMPILED-FUNCTION-FILE", EXT_ORDINARY, si_compiled_function_file, 1, ECL_NIL},

{SYS_ "PROPERTY-LIST", SI_ORDINARY, NULL, 1, OBJNULL},

{SYS_ "BYTECODES", SI_ORDINARY, NULL, 1, OBJNULL},

{SYS_ "HASH-EQL", SI_ORDINARY, si_hash_eql, -1, OBJNULL},
{SYS_ "HASH-EQUAL", SI_ORDINARY, si_hash_equal, -1, OBJNULL},
{SYS_ "HASH-EQUALP", SI_ORDINARY, si_hash_equalp, -1, OBJNULL},

{EXT_ "INTERACTIVE-INTERRUPT", EXT_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "STORAGE-EXHAUSTED", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "STACK-OVERFLOW", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "STACK-OVERFLOW-SIZE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "STACK-OVERFLOW-TYPE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "BINDING-STACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "FRAME-STACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "LISP-STACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "C-STACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "HEAP-SIZE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "ILLEGAL-INSTRUCTION", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "SET-LIMIT", EXT_ORDINARY, si_set_limit, 2, OBJNULL},
{EXT_ "GET-LIMIT", EXT_ORDINARY, si_get_limit, 1, OBJNULL},
{SYS_ "RESET-MARGIN", EXT_ORDINARY, si_reset_margin, 1, OBJNULL},
{EXT_ "SEGMENTATION-VIOLATION", EXT_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "EXTENDED-STRING", EXT_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "CHECK-PENDING-INTERRUPTS", SI_ORDINARY, si_check_pending_interrupts, 0, OBJNULL},

{KEY_ "LATIN-1", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "ISO-8859-1", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UTF-8", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UCS-2", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UCS-4", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "CONSTANTLY-T", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CONSTANTLY-NIL", EXT_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "MAYBE-QUOTE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "MAYBE-UNQUOTE", EXT_ORDINARY, NULL, -1, OBJNULL},

{KEY_ "CR", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LF", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "CRLF", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UCS-2BE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UCS-4BE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UCS-2LE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UCS-4LE", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "LOAD-ENCODING", EXT_ORDINARY, ECL_NAME(si_load_encoding), 1, OBJNULL},
{EXT_ "MAKE-ENCODING", EXT_ORDINARY, ECL_NAME(si_make_encoding), 1, OBJNULL},
{EXT_ "ALL-ENCODINGS", EXT_ORDINARY, NULL, -1, OBJNULL},

{KEY_ "US-ASCII", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "LITTLE-ENDIAN", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "BIG-ENDIAN", KEYWORD, NULL, -1, OBJNULL},

{SYS_ "+UNICODE-DATABASE+", SI_CONSTANT, NULL, -1, ECL_NIL},

{EXT_ "COPY-FILE", EXT_ORDINARY, si_copy_file, 2, OBJNULL},

{EXT_ "FILL-ARRAY-WITH-ELT", EXT_ORDINARY, si_fill_array_with_elt, 4, OBJNULL},

{EXT_ "+ECL-VERSION-NUMBER+", EXT_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_VERSION_NUMBER)},

{EXT_ "*BYTECODES-COMPILER*", EXT_SPECIAL, NULL, -1, ECL_NIL},

#ifdef ECL_IEEE_FP
{SYS_ "NAN", EXT_ORDINARY, si_nan, 0, OBJNULL},

{EXT_ "SHORT-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "SINGLE-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "DOUBLE-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "LONG-FLOAT-POSITIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},

{EXT_ "SHORT-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "SINGLE-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "DOUBLE-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "LONG-FLOAT-NEGATIVE-INFINITY", EXT_CONSTANT, NULL, -1, OBJNULL},
#endif /* ECL_IEEE_FP */

{EXT_ "FLOAT-NAN-P", EXT_ORDINARY, si_float_nan_p, 1, OBJNULL},
{EXT_ "FLOAT-INFINITY-P", EXT_ORDINARY, si_float_infinity_p, 1, OBJNULL},
{EXT_ "FLOAT-NAN-STRING", EXT_ORDINARY, NULL, 1, OBJNULL},
{EXT_ "FLOAT-INFINITY-STRING", EXT_ORDINARY, NULL, 1, OBJNULL},

{SYS_ "READ-OBJECT-OR-IGNORE", EXT_ORDINARY, si_read_object_or_ignore, 2, OBJNULL},

{EXT_ "READTABLE-LOCK", EXT_ORDINARY, si_readtable_lock, -2, OBJNULL},

{SYS_ "+IO-SYNTAX-PROGV-LIST+", SI_CONSTANT, NULL, -1, OBJNULL},
{SYS_ "+ECL-SYNTAX-PROGV-LIST+", SI_CONSTANT, NULL, -1, OBJNULL},
{SYS_ "WITH-ECL-IO-SYNTAX", SI_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "STREAM-EXTERNAL-FORMAT-SET", SI_ORDINARY, si_stream_external_format_set, 2, OBJNULL},

{KEY_ "CDECL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EABI", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "GNUW64", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "STDCALL", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SYSV", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNIX", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "UNIX64", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "VFP", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WIN64", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "WEAK-POINTER", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "MAKE-WEAK-POINTER", EXT_ORDINARY, si_make_weak_pointer, 1, OBJNULL},
{EXT_ "WEAK-POINTER-VALUE", EXT_ORDINARY, si_weak_pointer_value, 1, OBJNULL},

{SYS_ "*ALLOW-WITH-INTERRUPTS*", SI_SPECIAL, NULL, -1, ECL_T},

/* conveniance macros from CMU util */
{EXT_ "ONCE-ONLY", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "COLLECT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "WITH-UNIQUE-NAMES", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "WITH-GENSYMS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "WITH-CLEAN-SYMBOLS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "IF-LET", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "WHEN-LET", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "WHEN-LET*", EXT_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "HANDLE-SIGNAL", SI_ORDINARY, si_handle_signal, 2, OBJNULL},

{EXT_ "WITH-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "WITHOUT-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "WITH-RESTORED-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "WITH-LOCAL-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL},
{EXT_ "ALLOW-WITH-INTERRUPTS", MP_CONSTANT, NULL, -1, OBJNULL},

{SYS_ "*QUIT-TAG*", SI_SPECIAL, NULL, -1, OBJNULL},

{EXT_ "ARRAY-RAW-DATA", EXT_ORDINARY, si_array_raw_data, 1, OBJNULL},

{EXT_ "*PROGRAM-EXIT-CODE*", EXT_SPECIAL, NULL, -1, ecl_make_fixnum(0)},
{EXT_ "EXIT", EXT_ORDINARY, si_exit, -1, OBJNULL},

{EXT_ "ENVIRON", EXT_ORDINARY, si_environ, 0, OBJNULL},

{KEY_ "ENVIRON", KEYWORD, NULL, -1, OBJNULL},

/* external-process extension */
{EXT_ "RUN-PROGRAM", EXT_ORDINARY, ECL_NAME(si_run_program), -3, OBJNULL},

{EXT_ "MAKE-EXTERNAL-PROCESS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS-PID", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS-INPUT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS-OUTPUT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS-ERROR-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS-STATUS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EXTERNAL-PROCESS-WAIT", EXT_ORDINARY, NULL, -2, OBJNULL},
{EXT_ "TERMINATE-PROCESS", EXT_ORDINARY, ECL_NAME(si_terminate_process), -2, OBJNULL},

{KEY_ "RUNNING", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "EXITED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "SIGNALED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "STOPPED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "RESUMED", KEYWORD, NULL, -1, OBJNULL},
/* ~ external-process extension */

/* unixsys.d */
{SYS_ "WAITPID", SI_ORDINARY, si_waitpid, 2, OBJNULL},
#if !defined(ECL_MS_WINDOWS_HOST)
{SYS_ "KILLPID", SI_ORDINARY, si_killpid, 2, OBJNULL},
#else
{SYS_ "KILLPID", SI_ORDINARY, NULL, 2, OBJNULL},
#endif
{SYS_ "RUN-PROGRAM-INNER", SI_ORDINARY, si_run_program_inner, 4, OBJNULL},
{SYS_ "SPAWN-SUBPROCESS", SI_ORDINARY, si_spawn_subprocess, 6, OBJNULL},
#if defined(ECL_MS_WINDOWS_HOST)
{SYS_ "CLOSE-WINDOWS-HANDLE", SI_ORDINARY, si_close_windows_handle, 1, OBJNULL},
#else
{SYS_ "CLOSE-WINDOWS-HANDLE", SI_ORDINARY, NULL, -1, OBJNULL},
#endif
/* ~ */

{EXT_ "*INVOKE-DEBUGGER-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL},

{EXT_ "*DOCUMENTATION-POOL*", EXT_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "ANNOTATE", EXT_ORDINARY, NULL, -1, ECL_NIL},
{EXT_ "GET-ANNOTATION", EXT_ORDINARY, NULL, -1, ECL_NIL},
{EXT_ "REMOVE-ANNOTATION", EXT_ORDINARY, NULL, -1, ECL_NIL},
{EXT_ "FUNCTION-LAMBDA-LIST", EXT_ORDINARY, NULL, -1, ECL_NIL},
{EXT_ "DEFAULT-ANNOTATION-LOGIC", EXT_ORDINARY, NULL, -1, ECL_NIL},
{EXT_ "OPTIONAL-ANNOTATION", EXT_ORDINARY, NULL, -1, ECL_NIL},
{EXT_ "LOCATION", EXT_ORDINARY, NULL, -1, ECL_NIL},

{EXT_ "LISP-IMPLEMENTATION-VCS-ID", EXT_ORDINARY, ECL_NAME(si_lisp_implementation_vcs_id), 0, ECL_NIL},

{SYS_ "SIGNAL-SERVICING", SI_ORDINARY, NULL, -1, ECL_NIL},

{EXT_ "*DEFAULT-EXTERNAL-FORMAT*", EXT_SPECIAL, NULL, -1, ECL_T},
{KEY_ "PASS-THROUGH", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "WITH-BACKEND", EXT_ORDINARY, NULL, -1, OBJNULL},
{KEY_ "BYTECODES", KEYWORD, NULL, 1, OBJNULL},
{KEY_ "C/C++", KEYWORD, NULL, 1, OBJNULL},

{EXT_ "ARRAY-INDEX", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "ANSI-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "VIRTUAL-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "COMPLEX-ARRAY", EXT_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "SEQUENCE-START-END", SI_ORDINARY, si_sequence_start_end, 4, OBJNULL},
{SYS_ "SEQUENCE-COUNT", SI_ORDINARY, ECL_NAME(si_sequence_count), 1, OBJNULL},
{SYS_ "SHRINK-VECTOR", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "COPY-SUBARRAY", SI_ORDINARY, si_copy_subarray, 5, OBJNULL},

{SYS_ "CONS-CAR", SI_ORDINARY, cl_car, 1, OBJNULL},
{SYS_ "CONS-CDR", SI_ORDINARY, cl_cdr, 1, OBJNULL},

{EXT_ "COMPILER-TYPECASE", EXT_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "ASSERT-FAILURE", SI_ORDINARY, ECL_NAME(si_assert_failure), -2, OBJNULL},
{SYS_ "CCASE-ERROR", SI_ORDINARY, ECL_NAME(si_ccase_error), 3, OBJNULL},
{SYS_ "ECASE-ERROR", SI_ORDINARY, ECL_NAME(si_ecase_error), 2, OBJNULL},
{SYS_ "ETYPECASE-ERROR", SI_ORDINARY, ECL_NAME(si_etypecase_error), 2, OBJNULL},
{SYS_ "CTYPECASE-ERROR", SI_ORDINARY, ECL_NAME(si_ctypecase_error), 3, OBJNULL},
{SYS_ "DO-CHECK-TYPE", SI_ORDINARY, ECL_NAME(si_do_check_type), 4, OBJNULL},

/* #ifdef ECL_EXTERNALIZABLE */
{SYS_ "SERIALIZE", SI_ORDINARY, IF_EXTERNALIZABLE(si_serialize), 1, OBJNULL},
{SYS_ "DESERIALIZE", SI_ORDINARY, IF_EXTERNALIZABLE(si_deserialize), 1, OBJNULL},
/* #endif */

{EXT_ "ARRAY-ELEMENT-TYPE-BYTE-SIZE", EXT_ORDINARY, si_array_element_type_byte_size, 1, OBJNULL},

/* #ifdef ECL_COMPLEX_FLOAT */
{SYS_ "COMPLEX-FLOAT-P", SI_ORDINARY, IF_COMPLEX_FLOAT(si_complex_float_p), 1, OBJNULL},
{SYS_ "COMPLEX-FLOAT", SI_ORDINARY, IF_COMPLEX_FLOAT(si_complex_float), 2, OBJNULL},
{SYS_ "COMPLEX-SINGLE-FLOAT", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "COMPLEX-DOUBLE-FLOAT", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "COMPLEX-LONG-FLOAT", SI_ORDINARY, NULL, -1, OBJNULL},
/* #endif */

/* #ifdef ECL_SSE2 */
{EXT_ "SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "SSE-PACK-P", EXT_ORDINARY, IF_SSE2(si_sse_pack_p), 1, OBJNULL},
{EXT_ "SSE-PACK-AS-ELT-TYPE", EXT_ORDINARY, IF_SSE2(si_sse_pack_as_elt_type), 2, OBJNULL},
{EXT_ "VECTOR-TO-SSE-PACK", EXT_ORDINARY, IF_SSE2(si_vector_to_sse_pack), 1, OBJNULL},
{EXT_ "SSE-PACK-TO-VECTOR", EXT_ORDINARY, IF_SSE2(si_sse_pack_to_vector), 2, OBJNULL},
{EXT_ "INT-SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "FLOAT-SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "DOUBLE-SSE-PACK", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "SSE-PACK-ELEMENT-TYPE", EXT_ORDINARY, IF_SSE2(si_sse_pack_element_type), 1, OBJNULL},
{EXT_ "*SSE-PACK-PRINT-MODE*", EXT_SPECIAL, NULL, -1, ECL_NIL},
/* #endif ECL_SSE2 */

{EXT_ "UNIX-SIGNAL-RECEIVED", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "UNIX-SIGNAL-RECEIVED-CODE", EXT_ORDINARY, NULL, -1, OBJNULL},
{KEY_ "CODE", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "ASSUME-RIGHT-TYPE", EXT_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "FLOAT-TO-DIGITS", SI_ORDINARY, si_float_to_digits, 4, OBJNULL},
{SYS_ "FLOAT-TO-STRING-FREE", SI_ORDINARY, si_float_to_string_free, 4, OBJNULL},
{SYS_ "INTEGER-TO-STRING", SI_ORDINARY, si_integer_to_string, 5, OBJNULL},

{SYS_ "PRINT-UNREADABLE-OBJECT-FUNCTION", SI_ORDINARY, si_print_unreadable_object_function, 5, OBJNULL},

{EXT_ "DUMP-C-BACKTRACE", EXT_ORDINARY, si_dump_c_backtrace, 1, OBJNULL},

{EXT_ "+PROCESS-STANDARD-INPUT+", EXT_CONSTANT, NULL, -1, ECL_NIL},
{EXT_ "+PROCESS-STANDARD-OUTPUT+", EXT_CONSTANT, NULL, -1, ECL_NIL},
{EXT_ "+PROCESS-ERROR-OUTPUT+", EXT_CONSTANT, NULL, -1, ECL_NIL},

{EXT_ "*HELP-MESSAGE*", EXT_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "*LISP-INIT-FILE-LIST*", EXT_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "+DEFAULT-COMMAND-ARG-RULES+", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "COMMAND-ARGS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "*COMMAND-ARGS*", EXT_SPECIAL, NULL, -1, ECL_NIL},
{EXT_ "PROCESS-COMMAND-ARGS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "*UNPROCESSED-ECL-COMMAND-ARGS*", EXT_SPECIAL, NULL, -1, ECL_NIL},

/* #ifdef ECL_UNICODE */
{KEY_ "OCTETS", KEYWORD, NULL, -1, OBJNULL},
{EXT_ "CHARACTER-CODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHARACTER-CODING-ERROR-EXTERNAL-FORMAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHARACTER-ENCODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHARACTER-ENCODING-ERROR-CODE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHARACTER-DECODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHARACTER-DECODING-ERROR-OCTETS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "STREAM-DECODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "STREAM-ENCODING-ERROR", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "DECODING-ERROR", EXT_ORDINARY, NULL, 3, OBJNULL},
{EXT_ "ENCODING-ERROR", EXT_ORDINARY, NULL, 3, OBJNULL},
/* #endif ECL_UNICODE */

{SYS_ "PROPER-LIST-P", SI_ORDINARY, si_proper_list_p, 1, OBJNULL},
{SYS_ "TRACED-OLD-DEFINITION", SI_ORDINARY, ECL_NAME(si_traced_old_definition), 1, OBJNULL},
{SYS_ "*TRACE-LIST*", SI_SPECIAL, NULL, -1, ECL_NIL},

{SYS_ "FUNCTION-BOUNDARY", SI_ORDINARY, NULL, -1, OBJNULL},
{SYS_ "UNWIND-PROTECT-BOUNDARY", SI_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "*INSPECTOR-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL},

{KEY_ "RESOLVE-SYMLINKS", KEYWORD, NULL, -1, OBJNULL},

{SYS_ "LOAD-BYTECODES", SI_ORDINARY, si_load_bytecodes, 4, OBJNULL},

{KEY_ "SHARED", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "PRIVATE", KEYWORD, NULL, -1, OBJNULL},

{EXT_ "MMAP", EXT_ORDINARY, si_mmap, -2, OBJNULL},
{EXT_ "MUNMAP", EXT_ORDINARY, si_munmap, 1, OBJNULL},
{EXT_ "MMAP-ARRAY", EXT_ORDINARY, si_mmap_array, 1, OBJNULL},

{SYS_ "GET-CDATA", SI_ORDINARY, si_get_cdata, 1, OBJNULL},
{SYS_ "ADD-CDATA", SI_ORDINARY, si_add_cdata, 2, OBJNULL},

/*
 * CDR-5 http://cdr.eurolisp.org/document/5/extra-num-types.html
 */

{EXT_ "NEGATIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-FIXNUM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_negative_fixnum_p), 1, OBJNULL},
{EXT_ "POSITIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_positive_fixnum_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_non_negative_fixnum_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-FIXNUM-P", EXT_ORDINARY, ECL_NAME(si_non_positive_fixnum_p), 1, OBJNULL},

{EXT_ "NEGATIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-INTEGER", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_negative_integer_p), 1, OBJNULL},
{EXT_ "POSITIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_positive_integer_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_non_negative_integer_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-INTEGER-P", EXT_ORDINARY, ECL_NAME(si_non_positive_integer_p), 1, OBJNULL},

{EXT_ "NEGATIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-RATIONAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_negative_rational_p), 1, OBJNULL},
{EXT_ "POSITIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_positive_rational_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_non_negative_rational_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-RATIONAL-P", EXT_ORDINARY, ECL_NAME(si_non_positive_rational_p), 1, OBJNULL},

{EXT_ "NEGATIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-RATIO", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_negative_ratio_p), 1, OBJNULL},
{EXT_ "POSITIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_positive_ratio_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_non_negative_ratio_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-RATIO-P", EXT_ORDINARY, ECL_NAME(si_non_positive_ratio_p), 1, OBJNULL},

{EXT_ "NEGATIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-REAL", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_negative_real_p), 1, OBJNULL},
{EXT_ "POSITIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_positive_real_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_non_negative_real_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-REAL-P", EXT_ORDINARY, ECL_NAME(si_non_positive_real_p), 1, OBJNULL},

{EXT_ "NEGATIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_float_p), 1, OBJNULL},
{EXT_ "POSITIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_float_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_float_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_float_p), 1, OBJNULL},

{EXT_ "NEGATIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-SHORT-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_short_float_p), 1, OBJNULL},
{EXT_ "POSITIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_short_float_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_short_float_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-SHORT-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_short_float_p), 1, OBJNULL},

{EXT_ "NEGATIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-SINGLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_single_float_p), 1, OBJNULL},
{EXT_ "POSITIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_single_float_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_single_float_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-SINGLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_single_float_p), 1, OBJNULL},

{EXT_ "NEGATIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-DOUBLE-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_double_float_p), 1, OBJNULL},
{EXT_ "POSITIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_double_float_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_double_float_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-DOUBLE-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_double_float_p), 1, OBJNULL},

{EXT_ "NEGATIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-NEGATIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NON-POSITIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "POSITIVE-LONG-FLOAT", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "NEGATIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_negative_long_float_p), 1, OBJNULL},
{EXT_ "POSITIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_positive_long_float_p), 1, OBJNULL},
{EXT_ "NON-NEGATIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_negative_long_float_p), 1, OBJNULL},
{EXT_ "NON-POSITIVE-LONG-FLOAT-P", EXT_ORDINARY, ECL_NAME(si_non_positive_long_float_p), 1, OBJNULL},

{EXT_ "ARRAY-INDEX-P", EXT_ORDINARY, ECL_NAME(si_array_index_p), 1, OBJNULL},

{EXT_ "SEQUENCE-STREAM", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "MAKE-SEQUENCE-INPUT-STREAM", EXT_ORDINARY, si_make_sequence_input_stream, -2, OBJNULL},
{EXT_ "MAKE-SEQUENCE-OUTPUT-STREAM", EXT_ORDINARY, si_make_sequence_output_stream, -2, OBJNULL},

{EXT_ "CHMOD", EXT_ORDINARY, si_chmod, 2, OBJNULL},

{SYS_ "MISSING-KEYWORD", SI_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "HASH-TABLE-CONTENT", EXT_ORDINARY, si_hash_table_content, 1, OBJNULL},
{EXT_ "HASH-TABLE-FILL", EXT_ORDINARY, si_hash_table_fill, 2, OBJNULL},

{EXT_ "RANDOM-STATE-ARRAY", EXT_ORDINARY, si_random_state_array, 1, OBJNULL},

{SYS_ "REPORT-FUNCTION", SI_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "DO-DEFSETF", SI_ORDINARY, ECL_NAME(si_do_defsetf), -3, OBJNULL},
{SYS_ "DO-DEFINE-SETF-METHOD", SI_ORDINARY, ECL_NAME(si_do_define_setf_method), 2, OBJNULL},

{SYS_ "SETF-DEFINITION", SI_ORDINARY, ECL_NAME(si_setf_definition), 2, OBJNULL},

{EXT_ "ASSUME-NO-ERRORS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "ASSUME-TYPES-DONT-CHANGE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHECK-ARGUMENTS-TYPE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INLINE-ACCESSORS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INLINE-TYPE-CHECKS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "EVALUATE-FORMS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "TYPE-ASSERTIONS", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHECK-STACK-OVERFLOW", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "ARRAY-BOUNDS-CHECK", EXT_ORDINARY, NULL, -1, OBJNULL},

{KEY_ "VALUE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "KEY-AND-VALUE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "KEY-OR-VALUE", KEYWORD, NULL, -1, OBJNULL},
{KEY_ "WEAKNESS", KEYWORD, NULL, -1, OBJNULL},
{EXT_ "HASH-TABLE-WEAKNESS", EXT_ORDINARY, si_hash_table_weakness, 1, OBJNULL},
{KEY_ "SYNCHRONIZED", KEYWORD, NULL, -1, OBJNULL},
{EXT_ "HASH-TABLE-SYNCHRONIZED-P", EXT_ORDINARY, si_hash_table_synchronized_p, 1, OBJNULL},

{EXT_ "TRULY-THE", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "CHECKED-VALUE", EXT_ORDINARY, NULL, -1, OBJNULL},

{EXT_ "INSTALL-BYTECODES-COMPILER", EXT_ORDINARY, NULL, -1, OBJNULL},
{EXT_ "INSTALL-C-COMPILER", EXT_ORDINARY, NULL, -1, OBJNULL},

{FFI_ "C-CHAR-BIT", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_BIT)},
{FFI_ "C-CHAR-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_MAX)},
{FFI_ "C-CHAR-MIN", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_MIN)},
{FFI_ "C-INT-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
{FFI_ "C-INT-MIN", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
{FFI_ "C-SHORT-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(SHRT_MAX)},
{FFI_ "C-SHORT-MIN", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(SHRT_MIN)},
{FFI_ "C-LONG-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
{FFI_ "C-LONG-MIN", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
{FFI_ "C-LONG-LONG-MAX",FFI_CONSTANT,NULL,-1,OBJNULL}, /* See main.d */
{FFI_ "C-UCHAR-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(UCHAR_MAX)},
{FFI_ "C-UINT-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
{FFI_ "C-USHORT-MAX", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(USHRT_MAX)},
{FFI_ "C-ULONG-MAX", FFI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
{FFI_ "C-ULONG-LONG-MAX",FFI_CONSTANT,NULL,-1,OBJNULL}, /* See main.d */
#ifdef ecl_long_long_t
{FFI_ "C-LONG-LONG-BIT", FFI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_LONG_LONG_BITS)},
#else
{FFI_ "C-LONG-LONG-BIT", FFI_CONSTANT, NULL, -1, OBJNULL},
#endif

{FFI_ "*USE-DFFI*", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "+NULL-CSTRING-POINTER+", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "ALLOCATE-FOREIGN-OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "ALLOCATE-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "C-INLINE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "C-PROGN", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CALLBACK", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CHAR*", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CHAR-ARRAY-TO-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CLINES", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CONVERT-FROM-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CONVERT-FROM-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CONVERT-TO-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "CONVERT-TO-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-ARRAY", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-ARRAY-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-CONSTANT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-ENUM", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-FOREIGN-TYPE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-FOREIGN-VAR", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-FUNCTION", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-STRUCT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-TYPE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEF-UNION", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEFCALLBACK", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEFCBODY", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEFENTRY", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEFINLINE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEFLA", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEREF-ARRAY", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DEREF-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "DOUBLE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "ENSURE-CHAR-CHARACTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "ENSURE-CHAR-INTEGER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "ENSURE-CHAR-STORABLE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "FIND-FOREIGN-LIBRARY", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "FOREIGN-STRING-LENGTH", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "FREE-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "FREE-FOREIGN-OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "GET-SLOT-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "GET-SLOT-VALUE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "INT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "LOAD-FOREIGN-LIBRARY", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "MAKE-NULL-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "MAKE-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "NULL-CHAR-P", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "POINTER-ADDRESS", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "SIZE-OF-FOREIGN-TYPE", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "VOID", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-CAST-POINTER", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-CSTRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-CSTRINGS", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-FOREIGN-OBJECT", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-FOREIGN-OBJECTS", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-FOREIGN-STRING", FFI_ORDINARY, NULL, -1, OBJNULL},
{FFI_ "WITH-FOREIGN-STRINGS", FFI_ORDINARY, NULL, -1, OBJNULL},

{SYS_ "BIND-SIMPLE-RESTARTS", SI_ORDINARY, ECL_NAME(si_bind_simple_restarts), 2, OBJNULL},
{SYS_ "BIND-SIMPLE-HANDLERS", SI_ORDINARY, ECL_NAME(si_bind_simple_handlers), 2, OBJNULL},
{EXT_ "CONSTANT-FORM-VALUE", EXT_ORDINARY, si_constant_form_value, -2, OBJNULL},
{EXT_ "CONSTANTP-INNER", EXT_ORDINARY, si_constantp_inner, -2, OBJNULL},
{SYS_ "MAKE-BACKQ-VECTOR", SI_ORDINARY, si_make_backq_vector, 3, OBJNULL},

{SYS_ "RATIOP", SI_ORDINARY, ECL_NAME(si_ratiop), 1, OBJNULL},
{SYS_ "SHORT-FLOAT-P", SI_ORDINARY, ECL_NAME(si_short_float_p), 1, OBJNULL},
{SYS_ "SINGLE-FLOAT-P", SI_ORDINARY, ECL_NAME(si_single_float_p), 1, OBJNULL},
{SYS_ "DOUBLE-FLOAT-P", SI_ORDINARY, ECL_NAME(si_double_float_p), 1, OBJNULL},
{SYS_ "LONG-FLOAT-P", SI_ORDINARY, ECL_NAME(si_long_float_p), 1, OBJNULL},

{SYS_ "COPY-HASH-TABLE", SI_ORDINARY, si_copy_hash_table, 1, OBJNULL},

/* Tag for end of list */
{NULL, CL_ORDINARY, NULL, -1, OBJNULL}};
