Changeset 5107


Ignore:
Timestamp:
12/12/03 18:48:53 (17 years ago)
Author:
piso
Message:

signal()

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

Legend:

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

    r5101 r5107  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Lisp.java,v 1.187 2003-12-12 17:28:24 piso Exp $
     5 * $Id: Lisp.java,v 1.188 2003-12-12 18:48:45 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    336336        }
    337337    };
     338
     339    public static final void signal(Condition condition) throws ConditionThrowable
     340    {
     341        throw new ConditionThrowable(condition);
     342    }
    338343
    339344    public static final LispObject eval(final LispObject obj,
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r5106 r5107  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.525 2003-12-12 17:32:04 piso Exp $
     5 * $Id: Primitives.java,v 1.526 2003-12-12 18:48:53 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4141            if (arg.numberp())
    4242                return arg;
    43             throw new ConditionThrowable(new TypeError(arg, "number"));
     43            signal(new TypeError(arg, "number"));
     44            return NIL;
    4445        }
    4546        public LispObject execute(LispObject first, LispObject second)
     
    6263        public LispObject execute() throws ConditionThrowable
    6364        {
    64             throw new ConditionThrowable(new WrongNumberOfArgumentsException("/"));
     65            signal(new WrongNumberOfArgumentsException("/"));
     66            return NIL;
    6567        }
    6668        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8789        public LispObject execute() throws ConditionThrowable
    8890        {
    89             throw new ConditionThrowable(new WrongNumberOfArgumentsException("min"));
     91            signal(new WrongNumberOfArgumentsException("min"));
     92            return NIL;
    9093        }
    9194        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    9396            if (arg.realp())
    9497                return arg;
    95             throw new ConditionThrowable(new TypeError(arg, "real number"));
     98            signal(new TypeError(arg, "real number"));
     99            return NIL;
    96100        }
    97101        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    99103            LispObject result = args[0];
    100104            if (!result.realp())
    101                 throw new ConditionThrowable(new TypeError(result, "real number"));
     105                signal(new TypeError(result, "real number"));
    102106            for (int i = 1; i < args.length; i++) {
    103107                if (args[i].isLessThan(result))
     
    114118        public LispObject execute() throws ConditionThrowable
    115119        {
    116             throw new ConditionThrowable(new WrongNumberOfArgumentsException("max"));
     120            signal(new WrongNumberOfArgumentsException("max"));
     121            return NIL;
    117122        }
    118123        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    120125            if (arg.realp())
    121126                return arg;
    122             throw new ConditionThrowable(new TypeError(arg, "real number"));
     127            signal(new TypeError(arg, "real number"));
     128            return NIL;
    123129        }
    124130        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    126132            LispObject result = args[0];
    127133            if (!result.realp())
    128                 throw new ConditionThrowable(new TypeError(result, "real number"));
     134                signal(new TypeError(result, "real number"));
    129135            for (int i = 1; i < args.length; i++) {
    130136                if (args[i].isGreaterThan(result))
     
    200206            if (arg instanceof AbstractArray)
    201207                return NIL;
    202             throw new ConditionThrowable(new TypeError(arg, "array"));
     208            signal(new TypeError(arg, "array"));
     209            return NIL;
    203210        }
    204211    };
     
    476483                value = symbol.symbolValue();
    477484                if (value instanceof SymbolMacro)
    478                     throw new ConditionThrowable(new LispError(arg + " has no dynamic value"));
     485                    signal(new LispError(arg + " has no dynamic value"));
    479486            }
    480487            return value;
     
    565572            switch (args.length) {
    566573                case 0:
    567                     throw new ConditionThrowable(new WrongNumberOfArgumentsException("-"));
     574                    signal(new WrongNumberOfArgumentsException("-"));
    568575                case 1:
    569576                    return Fixnum.ZERO.subtract(args[0]);
     
    596603        {
    597604            if (args == NIL)
    598                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     605                signal(new WrongNumberOfArgumentsException(this));
    599606            final LispThread thread = LispThread.currentThread();
    600607            LispObject result = NIL;
     
    617624        {
    618625            if (args == NIL)
    619                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     626                signal(new WrongNumberOfArgumentsException(this));
    620627            final LispThread thread = LispThread.currentThread();
    621628            LispObject result = NIL;
     
    650657        {
    651658            if (args.length < 1 || args.length > 2)
    652                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     659                signal(new WrongNumberOfArgumentsException(this));
    653660            final CharacterOutputStream out;
    654661            if (args.length == 1)
     
    733740        {
    734741            if (args.length > 1)
    735                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     742                signal(new WrongNumberOfArgumentsException(this));
    736743            final CharacterOutputStream out;
    737744            if (args.length == 0)
     
    749756        {
    750757            if (args.length > 1)
    751                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     758                signal(new WrongNumberOfArgumentsException(this));
    752759            CharacterOutputStream out;
    753760            if (args.length == 0)
     
    794801                return f != null ? T : NIL;
    795802            }
    796             throw new ConditionThrowable(new TypeError(arg, "valid function name"));
     803            signal(new TypeError(arg, "valid function name"));
     804            return NIL;
    797805        }
    798806    };
     
    809817                        PACKAGE_SYS.intern("SETF-FUNCTION"));
    810818            } else
    811                 throw new ConditionThrowable(new TypeError(arg, "valid function name"));
     819                signal(new TypeError(arg, "valid function name"));
    812820            return arg;
    813821        }
     
    922930                            }
    923931                        } else
    924                             throw new ConditionThrowable(new TypeError(list, "list"));
     932                            signal(new TypeError(list, "list"));
    925933                    }
    926934                    if (result == null)
     
    945953            final int length = array.length;
    946954            if (length < 1)
    947                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     955                signal(new WrongNumberOfArgumentsException(this));
    948956            final LispObject obj = array[0];
    949957            for (int i = 1; i < length; i++) {
     
    968976                return array[0].isNotEqualTo(array[1]) ? T : NIL;
    969977            if (length < 1)
    970                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     978                signal(new WrongNumberOfArgumentsException(this));
    971979            for (int i = 0; i < length; i++) {
    972980                final LispObject obj = array[i];
     
    9921000            final int length = array.length;
    9931001            if (length < 1)
    994                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1002                signal(new WrongNumberOfArgumentsException(this));
    9951003            for (int i = 1; i < length; i++) {
    9961004                if (array[i].isLessThanOrEqualTo(array[i-1]))
     
    10121020            switch (array.length) {
    10131021                case 0:
    1014                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1022                    signal(new WrongNumberOfArgumentsException(this));
    10151023                case 1:
    10161024                    return T;
     
    10411049            final int length = array.length;
    10421050            if (length < 1)
    1043                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1051                signal(new WrongNumberOfArgumentsException(this));
    10441052            for (int i = 1; i < length; i++) {
    10451053                if (array[i].isGreaterThanOrEqualTo(array[i-1]))
     
    10621070            switch (length) {
    10631071                case 0:
    1064                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1072                    signal(new WrongNumberOfArgumentsException(this));
    10651073                case 1:
    10661074                    return T;
     
    10871095        {
    10881096            if (args.length != 2)
    1089                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1097                signal(new WrongNumberOfArgumentsException(this));
    10901098            LispObject item = args[0];
    10911099            LispObject alist = args[1];
     
    10961104                        return cons;
    10971105                } else if (cons != NIL)
    1098                     throw new ConditionThrowable(new TypeError(cons, "list"));
     1106                    signal(new TypeError(cons, "list"));
    10991107                alist = alist.cdr();
    11001108            }
     
    11121120            int index = Fixnum.getValue(first);
    11131121            if (index < 0)
    1114                 throw new ConditionThrowable(new LispError("bad index to NTH: " + index));
     1122                signal(new LispError("bad index to NTH: " + index));
    11151123            int i = 0;
    11161124            while (true) {
     
    11361144            int index = Fixnum.getValue(first);
    11371145            if (index < 0)
    1138                 throw new ConditionThrowable(new LispError("bad index to NTH: " + index));
     1146                signal(new LispError("bad index to NTH: " + index));
    11391147            int i = 0;
    11401148            while (true) {
     
    11441152                }
    11451153                second = second.cdr();
    1146                 if (second == NIL)
    1147                     throw new ConditionThrowable(new LispError(String.valueOf(index)) +
    1148                         "is too large an index for SETF of NTH");
     1154                if (second == NIL) {
     1155                    signal(new LispError(String.valueOf(index) +
     1156                                         "is too large an index for SETF of NTH"));
     1157                    return NIL;
     1158                }
    11491159                ++i;
    11501160            }
     
    11591169            final int index = Fixnum.getValue(first);
    11601170            if (index < 0)
    1161                 throw new ConditionThrowable(new TypeError("bad index to NTHCDR: " + index));
     1171                signal(new TypeError("bad index to NTHCDR: " + index));
    11621172            for (int i = 0; i < index; i++) {
    11631173                second = second.cdr();
     
    11741184        public LispObject execute(LispObject[] args) throws ConditionThrowable
    11751185        {
    1176             if (args.length < 1)
    1177                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1186            if (args.length < 1) {
     1187                signal(new WrongNumberOfArgumentsException(this));
     1188                return NIL;
     1189            }
    11781190            LispObject datum = args[0];
    1179             if (datum instanceof Condition)
    1180                 throw new ConditionThrowable((Condition)datum);
     1191            if (datum instanceof Condition) {
     1192                signal((Condition)datum);
     1193                return NIL;
     1194            }
    11811195            if (datum instanceof Symbol) {
    11821196                LispObject initArgs = NIL;
     
    12041218                    // Default.
    12051219                    condition = new  SimpleError(initArgs);
    1206                 throw new ConditionThrowable(condition);
     1220                signal(condition);
     1221                return NIL;
    12071222            }
    12081223            // Default is SIMPLE-ERROR.
     
    12111226            for (int i = 1; i < args.length; i++)
    12121227                formatArguments = new Cons(formatArguments, new Cons(args[i]));
    1213             throw new ConditionThrowable(new SimpleError(formatControl,
    1214                                                          formatArguments));
     1228            signal(new SimpleError(formatControl, formatArguments));
     1229            return NIL;
    12151230        }
    12161231    };
     
    12221237        {
    12231238            if (args.length < 1)
    1224                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1239                signal(new WrongNumberOfArgumentsException(this));
    12251240            final CharacterOutputStream out =
    12261241                checkCharacterOutputStream(_ERROR_OUTPUT_.symbolValue());
     
    12381253                else if (datum == Symbol.SIMPLE_WARNING)
    12391254                    condition = new SimpleWarning(initArgs);
    1240                 else
    1241                     throw new ConditionThrowable(new TypeError(datum,
    1242                                                                Symbol.WARNING));
     1255                else {
     1256                    signal(new TypeError(datum, Symbol.WARNING));
     1257                    return NIL;
     1258                }
    12431259            } else {
    12441260                // Default is SIMPLE-WARNING.
     
    12701286        {
    12711287            if (args.length < 1)
    1272                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1288                signal(new WrongNumberOfArgumentsException(this));
    12731289            if (args[0] instanceof Condition)
    1274                 throw new ConditionThrowable((Condition)args[0]);
    1275             throw new ConditionThrowable(new SimpleCondition());
     1290                signal((Condition)args[0]);
     1291            signal(new SimpleCondition());
     1292            return NIL;
    12761293        }
    12771294    };
     
    12931310        {
    12941311            if (args.length < 2)
    1295                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1312                signal(new WrongNumberOfArgumentsException(this));
    12961313            LispObject destination = args[0];
    12971314            // Copy remaining arguments.
     
    13161333                    return NIL;
    13171334                }
    1318                 throw new ConditionThrowable(new TypeError(destination, "character output stream"));
     1335                signal(new TypeError(destination, "character output stream"));
    13191336            }
    13201337            // Destination can also be a string with a fill pointer.
    1321 //             throw new ConditionThrowable(new LispError("FORMAT: not implemented"));
     1338//             signal(new LispError("FORMAT: not implemented"));
    13221339            return NIL;
    13231340        }
     
    13531370        public LispObject execute(LispObject[] args) throws ConditionThrowable
    13541371        {
    1355             if (args.length < 3 || args.length > 4)
    1356                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1372            if (args.length < 3 || args.length > 4) {
     1373                signal(new WrongNumberOfArgumentsException(this));
     1374                return NIL;
     1375            }
    13571376            LispObject first = args[0];
    13581377            LispObject second = args[1];
     
    13681387                    String message =
    13691388                        symbol.getName() + " is a special operator and may not be redefined";
    1370                     throw new ConditionThrowable(new ProgramError(message));
     1389                    signal(new ProgramError(message));
     1390                    return NIL;
    13711391                }
    13721392                LispObject arglist = checkList(second);
     
    14121432                return symbol;
    14131433            }
    1414             throw new ConditionThrowable(new TypeError(first, "valid function name"));
     1434            signal(new TypeError(first, "valid function name"));
     1435            return NIL;
    14151436        }
    14161437    };
     
    14231444        {
    14241445            if (args.length != 1)
    1425                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1446                signal(new WrongNumberOfArgumentsException(this));
    14261447            Symbol symbol = checkSymbol(args[0]);
    14271448            LispObject obj = symbol.getSymbolFunction();
     
    14931514                symbol.setVariableDocumentation(third);
    14941515            else if (third != NIL)
    1495                 throw new ConditionThrowable(new TypeError(third, "string"));
     1516                signal(new TypeError(third, "string"));
    14961517            symbol.setSymbolValue(second);
    14971518            symbol.setSpecial(true);
     
    15231544                symbol.setVariableDocumentation(third);
    15241545            else if (third != NIL)
    1525                 throw new ConditionThrowable(new TypeError(third, "string"));
     1546                signal(new TypeError(third, "string"));
    15261547            symbol.setSymbolValue(second);
    15271548            symbol.setSpecial(true);
     
    16241645                args = args.cdr();
    16251646            }
    1626             throw new ConditionThrowable(new TypeError("ECASE: no match for " + key));
     1647            signal(new TypeError("ECASE: no match for " + key));
     1648            return NIL;
    16271649        }
    16281650    };
     
    16601682                            handler = obj.getSymbolFunction();
    16611683                            if (handler == null)
    1662                                 throw new ConditionThrowable(new UndefinedFunction(obj));
     1684                                signal(new UndefinedFunction(obj));
    16631685                        } else
    16641686                            handler = obj;
     
    17201742                            return funcall(handler, handlerArgs, thread);
    17211743                        }
    1722                         throw new ConditionThrowable(new LispError("HANDLER-CASE: invalid handler clause"));
     1744                        signal(new LispError("HANDLER-CASE: invalid handler clause"));
    17231745                    }
    17241746                    clauses = clauses.cdr();
     
    18221844        {
    18231845            if (args.length < 1)
    1824                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1846                signal(new WrongNumberOfArgumentsException(this));
    18251847            AbstractArray array = checkArray(args[0]);
    18261848            int rank = array.getRank();
     
    18311853                sb.append(") for array of rank ");
    18321854                sb.append(rank);
    1833                 throw new ConditionThrowable(new ProgramError(sb.toString()));
     1855                signal(new ProgramError(sb.toString()));
    18341856            }
    18351857            for (int i = 0; i < rank; i++) {
     
    18421864                    return NIL;
    18431865                } else
    1844                     throw new ConditionThrowable(new TypeError(arg, "integer"));
     1866                    signal(new TypeError(arg, "integer"));
    18451867            }
    18461868            return T;
     
    18721894            sb.append("wrong number of subscripts (0) for array of rank ");
    18731895            sb.append(array.getRank());
    1874             throw new ConditionThrowable(new ProgramError(sb.toString()));
     1896            signal(new ProgramError(sb.toString()));
     1897            return NIL;
    18751898        }
    18761899        public LispObject execute(LispObject first, LispObject second)
     
    18821905        {
    18831906            if (args.length < 1)
    1884                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1907                signal(new WrongNumberOfArgumentsException(this));
    18851908            AbstractArray array = checkArray(args[0]);
    18861909            LispObject[] subscripts = new LispObject[args.length - 1];
     
    19021925            sb.append(") for array of rank ");
    19031926            sb.append(rank);
    1904             throw new ConditionThrowable(new ProgramError(sb.toString()));
     1927            signal(new ProgramError(sb.toString()));
    19051928        }
    19061929        if (rank == 0)
     
    19161939                int n = ((Fixnum)subscript).getValue();
    19171940                if (n < 0 || n >= array.getDimension(i))
    1918                     throw new ConditionThrowable(new ProgramError());
     1941                    signal(new ProgramError());
    19191942                sum += n * lastSize;
    19201943            } else if (subscript instanceof Bignum) {
    1921                 throw new ConditionThrowable(new ProgramError());
     1944                signal(new ProgramError());
    19221945            } else
    1923                 throw new ConditionThrowable(new TypeError(subscript, "integer"));
     1946                signal(new TypeError(subscript, "integer"));
    19241947        }
    19251948        return sum;
     
    19511974            }
    19521975            catch (ClassCastException e) {
    1953                 throw new ConditionThrowable(new TypeError(first, "array"));
     1976                signal(new TypeError(first, "array"));
     1977                return NIL;
    19541978            }
    19551979        }
     
    19782002            }
    19792003            catch (ClassCastException e) {
    1980                 throw new ConditionThrowable(new TypeError(first, "vector"));
     2004                signal(new TypeError(first, "vector"));
     2005                return NIL;
    19812006            }
    19822007        }
     
    19912016            AbstractVector v = checkVector(first);
    19922017            if (!v.isSimpleVector())
    1993                 throw new ConditionThrowable(new TypeError(first, "simple vector"));
     2018                signal(new TypeError(first, "simple vector"));
    19942019            int index = v.checkIndex(second);
    19952020            return v.get(index);
     
    20072032            AbstractVector v = checkVector(first);
    20082033            if (!v.isSimpleVector())
    2009                 throw new ConditionThrowable(new TypeError(first, "simple vector"));
     2034                signal(new TypeError(first, "simple vector"));
    20102035            int i = v.checkIndex(second);
    20112036            v.set(i, third);
     
    20222047            int fillPointer = checkVector(arg).getFillPointer();
    20232048            if (fillPointer < 0)
    2024                 throw new ConditionThrowable(new TypeError("array does not have a fill pointer"));
     2049                signal(new TypeError("array does not have a fill pointer"));
    20252050            return new Fixnum(fillPointer);
    20262051        }
     
    20362061            int fillPointer = v.getFillPointer();
    20372062            if (fillPointer < 0)
    2038                 throw new ConditionThrowable(new TypeError("array does not have a fill pointer"));
     2063                signal(new TypeError("array does not have a fill pointer"));
    20392064            v.setFillPointer(second);
    20402065            return second;
     
    20522077            int fillPointer = v.getFillPointer();
    20532078            if (fillPointer < 0)
    2054                 throw new ConditionThrowable(new TypeError("array does not have a fill pointer"));
     2079                signal(new TypeError("array does not have a fill pointer"));
    20552080            if (fillPointer >= v.capacity())
    20562081                return NIL;
     
    20682093        {
    20692094            if (args.length < 2 || args.length > 3)
    2070                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2095                signal(new WrongNumberOfArgumentsException(this));
    20712096            AbstractVector v = checkVector(args[1]);
    20722097            int extension = 0;
     
    20772102            int fillPointer = v.getFillPointer();
    20782103            if (fillPointer < 0)
    2079                 throw new ConditionThrowable(new TypeError("array does not have a fill pointer"));
     2104                signal(new TypeError("array does not have a fill pointer"));
    20802105            if (fillPointer >= v.capacity()) {
    20812106                // Need to extend vector.
     
    20972122            int fillPointer = v.getFillPointer();
    20982123            if (fillPointer < 0)
    2099                 throw new ConditionThrowable(new TypeError("array does not have a fill pointer"));
     2124                signal(new TypeError("array does not have a fill pointer"));
    21002125            if (fillPointer == 0)
    2101                 throw new ConditionThrowable(new LispError("nothing left to pop"));
     2126                signal(new LispError("nothing left to pop"));
    21022127            int newFillPointer = v.checkIndex(fillPointer - 1);
    21032128            LispObject element = v.get(newFillPointer);
     
    21252150                    return v.adjustArray(Fixnum.getValue(newSize));
    21262151            }
    2127             throw new ConditionThrowable(new LispError("ADJUST-ARRAY: unsupported case"));
     2152            signal(new LispError("ADJUST-ARRAY: unsupported case"));
     2153            return NIL;
    21282154        }
    21292155    };
     
    21962222            if (fun instanceof Function || fun instanceof GenericFunction)
    21972223                return funcall0(fun, LispThread.currentThread());
    2198             throw new ConditionThrowable(new UndefinedFunction(arg));
     2224            signal(new UndefinedFunction(arg));
     2225            return NIL;
    21992226        }
    22002227        public LispObject execute(LispObject first, LispObject second)
     
    22082235            if (fun instanceof Function || fun instanceof GenericFunction)
    22092236                return funcall1(fun, second, LispThread.currentThread());
    2210             throw new ConditionThrowable(new UndefinedFunction(first));
     2237            signal(new UndefinedFunction(first));
     2238            return NIL;
    22112239        }
    22122240        public LispObject execute(LispObject first, LispObject second,
     
    22212249            if (fun instanceof Function || fun instanceof GenericFunction)
    22222250                return funcall2(fun, second, third, LispThread.currentThread());
    2223             throw new ConditionThrowable(new UndefinedFunction(first));
    2224         }
    2225         public LispObject execute(LispObject[] args) throws ConditionThrowable
    2226         {
    2227             if (args.length < 1)
    2228                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2251            signal(new UndefinedFunction(first));
     2252            return NIL;
     2253        }
     2254        public LispObject execute(LispObject[] args) throws ConditionThrowable
     2255        {
     2256            if (args.length < 1) {
     2257                signal(new WrongNumberOfArgumentsException(this));
     2258                return NIL;
     2259            }
    22292260            LispObject fun;
    22302261            if (args[0] instanceof Symbol)
     
    22432274                }
    22442275            }
    2245             throw new ConditionThrowable(new UndefinedFunction(args[0]));
     2276            signal(new UndefinedFunction(args[0]));
     2277            return NIL;
    22462278        }
    22472279    };
     
    22782310                }
    22792311            }
    2280             throw new ConditionThrowable(new TypeError(fun, "function"));
     2312            signal(new TypeError(fun, "function"));
     2313            return NIL;
    22812314        }
    22822315        public LispObject execute(final LispObject[] args) throws ConditionThrowable
     
    22842317            final int numArgs = args.length;
    22852318            if (numArgs < 2)
    2286                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2319                signal(new WrongNumberOfArgumentsException(this));
    22872320            LispObject spread = checkList(args[numArgs - 1]);
    22882321            LispObject fun = args[0];
     
    23012334                return funcall(fun, funArgs, LispThread.currentThread());
    23022335            }
    2303             throw new ConditionThrowable(new TypeError(fun, "function"));
     2336            signal(new TypeError(fun, "function"));
     2337            return NIL;
    23042338        }
    23052339    };
     
    23342368                return result;
    23352369            }
    2336             throw new ConditionThrowable(new UndefinedFunction(op));
     2370            signal(new UndefinedFunction(op));
     2371            return NIL;
    23372372        }
    23382373        public LispObject execute(LispObject first, LispObject second,
     
    23442379                fun = fun.getSymbolFunction();
    23452380            if (!(fun instanceof Function || fun instanceof GenericFunction))
    2346                 throw new ConditionThrowable(new UndefinedFunction(first));
     2381                signal(new UndefinedFunction(first));
    23472382            // Remaining arguments must be lists.
    23482383            LispObject list1 = checkList(second);
     
    23712406            final int numArgs = args.length;
    23722407            if (numArgs < 2)
    2373                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2408                signal(new WrongNumberOfArgumentsException(this));
    23742409            // First argument must be a function.
    23752410            LispObject fun = args[0];
     
    23772412                fun = fun.getSymbolFunction();
    23782413            if (!(fun instanceof Function || fun instanceof GenericFunction))
    2379                 throw new ConditionThrowable(new UndefinedFunction(args[0]));
     2414                signal(new UndefinedFunction(args[0]));
    23802415            // Remaining arguments must be lists.
    23812416            int commonLength = -1;
    23822417            for (int i = 1; i < numArgs; i++) {
    23832418                if (!args[i].listp())
    2384                     throw new ConditionThrowable(new TypeError(args[i], "list"));
     2419                    signal(new TypeError(args[i], "list"));
    23852420                int len = args[i].length();
    23862421                if (commonLength < 0)
     
    24132448            final int length = args.length;
    24142449            if (length < 1 || length > 2)
    2415                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2450                signal(new WrongNumberOfArgumentsException(this));
    24162451            LispObject form = args[0];
    24172452            final Environment env;
     
    24632498                int n = ((Fixnum)arg).getValue();
    24642499                if (n < 0)
    2465                     throw new ConditionThrowable(new TypeError(arg,
     2500                    signal(new TypeError(arg,
    24662501                                                               "non-negative integer"));
    24672502                StringBuffer sb = new StringBuffer(prefix);
     
    24722507                BigInteger n = ((Bignum)arg).getValue();
    24732508                if (n.signum() < 0)
    2474                     throw new ConditionThrowable(new TypeError(arg,
     2509                    signal(new TypeError(arg,
    24752510                                                               "non-negative integer"));
    24762511                StringBuffer sb = new StringBuffer(prefix);
     
    24812516                prefix = ((LispString)arg).getValue();
    24822517            else
    2483                 throw new ConditionThrowable(new TypeError(arg, "string or non-negative integer"));
     2518                signal(new TypeError(arg, "string or non-negative integer"));
    24842519            return gensym(prefix);
    24852520        }
     
    25312566                }
    25322567                default:
    2533                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2568                    signal(new WrongNumberOfArgumentsException(this));
     2569                    return NIL;
    25342570            }
    25352571        }
     
    25422578        {
    25432579            if (args.length == 0 || args.length > 2)
    2544                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2580                signal(new WrongNumberOfArgumentsException(this));
    25452581            Symbol symbol = checkSymbol(args[0]);
    25462582            Package pkg;
     
    25912627                Packages.findPackage(packageName);
    25922628            if (pkg != null)
    2593                 throw new ConditionThrowable(new LispError("package " + packageName +
     2629                signal(new LispError("package " + packageName +
    25942630                                                           " already exists"));
    25952631            LispObject nicknames = checkList(second);
     
    25992635                    String nick = javaString(list.car());
    26002636                    if (Packages.findPackage(nick) != null) {
    2601                         throw new ConditionThrowable(new PackageError("a package named " + nick +
     2637                        signal(new PackageError("a package named " + nick +
    26022638                                                                      " already exists"));
    26032639                    }
     
    26152651                        String s = javaString(obj);
    26162652                        Package p = Packages.findPackage(s);
    2617                         if (p == null)
    2618                             throw new ConditionThrowable(new LispError(String.valueOf(obj)) +
    2619                                                 " is not the name of a package");
     2653                        if (p == null) {
     2654                            signal(new LispError(String.valueOf(obj) +
     2655                                                 " is not the name of a package"));
     2656                            return NIL;
     2657                        }
    26202658                    }
    26212659                    list = list.cdr();
     
    26382676                    String s = javaString(obj);
    26392677                    Package p = Packages.findPackage(s);
    2640                     if (p == null)
    2641                         throw new ConditionThrowable(new LispError(String.valueOf(obj)) +
    2642                                             " is not the name of a package");
     2678                    if (p == null) {
     2679                        signal(new LispError(String.valueOf(obj) +
     2680                                             " is not the name of a package"));
     2681                        return NIL;
     2682                    }
    26432683                    pkg.usePackage(p);
    26442684                }
     
    26572697            Package pkg = Packages.findPackage(packageName);
    26582698            if (pkg == null)
    2659                 throw new ConditionThrowable(new PackageError("package " + arg + " does not exist"));
     2699                signal(new PackageError("package " + arg + " does not exist"));
    26602700            LispThread thread = LispThread.currentThread();
    26612701            Environment dynEnv = thread.getDynamicEnvironment();
     
    26792719        {
    26802720            if (args.length < 1 || args.length > 2)
    2681                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2721                signal(new WrongNumberOfArgumentsException(this));
    26822722            Package pkg;
    26832723            if (args.length == 2)
     
    28172857        {
    28182858            if (args.length == 0 || args.length > 2)
    2819                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2859                signal(new WrongNumberOfArgumentsException(this));
    28202860            Package pkg;
    28212861            if (args.length == 2)
     
    28402880        {
    28412881            if (args.length == 0 || args.length > 2)
    2842                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     2882                signal(new WrongNumberOfArgumentsException(this));
    28432883            String name = LispString.getValue(args[0]);
    28442884            Package pkg;
     
    30303070        {
    30313071            if (args.length() != 1)
    3032                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3072                signal(new WrongNumberOfArgumentsException(this));
    30333073            throw new Go(args.car());
    30343074        }
     
    30423082        {
    30433083            if (args == NIL)
    3044                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3084                signal(new WrongNumberOfArgumentsException(this));
    30453085            LispObject tag;
    30463086            if (args.car() == NIL)
     
    30873127            final int length = args.length();
    30883128            if (length < 1 || length > 2)
    3089                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3129                signal(new WrongNumberOfArgumentsException(this));
    30903130            Symbol symbol = checkSymbol(args.car());
    30913131            Block block = env.lookupBlock(symbol);
     
    30943134                sb.append(symbol.getName());
    30953135                sb.append(" is currently visible");
    3096                 throw new ConditionThrowable(new LispError(sb.toString()));
     3136                signal(new LispError(sb.toString()));
    30973137            }
    30983138            LispObject result;
     
    31203160                                          LispThread.currentThread()));
    31213161                default:
    3122                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3162                    signal(new WrongNumberOfArgumentsException(this));
     3163                    return NIL;
    31233164            }
    31243165        }
     
    31323173        {
    31333174            if (args.length() < 1)
    3134                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3175                signal(new WrongNumberOfArgumentsException(this));
    31353176            final LispThread thread = LispThread.currentThread();
    31363177            LispObject tag = eval(args.car(), env, thread);
     
    31693210        {
    31703211            if (args.length() < 2)
    3171                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3212                signal(new WrongNumberOfArgumentsException(this));
    31723213            final LispThread thread = LispThread.currentThread();
    31733214            LispObject tag = eval(args.car(), env, thread);
     
    32683309        {
    32693310            if (args.length() == 0)
    3270                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3311                signal(new WrongNumberOfArgumentsException(this));
    32713312            final LispThread thread = LispThread.currentThread();
    32723313            LispObject result = eval(args.car(), env, thread);
     
    32903331        {
    32913332            if (args.length() == 0)
    3292                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3333                signal(new WrongNumberOfArgumentsException(this));
    32933334            final LispThread thread = LispThread.currentThread();
    32943335            LispObject function;
     
    32983339                function = obj.getSymbolFunction();
    32993340                if (function == null)
    3300                     throw new ConditionThrowable(new UndefinedFunction(obj));
     3341                    signal(new UndefinedFunction(obj));
    33013342            } else if (obj instanceof Function) {
    33023343                function = obj;
    3303             } else
    3304                 throw new ConditionThrowable(new LispError(String.valueOf(obj) + " is not a function name"));
     3344            } else {
     3345                signal(new LispError(String.valueOf(obj) + " is not a function name"));
     3346                return NIL;
     3347            }
    33053348            ArrayList arrayList = new ArrayList();
    33063349            while (args != NIL) {
     
    33743417        {
    33753418            if (args.length < 1 || args.length > 2)
    3376                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3419                signal(new WrongNumberOfArgumentsException(this));
    33773420            final char c = LispCharacter.getValue(args[0]);
    33783421            final CharacterOutputStream out;
     
    33943437        {
    33953438            if (args.length != 4)
    3396                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3439                signal(new WrongNumberOfArgumentsException(this));
    33973440            String s = LispString.getValue(args[0]);
    33983441            CharacterOutputStream out = outSynonymOf(args[1]);
     
    34223465        {
    34233466            if (args.length > 1)
    3424                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3467                signal(new WrongNumberOfArgumentsException(this));
    34253468            return flushOutput(args);
    34263469        }
     
    34333476        {
    34343477            if (args.length > 1)
    3435                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3478                signal(new WrongNumberOfArgumentsException(this));
    34363479            return flushOutput(args);
    34373480        }
     
    34483491        else if (args[0] instanceof TwoWayStream)
    34493492            out = ((TwoWayStream)args[0]).getOutputStream();
    3450         else
    3451             throw new ConditionThrowable(new TypeError(args[0], "output stream"));
     3493        else {
     3494            signal(new TypeError(args[0], "output stream"));
     3495            return NIL;
     3496        }
    34523497        out.flushOutput();
    34533498        return NIL;
     
    34603505        {
    34613506            if (args.length > 1)
    3462                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3507                signal(new WrongNumberOfArgumentsException(this));
    34633508            final CharacterInputStream in;
    34643509            if (args.length == 0)
     
    34783523            final int length = args.length;
    34793524            if (length == 0)
    3480                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3525                signal(new WrongNumberOfArgumentsException(this));
    34813526            LispObject abort = NIL; // Default.
    34823527            LispStream stream = checkStream(args[0]);
    34833528            if (length > 1) {
    34843529                if ((length - 1) % 2 != 0)
    3485                     throw new ConditionThrowable(new ProgramError("odd number of keyword arguments"));
     3530                    signal(new ProgramError("odd number of keyword arguments"));
    34863531                if (length > 3)
    3487                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3532                    signal(new WrongNumberOfArgumentsException(this));
    34883533                if (args[1] == Keyword.ABORT)
    34893534                    abort = args[2];
    34903535                else
    3491                     throw new ConditionThrowable(new LispError(
     3536                    signal(new LispError(
    34923537                        "CLOSE: unrecognized keyword argument: " + args[1]));
    34933538            }
     
    35073552        {
    35083553            if (args.length() != 1)
    3509                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3554                signal(new WrongNumberOfArgumentsException(this));
    35103555            final LispThread thread = LispThread.currentThread();
    35113556            LispObject result = eval(args.car(), env, thread);
     
    35333578        {
    35343579            if (args.length() != 2)
    3535                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3580                signal(new WrongNumberOfArgumentsException(this));
    35363581            final LispThread thread = LispThread.currentThread();
    35373582            int n = Fixnum.getInt(eval(args.car(), env, thread));
     
    35603605            int n = Fixnum.getValue(first);
    35613606            if (n < 0 || n > 255)
    3562                 throw new ConditionThrowable(new TypeError(first, "unsigned byte"));
     3607                signal(new TypeError(first, "unsigned byte"));
    35633608            final BinaryOutputStream out = checkBinaryOutputStream(second);
    35643609            out.writeByte(n);
     
    35753620            int length = args.length;
    35763621            if (length < 1 || length > 3)
    3577                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3622                signal(new WrongNumberOfArgumentsException(this));
    35783623            final BinaryInputStream in = checkBinaryInputStream(args[0]);
    35793624            boolean eofError = length > 1 ? (args[1] != NIL) : true;
     
    35923637            int length = args.length;
    35933638            if (length > 4)
    3594                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3639                signal(new WrongNumberOfArgumentsException(this));
    35953640            CharacterInputStream stream = null;
    35963641            if (length == 0)
     
    36043649            }
    36053650            if (stream == null)
    3606                 throw new ConditionThrowable(new TypeError(args[0], "character input stream"));
     3651                signal(new TypeError(args[0], "character input stream"));
    36073652            boolean eofError = length > 1 ? (args[1] != NIL) : true;
    36083653            LispObject eofValue = length > 2 ? args[2] : NIL;
     
    36213666        {
    36223667            if (args.length < 6)
    3623                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3668                signal(new WrongNumberOfArgumentsException(this));
    36243669            String s = LispString.getValue(args[0]);
    36253670            boolean eofError = args[1] != NIL;
     
    37323777                    break;
    37333778                default:
    3734                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3779                    signal(new WrongNumberOfArgumentsException(this));
     3780                    return NIL;
    37353781            }
    37363782            long weight = Fixnum.getValue(args[0]);
     
    37713817        {
    37723818            if (args.length < 2 || args.length > 3)
    3773                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3819                signal(new WrongNumberOfArgumentsException(this));
    37743820            char dispChar = LispCharacter.getValue(args[0]);
    37753821            char subChar = LispCharacter.getValue(args[1]);
     
    37913837        {
    37923838            if (args.length < 3 || args.length > 4)
    3793                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3839                signal(new WrongNumberOfArgumentsException(this));
    37943840            char dispChar = LispCharacter.getValue(args[0]);
    37953841            char subChar = LispCharacter.getValue(args[1]);
     
    38113857            int length = args.length;
    38123858            if (length > 4)
    3813                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3859                signal(new WrongNumberOfArgumentsException(this));
    38143860            CharacterInputStream stream =
    38153861                length > 0 ? checkCharacterInputStream(args[0]) : getStandardInput();
     
    38283874            int length = args.length;
    38293875            if (length > 4)
    3830                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3876                signal(new WrongNumberOfArgumentsException(this));
    38313877            CharacterInputStream stream =
    38323878                length > 0 ? checkCharacterInputStream(args[0]) : getStandardInput();
     
    38453891            int length = args.length;
    38463892            if (length < 1)
    3847                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3893                signal(new WrongNumberOfArgumentsException(this));
    38483894            CharacterInputStream stream =
    38493895                length > 1 ? checkCharacterInputStream(args[1]) : getStandardInput();
     
    38613907                f.setLambdaName(second);
    38623908                return second;
    3863             } else
    3864                 throw new ConditionThrowable(new TypeError(first, "function"));
     3909            } else {
     3910                signal(new TypeError(first, "function"));
     3911                return NIL;
     3912            }
    38653913        }
    38663914    };
     
    38973945                sb.append(end);
    38983946                sb.append(')');
    3899                 throw new ConditionThrowable(new TypeError(sb.toString()));
     3947                signal(new TypeError(sb.toString()));
    39003948            }
    39013949            return v.subseq(start, end);
     
    39093957        {
    39103958            int length = args.length;
    3911             if (length < 1 || length > 2)
    3912                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     3959            if (length < 1 || length > 2) {
     3960                signal(new WrongNumberOfArgumentsException(this));
     3961                return NIL;
     3962            }
    39133963            Random random;
    39143964            if (length == 2)
     
    39373987                }
    39383988            }
    3939             throw new ConditionThrowable(new TypeError(args[0], "positive integer or positive float"));
     3989            signal(new TypeError(args[0], "positive integer or positive float"));
     3990            return NIL;
    39403991        }
    39413992    };
     
    39564007        {
    39574008            final int length = args.length;
    3958             if (length < 1 || length > 2)
    3959                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     4009            if (length < 1 || length > 2) {
     4010                signal(new WrongNumberOfArgumentsException(this));
     4011                return NIL;
     4012            }
    39604013            LispObject n = args[0];
    39614014            LispObject d = length == 1 ? Fixnum.ONE : args[1];
     
    39684021            if (n instanceof LispFloat)
    39694022                return ((LispFloat)n).truncate(d);
    3970             throw new ConditionThrowable(new TypeError(n, "number"));
     4023            signal(new TypeError(n, "number"));
     4024            return NIL;
    39714025        }
    39724026    };
     
    40164070                }
    40174071            }
    4018             throw new ConditionThrowable(new LispError("EXPT: unsupported case"));
     4072            signal(new LispError("EXPT: unsupported case"));
     4073            return NIL;
    40194074        }
    40204075    };
     
    40494104        public LispObject execute() throws ConditionThrowable
    40504105        {
    4051             throw new ConditionThrowable(new WrongNumberOfArgumentsException("LIST*"));
     4106            signal(new WrongNumberOfArgumentsException("LIST*"));
     4107            return NIL;
    40524108        }
    40534109        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    41354191            if (arg == NIL)
    41364192                return NIL;
    4137             throw new ConditionThrowable(new TypeError(arg, "proper sequence"));
     4193            signal(new TypeError(arg, "proper sequence"));
     4194            return NIL;
    41384195        }
    41394196    };
     
    41544211                int index = Fixnum.getValue(second);
    41554212                if (index < 0)
    4156                     throw new ConditionThrowable(new TypeError());
     4213                    signal(new TypeError());
    41574214                LispObject list = first;
    41584215                int i = 0;
     
    41644221                    list = list.cdr();
    41654222                    if (list == NIL)
    4166                         throw new ConditionThrowable(new TypeError());
     4223                        signal(new TypeError());
    41674224                    ++i;
    41684225                }
    41694226            }
    4170             throw new ConditionThrowable(new TypeError(first, "sequence"));
     4227            signal(new TypeError(first, "sequence"));
     4228            return NIL;
    41714229        }
    41724230    };
     
    42094267            int size = Fixnum.getValue(first);
    42104268            if (size < 0)
    4211                 throw new ConditionThrowable(new TypeError("MAKE-LIST: " + size +
     4269                signal(new TypeError("MAKE-LIST: " + size +
    42124270                                                           " is not a valid list length"));
    42134271            LispObject result = NIL;
     
    42244282        {
    42254283            if (args.length != 5)
    4226                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     4284                signal(new WrongNumberOfArgumentsException(this));
    42274285            LispObject item = args[0];
    42284286            LispObject tail = checkList(args[1]);
     
    42324290                    key = key.getSymbolFunction();
    42334291                if (!(key instanceof Function))
    4234                     throw new ConditionThrowable(new UndefinedFunction(args[2]));
     4292                    signal(new UndefinedFunction(args[2]));
    42354293            }
    42364294            LispObject test = args[3];
    42374295            LispObject testNot = args[4];
    42384296            if (test != NIL && testNot != NIL)
    4239                 throw new ConditionThrowable(new LispError("MEMBER: test and test-not both supplied"));
     4297                signal(new LispError("MEMBER: test and test-not both supplied"));
    42404298            if (test == NIL && testNot == NIL) {
    42414299                test = EQL;
     
    42444302                    test = test.getSymbolFunction();
    42454303                if (!(test instanceof Function))
    4246                     throw new ConditionThrowable(new UndefinedFunction(args[3]));
     4304                    signal(new UndefinedFunction(args[3]));
    42474305            } else if (testNot != NIL) {
    42484306                if (testNot instanceof Symbol)
    42494307                    testNot = testNot.getSymbolFunction();
    42504308                if (!(testNot instanceof Function))
    4251                     throw new ConditionThrowable(new UndefinedFunction(args[3]));
     4309                    signal(new UndefinedFunction(args[3]));
    42524310            }
    42534311            if (key == NIL && test == EQL) {
     
    43654423            if (arg.realp())
    43664424                return arg;
    4367             throw new ConditionThrowable(new TypeError(arg, "real number"));
     4425            signal(new TypeError(arg, "real number"));
     4426            return NIL;
    43684427        }
    43694428        public LispObject execute(LispObject first, LispObject second)
     
    44084467            if (arg.numberp())
    44094468                return arg;
    4410             throw new ConditionThrowable(new TypeError(arg, "number"));
     4469            signal(new TypeError(arg, "number"));
     4470            return NIL;
    44114471        }
    44124472    };
     
    44334493            else if (arg instanceof Bignum)
    44344494                value = ((Bignum)arg).getValue();
    4435             else
    4436                 throw new ConditionThrowable(new TypeError(arg, "integer"));
     4495            else {
     4496                signal(new TypeError(arg, "integer"));
     4497                return NIL;
     4498            }
    44374499            return new Fixnum(value.bitLength());
    44384500        }
     
    44604522            return c;
    44614523        }
    4462 
    4463         throw new ConditionThrowable(new TypeError(arg, "number"));
     4524        signal(new TypeError(arg, "number"));
     4525        return NIL;
    44644526    }
    44654527
     
    44854547            return c;
    44864548        }
    4487 
    4488         throw new ConditionThrowable(new TypeError(arg, "number"));
     4549        signal(new TypeError(arg, "number"));
     4550        return NIL;
    44894551    }
    44904552
     
    45234585            return Complex.getInstance(resX, resY);
    45244586        }
    4525 
    4526         throw new ConditionThrowable(new TypeError(arg, "number"));
     4587        signal(new TypeError(arg, "number"));
     4588        return NIL;
    45274589    }
    45284590
     
    45494611            }
    45504612        }
    4551 
    4552         throw new ConditionThrowable(new TypeError(obj, "number"));
     4613        signal(new TypeError(obj, "number"));
     4614        return NIL;
    45534615    }
    45544616
     
    45914653            }
    45924654        }
    4593 
    4594         throw new ConditionThrowable(new TypeError(obj, "number"));
     4655        signal(new TypeError(obj, "number"));
     4656        return NIL;
    45954657    }
    45964658
     
    46074669            else if (first instanceof Bignum)
    46084670                n1 = ((Bignum)first).getValue();
    4609             else
    4610                 throw new ConditionThrowable(new TypeError(first, "integer"));
     4671            else {
     4672                signal(new TypeError(first, "integer"));
     4673                return NIL;
     4674            }
    46114675            if (second instanceof Fixnum)
    46124676                n2 = BigInteger.valueOf(((Fixnum)second).getValue());
    46134677            else if (second instanceof Bignum)
    46144678                n2 = ((Bignum)second).getValue();
    4615             else
    4616                 throw new ConditionThrowable(new TypeError(second, "integer"));
     4679            else {
     4680                signal(new TypeError(second, "integer"));
     4681                return NIL;
     4682            }
    46174683            return number(n1.gcd(n2));
    46184684        }
Note: See TracChangeset for help on using the changeset viewer.