001: /*
002: * BuiltInClass.java
003: *
004: * Copyright (C) 2003 Peter Graves
005: * $Id: BuiltInClass.java,v 1.6 2003/11/15 11:03:33 beedlem 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 String toString() {
046: StringBuffer sb = new StringBuffer("#<BUILT-IN-CLASS ");
047: sb.append(symbol.getName());
048: sb.append('>');
049: return sb.toString();
050: }
051:
052: private static BuiltInClass addClass(Symbol symbol) {
053: BuiltInClass c = new BuiltInClass(symbol);
054: addClass(symbol, c);
055: return c;
056: }
057:
058: public static final BuiltInClass CLASS_T = addClass(T);
059:
060: public static final BuiltInClass ARITHMETIC_ERROR = addClass(Symbol.ARITHMETIC_ERROR);
061: public static final BuiltInClass ARRAY = addClass(Symbol.ARRAY);
062: public static final BuiltInClass BIGNUM = addClass(Symbol.BIGNUM);
063: public static final BuiltInClass BIT_VECTOR = addClass(Symbol.BIT_VECTOR);
064: public static final BuiltInClass BROADCAST_STREAM = addClass(Symbol.BROADCAST_STREAM);
065: public static final BuiltInClass BUILT_IN_CLASS = addClass(Symbol.BUILT_IN_CLASS);
066: public static final BuiltInClass CELL_ERROR = addClass(Symbol.CELL_ERROR);
067: public static final BuiltInClass CHARACTER = addClass(Symbol.CHARACTER);
068: public static final BuiltInClass CLASS = addClass(Symbol.CLASS);
069: public static final BuiltInClass COMPLEX = addClass(Symbol.COMPLEX);
070: public static final BuiltInClass CONCATENATED_STREAM = addClass(Symbol.CONCATENATED_STREAM);
071: // public static final BuiltInClass CONDITION = addClass(Symbol.CONDITION);
072: public static final BuiltInClass CONS = addClass(Symbol.CONS);
073: public static final BuiltInClass CONTROL_ERROR = addClass(Symbol.CONTROL_ERROR);
074: public static final BuiltInClass DIVISION_BY_ZERO = addClass(Symbol.DIVISION_BY_ZERO);
075: public static final BuiltInClass ECHO_STREAM = addClass(Symbol.ECHO_STREAM);
076: public static final BuiltInClass END_OF_FILE = addClass(Symbol.END_OF_FILE);
077: public static final BuiltInClass ERROR = addClass(Symbol.ERROR);
078: public static final BuiltInClass FILE_ERROR = addClass(Symbol.FILE_ERROR);
079: public static final BuiltInClass FILE_STREAM = addClass(Symbol.FILE_STREAM);
080: public static final BuiltInClass FIXNUM = addClass(Symbol.FIXNUM);
081: public static final BuiltInClass FLOAT = addClass(Symbol.FLOAT);
082: public static final BuiltInClass FLOATING_POINT_INEXACT = addClass(Symbol.FLOATING_POINT_INEXACT);
083: public static final BuiltInClass FLOATING_POINT_INVALID_OPERATION = addClass(Symbol.FLOATING_POINT_INVALID_OPERATION);
084: public static final BuiltInClass FLOATING_POINT_OVERFLOW = addClass(Symbol.FLOATING_POINT_OVERFLOW);
085: public static final BuiltInClass FLOATING_POINT_UNDERFLOW = addClass(Symbol.FLOATING_POINT_UNDERFLOW);
086: public static final BuiltInClass FUNCTION = addClass(Symbol.FUNCTION);
087: // public static final BuiltInClass GENERIC_FUNCTION = addClass(Symbol.GENERIC_FUNCTION);
088: public static final BuiltInClass HASH_TABLE = addClass(Symbol.HASH_TABLE);
089: public static final BuiltInClass INTEGER = addClass(Symbol.INTEGER);
090: public static final BuiltInClass LIST = addClass(Symbol.LIST);
091: public static final BuiltInClass LOGICAL_PATHNAME = addClass(Symbol.LOGICAL_PATHNAME);
092: // public static final BuiltInClass METHOD = addClass(Symbol.METHOD);
093: public static final BuiltInClass METHOD_COMBINATION = addClass(Symbol.METHOD_COMBINATION);
094: public static final BuiltInClass NULL = addClass(Symbol.NULL);
095: public static final BuiltInClass NUMBER = addClass(Symbol.NUMBER);
096: public static final BuiltInClass PACKAGE = addClass(Symbol.PACKAGE);
097: public static final BuiltInClass PACKAGE_ERROR = addClass(Symbol.PACKAGE_ERROR);
098: public static final BuiltInClass PARSE_ERROR = addClass(Symbol.PARSE_ERROR);
099: public static final BuiltInClass PATHNAME = addClass(Symbol.PATHNAME);
100: public static final BuiltInClass PRINT_NOT_READABLE = addClass(Symbol.PRINT_NOT_READABLE);
101: public static final BuiltInClass PROGRAM_ERROR = addClass(Symbol.PROGRAM_ERROR);
102: public static final BuiltInClass RANDOM_STATE = addClass(Symbol.RANDOM_STATE);
103: public static final BuiltInClass RATIO = addClass(Symbol.RATIO);
104: public static final BuiltInClass RATIONAL = addClass(Symbol.RATIONAL);
105: public static final BuiltInClass READER_ERROR = addClass(Symbol.READER_ERROR);
106: public static final BuiltInClass READTABLE = addClass(Symbol.READTABLE);
107: public static final BuiltInClass REAL = addClass(Symbol.REAL);
108: public static final BuiltInClass RESTART = addClass(Symbol.RESTART);
109: public static final BuiltInClass SEQUENCE = addClass(Symbol.SEQUENCE);
110: public static final BuiltInClass SERIOUS_CONDITION = addClass(Symbol.SERIOUS_CONDITION);
111: public static final BuiltInClass SIMPLE_CONDITION = addClass(Symbol.SIMPLE_CONDITION);
112: public static final BuiltInClass SIMPLE_ERROR = addClass(Symbol.SIMPLE_ERROR);
113: public static final BuiltInClass SIMPLE_TYPE_ERROR = addClass(Symbol.SIMPLE_TYPE_ERROR);
114: public static final BuiltInClass SIMPLE_WARNING = addClass(Symbol.SIMPLE_WARNING);
115: // public static final BuiltInClass STANDARD_CLASS = addClass(Symbol.STANDARD_CLASS);
116: // public static final BuiltInClass STANDARD_GENERIC_FUNCTION = addClass(Symbol.STANDARD_GENERIC_FUNCTION);
117: // public static final BuiltInClass STANDARD_METHOD = addClass(Symbol.STANDARD_METHOD);
118: // public static final BuiltInClass STANDARD_OBJECT = addClass(Symbol.STANDARD_OBJECT);
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 STREAM_ERROR = addClass(Symbol.STREAM_ERROR);
122: public static final BuiltInClass STRING = addClass(Symbol.STRING);
123: public static final BuiltInClass STRING_STREAM = addClass(Symbol.STRING_STREAM);
124: public static final BuiltInClass STRUCTURE_CLASS = addClass(Symbol.STRUCTURE_CLASS);
125: public static final BuiltInClass STRUCTURE_OBJECT = addClass(Symbol.STRUCTURE_OBJECT);
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 TYPE_ERROR = addClass(Symbol.TYPE_ERROR);
131: public static final BuiltInClass UNBOUND_SLOT = addClass(Symbol.UNBOUND_SLOT);
132: public static final BuiltInClass UNBOUND_VARIABLE = addClass(Symbol.UNBOUND_VARIABLE);
133: public static final BuiltInClass UNDEFINED_FUNCTION = addClass(Symbol.UNDEFINED_FUNCTION);
134: public static final BuiltInClass VECTOR = addClass(Symbol.VECTOR);
135: public static final BuiltInClass WARNING = addClass(Symbol.WARNING);
136:
137: public static final StandardClass STANDARD_CLASS = new StandardClass(
138: Symbol.STANDARD_CLASS, list1(CLASS_T));
139: static {
140: addClass(Symbol.STANDARD_CLASS, STANDARD_CLASS);
141: }
142:
143: public static final StandardClass STANDARD_OBJECT = new StandardClass(
144: Symbol.STANDARD_OBJECT, list1(CLASS_T));
145: static {
146: addClass(Symbol.STANDARD_OBJECT, STANDARD_OBJECT);
147: }
148:
149: public static final StandardClass CONDITION = new StandardClass(
150: Symbol.CONDITION, list1(STANDARD_OBJECT));
151: static {
152: addClass(Symbol.CONDITION, CONDITION);
153: }
154:
155: public static final StandardClass GENERIC_FUNCTION = new StandardClass(
156: Symbol.GENERIC_FUNCTION, list1(FUNCTION));
157: static {
158: addClass(Symbol.GENERIC_FUNCTION, GENERIC_FUNCTION);
159: }
160:
161: public static final StandardClass METHOD = new StandardClass(
162: Symbol.METHOD, list1(STANDARD_OBJECT));
163: static {
164: addClass(Symbol.METHOD, METHOD);
165: }
166:
167: static {
168: ARITHMETIC_ERROR.setDirectSuperclass(ERROR);
169: ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR,
170: SERIOUS_CONDITION, CONDITION, CLASS_T);
171: ARRAY.setDirectSuperclass(CLASS_T);
172: ARRAY.setCPL(ARRAY, CLASS_T);
173: BIGNUM.setDirectSuperclass(INTEGER);
174: BIGNUM.setCPL(BIGNUM, INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
175: BIT_VECTOR.setDirectSuperclass(VECTOR);
176: BIT_VECTOR.setCPL(BIT_VECTOR, VECTOR, ARRAY, SEQUENCE, CLASS_T);
177: BROADCAST_STREAM.setDirectSuperclass(STREAM);
178: BROADCAST_STREAM.setCPL(BROADCAST_STREAM, STREAM, CLASS_T);
179: BUILT_IN_CLASS.setDirectSuperclass(CLASS);
180: BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
181: CLASS_T);
182: CELL_ERROR.setDirectSuperclass(ERROR);
183: CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION,
184: CONDITION, CLASS_T);
185: CHARACTER.setDirectSuperclass(CLASS_T);
186: CHARACTER.setCPL(CHARACTER, CLASS_T);
187: CLASS.setDirectSuperclass(CLASS_T);
188: CLASS.setCPL(CLASS, STANDARD_OBJECT, CLASS_T);
189: COMPLEX.setDirectSuperclass(NUMBER);
190: COMPLEX.setCPL(COMPLEX, NUMBER, CLASS_T);
191: CONCATENATED_STREAM.setDirectSuperclass(STREAM);
192: CONCATENATED_STREAM
193: .setCPL(CONCATENATED_STREAM, STREAM, CLASS_T);
194: CONDITION.setDirectSuperclass(STANDARD_OBJECT);
195: CONDITION.setCPL(CONDITION, STANDARD_OBJECT, CLASS_T);
196: CONS.setDirectSuperclass(LIST);
197: CONS.setCPL(CONS, LIST, SEQUENCE, CLASS_T);
198: CONTROL_ERROR.setDirectSuperclass(ERROR);
199: CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION,
200: CONDITION, CLASS_T);
201: DIVISION_BY_ZERO.setDirectSuperclass(ARITHMETIC_ERROR);
202: DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR,
203: ERROR, SERIOUS_CONDITION, CONDITION, CLASS_T);
204: ECHO_STREAM.setDirectSuperclass(CLASS_T);
205: ECHO_STREAM.setCPL(ECHO_STREAM, CLASS_T);
206: END_OF_FILE.setDirectSuperclass(STREAM_ERROR);
207: END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR,
208: SERIOUS_CONDITION, CONDITION, CLASS_T);
209: ERROR.setDirectSuperclass(SERIOUS_CONDITION);
210: ERROR.setCPL(ERROR, SERIOUS_CONDITION, CONDITION, CLASS_T);
211: FIXNUM.setDirectSuperclass(INTEGER);
212: FIXNUM.setCPL(FIXNUM, INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
213: FILE_ERROR.setDirectSuperclass(ERROR);
214: FILE_ERROR.setCPL(FILE_ERROR, ERROR, SERIOUS_CONDITION,
215: CONDITION, CLASS_T);
216: FILE_STREAM.setDirectSuperclass(STREAM);
217: FILE_STREAM.setCPL(FILE_STREAM, STREAM, CLASS_T);
218: FLOAT.setDirectSuperclass(REAL);
219: FLOAT.setCPL(FLOAT, REAL, NUMBER, CLASS_T);
220: FLOATING_POINT_INEXACT.setDirectSuperclass(ARITHMETIC_ERROR);
221: FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT,
222: ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
223: CLASS_T);
224: FLOATING_POINT_INVALID_OPERATION
225: .setDirectSuperclass(ARITHMETIC_ERROR);
226: FLOATING_POINT_INVALID_OPERATION.setCPL(
227: FLOATING_POINT_INVALID_OPERATION, ARITHMETIC_ERROR,
228: ERROR, SERIOUS_CONDITION, CONDITION, CLASS_T);
229: FLOATING_POINT_OVERFLOW.setDirectSuperclass(ARITHMETIC_ERROR);
230: FLOATING_POINT_OVERFLOW.setCPL(FLOATING_POINT_OVERFLOW,
231: ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
232: CLASS_T);
233: FLOATING_POINT_UNDERFLOW.setDirectSuperclass(ARITHMETIC_ERROR);
234: FLOATING_POINT_UNDERFLOW.setCPL(FLOATING_POINT_UNDERFLOW,
235: ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
236: CLASS_T);
237: FUNCTION.setDirectSuperclass(CLASS_T);
238: FUNCTION.setCPL(FUNCTION, CLASS_T);
239: GENERIC_FUNCTION.setDirectSuperclass(FUNCTION);
240: GENERIC_FUNCTION.setCPL(GENERIC_FUNCTION, FUNCTION, CLASS_T);
241: HASH_TABLE.setDirectSuperclass(CLASS_T);
242: HASH_TABLE.setCPL(HASH_TABLE, CLASS_T);
243: INTEGER.setDirectSuperclass(RATIONAL);
244: INTEGER.setCPL(INTEGER, RATIONAL, REAL, NUMBER, CLASS_T);
245: LIST.setDirectSuperclass(SEQUENCE);
246: LIST.setCPL(LIST, SEQUENCE, CLASS_T);
247: LOGICAL_PATHNAME.setDirectSuperclass(PATHNAME);
248: LOGICAL_PATHNAME.setCPL(LOGICAL_PATHNAME, PATHNAME, CLASS_T);
249: METHOD.setDirectSuperclass(STANDARD_OBJECT);
250: METHOD.setCPL(METHOD, STANDARD_OBJECT, CLASS_T);
251: METHOD_COMBINATION.setDirectSuperclass(CLASS_T);
252: METHOD_COMBINATION.setCPL(METHOD_COMBINATION, CLASS_T);
253: NULL.setDirectSuperclass(LIST);
254: NULL.setCPL(NULL, SYMBOL, LIST, SEQUENCE, CLASS_T);
255: NUMBER.setDirectSuperclass(CLASS_T);
256: NUMBER.setCPL(NUMBER, CLASS_T);
257: PACKAGE.setDirectSuperclass(CLASS_T);
258: PACKAGE.setCPL(PACKAGE, CLASS_T);
259: PACKAGE_ERROR.setDirectSuperclass(ERROR);
260: PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION,
261: CONDITION, CLASS_T);
262: PARSE_ERROR.setDirectSuperclass(ERROR);
263: PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION,
264: CONDITION, CLASS_T);
265: PATHNAME.setDirectSuperclass(CLASS_T);
266: PATHNAME.setCPL(PATHNAME, CLASS_T);
267: PRINT_NOT_READABLE.setDirectSuperclass(ERROR);
268: PRINT_NOT_READABLE.setCPL(PRINT_NOT_READABLE, ERROR,
269: SERIOUS_CONDITION, CONDITION, CLASS_T);
270: PROGRAM_ERROR.setDirectSuperclass(ERROR);
271: PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION,
272: CONDITION, CLASS_T);
273: RANDOM_STATE.setDirectSuperclass(CLASS_T);
274: RANDOM_STATE.setCPL(RANDOM_STATE, CLASS_T);
275: RATIO.setDirectSuperclass(RATIONAL);
276: RATIO.setCPL(RATIO, RATIONAL, REAL, NUMBER, CLASS_T);
277: RATIONAL.setDirectSuperclass(REAL);
278: RATIONAL.setCPL(RATIONAL, REAL, NUMBER, CLASS_T);
279: READER_ERROR.setDirectSuperclasses(list2(PARSE_ERROR,
280: STREAM_ERROR));
281: READER_ERROR.setCPL(READER_ERROR, PARSE_ERROR, STREAM_ERROR,
282: ERROR, SERIOUS_CONDITION, CONDITION, CLASS_T);
283: READTABLE.setDirectSuperclass(CLASS_T);
284: READTABLE.setCPL(READTABLE, CLASS_T);
285: REAL.setDirectSuperclass(NUMBER);
286: REAL.setCPL(REAL, NUMBER, CLASS_T);
287: RESTART.setDirectSuperclass(CLASS_T);
288: RESTART.setCPL(RESTART, CLASS_T);
289: SEQUENCE.setDirectSuperclass(CLASS_T);
290: SEQUENCE.setCPL(SEQUENCE, CLASS_T);
291: SERIOUS_CONDITION.setDirectSuperclass(CONDITION);
292: SERIOUS_CONDITION.setCPL(SERIOUS_CONDITION, CONDITION, CLASS_T);
293: SIMPLE_CONDITION.setDirectSuperclass(CONDITION);
294: SIMPLE_CONDITION.setCPL(SIMPLE_CONDITION, CONDITION, CLASS_T);
295: SIMPLE_ERROR.setDirectSuperclass(ERROR);
296: SIMPLE_ERROR.setCPL(SIMPLE_ERROR, SIMPLE_CONDITION, ERROR,
297: SERIOUS_CONDITION, CONDITION, CLASS_T);
298: SIMPLE_TYPE_ERROR.setDirectSuperclasses(list2(SIMPLE_CONDITION,
299: TYPE_ERROR));
300: SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
301: TYPE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
302: CLASS_T);
303: SIMPLE_WARNING.setDirectSuperclasses(list2(SIMPLE_CONDITION,
304: WARNING));
305: SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION,
306: WARNING, CONDITION, CLASS_T);
307: STANDARD_CLASS.setDirectSuperclass(CLASS);
308: STANDARD_CLASS.setCPL(STANDARD_CLASS, CLASS, STANDARD_OBJECT,
309: CLASS_T);
310: // STANDARD_GENERIC_FUNCTION.setDirectSuperclass(GENERIC_FUNCTION);
311: // STANDARD_GENERIC_FUNCTION.setCPL(STANDARD_GENERIC_FUNCTION,
312: // GENERIC_FUNCTION, FUNCTION, CLASS_T);
313: // STANDARD_METHOD.setDirectSuperclass(list2(METHOD, STANDARD_OBJECT));
314: // STANDARD_METHOD.setCPL(STANDARD_METHOD, METHOD, STANDARD_OBJECT,
315: // CLASS_T);
316: // STANDARD_OBJECT.setDirectSuperclass(CLASS_T);
317: STANDARD_OBJECT.setCPL(STANDARD_OBJECT, CLASS_T);
318: STORAGE_CONDITION.setDirectSuperclass(SERIOUS_CONDITION);
319: STORAGE_CONDITION.setCPL(STORAGE_CONDITION, SERIOUS_CONDITION,
320: CONDITION, CLASS_T);
321: STREAM.setDirectSuperclass(CLASS_T);
322: STREAM.setCPL(STREAM, CLASS_T);
323: STREAM_ERROR.setDirectSuperclass(ERROR);
324: STREAM_ERROR.setCPL(STREAM_ERROR, ERROR, SERIOUS_CONDITION,
325: CONDITION, CLASS_T);
326: STRING.setDirectSuperclass(VECTOR);
327: STRING.setCPL(STRING, VECTOR, ARRAY, SEQUENCE, CLASS_T);
328: STRING_STREAM.setDirectSuperclass(STREAM);
329: STRING_STREAM.setCPL(STRING_STREAM, STREAM, CLASS_T);
330: STRUCTURE_CLASS.setDirectSuperclass(CLASS);
331: STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
332: CLASS_T);
333: STRUCTURE_OBJECT.setDirectSuperclass(CLASS_T);
334: STRUCTURE_OBJECT.setCPL(STRUCTURE_OBJECT, CLASS_T);
335: STYLE_WARNING.setDirectSuperclass(WARNING);
336: STYLE_WARNING
337: .setCPL(STYLE_WARNING, WARNING, CONDITION, CLASS_T);
338: SYMBOL.setDirectSuperclass(CLASS_T);
339: SYMBOL.setCPL(SYMBOL, CLASS_T);
340: SYNONYM_STREAM.setDirectSuperclass(STREAM);
341: SYNONYM_STREAM.setCPL(SYNONYM_STREAM, STREAM, CLASS_T);
342: TWO_WAY_STREAM.setDirectSuperclass(STREAM);
343: TWO_WAY_STREAM.setCPL(TWO_WAY_STREAM, STREAM, CLASS_T);
344: TYPE_ERROR.setDirectSuperclass(ERROR);
345: TYPE_ERROR.setCPL(TYPE_ERROR, ERROR, SERIOUS_CONDITION,
346: CONDITION, CLASS_T);
347: UNBOUND_SLOT.setDirectSuperclass(CELL_ERROR);
348: UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR,
349: SERIOUS_CONDITION, CONDITION, CLASS_T);
350: UNBOUND_VARIABLE.setDirectSuperclass(CELL_ERROR);
351: UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
352: SERIOUS_CONDITION, CONDITION, CLASS_T);
353: UNDEFINED_FUNCTION.setDirectSuperclass(CELL_ERROR);
354: UNDEFINED_FUNCTION.setCPL(UNDEFINED_FUNCTION, CELL_ERROR,
355: ERROR, SERIOUS_CONDITION, CONDITION, CLASS_T);
356: VECTOR.setDirectSuperclasses(list2(ARRAY, SEQUENCE));
357: VECTOR.setCPL(VECTOR, ARRAY, SEQUENCE, CLASS_T);
358: WARNING.setDirectSuperclass(CONDITION);
359: WARNING.setCPL(WARNING, CONDITION, CLASS_T);
360: }
361: }
|