source: branches/0.19.x/abcl/src/org/armedbear/lisp/StandardClass.java

Last change on this file was 12481, checked in by ehuelsmann, 15 years ago

Merge 'metaclass' branch, making STANDARD-CLASS have slots to

be inherited by deriving metaclasses.

Note: this does definitely *not* complete the metaclass work.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 26.7 KB
Line 
1/*
2 * StandardClass.java
3 *
4 * Copyright (C) 2003-2005 Peter Graves
5 * $Id: StandardClass.java 12481 2010-02-14 21:29:58Z ehuelsmann $
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
41  private static Symbol symName = PACKAGE_MOP.intern("NAME");
42  private static Symbol symLayout = PACKAGE_MOP.intern("LAYOUT");
43  private static Symbol symDirectSuperclasses
44    = PACKAGE_MOP.intern("DIRECT-SUPERCLASSES");
45  private static Symbol symDirectSubclasses
46    = PACKAGE_MOP.intern("DIRECT-SUBCLASSES");
47  private static Symbol symClassPrecedenceList
48    = PACKAGE_MOP.intern("CLASS-PRECEDENCE-LIST");
49  private static Symbol symDirectMethods
50    = PACKAGE_MOP.intern("DIRECT-METHODS");
51  private static Symbol symDocumentation
52    = PACKAGE_MOP.intern("DOCUMENTATION");
53  private static Symbol symDirectSlots
54    = PACKAGE_MOP.intern("DIRECT-SLOTS");
55  private static Symbol symSlots
56    = PACKAGE_MOP.intern("SLOTS");
57  private static Symbol symDirectDefaultInitargs
58    = PACKAGE_MOP.intern("DIRECT-DEFAULT-INITARGS");
59  private static Symbol symDefaultInitargs
60    = PACKAGE_MOP.intern("DEFAULT-INITARGS");
61
62  static Layout layoutStandardClass =
63      new Layout(null,
64                 list(symName,
65                      symLayout,
66                      symDirectSuperclasses,
67                      symDirectSubclasses,
68                      symClassPrecedenceList,
69                      symDirectMethods,
70                      symDocumentation,
71                      symDirectSlots,
72                      symSlots,
73                      symDirectDefaultInitargs,
74                      symDefaultInitargs),
75                 NIL)
76      {
77        @Override
78        public LispClass getLispClass()
79        {
80          return STANDARD_CLASS;
81        }
82      };
83
84  public StandardClass()
85  {
86      super(layoutStandardClass);
87      setDirectSuperclasses(NIL);
88      setDirectSubclasses(NIL);
89      setCPL(NIL);
90      setDirectMethods(NIL);
91      setDocumentation(NIL);
92      setDirectSlotDefinitions(NIL);
93      setSlotDefinitions(NIL);
94      setDirectDefaultInitargs(NIL);
95      setDefaultInitargs(NIL);
96  }
97
98  public StandardClass(Symbol symbol, LispObject directSuperclasses)
99  {
100      super(layoutStandardClass,
101            symbol, directSuperclasses);
102      setDirectSubclasses(NIL);
103      setCPL(NIL);
104      setDirectMethods(NIL);
105      setDocumentation(NIL);
106      setDirectSlotDefinitions(NIL);
107      setSlotDefinitions(NIL);
108      setDirectDefaultInitargs(NIL);
109      setDefaultInitargs(NIL);
110  }
111
112  @Override
113  public LispObject getName()
114  {
115    return getInstanceSlotValue(symName);
116  }
117
118  @Override
119  public void setName(LispObject newName)
120  {
121    setInstanceSlotValue(symName, newName);
122  }
123
124  @Override
125  public Layout getClassLayout()
126  {
127    LispObject layout = getInstanceSlotValue(symLayout);
128    return (layout == UNBOUND_VALUE) ? null : (Layout)layout;
129  }
130
131  @Override
132  public void setClassLayout(Layout newLayout)
133  {
134    setInstanceSlotValue(symLayout, newLayout);
135  }
136
137  @Override
138  public LispObject getDirectSuperclasses()
139  {
140    return getInstanceSlotValue(symDirectSuperclasses);
141  }
142
143  @Override
144  public void setDirectSuperclasses(LispObject directSuperclasses)
145  {
146    setInstanceSlotValue(symDirectSuperclasses, directSuperclasses);
147  }
148
149  @Override
150  public LispObject getDirectSubclasses()
151  {
152    return getInstanceSlotValue(symDirectSubclasses);
153  }
154
155  @Override
156  public void setDirectSubclasses(LispObject directSubclasses)
157  {
158    setInstanceSlotValue(symDirectSubclasses, directSubclasses);
159  }
160
161  @Override
162  public LispObject getCPL()
163  {
164    return getInstanceSlotValue(symClassPrecedenceList);
165  }
166
167  @Override
168  public void setCPL(LispObject... cpl)
169  {
170    LispObject obj1 = cpl[0];
171    if (obj1.listp() && cpl.length == 1)
172      setInstanceSlotValue(symClassPrecedenceList, obj1);
173    else
174      {
175        Debug.assertTrue(obj1 == this);
176        LispObject l = NIL;
177        for (int i = cpl.length; i-- > 0;)
178            l = new Cons(cpl[i], l);
179        setInstanceSlotValue(symClassPrecedenceList, l);
180      }
181  }
182
183  @Override
184  public LispObject getDirectMethods()
185  {
186    return getInstanceSlotValue(symDirectMethods);
187  }
188
189  @Override
190  public void setDirectMethods(LispObject methods)
191  {
192    setInstanceSlotValue(symDirectMethods, methods);
193  }
194
195  @Override
196  public LispObject getDocumentation()
197  {
198    return getInstanceSlotValue(symDocumentation);
199  }
200
201  @Override
202  public void setDocumentation(LispObject doc)
203  {
204    setInstanceSlotValue(symDocumentation, doc);
205  }
206
207  @Override
208  public LispObject getDirectSlotDefinitions()
209  {
210    return getInstanceSlotValue(symDirectSlots);
211  }
212
213  @Override
214  public void setDirectSlotDefinitions(LispObject directSlotDefinitions)
215  {
216    setInstanceSlotValue(symDirectSlots, directSlotDefinitions);
217  }
218
219  @Override
220  public LispObject getSlotDefinitions()
221  {
222    return getInstanceSlotValue(symSlots);
223  }
224
225  @Override
226  public void setSlotDefinitions(LispObject slotDefinitions)
227  {
228     setInstanceSlotValue(symSlots, slotDefinitions);
229  }
230
231  @Override
232  public LispObject getDirectDefaultInitargs()
233  {
234    return getInstanceSlotValue(symDirectDefaultInitargs);
235  }
236
237  @Override
238  public void setDirectDefaultInitargs(LispObject directDefaultInitargs)
239  {
240    setInstanceSlotValue(symDirectDefaultInitargs, directDefaultInitargs);
241  }
242
243  @Override
244  public LispObject getDefaultInitargs()
245  {
246    return getInstanceSlotValue(symDefaultInitargs);
247  }
248
249  @Override
250  public void setDefaultInitargs(LispObject defaultInitargs)
251  {
252    setInstanceSlotValue(symDefaultInitargs, defaultInitargs);
253  }
254
255
256
257  @Override
258  public LispObject classOf()
259  {
260    return STANDARD_CLASS;
261  }
262
263  @Override
264  public LispObject typep(LispObject type)
265  {
266    if (type == Symbol.STANDARD_CLASS)
267      return T;
268    if (type == STANDARD_CLASS)
269      return T;
270    return super.typep(type);
271  }
272
273  public LispObject allocateInstance()
274  {
275    Layout layout = getClassLayout();
276    if (layout == null)
277      {
278        Symbol.ERROR.execute(Symbol.SIMPLE_ERROR,
279                             Keyword.FORMAT_CONTROL,
280                             new SimpleString("No layout for class ~S."),
281                             Keyword.FORMAT_ARGUMENTS,
282                             list(this));
283      }
284    return new StandardObject(this, layout.getLength());
285  }
286
287  @Override
288  public String writeToString()
289  {
290    StringBuilder sb =
291      new StringBuilder(Symbol.STANDARD_CLASS.writeToString());
292    if (getName() != null)
293      {
294        sb.append(' ');
295        sb.append(getName().writeToString());
296      }
297    return unreadableString(sb.toString());
298  }
299
300  private static final StandardClass addStandardClass(Symbol name,
301                                                      LispObject directSuperclasses)
302  {
303    StandardClass c = new StandardClass(name, directSuperclasses);
304    addClass(name, c);
305    return c;
306  }
307
308  // At this point, BuiltInClass.java has not been completely loaded yet, and
309  // BuiltInClass.CLASS_T is null. So we need to call setDirectSuperclass()
310  // for STANDARD_CLASS and STANDARD_OBJECT in initializeStandardClasses()
311  // below.
312  public static final StandardClass STANDARD_CLASS =
313    addStandardClass(Symbol.STANDARD_CLASS, list(BuiltInClass.CLASS_T));
314  public static final StandardClass STANDARD_OBJECT =
315    addStandardClass(Symbol.STANDARD_OBJECT, list(BuiltInClass.CLASS_T));
316
317  public static final StandardClass SLOT_DEFINITION =
318    new SlotDefinitionClass();
319  static
320  {
321    addClass(Symbol.SLOT_DEFINITION, SLOT_DEFINITION);
322
323    STANDARD_CLASS.setClassLayout(layoutStandardClass);
324    STANDARD_CLASS.setDirectSlotDefinitions(STANDARD_CLASS.getClassLayout().generateSlotDefinitions());
325  }
326
327  // BuiltInClass.FUNCTION is also null here (see previous comment).
328  public static final StandardClass GENERIC_FUNCTION =
329    addStandardClass(Symbol.GENERIC_FUNCTION, list(BuiltInClass.FUNCTION,
330                                                    STANDARD_OBJECT));
331
332  public static final StandardClass CLASS =
333    addStandardClass(Symbol.CLASS, list(STANDARD_OBJECT));
334
335  public static final StandardClass BUILT_IN_CLASS =
336    addStandardClass(Symbol.BUILT_IN_CLASS, list(CLASS));
337
338  public static final StandardClass JAVA_CLASS =
339      addStandardClass(Symbol.JAVA_CLASS, list(CLASS));
340 
341  public static final StandardClass FORWARD_REFERENCED_CLASS =
342    addStandardClass(Symbol.FORWARD_REFERENCED_CLASS, list(CLASS));
343
344  public static final StandardClass STRUCTURE_CLASS =
345    addStandardClass(Symbol.STRUCTURE_CLASS, list(CLASS));
346
347  public static final StandardClass CONDITION =
348    addStandardClass(Symbol.CONDITION, list(STANDARD_OBJECT));
349
350  public static final StandardClass SIMPLE_CONDITION =
351    addStandardClass(Symbol.SIMPLE_CONDITION, list(CONDITION));
352
353  public static final StandardClass WARNING =
354    addStandardClass(Symbol.WARNING, list(CONDITION));
355
356  public static final StandardClass SIMPLE_WARNING =
357    addStandardClass(Symbol.SIMPLE_WARNING, list(SIMPLE_CONDITION, WARNING));
358
359  public static final StandardClass STYLE_WARNING =
360    addStandardClass(Symbol.STYLE_WARNING, list(WARNING));
361
362  public static final StandardClass SERIOUS_CONDITION =
363    addStandardClass(Symbol.SERIOUS_CONDITION, list(CONDITION));
364
365  public static final StandardClass STORAGE_CONDITION =
366    addStandardClass(Symbol.STORAGE_CONDITION, list(SERIOUS_CONDITION));
367
368  public static final StandardClass ERROR =
369    addStandardClass(Symbol.ERROR, list(SERIOUS_CONDITION));
370
371  public static final StandardClass ARITHMETIC_ERROR =
372    addStandardClass(Symbol.ARITHMETIC_ERROR, list(ERROR));
373
374  public static final StandardClass CELL_ERROR =
375    addStandardClass(Symbol.CELL_ERROR, list(ERROR));
376
377  public static final StandardClass CONTROL_ERROR =
378    addStandardClass(Symbol.CONTROL_ERROR, list(ERROR));
379
380  public static final StandardClass FILE_ERROR =
381    addStandardClass(Symbol.FILE_ERROR, list(ERROR));
382
383  public static final StandardClass DIVISION_BY_ZERO =
384    addStandardClass(Symbol.DIVISION_BY_ZERO, list(ARITHMETIC_ERROR));
385
386  public static final StandardClass FLOATING_POINT_INEXACT =
387    addStandardClass(Symbol.FLOATING_POINT_INEXACT, list(ARITHMETIC_ERROR));
388
389  public static final StandardClass FLOATING_POINT_INVALID_OPERATION =
390    addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list(ARITHMETIC_ERROR));
391
392  public static final StandardClass FLOATING_POINT_OVERFLOW =
393    addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list(ARITHMETIC_ERROR));
394
395  public static final StandardClass FLOATING_POINT_UNDERFLOW =
396    addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list(ARITHMETIC_ERROR));
397
398  public static final StandardClass PROGRAM_ERROR =
399    addStandardClass(Symbol.PROGRAM_ERROR, list(ERROR));
400
401  public static final StandardClass PACKAGE_ERROR =
402    addStandardClass(Symbol.PACKAGE_ERROR, list(ERROR));
403
404  public static final StandardClass STREAM_ERROR =
405    addStandardClass(Symbol.STREAM_ERROR, list(ERROR));
406
407  public static final StandardClass PARSE_ERROR =
408    addStandardClass(Symbol.PARSE_ERROR, list(ERROR));
409
410  public static final StandardClass PRINT_NOT_READABLE =
411    addStandardClass(Symbol.PRINT_NOT_READABLE, list(ERROR));
412
413  public static final StandardClass READER_ERROR =
414    addStandardClass(Symbol.READER_ERROR, list(PARSE_ERROR, STREAM_ERROR));
415
416  public static final StandardClass END_OF_FILE =
417    addStandardClass(Symbol.END_OF_FILE, list(STREAM_ERROR));
418
419  public static final StandardClass SIMPLE_ERROR =
420    addStandardClass(Symbol.SIMPLE_ERROR, list(SIMPLE_CONDITION, ERROR));
421
422  public static final StandardClass TYPE_ERROR =
423    addStandardClass(Symbol.TYPE_ERROR, list(ERROR));
424
425  public static final StandardClass SIMPLE_TYPE_ERROR =
426    addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list(SIMPLE_CONDITION,
427                                                     TYPE_ERROR));
428
429  public static final StandardClass UNBOUND_SLOT =
430    addStandardClass(Symbol.UNBOUND_SLOT, list(CELL_ERROR));
431
432  public static final StandardClass UNBOUND_VARIABLE =
433    addStandardClass(Symbol.UNBOUND_VARIABLE, list(CELL_ERROR));
434
435  public static final StandardClass UNDEFINED_FUNCTION =
436    addStandardClass(Symbol.UNDEFINED_FUNCTION, list(CELL_ERROR));
437
438  public static final StandardClass COMPILER_ERROR =
439    addStandardClass(Symbol.COMPILER_ERROR, list(CONDITION));
440
441  public static final StandardClass COMPILER_UNSUPPORTED_FEATURE_ERROR =
442    addStandardClass(Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR,
443                     list(CONDITION));
444
445  public static final StandardClass JAVA_EXCEPTION =
446    addStandardClass(Symbol.JAVA_EXCEPTION, list(ERROR));
447
448  public static final StandardClass METHOD =
449    addStandardClass(Symbol.METHOD, list(STANDARD_OBJECT));
450
451  public static final StandardClass STANDARD_METHOD =
452    new StandardMethodClass();
453  static
454  {
455    addClass(Symbol.STANDARD_METHOD, STANDARD_METHOD);
456  }
457
458  public static final StandardClass STANDARD_READER_METHOD =
459    new StandardReaderMethodClass();
460  static
461  {
462    addClass(Symbol.STANDARD_READER_METHOD, STANDARD_READER_METHOD);
463  }
464
465  public static final StandardClass STANDARD_GENERIC_FUNCTION =
466    new StandardGenericFunctionClass();
467  static
468  {
469    addClass(Symbol.STANDARD_GENERIC_FUNCTION, STANDARD_GENERIC_FUNCTION);
470  }
471
472  public static void initializeStandardClasses()
473  {
474    // We need to call setDirectSuperclass() here for classes that have a
475    // BuiltInClass as a superclass. See comment above (at first mention of
476    // STANDARD_OBJECT).
477    STANDARD_CLASS.setDirectSuperclass(CLASS);
478    STANDARD_OBJECT.setDirectSuperclass(BuiltInClass.CLASS_T);
479    GENERIC_FUNCTION.setDirectSuperclasses(list(BuiltInClass.FUNCTION,
480                                                 STANDARD_OBJECT));
481
482    ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION,
483                            CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
484    ARITHMETIC_ERROR.setDirectSlotDefinitions(
485      list(new SlotDefinition(Symbol.OPERATION,
486                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERATION"))),
487            new SlotDefinition(Symbol.OPERANDS,
488                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERANDS")))));
489    BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
490                          BuiltInClass.CLASS_T);
491    JAVA_CLASS.setCPL(JAVA_CLASS, CLASS, STANDARD_OBJECT,
492            BuiltInClass.CLASS_T);
493    CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
494                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
495    CELL_ERROR.setDirectSlotDefinitions(
496      list(new SlotDefinition(Symbol.NAME,
497                               list(Symbol.CELL_ERROR_NAME))));
498    CLASS.setCPL(CLASS, STANDARD_OBJECT, BuiltInClass.CLASS_T);
499    COMPILER_ERROR.setCPL(COMPILER_ERROR, CONDITION, STANDARD_OBJECT,
500                          BuiltInClass.CLASS_T);
501    COMPILER_UNSUPPORTED_FEATURE_ERROR.setCPL(COMPILER_UNSUPPORTED_FEATURE_ERROR,
502                                              CONDITION, STANDARD_OBJECT,
503                                              BuiltInClass.CLASS_T);
504    CONDITION.setCPL(CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
505    CONDITION.setDirectSlotDefinitions(
506      list(new SlotDefinition(Symbol.FORMAT_CONTROL,
507                               list(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
508            new SlotDefinition(Symbol.FORMAT_ARGUMENTS,
509                               list(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
510                               NIL)));
511    CONDITION.setDirectDefaultInitargs(list(Keyword.FORMAT_ARGUMENTS,
512                                             // FIXME
513                                             new Closure(list(Symbol.LAMBDA, NIL, NIL),
514                                                         new Environment())));
515    CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
516                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
517    DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR, ERROR,
518                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
519                            BuiltInClass.CLASS_T);
520    END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR, SERIOUS_CONDITION,
521                       CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
522    ERROR.setCPL(ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
523                 BuiltInClass.CLASS_T);
524    FILE_ERROR.setCPL(FILE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
525                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
526    FILE_ERROR.setDirectSlotDefinitions(
527      list(new SlotDefinition(Symbol.PATHNAME,
528                               list(PACKAGE_CL.intern("FILE-ERROR-PATHNAME")))));
529    FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT, ARITHMETIC_ERROR,
530                                  ERROR, SERIOUS_CONDITION, CONDITION,
531                                  STANDARD_OBJECT, BuiltInClass.CLASS_T);
532    FLOATING_POINT_INVALID_OPERATION.setCPL(FLOATING_POINT_INVALID_OPERATION,
533                                            ARITHMETIC_ERROR, ERROR,
534                                            SERIOUS_CONDITION, CONDITION,
535                                            STANDARD_OBJECT, BuiltInClass.CLASS_T);
536    FLOATING_POINT_OVERFLOW.setCPL(FLOATING_POINT_OVERFLOW, ARITHMETIC_ERROR,
537                                   ERROR, SERIOUS_CONDITION, CONDITION,
538                                   STANDARD_OBJECT, BuiltInClass.CLASS_T);
539    FLOATING_POINT_UNDERFLOW.setCPL(FLOATING_POINT_UNDERFLOW, ARITHMETIC_ERROR,
540                                    ERROR, SERIOUS_CONDITION, CONDITION,
541                                    STANDARD_OBJECT, BuiltInClass.CLASS_T);
542    FORWARD_REFERENCED_CLASS.setCPL(FORWARD_REFERENCED_CLASS, CLASS,
543                                    BuiltInClass.CLASS_T);
544    GENERIC_FUNCTION.setCPL(GENERIC_FUNCTION, STANDARD_OBJECT,
545                            BuiltInClass.FUNCTION,
546                            BuiltInClass.CLASS_T);
547    JAVA_EXCEPTION.setCPL(JAVA_EXCEPTION, ERROR, SERIOUS_CONDITION, CONDITION,
548                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
549    JAVA_EXCEPTION.setDirectSlotDefinitions(
550      list(new SlotDefinition(Symbol.CAUSE, list(Symbol.JAVA_EXCEPTION_CAUSE))));
551    METHOD.setCPL(METHOD, STANDARD_OBJECT, BuiltInClass.CLASS_T);
552    PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
553                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
554    PACKAGE_ERROR.setDirectSlotDefinitions(
555      list(new SlotDefinition(Symbol.PACKAGE,
556                               list(PACKAGE_CL.intern("PACKAGE-ERROR-PACKAGE")))));
557    PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
558                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
559    PRINT_NOT_READABLE.setCPL(PRINT_NOT_READABLE, ERROR, SERIOUS_CONDITION,
560                              CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
561    PRINT_NOT_READABLE.setDirectSlotDefinitions(
562      list(new SlotDefinition(Symbol.OBJECT,
563                               list(PACKAGE_CL.intern("PRINT-NOT-READABLE-OBJECT")))));
564    PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
565                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
566    READER_ERROR.setCPL(READER_ERROR, PARSE_ERROR, STREAM_ERROR, ERROR,
567                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
568                        BuiltInClass.CLASS_T);
569    SERIOUS_CONDITION.setCPL(SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
570                             BuiltInClass.CLASS_T);
571    SIMPLE_CONDITION.setCPL(SIMPLE_CONDITION, CONDITION, STANDARD_OBJECT,
572                            BuiltInClass.CLASS_T);
573    SIMPLE_ERROR.setCPL(SIMPLE_ERROR, SIMPLE_CONDITION, ERROR,
574                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
575                        BuiltInClass.CLASS_T);
576    SIMPLE_TYPE_ERROR.setDirectSuperclasses(list(SIMPLE_CONDITION,
577                                                  TYPE_ERROR));
578    SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
579                             TYPE_ERROR, ERROR, SERIOUS_CONDITION,
580                             CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
581    SIMPLE_WARNING.setDirectSuperclasses(list(SIMPLE_CONDITION, WARNING));
582    SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
583                          CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
584    STANDARD_CLASS.setCPL(STANDARD_CLASS, CLASS,
585                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
586    STANDARD_OBJECT.setCPL(STANDARD_OBJECT, BuiltInClass.CLASS_T);
587    STORAGE_CONDITION.setCPL(STORAGE_CONDITION, SERIOUS_CONDITION, CONDITION,
588                             STANDARD_OBJECT, BuiltInClass.CLASS_T);
589    STREAM_ERROR.setCPL(STREAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
590                        STANDARD_OBJECT, BuiltInClass.CLASS_T);
591    STREAM_ERROR.setDirectSlotDefinitions(
592      list(new SlotDefinition(Symbol.STREAM,
593                               list(PACKAGE_CL.intern("STREAM-ERROR-STREAM")))));
594    STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
595                           BuiltInClass.CLASS_T);
596    STYLE_WARNING.setCPL(STYLE_WARNING, WARNING, CONDITION, STANDARD_OBJECT,
597                         BuiltInClass.CLASS_T);
598    TYPE_ERROR.setCPL(TYPE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
599                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
600    TYPE_ERROR.setDirectSlotDefinitions(
601      list(new SlotDefinition(Symbol.DATUM,
602                               list(PACKAGE_CL.intern("TYPE-ERROR-DATUM"))),
603            new SlotDefinition(Symbol.EXPECTED_TYPE,
604                               list(PACKAGE_CL.intern("TYPE-ERROR-EXPECTED-TYPE")))));
605    UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR, SERIOUS_CONDITION,
606                        CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
607    UNBOUND_SLOT.setDirectSlotDefinitions(
608      list(new SlotDefinition(Symbol.INSTANCE,
609                               list(PACKAGE_CL.intern("UNBOUND-SLOT-INSTANCE")))));
610    UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
611                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
612                            BuiltInClass.CLASS_T);
613    UNDEFINED_FUNCTION.setCPL(UNDEFINED_FUNCTION, CELL_ERROR, ERROR,
614                              SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
615                              BuiltInClass.CLASS_T);
616    WARNING.setCPL(WARNING, CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
617
618    // Condition classes.
619    ARITHMETIC_ERROR.finalizeClass();
620    CELL_ERROR.finalizeClass();
621    COMPILER_ERROR.finalizeClass();
622    COMPILER_UNSUPPORTED_FEATURE_ERROR.finalizeClass();
623    CONDITION.finalizeClass();
624    CONTROL_ERROR.finalizeClass();
625    DIVISION_BY_ZERO.finalizeClass();
626    END_OF_FILE.finalizeClass();
627    ERROR.finalizeClass();
628    FILE_ERROR.finalizeClass();
629    FLOATING_POINT_INEXACT.finalizeClass();
630    FLOATING_POINT_INVALID_OPERATION.finalizeClass();
631    FLOATING_POINT_OVERFLOW.finalizeClass();
632    FLOATING_POINT_UNDERFLOW.finalizeClass();
633    JAVA_EXCEPTION.finalizeClass();
634    PACKAGE_ERROR.finalizeClass();
635    PARSE_ERROR.finalizeClass();
636    PRINT_NOT_READABLE.finalizeClass();
637    PROGRAM_ERROR.finalizeClass();
638    READER_ERROR.finalizeClass();
639    SERIOUS_CONDITION.finalizeClass();
640    SIMPLE_CONDITION.finalizeClass();
641    SIMPLE_ERROR.finalizeClass();
642    SIMPLE_TYPE_ERROR.finalizeClass();
643    SIMPLE_WARNING.finalizeClass();
644    STORAGE_CONDITION.finalizeClass();
645    STREAM_ERROR.finalizeClass();
646    STYLE_WARNING.finalizeClass();
647    TYPE_ERROR.finalizeClass();
648    UNBOUND_SLOT.finalizeClass();
649    UNBOUND_VARIABLE.finalizeClass();
650    UNDEFINED_FUNCTION.finalizeClass();
651    WARNING.finalizeClass();
652
653    // SYS:SLOT-DEFINITION is constructed and finalized in
654    // SlotDefinitionClass.java, but we need to fill in a few things here.
655    Debug.assertTrue(SLOT_DEFINITION.isFinalized());
656    SLOT_DEFINITION.setCPL(SLOT_DEFINITION, STANDARD_OBJECT,
657                           BuiltInClass.CLASS_T);
658    SLOT_DEFINITION.setDirectSlotDefinitions(SLOT_DEFINITION.getClassLayout().generateSlotDefinitions());
659    // There are no inherited slots.
660    SLOT_DEFINITION.setSlotDefinitions(SLOT_DEFINITION.getDirectSlotDefinitions());
661
662    // STANDARD-METHOD
663    Debug.assertTrue(STANDARD_METHOD.isFinalized());
664    STANDARD_METHOD.setCPL(STANDARD_METHOD, METHOD, STANDARD_OBJECT,
665                           BuiltInClass.CLASS_T);
666    STANDARD_METHOD.setDirectSlotDefinitions(STANDARD_METHOD.getClassLayout().generateSlotDefinitions());
667    // There are no inherited slots.
668    STANDARD_METHOD.setSlotDefinitions(STANDARD_METHOD.getDirectSlotDefinitions());
669
670    // STANDARD-READER-METHOD
671    Debug.assertTrue(STANDARD_READER_METHOD.isFinalized());
672    STANDARD_READER_METHOD.setCPL(STANDARD_READER_METHOD, STANDARD_METHOD,
673                                  METHOD, STANDARD_OBJECT, BuiltInClass.CLASS_T);
674    STANDARD_READER_METHOD.setSlotDefinitions(STANDARD_READER_METHOD.getClassLayout().generateSlotDefinitions());
675    // All but the last slot are inherited.
676    STANDARD_READER_METHOD.setDirectSlotDefinitions(list(STANDARD_READER_METHOD.getSlotDefinitions().reverse().car()));
677
678    // STANDARD-GENERIC-FUNCTION
679    Debug.assertTrue(STANDARD_GENERIC_FUNCTION.isFinalized());
680    STANDARD_GENERIC_FUNCTION.setCPL(STANDARD_GENERIC_FUNCTION,
681                                     GENERIC_FUNCTION, STANDARD_OBJECT,
682                                     BuiltInClass.FUNCTION,
683                                     BuiltInClass.CLASS_T);
684    STANDARD_GENERIC_FUNCTION.setDirectSlotDefinitions(STANDARD_GENERIC_FUNCTION.getClassLayout().generateSlotDefinitions());
685    // There are no inherited slots.
686    STANDARD_GENERIC_FUNCTION.setSlotDefinitions(STANDARD_GENERIC_FUNCTION.getDirectSlotDefinitions());
687  }
688}
Note: See TracBrowser for help on using the repository browser.