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

Last change on this file was 12254, checked in by ehuelsmann, 16 years ago

Remove 'throws ConditionThrowable?' method annotations:

it's an unchecked exception now, so no need to declare it thrown.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 21.6 KB
Line 
1/*
2 * StandardClass.java
3 *
4 * Copyright (C) 2003-2005 Peter Graves
5 * $Id: StandardClass.java 12254 2009-11-06 20:07:54Z 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
36public class StandardClass extends SlotClass
37{
38  public StandardClass()
39  {
40    setClassLayout(new Layout(this, NIL, NIL));
41  }
42
43  public StandardClass(Symbol symbol, LispObject directSuperclasses)
44  {
45    super(symbol, directSuperclasses);
46    setClassLayout(new Layout(this, NIL, NIL));
47  }
48
49  @Override
50  public LispObject typeOf()
51  {
52    return Symbol.STANDARD_CLASS;
53  }
54
55  @Override
56  public LispObject classOf()
57  {
58    return STANDARD_CLASS;
59  }
60
61  @Override
62  public LispObject typep(LispObject type)
63  {
64    if (type == Symbol.STANDARD_CLASS)
65      return T;
66    if (type == STANDARD_CLASS)
67      return T;
68    return super.typep(type);
69  }
70
71  public LispObject allocateInstance()
72  {
73    Layout layout = getClassLayout();
74    if (layout == null)
75      {
76        Symbol.ERROR.execute(Symbol.SIMPLE_ERROR,
77                             Keyword.FORMAT_CONTROL,
78                             new SimpleString("No layout for class ~S."),
79                             Keyword.FORMAT_ARGUMENTS,
80                             list(this));
81      }
82    return new StandardObject(this, layout.getLength());
83  }
84
85  @Override
86  public String writeToString()
87  {
88    FastStringBuffer sb =
89      new FastStringBuffer(Symbol.STANDARD_CLASS.writeToString());
90    if (symbol != null)
91      {
92        sb.append(' ');
93        sb.append(symbol.writeToString());
94      }
95    return unreadableString(sb.toString());
96  }
97
98  private static final StandardClass addStandardClass(Symbol name,
99                                                      LispObject directSuperclasses)
100  {
101    StandardClass c = new StandardClass(name, directSuperclasses);
102    addClass(name, c);
103    return c;
104  }
105
106  // At this point, BuiltInClass.java has not been completely loaded yet, and
107  // BuiltInClass.CLASS_T is null. So we need to call setDirectSuperclass()
108  // for STANDARD_CLASS and STANDARD_OBJECT in initializeStandardClasses()
109  // below.
110  public static final StandardClass STANDARD_CLASS =
111    addStandardClass(Symbol.STANDARD_CLASS, list(BuiltInClass.CLASS_T));
112  public static final StandardClass STANDARD_OBJECT =
113    addStandardClass(Symbol.STANDARD_OBJECT, list(BuiltInClass.CLASS_T));
114
115  // BuiltInClass.FUNCTION is also null here (see previous comment).
116  public static final StandardClass GENERIC_FUNCTION =
117    addStandardClass(Symbol.GENERIC_FUNCTION, list(BuiltInClass.FUNCTION,
118                                                    STANDARD_OBJECT));
119
120  public static final StandardClass CLASS =
121    addStandardClass(Symbol.CLASS, list(STANDARD_OBJECT));
122
123  public static final StandardClass BUILT_IN_CLASS =
124    addStandardClass(Symbol.BUILT_IN_CLASS, list(CLASS));
125
126  public static final StandardClass JAVA_CLASS =
127      addStandardClass(Symbol.JAVA_CLASS, list(CLASS));
128 
129  public static final StandardClass FORWARD_REFERENCED_CLASS =
130    addStandardClass(Symbol.FORWARD_REFERENCED_CLASS, list(CLASS));
131
132  public static final StandardClass STRUCTURE_CLASS =
133    addStandardClass(Symbol.STRUCTURE_CLASS, list(CLASS));
134
135  public static final StandardClass CONDITION =
136    addStandardClass(Symbol.CONDITION, list(STANDARD_OBJECT));
137
138  public static final StandardClass SIMPLE_CONDITION =
139    addStandardClass(Symbol.SIMPLE_CONDITION, list(CONDITION));
140
141  public static final StandardClass WARNING =
142    addStandardClass(Symbol.WARNING, list(CONDITION));
143
144  public static final StandardClass SIMPLE_WARNING =
145    addStandardClass(Symbol.SIMPLE_WARNING, list(SIMPLE_CONDITION, WARNING));
146
147  public static final StandardClass STYLE_WARNING =
148    addStandardClass(Symbol.STYLE_WARNING, list(WARNING));
149
150  public static final StandardClass SERIOUS_CONDITION =
151    addStandardClass(Symbol.SERIOUS_CONDITION, list(CONDITION));
152
153  public static final StandardClass STORAGE_CONDITION =
154    addStandardClass(Symbol.STORAGE_CONDITION, list(SERIOUS_CONDITION));
155
156  public static final StandardClass ERROR =
157    addStandardClass(Symbol.ERROR, list(SERIOUS_CONDITION));
158
159  public static final StandardClass ARITHMETIC_ERROR =
160    addStandardClass(Symbol.ARITHMETIC_ERROR, list(ERROR));
161
162  public static final StandardClass CELL_ERROR =
163    addStandardClass(Symbol.CELL_ERROR, list(ERROR));
164
165  public static final StandardClass CONTROL_ERROR =
166    addStandardClass(Symbol.CONTROL_ERROR, list(ERROR));
167
168  public static final StandardClass FILE_ERROR =
169    addStandardClass(Symbol.FILE_ERROR, list(ERROR));
170
171  public static final StandardClass DIVISION_BY_ZERO =
172    addStandardClass(Symbol.DIVISION_BY_ZERO, list(ARITHMETIC_ERROR));
173
174  public static final StandardClass FLOATING_POINT_INEXACT =
175    addStandardClass(Symbol.FLOATING_POINT_INEXACT, list(ARITHMETIC_ERROR));
176
177  public static final StandardClass FLOATING_POINT_INVALID_OPERATION =
178    addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list(ARITHMETIC_ERROR));
179
180  public static final StandardClass FLOATING_POINT_OVERFLOW =
181    addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list(ARITHMETIC_ERROR));
182
183  public static final StandardClass FLOATING_POINT_UNDERFLOW =
184    addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list(ARITHMETIC_ERROR));
185
186  public static final StandardClass PROGRAM_ERROR =
187    addStandardClass(Symbol.PROGRAM_ERROR, list(ERROR));
188
189  public static final StandardClass PACKAGE_ERROR =
190    addStandardClass(Symbol.PACKAGE_ERROR, list(ERROR));
191
192  public static final StandardClass STREAM_ERROR =
193    addStandardClass(Symbol.STREAM_ERROR, list(ERROR));
194
195  public static final StandardClass PARSE_ERROR =
196    addStandardClass(Symbol.PARSE_ERROR, list(ERROR));
197
198  public static final StandardClass PRINT_NOT_READABLE =
199    addStandardClass(Symbol.PRINT_NOT_READABLE, list(ERROR));
200
201  public static final StandardClass READER_ERROR =
202    addStandardClass(Symbol.READER_ERROR, list(PARSE_ERROR, STREAM_ERROR));
203
204  public static final StandardClass END_OF_FILE =
205    addStandardClass(Symbol.END_OF_FILE, list(STREAM_ERROR));
206
207  public static final StandardClass SIMPLE_ERROR =
208    addStandardClass(Symbol.SIMPLE_ERROR, list(SIMPLE_CONDITION, ERROR));
209
210  public static final StandardClass TYPE_ERROR =
211    addStandardClass(Symbol.TYPE_ERROR, list(ERROR));
212
213  public static final StandardClass SIMPLE_TYPE_ERROR =
214    addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list(SIMPLE_CONDITION,
215                                                     TYPE_ERROR));
216
217  public static final StandardClass UNBOUND_SLOT =
218    addStandardClass(Symbol.UNBOUND_SLOT, list(CELL_ERROR));
219
220  public static final StandardClass UNBOUND_VARIABLE =
221    addStandardClass(Symbol.UNBOUND_VARIABLE, list(CELL_ERROR));
222
223  public static final StandardClass UNDEFINED_FUNCTION =
224    addStandardClass(Symbol.UNDEFINED_FUNCTION, list(CELL_ERROR));
225
226  public static final StandardClass COMPILER_ERROR =
227    addStandardClass(Symbol.COMPILER_ERROR, list(CONDITION));
228
229  public static final StandardClass COMPILER_UNSUPPORTED_FEATURE_ERROR =
230    addStandardClass(Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR,
231                     list(CONDITION));
232
233  public static final StandardClass JAVA_EXCEPTION =
234    addStandardClass(Symbol.JAVA_EXCEPTION, list(ERROR));
235
236  public static final StandardClass METHOD =
237    addStandardClass(Symbol.METHOD, list(STANDARD_OBJECT));
238
239  public static final StandardClass STANDARD_METHOD =
240    new StandardMethodClass();
241  static
242  {
243    addClass(Symbol.STANDARD_METHOD, STANDARD_METHOD);
244  }
245
246  public static final StandardClass STANDARD_READER_METHOD =
247    new StandardReaderMethodClass();
248  static
249  {
250    addClass(Symbol.STANDARD_READER_METHOD, STANDARD_READER_METHOD);
251  }
252
253  public static final StandardClass STANDARD_GENERIC_FUNCTION =
254    new StandardGenericFunctionClass();
255  static
256  {
257    addClass(Symbol.STANDARD_GENERIC_FUNCTION, STANDARD_GENERIC_FUNCTION);
258  }
259
260  public static final StandardClass SLOT_DEFINITION =
261    new SlotDefinitionClass();
262  static
263  {
264    addClass(Symbol.SLOT_DEFINITION, SLOT_DEFINITION);
265  }
266
267  public static void initializeStandardClasses()
268  {
269    // We need to call setDirectSuperclass() here for classes that have a
270    // BuiltInClass as a superclass. See comment above (at first mention of
271    // STANDARD_OBJECT).
272    STANDARD_CLASS.setDirectSuperclass(CLASS);
273    STANDARD_OBJECT.setDirectSuperclass(BuiltInClass.CLASS_T);
274    GENERIC_FUNCTION.setDirectSuperclasses(list(BuiltInClass.FUNCTION,
275                                                 STANDARD_OBJECT));
276
277    ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION,
278                            CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
279    ARITHMETIC_ERROR.setDirectSlotDefinitions(
280      list(new SlotDefinition(Symbol.OPERATION,
281                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERATION"))),
282            new SlotDefinition(Symbol.OPERANDS,
283                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERANDS")))));
284    BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
285                          BuiltInClass.CLASS_T);
286    JAVA_CLASS.setCPL(JAVA_CLASS, CLASS, STANDARD_OBJECT,
287            BuiltInClass.CLASS_T);
288    CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
289                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
290    CELL_ERROR.setDirectSlotDefinitions(
291      list(new SlotDefinition(Symbol.NAME,
292                               list(Symbol.CELL_ERROR_NAME))));
293    CLASS.setCPL(CLASS, STANDARD_OBJECT, BuiltInClass.CLASS_T);
294    COMPILER_ERROR.setCPL(COMPILER_ERROR, CONDITION, STANDARD_OBJECT,
295                          BuiltInClass.CLASS_T);
296    COMPILER_UNSUPPORTED_FEATURE_ERROR.setCPL(COMPILER_UNSUPPORTED_FEATURE_ERROR,
297                                              CONDITION, STANDARD_OBJECT,
298                                              BuiltInClass.CLASS_T);
299    CONDITION.setCPL(CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
300    CONDITION.setDirectSlotDefinitions(
301      list(new SlotDefinition(Symbol.FORMAT_CONTROL,
302                               list(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
303            new SlotDefinition(Symbol.FORMAT_ARGUMENTS,
304                               list(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
305                               NIL)));
306    CONDITION.setDirectDefaultInitargs(list(Keyword.FORMAT_ARGUMENTS,
307                                             // FIXME
308                                             new Closure(list(Symbol.LAMBDA, NIL, NIL),
309                                                         new Environment())));
310    CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
311                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
312    DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR, ERROR,
313                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
314                            BuiltInClass.CLASS_T);
315    END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR, SERIOUS_CONDITION,
316                       CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
317    ERROR.setCPL(ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
318                 BuiltInClass.CLASS_T);
319    FILE_ERROR.setCPL(FILE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
320                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
321    FILE_ERROR.setDirectSlotDefinitions(
322      list(new SlotDefinition(Symbol.PATHNAME,
323                               list(PACKAGE_CL.intern("FILE-ERROR-PATHNAME")))));
324    FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT, ARITHMETIC_ERROR,
325                                  ERROR, SERIOUS_CONDITION, CONDITION,
326                                  STANDARD_OBJECT, BuiltInClass.CLASS_T);
327    FLOATING_POINT_INVALID_OPERATION.setCPL(FLOATING_POINT_INVALID_OPERATION,
328                                            ARITHMETIC_ERROR, ERROR,
329                                            SERIOUS_CONDITION, CONDITION,
330                                            STANDARD_OBJECT, BuiltInClass.CLASS_T);
331    FLOATING_POINT_OVERFLOW.setCPL(FLOATING_POINT_OVERFLOW, ARITHMETIC_ERROR,
332                                   ERROR, SERIOUS_CONDITION, CONDITION,
333                                   STANDARD_OBJECT, BuiltInClass.CLASS_T);
334    FLOATING_POINT_UNDERFLOW.setCPL(FLOATING_POINT_UNDERFLOW, ARITHMETIC_ERROR,
335                                    ERROR, SERIOUS_CONDITION, CONDITION,
336                                    STANDARD_OBJECT, BuiltInClass.CLASS_T);
337    FORWARD_REFERENCED_CLASS.setCPL(FORWARD_REFERENCED_CLASS, CLASS,
338                                    BuiltInClass.CLASS_T);
339    GENERIC_FUNCTION.setCPL(GENERIC_FUNCTION, STANDARD_OBJECT,
340                            BuiltInClass.FUNCTION,
341                            BuiltInClass.CLASS_T);
342    JAVA_EXCEPTION.setCPL(JAVA_EXCEPTION, ERROR, SERIOUS_CONDITION, CONDITION,
343                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
344    JAVA_EXCEPTION.setDirectSlotDefinitions(
345      list(new SlotDefinition(Symbol.CAUSE, list(Symbol.JAVA_EXCEPTION_CAUSE))));
346    METHOD.setCPL(METHOD, STANDARD_OBJECT, BuiltInClass.CLASS_T);
347    PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
348                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
349    PACKAGE_ERROR.setDirectSlotDefinitions(
350      list(new SlotDefinition(Symbol.PACKAGE,
351                               list(PACKAGE_CL.intern("PACKAGE-ERROR-PACKAGE")))));
352    PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
353                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
354    PRINT_NOT_READABLE.setCPL(PRINT_NOT_READABLE, ERROR, SERIOUS_CONDITION,
355                              CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
356    PRINT_NOT_READABLE.setDirectSlotDefinitions(
357      list(new SlotDefinition(Symbol.OBJECT,
358                               list(PACKAGE_CL.intern("PRINT-NOT-READABLE-OBJECT")))));
359    PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
360                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
361    READER_ERROR.setCPL(READER_ERROR, PARSE_ERROR, STREAM_ERROR, ERROR,
362                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
363                        BuiltInClass.CLASS_T);
364    SERIOUS_CONDITION.setCPL(SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
365                             BuiltInClass.CLASS_T);
366    SIMPLE_CONDITION.setCPL(SIMPLE_CONDITION, CONDITION, STANDARD_OBJECT,
367                            BuiltInClass.CLASS_T);
368    SIMPLE_ERROR.setCPL(SIMPLE_ERROR, SIMPLE_CONDITION, ERROR,
369                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
370                        BuiltInClass.CLASS_T);
371    SIMPLE_TYPE_ERROR.setDirectSuperclasses(list(SIMPLE_CONDITION,
372                                                  TYPE_ERROR));
373    SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
374                             TYPE_ERROR, ERROR, SERIOUS_CONDITION,
375                             CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
376    SIMPLE_WARNING.setDirectSuperclasses(list(SIMPLE_CONDITION, WARNING));
377    SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
378                          CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
379    STANDARD_CLASS.setCPL(STANDARD_CLASS, CLASS,
380                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
381    STANDARD_OBJECT.setCPL(STANDARD_OBJECT, BuiltInClass.CLASS_T);
382    STORAGE_CONDITION.setCPL(STORAGE_CONDITION, SERIOUS_CONDITION, CONDITION,
383                             STANDARD_OBJECT, BuiltInClass.CLASS_T);
384    STREAM_ERROR.setCPL(STREAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
385                        STANDARD_OBJECT, BuiltInClass.CLASS_T);
386    STREAM_ERROR.setDirectSlotDefinitions(
387      list(new SlotDefinition(Symbol.STREAM,
388                               list(PACKAGE_CL.intern("STREAM-ERROR-STREAM")))));
389    STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
390                           BuiltInClass.CLASS_T);
391    STYLE_WARNING.setCPL(STYLE_WARNING, WARNING, CONDITION, STANDARD_OBJECT,
392                         BuiltInClass.CLASS_T);
393    TYPE_ERROR.setCPL(TYPE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
394                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
395    TYPE_ERROR.setDirectSlotDefinitions(
396      list(new SlotDefinition(Symbol.DATUM,
397                               list(PACKAGE_CL.intern("TYPE-ERROR-DATUM"))),
398            new SlotDefinition(Symbol.EXPECTED_TYPE,
399                               list(PACKAGE_CL.intern("TYPE-ERROR-EXPECTED-TYPE")))));
400    UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR, SERIOUS_CONDITION,
401                        CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
402    UNBOUND_SLOT.setDirectSlotDefinitions(
403      list(new SlotDefinition(Symbol.INSTANCE,
404                               list(PACKAGE_CL.intern("UNBOUND-SLOT-INSTANCE")))));
405    UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
406                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
407                            BuiltInClass.CLASS_T);
408    UNDEFINED_FUNCTION.setCPL(UNDEFINED_FUNCTION, CELL_ERROR, ERROR,
409                              SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
410                              BuiltInClass.CLASS_T);
411    WARNING.setCPL(WARNING, CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
412
413    // Condition classes.
414    ARITHMETIC_ERROR.finalizeClass();
415    CELL_ERROR.finalizeClass();
416    COMPILER_ERROR.finalizeClass();
417    COMPILER_UNSUPPORTED_FEATURE_ERROR.finalizeClass();
418    CONDITION.finalizeClass();
419    CONTROL_ERROR.finalizeClass();
420    DIVISION_BY_ZERO.finalizeClass();
421    END_OF_FILE.finalizeClass();
422    ERROR.finalizeClass();
423    FILE_ERROR.finalizeClass();
424    FLOATING_POINT_INEXACT.finalizeClass();
425    FLOATING_POINT_INVALID_OPERATION.finalizeClass();
426    FLOATING_POINT_OVERFLOW.finalizeClass();
427    FLOATING_POINT_UNDERFLOW.finalizeClass();
428    JAVA_EXCEPTION.finalizeClass();
429    PACKAGE_ERROR.finalizeClass();
430    PARSE_ERROR.finalizeClass();
431    PRINT_NOT_READABLE.finalizeClass();
432    PROGRAM_ERROR.finalizeClass();
433    READER_ERROR.finalizeClass();
434    SERIOUS_CONDITION.finalizeClass();
435    SIMPLE_CONDITION.finalizeClass();
436    SIMPLE_ERROR.finalizeClass();
437    SIMPLE_TYPE_ERROR.finalizeClass();
438    SIMPLE_WARNING.finalizeClass();
439    STORAGE_CONDITION.finalizeClass();
440    STREAM_ERROR.finalizeClass();
441    STYLE_WARNING.finalizeClass();
442    TYPE_ERROR.finalizeClass();
443    UNBOUND_SLOT.finalizeClass();
444    UNBOUND_VARIABLE.finalizeClass();
445    UNDEFINED_FUNCTION.finalizeClass();
446    WARNING.finalizeClass();
447
448    // SYS:SLOT-DEFINITION is constructed and finalized in
449    // SlotDefinitionClass.java, but we need to fill in a few things here.
450    Debug.assertTrue(SLOT_DEFINITION.isFinalized());
451    SLOT_DEFINITION.setCPL(SLOT_DEFINITION, STANDARD_OBJECT,
452                           BuiltInClass.CLASS_T);
453    SLOT_DEFINITION.setDirectSlotDefinitions(SLOT_DEFINITION.getClassLayout().generateSlotDefinitions());
454    // There are no inherited slots.
455    SLOT_DEFINITION.setSlotDefinitions(SLOT_DEFINITION.getDirectSlotDefinitions());
456
457    // STANDARD-METHOD
458    Debug.assertTrue(STANDARD_METHOD.isFinalized());
459    STANDARD_METHOD.setCPL(STANDARD_METHOD, METHOD, STANDARD_OBJECT,
460                           BuiltInClass.CLASS_T);
461    STANDARD_METHOD.setDirectSlotDefinitions(STANDARD_METHOD.getClassLayout().generateSlotDefinitions());
462    // There are no inherited slots.
463    STANDARD_METHOD.setSlotDefinitions(STANDARD_METHOD.getDirectSlotDefinitions());
464
465    // STANDARD-READER-METHOD
466    Debug.assertTrue(STANDARD_READER_METHOD.isFinalized());
467    STANDARD_READER_METHOD.setCPL(STANDARD_READER_METHOD, STANDARD_METHOD,
468                                  METHOD, STANDARD_OBJECT, BuiltInClass.CLASS_T);
469    STANDARD_READER_METHOD.setSlotDefinitions(STANDARD_READER_METHOD.getClassLayout().generateSlotDefinitions());
470    // All but the last slot are inherited.
471    STANDARD_READER_METHOD.setDirectSlotDefinitions(list(STANDARD_READER_METHOD.getSlotDefinitions().reverse().car()));
472
473    // STANDARD-GENERIC-FUNCTION
474    Debug.assertTrue(STANDARD_GENERIC_FUNCTION.isFinalized());
475    STANDARD_GENERIC_FUNCTION.setCPL(STANDARD_GENERIC_FUNCTION,
476                                     GENERIC_FUNCTION, STANDARD_OBJECT,
477                                     BuiltInClass.FUNCTION,
478                                     BuiltInClass.CLASS_T);
479    STANDARD_GENERIC_FUNCTION.setDirectSlotDefinitions(STANDARD_GENERIC_FUNCTION.getClassLayout().generateSlotDefinitions());
480    // There are no inherited slots.
481    STANDARD_GENERIC_FUNCTION.setSlotDefinitions(STANDARD_GENERIC_FUNCTION.getDirectSlotDefinitions());
482  }
483}
Note: See TracBrowser for help on using the repository browser.