source: branches/1.1.x/src/org/armedbear/lisp/Symbol.java

Last change on this file was 14207, checked in by rschlatte, 12 years ago

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