Changeset 5111


Ignore:
Timestamp:
12/12/03 19:41:51 (18 years ago)
Author:
piso
Message:

signal()

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

Legend:

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

    r4957 r5111  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: CharacterOutputStream.java,v 1.10 2003-12-04 03:18:49 piso Exp $
     5 * $Id: CharacterOutputStream.java,v 1.11 2003-12-12 19:41:51 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7171        }
    7272        catch (IOException e) {
    73             throw new ConditionThrowable(new StreamError(e));
     73            signal(new StreamError(e));
    7474        }
    7575        return NIL;
     
    8686        }
    8787        catch (IOException e) {
    88             throw new ConditionThrowable(new StreamError(e));
     88            signal(new StreamError(e));
    8989        }
    9090        return T;
     
    9797        }
    9898        catch (IOException e) {
    99             throw new ConditionThrowable(new StreamError(e));
     99            signal(new StreamError(e));
    100100        }
    101101    }
     
    112112        }
    113113        catch (IOException e) {
    114             throw new ConditionThrowable(new StreamError(e));
     114            signal(new StreamError(e));
    115115        }
    116116    }
     
    137137        }
    138138        catch (IOException e) {
    139             throw new ConditionThrowable(new StreamError(e));
     139            signal(new StreamError(e));
    140140        }
    141141    }
     
    159159        }
    160160        catch (IOException e) {
    161             throw new ConditionThrowable(new StreamError(e));
     161            signal(new StreamError(e));
    162162        }
    163163    }
     
    174174        }
    175175        catch (IOException e) {
    176             throw new ConditionThrowable(new StreamError(e));
     176            signal(new StreamError(e));
    177177        }
    178178    }
     
    196196        }
    197197        catch (IOException e) {
    198             throw new ConditionThrowable(new StreamError(e));
     198            signal(new StreamError(e));
    199199        }
    200200    }
     
    209209        }
    210210        catch (IOException e) {
    211             throw new ConditionThrowable(new StreamError(e));
     211            signal(new StreamError(e));
    212212        }
    213213    }
     
    225225        }
    226226        catch (IOException e) {
    227             throw new ConditionThrowable(new StreamError(e));
     227            signal(new StreamError(e));
    228228        }
    229229    }
     
    235235        }
    236236        catch (IOException e) {
    237             throw new ConditionThrowable(new StreamError(e));
     237            signal(new StreamError(e));
    238238        }
    239239    }
     
    247247        }
    248248        catch (IOException e) {
    249             throw new ConditionThrowable(new StreamError(e));
     249            return signal(new StreamError(e));
    250250        }
    251251    }
  • trunk/j/src/org/armedbear/lisp/Closure.java

    r4898 r5111  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Closure.java,v 1.60 2003-11-27 04:32:31 piso Exp $
     5 * $Id: Closure.java,v 1.61 2003-12-12 19:41:42 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9494                        maxArgs = -1;
    9595                        remaining = remaining.cdr();
    96                         if (remaining == NIL)
    97                             throw new ConditionThrowable(new LispError(
     96                        if (remaining == NIL) {
     97                            signal(new LispError(
    9898                                "&REST/&BODY must be followed by a variable"));
     99                        }
    99100                        Debug.assertTrue(restVar == null);
    100101                        try {
     
    102103                        }
    103104                        catch (ClassCastException e) {
    104                             throw new ConditionThrowable(new LispError(
     105                            signal(new LispError(
    105106                                "&REST/&BODY must be followed by a variable"));
    106107                        }
     
    267268        throws ConditionThrowable
    268269    {
    269         throw new ConditionThrowable(new LispError(String.valueOf(obj) +
    270             " may not be used as a variable in a lambda list"));
     270        signal(new LispError(String.valueOf(obj) +
     271                             " may not be used as a variable in a lambda list"));
    271272    }
    272273
     
    460461            // Fixed arity.
    461462            if (args.length != arity)
    462                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     463                signal(new WrongNumberOfArgumentsException(this));
    463464            return args;
    464465        }
    465466        // Not fixed arity.
    466467        if (args.length < minArgs)
    467             throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     468            signal(new WrongNumberOfArgumentsException(this));
    468469        Environment oldDynEnv = thread.getDynamicEnvironment();
    469470        Environment ext = new Environment(environment);
     
    534535            } else {
    535536                if ((argsLeft % 2) != 0)
    536                     throw new ConditionThrowable(new ProgramError("odd number of keyword arguments"));
     537                    signal(new ProgramError("odd number of keyword arguments"));
    537538                LispObject[] valueArray = new LispObject[keywordParameters.length];
    538539                boolean[] boundpArray = new boolean[keywordParameters.length];
     
    572573                    if (!allowOtherKeys &&
    573574                        (allowOtherKeysValue == null || allowOtherKeysValue == NIL))
    574                         throw new ConditionThrowable(new ProgramError("unrecognized keyword argument " +
    575                                                                       unrecognizedKeyword));
     575                        signal(new ProgramError("unrecognized keyword argument " +
     576                                                unrecognizedKeyword));
    576577                }
    577578                for (int n = 0; n < keywordParameters.length; n++) {
     
    619620            }
    620621            if (argsUsed < args.length) {
    621                 if (restVar == null) {
    622                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    623                 }
     622                if (restVar == null)
     623                    signal(new WrongNumberOfArgumentsException(this));
    624624            }
    625625        }
  • trunk/j/src/org/armedbear/lisp/Cons.java

    r4731 r5111  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Cons.java,v 1.33 2003-11-14 01:33:36 piso Exp $
     5 * $Id: Cons.java,v 1.34 2003-12-12 19:41:31 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    158158        }
    159159        catch (ClassCastException e) {
    160             throw new ConditionThrowable(new TypeError(obj, "list"));
     160            signal(new TypeError(obj, "list"));
    161161        }
    162162        return length;
     
    166166    {
    167167        if (index < 0) {
    168             throw new ConditionThrowable(new TypeError("ELT: invalid index " + index + " for " +
    169                                                        this));
     168            signal(new TypeError("ELT: invalid index " + index + " for " +
     169                                 this));
    170170        }
    171171        int i = 0;
     
    181181        catch (ClassCastException e) {
    182182            if (cons.cdr == NIL)
    183                 throw new ConditionThrowable(new TypeError("ELT: invalid index " + index + " for " +
    184                                                            this));
     183                signal(new TypeError("ELT: invalid index " + index + " for " +
     184                                     this));
    185185            else
    186                 throw new ConditionThrowable(new TypeError(this, "proper sequence"));
     186                signal(new TypeError(this, "proper sequence"));
     187            // Not reached.
     188            return NIL;
    187189        }
    188190    }
  • trunk/j/src/org/armedbear/lisp/Java.java

    r5020 r5111  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Java.java,v 1.27 2003-12-08 04:50:30 piso Exp $
     5 * $Id: Java.java,v 1.28 2003-12-12 19:41:20 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3939            }
    4040            catch (ClassNotFoundException e) {
    41                 throw new ConditionThrowable(new LispError("class not found: " + arg));
    42             }
    43             catch (Throwable t) {
    44                 throw new ConditionThrowable(new LispError(getMessage(t)));
    45             }
     41                signal(new LispError("class not found: " + arg));
     42            }
     43            catch (Throwable t) {
     44                signal(new LispError(getMessage(t)));
     45            }
     46            // Not reached.
     47            return NIL;
    4648        }
    4749    };
     
    8082        {
    8183            if (args.length < 2 || args.length > 4)
    82                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     84                signal(new WrongNumberOfArgumentsException(this));
    8385            String fieldName = null;
    8486            Class c;
     
    132134            }
    133135            catch (ClassNotFoundException e) {
    134                 throw new ConditionThrowable(new LispError("class not found: " +
    135                                                            e.getMessage()));
     136                signal(new LispError("class not found: " + e.getMessage()));
    136137            }
    137138            catch (NoSuchFieldException e) {
    138                 throw new ConditionThrowable(new LispError("no such field"));
     139                signal(new LispError("no such field"));
    139140            }
    140141            catch (SecurityException e) {
    141                 throw new ConditionThrowable(new LispError("inaccessible field"));
     142                signal(new LispError("inaccessible field"));
    142143            }
    143144            catch (IllegalAccessException e) {
    144                 throw new ConditionThrowable(new LispError("illegal access"));
     145                signal(new LispError("illegal access"));
    145146            }
    146147            catch (IllegalArgumentException e) {
    147                 throw new ConditionThrowable(new LispError("illegal argument"));
    148             }
    149             catch (Throwable t) {
    150                 throw new ConditionThrowable(new LispError(getMessage(t)));
    151             }
     148                signal(new LispError("illegal argument"));
     149            }
     150            catch (Throwable t) {
     151                signal(new LispError(getMessage(t)));
     152            }
     153            // Not reached.
     154            return NIL;
    152155        }
    153156    };
     
    161164        {
    162165            if (args.length < 1)
    163                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     166                signal(new WrongNumberOfArgumentsException(this));
    164167            try {
    165168                final Class c = forClassRef(args[0]);
     
    184187            }
    185188            catch (ClassNotFoundException e) {
    186                 throw new ConditionThrowable(new LispError("class not found: " + e.getMessage()));
     189                signal(new LispError("class not found: " + e.getMessage()));
    187190            }
    188191            catch (NoSuchMethodException e) {
    189                 throw new ConditionThrowable(new LispError("no such constructor"));
     192                signal(new LispError("no such constructor"));
    190193            }
    191194            catch (ConditionThrowable e) {
     
    193196            }
    194197            catch (Throwable t) {
    195                 throw new ConditionThrowable(new LispError(getMessage(t)));
    196             }
     198                signal(new LispError(getMessage(t)));
     199            }
     200            // Not reached.
     201            return NIL;
    197202        }
    198203    };
     
    205210        {
    206211            if (args.length < 2)
    207                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     212                signal(new WrongNumberOfArgumentsException(this));
    208213            String methodName = LispString.getValue(args[1]);
    209214            try {
     
    231236            }
    232237            catch (ClassNotFoundException e) {
    233                 throw new ConditionThrowable(new LispError("class not found: " + e.getMessage()));
     238                signal(new LispError("class not found: " + e.getMessage()));
    234239            }
    235240            catch (NoSuchMethodException e) {
    236                 throw new ConditionThrowable(new LispError("no such method: " + methodName));
     241                signal(new LispError("no such method: " + methodName));
    237242            }
    238243            catch (ConditionThrowable e) {
     
    240245            }
    241246            catch (Throwable t) {
    242                 throw new ConditionThrowable(new LispError(getMessage(t)));
    243             }
     247                signal(new LispError(getMessage(t)));
     248            }
     249            // Not reached.
     250            return NIL;
    244251        }
    245252    };
     
    252259        {
    253260            if (args.length < 2)
    254                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     261                signal(new WrongNumberOfArgumentsException(this));
    255262            try {
    256263                Method m = null;
     
    275282                        }
    276283                        if (m == null)
    277                             throw new ConditionThrowable(new LispError("no such method"));
     284                            signal(new LispError("no such method"));
    278285                    }
    279286                } else
    280                     throw new ConditionThrowable(new TypeError("wrong type: " + methodRef));
     287                    signal(new TypeError("wrong type: " + methodRef));
    281288                Object[] methodArgs = new Object[args.length-2];
    282289                for (int i = 2; i < args.length; i++) {
     
    287294            }
    288295            catch (Throwable t) {
    289                 throw new ConditionThrowable(new LispError(getMessage(t)));
    290             }
     296                signal(new LispError(getMessage(t)));
     297            }
     298            // Not reached.
     299            return NIL;
    291300        }
    292301    };
     
    299308        {
    300309            if (args.length < 1)
    301                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     310                signal(new WrongNumberOfArgumentsException(this));
    302311            LispObject classRef = args[0];
    303312            try {
     
    310319            }
    311320            catch (Throwable t) {
    312                 throw new ConditionThrowable(new LispError(getMessage(t)));
    313             }
     321                signal(new LispError(getMessage(t)));
     322            }
     323            // Not reached.
     324            return NIL;
    314325        }
    315326    };
     
    322333        {
    323334            if (args.length < 2)
    324                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     335                signal(new WrongNumberOfArgumentsException(this));
    325336            try {
    326337                Method method = (Method) JavaObject.getObject(args[0]);
     
    338349            }
    339350            catch (Throwable t) {
    340                 throw new ConditionThrowable(new LispError(getMessage(t)));
    341             }
     351                signal(new LispError(getMessage(t)));
     352            }
     353            // Not reached.
     354            return NIL;
    342355        }
    343356    };
     
    350363        {
    351364            if (args.length < 1)
    352                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     365                signal(new WrongNumberOfArgumentsException(this));
    353366            LispObject object = args[0];
    354367            try {
     
    366379            }
    367380            catch (Throwable t) {
    368                 throw new ConditionThrowable(new LispError("MAKE-IMMEDIATE-OBJECT: not implemented"));
    369             }
     381                signal(new LispError("MAKE-IMMEDIATE-OBJECT: not implemented"));
     382            }
     383            // Not reached.
     384            return NIL;
    370385        }
    371386    };
     
    410425            }
    411426        catch (ClassCastException e) {
    412             throw new ConditionThrowable(new TypeError(classRef, "Java class"));
     427            signal(new TypeError(classRef, "Java class"));
    413428        }
    414429        catch (ConditionThrowable e) {
    415430            throw new ClassNotFoundException(e.getMessage());
    416431        }
     432        // Not reached.
     433        return null;
    417434    }
    418435
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r5108 r5111  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Lisp.java,v 1.189 2003-12-12 19:12:51 piso Exp $
     5 * $Id: Lisp.java,v 1.190 2003-12-12 19:40:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    308308                if (debug)
    309309                    thread.saveBacktrace();
    310                 throw new ConditionThrowable(new LispError("stack overflow"));
     310                signal(new LispError("stack overflow"));
     311                // Not reached.
     312                return NIL;
    311313            }
    312314            catch (ConditionThrowable t) {
     
    367369                result = obj.getSymbolValue();
    368370                if (result == null)
    369                     throw new ConditionThrowable(new UnboundVariable(obj));
     371                    return signal(new UnboundVariable(obj));
    370372            }
    371373            if (result instanceof SymbolMacro)
     
    377379                LispObject fun = env.lookupFunctional(first);
    378380                if (fun == null)
    379                     throw new ConditionThrowable(new UndefinedFunction(first));
     381                    return signal(new UndefinedFunction(first));
    380382                switch (fun.getFunctionalType()) {
    381383                    case FTYPE_SPECIAL_OPERATOR: {
     
    436438                LispObject args = obj.cdr();
    437439                if (!args.listp())
    438                     throw new ConditionThrowable(new TypeError(args, "list"));
     440                    return signal(new TypeError(args, "list"));
    439441                LispObject funcar = first.car();
    440442                LispObject rest = first.cdr();
     
    444446                    return closure.execute(evalList(args, env, thread));
    445447                } else
    446                     throw new ConditionThrowable(new ProgramError("illegal function object: " + first));
     448                    return signal(new ProgramError("illegal function object: " + first));
    447449            }
    448450        } else
     
    621623        }
    622624        catch (ClassCastException e) {
    623             throw new ConditionThrowable(new TypeError(obj, "symbol"));
     625            signal(new TypeError(obj, "symbol"));
     626            // Not reached.
     627            return null;
    624628        }
    625629    }
     
    633637        }
    634638        catch (ClassCastException e) {
    635             throw new ConditionThrowable(new TypeError(obj, "cons"));
     639            signal(new TypeError(obj, "cons"));
     640            // Not reached.
     641            return null;
    636642        }
    637643    }
     
    644650        if (obj.listp())
    645651            return obj;
    646         throw new ConditionThrowable(new TypeError(obj, "list"));
     652        return signal(new TypeError(obj, "list"));
    647653    }
    648654
     
    656662        }
    657663        catch (ClassCastException e) {
    658             throw new ConditionThrowable(new TypeError(obj, "array"));
     664            signal(new TypeError(obj, "array"));
     665            // Not reached.
     666            return null;
    659667        }
    660668    }
     
    669677        }
    670678        catch (ClassCastException e) {
    671             throw new ConditionThrowable(new TypeError(obj, "vector"));
     679            signal(new TypeError(obj, "vector"));
     680            // Not reached.
     681            return null;
    672682        }
    673683    }
     
    682692        }
    683693        catch (ClassCastException e) {
    684             throw new ConditionThrowable(new TypeError(obj, "string"));
     694            signal(new TypeError(obj, "string"));
     695            // Not reached.
     696            return null;
    685697        }
    686698    }
     
    694706        if (arg instanceof LispCharacter)
    695707            return new LispString(((LispCharacter)arg).getValue());
    696         throw new ConditionThrowable(new TypeError(String.valueOf(arg) +
    697                                                    " cannot be coerced to a string"));
     708        signal(new TypeError(String.valueOf(arg) + " cannot be coerced to a string"));
     709        // Not reached.
     710        return null;
    698711    }
    699712
     
    706719        if (arg instanceof LispCharacter)
    707720            return String.valueOf(new char[] {((LispCharacter)arg).getValue()});
    708         throw new ConditionThrowable(new TypeError(String.valueOf(arg) +
    709                                                    " cannot be coerced to a string"));
     721        signal(new TypeError(String.valueOf(arg) + " cannot be coerced to a string"));
     722        // Not reached.
     723        return null;
    710724    }
    711725
     
    714728        if (n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE)
    715729            return new Fixnum((int)n);
    716         return new Bignum(n);
     730        else
     731            return new Bignum(n);
    717732    }
    718733
     
    725740    {
    726741        if (denominator.signum() == 0)
    727             throw new ConditionThrowable(new DivisionByZero());
     742            signal(new DivisionByZero());
    728743        if (denominator.signum() < 0) {
    729744            numerator = numerator.negate();
     
    737752        if (denominator.equals(BigInteger.ONE))
    738753            return number(numerator);
    739         return new Ratio(numerator, denominator);
     754        else
     755            return new Ratio(numerator, denominator);
    740756    }
    741757
     
    744760        if (n.compareTo(INT_MIN) >= 0 && n.compareTo(INT_MAX) <= 0)
    745761            return new Fixnum(n.intValue());
    746         return new Bignum(n);
     762        else
     763            return new Bignum(n);
    747764    }
    748765
     
    800817        }
    801818        catch (ClassCastException e) {
    802             throw new ConditionThrowable(new TypeError(obj, "character"));
     819            signal(new TypeError(obj, "character"));
     820            // Not reached.
     821            return null;
    803822        }
    804823    }
     
    813832        }
    814833        catch (ClassCastException e) {
    815             throw new ConditionThrowable(new TypeError(obj, "package"));
     834            signal(new TypeError(obj, "package"));
     835            // Not reached.
     836            return null;
    816837        }
    817838    }
     
    826847        }
    827848        catch (ClassCastException e) {
    828             throw new ConditionThrowable(new TypeError(obj, "function"));
     849            signal(new TypeError(obj, "function"));
     850            // Not reached.
     851            return null;
    829852        }
    830853    }
     
    839862        }
    840863        catch (ClassCastException e) {
    841             throw new ConditionThrowable(new TypeError(obj, "stream"));
     864            signal(new TypeError(obj, "stream"));
     865            // Not reached.
     866            return null;
    842867        }
    843868    }
     
    855880                return (CharacterInputStream) in;
    856881        }
    857         throw new ConditionThrowable(new TypeError(obj, "character input stream"));
     882        signal(new TypeError(obj, "character input stream"));
     883        // Not reached.
     884        return null;
    858885    }
    859886
     
    870897                return (CharacterOutputStream) out;
    871898        }
    872         throw new ConditionThrowable(new TypeError(obj, "character output stream"));
     899        signal(new TypeError(obj, "character output stream"));
     900        // Not reached.
     901        return null;
    873902    }
    874903
     
    885914                return (BinaryInputStream) in;
    886915        }
    887         throw new ConditionThrowable(new TypeError(obj, "binary input stream"));
     916        signal(new TypeError(obj, "binary input stream"));
     917        // Not reached.
     918        return null;
    888919    }
    889920
     
    900931                return (BinaryOutputStream) out;
    901932        }
    902         throw new ConditionThrowable(new TypeError(obj, "binary output stream"));
     933        signal(new TypeError(obj, "binary output stream"));
     934        // Not reached.
     935        return null;
    903936    }
    904937
     
    917950                return (CharacterInputStream) in;
    918951        }
    919         throw new ConditionThrowable(new TypeError(obj, "character input stream"));
     952        signal(new TypeError(obj, "character input stream"));
     953        // Not reached.
     954        return null;
    920955    }
    921956
     
    934969                return (CharacterOutputStream) out;
    935970        }
    936         throw new ConditionThrowable(new TypeError(obj, "character output stream"));
     971        signal(new TypeError(obj, "character output stream"));
     972        // Not reached.
     973        return null;
    937974    }
    938975
     
    946983        }
    947984        catch (ClassCastException e) {
    948             throw new ConditionThrowable(new TypeError(obj, "readtable"));
     985            signal(new TypeError(obj, "readtable"));
     986            // Not reached.
     987            return null;
    949988        }
    950989    }
     
    959998        }
    960999        catch (ClassCastException e) {
    961             throw new ConditionThrowable(new TypeError(obj, "environment"));
     1000            signal(new TypeError(obj, "environment"));
     1001            // Not reached.
     1002            return null;
    9621003        }
    9631004    }
     
    9741015        } else if (obj instanceof Cons && obj.car() == Symbol.LAMBDA)
    9751016            return new Closure(obj.cadr(), obj.cddr(), new Environment());
    976         throw new ConditionThrowable(new UndefinedFunction(obj));
     1017        signal(new UndefinedFunction(obj));
     1018        // Not reached.
     1019        return null;
    9771020    }
    9781021
     
    9881031        } else if (obj instanceof Cons && obj.car() == Symbol.LAMBDA)
    9891032            return new Closure(obj.cadr(), obj.cddr(), new Environment());
    990         throw new ConditionThrowable(new UndefinedFunction(obj));
     1033        signal(new UndefinedFunction(obj));
     1034        // Not reached.
     1035        return null;
    9911036    }
    9921037
     
    10001045        if (pkg != null)
    10011046            return pkg;
    1002         throw new ConditionThrowable(new PackageError(obj + " is not the name of a package"));
     1047        signal(new PackageError(obj + " is not the name of a package"));
     1048        // Not reached.
     1049        return null;
    10031050    }
    10041051
     
    10261073                list = list.cddr();
    10271074            else
    1028                 throw new ConditionThrowable(new TypeError("malformed property list: " + plist));
     1075                signal(new TypeError("malformed property list: " + plist));
    10291076        }
    10301077        return defaultValue;
     
    10851132        while (list != NIL) {
    10861133            if (!(list.cdr() instanceof Cons))
    1087                 throw new ConditionThrowable(new ProgramError(String.valueOf(symbol) +
     1134                signal(new ProgramError(String.valueOf(symbol) +
    10881135                                                              " has an odd number of items in its property list"));
    10891136            if (list.car() == indicator) {
     
    11811228        Package pkg = Packages.findPackage(packageName);
    11821229        if (pkg == null)
    1183             throw new ConditionThrowable(new LispError(packageName +
     1230            signal(new LispError(packageName +
    11841231                                                       " is not the name of a package"));
    11851232        return pkg.intern(name);
  • trunk/j/src/org/armedbear/lisp/LispObject.java

    r4920 r5111  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispObject.java,v 1.65 2003-11-30 05:53:22 piso Exp $
     5 * $Id: LispObject.java,v 1.66 2003-12-12 19:41:06 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7272    public Object javaInstance() throws ConditionThrowable
    7373    {
    74         throw new ConditionThrowable(new TypeError(this, "primitive type"));
     74        return signal(new TypeError(this, "primitive type"));
    7575    }
    7676
    7777    public LispObject car() throws ConditionThrowable
    7878    {
    79         throw new ConditionThrowable(new TypeError(this, "list"));
     79        return signal(new TypeError(this, "list"));
    8080    }
    8181
    8282    public void setCar(LispObject obj) throws ConditionThrowable
    8383    {
    84         throw new ConditionThrowable(new TypeError(this, "cons"));
     84        signal(new TypeError(this, "cons"));
    8585    }
    8686
    8787    public LispObject cdr() throws ConditionThrowable
    8888    {
    89         throw new ConditionThrowable(new TypeError(this, "list"));
     89        return signal(new TypeError(this, "list"));
    9090    }
    9191
    9292    public void setCdr(LispObject obj) throws ConditionThrowable
    9393    {
    94         throw new ConditionThrowable(new TypeError(this, "cons"));
     94        signal(new TypeError(this, "cons"));
    9595    }
    9696
    9797    public LispObject cadr() throws ConditionThrowable
    9898    {
    99         throw new ConditionThrowable(new TypeError(this, "list"));
     99        return signal(new TypeError(this, "list"));
    100100    }
    101101
    102102    public LispObject cddr() throws ConditionThrowable
    103103    {
    104         throw new ConditionThrowable(new TypeError(this, "list"));
     104        return signal(new TypeError(this, "list"));
    105105    }
    106106
     
    132132    public LispObject ABS() throws ConditionThrowable
    133133    {
    134         throw new ConditionThrowable(new TypeError(this, "number"));
     134        return signal(new TypeError(this, "number"));
    135135    }
    136136
    137137    public LispObject NUMERATOR() throws ConditionThrowable
    138138    {
    139         throw new ConditionThrowable(new TypeError(this, "rational number"));
     139        return signal(new TypeError(this, "rational number"));
    140140    }
    141141
    142142    public LispObject DENOMINATOR() throws ConditionThrowable
    143143    {
    144         throw new ConditionThrowable(new TypeError(this, "rational number"));
     144        return signal(new TypeError(this, "rational number"));
    145145    }
    146146
     
    152152    public boolean evenp() throws ConditionThrowable
    153153    {
    154         throw new ConditionThrowable(new TypeError(this, "integer"));
     154        signal(new TypeError(this, "integer"));
     155        // Not reached.
     156        return false;
    155157    }
    156158
     
    162164    public boolean oddp() throws ConditionThrowable
    163165    {
    164         throw new ConditionThrowable(new TypeError(this, "integer"));
     166        signal(new TypeError(this, "integer"));
     167        // Not reached.
     168        return false;
    165169    }
    166170
     
    172176    public boolean plusp() throws ConditionThrowable
    173177    {
    174         throw new ConditionThrowable(new TypeError(this, "real number"));
     178        signal(new TypeError(this, "real number"));
     179        // Not reached.
     180        return false;
    175181    }
    176182
     
    182188    public boolean minusp() throws ConditionThrowable
    183189    {
    184         throw new ConditionThrowable(new TypeError(this, "real number"));
     190        signal(new TypeError(this, "real number"));
     191        // Not reached.
     192        return false;
    185193    }
    186194
     
    202210    public boolean zerop() throws ConditionThrowable
    203211    {
    204         throw new ConditionThrowable(new TypeError(this, "number"));
     212        signal(new TypeError(this, "number"));
     213        // Not reached.
     214        return false;
    205215    }
    206216
     
    277287    public int length() throws ConditionThrowable
    278288    {
    279         throw new ConditionThrowable(new TypeError(this, "sequence"));
     289        signal(new TypeError(this, "sequence"));
     290        // Not reached.
     291        return 0;
    280292    }
    281293
     
    287299    public LispObject elt(int index) throws ConditionThrowable
    288300    {
    289         throw new ConditionThrowable(new TypeError(this, "sequence"));
     301        return signal(new TypeError(this, "sequence"));
    290302    }
    291303
    292304    public LispObject nreverse() throws ConditionThrowable
    293305    {
    294         throw new ConditionThrowable(new TypeError(this, "sequence"));
     306        return signal(new TypeError(this, "sequence"));
    295307    }
    296308
    297309    public LispObject AREF(LispObject index) throws ConditionThrowable
    298310    {
    299         throw new ConditionThrowable(new TypeError(this, "array"));
     311        return signal(new TypeError(this, "array"));
    300312    }
    301313
    302314    public LispObject[] copyToArray() throws ConditionThrowable
    303315    {
    304         throw new ConditionThrowable(new TypeError(this, "list"));
     316        signal(new TypeError(this, "list"));
     317        // Not reached.
     318        return null;
    305319    }
    306320
     
    322336    public LispObject ENDP() throws ConditionThrowable
    323337    {
    324         throw new ConditionThrowable(new TypeError(this, "list"));
     338        return signal(new TypeError(this, "list"));
    325339    }
    326340
     
    337351    public LispObject getSymbolValue() throws ConditionThrowable
    338352    {
    339         throw new ConditionThrowable(new TypeError(this, "symbol"));
     353        return signal(new TypeError(this, "symbol"));
    340354    }
    341355
    342356    public LispObject getSymbolFunction() throws ConditionThrowable
    343357    {
    344         throw new ConditionThrowable(new TypeError(this, "symbol"));
     358        return signal(new TypeError(this, "symbol"));
    345359    }
    346360
    347361    public LispObject getSymbolFunctionOrDie() throws ConditionThrowable
    348362    {
    349         throw new ConditionThrowable(new TypeError(this, "symbol"));
     363        return signal(new TypeError(this, "symbol"));
    350364    }
    351365
     
    369383        throws ConditionThrowable
    370384    {
    371         throw new ConditionThrowable(new LispError());
     385        return signal(new LispError());
    372386    }
    373387
     
    375389    public LispObject execute(LispObject[] args) throws ConditionThrowable
    376390    {
    377         throw new ConditionThrowable(new LispError());
     391        return signal(new LispError());
    378392    }
    379393
     
    381395    public LispObject execute() throws ConditionThrowable
    382396    {
    383         throw new ConditionThrowable(new LispError());
     397        return signal(new LispError());
    384398    }
    385399
     
    387401    public LispObject execute(LispObject arg) throws ConditionThrowable
    388402    {
    389         throw new ConditionThrowable(new LispError());
     403        return signal(new LispError());
    390404    }
    391405
     
    394408        throws ConditionThrowable
    395409    {
    396         throw new ConditionThrowable(new LispError());
     410        return signal(new LispError());
    397411    }
    398412
     
    401415        LispObject third) throws ConditionThrowable
    402416    {
    403         throw new ConditionThrowable(new LispError());
     417        return signal(new LispError());
    404418    }
    405419
    406420    public LispObject incr() throws ConditionThrowable
    407421    {
    408         throw new ConditionThrowable(new TypeError(this, "number"));
     422        return signal(new TypeError(this, "number"));
    409423    }
    410424
    411425    public LispObject decr() throws ConditionThrowable
    412426    {
    413         throw new ConditionThrowable(new TypeError(this, "number"));
     427        return signal(new TypeError(this, "number"));
    414428    }
    415429
    416430    public LispObject add(LispObject obj) throws ConditionThrowable
    417431    {
    418         throw new ConditionThrowable(new TypeError(this, "number"));
     432        return signal(new TypeError(this, "number"));
    419433    }
    420434
    421435    public LispObject subtract(LispObject obj) throws ConditionThrowable
    422436    {
    423         throw new ConditionThrowable(new TypeError(this, "number"));
     437        return signal(new TypeError(this, "number"));
    424438    }
    425439
    426440    public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
    427441    {
    428         throw new ConditionThrowable(new TypeError(this, "number"));
     442        return signal(new TypeError(this, "number"));
    429443    }
    430444
    431445    public LispObject divideBy(LispObject obj) throws ConditionThrowable
    432446    {
    433         throw new ConditionThrowable(new TypeError(this, "number"));
     447        return signal(new TypeError(this, "number"));
    434448    }
    435449
    436450    public boolean isEqualTo(LispObject obj) throws ConditionThrowable
    437451    {
    438         throw new ConditionThrowable(new TypeError(this, "number"));
     452        signal(new TypeError(this, "number"));
     453        // Not reached.
     454        return false;
    439455    }
    440456
     
    446462    public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
    447463    {
    448         throw new ConditionThrowable(new TypeError(this, "number"));
     464        signal(new TypeError(this, "number"));
     465        // Not reached.
     466        return false;
    449467    }
    450468
     
    456474    public boolean isLessThan(LispObject obj) throws ConditionThrowable
    457475    {
    458         throw new ConditionThrowable(new TypeError(this, "number"));
     476        signal(new TypeError(this, "number"));
     477        // Not reached.
     478        return false;
    459479    }
    460480
     
    466486    public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
    467487    {
    468         throw new ConditionThrowable(new TypeError(this, "number"));
     488        signal(new TypeError(this, "number"));
     489        // Not reached.
     490        return false;
    469491    }
    470492
     
    476498    public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
    477499    {
    478         throw new ConditionThrowable(new TypeError(this, "number"));
     500        signal(new TypeError(this, "number"));
     501        // Not reached.
     502        return false;
    479503    }
    480504
     
    486510    public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
    487511    {
    488         throw new ConditionThrowable(new TypeError(this, "number"));
     512        signal(new TypeError(this, "number"));
     513        // Not reached.
     514        return false;
    489515    }
    490516
     
    496522    public LispObject truncate(LispObject obj) throws ConditionThrowable
    497523    {
    498         throw new ConditionThrowable(new TypeError(this, "real number"));
     524        return signal(new TypeError(this, "real number"));
    499525    }
    500526
Note: See TracChangeset for help on using the changeset viewer.