Changeset 11158


Ignore:
Timestamp:
02/23/07 21:17:36 (15 years ago)
Author:
piso
Message:

signal => error

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

Legend:

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

    r10854 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: AbstractArray.java,v 1.48 2006-01-06 19:22:12 piso Exp $
     5 * $Id: AbstractArray.java,v 1.49 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    109109                subs[i] = ((Fixnum)subscript).value;
    110110            else
    111                 signalTypeError(subscript, Symbol.FIXNUM);
     111                type_error(subscript, Symbol.FIXNUM);
    112112        }
    113113        return getRowMajorIndex(subs);
     
    124124            sb.append(rank);
    125125            sb.append('.');
    126             signal(new ProgramError(sb.toString()));
     126            error(new ProgramError(sb.toString()));
    127127        }
    128128        int sum = 0;
     
    139139                sb.append(writeToString());
    140140                sb.append('.');
    141                 signal(new ProgramError(sb.toString()));
     141                error(new ProgramError(sb.toString()));
    142142            }
    143143            sum += n * lastSize;
     
    171171                        for (int j = i + 1; j < dimv.length; j++) {
    172172                            if (dimv[j] != 0) {
    173                                 signal(new PrintNotReadable(list2(Keyword.OBJECT,
     173                                error(new PrintNotReadable(list2(Keyword.OBJECT,
    174174                                                                  this)));
    175175                                return null; // Not reached.
  • trunk/j/src/org/armedbear/lisp/AbstractBitVector.java

    r10780 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: AbstractBitVector.java,v 1.14 2005-12-28 17:21:42 piso Exp $
     5 * $Id: AbstractBitVector.java,v 1.15 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    120120            // Fall through...
    121121        }
    122         signal(new TypeError(obj, Symbol.BIT));
     122        error(new TypeError(obj, Symbol.BIT));
    123123    }
    124124
     
    137137        }
    138138        catch (ArrayIndexOutOfBoundsException e) {
    139             return signal(new TypeError("Array index out of bounds: " + i + "."));
     139            return error(new TypeError("Array index out of bounds: " + i + "."));
    140140        }
    141141    }
     
    187187        }
    188188        catch (ClassCastException e) {
    189             return signal(new TypeError(index, Symbol.FIXNUM));
     189            return error(new TypeError(index, Symbol.FIXNUM));
    190190        }
    191191    }
  • trunk/j/src/org/armedbear/lisp/AbstractVector.java

    r10856 r11158  
    7575    if (n != 0)
    7676      {
    77         signal(new TypeError("bad dimension for vector"));
     77        error(new TypeError("bad dimension for vector"));
    7878        // Not reached.
    7979        return 0;
     
    146146        sb.append(").");
    147147      }
    148     signal(new TypeError(sb.toString(),
     148    error(new TypeError(sb.toString(),
    149149                         new Fixnum(index),
    150150                         list3(Symbol.INTEGER,
  • trunk/j/src/org/armedbear/lisp/ArithmeticError.java

    r10304 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: ArithmeticError.java,v 1.15 2005-11-01 01:40:14 piso Exp $
     5 * $Id: ArithmeticError.java,v 1.16 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    115115            }
    116116            catch (ClassCastException e) {
    117                 return signal(new TypeError(arg, Symbol.ARITHMETIC_ERROR));
     117                return error(new TypeError(arg, Symbol.ARITHMETIC_ERROR));
    118118            }
    119119        }
     
    129129            }
    130130            catch (ClassCastException e) {
    131                 return signal(new TypeError(arg, Symbol.ARITHMETIC_ERROR));
     131                return error(new TypeError(arg, Symbol.ARITHMETIC_ERROR));
    132132            }
    133133        }
  • trunk/j/src/org/armedbear/lisp/Autoload.java

    r11048 r11158  
    33 *
    44 * Copyright (C) 2003-2006 Peter Graves
    5  * $Id: Autoload.java,v 1.258 2006-04-08 00:20:11 piso Exp $
     5 * $Id: Autoload.java,v 1.259 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    258258                return T;
    259259            }
    260             return signal(new TypeError(first));
     260            return error(new TypeError(first));
    261261        }
    262262        public LispObject execute(LispObject first, LispObject second)
     
    276276                return T;
    277277            }
    278             return signal(new TypeError(first));
     278            return error(new TypeError(first));
    279279        }
    280280    };
  • trunk/j/src/org/armedbear/lisp/AutoloadMacro.java

    r7230 r11158  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: AutoloadMacro.java,v 1.13 2004-07-09 17:39:59 piso Exp $
     5 * $Id: AutoloadMacro.java,v 1.14 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7777                return T;
    7878            }
    79             return signal(new TypeError(first));
     79            return error(new TypeError(first));
    8080        }
    8181        public LispObject execute(LispObject first, LispObject second)
     
    9595                return T;
    9696            }
    97             return signal(new TypeError(first));
     97            return error(new TypeError(first));
    9898        }
    9999    };
  • trunk/j/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r9607 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: BasicVector_UnsignedByte16.java,v 1.1 2005-07-09 03:53:54 piso Exp $
     5 * $Id: BasicVector_UnsignedByte16.java,v 1.2 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    137137        }
    138138        catch (ClassCastException e) {
    139             return signal(new TypeError(index, Symbol.FIXNUM));
     139            return error(new TypeError(index, Symbol.FIXNUM));
    140140        }
    141141        catch (ArrayIndexOutOfBoundsException e) {
     
    164164        }
    165165        catch (ClassCastException e) {
    166             signal(new TypeError(obj, UNSIGNED_BYTE_16));
     166            error(new TypeError(obj, UNSIGNED_BYTE_16));
    167167        }
    168168    }
     
    178178        }
    179179        catch (ArrayIndexOutOfBoundsException e) {
    180             return signal(new TypeError("Array index out of bounds: " + i + "."));
     180            return error(new TypeError("Array index out of bounds: " + i + "."));
    181181        }
    182182    }
     
    200200        if (n == capacity)
    201201            return;
    202         signal(new LispError());
     202        error(new LispError());
    203203    }
    204204
     
    243243                    newElements[i] = initialContents.elt(i);
    244244            } else
    245                 signal(new TypeError(initialContents, Symbol.SEQUENCE));
     245                error(new TypeError(initialContents, Symbol.SEQUENCE));
    246246            return new BasicVector_UnsignedByte16(newElements);
    247247        }
  • trunk/j/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r10918 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: BasicVector_UnsignedByte32.java,v 1.5 2006-01-10 22:17:20 piso Exp $
     5 * $Id: BasicVector_UnsignedByte32.java,v 1.6 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    155155    catch (ClassCastException e)
    156156      {
    157         return signalTypeError(index, Symbol.FIXNUM);
     157        return type_error(index, Symbol.FIXNUM);
    158158      }
    159159    catch (ArrayIndexOutOfBoundsException e)
     
    189189      {
    190190        // FIXME
    191         return signal(new TypeError("Array index out of bounds: " + i + "."));
     191        return error(new TypeError("Array index out of bounds: " + i + "."));
    192192      }
    193193  }
     
    211211    if (n == capacity)
    212212      return;
    213     signal(new LispError());
     213    error(new LispError());
    214214  }
    215215
     
    261261          }
    262262        else
    263           signalTypeError(initialContents, Symbol.SEQUENCE);
     263          type_error(initialContents, Symbol.SEQUENCE);
    264264        return new BasicVector_UnsignedByte32(newElements);
    265265      }
  • trunk/j/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r10915 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: BasicVector_UnsignedByte8.java,v 1.7 2006-01-10 18:50:44 piso Exp $
     5 * $Id: BasicVector_UnsignedByte8.java,v 1.8 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    141141    catch (ClassCastException e)
    142142      {
    143         return signal(new TypeError(index, Symbol.FIXNUM));
     143        return error(new TypeError(index, Symbol.FIXNUM));
    144144      }
    145145    catch (ArrayIndexOutOfBoundsException e)
     
    186186    catch (ArrayIndexOutOfBoundsException e)
    187187      {
    188         return signal(new TypeError("Array index out of bounds: " + i + "."));
     188        return error(new TypeError("Array index out of bounds: " + i + "."));
    189189      }
    190190  }
     
    209209    if (n == capacity)
    210210      return;
    211     signal(new LispError());
     211    error(new LispError());
    212212  }
    213213
     
    259259          }
    260260        else
    261           signalTypeError(initialContents, Symbol.SEQUENCE);
     261          type_error(initialContents, Symbol.SEQUENCE);
    262262        return new BasicVector_UnsignedByte8(newElements);
    263263      }
  • trunk/j/src/org/armedbear/lisp/Bignum.java

    r11147 r11158  
    33 *
    44 * Copyright (C) 2003-2007 Peter Graves
    5  * $Id: Bignum.java,v 1.82 2007-02-21 18:39:38 piso Exp $
     5 * $Id: Bignum.java,v 1.83 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    228228    float f = value.floatValue();
    229229    if (Float.isInfinite(f))
    230       signal(new TypeError("The value " + writeToString() +
     230      error(new TypeError("The value " + writeToString() +
    231231                           " is too large to be converted to a single float."));
    232232    return f;
     
    237237    double d = value.doubleValue();
    238238    if (Double.isInfinite(d))
    239       signal(new TypeError("The value " + writeToString() +
     239      error(new TypeError("The value " + writeToString() +
    240240                           " is too large to be converted to a double float."));
    241241    return d;
     
    250250    catch (ClassCastException e)
    251251      {
    252         signalTypeError(obj, Symbol.BIGNUM);
     252        type_error(obj, Symbol.BIGNUM);
    253253        // Not reached.
    254254        return null;
     
    293293        return Complex.getInstance(add(c.getRealPart()), c.getImaginaryPart());
    294294      }
    295     return signalTypeError(obj, Symbol.NUMBER);
     295    return type_error(obj, Symbol.NUMBER);
    296296  }
    297297
     
    319319                                   Fixnum.ZERO.subtract(c.getImaginaryPart()));
    320320      }
    321     return signalTypeError(obj, Symbol.NUMBER);
     321    return type_error(obj, Symbol.NUMBER);
    322322  }
    323323
     
    359359                                   multiplyBy(c.getImaginaryPart()));
    360360      }
    361     return signalTypeError(obj, Symbol.NUMBER);
     361    return type_error(obj, Symbol.NUMBER);
    362362  }
    363363
     
    387387                                   Fixnum.ZERO.subtract(multiplyBy(imagPart).divideBy(denominator)));
    388388      }
    389     return signalTypeError(obj, Symbol.NUMBER);
     389    return type_error(obj, Symbol.NUMBER);
    390390  }
    391391
     
    400400    if (obj.numberp())
    401401      return false;
    402     signalTypeError(obj, Symbol.NUMBER);
     402    type_error(obj, Symbol.NUMBER);
    403403    // Not reached.
    404404    return false;
     
    415415    if (obj.numberp())
    416416      return true;
    417     signalTypeError(obj, Symbol.NUMBER);
     417    type_error(obj, Symbol.NUMBER);
    418418    // Not reached.
    419419    return false;
     
    435435    if (obj instanceof DoubleFloat)
    436436      return isLessThan(((DoubleFloat)obj).rational());
    437     signalTypeError(obj, Symbol.REAL);
     437    type_error(obj, Symbol.REAL);
    438438    // Not reached.
    439439    return false;
     
    455455    if (obj instanceof DoubleFloat)
    456456      return isGreaterThan(((DoubleFloat)obj).rational());
    457     signalTypeError(obj, Symbol.REAL);
     457    type_error(obj, Symbol.REAL);
    458458    // Not reached.
    459459    return false;
     
    475475    if (obj instanceof DoubleFloat)
    476476      return isLessThanOrEqualTo(((DoubleFloat)obj).rational());
    477     signalTypeError(obj, Symbol.REAL);
     477    type_error(obj, Symbol.REAL);
    478478    // Not reached.
    479479    return false;
     
    495495    if (obj instanceof DoubleFloat)
    496496      return isGreaterThanOrEqualTo(((DoubleFloat)obj).rational());
    497     signalTypeError(obj, Symbol.REAL);
     497    type_error(obj, Symbol.REAL);
    498498    // Not reached.
    499499    return false;
     
    549549          }
    550550        else
    551           return signalTypeError(obj, Symbol.REAL);
     551          return type_error(obj, Symbol.REAL);
    552552      }
    553553    catch (ArithmeticException e)
    554554      {
    555555        if (obj.zerop())
    556           return signal(new DivisionByZero());
     556          return error(new DivisionByZero());
    557557        else
    558           return signal(new ArithmeticError(e.getMessage()));
     558          return error(new ArithmeticError(e.getMessage()));
    559559      }
    560560    return thread.setValues(value1, value2);
     
    579579        BigInteger count = ((Bignum)obj).value;
    580580        if (count.signum() > 0)
    581           return signal(new LispError("Can't represent result of left shift."));
     581          return error(new LispError("Can't represent result of left shift."));
    582582        if (count.signum() < 0)
    583583          return n.signum() >= 0 ? Fixnum.ZERO : Fixnum.MINUS_ONE;
    584584        Debug.bug(); // Shouldn't happen.
    585585      }
    586     return signalTypeError(obj, Symbol.INTEGER);
     586    return type_error(obj, Symbol.INTEGER);
    587587  }
    588588
     
    616616      }
    617617    else
    618       return signalTypeError(obj, Symbol.INTEGER);
     618      return type_error(obj, Symbol.INTEGER);
    619619  }
    620620
     
    637637      }
    638638    else
    639       return signalTypeError(obj, Symbol.INTEGER);
     639      return type_error(obj, Symbol.INTEGER);
    640640  }
    641641
     
    653653      n = ((Bignum)obj).value;
    654654    else
    655       return signalTypeError(obj, Symbol.INTEGER);
     655      return type_error(obj, Symbol.INTEGER);
    656656    return number(value.xor(n));
    657657  }
  • trunk/j/src/org/armedbear/lisp/BroadcastStream.java

    r9082 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: BroadcastStream.java,v 1.12 2005-05-06 23:39:33 piso Exp $
     5 * $Id: BroadcastStream.java,v 1.13 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    181181    private void notSupported() throws ConditionThrowable
    182182    {
    183         signal(new TypeError("Operation is not supported for streams of type BROADCAST-STREAM."));
     183        error(new TypeError("Operation is not supported for streams of type BROADCAST-STREAM."));
    184184    }
    185185
     
    206206                        continue;
    207207                    } else
    208                         return signal(new TypeError(args[i], list2(Symbol.SATISFIES,
     208                        return error(new TypeError(args[i], list2(Symbol.SATISFIES,
    209209                                                                   Symbol.OUTPUT_STREAM_P)));
    210210                } else
    211                     return signal(new TypeError(args[i], Symbol.STREAM));
     211                    return error(new TypeError(args[i], Symbol.STREAM));
    212212            }
    213213            // All is well.
     
    231231            }
    232232            catch (ClassCastException e) {
    233                 return signal(new TypeError(arg, Symbol.BROADCAST_STREAM));
     233                return error(new TypeError(arg, Symbol.BROADCAST_STREAM));
    234234            }
    235235        }
  • trunk/j/src/org/armedbear/lisp/CaseFrobStream.java

    r8084 r11158  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: CaseFrobStream.java,v 1.6 2004-11-03 15:27:21 piso Exp $
     5 * $Id: CaseFrobStream.java,v 1.7 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    177177    private void notSupported() throws ConditionThrowable
    178178    {
    179         signal(new TypeError("Operation is not supported for streams of type CASE-FROB-STREAM."));
     179        error(new TypeError("Operation is not supported for streams of type CASE-FROB-STREAM."));
    180180    }
    181181
     
    196196            if (second == Keyword.CAPITALIZE_FIRST)
    197197                return new CapitalizeFirstStream(target);
    198             return signal(new TypeError(
     198            return error(new TypeError(
    199199                "Kind must be :UPCASE, :DOWNCASE, :CAPITALIZE or :CAPITALIZE-FIRST."));
    200200        }
  • trunk/j/src/org/armedbear/lisp/CharacterFunctions.java

    r11059 r11158  
    33 *
    44 * Copyright (C) 2003-2006 Peter Graves
    5  * $Id: CharacterFunctions.java,v 1.16 2006-05-17 11:55:03 piso Exp $
     5 * $Id: CharacterFunctions.java,v 1.17 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3030        public LispObject execute() throws ConditionThrowable
    3131        {
    32             return signal(new WrongNumberOfArgumentsException(this));
    33         }
    34         public LispObject execute(LispObject arg) throws ConditionThrowable
    35         {
    36             if (arg instanceof LispCharacter)
    37                 return T;
    38             return signalTypeError(arg, Symbol.CHARACTER);
     32            return error(new WrongNumberOfArgumentsException(this));
     33        }
     34        public LispObject execute(LispObject arg) throws ConditionThrowable
     35        {
     36            if (arg instanceof LispCharacter)
     37                return T;
     38            return type_error(arg, Symbol.CHARACTER);
    3939        }
    4040        public LispObject execute(LispObject first, LispObject second)
     
    5050                else
    5151                    datum = first;
    52                 return signalTypeError(datum, Symbol.CHARACTER);
     52                return type_error(datum, Symbol.CHARACTER);
    5353            }
    5454        }
     
    7171        public LispObject execute() throws ConditionThrowable
    7272        {
    73             return signal(new WrongNumberOfArgumentsException(this));
    74         }
    75         public LispObject execute(LispObject arg) throws ConditionThrowable
    76         {
    77             if (arg instanceof LispCharacter)
    78                 return T;
    79             return signalTypeError(arg, Symbol.CHARACTER);
     73            return error(new WrongNumberOfArgumentsException(this));
     74        }
     75        public LispObject execute(LispObject arg) throws ConditionThrowable
     76        {
     77            if (arg instanceof LispCharacter)
     78                return T;
     79            return type_error(arg, Symbol.CHARACTER);
    8080        }
    8181        public LispObject execute(LispObject first, LispObject second)
     
    8787            }
    8888            catch (ClassCastException e) {
    89                 return signalTypeError(first, Symbol.CHARACTER);
     89                return type_error(first, Symbol.CHARACTER);
    9090            }
    9191            try {
     
    9393            }
    9494            catch (ClassCastException e) {
    95                 return signalTypeError(second, Symbol.CHARACTER);
     95                return type_error(second, Symbol.CHARACTER);
    9696            }
    9797            if (c1 == c2)
     
    127127        public LispObject execute() throws ConditionThrowable
    128128        {
    129             return signal(new WrongNumberOfArgumentsException(this));
    130         }
    131         public LispObject execute(LispObject arg) throws ConditionThrowable
    132         {
    133             if (arg instanceof LispCharacter)
    134                 return T;
    135             return signalTypeError(arg, Symbol.CHARACTER);
     129            return error(new WrongNumberOfArgumentsException(this));
     130        }
     131        public LispObject execute(LispObject arg) throws ConditionThrowable
     132        {
     133            if (arg instanceof LispCharacter)
     134                return T;
     135            return type_error(arg, Symbol.CHARACTER);
    136136        }
    137137        public LispObject execute(LispObject first, LispObject second)
     
    162162        public LispObject execute() throws ConditionThrowable
    163163        {
    164             return signal(new WrongNumberOfArgumentsException(this));
    165         }
    166         public LispObject execute(LispObject arg) throws ConditionThrowable
    167         {
    168             if (arg instanceof LispCharacter)
    169                 return T;
    170             return signalTypeError(arg, Symbol.CHARACTER);
     164            return error(new WrongNumberOfArgumentsException(this));
     165        }
     166        public LispObject execute(LispObject arg) throws ConditionThrowable
     167        {
     168            if (arg instanceof LispCharacter)
     169                return T;
     170            return type_error(arg, Symbol.CHARACTER);
    171171        }
    172172        public LispObject execute(LispObject first, LispObject second)
     
    197197        public LispObject execute() throws ConditionThrowable
    198198        {
    199             return signal(new WrongNumberOfArgumentsException(this));
    200         }
    201         public LispObject execute(LispObject arg) throws ConditionThrowable
    202         {
    203             if (arg instanceof LispCharacter)
    204                 return T;
    205             return signalTypeError(arg, Symbol.CHARACTER);
     199            return error(new WrongNumberOfArgumentsException(this));
     200        }
     201        public LispObject execute(LispObject arg) throws ConditionThrowable
     202        {
     203            if (arg instanceof LispCharacter)
     204                return T;
     205            return type_error(arg, Symbol.CHARACTER);
    206206        }
    207207        public LispObject execute(LispObject first, LispObject second)
     
    217217                else
    218218                    datum = first;
    219                 return signalTypeError(datum, Symbol.CHARACTER);
     219                return type_error(datum, Symbol.CHARACTER);
    220220            }
    221221        }
     
    229229                }
    230230                catch (ClassCastException e) {
    231                     return signalTypeError(args[i], Symbol.CHARACTER);
     231                    return type_error(args[i], Symbol.CHARACTER);
    232232                }
    233233            }
     
    246246        public LispObject execute() throws ConditionThrowable
    247247        {
    248             return signal(new WrongNumberOfArgumentsException(this));
    249         }
    250         public LispObject execute(LispObject arg) throws ConditionThrowable
    251         {
    252             if (arg instanceof LispCharacter)
    253                 return T;
    254             return signalTypeError(arg, Symbol.CHARACTER);
     248            return error(new WrongNumberOfArgumentsException(this));
     249        }
     250        public LispObject execute(LispObject arg) throws ConditionThrowable
     251        {
     252            if (arg instanceof LispCharacter)
     253                return T;
     254            return type_error(arg, Symbol.CHARACTER);
    255255        }
    256256        public LispObject execute(LispObject first, LispObject second)
     
    266266                else
    267267                    datum = first;
    268                 return signalTypeError(datum, Symbol.CHARACTER);
     268                return type_error(datum, Symbol.CHARACTER);
    269269            }
    270270        }
     
    288288                else
    289289                    datum = third;
    290                 return signalTypeError(datum, Symbol.CHARACTER);
     290                return type_error(datum, Symbol.CHARACTER);
    291291            }
    292292        }
     
    300300                }
    301301                catch (ClassCastException e) {
    302                     return signalTypeError(args[i], Symbol.CHARACTER);
     302                    return type_error(args[i], Symbol.CHARACTER);
    303303                }
    304304            }
     
    317317        public LispObject execute() throws ConditionThrowable
    318318        {
    319             return signal(new WrongNumberOfArgumentsException(this));
    320         }
    321         public LispObject execute(LispObject arg) throws ConditionThrowable
    322         {
    323             if (arg instanceof LispCharacter)
    324                 return T;
    325             return signalTypeError(arg, Symbol.CHARACTER);
     319            return error(new WrongNumberOfArgumentsException(this));
     320        }
     321        public LispObject execute(LispObject arg) throws ConditionThrowable
     322        {
     323            if (arg instanceof LispCharacter)
     324                return T;
     325            return type_error(arg, Symbol.CHARACTER);
    326326        }
    327327        public LispObject execute(LispObject first, LispObject second)
     
    352352        public LispObject execute() throws ConditionThrowable
    353353        {
    354             return signal(new WrongNumberOfArgumentsException(this));
    355         }
    356         public LispObject execute(LispObject arg) throws ConditionThrowable
    357         {
    358             if (arg instanceof LispCharacter)
    359                 return T;
    360             return signalTypeError(arg, Symbol.CHARACTER);
     354            return error(new WrongNumberOfArgumentsException(this));
     355        }
     356        public LispObject execute(LispObject arg) throws ConditionThrowable
     357        {
     358            if (arg instanceof LispCharacter)
     359                return T;
     360            return type_error(arg, Symbol.CHARACTER);
    361361        }
    362362        public LispObject execute(LispObject first, LispObject second)
  • trunk/j/src/org/armedbear/lisp/Closure.java

    r11043 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: Closure.java,v 1.110 2006-03-27 01:15:06 piso Exp $
     5 * $Id: Closure.java,v 1.111 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7474    setLambdaList(lambdaList);
    7575    if (!(lambdaList == NIL || lambdaList instanceof Cons))
    76       signal(new LispError("The lambda list " + lambdaList.writeToString() +
     76      error(new LispError("The lambda list " + lambdaList.writeToString() +
    7777                           " is invalid."));
    7878    boolean _andKey = false;
     
    111111                    if (remaining == NIL)
    112112                      {
    113                         signal(new LispError(
     113                        error(new LispError(
    114114                          "&REST/&BODY must be followed by a variable."));
    115115                      }
     
    121121                    catch (ClassCastException e)
    122122                      {
    123                         signal(new LispError(
     123                        error(new LispError(
    124124                          "&REST/&BODY must be followed by a variable."));
    125125                      }
     
    375375    throws ConditionThrowable
    376376  {
    377     signal(new LispError(obj.writeToString() +
     377    error(new LispError(obj.writeToString() +
    378378                         " may not be used as a variable in a lambda list."));
    379379  }
     
    959959        // Fixed arity.
    960960        if (argsLength != arity)
    961           signal(new WrongNumberOfArgumentsException(this));
     961          error(new WrongNumberOfArgumentsException(this));
    962962        return args;
    963963      }
    964964    // Not fixed arity.
    965965    if (argsLength < minArgs)
    966       signal(new WrongNumberOfArgumentsException(this));
     966      error(new WrongNumberOfArgumentsException(this));
    967967    if (thread == null)
    968968      thread = LispThread.currentThread();
     
    10711071          {
    10721072            if ((argsLeft % 2) != 0)
    1073               signal(new ProgramError("Odd number of keyword arguments."));
     1073              error(new ProgramError("Odd number of keyword arguments."));
    10741074            LispObject allowOtherKeysValue = null;
    10751075            for (int k = 0; k < keywordParameters.length; k++)
     
    11611161                        if (!allowOtherKeys &&
    11621162                            (allowOtherKeysValue == null || allowOtherKeysValue == NIL))
    1163                           signal(new ProgramError("Unrecognized keyword argument " +
     1163                          error(new ProgramError("Unrecognized keyword argument " +
    11641164                                                  unrecognizedKeyword.writeToString()));
    11651165                      }
     
    12081208          {
    12091209            if (restVar == null)
    1210               signal(new WrongNumberOfArgumentsException(this));
     1210              error(new WrongNumberOfArgumentsException(this));
    12111211          }
    12121212      }
     
    12241224        // Fixed arity.
    12251225        if (argsLength != arity)
    1226           signal(new WrongNumberOfArgumentsException(this));
     1226          error(new WrongNumberOfArgumentsException(this));
    12271227        return args;
    12281228      }
    12291229    // Not fixed arity.
    12301230    if (argsLength < minArgs)
    1231       signal(new WrongNumberOfArgumentsException(this));
     1231      error(new WrongNumberOfArgumentsException(this));
    12321232    final LispObject[] array = new LispObject[variables.length];
    12331233    int index = 0;
     
    12891289          {
    12901290            if (restVar == null)
    1291               signal(new WrongNumberOfArgumentsException(this));
     1291              error(new WrongNumberOfArgumentsException(this));
    12921292          }
    12931293      }
  • trunk/j/src/org/armedbear/lisp/ClosureTemplateFunction.java

    r10704 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: ClosureTemplateFunction.java,v 1.11 2005-12-20 18:56:04 piso Exp $
     5 * $Id: ClosureTemplateFunction.java,v 1.12 2007-02-23 21:17:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9696  private final LispObject notImplemented() throws ConditionThrowable
    9797  {
    98     return signal(new WrongNumberOfArgumentsException(this));
     98    return error(new WrongNumberOfArgumentsException(this));
    9999  }
    100100
  • trunk/j/src/org/armedbear/lisp/CompiledFunction.java

    r10350 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: CompiledFunction.java,v 1.37 2005-11-04 13:09:37 piso Exp $
     5 * $Id: CompiledFunction.java,v 1.38 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    157157    public LispObject execute(LispObject[] args) throws ConditionThrowable
    158158    {
    159         return signal(new LispError("Not implemented."));
     159        return error(new LispError("Not implemented."));
    160160    }
    161161
     
    173173            if (namestring != null)
    174174                return loadCompiledFunction(namestring);
    175             return signal(new LispError("Unable to load " + arg.writeToString()));
     175            return error(new LispError("Unable to load " + arg.writeToString()));
    176176        }
    177177    };
     
    185185            if (arg instanceof Closure)
    186186                return ((Closure)arg).getVariableList();
    187             return signalTypeError(arg, Symbol.COMPILED_FUNCTION);
     187            return type_error(arg, Symbol.COMPILED_FUNCTION);
    188188        }
    189189    };
  • trunk/j/src/org/armedbear/lisp/Complex.java

    r11032 r11158  
    33 *
    44 * Copyright (C) 2003-2006 Peter Graves
    5  * $Id: Complex.java,v 1.38 2006-03-20 01:27:40 piso Exp $
     5 * $Id: Complex.java,v 1.39 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040  {
    4141    if (!realpart.realp())
    42       return signalTypeError(realpart, Symbol.REAL);
     42      return type_error(realpart, Symbol.REAL);
    4343    if (!imagpart.realp())
    44       return signalTypeError(imagpart, Symbol.REAL);
     44      return type_error(imagpart, Symbol.REAL);
    4545    if (realpart instanceof DoubleFloat)
    4646      imagpart = DoubleFloat.coerceToFloat(imagpart);
     
    264264        return false;
    265265      }
    266     signalTypeError(obj, Symbol.NUMBER);
     266    type_error(obj, Symbol.NUMBER);
    267267    // Not reached.
    268268    return false;
  • trunk/j/src/org/armedbear/lisp/ComplexArray.java

    r8835 r11158  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: ComplexArray.java,v 1.12 2005-03-25 03:19:20 piso Exp $
     5 * $Id: ComplexArray.java,v 1.13 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8181            }
    8282            catch (ArrayIndexOutOfBoundsException e) {
    83                 signal(new LispError("Bad initial contents for array."));
     83                error(new LispError("Bad initial contents for array."));
    8484                return -1;
    8585            }
     
    8888            int dim = dims[0];
    8989            if (dim != contents.length()) {
    90                 signal(new LispError("Bad initial contents for array."));
     90                error(new LispError("Bad initial contents for array."));
    9191                return -1;
    9292            }
     
    143143        }
    144144        catch (ArrayIndexOutOfBoundsException e) {
    145             signal(new TypeError("Bad array dimension " + n + "."));
     145            error(new TypeError("Bad array dimension " + n + "."));
    146146            return -1;
    147147        }
     
    178178            }
    179179            catch (ArrayIndexOutOfBoundsException e) {
    180                 return signal(new TypeError("Bad row major index " + index + "."));
     180                return error(new TypeError("Bad row major index " + index + "."));
    181181            }
    182182        } else
     
    191191            }
    192192            catch (ArrayIndexOutOfBoundsException e) {
    193                 signal(new TypeError("Bad row major index " + index + "."));
     193                error(new TypeError("Bad row major index " + index + "."));
    194194            }
    195195        } else
  • trunk/j/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r8835 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: ComplexArray_UnsignedByte32.java,v 1.2 2005-03-25 03:19:20 piso Exp $
     5 * $Id: ComplexArray_UnsignedByte32.java,v 1.3 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7777            }
    7878            catch (ArrayIndexOutOfBoundsException e) {
    79                 signal(new LispError("Bad initial contents for array."));
     79                error(new LispError("Bad initial contents for array."));
    8080                return -1;
    8181            }
     
    8484            int dim = dims[0];
    8585            if (dim != contents.length()) {
    86                 signal(new LispError("Bad initial contents for array."));
     86                error(new LispError("Bad initial contents for array."));
    8787                return -1;
    8888            }
     
    139139        }
    140140        catch (ArrayIndexOutOfBoundsException e) {
    141             signal(new TypeError("Bad array dimension " + n + "."));
     141            error(new TypeError("Bad array dimension " + n + "."));
    142142            return -1;
    143143        }
     
    174174            }
    175175            catch (ArrayIndexOutOfBoundsException e) {
    176                 return signal(new TypeError("Bad row major index " + index + "."));
     176                return error(new TypeError("Bad row major index " + index + "."));
    177177            }
    178178        } else
     
    187187            }
    188188            catch (ArrayIndexOutOfBoundsException e) {
    189                 signal(new TypeError("Bad row major index " + index + "."));
     189                error(new TypeError("Bad row major index " + index + "."));
    190190            }
    191191        } else
  • trunk/j/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r10202 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: ComplexArray_UnsignedByte8.java,v 1.4 2005-10-23 16:39:49 piso Exp $
     5 * $Id: ComplexArray_UnsignedByte8.java,v 1.5 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7373            }
    7474            catch (ArrayIndexOutOfBoundsException e) {
    75                 signal(new LispError("Bad initial contents for array."));
     75                error(new LispError("Bad initial contents for array."));
    7676                return -1;
    7777            }
     
    8080            int dim = dims[0];
    8181            if (dim != contents.length()) {
    82                 signal(new LispError("Bad initial contents for array."));
     82                error(new LispError("Bad initial contents for array."));
    8383                return -1;
    8484            }
     
    135135        }
    136136        catch (ArrayIndexOutOfBoundsException e) {
    137             signal(new TypeError("Bad array dimension " + n + "."));
     137            error(new TypeError("Bad array dimension " + n + "."));
    138138            return -1;
    139139        }
     
    170170            }
    171171            catch (ArrayIndexOutOfBoundsException e) {
    172                 return signal(new TypeError("Bad row major index " + index + "."));
     172                return error(new TypeError("Bad row major index " + index + "."));
    173173            }
    174174        } else
     
    183183            }
    184184            catch (ArrayIndexOutOfBoundsException e) {
    185                 signal(new TypeError("Bad row major index " + index + "."));
     185                error(new TypeError("Bad row major index " + index + "."));
    186186            }
    187187        } else
     
    204204    {
    205205        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
    206             signal(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     206            error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
    207207            // Not reached.
    208208            return null;
  • trunk/j/src/org/armedbear/lisp/ComplexBitVector.java

    r10861 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: ComplexBitVector.java,v 1.15 2006-01-07 00:55:07 piso Exp $
     5 * $Id: ComplexBitVector.java,v 1.16 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8080                sb.append(capacity());
    8181                sb.append(").");
    82                 signal(new LispError(sb.toString()));
     82                error(new LispError(sb.toString()));
    8383            } else if (n < 0) {
    8484                StringBuffer sb = new StringBuffer("The new fill pointer (");
    8585                sb.append(n);
    8686                sb.append(") is negative.");
    87                 signal(new LispError(sb.toString()));
     87                error(new LispError(sb.toString()));
    8888            } else
    8989                fillPointer = n;
     
    163163            // Fall through...
    164164        }
    165         signalTypeError(newValue, Symbol.BIT);
     165        type_error(newValue, Symbol.BIT);
    166166    }
    167167
     
    202202                return;
    203203        }
    204         signal(new LispError());
     204        error(new LispError());
    205205    }
    206206
     
    328328                        aset(i, initialContents.elt(i));
    329329                } else
    330                     signalTypeError(initialContents, Symbol.SEQUENCE);
     330                    type_error(initialContents, Symbol.SEQUENCE);
    331331            } else {
    332332                long[] newBits = new long[size];
  • trunk/j/src/org/armedbear/lisp/ComplexString.java

    r10861 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: ComplexString.java,v 1.35 2006-01-07 00:55:54 piso Exp $
     5 * $Id: ComplexString.java,v 1.36 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8989            sb.append(capacity());
    9090            sb.append(").");
    91             signal(new LispError(sb.toString()));
     91            error(new LispError(sb.toString()));
    9292          }
    9393        else if (n < 0)
     
    9696            sb.append(n);
    9797            sb.append(") is negative.");
    98             signal(new LispError(sb.toString()));
     98            error(new LispError(sb.toString()));
    9999          }
    100100        else
     
    373373    catch (ClassCastException e)
    374374      {
    375         signalTypeError(newValue, Symbol.CHARACTER);
     375        type_error(newValue, Symbol.CHARACTER);
    376376      }
    377377  }
     
    395395        catch (ClassCastException e)
    396396          {
    397             signalTypeError(element, Symbol.CHARACTER);
     397            type_error(element, Symbol.CHARACTER);
    398398          }
    399399      }
     
    430430        catch (ClassCastException e)
    431431          {
    432             signalTypeError(element, Symbol.CHARACTER);
     432            type_error(element, Symbol.CHARACTER);
    433433          }
    434434      }
     
    558558          }
    559559        else
    560           signalTypeError(initialContents, Symbol.SEQUENCE);
     560          type_error(initialContents, Symbol.SEQUENCE);
    561561        chars = newChars;
    562562      }
  • trunk/j/src/org/armedbear/lisp/ComplexVector.java

    r10861 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: ComplexVector.java,v 1.23 2006-01-07 00:56:27 piso Exp $
     5 * $Id: ComplexVector.java,v 1.24 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9090                sb.append(capacity());
    9191                sb.append(").");
    92                 signal(new LispError(sb.toString()));
     92                error(new LispError(sb.toString()));
    9393            } else if (n < 0) {
    9494                StringBuffer sb = new StringBuffer("The new fill pointer (");
    9595                sb.append(n);
    9696                sb.append(") is negative.");
    97                 signal(new LispError(sb.toString()));
     97                error(new LispError(sb.toString()));
    9898            } else
    9999                fillPointer = n;
     
    201201        }
    202202        catch (ArrayIndexOutOfBoundsException e) {
    203             return signal(new TypeError("Array index out of bounds: " + i + "."));
     203            return error(new TypeError("Array index out of bounds: " + i + "."));
    204204        }
    205205    }
     
    224224                return;
    225225        }
    226         signal(new LispError());
     226        error(new LispError());
    227227    }
    228228
     
    349349                    newElements[i] = initialContents.elt(i);
    350350            } else
    351                 signal(new TypeError(initialContents, Symbol.SEQUENCE));
     351                error(new TypeError(initialContents, Symbol.SEQUENCE));
    352352            elements = newElements;
    353353        } else {
  • trunk/j/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r10861 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: ComplexVector_UnsignedByte32.java,v 1.5 2006-01-07 00:57:49 piso Exp $
     5 * $Id: ComplexVector_UnsignedByte32.java,v 1.6 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9191                sb.append(capacity());
    9292                sb.append(").");
    93                 signal(new LispError(sb.toString()));
     93                error(new LispError(sb.toString()));
    9494            } else if (n < 0) {
    9595                StringBuffer sb = new StringBuffer("The new fill pointer (");
    9696                sb.append(n);
    9797                sb.append(") is negative.");
    98                 signal(new LispError(sb.toString()));
     98                error(new LispError(sb.toString()));
    9999            } else
    100100                fillPointer = n;
     
    202202        }
    203203        catch (ArrayIndexOutOfBoundsException e) {
    204             return signal(new TypeError("Array index out of bounds: " + i + "."));
     204            return error(new TypeError("Array index out of bounds: " + i + "."));
    205205        }
    206206    }
     
    225225                return;
    226226        }
    227         signal(new LispError());
     227        error(new LispError());
    228228    }
    229229
     
    351351                    newElements[i] = initialContents.elt(i);
    352352            } else
    353                 signal(new TypeError(initialContents, Symbol.SEQUENCE));
     353                error(new TypeError(initialContents, Symbol.SEQUENCE));
    354354            elements = newElements;
    355355        } else {
  • trunk/j/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r10861 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: ComplexVector_UnsignedByte8.java,v 1.7 2006-01-07 00:57:09 piso Exp $
     5 * $Id: ComplexVector_UnsignedByte8.java,v 1.8 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8989                sb.append(capacity());
    9090                sb.append(").");
    91                 signal(new LispError(sb.toString()));
     91                error(new LispError(sb.toString()));
    9292            } else if (n < 0) {
    9393                StringBuffer sb = new StringBuffer("The new fill pointer (");
    9494                sb.append(n);
    9595                sb.append(") is negative.");
    96                 signal(new LispError(sb.toString()));
     96                error(new LispError(sb.toString()));
    9797            } else
    9898                fillPointer = n;
     
    213213        }
    214214        catch (ArrayIndexOutOfBoundsException e) {
    215             return signal(new TypeError("Array index out of bounds: " + i + "."));
     215            return error(new TypeError("Array index out of bounds: " + i + "."));
    216216        }
    217217    }
     
    237237                return;
    238238        }
    239         signal(new LispError());
     239        error(new LispError());
    240240    }
    241241
     
    362362                    newElements[i] = coerceLispObjectToJavaByte(initialContents.elt(i));
    363363            } else
    364                 signal(new TypeError(initialContents, Symbol.SEQUENCE));
     364                error(new TypeError(initialContents, Symbol.SEQUENCE));
    365365            elements = newElements;
    366366        } else {
  • trunk/j/src/org/armedbear/lisp/ConcatenatedStream.java

    r10121 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: ConcatenatedStream.java,v 1.7 2005-10-16 11:27:42 piso Exp $
     5 * $Id: ConcatenatedStream.java,v 1.8 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8787        if (streams == NIL) {
    8888            if (eofError)
    89                 return signal(new EndOfFile(this));
     89                return error(new EndOfFile(this));
    9090            else
    9191                return eofValue;
     
    131131    {
    132132        if (unreadChar >= 0)
    133             signal(new StreamError(this, "UNREAD-CHAR was invoked twice consecutively without an intervening call to READ-CHAR."));
     133            error(new StreamError(this, "UNREAD-CHAR was invoked twice consecutively without an intervening call to READ-CHAR."));
    134134        unreadChar = n;
    135135    }
     
    206206    private void outputStreamError() throws ConditionThrowable
    207207    {
    208         signal(new StreamError(this,
     208        error(new StreamError(this,
    209209                               String.valueOf(this) + " is not an output stream."));
    210210    }
     
    226226                    }
    227227                }
    228                 signal(new TypeError(String.valueOf(args[i]) +
     228                error(new TypeError(String.valueOf(args[i]) +
    229229                                     " is not an input stream."));
    230230            }
     
    243243            }
    244244            catch (ClassCastException e) {
    245                 return signal(new TypeError(arg, Symbol.CONCATENATED_STREAM));
     245                return error(new TypeError(arg, Symbol.CONCATENATED_STREAM));
    246246            }
    247247        }
  • trunk/j/src/org/armedbear/lisp/Cons.java

    r10821 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Cons.java,v 1.72 2006-01-05 11:00:20 piso Exp $
     5 * $Id: Cons.java,v 1.73 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    156156  {
    157157    if (n < 0)
    158       return signalTypeError(new Fixnum(n),
     158      return type_error(new Fixnum(n),
    159159                             list2(Symbol.INTEGER, Fixnum.ZERO));
    160160    LispObject result = this;
     
    260260    catch (ClassCastException e)
    261261      {
    262         signalTypeError(obj, Symbol.LIST);
     262        type_error(obj, Symbol.LIST);
    263263      }
    264264    return length;
     
    268268  {
    269269    if (index < 0)
    270       signalTypeError(new Fixnum(index), Symbol.UNSIGNED_BYTE);
     270      type_error(new Fixnum(index), Symbol.UNSIGNED_BYTE);
    271271    int i = 0;
    272272    LispObject obj = this;
     
    295295            // FIXME (when machines have enough memory for it to matter)
    296296            if (arg.minusp())
    297               return signalTypeError(arg, Symbol.UNSIGNED_BYTE);
     297              return type_error(arg, Symbol.UNSIGNED_BYTE);
    298298            return NIL;
    299299          }
    300         return signalTypeError(arg, Symbol.UNSIGNED_BYTE);
     300        return type_error(arg, Symbol.UNSIGNED_BYTE);
    301301      }
    302302    if (index < 0)
    303       signalTypeError(arg, Symbol.UNSIGNED_BYTE);
     303      type_error(arg, Symbol.UNSIGNED_BYTE);
    304304    int i = 0;
    305305    LispObject obj = this;
     
    318318  {
    319319    if (index < 0)
    320       signalTypeError(new Fixnum(index), Symbol.UNSIGNED_BYTE);
     320      type_error(new Fixnum(index), Symbol.UNSIGNED_BYTE);
    321321    int i = 0;
    322322    Cons cons = this;
     
    334334              {
    335335                // Index too large.
    336                 signalTypeError(new Fixnum(index),
     336                type_error(new Fixnum(index),
    337337                                list3(Symbol.INTEGER, Fixnum.ZERO,
    338338                                      new Fixnum(length() - 1)));
     
    341341              {
    342342                // Dotted list.
    343                 signalTypeError(cons.cdr, Symbol.LIST);
     343                type_error(cons.cdr, Symbol.LIST);
    344344              }
    345345            // Not reached.
     
    360360      }
    361361    if (cons.cdr != NIL)
    362       return signalTypeError(cons.cdr, Symbol.LIST);
     362      return type_error(cons.cdr, Symbol.LIST);
    363363    return result;
    364364  }
     
    382382            while (cons.cdr instanceof Cons);
    383383            if (cons.cdr != NIL)
    384               return signalTypeError(cons.cdr, Symbol.LIST);
     384              return type_error(cons.cdr, Symbol.LIST);
    385385            cdr = list;
    386386            cons1.cdr = cons;
    387387          }
    388388        else if (cons.cdr != NIL)
    389           return signalTypeError(cons.cdr, Symbol.LIST);
     389          return type_error(cons.cdr, Symbol.LIST);
    390390        LispObject temp = car;
    391391        car = cons.car;
     
    393393      }
    394394    else if (cdr != NIL)
    395       return signalTypeError(cdr, Symbol.LIST);
     395      return type_error(cdr, Symbol.LIST);
    396396    return this;
    397397  }
     
    553553  private final LispObject signalExecutionError() throws ConditionThrowable
    554554  {
    555     return signalTypeError(this, list3(Symbol.OR, Symbol.FUNCTION,
     555    return type_error(this, list3(Symbol.OR, Symbol.FUNCTION,
    556556                                       Symbol.SYMBOL));
    557557  }
  • trunk/j/src/org/armedbear/lisp/DoubleFloat.java

    r11040 r11158  
    33 *
    44 * Copyright (C) 2003-2006 Peter Graves
    5  * $Id: DoubleFloat.java,v 1.7 2006-03-26 18:38:57 piso Exp $
     5 * $Id: DoubleFloat.java,v 1.8 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    174174        }
    175175        catch (ClassCastException e) {
    176             signalTypeError(obj, Symbol.FLOAT);
     176            type_error(obj, Symbol.FLOAT);
    177177            // Not reached.
    178178            return 0;
     
    224224            return Complex.getInstance(add(c.getRealPart()), c.getImaginaryPart());
    225225        }
    226         return signalTypeError(obj, Symbol.NUMBER);
     226        return type_error(obj, Symbol.NUMBER);
    227227    }
    228228
     
    244244                                       ZERO.subtract(c.getImaginaryPart()));
    245245        }
    246         return signalTypeError(obj, Symbol.NUMBER);
     246        return type_error(obj, Symbol.NUMBER);
    247247    }
    248248
     
    264264                                       multiplyBy(c.getImaginaryPart()));
    265265        }
    266         return signalTypeError(obj, Symbol.NUMBER);
     266        return type_error(obj, Symbol.NUMBER);
    267267    }
    268268
     
    289289            return Complex.getInstance(resX, resY);
    290290        }
    291         return signalTypeError(obj, Symbol.NUMBER);
     291        return type_error(obj, Symbol.NUMBER);
    292292    }
    293293
     
    306306        if (obj instanceof Complex)
    307307            return obj.isEqualTo(this);
    308         signalTypeError(obj, Symbol.NUMBER);
     308        type_error(obj, Symbol.NUMBER);
    309309        // Not reached.
    310310        return false;
     
    328328        if (obj instanceof Ratio)
    329329            return rational().isLessThan(obj);
    330         signalTypeError(obj, Symbol.REAL);
     330        type_error(obj, Symbol.REAL);
    331331        // Not reached.
    332332        return false;
     
    345345        if (obj instanceof Ratio)
    346346            return rational().isGreaterThan(obj);
    347         signalTypeError(obj, Symbol.REAL);
     347        type_error(obj, Symbol.REAL);
    348348        // Not reached.
    349349        return false;
     
    362362        if (obj instanceof Ratio)
    363363            return rational().isLessThanOrEqualTo(obj);
    364         signalTypeError(obj, Symbol.REAL);
     364        type_error(obj, Symbol.REAL);
    365365        // Not reached.
    366366        return false;
     
    379379        if (obj instanceof Ratio)
    380380            return rational().isGreaterThanOrEqualTo(obj);
    381         signalTypeError(obj, Symbol.REAL);
     381        type_error(obj, Symbol.REAL);
    382382        // Not reached.
    383383        return false;
     
    473473            return thread.setValues(result, remainder);
    474474        }
    475         return signalTypeError(obj, Symbol.REAL);
     475        return type_error(obj, Symbol.REAL);
    476476    }
    477477
     
    557557        if (obj instanceof Ratio)
    558558            return new DoubleFloat(((Ratio)obj).doubleValue());
    559         signal(new TypeError("The value " + obj.writeToString() +
     559        error(new TypeError("The value " + obj.writeToString() +
    560560                             " cannot be converted to type DOUBLE-FLOAT."));
    561561        // Not reached.
  • trunk/j/src/org/armedbear/lisp/EchoStream.java

    r9928 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: EchoStream.java,v 1.14 2005-08-27 11:34:50 piso Exp $
     5 * $Id: EchoStream.java,v 1.15 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    214214        {
    215215            if (!(first instanceof Stream))
    216                 return signalTypeError(first, Symbol.STREAM);
     216                return type_error(first, Symbol.STREAM);
    217217            if (!(second instanceof Stream))
    218                 return signalTypeError(second, Symbol.STREAM);
     218                return type_error(second, Symbol.STREAM);
    219219            return new EchoStream((Stream) first, (Stream) second);
    220220        }
     
    230230            if (arg instanceof EchoStream)
    231231                return ((EchoStream)arg).getInputStream();
    232             return signalTypeError(arg, Symbol.ECHO_STREAM);
     232            return type_error(arg, Symbol.ECHO_STREAM);
    233233        }
    234234    };
     
    243243            if (arg instanceof EchoStream)
    244244                return ((EchoStream)arg).getOutputStream();
    245             return signalTypeError(arg, Symbol.ECHO_STREAM);
     245            return type_error(arg, Symbol.ECHO_STREAM);
    246246        }
    247247    };
  • trunk/j/src/org/armedbear/lisp/Environment.java

    r10965 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: Environment.java,v 1.29 2006-01-20 13:40:08 piso Exp $
     5 * $Id: Environment.java,v 1.30 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    301301        catch (ClassCastException e)
    302302          {
    303             return signalTypeError(arg, Symbol.ENVIRONMENT);
     303            return type_error(arg, Symbol.ENVIRONMENT);
    304304          }
    305305      }
     
    323323        catch (ClassCastException e)
    324324          {
    325             return signalTypeError(arg, Symbol.ENVIRONMENT);
     325            return type_error(arg, Symbol.ENVIRONMENT);
    326326          }
    327327      }
  • trunk/j/src/org/armedbear/lisp/Extensions.java

    r11131 r11158  
    33 *
    44 * Copyright (C) 2002-2007 Peter Graves
    5  * $Id: Extensions.java,v 1.47 2007-02-11 15:47:45 piso Exp $
     5 * $Id: Extensions.java,v 1.48 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040      {
    4141        if (args.length() != 2)
    42           return signal(new WrongNumberOfArgumentsException(this));
     42          return error(new WrongNumberOfArgumentsException(this));
    4343        return eval(args.cadr(), env, LispThread.currentThread());
    4444      }
     
    7070          }
    7171        if (list != NIL)
    72           signalTypeError(list, Symbol.LIST);
     72          type_error(list, Symbol.LIST);
    7373        return NIL;
    7474      }
     
    8989          }
    9090        if (list != NIL)
    91           signalTypeError(list, Symbol.LIST);
     91          type_error(list, Symbol.LIST);
    9292        return NIL;
    9393      }
  • trunk/j/src/org/armedbear/lisp/FaslReader.java

    r10209 r11158  
    33 *
    44 * Copyright (C) 2005 Peter Graves
    5  * $Id: FaslReader.java,v 1.9 2005-10-23 18:11:10 piso Exp $
     5 * $Id: FaslReader.java,v 1.10 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5555                int n = stream._readChar();
    5656                if (n < 0) {
    57                     signal(new EndOfFile(stream));
     57                    error(new EndOfFile(stream));
    5858                    // Not reached.
    5959                    return null;
     
    6464                    n = stream._readChar();
    6565                    if (n < 0) {
    66                         signal(new EndOfFile(stream));
     66                        error(new EndOfFile(stream));
    6767                        // Not reached.
    6868                        return null;
     
    7575                        n = stream._readChar();
    7676                        if (n < 0) {
    77                             signal(new EndOfFile(stream));
     77                            error(new EndOfFile(stream));
    7878                            // Not reached.
    7979                            return null;
     
    118118            throws ConditionThrowable
    119119        {
    120             return signal(new ReaderError("Unmatched right parenthesis.", stream));
     120            return error(new ReaderError("Unmatched right parenthesis.", stream));
    121121        }
    122122    };
     
    204204                        if (name == null)
    205205                            name = "#\\" + c;
    206                         signal(new ReaderError("Illegal element for bit-vector: " + name,
     206                        error(new ReaderError("Illegal element for bit-vector: " + name,
    207207                                               stream));
    208208                    }
     
    216216                if (length == 0) {
    217217                    if (n > 0)
    218                         return signal(new ReaderError("No element specified for bit vector of length " +
     218                        return error(new ReaderError("No element specified for bit vector of length " +
    219219                                                      n + '.',
    220220                                                      stream));
     
    225225                        sb.append(c);
    226226                } else if (n < length) {
    227                     return signal(new ReaderError("Bit vector is longer than specified length: #" +
     227                    return error(new ReaderError("Bit vector is longer than specified length: #" +
    228228                                                  n + '*' + sb.toString(),
    229229                                                  stream));
     
    244244            final LispThread thread = LispThread.currentThread();
    245245            if (Symbol.READ_EVAL.symbolValue(thread) == NIL)
    246                 return signal(new ReaderError("Can't read #. when *READ-EVAL* is NIL.",
     246                return error(new ReaderError("Can't read #. when *READ-EVAL* is NIL.",
    247247                                              stream));
    248248            else
     
    424424            else
    425425                sb.append(c);
    426             return signal(new ReaderError(sb.toString(), stream));
     426            return error(new ReaderError(sb.toString(), stream));
    427427        }
    428428    };
  • trunk/j/src/org/armedbear/lisp/FileStream.java

    r11112 r11158  
    33 *
    44 * Copyright (C) 2004-2006 Peter Graves
    5  * $Id: FileStream.java,v 1.30 2006-10-19 23:39:56 piso Exp $
     5 * $Id: FileStream.java,v 1.31 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    141141        }
    142142        catch (IOException e) {
    143             signal(new StreamError(this, e));
     143            error(new StreamError(this, e));
    144144        }
    145145        // Not reached.
     
    155155            }
    156156            catch (IOException e) {
    157                 signal(new StreamError(this, e));
     157                error(new StreamError(this, e));
    158158                // Not reached.
    159159                return NIL;
     
    162162            String namestring = pathname.getNamestring();
    163163            if (namestring == null)
    164                 return signal(new SimpleError("Pathname has no namestring: " +
     164                return error(new SimpleError("Pathname has no namestring: " +
    165165                                              pathname.writeToString()));
    166166            File file = new File(namestring);
     
    186186                    if (sb.length() == 0) {
    187187                        if (eofError)
    188                             return signal(new EndOfFile(this));
     188                            return error(new EndOfFile(this));
    189189                        return thread.setValues(eofValue, T);
    190190                    }
     
    235235        }
    236236        catch (IOException e) {
    237             signal(new StreamError(this, e));
     237            error(new StreamError(this, e));
    238238        }
    239239        // Not reached.
     
    284284        }
    285285        catch (IOException e) {
    286             signal(new StreamError(this, e));
     286            error(new StreamError(this, e));
    287287        }
    288288    }
     
    383383        }
    384384        catch (IOException e) {
    385             signal(new StreamError(this, e));
     385            error(new StreamError(this, e));
    386386        }
    387387        // Not reached.
     
    402402            }
    403403            catch (IOException e) {
    404                 signal(new StreamError(this, e));
     404                error(new StreamError(this, e));
    405405            }
    406406        }
     
    423423        }
    424424        catch (IOException e) {
    425             signal(new StreamError(this, e));
     425            error(new StreamError(this, e));
    426426        }
    427427    }
     
    440440        }
    441441        catch (IOException e) {
    442             signal(new StreamError(this, e));
     442            error(new StreamError(this, e));
    443443            // Not reached.
    444444            return -1;
     
    465465        }
    466466        catch (IOException e) {
    467             signal(new StreamError(this, e));
     467            error(new StreamError(this, e));
    468468        }
    469469        return true;
     
    479479        }
    480480        catch (IOException e) {
    481             signal(new StreamError(this, e));
     481            error(new StreamError(this, e));
    482482        }
    483483    }
     
    504504        }
    505505        catch (IOException e) {
    506             signal(new StreamError(this, e));
     506            error(new StreamError(this, e));
    507507        }
    508508    }
     
    533533            }
    534534            catch (IOException e) {
    535                 signal(new StreamError(this, e));
     535                error(new StreamError(this, e));
    536536            }
    537537        }
     
    558558            }
    559559            catch (ClassCastException e) {
    560                 return signalTypeError(first, Symbol.PATHNAME);
     560                return type_error(first, Symbol.PATHNAME);
    561561            }
    562562            final LispObject namestring;
     
    565565            }
    566566            catch (ClassCastException e) {
    567                 return signalTypeError(second, Symbol.STRING);
     567                return type_error(second, Symbol.STRING);
    568568            }
    569569            LispObject elementType = third;
     
    572572            if (direction != Keyword.INPUT && direction != Keyword.OUTPUT &&
    573573                direction != Keyword.IO)
    574                 signal(new LispError("Direction must be :INPUT, :OUTPUT, or :IO."));
     574                error(new LispError("Direction must be :INPUT, :OUTPUT, or :IO."));
    575575            try {
    576576                return new FileStream(pathname, namestring.getStringValue(),
     
    581581            }
    582582            catch (IOException e) {
    583                 return signal(new StreamError(null, e));
     583                return error(new StreamError(null, e));
    584584            }
    585585        }
  • trunk/j/src/org/armedbear/lisp/FillPointerOutputStream.java

    r10027 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: FillPointerOutputStream.java,v 1.14 2005-09-25 14:58:12 piso Exp $
     5 * $Id: FillPointerOutputStream.java,v 1.15 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848                    return new FillPointerOutputStream(string);
    4949            }
    50             return signalTypeError(arg, list3(Symbol.AND, Symbol.STRING,
     50            return type_error(arg, list3(Symbol.AND, Symbol.STRING,
    5151                                              list2(Symbol.SATISFIES,
    5252                                                    Symbol.ARRAY_HAS_FILL_POINTER_P)));
  • trunk/j/src/org/armedbear/lisp/Fixnum.java

    r10890 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: Fixnum.java,v 1.137 2006-01-08 16:10:57 piso Exp $
     5 * $Id: Fixnum.java,v 1.138 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    268268    catch (ClassCastException e)
    269269      {
    270         signalTypeError(obj, Symbol.FIXNUM);
     270        type_error(obj, Symbol.FIXNUM);
    271271        // Not reached.
    272272        return 0;
     
    282282    catch (ClassCastException e)
    283283      {
    284         signalTypeError(obj, Symbol.FIXNUM);
     284        type_error(obj, Symbol.FIXNUM);
    285285        // Not reached.
    286286        return 0;
     
    296296    catch (ClassCastException e)
    297297      {
    298         signalTypeError(obj, Symbol.FIXNUM);
     298        type_error(obj, Symbol.FIXNUM);
    299299        // Not reached.
    300300        return null;
     
    377377        return Complex.getInstance(add(c.getRealPart()), c.getImaginaryPart());
    378378      }
    379     return signalTypeError(obj, Symbol.NUMBER);
     379    return type_error(obj, Symbol.NUMBER);
    380380  }
    381381
     
    413413                                   ZERO.subtract(c.getImaginaryPart()));
    414414      }
    415     return signalTypeError(obj, Symbol.NUMBER);
     415    return type_error(obj, Symbol.NUMBER);
    416416  }
    417417
     
    455455                                   multiplyBy(c.getImaginaryPart()));
    456456      }
    457     return signalTypeError(obj, Symbol.NUMBER);
     457    return type_error(obj, Symbol.NUMBER);
    458458  }
    459459
     
    495495                                       Fixnum.ZERO.subtract(multiplyBy(imagPart).divideBy(denominator)));
    496496          }
    497         return signalTypeError(obj, Symbol.NUMBER);
     497        return type_error(obj, Symbol.NUMBER);
    498498      }
    499499    catch (ArithmeticException e)
    500500      {
    501501        if (obj.zerop())
    502           return signal(new DivisionByZero());
    503         return signal(new ArithmeticError(e.getMessage()));
     502          return error(new DivisionByZero());
     503        return error(new ArithmeticError(e.getMessage()));
    504504      }
    505505  }
     
    522522    if (obj.numberp())
    523523      return false;
    524     signalTypeError(obj, Symbol.NUMBER);
     524    type_error(obj, Symbol.NUMBER);
    525525    // Not reached.
    526526    return false;
     
    545545    if (obj.numberp())
    546546      return true;
    547     signalTypeError(obj, Symbol.NUMBER);
     547    type_error(obj, Symbol.NUMBER);
    548548    // Not reached.
    549549    return false;
     
    570570    if (obj instanceof DoubleFloat)
    571571      return isLessThan(((DoubleFloat)obj).rational());
    572     signalTypeError(obj, Symbol.REAL);
     572    type_error(obj, Symbol.REAL);
    573573    // Not reached.
    574574    return false;
     
    595595    if (obj instanceof DoubleFloat)
    596596      return isGreaterThan(((DoubleFloat)obj).rational());
    597     signalTypeError(obj, Symbol.REAL);
     597    type_error(obj, Symbol.REAL);
    598598    // Not reached.
    599599    return false;
     
    620620    if (obj instanceof DoubleFloat)
    621621      return isLessThanOrEqualTo(((DoubleFloat)obj).rational());
    622     signalTypeError(obj, Symbol.REAL);
     622    type_error(obj, Symbol.REAL);
    623623    // Not reached.
    624624    return false;
     
    645645    if (obj instanceof DoubleFloat)
    646646      return isGreaterThanOrEqualTo(((DoubleFloat)obj).rational());
    647     signalTypeError(obj, Symbol.REAL);
     647    type_error(obj, Symbol.REAL);
    648648    // Not reached.
    649649    return false;
     
    699699          }
    700700        else
    701           return signalTypeError(obj, Symbol.REAL);
     701          return type_error(obj, Symbol.REAL);
    702702      }
    703703    catch (ArithmeticException e)
    704704      {
    705705        if (obj.zerop())
    706           return signal(new DivisionByZero());
     706          return error(new DivisionByZero());
    707707        else
    708           return signal(new ArithmeticError(e.getMessage()));
     708          return error(new ArithmeticError(e.getMessage()));
    709709      }
    710710    return thread.setValues(value1, value2);
     
    727727    catch (ArithmeticException e)
    728728      {
    729         return signal(new ArithmeticError("Division by zero."));
     729        return error(new ArithmeticError("Division by zero."));
    730730      }
    731731    if (r == 0)
     
    784784        BigInteger shift = ((Bignum)obj).value;
    785785        if (shift.signum() > 0)
    786           return signal(new LispError("Can't represent result of left shift."));
     786          return error(new LispError("Can't represent result of left shift."));
    787787        if (shift.signum() < 0)
    788788          return n.signum() >= 0 ? Fixnum.ZERO : Fixnum.MINUS_ONE;
    789789        Debug.bug(); // Shouldn't happen.
    790790      }
    791     return signalTypeError(obj, Symbol.INTEGER);
     791    return type_error(obj, Symbol.INTEGER);
    792792  }
    793793
     
    820820          }
    821821      }
    822     return signalTypeError(obj, Symbol.INTEGER);
     822    return type_error(obj, Symbol.INTEGER);
    823823  }
    824824
     
    838838        return number(n1.or(n2));
    839839      }
    840     return signalTypeError(obj, Symbol.INTEGER);
     840    return type_error(obj, Symbol.INTEGER);
    841841  }
    842842
     
    856856        return number(n1.xor(n2));
    857857      }
    858     return signalTypeError(obj, Symbol.INTEGER);
     858    return type_error(obj, Symbol.INTEGER);
    859859  }
    860860
  • trunk/j/src/org/armedbear/lisp/FloatFunctions.java

    r11056 r11158  
    33 *
    44 * Copyright (C) 2003-2006 Peter Graves
    5  * $Id: FloatFunctions.java,v 1.9 2006-04-18 00:30:31 piso Exp $
     5 * $Id: FloatFunctions.java,v 1.10 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3232        {
    3333            if (args.length % 2 != 0)
    34                 signal(new ProgramError("Odd number of keyword arguments."));
     34                error(new ProgramError("Odd number of keyword arguments."));
    3535            for (int i = 0; i < args.length; i += 2) {
    3636                LispObject key = checkSymbol(args[i]);
     
    4646                            trap_underflow = true;
    4747                        else
    48                             signal(new LispError("Unsupported floating point trap: " +
     48                            error(new LispError("Unsupported floating point trap: " +
    4949                                                 car.writeToString()));
    5050                        value = value.cdr();
     
    5353                    TRAP_UNDERFLOW = trap_underflow;
    5454                } else
    55                     signal(new LispError("Unrecognized keyword: " + key.writeToString()));
     55                    error(new LispError("Unrecognized keyword: " + key.writeToString()));
    5656            }
    5757            return LispThread.currentThread().nothing();
     
    124124                                                            sign);
    125125            }
    126             return signalTypeError(arg, Symbol.FLOAT);
     126            return type_error(arg, Symbol.FLOAT);
    127127        }
    128128    };
     
    140140            if (arg.rationalp())
    141141                return arg;
    142             return signalTypeError(arg, Symbol.REAL);
     142            return type_error(arg, Symbol.REAL);
    143143        }
    144144    };
     
    153153            if (arg instanceof SingleFloat || arg instanceof DoubleFloat)
    154154                return Fixnum.TWO;
    155             return signalTypeError(arg, Symbol.FLOAT);
     155            return type_error(arg, Symbol.FLOAT);
    156156        }
    157157    };
     
    171171            if (arg instanceof DoubleFloat)
    172172                return FIXNUM_53;
    173             return signalTypeError(arg, Symbol.FLOAT);
     173            return type_error(arg, Symbol.FLOAT);
    174174        }
    175175    };
     
    192192                return new DoubleFloat(d * Math.pow(2, n));
    193193            }
    194             return signalTypeError(first, Symbol.FLOAT);
     194            return type_error(first, Symbol.FLOAT);
    195195        }
    196196    };
     
    234234            if (second instanceof DoubleFloat)
    235235                return DoubleFloat.coerceToFloat(first);
    236             return signalTypeError(second, Symbol.FLOAT);
     236            return type_error(second, Symbol.FLOAT);
    237237        }
    238238    };
     
    262262                return new Fixnum(Float.floatToIntBits(f.value));
    263263            }
    264             return signalTypeError(arg, Symbol.FLOAT);
     264            return type_error(arg, Symbol.FLOAT);
    265265        }
    266266    };
     
    276276                return number(Double.doubleToLongBits(f.value) >>> 32);
    277277            }
    278             return signalTypeError(arg, Symbol.DOUBLE_FLOAT);
     278            return type_error(arg, Symbol.DOUBLE_FLOAT);
    279279        }
    280280    };
     
    290290                return number(Double.doubleToLongBits(f.value) & 0xffffffffL);
    291291            }
    292             return signalTypeError(arg, Symbol.DOUBLE_FLOAT);
     292            return type_error(arg, Symbol.DOUBLE_FLOAT);
    293293        }
    294294    };
     
    309309                return new SingleFloat(Float.intBitsToFloat((int)bits));
    310310            }
    311             return signalTypeError(arg, Symbol.INTEGER);
     311            return type_error(arg, Symbol.INTEGER);
    312312        }
    313313    };
     
    328328                return new DoubleFloat(Double.longBitsToDouble(bits));
    329329            }
    330             return signalTypeError(arg, Symbol.INTEGER);
     330            return type_error(arg, Symbol.INTEGER);
    331331        }
    332332    };
     
    343343            if (arg instanceof DoubleFloat)
    344344                return Double.isInfinite(((DoubleFloat)arg).value) ? T : NIL;
    345             return signalTypeError(arg, Symbol.FLOAT);
     345            return type_error(arg, Symbol.FLOAT);
    346346        }
    347347    };
     
    358358            if (arg instanceof DoubleFloat)
    359359                return Double.isNaN(((DoubleFloat)arg).value) ? T : NIL;
    360             return signalTypeError(arg, Symbol.FLOAT);
     360            return type_error(arg, Symbol.FLOAT);
    361361        }
    362362    };
     
    374374                s1 = String.valueOf(((DoubleFloat)arg).value);
    375375            else
    376                 return signalTypeError(arg, Symbol.FLOAT);
     376                return type_error(arg, Symbol.FLOAT);
    377377            int i = s1.indexOf('E');
    378378            if (i < 0)
  • trunk/j/src/org/armedbear/lisp/ForwardReferencedClass.java

    r9482 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: ForwardReferencedClass.java,v 1.3 2005-06-21 18:42:13 piso Exp $
     5 * $Id: ForwardReferencedClass.java,v 1.4 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7373            }
    7474            catch (ClassCastException e) {
    75                 return signal(new TypeError(arg.writeToString() +
     75                return error(new TypeError(arg.writeToString() +
    7676                                            " is not a valid class name."));
    7777            }
  • trunk/j/src/org/armedbear/lisp/Function.java

    r10224 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Function.java,v 1.58 2005-10-25 14:40:30 piso Exp $
     5 * $Id: Function.java,v 1.59 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    168168    public LispObject execute() throws ConditionThrowable
    169169    {
    170         return signal(new WrongNumberOfArgumentsException(this));
     170        return error(new WrongNumberOfArgumentsException(this));
    171171    }
    172172
    173173    public LispObject execute(LispObject arg) throws ConditionThrowable
    174174    {
    175         return signal(new WrongNumberOfArgumentsException(this));
     175        return error(new WrongNumberOfArgumentsException(this));
    176176    }
    177177
     
    179179        throws ConditionThrowable
    180180    {
    181         return signal(new WrongNumberOfArgumentsException(this));
     181        return error(new WrongNumberOfArgumentsException(this));
    182182    }
    183183
     
    186186        throws ConditionThrowable
    187187    {
    188         return signal(new WrongNumberOfArgumentsException(this));
     188        return error(new WrongNumberOfArgumentsException(this));
    189189    }
    190190
     
    193193        throws ConditionThrowable
    194194    {
    195         return signal(new WrongNumberOfArgumentsException(this));
     195        return error(new WrongNumberOfArgumentsException(this));
    196196    }
    197197
     
    201201        throws ConditionThrowable
    202202    {
    203         return signal(new WrongNumberOfArgumentsException(this));
     203        return error(new WrongNumberOfArgumentsException(this));
    204204    }
    205205
     
    209209        throws ConditionThrowable
    210210    {
    211         return signal(new WrongNumberOfArgumentsException(this));
     211        return error(new WrongNumberOfArgumentsException(this));
    212212    }
    213213
     
    218218        throws ConditionThrowable
    219219    {
    220         return signal(new WrongNumberOfArgumentsException(this));
     220        return error(new WrongNumberOfArgumentsException(this));
    221221    }
    222222
     
    227227        throws ConditionThrowable
    228228    {
    229         return signal(new WrongNumberOfArgumentsException(this));
     229        return error(new WrongNumberOfArgumentsException(this));
    230230    }
    231231
    232232    public LispObject execute(LispObject[] args) throws ConditionThrowable
    233233    {
    234         return signal(new WrongNumberOfArgumentsException(this));
     234        return error(new WrongNumberOfArgumentsException(this));
    235235    }
    236236
     
    276276    public final void argCountError() throws ConditionThrowable
    277277    {
    278         signal(new WrongNumberOfArgumentsException(this));
     278        error(new WrongNumberOfArgumentsException(this));
    279279    }
    280280
  • trunk/j/src/org/armedbear/lisp/HashTableFunctions.java

    r11041 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: HashTableFunctions.java,v 1.8 2006-03-26 18:42:24 piso Exp $
     5 * $Id: HashTableFunctions.java,v 1.9 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848        catch (ClassCastException e)
    4949          {
    50             return signalTypeError(size, Symbol.FIXNUM);
     50            return type_error(size, Symbol.FIXNUM);
    5151          }
    5252        if (test == FUNCTION_EQL || test == NIL)
     
    5858        if (test == FUNCTION_EQUALP)
    5959          return new EqualpHashTable(n, rehashSize, rehashThreshold);
    60         return signal(new LispError("Unsupported test for MAKE-HASH-TABLE: " +
     60        return error(new LispError("Unsupported test for MAKE-HASH-TABLE: " +
    6161                                    test.writeToString()));
    6262      }
     
    7676        catch (ClassCastException e)
    7777          {
    78             return signalTypeError(ht, Symbol.HASH_TABLE);
     78            return type_error(ht, Symbol.HASH_TABLE);
    7979          }
    8080      }
     
    8989        catch (ClassCastException e)
    9090          {
    91             return signalTypeError(ht, Symbol.HASH_TABLE);
     91            return type_error(ht, Symbol.HASH_TABLE);
    9292          }
    9393      }
     
    108108        catch (ClassCastException e)
    109109          {
    110             return signalTypeError(second, Symbol.HASH_TABLE);
     110            return type_error(second, Symbol.HASH_TABLE);
    111111          }
    112112        synchronized (ht)
     
    133133        catch (ClassCastException e)
    134134          {
    135             return signalTypeError(ht, Symbol.HASH_TABLE);
     135            return type_error(ht, Symbol.HASH_TABLE);
    136136          }
    137137      }
     
    146146        catch (ClassCastException e)
    147147          {
    148             return signalTypeError(ht, Symbol.HASH_TABLE);
     148            return type_error(ht, Symbol.HASH_TABLE);
    149149          }
    150150      }
     
    164164        catch (ClassCastException e)
    165165          {
    166             return signalTypeError(ht, Symbol.HASH_TABLE);
     166            return type_error(ht, Symbol.HASH_TABLE);
    167167          }
    168168      }
     
    182182        catch (ClassCastException e)
    183183          {
    184             return signalTypeError(ht, Symbol.HASH_TABLE);
     184            return type_error(ht, Symbol.HASH_TABLE);
    185185          }
    186186      }
     
    199199        catch (ClassCastException e)
    200200          {
    201             return signalTypeError(arg, Symbol.HASH_TABLE);
     201            return type_error(arg, Symbol.HASH_TABLE);
    202202          }
    203203      }
     
    247247        catch (ClassCastException e)
    248248          {
    249             return signalTypeError(arg, Symbol.HASH_TABLE);
     249            return type_error(arg, Symbol.HASH_TABLE);
    250250          }
    251251      }
     
    264264        catch (ClassCastException e)
    265265          {
    266             return signalTypeError(arg, Symbol.HASH_TABLE);
     266            return type_error(arg, Symbol.HASH_TABLE);
    267267          }
    268268      }
     
    281281        catch (ClassCastException e)
    282282          {
    283             return signalTypeError(arg, Symbol.HASH_TABLE);
     283            return type_error(arg, Symbol.HASH_TABLE);
    284284          }
    285285      }
     
    298298        catch (ClassCastException e)
    299299          {
    300             return signalTypeError(arg, Symbol.HASH_TABLE);
     300            return type_error(arg, Symbol.HASH_TABLE);
    301301          }
    302302      }
     
    315315        catch (ClassCastException e)
    316316          {
    317             return signalTypeError(arg, Symbol.HASH_TABLE);
     317            return type_error(arg, Symbol.HASH_TABLE);
    318318          }
    319319      }
     
    334334        catch (ClassCastException e)
    335335          {
    336             return signalTypeError(second, Symbol.HASH_TABLE);
     336            return type_error(second, Symbol.HASH_TABLE);
    337337          }
    338338        return ht.MAPHASH(first);
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r10990 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: Interpreter.java,v 1.101 2006-02-12 00:08:08 piso Exp $
     5 * $Id: Interpreter.java,v 1.102 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    536536        LispObject obj = stream.read(false, EOF, false, thread);
    537537        if (obj == EOF)
    538             return signal(new EndOfFile(stream));
     538            return error(new EndOfFile(stream));
    539539        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    540540        thread.bindSpecial(Symbol.DEBUGGER_HOOK, _DEBUGGER_HOOK_FUNCTION);
  • trunk/j/src/org/armedbear/lisp/JHandler.java

    r10555 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Andras Simon, Peter Graves
    5  * $Id: JHandler.java,v 1.9 2005-11-27 21:35:52 piso Exp $
     5 * $Id: JHandler.java,v 1.10 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8686        {
    8787            if (args.length != 5)
    88                 return signal(new WrongNumberOfArgumentsException(this));
     88                return error(new WrongNumberOfArgumentsException(this));
    8989            Map entryTable = null;
    9090            Object object = args[0].javaInstance();
  • trunk/j/src/org/armedbear/lisp/JProxy.java

    r10837 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves, Andras Simon
    5  * $Id: JProxy.java,v 1.8 2006-01-05 22:06:38 asimon Exp $
     5 * $Id: JProxy.java,v 1.9 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4242        int length = args.length;
    4343        if (length < 3 || length % 2 != 1)
    44           return signal(new WrongNumberOfArgumentsException(this));
     44          return error(new WrongNumberOfArgumentsException(this));
    4545        Map lispDefinedMethods = new HashMap();
    4646        for (int i = 1; i < length; i += 2)
  • trunk/j/src/org/armedbear/lisp/Java.java

    r10924 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves, Andras Simon
    5  * $Id: Java.java,v 1.71 2006-01-12 03:03:02 piso Exp $
     5 * $Id: Java.java,v 1.72 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    143143        {
    144144            if (args.length < 2 || args.length > 4)
    145                 signal(new WrongNumberOfArgumentsException(this));
     145                error(new WrongNumberOfArgumentsException(this));
    146146            String fieldName = null;
    147147            Class c;
     
    196196            }
    197197            catch (NoSuchFieldException e) {
    198                 signal(new LispError("no such field"));
     198                error(new LispError("no such field"));
    199199            }
    200200            catch (SecurityException e) {
    201                 signal(new LispError("inaccessible field"));
     201                error(new LispError("inaccessible field"));
    202202            }
    203203            catch (IllegalAccessException e) {
    204                 signal(new LispError("illegal access"));
     204                error(new LispError("illegal access"));
    205205            }
    206206            catch (IllegalArgumentException e) {
    207                 signal(new LispError("illegal argument"));
    208             }
    209             catch (Throwable t) {
    210                 signal(new LispError(getMessage(t)));
     207                error(new LispError("illegal argument"));
     208            }
     209            catch (Throwable t) {
     210                error(new LispError(getMessage(t)));
    211211            }
    212212            // Not reached.
     
    223223        {
    224224            if (args.length < 1)
    225                 signal(new WrongNumberOfArgumentsException(this));
     225                error(new WrongNumberOfArgumentsException(this));
    226226            try {
    227227                final Class c = javaClass(args[0]);
     
    246246            }
    247247            catch (NoSuchMethodException e) {
    248                 signal(new LispError("no such constructor"));
     248                error(new LispError("no such constructor"));
    249249            }
    250250            catch (ConditionThrowable e) {
     
    252252            }
    253253            catch (Throwable t) {
    254                 signal(new LispError(getMessage(t)));
     254                error(new LispError(getMessage(t)));
    255255            }
    256256            // Not reached.
     
    267267        {
    268268            if (args.length < 2)
    269                 signal(new WrongNumberOfArgumentsException(this));
     269                error(new WrongNumberOfArgumentsException(this));
    270270            final Class c = javaClass(args[0]);
    271271            String methodName = args[1].getStringValue();
     
    303303                }
    304304                sb.append(')');
    305                 signal(new LispError(sb.toString()));
     305                error(new LispError(sb.toString()));
    306306            }
    307307            catch (ConditionThrowable e) {
     
    309309            }
    310310            catch (Throwable t) {
    311                 signal(new LispError(getMessage(t)));
     311                error(new LispError(getMessage(t)));
    312312            }
    313313            // Not reached.
     
    334334        {
    335335            if (args.length < 2)
    336                 signal(new WrongNumberOfArgumentsException(this));
     336                error(new WrongNumberOfArgumentsException(this));
    337337            try {
    338338                Method m = null;
     
    359359                        }
    360360                        if (m == null)
    361                             signal(new LispError("no such method"));
     361                            error(new LispError("no such method"));
    362362                    }
    363363                } else
    364                     signal(new TypeError("wrong type: " + methodRef));
     364                    error(new TypeError("wrong type: " + methodRef));
    365365                Object[] methodArgs = new Object[args.length-2];
    366366                Class[] argTypes = m.getParameterTypes();
     
    380380                Symbol condition = getCondition(t.getClass());
    381381                if (condition == null)
    382                     signal(new JavaException(t));
     382                    error(new JavaException(t));
    383383                else
    384384                    Symbol.SIGNAL.execute(
     
    401401        {
    402402            if (args.length < 1)
    403                 signal(new WrongNumberOfArgumentsException(this));
     403                error(new WrongNumberOfArgumentsException(this));
    404404            LispObject classRef = args[0];
    405405            try {
     
    422422                Symbol condition = getCondition(t.getClass());
    423423                if (condition == null)
    424                     signal(new JavaException(t));
     424                    error(new JavaException(t));
    425425                else
    426426                    Symbol.SIGNAL.execute(
     
    444444        {
    445445            if (args.length < 2)
    446                 signal(new WrongNumberOfArgumentsException(this));
     446                error(new WrongNumberOfArgumentsException(this));
    447447            try {
    448448                Class c = javaClass(args[0]);
     
    453453            }
    454454            catch (Throwable t) {
    455                 signal(new JavaException(t));
     455                error(new JavaException(t));
    456456            }
    457457            // Not reached.
     
    479479        {
    480480            if (args.length < 2)
    481                 signal(new WrongNumberOfArgumentsException(this));
     481                error(new WrongNumberOfArgumentsException(this));
    482482            try {
    483483                Object a = args[0].javaInstance();
     
    489489                Symbol condition = getCondition(t.getClass());
    490490                if (condition == null)
    491                     signal(new JavaException(t));
     491                    error(new JavaException(t));
    492492                else
    493493                    Symbol.SIGNAL.execute(
     
    511511        {
    512512            if (args.length < 3)
    513                 signal(new WrongNumberOfArgumentsException(this));
     513                error(new WrongNumberOfArgumentsException(this));
    514514            try {
    515515                Object a = args[0].javaInstance();
     
    523523                Symbol condition = getCondition(t.getClass());
    524524                if (condition == null)
    525                     signal(new JavaException(t));
     525                    error(new JavaException(t));
    526526                else
    527527                    Symbol.SIGNAL.execute(
     
    545545        {
    546546            if (args.length < 2)
    547                 signal(new WrongNumberOfArgumentsException(this));
     547                error(new WrongNumberOfArgumentsException(this));
    548548            return makeLispObject(jcall(args));
    549549        }
     
    559559        {
    560560            if (args.length < 2)
    561                 signal(new WrongNumberOfArgumentsException(this));
     561                error(new WrongNumberOfArgumentsException(this));
    562562            return new JavaObject(jcall(args));
    563563        }
     
    575575            instance = ((JavaObject)instanceArg).getObject();
    576576        else {
    577             signalTypeError(instanceArg,
     577            type_error(instanceArg,
    578578                            list3(Symbol.OR, Symbol.STRING, Symbol.JAVA_OBJECT));
    579579            // Not reached.
     
    608608            Symbol condition = getCondition(t.getClass());
    609609            if (condition == null)
    610                 signal(new JavaException(t));
     610                error(new JavaException(t));
    611611            else
    612612                Symbol.SIGNAL.execute(
     
    643643        {
    644644            if (args.length < 1)
    645                 signal(new WrongNumberOfArgumentsException(this));
     645                error(new WrongNumberOfArgumentsException(this));
    646646            LispObject object = args[0];
    647647            try {
     
    665665            }
    666666            catch (Throwable t) {
    667                 signal(new LispError("MAKE-IMMEDIATE-OBJECT: not implemented"));
     667                error(new LispError("MAKE-IMMEDIATE-OBJECT: not implemented"));
    668668            }
    669669            // Not reached.
     
    702702            }
    703703            catch (ClassNotFoundException ex) {
    704                 signal(new LispError("Class not found: " + className));
     704                error(new LispError("Class not found: " + className));
    705705                // Not reached.
    706706                return null;
     
    739739        }
    740740        catch (ClassCastException e) {
    741             signalTypeError(obj, list3(Symbol.OR, Symbol.STRING,
     741            type_error(obj, list3(Symbol.OR, Symbol.STRING,
    742742                                       Symbol.JAVA_OBJECT));
    743743            // Not reached.
     
    748748        }
    749749        catch (ClassCastException e) {
    750             signal(new LispError(obj.writeToString() + " does not designate a Java class."));
     750            error(new LispError(obj.writeToString() + " does not designate a Java class."));
    751751            return null;
    752752        }
  • trunk/j/src/org/armedbear/lisp/JavaObject.java

    r10450 r11158  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: JavaObject.java,v 1.22 2005-11-11 21:12:34 piso Exp $
     5 * $Id: JavaObject.java,v 1.23 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7272        }
    7373        catch (ClassCastException e) {
    74             signalTypeError(o, Symbol.JAVA_OBJECT);
     74            type_error(o, Symbol.JAVA_OBJECT);
    7575            // Not reached.
    7676            return null;
     
    116116        {
    117117            if (!(first instanceof JavaObject))
    118                 return signalTypeError(first, Symbol.JAVA_OBJECT);
     118                return type_error(first, Symbol.JAVA_OBJECT);
    119119            final Stream stream;
    120120            try {
     
    122122            }
    123123            catch (ClassCastException e) {
    124                 return signalTypeError(second, Symbol.STREAM);
     124                return type_error(second, Symbol.STREAM);
    125125            }
    126126            final JavaObject javaObject = (JavaObject) first;
  • trunk/j/src/org/armedbear/lisp/Layout.java

    r10884 r11158  
    33 *
    44 * Copyright (C) 2003-2006 Peter Graves
    5  * $Id: Layout.java,v 1.27 2006-01-08 02:40:23 piso Exp $
     5 * $Id: Layout.java,v 1.28 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    167167        catch (ClassCastException e)
    168168          {
    169             return signalTypeError(first, Symbol.CLASS);
     169            return type_error(first, Symbol.CLASS);
    170170          }
    171171      }
     
    185185        catch (ClassCastException e)
    186186          {
    187             return signalTypeError(arg, Symbol.LAYOUT);
     187            return type_error(arg, Symbol.LAYOUT);
    188188          }
    189189      }
     
    202202        catch (ClassCastException e)
    203203          {
    204             return signalTypeError(arg, Symbol.LAYOUT);
     204            return type_error(arg, Symbol.LAYOUT);
    205205          }
    206206      }
     
    248248        catch (ClassCastException e)
    249249          {
    250             return signalTypeError(first, Symbol.LAYOUT);
     250            return type_error(first, Symbol.LAYOUT);
    251251          }
    252252      }
     
    282282        catch (ClassCastException e)
    283283          {
    284             return signalTypeError(first, Symbol.LAYOUT);
     284            return type_error(first, Symbol.LAYOUT);
    285285          }
    286286      }
     
    300300        catch (ClassCastException e)
    301301          {
    302             return signalTypeError(arg, Symbol.CLASS);
     302            return type_error(arg, Symbol.CLASS);
    303303          }
    304304        Layout oldLayout = lispClass.getClassLayout();
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r11157 r11158  
    33 *
    44 * Copyright (C) 2002-2007 Peter Graves
    5  * $Id: Lisp.java,v 1.445 2007-02-23 17:39:53 piso Exp $
     5 * $Id: Lisp.java,v 1.446 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    269269        catch (OutOfMemoryError e)
    270270          {
    271             return signal(new LispError("Out of memory."));
     271            return error(new LispError("Out of memory."));
    272272          }
    273273        catch (StackOverflowError e)
     
    275275            thread.setSpecialVariable(_SAVED_BACKTRACE_,
    276276                                      thread.backtraceAsList(0));
    277             return signal(new StorageCondition("Stack overflow."));
     277            return error(new StorageCondition("Stack overflow."));
    278278          }
    279279        catch (Go go)
     
    283283        catch (Throw t)
    284284          {
    285             return signal(new ControlError("Attempt to throw to the nonexistent tag " +
     285            return error(new ControlError("Attempt to throw to the nonexistent tag " +
    286286                                           t.tag.writeToString() + "."));
    287287          }
     
    291291            thread.setSpecialVariable(_SAVED_BACKTRACE_,
    292292                                      thread.backtraceAsList(0));
    293             return signal(new LispError("Caught " + t + "."));
     293            return error(new LispError("Caught " + t + "."));
    294294          }
    295295        Debug.assertTrue(result != null);
     
    323323    };
    324324
    325   public static final LispObject signal(LispObject condition)
    326     throws ConditionThrowable
    327   {
    328     return Symbol.SIGNAL.execute(condition);
    329   }
    330 
    331   public static final LispObject signal(LispObject condition, LispObject message)
    332     throws ConditionThrowable
    333   {
    334     return Symbol.SIGNAL.execute(condition, Keyword.FORMAT_CONTROL, message);
    335   }
    336 
    337325  public static final LispObject error(LispObject condition)
    338326    throws ConditionThrowable
     
    345333  {
    346334    return Symbol.ERROR.execute(condition, Keyword.FORMAT_CONTROL, message);
    347   }
    348 
    349   public static final LispObject signalTypeError(LispObject datum,
    350                                                  LispObject expectedType)
    351     throws ConditionThrowable
    352   {
    353     return signal(new TypeError(datum, expectedType));
    354335  }
    355336
     
    420401            result = obj.getSymbolValue();
    421402            if (result == null)
    422               return signal(new UnboundVariable(obj));
     403              return error(new UnboundVariable(obj));
    423404          }
    424405        if (result instanceof SymbolMacro)
     
    459440              }
    460441            else
    461               return signal(new ProgramError("Illegal function object: " +
     442              return error(new ProgramError("Illegal function object: " +
    462443                                             first.writeToString()));
    463444          }
     
    738719    catch (ClassCastException e)
    739720      {
    740         signalTypeError(obj, Symbol.SYMBOL);
     721        type_error(obj, Symbol.SYMBOL);
    741722        // Not reached.
    742723        return null;
     
    749730    if (obj.listp())
    750731      return obj;
    751     return signalTypeError(obj, Symbol.LIST);
     732    return type_error(obj, Symbol.LIST);
    752733  }
    753734
     
    763744    catch (ClassCastException e)
    764745      {
    765         signalTypeError(obj, Symbol.ARRAY);
     746        type_error(obj, Symbol.ARRAY);
    766747        // Not reached.
    767748        return null;
     
    780761    catch (ClassCastException e)
    781762      {
    782         signalTypeError(obj, Symbol.VECTOR);
     763        type_error(obj, Symbol.VECTOR);
    783764        // Not reached.
    784765        return null;
     
    820801        else
    821802          Symbol.GENSYM_COUNTER.setSymbolValue(Fixnum.ZERO);
    822         signal(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
     803        error(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
    823804                             oldValue.writeToString() + " New value: 0"));
    824805      }
     
    839820    if (arg instanceof LispCharacter)
    840821      return String.valueOf(new char[] {((LispCharacter)arg).value});
    841     signalTypeError(arg, list4(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
     822    type_error(arg, list4(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
    842823                               Symbol.CHARACTER));
    843824    // Not reached.
     
    861842  {
    862843    if (denominator.signum() == 0)
    863       signal(new DivisionByZero());
     844      error(new DivisionByZero());
    864845    if (denominator.signum() < 0)
    865846      {
     
    897878    catch (ArithmeticException e)
    898879      {
    899         signal(new ArithmeticError("Division by zero."));
     880        error(new ArithmeticError("Division by zero."));
    900881        // Not reached.
    901882        return 0;
     
    10601041            catch (VerifyError e)
    10611042              {
    1062                 return signal(new LispError("Class verification failed: " +
     1043                return error(new LispError("Class verification failed: " +
    10631044                                            e.getMessage()));
    10641045              }
     
    10721053              }
    10731054          }
    1074         return signal(new LispError("Unable to load " + namestring));
     1055        return error(new LispError("Unable to load " + namestring));
    10751056      }
    10761057    Pathname pathname = new Pathname(namestring);
     
    10891070        catch (VerifyError e)
    10901071          {
    1091             return signal(new LispError("Class verification failed: " +
     1072            return error(new LispError("Class verification failed: " +
    10921073                                        e.getMessage()));
    10931074          }
     
    10961077            Debug.trace(t);
    10971078          }
    1098         return signal(new LispError("Unable to load " +
     1079        return error(new LispError("Unable to load " +
    10991080                                    pathname.writeToString()));
    11001081      }
     
    11141095                  return obj;
    11151096                Debug.trace("Unable to load " + namestring);
    1116                 return signal(new LispError("Unable to load " + namestring));
     1097                return error(new LispError("Unable to load " + namestring));
    11171098              }
    11181099          }
     
    11261107        Debug.trace(t);
    11271108      }
    1128     return signal(new FileError("File not found: " + namestring,
     1109    return error(new FileError("File not found: " + namestring,
    11291110                                new Pathname(namestring)));
    11301111  }
     
    13441325    catch (ClassCastException e)
    13451326      {
    1346         signalTypeError(obj, Symbol.FIXNUM);
     1327        type_error(obj, Symbol.FIXNUM);
    13471328        // Not reached.
    13481329        return 0;
     
    13661347    catch (ClassCastException e)
    13671348      {
    1368         signalTypeError(obj, Symbol.CHARACTER);
     1349        type_error(obj, Symbol.CHARACTER);
    13691350        // Not reached.
    13701351        return null;
     
    13831364    catch (ClassCastException e)
    13841365      {
    1385         signalTypeError(obj, Symbol.PACKAGE);
     1366        type_error(obj, Symbol.PACKAGE);
    13861367        // Not reached.
    13871368        return null;
     
    14001381    catch (ClassCastException e)
    14011382      {
    1402         signalTypeError(obj, Symbol.FUNCTION);
     1383        type_error(obj, Symbol.FUNCTION);
    14031384        // Not reached.
    14041385        return null;
     
    14171398    catch (ClassCastException e)
    14181399      {
    1419         signalTypeError(obj, Symbol.STREAM);
     1400        type_error(obj, Symbol.STREAM);
    14201401        // Not reached.
    14211402        return null;
     
    14331414        if (stream.isCharacterInputStream())
    14341415          return stream;
    1435         signal(new TypeError("The value " + obj.writeToString() +
     1416        error(new TypeError("The value " + obj.writeToString() +
    14361417                             " is not a character input stream."));
    14371418        // Not reached.
     
    14401421    catch (ClassCastException e)
    14411422      {
    1442         signalTypeError(obj, Symbol.STREAM);
     1423        type_error(obj, Symbol.STREAM);
    14431424        // Not reached.
    14441425        return null;
     
    14791460        if (stream.isBinaryInputStream())
    14801461          return stream;
    1481         signal(new TypeError("The value " + obj.writeToString() +
     1462        error(new TypeError("The value " + obj.writeToString() +
    14821463                             " is not a binary input stream."));
    14831464        // Not reached.
     
    14861467    catch (ClassCastException e)
    14871468      {
    1488         signalTypeError(obj, Symbol.STREAM);
     1469        type_error(obj, Symbol.STREAM);
    14891470        // Not reached.
    14901471        return null;
     
    15011482    if (obj == NIL)
    15021483      return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue());
    1503     signalTypeError(obj, Symbol.STREAM);
     1484    type_error(obj, Symbol.STREAM);
    15041485    // Not reached.
    15051486    return null;
     
    15101491  {
    15111492    if (n < 0 || n > 255)
    1512       signalTypeError(new Fixnum(n), UNSIGNED_BYTE_8);
     1493      type_error(new Fixnum(n), UNSIGNED_BYTE_8);
    15131494    try
    15141495      {
     
    15171498    catch (ClassCastException e)
    15181499      {
    1519         signalTypeError(obj, Symbol.STREAM);
     1500        type_error(obj, Symbol.STREAM);
    15201501      }
    15211502  }
     
    15321513    catch (ClassCastException e)
    15331514      {
    1534         signalTypeError(obj, Symbol.READTABLE);
     1515        type_error(obj, Symbol.READTABLE);
    15351516        // Not reached.
    15361517        return null;
     
    15511532    catch (ClassCastException e)
    15521533      {
    1553         signalTypeError(obj, Symbol.READTABLE);
     1534        type_error(obj, Symbol.READTABLE);
    15541535        // Not reached.
    15551536        return null;
     
    15681549    catch (ClassCastException e)
    15691550      {
    1570         signalTypeError(obj, Symbol.ENVIRONMENT);
     1551        type_error(obj, Symbol.ENVIRONMENT);
    15711552        // Not reached.
    15721553        return null;
     
    15861567        sb.append(length);
    15871568        sb.append('.');
    1588         signal(new TypeError(sb.toString()));
     1569        error(new TypeError(sb.toString()));
    15891570      }
    15901571  }
     
    16051586    else if (obj instanceof Cons && obj.car() == Symbol.LAMBDA)
    16061587      return new Closure(obj, new Environment());
    1607     signal(new UndefinedFunction(obj));
     1588    error(new UndefinedFunction(obj));
    16081589    // Not reached.
    16091590    return null;
     
    16191600    if (pkg != null)
    16201601      return pkg;
    1621     signal(new PackageError(obj.writeToString() + " is not the name of a package."));
     1602    error(new PackageError(obj.writeToString() + " is not the name of a package."));
    16221603    // Not reached.
    16231604    return null;
     
    16331614    if (arg instanceof FileStream)
    16341615      return ((FileStream)arg).getPathname();
    1635     signalTypeError(arg, list4(Symbol.OR, Symbol.PATHNAME,
     1616    type_error(arg, list4(Symbol.OR, Symbol.PATHNAME,
    16361617                               Symbol.STRING, Symbol.FILE_STREAM));
    16371618    // Not reached.
     
    16511632          }
    16521633        else if (entry != NIL)
    1653           return signalTypeError(entry, Symbol.LIST);
     1634          return type_error(entry, Symbol.LIST);
    16541635        alist = ((Cons)alist).cdr;
    16551636      }
    16561637    if (alist != NIL)
    1657       return signalTypeError(alist, Symbol.LIST);
     1638      return type_error(alist, Symbol.LIST);
    16581639    return NIL;
    16591640  }
     
    16691650      }
    16701651    if (list != NIL)
    1671       signalTypeError(list, Symbol.LIST);
     1652      type_error(list, Symbol.LIST);
    16721653    return false;
    16731654  }
     
    16831664      }
    16841665    if (list != NIL)
    1685       signalTypeError(list, Symbol.LIST);
     1666      type_error(list, Symbol.LIST);
    16861667    return false;
    16871668  }
     
    17001681          list = list.cddr();
    17011682        else
    1702           return signal(new TypeError("Malformed property list: " +
     1683          return error(new TypeError("Malformed property list: " +
    17031684                                      plist.writeToString()));
    17041685      }
     
    17161697    catch (ClassCastException e)
    17171698      {
    1718         return signalTypeError(symbol, Symbol.SYMBOL);
     1699        return type_error(symbol, Symbol.SYMBOL);
    17191700      }
    17201701    while (list != NIL)
     
    17381719    catch (ClassCastException e)
    17391720      {
    1740         return signalTypeError(symbol, Symbol.SYMBOL);
     1721        return type_error(symbol, Symbol.SYMBOL);
    17411722      }
    17421723    while (list != NIL)
     
    18001781      {
    18011782        if (!(list.cdr() instanceof Cons))
    1802           signal(new ProgramError("The symbol " + symbol.writeToString() +
     1783          error(new ProgramError("The symbol " + symbol.writeToString() +
    18031784                                  " has an odd number of items in its property list."));
    18041785        if (list.car() == indicator)
     
    19211902    Package pkg = Packages.findPackage(packageName);
    19221903    if (pkg == null)
    1923       signal(new LispError(packageName + " is not the name of a package."));
     1904      error(new LispError(packageName + " is not the name of a package."));
    19241905    return pkg.intern(name);
    19251906  }
  • trunk/j/src/org/armedbear/lisp/LispCharacter.java

    r11148 r11158  
    33 *
    44 * Copyright (C) 2002-2007 Peter Graves
    5  * $Id: LispCharacter.java,v 1.76 2007-02-21 21:19:11 piso Exp $
     5 * $Id: LispCharacter.java,v 1.77 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    160160    catch (ClassCastException e)
    161161      {
    162         signalTypeError(obj, Symbol.CHARACTER);
     162        type_error(obj, Symbol.CHARACTER);
    163163        // Not reached.
    164164        return 0;
     
    262262              return getInstance(name.charAt(0));
    263263          }
    264         return signalTypeError(arg, Symbol.CHARACTER_DESIGNATOR);
     264        return type_error(arg, Symbol.CHARACTER_DESIGNATOR);
    265265      }
    266266    };
     
    278278        catch (ClassCastException e)
    279279          {
    280             return signalTypeError(arg, Symbol.CHARACTER);
     280            return type_error(arg, Symbol.CHARACTER);
    281281          }
    282282      }
     
    296296        catch (ClassCastException e)
    297297          {
    298             return signalTypeError(arg, Symbol.CHARACTER);
     298            return type_error(arg, Symbol.CHARACTER);
    299299          }
    300300      }
     
    314314        catch (ClassCastException e)
    315315          {
    316             return signalTypeError(arg, Symbol.CHARACTER);
     316            return type_error(arg, Symbol.CHARACTER);
    317317          }
    318318      }
     
    397397        catch (ClassCastException e)
    398398          {
    399             return signalTypeError(arg, Symbol.CHARACTER);
     399            return type_error(arg, Symbol.CHARACTER);
    400400          }
    401401        if (c < 128)
     
    418418        catch (ClassCastException e)
    419419          {
    420             return signalTypeError(arg, Symbol.CHARACTER);
     420            return type_error(arg, Symbol.CHARACTER);
    421421          }
    422422        if (c < 128)
     
    441441            if (arg instanceof Bignum)
    442442              return NIL;
    443             return signalTypeError(arg, Symbol.INTEGER);
     443            return type_error(arg, Symbol.INTEGER);
    444444          }
    445445        if (weight < 10)
     
    460460          }
    461461        if (radix < 2 || radix > 36)
    462           return signalTypeError(second,
     462          return type_error(second,
    463463                                 list3(Symbol.INTEGER, Fixnum.TWO,
    464464                                       Fixnum.constants[36]));
     
    472472            if (first instanceof Bignum)
    473473              return NIL;
    474             return signalTypeError(first, Symbol.INTEGER);
     474            return type_error(first, Symbol.INTEGER);
    475475          }
    476476        if (weight >= radix)
     
    495495        catch (ClassCastException e)
    496496          {
    497             return signalTypeError(arg, Symbol.CHARACTER);
     497            return type_error(arg, Symbol.CHARACTER);
    498498          }
    499499      }
     
    508508        catch (ClassCastException e)
    509509          {
    510             return signalTypeError(first, Symbol.CHARACTER);
     510            return type_error(first, Symbol.CHARACTER);
    511511          }
    512512        try
     
    520520          }
    521521        catch (ClassCastException e) {}
    522         return signalTypeError(second,
     522        return type_error(second,
    523523                               list3(Symbol.INTEGER, Fixnum.TWO,
    524524                                     Fixnum.constants[36]));
     
    538538        catch (ClassCastException e)
    539539          {
    540             return signalTypeError(arg, Symbol.CHARACTER);
     540            return type_error(arg, Symbol.CHARACTER);
    541541          }
    542542      }
     
    558558        catch (ClassCastException e)
    559559          {
    560             return signalTypeError(arg, Symbol.CHARACTER);
     560            return type_error(arg, Symbol.CHARACTER);
    561561          }
    562562      }
     
    575575        catch (ClassCastException e)
    576576          {
    577             return signalTypeError(arg, Symbol.CHARACTER);
     577            return type_error(arg, Symbol.CHARACTER);
    578578          }
    579579      }
     
    592592        catch (ClassCastException e)
    593593          {
    594             return signalTypeError(arg, Symbol.CHARACTER);
     594            return type_error(arg, Symbol.CHARACTER);
    595595          }
    596596      }
  • trunk/j/src/org/armedbear/lisp/LispClass.java

    r10847 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispClass.java,v 1.72 2006-01-06 18:14:26 piso Exp $
     5 * $Id: LispClass.java,v 1.73 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6060    catch (ClassCastException e)
    6161      {
    62         return signalTypeError(name, Symbol.SYMBOL);
     62        return type_error(name, Symbol.SYMBOL);
    6363      }
    6464    final LispClass c;
     
    7575        sb.append(name.writeToString());
    7676        sb.append('.');
    77         return signal(new LispError(sb.toString()));
     77        return error(new LispError(sb.toString()));
    7878      }
    7979    return NIL;
     
    348348        catch (ClassCastException e)
    349349          {
    350             return signalTypeError(first, Symbol.SYMBOL);
     350            return type_error(first, Symbol.SYMBOL);
    351351          }
    352352        if (second == NIL)
     
    362362        catch (ClassCastException e)
    363363          {
    364             return signalTypeError(second, Symbol.CLASS);
     364            return type_error(second, Symbol.CLASS);
    365365          }
    366366        addClass(name, c);
     
    383383        catch (ClassCastException e)
    384384          {
    385             return signalTypeError(first, Symbol.CLASS);
     385            return type_error(first, Symbol.CLASS);
    386386          }
    387387        return c.subclassp(second) ? T : NIL;
  • trunk/j/src/org/armedbear/lisp/LispObject.java

    r11073 r11158  
    33 *
    44 * Copyright (C) 2002-2006 Peter Graves
    5  * $Id: LispObject.java,v 1.165 2006-06-20 15:52:10 piso Exp $
     5 * $Id: LispObject.java,v 1.166 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8686  public Object javaInstance() throws ConditionThrowable
    8787  {
    88     return signal(new LispError("The value " + writeToString() +
     88    return error(new LispError("The value " + writeToString() +
    8989                                " is not of primitive type."));
    9090  }
     
    9494    if (c == LispObject.class)
    9595      return this;
    96     return signal(new LispError("The value " + writeToString() +
     96    return error(new LispError("The value " + writeToString() +
    9797                                " is not of primitive type."));
    9898  }
     
    100100  public LispObject car() throws ConditionThrowable
    101101  {
    102     return signalTypeError(this, Symbol.LIST);
     102    return type_error(this, Symbol.LIST);
    103103  }
    104104
    105105  public void setCar(LispObject obj) throws ConditionThrowable
    106106  {
    107     signalTypeError(this, Symbol.CONS);
     107    type_error(this, Symbol.CONS);
    108108  }
    109109
    110110  public LispObject RPLACA(LispObject obj) throws ConditionThrowable
    111111  {
    112     return signalTypeError(this, Symbol.CONS);
     112    return type_error(this, Symbol.CONS);
    113113  }
    114114
    115115  public LispObject cdr() throws ConditionThrowable
    116116  {
    117     return signalTypeError(this, Symbol.LIST);
     117    return type_error(this, Symbol.LIST);
    118118  }
    119119
    120120  public void setCdr(LispObject obj) throws ConditionThrowable
    121121  {
    122     signalTypeError(this, Symbol.CONS);
     122    type_error(this, Symbol.CONS);
    123123  }
    124124
    125125  public LispObject RPLACD(LispObject obj) throws ConditionThrowable
    126126  {
    127     return signalTypeError(this, Symbol.CONS);
     127    return type_error(this, Symbol.CONS);
    128128  }
    129129
    130130  public LispObject cadr() throws ConditionThrowable
    131131  {
    132     return signalTypeError(this, Symbol.LIST);
     132    return type_error(this, Symbol.LIST);
    133133  }
    134134
    135135  public LispObject cddr() throws ConditionThrowable
    136136  {
    137     return signalTypeError(this, Symbol.LIST);
     137    return type_error(this, Symbol.LIST);
    138138  }
    139139
    140140  public LispObject caddr() throws ConditionThrowable
    141141  {
    142     return signalTypeError(this, Symbol.LIST);
     142    return type_error(this, Symbol.LIST);
    143143  }
    144144
     
    146146  {
    147147    if (n < 0)
    148       return signalTypeError(new Fixnum(n),
     148      return type_error(new Fixnum(n),
    149149                             list2(Symbol.INTEGER, Fixnum.ZERO));
    150     return signalTypeError(this, Symbol.LIST);
     150    return type_error(this, Symbol.LIST);
    151151  }
    152152
    153153  public LispObject push(LispObject obj) throws ConditionThrowable
    154154  {
    155     return signalTypeError(this, Symbol.LIST);
     155    return type_error(this, Symbol.LIST);
    156156  }
    157157
     
    208208  public LispObject ABS() throws ConditionThrowable
    209209  {
    210     return signalTypeError(this, Symbol.NUMBER);
     210    return type_error(this, Symbol.NUMBER);
    211211  }
    212212
    213213  public LispObject NUMERATOR() throws ConditionThrowable
    214214  {
    215     return signalTypeError(this, Symbol.RATIONAL);
     215    return type_error(this, Symbol.RATIONAL);
    216216  }
    217217
    218218  public LispObject DENOMINATOR() throws ConditionThrowable
    219219  {
    220     return signalTypeError(this, Symbol.RATIONAL);
     220    return type_error(this, Symbol.RATIONAL);
    221221  }
    222222
     
    228228  public boolean evenp() throws ConditionThrowable
    229229  {
    230     signalTypeError(this, Symbol.INTEGER);
     230    type_error(this, Symbol.INTEGER);
    231231    // Not reached.
    232232    return false;
     
    240240  public boolean oddp() throws ConditionThrowable
    241241  {
    242     signalTypeError(this, Symbol.INTEGER);
     242    type_error(this, Symbol.INTEGER);
    243243    // Not reached.
    244244    return false;
     
    252252  public boolean plusp() throws ConditionThrowable
    253253  {
    254     signalTypeError(this, Symbol.REAL);
     254    type_error(this, Symbol.REAL);
    255255    // Not reached.
    256256    return false;
     
    264264  public boolean minusp() throws ConditionThrowable
    265265  {
    266     signalTypeError(this, Symbol.REAL);
     266    type_error(this, Symbol.REAL);
    267267    // Not reached.
    268268    return false;
     
    286286  public boolean zerop() throws ConditionThrowable
    287287  {
    288     signalTypeError(this, Symbol.NUMBER);
     288    type_error(this, Symbol.NUMBER);
    289289    // Not reached.
    290290    return false;
     
    373373  public int length() throws ConditionThrowable
    374374  {
    375     signalTypeError(this, Symbol.SEQUENCE);
     375    type_error(this, Symbol.SEQUENCE);
    376376    // Not reached.
    377377    return 0;
     
    385385  public LispObject CHAR(int index) throws ConditionThrowable
    386386  {
    387     return signalTypeError(this, Symbol.STRING);
     387    return type_error(this, Symbol.STRING);
    388388  }
    389389
    390390  public LispObject SCHAR(int index) throws ConditionThrowable
    391391  {
    392     return signalTypeError(this, Symbol.SIMPLE_STRING);
     392    return type_error(this, Symbol.SIMPLE_STRING);
    393393  }
    394394
    395395  public LispObject NTH(int index) throws ConditionThrowable
    396396  {
    397     return signalTypeError(this, Symbol.LIST);
     397    return type_error(this, Symbol.LIST);
    398398  }
    399399
    400400  public LispObject NTH(LispObject arg) throws ConditionThrowable
    401401  {
    402     return signalTypeError(this, Symbol.LIST);
     402    return type_error(this, Symbol.LIST);
    403403  }
    404404
    405405  public LispObject elt(int index) throws ConditionThrowable
    406406  {
    407     return signalTypeError(this, Symbol.SEQUENCE);
     407    return type_error(this, Symbol.SEQUENCE);
    408408  }
    409409
    410410  public LispObject reverse() throws ConditionThrowable
    411411  {
    412     return signalTypeError(this, Symbol.SEQUENCE);
     412    return type_error(this, Symbol.SEQUENCE);
    413413  }
    414414
    415415  public LispObject nreverse() throws ConditionThrowable
    416416  {
    417     return signalTypeError(this, Symbol.SEQUENCE);
     417    return type_error(this, Symbol.SEQUENCE);
    418418  }
    419419
     
    430430  public LispObject AREF(int index) throws ConditionThrowable
    431431  {
    432     return signalTypeError(this, Symbol.ARRAY);
     432    return type_error(this, Symbol.ARRAY);
    433433  }
    434434
     
    441441    catch (ClassCastException e)
    442442      {
    443         return signalTypeError(index, Symbol.FIXNUM);
     443        return type_error(index, Symbol.FIXNUM);
    444444      }
    445445  }
     
    454454    throws ConditionThrowable
    455455  {
    456     signalTypeError(this, Symbol.ARRAY);
     456    type_error(this, Symbol.ARRAY);
    457457  }
    458458
     
    466466    catch (ClassCastException e)
    467467      {
    468         signalTypeError(index, Symbol.FIXNUM);
     468        type_error(index, Symbol.FIXNUM);
    469469      }
    470470  }
     
    472472  public LispObject SVREF(int index) throws ConditionThrowable
    473473  {
    474     return signalTypeError(this, Symbol.SIMPLE_VECTOR);
     474    return type_error(this, Symbol.SIMPLE_VECTOR);
    475475  }
    476476
    477477  public void svset(int index, LispObject newValue) throws ConditionThrowable
    478478  {
    479     signalTypeError(this, Symbol.SIMPLE_VECTOR);
     479    type_error(this, Symbol.SIMPLE_VECTOR);
    480480  }
    481481
     
    500500  public final LispObject noFillPointer() throws ConditionThrowable
    501501  {
    502     return signalTypeError(this, list3(Symbol.AND, Symbol.VECTOR,
     502    return type_error(this, list3(Symbol.AND, Symbol.VECTOR,
    503503                                       list2(Symbol.SATISFIES,
    504504                                             Symbol.ARRAY_HAS_FILL_POINTER_P)));
     
    507507  public LispObject[] copyToArray() throws ConditionThrowable
    508508  {
    509     signalTypeError(this, Symbol.LIST);
     509    type_error(this, Symbol.LIST);
    510510    // Not reached.
    511511    return null;
     
    529529  public boolean endp() throws ConditionThrowable
    530530  {
    531     signalTypeError(this, Symbol.LIST);
     531    type_error(this, Symbol.LIST);
    532532    // Not reached.
    533533    return false;
     
    536536  public LispObject ENDP() throws ConditionThrowable
    537537  {
    538     return signalTypeError(this, Symbol.LIST);
     538    return type_error(this, Symbol.LIST);
    539539  }
    540540
     
    546546  public boolean isSpecialOperator() throws ConditionThrowable
    547547  {
    548     signalTypeError(this, Symbol.SYMBOL);
     548    type_error(this, Symbol.SYMBOL);
    549549    // Not reached.
    550550    return false;
     
    601601  public LispObject getSymbolValue() throws ConditionThrowable
    602602  {
    603     return signalTypeError(this, Symbol.SYMBOL);
     603    return type_error(this, Symbol.SYMBOL);
    604604  }
    605605
    606606  public LispObject getSymbolFunction() throws ConditionThrowable
    607607  {
    608     return signalTypeError(this, Symbol.SYMBOL);
     608    return type_error(this, Symbol.SYMBOL);
    609609  }
    610610
    611611  public LispObject getSymbolFunctionOrDie() throws ConditionThrowable
    612612  {
    613     return signalTypeError(this, Symbol.SYMBOL);
     613    return type_error(this, Symbol.SYMBOL);
    614614  }
    615615
     
    643643    throws ConditionThrowable
    644644  {
    645     return signal(new LispError());
     645    return error(new LispError());
    646646  }
    647647
    648648  public LispObject execute() throws ConditionThrowable
    649649  {
    650     return signalTypeError(this, Symbol.FUNCTION);
     650    return type_error(this, Symbol.FUNCTION);
    651651  }
    652652
    653653  public LispObject execute(LispObject arg) throws ConditionThrowable
    654654  {
    655     return signalTypeError(this, Symbol.FUNCTION);
     655    return type_error(this, Symbol.FUNCTION);
    656656  }
    657657
     
    659659    throws ConditionThrowable
    660660  {
    661     return signalTypeError(this, Symbol.FUNCTION);
     661    return type_error(this, Symbol.FUNCTION);
    662662  }
    663663
     
    666666    throws ConditionThrowable
    667667  {
    668     return signalTypeError(this, Symbol.FUNCTION);
     668    return type_error(this, Symbol.FUNCTION);
    669669  }
    670670
     
    673673    throws ConditionThrowable
    674674  {
    675     return signalTypeError(this, Symbol.FUNCTION);
     675    return type_error(this, Symbol.FUNCTION);
    676676  }
    677677
     
    681681    throws ConditionThrowable
    682682  {
    683     return signalTypeError(this, Symbol.FUNCTION);
     683    return type_error(this, Symbol.FUNCTION);
    684684  }
    685685
     
    689689    throws ConditionThrowable
    690690  {
    691     return signalTypeError(this, Symbol.FUNCTION);
     691    return type_error(this, Symbol.FUNCTION);
    692692  }
    693693
     
    698698    throws ConditionThrowable
    699699  {
    700     return signalTypeError(this, Symbol.FUNCTION);
     700    return type_error(this, Symbol.FUNCTION);
    701701  }
    702702
     
    707707    throws ConditionThrowable
    708708  {
    709     return signalTypeError(this, Symbol.FUNCTION);
     709    return type_error(this, Symbol.FUNCTION);
    710710  }
    711711
    712712  public LispObject execute(LispObject[] args) throws ConditionThrowable
    713713  {
    714     return signalTypeError(this, Symbol.FUNCTION);
     714    return type_error(this, Symbol.FUNCTION);
    715715  }
    716716
     
    742742                       args[5], args[6], args[7]);
    743743      default:
    744         return signalTypeError(this, Symbol.FUNCTION);
     744        return type_error(this, Symbol.FUNCTION);
    745745      }
    746746  }
     
    748748  public int intValue() throws ConditionThrowable
    749749  {
    750     signalTypeError(this, Symbol.INTEGER);
     750    type_error(this, Symbol.INTEGER);
    751751    // Not reached.
    752752    return 0;
     
    755755  public long longValue() throws ConditionThrowable
    756756  {
    757     signalTypeError(this, Symbol.INTEGER);
     757    type_error(this, Symbol.INTEGER);
    758758    // Not reached.
    759759    return 0;
     
    762762  public LispObject incr() throws ConditionThrowable
    763763  {
    764     return signalTypeError(this, Symbol.NUMBER);
     764    return type_error(this, Symbol.NUMBER);
    765765  }
    766766
    767767  public LispObject decr() throws ConditionThrowable
    768768  {
    769     return signalTypeError(this, Symbol.NUMBER);
     769    return type_error(this, Symbol.NUMBER);
    770770  }
    771771
     
    782782  public LispObject add(LispObject obj) throws ConditionThrowable
    783783  {
    784     return signalTypeError(this, Symbol.NUMBER);
     784    return type_error(this, Symbol.NUMBER);
    785785  }
    786786
     
    792792  public LispObject subtract(LispObject obj) throws ConditionThrowable
    793793  {
    794     return signalTypeError(this, Symbol.NUMBER);
     794    return type_error(this, Symbol.NUMBER);
    795795  }
    796796
     
    802802  public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
    803803  {
    804     return signalTypeError(this, Symbol.NUMBER);
     804    return type_error(this, Symbol.NUMBER);
    805805  }
    806806
    807807  public LispObject divideBy(LispObject obj) throws ConditionThrowable
    808808  {
    809     return signalTypeError(this, Symbol.NUMBER);
     809    return type_error(this, Symbol.NUMBER);
    810810  }
    811811
     
    817817  public boolean isEqualTo(LispObject obj) throws ConditionThrowable
    818818  {
    819     signalTypeError(this, Symbol.NUMBER);
     819    type_error(this, Symbol.NUMBER);
    820820    // Not reached.
    821821    return false;
     
    834834  public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
    835835  {
    836     signalTypeError(this, Symbol.NUMBER);
     836    type_error(this, Symbol.NUMBER);
    837837    // Not reached.
    838838    return false;
     
    851851  public boolean isLessThan(LispObject obj) throws ConditionThrowable
    852852  {
    853     signalTypeError(this, Symbol.REAL);
     853    type_error(this, Symbol.REAL);
    854854    // Not reached.
    855855    return false;
     
    868868  public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
    869869  {
    870     signalTypeError(this, Symbol.REAL);
     870    type_error(this, Symbol.REAL);
    871871    // Not reached.
    872872    return false;
     
    885885  public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
    886886  {
    887     signalTypeError(this, Symbol.REAL);
     887    type_error(this, Symbol.REAL);
    888888    // Not reached.
    889889    return false;
     
    902902  public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
    903903  {
    904     signalTypeError(this, Symbol.REAL);
     904    type_error(this, Symbol.REAL);
    905905    // Not reached.
    906906    return false;
     
    914914  public LispObject truncate(LispObject obj) throws ConditionThrowable
    915915  {
    916     return signalTypeError(this, Symbol.REAL);
     916    return type_error(this, Symbol.REAL);
    917917  }
    918918
     
    951951  public LispObject ash(LispObject obj) throws ConditionThrowable
    952952  {
    953     return signalTypeError(this, Symbol.INTEGER);
     953    return type_error(this, Symbol.INTEGER);
    954954  }
    955955
    956956  public LispObject LOGNOT() throws ConditionThrowable
    957957  {
    958     return signalTypeError(this, Symbol.INTEGER);
     958    return type_error(this, Symbol.INTEGER);
    959959  }
    960960
     
    966966  public LispObject LOGAND(LispObject obj) throws ConditionThrowable
    967967  {
    968     return signalTypeError(this, Symbol.INTEGER);
     968    return type_error(this, Symbol.INTEGER);
    969969  }
    970970
     
    976976  public LispObject LOGIOR(LispObject obj) throws ConditionThrowable
    977977  {
    978     return signalTypeError(this, Symbol.INTEGER);
     978    return type_error(this, Symbol.INTEGER);
    979979  }
    980980
     
    986986  public LispObject LOGXOR(LispObject obj) throws ConditionThrowable
    987987  {
    988     return signalTypeError(this, Symbol.INTEGER);
     988    return type_error(this, Symbol.INTEGER);
    989989  }
    990990
    991991  public LispObject LDB(int size, int position) throws ConditionThrowable
    992992  {
    993     return signalTypeError(this, Symbol.INTEGER);
     993    return type_error(this, Symbol.INTEGER);
    994994  }
    995995
     
    10121012  public LispObject STRING() throws ConditionThrowable
    10131013  {
    1014     return signal(new TypeError(writeToString() + " cannot be coerced to a string."));
     1014    return error(new TypeError(writeToString() + " cannot be coerced to a string."));
    10151015  }
    10161016
    10171017  public char[] chars() throws ConditionThrowable
    10181018  {
    1019     signal(new TypeError(this, Symbol.STRING));
     1019    error(new TypeError(this, Symbol.STRING));
    10201020    // Not reached.
    10211021    return null;
     
    10241024  public char[] getStringChars() throws ConditionThrowable
    10251025  {
    1026     signalTypeError(this, Symbol.STRING);
     1026    type_error(this, Symbol.STRING);
    10271027    // Not reached.
    10281028    return null;
     
    10311031  public String getStringValue() throws ConditionThrowable
    10321032  {
    1033     signalTypeError(this, Symbol.STRING);
     1033    type_error(this, Symbol.STRING);
    10341034    // Not reached.
    10351035    return null;
     
    10381038  public LispObject getSlotValue_0() throws ConditionThrowable
    10391039  {
    1040     return signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1040    return type_error(this, Symbol.STRUCTURE_OBJECT);
    10411041  }
    10421042
    10431043  public LispObject getSlotValue_1() throws ConditionThrowable
    10441044  {
    1045     return signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1045    return type_error(this, Symbol.STRUCTURE_OBJECT);
    10461046  }
    10471047
    10481048  public LispObject getSlotValue_2() throws ConditionThrowable
    10491049  {
    1050     return signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1050    return type_error(this, Symbol.STRUCTURE_OBJECT);
    10511051  }
    10521052
    10531053  public LispObject getSlotValue_3() throws ConditionThrowable
    10541054  {
    1055     return signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1055    return type_error(this, Symbol.STRUCTURE_OBJECT);
    10561056  }
    10571057
    10581058  public LispObject getSlotValue(int index) throws ConditionThrowable
    10591059  {
    1060     return signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1060    return type_error(this, Symbol.STRUCTURE_OBJECT);
    10611061  }
    10621062
    10631063  public int getFixnumSlotValue(int index) throws ConditionThrowable
    10641064  {
    1065     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1065    type_error(this, Symbol.STRUCTURE_OBJECT);
    10661066    // Not reached.
    10671067    return 0;
     
    10701070  public boolean getSlotValueAsBoolean(int index) throws ConditionThrowable
    10711071  {
    1072     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1072    type_error(this, Symbol.STRUCTURE_OBJECT);
    10731073    // Not reached.
    10741074    return false;
     
    10781078    throws ConditionThrowable
    10791079  {
    1080     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1080    type_error(this, Symbol.STRUCTURE_OBJECT);
    10811081  }
    10821082
     
    10841084    throws ConditionThrowable
    10851085  {
    1086     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1086    type_error(this, Symbol.STRUCTURE_OBJECT);
    10871087  }
    10881088
     
    10901090    throws ConditionThrowable
    10911091  {
    1092     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1092    type_error(this, Symbol.STRUCTURE_OBJECT);
    10931093  }
    10941094
     
    10961096    throws ConditionThrowable
    10971097  {
    1098     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1098    type_error(this, Symbol.STRUCTURE_OBJECT);
    10991099  }
    11001100
     
    11021102    throws ConditionThrowable
    11031103  {
    1104     signalTypeError(this, Symbol.STRUCTURE_OBJECT);
     1104    type_error(this, Symbol.STRUCTURE_OBJECT);
    11051105  }
    11061106
    11071107  public LispObject SLOT_VALUE(LispObject slotName) throws ConditionThrowable
    11081108  {
    1109     return signalTypeError(this, Symbol.STANDARD_OBJECT);
     1109    return type_error(this, Symbol.STANDARD_OBJECT);
    11101110  }
    11111111
     
    11131113    throws ConditionThrowable
    11141114  {
    1115     signalTypeError(this, Symbol.STANDARD_OBJECT);
     1115    type_error(this, Symbol.STANDARD_OBJECT);
    11161116  }
    11171117
  • trunk/j/src/org/armedbear/lisp/LispReader.java

    r11150 r11158  
    33 *
    44 * Copyright (C) 2004-2007 Peter Graves
    5  * $Id: LispReader.java,v 1.46 2007-02-22 16:03:48 piso Exp $
     5 * $Id: LispReader.java,v 1.47 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5656                int n = stream._readChar();
    5757                if (n < 0) {
    58                     signal(new EndOfFile(stream));
     58                    error(new EndOfFile(stream));
    5959                    // Not reached.
    6060                    return null;
     
    6565                    n = stream._readChar();
    6666                    if (n < 0) {
    67                         signal(new EndOfFile(stream));
     67                        error(new EndOfFile(stream));
    6868                        // Not reached.
    6969                        return null;
     
    7676                        n = stream._readChar();
    7777                        if (n < 0) {
    78                             signal(new EndOfFile(stream));
     78                            error(new EndOfFile(stream));
    7979                            // Not reached.
    8080                            return null;
     
    119119            throws ConditionThrowable
    120120        {
    121             return signal(new ReaderError("Unmatched right parenthesis.", stream));
     121            return error(new ReaderError("Unmatched right parenthesis.", stream));
    122122        }
    123123    };
     
    204204                        if (name == null)
    205205                            name = "#\\" + c;
    206                         signal(new ReaderError("Illegal element for bit-vector: " + name,
     206                        error(new ReaderError("Illegal element for bit-vector: " + name,
    207207                                               stream));
    208208                    }
     
    216216                if (length == 0) {
    217217                    if (n > 0)
    218                         return signal(new ReaderError("No element specified for bit vector of length " +
     218                        return error(new ReaderError("No element specified for bit vector of length " +
    219219                                                      n + '.',
    220220                                                      stream));
     
    225225                        sb.append(c);
    226226                } else if (n < length) {
    227                     return signal(new ReaderError("Bit vector is longer than specified length: #" +
     227                    return error(new ReaderError("Bit vector is longer than specified length: #" +
    228228                                                  n + '*' + sb.toString(),
    229229                                                  stream));
     
    244244            final LispThread thread = LispThread.currentThread();
    245245            if (Symbol.READ_EVAL.symbolValue(thread) == NIL)
    246                 return signal(new ReaderError("Can't read #. when *READ-EVAL* is NIL.",
     246                return error(new ReaderError("Can't read #. when *READ-EVAL* is NIL.",
    247247                                              stream));
    248248            else
     
    415415            else
    416416                sb.append(c);
    417             return signal(new ReaderError(sb.toString(), stream));
     417            return error(new ReaderError(sb.toString(), stream));
    418418        }
    419419    };
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r11126 r11158  
    33 *
    44 * Copyright (C) 2003-2007 Peter Graves
    5  * $Id: LispThread.java,v 1.91 2007-01-22 16:35:32 piso Exp $
     5 * $Id: LispThread.java,v 1.92 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    386386            return newValue;
    387387        } else
    388             return signal(new UnboundVariable(name));
     388            return error(new UnboundVariable(name));
    389389    }
    390390
     
    432432            rest = rest.cdr();
    433433        }
    434         signal(new ControlError("Attempt to throw to the nonexistent tag " +
     434        error(new ControlError("Attempt to throw to the nonexistent tag " +
    435435                                tag.writeToString() + "."));
    436436    }
     
    998998            final int length = args.length;
    999999            if (length == 0)
    1000                 signal(new WrongNumberOfArgumentsException(this));
     1000                error(new WrongNumberOfArgumentsException(this));
    10011001            LispObject name = NIL;
    10021002            if (length > 1) {
    10031003                if ((length - 1) % 2 != 0)
    1004                     signal(new ProgramError("Odd number of keyword arguments."));
     1004                    error(new ProgramError("Odd number of keyword arguments."));
    10051005                if (length > 3)
    1006                     signal(new WrongNumberOfArgumentsException(this));
     1006                    error(new WrongNumberOfArgumentsException(this));
    10071007                if (args[1] == Keyword.NAME)
    10081008                    name = args[2].STRING();
    10091009                else
    1010                     signal(new ProgramError("Unrecognized keyword argument " +
     1010                    error(new ProgramError("Unrecognized keyword argument " +
    10111011                                            args[1].writeToString() + "."));
    10121012            }
     
    10361036            }
    10371037            catch (ClassCastException e) {
    1038                 return signalTypeError(arg, Symbol.THREAD);
     1038                return type_error(arg, Symbol.THREAD);
    10391039            }
    10401040            return lispThread.javaThread.isAlive() ? T : NIL;
     
    10521052            }
    10531053            catch (ClassCastException e) {
    1054                 return signalTypeError(arg, Symbol.THREAD);
     1054                return type_error(arg, Symbol.THREAD);
    10551055            }
    10561056        }
     
    10651065                ((DoubleFloat)arg.multiplyBy(new DoubleFloat(1000))).getValue();
    10661066            if (d < 0)
    1067                 return signalTypeError(arg, list2(Symbol.REAL, Fixnum.ZERO));
     1067                return type_error(arg, list2(Symbol.REAL, Fixnum.ZERO));
    10681068            long millis = d < Long.MAX_VALUE ? (long) d : Long.MAX_VALUE;
    10691069            try {
     
    11071107            }
    11081108            catch (ClassCastException e) {
    1109                 return signalTypeError(arg, Symbol.THREAD);
     1109                return type_error(arg, Symbol.THREAD);
    11101110            }
    11111111            thread.setDestroyed(true);
     
    11251125        {
    11261126            if (args.length < 2)
    1127                 return signal(new WrongNumberOfArgumentsException(this));
     1127                return error(new WrongNumberOfArgumentsException(this));
    11281128            final LispThread thread;
    11291129            try {
     
    11311131            }
    11321132            catch (ClassCastException e) {
    1133                 return signalTypeError(args[0], Symbol.THREAD);
     1133                return type_error(args[0], Symbol.THREAD);
    11341134            }
    11351135            LispObject fun = args[1];
     
    11601160        {
    11611161            if (args.length > 1)
    1162                 return signal(new WrongNumberOfArgumentsException(this));
     1162                return error(new WrongNumberOfArgumentsException(this));
    11631163            int limit = args.length > 0 ? Fixnum.getValue(args[0]) : 0;
    11641164            return currentThread().backtraceAsList(limit);
  • trunk/j/src/org/armedbear/lisp/Load.java

    r11150 r11158  
    33 *
    44 * Copyright (C) 2002-2007 Peter Graves
    5  * $Id: Load.java,v 1.129 2007-02-22 16:03:48 piso Exp $
     5 * $Id: Load.java,v 1.130 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8686        if (!isFile) {
    8787            if (ifDoesNotExist)
    88                 return signal(new FileError("File not found: " + filename,
     88                return error(new FileError("File not found: " + filename,
    8989                                            pathname));
    9090            else
     
    114114                }
    115115                catch (IOException e) {
    116                     return signal(new LispError(e.getMessage()));
     116                    return error(new LispError(e.getMessage()));
    117117                }
    118118            }
     
    124124            catch (FileNotFoundException e) {
    125125                if (ifDoesNotExist)
    126                     return signal(new FileError("File not found: " + filename,
     126                    return error(new FileError("File not found: " + filename,
    127127                                                pathname));
    128128                else
     
    130130            }
    131131            catch (IOException e) {
    132                 return signal(new LispError(e.getMessage()));
     132                return error(new LispError(e.getMessage()));
    133133            }
    134134        }
     
    142142                new FastStringBuffer("Incorrect fasl version: ");
    143143            sb.append(truename);
    144             return signal(new SimpleError(sb.toString()));
     144            return error(new SimpleError(sb.toString()));
    145145        }
    146146        finally {
     
    150150                }
    151151                catch (IOException e) {
    152                     return signal(new LispError(e.getMessage()));
     152                    return error(new LispError(e.getMessage()));
    153153                }
    154154            }
     
    158158                }
    159159                catch (IOException e) {
    160                     return signal(new LispError(e.getMessage()));
     160                    return error(new LispError(e.getMessage()));
    161161                }
    162162            }
     
    302302                        }
    303303                        catch (IOException e) {
    304                             return signal(new LispError(e.getMessage()));
     304                            return error(new LispError(e.getMessage()));
    305305                        }
    306306                    }
     
    313313                    }
    314314                    catch (IOException e) {
    315                         return signal(new LispError(e.getMessage()));
    316                     }
    317                 }
    318             }
    319         }
    320         return signal(new LispError("File not found: " + filename));
     315                        return error(new LispError(e.getMessage()));
     316                    }
     317                }
     318            }
     319        }
     320        return error(new LispError("File not found: " + filename));
    321321    }
    322322
  • trunk/j/src/org/armedbear/lisp/LogicalPathname.java

    r10209 r11158  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: LogicalPathname.java,v 1.22 2005-10-23 18:11:10 piso Exp $
     5 * $Id: LogicalPathname.java,v 1.23 2007-02-23 21:17:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4242            char c = rest.charAt(i);
    4343            if (LOGICAL_PATHNAME_CHARS.indexOf(c) < 0) {
    44                 signal(new ParseError("The character #\\" + c + " is not valid in a logical pathname."));
     44                error(new ParseError("The character #\\" + c + " is not valid in a logical pathname."));
    4545                return;
    4646            }
     
    115115            char c = s.charAt(i);
    116116            if (LOGICAL_PATHNAME_COMPONENT_CHARS.indexOf(c) < 0) {
    117                 signal(new ParseError("Invalid character #\\" + c +
     117                error(new ParseError("Invalid character #\\" + c +
    118118                                      " in logical pathname component \"" + s +
    119119                                      '"'));
     
    195195                sb.append(';');
    196196            else
    197                 signal(new FileError("Unsupported directory component " + part.writeToString() + ".",
     197                error(new FileError("Unsupported directory component " + part.writeToString() + ".",
    198198                                     this));
    199199            temp = temp.cdr();
     
    209209                    sb.append("..");
    210210                else
    211                     signal(new FileError("Unsupported directory component " + part.writeToString() + ".",
     211                    error(new FileError("Unsupported directory component " + part.writeToString() + ".",
    212212                                         this));
    213213                sb.append(';');
     
    272272                    // "The null string, "", is not a valid value for any
    273273                    // component of a logical pathname." 19.3.2.2
    274                     return signal(new LispError("Invalid logical host name: \"" +
     274                    return error(new LispError("Invalid logical host name: \"" +
    275275                                                s.getStringValue() + '"'));
    276276                }
     
    278278            }
    279279            catch (ClassCastException e) {
    280                 return signalTypeError(arg, Symbol.STRING);
     280                return type_error(arg, Symbol.STRING);
    281281            }
    282282        }
     
    297297                    // "The null string, "", is not a valid value for any
    298298                    // component of a logical pathname." 19.3.2.2
    299                     return signal(new LispError("Invalid logical host name: \"" +
     299                    return error(new LispError("Invalid logical host name: \"" +
    300300                                                h + '"'));
    301301                }
     
    305305                }
    306306            }
    307             return signal(new TypeError("Logical namestring does not specify a host: \"" + s + '"'));
     307            return error(new TypeError("Logical namestring does not specify a host: \"" + s + '"'));
    308308        }
    309309    };
  • trunk/j/src/org/armedbear/lisp/MacroObject.java

    r10739 r11158  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: MacroObject.java,v 1.15 2005-12-24 16:31:51 piso Exp $
     5 * $Id: MacroObject.java,v 1.16 2007-02-23 21:17:34 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3838  public LispObject execute() throws ConditionThrowable
    3939  {
    40     return signal(new UndefinedFunction(name));
     40    return error(new UndefinedFunction(name));
    4141  }
    4242
    4343  public LispObject execute(LispObject arg) throws ConditionThrowable
    4444  {
    45     return signal(new UndefinedFunction(name));
     45    return error(new UndefinedFunction(name));
    4646  }
    4747
     
    4949    throws ConditionThrowable
    5050  {
    51     return signal(new UndefinedFunction(name));
     51    return error(new UndefinedFunction(name));
    5252  }
    5353
     
    5656    throws ConditionThrowable
    5757  {
    58     return signal(new UndefinedFunction(name));
     58    return error(new UndefinedFunction(name));