001: /*
002: * BuiltInClass.java
003: *
004: * Copyright (C) 2003-2004 Peter Graves
005: * $Id: BuiltInClass.java,v 1.31 2004/06/08 10:54:18 piso Exp $
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License
009: * as published by the Free Software Foundation; either version 2
010: * of the License, or (at your option) any later version.
011: *
012: * This program is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
015: * GNU General Public License for more details.
016: *
017: * You should have received a copy of the GNU General Public License
018: * along with this program; if not, write to the Free Software
019: * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
020: */
021:
022: package org.armedbear.lisp;
023:
024: public class BuiltInClass extends LispClass {
025: private BuiltInClass(Symbol symbol) {
026: super (symbol);
027: }
028:
029: public LispObject typeOf() {
030: return Symbol.BUILT_IN_CLASS;
031: }
032:
033: public LispClass classOf() {
034: return BuiltInClass.BUILT_IN_CLASS;
035: }
036:
037: public LispObject typep(LispObject type) throws ConditionThrowable {
038: if (type == Symbol.BUILT_IN_CLASS)
039: return T;
040: if (type == BuiltInClass.BUILT_IN_CLASS)
041: return T;
042: return super .typep(type);
043: }
044:
045: public LispObject getDescription() throws ConditionThrowable {
046: return new SimpleString(writeToString());
047: }
048:
049: public String writeToString() throws ConditionThrowable {
050: StringBuffer sb = new StringBuffer("#<BUILT-IN-CLASS ");
051: sb.append(symbol.writeToString());
052: sb.append('>');
053: return sb.toString();
054: }
055:
056: private static BuiltInClass addClass(Symbol symbol) {
057: BuiltInClass c = new BuiltInClass(symbol);
058: addClass(symbol, c);
059: return c;
060: }
061:
062: public static final BuiltInClass CLASS_T = addClass(T);
063:
064: public static final BuiltInClass ARRAY = addClass(Symbol.ARRAY);
065: public static final BuiltInClass BIGNUM = addClass(Symbol.BIGNUM);
066: public static final BuiltInClass BIT_VECTOR = addClass(Symbol.BIT_VECTOR);
067: public static final BuiltInClass BROADCAST_STREAM = addClass(Symbol.BROADCAST_STREAM);
068: public static final BuiltInClass BUILT_IN_CLASS = addClass(Symbol.BUILT_IN_CLASS);
069: public static final BuiltInClass CASE_FROB_STREAM = addClass(Symbol.CASE_FROB_STREAM);
070: public static final BuiltInClass CHARACTER = addClass(Symbol.CHARACTER);
071: public static final BuiltInClass CLASS = addClass(Symbol.CLASS);
072: public static final BuiltInClass COMPLEX = addClass(Symbol.COMPLEX);
073: public static final BuiltInClass CONCATENATED_STREAM = addClass(Symbol.CONCATENATED_STREAM);
074: public static final BuiltInClass CONS = addClass(Symbol.CONS);
075: public static final BuiltInClass DIVISION_BY_ZERO = addClass(Symbol.DIVISION_BY_ZERO);
076: public static final BuiltInClass ECHO_STREAM = addClass(Symbol.ECHO_STREAM);
077: public static final BuiltInClass END_OF_FILE = addClass(Symbol.END_OF_FILE);
078: public static final BuiltInClass FILE_STREAM = addClass(Symbol.FILE_STREAM);
079: public static final BuiltInClass FIXNUM = addClass(Symbol.FIXNUM);
080: public static final BuiltInClass FLOAT = addClass(Symbol.FLOAT);
081: public static final BuiltInClass FLOATING_POINT_INEXACT = addClass(Symbol.FLOATING_POINT_INEXACT);
082: public static final BuiltInClass FLOATING_POINT_INVALID_OPERATION = addClass(Symbol.FLOATING_POINT_INVALID_OPERATION);
083: public static final BuiltInClass FLOATING_POINT_OVERFLOW = addClass(Symbol.FLOATING_POINT_OVERFLOW);
084: public static final BuiltInClass FLOATING_POINT_UNDERFLOW = addClass(Symbol.FLOATING_POINT_UNDERFLOW);
085: public static final BuiltInClass FUNCTION = addClass(Symbol.FUNCTION);
086: public static final BuiltInClass HASH_TABLE = addClass(Symbol.HASH_TABLE);
087: public static final BuiltInClass INTEGER = addClass(Symbol.INTEGER);
088: public static final BuiltInClass LIST = addClass(Symbol.LIST);
089: public static final BuiltInClass LOGICAL_PATHNAME = addClass(Symbol.LOGICAL_PATHNAME);
090: public static final BuiltInClass METHOD_COMBINATION = addClass(Symbol.METHOD_COMBINATION);
091: public static final BuiltInClass NIL_VECTOR = addClass(Symbol.NIL_VECTOR);
092: public static final BuiltInClass NULL = addClass(Symbol.NULL);
093: public static final BuiltInClass NUMBER = addClass(Symbol.NUMBER);
094: public static final BuiltInClass PACKAGE = addClass(Symbol.PACKAGE);
095: public static final BuiltInClass PATHNAME = addClass(Symbol.PATHNAME);
096: public static final BuiltInClass PRINT_NOT_READABLE = addClass(Symbol.PRINT_NOT_READABLE);
097: public static final BuiltInClass RANDOM_STATE = addClass(Symbol.RANDOM_STATE);
098: public static final BuiltInClass RATIO = addClass(Symbol.RATIO);
099: public static final BuiltInClass RATIONAL = addClass(Symbol.RATIONAL);
100: public static final BuiltInClass READTABLE = addClass(Symbol.READTABLE);
101: public static final BuiltInClass REAL = addClass(Symbol.REAL);
102: public static final BuiltInClass RESTART = addClass(Symbol.RESTART);
103: public static final BuiltInClass SEQUENCE = addClass(Symbol.SEQUENCE);
104: public static final BuiltInClass SIMPLE_ARRAY = addClass(Symbol.SIMPLE_ARRAY);
105: public static final BuiltInClass SIMPLE_BIT_VECTOR = addClass(Symbol.SIMPLE_BIT_VECTOR);
106: public static final BuiltInClass SIMPLE_ERROR = addClass(Symbol.SIMPLE_ERROR);
107: public static final BuiltInClass SIMPLE_STRING = addClass(Symbol.SIMPLE_STRING);
108: public static final BuiltInClass SIMPLE_VECTOR = addClass(Symbol.SIMPLE_VECTOR);
109: public static final BuiltInClass SIMPLE_TYPE_ERROR = addClass(Symbol.SIMPLE_TYPE_ERROR);
110: public static final BuiltInClass SOCKET_STREAM = addClass(Symbol.SOCKET_STREAM);
111: public static final BuiltInClass STORAGE_CONDITION = addClass(Symbol.STORAGE_CONDITION);
112: public static final BuiltInClass STREAM = addClass(Symbol.STREAM);
113: public static final BuiltInClass STRING = addClass(Symbol.STRING);
114: public static final BuiltInClass STRING_INPUT_STREAM = addClass(Symbol.STRING_INPUT_STREAM);
115: public static final BuiltInClass STRING_OUTPUT_STREAM = addClass(Symbol.STRING_OUTPUT_STREAM);
116: public static final BuiltInClass STRING_STREAM = addClass(Symbol.STRING_STREAM);
117: public static final BuiltInClass STRUCTURE_CLASS = addClass(Symbol.STRUCTURE_CLASS);
118: public static final BuiltInClass STYLE_WARNING = addClass(Symbol.STYLE_WARNING);
119: public static final BuiltInClass SYMBOL = addClass(Symbol.SYMBOL);
120: public static final BuiltInClass SYNONYM_STREAM = addClass(Symbol.SYNONYM_STREAM);
121: public static final BuiltInClass TWO_WAY_STREAM = addClass(Symbol.TWO_WAY_STREAM);
122: public static final BuiltInClass VECTOR = addClass(Symbol.VECTOR);
123:
124: public static final StructureClass STRUCTURE_OBJECT = new StructureClass(
125: Symbol.STRUCTURE_OBJECT, list1(CLASS_T));
126: static {
127: addClass(Symbol.STRUCTURE_OBJECT, STRUCTURE_OBJECT);
128: }
129:
130: public static final StandardClass STANDARD_CLASS = new StandardClass(
131: Symbol.STANDARD_CLASS, list1(CLASS_T));
132: static {
133: addClass(Symbol.STANDARD_CLASS, STANDARD_CLASS);
134: }
135:
136: public static final StandardClass STANDARD_OBJECT = new StandardClass(
137: Symbol.STANDARD_OBJECT, list1(CLASS_T));
138: static {
139: addClass(Symbol.STANDARD_OBJECT, STANDARD_OBJECT);
140: }
141:
142: public static final StandardClass CONDITION = new StandardClass(
143: Symbol.CONDITION, list1(STANDARD_OBJECT));
144: static {
145: addClass(Symbol.CONDITION, CONDITION);
146: }
147:
148: public static final StandardClass SIMPLE_CONDITION = new StandardClass(
149: Symbol.SIMPLE_CONDITION, list1(CONDITION));
150: static {
151: addClass(Symbol.SIMPLE_CONDITION, SIMPLE_CONDITION);
152: }
153:
154: public static final StandardClass SERIOUS_CONDITION = new StandardClass(
155: Symbol.SERIOUS_CONDITION, list1(CONDITION));
156: static {
157: addClass(Symbol.SERIOUS_CONDITION, SERIOUS_CONDITION);
158: }
159:
160: public static final StandardClass WARNING = new StandardClass(
161: Symbol.WARNING, list1(CONDITION));
162: static {
163: addClass(Symbol.WARNING, WARNING);
164: }
165:
166: public static final StandardClass SIMPLE_WARNING = new StandardClass(
167: Symbol.SIMPLE_WARNING, list2(SIMPLE_CONDITION, WARNING));
168: static {
169: addClass(Symbol.SIMPLE_WARNING, SIMPLE_WARNING);
170: }
171:
172: public static final StandardClass ERROR = new StandardClass(
173: Symbol.ERROR, list1(SERIOUS_CONDITION));
174: static {
175: addClass(Symbol.ERROR, ERROR);
176: }
177:
178: public static final StandardClass ARITHMETIC_ERROR = new StandardClass(
179: Symbol.ARITHMETIC_ERROR, list1(ERROR));
180: static {
181: addClass(Symbol.ARITHMETIC_ERROR, ARITHMETIC_ERROR);
182: }
183:
184: public static final StandardClass CELL_ERROR = new StandardClass(
185: Symbol.CELL_ERROR, list1(ERROR));
186: static {
187: addClass(Symbol.CELL_ERROR, CELL_ERROR);
188: }
189:
190: public static final StandardClass UNBOUND_SLOT = new StandardClass(
191: Symbol.UNBOUND_SLOT, list1(CELL_ERROR));
192: static {
193: addClass(Symbol.UNBOUND_SLOT, UNBOUND_SLOT);
194: }
195:
196: public static final StandardClass UNBOUND_VARIABLE = new StandardClass(
197: Symbol.UNBOUND_VARIABLE, list1(CELL_ERROR));
198: static {
199: addClass(Symbol.UNBOUND_VARIABLE, UNBOUND_VARIABLE);
200: }
201:
202: public static final StandardClass UNDEFINED_FUNCTION = new StandardClass(
203: Symbol.UNDEFINED_FUNCTION, list1(CELL_ERROR));
204: static {
205: addClass(Symbol.UNDEFINED_FUNCTION, UNDEFINED_FUNCTION);
206: }
207:
208: public static final StandardClass CONTROL_ERROR = new StandardClass(
209: Symbol.CONTROL_ERROR, list1(ERROR));
210: static {
211: addClass(Symbol.CONTROL_ERROR, CONTROL_ERROR);
212: }
213:
214: public static final StandardClass FILE_ERROR = new StandardClass(
215: Symbol.FILE_ERROR, list1(ERROR));
216: static {
217: addClass(Symbol.FILE_ERROR, FILE_ERROR);
218: }
219:
220: public static final StandardClass PACKAGE_ERROR = new StandardClass(
221: Symbol.PACKAGE_ERROR, list1(ERROR));
222: static {
223: addClass(Symbol.PACKAGE_ERROR, PACKAGE_ERROR);
224: }
225:
226: public static final StandardClass PARSE_ERROR = new StandardClass(
227: Symbol.PARSE_ERROR, list1(ERROR));
228: static {
229: addClass(Symbol.PARSE_ERROR, PARSE_ERROR);
230: }
231:
232: public static final StandardClass PROGRAM_ERROR = new StandardClass(
233: Symbol.PROGRAM_ERROR, list1(ERROR));
234: static {
235: addClass(Symbol.PROGRAM_ERROR, PROGRAM_ERROR);
236: }
237:
238: public static final StandardClass STREAM_ERROR = new StandardClass(
239: Symbol.STREAM_ERROR, list1(ERROR));
240: static {
241: addClass(Symbol.STREAM_ERROR, STREAM_ERROR);
242: }
243:
244: public static final StandardClass TYPE_ERROR = new StandardClass(
245: Symbol.TYPE_ERROR, list1(ERROR));
246: static {
247: addClass(Symbol.TYPE_ERROR, TYPE_ERROR);
248: }
249:
250: public static final StandardClass READER_ERROR = new StandardClass(
251: Symbol.READER_ERROR, list2(PARSE_ERROR, STREAM_ERROR));
252: static {
253: addClass(Symbol.READER_ERROR, READER_ERROR);
254: }
255:
256: public static final StandardClass GENERIC_FUNCTION = new StandardClass(
257: Symbol.GENERIC_FUNCTION, list2(FUNCTION, STANDARD_OBJECT));
258: static {
259: addClass(Symbol.GENERIC_FUNCTION, GENERIC_FUNCTION);
260: }
261:
262: public static final StandardClass METHOD = new StandardClass(
263: Symbol.METHOD, list1(STANDARD_OBJECT));
264: static {
265: addClass(Symbol.METHOD, METHOD);
266: }
267:
268: static {
269: ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR,
270: SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT, CLASS_T);
271: ARRAY.setDirectSuperclass(CLASS_T);
272: ARRAY.setCPL(ARRAY, CLASS_T);
273: BIGNUM.setDirectSuperclass(INTEGER);
274: BIGNUM.setCPL(BIGNUM, INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
275: BIT_VECTOR.setDirectSuperclass(VECTOR);
276: BIT_VECTOR.setCPL(BIT_VECTOR, VECTOR, ARRAY, SEQUENCE, CLASS_T);
277: BROADCAST_STREAM.setDirectSuperclass(STREAM);
278: BROADCAST_STREAM.setCPL(BROADCAST_STREAM, STREAM, CLASS_T);
279: BUILT_IN_CLASS.setDirectSuperclass(CLASS);
280: BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
281: CLASS_T);
282: CASE_FROB_STREAM.setDirectSuperclass(STREAM);
283: CASE_FROB_STREAM.setCPL(CASE_FROB_STREAM, STREAM, CLASS_T);
284: CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION,
285: CONDITION, STANDARD_OBJECT, CLASS_T);
286: CHARACTER.setDirectSuperclass(CLASS_T);
287: CHARACTER.setCPL(CHARACTER, CLASS_T);
288: CLASS.setDirectSuperclass(CLASS_T);
289: CLASS.setCPL(CLASS, STANDARD_OBJECT, CLASS_T);
290: CLASS_T.setCPL(CLASS_T);
291: COMPLEX.setDirectSuperclass(NUMBER);
292: COMPLEX.setCPL(COMPLEX, NUMBER, CLASS_T);
293: CONCATENATED_STREAM.setDirectSuperclass(STREAM);
294: CONCATENATED_STREAM
295: .setCPL(CONCATENATED_STREAM, STREAM, CLASS_T);
296: CONDITION.setCPL(CONDITION, STANDARD_OBJECT, CLASS_T);
297: CONS.setDirectSuperclass(LIST);
298: CONS.setCPL(CONS, LIST, SEQUENCE, CLASS_T);
299: CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION,
300: CONDITION, STANDARD_OBJECT, CLASS_T);
301: DIVISION_BY_ZERO.setDirectSuperclass(ARITHMETIC_ERROR);
302: DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR,
303: ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
304: CLASS_T);
305: ECHO_STREAM.setDirectSuperclass(STREAM);
306: ECHO_STREAM.setCPL(ECHO_STREAM, STREAM, CLASS_T);
307: END_OF_FILE.setDirectSuperclass(STREAM_ERROR);
308: END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR,
309: SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT, CLASS_T);
310: ERROR.setCPL(ERROR, SERIOUS_CONDITION, CONDITION,
311: STANDARD_OBJECT, CLASS_T);
312: FIXNUM.setDirectSuperclass(INTEGER);
313: FIXNUM.setCPL(FIXNUM, INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
314: FILE_ERROR.setCPL(FILE_ERROR, ERROR, SERIOUS_CONDITION,
315: CONDITION, STANDARD_OBJECT, CLASS_T);
316: FILE_STREAM.setDirectSuperclass(STREAM);
317: FILE_STREAM.setCPL(FILE_STREAM, STREAM, CLASS_T);
318: FLOAT.setDirectSuperclass(REAL);
319: FLOAT.setCPL(FLOAT, REAL, NUMBER, CLASS_T);
320: FLOATING_POINT_INEXACT.setDirectSuperclass(ARITHMETIC_ERROR);
321: FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT,
322: ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
323: STANDARD_OBJECT, CLASS_T);
324: FLOATING_POINT_INVALID_OPERATION
325: .setDirectSuperclass(ARITHMETIC_ERROR);
326: FLOATING_POINT_INVALID_OPERATION.setCPL(
327: FLOATING_POINT_INVALID_OPERATION, ARITHMETIC_ERROR,
328: ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
329: CLASS_T);
330: FLOATING_POINT_OVERFLOW.setDirectSuperclass(ARITHMETIC_ERROR);
331: FLOATING_POINT_OVERFLOW.setCPL(FLOATING_POINT_OVERFLOW,
332: ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
333: STANDARD_OBJECT, CLASS_T);
334: FLOATING_POINT_UNDERFLOW.setDirectSuperclass(ARITHMETIC_ERROR);
335: FLOATING_POINT_UNDERFLOW.setCPL(FLOATING_POINT_UNDERFLOW,
336: ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
337: STANDARD_OBJECT, CLASS_T);
338: FUNCTION.setDirectSuperclass(CLASS_T);
339: FUNCTION.setCPL(FUNCTION, CLASS_T);
340: GENERIC_FUNCTION.setCPL(GENERIC_FUNCTION, STANDARD_OBJECT,
341: FUNCTION, CLASS_T);
342: HASH_TABLE.setDirectSuperclass(CLASS_T);
343: HASH_TABLE.setCPL(HASH_TABLE, CLASS_T);
344: INTEGER.setDirectSuperclass(RATIONAL);
345: INTEGER.setCPL(INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
346: LIST.setDirectSuperclass(SEQUENCE);
347: LIST.setCPL(LIST, SEQUENCE, CLASS_T);
348: LOGICAL_PATHNAME.setDirectSuperclass(PATHNAME);
349: LOGICAL_PATHNAME.setCPL(LOGICAL_PATHNAME, PATHNAME, CLASS_T);
350: METHOD.setDirectSuperclass(STANDARD_OBJECT);
351: METHOD.setCPL(METHOD, STANDARD_OBJECT, CLASS_T);
352: METHOD_COMBINATION.setDirectSuperclass(CLASS_T);
353: METHOD_COMBINATION.setCPL(METHOD_COMBINATION, CLASS_T);
354: NIL_VECTOR.setDirectSuperclass(STRING);
355: NIL_VECTOR.setCPL(NIL_VECTOR, STRING, VECTOR, ARRAY, SEQUENCE,
356: CLASS_T);
357: NULL.setDirectSuperclass(LIST);
358: NULL.setCPL(NULL, SYMBOL, LIST, SEQUENCE, CLASS_T);
359: NUMBER.setDirectSuperclass(CLASS_T);
360: NUMBER.setCPL(NUMBER, CLASS_T);
361: PACKAGE.setDirectSuperclass(CLASS_T);
362: PACKAGE.setCPL(PACKAGE, CLASS_T);
363: PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION,
364: CONDITION, STANDARD_OBJECT, CLASS_T);
365: PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION,
366: CONDITION, STANDARD_OBJECT, CLASS_T);
367: PATHNAME.setDirectSuperclass(CLASS_T);
368: PATHNAME.setCPL(PATHNAME, CLASS_T);
369: PRINT_NOT_READABLE.setDirectSuperclass(ERROR);
370: PRINT_NOT_READABLE.setCPL(PRINT_NOT_READABLE, ERROR,
371: SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT, CLASS_T);
372: PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION,
373: CONDITION, STANDARD_OBJECT, CLASS_T);
374: RANDOM_STATE.setDirectSuperclass(CLASS_T);
375: RANDOM_STATE.setCPL(RANDOM_STATE, CLASS_T);
376: RATIO.setDirectSuperclass(RATIONAL);
377: RATIO.setCPL(RATIO, RATIONAL, REAL, NUMBER, CLASS_T);
378: RATIONAL.setDirectSuperclass(REAL);
379: RATIONAL.setCPL(RATIONAL, REAL, NUMBER, CLASS_T);
380: READER_ERROR.setCPL(READER_ERROR, PARSE_ERROR, STREAM_ERROR,
381: ERROR, SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
382: CLASS_T);
383: READTABLE.setDirectSuperclass(CLASS_T);
384: READTABLE.setCPL(READTABLE, CLASS_T);
385: REAL.setDirectSuperclass(NUMBER);
386: REAL.setCPL(REAL, NUMBER, CLASS_T);
387: RESTART.setDirectSuperclass(CLASS_T);
388: RESTART.setCPL(RESTART, CLASS_T);
389: SEQUENCE.setDirectSuperclass(CLASS_T);
390: SEQUENCE.setCPL(SEQUENCE, CLASS_T);
391: SERIOUS_CONDITION.setDirectSuperclass(CONDITION);
392: SERIOUS_CONDITION.setCPL(SERIOUS_CONDITION, CONDITION,
393: STANDARD_OBJECT, CLASS_T);
394: SIMPLE_ARRAY.setDirectSuperclass(ARRAY);
395: SIMPLE_ARRAY.setCPL(SIMPLE_ARRAY, ARRAY, CLASS_T);
396: SIMPLE_BIT_VECTOR.setDirectSuperclasses(list2(BIT_VECTOR,
397: SIMPLE_ARRAY));
398: SIMPLE_BIT_VECTOR.setCPL(SIMPLE_BIT_VECTOR, BIT_VECTOR, VECTOR,
399: SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
400: SIMPLE_CONDITION.setCPL(SIMPLE_CONDITION, CONDITION,
401: STANDARD_OBJECT, CLASS_T);
402: SIMPLE_ERROR.setDirectSuperclass(ERROR);
403: SIMPLE_ERROR.setCPL(SIMPLE_ERROR, SIMPLE_CONDITION, ERROR,
404: SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT, CLASS_T);
405: SIMPLE_TYPE_ERROR.setDirectSuperclasses(list2(SIMPLE_CONDITION,
406: TYPE_ERROR));
407: SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
408: TYPE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
409: STANDARD_OBJECT, CLASS_T);
410: SIMPLE_STRING
411: .setDirectSuperclasses(list2(STRING, SIMPLE_ARRAY));
412: SIMPLE_STRING.setCPL(SIMPLE_STRING, STRING, VECTOR,
413: SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
414: SIMPLE_VECTOR
415: .setDirectSuperclasses(list2(VECTOR, SIMPLE_ARRAY));
416: SIMPLE_VECTOR.setCPL(SIMPLE_VECTOR, VECTOR, SIMPLE_ARRAY,
417: ARRAY, SEQUENCE, CLASS_T);
418: SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION,
419: WARNING, CONDITION, STANDARD_OBJECT, CLASS_T);
420: SOCKET_STREAM.setDirectSuperclass(TWO_WAY_STREAM);
421: SOCKET_STREAM.setCPL(SOCKET_STREAM, TWO_WAY_STREAM, STREAM,
422: CLASS_T);
423: STANDARD_CLASS.setDirectSuperclass(CLASS);
424: STANDARD_CLASS.setCPL(STANDARD_CLASS, CLASS, STANDARD_OBJECT,
425: CLASS_T);
426: STANDARD_OBJECT.setCPL(STANDARD_OBJECT, CLASS_T);
427: STORAGE_CONDITION.setDirectSuperclass(SERIOUS_CONDITION);
428: STORAGE_CONDITION.setCPL(STORAGE_CONDITION, SERIOUS_CONDITION,
429: CONDITION, STANDARD_OBJECT, CLASS_T);
430: STREAM.setDirectSuperclass(CLASS_T);
431: STREAM.setCPL(STREAM, CLASS_T);
432: STREAM_ERROR.setCPL(STREAM_ERROR, ERROR, SERIOUS_CONDITION,
433: CONDITION, STANDARD_OBJECT, CLASS_T);
434: STRING.setDirectSuperclass(VECTOR);
435: STRING.setCPL(STRING, VECTOR, ARRAY, SEQUENCE, CLASS_T);
436: STRING_INPUT_STREAM.setDirectSuperclass(STRING_STREAM);
437: STRING_INPUT_STREAM.setCPL(STRING_INPUT_STREAM, STRING_STREAM,
438: STREAM, CLASS_T);
439: STRING_OUTPUT_STREAM.setDirectSuperclass(STRING_STREAM);
440: STRING_OUTPUT_STREAM.setCPL(STRING_OUTPUT_STREAM,
441: STRING_STREAM, STREAM, CLASS_T);
442: STRING_STREAM.setDirectSuperclass(STREAM);
443: STRING_STREAM.setCPL(STRING_STREAM, STREAM, CLASS_T);
444: STRUCTURE_CLASS.setDirectSuperclass(CLASS);
445: STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
446: CLASS_T);
447: STRUCTURE_OBJECT.setCPL(STRUCTURE_OBJECT, CLASS_T);
448: STYLE_WARNING.setDirectSuperclass(WARNING);
449: STYLE_WARNING.setCPL(STYLE_WARNING, WARNING, CONDITION,
450: STANDARD_OBJECT, CLASS_T);
451: SYMBOL.setDirectSuperclass(CLASS_T);
452: SYMBOL.setCPL(SYMBOL, CLASS_T);
453: SYNONYM_STREAM.setDirectSuperclass(STREAM);
454: SYNONYM_STREAM.setCPL(SYNONYM_STREAM, STREAM, CLASS_T);
455: TWO_WAY_STREAM.setDirectSuperclass(STREAM);
456: TWO_WAY_STREAM.setCPL(TWO_WAY_STREAM, STREAM, CLASS_T);
457: TYPE_ERROR.setCPL(TYPE_ERROR, ERROR, SERIOUS_CONDITION,
458: CONDITION, STANDARD_OBJECT, CLASS_T);
459: UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR,
460: SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT, CLASS_T);
461: UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
462: SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT, CLASS_T);
463: UNDEFINED_FUNCTION.setCPL(UNDEFINED_FUNCTION, CELL_ERROR,
464: ERROR, 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: }
|