1 /*
2  * Symbol.java
3  *
4  * Copyright (C) 2002-2007 Peter Graves
5  * $Id$
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20  *
21  * As a special exception, the copyright holders of this library give you
22  * permission to link this library with independent modules to produce an
23  * executable, regardless of the license terms of these independent
24  * modules, and to copy and distribute the resulting executable under
25  * terms of your choice, provided that you also meet, for each linked
26  * independent module, the terms and conditions of the license of that
27  * module.  An independent module is a module which is not derived from
28  * or based on this library.  If you modify this library, you may extend
29  * this exception to your version of the library, but you are not
30  * obligated to do so.  If you do not wish to do so, delete this
31  * exception statement from your version.
32  */
33 
34 package org.armedbear.lisp;
35 
36 import static org.armedbear.lisp.Lisp.*;
37 
38 public class Symbol extends LispObject implements java.io.Serializable
39 {
40   // Bit flags.
41   private static final int FLAG_SPECIAL           = 0x0001;
42   private static final int FLAG_CONSTANT          = 0x0002;
43   private static final int FLAG_BUILT_IN_FUNCTION = 0x0004;
44 
addFunction(String name, LispObject obj)45   public static final Symbol addFunction(String name, LispObject obj)
46   {
47     Symbol symbol = PACKAGE_CL.internAndExport(name);
48     symbol.function = obj;
49     return symbol;
50   }
51 
52   public final SimpleString name;
53   private int hash = -1;
54 
55   /** To be accessed by LispThread only:
56    * used to find the index in the LispThread.specials array
57    */
58   transient int specialIndex = LispThread.UNASSIGNED_SPECIAL_INDEX;
59   private LispObject pkg; // Either a package object or NIL.
60   private transient LispObject value;
61   private transient LispObject function;
62   private transient LispObject propertyList;
63   private int flags;
64 
65   // Construct an uninterned symbol.
Symbol(String s)66   public Symbol(String s)
67   {
68     name = new SimpleString(s);
69     pkg = NIL;
70   }
71 
Symbol(SimpleString string)72   public Symbol(SimpleString string)
73   {
74     name = string;
75     pkg = NIL;
76   }
77 
Symbol(String s, Package pkg)78   public Symbol(String s, Package pkg)
79   {
80     name = new SimpleString(s);
81     this.pkg = pkg;
82   }
83 
Symbol(SimpleString string, Package pkg)84   public Symbol(SimpleString string, Package pkg)
85   {
86     name = string;
87     this.pkg = pkg;
88   }
89 
Symbol(SimpleString string, int hash, Package pkg)90   public Symbol(SimpleString string, int hash, Package pkg)
91   {
92     name = string;
93     this.hash = hash;
94     this.pkg = pkg;
95   }
96 
97     @Override
98     @SuppressWarnings("FinalizeDeclaration")
finalize()99     protected void finalize() throws Throwable {
100         try {
101             if (specialIndex != LispThread.UNASSIGNED_SPECIAL_INDEX)
102                 LispThread.releaseSpecialIndex(this);
103         } finally {
104             super.finalize();
105         }
106     }
107 
108   @Override
typeOf()109   public LispObject typeOf()
110   {
111     if (pkg == PACKAGE_KEYWORD)
112       return Symbol.KEYWORD;
113     if (this == T)
114       return Symbol.BOOLEAN;
115     return Symbol.SYMBOL;
116   }
117 
118   @Override
classOf()119   public LispObject classOf()
120   {
121     return BuiltInClass.SYMBOL;
122   }
123 
124   @Override
getDescription()125   public LispObject getDescription()
126   {
127     final LispThread thread = LispThread.currentThread();
128     final SpecialBindingsMark mark = thread.markSpecialBindings();
129     thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
130     try
131       {
132         StringBuilder sb = new StringBuilder("The symbol ");
133         sb.append(name.princToString());
134         sb.append(" at #x");
135         sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
136         if (pkg instanceof Package)
137           {
138             sb.append(", an ");
139             Symbol sym = ((Package)pkg).findExternalSymbol(name);
140             sb.append(sym == this ? "external" : "internal");
141             sb.append(" symbol in the ");
142             sb.append(((Package)pkg).getName());
143             sb.append(" package");
144           }
145         return new SimpleString(sb);
146       }
147     finally
148       {
149         thread.resetSpecialBindings(mark);
150       }
151   }
152 
153   @Override
getParts()154   public LispObject getParts()
155   {
156     LispObject parts = NIL;
157     parts = parts.push(new Cons("name", name));
158     parts = parts.push(new Cons("package", pkg));
159     parts = parts.push(new Cons("value", value));
160     parts = parts.push(new Cons("function", function));
161     parts = parts.push(new Cons("plist", propertyList));
162     parts = parts.push(new Cons("flags", Fixnum.getInstance(flags)));
163     parts = parts.push(new Cons("hash", Fixnum.getInstance(hash)));
164     return parts.nreverse();
165   }
166 
167   @Override
typep(LispObject type)168   public LispObject typep(LispObject type)
169   {
170     if (type == Symbol.SYMBOL)
171       return T;
172     if (type == BuiltInClass.SYMBOL)
173       return T;
174     if (type == Symbol.KEYWORD)
175       return pkg == PACKAGE_KEYWORD ? T : NIL;
176     if (type == Symbol.BOOLEAN)
177       return this == T ? T : NIL;
178     return super.typep(type);
179   }
180 
181   @Override
constantp()182   public boolean constantp()
183   {
184     return (flags & FLAG_CONSTANT) != 0;
185   }
186 
187   @Override
STRING()188   public final LispObject STRING()
189   {
190     return name;
191   }
192 
getPackage()193   public final LispObject getPackage()
194   {
195     return pkg;
196   }
197 
setPackage(LispObject obj)198   public final void setPackage(LispObject obj)
199   {
200     pkg = obj;
201   }
202 
203   @Override
isSpecialOperator()204   public final boolean isSpecialOperator()
205   {
206     return (function instanceof SpecialOperator);
207   }
208 
209   @Override
isSpecialVariable()210   public final boolean isSpecialVariable()
211   {
212     return (flags & FLAG_SPECIAL) != 0;
213   }
214 
setSpecial(boolean b)215   public final void setSpecial(boolean b)
216   {
217     if (b)
218       flags |= FLAG_SPECIAL;
219     else
220       flags &= ~FLAG_SPECIAL;
221   }
222 
initializeSpecial(LispObject value)223   public final void initializeSpecial(LispObject value)
224   {
225     flags |= FLAG_SPECIAL;
226     this.value = value;
227   }
228 
isConstant()229   public final boolean isConstant()
230   {
231     return (flags & FLAG_CONSTANT) != 0;
232   }
233 
initializeConstant(LispObject value)234   public final void initializeConstant(LispObject value)
235   {
236     flags |= (FLAG_SPECIAL | FLAG_CONSTANT);
237     this.value = value;
238   }
239 
isBuiltInFunction()240   public final boolean isBuiltInFunction()
241   {
242     return (flags & FLAG_BUILT_IN_FUNCTION) != 0;
243   }
244 
setBuiltInFunction(boolean b)245   public final void setBuiltInFunction(boolean b)
246   {
247     if (b)
248       flags |= FLAG_BUILT_IN_FUNCTION;
249     else
250       flags &= ~FLAG_BUILT_IN_FUNCTION;
251   }
252 
getName()253   public final String getName()
254   {
255     return name.getStringValue();
256   }
257 
getQualifiedName()258   public final String getQualifiedName()
259   {
260     final String n = name.getStringValue();
261     if (pkg == NIL)
262       return("#:".concat(n));
263     if (pkg == PACKAGE_KEYWORD)
264       return ":".concat(n);
265     StringBuilder sb = new StringBuilder(((Package)pkg).getName());
266     if (((Package)pkg).findExternalSymbol(name) != null)
267       sb.append(':');
268     else
269       sb.append("::");
270     sb.append(n);
271     return sb.toString();
272   }
273 
274   /** Gets the value associated with the symbol
275    * as set by SYMBOL-VALUE.
276    *
277    * @return The associated value, or null if unbound.
278    *
279    * @see Symbol#symbolValue
280    */
281   @Override
getSymbolValue()282   public LispObject getSymbolValue()
283   {
284     return value;
285   }
286 
287   /** Sets the value associated with the symbol
288    * as if set by SYMBOL-VALUE.
289    *
290    * @return The associated value, or null if unbound.
291    *
292    * @see Symbol#symbolValue
293    */
setSymbolValue(LispObject value)294   public final void setSymbolValue(LispObject value)
295   {
296     if (isConstant())
297       // Complement the check already done in SpecialOperators.sf_setq
298       program_error("Can't change value of constant symbol "
299                     + princToString() + ".");
300     this.value = value;
301   }
302 
getSymbolMacro()303     public SymbolMacro getSymbolMacro() {
304         LispObject symbolMacro = get(this, SYMBOL_MACRO, null);
305         if(symbolMacro instanceof SymbolMacro) {
306             return (SymbolMacro) symbolMacro;
307         } else if(symbolMacro != null) {
308             error(new TypeError("The object " + symbolMacro + " is not a symbol macro"));
309         }
310         return null;
311     }
312 
setSymbolMacro(SymbolMacro symbolMacro)313     public void setSymbolMacro(SymbolMacro symbolMacro) {
314         if(isSpecialVariable()) {
315             program_error("Symbol " + princToString() + " names a special variable; can't install symbol macro.");
316         }
317         put(this, SYMBOL_MACRO, symbolMacro);
318     }
319 
320   /** Returns the value associated with this symbol in the current
321    * thread context when it is treated as a special variable.
322    *
323    * A lisp error is thrown if the symbol is unbound.
324    *
325    * @return The associated value
326    *
327    * @see LispThread#lookupSpecial
328    * @see Symbol#getSymbolValue()
329    *
330    */
symbolValue()331   public final LispObject symbolValue()
332   {
333     return symbolValue(LispThread.currentThread());
334   }
335 
336   /** Returns the value associated with this symbol in the specified
337    * thread context when it is treated as a special variable.
338    *
339    * A lisp error is thrown if the symbol is unbound.
340    *
341    * @return The associated value
342    *
343    * @see LispThread#lookupSpecial
344    * @see Symbol#getSymbolValue()
345    *
346    */
symbolValue(LispThread thread)347   public final LispObject symbolValue(LispThread thread)
348   {
349     LispObject val = thread.lookupSpecial(this);
350     if (val != null)
351       return val;
352     if (value != null)
353       return value;
354     return error(new UnboundVariable(this));
355   }
356 
357   /** Returns the value of the symbol in the current thread context;
358    * if the symbol has been declared special, the value of the innermost
359    * binding is returned. Otherwise, the SYMBOL-VALUE is returned, or
360    * null if unbound.
361    *
362    * @return A lisp object, or null if unbound
363    *
364    * @see LispThread#lookupSpecial
365    * @see Symbol#getSymbolValue()
366    *
367    */
symbolValueNoThrow()368   public final LispObject symbolValueNoThrow()
369   {
370     return symbolValueNoThrow(LispThread.currentThread());
371   }
372 
373   /** Returns the value of the symbol in the current thread context;
374    * if the symbol has been declared special, the value of the innermost
375    * binding is returned. Otherwise, the SYMBOL-VALUE is returned, or
376    * null if unbound.
377    *
378    * @return A lisp object, or null if unbound
379    *
380    * @see LispThread#lookupSpecial
381    * @see Symbol#getSymbolValue()
382    *
383    */
symbolValueNoThrow(LispThread thread)384   public final LispObject symbolValueNoThrow(LispThread thread)
385   {
386     if ((flags & FLAG_SPECIAL) != 0)
387       {
388         LispObject val = thread.lookupSpecial(this);
389         if (val != null)
390           return val;
391       }
392     return value;
393   }
394 
395   @Override
getSymbolFunction()396   public LispObject getSymbolFunction()
397   {
398     return function;
399   }
400 
401   @Override
getSymbolFunctionOrDie()402   public final LispObject getSymbolFunctionOrDie()
403   {
404     if (function == null)
405       return error(new UndefinedFunction(this));
406     if (function instanceof Autoload)
407       {
408         Autoload autoload = (Autoload) function;
409         autoload.load();
410       }
411     return function;
412   }
413 
414   @Override
getSymbolSetfFunction()415   public final LispObject getSymbolSetfFunction()
416   {
417     return get(this, Symbol.SETF_FUNCTION, NIL);
418   }
419 
420 
421   @Override
getSymbolSetfFunctionOrDie()422   public final LispObject getSymbolSetfFunctionOrDie()
423   {
424     LispObject obj = get(this, Symbol.SETF_FUNCTION, null);
425     if (obj == null)
426       error(new UndefinedFunction(list(Keyword.NAME,
427                                          list(Symbol.SETF,
428                                                this))));
429     return obj;
430   }
431 
setSymbolFunction(LispObject obj)432   public final void setSymbolFunction(LispObject obj)
433   {
434     this.function = obj;
435   }
436 
437   /** See LispObject.getStringValue() */
438   @Override
getStringValue()439   public String getStringValue()
440   {
441     return name.getStringValue();
442   }
443 
444   @Override
getPropertyList()445   public final LispObject getPropertyList()
446   {
447     if (propertyList == null)
448       propertyList = NIL;
449     return propertyList;
450   }
451 
452   @Override
setPropertyList(LispObject obj)453   public final void setPropertyList(LispObject obj)
454   {
455     if (obj == null)
456       throw new NullPointerException();
457     propertyList = obj;
458   }
459 
460   @Override
printObject()461   public String printObject()
462   {
463     final String n = name.getStringValue();
464     final LispThread thread = LispThread.currentThread();
465     boolean printEscape = (PRINT_ESCAPE.symbolValue(thread) != NIL);
466     LispObject printCase = PRINT_CASE.symbolValue(thread);
467     final LispObject readtableCase =
468       ((Readtable)CURRENT_READTABLE.symbolValue(thread)).getReadtableCase();
469     boolean printReadably = (PRINT_READABLY.symbolValue(thread) != NIL);
470 
471     if (printReadably) {
472       if (readtableCase != Keyword.UPCASE || printCase != Keyword.UPCASE) {
473         StringBuilder sb = new StringBuilder();
474         if (pkg == PACKAGE_KEYWORD) {
475           sb.append(':');
476         } else if (pkg instanceof Package) {
477           sb.append(multipleEscape(((Package)pkg).getName()));
478           sb.append("::");
479         } else {
480           sb.append("#:");
481         }
482         sb.append(multipleEscape(n));
483         return sb.toString();
484       }
485       else {
486         printEscape = true;
487       }
488     }
489     if (!printEscape) {
490       if (pkg == PACKAGE_KEYWORD) {
491         if (printCase == Keyword.DOWNCASE)
492           return n.toLowerCase();
493         if (printCase == Keyword.CAPITALIZE)
494           return capitalize(n, readtableCase);
495         return n;
496       }
497       // Printer escaping is disabled.
498       if (readtableCase == Keyword.UPCASE) {
499         if (printCase == Keyword.DOWNCASE)
500           return n.toLowerCase();
501         if (printCase == Keyword.CAPITALIZE)
502           return capitalize(n, readtableCase);
503         return n;
504       } else if (readtableCase == Keyword.DOWNCASE) {
505         // "When the readtable case is :DOWNCASE, uppercase characters
506         // are printed in their own case, and lowercase characters are
507         // printed in the case specified by *PRINT-CASE*." (22.1.3.3.2)
508         if (printCase == Keyword.DOWNCASE)
509           return n;
510         if (printCase == Keyword.UPCASE)
511           return n.toUpperCase();
512         if (printCase == Keyword.CAPITALIZE)
513           return capitalize(n, readtableCase);
514         return n;
515       } else if (readtableCase == Keyword.PRESERVE) {
516         return n;
517       } else // INVERT
518         return invert(n);
519     }
520     // Printer escaping is enabled.
521     final boolean escapeSymbolName = needsEscape(n, readtableCase, thread);
522     String symbolName = escapeSymbolName ? multipleEscape(n) : n;
523     if (!escapeSymbolName) {
524       if (readtableCase == Keyword.PRESERVE) {
525         // nothing to do
526       } else if (readtableCase == Keyword.INVERT) {
527         symbolName = invert(symbolName);
528       } else if (printCase == Keyword.DOWNCASE) {
529         symbolName = symbolName.toLowerCase();
530       } else if (printCase == Keyword.UPCASE) {
531         symbolName = symbolName.toUpperCase();
532       } else if (printCase == Keyword.CAPITALIZE) {
533           symbolName = capitalize(symbolName, readtableCase);
534       }
535     }
536     if (pkg == NIL) {
537       if (printReadably || PRINT_GENSYM.symbolValue(thread) != NIL) {
538         return "#:".concat(symbolName);
539       } else {
540           return symbolName;
541       }
542     }
543     if (pkg == PACKAGE_KEYWORD) {
544       return ":".concat(symbolName);
545     }
546     // "Package prefixes are printed if necessary." (22.1.3.3.1)
547     // Here we also use a package-local nickname if appropriate.
548     final Package currentPackage = (Package) _PACKAGE_.symbolValue(thread);
549     if (pkg == currentPackage) {
550       return symbolName;
551     }
552     if (currentPackage != null && currentPackage.uses(pkg)) {
553         // Check for name conflict in current package.
554         if (currentPackage.findExternalSymbol(name) == null)
555           if (currentPackage.findInternalSymbol(name) == null)
556             if (((Package)pkg).findExternalSymbol(name) != null)
557               return symbolName;
558     }
559     // Has this symbol been imported into the current package?
560     if (currentPackage.findExternalSymbol(name) == this)
561       return symbolName;
562     if (currentPackage.findInternalSymbol(name) == this)
563       return symbolName;
564     // Package prefix is necessary.
565     String packageName = ((Package)pkg).getName();
566     if (currentPackage.getLocallyNicknamedPackages().contains(pkg)) {
567       LispObject nicknames = currentPackage.getLocalPackageNicknames();
568       while (nicknames != NIL) {
569         if (nicknames.car().cdr() == pkg) {
570           packageName = javaString(nicknames.car().car());
571           nicknames = NIL;
572         } else {
573           nicknames = nicknames.cdr();
574         }
575       }
576     }
577     final boolean escapePackageName = needsEscape(packageName, readtableCase, thread);
578     if (escapePackageName)
579       {
580         packageName = multipleEscape(packageName);
581       }
582     else
583       {
584         if (readtableCase == Keyword.UPCASE)
585           {
586             if (printCase == Keyword.DOWNCASE)
587               packageName = packageName.toLowerCase();
588             else if (printCase == Keyword.CAPITALIZE)
589               packageName = capitalize(packageName, readtableCase);
590           }
591         else if (readtableCase == Keyword.DOWNCASE)
592           {
593             if (printCase == Keyword.UPCASE)
594               packageName = packageName.toUpperCase();
595             else if (printCase == Keyword.CAPITALIZE)
596               packageName = capitalize(packageName, readtableCase);
597           }
598         else if (readtableCase == Keyword.INVERT)
599           {
600             packageName = invert(packageName);
601           }
602       }
603     StringBuilder sb = new StringBuilder(packageName);
604     if (((Package)pkg).findExternalSymbol(name) != null
605         && DOUBLE_COLON_PACKAGE_SEPARATORS.symbolValue(thread) == NIL)
606       sb.append(':');
607     else
608       sb.append("::");
609     sb.append(symbolName);
610     return sb.toString();
611   }
612 
invert(String s)613   private static final String invert(String s)
614   {
615     // "When the readtable case is :INVERT, the case of all alphabetic
616     // characters in single case symbol names is inverted. Mixed-case
617     // symbol names are printed as is." (22.1.3.3.2)
618     final int limit = s.length();
619     final int LOWER = 1;
620     final int UPPER = 2;
621     int state = 0;
622     for (int i = 0; i < limit; i++)
623       {
624         char c = s.charAt(i);
625         if (Character.isUpperCase(c))
626           {
627             if (state == LOWER)
628               return s; // Mixed case.
629             state = UPPER;
630           }
631         if (Character.isLowerCase(c))
632           {
633             if (state == UPPER)
634               return s; // Mixed case.
635             state = LOWER;
636           }
637       }
638     StringBuilder sb = new StringBuilder(limit);
639     for (int i = 0; i < limit; i++)
640       {
641         char c = s.charAt(i);
642         if (Character.isUpperCase(c))
643           sb.append(Character.toLowerCase(c));
644         else if (Character.isLowerCase(c))
645           sb.append(Character.toUpperCase(c));
646         else
647           sb.append(c);
648       }
649     return sb.toString();
650   }
651 
needsEscape(String s, LispObject readtableCase, LispThread thread)652   private static final boolean needsEscape(String s,
653                                            LispObject readtableCase,
654                                            LispThread thread)
655 
656   {
657     boolean escape = false;
658     final int length = s.length();
659     if (length == 0)
660       return true;
661     if (s.charAt(0) == '#')
662       return true;
663     int radix;
664     LispObject printBaseBinding = PRINT_BASE.symbolValue(thread);
665     if (printBaseBinding instanceof Fixnum)
666       {
667         radix = ((Fixnum)printBaseBinding).value;
668       }
669     else
670       {
671         error(new TypeError("The value of *PRINT-BASE* is not of type (INTEGER 2 36)."));
672         // Not reached.
673         return false;
674       }
675     if (radix < 2 || radix > 36)
676       {
677         error(new TypeError("The value of *PRINT-BASE* is not of type (INTEGER 2 36)."));
678         // Not reached.
679         return false;
680       }
681     boolean seenNonDigit = false;
682     for (int i = length; i-- > 0;)
683       {
684         char c = s.charAt(i);
685         if ("(),|\\`'\";:".indexOf(c) >= 0)
686           return true;
687         if (Character.isWhitespace(c))
688           return true;
689         if (readtableCase == Keyword.UPCASE)
690           {
691             if (Character.isLowerCase(c))
692               return true;
693           }
694         else if (readtableCase == Keyword.DOWNCASE)
695           {
696             if (Character.isUpperCase(c))
697               return true;
698           }
699         if (!escape && !seenNonDigit)
700           {
701             if (Character.digit(c, radix) < 0)
702               seenNonDigit = true;
703           }
704       }
705     if (!seenNonDigit)
706       return true;
707     if (s.charAt(0) == '.')
708       {
709         boolean allDots = true;
710         for (int i = length; i-- > 1;)
711           {
712             if (s.charAt(i) != '.')
713               {
714                 allDots = false;
715                 break;
716               }
717           }
718         if (allDots)
719           return true;
720       }
721     return false;
722   }
723 
multipleEscape(String s)724   private static final String multipleEscape(String s)
725   {
726     StringBuilder sb = new StringBuilder("|");
727     final int limit = s.length();
728     for (int i = 0; i < limit; i++)
729       {
730         char c = s.charAt(i);
731         if (c == '|' || c == '\\')
732           sb.append('\\');
733         sb.append(c);
734       }
735     sb.append('|');
736     return sb.toString();
737   }
738 
capitalize(String s, LispObject readtableCase)739   private static final String capitalize(String s, LispObject readtableCase)
740   {
741     if (readtableCase == Keyword.INVERT || readtableCase == Keyword.PRESERVE)
742       return s;
743     final int limit = s.length();
744     StringBuilder sb = new StringBuilder(limit);
745     boolean lastCharWasAlphanumeric = false;
746     for (int i = 0; i < limit; i++)
747       {
748         char c = s.charAt(i);
749         if (Character.isLowerCase(c))
750           {
751             if (readtableCase == Keyword.UPCASE)
752               sb.append(c);
753             else // DOWNCASE
754               sb.append(lastCharWasAlphanumeric ? c : LispCharacter.toUpperCase(c));
755             lastCharWasAlphanumeric = true;
756           }
757         else if (Character.isUpperCase(c))
758           {
759             if (readtableCase == Keyword.UPCASE)
760               sb.append(lastCharWasAlphanumeric ? LispCharacter.toLowerCase(c) : c);
761             else // DOWNCASE
762               sb.append(c);
763             lastCharWasAlphanumeric = true;
764           }
765         else
766           {
767             sb.append(c);
768             lastCharWasAlphanumeric = Character.isDigit(c);
769           }
770       }
771     return sb.toString();
772   }
773 
774   @Override
sxhash()775   public final int sxhash()
776   {
777     int h = hash;
778     if (h < 0)
779       {
780         h = name.sxhash();
781         hash = h;
782       }
783     return h;
784   }
785 
786   @Override
execute()787   final public LispObject execute()
788   {
789     LispObject fun;
790     if ((fun = function) == null)
791         return undefinedFunction(NIL);
792 
793     return fun.execute();
794   }
795 
796   @Override
execute(LispObject arg)797   final public LispObject execute(LispObject arg)
798   {
799     LispObject fun;
800     if ((fun = function) == null)
801         return undefinedFunction(list(arg));
802 
803     return fun.execute(arg);
804   }
805 
806   @Override
execute(LispObject first, LispObject second)807   final public LispObject execute(LispObject first, LispObject second)
808 
809   {
810     LispObject fun;
811     if ((fun = function) == null)
812         return undefinedFunction(list(first, second));
813 
814     return fun.execute(first, second);
815   }
816 
817   @Override
execute(LispObject first, LispObject second, LispObject third)818   final public LispObject execute(LispObject first, LispObject second,
819                             LispObject third)
820 
821   {
822     LispObject fun;
823     if ((fun = function) == null)
824         return undefinedFunction(list(first, second, third));
825 
826     return fun.execute(first, second, third);
827   }
828 
829   @Override
execute(LispObject first, LispObject second, LispObject third, LispObject fourth)830   final public LispObject execute(LispObject first, LispObject second,
831                             LispObject third, LispObject fourth)
832 
833   {
834     LispObject fun;
835     if ((fun = function) == null)
836         return undefinedFunction(list(first, second, third, fourth));
837 
838     return fun.execute(first, second, third, fourth);
839   }
840 
841   @Override
execute(LispObject first, LispObject second, LispObject third, LispObject fourth, LispObject fifth)842   final public LispObject execute(LispObject first, LispObject second,
843                             LispObject third, LispObject fourth,
844                             LispObject fifth)
845 
846   {
847     LispObject fun;
848     if ((fun = function) == null)
849         return undefinedFunction(list(first, second, third, fourth,
850                                       fifth));
851 
852     return fun.execute(first, second, third, fourth,
853                        fifth);
854   }
855 
856   @Override
execute(LispObject first, LispObject second, LispObject third, LispObject fourth, LispObject fifth, LispObject sixth)857   final public LispObject execute(LispObject first, LispObject second,
858                             LispObject third, LispObject fourth,
859                             LispObject fifth, LispObject sixth)
860 
861   {
862     LispObject fun;
863     if ((fun = function) == null)
864         return undefinedFunction(list(first, second, third, fourth,
865                                       fifth, sixth));
866 
867     return fun.execute(first, second, third, fourth,
868                        fifth, sixth);
869   }
870 
871   @Override
execute(LispObject first, LispObject second, LispObject third, LispObject fourth, LispObject fifth, LispObject sixth, LispObject seventh)872   final public LispObject execute(LispObject first, LispObject second,
873                             LispObject third, LispObject fourth,
874                             LispObject fifth, LispObject sixth,
875                             LispObject seventh)
876 
877   {
878     LispObject fun;
879     if ((fun = function) == null)
880         return undefinedFunction(list(first, second, third, fourth,
881                                       fifth, sixth, seventh));
882 
883     return fun.execute(first, second, third, fourth,
884                        fifth, sixth, seventh);
885   }
886 
887   @Override
execute(LispObject first, LispObject second, LispObject third, LispObject fourth, LispObject fifth, LispObject sixth, LispObject seventh, LispObject eighth)888   final public LispObject execute(LispObject first, LispObject second,
889                             LispObject third, LispObject fourth,
890                             LispObject fifth, LispObject sixth,
891                             LispObject seventh, LispObject eighth)
892 
893   {
894     LispObject fun;
895     if ((fun = function) == null)
896         return undefinedFunction(list(first, second, third, fourth,
897                                       fifth, sixth, seventh, eighth));
898 
899     return fun.execute(first, second, third, fourth,
900                        fifth, sixth, seventh, eighth);
901   }
902 
903   @Override
execute(LispObject[] args)904   final public LispObject execute(LispObject[] args)
905   {
906     LispObject fun;
907     if ((fun = function) == null) {
908         LispObject list = NIL;
909         for (int i = args.length; i-- > 0;)
910           list = new Cons(args[i], list);
911         return undefinedFunction(list);
912     }
913 
914     return fun.execute(args);
915   }
916 
undefinedFunction(LispObject args)917   private final LispObject undefinedFunction(LispObject args)
918 
919   {
920     return LispThread.currentThread().execute(Symbol.UNDEFINED_FUNCTION_CALLED,
921                                               this, args);
922   }
923 
924   @Override
incrementCallCount()925   public void incrementCallCount()
926   {
927     if (function != null)
928       function.incrementCallCount();
929   }
930 
931   @Override
incrementHotCount()932   public void incrementHotCount()
933   {
934     if (function != null)
935       function.incrementHotCount();
936   }
937 
readResolve()938     public Object readResolve() throws java.io.ObjectStreamException {
939 	if(pkg instanceof Package) {
940 	    Symbol s = ((Package) pkg).intern(name.getStringValue());
941 	    return s;
942 	} else {
943 	    return this;
944 	}
945     }
946 
947     @Override
toString()948     public String toString() {
949         StringBuilder sb = new StringBuilder();
950         if (pkg instanceof Package) {
951             sb.append(((Package)pkg).getName());
952             sb.append(":");
953         } else {
954             sb.append("#:");
955         }
956         sb.append(name);
957         return sb.toString();
958     }
959 
960 
961   // External symbols in CL package.
962   public static final Symbol AND_ALLOW_OTHER_KEYS =
963     PACKAGE_CL.addExternalSymbol("&ALLOW-OTHER-KEYS");
964   public static final Symbol AND_AUX =
965     PACKAGE_CL.addExternalSymbol("&AUX");
966   public static final Symbol AND_BODY =
967     PACKAGE_CL.addExternalSymbol("&BODY");
968   public static final Symbol AND_ENVIRONMENT =
969     PACKAGE_CL.addExternalSymbol("&ENVIRONMENT");
970   public static final Symbol AND_KEY =
971     PACKAGE_CL.addExternalSymbol("&KEY");
972   public static final Symbol AND_OPTIONAL =
973     PACKAGE_CL.addExternalSymbol("&OPTIONAL");
974   public static final Symbol AND_REST =
975     PACKAGE_CL.addExternalSymbol("&REST");
976   public static final Symbol AND_WHOLE =
977     PACKAGE_CL.addExternalSymbol("&WHOLE");
978   public static final Symbol STAR =
979     PACKAGE_CL.addExternalSymbol("*");
980   public static final Symbol STAR_STAR =
981     PACKAGE_CL.addExternalSymbol("**");
982   public static final Symbol STAR_STAR_STAR =
983     PACKAGE_CL.addExternalSymbol("***");
984   public static final Symbol BREAK_ON_SIGNALS =
985     PACKAGE_CL.addExternalSymbol("*BREAK-ON-SIGNALS*");
986   public static final Symbol _COMPILE_FILE_PATHNAME_ =
987     PACKAGE_CL.addExternalSymbol("*COMPILE-FILE-PATHNAME*");
988   public static final Symbol COMPILE_FILE_TRUENAME =
989     PACKAGE_CL.addExternalSymbol("*COMPILE-FILE-TRUENAME*");
990   public static final Symbol COMPILE_PRINT =
991     PACKAGE_CL.addExternalSymbol("*COMPILE-PRINT*");
992   public static final Symbol COMPILE_VERBOSE =
993     PACKAGE_CL.addExternalSymbol("*COMPILE-VERBOSE*");
994   public static final Symbol DEBUG_IO =
995     PACKAGE_CL.addExternalSymbol("*DEBUG-IO*");
996   public static final Symbol DEBUGGER_HOOK =
997     PACKAGE_CL.addExternalSymbol("*DEBUGGER-HOOK*");
998   public static final Symbol DEFAULT_PATHNAME_DEFAULTS =
999     PACKAGE_CL.addExternalSymbol("*DEFAULT-PATHNAME-DEFAULTS*");
1000   public static final Symbol ERROR_OUTPUT =
1001     PACKAGE_CL.addExternalSymbol("*ERROR-OUTPUT*");
1002   public static final Symbol FEATURES =
1003     PACKAGE_CL.addExternalSymbol("*FEATURES*");
1004   public static final Symbol GENSYM_COUNTER =
1005     PACKAGE_CL.addExternalSymbol("*GENSYM-COUNTER*");
1006   public static final Symbol LOAD_PATHNAME =
1007     PACKAGE_CL.addExternalSymbol("*LOAD-PATHNAME*");
1008   public static final Symbol LOAD_PRINT =
1009     PACKAGE_CL.addExternalSymbol("*LOAD-PRINT*");
1010   public static final Symbol LOAD_TRUENAME =
1011     PACKAGE_CL.addExternalSymbol("*LOAD-TRUENAME*");
1012   public static final Symbol LOAD_VERBOSE =
1013     PACKAGE_CL.addExternalSymbol("*LOAD-VERBOSE*");
1014   public static final Symbol MACROEXPAND_HOOK =
1015     PACKAGE_CL.addExternalSymbol("*MACROEXPAND-HOOK*");
1016   public static final Symbol MODULES =
1017     PACKAGE_CL.addExternalSymbol("*MODULES*");
1018   public static final Symbol _PACKAGE_ =
1019     PACKAGE_CL.addExternalSymbol("*PACKAGE*");
1020   public static final Symbol PRINT_ARRAY =
1021     PACKAGE_CL.addExternalSymbol("*PRINT-ARRAY*");
1022   public static final Symbol PRINT_BASE =
1023     PACKAGE_CL.addExternalSymbol("*PRINT-BASE*");
1024   public static final Symbol PRINT_CASE =
1025     PACKAGE_CL.addExternalSymbol("*PRINT-CASE*");
1026   public static final Symbol PRINT_CIRCLE =
1027     PACKAGE_CL.addExternalSymbol("*PRINT-CIRCLE*");
1028   public static final Symbol PRINT_ESCAPE =
1029     PACKAGE_CL.addExternalSymbol("*PRINT-ESCAPE*");
1030   public static final Symbol PRINT_GENSYM =
1031     PACKAGE_CL.addExternalSymbol("*PRINT-GENSYM*");
1032   public static final Symbol PRINT_LENGTH =
1033     PACKAGE_CL.addExternalSymbol("*PRINT-LENGTH*");
1034   public static final Symbol PRINT_LEVEL =
1035     PACKAGE_CL.addExternalSymbol("*PRINT-LEVEL*");
1036   public static final Symbol PRINT_LINES =
1037     PACKAGE_CL.addExternalSymbol("*PRINT-LINES*");
1038   public static final Symbol PRINT_MISER_WIDTH =
1039     PACKAGE_CL.addExternalSymbol("*PRINT-MISER-WIDTH*");
1040   public static final Symbol PRINT_PPRINT_DISPATCH =
1041     PACKAGE_CL.addExternalSymbol("*PRINT-PPRINT-DISPATCH*");
1042   public static final Symbol PRINT_PRETTY =
1043     PACKAGE_CL.addExternalSymbol("*PRINT-PRETTY*");
1044   public static final Symbol PRINT_RADIX =
1045     PACKAGE_CL.addExternalSymbol("*PRINT-RADIX*");
1046   public static final Symbol PRINT_READABLY =
1047     PACKAGE_CL.addExternalSymbol("*PRINT-READABLY*");
1048   public static final Symbol PRINT_RIGHT_MARGIN =
1049     PACKAGE_CL.addExternalSymbol("*PRINT-RIGHT-MARGIN*");
1050   public static final Symbol QUERY_IO =
1051     PACKAGE_CL.addExternalSymbol("*QUERY-IO*");
1052   public static final Symbol _RANDOM_STATE_ =
1053     PACKAGE_CL.addExternalSymbol("*RANDOM-STATE*");
1054   public static final Symbol READ_BASE =
1055     PACKAGE_CL.addExternalSymbol("*READ-BASE*");
1056   public static final Symbol READ_DEFAULT_FLOAT_FORMAT =
1057     PACKAGE_CL.addExternalSymbol("*READ-DEFAULT-FLOAT-FORMAT*");
1058   public static final Symbol READ_EVAL =
1059     PACKAGE_CL.addExternalSymbol("*READ-EVAL*");
1060   public static final Symbol READ_SUPPRESS =
1061     PACKAGE_CL.addExternalSymbol("*READ-SUPPRESS*");
1062   public static final Symbol CURRENT_READTABLE =
1063     PACKAGE_CL.addExternalSymbol("*READTABLE*");
1064   public static final Symbol STANDARD_INPUT =
1065     PACKAGE_CL.addExternalSymbol("*STANDARD-INPUT*");
1066   public static final Symbol STANDARD_OUTPUT =
1067     PACKAGE_CL.addExternalSymbol("*STANDARD-OUTPUT*");
1068   public static final Symbol TERMINAL_IO =
1069     PACKAGE_CL.addExternalSymbol("*TERMINAL-IO*");
1070   public static final Symbol TRACE_OUTPUT =
1071     PACKAGE_CL.addExternalSymbol("*TRACE-OUTPUT*");
1072   public static final Symbol PLUS =
1073     PACKAGE_CL.addExternalSymbol("+");
1074   public static final Symbol PLUS_PLUS =
1075     PACKAGE_CL.addExternalSymbol("++");
1076   public static final Symbol PLUS_PLUS_PLUS =
1077     PACKAGE_CL.addExternalSymbol("+++");
1078   public static final Symbol MINUS =
1079     PACKAGE_CL.addExternalSymbol("-");
1080   public static final Symbol SLASH =
1081     PACKAGE_CL.addExternalSymbol("/");
1082   public static final Symbol SLASH_SLASH =
1083     PACKAGE_CL.addExternalSymbol("//");
1084   public static final Symbol SLASH_SLASH_SLASH =
1085     PACKAGE_CL.addExternalSymbol("///");
1086   public static final Symbol NOT_EQUALS =
1087     PACKAGE_CL.addExternalSymbol("/=");
1088   public static final Symbol ONE_PLUS =
1089     PACKAGE_CL.addExternalSymbol("1+");
1090   public static final Symbol ONE_MINUS =
1091     PACKAGE_CL.addExternalSymbol("1-");
1092   public static final Symbol LT =
1093     PACKAGE_CL.addExternalSymbol("<");
1094   public static final Symbol LE =
1095     PACKAGE_CL.addExternalSymbol("<=");
1096   public static final Symbol EQUALS =
1097     PACKAGE_CL.addExternalSymbol("=");
1098   public static final Symbol GT =
1099     PACKAGE_CL.addExternalSymbol(">");
1100   public static final Symbol GE =
1101     PACKAGE_CL.addExternalSymbol(">=");
1102   public static final Symbol ABORT =
1103     PACKAGE_CL.addExternalSymbol("ABORT");
1104   public static final Symbol ABS =
1105     PACKAGE_CL.addExternalSymbol("ABS");
1106   public static final Symbol ACONS =
1107     PACKAGE_CL.addExternalSymbol("ACONS");
1108   public static final Symbol ACOS =
1109     PACKAGE_CL.addExternalSymbol("ACOS");
1110   public static final Symbol ACOSH =
1111     PACKAGE_CL.addExternalSymbol("ACOSH");
1112   public static final Symbol ADD_METHOD =
1113     PACKAGE_CL.addExternalSymbol("ADD-METHOD");
1114   public static final Symbol ADJOIN =
1115     PACKAGE_CL.addExternalSymbol("ADJOIN");
1116   public static final Symbol ADJUST_ARRAY =
1117     PACKAGE_CL.addExternalSymbol("ADJUST-ARRAY");
1118   public static final Symbol ADJUSTABLE_ARRAY_P =
1119     PACKAGE_CL.addExternalSymbol("ADJUSTABLE-ARRAY-P");
1120   public static final Symbol ALLOCATE_INSTANCE =
1121     PACKAGE_CL.addExternalSymbol("ALLOCATE-INSTANCE");
1122   public static final Symbol ALPHA_CHAR_P =
1123     PACKAGE_CL.addExternalSymbol("ALPHA-CHAR-P");
1124   public static final Symbol ALPHANUMERICP =
1125     PACKAGE_CL.addExternalSymbol("ALPHANUMERICP");
1126   public static final Symbol AND =
1127     PACKAGE_CL.addExternalSymbol("AND");
1128   public static final Symbol APPEND =
1129     PACKAGE_CL.addExternalSymbol("APPEND");
1130   public static final Symbol APPLY =
1131     PACKAGE_CL.addExternalSymbol("APPLY");
1132   public static final Symbol APROPOS =
1133     PACKAGE_CL.addExternalSymbol("APROPOS");
1134   public static final Symbol APROPOS_LIST =
1135     PACKAGE_CL.addExternalSymbol("APROPOS-LIST");
1136   public static final Symbol AREF =
1137     PACKAGE_CL.addExternalSymbol("AREF");
1138   public static final Symbol ARITHMETIC_ERROR =
1139     PACKAGE_CL.addExternalSymbol("ARITHMETIC-ERROR");
1140   public static final Symbol ARITHMETIC_ERROR_OPERANDS =
1141     PACKAGE_CL.addExternalSymbol("ARITHMETIC-ERROR-OPERANDS");
1142   public static final Symbol ARITHMETIC_ERROR_OPERATION =
1143     PACKAGE_CL.addExternalSymbol("ARITHMETIC-ERROR-OPERATION");
1144   public static final Symbol ARRAY =
1145     PACKAGE_CL.addExternalSymbol("ARRAY");
1146   public static final Symbol ARRAY_DIMENSION =
1147     PACKAGE_CL.addExternalSymbol("ARRAY-DIMENSION");
1148   public static final Symbol ARRAY_DIMENSION_LIMIT =
1149     PACKAGE_CL.addExternalSymbol("ARRAY-DIMENSION-LIMIT");
1150   public static final Symbol ARRAY_DIMENSIONS =
1151     PACKAGE_CL.addExternalSymbol("ARRAY-DIMENSIONS");
1152   public static final Symbol ARRAY_DISPLACEMENT =
1153     PACKAGE_CL.addExternalSymbol("ARRAY-DISPLACEMENT");
1154   public static final Symbol ARRAY_ELEMENT_TYPE =
1155     PACKAGE_CL.addExternalSymbol("ARRAY-ELEMENT-TYPE");
1156   public static final Symbol ARRAY_HAS_FILL_POINTER_P =
1157     PACKAGE_CL.addExternalSymbol("ARRAY-HAS-FILL-POINTER-P");
1158   public static final Symbol ARRAY_IN_BOUNDS_P =
1159     PACKAGE_CL.addExternalSymbol("ARRAY-IN-BOUNDS-P");
1160   public static final Symbol ARRAY_RANK =
1161     PACKAGE_CL.addExternalSymbol("ARRAY-RANK");
1162   public static final Symbol ARRAY_RANK_LIMIT =
1163     PACKAGE_CL.addExternalSymbol("ARRAY-RANK-LIMIT");
1164   public static final Symbol ARRAY_ROW_MAJOR_INDEX =
1165     PACKAGE_CL.addExternalSymbol("ARRAY-ROW-MAJOR-INDEX");
1166   public static final Symbol ARRAY_TOTAL_SIZE =
1167     PACKAGE_CL.addExternalSymbol("ARRAY-TOTAL-SIZE");
1168   public static final Symbol ARRAY_TOTAL_SIZE_LIMIT =
1169     PACKAGE_CL.addExternalSymbol("ARRAY-TOTAL-SIZE-LIMIT");
1170   public static final Symbol ARRAYP =
1171     PACKAGE_CL.addExternalSymbol("ARRAYP");
1172   public static final Symbol ASH =
1173     PACKAGE_CL.addExternalSymbol("ASH");
1174   public static final Symbol ASIN =
1175     PACKAGE_CL.addExternalSymbol("ASIN");
1176   public static final Symbol ASINH =
1177     PACKAGE_CL.addExternalSymbol("ASINH");
1178   public static final Symbol ASSERT =
1179     PACKAGE_CL.addExternalSymbol("ASSERT");
1180   public static final Symbol ASSOC =
1181     PACKAGE_CL.addExternalSymbol("ASSOC");
1182   public static final Symbol ASSOC_IF =
1183     PACKAGE_CL.addExternalSymbol("ASSOC-IF");
1184   public static final Symbol ASSOC_IF_NOT =
1185     PACKAGE_CL.addExternalSymbol("ASSOC-IF-NOT");
1186   public static final Symbol ATAN =
1187     PACKAGE_CL.addExternalSymbol("ATAN");
1188   public static final Symbol ATANH =
1189     PACKAGE_CL.addExternalSymbol("ATANH");
1190   public static final Symbol ATOM =
1191     PACKAGE_CL.addExternalSymbol("ATOM");
1192   public static final Symbol BASE_CHAR =
1193     PACKAGE_CL.addExternalSymbol("BASE-CHAR");
1194   public static final Symbol BASE_STRING =
1195     PACKAGE_CL.addExternalSymbol("BASE-STRING");
1196   public static final Symbol BIGNUM =
1197     PACKAGE_CL.addExternalSymbol("BIGNUM");
1198   public static final Symbol BIT =
1199     PACKAGE_CL.addExternalSymbol("BIT");
1200   public static final Symbol BIT_AND =
1201     PACKAGE_CL.addExternalSymbol("BIT-AND");
1202   public static final Symbol BIT_ANDC1 =
1203     PACKAGE_CL.addExternalSymbol("BIT-ANDC1");
1204   public static final Symbol BIT_ANDC2 =
1205     PACKAGE_CL.addExternalSymbol("BIT-ANDC2");
1206   public static final Symbol BIT_EQV =
1207     PACKAGE_CL.addExternalSymbol("BIT-EQV");
1208   public static final Symbol BIT_IOR =
1209     PACKAGE_CL.addExternalSymbol("BIT-IOR");
1210   public static final Symbol BIT_NAND =
1211     PACKAGE_CL.addExternalSymbol("BIT-NAND");
1212   public static final Symbol BIT_NOR =
1213     PACKAGE_CL.addExternalSymbol("BIT-NOR");
1214   public static final Symbol BIT_NOT =
1215     PACKAGE_CL.addExternalSymbol("BIT-NOT");
1216   public static final Symbol BIT_ORC1 =
1217     PACKAGE_CL.addExternalSymbol("BIT-ORC1");
1218   public static final Symbol BIT_ORC2 =
1219     PACKAGE_CL.addExternalSymbol("BIT-ORC2");
1220   public static final Symbol BIT_VECTOR =
1221     PACKAGE_CL.addExternalSymbol("BIT-VECTOR");
1222   public static final Symbol BIT_VECTOR_P =
1223     PACKAGE_CL.addExternalSymbol("BIT-VECTOR-P");
1224   public static final Symbol BIT_XOR =
1225     PACKAGE_CL.addExternalSymbol("BIT-XOR");
1226   public static final Symbol BLOCK =
1227     PACKAGE_CL.addExternalSymbol("BLOCK");
1228   public static final Symbol BOOLE =
1229     PACKAGE_CL.addExternalSymbol("BOOLE");
1230   public static final Symbol BOOLE_1 =
1231     PACKAGE_CL.addExternalSymbol("BOOLE-1");
1232   public static final Symbol BOOLE_2 =
1233     PACKAGE_CL.addExternalSymbol("BOOLE-2");
1234   public static final Symbol BOOLE_AND =
1235     PACKAGE_CL.addExternalSymbol("BOOLE-AND");
1236   public static final Symbol BOOLE_ANDC1 =
1237     PACKAGE_CL.addExternalSymbol("BOOLE-ANDC1");
1238   public static final Symbol BOOLE_ANDC2 =
1239     PACKAGE_CL.addExternalSymbol("BOOLE-ANDC2");
1240   public static final Symbol BOOLE_C1 =
1241     PACKAGE_CL.addExternalSymbol("BOOLE-C1");
1242   public static final Symbol BOOLE_C2 =
1243     PACKAGE_CL.addExternalSymbol("BOOLE-C2");
1244   public static final Symbol BOOLE_CLR =
1245     PACKAGE_CL.addExternalSymbol("BOOLE-CLR");
1246   public static final Symbol BOOLE_EQV =
1247     PACKAGE_CL.addExternalSymbol("BOOLE-EQV");
1248   public static final Symbol BOOLE_IOR =
1249     PACKAGE_CL.addExternalSymbol("BOOLE-IOR");
1250   public static final Symbol BOOLE_NAND =
1251     PACKAGE_CL.addExternalSymbol("BOOLE-NAND");
1252   public static final Symbol BOOLE_NOR =
1253     PACKAGE_CL.addExternalSymbol("BOOLE-NOR");
1254   public static final Symbol BOOLE_ORC1 =
1255     PACKAGE_CL.addExternalSymbol("BOOLE-ORC1");
1256   public static final Symbol BOOLE_ORC2 =
1257     PACKAGE_CL.addExternalSymbol("BOOLE-ORC2");
1258   public static final Symbol BOOLE_SET =
1259     PACKAGE_CL.addExternalSymbol("BOOLE-SET");
1260   public static final Symbol BOOLE_XOR =
1261     PACKAGE_CL.addExternalSymbol("BOOLE-XOR");
1262   public static final Symbol BOOLEAN =
1263     PACKAGE_CL.addExternalSymbol("BOOLEAN");
1264   public static final Symbol BOTH_CASE_P =
1265     PACKAGE_CL.addExternalSymbol("BOTH-CASE-P");
1266   public static final Symbol BOUNDP =
1267     PACKAGE_CL.addExternalSymbol("BOUNDP");
1268   public static final Symbol BREAK =
1269     PACKAGE_CL.addExternalSymbol("BREAK");
1270   public static final Symbol BROADCAST_STREAM =
1271     PACKAGE_CL.addExternalSymbol("BROADCAST-STREAM");
1272   public static final Symbol BROADCAST_STREAM_STREAMS =
1273     PACKAGE_CL.addExternalSymbol("BROADCAST-STREAM-STREAMS");
1274   public static final Symbol BUILT_IN_CLASS =
1275     PACKAGE_CL.addExternalSymbol("BUILT-IN-CLASS");
1276   public static final Symbol BUTLAST =
1277     PACKAGE_CL.addExternalSymbol("BUTLAST");
1278   public static final Symbol BYTE =
1279     PACKAGE_CL.addExternalSymbol("BYTE");
1280   public static final Symbol BYTE_POSITION =
1281     PACKAGE_CL.addExternalSymbol("BYTE-POSITION");
1282   public static final Symbol BYTE_SIZE =
1283     PACKAGE_CL.addExternalSymbol("BYTE-SIZE");
1284   public static final Symbol CAAAAR =
1285     PACKAGE_CL.addExternalSymbol("CAAAAR");
1286   public static final Symbol CAAADR =
1287     PACKAGE_CL.addExternalSymbol("CAAADR");
1288   public static final Symbol CAAAR =
1289     PACKAGE_CL.addExternalSymbol("CAAAR");
1290   public static final Symbol CAADAR =
1291     PACKAGE_CL.addExternalSymbol("CAADAR");
1292   public static final Symbol CAADDR =
1293     PACKAGE_CL.addExternalSymbol("CAADDR");
1294   public static final Symbol CAADR =
1295     PACKAGE_CL.addExternalSymbol("CAADR");
1296   public static final Symbol CAAR =
1297     PACKAGE_CL.addExternalSymbol("CAAR");
1298   public static final Symbol CADAAR =
1299     PACKAGE_CL.addExternalSymbol("CADAAR");
1300   public static final Symbol CADADR =
1301     PACKAGE_CL.addExternalSymbol("CADADR");
1302   public static final Symbol CADAR =
1303     PACKAGE_CL.addExternalSymbol("CADAR");
1304   public static final Symbol CADDAR =
1305     PACKAGE_CL.addExternalSymbol("CADDAR");
1306   public static final Symbol CADDDR =
1307     PACKAGE_CL.addExternalSymbol("CADDDR");
1308   public static final Symbol CADDR =
1309     PACKAGE_CL.addExternalSymbol("CADDR");
1310   public static final Symbol CADR =
1311     PACKAGE_CL.addExternalSymbol("CADR");
1312   public static final Symbol CALL_ARGUMENTS_LIMIT =
1313     PACKAGE_CL.addExternalSymbol("CALL-ARGUMENTS-LIMIT");
1314   public static final Symbol CALL_METHOD =
1315     PACKAGE_CL.addExternalSymbol("CALL-METHOD");
1316   public static final Symbol CALL_NEXT_METHOD =
1317     PACKAGE_CL.addExternalSymbol("CALL-NEXT-METHOD");
1318   public static final Symbol CAR =
1319     PACKAGE_CL.addExternalSymbol("CAR");
1320   public static final Symbol CASE =
1321     PACKAGE_CL.addExternalSymbol("CASE");
1322   public static final Symbol CATCH =
1323     PACKAGE_CL.addExternalSymbol("CATCH");
1324   public static final Symbol CCASE =
1325     PACKAGE_CL.addExternalSymbol("CCASE");
1326   public static final Symbol CDAAAR =
1327     PACKAGE_CL.addExternalSymbol("CDAAAR");
1328   public static final Symbol CDAADR =
1329     PACKAGE_CL.addExternalSymbol("CDAADR");
1330   public static final Symbol CDAAR =
1331     PACKAGE_CL.addExternalSymbol("CDAAR");
1332   public static final Symbol CDADAR =
1333     PACKAGE_CL.addExternalSymbol("CDADAR");
1334   public static final Symbol CDADDR =
1335     PACKAGE_CL.addExternalSymbol("CDADDR");
1336   public static final Symbol CDADR =
1337     PACKAGE_CL.addExternalSymbol("CDADR");
1338   public static final Symbol CDAR =
1339     PACKAGE_CL.addExternalSymbol("CDAR");
1340   public static final Symbol CDDAAR =
1341     PACKAGE_CL.addExternalSymbol("CDDAAR");
1342   public static final Symbol CDDADR =
1343     PACKAGE_CL.addExternalSymbol("CDDADR");
1344   public static final Symbol CDDAR =
1345     PACKAGE_CL.addExternalSymbol("CDDAR");
1346   public static final Symbol CDDDAR =
1347     PACKAGE_CL.addExternalSymbol("CDDDAR");
1348   public static final Symbol CDDDDR =
1349     PACKAGE_CL.addExternalSymbol("CDDDDR");
1350   public static final Symbol CDDDR =
1351     PACKAGE_CL.addExternalSymbol("CDDDR");
1352   public static final Symbol CDDR =
1353     PACKAGE_CL.addExternalSymbol("CDDR");
1354   public static final Symbol CDR =
1355     PACKAGE_CL.addExternalSymbol("CDR");
1356   public static final Symbol CEILING =
1357     PACKAGE_CL.addExternalSymbol("CEILING");
1358   public static final Symbol CELL_ERROR =
1359     PACKAGE_CL.addExternalSymbol("CELL-ERROR");
1360   public static final Symbol CELL_ERROR_NAME =
1361     PACKAGE_CL.addExternalSymbol("CELL-ERROR-NAME");
1362   public static final Symbol CERROR =
1363     PACKAGE_CL.addExternalSymbol("CERROR");
1364   public static final Symbol CHANGE_CLASS =
1365     PACKAGE_CL.addExternalSymbol("CHANGE-CLASS");
1366   public static final Symbol CHAR =
1367     PACKAGE_CL.addExternalSymbol("CHAR");
1368   public static final Symbol CHAR_CODE =
1369     PACKAGE_CL.addExternalSymbol("CHAR-CODE");
1370   public static final Symbol CHAR_CODE_LIMIT =
1371     PACKAGE_CL.addExternalSymbol("CHAR-CODE-LIMIT");
1372   public static final Symbol CHAR_DOWNCASE =
1373     PACKAGE_CL.addExternalSymbol("CHAR-DOWNCASE");
1374   public static final Symbol CHAR_EQUAL =
1375     PACKAGE_CL.addExternalSymbol("CHAR-EQUAL");
1376   public static final Symbol CHAR_GREATERP =
1377     PACKAGE_CL.addExternalSymbol("CHAR-GREATERP");
1378   public static final Symbol CHAR_INT =
1379     PACKAGE_CL.addExternalSymbol("CHAR-INT");
1380   public static final Symbol CHAR_LESSP =
1381     PACKAGE_CL.addExternalSymbol("CHAR-LESSP");
1382   public static final Symbol CHAR_NAME =
1383     PACKAGE_CL.addExternalSymbol("CHAR-NAME");
1384   public static final Symbol CHAR_NOT_EQUAL =
1385     PACKAGE_CL.addExternalSymbol("CHAR-NOT-EQUAL");
1386   public static final Symbol CHAR_NOT_GREATERP =
1387     PACKAGE_CL.addExternalSymbol("CHAR-NOT-GREATERP");
1388   public static final Symbol CHAR_NOT_LESSP =
1389     PACKAGE_CL.addExternalSymbol("CHAR-NOT-LESSP");
1390   public static final Symbol CHAR_UPCASE =
1391     PACKAGE_CL.addExternalSymbol("CHAR-UPCASE");
1392   public static final Symbol CHAR_NE =
1393     PACKAGE_CL.addExternalSymbol("CHAR/=");
1394   public static final Symbol CHAR_LT =
1395     PACKAGE_CL.addExternalSymbol("CHAR<");
1396   public static final Symbol CHAR_LE =
1397     PACKAGE_CL.addExternalSymbol("CHAR<=");
1398   public static final Symbol CHAR_EQUALS =
1399     PACKAGE_CL.addExternalSymbol("CHAR=");
1400   public static final Symbol CHAR_GT =
1401     PACKAGE_CL.addExternalSymbol("CHAR>");
1402   public static final Symbol CHAR_GE =
1403     PACKAGE_CL.addExternalSymbol("CHAR>=");
1404   public static final Symbol CHARACTER =
1405     PACKAGE_CL.addExternalSymbol("CHARACTER");
1406   public static final Symbol CHARACTERP =
1407     PACKAGE_CL.addExternalSymbol("CHARACTERP");
1408   public static final Symbol CHECK_TYPE =
1409     PACKAGE_CL.addExternalSymbol("CHECK-TYPE");
1410   public static final Symbol CIS =
1411     PACKAGE_CL.addExternalSymbol("CIS");
1412   public static final Symbol CLASS =
1413     PACKAGE_CL.addExternalSymbol("CLASS");
1414   public static final Symbol CLASS_NAME =
1415     PACKAGE_CL.addExternalSymbol("CLASS-NAME");
1416   public static final Symbol CLASS_OF =
1417     PACKAGE_CL.addExternalSymbol("CLASS-OF");
1418   public static final Symbol CLEAR_INPUT =
1419     PACKAGE_CL.addExternalSymbol("CLEAR-INPUT");
1420   public static final Symbol CLEAR_OUTPUT =
1421     PACKAGE_CL.addExternalSymbol("CLEAR-OUTPUT");
1422   public static final Symbol CLOSE =
1423     PACKAGE_CL.addExternalSymbol("CLOSE");
1424   public static final Symbol CLRHASH =
1425     PACKAGE_CL.addExternalSymbol("CLRHASH");
1426   public static final Symbol CODE_CHAR =
1427     PACKAGE_CL.addExternalSymbol("CODE-CHAR");
1428   public static final Symbol COERCE =
1429     PACKAGE_CL.addExternalSymbol("COERCE");
1430   public static final Symbol COMPILATION_SPEED =
1431     PACKAGE_CL.addExternalSymbol("COMPILATION-SPEED");
1432   public static final Symbol COMPILE =
1433     PACKAGE_CL.addExternalSymbol("COMPILE");
1434   public static final Symbol COMPILE_FILE =
1435     PACKAGE_CL.addExternalSymbol("COMPILE-FILE");
1436   public static final Symbol COMPILE_FILE_PATHNAME =
1437     PACKAGE_CL.addExternalSymbol("COMPILE-FILE-PATHNAME");
1438   public static final Symbol COMPILED_FUNCTION =
1439     PACKAGE_CL.addExternalSymbol("COMPILED-FUNCTION");
1440   public static final Symbol COMPILED_FUNCTION_P =
1441     PACKAGE_CL.addExternalSymbol("COMPILED-FUNCTION-P");
1442   public static final Symbol COMPILER_MACRO =
1443     PACKAGE_CL.addExternalSymbol("COMPILER-MACRO");
1444   public static final Symbol COMPILER_MACRO_FUNCTION =
1445     PACKAGE_CL.addExternalSymbol("COMPILER-MACRO-FUNCTION");
1446   public static final Symbol COMPLEMENT =
1447     PACKAGE_CL.addExternalSymbol("COMPLEMENT");
1448   public static final Symbol COMPLEX =
1449     PACKAGE_CL.addExternalSymbol("COMPLEX");
1450   public static final Symbol COMPLEXP =
1451     PACKAGE_CL.addExternalSymbol("COMPLEXP");
1452   public static final Symbol COMPUTE_APPLICABLE_METHODS =
1453     PACKAGE_CL.addExternalSymbol("COMPUTE-APPLICABLE-METHODS");
1454   public static final Symbol COMPUTE_RESTARTS =
1455     PACKAGE_CL.addExternalSymbol("COMPUTE-RESTARTS");
1456   public static final Symbol CONCATENATE =
1457     PACKAGE_CL.addExternalSymbol("CONCATENATE");
1458   public static final Symbol CONCATENATED_STREAM =
1459     PACKAGE_CL.addExternalSymbol("CONCATENATED-STREAM");
1460   public static final Symbol CONCATENATED_STREAM_STREAMS =
1461     PACKAGE_CL.addExternalSymbol("CONCATENATED-STREAM-STREAMS");
1462   public static final Symbol COND =
1463     PACKAGE_CL.addExternalSymbol("COND");
1464   public static final Symbol CONDITION =
1465     PACKAGE_CL.addExternalSymbol("CONDITION");
1466   public static final Symbol CONJUGATE =
1467     PACKAGE_CL.addExternalSymbol("CONJUGATE");
1468   public static final Symbol CONS =
1469     PACKAGE_CL.addExternalSymbol("CONS");
1470   public static final Symbol CONSP =
1471     PACKAGE_CL.addExternalSymbol("CONSP");
1472   public static final Symbol CONSTANTLY =
1473     PACKAGE_CL.addExternalSymbol("CONSTANTLY");
1474   public static final Symbol CONSTANTP =
1475     PACKAGE_CL.addExternalSymbol("CONSTANTP");
1476   public static final Symbol CONTINUE =
1477     PACKAGE_CL.addExternalSymbol("CONTINUE");
1478   public static final Symbol CONTROL_ERROR =
1479     PACKAGE_CL.addExternalSymbol("CONTROL-ERROR");
1480   public static final Symbol COPY_ALIST =
1481     PACKAGE_CL.addExternalSymbol("COPY-ALIST");
1482   public static final Symbol COPY_LIST =
1483     PACKAGE_CL.addExternalSymbol("COPY-LIST");
1484   public static final Symbol COPY_PPRINT_DISPATCH =
1485     PACKAGE_CL.addExternalSymbol("COPY-PPRINT-DISPATCH");
1486   public static final Symbol COPY_READTABLE =
1487     PACKAGE_CL.addExternalSymbol("COPY-READTABLE");
1488   public static final Symbol COPY_SEQ =
1489     PACKAGE_CL.addExternalSymbol("COPY-SEQ");
1490   public static final Symbol COPY_STRUCTURE =
1491     PACKAGE_CL.addExternalSymbol("COPY-STRUCTURE");
1492   public static final Symbol COPY_SYMBOL =
1493     PACKAGE_CL.addExternalSymbol("COPY-SYMBOL");
1494   public static final Symbol COPY_TREE =
1495     PACKAGE_CL.addExternalSymbol("COPY-TREE");
1496   public static final Symbol COS =
1497     PACKAGE_CL.addExternalSymbol("COS");
1498   public static final Symbol COSH =
1499     PACKAGE_CL.addExternalSymbol("COSH");
1500   public static final Symbol COUNT =
1501     PACKAGE_CL.addExternalSymbol("COUNT");
1502   public static final Symbol COUNT_IF =
1503     PACKAGE_CL.addExternalSymbol("COUNT-IF");
1504   public static final Symbol COUNT_IF_NOT =
1505     PACKAGE_CL.addExternalSymbol("COUNT-IF-NOT");
1506   public static final Symbol CTYPECASE =
1507     PACKAGE_CL.addExternalSymbol("CTYPECASE");
1508   public static final Symbol DEBUG =
1509     PACKAGE_CL.addExternalSymbol("DEBUG");
1510   public static final Symbol DECF =
1511     PACKAGE_CL.addExternalSymbol("DECF");
1512   public static final Symbol DECLAIM =
1513     PACKAGE_CL.addExternalSymbol("DECLAIM");
1514   public static final Symbol DECLARATION =
1515     PACKAGE_CL.addExternalSymbol("DECLARATION");
1516   public static final Symbol DECLARE =
1517     PACKAGE_CL.addExternalSymbol("DECLARE");
1518   public static final Symbol DECODE_FLOAT =
1519     PACKAGE_CL.addExternalSymbol("DECODE-FLOAT");
1520   public static final Symbol DECODE_UNIVERSAL_TIME =
1521     PACKAGE_CL.addExternalSymbol("DECODE-UNIVERSAL-TIME");
1522   public static final Symbol DEFCLASS =
1523     PACKAGE_CL.addExternalSymbol("DEFCLASS");
1524   public static final Symbol DEFCONSTANT =
1525     PACKAGE_CL.addExternalSymbol("DEFCONSTANT");
1526   public static final Symbol DEFGENERIC =
1527     PACKAGE_CL.addExternalSymbol("DEFGENERIC");
1528   public static final Symbol DEFINE_COMPILER_MACRO =
1529     PACKAGE_CL.addExternalSymbol("DEFINE-COMPILER-MACRO");
1530   public static final Symbol DEFINE_CONDITION =
1531     PACKAGE_CL.addExternalSymbol("DEFINE-CONDITION");
1532   public static final Symbol DEFINE_METHOD_COMBINATION =
1533     PACKAGE_CL.addExternalSymbol("DEFINE-METHOD-COMBINATION");
1534   public static final Symbol DEFINE_MODIFY_MACRO =
1535     PACKAGE_CL.addExternalSymbol("DEFINE-MODIFY-MACRO");
1536   public static final Symbol DEFINE_SETF_EXPANDER =
1537     PACKAGE_CL.addExternalSymbol("DEFINE-SETF-EXPANDER");
1538   public static final Symbol DEFINE_SYMBOL_MACRO =
1539     PACKAGE_CL.addExternalSymbol("DEFINE-SYMBOL-MACRO");
1540   public static final Symbol DEFMACRO =
1541     PACKAGE_CL.addExternalSymbol("DEFMACRO");
1542   public static final Symbol DEFMETHOD =
1543     PACKAGE_CL.addExternalSymbol("DEFMETHOD");
1544   public static final Symbol DEFPACKAGE =
1545     PACKAGE_CL.addExternalSymbol("DEFPACKAGE");
1546   public static final Symbol DEFPARAMETER =
1547     PACKAGE_CL.addExternalSymbol("DEFPARAMETER");
1548   public static final Symbol DEFSETF =
1549     PACKAGE_CL.addExternalSymbol("DEFSETF");
1550   public static final Symbol DEFSTRUCT =
1551     PACKAGE_CL.addExternalSymbol("DEFSTRUCT");
1552   public static final Symbol DEFTYPE =
1553     PACKAGE_CL.addExternalSymbol("DEFTYPE");
1554   public static final Symbol DEFUN =
1555     PACKAGE_CL.addExternalSymbol("DEFUN");
1556   public static final Symbol DEFVAR =
1557     PACKAGE_CL.addExternalSymbol("DEFVAR");
1558   public static final Symbol DELETE =
1559     PACKAGE_CL.addExternalSymbol("DELETE");
1560   public static final Symbol DELETE_DUPLICATES =
1561     PACKAGE_CL.addExternalSymbol("DELETE-DUPLICATES");
1562   public static final Symbol DELETE_FILE =
1563     PACKAGE_CL.addExternalSymbol("DELETE-FILE");
1564   public static final Symbol DELETE_IF =
1565     PACKAGE_CL.addExternalSymbol("DELETE-IF");
1566   public static final Symbol DELETE_IF_NOT =
1567     PACKAGE_CL.addExternalSymbol("DELETE-IF-NOT");
1568   public static final Symbol DELETE_PACKAGE =
1569     PACKAGE_CL.addExternalSymbol("DELETE-PACKAGE");
1570   public static final Symbol DENOMINATOR =
1571     PACKAGE_CL.addExternalSymbol("DENOMINATOR");
1572   public static final Symbol DEPOSIT_FIELD =
1573     PACKAGE_CL.addExternalSymbol("DEPOSIT-FIELD");
1574   public static final Symbol DESCRIBE =
1575     PACKAGE_CL.addExternalSymbol("DESCRIBE");
1576   public static final Symbol DESCRIBE_OBJECT =
1577     PACKAGE_CL.addExternalSymbol("DESCRIBE-OBJECT");
1578   public static final Symbol DESTRUCTURING_BIND =
1579     PACKAGE_CL.addExternalSymbol("DESTRUCTURING-BIND");
1580   public static final Symbol DIGIT_CHAR =
1581     PACKAGE_CL.addExternalSymbol("DIGIT-CHAR");
1582   public static final Symbol DIGIT_CHAR_P =
1583     PACKAGE_CL.addExternalSymbol("DIGIT-CHAR-P");
1584   public static final Symbol DIRECTORY =
1585     PACKAGE_CL.addExternalSymbol("DIRECTORY");
1586   public static final Symbol DIRECTORY_NAMESTRING =
1587     PACKAGE_CL.addExternalSymbol("DIRECTORY-NAMESTRING");
1588   public static final Symbol DISASSEMBLE =
1589     PACKAGE_CL.addExternalSymbol("DISASSEMBLE");
1590   public static final Symbol DIVISION_BY_ZERO =
1591     PACKAGE_CL.addExternalSymbol("DIVISION-BY-ZERO");
1592   public static final Symbol DO =
1593     PACKAGE_CL.addExternalSymbol("DO");
1594   public static final Symbol DO_STAR =
1595     PACKAGE_CL.addExternalSymbol("DO*");
1596   public static final Symbol DO_ALL_SYMBOLS =
1597     PACKAGE_CL.addExternalSymbol("DO-ALL-SYMBOLS");
1598   public static final Symbol DO_EXTERNAL_SYMBOLS =
1599     PACKAGE_CL.addExternalSymbol("DO-EXTERNAL-SYMBOLS");
1600   public static final Symbol DO_SYMBOLS =
1601     PACKAGE_CL.addExternalSymbol("DO-SYMBOLS");
1602   public static final Symbol DOCUMENTATION =
1603     PACKAGE_CL.addExternalSymbol("DOCUMENTATION");
1604   public static final Symbol DOLIST =
1605     PACKAGE_CL.addExternalSymbol("DOLIST");
1606   public static final Symbol DOTIMES =
1607     PACKAGE_CL.addExternalSymbol("DOTIMES");
1608   public static final Symbol DOUBLE_FLOAT =
1609     PACKAGE_CL.addExternalSymbol("DOUBLE-FLOAT");
1610   public static final Symbol DOUBLE_FLOAT_EPSILON =
1611     PACKAGE_CL.addExternalSymbol("DOUBLE-FLOAT-EPSILON");
1612   public static final Symbol DOUBLE_FLOAT_NEGATIVE_EPSILON =
1613     PACKAGE_CL.addExternalSymbol("DOUBLE-FLOAT-NEGATIVE-EPSILON");
1614   public static final Symbol DPB =
1615     PACKAGE_CL.addExternalSymbol("DPB");
1616   public static final Symbol DRIBBLE =
1617     PACKAGE_CL.addExternalSymbol("DRIBBLE");
1618   public static final Symbol DYNAMIC_EXTENT =
1619     PACKAGE_CL.addExternalSymbol("DYNAMIC-EXTENT");
1620   public static final Symbol ECASE =
1621     PACKAGE_CL.addExternalSymbol("ECASE");
1622   public static final Symbol ECHO_STREAM =
1623     PACKAGE_CL.addExternalSymbol("ECHO-STREAM");
1624   public static final Symbol ECHO_STREAM_INPUT_STREAM =
1625     PACKAGE_CL.addExternalSymbol("ECHO-STREAM-INPUT-STREAM");
1626   public static final Symbol ECHO_STREAM_OUTPUT_STREAM =
1627     PACKAGE_CL.addExternalSymbol("ECHO-STREAM-OUTPUT-STREAM");
1628   public static final Symbol ED =
1629     PACKAGE_CL.addExternalSymbol("ED");
1630   public static final Symbol EIGHTH =
1631     PACKAGE_CL.addExternalSymbol("EIGHTH");
1632   public static final Symbol ELT =
1633     PACKAGE_CL.addExternalSymbol("ELT");
1634   public static final Symbol ENCODE_UNIVERSAL_TIME =
1635     PACKAGE_CL.addExternalSymbol("ENCODE-UNIVERSAL-TIME");
1636   public static final Symbol END_OF_FILE =
1637     PACKAGE_CL.addExternalSymbol("END-OF-FILE");
1638   public static final Symbol ENDP =
1639     PACKAGE_CL.addExternalSymbol("ENDP");
1640   public static final Symbol ENOUGH_NAMESTRING =
1641     PACKAGE_CL.addExternalSymbol("ENOUGH-NAMESTRING");
1642   public static final Symbol ENSURE_DIRECTORIES_EXIST =
1643     PACKAGE_CL.addExternalSymbol("ENSURE-DIRECTORIES-EXIST");
1644   public static final Symbol ENSURE_GENERIC_FUNCTION =
1645     PACKAGE_CL.addExternalSymbol("ENSURE-GENERIC-FUNCTION");
1646   public static final Symbol EQ =
1647     PACKAGE_CL.addExternalSymbol("EQ");
1648   public static final Symbol EQL =
1649     PACKAGE_CL.addExternalSymbol("EQL");
1650   public static final Symbol EQUAL =
1651     PACKAGE_CL.addExternalSymbol("EQUAL");
1652   public static final Symbol EQUALP =
1653     PACKAGE_CL.addExternalSymbol("EQUALP");
1654   public static final Symbol ERROR =
1655     PACKAGE_CL.addExternalSymbol("ERROR");
1656   public static final Symbol ETYPECASE =
1657     PACKAGE_CL.addExternalSymbol("ETYPECASE");
1658   public static final Symbol EVAL =
1659     PACKAGE_CL.addExternalSymbol("EVAL");
1660   public static final Symbol EVAL_WHEN =
1661     PACKAGE_CL.addExternalSymbol("EVAL-WHEN");
1662   public static final Symbol EVENP =
1663     PACKAGE_CL.addExternalSymbol("EVENP");
1664   public static final Symbol EVERY =
1665     PACKAGE_CL.addExternalSymbol("EVERY");
1666   public static final Symbol EXP =
1667     PACKAGE_CL.addExternalSymbol("EXP");
1668   public static final Symbol EXPORT =
1669     PACKAGE_CL.addExternalSymbol("EXPORT");
1670   public static final Symbol EXPT =
1671     PACKAGE_CL.addExternalSymbol("EXPT");
1672   public static final Symbol EXTENDED_CHAR =
1673     PACKAGE_CL.addExternalSymbol("EXTENDED-CHAR");
1674   public static final Symbol FBOUNDP =
1675     PACKAGE_CL.addExternalSymbol("FBOUNDP");
1676   public static final Symbol FCEILING =
1677     PACKAGE_CL.addExternalSymbol("FCEILING");
1678   public static final Symbol FDEFINITION =
1679     PACKAGE_CL.addExternalSymbol("FDEFINITION");
1680   public static final Symbol FFLOOR =
1681     PACKAGE_CL.addExternalSymbol("FFLOOR");
1682   public static final Symbol FIFTH =
1683     PACKAGE_CL.addExternalSymbol("FIFTH");
1684   public static final Symbol FILE_AUTHOR =
1685     PACKAGE_CL.addExternalSymbol("FILE-AUTHOR");
1686   public static final Symbol FILE_ERROR =
1687     PACKAGE_CL.addExternalSymbol("FILE-ERROR");
1688   public static final Symbol FILE_ERROR_PATHNAME =
1689     PACKAGE_CL.addExternalSymbol("FILE-ERROR-PATHNAME");
1690   public static final Symbol FILE_LENGTH =
1691     PACKAGE_CL.addExternalSymbol("FILE-LENGTH");
1692   public static final Symbol FILE_NAMESTRING =
1693     PACKAGE_CL.addExternalSymbol("FILE-NAMESTRING");
1694   public static final Symbol FILE_POSITION =
1695     PACKAGE_CL.addExternalSymbol("FILE-POSITION");
1696   public static final Symbol FILE_STREAM =
1697     PACKAGE_CL.addExternalSymbol("FILE-STREAM");
1698   public static final Symbol FILE_STRING_LENGTH =
1699     PACKAGE_CL.addExternalSymbol("FILE-STRING-LENGTH");
1700   public static final Symbol FILE_WRITE_DATE =
1701     PACKAGE_CL.addExternalSymbol("FILE-WRITE-DATE");
1702   public static final Symbol FILL =
1703     PACKAGE_CL.addExternalSymbol("FILL");
1704   public static final Symbol FILL_POINTER =
1705     PACKAGE_CL.addExternalSymbol("FILL-POINTER");
1706   public static final Symbol FIND =
1707     PACKAGE_CL.addExternalSymbol("FIND");
1708   public static final Symbol FIND_ALL_SYMBOLS =
1709     PACKAGE_CL.addExternalSymbol("FIND-ALL-SYMBOLS");
1710   public static final Symbol FIND_CLASS =
1711     PACKAGE_CL.addExternalSymbol("FIND-CLASS");
1712   public static final Symbol FIND_IF =
1713     PACKAGE_CL.addExternalSymbol("FIND-IF");
1714   public static final Symbol FIND_IF_NOT =
1715     PACKAGE_CL.addExternalSymbol("FIND-IF-NOT");
1716   public static final Symbol FIND_METHOD =
1717     PACKAGE_CL.addExternalSymbol("FIND-METHOD");
1718   public static final Symbol FIND_PACKAGE =
1719     PACKAGE_CL.addExternalSymbol("FIND-PACKAGE");
1720   public static final Symbol FIND_RESTART =
1721     PACKAGE_CL.addExternalSymbol("FIND-RESTART");
1722   public static final Symbol FIND_SYMBOL =
1723     PACKAGE_CL.addExternalSymbol("FIND-SYMBOL");
1724   public static final Symbol FINISH_OUTPUT =
1725     PACKAGE_CL.addExternalSymbol("FINISH-OUTPUT");
1726   public static final Symbol FIRST =
1727     PACKAGE_CL.addExternalSymbol("FIRST");
1728   public static final Symbol FIXNUM =
1729     PACKAGE_CL.addExternalSymbol("FIXNUM");
1730   public static final Symbol FLET =
1731     PACKAGE_CL.addExternalSymbol("FLET");
1732   public static final Symbol FLOAT =
1733     PACKAGE_CL.addExternalSymbol("FLOAT");
1734   public static final Symbol FLOAT_DIGITS =
1735     PACKAGE_CL.addExternalSymbol("FLOAT-DIGITS");
1736   public static final Symbol FLOAT_PRECISION =
1737     PACKAGE_CL.addExternalSymbol("FLOAT-PRECISION");
1738   public static final Symbol FLOAT_RADIX =
1739     PACKAGE_CL.addExternalSymbol("FLOAT-RADIX");
1740   public static final Symbol FLOAT_SIGN =
1741     PACKAGE_CL.addExternalSymbol("FLOAT-SIGN");
1742   public static final Symbol FLOATING_POINT_INEXACT =
1743     PACKAGE_CL.addExternalSymbol("FLOATING-POINT-INEXACT");
1744   public static final Symbol FLOATING_POINT_INVALID_OPERATION =
1745     PACKAGE_CL.addExternalSymbol("FLOATING-POINT-INVALID-OPERATION");
1746   public static final Symbol FLOATING_POINT_OVERFLOW =
1747     PACKAGE_CL.addExternalSymbol("FLOATING-POINT-OVERFLOW");
1748   public static final Symbol FLOATING_POINT_UNDERFLOW =
1749     PACKAGE_CL.addExternalSymbol("FLOATING-POINT-UNDERFLOW");
1750   public static final Symbol FLOATP =
1751     PACKAGE_CL.addExternalSymbol("FLOATP");
1752   public static final Symbol FLOOR =
1753     PACKAGE_CL.addExternalSymbol("FLOOR");
1754   public static final Symbol FMAKUNBOUND =
1755     PACKAGE_CL.addExternalSymbol("FMAKUNBOUND");
1756   public static final Symbol FORCE_OUTPUT =
1757     PACKAGE_CL.addExternalSymbol("FORCE-OUTPUT");
1758   public static final Symbol FORMAT =
1759     PACKAGE_CL.addExternalSymbol("FORMAT");
1760   public static final Symbol FORMATTER =
1761     PACKAGE_CL.addExternalSymbol("FORMATTER");
1762   public static final Symbol FOURTH =
1763     PACKAGE_CL.addExternalSymbol("FOURTH");
1764   public static final Symbol FRESH_LINE =
1765     PACKAGE_CL.addExternalSymbol("FRESH-LINE");
1766   public static final Symbol FROUND =
1767     PACKAGE_CL.addExternalSymbol("FROUND");
1768   public static final Symbol FTRUNCATE =
1769     PACKAGE_CL.addExternalSymbol("FTRUNCATE");
1770   public static final Symbol FTYPE =
1771     PACKAGE_CL.addExternalSymbol("FTYPE");
1772   public static final Symbol FUNCALL =
1773     PACKAGE_CL.addExternalSymbol("FUNCALL");
1774   public static final Symbol FUNCTION =
1775     PACKAGE_CL.addExternalSymbol("FUNCTION");
1776   public static final Symbol FUNCTION_KEYWORDS =
1777     PACKAGE_CL.addExternalSymbol("FUNCTION-KEYWORDS");
1778   public static final Symbol FUNCTION_LAMBDA_EXPRESSION =
1779     PACKAGE_CL.addExternalSymbol("FUNCTION-LAMBDA-EXPRESSION");
1780   public static final Symbol FUNCTIONP =
1781     PACKAGE_CL.addExternalSymbol("FUNCTIONP");
1782   public static final Symbol GCD =
1783     PACKAGE_CL.addExternalSymbol("GCD");
1784   public static final Symbol GENERIC_FUNCTION =
1785     PACKAGE_CL.addExternalSymbol("GENERIC-FUNCTION");
1786   public static final Symbol GENSYM =
1787     PACKAGE_CL.addExternalSymbol("GENSYM");
1788   public static final Symbol GENTEMP =
1789     PACKAGE_CL.addExternalSymbol("GENTEMP");
1790   public static final Symbol GET =
1791     PACKAGE_CL.addExternalSymbol("GET");
1792   public static final Symbol GET_DECODED_TIME =
1793     PACKAGE_CL.addExternalSymbol("GET-DECODED-TIME");
1794   public static final Symbol GET_DISPATCH_MACRO_CHARACTER =
1795     PACKAGE_CL.addExternalSymbol("GET-DISPATCH-MACRO-CHARACTER");
1796   public static final Symbol GET_INTERNAL_REAL_TIME =
1797     PACKAGE_CL.addExternalSymbol("GET-INTERNAL-REAL-TIME");
1798   public static final Symbol GET_INTERNAL_RUN_TIME =
1799     PACKAGE_CL.addExternalSymbol("GET-INTERNAL-RUN-TIME");
1800   public static final Symbol GET_MACRO_CHARACTER =
1801     PACKAGE_CL.addExternalSymbol("GET-MACRO-CHARACTER");
1802   public static final Symbol GET_OUTPUT_STREAM_STRING =
1803     PACKAGE_CL.addExternalSymbol("GET-OUTPUT-STREAM-STRING");
1804   public static final Symbol GET_PROPERTIES =
1805     PACKAGE_CL.addExternalSymbol("GET-PROPERTIES");
1806   public static final Symbol GET_SETF_EXPANSION =
1807     PACKAGE_CL.addExternalSymbol("GET-SETF-EXPANSION");
1808   public static final Symbol GET_UNIVERSAL_TIME =
1809     PACKAGE_CL.addExternalSymbol("GET-UNIVERSAL-TIME");
1810   public static final Symbol GETF =
1811     PACKAGE_CL.addExternalSymbol("GETF");
1812   public static final Symbol GETHASH =
1813     PACKAGE_CL.addExternalSymbol("GETHASH");
1814   public static final Symbol GO =
1815     PACKAGE_CL.addExternalSymbol("GO");
1816   public static final Symbol GRAPHIC_CHAR_P =
1817     PACKAGE_CL.addExternalSymbol("GRAPHIC-CHAR-P");
1818   public static final Symbol HANDLER_BIND =
1819     PACKAGE_CL.addExternalSymbol("HANDLER-BIND");
1820   public static final Symbol HANDLER_CASE =
1821     PACKAGE_CL.addExternalSymbol("HANDLER-CASE");
1822   public static final Symbol HASH_TABLE =
1823     PACKAGE_CL.addExternalSymbol("HASH-TABLE");
1824   public static final Symbol HASH_TABLE_COUNT =
1825     PACKAGE_CL.addExternalSymbol("HASH-TABLE-COUNT");
1826   public static final Symbol HASH_TABLE_P =
1827     PACKAGE_CL.addExternalSymbol("HASH-TABLE-P");
1828   public static final Symbol HASH_TABLE_REHASH_SIZE =
1829     PACKAGE_CL.addExternalSymbol("HASH-TABLE-REHASH-SIZE");
1830   public static final Symbol HASH_TABLE_REHASH_THRESHOLD =
1831     PACKAGE_CL.addExternalSymbol("HASH-TABLE-REHASH-THRESHOLD");
1832   public static final Symbol HASH_TABLE_SIZE =
1833     PACKAGE_CL.addExternalSymbol("HASH-TABLE-SIZE");
1834   public static final Symbol HASH_TABLE_TEST =
1835     PACKAGE_CL.addExternalSymbol("HASH-TABLE-TEST");
1836   public static final Symbol HOST_NAMESTRING =
1837     PACKAGE_CL.addExternalSymbol("HOST-NAMESTRING");
1838   public static final Symbol IDENTITY =
1839     PACKAGE_CL.addExternalSymbol("IDENTITY");
1840   public static final Symbol IF =
1841     PACKAGE_CL.addExternalSymbol("IF");
1842   public static final Symbol IGNORABLE =
1843     PACKAGE_CL.addExternalSymbol("IGNORABLE");
1844   public static final Symbol IGNORE =
1845     PACKAGE_CL.addExternalSymbol("IGNORE");
1846   public static final Symbol IGNORE_ERRORS =
1847     PACKAGE_CL.addExternalSymbol("IGNORE-ERRORS");
1848   public static final Symbol IMAGPART =
1849     PACKAGE_CL.addExternalSymbol("IMAGPART");
1850   public static final Symbol IMPORT =
1851     PACKAGE_CL.addExternalSymbol("IMPORT");
1852   public static final Symbol IN_PACKAGE =
1853     PACKAGE_CL.addExternalSymbol("IN-PACKAGE");
1854   public static final Symbol INCF =
1855     PACKAGE_CL.addExternalSymbol("INCF");
1856   public static final Symbol INITIALIZE_INSTANCE =
1857     PACKAGE_CL.addExternalSymbol("INITIALIZE-INSTANCE");
1858   public static final Symbol INLINE =
1859     PACKAGE_CL.addExternalSymbol("INLINE");
1860   public static final Symbol INPUT_STREAM_P =
1861     PACKAGE_CL.addExternalSymbol("INPUT-STREAM-P");
1862   public static final Symbol INSPECT =
1863     PACKAGE_CL.addExternalSymbol("INSPECT");
1864   public static final Symbol INTEGER =
1865     PACKAGE_CL.addExternalSymbol("INTEGER");
1866   public static final Symbol INTEGER_DECODE_FLOAT =
1867     PACKAGE_CL.addExternalSymbol("INTEGER-DECODE-FLOAT");
1868   public static final Symbol INTEGER_LENGTH =
1869     PACKAGE_CL.addExternalSymbol("INTEGER-LENGTH");
1870   public static final Symbol INTEGERP =
1871     PACKAGE_CL.addExternalSymbol("INTEGERP");
1872   public static final Symbol INTERACTIVE_STREAM_P =
1873     PACKAGE_CL.addExternalSymbol("INTERACTIVE-STREAM-P");
1874   public static final Symbol INTERN =
1875     PACKAGE_CL.addExternalSymbol("INTERN");
1876   public static final Symbol INTERNAL_TIME_UNITS_PER_SECOND =
1877     PACKAGE_CL.addExternalSymbol("INTERNAL-TIME-UNITS-PER-SECOND");
1878   public static final Symbol INTERSECTION =
1879     PACKAGE_CL.addExternalSymbol("INTERSECTION");
1880   public static final Symbol INVALID_METHOD_ERROR =
1881     PACKAGE_CL.addExternalSymbol("INVALID-METHOD-ERROR");
1882   public static final Symbol INVOKE_DEBUGGER =
1883     PACKAGE_CL.addExternalSymbol("INVOKE-DEBUGGER");
1884   public static final Symbol INVOKE_RESTART =
1885     PACKAGE_CL.addExternalSymbol("INVOKE-RESTART");
1886   public static final Symbol INVOKE_RESTART_INTERACTIVELY =
1887     PACKAGE_CL.addExternalSymbol("INVOKE-RESTART-INTERACTIVELY");
1888   public static final Symbol ISQRT =
1889     PACKAGE_CL.addExternalSymbol("ISQRT");
1890   public static final Symbol KEYWORD =
1891     PACKAGE_CL.addExternalSymbol("KEYWORD");
1892   public static final Symbol KEYWORDP =
1893     PACKAGE_CL.addExternalSymbol("KEYWORDP");
1894   public static final Symbol LABELS =
1895     PACKAGE_CL.addExternalSymbol("LABELS");
1896   public static final Symbol LAMBDA =
1897     PACKAGE_CL.addExternalSymbol("LAMBDA");
1898   public static final Symbol LAMBDA_LIST_KEYWORDS =
1899     PACKAGE_CL.addExternalSymbol("LAMBDA-LIST-KEYWORDS");
1900   public static final Symbol LAMBDA_PARAMETERS_LIMIT =
1901     PACKAGE_CL.addExternalSymbol("LAMBDA-PARAMETERS-LIMIT");
1902   public static final Symbol LAST =
1903     PACKAGE_CL.addExternalSymbol("LAST");
1904   public static final Symbol LCM =
1905     PACKAGE_CL.addExternalSymbol("LCM");
1906   public static final Symbol LDB =
1907     PACKAGE_CL.addExternalSymbol("LDB");
1908   public static final Symbol LDB_TEST =
1909     PACKAGE_CL.addExternalSymbol("LDB-TEST");
1910   public static final Symbol LDIFF =
1911     PACKAGE_CL.addExternalSymbol("LDIFF");
1912   public static final Symbol LEAST_NEGATIVE_DOUBLE_FLOAT =
1913     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-DOUBLE-FLOAT");
1914   public static final Symbol LEAST_NEGATIVE_LONG_FLOAT =
1915     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-LONG-FLOAT");
1916   public static final Symbol LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT =
1917     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT");
1918   public static final Symbol LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT =
1919     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT");
1920   public static final Symbol LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT =
1921     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT");
1922   public static final Symbol LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT =
1923     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT");
1924   public static final Symbol LEAST_NEGATIVE_SHORT_FLOAT =
1925     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-SHORT-FLOAT");
1926   public static final Symbol LEAST_NEGATIVE_SINGLE_FLOAT =
1927     PACKAGE_CL.addExternalSymbol("LEAST-NEGATIVE-SINGLE-FLOAT");
1928   public static final Symbol LEAST_POSITIVE_DOUBLE_FLOAT =
1929     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-DOUBLE-FLOAT");
1930   public static final Symbol LEAST_POSITIVE_LONG_FLOAT =
1931     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-LONG-FLOAT");
1932   public static final Symbol LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT =
1933     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT");
1934   public static final Symbol LEAST_POSITIVE_NORMALIZED_LONG_FLOAT =
1935     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-LONG-FLOAT");
1936   public static final Symbol LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT =
1937     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT");
1938   public static final Symbol LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT =
1939     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT");
1940   public static final Symbol LEAST_POSITIVE_SHORT_FLOAT =
1941     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-SHORT-FLOAT");
1942   public static final Symbol LEAST_POSITIVE_SINGLE_FLOAT =
1943     PACKAGE_CL.addExternalSymbol("LEAST-POSITIVE-SINGLE-FLOAT");
1944   public static final Symbol LENGTH =
1945     PACKAGE_CL.addExternalSymbol("LENGTH");
1946   public static final Symbol LET =
1947     PACKAGE_CL.addExternalSymbol("LET");
1948   public static final Symbol LET_STAR =
1949     PACKAGE_CL.addExternalSymbol("LET*");
1950   public static final Symbol LISP_IMPLEMENTATION_TYPE =
1951     PACKAGE_CL.addExternalSymbol("LISP-IMPLEMENTATION-TYPE");
1952   public static final Symbol LISP_IMPLEMENTATION_VERSION =
1953     PACKAGE_CL.addExternalSymbol("LISP-IMPLEMENTATION-VERSION");
1954   public static final Symbol LIST =
1955     PACKAGE_CL.addExternalSymbol("LIST");
1956   public static final Symbol LIST_STAR =
1957     PACKAGE_CL.addExternalSymbol("LIST*");
1958   public static final Symbol LIST_ALL_PACKAGES =
1959     PACKAGE_CL.addExternalSymbol("LIST-ALL-PACKAGES");
1960   public static final Symbol LIST_LENGTH =
1961     PACKAGE_CL.addExternalSymbol("LIST-LENGTH");
1962   public static final Symbol LISTEN =
1963     PACKAGE_CL.addExternalSymbol("LISTEN");
1964   public static final Symbol LISTP =
1965     PACKAGE_CL.addExternalSymbol("LISTP");
1966   public static final Symbol LOAD =
1967     PACKAGE_CL.addExternalSymbol("LOAD");
1968   public static final Symbol LOAD_LOGICAL_PATHNAME_TRANSLATIONS =
1969     PACKAGE_CL.addExternalSymbol("LOAD-LOGICAL-PATHNAME-TRANSLATIONS");
1970   public static final Symbol LOAD_TIME_VALUE =
1971     PACKAGE_CL.addExternalSymbol("LOAD-TIME-VALUE");
1972   public static final Symbol LOCALLY =
1973     PACKAGE_CL.addExternalSymbol("LOCALLY");
1974   public static final Symbol LOG =
1975     PACKAGE_CL.addExternalSymbol("LOG");
1976   public static final Symbol LOGAND =
1977     PACKAGE_CL.addExternalSymbol("LOGAND");
1978   public static final Symbol LOGANDC1 =
1979     PACKAGE_CL.addExternalSymbol("LOGANDC1");
1980   public static final Symbol LOGANDC2 =
1981     PACKAGE_CL.addExternalSymbol("LOGANDC2");
1982   public static final Symbol LOGBITP =
1983     PACKAGE_CL.addExternalSymbol("LOGBITP");
1984   public static final Symbol LOGCOUNT =
1985     PACKAGE_CL.addExternalSymbol("LOGCOUNT");
1986   public static final Symbol LOGEQV =
1987     PACKAGE_CL.addExternalSymbol("LOGEQV");
1988   public static final Symbol LOGICAL_PATHNAME =
1989     PACKAGE_CL.addExternalSymbol("LOGICAL-PATHNAME");
1990   public static final Symbol LOGICAL_PATHNAME_TRANSLATIONS =
1991     PACKAGE_CL.addExternalSymbol("LOGICAL-PATHNAME-TRANSLATIONS");
1992   public static final Symbol LOGIOR =
1993     PACKAGE_CL.addExternalSymbol("LOGIOR");
1994   public static final Symbol LOGNAND =
1995     PACKAGE_CL.addExternalSymbol("LOGNAND");
1996   public static final Symbol LOGNOR =
1997     PACKAGE_CL.addExternalSymbol("LOGNOR");
1998   public static final Symbol LOGNOT =
1999     PACKAGE_CL.addExternalSymbol("LOGNOT");
2000   public static final Symbol LOGORC1 =
2001     PACKAGE_CL.addExternalSymbol("LOGORC1");
2002   public static final Symbol LOGORC2 =
2003     PACKAGE_CL.addExternalSymbol("LOGORC2");
2004   public static final Symbol LOGTEST =
2005     PACKAGE_CL.addExternalSymbol("LOGTEST");
2006   public static final Symbol LOGXOR =
2007     PACKAGE_CL.addExternalSymbol("LOGXOR");
2008   public static final Symbol LONG_FLOAT =
2009     PACKAGE_CL.addExternalSymbol("LONG-FLOAT");
2010   public static final Symbol LONG_FLOAT_EPSILON =
2011     PACKAGE_CL.addExternalSymbol("LONG-FLOAT-EPSILON");
2012   public static final Symbol LONG_FLOAT_NEGATIVE_EPSILON =
2013     PACKAGE_CL.addExternalSymbol("LONG-FLOAT-NEGATIVE-EPSILON");
2014   public static final Symbol LONG_SITE_NAME =
2015     PACKAGE_CL.addExternalSymbol("LONG-SITE-NAME");
2016   public static final Symbol LOOP =
2017     PACKAGE_CL.addExternalSymbol("LOOP");
2018   public static final Symbol LOOP_FINISH =
2019     PACKAGE_CL.addExternalSymbol("LOOP-FINISH");
2020   public static final Symbol LOWER_CASE_P =
2021     PACKAGE_CL.addExternalSymbol("LOWER-CASE-P");
2022   public static final Symbol MACHINE_INSTANCE =
2023     PACKAGE_CL.addExternalSymbol("MACHINE-INSTANCE");
2024   public static final Symbol MACHINE_TYPE =
2025     PACKAGE_CL.addExternalSymbol("MACHINE-TYPE");
2026   public static final Symbol MACHINE_VERSION =
2027     PACKAGE_CL.addExternalSymbol("MACHINE-VERSION");
2028   public static final Symbol MACRO_FUNCTION =
2029     PACKAGE_CL.addExternalSymbol("MACRO-FUNCTION");
2030   public static final Symbol MACROEXPAND =
2031     PACKAGE_CL.addExternalSymbol("MACROEXPAND");
2032   public static final Symbol MACROEXPAND_1 =
2033     PACKAGE_CL.addExternalSymbol("MACROEXPAND-1");
2034   public static final Symbol MACROLET =
2035     PACKAGE_CL.addExternalSymbol("MACROLET");
2036   public static final Symbol MAKE_ARRAY =
2037     PACKAGE_CL.addExternalSymbol("MAKE-ARRAY");
2038   public static final Symbol MAKE_BROADCAST_STREAM =
2039     PACKAGE_CL.addExternalSymbol("MAKE-BROADCAST-STREAM");
2040   public static final Symbol MAKE_CONCATENATED_STREAM =
2041     PACKAGE_CL.addExternalSymbol("MAKE-CONCATENATED-STREAM");
2042   public static final Symbol MAKE_CONDITION =
2043     PACKAGE_CL.addExternalSymbol("MAKE-CONDITION");
2044   public static final Symbol MAKE_DISPATCH_MACRO_CHARACTER =
2045     PACKAGE_CL.addExternalSymbol("MAKE-DISPATCH-MACRO-CHARACTER");
2046   public static final Symbol MAKE_ECHO_STREAM =
2047     PACKAGE_CL.addExternalSymbol("MAKE-ECHO-STREAM");
2048   public static final Symbol MAKE_HASH_TABLE =
2049     PACKAGE_CL.addExternalSymbol("MAKE-HASH-TABLE");
2050   public static final Symbol MAKE_INSTANCE =
2051     PACKAGE_CL.addExternalSymbol("MAKE-INSTANCE");
2052   public static final Symbol MAKE_INSTANCES_OBSOLETE =
2053     PACKAGE_CL.addExternalSymbol("MAKE-INSTANCES-OBSOLETE");
2054   public static final Symbol MAKE_LIST =
2055     PACKAGE_CL.addExternalSymbol("MAKE-LIST");
2056   public static final Symbol MAKE_LOAD_FORM =
2057     PACKAGE_CL.addExternalSymbol("MAKE-LOAD-FORM");
2058   public static final Symbol MAKE_LOAD_FORM_SAVING_SLOTS =
2059     PACKAGE_CL.addExternalSymbol("MAKE-LOAD-FORM-SAVING-SLOTS");
2060   public static final Symbol MAKE_METHOD =
2061     PACKAGE_CL.addExternalSymbol("MAKE-METHOD");
2062   public static final Symbol MAKE_PACKAGE =
2063     PACKAGE_CL.addExternalSymbol("MAKE-PACKAGE");
2064   public static final Symbol MAKE_PATHNAME =
2065     PACKAGE_CL.addExternalSymbol("MAKE-PATHNAME");
2066   public static final Symbol MAKE_RANDOM_STATE =
2067     PACKAGE_CL.addExternalSymbol("MAKE-RANDOM-STATE");
2068   public static final Symbol MAKE_SEQUENCE =
2069     PACKAGE_CL.addExternalSymbol("MAKE-SEQUENCE");
2070   public static final Symbol MAKE_STRING =
2071     PACKAGE_CL.addExternalSymbol("MAKE-STRING");
2072   public static final Symbol MAKE_STRING_INPUT_STREAM =
2073     PACKAGE_CL.addExternalSymbol("MAKE-STRING-INPUT-STREAM");
2074   public static final Symbol MAKE_STRING_OUTPUT_STREAM =
2075     PACKAGE_CL.addExternalSymbol("MAKE-STRING-OUTPUT-STREAM");
2076   public static final Symbol MAKE_SYMBOL =
2077     PACKAGE_CL.addExternalSymbol("MAKE-SYMBOL");
2078   public static final Symbol MAKE_SYNONYM_STREAM =
2079     PACKAGE_CL.addExternalSymbol("MAKE-SYNONYM-STREAM");
2080   public static final Symbol MAKE_TWO_WAY_STREAM =
2081     PACKAGE_CL.addExternalSymbol("MAKE-TWO-WAY-STREAM");
2082   public static final Symbol MAKUNBOUND =
2083     PACKAGE_CL.addExternalSymbol("MAKUNBOUND");
2084   public static final Symbol MAP =
2085     PACKAGE_CL.addExternalSymbol("MAP");
2086   public static final Symbol MAP_INTO =
2087     PACKAGE_CL.addExternalSymbol("MAP-INTO");
2088   public static final Symbol MAPC =
2089     PACKAGE_CL.addExternalSymbol("MAPC");
2090   public static final Symbol MAPCAN =
2091     PACKAGE_CL.addExternalSymbol("MAPCAN");
2092   public static final Symbol MAPCAR =
2093     PACKAGE_CL.addExternalSymbol("MAPCAR");
2094   public static final Symbol MAPCON =
2095     PACKAGE_CL.addExternalSymbol("MAPCON");
2096   public static final Symbol MAPHASH =
2097     PACKAGE_CL.addExternalSymbol("MAPHASH");
2098   public static final Symbol MAPL =
2099     PACKAGE_CL.addExternalSymbol("MAPL");
2100   public static final Symbol MAPLIST =
2101     PACKAGE_CL.addExternalSymbol("MAPLIST");
2102   public static final Symbol MASK_FIELD =
2103     PACKAGE_CL.addExternalSymbol("MASK-FIELD");
2104   public static final Symbol MAX =
2105     PACKAGE_CL.addExternalSymbol("MAX");
2106   public static final Symbol MEMBER =
2107     PACKAGE_CL.addExternalSymbol("MEMBER");
2108   public static final Symbol MEMBER_IF =
2109     PACKAGE_CL.addExternalSymbol("MEMBER-IF");
2110   public static final Symbol MEMBER_IF_NOT =
2111     PACKAGE_CL.addExternalSymbol("MEMBER-IF-NOT");
2112   public static final Symbol MERGE =
2113     PACKAGE_CL.addExternalSymbol("MERGE");
2114   public static final Symbol MERGE_PATHNAMES =
2115     PACKAGE_CL.addExternalSymbol("MERGE-PATHNAMES");
2116   public static final Symbol METHOD =
2117     PACKAGE_CL.addExternalSymbol("METHOD");
2118   public static final Symbol METHOD_COMBINATION =
2119     PACKAGE_CL.addExternalSymbol("METHOD-COMBINATION");
2120   public static final Symbol METHOD_COMBINATION_ERROR =
2121     PACKAGE_CL.addExternalSymbol("METHOD-COMBINATION-ERROR");
2122   public static final Symbol METHOD_QUALIFIERS =
2123     PACKAGE_CL.addExternalSymbol("METHOD-QUALIFIERS");
2124   public static final Symbol MIN =
2125     PACKAGE_CL.addExternalSymbol("MIN");
2126   public static final Symbol MINUSP =
2127     PACKAGE_CL.addExternalSymbol("MINUSP");
2128   public static final Symbol MISMATCH =
2129     PACKAGE_CL.addExternalSymbol("MISMATCH");
2130   public static final Symbol MOD =
2131     PACKAGE_CL.addExternalSymbol("MOD");
2132   public static final Symbol MOST_NEGATIVE_DOUBLE_FLOAT =
2133     PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-DOUBLE-FLOAT");
2134   public static final Symbol MOST_NEGATIVE_FIXNUM =
2135     PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-FIXNUM");
2136   public static final Symbol MOST_NEGATIVE_LONG_FLOAT =
2137     PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-LONG-FLOAT");
2138   public static final Symbol MOST_NEGATIVE_SHORT_FLOAT =
2139     PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-SHORT-FLOAT");
2140   public static final Symbol MOST_NEGATIVE_SINGLE_FLOAT =
2141     PACKAGE_CL.addExternalSymbol("MOST-NEGATIVE-SINGLE-FLOAT");
2142   public static final Symbol MOST_POSITIVE_DOUBLE_FLOAT =
2143     PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-DOUBLE-FLOAT");
2144   public static final Symbol MOST_POSITIVE_FIXNUM =
2145     PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-FIXNUM");
2146   public static final Symbol MOST_POSITIVE_LONG_FLOAT =
2147     PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-LONG-FLOAT");
2148   public static final Symbol MOST_POSITIVE_SHORT_FLOAT =
2149     PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-SHORT-FLOAT");
2150   public static final Symbol MOST_POSITIVE_SINGLE_FLOAT =
2151     PACKAGE_CL.addExternalSymbol("MOST-POSITIVE-SINGLE-FLOAT");
2152   public static final Symbol MUFFLE_WARNING =
2153     PACKAGE_CL.addExternalSymbol("MUFFLE-WARNING");
2154   public static final Symbol MULTIPLE_VALUE_BIND =
2155     PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-BIND");
2156   public static final Symbol MULTIPLE_VALUE_CALL =
2157     PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-CALL");
2158   public static final Symbol MULTIPLE_VALUE_LIST =
2159     PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-LIST");
2160   public static final Symbol MULTIPLE_VALUE_PROG1 =
2161     PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-PROG1");
2162   public static final Symbol MULTIPLE_VALUE_SETQ =
2163     PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUE-SETQ");
2164   public static final Symbol MULTIPLE_VALUES_LIMIT =
2165     PACKAGE_CL.addExternalSymbol("MULTIPLE-VALUES-LIMIT");
2166   public static final Symbol NAME_CHAR =
2167     PACKAGE_CL.addExternalSymbol("NAME-CHAR");
2168   public static final Symbol NAMESTRING =
2169     PACKAGE_CL.addExternalSymbol("NAMESTRING");
2170   public static final Symbol NBUTLAST =
2171     PACKAGE_CL.addExternalSymbol("NBUTLAST");
2172   public static final Symbol NCONC =
2173     PACKAGE_CL.addExternalSymbol("NCONC");
2174   public static final Symbol NEXT_METHOD_P =
2175     PACKAGE_CL.addExternalSymbol("NEXT-METHOD-P");
2176   // NIL is a special case.
2177   //     public static final Symbol NIL =
2178   //         PACKAGE_CL.addExternalSymbol("NIL");
2179   public static final Symbol NINTERSECTION =
2180     PACKAGE_CL.addExternalSymbol("NINTERSECTION");
2181   public static final Symbol NINTH =
2182     PACKAGE_CL.addExternalSymbol("NINTH");
2183   public static final Symbol NO_APPLICABLE_METHOD =
2184     PACKAGE_CL.addExternalSymbol("NO-APPLICABLE-METHOD");
2185   public static final Symbol NO_NEXT_METHOD =
2186     PACKAGE_CL.addExternalSymbol("NO-NEXT-METHOD");
2187   public static final Symbol NOT =
2188     PACKAGE_CL.addExternalSymbol("NOT");
2189   public static final Symbol NOTANY =
2190     PACKAGE_CL.addExternalSymbol("NOTANY");
2191   public static final Symbol NOTEVERY =
2192     PACKAGE_CL.addExternalSymbol("NOTEVERY");
2193   public static final Symbol NOTINLINE =
2194     PACKAGE_CL.addExternalSymbol("NOTINLINE");
2195   public static final Symbol NRECONC =
2196     PACKAGE_CL.addExternalSymbol("NRECONC");
2197   public static final Symbol NREVERSE =
2198     PACKAGE_CL.addExternalSymbol("NREVERSE");
2199   public static final Symbol NSET_DIFFERENCE =
2200     PACKAGE_CL.addExternalSymbol("NSET-DIFFERENCE");
2201   public static final Symbol NSET_EXCLUSIVE_OR =
2202     PACKAGE_CL.addExternalSymbol("NSET-EXCLUSIVE-OR");
2203   public static final Symbol NSTRING_CAPITALIZE =
2204     PACKAGE_CL.addExternalSymbol("NSTRING-CAPITALIZE");
2205   public static final Symbol NSTRING_DOWNCASE =
2206     PACKAGE_CL.addExternalSymbol("NSTRING-DOWNCASE");
2207   public static final Symbol NSTRING_UPCASE =
2208     PACKAGE_CL.addExternalSymbol("NSTRING-UPCASE");
2209   public static final Symbol NSUBLIS =
2210     PACKAGE_CL.addExternalSymbol("NSUBLIS");
2211   public static final Symbol NSUBST =
2212     PACKAGE_CL.addExternalSymbol("NSUBST");
2213   public static final Symbol NSUBST_IF =
2214     PACKAGE_CL.addExternalSymbol("NSUBST-IF");
2215   public static final Symbol NSUBST_IF_NOT =
2216     PACKAGE_CL.addExternalSymbol("NSUBST-IF-NOT");
2217   public static final Symbol NSUBSTITUTE =
2218     PACKAGE_CL.addExternalSymbol("NSUBSTITUTE");
2219   public static final Symbol NSUBSTITUTE_IF =
2220     PACKAGE_CL.addExternalSymbol("NSUBSTITUTE-IF");
2221   public static final Symbol NSUBSTITUTE_IF_NOT =
2222     PACKAGE_CL.addExternalSymbol("NSUBSTITUTE-IF-NOT");
2223   public static final Symbol NTH =
2224     PACKAGE_CL.addExternalSymbol("NTH");
2225   public static final Symbol NTH_VALUE =
2226     PACKAGE_CL.addExternalSymbol("NTH-VALUE");
2227   public static final Symbol NTHCDR =
2228     PACKAGE_CL.addExternalSymbol("NTHCDR");
2229   public static final Symbol NULL =
2230     PACKAGE_CL.addExternalSymbol("NULL");
2231   public static final Symbol NUMBER =
2232     PACKAGE_CL.addExternalSymbol("NUMBER");
2233   public static final Symbol NUMBERP =
2234     PACKAGE_CL.addExternalSymbol("NUMBERP");
2235   public static final Symbol NUMERATOR =
2236     PACKAGE_CL.addExternalSymbol("NUMERATOR");
2237   public static final Symbol NUNION =
2238     PACKAGE_CL.addExternalSymbol("NUNION");
2239   public static final Symbol ODDP =
2240     PACKAGE_CL.addExternalSymbol("ODDP");
2241   public static final Symbol OPEN =
2242     PACKAGE_CL.addExternalSymbol("OPEN");
2243   public static final Symbol OPEN_STREAM_P =
2244     PACKAGE_CL.addExternalSymbol("OPEN-STREAM-P");
2245   public static final Symbol OPTIMIZE =
2246     PACKAGE_CL.addExternalSymbol("OPTIMIZE");
2247   public static final Symbol OR =
2248     PACKAGE_CL.addExternalSymbol("OR");
2249   public static final Symbol OTHERWISE =
2250     PACKAGE_CL.addExternalSymbol("OTHERWISE");
2251   public static final Symbol OUTPUT_STREAM_P =
2252     PACKAGE_CL.addExternalSymbol("OUTPUT-STREAM-P");
2253   public static final Symbol PACKAGE =
2254     PACKAGE_CL.addExternalSymbol("PACKAGE");
2255   public static final Symbol PACKAGE_ERROR =
2256     PACKAGE_CL.addExternalSymbol("PACKAGE-ERROR");
2257   public static final Symbol PACKAGE_ERROR_PACKAGE =
2258     PACKAGE_CL.addExternalSymbol("PACKAGE-ERROR-PACKAGE");
2259   public static final Symbol PACKAGE_NAME =
2260     PACKAGE_CL.addExternalSymbol("PACKAGE-NAME");
2261   public static final Symbol PACKAGE_NICKNAMES =
2262     PACKAGE_CL.addExternalSymbol("PACKAGE-NICKNAMES");
2263   public static final Symbol PACKAGE_SHADOWING_SYMBOLS =
2264     PACKAGE_CL.addExternalSymbol("PACKAGE-SHADOWING-SYMBOLS");
2265   public static final Symbol PACKAGE_USE_LIST =
2266     PACKAGE_CL.addExternalSymbol("PACKAGE-USE-LIST");
2267   public static final Symbol PACKAGE_USED_BY_LIST =
2268     PACKAGE_CL.addExternalSymbol("PACKAGE-USED-BY-LIST");
2269   public static final Symbol PACKAGEP =
2270     PACKAGE_CL.addExternalSymbol("PACKAGEP");
2271   public static final Symbol PAIRLIS =
2272     PACKAGE_CL.addExternalSymbol("PAIRLIS");
2273   public static final Symbol PARSE_ERROR =
2274     PACKAGE_CL.addExternalSymbol("PARSE-ERROR");
2275   public static final Symbol PARSE_INTEGER =
2276     PACKAGE_CL.addExternalSymbol("PARSE-INTEGER");
2277   public static final Symbol PARSE_NAMESTRING =
2278     PACKAGE_CL.addExternalSymbol("PARSE-NAMESTRING");
2279   public static final Symbol PATHNAME =
2280     PACKAGE_CL.addExternalSymbol("PATHNAME");
2281   public static final Symbol PATHNAME_DEVICE =
2282     PACKAGE_CL.addExternalSymbol("PATHNAME-DEVICE");
2283   public static final Symbol PATHNAME_DIRECTORY =
2284     PACKAGE_CL.addExternalSymbol("PATHNAME-DIRECTORY");
2285   public static final Symbol PATHNAME_HOST =
2286     PACKAGE_CL.addExternalSymbol("PATHNAME-HOST");
2287   public static final Symbol PATHNAME_MATCH_P =
2288     PACKAGE_CL.addExternalSymbol("PATHNAME-MATCH-P");
2289   public static final Symbol PATHNAME_NAME =
2290     PACKAGE_CL.addExternalSymbol("PATHNAME-NAME");
2291   public static final Symbol PATHNAME_TYPE =
2292     PACKAGE_CL.addExternalSymbol("PATHNAME-TYPE");
2293   public static final Symbol PATHNAME_VERSION =
2294     PACKAGE_CL.addExternalSymbol("PATHNAME-VERSION");
2295   public static final Symbol PATHNAMEP =
2296     PACKAGE_CL.addExternalSymbol("PATHNAMEP");
2297   public static final Symbol PEEK_CHAR =
2298     PACKAGE_CL.addExternalSymbol("PEEK-CHAR");
2299   public static final Symbol PHASE =
2300     PACKAGE_CL.addExternalSymbol("PHASE");
2301   public static final Symbol PI =
2302     PACKAGE_CL.addExternalSymbol("PI");
2303   public static final Symbol PLUSP =
2304     PACKAGE_CL.addExternalSymbol("PLUSP");
2305   public static final Symbol POP =
2306     PACKAGE_CL.addExternalSymbol("POP");
2307   public static final Symbol POSITION =
2308     PACKAGE_CL.addExternalSymbol("POSITION");
2309   public static final Symbol POSITION_IF =
2310     PACKAGE_CL.addExternalSymbol("POSITION-IF");
2311   public static final Symbol POSITION_IF_NOT =
2312     PACKAGE_CL.addExternalSymbol("POSITION-IF-NOT");
2313   public static final Symbol PPRINT =
2314     PACKAGE_CL.addExternalSymbol("PPRINT");
2315   public static final Symbol PPRINT_DISPATCH =
2316     PACKAGE_CL.addExternalSymbol("PPRINT-DISPATCH");
2317   public static final Symbol PPRINT_EXIT_IF_LIST_EXHAUSTED =
2318     PACKAGE_CL.addExternalSymbol("PPRINT-EXIT-IF-LIST-EXHAUSTED");
2319   public static final Symbol PPRINT_FILL =
2320     PACKAGE_CL.addExternalSymbol("PPRINT-FILL");
2321   public static final Symbol PPRINT_INDENT =
2322     PACKAGE_CL.addExternalSymbol("PPRINT-INDENT");
2323   public static final Symbol PPRINT_LINEAR =
2324     PACKAGE_CL.addExternalSymbol("PPRINT-LINEAR");
2325   public static final Symbol PPRINT_LOGICAL_BLOCK =
2326     PACKAGE_CL.addExternalSymbol("PPRINT-LOGICAL-BLOCK");
2327   public static final Symbol PPRINT_NEWLINE =
2328     PACKAGE_CL.addExternalSymbol("PPRINT-NEWLINE");
2329   public static final Symbol PPRINT_POP =
2330     PACKAGE_CL.addExternalSymbol("PPRINT-POP");
2331   public static final Symbol PPRINT_TAB =
2332     PACKAGE_CL.addExternalSymbol("PPRINT-TAB");
2333   public static final Symbol PPRINT_TABULAR =
2334     PACKAGE_CL.addExternalSymbol("PPRINT-TABULAR");
2335   public static final Symbol PRIN1 =
2336     PACKAGE_CL.addExternalSymbol("PRIN1");
2337   public static final Symbol PRIN1_TO_STRING =
2338     PACKAGE_CL.addExternalSymbol("PRIN1-TO-STRING");
2339   public static final Symbol PRINC =
2340     PACKAGE_CL.addExternalSymbol("PRINC");
2341   public static final Symbol PRINC_TO_STRING =
2342     PACKAGE_CL.addExternalSymbol("PRINC-TO-STRING");
2343   public static final Symbol PRINT =
2344     PACKAGE_CL.addExternalSymbol("PRINT");
2345   public static final Symbol PRINT_NOT_READABLE =
2346     PACKAGE_CL.addExternalSymbol("PRINT-NOT-READABLE");
2347   public static final Symbol PRINT_NOT_READABLE_OBJECT =
2348     PACKAGE_CL.addExternalSymbol("PRINT-NOT-READABLE-OBJECT");
2349   public static final Symbol PRINT_OBJECT =
2350     PACKAGE_CL.addExternalSymbol("PRINT-OBJECT");
2351   public static final Symbol PRINT_UNREADABLE_OBJECT =
2352     PACKAGE_CL.addExternalSymbol("PRINT-UNREADABLE-OBJECT");
2353   public static final Symbol PROBE_FILE =
2354     PACKAGE_CL.addExternalSymbol("PROBE-FILE");
2355   public static final Symbol PROCLAIM =
2356     PACKAGE_CL.addExternalSymbol("PROCLAIM");
2357   public static final Symbol PROG =
2358     PACKAGE_CL.addExternalSymbol("PROG");
2359   public static final Symbol PROG_STAR =
2360     PACKAGE_CL.addExternalSymbol("PROG*");
2361   public static final Symbol PROG1 =
2362     PACKAGE_CL.addExternalSymbol("PROG1");
2363   public static final Symbol PROG2 =
2364     PACKAGE_CL.addExternalSymbol("PROG2");
2365   public static final Symbol PROGN =
2366     PACKAGE_CL.addExternalSymbol("PROGN");
2367   public static final Symbol PROGRAM_ERROR =
2368     PACKAGE_CL.addExternalSymbol("PROGRAM-ERROR");
2369   public static final Symbol PROGV =
2370     PACKAGE_CL.addExternalSymbol("PROGV");
2371   public static final Symbol PROVIDE =
2372     PACKAGE_CL.addExternalSymbol("PROVIDE");
2373   public static final Symbol PSETF =
2374     PACKAGE_CL.addExternalSymbol("PSETF");
2375   public static final Symbol PSETQ =
2376     PACKAGE_CL.addExternalSymbol("PSETQ");
2377   public static final Symbol PUSH =
2378     PACKAGE_CL.addExternalSymbol("PUSH");
2379   public static final Symbol PUSHNEW =
2380     PACKAGE_CL.addExternalSymbol("PUSHNEW");
2381   public static final Symbol QUOTE =
2382     PACKAGE_CL.addExternalSymbol("QUOTE");
2383   public static final Symbol RANDOM =
2384     PACKAGE_CL.addExternalSymbol("RANDOM");
2385   public static final Symbol RANDOM_STATE =
2386     PACKAGE_CL.addExternalSymbol("RANDOM-STATE");
2387   public static final Symbol RANDOM_STATE_P =
2388     PACKAGE_CL.addExternalSymbol("RANDOM-STATE-P");
2389   public static final Symbol RASSOC =
2390     PACKAGE_CL.addExternalSymbol("RASSOC");
2391   public static final Symbol RASSOC_IF =
2392     PACKAGE_CL.addExternalSymbol("RASSOC-IF");
2393   public static final Symbol RASSOC_IF_NOT =
2394     PACKAGE_CL.addExternalSymbol("RASSOC-IF-NOT");
2395   public static final Symbol RATIO =
2396     PACKAGE_CL.addExternalSymbol("RATIO");
2397   public static final Symbol RATIONAL =
2398     PACKAGE_CL.addExternalSymbol("RATIONAL");
2399   public static final Symbol RATIONALIZE =
2400     PACKAGE_CL.addExternalSymbol("RATIONALIZE");
2401   public static final Symbol RATIONALP =
2402     PACKAGE_CL.addExternalSymbol("RATIONALP");
2403   public static final Symbol READ =
2404     PACKAGE_CL.addExternalSymbol("READ");
2405   public static final Symbol READ_BYTE =
2406     PACKAGE_CL.addExternalSymbol("READ-BYTE");
2407   public static final Symbol READ_CHAR =
2408     PACKAGE_CL.addExternalSymbol("READ-CHAR");
2409   public static final Symbol READ_CHAR_NO_HANG =
2410     PACKAGE_CL.addExternalSymbol("READ-CHAR-NO-HANG");
2411   public static final Symbol READ_DELIMITED_LIST =
2412     PACKAGE_CL.addExternalSymbol("READ-DELIMITED-LIST");
2413   public static final Symbol READ_FROM_STRING =
2414     PACKAGE_CL.addExternalSymbol("READ-FROM-STRING");
2415   public static final Symbol READ_LINE =
2416     PACKAGE_CL.addExternalSymbol("READ-LINE");
2417   public static final Symbol READ_PRESERVING_WHITESPACE =
2418     PACKAGE_CL.addExternalSymbol("READ-PRESERVING-WHITESPACE");
2419   public static final Symbol READ_SEQUENCE =
2420     PACKAGE_CL.addExternalSymbol("READ-SEQUENCE");
2421   public static final Symbol READER_ERROR =
2422     PACKAGE_CL.addExternalSymbol("READER-ERROR");
2423   public static final Symbol READTABLE =
2424     PACKAGE_CL.addExternalSymbol("READTABLE");
2425   public static final Symbol READTABLE_CASE =
2426     PACKAGE_CL.addExternalSymbol("READTABLE-CASE");
2427   public static final Symbol READTABLEP =
2428     PACKAGE_CL.addExternalSymbol("READTABLEP");
2429   public static final Symbol REAL =
2430     PACKAGE_CL.addExternalSymbol("REAL");
2431   public static final Symbol REALP =
2432     PACKAGE_CL.addExternalSymbol("REALP");
2433   public static final Symbol REALPART =
2434     PACKAGE_CL.addExternalSymbol("REALPART");
2435   public static final Symbol REDUCE =
2436     PACKAGE_CL.addExternalSymbol("REDUCE");
2437   public static final Symbol REINITIALIZE_INSTANCE =
2438     PACKAGE_CL.addExternalSymbol("REINITIALIZE-INSTANCE");
2439   public static final Symbol REM =
2440     PACKAGE_CL.addExternalSymbol("REM");
2441   public static final Symbol REMF =
2442     PACKAGE_CL.addExternalSymbol("REMF");
2443   public static final Symbol REMHASH =
2444     PACKAGE_CL.addExternalSymbol("REMHASH");
2445   public static final Symbol REMOVE =
2446     PACKAGE_CL.addExternalSymbol("REMOVE");
2447   public static final Symbol REMOVE_DUPLICATES =
2448     PACKAGE_CL.addExternalSymbol("REMOVE-DUPLICATES");
2449   public static final Symbol REMOVE_IF =
2450     PACKAGE_CL.addExternalSymbol("REMOVE-IF");
2451   public static final Symbol REMOVE_IF_NOT =
2452     PACKAGE_CL.addExternalSymbol("REMOVE-IF-NOT");
2453   public static final Symbol REMOVE_METHOD =
2454     PACKAGE_CL.addExternalSymbol("REMOVE-METHOD");
2455   public static final Symbol REMPROP =
2456     PACKAGE_CL.addExternalSymbol("REMPROP");
2457   public static final Symbol RENAME_FILE =
2458     PACKAGE_CL.addExternalSymbol("RENAME-FILE");
2459   public static final Symbol RENAME_PACKAGE =
2460     PACKAGE_CL.addExternalSymbol("RENAME-PACKAGE");
2461   public static final Symbol REPLACE =
2462     PACKAGE_CL.addExternalSymbol("REPLACE");
2463   public static final Symbol REQUIRE =
2464     PACKAGE_CL.addExternalSymbol("REQUIRE");
2465   public static final Symbol REST =
2466     PACKAGE_CL.addExternalSymbol("REST");
2467   public static final Symbol RESTART =
2468     PACKAGE_CL.addExternalSymbol("RESTART");
2469   public static final Symbol RESTART_BIND =
2470     PACKAGE_CL.addExternalSymbol("RESTART-BIND");
2471   public static final Symbol RESTART_CASE =
2472     PACKAGE_CL.addExternalSymbol("RESTART-CASE");
2473   public static final Symbol RESTART_NAME =
2474     PACKAGE_CL.addExternalSymbol("RESTART-NAME");
2475   public static final Symbol RETURN =
2476     PACKAGE_CL.addExternalSymbol("RETURN");
2477   public static final Symbol RETURN_FROM =
2478     PACKAGE_CL.addExternalSymbol("RETURN-FROM");
2479   public static final Symbol REVAPPEND =
2480     PACKAGE_CL.addExternalSymbol("REVAPPEND");
2481   public static final Symbol REVERSE =
2482     PACKAGE_CL.addExternalSymbol("REVERSE");
2483   public static final Symbol ROOM =
2484     PACKAGE_CL.addExternalSymbol("ROOM");
2485   public static final Symbol ROTATEF =
2486     PACKAGE_CL.addExternalSymbol("ROTATEF");
2487   public static final Symbol ROUND =
2488     PACKAGE_CL.addExternalSymbol("ROUND");
2489   public static final Symbol ROW_MAJOR_AREF =
2490     PACKAGE_CL.addExternalSymbol("ROW-MAJOR-AREF");
2491   public static final Symbol RPLACA =
2492     PACKAGE_CL.addExternalSymbol("RPLACA");
2493   public static final Symbol RPLACD =
2494     PACKAGE_CL.addExternalSymbol("RPLACD");
2495   public static final Symbol SAFETY =
2496     PACKAGE_CL.addExternalSymbol("SAFETY");
2497   public static final Symbol SATISFIES =
2498     PACKAGE_CL.addExternalSymbol("SATISFIES");
2499   public static final Symbol SBIT =
2500     PACKAGE_CL.addExternalSymbol("SBIT");
2501   public static final Symbol SCALE_FLOAT =
2502     PACKAGE_CL.addExternalSymbol("SCALE-FLOAT");
2503   public static final Symbol SCHAR =
2504     PACKAGE_CL.addExternalSymbol("SCHAR");
2505   public static final Symbol SEARCH =
2506     PACKAGE_CL.addExternalSymbol("SEARCH");
2507   public static final Symbol SECOND =
2508     PACKAGE_CL.addExternalSymbol("SECOND");
2509   public static final Symbol SEQUENCE =
2510     PACKAGE_CL.addExternalSymbol("SEQUENCE");
2511   public static final Symbol SERIOUS_CONDITION =
2512     PACKAGE_CL.addExternalSymbol("SERIOUS-CONDITION");
2513   public static final Symbol SET =
2514     PACKAGE_CL.addExternalSymbol("SET");
2515   public static final Symbol SET_DIFFERENCE =
2516     PACKAGE_CL.addExternalSymbol("SET-DIFFERENCE");
2517   public static final Symbol SET_DISPATCH_MACRO_CHARACTER =
2518     PACKAGE_CL.addExternalSymbol("SET-DISPATCH-MACRO-CHARACTER");
2519   public static final Symbol SET_EXCLUSIVE_OR =
2520     PACKAGE_CL.addExternalSymbol("SET-EXCLUSIVE-OR");
2521   public static final Symbol SET_MACRO_CHARACTER =
2522     PACKAGE_CL.addExternalSymbol("SET-MACRO-CHARACTER");
2523   public static final Symbol SET_PPRINT_DISPATCH =
2524     PACKAGE_CL.addExternalSymbol("SET-PPRINT-DISPATCH");
2525   public static final Symbol SET_SYNTAX_FROM_CHAR =
2526     PACKAGE_CL.addExternalSymbol("SET-SYNTAX-FROM-CHAR");
2527   public static final Symbol SETF =
2528     PACKAGE_CL.addExternalSymbol("SETF");
2529   public static final Symbol SETQ =
2530     PACKAGE_CL.addExternalSymbol("SETQ");
2531   public static final Symbol SEVENTH =
2532     PACKAGE_CL.addExternalSymbol("SEVENTH");
2533   public static final Symbol SHADOW =
2534     PACKAGE_CL.addExternalSymbol("SHADOW");
2535   public static final Symbol SHADOWING_IMPORT =
2536     PACKAGE_CL.addExternalSymbol("SHADOWING-IMPORT");
2537   public static final Symbol SHARED_INITIALIZE =
2538     PACKAGE_CL.addExternalSymbol("SHARED-INITIALIZE");
2539   public static final Symbol SHIFTF =
2540     PACKAGE_CL.addExternalSymbol("SHIFTF");
2541   public static final Symbol SHORT_FLOAT =
2542     PACKAGE_CL.addExternalSymbol("SHORT-FLOAT");
2543   public static final Symbol SHORT_FLOAT_EPSILON =
2544     PACKAGE_CL.addExternalSymbol("SHORT-FLOAT-EPSILON");
2545   public static final Symbol SHORT_FLOAT_NEGATIVE_EPSILON =
2546     PACKAGE_CL.addExternalSymbol("SHORT-FLOAT-NEGATIVE-EPSILON");
2547   public static final Symbol SHORT_SITE_NAME =
2548     PACKAGE_CL.addExternalSymbol("SHORT-SITE-NAME");
2549   public static final Symbol SIGNAL =
2550     PACKAGE_CL.addExternalSymbol("SIGNAL");
2551   public static final Symbol SIGNED_BYTE =
2552     PACKAGE_CL.addExternalSymbol("SIGNED-BYTE");
2553   public static final Symbol SIGNUM =
2554     PACKAGE_CL.addExternalSymbol("SIGNUM");
2555   public static final Symbol SIMPLE_ARRAY =
2556     PACKAGE_CL.addExternalSymbol("SIMPLE-ARRAY");
2557   public static final Symbol SIMPLE_BASE_STRING =
2558     PACKAGE_CL.addExternalSymbol("SIMPLE-BASE-STRING");
2559   public static final Symbol SIMPLE_BIT_VECTOR =
2560     PACKAGE_CL.addExternalSymbol("SIMPLE-BIT-VECTOR");
2561   public static final Symbol SIMPLE_BIT_VECTOR_P =
2562     PACKAGE_CL.addExternalSymbol("SIMPLE-BIT-VECTOR-P");
2563   public static final Symbol SIMPLE_CONDITION =
2564     PACKAGE_CL.addExternalSymbol("SIMPLE-CONDITION");
2565   public static final Symbol SIMPLE_CONDITION_FORMAT_ARGUMENTS =
2566     PACKAGE_CL.addExternalSymbol("SIMPLE-CONDITION-FORMAT-ARGUMENTS");
2567   public static final Symbol SIMPLE_CONDITION_FORMAT_CONTROL =
2568     PACKAGE_CL.addExternalSymbol("SIMPLE-CONDITION-FORMAT-CONTROL");
2569   public static final Symbol SIMPLE_ERROR =
2570     PACKAGE_CL.addExternalSymbol("SIMPLE-ERROR");
2571   public static final Symbol SIMPLE_STRING =
2572     PACKAGE_CL.addExternalSymbol("SIMPLE-STRING");
2573   public static final Symbol SIMPLE_STRING_P =
2574     PACKAGE_CL.addExternalSymbol("SIMPLE-STRING-P");
2575   public static final Symbol SIMPLE_TYPE_ERROR =
2576     PACKAGE_CL.addExternalSymbol("SIMPLE-TYPE-ERROR");
2577   public static final Symbol SIMPLE_VECTOR =
2578     PACKAGE_CL.addExternalSymbol("SIMPLE-VECTOR");
2579   public static final Symbol SIMPLE_VECTOR_P =
2580     PACKAGE_CL.addExternalSymbol("SIMPLE-VECTOR-P");
2581   public static final Symbol SIMPLE_WARNING =
2582     PACKAGE_CL.addExternalSymbol("SIMPLE-WARNING");
2583   public static final Symbol SIN =
2584     PACKAGE_CL.addExternalSymbol("SIN");
2585   public static final Symbol SINGLE_FLOAT =
2586     PACKAGE_CL.addExternalSymbol("SINGLE-FLOAT");
2587   public static final Symbol SINGLE_FLOAT_EPSILON =
2588     PACKAGE_CL.addExternalSymbol("SINGLE-FLOAT-EPSILON");
2589   public static final Symbol SINGLE_FLOAT_NEGATIVE_EPSILON =
2590     PACKAGE_CL.addExternalSymbol("SINGLE-FLOAT-NEGATIVE-EPSILON");
2591   public static final Symbol SINH =
2592     PACKAGE_CL.addExternalSymbol("SINH");
2593   public static final Symbol SIXTH =
2594     PACKAGE_CL.addExternalSymbol("SIXTH");
2595   public static final Symbol SLEEP =
2596     PACKAGE_CL.addExternalSymbol("SLEEP");
2597   public static final Symbol SLOT_BOUNDP =
2598     PACKAGE_CL.addExternalSymbol("SLOT-BOUNDP");
2599   public static final Symbol SLOT_EXISTS_P =
2600     PACKAGE_CL.addExternalSymbol("SLOT-EXISTS-P");
2601   public static final Symbol SLOT_MAKUNBOUND =
2602     PACKAGE_CL.addExternalSymbol("SLOT-MAKUNBOUND");
2603   public static final Symbol SLOT_MISSING =
2604     PACKAGE_CL.addExternalSymbol("SLOT-MISSING");
2605   public static final Symbol SLOT_UNBOUND =
2606     PACKAGE_CL.addExternalSymbol("SLOT-UNBOUND");
2607   public static final Symbol SLOT_VALUE =
2608     PACKAGE_CL.addExternalSymbol("SLOT-VALUE");
2609   public static final Symbol SOFTWARE_TYPE =
2610     PACKAGE_CL.addExternalSymbol("SOFTWARE-TYPE");
2611   public static final Symbol SOFTWARE_VERSION =
2612     PACKAGE_CL.addExternalSymbol("SOFTWARE-VERSION");
2613   public static final Symbol SOME =
2614     PACKAGE_CL.addExternalSymbol("SOME");
2615   public static final Symbol SORT =
2616     PACKAGE_CL.addExternalSymbol("SORT");
2617   public static final Symbol SPACE =
2618     PACKAGE_CL.addExternalSymbol("SPACE");
2619   public static final Symbol SPECIAL =
2620     PACKAGE_CL.addExternalSymbol("SPECIAL");
2621   public static final Symbol SPECIAL_OPERATOR_P =
2622     PACKAGE_CL.addExternalSymbol("SPECIAL-OPERATOR-P");
2623   public static final Symbol SPEED =
2624     PACKAGE_CL.addExternalSymbol("SPEED");
2625   public static final Symbol SQRT =
2626     PACKAGE_CL.addExternalSymbol("SQRT");
2627   public static final Symbol STABLE_SORT =
2628     PACKAGE_CL.addExternalSymbol("STABLE-SORT");
2629   public static final Symbol STANDARD =
2630     PACKAGE_CL.addExternalSymbol("STANDARD");
2631   public static final Symbol STANDARD_CHAR =
2632     PACKAGE_CL.addExternalSymbol("STANDARD-CHAR");
2633   public static final Symbol STANDARD_CHAR_P =
2634     PACKAGE_CL.addExternalSymbol("STANDARD-CHAR-P");
2635   public static final Symbol STANDARD_CLASS =
2636     PACKAGE_CL.addExternalSymbol("STANDARD-CLASS");
2637   public static final Symbol STANDARD_GENERIC_FUNCTION =
2638     PACKAGE_CL.addExternalSymbol("STANDARD-GENERIC-FUNCTION");
2639   public static final Symbol STANDARD_METHOD =
2640     PACKAGE_CL.addExternalSymbol("STANDARD-METHOD");
2641   public static final Symbol STANDARD_OBJECT =
2642     PACKAGE_CL.addExternalSymbol("STANDARD-OBJECT");
2643   public static final Symbol STEP =
2644     PACKAGE_CL.addExternalSymbol("STEP");
2645   public static final Symbol STORAGE_CONDITION =
2646     PACKAGE_CL.addExternalSymbol("STORAGE-CONDITION");
2647   public static final Symbol STORE_VALUE =
2648     PACKAGE_CL.addExternalSymbol("STORE-VALUE");
2649   public static final Symbol STREAM =
2650     PACKAGE_CL.addExternalSymbol("STREAM");
2651   public static final Symbol STREAM_ELEMENT_TYPE =
2652     PACKAGE_CL.addExternalSymbol("STREAM-ELEMENT-TYPE");
2653   public static final Symbol STREAM_ERROR =
2654     PACKAGE_CL.addExternalSymbol("STREAM-ERROR");
2655   public static final Symbol STREAM_ERROR_STREAM =
2656     PACKAGE_CL.addExternalSymbol("STREAM-ERROR-STREAM");
2657   public static final Symbol STREAM_EXTERNAL_FORMAT =
2658     PACKAGE_CL.addExternalSymbol("STREAM-EXTERNAL-FORMAT");
2659   public static final Symbol STREAMP =
2660     PACKAGE_CL.addExternalSymbol("STREAMP");
2661   public static final Symbol STRING =
2662     PACKAGE_CL.addExternalSymbol("STRING");
2663   public static final Symbol STRING_CAPITALIZE =
2664     PACKAGE_CL.addExternalSymbol("STRING-CAPITALIZE");
2665   public static final Symbol STRING_DOWNCASE =
2666     PACKAGE_CL.addExternalSymbol("STRING-DOWNCASE");
2667   public static final Symbol STRING_EQUAL =
2668     PACKAGE_CL.addExternalSymbol("STRING-EQUAL");
2669   public static final Symbol STRING_GREATERP =
2670     PACKAGE_CL.addExternalSymbol("STRING-GREATERP");
2671   public static final Symbol STRING_LEFT_TRIM =
2672     PACKAGE_CL.addExternalSymbol("STRING-LEFT-TRIM");
2673   public static final Symbol STRING_LESSP =
2674     PACKAGE_CL.addExternalSymbol("STRING-LESSP");
2675   public static final Symbol STRING_NOT_EQUAL =
2676     PACKAGE_CL.addExternalSymbol("STRING-NOT-EQUAL");
2677   public static final Symbol STRING_NOT_GREATERP =
2678     PACKAGE_CL.addExternalSymbol("STRING-NOT-GREATERP");
2679   public static final Symbol STRING_NOT_LESSP =
2680     PACKAGE_CL.addExternalSymbol("STRING-NOT-LESSP");
2681   public static final Symbol STRING_RIGHT_TRIM =
2682     PACKAGE_CL.addExternalSymbol("STRING-RIGHT-TRIM");
2683   public static final Symbol STRING_STREAM =
2684     PACKAGE_CL.addExternalSymbol("STRING-STREAM");
2685   public static final Symbol STRING_TRIM =
2686     PACKAGE_CL.addExternalSymbol("STRING-TRIM");
2687   public static final Symbol STRING_UPCASE =
2688     PACKAGE_CL.addExternalSymbol("STRING-UPCASE");
2689   public static final Symbol STRING_NE =
2690     PACKAGE_CL.addExternalSymbol("STRING/=");
2691   public static final Symbol STRING_LT =
2692     PACKAGE_CL.addExternalSymbol("STRING<");
2693   public static final Symbol STRING_LE =
2694     PACKAGE_CL.addExternalSymbol("STRING<=");
2695   public static final Symbol STRING_EQUALS =
2696     PACKAGE_CL.addExternalSymbol("STRING=");
2697   public static final Symbol STRING_GT =
2698     PACKAGE_CL.addExternalSymbol("STRING>");
2699   public static final Symbol STRING_GE =
2700     PACKAGE_CL.addExternalSymbol("STRING>=");
2701   public static final Symbol STRINGP =
2702     PACKAGE_CL.addExternalSymbol("STRINGP");
2703   public static final Symbol STRUCTURE =
2704     PACKAGE_CL.addExternalSymbol("STRUCTURE");
2705   public static final Symbol STRUCTURE_CLASS =
2706     PACKAGE_CL.addExternalSymbol("STRUCTURE-CLASS");
2707   public static final Symbol STRUCTURE_OBJECT =
2708     PACKAGE_CL.addExternalSymbol("STRUCTURE-OBJECT");
2709   public static final Symbol STYLE_WARNING =
2710     PACKAGE_CL.addExternalSymbol("STYLE-WARNING");
2711   public static final Symbol SUBLIS =
2712     PACKAGE_CL.addExternalSymbol("SUBLIS");
2713   public static final Symbol SUBSEQ =
2714     PACKAGE_CL.addExternalSymbol("SUBSEQ");
2715   public static final Symbol SUBSETP =
2716     PACKAGE_CL.addExternalSymbol("SUBSETP");
2717   public static final Symbol SUBST =
2718     PACKAGE_CL.addExternalSymbol("SUBST");
2719   public static final Symbol SUBST_IF =
2720     PACKAGE_CL.addExternalSymbol("SUBST-IF");
2721   public static final Symbol SUBST_IF_NOT =
2722     PACKAGE_CL.addExternalSymbol("SUBST-IF-NOT");
2723   public static final Symbol SUBSTITUTE =
2724     PACKAGE_CL.addExternalSymbol("SUBSTITUTE");
2725   public static final Symbol SUBSTITUTE_IF =
2726     PACKAGE_CL.addExternalSymbol("SUBSTITUTE-IF");
2727   public static final Symbol SUBSTITUTE_IF_NOT =
2728     PACKAGE_CL.addExternalSymbol("SUBSTITUTE-IF-NOT");
2729   public static final Symbol SUBTYPEP =
2730     PACKAGE_CL.addExternalSymbol("SUBTYPEP");
2731   public static final Symbol SVREF =
2732     PACKAGE_CL.addExternalSymbol("SVREF");
2733   public static final Symbol SXHASH =
2734     PACKAGE_CL.addExternalSymbol("SXHASH");
2735   public static final Symbol SYMBOL =
2736     PACKAGE_CL.addExternalSymbol("SYMBOL");
2737   public static final Symbol SYMBOL_FUNCTION =
2738     PACKAGE_CL.addExternalSymbol("SYMBOL-FUNCTION");
2739   public static final Symbol SYMBOL_MACROLET =
2740     PACKAGE_CL.addExternalSymbol("SYMBOL-MACROLET");
2741   public static final Symbol SYMBOL_NAME =
2742     PACKAGE_CL.addExternalSymbol("SYMBOL-NAME");
2743   public static final Symbol SYMBOL_PACKAGE =
2744     PACKAGE_CL.addExternalSymbol("SYMBOL-PACKAGE");
2745   public static final Symbol SYMBOL_PLIST =
2746     PACKAGE_CL.addExternalSymbol("SYMBOL-PLIST");
2747   public static final Symbol SYMBOL_VALUE =
2748     PACKAGE_CL.addExternalSymbol("SYMBOL-VALUE");
2749   public static final Symbol SYMBOLP =
2750     PACKAGE_CL.addExternalSymbol("SYMBOLP");
2751   public static final Symbol SYNONYM_STREAM =
2752     PACKAGE_CL.addExternalSymbol("SYNONYM-STREAM");
2753   public static final Symbol SYNONYM_STREAM_SYMBOL =
2754     PACKAGE_CL.addExternalSymbol("SYNONYM-STREAM-SYMBOL");
2755   public static final Symbol T =
2756     PACKAGE_CL.addExternalSymbol("T");
2757   public static final Symbol TAGBODY =
2758     PACKAGE_CL.addExternalSymbol("TAGBODY");
2759   public static final Symbol TAILP =
2760     PACKAGE_CL.addExternalSymbol("TAILP");
2761   public static final Symbol TAN =
2762     PACKAGE_CL.addExternalSymbol("TAN");
2763   public static final Symbol TANH =
2764     PACKAGE_CL.addExternalSymbol("TANH");
2765   public static final Symbol TENTH =
2766     PACKAGE_CL.addExternalSymbol("TENTH");
2767   public static final Symbol TERPRI =
2768     PACKAGE_CL.addExternalSymbol("TERPRI");
2769   public static final Symbol THE =
2770     PACKAGE_CL.addExternalSymbol("THE");
2771   public static final Symbol THIRD =
2772     PACKAGE_CL.addExternalSymbol("THIRD");
2773   public static final Symbol THROW =
2774     PACKAGE_CL.addExternalSymbol("THROW");
2775   public static final Symbol TIME =
2776     PACKAGE_CL.addExternalSymbol("TIME");
2777   public static final Symbol TRACE =
2778     PACKAGE_CL.addExternalSymbol("TRACE");
2779   public static final Symbol TRANSLATE_LOGICAL_PATHNAME =
2780     PACKAGE_CL.addExternalSymbol("TRANSLATE-LOGICAL-PATHNAME");
2781   public static final Symbol TRANSLATE_PATHNAME =
2782     PACKAGE_CL.addExternalSymbol("TRANSLATE-PATHNAME");
2783   public static final Symbol TREE_EQUAL =
2784     PACKAGE_CL.addExternalSymbol("TREE-EQUAL");
2785   public static final Symbol TRUENAME =
2786     PACKAGE_CL.addExternalSymbol("TRUENAME");
2787   public static final Symbol TRUNCATE =
2788     PACKAGE_CL.addExternalSymbol("TRUNCATE");
2789   public static final Symbol TWO_WAY_STREAM =
2790     PACKAGE_CL.addExternalSymbol("TWO-WAY-STREAM");
2791   public static final Symbol TWO_WAY_STREAM_INPUT_STREAM =
2792     PACKAGE_CL.addExternalSymbol("TWO-WAY-STREAM-INPUT-STREAM");
2793   public static final Symbol TWO_WAY_STREAM_OUTPUT_STREAM =
2794     PACKAGE_CL.addExternalSymbol("TWO-WAY-STREAM-OUTPUT-STREAM");
2795   public static final Symbol TYPE =
2796     PACKAGE_CL.addExternalSymbol("TYPE");
2797   public static final Symbol TYPE_ERROR =
2798     PACKAGE_CL.addExternalSymbol("TYPE-ERROR");
2799   public static final Symbol TYPE_ERROR_DATUM =
2800     PACKAGE_CL.addExternalSymbol("TYPE-ERROR-DATUM");
2801   public static final Symbol TYPE_ERROR_EXPECTED_TYPE =
2802     PACKAGE_CL.addExternalSymbol("TYPE-ERROR-EXPECTED-TYPE");
2803   public static final Symbol TYPE_OF =
2804     PACKAGE_CL.addExternalSymbol("TYPE-OF");
2805   public static final Symbol TYPECASE =
2806     PACKAGE_CL.addExternalSymbol("TYPECASE");
2807   public static final Symbol TYPEP =
2808     PACKAGE_CL.addExternalSymbol("TYPEP");
2809   public static final Symbol UNBOUND_SLOT =
2810     PACKAGE_CL.addExternalSymbol("UNBOUND-SLOT");
2811   public static final Symbol UNBOUND_SLOT_INSTANCE =
2812     PACKAGE_CL.addExternalSymbol("UNBOUND-SLOT-INSTANCE");
2813   public static final Symbol UNBOUND_VARIABLE =
2814     PACKAGE_CL.addExternalSymbol("UNBOUND-VARIABLE");
2815   public static final Symbol UNDEFINED_FUNCTION =
2816     PACKAGE_CL.addExternalSymbol("UNDEFINED-FUNCTION");
2817   public static final Symbol UNEXPORT =
2818     PACKAGE_CL.addExternalSymbol("UNEXPORT");
2819   public static final Symbol UNINTERN =
2820     PACKAGE_CL.addExternalSymbol("UNINTERN");
2821   public static final Symbol UNION =
2822     PACKAGE_CL.addExternalSymbol("UNION");
2823   public static final Symbol UNLESS =
2824     PACKAGE_CL.addExternalSymbol("UNLESS");
2825   public static final Symbol UNREAD_CHAR =
2826     PACKAGE_CL.addExternalSymbol("UNREAD-CHAR");
2827   public static final Symbol UNSIGNED_BYTE =
2828     PACKAGE_CL.addExternalSymbol("UNSIGNED-BYTE");
2829   public static final Symbol UNTRACE =
2830     PACKAGE_CL.addExternalSymbol("UNTRACE");
2831   public static final Symbol UNUSE_PACKAGE =
2832     PACKAGE_CL.addExternalSymbol("UNUSE-PACKAGE");
2833   public static final Symbol UNWIND_PROTECT =
2834     PACKAGE_CL.addExternalSymbol("UNWIND-PROTECT");
2835   public static final Symbol UPDATE_INSTANCE_FOR_DIFFERENT_CLASS =
2836     PACKAGE_CL.addExternalSymbol("UPDATE-INSTANCE-FOR-DIFFERENT-CLASS");
2837   public static final Symbol UPDATE_INSTANCE_FOR_REDEFINED_CLASS =
2838     PACKAGE_CL.addExternalSymbol("UPDATE-INSTANCE-FOR-REDEFINED-CLASS");
2839   public static final Symbol UPGRADED_ARRAY_ELEMENT_TYPE =
2840     PACKAGE_CL.addExternalSymbol("UPGRADED-ARRAY-ELEMENT-TYPE");
2841   public static final Symbol UPGRADED_COMPLEX_PART_TYPE =
2842     PACKAGE_CL.addExternalSymbol("UPGRADED-COMPLEX-PART-TYPE");
2843   public static final Symbol UPPER_CASE_P =
2844     PACKAGE_CL.addExternalSymbol("UPPER-CASE-P");
2845   public static final Symbol USE_PACKAGE =
2846     PACKAGE_CL.addExternalSymbol("USE-PACKAGE");
2847   public static final Symbol USE_VALUE =
2848     PACKAGE_CL.addExternalSymbol("USE-VALUE");
2849   public static final Symbol USER_HOMEDIR_PATHNAME =
2850     PACKAGE_CL.addExternalSymbol("USER-HOMEDIR-PATHNAME");
2851   public static final Symbol VALUES =
2852     PACKAGE_CL.addExternalSymbol("VALUES");
2853   public static final Symbol VALUES_LIST =
2854     PACKAGE_CL.addExternalSymbol("VALUES-LIST");
2855   public static final Symbol VARIABLE =
2856     PACKAGE_CL.addExternalSymbol("VARIABLE");
2857   public static final Symbol VECTOR =
2858     PACKAGE_CL.addExternalSymbol("VECTOR");
2859   public static final Symbol VECTOR_POP =
2860     PACKAGE_CL.addExternalSymbol("VECTOR-POP");
2861   public static final Symbol VECTOR_PUSH =
2862     PACKAGE_CL.addExternalSymbol("VECTOR-PUSH");
2863   public static final Symbol VECTOR_PUSH_EXTEND =
2864     PACKAGE_CL.addExternalSymbol("VECTOR-PUSH-EXTEND");
2865   public static final Symbol VECTORP =
2866     PACKAGE_CL.addExternalSymbol("VECTORP");
2867   public static final Symbol WARN =
2868     PACKAGE_CL.addExternalSymbol("WARN");
2869   public static final Symbol WARNING =
2870     PACKAGE_CL.addExternalSymbol("WARNING");
2871   public static final Symbol WHEN =
2872     PACKAGE_CL.addExternalSymbol("WHEN");
2873   public static final Symbol WILD_PATHNAME_P =
2874     PACKAGE_CL.addExternalSymbol("WILD-PATHNAME-P");
2875   public static final Symbol WITH_ACCESSORS =
2876     PACKAGE_CL.addExternalSymbol("WITH-ACCESSORS");
2877   public static final Symbol WITH_COMPILATION_UNIT =
2878     PACKAGE_CL.addExternalSymbol("WITH-COMPILATION-UNIT");
2879   public static final Symbol WITH_CONDITION_RESTARTS =
2880     PACKAGE_CL.addExternalSymbol("WITH-CONDITION-RESTARTS");
2881   public static final Symbol WITH_HASH_TABLE_ITERATOR =
2882     PACKAGE_CL.addExternalSymbol("WITH-HASH-TABLE-ITERATOR");
2883   public static final Symbol WITH_INPUT_FROM_STRING =
2884     PACKAGE_CL.addExternalSymbol("WITH-INPUT-FROM-STRING");
2885   public static final Symbol WITH_OPEN_FILE =
2886     PACKAGE_CL.addExternalSymbol("WITH-OPEN-FILE");
2887   public static final Symbol WITH_OPEN_STREAM =
2888     PACKAGE_CL.addExternalSymbol("WITH-OPEN-STREAM");
2889   public static final Symbol WITH_OUTPUT_TO_STRING =
2890     PACKAGE_CL.addExternalSymbol("WITH-OUTPUT-TO-STRING");
2891   public static final Symbol WITH_PACKAGE_ITERATOR =
2892     PACKAGE_CL.addExternalSymbol("WITH-PACKAGE-ITERATOR");
2893   public static final Symbol WITH_SIMPLE_RESTART =
2894     PACKAGE_CL.addExternalSymbol("WITH-SIMPLE-RESTART");
2895   public static final Symbol WITH_SLOTS =
2896     PACKAGE_CL.addExternalSymbol("WITH-SLOTS");
2897   public static final Symbol WITH_STANDARD_IO_SYNTAX =
2898     PACKAGE_CL.addExternalSymbol("WITH-STANDARD-IO-SYNTAX");
2899   public static final Symbol WRITE =
2900     PACKAGE_CL.addExternalSymbol("WRITE");
2901   public static final Symbol WRITE_BYTE =
2902     PACKAGE_CL.addExternalSymbol("WRITE-BYTE");
2903   public static final Symbol WRITE_CHAR =
2904     PACKAGE_CL.addExternalSymbol("WRITE-CHAR");
2905   public static final Symbol WRITE_LINE =
2906     PACKAGE_CL.addExternalSymbol("WRITE-LINE");
2907   public static final Symbol WRITE_SEQUENCE =
2908     PACKAGE_CL.addExternalSymbol("WRITE-SEQUENCE");
2909   public static final Symbol WRITE_STRING =
2910     PACKAGE_CL.addExternalSymbol("WRITE-STRING");
2911   public static final Symbol WRITE_TO_STRING =
2912     PACKAGE_CL.addExternalSymbol("WRITE-TO-STRING");
2913   public static final Symbol Y_OR_N_P =
2914     PACKAGE_CL.addExternalSymbol("Y-OR-N-P");
2915   public static final Symbol YES_OR_NO_P =
2916     PACKAGE_CL.addExternalSymbol("YES-OR-NO-P");
2917   public static final Symbol ZEROP =
2918     PACKAGE_CL.addExternalSymbol("ZEROP");
2919   // End of CL symbols.
2920 
2921   // Extensions.
2922   public static final Symbol MOST_POSITIVE_JAVA_LONG =
2923     PACKAGE_EXT.addExternalSymbol("MOST-POSITIVE-JAVA-LONG");
2924   public static final Symbol MOST_NEGATIVE_JAVA_LONG=
2925     PACKAGE_EXT.addExternalSymbol("MOST-NEGATIVE-JAVA-LONG");
2926   public static final Symbol SINGLE_FLOAT_POSITIVE_INFINITY =
2927     PACKAGE_EXT.addExternalSymbol("SINGLE-FLOAT-POSITIVE-INFINITY");
2928   public static final Symbol SINGLE_FLOAT_NEGATIVE_INFINITY =
2929     PACKAGE_EXT.addExternalSymbol("SINGLE-FLOAT-NEGATIVE-INFINITY");
2930   public static final Symbol DOUBLE_FLOAT_POSITIVE_INFINITY =
2931     PACKAGE_EXT.addExternalSymbol("DOUBLE-FLOAT-POSITIVE-INFINITY");
2932   public static final Symbol DOUBLE_FLOAT_NEGATIVE_INFINITY =
2933     PACKAGE_EXT.addExternalSymbol("DOUBLE-FLOAT-NEGATIVE-INFINITY");
2934   public static final Symbol STYLE_WARN =
2935     PACKAGE_EXT.addExternalSymbol("STYLE-WARN");
2936   public static final Symbol MEMQ =
2937     PACKAGE_EXT.addExternalSymbol("MEMQ");
2938   public static final Symbol MEMQL =
2939     PACKAGE_EXT.addExternalSymbol("MEMQL");
2940   public static final Symbol NIL_VECTOR =
2941     PACKAGE_EXT.addExternalSymbol("NIL-VECTOR");
2942   public static final Symbol MAILBOX =
2943     PACKAGE_EXT.addExternalSymbol("MAILBOX");
2944   public static final Symbol MUTEX =
2945     PACKAGE_EXT.addExternalSymbol("MUTEX");
2946   public static final Symbol SUPPRESS_COMPILER_WARNINGS =
2947     PACKAGE_EXT.addExternalSymbol("*SUPPRESS-COMPILER-WARNINGS*");
2948   public static final Symbol NEQ =
2949     PACKAGE_EXT.addExternalSymbol("NEQ");
2950   public static final Symbol ADJOIN_EQL =
2951     PACKAGE_EXT.addExternalSymbol("ADJOIN-EQL");
2952   public static final Symbol CHARACTER_DESIGNATOR =
2953     PACKAGE_EXT.addExternalSymbol("CHARACTER-DESIGNATOR");
2954   public static final Symbol INTERRUPT_LISP =
2955     PACKAGE_EXT.addExternalSymbol("INTERRUPT-LISP");
2956   public static final Symbol GETENV =
2957     PACKAGE_EXT.addExternalSymbol("GETENV");
2958   public static final Symbol MACROEXPAND_ALL =
2959     PACKAGE_EXT.addExternalSymbol("MACROEXPAND-ALL");
2960   public static final Symbol LOAD_TRUENAME_FASL =
2961     PACKAGE_EXT.addExternalSymbol("*LOAD-TRUENAME-FASL*");
2962   public static final Symbol SLIME_INPUT_STREAM =
2963     PACKAGE_EXT.addExternalSymbol("SLIME-INPUT-STREAM");
2964   public static final Symbol SLIME_OUTPUT_STREAM =
2965     PACKAGE_EXT.addExternalSymbol("SLIME-OUTPUT-STREAM");
2966   public static final Symbol JAR_PATHNAME =
2967     PACKAGE_EXT.addExternalSymbol("JAR-PATHNAME");
2968   public static final Symbol URL_PATHNAME =
2969     PACKAGE_EXT.addExternalSymbol("URL-PATHNAME");
2970   public static final Symbol WEAK_REFERENCE =
2971     PACKAGE_EXT.addExternalSymbol("WEAK-REFERENCE");
2972   public static final Symbol ADD_PACKAGE_LOCAL_NICKNAME =
2973     PACKAGE_EXT.addExternalSymbol("ADD-PACKAGE-LOCAL-NICKNAME");
2974 
2975   // MOP.
2976   public static final Symbol CLASS_LAYOUT =
2977     PACKAGE_MOP.addInternalSymbol("CLASS-LAYOUT");
2978   public static final Symbol CLASS_DEFAULT_INITARGS =
2979     PACKAGE_MOP.addExternalSymbol("CLASS-DEFAULT_INITARGS");
2980   public static final Symbol CLASS_DIRECT_METHODS =
2981     PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-METHODS");
2982   public static final Symbol CLASS_DIRECT_DEFAULT_INITARGS =
2983     PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-DEFAULT_INITARGS");
2984   public static final Symbol CLASS_DIRECT_SLOTS =
2985     PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-SLOTS");
2986   public static final Symbol CLASS_DIRECT_SUBCLASSES =
2987     PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-SUBCLASSES");
2988   public static final Symbol CLASS_DIRECT_SUPERCLASSES =
2989     PACKAGE_MOP.addExternalSymbol("CLASS-DIRECT-SUPERCLASSES");
2990   public static final Symbol CLASS_DOCUMENTATION =
2991     PACKAGE_MOP.addExternalSymbol("CLASS-DOCUMENTATION");
2992   public static final Symbol CLASS_FINALIZED_P =
2993     PACKAGE_MOP.addExternalSymbol("CLASS-FINALIZED-P");
2994   public static final Symbol CLASS_PRECEDENCE_LIST =
2995     PACKAGE_MOP.addExternalSymbol("CLASS-PRECEDENCE-LIST");
2996   public static final Symbol CLASS_SLOTS =
2997     PACKAGE_MOP.addExternalSymbol("CLASS-SLOTS");
2998   public static final Symbol EQL_SPECIALIZER =
2999     PACKAGE_MOP.addExternalSymbol("EQL-SPECIALIZER");
3000   public static final Symbol EQL_SPECIALIZER_OBJECT =
3001     PACKAGE_MOP.addExternalSymbol("EQL-SPECIALIZER-OBJECT");
3002   public static final Symbol FUNCALLABLE_STANDARD_OBJECT =
3003     PACKAGE_MOP.addExternalSymbol("FUNCALLABLE-STANDARD-OBJECT");
3004   public static final Symbol FUNCALLABLE_STANDARD_CLASS =
3005     PACKAGE_MOP.addExternalSymbol("FUNCALLABLE-STANDARD-CLASS");
3006   public static final Symbol GENERIC_FUNCTION_METHODS =
3007     PACKAGE_MOP.addExternalSymbol("GENERIC-FUNCTION-METHODS");
3008   public static final Symbol GENERIC_FUNCTION_NAME =
3009     PACKAGE_MOP.addExternalSymbol("GENERIC-FUNCTION-NAME");
3010   public static final Symbol METAOBJECT =
3011     PACKAGE_MOP.addExternalSymbol("METAOBJECT");
3012   public static final Symbol METHOD_FUNCTION =
3013     PACKAGE_MOP.addExternalSymbol("METHOD-FUNCTION");
3014   public static final Symbol SPECIALIZER =
3015     PACKAGE_MOP.addExternalSymbol("SPECIALIZER");
3016   public static final Symbol STANDARD_ACCESSOR_METHOD =
3017     PACKAGE_MOP.addExternalSymbol("STANDARD-ACCESSOR-METHOD");
3018   public static final Symbol STANDARD_READER_METHOD =
3019     PACKAGE_MOP.addExternalSymbol("STANDARD-READER-METHOD");
3020   public static final Symbol STANDARD_WRITER_METHOD =
3021     PACKAGE_MOP.addExternalSymbol("STANDARD-WRITER-METHOD");
3022   public static final Symbol DIRECT_SLOT_DEFINITION =
3023     PACKAGE_MOP.addExternalSymbol("DIRECT-SLOT-DEFINITION");
3024   public static final Symbol EFFECTIVE_SLOT_DEFINITION =
3025     PACKAGE_MOP.addExternalSymbol("EFFECTIVE-SLOT-DEFINITION");
3026   public static final Symbol STANDARD_SLOT_DEFINITION =
3027     PACKAGE_MOP.addExternalSymbol("STANDARD-SLOT-DEFINITION");
3028   public static final Symbol STANDARD_DIRECT_SLOT_DEFINITION =
3029     PACKAGE_MOP.addExternalSymbol("STANDARD-DIRECT-SLOT-DEFINITION");
3030   public static final Symbol STANDARD_EFFECTIVE_SLOT_DEFINITION =
3031     PACKAGE_MOP.addExternalSymbol("STANDARD-EFFECTIVE-SLOT-DEFINITION");
3032   // MOP method combination readers.
3033   public static final Symbol METHOD_COMBINATION_NAME =
3034     PACKAGE_MOP.addInternalSymbol("METHOD-COMBINATION-NAME");
3035   public static final Symbol METHOD_COMBINATION_DOCUMENTATION =
3036     PACKAGE_MOP.addInternalSymbol("METHOD-COMBINATION-DOCUMENTATION");
3037 
3038   // Java interface.
3039   public static final Symbol JAVA_EXCEPTION =
3040     PACKAGE_JAVA.addExternalSymbol("JAVA-EXCEPTION");
3041   public static final Symbol JAVA_EXCEPTION_CAUSE =
3042     PACKAGE_JAVA.addExternalSymbol("JAVA-EXCEPTION-CAUSE");
3043   public static final Symbol JAVA_OBJECT =
3044     PACKAGE_JAVA.addExternalSymbol("JAVA-OBJECT");
3045   public static final Symbol JAVA_CLASS =
3046     PACKAGE_JAVA.addExternalSymbol("JAVA-CLASS");
3047   public static final Symbol JCALL =
3048     PACKAGE_JAVA.addExternalSymbol("JCALL");
3049   public static final Symbol JCALL_RAW =
3050     PACKAGE_JAVA.addExternalSymbol("JCALL-RAW");
3051   public static final Symbol JCLASS =
3052     PACKAGE_JAVA.addExternalSymbol("JCLASS");
3053   public static final Symbol JCLASS_NAME =
3054     PACKAGE_JAVA.addExternalSymbol("JCLASS-NAME");
3055   public static final Symbol JCLASS_OF =
3056     PACKAGE_JAVA.addExternalSymbol("JCLASS-OF");
3057   public static final Symbol JINPUT_STREAM =
3058     PACKAGE_JAVA.addExternalSymbol("JINPUT-STREAM");
3059   public static final Symbol JMETHOD_RETURN_TYPE =
3060     PACKAGE_JAVA.addExternalSymbol("JMETHOD-RETURN-TYPE");
3061   public static final Symbol JRESOLVE_METHOD =
3062     PACKAGE_JAVA.addExternalSymbol("JRESOLVE-METHOD");
3063   public static final Symbol ADD_TO_CLASSPATH =
3064     PACKAGE_JAVA.addExternalSymbol("ADD-TO-CLASSPATH");
3065 
3066   // External symbols in SYSTEM package.
3067   public static final Symbol AUTOCOMPILE =
3068     PACKAGE_SYS.addExternalSymbol("AUTOCOMPILE");
3069   public static final Symbol CLASS_BYTES =
3070     PACKAGE_SYS.addExternalSymbol("CLASS-BYTES");
3071   public static final Symbol _CLASS_SLOTS =
3072     PACKAGE_SYS.addExternalSymbol("%CLASS-SLOTS");
3073   public static final Symbol COMPILED_LISP_FUNCTION_P =
3074     PACKAGE_SYS.addExternalSymbol("COMPILED-LISP-FUNCTION-P");
3075   public static final Symbol DEFAULT_INITARGS =
3076     PACKAGE_SYS.addExternalSymbol("DEFAULT-INITARGS");
3077   public static final Symbol DIRECT_METHODS =
3078     PACKAGE_SYS.addExternalSymbol("DIRECT-METHODS");
3079   public static final Symbol DIRECT_SLOTS =
3080     PACKAGE_SYS.addExternalSymbol("DIRECT-SLOTS");
3081   public static final Symbol DIRECT_SUBCLASSES =
3082     PACKAGE_SYS.addExternalSymbol("DIRECT-SUBCLASSES");
3083   public static final Symbol DIRECT_DEFAULT_INITARGS =
3084     PACKAGE_SYS.addExternalSymbol("DIRECT-DEFAULT-INITARGS");
3085   public static final Symbol DIRECT_SUPERCLASSES =
3086     PACKAGE_SYS.addExternalSymbol("DIRECT-SUPERCLASSES");
3087   public static final Symbol __DISASSEMBLERS__ =
3088     PACKAGE_SYS.addExternalSymbol("*DISASSEMBLERS*");
3089   public static final Symbol CHOOSE_DISASSEMBLER =
3090     PACKAGE_SYS.addExternalSymbol("CHOOSE-DISASSEMBLER");
3091   public static final Symbol _DOCUMENTATION =
3092     PACKAGE_SYS.addExternalSymbol("%DOCUMENTATION");
3093   public static final Symbol _ENABLE_AUTOCOMPILE_ =
3094     PACKAGE_SYS.addExternalSymbol("*ENABLE-AUTOCOMPILE*");
3095   public static final Symbol GET_INPUT_STREAM =
3096     PACKAGE_SYS.addExternalSymbol("GET-INPUT-STREAM");
3097   public static final Symbol ENVIRONMENT =
3098     PACKAGE_SYS.addExternalSymbol("ENVIRONMENT");
3099   public static final Symbol FINALIZED_P =
3100     PACKAGE_SYS.addExternalSymbol("FINALIZED-P");
3101   public static final Symbol FLOAT_UNDERFLOW_MODE =
3102     PACKAGE_SYS.addExternalSymbol("FLOAT-UNDERFLOW-MODE");
3103   public static final Symbol FLOAT_OVERFLOW_MODE =
3104     PACKAGE_SYS.addExternalSymbol("FLOAT-OVERFLOW-MODE");
3105   public static final Symbol GETHASH1 =
3106     PACKAGE_SYS.addExternalSymbol("GETHASH1");
3107   public static final Symbol HASH_TABLE_WEAKNESS =
3108     PACKAGE_SYS.addExternalSymbol("HASH-TABLE-WEAKNESS");
3109   public static final Symbol JAR_STREAM =
3110     PACKAGE_SYS.addExternalSymbol("JAR-STREAM");
3111   public static final Symbol LAYOUT =
3112     PACKAGE_SYS.addExternalSymbol("LAYOUT");
3113   public static final Symbol MATCH_WILD_JAR_PATHNAME =
3114     PACKAGE_SYS.addExternalSymbol("MATCH-WILD-JAR-PATHNAME");
3115   public static final Symbol NAME =
3116     PACKAGE_SYS.addExternalSymbol("NAME");
3117   public static final Symbol NAMED_LAMBDA =
3118     PACKAGE_SYS.addExternalSymbol("NAMED-LAMBDA");
3119   public static final Symbol OUTPUT_OBJECT =
3120     PACKAGE_SYS.addExternalSymbol("OUTPUT-OBJECT");
3121   public static final Symbol PRECEDENCE_LIST =
3122     PACKAGE_SYS.addExternalSymbol("PRECEDENCE-LIST");
3123   public static final Symbol PUTHASH =
3124     PACKAGE_SYS.addExternalSymbol("PUTHASH");
3125   public static final Symbol RECORD_SOURCE_INFORMATION_FOR_TYPE =
3126     PACKAGE_SYS.addExternalSymbol("RECORD-SOURCE-INFORMATION-FOR-TYPE");
3127   public static final Symbol SET_CHAR =
3128     PACKAGE_SYS.addExternalSymbol("SET-CHAR");
3129   public static final Symbol _SET_CLASS_SLOTS =
3130     PACKAGE_SYS.addExternalSymbol("%SET-CLASS-SLOTS");
3131   public static final Symbol SET_SCHAR =
3132     PACKAGE_SYS.addExternalSymbol("SET-SCHAR");
3133   public static final Symbol SET_STD_SLOT_VALUE =
3134     PACKAGE_SYS.addExternalSymbol("SET-STD-SLOT-VALUE");
3135   public static final Symbol SETF_FUNCTION =
3136     PACKAGE_SYS.addExternalSymbol("SETF-FUNCTION");
3137   public static final Symbol SETF_INVERSE =
3138     PACKAGE_SYS.addExternalSymbol("SETF-INVERSE");
3139   public static final Symbol SLOTS = PACKAGE_SYS.addExternalSymbol("SLOTS");
3140   public static final Symbol SLOT_DEFINITION =
3141     PACKAGE_SYS.addExternalSymbol("SLOT-DEFINITION");
3142   public static final Symbol __SOURCE =
3143     PACKAGE_SYS.addInternalSymbol("SOURCE");
3144   public static final Symbol STD_SLOT_BOUNDP =
3145     PACKAGE_SYS.addExternalSymbol("STD-SLOT-BOUNDP");
3146   public static final Symbol STD_SLOT_VALUE =
3147     PACKAGE_SYS.addExternalSymbol("STD-SLOT-VALUE");
3148   public static final Symbol SUBCLASSP =
3149     PACKAGE_SYS.addExternalSymbol("SUBCLASSP");
3150   public static final Symbol SYMBOL_MACRO =
3151     PACKAGE_SYS.addExternalSymbol("SYMBOL-MACRO");
3152   public static final Symbol UNDEFINED_FUNCTION_CALLED =
3153     PACKAGE_SYS.addExternalSymbol("UNDEFINED-FUNCTION-CALLED");
3154   public static final Symbol URL_STREAM =
3155     PACKAGE_SYS.addExternalSymbol("URL-STREAM");
3156 
3157 
3158   // Internal symbols in SYSTEM package.
3159   public static final Symbol ALLOCATION =
3160     PACKAGE_SYS.addInternalSymbol("ALLOCATION");
3161   public static final Symbol ALLOCATION_CLASS =
3162     PACKAGE_SYS.addInternalSymbol("ALLOCATION-CLASS");
3163   public static final Symbol ARGUMENT_PRECEDENCE_ORDER =
3164     PACKAGE_SYS.addInternalSymbol("ARGUMENT-PRECEDENCE-ORDER");
3165   public static final Symbol BACKQUOTE_MACRO =
3166     PACKAGE_SYS.addInternalSymbol("BACKQUOTE-MACRO");
3167   public static final Symbol CASE_FROB_STREAM =
3168     PACKAGE_SYS.addInternalSymbol("CASE-FROB-STREAM");
3169   public static final Symbol CAUSE =
3170     PACKAGE_SYS.addInternalSymbol("CAUSE");
3171   public static final Symbol COMMA_MACRO =
3172     PACKAGE_SYS.addInternalSymbol("COMMA-MACRO");
3173   public static final Symbol DATUM =
3174     PACKAGE_SYS.addInternalSymbol("DATUM");
3175   public static final Symbol DECLARATIONS =
3176     PACKAGE_SYS.addInternalSymbol("DECLARATIONS");
3177   public static final Symbol DEFTYPE_DEFINITION =
3178     PACKAGE_SYS.addInternalSymbol("DEFTYPE-DEFINITION");
3179   public static final Symbol EXPECTED_TYPE =
3180     PACKAGE_SYS.addInternalSymbol("EXPECTED-TYPE");
3181   public static final Symbol FAST_FUNCTION =
3182     PACKAGE_SYS.addInternalSymbol("FAST-FUNCTION");
3183   public static final Symbol FORMAT_ARGUMENTS =
3184     PACKAGE_SYS.addInternalSymbol("FORMAT-ARGUMENTS");
3185   public static final Symbol FORMAT_CONTROL =
3186     PACKAGE_SYS.addInternalSymbol("FORMAT-CONTROL");
3187   public static final Symbol FSET = PACKAGE_SYS.addInternalSymbol("FSET");
3188   public static final Symbol _FUNCTION =
3189     PACKAGE_SYS.addInternalSymbol("%FUNCTION");
3190   public static final Symbol FUNCTION_PRELOAD =
3191     PACKAGE_SYS.addInternalSymbol("FUNCTION-PRELOAD");
3192   public static final Symbol _GENERIC_FUNCTION =
3193     PACKAGE_SYS.addInternalSymbol("%GENERIC-FUNCTION");
3194   public static final Symbol INITARGS =
3195     PACKAGE_SYS.addInternalSymbol("INITARGS");
3196   public static final Symbol INITFORM =
3197     PACKAGE_SYS.addInternalSymbol("INITFORM");
3198   public static final Symbol INITFUNCTION =
3199     PACKAGE_SYS.addInternalSymbol("INITFUNCTION");
3200   public static final Symbol INITIAL_METHODS =
3201     PACKAGE_SYS.addInternalSymbol("INITIAL-METHODS");
3202   public static final Symbol INSTANCE =
3203     PACKAGE_SYS.addInternalSymbol("INSTANCE");
3204   public static final Symbol JAVA_STACK_FRAME =
3205     PACKAGE_SYS.addInternalSymbol("JAVA-STACK-FRAME");
3206   public static final Symbol KEYWORDS =
3207     PACKAGE_SYS.addInternalSymbol("KEYWORDS");
3208   public static final Symbol LAMBDA_LIST =
3209     PACKAGE_SYS.addInternalSymbol("LAMBDA-LIST");
3210   public static final Symbol LISP_STACK_FRAME =
3211     PACKAGE_SYS.addInternalSymbol("LISP-STACK-FRAME");
3212   public static final Symbol LOCATION =
3213     PACKAGE_SYS.addInternalSymbol("LOCATION");
3214   public static final Symbol MACROEXPAND_MACRO =
3215     PACKAGE_SYS.addInternalSymbol("MACROEXPAND-MACRO");
3216   public static final Symbol MAKE_FUNCTION_PRELOADING_CONTEXT =
3217     PACKAGE_SYS.addInternalSymbol("MAKE-FUNCTION-PRELOADING-CONTEXT");
3218   public static final Symbol METHOD_CLASS =
3219     PACKAGE_SYS.addInternalSymbol("METHOD-CLASS");
3220   public static final Symbol _METHOD_COMBINATION =
3221     PACKAGE_SYS.addInternalSymbol("%METHOD-COMBINATION");
3222   public static final Symbol METHODS = PACKAGE_SYS.addInternalSymbol("METHODS");
3223   public static final Symbol OBJECT = PACKAGE_SYS.addInternalSymbol("OBJECT");
3224   public static final Symbol OPERANDS =
3225     PACKAGE_SYS.addInternalSymbol("OPERANDS");
3226   public static final Symbol OPERATION =
3227     PACKAGE_SYS.addInternalSymbol("OPERATION");
3228   public static final Symbol OPTIONAL_ARGS =
3229     PACKAGE_SYS.addInternalSymbol("OPTIONAL-ARGS");
3230   public static final Symbol OTHER_KEYWORDS_P =
3231     PACKAGE_SYS.addInternalSymbol("OTHER-KEYWORDS-P");
3232   public static final Symbol PROXY_PRELOADED_FUNCTION =
3233     PACKAGE_SYS.addInternalSymbol("PROXY-PRELOADED-FUNCTION");
3234   public static final Symbol QUALIFIERS =
3235     PACKAGE_SYS.addInternalSymbol("QUALIFIERS");
3236   public static final Symbol READERS =
3237     PACKAGE_SYS.addInternalSymbol("READERS");
3238   public static final Symbol REQUIRED_ARGS =
3239     PACKAGE_SYS.addInternalSymbol("REQUIRED-ARGS");
3240   // DEPRECATED: to be removed with abcl-1.7
3241   public static final Symbol _SOURCE =
3242     PACKAGE_SYS.addInternalSymbol("%SOURCE");
3243   public static final Symbol SOCKET_STREAM =
3244     PACKAGE_SYS.addInternalSymbol("SOCKET-STREAM");
3245   public static final Symbol SPECIALIZERS =
3246     PACKAGE_SYS.addInternalSymbol("SPECIALIZERS");
3247   public static final Symbol STRING_INPUT_STREAM =
3248     PACKAGE_SYS.addInternalSymbol("STRING-INPUT-STREAM");
3249   public static final Symbol STRING_OUTPUT_STREAM =
3250     PACKAGE_SYS.addInternalSymbol("STRING-OUTPUT-STREAM");
3251   public static final Symbol SYSTEM_STREAM =
3252     PACKAGE_SYS.addInternalSymbol("SYSTEM-STREAM");
3253   public static final Symbol STACK_FRAME =
3254     PACKAGE_SYS.addInternalSymbol("STACK-FRAME");
3255   public static final Symbol _TYPE =
3256     PACKAGE_SYS.addInternalSymbol("%TYPE");
3257   public static final Symbol WRITERS =
3258     PACKAGE_SYS.addInternalSymbol("WRITERS");
3259 
3260   // CDR6
3261   public static final Symbol _INSPECTOR_HOOK_ =
3262     PACKAGE_EXT.addExternalSymbol("*INSPECTOR-HOOK*");
3263 
3264   public static final Symbol COMPILER_LET =
3265     PACKAGE_LISP.addExternalSymbol("COMPILER-LET");
3266 
3267   // THREADS
3268   public static final Symbol THREAD =
3269     PACKAGE_THREADS.addExternalSymbol("THREAD");
3270 
3271   // JVM
3272   public static final Symbol _RESIGNAL_COMPILER_WARINGS_ =
3273     PACKAGE_JVM.addExternalSymbol("*RESIGNAL-COMPILER-WARNINGS*");
3274 }
3275