|
1
21
22 package org.armedbear.lisp;
23
24 public class BuiltInClass extends LispClass
25 {
26 private BuiltInClass(Symbol symbol)
27 {
28 super(symbol);
29 }
30
31 public LispObject typeOf()
32 {
33 return Symbol.BUILT_IN_CLASS;
34 }
35
36 public LispClass classOf()
37 {
38 return BuiltInClass.BUILT_IN_CLASS;
39 }
40
41 public LispObject typep(LispObject type) throws ConditionThrowable
42 {
43 if (type == Symbol.BUILT_IN_CLASS)
44 return T;
45 if (type == BuiltInClass.BUILT_IN_CLASS)
46 return T;
47 return super.typep(type);
48 }
49
50 public LispObject getDescription() throws ConditionThrowable
51 {
52 return new SimpleString(writeToString());
53 }
54
55 public String  writeToString() throws ConditionThrowable
56 {
57 StringBuffer sb = new StringBuffer ("#<BUILT-IN-CLASS ");
58 sb.append(symbol.writeToString());
59 sb.append('>');
60 return sb.toString();
61 }
62
63 private static BuiltInClass addClass(Symbol symbol)
64 {
65 BuiltInClass c = new BuiltInClass(symbol);
66 addClass(symbol, c);
67 return c;
68 }
69
70 public static final BuiltInClass CLASS_T = addClass(T);
71
72 public static final BuiltInClass ARRAY = addClass(Symbol.ARRAY);
73 public static final BuiltInClass BIGNUM = addClass(Symbol.BIGNUM);
74 public static final BuiltInClass BIT_VECTOR = addClass(Symbol.BIT_VECTOR);
75 public static final BuiltInClass BROADCAST_STREAM = addClass(Symbol.BROADCAST_STREAM);
76 public static final BuiltInClass BUILT_IN_CLASS = addClass(Symbol.BUILT_IN_CLASS);
77 public static final BuiltInClass CASE_FROB_STREAM = addClass(Symbol.CASE_FROB_STREAM);
78 public static final BuiltInClass CHARACTER = addClass(Symbol.CHARACTER);
79 public static final BuiltInClass CLASS = addClass(Symbol.CLASS);
80 public static final BuiltInClass COMPLEX = addClass(Symbol.COMPLEX);
81 public static final BuiltInClass CONCATENATED_STREAM = addClass(Symbol.CONCATENATED_STREAM);
82 public static final BuiltInClass CONS = addClass(Symbol.CONS);
83 public static final BuiltInClass DIVISION_BY_ZERO = addClass(Symbol.DIVISION_BY_ZERO);
84 public static final BuiltInClass ECHO_STREAM = addClass(Symbol.ECHO_STREAM);
85 public static final BuiltInClass END_OF_FILE = addClass(Symbol.END_OF_FILE);
86 public static final BuiltInClass FILE_STREAM = addClass(Symbol.FILE_STREAM);
87 public static final BuiltInClass FIXNUM = addClass(Symbol.FIXNUM);
88 public static final BuiltInClass FLOAT = addClass(Symbol.FLOAT);
89 public static final BuiltInClass FLOATING_POINT_INEXACT = addClass(Symbol.FLOATING_POINT_INEXACT);
90 public static final BuiltInClass FLOATING_POINT_INVALID_OPERATION = addClass(Symbol.FLOATING_POINT_INVALID_OPERATION);
91 public static final BuiltInClass FLOATING_POINT_OVERFLOW = addClass(Symbol.FLOATING_POINT_OVERFLOW);
92 public static final BuiltInClass FLOATING_POINT_UNDERFLOW = addClass(Symbol.FLOATING_POINT_UNDERFLOW);
93 public static final BuiltInClass FUNCTION = addClass(Symbol.FUNCTION);
94 public static final BuiltInClass HASH_TABLE = addClass(Symbol.HASH_TABLE);
95 public static final BuiltInClass INTEGER = addClass(Symbol.INTEGER);
96 public static final BuiltInClass LIST = addClass(Symbol.LIST);
97 public static final BuiltInClass LOGICAL_PATHNAME = addClass(Symbol.LOGICAL_PATHNAME);
98 public static final BuiltInClass METHOD_COMBINATION = addClass(Symbol.METHOD_COMBINATION);
99 public static final BuiltInClass NIL_VECTOR = addClass(Symbol.NIL_VECTOR);
100 public static final BuiltInClass NULL = addClass(Symbol.NULL);
101 public static final BuiltInClass NUMBER = addClass(Symbol.NUMBER);
102 public static final BuiltInClass PACKAGE = addClass(Symbol.PACKAGE);
103 public static final BuiltInClass PATHNAME = addClass(Symbol.PATHNAME);
104 public static final BuiltInClass PRINT_NOT_READABLE = addClass(Symbol.PRINT_NOT_READABLE);
105 public static final BuiltInClass RANDOM_STATE = addClass(Symbol.RANDOM_STATE);
106 public static final BuiltInClass RATIO = addClass(Symbol.RATIO);
107 public static final BuiltInClass RATIONAL = addClass(Symbol.RATIONAL);
108 public static final BuiltInClass READTABLE = addClass(Symbol.READTABLE);
109 public static final BuiltInClass REAL = addClass(Symbol.REAL);
110 public static final BuiltInClass RESTART = addClass(Symbol.RESTART);
111 public static final BuiltInClass SEQUENCE = addClass(Symbol.SEQUENCE);
112 public static final BuiltInClass SIMPLE_ARRAY = addClass(Symbol.SIMPLE_ARRAY);
113 public static final BuiltInClass SIMPLE_BIT_VECTOR = addClass(Symbol.SIMPLE_BIT_VECTOR);
114 public static final BuiltInClass SIMPLE_ERROR = addClass(Symbol.SIMPLE_ERROR);
115 public static final BuiltInClass SIMPLE_STRING = addClass(Symbol.SIMPLE_STRING);
116 public static final BuiltInClass SIMPLE_VECTOR = addClass(Symbol.SIMPLE_VECTOR);
117 public static final BuiltInClass SIMPLE_TYPE_ERROR = addClass(Symbol.SIMPLE_TYPE_ERROR);
118 public static final BuiltInClass SOCKET_STREAM = addClass(Symbol.SOCKET_STREAM);
119 public static final BuiltInClass STORAGE_CONDITION = addClass(Symbol.STORAGE_CONDITION);
120 public static final BuiltInClass STREAM = addClass(Symbol.STREAM);
121 public static final BuiltInClass STRING = addClass(Symbol.STRING);
122 public static final BuiltInClass STRING_INPUT_STREAM = addClass(Symbol.STRING_INPUT_STREAM);
123 public static final BuiltInClass STRING_OUTPUT_STREAM = addClass(Symbol.STRING_OUTPUT_STREAM);
124 public static final BuiltInClass STRING_STREAM = addClass(Symbol.STRING_STREAM);
125 public static final BuiltInClass STRUCTURE_CLASS = addClass(Symbol.STRUCTURE_CLASS);
126 public static final BuiltInClass STYLE_WARNING = addClass(Symbol.STYLE_WARNING);
127 public static final BuiltInClass SYMBOL = addClass(Symbol.SYMBOL);
128 public static final BuiltInClass SYNONYM_STREAM = addClass(Symbol.SYNONYM_STREAM);
129 public static final BuiltInClass TWO_WAY_STREAM = addClass(Symbol.TWO_WAY_STREAM);
130 public static final BuiltInClass VECTOR = addClass(Symbol.VECTOR);
131
132 public static final StructureClass STRUCTURE_OBJECT =
133 new StructureClass(Symbol.STRUCTURE_OBJECT, list1(CLASS_T));
134 static {
135 addClass(Symbol.STRUCTURE_OBJECT, STRUCTURE_OBJECT);
136 }
137
138 public static final StandardClass STANDARD_CLASS =
139 new StandardClass(Symbol.STANDARD_CLASS, list1(CLASS_T));
140 static {
141 addClass(Symbol.STANDARD_CLASS, STANDARD_CLASS);
142 }
143
144 public static final StandardClass STANDARD_OBJECT =
145 new StandardClass(Symbol.STANDARD_OBJECT, list1(CLASS_T));
146 static {
147 addClass(Symbol.STANDARD_OBJECT, STANDARD_OBJECT);
148 }
149
150 public static final StandardClass CONDITION =
151 new StandardClass(Symbol.CONDITION, list1(STANDARD_OBJECT));
152 static {
153 addClass(Symbol.CONDITION, CONDITION);
154 }
155
156 public static final StandardClass SIMPLE_CONDITION =
157 new StandardClass(Symbol.SIMPLE_CONDITION, list1(CONDITION));
158 static {
159 addClass(Symbol.SIMPLE_CONDITION, SIMPLE_CONDITION);
160 }
161
162 public static final StandardClass SERIOUS_CONDITION =
163 new StandardClass(Symbol.SERIOUS_CONDITION, list1(CONDITION));
164 static {
165 addClass(Symbol.SERIOUS_CONDITION, SERIOUS_CONDITION);
166 }
167
168 public static final StandardClass WARNING =
169 new StandardClass(Symbol.WARNING, list1(CONDITION));
170 static {
171 addClass(Symbol.WARNING, WARNING);
172 }
173
174 public static final StandardClass SIMPLE_WARNING =
175 new StandardClass(Symbol.SIMPLE_WARNING, list2(SIMPLE_CONDITION, WARNING));
176 static {
177 addClass(Symbol.SIMPLE_WARNING, SIMPLE_WARNING);
178 }
179
180 public static final StandardClass ERROR =
181 new StandardClass(Symbol.ERROR, list1(SERIOUS_CONDITION));
182 static {
183 addClass(Symbol.ERROR, ERROR);
184 }
185
186 public static final StandardClass ARITHMETIC_ERROR =
187 new StandardClass(Symbol.ARITHMETIC_ERROR, list1(ERROR));
188 static {
189 addClass(Symbol.ARITHMETIC_ERROR, ARITHMETIC_ERROR);
190 }
191
192 public static final StandardClass CELL_ERROR =
193 new StandardClass(Symbol.CELL_ERROR, list1(ERROR));
194 static {
195 addClass(Symbol.CELL_ERROR, CELL_ERROR);
196 }
197
198 public static final StandardClass UNBOUND_SLOT =
199 new StandardClass(Symbol.UNBOUND_SLOT, list1(CELL_ERROR));
200 static {
201 addClass(Symbol.UNBOUND_SLOT, UNBOUND_SLOT);
202 }
203
204 public static final StandardClass UNBOUND_VARIABLE =
205 new StandardClass(Symbol.UNBOUND_VARIABLE, list1(CELL_ERROR));
206 static {
207 addClass(Symbol.UNBOUND_VARIABLE, UNBOUND_VARIABLE);
208 }
209
210 public static final StandardClass UNDEFINED_FUNCTION =
211 new StandardClass(Symbol.UNDEFINED_FUNCTION, list1(CELL_ERROR));
212 static {
213 addClass(Symbol.UNDEFINED_FUNCTION, UNDEFINED_FUNCTION);
214 }
215
216 public static final StandardClass CONTROL_ERROR =
217 new StandardClass(Symbol.CONTROL_ERROR, list1(ERROR));
218 static {
219 addClass(Symbol.CONTROL_ERROR, CONTROL_ERROR);
220 }
221
222 public static final StandardClass FILE_ERROR =
223 new StandardClass(Symbol.FILE_ERROR, list1(ERROR));
224 static {
225 addClass(Symbol.FILE_ERROR, FILE_ERROR);
226 }
227
228 public static final StandardClass PACKAGE_ERROR =
229 new StandardClass(Symbol.PACKAGE_ERROR, list1(ERROR));
230 static {
231 addClass(Symbol.PACKAGE_ERROR, PACKAGE_ERROR);
232 }
233
234 public static final StandardClass PARSE_ERROR =
235 new StandardClass(Symbol.PARSE_ERROR, list1(ERROR));
236 static {
237 addClass(Symbol.PARSE_ERROR, PARSE_ERROR);
238 }
239
240 public static final StandardClass PROGRAM_ERROR =
241 new StandardClass(Symbol.PROGRAM_ERROR, list1(ERROR));
242 static {
243 addClass(Symbol.PROGRAM_ERROR, PROGRAM_ERROR);
244 }
245
246 public static final StandardClass STREAM_ERROR =
247 new StandardClass(Symbol.STREAM_ERROR, list1(ERROR));
248 static {
249 addClass(Symbol.STREAM_ERROR, STREAM_ERROR);
250 }
251
252 public static final StandardClass TYPE_ERROR =
253 new StandardClass(Symbol.TYPE_ERROR, list1(ERROR));
254 static {
255 addClass(Symbol.TYPE_ERROR, TYPE_ERROR);
256 }
257
258 public static final StandardClass READER_ERROR =
259 new StandardClass(Symbol.READER_ERROR, list2(PARSE_ERROR, STREAM_ERROR));
260 static {
261 addClass(Symbol.READER_ERROR, READER_ERROR);
262 }
263
264 public static final StandardClass GENERIC_FUNCTION =
265 new StandardClass(Symbol.GENERIC_FUNCTION, list2(FUNCTION, STANDARD_OBJECT));
266 static {
267 addClass(Symbol.GENERIC_FUNCTION, GENERIC_FUNCTION);
268 }
269
270 public static final StandardClass METHOD =
271 new StandardClass(Symbol.METHOD, list1(STANDARD_OBJECT));
272 static {
273 addClass(Symbol.METHOD, METHOD);
274 }
275
276 static {
277 ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION,
278 CONDITION, STANDARD_OBJECT, CLASS_T);
279 ARRAY.setDirectSuperclass(CLASS_T);
280 ARRAY.setCPL(ARRAY, CLASS_T);
281 BIGNUM.setDirectSuperclass(INTEGER);
282 BIGNUM.setCPL(BIGNUM, INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
283 BIT_VECTOR.setDirectSuperclass(VECTOR);
284 BIT_VECTOR.setCPL(BIT_VECTOR, VECTOR, ARRAY, SEQUENCE, CLASS_T);
285 BROADCAST_STREAM.setDirectSuperclass(STREAM);
286 BROADCAST_STREAM.setCPL(BROADCAST_STREAM, STREAM, CLASS_T);
287 BUILT_IN_CLASS.setDirectSuperclass(CLASS);
288 BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT, CLASS_T);
289 CASE_FROB_STREAM.setDirectSuperclass(STREAM);
290 CASE_FROB_STREAM.setCPL(CASE_FROB_STREAM, STREAM, CLASS_T);
291 CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
292 STANDARD_OBJECT, CLASS_T);
293 CHARACTER.setDirectSuperclass(CLASS_T);
294 CHARACTER.setCPL(CHARACTER, CLASS_T);
295 CLASS.setDirectSuperclass(CLASS_T);
296 CLASS.setCPL(CLASS, STANDARD_OBJECT, CLASS_T);
297 CLASS_T.setCPL(CLASS_T);
298 COMPLEX.setDirectSuperclass(NUMBER);
299 COMPLEX.setCPL(COMPLEX, NUMBER, CLASS_T);
300 CONCATENATED_STREAM.setDirectSuperclass(STREAM);
301 CONCATENATED_STREAM.setCPL(CONCATENATED_STREAM, STREAM, CLASS_T);
302 CONDITION.setCPL(CONDITION, STANDARD_OBJECT, CLASS_T);
303 CONS.setDirectSuperclass(LIST);
304 CONS.setCPL(CONS, LIST, SEQUENCE, CLASS_T);
305 CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
306 STANDARD_OBJECT, CLASS_T);
307 DIVISION_BY_ZERO.setDirectSuperclass(ARITHMETIC_ERROR);
308 DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR, ERROR,
309 SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
310 CLASS_T);
311 ECHO_STREAM.setDirectSuperclass(STREAM);
312 ECHO_STREAM.setCPL(ECHO_STREAM, STREAM, CLASS_T);
313 END_OF_FILE.setDirectSuperclass(STREAM_ERROR);
314 END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR, SERIOUS_CONDITION,
315 CONDITION, STANDARD_OBJECT, CLASS_T);
316 ERROR.setCPL(ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
317 CLASS_T);
318 FIXNUM.setDirectSuperclass(INTEGER);
319 FIXNUM.setCPL(FIXNUM, INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
320 FILE_ERROR.setCPL(FILE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
321 STANDARD_OBJECT, CLASS_T);
322 FILE_STREAM.setDirectSuperclass(STREAM);
323 FILE_STREAM.setCPL(FILE_STREAM, STREAM, CLASS_T);
324 FLOAT.setDirectSuperclass(REAL);
325 FLOAT.setCPL(FLOAT, REAL, NUMBER, CLASS_T);
326 FLOATING_POINT_INEXACT.setDirectSuperclass(ARITHMETIC_ERROR);
327 FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT, ARITHMETIC_ERROR,
328 ERROR, SERIOUS_CONDITION, CONDITION,
329 STANDARD_OBJECT, CLASS_T);
330 FLOATING_POINT_INVALID_OPERATION.setDirectSuperclass(ARITHMETIC_ERROR);
331 FLOATING_POINT_INVALID_OPERATION.setCPL(FLOATING_POINT_INVALID_OPERATION,
332 ARITHMETIC_ERROR, ERROR,
333 SERIOUS_CONDITION, CONDITION,
334 STANDARD_OBJECT, CLASS_T);
335 FLOATING_POINT_OVERFLOW.setDirectSuperclass(ARITHMETIC_ERROR);
336 FLOATING_POINT_OVERFLOW.setCPL(FLOATING_POINT_OVERFLOW, ARITHMETIC_ERROR,
337 ERROR, SERIOUS_CONDITION, CONDITION,
338 STANDARD_OBJECT, CLASS_T);
339 FLOATING_POINT_UNDERFLOW.setDirectSuperclass(ARITHMETIC_ERROR);
340 FLOATING_POINT_UNDERFLOW.setCPL(FLOATING_POINT_UNDERFLOW, ARITHMETIC_ERROR,
341 ERROR, SERIOUS_CONDITION, CONDITION,
342 STANDARD_OBJECT, CLASS_T);
343 FUNCTION.setDirectSuperclass(CLASS_T);
344 FUNCTION.setCPL(FUNCTION, CLASS_T);
345 GENERIC_FUNCTION.setCPL(GENERIC_FUNCTION, STANDARD_OBJECT, FUNCTION,
346 CLASS_T);
347 HASH_TABLE.setDirectSuperclass(CLASS_T);
348 HASH_TABLE.setCPL(HASH_TABLE, CLASS_T);
349 INTEGER.setDirectSuperclass(RATIONAL);
350 INTEGER.setCPL(INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
351 LIST.setDirectSuperclass(SEQUENCE);
352 LIST.setCPL(LIST, SEQUENCE, CLASS_T);
353 LOGICAL_PATHNAME.setDirectSuperclass(PATHNAME);
354 LOGICAL_PATHNAME.setCPL(LOGICAL_PATHNAME, PATHNAME, CLASS_T);
355 METHOD.setDirectSuperclass(STANDARD_OBJECT);
356 METHOD.setCPL(METHOD, STANDARD_OBJECT, CLASS_T);
357 METHOD_COMBINATION.setDirectSuperclass(CLASS_T);
358 METHOD_COMBINATION.setCPL(METHOD_COMBINATION, CLASS_T);
359 NIL_VECTOR.setDirectSuperclass(STRING);
360 NIL_VECTOR.setCPL(NIL_VECTOR, STRING, VECTOR, ARRAY, SEQUENCE, CLASS_T);
361 NULL.setDirectSuperclass(LIST);
362 NULL.setCPL(NULL, SYMBOL, LIST, SEQUENCE, CLASS_T);
363 NUMBER.setDirectSuperclass(CLASS_T);
364 NUMBER.setCPL(NUMBER, CLASS_T);
365 PACKAGE.setDirectSuperclass(CLASS_T);
366 PACKAGE.setCPL(PACKAGE, CLASS_T);
367 PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
368 STANDARD_OBJECT, CLASS_T);
369 PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
370 STANDARD_OBJECT, CLASS_T);
371 PATHNAME.setDirectSuperclass(CLASS_T);
372 PATHNAME.setCPL(PATHNAME, CLASS_T);
373 PRINT_NOT_READABLE.setDirectSuperclass(ERROR);
374 PRINT_NOT_READABLE.setCPL(PRINT_NOT_READABLE, ERROR, SERIOUS_CONDITION,
375 CONDITION, STANDARD_OBJECT, CLASS_T);
376 PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
377 STANDARD_OBJECT, CLASS_T);
378 RANDOM_STATE.setDirectSuperclass(CLASS_T);
379 RANDOM_STATE.setCPL(RANDOM_STATE, CLASS_T);
380 RATIO.setDirectSuperclass(RATIONAL);
381 RATIO.setCPL(RATIO, RATIONAL, REAL, NUMBER, CLASS_T);
382 RATIONAL.setDirectSuperclass(REAL);
383 RATIONAL.setCPL(RATIONAL, REAL, NUMBER, CLASS_T);
384 READER_ERROR.setCPL(READER_ERROR, PARSE_ERROR, STREAM_ERROR, ERROR,
385 SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
386 CLASS_T);
387 READTABLE.setDirectSuperclass(CLASS_T);
388 READTABLE.setCPL(READTABLE, CLASS_T);
389 REAL.setDirectSuperclass(NUMBER);
390 REAL.setCPL(REAL, NUMBER, CLASS_T);
391 RESTART.setDirectSuperclass(CLASS_T);
392 RESTART.setCPL(RESTART, CLASS_T);
393 SEQUENCE.setDirectSuperclass(CLASS_T);
394 SEQUENCE.setCPL(SEQUENCE, CLASS_T);
395 SERIOUS_CONDITION.setDirectSuperclass(CONDITION);
396 SERIOUS_CONDITION.setCPL(SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
397 CLASS_T);
398 SIMPLE_ARRAY.setDirectSuperclass(ARRAY);
399 SIMPLE_ARRAY.setCPL(SIMPLE_ARRAY, ARRAY, CLASS_T);
400 SIMPLE_BIT_VECTOR.setDirectSuperclasses(list2(BIT_VECTOR, SIMPLE_ARRAY));
401 SIMPLE_BIT_VECTOR.setCPL(SIMPLE_BIT_VECTOR, BIT_VECTOR, VECTOR,
402 SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
403 SIMPLE_CONDITION.setCPL(SIMPLE_CONDITION, CONDITION, STANDARD_OBJECT,
404 CLASS_T);
405 SIMPLE_ERROR.setDirectSuperclass(ERROR);
406 SIMPLE_ERROR.setCPL(SIMPLE_ERROR, SIMPLE_CONDITION, ERROR,
407 SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
408 CLASS_T);
409 SIMPLE_TYPE_ERROR.setDirectSuperclasses(list2(SIMPLE_CONDITION, TYPE_ERROR));
410 SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
411 TYPE_ERROR, ERROR, SERIOUS_CONDITION,
412 CONDITION, STANDARD_OBJECT, CLASS_T);
413 SIMPLE_STRING.setDirectSuperclasses(list2(STRING, SIMPLE_ARRAY));
414 SIMPLE_STRING.setCPL(SIMPLE_STRING, STRING, VECTOR, SIMPLE_ARRAY, ARRAY,
415 SEQUENCE, CLASS_T);
416 SIMPLE_VECTOR.setDirectSuperclasses(list2(VECTOR, SIMPLE_ARRAY));
417 SIMPLE_VECTOR.setCPL(SIMPLE_VECTOR, VECTOR, SIMPLE_ARRAY, ARRAY, SEQUENCE,
418 CLASS_T);
419 SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
420 CONDITION, STANDARD_OBJECT, CLASS_T);
421 SOCKET_STREAM.setDirectSuperclass(TWO_WAY_STREAM);
422 SOCKET_STREAM.setCPL(SOCKET_STREAM, TWO_WAY_STREAM, STREAM, CLASS_T);
423 STANDARD_CLASS.setDirectSuperclass(CLASS);
424 STANDARD_CLASS.setCPL(STANDARD_CLASS, CLASS, STANDARD_OBJECT, CLASS_T);
425 STANDARD_OBJECT.setCPL(STANDARD_OBJECT, CLASS_T);
426 STORAGE_CONDITION.setDirectSuperclass(SERIOUS_CONDITION);
427 STORAGE_CONDITION.setCPL(STORAGE_CONDITION, SERIOUS_CONDITION, CONDITION,
428 STANDARD_OBJECT, CLASS_T);
429 STREAM.setDirectSuperclass(CLASS_T);
430 STREAM.setCPL(STREAM, CLASS_T);
431 STREAM_ERROR.setCPL(STREAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
432 STANDARD_OBJECT, CLASS_T);
433 STRING.setDirectSuperclass(VECTOR);
434 STRING.setCPL(STRING, VECTOR, ARRAY, SEQUENCE, CLASS_T);
435 STRING_INPUT_STREAM.setDirectSuperclass(STRING_STREAM);
436 STRING_INPUT_STREAM.setCPL(STRING_INPUT_STREAM, STRING_STREAM, STREAM,
437 CLASS_T);
438 STRING_OUTPUT_STREAM.setDirectSuperclass(STRING_STREAM);
439 STRING_OUTPUT_STREAM.setCPL(STRING_OUTPUT_STREAM, STRING_STREAM, STREAM,
440 CLASS_T);
441 STRING_STREAM.setDirectSuperclass(STREAM);
442 STRING_STREAM.setCPL(STRING_STREAM, STREAM, CLASS_T);
443 STRUCTURE_CLASS.setDirectSuperclass(CLASS);
444 STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
445 CLASS_T);
446 STRUCTURE_OBJECT.setCPL(STRUCTURE_OBJECT, CLASS_T);
447 STYLE_WARNING.setDirectSuperclass(WARNING);
448 STYLE_WARNING.setCPL(STYLE_WARNING, WARNING, CONDITION, STANDARD_OBJECT,
449 CLASS_T);
450 SYMBOL.setDirectSuperclass(CLASS_T);
451 SYMBOL.setCPL(SYMBOL, CLASS_T);
452 SYNONYM_STREAM.setDirectSuperclass(STREAM);
453 SYNONYM_STREAM.setCPL(SYNONYM_STREAM, STREAM, CLASS_T);
454 TWO_WAY_STREAM.setDirectSuperclass(STREAM);
455 TWO_WAY_STREAM.setCPL(TWO_WAY_STREAM, STREAM, CLASS_T);
456 TYPE_ERROR.setCPL(TYPE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
457 STANDARD_OBJECT, CLASS_T);
458 UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR, SERIOUS_CONDITION,
459 CONDITION, STANDARD_OBJECT, CLASS_T);
460 UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
461 SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
462 CLASS_T);
463 UNDEFINED_FUNCTION.setCPL(UNDEFINED_FUNCTION, CELL_ERROR, ERROR,
464 SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
465 CLASS_T);
466 VECTOR.setDirectSuperclasses(list2(ARRAY, SEQUENCE));
467 VECTOR.setCPL(VECTOR, ARRAY, SEQUENCE, CLASS_T);
468 WARNING.setCPL(WARNING, CONDITION, STANDARD_OBJECT, CLASS_T);
469 }
470 }
471 |
Popular Tags |
Java API By Example, From Geeks To Geeks.