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