source: branches/streams/abcl/src/org/armedbear/lisp/Symbol.java

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

Remove casts to StandardGenericFunction?

Replaced with function invocations / slot access.

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