source: trunk/abcl/src/org/armedbear/lisp/StandardClass.java

Last change on this file was 14501, checked in by rschlatte, 11 years ago

Move generic-function definition into Lisp
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 31.9 KB
Line 
1/*
2 * StandardClass.java
3 *
4 * Copyright (C) 2003-2005 Peter Graves
5 * $Id: StandardClass.java 14501 2013-05-15 08:06:06Z 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 StandardClass extends SlotClass
39{
40  // Slot names for standard-class.  Must agree with
41  // redefine-class-forwarder calls in clos.lisp.
42  public static Symbol symName = Symbol.NAME;
43  public static Symbol symLayout = Symbol.LAYOUT;
44  public static Symbol symDirectSuperclasses = Symbol.DIRECT_SUPERCLASSES;
45  public static Symbol symDirectSubclasses = Symbol.DIRECT_SUBCLASSES;
46  public static Symbol symPrecedenceList = Symbol.PRECEDENCE_LIST;
47  public static Symbol symDirectMethods = Symbol.DIRECT_METHODS;
48  public static Symbol symDirectSlots = Symbol.DIRECT_SLOTS; 
49  public static Symbol symSlots = Symbol.SLOTS;
50  public static Symbol symDirectDefaultInitargs
51    = Symbol.DIRECT_DEFAULT_INITARGS;
52  public static Symbol symDefaultInitargs = Symbol.DEFAULT_INITARGS;
53  public static Symbol symFinalizedP = Symbol.FINALIZED_P;
54
55  // used as init-function for slots in this file.
56  static Function constantlyNil = new Function() {
57    @Override
58    public LispObject execute()
59    {
60      return NIL;
61    }
62  };
63
64
65
66  static Layout layoutStandardClass =
67      new Layout(null,
68                 list(symName,
69                      symLayout,
70                      symDirectSuperclasses,
71                      symDirectSubclasses,
72                      symPrecedenceList,
73                      symDirectMethods,
74                      symDirectSlots,
75                      symSlots,
76                      symDirectDefaultInitargs,
77                      symDefaultInitargs,
78                      symFinalizedP,
79                      Symbol._DOCUMENTATION),
80                 NIL)
81      {
82        @Override
83        public LispClass getLispClass()
84        {
85          return STANDARD_CLASS;
86        }
87      };
88
89  static Layout layoutFuncallableStandardClass =
90      new Layout(null,
91                 list(symName,
92                      symLayout,
93                      symDirectSuperclasses,
94                      symDirectSubclasses,
95                      symPrecedenceList,
96                      symDirectMethods,
97                      symDirectSlots,
98                      symSlots,
99                      symDirectDefaultInitargs,
100                      symDefaultInitargs,
101                      symFinalizedP,
102                      Symbol._DOCUMENTATION),
103                 NIL)
104      {
105        @Override
106        public LispClass getLispClass()
107        {
108          return FUNCALLABLE_STANDARD_CLASS;
109        }
110      };
111
112  public StandardClass()
113  {
114      super(layoutStandardClass);
115      setDirectSuperclasses(NIL);
116      setDirectSubclasses(NIL);
117      setClassLayout(layoutStandardClass);
118      setCPL(NIL);
119      setDirectMethods(NIL);
120      setDocumentation(NIL);
121      setDirectSlotDefinitions(NIL);
122      setSlotDefinitions(NIL);
123      setDirectDefaultInitargs(NIL);
124      setDefaultInitargs(NIL);
125      setFinalized(false);
126  }
127
128  public StandardClass(Symbol symbol, LispObject directSuperclasses)
129  {
130      super(layoutStandardClass,
131            symbol, directSuperclasses);
132      setDirectSubclasses(NIL);
133      setClassLayout(layoutStandardClass);
134      setCPL(NIL);
135      setDirectMethods(NIL);
136      setDocumentation(NIL);
137      setDirectSlotDefinitions(NIL);
138      setSlotDefinitions(NIL);
139      setDirectDefaultInitargs(NIL);
140      setDefaultInitargs(NIL);
141      setFinalized(false);
142  }
143
144  public StandardClass(Layout layout)
145  {
146    super(layout);
147    setDirectSuperclasses(NIL);
148    setDirectSubclasses(NIL);
149    setClassLayout(layout);
150    setCPL(NIL);
151    setDirectMethods(NIL);
152    setDocumentation(NIL);
153    setDirectSlotDefinitions(NIL);
154    setSlotDefinitions(NIL);
155    setDirectDefaultInitargs(NIL);
156    setDefaultInitargs(NIL);
157    setFinalized(false);
158  }
159
160  public StandardClass(Layout layout, Symbol symbol, LispObject directSuperclasses)
161  {
162    super(layout, symbol, directSuperclasses);
163    setDirectSubclasses(NIL);
164    setClassLayout(layout);
165    setCPL(NIL);
166    setDirectMethods(NIL);
167    setDocumentation(NIL);
168    setDirectSlotDefinitions(NIL);
169    setSlotDefinitions(NIL);
170    setDirectDefaultInitargs(NIL);
171    setDefaultInitargs(NIL);
172    setFinalized(false);
173   
174  }
175
176  @Override
177  public LispObject getName()
178  {
179    return getInstanceSlotValue(symName);
180  }
181
182  @Override
183  public void setName(LispObject newName)
184  {
185    setInstanceSlotValue(symName, newName);
186  }
187
188  @Override
189  public Layout getClassLayout()
190  {
191    LispObject layout = getInstanceSlotValue(symLayout);
192    if (layout == UNBOUND_VALUE)
193      return null;
194
195    if (! (layout instanceof Layout)) {
196      // (new Error()).printStackTrace();
197      // LispThread.currentThread().printBacktrace();
198      // System.err.println("Class: " + this.princToString());
199      return (Layout)Lisp.error(Symbol.TYPE_ERROR,
200              new SimpleString("The value " + layout.princToString()
201                               + " is not of expected type "
202                               + Symbol.LAYOUT.princToString()
203                               + " in class " + this.princToString() + "."));
204    }
205   
206    return (layout == UNBOUND_VALUE) ? null : (Layout)layout;
207  }
208
209  @Override
210  public void setClassLayout(LispObject newLayout)
211  {
212    setInstanceSlotValue(symLayout, newLayout);
213  }
214
215  @Override
216  public LispObject getDirectSuperclasses()
217  {
218    return getInstanceSlotValue(symDirectSuperclasses);
219  }
220
221  @Override
222  public void setDirectSuperclasses(LispObject directSuperclasses)
223  {
224    setInstanceSlotValue(symDirectSuperclasses, directSuperclasses);
225  }
226
227  @Override
228  public final boolean isFinalized()
229  {
230    return getInstanceSlotValue(symFinalizedP) != NIL;
231  }
232
233  @Override
234  public final void setFinalized(boolean b)
235  {
236    setInstanceSlotValue(symFinalizedP, b ? T : NIL);
237  }
238
239  @Override
240  public LispObject getDirectSubclasses()
241  {
242    return getInstanceSlotValue(symDirectSubclasses);
243  }
244
245  @Override
246  public void setDirectSubclasses(LispObject directSubclasses)
247  {
248    setInstanceSlotValue(symDirectSubclasses, directSubclasses);
249  }
250
251  @Override
252  public LispObject getCPL()
253  {
254    return getInstanceSlotValue(symPrecedenceList);
255  }
256
257  @Override
258  public void setCPL(LispObject... cpl)
259  {
260    LispObject obj1 = cpl[0];
261    if (obj1.listp() && cpl.length == 1)
262      setInstanceSlotValue(symPrecedenceList, obj1);
263    else
264      {
265        Debug.assertTrue(obj1 == this);
266        LispObject l = NIL;
267        for (int i = cpl.length; i-- > 0;)
268            l = new Cons(cpl[i], l);
269        setInstanceSlotValue(symPrecedenceList, l);
270      }
271  }
272
273  @Override
274  public LispObject getDirectMethods()
275  {
276    return getInstanceSlotValue(symDirectMethods);
277  }
278
279  @Override
280  public void setDirectMethods(LispObject methods)
281  {
282    setInstanceSlotValue(symDirectMethods, methods);
283  }
284
285  @Override
286  public LispObject getDocumentation()
287  {
288    return getInstanceSlotValue(Symbol._DOCUMENTATION);
289  }
290
291  @Override
292  public void setDocumentation(LispObject doc)
293  {
294    setInstanceSlotValue(Symbol._DOCUMENTATION, doc);
295  }
296
297  @Override
298  public LispObject getDirectSlotDefinitions()
299  {
300    return getInstanceSlotValue(symDirectSlots);
301  }
302
303  @Override
304  public void setDirectSlotDefinitions(LispObject directSlotDefinitions)
305  {
306    setInstanceSlotValue(symDirectSlots, directSlotDefinitions);
307  }
308
309  @Override
310  public LispObject getSlotDefinitions()
311  {
312    return getInstanceSlotValue(symSlots);
313  }
314
315  @Override
316  public void setSlotDefinitions(LispObject slotDefinitions)
317  {
318     setInstanceSlotValue(symSlots, slotDefinitions);
319  }
320
321  @Override
322  public LispObject getDirectDefaultInitargs()
323  {
324    return getInstanceSlotValue(symDirectDefaultInitargs);
325  }
326
327  @Override
328  public void setDirectDefaultInitargs(LispObject directDefaultInitargs)
329  {
330    setInstanceSlotValue(symDirectDefaultInitargs, directDefaultInitargs);
331  }
332
333  @Override
334  public LispObject getDefaultInitargs()
335  {
336    return getInstanceSlotValue(symDefaultInitargs);
337  }
338
339  @Override
340  public void setDefaultInitargs(LispObject defaultInitargs)
341  {
342    setInstanceSlotValue(symDefaultInitargs, defaultInitargs);
343  }
344
345  @Override
346  public LispObject typeOf()
347  {
348    return Symbol.STANDARD_CLASS;
349  }
350
351  @Override
352  public LispObject classOf()
353  {
354    return STANDARD_CLASS;
355  }
356
357  @Override
358  public LispObject typep(LispObject type)
359  {
360    if (type == Symbol.STANDARD_CLASS)
361      return T;
362    if (type == STANDARD_CLASS)
363      return T;
364    return super.typep(type);
365  }
366
367  @Override
368  public String printObject()
369  {
370    StringBuilder sb =
371      new StringBuilder(Symbol.STANDARD_CLASS.printObject());
372    if (getName() != null)
373      {
374        sb.append(' ');
375        sb.append(getName().printObject());
376      }
377    return unreadableString(sb.toString());
378  }
379
380  private static final LispObject standardClassSlotDefinitions()
381  {
382    return
383      list(new SlotDefinition(symName, list(Symbol.CLASS_NAME), constantlyNil),
384           new SlotDefinition(symLayout, list(Symbol.CLASS_LAYOUT), constantlyNil),
385           new SlotDefinition(symDirectSuperclasses, list(Symbol.CLASS_DIRECT_SUPERCLASSES), constantlyNil),
386           new SlotDefinition(symDirectSubclasses, list(Symbol.CLASS_DIRECT_SUBCLASSES), constantlyNil),
387           new SlotDefinition(symPrecedenceList, list(Symbol.CLASS_PRECEDENCE_LIST), constantlyNil),
388           new SlotDefinition(symDirectMethods, list(Symbol.CLASS_DIRECT_METHODS), constantlyNil),
389           new SlotDefinition(symDirectSlots, list(Symbol.CLASS_DIRECT_SLOTS), constantlyNil),
390           new SlotDefinition(symSlots, list(Symbol.CLASS_SLOTS), constantlyNil),
391           new SlotDefinition(symDirectDefaultInitargs, list(Symbol.CLASS_DIRECT_DEFAULT_INITARGS), constantlyNil),
392           new SlotDefinition(symDefaultInitargs, list(Symbol.CLASS_DEFAULT_INITARGS), constantlyNil),
393           new SlotDefinition(symFinalizedP, list(Symbol.CLASS_FINALIZED_P), constantlyNil),
394           new SlotDefinition(Symbol._DOCUMENTATION,
395                              list(Symbol.CLASS_DOCUMENTATION),
396                              constantlyNil, list(internKeyword("DOCUMENTATION"))));
397  }
398
399  private static final StandardClass addStandardClass(Symbol name,
400                                                      LispObject directSuperclasses)
401  {
402    StandardClass c = new StandardClass(name, directSuperclasses);
403    addClass(name, c);
404    return c;
405  }
406
407  private static final FuncallableStandardClass addFuncallableStandardClass
408    (Symbol name, LispObject directSuperclasses)
409  {
410    FuncallableStandardClass c = new FuncallableStandardClass(name, directSuperclasses);
411    addClass(name, c);
412    return c;
413  }
414
415  // At this point, BuiltInClass.java has not been completely loaded yet, and
416  // BuiltInClass.CLASS_T is null. So we need to call setDirectSuperclass()
417  // for STANDARD_CLASS and STANDARD_OBJECT in initializeStandardClasses()
418  // below.
419  public static final StandardClass STANDARD_CLASS =
420    addStandardClass(Symbol.STANDARD_CLASS, list(BuiltInClass.CLASS_T));
421  public static final StandardClass STANDARD_OBJECT =
422    addStandardClass(Symbol.STANDARD_OBJECT, list(BuiltInClass.CLASS_T));
423  public static final StandardClass METAOBJECT =
424    addStandardClass(Symbol.METAOBJECT, list(STANDARD_OBJECT));
425  public static final StandardClass SPECIALIZER =
426    addStandardClass(Symbol.SPECIALIZER, list(METAOBJECT));
427
428    public static final StandardClass SLOT_DEFINITION =
429        addStandardClass(Symbol.SLOT_DEFINITION, list(METAOBJECT));
430    public static final StandardClass STANDARD_SLOT_DEFINITION =
431        addClass(Symbol.STANDARD_SLOT_DEFINITION, new SlotDefinitionClass(Symbol.STANDARD_SLOT_DEFINITION, list(SLOT_DEFINITION)));
432
433  static
434  {
435      SLOT_DEFINITION.finalizeClass();
436
437    STANDARD_CLASS.setClassLayout(layoutStandardClass);
438    STANDARD_CLASS.setDirectSlotDefinitions(standardClassSlotDefinitions());
439  }
440
441    public static final StandardClass DIRECT_SLOT_DEFINITION =
442      addStandardClass(Symbol.DIRECT_SLOT_DEFINITION, list(SLOT_DEFINITION));
443    public static final StandardClass EFFECTIVE_SLOT_DEFINITION =
444        addStandardClass(Symbol.EFFECTIVE_SLOT_DEFINITION, list(SLOT_DEFINITION));
445    //      addStandardClass(Symbol.STANDARD_SLOT_DEFINITION, list(SLOT_DEFINITION));
446    public static final StandardClass STANDARD_DIRECT_SLOT_DEFINITION =
447        addClass(Symbol.STANDARD_DIRECT_SLOT_DEFINITION,
448                 new SlotDefinitionClass(Symbol.STANDARD_DIRECT_SLOT_DEFINITION,
449                                         list(STANDARD_SLOT_DEFINITION, DIRECT_SLOT_DEFINITION)));
450    public static final StandardClass STANDARD_EFFECTIVE_SLOT_DEFINITION =
451        addClass(Symbol.STANDARD_EFFECTIVE_SLOT_DEFINITION,
452                 new SlotDefinitionClass(Symbol.STANDARD_EFFECTIVE_SLOT_DEFINITION,
453                                         list(STANDARD_SLOT_DEFINITION, EFFECTIVE_SLOT_DEFINITION)));
454
455
456  // BuiltInClass.FUNCTION is also null here (see previous comment).
457  // Following SBCL's lead, we make funcallable-standard-object a
458  // funcallable-standard-class.
459  public static final StandardClass FUNCALLABLE_STANDARD_OBJECT =
460      addFuncallableStandardClass(Symbol.FUNCALLABLE_STANDARD_OBJECT,
461                       list(STANDARD_OBJECT, BuiltInClass.FUNCTION));
462
463  public static final StandardClass CLASS =
464    addStandardClass(Symbol.CLASS, list(SPECIALIZER));
465
466  public static final StandardClass BUILT_IN_CLASS =
467    addStandardClass(Symbol.BUILT_IN_CLASS, list(CLASS));
468
469  public static final StandardClass FUNCALLABLE_STANDARD_CLASS =
470    addStandardClass(Symbol.FUNCALLABLE_STANDARD_CLASS, list(CLASS));
471
472  public static final StandardClass CONDITION =
473    addStandardClass(Symbol.CONDITION, list(STANDARD_OBJECT));
474
475  public static final StandardClass SIMPLE_CONDITION =
476    addStandardClass(Symbol.SIMPLE_CONDITION, list(CONDITION));
477
478  public static final StandardClass WARNING =
479    addStandardClass(Symbol.WARNING, list(CONDITION));
480
481  public static final StandardClass SIMPLE_WARNING =
482    addStandardClass(Symbol.SIMPLE_WARNING, list(SIMPLE_CONDITION, WARNING));
483
484  public static final StandardClass STYLE_WARNING =
485    addStandardClass(Symbol.STYLE_WARNING, list(WARNING));
486
487  public static final StandardClass SERIOUS_CONDITION =
488    addStandardClass(Symbol.SERIOUS_CONDITION, list(CONDITION));
489
490  public static final StandardClass STORAGE_CONDITION =
491    addStandardClass(Symbol.STORAGE_CONDITION, list(SERIOUS_CONDITION));
492
493  public static final StandardClass ERROR =
494    addStandardClass(Symbol.ERROR, list(SERIOUS_CONDITION));
495
496  public static final StandardClass ARITHMETIC_ERROR =
497    addStandardClass(Symbol.ARITHMETIC_ERROR, list(ERROR));
498
499  public static final StandardClass CELL_ERROR =
500    addStandardClass(Symbol.CELL_ERROR, list(ERROR));
501
502  public static final StandardClass CONTROL_ERROR =
503    addStandardClass(Symbol.CONTROL_ERROR, list(ERROR));
504
505  public static final StandardClass FILE_ERROR =
506    addStandardClass(Symbol.FILE_ERROR, list(ERROR));
507
508  public static final StandardClass DIVISION_BY_ZERO =
509    addStandardClass(Symbol.DIVISION_BY_ZERO, list(ARITHMETIC_ERROR));
510
511  public static final StandardClass FLOATING_POINT_INEXACT =
512    addStandardClass(Symbol.FLOATING_POINT_INEXACT, list(ARITHMETIC_ERROR));
513
514  public static final StandardClass FLOATING_POINT_INVALID_OPERATION =
515    addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list(ARITHMETIC_ERROR));
516
517  public static final StandardClass FLOATING_POINT_OVERFLOW =
518    addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list(ARITHMETIC_ERROR));
519
520  public static final StandardClass FLOATING_POINT_UNDERFLOW =
521    addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list(ARITHMETIC_ERROR));
522
523  public static final StandardClass PROGRAM_ERROR =
524    addStandardClass(Symbol.PROGRAM_ERROR, list(ERROR));
525
526  public static final StandardClass PACKAGE_ERROR =
527    addStandardClass(Symbol.PACKAGE_ERROR, list(ERROR));
528
529  public static final StandardClass STREAM_ERROR =
530    addStandardClass(Symbol.STREAM_ERROR, list(ERROR));
531
532  public static final StandardClass PARSE_ERROR =
533    addStandardClass(Symbol.PARSE_ERROR, list(ERROR));
534
535  public static final StandardClass PRINT_NOT_READABLE =
536    addStandardClass(Symbol.PRINT_NOT_READABLE, list(ERROR));
537
538  public static final StandardClass READER_ERROR =
539    addStandardClass(Symbol.READER_ERROR, list(PARSE_ERROR, STREAM_ERROR));
540
541  public static final StandardClass END_OF_FILE =
542    addStandardClass(Symbol.END_OF_FILE, list(STREAM_ERROR));
543
544  public static final StandardClass SIMPLE_ERROR =
545    addStandardClass(Symbol.SIMPLE_ERROR, list(SIMPLE_CONDITION, ERROR));
546
547  public static final StandardClass TYPE_ERROR =
548    addStandardClass(Symbol.TYPE_ERROR, list(ERROR));
549
550  public static final StandardClass SIMPLE_TYPE_ERROR =
551    addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list(SIMPLE_CONDITION,
552                                                     TYPE_ERROR));
553
554  public static final StandardClass UNBOUND_SLOT =
555    addStandardClass(Symbol.UNBOUND_SLOT, list(CELL_ERROR));
556
557  public static final StandardClass UNBOUND_VARIABLE =
558    addStandardClass(Symbol.UNBOUND_VARIABLE, list(CELL_ERROR));
559
560  public static final StandardClass UNDEFINED_FUNCTION =
561    addStandardClass(Symbol.UNDEFINED_FUNCTION, list(CELL_ERROR));
562
563  public static final StandardClass JAVA_EXCEPTION =
564    addStandardClass(Symbol.JAVA_EXCEPTION, list(ERROR));
565
566  public static final StandardClass METHOD =
567    addStandardClass(Symbol.METHOD, list(METAOBJECT));
568
569  public static final StandardClass STANDARD_METHOD =
570    addStandardClass(Symbol.STANDARD_METHOD, list(METHOD));
571
572  public static void initializeStandardClasses()
573  {
574    // We need to call setDirectSuperclass() here for classes that have a
575    // BuiltInClass as a superclass. See comment above (at first mention of
576    // STANDARD_OBJECT).
577    STANDARD_CLASS.setDirectSuperclass(CLASS);
578    STANDARD_OBJECT.setDirectSuperclass(BuiltInClass.CLASS_T);
579    FUNCALLABLE_STANDARD_OBJECT.setDirectSuperclasses(list(STANDARD_OBJECT, BuiltInClass.FUNCTION));
580    ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION,
581                            CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
582    ARITHMETIC_ERROR.setDirectSlotDefinitions(
583      list(new SlotDefinition(Symbol.OPERATION,
584                               list(Symbol.ARITHMETIC_ERROR_OPERATION)),
585            new SlotDefinition(Symbol.OPERANDS,
586                               list(Symbol.ARITHMETIC_ERROR_OPERANDS))));
587    BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, SPECIALIZER, METAOBJECT, STANDARD_OBJECT,
588                          BuiltInClass.CLASS_T);
589    CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
590                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
591    CELL_ERROR.setDirectSlotDefinitions(
592      list(new SlotDefinition(Symbol.NAME,
593                               list(Symbol.CELL_ERROR_NAME))));
594    CLASS.setCPL(CLASS, SPECIALIZER, METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
595    CONDITION.setCPL(CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
596    CONDITION.setDirectSlotDefinitions(
597      list(new SlotDefinition(Symbol.FORMAT_CONTROL,
598                               list(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
599            new SlotDefinition(Symbol.FORMAT_ARGUMENTS,
600                               list(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
601                               NIL)));
602    CONDITION.setDirectDefaultInitargs(list(list(Keyword.FORMAT_ARGUMENTS,
603                                                 NIL,
604                                                 constantlyNil)));
605    CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
606                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
607    DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR, ERROR,
608                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
609                            BuiltInClass.CLASS_T);
610    END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR, SERIOUS_CONDITION,
611                       CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
612    ERROR.setCPL(ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
613                 BuiltInClass.CLASS_T);
614    FILE_ERROR.setCPL(FILE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
615                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
616    FILE_ERROR.setDirectSlotDefinitions(
617      list(new SlotDefinition(Symbol.PATHNAME,
618                               list(Symbol.FILE_ERROR_PATHNAME))));
619    FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT, ARITHMETIC_ERROR,
620                                  ERROR, SERIOUS_CONDITION, CONDITION,
621                                  STANDARD_OBJECT, BuiltInClass.CLASS_T);
622    FLOATING_POINT_INVALID_OPERATION.setCPL(FLOATING_POINT_INVALID_OPERATION,
623                                            ARITHMETIC_ERROR, ERROR,
624                                            SERIOUS_CONDITION, CONDITION,
625                                            STANDARD_OBJECT, BuiltInClass.CLASS_T);
626    FLOATING_POINT_OVERFLOW.setCPL(FLOATING_POINT_OVERFLOW, ARITHMETIC_ERROR,
627                                   ERROR, SERIOUS_CONDITION, CONDITION,
628                                   STANDARD_OBJECT, BuiltInClass.CLASS_T);
629    FLOATING_POINT_UNDERFLOW.setCPL(FLOATING_POINT_UNDERFLOW, ARITHMETIC_ERROR,
630                                    ERROR, SERIOUS_CONDITION, CONDITION,
631                                    STANDARD_OBJECT, BuiltInClass.CLASS_T);
632    FUNCALLABLE_STANDARD_OBJECT.setCPL(FUNCALLABLE_STANDARD_OBJECT,
633                                       STANDARD_OBJECT, BuiltInClass.FUNCTION,
634                                       BuiltInClass.CLASS_T);
635    JAVA_EXCEPTION.setCPL(JAVA_EXCEPTION, ERROR, SERIOUS_CONDITION, CONDITION,
636                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
637    JAVA_EXCEPTION.setDirectSlotDefinitions(
638      list(new SlotDefinition(Symbol.CAUSE, list(Symbol.JAVA_EXCEPTION_CAUSE))));
639    METAOBJECT.setCPL(METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
640    SPECIALIZER.setCPL(SPECIALIZER, METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
641    METHOD.setCPL(METHOD, METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
642    STANDARD_METHOD.setCPL(STANDARD_METHOD, METHOD, METAOBJECT, STANDARD_OBJECT,
643                           BuiltInClass.CLASS_T);
644    STANDARD_METHOD.setDirectSlotDefinitions(
645      list(new SlotDefinition(Symbol._GENERIC_FUNCTION, NIL, constantlyNil,
646                              list(internKeyword("GENERIC-FUNCTION"))),
647           new SlotDefinition(Symbol.LAMBDA_LIST, NIL, constantlyNil),
648           new SlotDefinition(Symbol.KEYWORDS, NIL, constantlyNil),
649           new SlotDefinition(Symbol.OTHER_KEYWORDS_P, NIL, constantlyNil),
650           new SlotDefinition(Symbol.SPECIALIZERS, NIL, constantlyNil),
651           new SlotDefinition(Symbol.QUALIFIERS, NIL, constantlyNil),
652           new SlotDefinition(Symbol._FUNCTION, NIL, constantlyNil,
653                              list(internKeyword("FUNCTION"))),
654           new SlotDefinition(Symbol.FAST_FUNCTION, NIL, constantlyNil),
655           new SlotDefinition(Symbol._DOCUMENTATION, NIL, constantlyNil,
656                              list(internKeyword("DOCUMENTATION")))));
657    PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
658                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
659    PACKAGE_ERROR.setDirectSlotDefinitions(
660      list(new SlotDefinition(Symbol.PACKAGE,
661                               list(Symbol.PACKAGE_ERROR_PACKAGE))));
662    PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
663                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
664    PRINT_NOT_READABLE.setCPL(PRINT_NOT_READABLE, ERROR, SERIOUS_CONDITION,
665                              CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
666    PRINT_NOT_READABLE.setDirectSlotDefinitions(
667      list(new SlotDefinition(Symbol.OBJECT,
668                               list(Symbol.PRINT_NOT_READABLE_OBJECT))));
669    PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
670                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
671    READER_ERROR.setCPL(READER_ERROR, PARSE_ERROR, STREAM_ERROR, ERROR,
672                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
673                        BuiltInClass.CLASS_T);
674    SERIOUS_CONDITION.setCPL(SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
675                             BuiltInClass.CLASS_T);
676    SIMPLE_CONDITION.setCPL(SIMPLE_CONDITION, CONDITION, STANDARD_OBJECT,
677                            BuiltInClass.CLASS_T);
678    SIMPLE_ERROR.setCPL(SIMPLE_ERROR, SIMPLE_CONDITION, ERROR,
679                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
680                        BuiltInClass.CLASS_T);
681    SIMPLE_TYPE_ERROR.setDirectSuperclasses(list(SIMPLE_CONDITION,
682                                                  TYPE_ERROR));
683    SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
684                             TYPE_ERROR, ERROR, SERIOUS_CONDITION,
685                             CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
686    SIMPLE_WARNING.setDirectSuperclasses(list(SIMPLE_CONDITION, WARNING));
687    SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
688                          CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
689    STANDARD_CLASS.setCPL(STANDARD_CLASS, CLASS, SPECIALIZER, METAOBJECT,
690                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
691    FUNCALLABLE_STANDARD_CLASS.setCPL(FUNCALLABLE_STANDARD_CLASS, CLASS,
692                                      SPECIALIZER, METAOBJECT, STANDARD_OBJECT,
693                                      BuiltInClass.CLASS_T);
694    // funcallable-standard-class has the same interface as
695    // standard-class.
696    FUNCALLABLE_STANDARD_CLASS.setClassLayout(layoutStandardClass);
697    FUNCALLABLE_STANDARD_CLASS.setDirectSlotDefinitions(standardClassSlotDefinitions());
698    STANDARD_OBJECT.setCPL(STANDARD_OBJECT, BuiltInClass.CLASS_T);
699    STORAGE_CONDITION.setCPL(STORAGE_CONDITION, SERIOUS_CONDITION, CONDITION,
700                             STANDARD_OBJECT, BuiltInClass.CLASS_T);
701    STREAM_ERROR.setCPL(STREAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
702                        STANDARD_OBJECT, BuiltInClass.CLASS_T);
703    STREAM_ERROR.setDirectSlotDefinitions(
704      list(new SlotDefinition(Symbol.STREAM,
705                               list(Symbol.STREAM_ERROR_STREAM))));
706    STYLE_WARNING.setCPL(STYLE_WARNING, WARNING, CONDITION, STANDARD_OBJECT,
707                         BuiltInClass.CLASS_T);
708    TYPE_ERROR.setCPL(TYPE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
709                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
710    TYPE_ERROR.setDirectSlotDefinitions(
711      list(new SlotDefinition(Symbol.DATUM,
712                               list(Symbol.TYPE_ERROR_DATUM)),
713            new SlotDefinition(Symbol.EXPECTED_TYPE,
714                               list(Symbol.TYPE_ERROR_EXPECTED_TYPE))));
715    UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR, SERIOUS_CONDITION,
716                        CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
717    UNBOUND_SLOT.setDirectSlotDefinitions(
718      list(new SlotDefinition(Symbol.INSTANCE,
719                               list(Symbol.UNBOUND_SLOT_INSTANCE))));
720    UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
721                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
722                            BuiltInClass.CLASS_T);
723    UNDEFINED_FUNCTION.setCPL(UNDEFINED_FUNCTION, CELL_ERROR, ERROR,
724                              SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
725                              BuiltInClass.CLASS_T);
726    WARNING.setCPL(WARNING, CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
727
728    // Condition classes.
729    STANDARD_CLASS.finalizeClass();
730    STANDARD_OBJECT.finalizeClass();
731    FUNCALLABLE_STANDARD_OBJECT.finalizeClass();
732    FUNCALLABLE_STANDARD_CLASS.finalizeClass();
733    ARITHMETIC_ERROR.finalizeClass();
734    CELL_ERROR.finalizeClass();
735    CONDITION.finalizeClass();
736    CONTROL_ERROR.finalizeClass();
737    DIVISION_BY_ZERO.finalizeClass();
738    END_OF_FILE.finalizeClass();
739    ERROR.finalizeClass();
740    FILE_ERROR.finalizeClass();
741    FLOATING_POINT_INEXACT.finalizeClass();
742    FLOATING_POINT_INVALID_OPERATION.finalizeClass();
743    FLOATING_POINT_OVERFLOW.finalizeClass();
744    FLOATING_POINT_UNDERFLOW.finalizeClass();
745    JAVA_EXCEPTION.finalizeClass();
746    METAOBJECT.finalizeClass();
747    METHOD.finalizeClass();
748    STANDARD_METHOD.finalizeClass();
749    SPECIALIZER.finalizeClass();
750    CLASS.finalizeClass();
751    BUILT_IN_CLASS.finalizeClass();
752    PACKAGE_ERROR.finalizeClass();
753    PARSE_ERROR.finalizeClass();
754    PRINT_NOT_READABLE.finalizeClass();
755    PROGRAM_ERROR.finalizeClass();
756    READER_ERROR.finalizeClass();
757    SERIOUS_CONDITION.finalizeClass();
758    SIMPLE_CONDITION.finalizeClass();
759    SIMPLE_ERROR.finalizeClass();
760    SIMPLE_TYPE_ERROR.finalizeClass();
761    SIMPLE_WARNING.finalizeClass();
762    STORAGE_CONDITION.finalizeClass();
763    STREAM_ERROR.finalizeClass();
764    STYLE_WARNING.finalizeClass();
765    TYPE_ERROR.finalizeClass();
766    UNBOUND_SLOT.finalizeClass();
767    UNBOUND_VARIABLE.finalizeClass();
768    UNDEFINED_FUNCTION.finalizeClass();
769    WARNING.finalizeClass();
770
771    // SYS:SLOT-DEFINITION is constructed and finalized in
772    // SlotDefinitionClass.java, but we need to fill in a few things here.
773    Debug.assertTrue(SLOT_DEFINITION.isFinalized());
774    SLOT_DEFINITION.setCPL(SLOT_DEFINITION, METAOBJECT, STANDARD_OBJECT,
775                           BuiltInClass.CLASS_T);
776    SLOT_DEFINITION.setDirectSlotDefinitions(SLOT_DEFINITION.getClassLayout().generateSlotDefinitions());
777    // There are no inherited slots.
778    SLOT_DEFINITION.setSlotDefinitions(SLOT_DEFINITION.getDirectSlotDefinitions());
779
780    DIRECT_SLOT_DEFINITION.setCPL(DIRECT_SLOT_DEFINITION, SLOT_DEFINITION,
781                                  METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
782    DIRECT_SLOT_DEFINITION.finalizeClass();
783    EFFECTIVE_SLOT_DEFINITION.setCPL(EFFECTIVE_SLOT_DEFINITION, SLOT_DEFINITION,
784                                     METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
785    EFFECTIVE_SLOT_DEFINITION.finalizeClass();
786    STANDARD_SLOT_DEFINITION.setCPL(STANDARD_SLOT_DEFINITION, SLOT_DEFINITION,
787                                    METAOBJECT, STANDARD_OBJECT, BuiltInClass.CLASS_T);
788    STANDARD_SLOT_DEFINITION.finalizeClass();
789    STANDARD_DIRECT_SLOT_DEFINITION.setCPL(STANDARD_DIRECT_SLOT_DEFINITION, STANDARD_SLOT_DEFINITION,
790                                           DIRECT_SLOT_DEFINITION, SLOT_DEFINITION, METAOBJECT, STANDARD_OBJECT,
791                                           BuiltInClass.CLASS_T);
792    STANDARD_DIRECT_SLOT_DEFINITION.finalizeClass();
793    STANDARD_EFFECTIVE_SLOT_DEFINITION.setCPL(STANDARD_EFFECTIVE_SLOT_DEFINITION, STANDARD_SLOT_DEFINITION,
794                                              EFFECTIVE_SLOT_DEFINITION, SLOT_DEFINITION, METAOBJECT, STANDARD_OBJECT,
795                                              BuiltInClass.CLASS_T);
796    STANDARD_EFFECTIVE_SLOT_DEFINITION.finalizeClass();
797
798  }
799}
Note: See TracBrowser for help on using the repository browser.