Changeset 3929


Ignore:
Timestamp:
09/20/03 17:02:05 (19 years ago)
Author:
piso
Message:

LispClass? => BuiltInClass?

Location:
trunk/j/src/org/armedbear/lisp
Files:
33 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/AbstractArray.java

    r3883 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: AbstractArray.java,v 1.9 2003-09-19 01:46:39 piso Exp $
     5 * $Id: AbstractArray.java,v 1.10 2003-09-20 17:01:58 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2828        if (type == Symbol.ARRAY)
    2929            return T;
    30         if (type == LispClass.ARRAY)
     30        if (type == BuiltInClass.ARRAY)
    3131            return T;
    3232        return super.typep(type);
  • trunk/j/src/org/armedbear/lisp/AbstractVector.java

    r3894 r3929  
    2929        if (type == Symbol.VECTOR)
    3030            return T;
    31         if (type == LispClass.VECTOR)
     31        if (type == BuiltInClass.VECTOR)
    3232            return T;
    3333        if (type == Symbol.SEQUENCE)
    3434            return T;
    35         if (type == LispClass.SEQUENCE)
     35        if (type == BuiltInClass.SEQUENCE)
    3636            return T;
    3737        if (type == Symbol.SIMPLE_VECTOR)
  • trunk/j/src/org/armedbear/lisp/ArithmeticError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: ArithmeticError.java,v 1.5 2003-09-19 16:04:50 piso Exp $
     5 * $Id: ArithmeticError.java,v 1.6 2003-09-20 17:01:59 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.ARITHMETIC_ERROR;
     42        return BuiltInClass.ARITHMETIC_ERROR;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/Array.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Array.java,v 1.14 2003-09-19 14:44:10 piso Exp $
     5 * $Id: Array.java,v 1.15 2003-09-20 17:02:00 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    126126    public LispClass classOf()
    127127    {
    128         return LispClass.ARRAY;
     128        return BuiltInClass.ARRAY;
    129129    }
    130130
  • trunk/j/src/org/armedbear/lisp/Autoload.java

    r3884 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Autoload.java,v 1.69 2003-09-19 11:50:18 piso Exp $
     5 * $Id: Autoload.java,v 1.70 2003-09-20 17:02:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    209209        autoload("logorc2", "logorc2");
    210210        autoload("logxor", "logxor");
     211        autoload("make-condition", "make_condition");
    211212        autoload("make-string-output-stream", "StringOutputStream");
    212213        autoload("namestring", "Pathname");
     
    228229        autoload("unexport", "PackageFunctions");
    229230        autoload("unuse-package", "PackageFunctions");
     231        autoload(PACKAGE_SYS, "%define-condition", "define_condition");
    230232        autoload(PACKAGE_SYS, "%defpackage", "PackageFunctions");
    231233        autoload(PACKAGE_SYS, "%make-array", "make_array");
  • trunk/j/src/org/armedbear/lisp/Bignum.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Bignum.java,v 1.45 2003-09-19 14:44:10 piso Exp $
     5 * $Id: Bignum.java,v 1.46 2003-09-20 17:02:03 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4545    public LispClass classOf()
    4646    {
    47         return LispClass.BIGNUM;
     47        return BuiltInClass.BIGNUM;
    4848    }
    4949
     
    5252        if (type == Symbol.BIGNUM)
    5353            return T;
    54         if (type == LispClass.BIGNUM)
     54        if (type == BuiltInClass.BIGNUM)
    5555            return T;
    5656        if (type == Symbol.INTEGER)
    5757            return T;
    58         if (type == LispClass.INTEGER)
     58        if (type == BuiltInClass.INTEGER)
    5959            return T;
    6060        if (type == Symbol.RATIONAL)
    6161            return T;
    62         if (type == LispClass.RATIONAL)
     62        if (type == BuiltInClass.RATIONAL)
    6363            return T;
    6464        if (type == Symbol.REAL)
    6565            return T;
    66         if (type == LispClass.REAL)
     66        if (type == BuiltInClass.REAL)
    6767            return T;
    6868        if (type == Symbol.NUMBER)
    6969            return T;
    70         if (type == LispClass.NUMBER)
     70        if (type == BuiltInClass.NUMBER)
    7171            return T;
    7272        if (type == Symbol.UNSIGNED_BYTE)
  • trunk/j/src/org/armedbear/lisp/Complex.java

    r3884 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Complex.java,v 1.23 2003-09-19 11:50:18 piso Exp $
     5 * $Id: Complex.java,v 1.24 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6969    public LispClass classOf()
    7070    {
    71         return LispClass.COMPLEX;
    72     }
    73 
    74     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    75     {
    76         if (typeSpecifier == Symbol.COMPLEX)
    77             return T;
    78         if (typeSpecifier == Symbol.NUMBER)
    79             return T;
    80         if (typeSpecifier == LispClass.COMPLEX)
    81             return T;
    82         if (typeSpecifier == LispClass.NUMBER)
    83             return T;
    84         return super.typep(typeSpecifier);
     71        return BuiltInClass.COMPLEX;
     72    }
     73
     74    public LispObject typep(LispObject type) throws ConditionThrowable
     75    {
     76        if (type == Symbol.COMPLEX)
     77            return T;
     78        if (type == Symbol.NUMBER)
     79            return T;
     80        if (type == BuiltInClass.COMPLEX)
     81            return T;
     82        if (type == BuiltInClass.NUMBER)
     83            return T;
     84        return super.typep(type);
    8585    }
    8686
  • trunk/j/src/org/armedbear/lisp/Condition.java

    r3904 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Condition.java,v 1.8 2003-09-19 16:13:45 piso Exp $
     5 * $Id: Condition.java,v 1.9 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public class Condition extends LispObject
     24public class Condition extends StandardObject
    2525{
    2626    private final String message;
     
    4848    public LispClass classOf()
    4949    {
    50         return LispClass.CONDITION;
     50        return BuiltInClass.CONDITION;
    5151    }
    5252
  • trunk/j/src/org/armedbear/lisp/Cons.java

    r3884 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Cons.java,v 1.28 2003-09-19 11:50:18 piso Exp $
     5 * $Id: Cons.java,v 1.29 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848    public LispClass classOf()
    4949    {
    50         return LispClass.CONS;
     50        return BuiltInClass.CONS;
    5151    }
    5252
     
    5959        if (typeSpecifier == Symbol.SEQUENCE)
    6060            return T;
    61         if (typeSpecifier == LispClass.LIST)
    62             return T;
    63         if (typeSpecifier == LispClass.CONS)
    64             return T;
    65         if (typeSpecifier == LispClass.SEQUENCE)
     61        if (typeSpecifier == BuiltInClass.LIST)
     62            return T;
     63        if (typeSpecifier == BuiltInClass.CONS)
     64            return T;
     65        if (typeSpecifier == BuiltInClass.SEQUENCE)
    6666            return T;
    6767        if (typeSpecifier == Symbol.ATOM)
  • trunk/j/src/org/armedbear/lisp/ControlError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: ControlError.java,v 1.4 2003-09-19 16:04:50 piso Exp $
     5 * $Id: ControlError.java,v 1.5 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.CONTROL_ERROR;
     42        return BuiltInClass.CONTROL_ERROR;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/DisplacedArray.java

    r3884 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: DisplacedArray.java,v 1.12 2003-09-19 11:50:18 piso Exp $
     5 * $Id: DisplacedArray.java,v 1.13 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5959    public LispObject typep(LispObject type) throws ConditionThrowable
    6060    {
    61         if (type == Symbol.VECTOR || type == LispClass.VECTOR)
     61        if (type == Symbol.VECTOR || type == BuiltInClass.VECTOR)
    6262            return VECTORP();
    63         if (type == Symbol.BIT_VECTOR || type == LispClass.BIT_VECTOR)
     63        if (type == Symbol.BIT_VECTOR || type == BuiltInClass.BIT_VECTOR)
    6464            return BIT_VECTOR_P();
    65         if (type == Symbol.SEQUENCE || type == LispClass.SEQUENCE)
     65        if (type == Symbol.SEQUENCE || type == BuiltInClass.SEQUENCE)
    6666            return VECTORP();
    6767        return super.typep(type);
  • trunk/j/src/org/armedbear/lisp/Fixnum.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Fixnum.java,v 1.73 2003-09-19 14:44:10 piso Exp $
     5 * $Id: Fixnum.java,v 1.74 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4949    public LispClass classOf()
    5050    {
    51         return LispClass.FIXNUM;
     51        return BuiltInClass.FIXNUM;
    5252    }
    5353
     
    5656        if (type == Symbol.FIXNUM)
    5757            return T;
    58         if (type == LispClass.FIXNUM)
     58        if (type == BuiltInClass.FIXNUM)
    5959            return T;
    6060        if (type == Symbol.INTEGER)
    6161            return T;
    62         if (type == LispClass.INTEGER)
     62        if (type == BuiltInClass.INTEGER)
    6363            return T;
    6464        if (type == Symbol.RATIONAL)
    6565            return T;
    66         if (type == LispClass.RATIONAL)
     66        if (type == BuiltInClass.RATIONAL)
    6767            return T;
    6868        if (type == Symbol.REAL)
    6969            return T;
    70         if (type == LispClass.REAL)
     70        if (type == BuiltInClass.REAL)
    7171            return T;
    7272        if (type == Symbol.NUMBER)
    7373            return T;
    74         if (type == LispClass.NUMBER)
     74        if (type == BuiltInClass.NUMBER)
    7575            return T;
    7676        if (type == Symbol.UNSIGNED_BYTE)
  • trunk/j/src/org/armedbear/lisp/Function.java

    r3883 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Function.java,v 1.23 2003-09-19 01:46:40 piso Exp $
     5 * $Id: Function.java,v 1.24 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    104104    public LispClass classOf()
    105105    {
    106         return LispClass.FUNCTION;
     106        return BuiltInClass.FUNCTION;
    107107    }
    108108
     
    113113        if (typeSpecifier == Symbol.COMPILED_FUNCTION)
    114114            return T;
    115         if (typeSpecifier == LispClass.FUNCTION)
     115        if (typeSpecifier == BuiltInClass.FUNCTION)
    116116            return T;
    117117        return super.typep(typeSpecifier);
  • trunk/j/src/org/armedbear/lisp/HashTable.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: HashTable.java,v 1.20 2003-09-19 14:44:10 piso Exp $
     5 * $Id: HashTable.java,v 1.21 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6969    public LispClass classOf()
    7070    {
    71         return LispClass.HASH_TABLE;
    72     }
    73 
    74     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    75     {
    76         if (typeSpecifier == Symbol.HASH_TABLE)
     71        return BuiltInClass.HASH_TABLE;
     72    }
     73
     74    public LispObject typep(LispObject type) throws ConditionThrowable
     75    {
     76        if (type == Symbol.HASH_TABLE)
    7777            return T;
    78         if (typeSpecifier == LispClass.HASH_TABLE)
     78        if (type == BuiltInClass.HASH_TABLE)
    7979            return T;
    80         return super.typep(typeSpecifier);
     80        return super.typep(type);
    8181    }
    8282
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r3916 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Interpreter.java,v 1.35 2003-09-20 00:30:04 piso Exp $
     5 * $Id: Interpreter.java,v 1.36 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    210210                catch (ConditionThrowable c) {
    211211                    getStandardInput().clearInput();
     212                    getStandardOutput().freshLine();
    212213                    String message = c.getCondition().getMessage();
    213214                    if (message != null)
    214215                        out.writeLine("Error: " + message + ".");
    215216                    else
    216                         out.writeLine("Error");
     217                        out.writeLine("Error: unhandled condition: " + c.getCondition());
    217218                    thread.backtrace();
    218219                }
  • trunk/j/src/org/armedbear/lisp/LispCharacter.java

    r3884 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispCharacter.java,v 1.26 2003-09-19 11:50:18 piso Exp $
     5 * $Id: LispCharacter.java,v 1.27 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5555    public LispClass classOf()
    5656    {
    57         return LispClass.CHARACTER;
     57        return BuiltInClass.CHARACTER;
    5858    }
    5959
     
    6262        if (type == Symbol.CHARACTER)
    6363            return T;
    64         if (type == LispClass.CHARACTER)
     64        if (type == BuiltInClass.CHARACTER)
    6565            return T;
    6666        if (type == Symbol.BASE_CHAR)
  • trunk/j/src/org/armedbear/lisp/LispError.java

    r3921 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispError.java,v 1.6 2003-09-20 00:40:13 piso Exp $
     5 * $Id: LispError.java,v 1.7 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.ERROR;
     42        return BuiltInClass.ERROR;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispFloat.java,v 1.48 2003-09-19 14:44:10 piso Exp $
     5 * $Id: LispFloat.java,v 1.49 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4141    public LispClass classOf()
    4242    {
    43         return LispClass.FLOAT;
     43        return BuiltInClass.FLOAT;
    4444    }
    4545
     
    4848        if (typeSpecifier == Symbol.FLOAT)
    4949            return T;
    50         if (typeSpecifier == LispClass.FLOAT)
     50        if (typeSpecifier == BuiltInClass.FLOAT)
    5151            return T;
    5252        if (typeSpecifier == Symbol.REAL)
  • trunk/j/src/org/armedbear/lisp/LispObject.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispObject.java,v 1.59 2003-09-19 14:44:10 piso Exp $
     5 * $Id: LispObject.java,v 1.60 2003-09-20 17:02:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3636    public LispClass classOf()
    3737    {
    38         return LispClass.CLASS_T;
     38        return BuiltInClass.CLASS_T;
    3939    }
    4040
     
    4343        if (typeSpecifier == T)
    4444            return T;
    45         if (typeSpecifier == LispClass.CLASS_T)
     45        if (typeSpecifier == BuiltInClass.CLASS_T)
    4646            return T;
    4747        if (typeSpecifier == Symbol.ATOM)
  • trunk/j/src/org/armedbear/lisp/Package.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Package.java,v 1.46 2003-09-19 14:44:10 piso Exp $
     5 * $Id: Package.java,v 1.47 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5555    public LispClass classOf()
    5656    {
    57         return LispClass.PACKAGE;
    58     }
    59 
    60     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    61     {
    62         if (typeSpecifier == Symbol.PACKAGE)
     57        return BuiltInClass.PACKAGE;
     58    }
     59
     60    public LispObject typep(LispObject type) throws ConditionThrowable
     61    {
     62        if (type == Symbol.PACKAGE)
    6363            return T;
    64         if (typeSpecifier == LispClass.PACKAGE)
     64        if (type == BuiltInClass.PACKAGE)
    6565            return T;
    66         return super.typep(typeSpecifier);
     66        return super.typep(type);
    6767    }
    6868
  • trunk/j/src/org/armedbear/lisp/PackageError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: PackageError.java,v 1.5 2003-09-19 16:04:50 piso Exp $
     5 * $Id: PackageError.java,v 1.6 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.PACKAGE_ERROR;
     42        return BuiltInClass.PACKAGE_ERROR;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/ParseError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: ParseError.java,v 1.6 2003-09-19 16:04:50 piso Exp $
     5 * $Id: ParseError.java,v 1.7 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3636    public LispClass classOf()
    3737    {
    38         return LispClass.PARSE_ERROR;
     38        return BuiltInClass.PARSE_ERROR;
    3939    }
    4040
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r3924 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.418 2003-09-20 14:15:51 piso Exp $
     5 * $Id: Primitives.java,v 1.419 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    18261826        if (type == Symbol.SIMPLE_ERROR)
    18271827            return c.getCondition() instanceof SimpleError;
    1828         if (type == Symbol.ERROR || type == LispClass.ERROR) {
     1828        if (type == Symbol.ERROR || type == BuiltInClass.ERROR) {
    18291829            Condition condition = c.getCondition();
    18301830            if (condition.typep(Symbol.ERROR) == T)
  • trunk/j/src/org/armedbear/lisp/ProgramError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: ProgramError.java,v 1.8 2003-09-19 16:04:50 piso Exp $
     5 * $Id: ProgramError.java,v 1.9 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.PROGRAM_ERROR;
     42        return BuiltInClass.PROGRAM_ERROR;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/SimpleCondition.java

    r3918 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SimpleCondition.java,v 1.3 2003-09-20 00:38:41 piso Exp $
     5 * $Id: SimpleCondition.java,v 1.4 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.SIMPLE_CONDITION;
     42        return BuiltInClass.SIMPLE_CONDITION;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/SimpleError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SimpleError.java,v 1.3 2003-09-19 16:04:50 piso Exp $
     5 * $Id: SimpleError.java,v 1.4 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    public LispClass classOf()
    4141    {
    42         return LispClass.SIMPLE_ERROR;
     42        return BuiltInClass.SIMPLE_ERROR;
    4343    }
    4444
  • trunk/j/src/org/armedbear/lisp/StreamError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: StreamError.java,v 1.7 2003-09-19 16:04:50 piso Exp $
     5 * $Id: StreamError.java,v 1.8 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848    public LispClass classOf()
    4949    {
    50         return LispClass.STREAM_ERROR;
     50        return BuiltInClass.STREAM_ERROR;
    5151    }
    5252
  • trunk/j/src/org/armedbear/lisp/StructureObject.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StructureObject.java,v 1.12 2003-09-19 14:44:10 piso Exp $
     5 * $Id: StructureObject.java,v 1.13 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4646    }
    4747
    48     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    49     {
    50         if (typeSpecifier == name)
     48    public LispObject typep(LispObject type) throws ConditionThrowable
     49    {
     50        if (type == name)
    5151            return T;
    52         if (typeSpecifier == Symbol.STRUCTURE_OBJECT)
     52        if (type == Symbol.STRUCTURE_OBJECT)
    5353            return T;
    54         if (typeSpecifier == LispClass.STRUCTURE_OBJECT)
     54        if (type == BuiltInClass.STRUCTURE_OBJECT)
    5555            return T;
    56         return super.typep(typeSpecifier);
     56        return super.typep(type);
    5757    }
    5858
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Symbol.java,v 1.80 2003-09-19 16:04:50 piso Exp $
     5 * $Id: Symbol.java,v 1.81 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    183183    public LispClass classOf()
    184184    {
    185         return LispClass.SYMBOL;
    186     }
    187 
    188     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    189     {
    190         if (typeSpecifier == Symbol.SYMBOL)
     185        return BuiltInClass.SYMBOL;
     186    }
     187
     188    public LispObject typep(LispObject type) throws ConditionThrowable
     189    {
     190        if (type == Symbol.SYMBOL)
    191191            return T;
    192         if (typeSpecifier == Symbol.BOOLEAN)
     192        if (type == BuiltInClass.SYMBOL)
     193            return T;
     194        if (type == Symbol.BOOLEAN)
    193195            return this == T ? T : NIL;
    194         if (typeSpecifier instanceof LispClass) {
    195             final String name = typeSpecifier.getName();
    196             if (name.equals("SYMBOL"))
    197                 return T;
    198         }
    199         return super.typep(typeSpecifier);
     196        return super.typep(type);
    200197    }
    201198
  • trunk/j/src/org/armedbear/lisp/TypeError.java

    r3902 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: TypeError.java,v 1.6 2003-09-19 16:04:50 piso Exp $
     5 * $Id: TypeError.java,v 1.7 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5757    public LispClass classOf()
    5858    {
    59         return LispClass.TYPE_ERROR;
     59        return BuiltInClass.TYPE_ERROR;
    6060    }
    6161
  • trunk/j/src/org/armedbear/lisp/UnboundVariable.java

    r3901 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: UnboundVariable.java,v 1.1 2003-09-19 16:04:29 piso Exp $
     5 * $Id: UnboundVariable.java,v 1.2 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4545    public LispClass classOf()
    4646    {
    47         return LispClass.UNBOUND_VARIABLE;
     47        return BuiltInClass.UNBOUND_VARIABLE;
    4848    }
    4949
  • trunk/j/src/org/armedbear/lisp/UndefinedFunction.java

    r3899 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: UndefinedFunction.java,v 1.1 2003-09-19 15:50:19 piso Exp $
     5 * $Id: UndefinedFunction.java,v 1.2 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5252    public LispClass classOf()
    5353    {
    54         return LispClass.UNDEFINED_FUNCTION;
     54        return BuiltInClass.UNDEFINED_FUNCTION;
    5555    }
    5656
  • trunk/j/src/org/armedbear/lisp/Vector.java

    r3894 r3929  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Vector.java,v 1.25 2003-09-19 14:44:10 piso Exp $
     5 * $Id: Vector.java,v 1.26 2003-09-20 17:02:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5454    public LispClass classOf()
    5555    {
    56         return LispClass.VECTOR;
     56        return BuiltInClass.VECTOR;
    5757    }
    5858
Note: See TracChangeset for help on using the changeset viewer.