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

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

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