org.armedbear.lisp.Symbol Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of abcl Show documentation
Show all versions of abcl Show documentation
Common Lisp implementation running on the JVM
/*
* Symbol.java
*
* Copyright (C) 2002-2007 Peter Graves
* $Id$
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* As a special exception, the copyright holders of this library give you
* permission to link this library with independent modules to produce an
* executable, regardless of the license terms of these independent
* modules, and to copy and distribute the resulting executable under
* terms of your choice, provided that you also meet, for each linked
* independent module, the terms and conditions of the license of that
* module. An independent module is a module which is not derived from
* or based on this library. If you modify this library, you may extend
* this exception to your version of the library, but you are not
* obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*/
package org.armedbear.lisp;
import static org.armedbear.lisp.Lisp.*;
public class Symbol extends LispObject implements java.io.Serializable
{
// Bit flags.
private static final int FLAG_SPECIAL = 0x0001;
private static final int FLAG_CONSTANT = 0x0002;
private static final int FLAG_BUILT_IN_FUNCTION = 0x0004;
public static final Symbol addFunction(String name, LispObject obj)
{
Symbol symbol = PACKAGE_CL.internAndExport(name);
symbol.function = obj;
return symbol;
}
public final SimpleString name;
private int hash = -1;
/** To be accessed by LispThread only:
* used to find the index in the LispThread.specials array
*/
transient int specialIndex = LispThread.UNASSIGNED_SPECIAL_INDEX;
private LispObject pkg; // Either a package object or NIL.
private transient LispObject value;
private transient LispObject function;
private transient LispObject propertyList;
private int flags;
// Construct an uninterned symbol.
public Symbol(String s)
{
name = new SimpleString(s);
pkg = NIL;
}
public Symbol(SimpleString string)
{
name = string;
pkg = NIL;
}
public Symbol(String s, Package pkg)
{
name = new SimpleString(s);
this.pkg = pkg;
}
public Symbol(SimpleString string, Package pkg)
{
name = string;
this.pkg = pkg;
}
public Symbol(SimpleString string, int hash, Package pkg)
{
name = string;
this.hash = hash;
this.pkg = pkg;
}
@Override
@SuppressWarnings("FinalizeDeclaration")
protected void finalize() throws Throwable {
try {
if (specialIndex != LispThread.UNASSIGNED_SPECIAL_INDEX)
LispThread.releaseSpecialIndex(this);
} finally {
super.finalize();
}
}
@Override
public LispObject typeOf()
{
if (pkg == PACKAGE_KEYWORD)
return Symbol.KEYWORD;
if (this == T)
return Symbol.BOOLEAN;
return Symbol.SYMBOL;
}
@Override
public LispObject classOf()
{
return BuiltInClass.SYMBOL;
}
@Override
public LispObject getDescription()
{
final LispThread thread = LispThread.currentThread();
final SpecialBindingsMark mark = thread.markSpecialBindings();
thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
try
{
StringBuilder sb = new StringBuilder("The symbol ");
sb.append(name.princToString());
sb.append(" at #x");
sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
if (pkg instanceof Package)
{
sb.append(", an ");
Symbol sym = ((Package)pkg).findExternalSymbol(name);
sb.append(sym == this ? "external" : "internal");
sb.append(" symbol in the ");
sb.append(((Package)pkg).getName());
sb.append(" package");
}
return new SimpleString(sb);
}
finally
{
thread.resetSpecialBindings(mark);
}
}
@Override
public LispObject getParts()
{
LispObject parts = NIL;
parts = parts.push(new Cons("name", name));
parts = parts.push(new Cons("package", pkg));
parts = parts.push(new Cons("value", value));
parts = parts.push(new Cons("function", function));
parts = parts.push(new Cons("plist", propertyList));
parts = parts.push(new Cons("flags", Fixnum.getInstance(flags)));
parts = parts.push(new Cons("hash", Fixnum.getInstance(hash)));
return parts.nreverse();
}
@Override
public LispObject typep(LispObject type)
{
if (type == Symbol.SYMBOL)
return T;
if (type == BuiltInClass.SYMBOL)
return T;
if (type == Symbol.KEYWORD)
return pkg == PACKAGE_KEYWORD ? T : NIL;
if (type == Symbol.BOOLEAN)
return this == T ? T : NIL;
return super.typep(type);
}
@Override
public boolean constantp()
{
return (flags & FLAG_CONSTANT) != 0;
}
@Override
public final LispObject STRING()
{
return name;
}
public final LispObject getPackage()
{
return pkg;
}
public final void setPackage(LispObject obj)
{
pkg = obj;
}
@Override
public final boolean isSpecialOperator()
{
return (function instanceof SpecialOperator);
}
@Override
public final boolean isSpecialVariable()
{
return (flags & FLAG_SPECIAL) != 0;
}
public final void setSpecial(boolean b)
{
if (b)
flags |= FLAG_SPECIAL;
else
flags &= ~FLAG_SPECIAL;
}
public final void initializeSpecial(LispObject value)
{
flags |= FLAG_SPECIAL;
this.value = value;
}
public final boolean isConstant()
{
return (flags & FLAG_CONSTANT) != 0;
}
public final void initializeConstant(LispObject value)
{
flags |= (FLAG_SPECIAL | FLAG_CONSTANT);
this.value = value;
}
public final boolean isBuiltInFunction()
{
return (flags & FLAG_BUILT_IN_FUNCTION) != 0;
}
public final void setBuiltInFunction(boolean b)
{
if (b)
flags |= FLAG_BUILT_IN_FUNCTION;
else
flags &= ~FLAG_BUILT_IN_FUNCTION;
}
public final String getName()
{
return name.getStringValue();
}
public final String getQualifiedName()
{
final String n = name.getStringValue();
if (pkg == NIL)
return("#:".concat(n));
if (pkg == PACKAGE_KEYWORD)
return ":".concat(n);
StringBuilder sb = new StringBuilder(((Package)pkg).getName());
if (((Package)pkg).findExternalSymbol(name) != null)
sb.append(':');
else
sb.append("::");
sb.append(n);
return sb.toString();
}
/** Gets the value associated with the symbol
* as set by SYMBOL-VALUE.
*
* @return The associated value, or null if unbound.
*
* @see Symbol#symbolValue
*/
@Override
public LispObject getSymbolValue()
{
return value;
}
/** Sets the value associated with the symbol
* as if set by SYMBOL-VALUE.
*
* @return The associated value, or null if unbound.
*
* @see Symbol#symbolValue
*/
public final void setSymbolValue(LispObject value)
{
if (isConstant())
// Complement the check already done in SpecialOperators.sf_setq
program_error("Can't change value of constant symbol "
+ princToString() + ".");
this.value = value;
}
public SymbolMacro getSymbolMacro() {
LispObject symbolMacro = get(this, SYMBOL_MACRO, null);
if(symbolMacro instanceof SymbolMacro) {
return (SymbolMacro) symbolMacro;
} else if(symbolMacro != null) {
error(new TypeError("The object " + symbolMacro + " is not a symbol macro"));
}
return null;
}
public void setSymbolMacro(SymbolMacro symbolMacro) {
if(isSpecialVariable()) {
program_error("Symbol " + princToString() + " names a special variable; can't install symbol macro.");
}
put(this, SYMBOL_MACRO, symbolMacro);
}
/** Returns the value associated with this symbol in the current
* thread context when it is treated as a special variable.
*
* A lisp error is thrown if the symbol is unbound.
*
* @return The associated value
*
* @see LispThread#lookupSpecial
* @see Symbol#getSymbolValue()
*
*/
public final LispObject symbolValue()
{
return symbolValue(LispThread.currentThread());
}
/** Returns the value associated with this symbol in the specified
* thread context when it is treated as a special variable.
*
* A lisp error is thrown if the symbol is unbound.
*
* @return The associated value
*
* @see LispThread#lookupSpecial
* @see Symbol#getSymbolValue()
*
*/
public final LispObject symbolValue(LispThread thread)
{
LispObject val = thread.lookupSpecial(this);
if (val != null)
return val;
if (value != null)
return value;
return error(new UnboundVariable(this));
}
/** Returns the value of the symbol in the current thread context;
* if the symbol has been declared special, the value of the innermost
* binding is returned. Otherwise, the SYMBOL-VALUE is returned, or
* null if unbound.
*
* @return A lisp object, or null if unbound
*
* @see LispThread#lookupSpecial
* @see Symbol#getSymbolValue()
*
*/
public final LispObject symbolValueNoThrow()
{
return symbolValueNoThrow(LispThread.currentThread());
}
/** Returns the value of the symbol in the current thread context;
* if the symbol has been declared special, the value of the innermost
* binding is returned. Otherwise, the SYMBOL-VALUE is returned, or
* null if unbound.
*
* @return A lisp object, or null if unbound
*
* @see LispThread#lookupSpecial
* @see Symbol#getSymbolValue()
*
*/
public final LispObject symbolValueNoThrow(LispThread thread)
{
if ((flags & FLAG_SPECIAL) != 0)
{
LispObject val = thread.lookupSpecial(this);
if (val != null)
return val;
}
return value;
}
@Override
public LispObject getSymbolFunction()
{
return function;
}
@Override
public final LispObject getSymbolFunctionOrDie()
{
if (function == null)
return error(new UndefinedFunction(this));
if (function instanceof Autoload)
{
Autoload autoload = (Autoload) function;
autoload.load();
}
return function;
}
@Override
public final LispObject getSymbolSetfFunction()
{
return get(this, Symbol.SETF_FUNCTION, NIL);
}
@Override
public final LispObject getSymbolSetfFunctionOrDie()
{
LispObject obj = get(this, Symbol.SETF_FUNCTION, null);
if (obj == null)
error(new UndefinedFunction(list(Keyword.NAME,
list(Symbol.SETF,
this))));
return obj;
}
public final void setSymbolFunction(LispObject obj)
{
this.function = obj;
}
/** See LispObject.getStringValue() */
@Override
public String getStringValue()
{
return name.getStringValue();
}
@Override
public final LispObject getPropertyList()
{
if (propertyList == null)
propertyList = NIL;
return propertyList;
}
@Override
public final void setPropertyList(LispObject obj)
{
if (obj == null)
throw new NullPointerException();
propertyList = obj;
}
@Override
public String printObject()
{
final String n = name.getStringValue();
final LispThread thread = LispThread.currentThread();
boolean printEscape = (PRINT_ESCAPE.symbolValue(thread) != NIL);
LispObject printCase = PRINT_CASE.symbolValue(thread);
final LispObject readtableCase =
((Readtable)CURRENT_READTABLE.symbolValue(thread)).getReadtableCase();
boolean printReadably = (PRINT_READABLY.symbolValue(thread) != NIL);
if (printReadably) {
if (readtableCase != Keyword.UPCASE || printCase != Keyword.UPCASE) {
StringBuilder sb = new StringBuilder();
if (pkg == PACKAGE_KEYWORD) {
sb.append(':');
} else if (pkg instanceof Package) {
sb.append(multipleEscape(((Package)pkg).getName()));
sb.append("::");
} else {
sb.append("#:");
}
sb.append(multipleEscape(n));
return sb.toString();
}
else {
printEscape = true;
}
}
if (!printEscape) {
if (pkg == PACKAGE_KEYWORD) {
if (printCase == Keyword.DOWNCASE)
return n.toLowerCase();
if (printCase == Keyword.CAPITALIZE)
return capitalize(n, readtableCase);
return n;
}
// Printer escaping is disabled.
if (readtableCase == Keyword.UPCASE) {
if (printCase == Keyword.DOWNCASE)
return n.toLowerCase();
if (printCase == Keyword.CAPITALIZE)
return capitalize(n, readtableCase);
return n;
} else if (readtableCase == Keyword.DOWNCASE) {
// "When the readtable case is :DOWNCASE, uppercase characters
// are printed in their own case, and lowercase characters are
// printed in the case specified by *PRINT-CASE*." (22.1.3.3.2)
if (printCase == Keyword.DOWNCASE)
return n;
if (printCase == Keyword.UPCASE)
return n.toUpperCase();
if (printCase == Keyword.CAPITALIZE)
return capitalize(n, readtableCase);
return n;
} else if (readtableCase == Keyword.PRESERVE) {
return n;
} else // INVERT
return invert(n);
}
// Printer escaping is enabled.
final boolean escapeSymbolName = needsEscape(n, readtableCase, thread);
String symbolName = escapeSymbolName ? multipleEscape(n) : n;
if (!escapeSymbolName) {
if (readtableCase == Keyword.PRESERVE) {
// nothing to do
} else if (readtableCase == Keyword.INVERT) {
symbolName = invert(symbolName);
} else if (printCase == Keyword.DOWNCASE) {
symbolName = symbolName.toLowerCase();
} else if (printCase == Keyword.UPCASE) {
symbolName = symbolName.toUpperCase();
} else if (printCase == Keyword.CAPITALIZE) {
symbolName = capitalize(symbolName, readtableCase);
}
}
if (pkg == NIL) {
if (printReadably || PRINT_GENSYM.symbolValue(thread) != NIL) {
return "#:".concat(symbolName);
} else {
return symbolName;
}
}
if (pkg == PACKAGE_KEYWORD) {
return ":".concat(symbolName);
}
// "Package prefixes are printed if necessary." (22.1.3.3.1)
// Here we also use a package-local nickname if appropriate.
final Package currentPackage = (Package) _PACKAGE_.symbolValue(thread);
if (pkg == currentPackage) {
return symbolName;
}
if (currentPackage != null && currentPackage.uses(pkg)) {
// Check for name conflict in current package.
if (currentPackage.findExternalSymbol(name) == null)
if (currentPackage.findInternalSymbol(name) == null)
if (((Package)pkg).findExternalSymbol(name) != null)
return symbolName;
}
// Has this symbol been imported into the current package?
if (currentPackage.findExternalSymbol(name) == this)
return symbolName;
if (currentPackage.findInternalSymbol(name) == this)
return symbolName;
// Package prefix is necessary.
String packageName = ((Package)pkg).getName();
if (currentPackage.getLocallyNicknamedPackages().contains(pkg)) {
LispObject nicknames = currentPackage.getLocalPackageNicknames();
while (nicknames != NIL) {
if (nicknames.car().cdr() == pkg) {
packageName = javaString(nicknames.car().car());
nicknames = NIL;
} else {
nicknames = nicknames.cdr();
}
}
}
final boolean escapePackageName = needsEscape(packageName, readtableCase, thread);
if (escapePackageName)
{
packageName = multipleEscape(packageName);
}
else
{
if (readtableCase == Keyword.UPCASE)
{
if (printCase == Keyword.DOWNCASE)
packageName = packageName.toLowerCase();
else if (printCase == Keyword.CAPITALIZE)
packageName = capitalize(packageName, readtableCase);
}
else if (readtableCase == Keyword.DOWNCASE)
{
if (printCase == Keyword.UPCASE)
packageName = packageName.toUpperCase();
else if (printCase == Keyword.CAPITALIZE)
packageName = capitalize(packageName, readtableCase);
}
else if (readtableCase == Keyword.INVERT)
{
packageName = invert(packageName);
}
}
StringBuilder sb = new StringBuilder(packageName);
if (((Package)pkg).findExternalSymbol(name) != null
&& DOUBLE_COLON_PACKAGE_SEPARATORS.symbolValue(thread) == NIL)
sb.append(':');
else
sb.append("::");
sb.append(symbolName);
return sb.toString();
}
private static final String invert(String s)
{
// "When the readtable case is :INVERT, the case of all alphabetic
// characters in single case symbol names is inverted. Mixed-case
// symbol names are printed as is." (22.1.3.3.2)
final int limit = s.length();
final int LOWER = 1;
final int UPPER = 2;
int state = 0;
for (int i = 0; i < limit; i++)
{
char c = s.charAt(i);
if (Character.isUpperCase(c))
{
if (state == LOWER)
return s; // Mixed case.
state = UPPER;
}
if (Character.isLowerCase(c))
{
if (state == UPPER)
return s; // Mixed case.
state = LOWER;
}
}
StringBuilder sb = new StringBuilder(limit);
for (int i = 0; i < limit; i++)
{
char c = s.charAt(i);
if (Character.isUpperCase(c))
sb.append(Character.toLowerCase(c));
else if (Character.isLowerCase(c))
sb.append(Character.toUpperCase(c));
else
sb.append(c);
}
return sb.toString();
}
private static final boolean needsEscape(String s,
LispObject readtableCase,
LispThread thread)
{
boolean escape = false;
final int length = s.length();
if (length == 0)
return true;
if (s.charAt(0) == '#')
return true;
int radix;
LispObject printBaseBinding = PRINT_BASE.symbolValue(thread);
if (printBaseBinding instanceof Fixnum)
{
radix = ((Fixnum)printBaseBinding).value;
}
else
{
error(new TypeError("The value of *PRINT-BASE* is not of type (INTEGER 2 36)."));
// Not reached.
return false;
}
if (radix < 2 || radix > 36)
{
error(new TypeError("The value of *PRINT-BASE* is not of type (INTEGER 2 36)."));
// Not reached.
return false;
}
boolean seenNonDigit = false;
for (int i = length; i-- > 0;)
{
char c = s.charAt(i);
if ("(),|\\`'\";:".indexOf(c) >= 0)
return true;
if (Character.isWhitespace(c))
return true;
if (readtableCase == Keyword.UPCASE)
{
if (Character.isLowerCase(c))
return true;
}
else if (readtableCase == Keyword.DOWNCASE)
{
if (Character.isUpperCase(c))
return true;
}
if (!escape && !seenNonDigit)
{
if (Character.digit(c, radix) < 0)
seenNonDigit = true;
}
}
if (!seenNonDigit)
return true;
if (s.charAt(0) == '.')
{
boolean allDots = true;
for (int i = length; i-- > 1;)
{
if (s.charAt(i) != '.')
{
allDots = false;
break;
}
}
if (allDots)
return true;
}
return false;
}
private static final String multipleEscape(String s)
{
StringBuilder sb = new StringBuilder("|");
final int limit = s.length();
for (int i = 0; i < limit; i++)
{
char c = s.charAt(i);
if (c == '|' || c == '\\')
sb.append('\\');
sb.append(c);
}
sb.append('|');
return sb.toString();
}
private static final String capitalize(String s, LispObject readtableCase)
{
if (readtableCase == Keyword.INVERT || readtableCase == Keyword.PRESERVE)
return s;
final int limit = s.length();
StringBuilder sb = new StringBuilder(limit);
boolean lastCharWasAlphanumeric = false;
for (int i = 0; i < limit; i++)
{
char c = s.charAt(i);
if (Character.isLowerCase(c))
{
if (readtableCase == Keyword.UPCASE)
sb.append(c);
else // DOWNCASE
sb.append(lastCharWasAlphanumeric ? c : LispCharacter.toUpperCase(c));
lastCharWasAlphanumeric = true;
}
else if (Character.isUpperCase(c))
{
if (readtableCase == Keyword.UPCASE)
sb.append(lastCharWasAlphanumeric ? LispCharacter.toLowerCase(c) : c);
else // DOWNCASE
sb.append(c);
lastCharWasAlphanumeric = true;
}
else
{
sb.append(c);
lastCharWasAlphanumeric = Character.isDigit(c);
}
}
return sb.toString();
}
@Override
public final int sxhash()
{
int h = hash;
if (h < 0)
{
h = name.sxhash();
hash = h;
}
return h;
}
@Override
final public LispObject execute()
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(NIL);
return fun.execute();
}
@Override
final public LispObject execute(LispObject arg)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(arg));
return fun.execute(arg);
}
@Override
final public LispObject execute(LispObject first, LispObject second)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second));
return fun.execute(first, second);
}
@Override
final public LispObject execute(LispObject first, LispObject second,
LispObject third)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second, third));
return fun.execute(first, second, third);
}
@Override
final public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second, third, fourth));
return fun.execute(first, second, third, fourth);
}
@Override
final public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second, third, fourth,
fifth));
return fun.execute(first, second, third, fourth,
fifth);
}
@Override
final public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second, third, fourth,
fifth, sixth));
return fun.execute(first, second, third, fourth,
fifth, sixth);
}
@Override
final public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth,
LispObject seventh)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second, third, fourth,
fifth, sixth, seventh));
return fun.execute(first, second, third, fourth,
fifth, sixth, seventh);
}
@Override
final public LispObject execute(LispObject first, LispObject second,
LispObject third, LispObject fourth,
LispObject fifth, LispObject sixth,
LispObject seventh, LispObject eighth)
{
LispObject fun;
if ((fun = function) == null)
return undefinedFunction(list(first, second, third, fourth,
fifth, sixth, seventh, eighth));
return fun.execute(first, second, third, fourth,
fifth, sixth, seventh, eighth);
}
@Override
final public LispObject execute(LispObject[] args)
{
LispObject fun;
if ((fun = function) == null) {
LispObject list = NIL;
for (int i = args.length; i-- > 0;)
list = new Cons(args[i], list);
return undefinedFunction(list);
}
return fun.execute(args);
}
private final LispObject undefinedFunction(LispObject args)
{
return LispThread.currentThread().execute(Symbol.UNDEFINED_FUNCTION_CALLED,
this, args);
}
@Override
public void incrementCallCount()
{
if (function != null)
function.incrementCallCount();
}
@Override
public void incrementHotCount()
{
if (function != null)
function.incrementHotCount();
}
public Object readResolve() throws java.io.ObjectStreamException {
if(pkg instanceof Package) {
Symbol s = ((Package) pkg).intern(name.getStringValue());
return s;
} else {
return this;
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
if (pkg instanceof Package) {
sb.append(((Package)pkg).getName());
sb.append(":");
} else {
sb.append("#:");
}
sb.append(name);
return sb.toString();
}
// External symbols in CL package.
public static final Symbol AND_ALLOW_OTHER_KEYS =
PACKAGE_CL.addExternalSymbol("&ALLOW-OTHER-KEYS");
public static final Symbol AND_AUX =
PACKAGE_CL.addExternalSymbol("&AUX");
public static final Symbol AND_BODY =
PACKAGE_CL.addExternalSymbol("&BODY");
public static final Symbol AND_ENVIRONMENT =
PACKAGE_CL.addExternalSymbol("&ENVIRONMENT");
public static final Symbol AND_KEY =
PACKAGE_CL.addExternalSymbol("&KEY");
public static final Symbol AND_OPTIONAL =
PACKAGE_CL.addExternalSymbol("&OPTIONAL");
public static final Symbol AND_REST =
PACKAGE_CL.addExternalSymbol("&REST");
public static final Symbol AND_WHOLE =
PACKAGE_CL.addExternalSymbol("&WHOLE");
public static final Symbol STAR =
PACKAGE_CL.addExternalSymbol("*");
public static final Symbol STAR_STAR =
PACKAGE_CL.addExternalSymbol("**");
public static final Symbol STAR_STAR_STAR =
PACKAGE_CL.addExternalSymbol("***");
public static final Symbol BREAK_ON_SIGNALS =
PACKAGE_CL.addExternalSymbol("*BREAK-ON-SIGNALS*");
public static final Symbol _COMPILE_FILE_PATHNAME_ =
PACKAGE_CL.addExternalSymbol("*COMPILE-FILE-PATHNAME*");
public static final Symbol COMPILE_FILE_TRUENAME =
PACKAGE_CL.addExternalSymbol("*COMPILE-FILE-TRUENAME*");
public static final Symbol COMPILE_PRINT =
PACKAGE_CL.addExternalSymbol("*COMPILE-PRINT*");
public static final Symbol COMPILE_VERBOSE =
PACKAGE_CL.addExternalSymbol("*COMPILE-VERBOSE*");
public static final Symbol DEBUG_IO =
PACKAGE_CL.addExternalSymbol("*DEBUG-IO*");
public static final Symbol DEBUGGER_HOOK =
PACKAGE_CL.addExternalSymbol("*DEBUGGER-HOOK*");
public static final Symbol DEFAULT_PATHNAME_DEFAULTS =
PACKAGE_CL.addExternalSymbol("*DEFAULT-PATHNAME-DEFAULTS*");
public static final Symbol ERROR_OUTPUT =
PACKAGE_CL.addExternalSymbol("*ERROR-OUTPUT*");
public static final Symbol FEATURES =
PACKAGE_CL.addExternalSymbol("*FEATURES*");
public static final Symbol GENSYM_COUNTER =
PACKAGE_CL.addExternalSymbol("*GENSYM-COUNTER*");
public static final Symbol LOAD_PATHNAME =
PACKAGE_CL.addExternalSymbol("*LOAD-PATHNAME*");
public static final Symbol LOAD_PRINT =
PACKAGE_CL.addExternalSymbol("*LOAD-PRINT*");
public static final Symbol LOAD_TRUENAME =
PACKAGE_CL.addExternalSymbol("*LOAD-TRUENAME*");
public static final Symbol LOAD_VERBOSE =
PACKAGE_CL.addExternalSymbol("*LOAD-VERBOSE*");
public static final Symbol MACROEXPAND_HOOK =
PACKAGE_CL.addExternalSymbol("*MACROEXPAND-HOOK*");
public static final Symbol MODULES =
PACKAGE_CL.addExternalSymbol("*MODULES*");
public static final Symbol _PACKAGE_ =
PACKAGE_CL.addExternalSymbol("*PACKAGE*");
public static final Symbol PRINT_ARRAY =
PACKAGE_CL.addExternalSymbol("*PRINT-ARRAY*");
public static final Symbol PRINT_BASE =
PACKAGE_CL.addExternalSymbol("*PRINT-BASE*");
public static final Symbol PRINT_CASE =
PACKAGE_CL.addExternalSymbol("*PRINT-CASE*");
public static final Symbol PRINT_CIRCLE =
PACKAGE_CL.addExternalSymbol("*PRINT-CIRCLE*");
public static final Symbol PRINT_ESCAPE =
PACKAGE_CL.addExternalSymbol("*PRINT-ESCAPE*");
public static final Symbol PRINT_GENSYM =
PACKAGE_CL.addExternalSymbol("*PRINT-GENSYM*");
public static final Symbol PRINT_LENGTH =
PACKAGE_CL.addExternalSymbol("*PRINT-LENGTH*");
public static final Symbol PRINT_LEVEL =
PACKAGE_CL.addExternalSymbol("*PRINT-LEVEL*");
public static final Symbol PRINT_LINES =
PACKAGE_CL.addExternalSymbol("*PRINT-LINES*");
public static final Symbol PRINT_MISER_WIDTH =
PACKAGE_CL.addExternalSymbol("*PRINT-MISER-WIDTH*");
public static final Symbol PRINT_PPRINT_DISPATCH =
PACKAGE_CL.addExternalSymbol("*PRINT-PPRINT-DISPATCH*");
public static final Symbol PRINT_PRETTY =
PACKAGE_CL.addExternalSymbol("*PRINT-PRETTY*");
public static final Symbol PRINT_RADIX =
PACKAGE_CL.addExternalSymbol("*PRINT-RADIX*");
public static final Symbol PRINT_READABLY =
PACKAGE_CL.addExternalSymbol("*PRINT-READABLY*");
public static final Symbol PRINT_RIGHT_MARGIN =
PACKAGE_CL.addExternalSymbol("*PRINT-RIGHT-MARGIN*");
public static final Symbol QUERY_IO =
PACKAGE_CL.addExternalSymbol("*QUERY-IO*");
public static final Symbol _RANDOM_STATE_ =
PACKAGE_CL.addExternalSymbol("*RANDOM-STATE*");
public static final Symbol READ_BASE =
PACKAGE_CL.addExternalSymbol("*READ-BASE*");
public static final Symbol READ_DEFAULT_FLOAT_FORMAT =
PACKAGE_CL.addExternalSymbol("*READ-DEFAULT-FLOAT-FORMAT*");
public static final Symbol READ_EVAL =
PACKAGE_CL.addExternalSymbol("*READ-EVAL*");
public static final Symbol READ_SUPPRESS =
PACKAGE_CL.addExternalSymbol("*READ-SUPPRESS*");
public static final Symbol CURRENT_READTABLE =
PACKAGE_CL.addExternalSymbol("*READTABLE*");
public static final Symbol STANDARD_INPUT =
PACKAGE_CL.addExternalSymbol("*STANDARD-INPUT*");
public static final Symbol STANDARD_OUTPUT =
PACKAGE_CL.addExternalSymbol("*STANDARD-OUTPUT*");
public static final Symbol TERMINAL_IO =
PACKAGE_CL.addExternalSymbol("*TERMINAL-IO*");
public static final Symbol TRACE_OUTPUT =
PACKAGE_CL.addExternalSymbol("*TRACE-OUTPUT*");
public static final Symbol PLUS =
PACKAGE_CL.addExternalSymbol("+");
public static final Symbol PLUS_PLUS =
PACKAGE_CL.addExternalSymbol("++");
public static final Symbol PLUS_PLUS_PLUS =
PACKAGE_CL.addExternalSymbol("+++");
public static final Symbol MINUS =
PACKAGE_CL.addExternalSymbol("-");
public static final Symbol SLASH =
PACKAGE_CL.addExternalSymbol("/");
public static final Symbol SLASH_SLASH =
PACKAGE_CL.addExternalSymbol("//");
public static final Symbol SLASH_SLASH_SLASH =
PACKAGE_CL.addExternalSymbol("///");
public static final Symbol NOT_EQUALS =
PACKAGE_CL.addExternalSymbol("/=");
public static final Symbol ONE_PLUS =
PACKAGE_CL.addExternalSymbol("1+");
public static final Symbol ONE_MINUS =
PACKAGE_CL.addExternalSymbol("1-");
public static final Symbol LT =
PACKAGE_CL.addExternalSymbol("<");
public static final Symbol LE =
PACKAGE_CL.addExternalSymbol("<=");
public static final Symbol EQUALS =
PACKAGE_CL.addExternalSymbol("=");
public static final Symbol GT =
PACKAGE_CL.addExternalSymbol(">");
public static final Symbol GE =
PACKAGE_CL.addExternalSymbol(">=");
public static final Symbol ABORT =
PACKAGE_CL.addExternalSymbol("ABORT");
public static final Symbol ABS =
PACKAGE_CL.addExternalSymbol("ABS");
public static final Symbol ACONS =
PACKAGE_CL.addExternalSymbol("ACONS");
public static final Symbol ACOS =
PACKAGE_CL.addExternalSymbol("ACOS");
public static final Symbol ACOSH =
PACKAGE_CL.addExternalSymbol("ACOSH");
public static final Symbol ADD_METHOD =
PACKAGE_CL.addExternalSymbol("ADD-METHOD");
public static final Symbol ADJOIN =
PACKAGE_CL.addExternalSymbol("ADJOIN");
public static final Symbol ADJUST_ARRAY =
PACKAGE_CL.addExternalSymbol("ADJUST-ARRAY");
public static final Symbol ADJUSTABLE_ARRAY_P =
PACKAGE_CL.addExternalSymbol("ADJUSTABLE-ARRAY-P");
public static final Symbol ALLOCATE_INSTANCE =
PACKAGE_CL.addExternalSymbol("ALLOCATE-INSTANCE");
public static final Symbol ALPHA_CHAR_P =
PACKAGE_CL.addExternalSymbol("ALPHA-CHAR-P");
public static final Symbol ALPHANUMERICP =
PACKAGE_CL.addExternalSymbol("ALPHANUMERICP");
public static final Symbol AND =
PACKAGE_CL.addExternalSymbol("AND");
public static final Symbol APPEND =
PACKAGE_CL.addExternalSymbol("APPEND");
public static final Symbol APPLY =
PACKAGE_CL.addExternalSymbol("APPLY");
public static final Symbol APROPOS =
PACKAGE_CL.addExternalSymbol("APROPOS");
public static final Symbol APROPOS_LIST =
PACKAGE_CL.addExternalSymbol("APROPOS-LIST");
public static final Symbol AREF =
PACKAGE_CL.addExternalSymbol("AREF");
public static final Symbol ARITHMETIC_ERROR =
PACKAGE_CL.addExternalSymbol("ARITHMETIC-ERROR");
public static final Symbol ARITHMETIC_ERROR_OPERANDS =
PACKAGE_CL.addExternalSymbol("ARITHMETIC-ERROR-OPERANDS");
public static final Symbol ARITHMETIC_ERROR_OPERATION =
PACKAGE_CL.addExternalSymbol("ARITHMETIC-ERROR-OPERATION");
public static final Symbol ARRAY =
PACKAGE_CL.addExternalSymbol("ARRAY");
public static final Symbol ARRAY_DIMENSION =
PACKAGE_CL.addExternalSymbol("ARRAY-DIMENSION");
public static final Symbol ARRAY_DIMENSION_LIMIT =
PACKAGE_CL.addExternalSymbol("ARRAY-DIMENSION-LIMIT");
public static final Symbol ARRAY_DIMENSIONS =
PACKAGE_CL.addExternalSymbol("ARRAY-DIMENSIONS");
public static final Symbol ARRAY_DISPLACEMENT =
PACKAGE_CL.addExternalSymbol("ARRAY-DISPLACEMENT");
public static final Symbol ARRAY_ELEMENT_TYPE =
PACKAGE_CL.addExternalSymbol("ARRAY-ELEMENT-TYPE");
public static final Symbol ARRAY_HAS_FILL_POINTER_P =
PACKAGE_CL.addExternalSymbol("ARRAY-HAS-FILL-POINTER-P");
public static final Symbol ARRAY_IN_BOUNDS_P =
PACKAGE_CL.addExternalSymbol("ARRAY-IN-BOUNDS-P");
public static final Symbol ARRAY_RANK =
PACKAGE_CL.addExternalSymbol("ARRAY-RANK");
public static final Symbol ARRAY_RANK_LIMIT =
PACKAGE_CL.addExternalSymbol("ARRAY-RANK-LIMIT");
public static final Symbol ARRAY_ROW_MAJOR_INDEX =
PACKAGE_CL.addExternalSymbol("ARRAY-ROW-MAJOR-INDEX");
public static final Symbol ARRAY_TOTAL_SIZE =
PACKAGE_CL.addExternalSymbol("ARRAY-TOTAL-SIZE");
public static final Symbol ARRAY_TOTAL_SIZE_LIMIT =
PACKAGE_CL.addExternalSymbol("ARRAY-TOTAL-SIZE-LIMIT");
public static final Symbol ARRAYP =
PACKAGE_CL.addExternalSymbol("ARRAYP");
public static final Symbol ASH =
PACKAGE_CL.addExternalSymbol("ASH");
public static final Symbol ASIN =
PACKAGE_CL.addExternalSymbol("ASIN");
public static final Symbol ASINH =
PACKAGE_CL.addExternalSymbol("ASINH");
public static final Symbol ASSERT =
PACKAGE_CL.addExternalSymbol("ASSERT");
public static final Symbol ASSOC =
PACKAGE_CL.addExternalSymbol("ASSOC");
public static final Symbol ASSOC_IF =
PACKAGE_CL.addExternalSymbol("ASSOC-IF");
public static final Symbol ASSOC_IF_NOT =
PACKAGE_CL.addExternalSymbol("ASSOC-IF-NOT");
public static final Symbol ATAN =
PACKAGE_CL.addExternalSymbol("ATAN");
public static final Symbol ATANH =
PACKAGE_CL.addExternalSymbol("ATANH");
public static final Symbol ATOM =
PACKAGE_CL.addExternalSymbol("ATOM");
public static final Symbol BASE_CHAR =
PACKAGE_CL.addExternalSymbol("BASE-CHAR");
public static final Symbol BASE_STRING =
PACKAGE_CL.addExternalSymbol("BASE-STRING");
public static final Symbol BIGNUM =
PACKAGE_CL.addExternalSymbol("BIGNUM");
public static final Symbol BIT =
PACKAGE_CL.addExternalSymbol("BIT");
public static final Symbol BIT_AND =
PACKAGE_CL.addExternalSymbol("BIT-AND");
public static final Symbol BIT_ANDC1 =
PACKAGE_CL.addExternalSymbol("BIT-ANDC1");
public static final Symbol BIT_ANDC2 =
PACKAGE_CL.addExternalSymbol("BIT-ANDC2");
public static final Symbol BIT_EQV =
PACKAGE_CL.addExternalSymbol("BIT-EQV");
public static final Symbol BIT_IOR =
PACKAGE_CL.addExternalSymbol("BIT-IOR");
public static final Symbol BIT_NAND =
PACKAGE_CL.addExternalSymbol("BIT-NAND");
public static final Symbol BIT_NOR =
PACKAGE_CL.addExternalSymbol("BIT-NOR");
public static final Symbol BIT_NOT =
PACKAGE_CL.addExternalSymbol("BIT-NOT");
public static final Symbol BIT_ORC1 =
PACKAGE_CL.addExternalSymbol("BIT-ORC1");
public static final Symbol BIT_ORC2 =
PACKAGE_CL.addExternalSymbol("BIT-ORC2");
public static final Symbol BIT_VECTOR =
PACKAGE_CL.addExternalSymbol("BIT-VECTOR");
public static final Symbol BIT_VECTOR_P =
PACKAGE_CL.addExternalSymbol("BIT-VECTOR-P");
public static final Symbol BIT_XOR =
PACKAGE_CL.addExternalSymbol("BIT-XOR");
public static final Symbol BLOCK =
PACKAGE_CL.addExternalSymbol("BLOCK");
public static final Symbol BOOLE =
PACKAGE_CL.addExternalSymbol("BOOLE");
public static final Symbol BOOLE_1 =
PACKAGE_CL.addExternalSymbol("BOOLE-1");
public static final Symbol BOOLE_2 =
PACKAGE_CL.addExternalSymbol("BOOLE-2");
public static final Symbol BOOLE_AND =
PACKAGE_CL.addExternalSymbol("BOOLE-AND");
public static final Symbol BOOLE_ANDC1 =
PACKAGE_CL.addExternalSymbol("BOOLE-ANDC1");
public static final Symbol BOOLE_ANDC2 =
PACKAGE_CL.addExternalSymbol("BOOLE-ANDC2");
public static final Symbol BOOLE_C1 =
PACKAGE_CL.addExternalSymbol("BOOLE-C1");
public static final Symbol BOOLE_C2 =
PACKAGE_CL.addExternalSymbol("BOOLE-C2");
public static final Symbol BOOLE_CLR =
PACKAGE_CL.addExternalSymbol("BOOLE-CLR");
public static final Symbol BOOLE_EQV =
PACKAGE_CL.addExternalSymbol("BOOLE-EQV");
public static final Symbol BOOLE_IOR =
PACKAGE_CL.addExternalSymbol("BOOLE-IOR");
public static final Symbol BOOLE_NAND =
PACKAGE_CL.addExternalSymbol("BOOLE-NAND");
public static final Symbol BOOLE_NOR =
PACKAGE_CL.addExternalSymbol("BOOLE-NOR");
public static final Symbol BOOLE_ORC1 =
PACKAGE_CL.addExternalSymbol("BOOLE-ORC1");
public static final Symbol BOOLE_ORC2 =
PACKAGE_CL.addExternalSymbol("BOOLE-ORC2");
public static final Symbol BOOLE_SET =
PACKAGE_CL.addExternalSymbol("BOOLE-SET");
public static final Symbol BOOLE_XOR =
PACKAGE_CL.addExternalSymbol("BOOLE-XOR");
public static final Symbol BOOLEAN =
PACKAGE_CL.addExternalSymbol("BOOLEAN");
public static final Symbol BOTH_CASE_P =
PACKAGE_CL.addExternalSymbol("BOTH-CASE-P");
public static final Symbol BOUNDP =
PACKAGE_CL.addExternalSymbol("BOUNDP");
public static final Symbol BREAK =
PACKAGE_CL.addExternalSymbol("BREAK");
public static final Symbol BROADCAST_STREAM =
PACKAGE_CL.addExternalSymbol("BROADCAST-STREAM");
public static final Symbol BROADCAST_STREAM_STREAMS =
PACKAGE_CL.addExternalSymbol("BROADCAST-STREAM-STREAMS");
public static final Symbol BUILT_IN_CLASS =
PACKAGE_CL.addExternalSymbol("BUILT-IN-CLASS");
public static final Symbol BUTLAST =
PACKAGE_CL.addExternalSymbol("BUTLAST");
public static final Symbol BYTE =
PACKAGE_CL.addExternalSymbol("BYTE");
public static final Symbol BYTE_POSITION =
PACKAGE_CL.addExternalSymbol("BYTE-POSITION");
public static final Symbol BYTE_SIZE =
PACKAGE_CL.addExternalSymbol("BYTE-SIZE");
public static final Symbol CAAAAR =
PACKAGE_CL.addExternalSymbol("CAAAAR");
public static final Symbol CAAADR =
PACKAGE_CL.addExternalSymbol("CAAADR");
public static final Symbol CAAAR =
PACKAGE_CL.addExternalSymbol("CAAAR");
public static final Symbol CAADAR =
PACKAGE_CL.addExternalSymbol("CAADAR");
public static final Symbol CAADDR =
PACKAGE_CL.addExternalSymbol("CAADDR");
public static final Symbol CAADR =
PACKAGE_CL.addExternalSymbol("CAADR");
public static final Symbol CAAR =
PACKAGE_CL.addExternalSymbol("CAAR");
public static final Symbol CADAAR =
PACKAGE_CL.addExternalSymbol("CADAAR");
public static final Symbol CADADR =
PACKAGE_CL.addExternalSymbol("CADADR");
public static final Symbol CADAR =
PACKAGE_CL.addExternalSymbol("CADAR");
public static final Symbol CADDAR =
PACKAGE_CL.addExternalSymbol("CADDAR");
public static final Symbol CADDDR =
PACKAGE_CL.addExternalSymbol("CADDDR");
public static final Symbol CADDR =
PACKAGE_CL.addExternalSymbol("CADDR");
public static final Symbol CADR =
PACKAGE_CL.addExternalSymbol("CADR");
public static final Symbol CALL_ARGUMENTS_LIMIT =
PACKAGE_CL.addExternalSymbol("CALL-ARGUMENTS-LIMIT");
public static final Symbol CALL_METHOD =
PACKAGE_CL.addExternalSymbol("CALL-METHOD");
public static final Symbol CALL_NEXT_METHOD =
PACKAGE_CL.addExternalSymbol("CALL-NEXT-METHOD");
public static final Symbol CAR =
PACKAGE_CL.addExternalSymbol("CAR");
public static final Symbol CASE =
PACKAGE_CL.addExternalSymbol("CASE");
public static final Symbol CATCH =
PACKAGE_CL.addExternalSymbol("CATCH");
public static final Symbol CCASE =
PACKAGE_CL.addExternalSymbol("CCASE");
public static final Symbol CDAAAR =
PACKAGE_CL.addExternalSymbol("CDAAAR");
public static final Symbol CDAADR =
PACKAGE_CL.addExternalSymbol("CDAADR");
public static final Symbol CDAAR =
PACKAGE_CL.addExternalSymbol("CDAAR");
public static final Symbol CDADAR =
PACKAGE_CL.addExternalSymbol("CDADAR");
public static final Symbol CDADDR =
PACKAGE_CL.addExternalSymbol("CDADDR");
public static final Symbol CDADR =
PACKAGE_CL.addExternalSymbol("CDADR");
public static final Symbol CDAR =
PACKAGE_CL.addExternalSymbol("CDAR");
public static final Symbol CDDAAR =
PACKAGE_CL.addExternalSymbol("CDDAAR");
public static final Symbol CDDADR =
PACKAGE_CL.addExternalSymbol("CDDADR");
public static final Symbol CDDAR =
PACKAGE_CL.addExternalSymbol("CDDAR");
public static final Symbol CDDDAR =
PACKAGE_CL.addExternalSymbol("CDDDAR");
public static final Symbol CDDDDR =
PACKAGE_CL.addExternalSymbol("CDDDDR");
public static final Symbol CDDDR =
PACKAGE_CL.addExternalSymbol("CDDDR");
public static final Symbol CDDR =
PACKAGE_CL.addExternalSymbol("CDDR");
public static final Symbol CDR =
PACKAGE_CL.addExternalSymbol("CDR");
public static final Symbol CEILING =
PACKAGE_CL.addExternalSymbol("CEILING");
public static final Symbol CELL_ERROR =
PACKAGE_CL.addExternalSymbol("CELL-ERROR");
public static final Symbol CELL_ERROR_NAME =
PACKAGE_CL.addExternalSymbol("CELL-ERROR-NAME");
public static final Symbol CERROR =
PACKAGE_CL.addExternalSymbol("CERROR");
public static final Symbol CHANGE_CLASS =
PACKAGE_CL.addExternalSymbol("CHANGE-CLASS");
public static final Symbol CHAR =
PACKAGE_CL.addExternalSymbol("CHAR");
public static final Symbol CHAR_CODE =
PACKAGE_CL.addExternalSymbol("CHAR-CODE");
public static final Symbol CHAR_CODE_LIMIT =
PACKAGE_CL.addExternalSymbol("CHAR-CODE-LIMIT");
public static final Symbol CHAR_DOWNCASE =
PACKAGE_CL.addExternalSymbol("CHAR-DOWNCASE");
public static final Symbol CHAR_EQUAL =
PACKAGE_CL.addExternalSymbol("CHAR-EQUAL");
public static final Symbol CHAR_GREATERP =
PACKAGE_CL.addExternalSymbol("CHAR-GREATERP");
public static final Symbol CHAR_INT =
PACKAGE_CL.addExternalSymbol("CHAR-INT");
public static final Symbol CHAR_LESSP =
PACKAGE_CL.addExternalSymbol("CHAR-LESSP");
public static final Symbol CHAR_NAME =
PACKAGE_CL.addExternalSymbol("CHAR-NAME");
public static final Symbol CHAR_NOT_EQUAL =
PACKAGE_CL.addExternalSymbol("CHAR-NOT-EQUAL");
public static final Symbol CHAR_NOT_GREATERP =
PACKAGE_CL.addExternalSymbol("CHAR-NOT-GREATERP");
public static final Symbol CHAR_NOT_LESSP =
PACKAGE_CL.addExternalSymbol("CHAR-NOT-LESSP");
public static final Symbol CHAR_UPCASE =
PACKAGE_CL.addExternalSymbol("CHAR-UPCASE");
public static final Symbol CHAR_NE =
PACKAGE_CL.addExternalSymbol("CHAR/=");
public static final Symbol CHAR_LT =
PACKAGE_CL.addExternalSymbol("CHAR<");
public static final Symbol CHAR_LE =
PACKAGE_CL.addExternalSymbol("CHAR<=");
public static final Symbol CHAR_EQUALS =
PACKAGE_CL.addExternalSymbol("CHAR=");
public static final Symbol CHAR_GT =
PACKAGE_CL.addExternalSymbol("CHAR>");
public static final Symbol CHAR_GE =
PACKAGE_CL.addExternalSymbol("CHAR>=");
public static final Symbol CHARACTER =
PACKAGE_CL.addExternalSymbol("CHARACTER");
public static final Symbol CHARACTERP =
PACKAGE_CL.addExternalSymbol("CHARACTERP");
public static final Symbol CHECK_TYPE =
PACKAGE_CL.addExternalSymbol("CHECK-TYPE");
public static final Symbol CIS =
PACKAGE_CL.addExternalSymbol("CIS");
public static final Symbol CLASS =
PACKAGE_CL.addExternalSymbol("CLASS");
public static final Symbol CLASS_NAME =
PACKAGE_CL.addExternalSymbol("CLASS-NAME");
public static final Symbol CLASS_OF =
PACKAGE_CL.addExternalSymbol("CLASS-OF");
public static final Symbol CLEAR_INPUT =
PACKAGE_CL.addExternalSymbol("CLEAR-INPUT");
public static final Symbol CLEAR_OUTPUT =
PACKAGE_CL.addExternalSymbol("CLEAR-OUTPUT");
public static final Symbol CLOSE =
PACKAGE_CL.addExternalSymbol("CLOSE");
public static final Symbol CLRHASH =
PACKAGE_CL.addExternalSymbol("CLRHASH");
public static final Symbol CODE_CHAR =
PACKAGE_CL.addExternalSymbol("CODE-CHAR");
public static final Symbol COERCE =
PACKAGE_CL.addExternalSymbol("COERCE");
public static final Symbol COMPILATION_SPEED =
PACKAGE_CL.addExternalSymbol("COMPILATION-SPEED");
public static final Symbol COMPILE =
PACKAGE_CL.addExternalSymbol("COMPILE");
public static final Symbol COMPILE_FILE =
PACKAGE_CL.addExternalSymbol("COMPILE-FILE");
public static final Symbol COMPILE_FILE_PATHNAME =
PACKAGE_CL.addExternalSymbol("COMPILE-FILE-PATHNAME");
public static final Symbol COMPILED_FUNCTION =
PACKAGE_CL.addExternalSymbol("COMPILED-FUNCTION");
public static final Symbol COMPILED_FUNCTION_P =
PACKAGE_CL.addExternalSymbol("COMPILED-FUNCTION-P");
public static final Symbol COMPILER_MACRO =
PACKAGE_CL.addExternalSymbol("COMPILER-MACRO");
public static final Symbol COMPILER_MACRO_FUNCTION =
PACKAGE_CL.addExternalSymbol("COMPILER-MACRO-FUNCTION");
public static final Symbol COMPLEMENT =
PACKAGE_CL.addExternalSymbol("COMPLEMENT");
public static final Symbol COMPLEX =
PACKAGE_CL.addExternalSymbol("COMPLEX");
public static final Symbol COMPLEXP =
PACKAGE_CL.addExternalSymbol("COMPLEXP");
public static final Symbol COMPUTE_APPLICABLE_METHODS =
PACKAGE_CL.addExternalSymbol("COMPUTE-APPLICABLE-METHODS");
public static final Symbol COMPUTE_RESTARTS =
PACKAGE_CL.addExternalSymbol("COMPUTE-RESTARTS");
public static final Symbol CONCATENATE =
PACKAGE_CL.addExternalSymbol("CONCATENATE");
public static final Symbol CONCATENATED_STREAM =
PACKAGE_CL.addExternalSymbol("CONCATENATED-STREAM");
public static final Symbol CONCATENATED_STREAM_STREAMS =
PACKAGE_CL.addExternalSymbol("CONCATENATED-STREAM-STREAMS");
public static final Symbol COND =
PACKAGE_CL.addExternalSymbol("COND");
public static final Symbol CONDITION =
PACKAGE_CL.addExternalSymbol("CONDITION");
public static final Symbol CONJUGATE =
PACKAGE_CL.addExternalSymbol("CONJUGATE");
public static final Symbol CONS =
PACKAGE_CL.addExternalSymbol("CONS");
public static final Symbol CONSP =
PACKAGE_CL.addExternalSymbol("CONSP");
public static final Symbol CONSTANTLY =
PACKAGE_CL.addExternalSymbol("CONSTANTLY");
public static final Symbol CONSTANTP =
PACKAGE_CL.addExternalSymbol("CONSTANTP");
public static final Symbol CONTINUE =
PACKAGE_CL.addExternalSymbol("CONTINUE");
public static final Symbol CONTROL_ERROR =
PACKAGE_CL.addExternalSymbol("CONTROL-ERROR");
public static final Symbol COPY_ALIST =
PACKAGE_CL.addExternalSymbol("COPY-ALIST");
public static final Symbol COPY_LIST =
PACKAGE_CL.addExternalSymbol("COPY-LIST");
public static final Symbol COPY_PPRINT_DISPATCH =
PACKAGE_CL.addExternalSymbol("COPY-PPRINT-DISPATCH");
public static final Symbol COPY_READTABLE =
PACKAGE_CL.addExternalSymbol("COPY-READTABLE");
public static final Symbol COPY_SEQ =
PACKAGE_CL.addExternalSymbol("COPY-SEQ");
public static final Symbol COPY_STRUCTURE =
PACKAGE_CL.addExternalSymbol("COPY-STRUCTURE");
public static final Symbol COPY_SYMBOL =
PACKAGE_CL.addExternalSymbol("COPY-SYMBOL");
public static final Symbol COPY_TREE =
PACKAGE_CL.addExternalSymbol("COPY-TREE");
public static final Symbol COS =
PACKAGE_CL.addExternalSymbol("COS");
public static final Symbol COSH =
PACKAGE_CL.addExternalSymbol("COSH");
public static final Symbol COUNT =
PACKAGE_CL.addExternalSymbol("COUNT");
public static final Symbol COUNT_IF =
PACKAGE_CL.addExternalSymbol("COUNT-IF");
public static final Symbol COUNT_IF_NOT =
PACKAGE_CL.addExternalSymbol("COUNT-IF-NOT");
public static final Symbol CTYPECASE =
PACKAGE_CL.addExternalSymbol("CTYPECASE");
public static final Symbol DEBUG =
PACKAGE_CL.addExternalSymbol("DEBUG");
public static final Symbol DECF =
PACKAGE_CL.addExternalSymbol("DECF");
public static final Symbol DECLAIM =
PACKAGE_CL.addExternalSymbol("DECLAIM");
public static final Symbol DECLARATION =
PACKAGE_CL.addExternalSymbol("DECLARATION");
public static final Symbol DECLARE =
PACKAGE_CL.addExternalSymbol("DECLARE");
public static final Symbol DECODE_FLOAT =
PACKAGE_CL.addExternalSymbol("DECODE-FLOAT");
public static final Symbol DECODE_UNIVERSAL_TIME =
PACKAGE_CL.addExternalSymbol("DECODE-UNIVERSAL-TIME");
public static final Symbol DEFCLASS =
PACKAGE_CL.addExternalSymbol("DEFCLASS");
public static final Symbol DEFCONSTANT =
PACKAGE_CL.addExternalSymbol("DEFCONSTANT");
public static final Symbol DEFGENERIC =
PACKAGE_CL.addExternalSymbol("DEFGENERIC");
public static final Symbol DEFINE_COMPILER_MACRO =
PACKAGE_CL.addExternalSymbol("DEFINE-COMPILER-MACRO");
public static final Symbol DEFINE_CONDITION =
PACKAGE_CL.addExternalSymbol("DEFINE-CONDITION");
public static final Symbol DEFINE_METHOD_COMBINATION =
PACKAGE_CL.addExternalSymbol("DEFINE-METHOD-COMBINATION");
public static final Symbol DEFINE_MODIFY_MACRO =
PACKAGE_CL.addExternalSymbol("DEFINE-MODIFY-MACRO");
public static final Symbol DEFINE_SETF_EXPANDER =
PACKAGE_CL.addExternalSymbol("DEFINE-SETF-EXPANDER");
public static final Symbol DEFINE_SYMBOL_MACRO =
PACKAGE_CL.addExternalSymbol("DEFINE-SYMBOL-MACRO");
public static final Symbol DEFMACRO =
PACKAGE_CL.addExternalSymbol("DEFMACRO");
public static final Symbol DEFMETHOD =
PACKAGE_CL.addExternalSymbol("DEFMETHOD");
public static final Symbol DEFPACKAGE =
PACKAGE_CL.addExternalSymbol("DEFPACKAGE");
public static final Symbol DEFPARAMETER =
PACKAGE_CL.addExternalSymbol("DEFPARAMETER");
public static final Symbol DEFSETF =
PACKAGE_CL.addExternalSymbol("DEFSETF");
public static final Symbol DEFSTRUCT =
PACKAGE_CL.addExternalSymbol("DEFSTRUCT");
public static final Symbol DEFTYPE =
PACKAGE_CL.addExternalSymbol("DEFTYPE");
public static final Symbol DEFUN =
PACKAGE_CL.addExternalSymbol("DEFUN");
public static final Symbol DEFVAR =
PACKAGE_CL.addExternalSymbol("DEFVAR");
public static final Symbol DELETE =
PACKAGE_CL.addExternalSymbol("DELETE");
public static final Symbol DELETE_DUPLICATES =
PACKAGE_CL.addExternalSymbol("DELETE-DUPLICATES");
public static final Symbol DELETE_FILE =
PACKAGE_CL.addExternalSymbol("DELETE-FILE");
public static final Symbol DELETE_IF =
PACKAGE_CL.addExternalSymbol("DELETE-IF");
public static final Symbol DELETE_IF_NOT =
PACKAGE_CL.addExternalSymbol("DELETE-IF-NOT");
public static final Symbol DELETE_PACKAGE =
PACKAGE_CL.addExternalSymbol("DELETE-PACKAGE");
public static final Symbol DENOMINATOR =
PACKAGE_CL.addExternalSymbol("DENOMINATOR");
public static final Symbol DEPOSIT_FIELD =
PACKAGE_CL.addExternalSymbol("DEPOSIT-FIELD");
public static final Symbol DESCRIBE =
PACKAGE_CL.addExternalSymbol("DESCRIBE");
public static final Symbol DESCRIBE_OBJECT =
PACKAGE_CL.addExternalSymbol("DESCRIBE-OBJECT");
public static final Symbol DESTRUCTURING_BIND =
PACKAGE_CL.addExternalSymbol("DESTRUCTURING-BIND");
public static final Symbol DIGIT_CHAR =
PACKAGE_CL.addExternalSymbol("DIGIT-CHAR");
public static final Symbol DIGIT_CHAR_P =
PACKAGE_CL.addExternalSymbol("DIGIT-CHAR-P");
public static final Symbol DIRECTORY =
PACKAGE_CL.addExternalSymbol("DIRECTORY");
public static final Symbol DIRECTORY_NAMESTRING =
PACKAGE_CL.addExternalSymbol("DIRECTORY-NAMESTRING");
public static final Symbol DISASSEMBLE =
PACKAGE_CL.addExternalSymbol("DISASSEMBLE");
public static final Symbol DIVISION_BY_ZERO =
PACKAGE_CL.addExternalSymbol("DIVISION-BY-ZERO");
public static final Symbol DO =
PACKAGE_CL.addExternalSymbol("DO");
public static final Symbol DO_STAR =
PACKAGE_CL.addExternalSymbol("DO*");
public static final Symbol DO_ALL_SYMBOLS =
PACKAGE_CL.addExternalSymbol("DO-ALL-SYMBOLS");
public static final Symbol DO_EXTERNAL_SYMBOLS =
PACKAGE_CL.addExternalSymbol("DO-EXTERNAL-SYMBOLS");
public static final Symbol DO_SYMBOLS =
PACKAGE_CL.addExternalSymbol("DO-SYMBOLS");
public static final Symbol DOCUMENTATION =
PACKAGE_CL.addExternalSymbol("DOCUMENTATION");
public static final Symbol DOLIST =
PACKAGE_CL.addExternalSymbol("DOLIST");
public static final Symbol DOTIMES =
PACKAGE_CL.addExternalSymbol("DOTIMES");
public static final Symbol DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("DOUBLE-FLOAT");
public static final Symbol DOUBLE_FLOAT_EPSILON =
PACKAGE_CL.addExternalSymbol("DOUBLE-FLOAT-EPSILON");
public static final Symbol DOUBLE_FLOAT_NEGATIVE_EPSILON =
PACKAGE_CL.addExternalSymbol("DOUBLE-FLOAT-NEGATIVE-EPSILON");
public static final Symbol DPB =
PACKAGE_CL.addExternalSymbol("DPB");
public static final Symbol DRIBBLE =
PACKAGE_CL.addExternalSymbol("DRIBBLE");
public static final Symbol DYNAMIC_EXTENT =
PACKAGE_CL.addExternalSymbol("DYNAMIC-EXTENT");
public static final Symbol ECASE =
PACKAGE_CL.addExternalSymbol("ECASE");
public static final Symbol ECHO_STREAM =
PACKAGE_CL.addExternalSymbol("ECHO-STREAM");
public static final Symbol ECHO_STREAM_INPUT_STREAM =
PACKAGE_CL.addExternalSymbol("ECHO-STREAM-INPUT-STREAM");
public static final Symbol ECHO_STREAM_OUTPUT_STREAM =
PACKAGE_CL.addExternalSymbol("ECHO-STREAM-OUTPUT-STREAM");
public static final Symbol ED =
PACKAGE_CL.addExternalSymbol("ED");
public static final Symbol EIGHTH =
PACKAGE_CL.addExternalSymbol("EIGHTH");
public static final Symbol ELT =
PACKAGE_CL.addExternalSymbol("ELT");
public static final Symbol ENCODE_UNIVERSAL_TIME =
PACKAGE_CL.addExternalSymbol("ENCODE-UNIVERSAL-TIME");
public static final Symbol END_OF_FILE =
PACKAGE_CL.addExternalSymbol("END-OF-FILE");
public static final Symbol ENDP =
PACKAGE_CL.addExternalSymbol("ENDP");
public static final Symbol ENOUGH_NAMESTRING =
PACKAGE_CL.addExternalSymbol("ENOUGH-NAMESTRING");
public static final Symbol ENSURE_DIRECTORIES_EXIST =
PACKAGE_CL.addExternalSymbol("ENSURE-DIRECTORIES-EXIST");
public static final Symbol ENSURE_GENERIC_FUNCTION =
PACKAGE_CL.addExternalSymbol("ENSURE-GENERIC-FUNCTION");
public static final Symbol EQ =
PACKAGE_CL.addExternalSymbol("EQ");
public static final Symbol EQL =
PACKAGE_CL.addExternalSymbol("EQL");
public static final Symbol EQUAL =
PACKAGE_CL.addExternalSymbol("EQUAL");
public static final Symbol EQUALP =
PACKAGE_CL.addExternalSymbol("EQUALP");
public static final Symbol ERROR =
PACKAGE_CL.addExternalSymbol("ERROR");
public static final Symbol ETYPECASE =
PACKAGE_CL.addExternalSymbol("ETYPECASE");
public static final Symbol EVAL =
PACKAGE_CL.addExternalSymbol("EVAL");
public static final Symbol EVAL_WHEN =
PACKAGE_CL.addExternalSymbol("EVAL-WHEN");
public static final Symbol EVENP =
PACKAGE_CL.addExternalSymbol("EVENP");
public static final Symbol EVERY =
PACKAGE_CL.addExternalSymbol("EVERY");
public static final Symbol EXP =
PACKAGE_CL.addExternalSymbol("EXP");
public static final Symbol EXPORT =
PACKAGE_CL.addExternalSymbol("EXPORT");
public static final Symbol EXPT =
PACKAGE_CL.addExternalSymbol("EXPT");
public static final Symbol EXTENDED_CHAR =
PACKAGE_CL.addExternalSymbol("EXTENDED-CHAR");
public static final Symbol FBOUNDP =
PACKAGE_CL.addExternalSymbol("FBOUNDP");
public static final Symbol FCEILING =
PACKAGE_CL.addExternalSymbol("FCEILING");
public static final Symbol FDEFINITION =
PACKAGE_CL.addExternalSymbol("FDEFINITION");
public static final Symbol FFLOOR =
PACKAGE_CL.addExternalSymbol("FFLOOR");
public static final Symbol FIFTH =
PACKAGE_CL.addExternalSymbol("FIFTH");
public static final Symbol FILE_AUTHOR =
PACKAGE_CL.addExternalSymbol("FILE-AUTHOR");
public static final Symbol FILE_ERROR =
PACKAGE_CL.addExternalSymbol("FILE-ERROR");
public static final Symbol FILE_ERROR_PATHNAME =
PACKAGE_CL.addExternalSymbol("FILE-ERROR-PATHNAME");
public static final Symbol FILE_LENGTH =
PACKAGE_CL.addExternalSymbol("FILE-LENGTH");
public static final Symbol FILE_NAMESTRING =
PACKAGE_CL.addExternalSymbol("FILE-NAMESTRING");
public static final Symbol FILE_POSITION =
PACKAGE_CL.addExternalSymbol("FILE-POSITION");
public static final Symbol FILE_STREAM =
PACKAGE_CL.addExternalSymbol("FILE-STREAM");
public static final Symbol FILE_STRING_LENGTH =
PACKAGE_CL.addExternalSymbol("FILE-STRING-LENGTH");
public static final Symbol FILE_WRITE_DATE =
PACKAGE_CL.addExternalSymbol("FILE-WRITE-DATE");
public static final Symbol FILL =
PACKAGE_CL.addExternalSymbol("FILL");
public static final Symbol FILL_POINTER =
PACKAGE_CL.addExternalSymbol("FILL-POINTER");
public static final Symbol FIND =
PACKAGE_CL.addExternalSymbol("FIND");
public static final Symbol FIND_ALL_SYMBOLS =
PACKAGE_CL.addExternalSymbol("FIND-ALL-SYMBOLS");
public static final Symbol FIND_CLASS =
PACKAGE_CL.addExternalSymbol("FIND-CLASS");
public static final Symbol FIND_IF =
PACKAGE_CL.addExternalSymbol("FIND-IF");
public static final Symbol FIND_IF_NOT =
PACKAGE_CL.addExternalSymbol("FIND-IF-NOT");
public static final Symbol FIND_METHOD =
PACKAGE_CL.addExternalSymbol("FIND-METHOD");
public static final Symbol FIND_PACKAGE =
PACKAGE_CL.addExternalSymbol("FIND-PACKAGE");
public static final Symbol FIND_RESTART =
PACKAGE_CL.addExternalSymbol("FIND-RESTART");
public static final Symbol FIND_SYMBOL =
PACKAGE_CL.addExternalSymbol("FIND-SYMBOL");
public static final Symbol FINISH_OUTPUT =
PACKAGE_CL.addExternalSymbol("FINISH-OUTPUT");
public static final Symbol FIRST =
PACKAGE_CL.addExternalSymbol("FIRST");
public static final Symbol FIXNUM =
PACKAGE_CL.addExternalSymbol("FIXNUM");
public static final Symbol FLET =
PACKAGE_CL.addExternalSymbol("FLET");
public static final Symbol FLOAT =
PACKAGE_CL.addExternalSymbol("FLOAT");
public static final Symbol FLOAT_DIGITS =
PACKAGE_CL.addExternalSymbol("FLOAT-DIGITS");
public static final Symbol FLOAT_PRECISION =
PACKAGE_CL.addExternalSymbol("FLOAT-PRECISION");
public static final Symbol FLOAT_RADIX =
PACKAGE_CL.addExternalSymbol("FLOAT-RADIX");
public static final Symbol FLOAT_SIGN =
PACKAGE_CL.addExternalSymbol("FLOAT-SIGN");
public static final Symbol FLOATING_POINT_INEXACT =
PACKAGE_CL.addExternalSymbol("FLOATING-POINT-INEXACT");
public static final Symbol FLOATING_POINT_INVALID_OPERATION =
PACKAGE_CL.addExternalSymbol("FLOATING-POINT-INVALID-OPERATION");
public static final Symbol FLOATING_POINT_OVERFLOW =
PACKAGE_CL.addExternalSymbol("FLOATING-POINT-OVERFLOW");
public static final Symbol FLOATING_POINT_UNDERFLOW =
PACKAGE_CL.addExternalSymbol("FLOATING-POINT-UNDERFLOW");
public static final Symbol FLOATP =
PACKAGE_CL.addExternalSymbol("FLOATP");
public static final Symbol FLOOR =
PACKAGE_CL.addExternalSymbol("FLOOR");
public static final Symbol FMAKUNBOUND =
PACKAGE_CL.addExternalSymbol("FMAKUNBOUND");
public static final Symbol FORCE_OUTPUT =
PACKAGE_CL.addExternalSymbol("FORCE-OUTPUT");
public static final Symbol FORMAT =
PACKAGE_CL.addExternalSymbol("FORMAT");
public static final Symbol FORMATTER =
PACKAGE_CL.addExternalSymbol("FORMATTER");
public static final Symbol FOURTH =
PACKAGE_CL.addExternalSymbol("FOURTH");
public static final Symbol FRESH_LINE =
PACKAGE_CL.addExternalSymbol("FRESH-LINE");
public static final Symbol FROUND =
PACKAGE_CL.addExternalSymbol("FROUND");
public static final Symbol FTRUNCATE =
PACKAGE_CL.addExternalSymbol("FTRUNCATE");
public static final Symbol FTYPE =
PACKAGE_CL.addExternalSymbol("FTYPE");
public static final Symbol FUNCALL =
PACKAGE_CL.addExternalSymbol("FUNCALL");
public static final Symbol FUNCTION =
PACKAGE_CL.addExternalSymbol("FUNCTION");
public static final Symbol FUNCTION_KEYWORDS =
PACKAGE_CL.addExternalSymbol("FUNCTION-KEYWORDS");
public static final Symbol FUNCTION_LAMBDA_EXPRESSION =
PACKAGE_CL.addExternalSymbol("FUNCTION-LAMBDA-EXPRESSION");
public static final Symbol FUNCTIONP =
PACKAGE_CL.addExternalSymbol("FUNCTIONP");
public static final Symbol GCD =
PACKAGE_CL.addExternalSymbol("GCD");
public static final Symbol GENERIC_FUNCTION =
PACKAGE_CL.addExternalSymbol("GENERIC-FUNCTION");
public static final Symbol GENSYM =
PACKAGE_CL.addExternalSymbol("GENSYM");
public static final Symbol GENTEMP =
PACKAGE_CL.addExternalSymbol("GENTEMP");
public static final Symbol GET =
PACKAGE_CL.addExternalSymbol("GET");
public static final Symbol GET_DECODED_TIME =
PACKAGE_CL.addExternalSymbol("GET-DECODED-TIME");
public static final Symbol GET_DISPATCH_MACRO_CHARACTER =
PACKAGE_CL.addExternalSymbol("GET-DISPATCH-MACRO-CHARACTER");
public static final Symbol GET_INTERNAL_REAL_TIME =
PACKAGE_CL.addExternalSymbol("GET-INTERNAL-REAL-TIME");
public static final Symbol GET_INTERNAL_RUN_TIME =
PACKAGE_CL.addExternalSymbol("GET-INTERNAL-RUN-TIME");
public static final Symbol GET_MACRO_CHARACTER =
PACKAGE_CL.addExternalSymbol("GET-MACRO-CHARACTER");
public static final Symbol GET_OUTPUT_STREAM_STRING =
PACKAGE_CL.addExternalSymbol("GET-OUTPUT-STREAM-STRING");
public static final Symbol GET_PROPERTIES =
PACKAGE_CL.addExternalSymbol("GET-PROPERTIES");
public static final Symbol GET_SETF_EXPANSION =
PACKAGE_CL.addExternalSymbol("GET-SETF-EXPANSION");
public static final Symbol GET_UNIVERSAL_TIME =
PACKAGE_CL.addExternalSymbol("GET-UNIVERSAL-TIME");
public static final Symbol GETF =
PACKAGE_CL.addExternalSymbol("GETF");
public static final Symbol GETHASH =
PACKAGE_CL.addExternalSymbol("GETHASH");
public static final Symbol GO =
PACKAGE_CL.addExternalSymbol("GO");
public static final Symbol GRAPHIC_CHAR_P =
PACKAGE_CL.addExternalSymbol("GRAPHIC-CHAR-P");
public static final Symbol HANDLER_BIND =
PACKAGE_CL.addExternalSymbol("HANDLER-BIND");
public static final Symbol HANDLER_CASE =
PACKAGE_CL.addExternalSymbol("HANDLER-CASE");
public static final Symbol HASH_TABLE =
PACKAGE_CL.addExternalSymbol("HASH-TABLE");
public static final Symbol HASH_TABLE_COUNT =
PACKAGE_CL.addExternalSymbol("HASH-TABLE-COUNT");
public static final Symbol HASH_TABLE_P =
PACKAGE_CL.addExternalSymbol("HASH-TABLE-P");
public static final Symbol HASH_TABLE_REHASH_SIZE =
PACKAGE_CL.addExternalSymbol("HASH-TABLE-REHASH-SIZE");
public static final Symbol HASH_TABLE_REHASH_THRESHOLD =
PACKAGE_CL.addExternalSymbol("HASH-TABLE-REHASH-THRESHOLD");
public static final Symbol HASH_TABLE_SIZE =
PACKAGE_CL.addExternalSymbol("HASH-TABLE-SIZE");
public static final Symbol HASH_TABLE_TEST =
PACKAGE_CL.addExternalSymbol("HASH-TABLE-TEST");
public static final Symbol HOST_NAMESTRING =
PACKAGE_CL.addExternalSymbol("HOST-NAMESTRING");
public static final Symbol IDENTITY =
PACKAGE_CL.addExternalSymbol("IDENTITY");
public static final Symbol IF =
PACKAGE_CL.addExternalSymbol("IF");
public static final Symbol IGNORABLE =
PACKAGE_CL.addExternalSymbol("IGNORABLE");
public static final Symbol IGNORE =
PACKAGE_CL.addExternalSymbol("IGNORE");
public static final Symbol IGNORE_ERRORS =
PACKAGE_CL.addExternalSymbol("IGNORE-ERRORS");
public static final Symbol IMAGPART =
PACKAGE_CL.addExternalSymbol("IMAGPART");
public static final Symbol IMPORT =
PACKAGE_CL.addExternalSymbol("IMPORT");
public static final Symbol IN_PACKAGE =
PACKAGE_CL.addExternalSymbol("IN-PACKAGE");
public static final Symbol INCF =
PACKAGE_CL.addExternalSymbol("INCF");
public static final Symbol INITIALIZE_INSTANCE =
PACKAGE_CL.addExternalSymbol("INITIALIZE-INSTANCE");
public static final Symbol INLINE =
PACKAGE_CL.addExternalSymbol("INLINE");
public static final Symbol INPUT_STREAM_P =
PACKAGE_CL.addExternalSymbol("INPUT-STREAM-P");
public static final Symbol INSPECT =
PACKAGE_CL.addExternalSymbol("INSPECT");
public static final Symbol INTEGER =
PACKAGE_CL.addExternalSymbol("INTEGER");
public static final Symbol INTEGER_DECODE_FLOAT =
PACKAGE_CL.addExternalSymbol("INTEGER-DECODE-FLOAT");
public static final Symbol INTEGER_LENGTH =
PACKAGE_CL.addExternalSymbol("INTEGER-LENGTH");
public static final Symbol INTEGERP =
PACKAGE_CL.addExternalSymbol("INTEGERP");
public static final Symbol INTERACTIVE_STREAM_P =
PACKAGE_CL.addExternalSymbol("INTERACTIVE-STREAM-P");
public static final Symbol INTERN =
PACKAGE_CL.addExternalSymbol("INTERN");
public static final Symbol INTERNAL_TIME_UNITS_PER_SECOND =
PACKAGE_CL.addExternalSymbol("INTERNAL-TIME-UNITS-PER-SECOND");
public static final Symbol INTERSECTION =
PACKAGE_CL.addExternalSymbol("INTERSECTION");
public static final Symbol INVALID_METHOD_ERROR =
PACKAGE_CL.addExternalSymbol("INVALID-METHOD-ERROR");
public static final Symbol INVOKE_DEBUGGER =
PACKAGE_CL.addExternalSymbol("INVOKE-DEBUGGER");
public static final Symbol INVOKE_RESTART =
PACKAGE_CL.addExternalSymbol("INVOKE-RESTART");
public static final Symbol INVOKE_RESTART_INTERACTIVELY =
PACKAGE_CL.addExternalSymbol("INVOKE-RESTART-INTERACTIVELY");
public static final Symbol ISQRT =
PACKAGE_CL.addExternalSymbol("ISQRT");
public static final Symbol KEYWORD =
PACKAGE_CL.addExternalSymbol("KEYWORD");
public static final Symbol KEYWORDP =
PACKAGE_CL.addExternalSymbol("KEYWORDP");
public static final Symbol LABELS =
PACKAGE_CL.addExternalSymbol("LABELS");
public static final Symbol LAMBDA =
PACKAGE_CL.addExternalSymbol("LAMBDA");
public static final Symbol LAMBDA_LIST_KEYWORDS =
PACKAGE_CL.addExternalSymbol("LAMBDA-LIST-KEYWORDS");
public static final Symbol LAMBDA_PARAMETERS_LIMIT =
PACKAGE_CL.addExternalSymbol("LAMBDA-PARAMETERS-LIMIT");
public static final Symbol LAST =
PACKAGE_CL.addExternalSymbol("LAST");
public static final Symbol LCM =
PACKAGE_CL.addExternalSymbol("LCM");
public static final Symbol LDB =
PACKAGE_CL.addExternalSymbol("LDB");
public static final Symbol LDB_TEST =
PACKAGE_CL.addExternalSymbol("LDB-TEST");
public static final Symbol LDIFF =
PACKAGE_CL.addExternalSymbol("LDIFF");
public static final Symbol LEAST_NEGATIVE_DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-DOUBLE-FLOAT");
public static final Symbol LEAST_NEGATIVE_LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-LONG-FLOAT");
public static final Symbol LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT");
public static final Symbol LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT");
public static final Symbol LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT");
public static final Symbol LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT");
public static final Symbol LEAST_NEGATIVE_SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-SHORT-FLOAT");
public static final Symbol LEAST_NEGATIVE_SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-SINGLE-FLOAT");
public static final Symbol LEAST_POSITIVE_DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-DOUBLE-FLOAT");
public static final Symbol LEAST_POSITIVE_LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-LONG-FLOAT");
public static final Symbol LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT");
public static final Symbol LEAST_POSITIVE_NORMALIZED_LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-LONG-FLOAT");
public static final Symbol LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT");
public static final Symbol LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT");
public static final Symbol LEAST_POSITIVE_SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-SHORT-FLOAT");
public static final Symbol LEAST_POSITIVE_SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-SINGLE-FLOAT");
public static final Symbol LENGTH =
PACKAGE_CL.addExternalSymbol("LENGTH");
public static final Symbol LET =
PACKAGE_CL.addExternalSymbol("LET");
public static final Symbol LET_STAR =
PACKAGE_CL.addExternalSymbol("LET*");
public static final Symbol LISP_IMPLEMENTATION_TYPE =
PACKAGE_CL.addExternalSymbol("LISP-IMPLEMENTATION-TYPE");
public static final Symbol LISP_IMPLEMENTATION_VERSION =
PACKAGE_CL.addExternalSymbol("LISP-IMPLEMENTATION-VERSION");
public static final Symbol LIST =
PACKAGE_CL.addExternalSymbol("LIST");
public static final Symbol LIST_STAR =
PACKAGE_CL.addExternalSymbol("LIST*");
public static final Symbol LIST_ALL_PACKAGES =
PACKAGE_CL.addExternalSymbol("LIST-ALL-PACKAGES");
public static final Symbol LIST_LENGTH =
PACKAGE_CL.addExternalSymbol("LIST-LENGTH");
public static final Symbol LISTEN =
PACKAGE_CL.addExternalSymbol("LISTEN");
public static final Symbol LISTP =
PACKAGE_CL.addExternalSymbol("LISTP");
public static final Symbol LOAD =
PACKAGE_CL.addExternalSymbol("LOAD");
public static final Symbol LOAD_LOGICAL_PATHNAME_TRANSLATIONS =
PACKAGE_CL.addExternalSymbol("LOAD-LOGICAL-PATHNAME-TRANSLATIONS");
public static final Symbol LOAD_TIME_VALUE =
PACKAGE_CL.addExternalSymbol("LOAD-TIME-VALUE");
public static final Symbol LOCALLY =
PACKAGE_CL.addExternalSymbol("LOCALLY");
public static final Symbol LOG =
PACKAGE_CL.addExternalSymbol("LOG");
public static final Symbol LOGAND =
PACKAGE_CL.addExternalSymbol("LOGAND");
public static final Symbol LOGANDC1 =
PACKAGE_CL.addExternalSymbol("LOGANDC1");
public static final Symbol LOGANDC2 =
PACKAGE_CL.addExternalSymbol("LOGANDC2");
public static final Symbol LOGBITP =
PACKAGE_CL.addExternalSymbol("LOGBITP");
public static final Symbol LOGCOUNT =
PACKAGE_CL.addExternalSymbol("LOGCOUNT");
public static final Symbol LOGEQV =
PACKAGE_CL.addExternalSymbol("LOGEQV");
public static final Symbol LOGICAL_PATHNAME =
PACKAGE_CL.addExternalSymbol("LOGICAL-PATHNAME");
public static final Symbol LOGICAL_PATHNAME_TRANSLATIONS =
PACKAGE_CL.addExternalSymbol("LOGICAL-PATHNAME-TRANSLATIONS");
public static final Symbol LOGIOR =
PACKAGE_CL.addExternalSymbol("LOGIOR");
public static final Symbol LOGNAND =
PACKAGE_CL.addExternalSymbol("LOGNAND");
public static final Symbol LOGNOR =
PACKAGE_CL.addExternalSymbol("LOGNOR");
public static final Symbol LOGNOT =
PACKAGE_CL.addExternalSymbol("LOGNOT");
public static final Symbol LOGORC1 =
PACKAGE_CL.addExternalSymbol("LOGORC1");
public static final Symbol LOGORC2 =
PACKAGE_CL.addExternalSymbol("LOGORC2");
public static final Symbol LOGTEST =
PACKAGE_CL.addExternalSymbol("LOGTEST");
public static final Symbol LOGXOR =
PACKAGE_CL.addExternalSymbol("LOGXOR");
public static final Symbol LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("LONG-FLOAT");
public static final Symbol LONG_FLOAT_EPSILON =
PACKAGE_CL.addExternalSymbol("LONG-FLOAT-EPSILON");
public static final Symbol LONG_FLOAT_NEGATIVE_EPSILON =
PACKAGE_CL.addExternalSymbol("LONG-FLOAT-NEGATIVE-EPSILON");
public static final Symbol LONG_SITE_NAME =
PACKAGE_CL.addExternalSymbol("LONG-SITE-NAME");
public static final Symbol LOOP =
PACKAGE_CL.addExternalSymbol("LOOP");
public static final Symbol LOOP_FINISH =
PACKAGE_CL.addExternalSymbol("LOOP-FINISH");
public static final Symbol LOWER_CASE_P =
PACKAGE_CL.addExternalSymbol("LOWER-CASE-P");
public static final Symbol MACHINE_INSTANCE =
PACKAGE_CL.addExternalSymbol("MACHINE-INSTANCE");
public static final Symbol MACHINE_TYPE =
PACKAGE_CL.addExternalSymbol("MACHINE-TYPE");
public static final Symbol MACHINE_VERSION =
PACKAGE_CL.addExternalSymbol("MACHINE-VERSION");
public static final Symbol MACRO_FUNCTION =
PACKAGE_CL.addExternalSymbol("MACRO-FUNCTION");
public static final Symbol MACROEXPAND =
PACKAGE_CL.addExternalSymbol("MACROEXPAND");
public static final Symbol MACROEXPAND_1 =
PACKAGE_CL.addExternalSymbol("MACROEXPAND-1");
public static final Symbol MACROLET =
PACKAGE_CL.addExternalSymbol("MACROLET");
public static final Symbol MAKE_ARRAY =
PACKAGE_CL.addExternalSymbol("MAKE-ARRAY");
public static final Symbol MAKE_BROADCAST_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-BROADCAST-STREAM");
public static final Symbol MAKE_CONCATENATED_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-CONCATENATED-STREAM");
public static final Symbol MAKE_CONDITION =
PACKAGE_CL.addExternalSymbol("MAKE-CONDITION");
public static final Symbol MAKE_DISPATCH_MACRO_CHARACTER =
PACKAGE_CL.addExternalSymbol("MAKE-DISPATCH-MACRO-CHARACTER");
public static final Symbol MAKE_ECHO_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-ECHO-STREAM");
public static final Symbol MAKE_HASH_TABLE =
PACKAGE_CL.addExternalSymbol("MAKE-HASH-TABLE");
public static final Symbol MAKE_INSTANCE =
PACKAGE_CL.addExternalSymbol("MAKE-INSTANCE");
public static final Symbol MAKE_INSTANCES_OBSOLETE =
PACKAGE_CL.addExternalSymbol("MAKE-INSTANCES-OBSOLETE");
public static final Symbol MAKE_LIST =
PACKAGE_CL.addExternalSymbol("MAKE-LIST");
public static final Symbol MAKE_LOAD_FORM =
PACKAGE_CL.addExternalSymbol("MAKE-LOAD-FORM");
public static final Symbol MAKE_LOAD_FORM_SAVING_SLOTS =
PACKAGE_CL.addExternalSymbol("MAKE-LOAD-FORM-SAVING-SLOTS");
public static final Symbol MAKE_METHOD =
PACKAGE_CL.addExternalSymbol("MAKE-METHOD");
public static final Symbol MAKE_PACKAGE =
PACKAGE_CL.addExternalSymbol("MAKE-PACKAGE");
public static final Symbol MAKE_PATHNAME =
PACKAGE_CL.addExternalSymbol("MAKE-PATHNAME");
public static final Symbol MAKE_RANDOM_STATE =
PACKAGE_CL.addExternalSymbol("MAKE-RANDOM-STATE");
public static final Symbol MAKE_SEQUENCE =
PACKAGE_CL.addExternalSymbol("MAKE-SEQUENCE");
public static final Symbol MAKE_STRING =
PACKAGE_CL.addExternalSymbol("MAKE-STRING");
public static final Symbol MAKE_STRING_INPUT_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-STRING-INPUT-STREAM");
public static final Symbol MAKE_STRING_OUTPUT_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-STRING-OUTPUT-STREAM");
public static final Symbol MAKE_SYMBOL =
PACKAGE_CL.addExternalSymbol("MAKE-SYMBOL");
public static final Symbol MAKE_SYNONYM_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-SYNONYM-STREAM");
public static final Symbol MAKE_TWO_WAY_STREAM =
PACKAGE_CL.addExternalSymbol("MAKE-TWO-WAY-STREAM");
public static final Symbol MAKUNBOUND =
PACKAGE_CL.addExternalSymbol("MAKUNBOUND");
public static final Symbol MAP =
PACKAGE_CL.addExternalSymbol("MAP");
public static final Symbol MAP_INTO =
PACKAGE_CL.addExternalSymbol("MAP-INTO");
public static final Symbol MAPC =
PACKAGE_CL.addExternalSymbol("MAPC");
public static final Symbol MAPCAN =
PACKAGE_CL.addExternalSymbol("MAPCAN");
public static final Symbol MAPCAR =
PACKAGE_CL.addExternalSymbol("MAPCAR");
public static final Symbol MAPCON =
PACKAGE_CL.addExternalSymbol("MAPCON");
public static final Symbol MAPHASH =
PACKAGE_CL.addExternalSymbol("MAPHASH");
public static final Symbol MAPL =
PACKAGE_CL.addExternalSymbol("MAPL");
public static final Symbol MAPLIST =
PACKAGE_CL.addExternalSymbol("MAPLIST");
public static final Symbol MASK_FIELD =
PACKAGE_CL.addExternalSymbol("MASK-FIELD");
public static final Symbol MAX =
PACKAGE_CL.addExternalSymbol("MAX");
public static final Symbol MEMBER =
PACKAGE_CL.addExternalSymbol("MEMBER");
public static final Symbol MEMBER_IF =
PACKAGE_CL.addExternalSymbol("MEMBER-IF");
public static final Symbol MEMBER_IF_NOT =
PACKAGE_CL.addExternalSymbol("MEMBER-IF-NOT");
public static final Symbol MERGE =
PACKAGE_CL.addExternalSymbol("MERGE");
public static final Symbol MERGE_PATHNAMES =
PACKAGE_CL.addExternalSymbol("MERGE-PATHNAMES");
public static final Symbol METHOD =
PACKAGE_CL.addExternalSymbol("METHOD");
public static final Symbol METHOD_COMBINATION =
PACKAGE_CL.addExternalSymbol("METHOD-COMBINATION");
public static final Symbol METHOD_COMBINATION_ERROR =
PACKAGE_CL.addExternalSymbol("METHOD-COMBINATION-ERROR");
public static final Symbol METHOD_QUALIFIERS =
PACKAGE_CL.addExternalSymbol("METHOD-QUALIFIERS");
public static final Symbol MIN =
PACKAGE_CL.addExternalSymbol("MIN");
public static final Symbol MINUSP =
PACKAGE_CL.addExternalSymbol("MINUSP");
public static final Symbol MISMATCH =
PACKAGE_CL.addExternalSymbol("MISMATCH");
public static final Symbol MOD =
PACKAGE_CL.addExternalSymbol("MOD");
public static final Symbol MOST_NEGATIVE_DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-DOUBLE-FLOAT");
public static final Symbol MOST_NEGATIVE_FIXNUM =
PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-FIXNUM");
public static final Symbol MOST_NEGATIVE_LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-LONG-FLOAT");
public static final Symbol MOST_NEGATIVE_SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-SHORT-FLOAT");
public static final Symbol MOST_NEGATIVE_SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-SINGLE-FLOAT");
public static final Symbol MOST_POSITIVE_DOUBLE_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-DOUBLE-FLOAT");
public static final Symbol MOST_POSITIVE_FIXNUM =
PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-FIXNUM");
public static final Symbol MOST_POSITIVE_LONG_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-LONG-FLOAT");
public static final Symbol MOST_POSITIVE_SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-SHORT-FLOAT");
public static final Symbol MOST_POSITIVE_SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-SINGLE-FLOAT");
public static final Symbol MUFFLE_WARNING =
PACKAGE_CL.addExternalSymbol("MUFFLE-WARNING");
public static final Symbol MULTIPLE_VALUE_BIND =
PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-BIND");
public static final Symbol MULTIPLE_VALUE_CALL =
PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-CALL");
public static final Symbol MULTIPLE_VALUE_LIST =
PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-LIST");
public static final Symbol MULTIPLE_VALUE_PROG1 =
PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-PROG1");
public static final Symbol MULTIPLE_VALUE_SETQ =
PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-SETQ");
public static final Symbol MULTIPLE_VALUES_LIMIT =
PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUES-LIMIT");
public static final Symbol NAME_CHAR =
PACKAGE_CL.addExternalSymbol("NAME-CHAR");
public static final Symbol NAMESTRING =
PACKAGE_CL.addExternalSymbol("NAMESTRING");
public static final Symbol NBUTLAST =
PACKAGE_CL.addExternalSymbol("NBUTLAST");
public static final Symbol NCONC =
PACKAGE_CL.addExternalSymbol("NCONC");
public static final Symbol NEXT_METHOD_P =
PACKAGE_CL.addExternalSymbol("NEXT-METHOD-P");
// NIL is a special case.
// public static final Symbol NIL =
// PACKAGE_CL.addExternalSymbol("NIL");
public static final Symbol NINTERSECTION =
PACKAGE_CL.addExternalSymbol("NINTERSECTION");
public static final Symbol NINTH =
PACKAGE_CL.addExternalSymbol("NINTH");
public static final Symbol NO_APPLICABLE_METHOD =
PACKAGE_CL.addExternalSymbol("NO-APPLICABLE-METHOD");
public static final Symbol NO_NEXT_METHOD =
PACKAGE_CL.addExternalSymbol("NO-NEXT-METHOD");
public static final Symbol NOT =
PACKAGE_CL.addExternalSymbol("NOT");
public static final Symbol NOTANY =
PACKAGE_CL.addExternalSymbol("NOTANY");
public static final Symbol NOTEVERY =
PACKAGE_CL.addExternalSymbol("NOTEVERY");
public static final Symbol NOTINLINE =
PACKAGE_CL.addExternalSymbol("NOTINLINE");
public static final Symbol NRECONC =
PACKAGE_CL.addExternalSymbol("NRECONC");
public static final Symbol NREVERSE =
PACKAGE_CL.addExternalSymbol("NREVERSE");
public static final Symbol NSET_DIFFERENCE =
PACKAGE_CL.addExternalSymbol("NSET-DIFFERENCE");
public static final Symbol NSET_EXCLUSIVE_OR =
PACKAGE_CL.addExternalSymbol("NSET-EXCLUSIVE-OR");
public static final Symbol NSTRING_CAPITALIZE =
PACKAGE_CL.addExternalSymbol("NSTRING-CAPITALIZE");
public static final Symbol NSTRING_DOWNCASE =
PACKAGE_CL.addExternalSymbol("NSTRING-DOWNCASE");
public static final Symbol NSTRING_UPCASE =
PACKAGE_CL.addExternalSymbol("NSTRING-UPCASE");
public static final Symbol NSUBLIS =
PACKAGE_CL.addExternalSymbol("NSUBLIS");
public static final Symbol NSUBST =
PACKAGE_CL.addExternalSymbol("NSUBST");
public static final Symbol NSUBST_IF =
PACKAGE_CL.addExternalSymbol("NSUBST-IF");
public static final Symbol NSUBST_IF_NOT =
PACKAGE_CL.addExternalSymbol("NSUBST-IF-NOT");
public static final Symbol NSUBSTITUTE =
PACKAGE_CL.addExternalSymbol("NSUBSTITUTE");
public static final Symbol NSUBSTITUTE_IF =
PACKAGE_CL.addExternalSymbol("NSUBSTITUTE-IF");
public static final Symbol NSUBSTITUTE_IF_NOT =
PACKAGE_CL.addExternalSymbol("NSUBSTITUTE-IF-NOT");
public static final Symbol NTH =
PACKAGE_CL.addExternalSymbol("NTH");
public static final Symbol NTH_VALUE =
PACKAGE_CL.addExternalSymbol("NTH-VALUE");
public static final Symbol NTHCDR =
PACKAGE_CL.addExternalSymbol("NTHCDR");
public static final Symbol NULL =
PACKAGE_CL.addExternalSymbol("NULL");
public static final Symbol NUMBER =
PACKAGE_CL.addExternalSymbol("NUMBER");
public static final Symbol NUMBERP =
PACKAGE_CL.addExternalSymbol("NUMBERP");
public static final Symbol NUMERATOR =
PACKAGE_CL.addExternalSymbol("NUMERATOR");
public static final Symbol NUNION =
PACKAGE_CL.addExternalSymbol("NUNION");
public static final Symbol ODDP =
PACKAGE_CL.addExternalSymbol("ODDP");
public static final Symbol OPEN =
PACKAGE_CL.addExternalSymbol("OPEN");
public static final Symbol OPEN_STREAM_P =
PACKAGE_CL.addExternalSymbol("OPEN-STREAM-P");
public static final Symbol OPTIMIZE =
PACKAGE_CL.addExternalSymbol("OPTIMIZE");
public static final Symbol OR =
PACKAGE_CL.addExternalSymbol("OR");
public static final Symbol OTHERWISE =
PACKAGE_CL.addExternalSymbol("OTHERWISE");
public static final Symbol OUTPUT_STREAM_P =
PACKAGE_CL.addExternalSymbol("OUTPUT-STREAM-P");
public static final Symbol PACKAGE =
PACKAGE_CL.addExternalSymbol("PACKAGE");
public static final Symbol PACKAGE_ERROR =
PACKAGE_CL.addExternalSymbol("PACKAGE-ERROR");
public static final Symbol PACKAGE_ERROR_PACKAGE =
PACKAGE_CL.addExternalSymbol("PACKAGE-ERROR-PACKAGE");
public static final Symbol PACKAGE_NAME =
PACKAGE_CL.addExternalSymbol("PACKAGE-NAME");
public static final Symbol PACKAGE_NICKNAMES =
PACKAGE_CL.addExternalSymbol("PACKAGE-NICKNAMES");
public static final Symbol PACKAGE_SHADOWING_SYMBOLS =
PACKAGE_CL.addExternalSymbol("PACKAGE-SHADOWING-SYMBOLS");
public static final Symbol PACKAGE_USE_LIST =
PACKAGE_CL.addExternalSymbol("PACKAGE-USE-LIST");
public static final Symbol PACKAGE_USED_BY_LIST =
PACKAGE_CL.addExternalSymbol("PACKAGE-USED-BY-LIST");
public static final Symbol PACKAGEP =
PACKAGE_CL.addExternalSymbol("PACKAGEP");
public static final Symbol PAIRLIS =
PACKAGE_CL.addExternalSymbol("PAIRLIS");
public static final Symbol PARSE_ERROR =
PACKAGE_CL.addExternalSymbol("PARSE-ERROR");
public static final Symbol PARSE_INTEGER =
PACKAGE_CL.addExternalSymbol("PARSE-INTEGER");
public static final Symbol PARSE_NAMESTRING =
PACKAGE_CL.addExternalSymbol("PARSE-NAMESTRING");
public static final Symbol PATHNAME =
PACKAGE_CL.addExternalSymbol("PATHNAME");
public static final Symbol PATHNAME_DEVICE =
PACKAGE_CL.addExternalSymbol("PATHNAME-DEVICE");
public static final Symbol PATHNAME_DIRECTORY =
PACKAGE_CL.addExternalSymbol("PATHNAME-DIRECTORY");
public static final Symbol PATHNAME_HOST =
PACKAGE_CL.addExternalSymbol("PATHNAME-HOST");
public static final Symbol PATHNAME_MATCH_P =
PACKAGE_CL.addExternalSymbol("PATHNAME-MATCH-P");
public static final Symbol PATHNAME_NAME =
PACKAGE_CL.addExternalSymbol("PATHNAME-NAME");
public static final Symbol PATHNAME_TYPE =
PACKAGE_CL.addExternalSymbol("PATHNAME-TYPE");
public static final Symbol PATHNAME_VERSION =
PACKAGE_CL.addExternalSymbol("PATHNAME-VERSION");
public static final Symbol PATHNAMEP =
PACKAGE_CL.addExternalSymbol("PATHNAMEP");
public static final Symbol PEEK_CHAR =
PACKAGE_CL.addExternalSymbol("PEEK-CHAR");
public static final Symbol PHASE =
PACKAGE_CL.addExternalSymbol("PHASE");
public static final Symbol PI =
PACKAGE_CL.addExternalSymbol("PI");
public static final Symbol PLUSP =
PACKAGE_CL.addExternalSymbol("PLUSP");
public static final Symbol POP =
PACKAGE_CL.addExternalSymbol("POP");
public static final Symbol POSITION =
PACKAGE_CL.addExternalSymbol("POSITION");
public static final Symbol POSITION_IF =
PACKAGE_CL.addExternalSymbol("POSITION-IF");
public static final Symbol POSITION_IF_NOT =
PACKAGE_CL.addExternalSymbol("POSITION-IF-NOT");
public static final Symbol PPRINT =
PACKAGE_CL.addExternalSymbol("PPRINT");
public static final Symbol PPRINT_DISPATCH =
PACKAGE_CL.addExternalSymbol("PPRINT-DISPATCH");
public static final Symbol PPRINT_EXIT_IF_LIST_EXHAUSTED =
PACKAGE_CL.addExternalSymbol("PPRINT-EXIT-IF-LIST-EXHAUSTED");
public static final Symbol PPRINT_FILL =
PACKAGE_CL.addExternalSymbol("PPRINT-FILL");
public static final Symbol PPRINT_INDENT =
PACKAGE_CL.addExternalSymbol("PPRINT-INDENT");
public static final Symbol PPRINT_LINEAR =
PACKAGE_CL.addExternalSymbol("PPRINT-LINEAR");
public static final Symbol PPRINT_LOGICAL_BLOCK =
PACKAGE_CL.addExternalSymbol("PPRINT-LOGICAL-BLOCK");
public static final Symbol PPRINT_NEWLINE =
PACKAGE_CL.addExternalSymbol("PPRINT-NEWLINE");
public static final Symbol PPRINT_POP =
PACKAGE_CL.addExternalSymbol("PPRINT-POP");
public static final Symbol PPRINT_TAB =
PACKAGE_CL.addExternalSymbol("PPRINT-TAB");
public static final Symbol PPRINT_TABULAR =
PACKAGE_CL.addExternalSymbol("PPRINT-TABULAR");
public static final Symbol PRIN1 =
PACKAGE_CL.addExternalSymbol("PRIN1");
public static final Symbol PRIN1_TO_STRING =
PACKAGE_CL.addExternalSymbol("PRIN1-TO-STRING");
public static final Symbol PRINC =
PACKAGE_CL.addExternalSymbol("PRINC");
public static final Symbol PRINC_TO_STRING =
PACKAGE_CL.addExternalSymbol("PRINC-TO-STRING");
public static final Symbol PRINT =
PACKAGE_CL.addExternalSymbol("PRINT");
public static final Symbol PRINT_NOT_READABLE =
PACKAGE_CL.addExternalSymbol("PRINT-NOT-READABLE");
public static final Symbol PRINT_NOT_READABLE_OBJECT =
PACKAGE_CL.addExternalSymbol("PRINT-NOT-READABLE-OBJECT");
public static final Symbol PRINT_OBJECT =
PACKAGE_CL.addExternalSymbol("PRINT-OBJECT");
public static final Symbol PRINT_UNREADABLE_OBJECT =
PACKAGE_CL.addExternalSymbol("PRINT-UNREADABLE-OBJECT");
public static final Symbol PROBE_FILE =
PACKAGE_CL.addExternalSymbol("PROBE-FILE");
public static final Symbol PROCLAIM =
PACKAGE_CL.addExternalSymbol("PROCLAIM");
public static final Symbol PROG =
PACKAGE_CL.addExternalSymbol("PROG");
public static final Symbol PROG_STAR =
PACKAGE_CL.addExternalSymbol("PROG*");
public static final Symbol PROG1 =
PACKAGE_CL.addExternalSymbol("PROG1");
public static final Symbol PROG2 =
PACKAGE_CL.addExternalSymbol("PROG2");
public static final Symbol PROGN =
PACKAGE_CL.addExternalSymbol("PROGN");
public static final Symbol PROGRAM_ERROR =
PACKAGE_CL.addExternalSymbol("PROGRAM-ERROR");
public static final Symbol PROGV =
PACKAGE_CL.addExternalSymbol("PROGV");
public static final Symbol PROVIDE =
PACKAGE_CL.addExternalSymbol("PROVIDE");
public static final Symbol PSETF =
PACKAGE_CL.addExternalSymbol("PSETF");
public static final Symbol PSETQ =
PACKAGE_CL.addExternalSymbol("PSETQ");
public static final Symbol PUSH =
PACKAGE_CL.addExternalSymbol("PUSH");
public static final Symbol PUSHNEW =
PACKAGE_CL.addExternalSymbol("PUSHNEW");
public static final Symbol QUOTE =
PACKAGE_CL.addExternalSymbol("QUOTE");
public static final Symbol RANDOM =
PACKAGE_CL.addExternalSymbol("RANDOM");
public static final Symbol RANDOM_STATE =
PACKAGE_CL.addExternalSymbol("RANDOM-STATE");
public static final Symbol RANDOM_STATE_P =
PACKAGE_CL.addExternalSymbol("RANDOM-STATE-P");
public static final Symbol RASSOC =
PACKAGE_CL.addExternalSymbol("RASSOC");
public static final Symbol RASSOC_IF =
PACKAGE_CL.addExternalSymbol("RASSOC-IF");
public static final Symbol RASSOC_IF_NOT =
PACKAGE_CL.addExternalSymbol("RASSOC-IF-NOT");
public static final Symbol RATIO =
PACKAGE_CL.addExternalSymbol("RATIO");
public static final Symbol RATIONAL =
PACKAGE_CL.addExternalSymbol("RATIONAL");
public static final Symbol RATIONALIZE =
PACKAGE_CL.addExternalSymbol("RATIONALIZE");
public static final Symbol RATIONALP =
PACKAGE_CL.addExternalSymbol("RATIONALP");
public static final Symbol READ =
PACKAGE_CL.addExternalSymbol("READ");
public static final Symbol READ_BYTE =
PACKAGE_CL.addExternalSymbol("READ-BYTE");
public static final Symbol READ_CHAR =
PACKAGE_CL.addExternalSymbol("READ-CHAR");
public static final Symbol READ_CHAR_NO_HANG =
PACKAGE_CL.addExternalSymbol("READ-CHAR-NO-HANG");
public static final Symbol READ_DELIMITED_LIST =
PACKAGE_CL.addExternalSymbol("READ-DELIMITED-LIST");
public static final Symbol READ_FROM_STRING =
PACKAGE_CL.addExternalSymbol("READ-FROM-STRING");
public static final Symbol READ_LINE =
PACKAGE_CL.addExternalSymbol("READ-LINE");
public static final Symbol READ_PRESERVING_WHITESPACE =
PACKAGE_CL.addExternalSymbol("READ-PRESERVING-WHITESPACE");
public static final Symbol READ_SEQUENCE =
PACKAGE_CL.addExternalSymbol("READ-SEQUENCE");
public static final Symbol READER_ERROR =
PACKAGE_CL.addExternalSymbol("READER-ERROR");
public static final Symbol READTABLE =
PACKAGE_CL.addExternalSymbol("READTABLE");
public static final Symbol READTABLE_CASE =
PACKAGE_CL.addExternalSymbol("READTABLE-CASE");
public static final Symbol READTABLEP =
PACKAGE_CL.addExternalSymbol("READTABLEP");
public static final Symbol REAL =
PACKAGE_CL.addExternalSymbol("REAL");
public static final Symbol REALP =
PACKAGE_CL.addExternalSymbol("REALP");
public static final Symbol REALPART =
PACKAGE_CL.addExternalSymbol("REALPART");
public static final Symbol REDUCE =
PACKAGE_CL.addExternalSymbol("REDUCE");
public static final Symbol REINITIALIZE_INSTANCE =
PACKAGE_CL.addExternalSymbol("REINITIALIZE-INSTANCE");
public static final Symbol REM =
PACKAGE_CL.addExternalSymbol("REM");
public static final Symbol REMF =
PACKAGE_CL.addExternalSymbol("REMF");
public static final Symbol REMHASH =
PACKAGE_CL.addExternalSymbol("REMHASH");
public static final Symbol REMOVE =
PACKAGE_CL.addExternalSymbol("REMOVE");
public static final Symbol REMOVE_DUPLICATES =
PACKAGE_CL.addExternalSymbol("REMOVE-DUPLICATES");
public static final Symbol REMOVE_IF =
PACKAGE_CL.addExternalSymbol("REMOVE-IF");
public static final Symbol REMOVE_IF_NOT =
PACKAGE_CL.addExternalSymbol("REMOVE-IF-NOT");
public static final Symbol REMOVE_METHOD =
PACKAGE_CL.addExternalSymbol("REMOVE-METHOD");
public static final Symbol REMPROP =
PACKAGE_CL.addExternalSymbol("REMPROP");
public static final Symbol RENAME_FILE =
PACKAGE_CL.addExternalSymbol("RENAME-FILE");
public static final Symbol RENAME_PACKAGE =
PACKAGE_CL.addExternalSymbol("RENAME-PACKAGE");
public static final Symbol REPLACE =
PACKAGE_CL.addExternalSymbol("REPLACE");
public static final Symbol REQUIRE =
PACKAGE_CL.addExternalSymbol("REQUIRE");
public static final Symbol REST =
PACKAGE_CL.addExternalSymbol("REST");
public static final Symbol RESTART =
PACKAGE_CL.addExternalSymbol("RESTART");
public static final Symbol RESTART_BIND =
PACKAGE_CL.addExternalSymbol("RESTART-BIND");
public static final Symbol RESTART_CASE =
PACKAGE_CL.addExternalSymbol("RESTART-CASE");
public static final Symbol RESTART_NAME =
PACKAGE_CL.addExternalSymbol("RESTART-NAME");
public static final Symbol RETURN =
PACKAGE_CL.addExternalSymbol("RETURN");
public static final Symbol RETURN_FROM =
PACKAGE_CL.addExternalSymbol("RETURN-FROM");
public static final Symbol REVAPPEND =
PACKAGE_CL.addExternalSymbol("REVAPPEND");
public static final Symbol REVERSE =
PACKAGE_CL.addExternalSymbol("REVERSE");
public static final Symbol ROOM =
PACKAGE_CL.addExternalSymbol("ROOM");
public static final Symbol ROTATEF =
PACKAGE_CL.addExternalSymbol("ROTATEF");
public static final Symbol ROUND =
PACKAGE_CL.addExternalSymbol("ROUND");
public static final Symbol ROW_MAJOR_AREF =
PACKAGE_CL.addExternalSymbol("ROW-MAJOR-AREF");
public static final Symbol RPLACA =
PACKAGE_CL.addExternalSymbol("RPLACA");
public static final Symbol RPLACD =
PACKAGE_CL.addExternalSymbol("RPLACD");
public static final Symbol SAFETY =
PACKAGE_CL.addExternalSymbol("SAFETY");
public static final Symbol SATISFIES =
PACKAGE_CL.addExternalSymbol("SATISFIES");
public static final Symbol SBIT =
PACKAGE_CL.addExternalSymbol("SBIT");
public static final Symbol SCALE_FLOAT =
PACKAGE_CL.addExternalSymbol("SCALE-FLOAT");
public static final Symbol SCHAR =
PACKAGE_CL.addExternalSymbol("SCHAR");
public static final Symbol SEARCH =
PACKAGE_CL.addExternalSymbol("SEARCH");
public static final Symbol SECOND =
PACKAGE_CL.addExternalSymbol("SECOND");
public static final Symbol SEQUENCE =
PACKAGE_CL.addExternalSymbol("SEQUENCE");
public static final Symbol SERIOUS_CONDITION =
PACKAGE_CL.addExternalSymbol("SERIOUS-CONDITION");
public static final Symbol SET =
PACKAGE_CL.addExternalSymbol("SET");
public static final Symbol SET_DIFFERENCE =
PACKAGE_CL.addExternalSymbol("SET-DIFFERENCE");
public static final Symbol SET_DISPATCH_MACRO_CHARACTER =
PACKAGE_CL.addExternalSymbol("SET-DISPATCH-MACRO-CHARACTER");
public static final Symbol SET_EXCLUSIVE_OR =
PACKAGE_CL.addExternalSymbol("SET-EXCLUSIVE-OR");
public static final Symbol SET_MACRO_CHARACTER =
PACKAGE_CL.addExternalSymbol("SET-MACRO-CHARACTER");
public static final Symbol SET_PPRINT_DISPATCH =
PACKAGE_CL.addExternalSymbol("SET-PPRINT-DISPATCH");
public static final Symbol SET_SYNTAX_FROM_CHAR =
PACKAGE_CL.addExternalSymbol("SET-SYNTAX-FROM-CHAR");
public static final Symbol SETF =
PACKAGE_CL.addExternalSymbol("SETF");
public static final Symbol SETQ =
PACKAGE_CL.addExternalSymbol("SETQ");
public static final Symbol SEVENTH =
PACKAGE_CL.addExternalSymbol("SEVENTH");
public static final Symbol SHADOW =
PACKAGE_CL.addExternalSymbol("SHADOW");
public static final Symbol SHADOWING_IMPORT =
PACKAGE_CL.addExternalSymbol("SHADOWING-IMPORT");
public static final Symbol SHARED_INITIALIZE =
PACKAGE_CL.addExternalSymbol("SHARED-INITIALIZE");
public static final Symbol SHIFTF =
PACKAGE_CL.addExternalSymbol("SHIFTF");
public static final Symbol SHORT_FLOAT =
PACKAGE_CL.addExternalSymbol("SHORT-FLOAT");
public static final Symbol SHORT_FLOAT_EPSILON =
PACKAGE_CL.addExternalSymbol("SHORT-FLOAT-EPSILON");
public static final Symbol SHORT_FLOAT_NEGATIVE_EPSILON =
PACKAGE_CL.addExternalSymbol("SHORT-FLOAT-NEGATIVE-EPSILON");
public static final Symbol SHORT_SITE_NAME =
PACKAGE_CL.addExternalSymbol("SHORT-SITE-NAME");
public static final Symbol SIGNAL =
PACKAGE_CL.addExternalSymbol("SIGNAL");
public static final Symbol SIGNED_BYTE =
PACKAGE_CL.addExternalSymbol("SIGNED-BYTE");
public static final Symbol SIGNUM =
PACKAGE_CL.addExternalSymbol("SIGNUM");
public static final Symbol SIMPLE_ARRAY =
PACKAGE_CL.addExternalSymbol("SIMPLE-ARRAY");
public static final Symbol SIMPLE_BASE_STRING =
PACKAGE_CL.addExternalSymbol("SIMPLE-BASE-STRING");
public static final Symbol SIMPLE_BIT_VECTOR =
PACKAGE_CL.addExternalSymbol("SIMPLE-BIT-VECTOR");
public static final Symbol SIMPLE_BIT_VECTOR_P =
PACKAGE_CL.addExternalSymbol("SIMPLE-BIT-VECTOR-P");
public static final Symbol SIMPLE_CONDITION =
PACKAGE_CL.addExternalSymbol("SIMPLE-CONDITION");
public static final Symbol SIMPLE_CONDITION_FORMAT_ARGUMENTS =
PACKAGE_CL.addExternalSymbol("SIMPLE-CONDITION-FORMAT-ARGUMENTS");
public static final Symbol SIMPLE_CONDITION_FORMAT_CONTROL =
PACKAGE_CL.addExternalSymbol("SIMPLE-CONDITION-FORMAT-CONTROL");
public static final Symbol SIMPLE_ERROR =
PACKAGE_CL.addExternalSymbol("SIMPLE-ERROR");
public static final Symbol SIMPLE_STRING =
PACKAGE_CL.addExternalSymbol("SIMPLE-STRING");
public static final Symbol SIMPLE_STRING_P =
PACKAGE_CL.addExternalSymbol("SIMPLE-STRING-P");
public static final Symbol SIMPLE_TYPE_ERROR =
PACKAGE_CL.addExternalSymbol("SIMPLE-TYPE-ERROR");
public static final Symbol SIMPLE_VECTOR =
PACKAGE_CL.addExternalSymbol("SIMPLE-VECTOR");
public static final Symbol SIMPLE_VECTOR_P =
PACKAGE_CL.addExternalSymbol("SIMPLE-VECTOR-P");
public static final Symbol SIMPLE_WARNING =
PACKAGE_CL.addExternalSymbol("SIMPLE-WARNING");
public static final Symbol SIN =
PACKAGE_CL.addExternalSymbol("SIN");
public static final Symbol SINGLE_FLOAT =
PACKAGE_CL.addExternalSymbol("SINGLE-FLOAT");
public static final Symbol SINGLE_FLOAT_EPSILON =
PACKAGE_CL.addExternalSymbol("SINGLE-FLOAT-EPSILON");
public static final Symbol SINGLE_FLOAT_NEGATIVE_EPSILON =
PACKAGE_CL.addExternalSymbol("SINGLE-FLOAT-NEGATIVE-EPSILON");
public static final Symbol SINH =
PACKAGE_CL.addExternalSymbol("SINH");
public static final Symbol SIXTH =
PACKAGE_CL.addExternalSymbol("SIXTH");
public static final Symbol SLEEP =
PACKAGE_CL.addExternalSymbol("SLEEP");
public static final Symbol SLOT_BOUNDP =
PACKAGE_CL.addExternalSymbol("SLOT-BOUNDP");
public static final Symbol SLOT_EXISTS_P =
PACKAGE_CL.addExternalSymbol("SLOT-EXISTS-P");
public static final Symbol SLOT_MAKUNBOUND =
PACKAGE_CL.addExternalSymbol("SLOT-MAKUNBOUND");
public static final Symbol SLOT_MISSING =
PACKAGE_CL.addExternalSymbol("SLOT-MISSING");
public static final Symbol SLOT_UNBOUND =
PACKAGE_CL.addExternalSymbol("SLOT-UNBOUND");
public static final Symbol SLOT_VALUE =
PACKAGE_CL.addExternalSymbol("SLOT-VALUE");
public static final Symbol SOFTWARE_TYPE =
PACKAGE_CL.addExternalSymbol("SOFTWARE-TYPE");
public static final Symbol SOFTWARE_VERSION =
PACKAGE_CL.addExternalSymbol("SOFTWARE-VERSION");
public static final Symbol SOME =
PACKAGE_CL.addExternalSymbol("SOME");
public static final Symbol SORT =
PACKAGE_CL.addExternalSymbol("SORT");
public static final Symbol SPACE =
PACKAGE_CL.addExternalSymbol("SPACE");
public static final Symbol SPECIAL =
PACKAGE_CL.addExternalSymbol("SPECIAL");
public static final Symbol SPECIAL_OPERATOR_P =
PACKAGE_CL.addExternalSymbol("SPECIAL-OPERATOR-P");
public static final Symbol SPEED =
PACKAGE_CL.addExternalSymbol("SPEED");
public static final Symbol SQRT =
PACKAGE_CL.addExternalSymbol("SQRT");
public static final Symbol STABLE_SORT =
PACKAGE_CL.addExternalSymbol("STABLE-SORT");
public static final Symbol STANDARD =
PACKAGE_CL.addExternalSymbol("STANDARD");
public static final Symbol STANDARD_CHAR =
PACKAGE_CL.addExternalSymbol("STANDARD-CHAR");
public static final Symbol STANDARD_CHAR_P =
PACKAGE_CL.addExternalSymbol("STANDARD-CHAR-P");
public static final Symbol STANDARD_CLASS =
PACKAGE_CL.addExternalSymbol("STANDARD-CLASS");
public static final Symbol STANDARD_GENERIC_FUNCTION =
PACKAGE_CL.addExternalSymbol("STANDARD-GENERIC-FUNCTION");
public static final Symbol STANDARD_METHOD =
PACKAGE_CL.addExternalSymbol("STANDARD-METHOD");
public static final Symbol STANDARD_OBJECT =
PACKAGE_CL.addExternalSymbol("STANDARD-OBJECT");
public static final Symbol STEP =
PACKAGE_CL.addExternalSymbol("STEP");
public static final Symbol STORAGE_CONDITION =
PACKAGE_CL.addExternalSymbol("STORAGE-CONDITION");
public static final Symbol STORE_VALUE =
PACKAGE_CL.addExternalSymbol("STORE-VALUE");
public static final Symbol STREAM =
PACKAGE_CL.addExternalSymbol("STREAM");
public static final Symbol STREAM_ELEMENT_TYPE =
PACKAGE_CL.addExternalSymbol("STREAM-ELEMENT-TYPE");
public static final Symbol STREAM_ERROR =
PACKAGE_CL.addExternalSymbol("STREAM-ERROR");
public static final Symbol STREAM_ERROR_STREAM =
PACKAGE_CL.addExternalSymbol("STREAM-ERROR-STREAM");
public static final Symbol STREAM_EXTERNAL_FORMAT =
PACKAGE_CL.addExternalSymbol("STREAM-EXTERNAL-FORMAT");
public static final Symbol STREAMP =
PACKAGE_CL.addExternalSymbol("STREAMP");
public static final Symbol STRING =
PACKAGE_CL.addExternalSymbol("STRING");
public static final Symbol STRING_CAPITALIZE =
PACKAGE_CL.addExternalSymbol("STRING-CAPITALIZE");
public static final Symbol STRING_DOWNCASE =
PACKAGE_CL.addExternalSymbol("STRING-DOWNCASE");
public static final Symbol STRING_EQUAL =
PACKAGE_CL.addExternalSymbol("STRING-EQUAL");
public static final Symbol STRING_GREATERP =
PACKAGE_CL.addExternalSymbol("STRING-GREATERP");
public static final Symbol STRING_LEFT_TRIM =
PACKAGE_CL.addExternalSymbol("STRING-LEFT-TRIM");
public static final Symbol STRING_LESSP =
PACKAGE_CL.addExternalSymbol("STRING-LESSP");
public static final Symbol STRING_NOT_EQUAL =
PACKAGE_CL.addExternalSymbol("STRING-NOT-EQUAL");
public static final Symbol STRING_NOT_GREATERP =
PACKAGE_CL.addExternalSymbol("STRING-NOT-GREATERP");
public static final Symbol STRING_NOT_LESSP =
PACKAGE_CL.addExternalSymbol("STRING-NOT-LESSP");
public static final Symbol STRING_RIGHT_TRIM =
PACKAGE_CL.addExternalSymbol("STRING-RIGHT-TRIM");
public static final Symbol STRING_STREAM =
PACKAGE_CL.addExternalSymbol("STRING-STREAM");
public static final Symbol STRING_TRIM =
PACKAGE_CL.addExternalSymbol("STRING-TRIM");
public static final Symbol STRING_UPCASE =
PACKAGE_CL.addExternalSymbol("STRING-UPCASE");
public static final Symbol STRING_NE =
PACKAGE_CL.addExternalSymbol("STRING/=");
public static final Symbol STRING_LT =
PACKAGE_CL.addExternalSymbol("STRING<");
public static final Symbol STRING_LE =
PACKAGE_CL.addExternalSymbol("STRING<=");
public static final Symbol STRING_EQUALS =
PACKAGE_CL.addExternalSymbol("STRING=");
public static final Symbol STRING_GT =
PACKAGE_CL.addExternalSymbol("STRING>");
public static final Symbol STRING_GE =
PACKAGE_CL.addExternalSymbol("STRING>=");
public static final Symbol STRINGP =
PACKAGE_CL.addExternalSymbol("STRINGP");
public static final Symbol STRUCTURE =
PACKAGE_CL.addExternalSymbol("STRUCTURE");
public static final Symbol STRUCTURE_CLASS =
PACKAGE_CL.addExternalSymbol("STRUCTURE-CLASS");
public static final Symbol STRUCTURE_OBJECT =
PACKAGE_CL.addExternalSymbol("STRUCTURE-OBJECT");
public static final Symbol STYLE_WARNING =
PACKAGE_CL.addExternalSymbol("STYLE-WARNING");
public static final Symbol SUBLIS =
PACKAGE_CL.addExternalSymbol("SUBLIS");
public static final Symbol SUBSEQ =
PACKAGE_CL.addExternalSymbol("SUBSEQ");
public static final Symbol SUBSETP =
PACKAGE_CL.addExternalSymbol("SUBSETP");
public static final Symbol SUBST =
PACKAGE_CL.addExternalSymbol("SUBST");
public static final Symbol SUBST_IF =
PACKAGE_CL.addExternalSymbol("SUBST-IF");
public static final Symbol SUBST_IF_NOT =
PACKAGE_CL.addExternalSymbol("SUBST-IF-NOT");
public static final Symbol SUBSTITUTE =
PACKAGE_CL.addExternalSymbol("SUBSTITUTE");
public static final Symbol SUBSTITUTE_IF =
PACKAGE_CL.addExternalSymbol("SUBSTITUTE-IF");
public static final Symbol SUBSTITUTE_IF_NOT =
PACKAGE_CL.addExternalSymbol("SUBSTITUTE-IF-NOT");
public static final Symbol SUBTYPEP =
PACKAGE_CL.addExternalSymbol("SUBTYPEP");
public static final Symbol SVREF =
PACKAGE_CL.addExternalSymbol("SVREF");
public static final Symbol SXHASH =
PACKAGE_CL.addExternalSymbol("SXHASH");
public static final Symbol SYMBOL =
PACKAGE_CL.addExternalSymbol("SYMBOL");
public static final Symbol SYMBOL_FUNCTION =
PACKAGE_CL.addExternalSymbol("SYMBOL-FUNCTION");
public static final Symbol SYMBOL_MACROLET =
PACKAGE_CL.addExternalSymbol("SYMBOL-MACROLET");
public static final Symbol SYMBOL_NAME =
PACKAGE_CL.addExternalSymbol("SYMBOL-NAME");
public static final Symbol SYMBOL_PACKAGE =
PACKAGE_CL.addExternalSymbol("SYMBOL-PACKAGE");
public static final Symbol SYMBOL_PLIST =
PACKAGE_CL.addExternalSymbol("SYMBOL-PLIST");
public static final Symbol SYMBOL_VALUE =
PACKAGE_CL.addExternalSymbol("SYMBOL-VALUE");
public static final Symbol SYMBOLP =
PACKAGE_CL.addExternalSymbol("SYMBOLP");
public static final Symbol SYNONYM_STREAM =
PACKAGE_CL.addExternalSymbol("SYNONYM-STREAM");
public static final Symbol SYNONYM_STREAM_SYMBOL =
PACKAGE_CL.addExternalSymbol("SYNONYM-STREAM-SYMBOL");
public static final Symbol T =
PACKAGE_CL.addExternalSymbol("T");
public static final Symbol TAGBODY =
PACKAGE_CL.addExternalSymbol("TAGBODY");
public static final Symbol TAILP =
PACKAGE_CL.addExternalSymbol("TAILP");
public static final Symbol TAN =
PACKAGE_CL.addExternalSymbol("TAN");
public static final Symbol TANH =
PACKAGE_CL.addExternalSymbol("TANH");
public static final Symbol TENTH =
PACKAGE_CL.addExternalSymbol("TENTH");
public static final Symbol TERPRI =
PACKAGE_CL.addExternalSymbol("TERPRI");
public static final Symbol THE =
PACKAGE_CL.addExternalSymbol("THE");
public static final Symbol THIRD =
PACKAGE_CL.addExternalSymbol("THIRD");
public static final Symbol THROW =
PACKAGE_CL.addExternalSymbol("THROW");
public static final Symbol TIME =
PACKAGE_CL.addExternalSymbol("TIME");
public static final Symbol TRACE =
PACKAGE_CL.addExternalSymbol("TRACE");
public static final Symbol TRANSLATE_LOGICAL_PATHNAME =
PACKAGE_CL.addExternalSymbol("TRANSLATE-LOGICAL-PATHNAME");
public static final Symbol TRANSLATE_PATHNAME =
PACKAGE_CL.addExternalSymbol("TRANSLATE-PATHNAME");
public static final Symbol TREE_EQUAL =
PACKAGE_CL.addExternalSymbol("TREE-EQUAL");
public static final Symbol TRUENAME =
PACKAGE_CL.addExternalSymbol("TRUENAME");
public static final Symbol TRUNCATE =
PACKAGE_CL.addExternalSymbol("TRUNCATE");
public static final Symbol TWO_WAY_STREAM =
PACKAGE_CL.addExternalSymbol("TWO-WAY-STREAM");
public static final Symbol TWO_WAY_STREAM_INPUT_STREAM =
PACKAGE_CL.addExternalSymbol("TWO-WAY-STREAM-INPUT-STREAM");
public static final Symbol TWO_WAY_STREAM_OUTPUT_STREAM =
PACKAGE_CL.addExternalSymbol("TWO-WAY-STREAM-OUTPUT-STREAM");
public static final Symbol TYPE =
PACKAGE_CL.addExternalSymbol("TYPE");
public static final Symbol TYPE_ERROR =
PACKAGE_CL.addExternalSymbol("TYPE-ERROR");
public static final Symbol TYPE_ERROR_DATUM =
PACKAGE_CL.addExternalSymbol("TYPE-ERROR-DATUM");
public static final Symbol TYPE_ERROR_EXPECTED_TYPE =
PACKAGE_CL.addExternalSymbol("TYPE-ERROR-EXPECTED-TYPE");
public static final Symbol TYPE_OF =
PACKAGE_CL.addExternalSymbol("TYPE-OF");
public static final Symbol TYPECASE =
PACKAGE_CL.addExternalSymbol("TYPECASE");
public static final Symbol TYPEP =
PACKAGE_CL.addExternalSymbol("TYPEP");
public static final Symbol UNBOUND_SLOT =
PACKAGE_CL.addExternalSymbol("UNBOUND-SLOT");
public static final Symbol UNBOUND_SLOT_INSTANCE =
PACKAGE_CL.addExternalSymbol("UNBOUND-SLOT-INSTANCE");
public static final Symbol UNBOUND_VARIABLE =
PACKAGE_CL.addExternalSymbol("UNBOUND-VARIABLE");
public static final Symbol UNDEFINED_FUNCTION =
PACKAGE_CL.addExternalSymbol("UNDEFINED-FUNCTION");
public static final Symbol UNEXPORT =
PACKAGE_CL.addExternalSymbol("UNEXPORT");
public static final Symbol UNINTERN =
PACKAGE_CL.addExternalSymbol("UNINTERN");
public static final Symbol UNION =
PACKAGE_CL.addExternalSymbol("UNION");
public static final Symbol UNLESS =
PACKAGE_CL.addExternalSymbol("UNLESS");
public static final Symbol UNREAD_CHAR =
PACKAGE_CL.addExternalSymbol("UNREAD-CHAR");
public static final Symbol UNSIGNED_BYTE =
PACKAGE_CL.addExternalSymbol("UNSIGNED-BYTE");
public static final Symbol UNTRACE =
PACKAGE_CL.addExternalSymbol("UNTRACE");
public static final Symbol UNUSE_PACKAGE =
PACKAGE_CL.addExternalSymbol("UNUSE-PACKAGE");
public static final Symbol UNWIND_PROTECT =
PACKAGE_CL.addExternalSymbol("UNWIND-PROTECT");
public static final Symbol UPDATE_INSTANCE_FOR_DIFFERENT_CLASS =
PACKAGE_CL.addExternalSymbol("UPDATE-INSTANCE-FOR-DIFFERENT-CLASS");
public static final Symbol UPDATE_INSTANCE_FOR_REDEFINED_CLASS =
PACKAGE_CL.addExternalSymbol("UPDATE-INSTANCE-FOR-REDEFINED-CLASS");
public static final Symbol UPGRADED_ARRAY_ELEMENT_TYPE =
PACKAGE_CL.addExternalSymbol("UPGRADED-ARRAY-ELEMENT-TYPE");
public static final Symbol UPGRADED_COMPLEX_PART_TYPE =
PACKAGE_CL.addExternalSymbol("UPGRADED-COMPLEX-PART-TYPE");
public static final Symbol UPPER_CASE_P =
PACKAGE_CL.addExternalSymbol("UPPER-CASE-P");
public static final Symbol USE_PACKAGE =
PACKAGE_CL.addExternalSymbol("USE-PACKAGE");
public static final Symbol USE_VALUE =
PACKAGE_CL.addExternalSymbol("USE-VALUE");
public static final Symbol USER_HOMEDIR_PATHNAME =
PACKAGE_CL.addExternalSymbol("USER-HOMEDIR-PATHNAME");
public static final Symbol VALUES =
PACKAGE_CL.addExternalSymbol("VALUES");
public static final Symbol VALUES_LIST =
PACKAGE_CL.addExternalSymbol("VALUES-LIST");
public static final Symbol VARIABLE =
PACKAGE_CL.addExternalSymbol("VARIABLE");
public static final Symbol VECTOR =
PACKAGE_CL.addExternalSymbol("VECTOR");
public static final Symbol VECTOR_POP =
PACKAGE_CL.addExternalSymbol("VECTOR-POP");
public static final Symbol VECTOR_PUSH =
PACKAGE_CL.addExternalSymbol("VECTOR-PUSH");
public static final Symbol VECTOR_PUSH_EXTEND =
PACKAGE_CL.addExternalSymbol("VECTOR-PUSH-EXTEND");
public static final Symbol VECTORP =
PACKAGE_CL.addExternalSymbol("VECTORP");
public static final Symbol WARN =
PACKAGE_CL.addExternalSymbol("WARN");
public static final Symbol WARNING =
PACKAGE_CL.addExternalSymbol("WARNING");
public static final Symbol WHEN =
PACKAGE_CL.addExternalSymbol("WHEN");
public static final Symbol WILD_PATHNAME_P =
PACKAGE_CL.addExternalSymbol("WILD-PATHNAME-P");
public static final Symbol WITH_ACCESSORS =
PACKAGE_CL.addExternalSymbol("WITH-ACCESSORS");
public static final Symbol WITH_COMPILATION_UNIT =
PACKAGE_CL.addExternalSymbol("WITH-COMPILATION-UNIT");
public static final Symbol WITH_CONDITION_RESTARTS =
PACKAGE_CL.addExternalSymbol("WITH-CONDITION-RESTARTS");
public static final Symbol WITH_HASH_TABLE_ITERATOR =
PACKAGE_CL.addExternalSymbol("WITH-HASH-TABLE-ITERATOR");
public static final Symbol WITH_INPUT_FROM_STRING =
PACKAGE_CL.addExternalSymbol("WITH-INPUT-FROM-STRING");
public static final Symbol WITH_OPEN_FILE =
PACKAGE_CL.addExternalSymbol("WITH-OPEN-FILE");
public static final Symbol WITH_OPEN_STREAM =
PACKAGE_CL.addExternalSymbol("WITH-OPEN-STREAM");
public static final Symbol WITH_OUTPUT_TO_STRING =
PACKAGE_CL.addExternalSymbol("WITH-OUTPUT-TO-STRING");
public static final Symbol WITH_PACKAGE_ITERATOR =
PACKAGE_CL.addExternalSymbol("WITH-PACKAGE-ITERATOR");
public static final Symbol WITH_SIMPLE_RESTART =
PACKAGE_CL.addExternalSymbol("WITH-SIMPLE-RESTART");
public static final Symbol WITH_SLOTS =
PACKAGE_CL.addExternalSymbol("WITH-SLOTS");
public static final Symbol WITH_STANDARD_IO_SYNTAX =
PACKAGE_CL.addExternalSymbol("WITH-STANDARD-IO-SYNTAX");
public static final Symbol WRITE =
PACKAGE_CL.addExternalSymbol("WRITE");
public static final Symbol WRITE_BYTE =
PACKAGE_CL.addExternalSymbol("WRITE-BYTE");
public static final Symbol WRITE_CHAR =
PACKAGE_CL.addExternalSymbol("WRITE-CHAR");
public static final Symbol WRITE_LINE =
PACKAGE_CL.addExternalSymbol("WRITE-LINE");
public static final Symbol WRITE_SEQUENCE =
PACKAGE_CL.addExternalSymbol("WRITE-SEQUENCE");
public static final Symbol WRITE_STRING =
PACKAGE_CL.addExternalSymbol("WRITE-STRING");
public static final Symbol WRITE_TO_STRING =
PACKAGE_CL.addExternalSymbol("WRITE-TO-STRING");
public static final Symbol Y_OR_N_P =
PACKAGE_CL.addExternalSymbol("Y-OR-N-P");
public static final Symbol YES_OR_NO_P =
PACKAGE_CL.addExternalSymbol("YES-OR-NO-P");
public static final Symbol ZEROP =
PACKAGE_CL.addExternalSymbol("ZEROP");
// End of CL symbols.
// Extensions.
public static final Symbol MOST_POSITIVE_JAVA_LONG =
PACKAGE_EXT.addExternalSymbol("MOST-POSITIVE-JAVA-LONG");
public static final Symbol MOST_NEGATIVE_JAVA_LONG=
PACKAGE_EXT.addExternalSymbol("MOST-NEGATIVE-JAVA-LONG");
public static final Symbol SINGLE_FLOAT_POSITIVE_INFINITY =
PACKAGE_EXT.addExternalSymbol("SINGLE-FLOAT-POSITIVE-INFINITY");
public static final Symbol SINGLE_FLOAT_NEGATIVE_INFINITY =
PACKAGE_EXT.addExternalSymbol("SINGLE-FLOAT-NEGATIVE-INFINITY");
public static final Symbol DOUBLE_FLOAT_POSITIVE_INFINITY =
PACKAGE_EXT.addExternalSymbol("DOUBLE-FLOAT-POSITIVE-INFINITY");
public static final Symbol DOUBLE_FLOAT_NEGATIVE_INFINITY =
PACKAGE_EXT.addExternalSymbol("DOUBLE-FLOAT-NEGATIVE-INFINITY");
public static final Symbol STYLE_WARN =
PACKAGE_EXT.addExternalSymbol("STYLE-WARN");
public static final Symbol MEMQ =
PACKAGE_EXT.addExternalSymbol("MEMQ");
public static final Symbol MEMQL =
PACKAGE_EXT.addExternalSymbol("MEMQL");
public static final Symbol NIL_VECTOR =
PACKAGE_EXT.addExternalSymbol("NIL-VECTOR");
public static final Symbol MAILBOX =
PACKAGE_EXT.addExternalSymbol("MAILBOX");
public static final Symbol MUTEX =
PACKAGE_EXT.addExternalSymbol("MUTEX");
public static final Symbol SUPPRESS_COMPILER_WARNINGS =
PACKAGE_EXT.addExternalSymbol("*SUPPRESS-COMPILER-WARNINGS*");
public static final Symbol NEQ =
PACKAGE_EXT.addExternalSymbol("NEQ");
public static final Symbol ADJOIN_EQL =
PACKAGE_EXT.addExternalSymbol("ADJOIN-EQL");
public static final Symbol CHARACTER_DESIGNATOR =
PACKAGE_EXT.addExternalSymbol("CHARACTER-DESIGNATOR");
public static final Symbol INTERRUPT_LISP =
PACKAGE_EXT.addExternalSymbol("INTERRUPT-LISP");
public static final Symbol GETENV =
PACKAGE_EXT.addExternalSymbol("GETENV");
public static final Symbol MACROEXPAND_ALL =
PACKAGE_EXT.addExternalSymbol("MACROEXPAND-ALL");
public static final Symbol LOAD_TRUENAME_FASL =
PACKAGE_EXT.addExternalSymbol("*LOAD-TRUENAME-FASL*");
public static final Symbol SLIME_INPUT_STREAM =
PACKAGE_EXT.addExternalSymbol("SLIME-INPUT-STREAM");
public static final Symbol SLIME_OUTPUT_STREAM =
PACKAGE_EXT.addExternalSymbol("SLIME-OUTPUT-STREAM");
public static final Symbol JAR_PATHNAME =
PACKAGE_EXT.addExternalSymbol("JAR-PATHNAME");
public static final Symbol URL_PATHNAME =
PACKAGE_EXT.addExternalSymbol("URL-PATHNAME");
public static final Symbol WEAK_REFERENCE =
PACKAGE_EXT.addExternalSymbol("WEAK-REFERENCE");
public static final Symbol ADD_PACKAGE_LOCAL_NICKNAME =
PACKAGE_EXT.addExternalSymbol("ADD-PACKAGE-LOCAL-NICKNAME");
// MOP.
public static final Symbol CLASS_LAYOUT =
PACKAGE_MOP.addInternalSymbol("CLASS-LAYOUT");
public static final Symbol CLASS_DEFAULT_INITARGS =
PACKAGE_MOP.addExternalSymbol("CLASS-DEFAULT_INITARGS");
public static final Symbol CLASS_DIRECT_METHODS =
PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-METHODS");
public static final Symbol CLASS_DIRECT_DEFAULT_INITARGS =
PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-DEFAULT_INITARGS");
public static final Symbol CLASS_DIRECT_SLOTS =
PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-SLOTS");
public static final Symbol CLASS_DIRECT_SUBCLASSES =
PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-SUBCLASSES");
public static final Symbol CLASS_DIRECT_SUPERCLASSES =
PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-SUPERCLASSES");
public static final Symbol CLASS_DOCUMENTATION =
PACKAGE_MOP.addExternalSymbol("CLASS-DOCUMENTATION");
public static final Symbol CLASS_FINALIZED_P =
PACKAGE_MOP.addExternalSymbol("CLASS-FINALIZED-P");
public static final Symbol CLASS_PRECEDENCE_LIST =
PACKAGE_MOP.addExternalSymbol("CLASS-PRECEDENCE-LIST");
public static final Symbol CLASS_SLOTS =
PACKAGE_MOP.addExternalSymbol("CLASS-SLOTS");
public static final Symbol EQL_SPECIALIZER =
PACKAGE_MOP.addExternalSymbol("EQL-SPECIALIZER");
public static final Symbol EQL_SPECIALIZER_OBJECT =
PACKAGE_MOP.addExternalSymbol("EQL-SPECIALIZER-OBJECT");
public static final Symbol FUNCALLABLE_STANDARD_OBJECT =
PACKAGE_MOP.addExternalSymbol("FUNCALLABLE-STANDARD-OBJECT");
public static final Symbol FUNCALLABLE_STANDARD_CLASS =
PACKAGE_MOP.addExternalSymbol("FUNCALLABLE-STANDARD-CLASS");
public static final Symbol GENERIC_FUNCTION_METHODS =
PACKAGE_MOP.addExternalSymbol("GENERIC-FUNCTION-METHODS");
public static final Symbol GENERIC_FUNCTION_NAME =
PACKAGE_MOP.addExternalSymbol("GENERIC-FUNCTION-NAME");
public static final Symbol METAOBJECT =
PACKAGE_MOP.addExternalSymbol("METAOBJECT");
public static final Symbol METHOD_FUNCTION =
PACKAGE_MOP.addExternalSymbol("METHOD-FUNCTION");
public static final Symbol SPECIALIZER =
PACKAGE_MOP.addExternalSymbol("SPECIALIZER");
public static final Symbol STANDARD_ACCESSOR_METHOD =
PACKAGE_MOP.addExternalSymbol("STANDARD-ACCESSOR-METHOD");
public static final Symbol STANDARD_READER_METHOD =
PACKAGE_MOP.addExternalSymbol("STANDARD-READER-METHOD");
public static final Symbol STANDARD_WRITER_METHOD =
PACKAGE_MOP.addExternalSymbol("STANDARD-WRITER-METHOD");
public static final Symbol DIRECT_SLOT_DEFINITION =
PACKAGE_MOP.addExternalSymbol("DIRECT-SLOT-DEFINITION");
public static final Symbol EFFECTIVE_SLOT_DEFINITION =
PACKAGE_MOP.addExternalSymbol("EFFECTIVE-SLOT-DEFINITION");
public static final Symbol STANDARD_SLOT_DEFINITION =
PACKAGE_MOP.addExternalSymbol("STANDARD-SLOT-DEFINITION");
public static final Symbol STANDARD_DIRECT_SLOT_DEFINITION =
PACKAGE_MOP.addExternalSymbol("STANDARD-DIRECT-SLOT-DEFINITION");
public static final Symbol STANDARD_EFFECTIVE_SLOT_DEFINITION =
PACKAGE_MOP.addExternalSymbol("STANDARD-EFFECTIVE-SLOT-DEFINITION");
// MOP method combination readers.
public static final Symbol METHOD_COMBINATION_NAME =
PACKAGE_MOP.addInternalSymbol("METHOD-COMBINATION-NAME");
public static final Symbol METHOD_COMBINATION_DOCUMENTATION =
PACKAGE_MOP.addInternalSymbol("METHOD-COMBINATION-DOCUMENTATION");
// Java interface.
public static final Symbol JAVA_EXCEPTION =
PACKAGE_JAVA.addExternalSymbol("JAVA-EXCEPTION");
public static final Symbol JAVA_EXCEPTION_CAUSE =
PACKAGE_JAVA.addExternalSymbol("JAVA-EXCEPTION-CAUSE");
public static final Symbol JAVA_OBJECT =
PACKAGE_JAVA.addExternalSymbol("JAVA-OBJECT");
public static final Symbol JAVA_CLASS =
PACKAGE_JAVA.addExternalSymbol("JAVA-CLASS");
public static final Symbol JCALL =
PACKAGE_JAVA.addExternalSymbol("JCALL");
public static final Symbol JCALL_RAW =
PACKAGE_JAVA.addExternalSymbol("JCALL-RAW");
public static final Symbol JCLASS =
PACKAGE_JAVA.addExternalSymbol("JCLASS");
public static final Symbol JCLASS_NAME =
PACKAGE_JAVA.addExternalSymbol("JCLASS-NAME");
public static final Symbol JCLASS_OF =
PACKAGE_JAVA.addExternalSymbol("JCLASS-OF");
public static final Symbol JINPUT_STREAM =
PACKAGE_JAVA.addExternalSymbol("JINPUT-STREAM");
public static final Symbol JMETHOD_RETURN_TYPE =
PACKAGE_JAVA.addExternalSymbol("JMETHOD-RETURN-TYPE");
public static final Symbol JRESOLVE_METHOD =
PACKAGE_JAVA.addExternalSymbol("JRESOLVE-METHOD");
public static final Symbol ADD_TO_CLASSPATH =
PACKAGE_JAVA.addExternalSymbol("ADD-TO-CLASSPATH");
// External symbols in SYSTEM package.
public static final Symbol AUTOCOMPILE =
PACKAGE_SYS.addExternalSymbol("AUTOCOMPILE");
public static final Symbol CLASS_BYTES =
PACKAGE_SYS.addExternalSymbol("CLASS-BYTES");
public static final Symbol _CLASS_SLOTS =
PACKAGE_SYS.addExternalSymbol("%CLASS-SLOTS");
public static final Symbol COMPILED_LISP_FUNCTION_P =
PACKAGE_SYS.addExternalSymbol("COMPILED-LISP-FUNCTION-P");
public static final Symbol DEFAULT_INITARGS =
PACKAGE_SYS.addExternalSymbol("DEFAULT-INITARGS");
public static final Symbol DIRECT_METHODS =
PACKAGE_SYS.addExternalSymbol("DIRECT-METHODS");
public static final Symbol DIRECT_SLOTS =
PACKAGE_SYS.addExternalSymbol("DIRECT-SLOTS");
public static final Symbol DIRECT_SUBCLASSES =
PACKAGE_SYS.addExternalSymbol("DIRECT-SUBCLASSES");
public static final Symbol DIRECT_DEFAULT_INITARGS =
PACKAGE_SYS.addExternalSymbol("DIRECT-DEFAULT-INITARGS");
public static final Symbol DIRECT_SUPERCLASSES =
PACKAGE_SYS.addExternalSymbol("DIRECT-SUPERCLASSES");
public static final Symbol __DISASSEMBLERS__ =
PACKAGE_SYS.addExternalSymbol("*DISASSEMBLERS*");
public static final Symbol CHOOSE_DISASSEMBLER =
PACKAGE_SYS.addExternalSymbol("CHOOSE-DISASSEMBLER");
public static final Symbol _DOCUMENTATION =
PACKAGE_SYS.addExternalSymbol("%DOCUMENTATION");
public static final Symbol _ENABLE_AUTOCOMPILE_ =
PACKAGE_SYS.addExternalSymbol("*ENABLE-AUTOCOMPILE*");
public static final Symbol ENSURE_INPUT_STREAM =
PACKAGE_SYS.addExternalSymbol("ENSURE-INPUT-STREAM");
public static final Symbol ENVIRONMENT =
PACKAGE_SYS.addExternalSymbol("ENVIRONMENT");
public static final Symbol FINALIZED_P =
PACKAGE_SYS.addExternalSymbol("FINALIZED-P");
public static final Symbol FLOAT_UNDERFLOW_MODE =
PACKAGE_SYS.addExternalSymbol("FLOAT-UNDERFLOW-MODE");
public static final Symbol FLOAT_OVERFLOW_MODE =
PACKAGE_SYS.addExternalSymbol("FLOAT-OVERFLOW-MODE");
public static final Symbol GETHASH1 =
PACKAGE_SYS.addExternalSymbol("GETHASH1");
public static final Symbol HASH_TABLE_WEAKNESS =
PACKAGE_SYS.addExternalSymbol("HASH-TABLE-WEAKNESS");
public static final Symbol JAR_STREAM =
PACKAGE_SYS.addExternalSymbol("JAR-STREAM");
public static final Symbol LAYOUT =
PACKAGE_SYS.addExternalSymbol("LAYOUT");
public static final Symbol NAME =
PACKAGE_SYS.addExternalSymbol("NAME");
public static final Symbol NAMED_LAMBDA =
PACKAGE_SYS.addExternalSymbol("NAMED-LAMBDA");
public static final Symbol OUTPUT_OBJECT =
PACKAGE_SYS.addExternalSymbol("OUTPUT-OBJECT");
public static final Symbol PRECEDENCE_LIST =
PACKAGE_SYS.addExternalSymbol("PRECEDENCE-LIST");
public static final Symbol PUTHASH =
PACKAGE_SYS.addExternalSymbol("PUTHASH");
public static final Symbol RECORD_SOURCE_INFORMATION_FOR_TYPE =
PACKAGE_SYS.addExternalSymbol("RECORD-SOURCE-INFORMATION-FOR-TYPE");
public static final Symbol SET_CHAR =
PACKAGE_SYS.addExternalSymbol("SET-CHAR");
public static final Symbol _SET_CLASS_SLOTS =
PACKAGE_SYS.addExternalSymbol("%SET-CLASS-SLOTS");
public static final Symbol SET_SCHAR =
PACKAGE_SYS.addExternalSymbol("SET-SCHAR");
public static final Symbol SET_STD_SLOT_VALUE =
PACKAGE_SYS.addExternalSymbol("SET-STD-SLOT-VALUE");
public static final Symbol SETF_FUNCTION =
PACKAGE_SYS.addExternalSymbol("SETF-FUNCTION");
public static final Symbol SETF_INVERSE =
PACKAGE_SYS.addExternalSymbol("SETF-INVERSE");
public static final Symbol SLOTS = PACKAGE_SYS.addExternalSymbol("SLOTS");
public static final Symbol SLOT_DEFINITION =
PACKAGE_SYS.addExternalSymbol("SLOT-DEFINITION");
public static final Symbol __SOURCE =
PACKAGE_SYS.addInternalSymbol("SOURCE");
public static final Symbol STD_SLOT_BOUNDP =
PACKAGE_SYS.addExternalSymbol("STD-SLOT-BOUNDP");
public static final Symbol STD_SLOT_VALUE =
PACKAGE_SYS.addExternalSymbol("STD-SLOT-VALUE");
public static final Symbol SUBCLASSP =
PACKAGE_SYS.addExternalSymbol("SUBCLASSP");
public static final Symbol SYMBOL_MACRO =
PACKAGE_SYS.addExternalSymbol("SYMBOL-MACRO");
public static final Symbol UNDEFINED_FUNCTION_CALLED =
PACKAGE_SYS.addExternalSymbol("UNDEFINED-FUNCTION-CALLED");
public static final Symbol URL_STREAM =
PACKAGE_SYS.addExternalSymbol("URL-STREAM");
// Internal symbols in SYSTEM package.
public static final Symbol ALLOCATION =
PACKAGE_SYS.addInternalSymbol("ALLOCATION");
public static final Symbol ALLOCATION_CLASS =
PACKAGE_SYS.addInternalSymbol("ALLOCATION-CLASS");
public static final Symbol ARGUMENT_PRECEDENCE_ORDER =
PACKAGE_SYS.addInternalSymbol("ARGUMENT-PRECEDENCE-ORDER");
public static final Symbol BACKQUOTE_MACRO =
PACKAGE_SYS.addInternalSymbol("BACKQUOTE-MACRO");
public static final Symbol CASE_FROB_STREAM =
PACKAGE_SYS.addInternalSymbol("CASE-FROB-STREAM");
public static final Symbol CAUSE =
PACKAGE_SYS.addInternalSymbol("CAUSE");
public static final Symbol COMMA_MACRO =
PACKAGE_SYS.addInternalSymbol("COMMA-MACRO");
public static final Symbol DATUM =
PACKAGE_SYS.addInternalSymbol("DATUM");
public static final Symbol DECLARATIONS =
PACKAGE_SYS.addInternalSymbol("DECLARATIONS");
public static final Symbol DEFTYPE_DEFINITION =
PACKAGE_SYS.addInternalSymbol("DEFTYPE-DEFINITION");
public static final Symbol EXPECTED_TYPE =
PACKAGE_SYS.addInternalSymbol("EXPECTED-TYPE");
public static final Symbol FAST_FUNCTION =
PACKAGE_SYS.addInternalSymbol("FAST-FUNCTION");
public static final Symbol FORMAT_ARGUMENTS =
PACKAGE_SYS.addInternalSymbol("FORMAT-ARGUMENTS");
public static final Symbol FORMAT_CONTROL =
PACKAGE_SYS.addInternalSymbol("FORMAT-CONTROL");
public static final Symbol FSET = PACKAGE_SYS.addInternalSymbol("FSET");
public static final Symbol _FUNCTION =
PACKAGE_SYS.addInternalSymbol("%FUNCTION");
public static final Symbol FUNCTION_PRELOAD =
PACKAGE_SYS.addInternalSymbol("FUNCTION-PRELOAD");
public static final Symbol _GENERIC_FUNCTION =
PACKAGE_SYS.addInternalSymbol("%GENERIC-FUNCTION");
public static final Symbol INITARGS =
PACKAGE_SYS.addInternalSymbol("INITARGS");
public static final Symbol INITFORM =
PACKAGE_SYS.addInternalSymbol("INITFORM");
public static final Symbol INITFUNCTION =
PACKAGE_SYS.addInternalSymbol("INITFUNCTION");
public static final Symbol INITIAL_METHODS =
PACKAGE_SYS.addInternalSymbol("INITIAL-METHODS");
public static final Symbol INSTANCE =
PACKAGE_SYS.addInternalSymbol("INSTANCE");
public static final Symbol JAVA_STACK_FRAME =
PACKAGE_SYS.addInternalSymbol("JAVA-STACK-FRAME");
public static final Symbol KEYWORDS =
PACKAGE_SYS.addInternalSymbol("KEYWORDS");
public static final Symbol LAMBDA_LIST =
PACKAGE_SYS.addInternalSymbol("LAMBDA-LIST");
public static final Symbol LISP_STACK_FRAME =
PACKAGE_SYS.addInternalSymbol("LISP-STACK-FRAME");
public static final Symbol LOCATION =
PACKAGE_SYS.addInternalSymbol("LOCATION");
public static final Symbol MACROEXPAND_MACRO =
PACKAGE_SYS.addInternalSymbol("MACROEXPAND-MACRO");
public static final Symbol MAKE_FUNCTION_PRELOADING_CONTEXT =
PACKAGE_SYS.addInternalSymbol("MAKE-FUNCTION-PRELOADING-CONTEXT");
public static final Symbol METHOD_CLASS =
PACKAGE_SYS.addInternalSymbol("METHOD-CLASS");
public static final Symbol _METHOD_COMBINATION =
PACKAGE_SYS.addInternalSymbol("%METHOD-COMBINATION");
public static final Symbol METHODS = PACKAGE_SYS.addInternalSymbol("METHODS");
public static final Symbol OBJECT = PACKAGE_SYS.addInternalSymbol("OBJECT");
public static final Symbol OPERANDS =
PACKAGE_SYS.addInternalSymbol("OPERANDS");
public static final Symbol OPERATION =
PACKAGE_SYS.addInternalSymbol("OPERATION");
public static final Symbol OPTIONAL_ARGS =
PACKAGE_SYS.addInternalSymbol("OPTIONAL-ARGS");
public static final Symbol OTHER_KEYWORDS_P =
PACKAGE_SYS.addInternalSymbol("OTHER-KEYWORDS-P");
public static final Symbol PROXY_PRELOADED_FUNCTION =
PACKAGE_SYS.addInternalSymbol("PROXY-PRELOADED-FUNCTION");
public static final Symbol QUALIFIERS =
PACKAGE_SYS.addInternalSymbol("QUALIFIERS");
public static final Symbol READERS =
PACKAGE_SYS.addInternalSymbol("READERS");
public static final Symbol REQUIRED_ARGS =
PACKAGE_SYS.addInternalSymbol("REQUIRED-ARGS");
// DEPRECATED: to be removed with abcl-1.7
public static final Symbol _SOURCE =
PACKAGE_SYS.addInternalSymbol("%SOURCE");
public static final Symbol SOCKET_STREAM =
PACKAGE_SYS.addInternalSymbol("SOCKET-STREAM");
public static final Symbol SPECIALIZERS =
PACKAGE_SYS.addInternalSymbol("SPECIALIZERS");
public static final Symbol STRING_INPUT_STREAM =
PACKAGE_SYS.addInternalSymbol("STRING-INPUT-STREAM");
public static final Symbol STRING_OUTPUT_STREAM =
PACKAGE_SYS.addInternalSymbol("STRING-OUTPUT-STREAM");
public static final Symbol SYSTEM_STREAM =
PACKAGE_SYS.addInternalSymbol("SYSTEM-STREAM");
public static final Symbol STACK_FRAME =
PACKAGE_SYS.addInternalSymbol("STACK-FRAME");
public static final Symbol _TYPE =
PACKAGE_SYS.addInternalSymbol("%TYPE");
public static final Symbol WRITERS =
PACKAGE_SYS.addInternalSymbol("WRITERS");
// CDR6
public static final Symbol _INSPECTOR_HOOK_ =
PACKAGE_EXT.addExternalSymbol("*INSPECTOR-HOOK*");
public static final Symbol COMPILER_LET =
PACKAGE_LISP.addExternalSymbol("COMPILER-LET");
// THREADS
public static final Symbol THREAD =
PACKAGE_THREADS.addExternalSymbol("THREAD");
// JVM
public static final Symbol _RESIGNAL_COMPILER_WARINGS_ =
PACKAGE_JVM.addExternalSymbol("*RESIGNAL-COMPILER-WARNINGS*");
}