Changeset 5112


Ignore:
Timestamp:
12/13/03 00:02:47 (18 years ago)
Author:
piso
Message:

signal()

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

Legend:

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

    r4263 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Array.java,v 1.16 2003-10-09 15:21:22 piso Exp $
     5 * $Id: Array.java,v 1.17 2003-12-13 00:02:46 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8080            }
    8181            catch (ArrayIndexOutOfBoundsException e) {
    82                 throw new ConditionThrowable(new LispError("bad initial contents for array"));
     82                signal(new LispError("bad initial contents for array"));
     83                return -1;
    8384            }
    8485            ++index;
    8586        } else {
    8687            int dim = dims[0];
    87             if (dim != contents.length())
    88                 throw new ConditionThrowable(new LispError("bad initial contents for array"));
     88            if (dim != contents.length()) {
     89                signal(new LispError("bad initial contents for array"));
     90                return -1;
     91            }
    8992            int[] newDims = new int[dims.length-1];
    9093            for (int i = 1; i < dims.length; i++)
     
    155158        }
    156159        catch (ArrayIndexOutOfBoundsException e) {
    157             throw new ConditionThrowable(new TypeError("bad array dimension"));
     160            signal(new TypeError("bad array dimension"));
     161            return -1;
    158162        }
    159163    }
     
    175179        }
    176180        catch (ArrayIndexOutOfBoundsException e) {
    177             throw new ConditionThrowable(new TypeError("bad row major index " + index));
     181            return signal(new TypeError("bad row major index " + index));
    178182        }
    179183    }
     
    185189        }
    186190        catch (ArrayIndexOutOfBoundsException e) {
    187             throw new ConditionThrowable(new TypeError("bad row major index " + index));
     191            signal(new TypeError("bad row major index " + index));
    188192        }
    189193    }
  • trunk/j/src/org/armedbear/lisp/Bignum.java

    r4950 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Bignum.java,v 1.49 2003-12-03 01:51:38 piso Exp $
     5 * $Id: Bignum.java,v 1.50 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    177177        double d = value.doubleValue();
    178178        if (Double.isInfinite(d))
    179             throw new ConditionThrowable(
    180                 new TypeError(toString() +
    181                               " is too large to be converted to a float"));
     179            signal(new TypeError(toString() +
     180                                 " is too large to be converted to a float"));
    182181        return d;
    183182    }
     
    189188        }
    190189        catch (ClassCastException e) {
    191             throw new ConditionThrowable(new TypeError(obj, "bignum"));
     190            signal(new TypeError(obj, "bignum"));
     191            // Not reached.
     192            return null;
    192193        }
    193194    }
     
    226227            return Complex.getInstance(add(c.getRealPart()), c.getImaginaryPart());
    227228        }
    228         throw new ConditionThrowable(new TypeError(obj, "number"));
     229        return signal(new TypeError(obj, "number"));
    229230    }
    230231
     
    248249                                       Fixnum.ZERO.subtract(c.getImaginaryPart()));
    249250        }
    250         throw new ConditionThrowable(new TypeError(obj, "number"));
     251        return signal(new TypeError(obj, "number"));
    251252    }
    252253
     
    269270        if (obj instanceof LispFloat)
    270271            return new LispFloat(floatValue() * ((LispFloat)obj).getValue());
    271         throw new ConditionThrowable(new TypeError(obj, "number"));
     272        return signal(new TypeError(obj, "number"));
    272273    }
    273274
     
    284285        if (obj instanceof LispFloat)
    285286            return new LispFloat(floatValue() / ((LispFloat)obj).getValue());
    286         throw new ConditionThrowable(new TypeError(obj, "number"));
     287        return signal(new TypeError(obj, "number"));
    287288    }
    288289
     
    295296        if (obj.numberp())
    296297            return false;
    297         throw new ConditionThrowable(new TypeError(obj, "number"));
     298        signal(new TypeError(obj, "number"));
     299        // Not reached.
     300        return false;
    298301    }
    299302
     
    306309        if (obj.numberp())
    307310            return true;
    308         throw new ConditionThrowable(new TypeError(obj, "number"));
     311        signal(new TypeError(obj, "number"));
     312        // Not reached.
     313        return false;
    309314    }
    310315
     
    321326        if (obj instanceof LispFloat)
    322327            return floatValue() < ((LispFloat)obj).getValue();
    323         throw new ConditionThrowable(new TypeError(obj, "real"));
     328        signal(new TypeError(obj, "real"));
     329        // Not reached.
     330        return false;
    324331    }
    325332
     
    336343        if (obj instanceof LispFloat)
    337344            return floatValue() > ((LispFloat)obj).getValue();
    338         throw new ConditionThrowable(new TypeError(obj, "real"));
     345        signal(new TypeError(obj, "real"));
     346        // Not reached.
     347        return false;
    339348    }
    340349
     
    351360        if (obj instanceof LispFloat)
    352361            return floatValue() <= ((LispFloat)obj).getValue();
    353         throw new ConditionThrowable(new TypeError(obj, "real"));
     362        signal(new TypeError(obj, "real"));
     363        // Not reached.
     364        return false;
    354365    }
    355366
     
    366377        if (obj instanceof LispFloat)
    367378            return floatValue() >= ((LispFloat)obj).getValue();
    368         throw new ConditionThrowable(new TypeError(obj, "real"));
     379        signal(new TypeError(obj, "real"));
     380        // Not reached.
     381        return false;
    369382    }
    370383
     
    374387        LispObject value1, value2;
    375388  try {
    376     if (obj instanceof Ratio) {
    377             Ratio divisor = (Ratio) obj;
    378             LispObject quotient =
    379         multiplyBy(divisor.DENOMINATOR()).truncate(divisor.NUMERATOR());
    380             LispObject remainder =
    381         subtract(quotient.multiplyBy(divisor));
    382             value1 = quotient;
    383             value2 = remainder;
    384     } else if (obj instanceof Fixnum) {
    385             BigInteger divisor = ((Fixnum)obj).getBigInteger();
    386             BigInteger[] results = value.divideAndRemainder(divisor);
    387             BigInteger quotient = results[0];
    388             BigInteger remainder = results[1];
    389             value1 = number(quotient);
    390             value2 = (remainder.signum() == 0) ? Fixnum.ZERO : number(remainder);
    391     } else if (obj instanceof Bignum) {
    392             BigInteger divisor = ((Bignum)obj).getValue();
    393             BigInteger[] results = value.divideAndRemainder(divisor);
    394             BigInteger quotient = results[0];
    395             BigInteger remainder = results[1];
    396             value1 = number(quotient);
    397             value2 = (remainder.signum() == 0) ? Fixnum.ZERO : number(remainder);
    398     } else if (obj instanceof Ratio) {
    399             Ratio divisor = (Ratio) obj;
    400             LispObject quotient =
    401         multiplyBy(divisor.DENOMINATOR()).truncate(divisor.NUMERATOR());
    402             LispObject remainder =
    403         subtract(quotient.multiplyBy(divisor));
    404             value1 = quotient;
    405             value2 = remainder;
    406     } else
    407             throw new ConditionThrowable(new LispError("Bignum.truncate(): not implemented: " + obj.typeOf()));
     389            if (obj instanceof Ratio) {
     390                Ratio divisor = (Ratio) obj;
     391                LispObject quotient =
     392                    multiplyBy(divisor.DENOMINATOR()).truncate(divisor.NUMERATOR());
     393                LispObject remainder =
     394                    subtract(quotient.multiplyBy(divisor));
     395                value1 = quotient;
     396                value2 = remainder;
     397            } else if (obj instanceof Fixnum) {
     398                BigInteger divisor = ((Fixnum)obj).getBigInteger();
     399                BigInteger[] results = value.divideAndRemainder(divisor);
     400                BigInteger quotient = results[0];
     401                BigInteger remainder = results[1];
     402                value1 = number(quotient);
     403                value2 = (remainder.signum() == 0) ? Fixnum.ZERO : number(remainder);
     404            } else if (obj instanceof Bignum) {
     405                BigInteger divisor = ((Bignum)obj).getValue();
     406                BigInteger[] results = value.divideAndRemainder(divisor);
     407                BigInteger quotient = results[0];
     408                BigInteger remainder = results[1];
     409                value1 = number(quotient);
     410                value2 = (remainder.signum() == 0) ? Fixnum.ZERO : number(remainder);
     411            } else if (obj instanceof Ratio) {
     412                Ratio divisor = (Ratio) obj;
     413                LispObject quotient =
     414                    multiplyBy(divisor.DENOMINATOR()).truncate(divisor.NUMERATOR());
     415                LispObject remainder =
     416                    subtract(quotient.multiplyBy(divisor));
     417                value1 = quotient;
     418                value2 = remainder;
     419            } else
     420                return signal(new LispError("Bignum.truncate(): not implemented: " + obj.typeOf()));
    408421        }
    409422        catch (ArithmeticException e) {
    410423            if (obj.zerop())
    411                 throw new ConditionThrowable(new DivisionByZero());
    412             throw new ConditionThrowable(new ArithmeticError(e.getMessage()));
     424                return signal(new DivisionByZero());
     425            else
     426                return signal(new ArithmeticError(e.getMessage()));
    413427        }
    414428        return thread.setValues(value1, value2);
  • trunk/j/src/org/armedbear/lisp/CharacterFunctions.java

    r5037 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterFunctions.java,v 1.6 2003-12-09 20:26:22 asimon Exp $
     5 * $Id: CharacterFunctions.java,v 1.7 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3535            final int length = array.length;
    3636            if (length == 0)
    37                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     37                return signal(new WrongNumberOfArgumentsException(this));
    3838            if (length > 1) {
    3939                final char c0 = LispCharacter.getValue(array[0]);
     
    6666            final int length = array.length;
    6767            if (length == 0)
    68                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     68                return signal(new WrongNumberOfArgumentsException(this));
    6969            if (length > 1) {
    7070                final char c0 = LispCharacter.getValue(array[0]);
     
    9898            final int length = array.length;
    9999            if (length == 0)
    100                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     100                return signal(new WrongNumberOfArgumentsException(this));
    101101            if (length > 1) {
    102102                char[] chars = new char[length];
     
    126126            final int length = array.length;
    127127            if (length == 0)
    128                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     128                return signal(new WrongNumberOfArgumentsException(this));
    129129            if (length > 1) {
    130130                char[] chars = new char[length];
     
    154154            final int length = array.length;
    155155            if (length == 0)
    156                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     156                return signal(new WrongNumberOfArgumentsException(this));
    157157            if (length > 1) {
    158158                char[] chars = new char[length];
     
    182182            final int length = array.length;
    183183            if (length == 0)
    184                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     184                return signal(new WrongNumberOfArgumentsException(this));
    185185            if (length > 1) {
    186186                char[] chars = new char[length];
  • trunk/j/src/org/armedbear/lisp/CharacterInputStream.java

    r4791 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterInputStream.java,v 1.57 2003-11-16 18:28:49 piso Exp $
     5 * $Id: CharacterInputStream.java,v 1.58 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7878        }
    7979        catch (IOException e) {
    80             throw new ConditionThrowable(new StreamError(e));
     80            return signal(new StreamError(e));
    8181        }
    8282    }
     
    9393            }
    9494            catch (IOException e) {
    95                 throw new ConditionThrowable(new StreamError(e));
     95                return signal(new StreamError(e));
    9696            }
    9797            if (n < 0) {
    9898                if (eofError)
    99                     throw new ConditionThrowable(new EndOfFile());
     99                    return signal(new EndOfFile());
    100100                else
    101101                    return eofValue;
     
    144144            while (true) {
    145145                int n = read();
    146                 if (n < 0)
    147                     throw new ConditionThrowable(new EndOfFile());
     146                if (n < 0) {
     147                    signal(new EndOfFile());
     148                    // Not reached.
     149                    return null;
     150                }
    148151                char c = (char) n;
    149152                if (c == '\\') {
    150153                    // Single escape.
    151154                    n = read();
    152                     if (n < 0)
    153                         throw new ConditionThrowable(new EndOfFile());
     155                    if (n < 0) {
     156                        signal(new EndOfFile());
     157                        // Not reached.
     158                        return null;
     159                    }
    154160                    sb.append((char)n);
    155161                    continue;
     
    163169        }
    164170        catch (IOException e) {
    165             throw new ConditionThrowable(new StreamError(e));
     171            signal(new StreamError(e));
     172            // Not reached.
     173            return null;
    166174        }
    167175    }
     
    179187        }
    180188        catch (IOException e) {
    181             throw new ConditionThrowable(new StreamError(e));
     189            return signal(new StreamError(e));
    182190        }
    183191        if (n < 0)
    184             throw new ConditionThrowable(new EndOfFile());
     192            return signal(new EndOfFile());
    185193        char nextChar = (char) n;
    186194        if (nextChar == '"')
    187195            return Pathname.parseNamestring(_readString());
    188         throw new ConditionThrowable(new TypeError("#p requires a string argument"));
     196        return signal(new TypeError("#p requires a string argument"));
    189197    }
    190198
     
    207215                    int n = read();
    208216                    if (n < 0)
    209                         throw new ConditionThrowable(new EndOfFile());
     217                        return signal(new EndOfFile());
    210218                    char nextChar = (char) n;
    211219                    if (isTokenDelimiter(nextChar)) {
    212220                        if (last == null)
    213                             throw new ConditionThrowable(new LispError("nothing appears before . in list"));
     221                            return signal(new LispError("nothing appears before . in list"));
    214222                        LispObject obj = read(true, NIL, true);
    215223                        last.setCdr(obj);
     
    236244        }
    237245        catch (IOException e) {
    238             throw new ConditionThrowable(new StreamError(e));
     246            return signal(new StreamError(e));
    239247        }
    240248    }
     
    258266    private LispObject readRightParen() throws ConditionThrowable
    259267    {
    260         throw new ConditionThrowable(new LispError("unmatched right parenthesis"));
     268        return signal(new LispError("unmatched right parenthesis"));
    261269    }
    262270
     
    273281        }
    274282        catch (IOException e) {
    275             throw new ConditionThrowable(new StreamError(e));
     283            return signal(new StreamError(e));
    276284        }
    277285    }
     
    282290            int n = read();
    283291            if (n < 0)
    284                 throw new ConditionThrowable(new EndOfFile());
     292                return signal(new EndOfFile());
    285293            char c = (char) n;
    286294            switch (c) {
     
    298306        }
    299307        catch (IOException e) {
    300             throw new ConditionThrowable(new StreamError(e));
     308            return signal(new StreamError(e));
    301309        }
    302310    }
     
    315323                int n = read();
    316324                if (n < 0)
    317                     throw new ConditionThrowable(new EndOfFile());
     325                    return signal(new EndOfFile());
    318326                c = (char) n;
    319327                if (c < '0' || c > '9')
     
    374382                default:
    375383                    //clearInput();
    376                     //throw new ConditionThrowable(new LispError("unsupported '#' macro character '" +
     384                    //return signal(new LispError("unsupported '#' macro character '" +
    377385                    //    c + '\'');
    378386                    return null;
     
    380388        }
    381389        catch (IOException e) {
    382             throw new ConditionThrowable(new StreamError(e));
     390            return signal(new StreamError(e));
    383391        }
    384392    }
     
    389397            int n = read();
    390398            if (n < 0)
    391                 throw new ConditionThrowable(new EndOfFile());
     399                return signal(new EndOfFile());
    392400            char c = (char) n;
    393401            StringBuffer sb = new StringBuffer();
     
    412420            if (n >= 0)
    413421                return LispCharacter.getInstance((char)n);
    414             throw new ConditionThrowable(new LispError("unrecognized character name: " + token));
    415         }
    416         catch (IOException e) {
    417             throw new ConditionThrowable(new StreamError(e));
     422            return signal(new LispError("unrecognized character name: " + token));
     423        }
     424        catch (IOException e) {
     425            return signal(new StreamError(e));
    418426        }
    419427    }
     
    444452        try {
    445453            int n = read();
    446             if (n < 0)
    447                 throw new ConditionThrowable(new EndOfFile());
     454            if (n < 0) {
     455                signal(new EndOfFile());
     456                // Not reached.
     457                return null;
     458            }
    448459            char c = (char) n;
    449460            StringBuffer sb = new StringBuffer();
     
    451462                while (true) {
    452463                    n = read();
    453                     if (n < 0)
    454                         throw new ConditionThrowable(new EndOfFile());
     464                    if (n < 0) {
     465                        signal(new EndOfFile());
     466                        // Not reached.
     467                        return null;
     468                    }
    455469                    c = (char) n;
    456470                    if (c == '\\') {
    457471                        // Single escape.
    458472                        n = read();
    459                         if (n < 0)
    460                             throw new ConditionThrowable(new EndOfFile());
     473                        if (n < 0) {
     474                            signal(new EndOfFile());
     475                            // Not reached.
     476                            return null;
     477                        }
    461478                        sb.append((char)n);
    462479                        continue;
     
    476493                        // Single escape.
    477494                        n = read();
    478                         if (n < 0)
    479                             throw new ConditionThrowable(new EndOfFile());
     495                        if (n < 0) {
     496                            signal(new EndOfFile());
     497                            // Not reached.
     498                            return null;
     499                        }
    480500                        sb.append((char)n);
    481501                        continue;
     
    493513        }
    494514        catch (IOException e) {
    495             throw new ConditionThrowable(new StreamError(e));
     515            signal(new StreamError(e));
     516            // Not reached.
     517            return null;
    496518        }
    497519    }
     
    520542        }
    521543        catch (IOException e) {
    522             throw new ConditionThrowable(new StreamError(e));
     544            signal(new StreamError(e));
    523545        }
    524546    }
     
    543565        }
    544566        catch (IOException e) {
    545             throw new ConditionThrowable(new StreamError(e));
     567            return signal(new StreamError(e));
    546568        }
    547569    }
     
    560582        if (obj instanceof Cons && obj.length() == 2)
    561583            return Complex.getInstance(obj.car(), obj.cadr());
    562         throw new ConditionThrowable(new LispError("invalid complex number format #C" + obj));
     584        return signal(new LispError("invalid complex number format #C" + obj));
    563585    }
    564586
     
    579601        }
    580602        catch (IOException e) {
    581             throw new ConditionThrowable(new StreamError(e));
     603            signal(new StreamError(e));
     604            // Not reached.
     605            return null;
    582606        }
    583607    }
     
    607631        }
    608632        catch (IOException e) {
    609             throw new ConditionThrowable(new StreamError(e));
     633            return signal(new StreamError(e));
    610634        }
    611635    }
     
    634658        }
    635659        catch (IOException e) {
    636             throw new ConditionThrowable(new StreamError(e));
     660            return signal(new StreamError(e));
    637661        }
    638662    }
     
    661685            Package pkg = Packages.findPackage(packageName);
    662686            if (pkg == null)
    663                 throw new ConditionThrowable(new LispError("package \"" + packageName +
     687                return signal(new LispError("package \"" + packageName +
    664688                                                           "\" not found"));
    665689            return pkg.intern(symbolName);
     
    671695            Package pkg = Packages.findPackage(packageName);
    672696            if (pkg == null)
    673                 throw new ConditionThrowable(new PackageError("package \"" + packageName +
     697                return signal(new PackageError("package \"" + packageName +
    674698                                                              "\" not found"));
    675699            Symbol symbol = pkg.findExternalSymbol(symbolName);
     
    678702            // Error!
    679703            if (pkg.findInternalSymbol(symbolName) != null)
    680                 throw new ConditionThrowable(new LispError("symbol \"" + symbolName +
     704                return signal(new LispError("symbol \"" + symbolName +
    681705                                                           "\" is not external in package " +
    682706                                                           packageName));
    683707            else
    684                 throw new ConditionThrowable(new LispError("symbol \"" + symbolName +
     708                return signal(new LispError("symbol \"" + symbolName +
    685709                                                           "\" not found in package " +
    686710                                                           packageName));
     
    802826            catch (NumberFormatException e) {}
    803827            // Not a number.
    804             throw new ConditionThrowable(new LispError());
    805         }
    806         catch (IOException e) {
    807             throw new ConditionThrowable(new StreamError(e));
     828            return signal(new LispError());
     829        }
     830        catch (IOException e) {
     831            return signal(new StreamError(e));
    808832        }
    809833    }
     
    840864            catch (NumberFormatException e) {}
    841865            // Not a number.
    842             throw new ConditionThrowable(new LispError());
    843         }
    844         catch (IOException e) {
    845             throw new ConditionThrowable(new StreamError(e));
     866            return signal(new LispError());
     867        }
     868        catch (IOException e) {
     869            return signal(new StreamError(e));
    846870        }
    847871    }
     
    852876            while (true) {
    853877                int n = read();
    854                 if (n < 0)
    855                     throw new ConditionThrowable(new EndOfFile());
     878                if (n < 0) {
     879                    signal(new EndOfFile());
     880                    // Not reached.
     881                    return 0;
     882                }
    856883                char c = (char) n;
    857884                if (!Character.isWhitespace(c))
     
    860887        }
    861888        catch (IOException e) {
    862             throw new ConditionThrowable(new StreamError(e));
     889            signal(new StreamError(e));
     890            // Not reached.
     891            return 0;
    863892        }
    864893    }
     
    877906                    if (sb.length() == 0) {
    878907                        if (eofError)
    879                             throw new ConditionThrowable(new EndOfFile());
     908                            return signal(new EndOfFile());
    880909                        return eofValue;
    881910                    }
     
    893922            }
    894923            catch (IOException e) {
    895                 throw new ConditionThrowable(new StreamError(e));
     924                return signal(new StreamError(e));
    896925            }
    897926        }
     
    908937        }
    909938        catch (IOException e) {
    910             throw new ConditionThrowable(new StreamError(e));
     939            return signal(new StreamError(e));
    911940        }
    912941        if (n < 0) {
    913942            if (eofError)
    914                 throw new ConditionThrowable(new EndOfFile());
     943                return signal(new EndOfFile());
    915944            else
    916945                return eofValue;
     
    926955        }
    927956        catch (IOException e) {
    928             throw new ConditionThrowable(new StreamError(e));
     957            return signal(new StreamError(e));
    929958        }
    930959        return NIL;
     
    939968        }
    940969        catch (IOException e) {
    941             throw new ConditionThrowable(new StreamError(e));
     970            return signal(new StreamError(e));
    942971        }
    943972        return NIL;
     
    953982        }
    954983        catch (IOException e) {
    955             throw new ConditionThrowable(new StreamError(e));
     984            return signal(new StreamError(e));
    956985        }
    957986    }
  • trunk/j/src/org/armedbear/lisp/HashTable.java

    r5037 r5112  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: HashTable.java,v 1.27 2003-12-09 20:26:22 asimon Exp $
     5 * $Id: HashTable.java,v 1.28 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5656            this.test = TEST_EQUALP;
    5757        else
    58             throw new ConditionThrowable(new LispError("MAKE-HASH-TABLE:  test " + test));
     58            signal(new LispError("MAKE-HASH-TABLE:  test " + test));
    5959        // Ignore rehashSize and rehashThreshold.
    6060        buckets = new HashEntry[size];
     
    285285        {
    286286            if (args.length != 4)
    287                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     287                return signal(new WrongNumberOfArgumentsException(this));
    288288            LispObject test = args[0];
    289289            int size = Fixnum.getValue(args[1]);
     
    301301            final int length = args.length;
    302302            if (length < 2 || length > 3)
    303                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     303                return signal(new WrongNumberOfArgumentsException(this));
    304304            if (args[1] instanceof HashTable) {
    305305                LispObject key = args[0];
     
    309309                return ht.gethash(key, defaultValue);
    310310            }
    311             throw new ConditionThrowable(new TypeError(args[1], "hash-table"));
     311            return signal(new TypeError(args[1], "hash-table"));
    312312        }
    313313    };
     
    321321            final int length = args.length;
    322322            if (length < 3 || length > 4)
    323                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     323                return signal(new WrongNumberOfArgumentsException(this));
    324324            if (args[1] instanceof HashTable) {
    325325                LispObject key = args[0];
     
    334334                return ht.puthash(key, value);
    335335            }
    336             throw new ConditionThrowable(new TypeError(args[1], "hash-table"));
     336            return signal(new TypeError(args[1], "hash-table"));
    337337        }
    338338    };
     
    348348                return ht.remhash(key);
    349349            }
    350             throw new ConditionThrowable(new TypeError(second, "hash-table"));
     350            return signal(new TypeError(second, "hash-table"));
    351351        }
    352352    };
     
    361361                return arg;
    362362            }
    363             throw new ConditionThrowable(new TypeError(arg, "hash-table"));
     363            return signal(new TypeError(arg, "hash-table"));
    364364        }
    365365    };
     
    372372            if (arg instanceof HashTable)
    373373                return new Fixnum(((HashTable)arg).getCount());
    374             throw new ConditionThrowable(new TypeError(arg, "hash-table"));
     374            return signal(new TypeError(arg, "hash-table"));
    375375        }
    376376    };
     
    402402            if (arg instanceof HashTable)
    403403                return ((HashTable)arg).ENTRIES();
    404             throw new ConditionThrowable(new TypeError(arg, "hash-table"));
     404            return signal(new TypeError(arg, "hash-table"));
    405405        }
    406406    };
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r5079 r5112  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Interpreter.java,v 1.46 2003-12-12 01:12:19 piso Exp $
     5 * $Id: Interpreter.java,v 1.47 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    339339                if (ldArgs != null)
    340340                    args = ldArgs;
    341                 else
    342                     throw new ConditionThrowable(new LispError("ld: no previous file"));
     341                else {
     342                    signal(new LispError("ld: no previous file"));
     343                    return true;
     344                }
    343345            }
    344346            if (args != null && args.length() > 0) {
     
    382384                }
    383385                catch (IOException e) {
    384                     throw new ConditionThrowable(new LispError(e.getMessage()));
     386                    signal(new LispError(e.getMessage()));
     387                    return true;
    385388                }
    386389            }
     
    417420                    new StringInputStream("(apropos " + args + ")");
    418421                LispObject obj = stream.read(false, EOF, false);
    419                 if (obj == EOF)
    420                     throw new ConditionThrowable(new EndOfFile());
     422                if (obj == EOF) {
     423                    signal(new EndOfFile());
     424                    return true;
     425                }
    421426                eval(obj, new Environment(), LispThread.currentThread());
    422427                getStandardOutput().freshLine();
     
    431436                    new StringInputStream("(describe " + args + ")");
    432437                LispObject obj = stream.read(false, EOF, false);
    433                 if (obj == EOF)
    434                     throw new ConditionThrowable(new EndOfFile());
     438                if (obj == EOF) {
     439                    signal(new EndOfFile());
     440                    return true;
     441                }
    435442                eval(obj, new Environment(), LispThread.currentThread());
    436443                return true;
     
    589596        LispObject obj = stream.read(false, EOF, false);
    590597        if (obj == EOF)
    591             throw new ConditionThrowable(new EndOfFile());
     598            return signal(new EndOfFile());
    592599        return eval(obj, new Environment(), LispThread.currentThread());
    593600    }
  • trunk/j/src/org/armedbear/lisp/Layout.java

    r5064 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Layout.java,v 1.1 2003-12-11 19:08:23 piso Exp $
     5 * $Id: Layout.java,v 1.2 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848            }
    4949            catch (ClassCastException e) {
    50                 throw new ConditionThrowable(new TypeError(first, "class"));
     50                return signal(new TypeError(first, "class"));
    5151            }
    5252        }
     
    6363            }
    6464            catch (ClassCastException e) {
    65                 throw new ConditionThrowable(new TypeError(arg, "layout"));
     65                return signal(new TypeError(arg, "layout"));
    6666            }
    6767        }
     
    7777            }
    7878            catch (ClassCastException e) {
    79                 throw new ConditionThrowable(new TypeError(arg, "layout"));
     79                return signal(new TypeError(arg, "layout"));
    8080            }
    8181        }
  • trunk/j/src/org/armedbear/lisp/LispClass.java

    r5075 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispClass.java,v 1.36 2003-12-11 20:37:53 piso Exp $
     5 * $Id: LispClass.java,v 1.37 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    200200                StringBuffer sb = new StringBuffer("there is no class named ");
    201201                sb.append(symbol);
    202                 throw new ConditionThrowable(new LispError(sb.toString()));
     202                return signal(new LispError(sb.toString()));
    203203            }
    204204            return c;
     
    212212                    StringBuffer sb = new StringBuffer("there is no class named ");
    213213                    sb.append(symbol);
    214                     throw new ConditionThrowable(new LispError(sb.toString()));
     214                    return signal(new LispError(sb.toString()));
    215215                }
    216216                return NIL;
     
    243243                return second;
    244244            }
    245             throw new ConditionThrowable(new TypeError(second, "class"));
     245            return signal(new TypeError(second, "class"));
    246246        }
    247247    };
     
    256256            }
    257257            catch (ClassCastException e) {
    258                 throw new ConditionThrowable(new TypeError(arg, "class"));
     258                return signal(new TypeError(arg, "class"));
    259259            }
    260260        }
     
    273273            }
    274274            catch (ClassCastException e) {
    275                 throw new ConditionThrowable(new TypeError(first, "class"));
     275                return signal(new TypeError(first, "class"));
    276276            }
    277277        }
     
    289289            }
    290290            catch (ClassCastException e) {
    291                 throw new ConditionThrowable(new TypeError(arg, "class"));
     291                return signal(new TypeError(arg, "class"));
    292292            }
    293293        }
     
    307307            catch (ClassCastException e) {
    308308                if (!(first instanceof LispClass))
    309                     throw new ConditionThrowable(new TypeError(first, "class"));
     309                    return signal(new TypeError(first, "class"));
    310310                if (!(second instanceof Layout))
    311                     throw new ConditionThrowable(new TypeError(second, "layout"));
     311                    return signal(new TypeError(second, "layout"));
    312312                // Not reached.
    313313                return NIL;
     
    324324            if (arg instanceof LispClass)
    325325                return ((LispClass)arg).getDirectSuperclasses();
    326             throw new ConditionThrowable(new TypeError(arg, "class"));
     326            return signal(new TypeError(arg, "class"));
    327327        }
    328328    };
     
    339339                return second;
    340340            }
    341             throw new ConditionThrowable(new TypeError(first, "class"));
     341            return signal(new TypeError(first, "class"));
    342342        }
    343343    };
     
    351351            if (arg instanceof LispClass)
    352352                return ((LispClass)arg).getDirectSubclasses();
    353             throw new ConditionThrowable(new TypeError(arg, "class"));
     353            return signal(new TypeError(arg, "class"));
    354354        }
    355355    };
     
    366366                return second;
    367367            }
    368             throw new ConditionThrowable(new TypeError(first, "class"));
     368            return signal(new TypeError(first, "class"));
    369369        }
    370370    };
     
    378378            if (arg instanceof LispClass)
    379379                return ((LispClass)arg).getCPL();
    380             throw new ConditionThrowable(new TypeError(arg, "class"));
     380            return signal(new TypeError(arg, "class"));
    381381        }
    382382    };
     
    393393                return second;
    394394            }
    395             throw new ConditionThrowable(new TypeError(first, "class"));
     395            return signal(new TypeError(first, "class"));
    396396        }
    397397    };
     
    406406            if (arg instanceof LispClass)
    407407                return ((LispClass)arg).directMethods;
    408             throw new ConditionThrowable(new TypeError(arg, "class"));
     408            return signal(new TypeError(arg, "class"));
    409409        }
    410410    };
     
    421421                return second;
    422422            }
    423             throw new ConditionThrowable(new TypeError(first, "class"));
     423            return signal(new TypeError(first, "class"));
    424424        }
    425425    };
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r5037 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispFloat.java,v 1.52 2003-12-09 20:26:22 asimon Exp $
     5 * $Id: LispFloat.java,v 1.53 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    153153        }
    154154        catch (ClassCastException e) {
    155             throw new ConditionThrowable(new TypeError(obj, "float"));
     155            signal(new TypeError(obj, "float"));
     156            // Not reached.
     157            return 0;
    156158        }
    157159    }
     
    191193            return Complex.getInstance(add(c.getRealPart()), c.getImaginaryPart());
    192194        }
    193         throw new ConditionThrowable(new TypeError(obj, "number"));
     195        return signal(new TypeError(obj, "number"));
    194196    }
    195197
     
    209211                                       ZERO.subtract(c.getImaginaryPart()));
    210212        }
    211         throw new ConditionThrowable(new TypeError(obj, "number"));
     213        return signal(new TypeError(obj, "number"));
    212214    }
    213215
     
    222224        if (obj instanceof Ratio)
    223225            return new LispFloat(value * ((Ratio)obj).floatValue());
    224         throw new ConditionThrowable(new TypeError(obj, "number"));
     226        return signal(new TypeError(obj, "number"));
    225227    }
    226228
     
    228230    {
    229231        if (obj.zerop())
    230             throw new ConditionThrowable(new DivisionByZero());
     232            return signal(new DivisionByZero());
    231233        if (obj instanceof LispFloat)
    232234            return new LispFloat(value / ((LispFloat)obj).value);
     
    237239        if (obj instanceof Ratio)
    238240            return new LispFloat(value / ((Ratio)obj).floatValue());
    239         throw new ConditionThrowable(new TypeError(obj, "number"));
     241        return signal(new TypeError(obj, "number"));
    240242    }
    241243
     
    252254        if (obj instanceof Complex)
    253255            return obj.isEqualTo(this);
    254         throw new ConditionThrowable(new TypeError(obj, "number"));
     256        signal(new TypeError(obj, "number"));
     257        // Not reached.
     258        return false;
    255259    }
    256260
     
    270274        if (obj instanceof Ratio)
    271275            return value < ((Ratio)obj).floatValue();
    272         throw new ConditionThrowable(new TypeError(obj, "real"));
     276        signal(new TypeError(obj, "real"));
     277        // Not reached.
     278        return false;
    273279    }
    274280
     
    283289        if (obj instanceof Ratio)
    284290            return value > ((Ratio)obj).floatValue();
    285         throw new ConditionThrowable(new TypeError(obj, "real"));
     291        signal(new TypeError(obj, "real"));
     292        // Not reached.
     293        return false;
    286294    }
    287295
     
    296304        if (obj instanceof Ratio)
    297305            return value <= ((Ratio)obj).floatValue();
    298         throw new ConditionThrowable(new TypeError(obj, "real"));
     306        signal(new TypeError(obj, "real"));
     307        // Not reached.
     308        return false;
    299309    }
    300310
     
    309319        if (obj instanceof Ratio)
    310320            return value >= ((Ratio)obj).floatValue();
    311         throw new ConditionThrowable(new TypeError(obj, "real"));
     321        signal(new TypeError(obj, "real"));
     322        // Not reached.
     323        return false;
    312324    }
    313325
     
    352364            return thread.setValues(result, remainder);
    353365        }
    354         throw new ConditionThrowable(new LispError("LispFloat.truncate(): not implemented: " + obj.typeOf()));
     366        return signal(new LispError("LispFloat.truncate(): not implemented: " + obj.typeOf()));
    355367    }
    356368
     
    391403                                                            sign);
    392404            }
    393             throw new ConditionThrowable(new TypeError(arg, "float"));
     405            return signal(new TypeError(arg, "float"));
    394406        }
    395407    };
     
    403415            if (arg instanceof LispFloat)
    404416                return Fixnum.TWO;
    405             throw new ConditionThrowable(new TypeError(arg, "float"));
     417            return signal(new TypeError(arg, "float"));
    406418        }
    407419    };
     
    415427            if (arg instanceof LispFloat)
    416428                return new Fixnum(52);
    417             throw new ConditionThrowable(new TypeError(arg, "float"));
     429            return signal(new TypeError(arg, "float"));
    418430        }
    419431    };
     
    429441        if (obj instanceof Ratio)
    430442            return new LispFloat(((Ratio)obj).floatValue());
    431         throw new ConditionThrowable(new TypeError(obj, "real number"));
     443        signal(new TypeError(obj, "real number"));
     444        // Not reached.
     445        return LispFloat.ZERO;
    432446    }
    433447
     
    439453            final int length = args.length;
    440454            if (length < 1 || length > 2)
    441                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     455                return signal(new WrongNumberOfArgumentsException(this));
    442456            // FIXME Ignore prototype (args[1] if present).
    443457            return coerceToFloat(args[0]);
  • trunk/j/src/org/armedbear/lisp/PackageFunctions.java

    r5045 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: PackageFunctions.java,v 1.22 2003-12-10 07:25:34 asimon Exp $
     5 * $Id: PackageFunctions.java,v 1.23 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8080        {
    8181            if (args.length == 0 || args.length > 2)
    82                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     82                return signal(new WrongNumberOfArgumentsException(this));
    8383            LispObject symbols = args[0];
    8484            Package pkg =
     
    101101        {
    102102            if (args.length == 0 || args.length > 2)
    103                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     103                return signal(new WrongNumberOfArgumentsException(this));
    104104            LispObject symbols = args[0];
    105105            Package pkg =
     
    122122        {
    123123            if (args.length == 0 || args.length > 2)
    124                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     124                return signal(new WrongNumberOfArgumentsException(this));
    125125            LispObject symbols = args[0];
    126126            Package pkg =
     
    144144        {
    145145            if (args.length == 0 || args.length > 2)
    146                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     146                return signal(new WrongNumberOfArgumentsException(this));
    147147            LispObject symbols = args[0];
    148148            Package pkg =
     
    185185        {
    186186            if (args.length < 1 || args.length > 2)
    187                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     187                return signal(new WrongNumberOfArgumentsException(this));
    188188            Package pkg;
    189189            if (args.length == 2)
     
    210210        {
    211211            if (args.length < 2 || args.length > 3)
    212                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     212                return signal(new WrongNumberOfArgumentsException(this));
    213213            Package pkg = coerceToPackage(args[0]);
    214214            String newName = javaString(args[1]);
     
    235235        {
    236236            if (args.length != 10)
    237                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     237                return signal(new WrongNumberOfArgumentsException(this));
    238238            final String packageName = LispString.getValue(args[0]);
    239239            LispObject nicknames = checkList(args[1]);
     
    256256                    String nick = javaString(list.car());
    257257                    if (Packages.findPackage(nick) != null) {
    258                         throw new ConditionThrowable(new PackageError("a package named " + nick +
     258                        return signal(new PackageError("a package named " + nick +
    259259                                                                      " already exists"));
    260260                    }
     
    287287                        pkg.shadowingImport(sym);
    288288                    else
    289                         throw new ConditionThrowable(new LispError(symbolName +
     289                        return signal(new LispError(symbolName +
    290290                                                                   " not found in package " +
    291291                                                                   otherPkg.getName()));
     
    303303                    Package p = Packages.findPackage(string.getValue());
    304304                    if (p == null)
    305                         throw new ConditionThrowable(new LispError(String.valueOf(obj) +
     305                        return signal(new LispError(String.valueOf(obj) +
    306306                                                                   " is not the name of a package"));
    307307                    pkg.usePackage(p);
     
    320320                        pkg.importSymbol(sym);
    321321                    else
    322                         throw new ConditionThrowable(new LispError(symbolName +
     322                        return signal(new LispError(symbolName +
    323323                                                                   " not found in package " +
    324324                                                                   otherPkg.getName()));
  • trunk/j/src/org/armedbear/lisp/Ratio.java

    r4790 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Ratio.java,v 1.38 2003-11-16 18:25:31 piso Exp $
     5 * $Id: Ratio.java,v 1.39 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    195195            return Complex.getInstance(add(c.getRealPart()), c.getImaginaryPart());
    196196        }
    197         throw new ConditionThrowable(new TypeError(obj, "number"));
     197        return signal(new TypeError(obj, "number"));
    198198    }
    199199
     
    227227                                       Fixnum.ZERO.subtract(c.getImaginaryPart()));
    228228        }
    229         throw new ConditionThrowable(new TypeError(obj, "number"));
     229        return signal(new TypeError(obj, "number"));
    230230    }
    231231
     
    248248            return new LispFloat(floatValue() * ((LispFloat)obj).getValue());
    249249        }
    250         throw new ConditionThrowable(new TypeError(obj, "number"));
     250        return signal(new TypeError(obj, "number"));
    251251    }
    252252
     
    268268        if (obj instanceof LispFloat) {
    269269            if (obj.zerop())
    270                 throw new ConditionThrowable(new DivisionByZero());
     270                return signal(new DivisionByZero());
    271271            return new LispFloat(floatValue() / ((LispFloat)obj).getValue());
    272272        }
    273         throw new ConditionThrowable(new TypeError(obj, "number"));
     273        return signal(new TypeError(obj, "number"));
    274274    }
    275275
     
    283283        if (obj.numberp())
    284284            return false;
    285         throw new ConditionThrowable(new TypeError(obj, "number"));
     285        signal(new TypeError(obj, "number"));
     286        // Not reached.
     287        return false;
    286288    }
    287289
     
    309311            return floatValue() < ((LispFloat)obj).getValue();
    310312        }
    311         throw new ConditionThrowable(new TypeError(obj, "real"));
     313        signal(new TypeError(obj, "real"));
     314        // Not reached.
     315        return false;
    312316    }
    313317
     
    330334            return floatValue() > ((LispFloat)obj).getValue();
    331335        }
    332         throw new ConditionThrowable(new TypeError(obj, "real"));
     336        signal(new TypeError(obj, "real"));
     337        // Not reached.
     338        return false;
    333339    }
    334340
     
    351357            return floatValue() <= ((LispFloat)obj).getValue();
    352358        }
    353         throw new ConditionThrowable(new TypeError(obj, "real"));
     359        signal(new TypeError(obj, "real"));
     360        // Not reached.
     361        return false;
    354362    }
    355363
     
    372380            return floatValue() >= ((LispFloat)obj).getValue();
    373381        }
    374         throw new ConditionThrowable(new TypeError(obj, "real"));
     382        signal(new TypeError(obj, "real"));
     383        // Not reached.
     384        return false;
    375385    }
    376386
     
    390400    } else {
    391401            Thread.dumpStack();
    392             throw new ConditionThrowable(new TypeError(obj, "number"));
     402            return signal(new TypeError(obj, "number"));
    393403    }
    394404
     
    408418        catch (ArithmeticException e) {
    409419            if (obj.zerop())
    410                 throw new ConditionThrowable(new DivisionByZero());
    411             throw new ConditionThrowable(new ArithmeticError(e.getMessage()));
     420                return signal(new DivisionByZero());
     421            return signal(new ArithmeticError(e.getMessage()));
    412422        }
    413423    }
  • trunk/j/src/org/armedbear/lisp/SlotClass.java

    r4855 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SlotClass.java,v 1.3 2003-11-21 01:06:35 piso Exp $
     5 * $Id: SlotClass.java,v 1.4 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6464            if (arg instanceof BuiltInClass)
    6565                return NIL;
    66             throw new ConditionThrowable(new TypeError(arg, "standard class"));
     66            return signal(new TypeError(arg, "standard class"));
    6767        }
    6868    };
     
    7979                return second;
    8080            }
    81             throw new ConditionThrowable(new TypeError(first, "standard class"));
     81            return signal(new TypeError(first, "standard class"));
    8282        }
    8383    };
     
    9494            if (arg instanceof BuiltInClass)
    9595                return NIL;
    96             throw new ConditionThrowable(new TypeError(arg, "standard class"));
     96            return signal(new TypeError(arg, "standard class"));
    9797        }
    9898    };
     
    109109                return second;
    110110            }
    111             throw new ConditionThrowable(new TypeError(first, "standard class"));
     111            return signal(new TypeError(first, "standard class"));
    112112        }
    113113    };
     
    124124            if (arg instanceof BuiltInClass)
    125125                return NIL;
    126             throw new ConditionThrowable(new TypeError(arg, "standard class"));
     126            return signal(new TypeError(arg, "standard class"));
    127127        }
    128128    };
     
    139139                return second;
    140140            }
    141             throw new ConditionThrowable(new TypeError(first, "standard class"));
     141            return signal(new TypeError(first, "standard class"));
    142142        }
    143143    };
     
    154154            if (arg instanceof BuiltInClass)
    155155                return NIL;
    156             throw new ConditionThrowable(new TypeError(arg, "standard class"));
     156            return signal(new TypeError(arg, "standard class"));
    157157        }
    158158    };
     
    169169                return second;
    170170            }
    171             throw new ConditionThrowable(new TypeError(first, "standard class"));
     171            return signal(new TypeError(first, "standard class"));
    172172        }
    173173    };
  • trunk/j/src/org/armedbear/lisp/SpecialOperators.java

    r4839 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SpecialOperators.java,v 1.18 2003-11-19 16:17:32 piso Exp $
     5 * $Id: SpecialOperators.java,v 1.19 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5353                }
    5454                default:
    55                     throw new ConditionThrowable(new WrongNumberOfArgumentsException("IF"));
     55                    return signal(new WrongNumberOfArgumentsException("IF"));
    5656            }
    5757        }
     
    167167                                 ext);
    168168                        } else
    169                             throw new ConditionThrowable(new ProgramError("SYMBOL-MACROLET: bad symbol-expansion pair: " + obj));
     169                            return signal(new ProgramError("SYMBOL-MACROLET: bad symbol-expansion pair: " + obj));
    170170                    }
    171171                    LispObject body = args.cdr();
     
    203203                                LispThread.currentThread());
    204204                default:
    205                     throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     205                    return signal(new WrongNumberOfArgumentsException(this));
    206206            }
    207207        }
     
    303303        {
    304304            if (args.length() != 2)
    305                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     305                return signal(new WrongNumberOfArgumentsException(this));
    306306            return eval(args.cadr(), env, LispThread.currentThread());
    307307        }
     
    315315        {
    316316            if (args.length() < 2)
    317                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     317                return signal(new WrongNumberOfArgumentsException(this));
    318318            final LispThread thread = LispThread.currentThread();
    319319            final LispObject symbols = checkList(eval(args.car(), env, thread));
     
    387387                if (functional instanceof GenericFunction)
    388388                    return functional;
    389                 throw new ConditionThrowable(new UndefinedFunction(arg));
     389                return signal(new UndefinedFunction(arg));
    390390            }
    391391            if (arg instanceof Cons) {
     
    399399                }
    400400            }
    401             throw new ConditionThrowable(new UndefinedFunction(arg));
     401            return signal(new UndefinedFunction(arg));
    402402        }
    403403    };
  • trunk/j/src/org/armedbear/lisp/StringFunctions.java

    r4271 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StringFunctions.java,v 1.11 2003-10-10 00:49:55 piso Exp $
     5 * $Id: StringFunctions.java,v 1.12 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3232        {
    3333            if (args.length != 6)
    34                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     34                return signal(new WrongNumberOfArgumentsException(this));
    3535            char[] array1 = string(args[0]).chars();
    3636            char[] array2 = string(args[1]).chars();
     
    6262        {
    6363            if (args.length != 6)
    64                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     64                return signal(new WrongNumberOfArgumentsException(this));
    6565            char[] array1 = string(args[0]).chars();
    6666            char[] array2 = string(args[1]).chars();
     
    9898        {
    9999            if (args.length != 6)
    100                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     100                return signal(new WrongNumberOfArgumentsException(this));
    101101            char[] array1 = string(args[0]).chars();
    102102            char[] array2 = string(args[1]).chars();
     
    131131        {
    132132            if (args.length != 6)
    133                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     133                return signal(new WrongNumberOfArgumentsException(this));
    134134            char[] array1 = string(args[0]).chars();
    135135            char[] array2 = string(args[1]).chars();
     
    174174        {
    175175            if (args.length != 6)
    176                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     176                return signal(new WrongNumberOfArgumentsException(this));
    177177            char[] array1 = string(args[0]).chars();
    178178            char[] array2 = string(args[1]).chars();
     
    217217        {
    218218            if (args.length != 6)
    219                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     219                return signal(new WrongNumberOfArgumentsException(this));
    220220            char[] array1 = string(args[0]).chars();
    221221            char[] array2 = string(args[1]).chars();
     
    258258        {
    259259            if (args.length != 6)
    260                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     260                return signal(new WrongNumberOfArgumentsException(this));
    261261            char[] array1 = string(args[0]).chars();
    262262            char[] array2 = string(args[1]).chars();
     
    299299        {
    300300            if (args.length != 6)
    301                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     301                return signal(new WrongNumberOfArgumentsException(this));
    302302            char[] array1 = string(args[0]).chars();
    303303            char[] array2 = string(args[1]).chars();
     
    342342        {
    343343            if (args.length != 6)
    344                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     344                return signal(new WrongNumberOfArgumentsException(this));
    345345            char[] array1 = string(args[0]).chars();
    346346            char[] array2 = string(args[1]).chars();
     
    385385        {
    386386            if (args.length != 6)
    387                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     387                return signal(new WrongNumberOfArgumentsException(this));
    388388            char[] array1 = string(args[0]).chars();
    389389            char[] array2 = string(args[1]).chars();
     
    426426        {
    427427            if (args.length != 6)
    428                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     428                return signal(new WrongNumberOfArgumentsException(this));
    429429            char[] array1 = string(args[0]).chars();
    430430            char[] array2 = string(args[1]).chars();
     
    469469        {
    470470            if (args.length != 6)
    471                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     471                return signal(new WrongNumberOfArgumentsException(this));
    472472            char[] array1 = string(args[0]).chars();
    473473            char[] array2 = string(args[1]).chars();
     
    513513            int start = (int) Fixnum.getValue(second);
    514514            if (start < 0 || start > length)
    515                 throw new ConditionThrowable(new TypeError("invalid start position " + start));
     515                return signal(new TypeError("invalid start position " + start));
    516516            int end;
    517517            if (third == NIL)
     
    520520                end = (int) Fixnum.getValue(third);
    521521            if (end < 0 || end > length)
    522                 throw new ConditionThrowable(new TypeError("invalid end position " + start));
     522                return signal(new TypeError("invalid end position " + start));
    523523            if (start > end)
    524                 throw new ConditionThrowable(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
     524                return signal(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
    525525            StringBuffer sb = new StringBuffer(length);
    526526            char[] array = s.chars();
     
    547547            int start = (int) Fixnum.getValue(second);
    548548            if (start < 0 || start > length)
    549                 throw new ConditionThrowable(new TypeError("invalid start position " + start));
     549                return signal(new TypeError("invalid start position " + start));
    550550            int end;
    551551            if (third == NIL)
     
    554554                end = (int) Fixnum.getValue(third);
    555555            if (end < 0 || end > length)
    556                 throw new ConditionThrowable(new TypeError("invalid end position " + start));
     556                return signal(new TypeError("invalid end position " + start));
    557557            if (start > end)
    558                 throw new ConditionThrowable(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
     558                return signal(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
    559559            StringBuffer sb = new StringBuffer(length);
    560560            char[] array = s.chars();
     
    581581            int start = (int) Fixnum.getValue(second);
    582582            if (start < 0 || start > length)
    583                 throw new ConditionThrowable(new TypeError("invalid start position " + start));
     583                return signal(new TypeError("invalid start position " + start));
    584584            int end;
    585585            if (third == NIL)
     
    588588                end = (int) Fixnum.getValue(third);
    589589            if (end < 0 || end > length)
    590                 throw new ConditionThrowable(new TypeError("invalid end position " + start));
     590                return signal(new TypeError("invalid end position " + start));
    591591            if (start > end)
    592                 throw new ConditionThrowable(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
     592                return signal(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
    593593            StringBuffer sb = new StringBuffer(length);
    594594            char[] array = s.chars();
     
    627627            int start = (int) Fixnum.getValue(second);
    628628            if (start < 0 || start > length)
    629                 throw new ConditionThrowable(new TypeError("invalid start position " + start));
     629                return signal(new TypeError("invalid start position " + start));
    630630            int end;
    631631            if (third == NIL)
     
    634634                end = (int) Fixnum.getValue(third);
    635635            if (end < 0 || end > length)
    636                 throw new ConditionThrowable(new TypeError("invalid end position " + start));
     636                return signal(new TypeError("invalid end position " + start));
    637637            if (start > end)
    638                 throw new ConditionThrowable(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
     638                return signal(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
    639639            char[] array = s.chars();
    640640            for (int i = start; i < end; i++)
     
    655655            int start = (int) Fixnum.getValue(second);
    656656            if (start < 0 || start > length)
    657                 throw new ConditionThrowable(new TypeError("invalid start position " + start));
     657                return signal(new TypeError("invalid start position " + start));
    658658            int end;
    659659            if (third == NIL)
     
    662662                end = (int) Fixnum.getValue(third);
    663663            if (end < 0 || end > length)
    664                 throw new ConditionThrowable(new TypeError("invalid end position " + start));
     664                return signal(new TypeError("invalid end position " + start));
    665665            if (start > end)
    666                 throw new ConditionThrowable(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
     666                return signal(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
    667667            char[] array = s.chars();
    668668            for (int i = start; i < end; i++)
     
    683683            int start = (int) Fixnum.getValue(second);
    684684            if (start < 0 || start > length)
    685                 throw new ConditionThrowable(new TypeError("invalid start position " + start));
     685                return signal(new TypeError("invalid start position " + start));
    686686            int end;
    687687            if (third == NIL)
     
    690690                end = (int) Fixnum.getValue(third);
    691691            if (end < 0 || end > length)
    692                 throw new ConditionThrowable(new TypeError("invalid end position " + start));
     692                return signal(new TypeError("invalid end position " + start));
    693693            if (start > end)
    694                 throw new ConditionThrowable(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
     694                return signal(new TypeError("start (" + start + ") is greater than end (" + end + ")"));
    695695            char[] array = s.chars();
    696696            boolean lastCharWasAlphanumeric = false;
  • trunk/j/src/org/armedbear/lisp/StructureObject.java

    r5037 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StructureObject.java,v 1.16 2003-12-09 20:26:23 asimon Exp $
     5 * $Id: StructureObject.java,v 1.17 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9292            }
    9393            catch (ClassCastException e) {
    94                 throw new ConditionThrowable(new TypeError());
    95             }
    96             catch (ArrayIndexOutOfBoundsException e) {
    97                 // Shouldn't happen.
    98                 throw new ConditionThrowable(new LispError("internal error"));
     94                return signal(new TypeError());
     95            }
     96            catch (ArrayIndexOutOfBoundsException e) {
     97                // Shouldn't happen.
     98                return signal(new LispError("internal error"));
    9999            }
    100100        }
     
    109109            }
    110110            catch (ClassCastException e) {
    111                 throw new ConditionThrowable(new TypeError());
    112             }
    113             catch (ArrayIndexOutOfBoundsException e) {
    114                 // Shouldn't happen.
    115                 throw new ConditionThrowable(new LispError("internal error"));
     111                return signal(new TypeError());
     112            }
     113            catch (ArrayIndexOutOfBoundsException e) {
     114                // Shouldn't happen.
     115                return signal(new LispError("internal error"));
    116116            }
    117117        }
     
    126126            }
    127127            catch (ClassCastException e) {
    128                 throw new ConditionThrowable(new TypeError());
    129             }
    130             catch (ArrayIndexOutOfBoundsException e) {
    131                 // Shouldn't happen.
    132                 throw new ConditionThrowable(new LispError("internal error"));
     128                return signal(new TypeError());
     129            }
     130            catch (ArrayIndexOutOfBoundsException e) {
     131                // Shouldn't happen.
     132                return signal(new LispError("internal error"));
    133133            }
    134134        }
     
    143143            }
    144144            catch (ClassCastException e) {
    145                 throw new ConditionThrowable(new TypeError());
    146             }
    147             catch (ArrayIndexOutOfBoundsException e) {
    148                 // Shouldn't happen.
    149                 throw new ConditionThrowable(new LispError("internal error"));
     145                return signal(new TypeError());
     146            }
     147            catch (ArrayIndexOutOfBoundsException e) {
     148                // Shouldn't happen.
     149                return signal(new LispError("internal error"));
    150150            }
    151151        }
     
    165165            }
    166166            catch (ClassCastException e) {
    167                 throw new ConditionThrowable(new TypeError());
    168             }
    169             catch (ArrayIndexOutOfBoundsException e) {
    170                 // Shouldn't happen.
    171                 throw new ConditionThrowable(new LispError("internal error"));
     167                return signal(new TypeError());
     168            }
     169            catch (ArrayIndexOutOfBoundsException e) {
     170                // Shouldn't happen.
     171                return signal(new LispError("internal error"));
    172172            }
    173173        }
     
    184184            }
    185185            catch (ClassCastException e) {
    186                 throw new ConditionThrowable(new TypeError());
    187             }
    188             catch (ArrayIndexOutOfBoundsException e) {
    189                 // Shouldn't happen.
    190                 throw new ConditionThrowable(new LispError("internal error"));
     186                return signal(new TypeError());
     187            }
     188            catch (ArrayIndexOutOfBoundsException e) {
     189                // Shouldn't happen.
     190                return signal(new LispError("internal error"));
    191191            }
    192192        }
     
    203203            }
    204204            catch (ClassCastException e) {
    205                 throw new ConditionThrowable(new TypeError());
    206             }
    207             catch (ArrayIndexOutOfBoundsException e) {
    208                 // Shouldn't happen.
    209                 throw new ConditionThrowable(new LispError("internal error"));
     205                return signal(new TypeError());
     206            }
     207            catch (ArrayIndexOutOfBoundsException e) {
     208                // Shouldn't happen.
     209                return signal(new LispError("internal error"));
    210210            }
    211211        }
     
    222222            }
    223223            catch (ClassCastException e) {
    224                 throw new ConditionThrowable(new TypeError());
    225             }
    226             catch (ArrayIndexOutOfBoundsException e) {
    227                 // Shouldn't happen.
    228                 throw new ConditionThrowable(new LispError("internal error"));
     224                return signal(new TypeError());
     225            }
     226            catch (ArrayIndexOutOfBoundsException e) {
     227                // Shouldn't happen.
     228                return signal(new LispError("internal error"));
    229229            }
    230230        }
     
    252252            }
    253253            catch (ClassCastException e) {
    254                 throw new ConditionThrowable(new TypeError(arg, "STRUCTURE-OBJECT"));
     254                return signal(new TypeError(arg, "STRUCTURE-OBJECT"));
    255255            }
    256256        }
  • trunk/j/src/org/armedbear/lisp/make_array.java

    r3894 r5112  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: make_array.java,v 1.6 2003-09-19 14:44:10 piso Exp $
     5 * $Id: make_array.java,v 1.7 2003-12-13 00:02:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3333    {
    3434        if (args.length != 9)
    35             throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     35            return signal(new WrongNumberOfArgumentsException(this));
    3636        LispObject dimensions = args[0];
    3737        LispObject elementType = args[1];
     
    4444        LispObject displacedIndexOffset = args[8];
    4545        if (initialElementProvided != NIL && initialContents != NIL) {
    46             throw new ConditionThrowable(new LispError("MAKE-ARRAY: cannot specify both " +
    47                                                        ":INITIAL-ELEMENT AND :INITIAL-CONTENTS"));
     46            return signal(new LispError("MAKE-ARRAY: cannot specify both " +
     47                                        ":INITIAL-ELEMENT AND :INITIAL-CONTENTS"));
    4848        }
    4949        final int rank = dimensions.listp() ? dimensions.length() : 1;
     
    6565                offset = 0;
    6666            if (initialElementProvided != NIL)
    67                 throw new ConditionThrowable(new LispError(":INITIAL-ELEMENT must not be specified with :DISPLACED-TO"));
     67                return signal(new LispError(":INITIAL-ELEMENT must not be specified with :DISPLACED-TO"));
    6868            if (initialContents != NIL)
    69                 throw new ConditionThrowable(new LispError(":INITIAL-CONTENTS must not be specified with :DISPLACED-TO"));
     69                return signal(new LispError(":INITIAL-CONTENTS must not be specified with :DISPLACED-TO"));
    7070            return new DisplacedArray(dimv, array, offset);
    7171        }
     
    8585                } else
    8686                    sb.append(" is negative");
    87                 throw new ConditionThrowable(new LispError(sb.toString()));
     87                return signal(new LispError(sb.toString()));
    8888            }
    8989            AbstractVector v;
     
    110110                        v.set(i, initialContents.elt(i));
    111111                } else
    112                     throw new ConditionThrowable(new TypeError(initialContents, "sequence"));
     112                    return signal(new TypeError(initialContents, "sequence"));
    113113            }
    114114            if (fillPointer != NIL)
Note: See TracChangeset for help on using the changeset viewer.