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

Last change on this file was 12620, checked in by Mark Evenson, 15 years ago

Use interpreted form in a FASL if compliation fails.

INTERNAL-COMPILER-ERROR now signals that the form being compiled
should be written to the init FASL to be interpreted rather than being
the object of a SYSTEm:PROXY-PRELOADED-FUNCTION. A further
optimization of this strategy would be to actually not include the
failed compilation unit in the packed FASL.

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