Changeset 3871


Ignore:
Timestamp:
09/19/03 00:06:15 (19 years ago)
Author:
piso
Message:

Condition.java => ConditionThrowable?.java

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

Legend:

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

    r3827 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Autoload.java,v 1.66 2003-09-16 17:41:35 piso Exp $
     5 * $Id: Autoload.java,v 1.67 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6262    }
    6363
    64     public void load() throws Condition
     64    public void load() throws ConditionThrowable
    6565    {
    6666        if (className != null) {
     
    159159        new Primitive1("resolve", PACKAGE_SYS, false)
    160160    {
    161         public LispObject execute(LispObject arg) throws Condition
     161        public LispObject execute(LispObject arg) throws ConditionThrowable
    162162        {
    163163            Symbol symbol = checkSymbol(arg);
  • trunk/j/src/org/armedbear/lisp/AutoloadMacro.java

    r3814 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: AutoloadMacro.java,v 1.1 2003-09-16 16:16:42 piso Exp $
     5 * $Id: AutoloadMacro.java,v 1.2 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3434    }
    3535
    36     public void load() throws Condition
     36    public void load() throws ConditionThrowable
    3737    {
    3838        Load._load(getFileName(), true, false);
  • trunk/j/src/org/armedbear/lisp/Bignum.java

    r3859 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Bignum.java,v 1.41 2003-09-17 19:19:52 piso Exp $
     5 * $Id: Bignum.java,v 1.42 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    368368    }
    369369
    370     public LispObject truncate(LispObject obj) throws Condition
     370    public LispObject truncate(LispObject obj) throws ConditionThrowable
    371371    {
    372372        final LispThread thread = LispThread.currentThread();
  • trunk/j/src/org/armedbear/lisp/CharacterInputStream.java

    r3642 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterInputStream.java,v 1.45 2003-09-10 00:42:14 piso Exp $
     5 * $Id: CharacterInputStream.java,v 1.46 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6161
    6262    public LispObject read(boolean eofError, LispObject eofValue,
    63         boolean recursive) throws Condition
     63        boolean recursive) throws ConditionThrowable
    6464    {
    6565        try {
     
    8484
    8585    public LispObject readPreservingWhitespace(boolean eofError,
    86         LispObject eofValue, boolean recursive) throws Condition
     86        LispObject eofValue, boolean recursive) throws ConditionThrowable
    8787    {
    8888        while (true) {
     
    109109    }
    110110
    111     private LispObject processChar(char c) throws Condition
     111    private LispObject processChar(char c) throws ConditionThrowable
    112112    {
    113113        switch (c) {
     
    166166    }
    167167
    168     private LispObject readQuote() throws Condition
     168    private LispObject readQuote() throws ConditionThrowable
    169169    {
    170170        return new Cons(Symbol.QUOTE, new Cons(read(true, NIL, true)));
    171171    }
    172172
    173     private LispObject readList() throws Condition
     173    private LispObject readList() throws ConditionThrowable
    174174    {
    175175        try {
     
    254254    }
    255255
    256     private LispObject readComma() throws Condition
     256    private LispObject readComma() throws ConditionThrowable
    257257    {
    258258        try {
     
    279279    }
    280280
    281     private LispObject readBackquote() throws Condition
     281    private LispObject readBackquote() throws ConditionThrowable
    282282    {
    283283        return new Cons(Symbol.BACKQUOTE, new Cons(read(true, NIL, true)));
    284284    }
    285285
    286     private LispObject readSharp() throws Condition
     286    private LispObject readSharp() throws ConditionThrowable
    287287    {
    288288        try {
     
    358358    }
    359359
    360     private LispObject readCharacterLiteral() throws Condition
     360    private LispObject readCharacterLiteral() throws ConditionThrowable
    361361    {
    362362        try {
     
    394394
    395395    // FIXME
    396     private LispObject handleFeature(char c) throws Condition
     396    private LispObject handleFeature(char c) throws ConditionThrowable
    397397    {
    398398        LispObject feature = read(true, NIL, true);
     
    505505    }
    506506
    507     private LispObject readArray(int rank) throws Condition
     507    private LispObject readArray(int rank) throws ConditionThrowable
    508508    {
    509509        LispObject obj = read(true, NIL, true);
     
    513513    }
    514514
    515     private LispObject readComplex() throws Condition
     515    private LispObject readComplex() throws ConditionThrowable
    516516    {
    517517        LispObject obj = read(true, NIL, true);
     
    521521    }
    522522
    523     private String readMultipleEscape() throws Condition
     523    private String readMultipleEscape() throws ConditionThrowable
    524524    {
    525525        try {
     
    541541    }
    542542
    543     private LispObject readKeyword() throws Condition
     543    private LispObject readKeyword() throws ConditionThrowable
    544544    {
    545545        try {
  • trunk/j/src/org/armedbear/lisp/Closure.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Closure.java,v 1.53 2003-09-14 17:36:11 piso Exp $
     5 * $Id: Closure.java,v 1.54 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    299299    }
    300300
    301     public LispObject execute() throws Condition
     301    public LispObject execute() throws ConditionThrowable
    302302    {
    303303        if (arity == 0) {
     
    314314    }
    315315
    316     public LispObject execute(LispObject arg) throws Condition
     316    public LispObject execute(LispObject arg) throws ConditionThrowable
    317317    {
    318318        if (minArgs == 1) {
     
    347347
    348348    public LispObject execute(LispObject first, LispObject second)
    349         throws Condition
     349        throws ConditionThrowable
    350350    {
    351351        if (minArgs == 2) {
     
    383383    public LispObject execute(LispObject first, LispObject second,
    384384                              LispObject third)
    385         throws Condition
     385        throws ConditionThrowable
    386386    {
    387387        if (minArgs == 3) {
     
    420420
    421421    public LispObject execute(LispObject args, Environment env)
    422         throws Condition
     422        throws ConditionThrowable
    423423    {
    424424        LispObject array[] = new LispObject[2];
     
    428428    }
    429429
    430     public LispObject execute(LispObject[] args) throws Condition
     430    public LispObject execute(LispObject[] args) throws ConditionThrowable
    431431    {
    432432        final LispThread thread = LispThread.currentThread();
     
    449449    }
    450450
    451     protected LispObject[] processArgs(LispObject[] args) throws Condition
     451    protected LispObject[] processArgs(LispObject[] args) throws ConditionThrowable
    452452    {
    453453        final LispThread thread = LispThread.currentThread();
     
    609609    private final void bindOptionalParameterDefaults(Environment env,
    610610                                                     LispThread thread)
    611         throws Condition
     611        throws ConditionThrowable
    612612    {
    613613        for (int i = 0; i < optionalParameters.length; i++) {
     
    624624    private final void bindKeywordParameterDefaults(Environment env,
    625625                                                    LispThread thread)
    626         throws Condition
     626        throws ConditionThrowable
    627627    {
    628628        for (int i = 0; i < keywordParameters.length; i++) {
     
    638638
    639639    private final void bindAuxVars(Environment env, LispThread thread)
    640         throws Condition
     640        throws ConditionThrowable
    641641    {
    642642        // Aux variable processing is analogous to LET* processing.
  • trunk/j/src/org/armedbear/lisp/CompiledFunction.java

    r3864 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CompiledFunction.java,v 1.9 2003-09-18 13:11:26 piso Exp $
     5 * $Id: CompiledFunction.java,v 1.10 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3838    }
    3939
    40     public LispObject execute(LispObject arg) throws Condition
     40    public LispObject execute(LispObject arg) throws ConditionThrowable
    4141    {
    4242        LispObject[] args = new LispObject[1];
     
    4646
    4747    public LispObject execute(LispObject first, LispObject second)
    48         throws Condition
     48        throws ConditionThrowable
    4949    {
    5050        LispObject[] args = new LispObject[2];
     
    5656    public LispObject execute(LispObject first, LispObject second,
    5757                              LispObject third)
    58         throws Condition
     58        throws ConditionThrowable
    5959    {
    6060        LispObject[] args = new LispObject[3];
     
    6565    }
    6666
    67     public LispObject execute(LispObject[] args) throws Condition
     67    public LispObject execute(LispObject[] args) throws ConditionThrowable
    6868    {
    6969        throw new LispError("not implemented");
  • trunk/j/src/org/armedbear/lisp/Extensions.java

    r3509 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Extensions.java,v 1.7 2003-08-25 17:36:42 piso Exp $
     5 * $Id: Extensions.java,v 1.8 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2929    private static final Primitive1 SPECIAL_VARIABLE_P =
    3030        new Primitive1("special-variable-p", PACKAGE_EXT, true) {
    31         public LispObject execute(LispObject arg) throws Condition
     31        public LispObject execute(LispObject arg) throws ConditionThrowable
    3232        {
    3333            return arg.isSpecialVariable() ? T : NIL;
     
    3838    private static final Primitive1 CHARPOS =
    3939        new Primitive1("charpos", PACKAGE_EXT, true) {
    40         public LispObject execute(LispObject arg) throws Condition
     40        public LispObject execute(LispObject arg) throws ConditionThrowable
    4141        {
    4242            if (arg instanceof CharacterOutputStream)
  • trunk/j/src/org/armedbear/lisp/Fixnum.java

    r3859 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Fixnum.java,v 1.68 2003-09-17 19:20:24 piso Exp $
     5 * $Id: Fixnum.java,v 1.69 2003-09-19 00:05:09 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    440440    }
    441441
    442     public LispObject truncate(LispObject obj) throws Condition
     442    public LispObject truncate(LispObject obj) throws ConditionThrowable
    443443    {
    444444        final LispThread thread = LispThread.currentThread();
  • trunk/j/src/org/armedbear/lisp/Function.java

    r3841 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Function.java,v 1.21 2003-09-17 15:00:45 piso Exp $
     5 * $Id: Function.java,v 1.22 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    134134
    135135    // Primitive
    136     public LispObject execute(LispObject[] args) throws Condition
     136    public LispObject execute(LispObject[] args) throws ConditionThrowable
    137137    {
    138138        if (module != null)
     
    142142
    143143    // Primitive1
    144     public LispObject execute(LispObject arg) throws Condition
     144    public LispObject execute(LispObject arg) throws ConditionThrowable
    145145    {
    146146        if (module != null)
     
    153153    // Primitive2
    154154    public LispObject execute(LispObject first, LispObject second)
    155         throws Condition
     155        throws ConditionThrowable
    156156    {
    157157        if (module != null)
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r3868 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Interpreter.java,v 1.30 2003-09-18 18:56:25 piso Exp $
     5 * $Id: Interpreter.java,v 1.31 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    208208                    out.writeLine("Stack overflow");
    209209                }
    210                 catch (Condition c) {
     210                catch (ConditionThrowable c) {
    211211                    getStandardInput().clearInput();
    212212                    String message = c.getMessage();
     
    277277    }
    278278
    279     private static boolean doCommand(String s) throws Condition
     279    private static boolean doCommand(String s) throws ConditionThrowable
    280280    {
    281281        s = s.trim();
     
    524524
    525525    // Used only by org.armedbear.j.Editor.executeCommand().
    526     public static LispObject evaluate(String s) throws Condition
     526    public static LispObject evaluate(String s) throws ConditionThrowable
    527527    {
    528528        if (!initialized)
  • trunk/j/src/org/armedbear/lisp/JavaObject.java

    r2751 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: JavaObject.java,v 1.6 2003-07-03 18:06:57 piso Exp $
     5 * $Id: JavaObject.java,v 1.7 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4949    public String toString()
    5050    {
    51         if (obj instanceof Condition)
     51        if (obj instanceof ConditionThrowable)
    5252            return obj.toString();
    5353
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r3817 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Lisp.java,v 1.132 2003-09-16 16:26:32 piso Exp $
     5 * $Id: Lisp.java,v 1.133 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7474    // argv must not be null!
    7575    public static final LispObject funcall(LispObject fun, LispObject[] argv,
    76         LispThread thread) throws Condition
     76        LispThread thread) throws ConditionThrowable
    7777    {
    7878        if (fun instanceof Autoload) {
     
    110110
    111111    public static final LispObject funcall0(LispObject fun, LispThread thread)
    112         throws Condition
     112        throws ConditionThrowable
    113113    {
    114114        if (fun instanceof Autoload) {
     
    132132
    133133    public static final LispObject funcall1(LispObject fun, LispObject arg,
    134         LispThread thread) throws Condition
     134        LispThread thread) throws ConditionThrowable
    135135    {
    136136        if (fun instanceof Autoload) {
     
    155155
    156156    public static final LispObject funcall2(LispObject fun, LispObject first,
    157         LispObject second, LispThread thread) throws Condition
     157        LispObject second, LispThread thread) throws ConditionThrowable
    158158    {
    159159        if (fun instanceof Autoload) {
     
    179179
    180180    public static final LispObject funcall3(LispObject fun, LispObject first,
    181         LispObject second, LispObject third, LispThread thread) throws Condition
     181        LispObject second, LispObject third, LispThread thread) throws ConditionThrowable
    182182    {
    183183        if (fun instanceof Autoload) {
     
    206206                                               final Environment env,
    207207                                               final LispThread thread)
    208         throws Condition
     208        throws ConditionThrowable
    209209    {
    210210        LispObject expanded = NIL;
     
    223223                                                 final Environment env,
    224224                                                 final LispThread thread)
    225         throws Condition
     225        throws ConditionThrowable
    226226    {
    227227        LispObject[] results = new LispObject[2];
     
    261261                                        final Environment env,
    262262                                        final LispThread thread)
    263         throws Condition
     263        throws ConditionThrowable
    264264    {
    265265        thread.clearValues();
     
    357357                                               Environment env,
    358358                                               LispThread thread)
    359         throws Condition
     359        throws ConditionThrowable
    360360    {
    361361        final int length = exps.length();
     
    372372    public static final LispObject progn(LispObject body, Environment env,
    373373                                         LispThread thread)
    374         throws Condition
     374        throws ConditionThrowable
    375375    {
    376376        LispObject result = NIL;
  • trunk/j/src/org/armedbear/lisp/LispError.java

    r743 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispError.java,v 1.1 2003-02-15 16:48:16 piso Exp $
     5 * $Id: LispError.java,v 1.2 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public class LispError extends Condition
     24public class LispError extends ConditionThrowable
    2525{
    2626    public LispError()
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r3845 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispFloat.java,v 1.43 2003-09-17 15:09:56 piso Exp $
     5 * $Id: LispFloat.java,v 1.44 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    307307    }
    308308
    309     public LispObject truncate(LispObject obj) throws Condition
     309    public LispObject truncate(LispObject obj) throws ConditionThrowable
    310310    {
    311311        final LispThread thread = LispThread.currentThread();
  • trunk/j/src/org/armedbear/lisp/LispObject.java

    r3844 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispObject.java,v 1.55 2003-09-17 15:12:15 piso Exp $
     5 * $Id: LispObject.java,v 1.56 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    347347    // Special operator
    348348    public LispObject execute(LispObject args, Environment env)
    349         throws Condition
     349        throws ConditionThrowable
    350350    {
    351351        throw new LispError();
     
    353353
    354354    // Primitive
    355     public LispObject execute(LispObject[] args) throws Condition
     355    public LispObject execute(LispObject[] args) throws ConditionThrowable
    356356    {
    357357        throw new LispError();
     
    359359
    360360    // Primitive0
    361     public LispObject execute() throws Condition
     361    public LispObject execute() throws ConditionThrowable
    362362    {
    363363        throw new LispError();
     
    365365
    366366    // Primitive1
    367     public LispObject execute(LispObject arg) throws Condition
     367    public LispObject execute(LispObject arg) throws ConditionThrowable
    368368    {
    369369        throw new LispError();
     
    372372    // Primitive2
    373373    public LispObject execute(LispObject first, LispObject second)
    374         throws Condition
     374        throws ConditionThrowable
    375375    {
    376376        throw new LispError();
     
    379379    // Primitive3
    380380    public LispObject execute(LispObject first, LispObject second,
    381         LispObject third) throws Condition
     381        LispObject third) throws ConditionThrowable
    382382    {
    383383        throw new LispError();
     
    474474    }
    475475
    476     public LispObject truncate(LispObject obj) throws Condition
     476    public LispObject truncate(LispObject obj) throws ConditionThrowable
    477477    {
    478478        throw new TypeError(this, "real number");
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r3565 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispThread.java,v 1.9 2003-09-03 23:45:26 piso Exp $
     5 * $Id: LispThread.java,v 1.10 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    355355    private static final Primitive1 MAPCAR_THREADS =
    356356        new Primitive1("mapcar-threads", PACKAGE_EXT, true) {
    357         public LispObject execute(LispObject arg) throws Condition
     357        public LispObject execute(LispObject arg) throws ConditionThrowable
    358358        {
    359359            Function fun = checkFunction(arg);
     
    373373    private static final Primitive1 DESTROY_THREAD =
    374374        new Primitive1("destroy-thread", PACKAGE_EXT, true) {
    375         public LispObject execute(LispObject arg) throws Condition
     375        public LispObject execute(LispObject arg) throws ConditionThrowable
    376376        {
    377377            if (arg instanceof LispThread) {
     
    387387    private static final Primitive0 CURRENT_THREAD =
    388388        new Primitive0("current-thread", PACKAGE_EXT, true) {
    389         public LispObject execute() throws Condition
     389        public LispObject execute() throws ConditionThrowable
    390390        {
    391391            return currentThread();
  • trunk/j/src/org/armedbear/lisp/Load.java

    r3430 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Load.java,v 1.16 2003-08-16 13:23:40 piso Exp $
     5 * $Id: Load.java,v 1.17 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5353
    5454    /*package*/ static final LispObject load(String filename)
    55         throws Condition
     55        throws ConditionThrowable
    5656    {
    5757        return load(filename,
     
    6262    private static final LispObject load(final String filename,
    6363                                         boolean verbose, boolean print)
    64         throws Condition
     64        throws ConditionThrowable
    6565    {
    6666        File file = null;
     
    122122    /*package*/ static final LispObject _load(final String filename,
    123123                                              boolean verbose, boolean print)
    124         throws Condition
     124        throws ConditionThrowable
    125125    {
    126126        InputStream in = null;
     
    166166                                                       boolean verbose,
    167167                                                       boolean print)
    168         throws Condition
     168        throws ConditionThrowable
    169169    {
    170170        long start = System.currentTimeMillis();
     
    206206
    207207    private static final LispObject loadStream(InputStream inputStream,
    208         boolean print) throws Condition
     208        boolean print) throws ConditionThrowable
    209209    {
    210210        CharacterInputStream in = new CharacterInputStream(inputStream);
     
    276276    // load filespec &key verbose print if-does-not-exist external-format
    277277    public static final Primitive LOAD = new Primitive("load") {
    278         public LispObject execute(LispObject[] args) throws Condition
     278        public LispObject execute(LispObject[] args) throws ConditionThrowable
    279279        {
    280280            if (args.length == 0)
     
    295295    public static final Primitive1 _LOAD =
    296296        new Primitive1("%load", PACKAGE_SYS, false) {
    297         public LispObject execute(LispObject arg) throws Condition
     297        public LispObject execute(LispObject arg) throws ConditionThrowable
    298298        {
    299299            return _load(LispString.getValue(arg),
  • trunk/j/src/org/armedbear/lisp/Makefile.in

    r3857 r3871  
    22
    33# Copyright (C) 2003 Peter Graves
    4 # $Id: Makefile.in,v 1.71 2003-09-17 18:51:25 piso Exp $
     4# $Id: Makefile.in,v 1.72 2003-09-19 00:06:15 piso Exp $
    55
    66# This program is free software; you can redistribute it and/or
     
    4141    CompiledFunction.class \
    4242    Complex.class \
    43     Condition.class \
     43    ConditionThrowable.class \
    4444    Cons.class \
    4545    ControlError.class \
  • trunk/j/src/org/armedbear/lisp/Module.java

    r1002 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Module.java,v 1.3 2003-03-03 03:04:50 piso Exp $
     5 * $Id: Module.java,v 1.4 2003-09-19 00:05:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727
    2828    public LispObject dispatch(LispObject args, Environment env, int index)
    29         throws Condition
     29        throws ConditionThrowable
    3030    {
    3131        throw new LispError();
     
    3333
    3434    public LispObject dispatch(LispObject[] args, int index)
    35         throws Condition
     35        throws ConditionThrowable
    3636    {
    3737        throw new LispError();
    3838    }
    3939
    40     public LispObject dispatch(LispObject arg, int index) throws Condition
     40    public LispObject dispatch(LispObject arg, int index) throws ConditionThrowable
    4141    {
    4242        throw new LispError();
  • trunk/j/src/org/armedbear/lisp/Pathname.java

    r3793 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Pathname.java,v 1.10 2003-09-15 15:48:25 piso Exp $
     5 * $Id: Pathname.java,v 1.11 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9090    // FIXME arg can be a stream, too...
    9191    private static final Primitive1 NAMESTRING = new Primitive1("namestring") {
    92         public LispObject execute(LispObject arg) throws Condition
     92        public LispObject execute(LispObject arg) throws ConditionThrowable
    9393        {
    9494            if (arg instanceof LispString)
     
    106106        new Primitive1("directory-namestring")
    107107    {
    108         public LispObject execute(LispObject arg) throws Condition
     108        public LispObject execute(LispObject arg) throws ConditionThrowable
    109109        {
    110110            String namestring;
     
    130130    // FIXME pathspec can be a stream, too...
    131131    private static final Primitive1 PATHNAME = new Primitive1("pathname") {
    132         public LispObject execute(LispObject arg) throws Condition
     132        public LispObject execute(LispObject arg) throws ConditionThrowable
    133133        {
    134134            if (arg instanceof Pathname)
     
    146146    private static final Primitive _MAKE_PATHNAME =
    147147        new Primitive("%make-pathname", PACKAGE_SYS, false) {
    148         public LispObject execute(LispObject[] args) throws Condition
     148        public LispObject execute(LispObject[] args) throws ConditionThrowable
    149149        {
    150150            if (args.length != 8)
     
    195195    // ### pathnamep
    196196    private static final Primitive1 PATHNAMEP = new Primitive1("pathnamep") {
    197         public LispObject execute(LispObject arg) throws Condition
     197        public LispObject execute(LispObject arg) throws ConditionThrowable
    198198        {
    199199            return arg instanceof Pathname ? T : NIL;
  • trunk/j/src/org/armedbear/lisp/Primitive.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitive.java,v 1.5 2003-09-14 17:36:12 piso Exp $
     5 * $Id: Primitive.java,v 1.6 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848    }
    4949
    50     public LispObject execute() throws Condition
     50    public LispObject execute() throws ConditionThrowable
    5151    {
    5252        LispObject[] args = new LispObject[0];
     
    5454    }
    5555
    56     public LispObject execute(LispObject arg) throws Condition
     56    public LispObject execute(LispObject arg) throws ConditionThrowable
    5757    {
    5858        LispObject[] args = new LispObject[1];
     
    6262
    6363    public LispObject execute(LispObject first, LispObject second)
    64         throws Condition
     64        throws ConditionThrowable
    6565    {
    6666        LispObject[] args = new LispObject[2];
     
    7171
    7272    public LispObject execute(LispObject first, LispObject second,
    73         LispObject third) throws Condition
     73        LispObject third) throws ConditionThrowable
    7474    {
    7575        LispObject[] args = new LispObject[3];
  • trunk/j/src/org/armedbear/lisp/Primitive0.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitive0.java,v 1.6 2003-09-14 17:36:12 piso Exp $
     5 * $Id: Primitive0.java,v 1.7 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5454    }
    5555
    56     public LispObject execute(LispObject first) throws Condition
     56    public LispObject execute(LispObject first) throws ConditionThrowable
    5757    {
    5858        throw new WrongNumberOfArgumentsException(this);
     
    6060
    6161    public LispObject execute(LispObject first, LispObject second)
    62         throws Condition
     62        throws ConditionThrowable
    6363    {
    6464        throw new WrongNumberOfArgumentsException(this);
     
    6666
    6767    public LispObject execute(LispObject first, LispObject second,
    68         LispObject third) throws Condition
     68        LispObject third) throws ConditionThrowable
    6969    {
    7070        throw new WrongNumberOfArgumentsException(this);
    7171    }
    7272
    73     public LispObject execute(LispObject[] args) throws Condition
     73    public LispObject execute(LispObject[] args) throws ConditionThrowable
    7474    {
    7575        if (args.length != 0)
  • trunk/j/src/org/armedbear/lisp/Primitive1.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitive1.java,v 1.6 2003-09-14 17:36:12 piso Exp $
     5 * $Id: Primitive1.java,v 1.7 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5454    }
    5555
    56     public LispObject execute() throws Condition
     56    public LispObject execute() throws ConditionThrowable
    5757    {
    5858        throw new WrongNumberOfArgumentsException(this);
     
    6060
    6161    public LispObject execute(LispObject first, LispObject second)
    62         throws Condition
     62        throws ConditionThrowable
    6363    {
    6464        throw new WrongNumberOfArgumentsException(this);
     
    6666
    6767    public LispObject execute(LispObject first, LispObject second,
    68         LispObject third) throws Condition
     68        LispObject third) throws ConditionThrowable
    6969    {
    7070        throw new WrongNumberOfArgumentsException(this);
    7171    }
    7272
    73     public LispObject execute(LispObject[] args) throws Condition
     73    public LispObject execute(LispObject[] args) throws ConditionThrowable
    7474    {
    7575        if (args.length != 1)
  • trunk/j/src/org/armedbear/lisp/Primitive2.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitive2.java,v 1.5 2003-09-14 17:36:12 piso Exp $
     5 * $Id: Primitive2.java,v 1.6 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848    }
    4949
    50     public LispObject execute() throws Condition
     50    public LispObject execute() throws ConditionThrowable
    5151    {
    5252        throw new WrongNumberOfArgumentsException(this);
     
    5454
    5555    public LispObject execute(LispObject first)
    56         throws Condition
     56        throws ConditionThrowable
    5757    {
    5858        throw new WrongNumberOfArgumentsException(this);
     
    6060
    6161    public LispObject execute(LispObject first, LispObject second,
    62         LispObject third) throws Condition
     62        LispObject third) throws ConditionThrowable
    6363    {
    6464        throw new WrongNumberOfArgumentsException(this);
    6565    }
    6666
    67     public LispObject execute(LispObject[] args) throws Condition
     67    public LispObject execute(LispObject[] args) throws ConditionThrowable
    6868    {
    6969        if (args.length != 2)
  • trunk/j/src/org/armedbear/lisp/Primitive3.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitive3.java,v 1.6 2003-09-14 17:36:12 piso Exp $
     5 * $Id: Primitive3.java,v 1.7 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4848    }
    4949
    50     public LispObject execute() throws Condition
     50    public LispObject execute() throws ConditionThrowable
    5151    {
    5252        throw new WrongNumberOfArgumentsException(this);
     
    5454
    5555    public LispObject execute(LispObject first)
    56         throws Condition
     56        throws ConditionThrowable
    5757    {
    5858        throw new WrongNumberOfArgumentsException(this);
     
    6060
    6161    public LispObject execute(LispObject first, LispObject second)
    62         throws Condition
     62        throws ConditionThrowable
    6363    {
    6464        throw new WrongNumberOfArgumentsException(this);
    6565    }
    6666
    67     public LispObject execute(LispObject[] args) throws Condition
     67    public LispObject execute(LispObject[] args) throws ConditionThrowable
    6868    {
    6969        if (args.length != 3)
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r3865 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.401 2003-09-18 15:40:15 piso Exp $
     5 * $Id: Primitives.java,v 1.402 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    167167    // SpecialOperator
    168168    public LispObject dispatch(LispObject args, Environment env, int index)
    169         throws Condition
     169        throws ConditionThrowable
    170170    {
    171171        switch (index) {
     
    245245    // Primitive1
    246246    public LispObject dispatch(LispObject arg, int index)
    247         throws Condition
     247        throws ConditionThrowable
    248248    {
    249249        switch (index) {
     
    605605    private static final SpecialOperator IF = new SpecialOperator("if") {
    606606        public LispObject execute(LispObject args, Environment env)
    607             throws Condition
     607            throws ConditionThrowable
    608608        {
    609609            final LispThread thread = LispThread.currentThread();
     
    628628    private static final SpecialOperator WHEN = new SpecialOperator("when") {
    629629        public LispObject execute(LispObject args, Environment env)
    630             throws Condition
     630            throws ConditionThrowable
    631631        {
    632632            if (args == NIL)
     
    649649        new SpecialOperator("unless") {
    650650        public LispObject execute(LispObject args, Environment env)
    651             throws Condition
     651            throws ConditionThrowable
    652652        {
    653653            if (args == NIL)
     
    11661166    // ### signal
    11671167    private static final Primitive SIGNAL = new Primitive("signal") {
    1168         public LispObject execute(LispObject[] args) throws Condition
     1168        public LispObject execute(LispObject[] args) throws ConditionThrowable
    11691169        {
    11701170            if (args.length < 1)
     
    14371437    private static final SpecialOperator COND = new SpecialOperator("cond") {
    14381438        public LispObject execute(LispObject args, Environment env)
    1439             throws Condition
     1439            throws ConditionThrowable
    14401440        {
    14411441            final LispThread thread = LispThread.currentThread();
     
    14621462    private static final SpecialOperator CASE = new SpecialOperator("case") {
    14631463        public LispObject execute(LispObject args, Environment env)
    1464             throws Condition
     1464            throws ConditionThrowable
    14651465        {
    14661466            final LispThread thread = LispThread.currentThread();
     
    14991499    private static final SpecialOperator ECASE = new SpecialOperator("ecase") {
    15001500        public LispObject execute(LispObject args, Environment env)
    1501             throws Condition
     1501            throws ConditionThrowable
    15021502        {
    15031503            final LispThread thread = LispThread.currentThread();
     
    15331533    private static final LispObject _do(LispObject args, Environment env,
    15341534                                        boolean sequential)
    1535         throws Condition
     1535        throws ConditionThrowable
    15361536    {
    15371537        // Process variable specifications.
     
    16231623    private static final SpecialOperator DOLIST = new SpecialOperator("dolist") {
    16241624        public LispObject execute(LispObject args, Environment env)
    1625             throws Condition
     1625            throws ConditionThrowable
    16261626        {
    16271627            LispObject bodyForm = args.cdr();
     
    16651665        new SpecialOperator("dotimes") {
    16661666        public LispObject execute(LispObject args, Environment env)
    1667             throws Condition
     1667            throws ConditionThrowable
    16681668        {
    16691669            LispObject bodyForm = args.cdr();
     
    17071707        new SpecialOperator("handler-bind") {
    17081708        public LispObject execute(LispObject args, Environment env)
    1709             throws Condition
     1709            throws ConditionThrowable
    17101710        {
    17111711            LispObject bindings = checkList(args.car());
     
    17181718                throw ret;
    17191719            }
    1720             catch (Condition c) {
     1720            catch (ConditionThrowable c) {
    17211721                while (bindings != NIL) {
    17221722                    Cons binding = checkCons(bindings.car());
     
    17481748        new SpecialOperator("handler-case") {
    17491749        public LispObject execute(LispObject args, Environment env)
    1750             throws Condition
     1750            throws ConditionThrowable
    17511751        {
    17521752            LispObject form = args.car();
     
    17571757                return eval(form, env, thread);
    17581758            }
    1759             catch (Condition c) {
     1759            catch (ConditionThrowable c) {
    17601760                thread.setStackDepth(depth);
    17611761                while (clauses != NIL) {
     
    17861786    };
    17871787
    1788     private static boolean isConditionOfType(Condition c, LispObject type)
     1788    private static boolean isConditionOfType(ConditionThrowable c, LispObject type)
    17891789    {
    17901790        if (type == Symbol.END_OF_FILE)
     
    22122212    // This needs to be public for LispAPI.java.
    22132213    public static final Primitive FUNCALL = new Primitive("funcall") {
    2214         public LispObject execute(LispObject arg) throws Condition
     2214        public LispObject execute(LispObject arg) throws ConditionThrowable
    22152215        {
    22162216            LispObject fun;
     
    22242224        }
    22252225        public LispObject execute(LispObject first, LispObject second)
    2226             throws Condition
     2226            throws ConditionThrowable
    22272227        {
    22282228            LispObject fun;
     
    22372237        public LispObject execute(LispObject first, LispObject second,
    22382238                                  LispObject third)
    2239             throws Condition
     2239            throws ConditionThrowable
    22402240        {
    22412241            LispObject fun;
     
    22482248            throw new UndefinedFunctionError(first);
    22492249        }
    2250         public LispObject execute(LispObject[] args) throws Condition
     2250        public LispObject execute(LispObject[] args) throws ConditionThrowable
    22512251        {
    22522252            if (args.length < 1)
     
    22752275    private static final Primitive APPLY = new Primitive("apply") {
    22762276        public LispObject execute(LispObject first, LispObject second)
    2277             throws Condition
     2277            throws ConditionThrowable
    22782278        {
    22792279            LispObject spread = checkList(second);
     
    23052305            throw new TypeError(fun, "function");
    23062306        }
    2307         public LispObject execute(final LispObject[] args) throws Condition
     2307        public LispObject execute(final LispObject[] args) throws ConditionThrowable
    23082308        {
    23092309            final int numArgs = args.length;
     
    23332333    private static final Primitive MAPCAR = new Primitive("mapcar") {
    23342334        public LispObject execute(LispObject first, LispObject second)
    2335             throws Condition
     2335            throws ConditionThrowable
    23362336        {
    23372337            // First argument must be a function.
     
    23612361        }
    23622362        public LispObject execute(LispObject first, LispObject second,
    2363             LispObject third) throws Condition
     2363            LispObject third) throws ConditionThrowable
    23642364        {
    23652365            // First argument must be a function.
     
    23912391            return result;
    23922392        }
    2393         public LispObject execute(final LispObject[] args) throws Condition
     2393        public LispObject execute(final LispObject[] args) throws ConditionThrowable
    23942394        {
    23952395            final int numArgs = args.length;
     
    24332433    // ### macroexpand
    24342434    private static final Primitive MACROEXPAND = new Primitive("macroexpand") {
    2435         public LispObject execute(LispObject[] args) throws Condition
     2435        public LispObject execute(LispObject[] args) throws ConditionThrowable
    24362436        {
    24372437            final int length = args.length;
     
    24482448    private static final Primitive MACROEXPAND_1 =
    24492449        new Primitive("macroexpand-1") {
    2450         public LispObject execute(LispObject[] args) throws Condition
     2450        public LispObject execute(LispObject[] args) throws ConditionThrowable
    24512451        {
    24522452            final int length = args.length;
     
    27272727        new SpecialOperator("do-external-symbols") {
    27282728        public LispObject execute(LispObject args, Environment env)
    2729             throws Condition
     2729            throws ConditionThrowable
    27302730        {
    27312731            return doSymbols(args, env, true);
     
    27402740        new SpecialOperator("do-symbols") {
    27412741        public LispObject execute(LispObject args, Environment env)
    2742             throws Condition
     2742            throws ConditionThrowable
    27432743        {
    27442744            return doSymbols(args, env, false);
     
    27482748    private static final LispObject doSymbols(LispObject args, Environment env,
    27492749                                              boolean externalOnly)
    2750         throws Condition
     2750        throws ConditionThrowable
    27512751    {
    27522752        LispObject bodyForm = args.cdr();
     
    28002800    private static final Primitive1 PACKAGE_SYMBOLS =
    28012801        new Primitive1("package-symbols", PACKAGE_SYS, false) {
    2802         public LispObject execute(LispObject arg) throws Condition
     2802        public LispObject execute(LispObject arg) throws ConditionThrowable
    28032803        {
    28042804            return coerceToPackage(arg).getSymbols();
     
    28092809    private static final Primitive1 PACKAGE_INTERNAL_SYMBOLS =
    28102810        new Primitive1("package-internal-symbols", PACKAGE_SYS, false) {
    2811         public LispObject execute(LispObject arg) throws Condition
     2811        public LispObject execute(LispObject arg) throws ConditionThrowable
    28122812        {
    28132813            return coerceToPackage(arg).PACKAGE_INTERNAL_SYMBOLS();
     
    28182818    private static final Primitive1 PACKAGE_EXTERNAL_SYMBOLS =
    28192819        new Primitive1("package-external-symbols", PACKAGE_SYS, false) {
    2820         public LispObject execute(LispObject arg) throws Condition
     2820        public LispObject execute(LispObject arg) throws ConditionThrowable
    28212821        {
    28222822            return coerceToPackage(arg).PACKAGE_EXTERNAL_SYMBOLS();
     
    28272827    private static final Primitive1 PACKAGE_INHERITED_SYMBOLS =
    28282828        new Primitive1("package-inherited-symbols", PACKAGE_SYS, false) {
    2829         public LispObject execute(LispObject arg) throws Condition
     2829        public LispObject execute(LispObject arg) throws ConditionThrowable
    28302830        {
    28312831            return coerceToPackage(arg).PACKAGE_INHERITED_SYMBOLS();
     
    29622962    private static final SpecialOperator LET = new SpecialOperator("let") {
    29632963        public LispObject execute(LispObject args, Environment env)
    2964             throws Condition
     2964            throws ConditionThrowable
    29652965        {
    29662966            return _let(args, env, false);
     
    29702970    private static final SpecialOperator LETX = new SpecialOperator("let*") {
    29712971        public LispObject execute(LispObject args, Environment env)
    2972             throws Condition
     2972            throws ConditionThrowable
    29732973        {
    29742974            return _let(args, env, true);
     
    29772977
    29782978    private static final LispObject _let(LispObject args, Environment env,
    2979         boolean sequential) throws Condition
     2979        boolean sequential) throws ConditionThrowable
    29802980    {
    29812981        LispObject varList = checkList(args.car());
     
    30133013
    30143014    private static final LispObject _flet(LispObject args, Environment env,
    3015         boolean recursive) throws Condition
     3015        boolean recursive) throws ConditionThrowable
    30163016    {
    30173017        // First argument is a list of local function definitions.
     
    30513051        new SpecialOperator("macrolet") {
    30523052        public LispObject execute(LispObject args, Environment env)
    3053             throws Condition
     3053            throws ConditionThrowable
    30543054        {
    30553055            LispObject defs = checkList(args.car());
     
    30913091        new SpecialOperator("tagbody") {
    30923092        public LispObject execute(LispObject args, Environment env)
    3093             throws Condition
     3093            throws ConditionThrowable
    30943094        {
    30953095            Binding tags = null;
     
    31663166    private static final SpecialOperator BLOCK = new SpecialOperator("block") {
    31673167        public LispObject execute(LispObject args, Environment env)
    3168             throws Condition
     3168            throws ConditionThrowable
    31693169        {
    31703170            if (args == NIL)
     
    32103210        new SpecialOperator("return-from") {
    32113211        public LispObject execute(LispObject args, Environment env)
    3212             throws Condition
     3212            throws ConditionThrowable
    32133213        {
    32143214            final int length = args.length();
     
    32373237        new SpecialOperator("return") {
    32383238        public LispObject execute(LispObject args, Environment env)
    3239             throws Condition
     3239            throws ConditionThrowable
    32403240        {
    32413241            switch (args.length()) {
     
    32553255    private static final SpecialOperator CATCH = new SpecialOperator("catch") {
    32563256        public LispObject execute(LispObject args, Environment env)
    3257             throws Condition
     3257            throws ConditionThrowable
    32583258        {
    32593259            if (args.length() < 1)
     
    32873287    private static final SpecialOperator THROW = new SpecialOperator("throw") {
    32883288        public LispObject execute(LispObject args, Environment env)
    3289             throws Condition
     3289            throws ConditionThrowable
    32903290        {
    32913291            if (args.length() < 2)
     
    33023302        new SpecialOperator("unwind-protect") {
    33033303        public LispObject execute(LispObject args, Environment env)
    3304             throws Condition
     3304            throws ConditionThrowable
    33053305        {
    33063306            final LispThread thread = LispThread.currentThread();
     
    33273327        new SpecialOperator("function") {
    33283328        public LispObject execute(LispObject args, Environment env)
    3329             throws Condition
     3329            throws ConditionThrowable
    33303330        {
    33313331            LispObject arg = args.car();
     
    33523352    private static final SpecialOperator SETQ = new SpecialOperator("setq") {
    33533353        public LispObject execute(LispObject args, Environment env)
    3354             throws Condition
     3354            throws ConditionThrowable
    33553355        {
    33563356            LispObject value = Symbol.NIL;
     
    33923392        new SpecialOperator("multiple-value-bind") {
    33933393        public LispObject execute(LispObject args, Environment env)
    3394             throws Condition
     3394            throws ConditionThrowable
    33953395        {
    33963396            LispObject vars = args.car();
     
    34373437        new SpecialOperator("multiple-value-setq") {
    34383438        public LispObject execute(LispObject args, Environment env)
    3439             throws Condition
     3439            throws ConditionThrowable
    34403440        {
    34413441            if (args.length() != 2)
     
    34883488        new SpecialOperator("multiple-value-prog1") {
    34893489        public LispObject execute(LispObject args, Environment env)
    3490             throws Condition
     3490            throws ConditionThrowable
    34913491        {
    34923492            if (args.length() == 0)
     
    35063506        new SpecialOperator("multiple-value-call") {
    35073507        public LispObject execute(LispObject args, Environment env)
    3508             throws Condition
     3508            throws ConditionThrowable
    35093509        {
    35103510            if (args.length() == 0)
     
    35443544    private static final SpecialOperator AND = new SpecialOperator("and") {
    35453545        public LispObject execute(LispObject args, Environment env)
    3546             throws Condition
     3546            throws ConditionThrowable
    35473547        {
    35483548            final LispThread thread = LispThread.currentThread();
     
    35673567    private static final SpecialOperator OR = new SpecialOperator("or") {
    35683568        public LispObject execute(LispObject args, Environment env)
    3569             throws Condition
     3569            throws ConditionThrowable
    35703570        {
    35713571            final LispThread thread = LispThread.currentThread();
     
    35913591        new SpecialOperator("assert") {
    35923592        public LispObject execute(LispObject args, Environment env)
    3593             throws Condition
     3593            throws ConditionThrowable
    35943594        {
    35953595            if (args.length() != 1)
     
    37143714        new SpecialOperator("multiple-value-list") {
    37153715        public LispObject execute(LispObject args, Environment env)
    3716             throws Condition
     3716            throws ConditionThrowable
    37173717        {
    37183718            if (args.length() != 1)
     
    37393739        new SpecialOperator("nth-value") {
    37403740        public LispObject execute(LispObject args, Environment env)
    3741             throws Condition
     3741            throws ConditionThrowable
    37423742        {
    37433743            if (args.length() != 2)
     
    38033803    private static final Primitive READ_LINE =
    38043804        new Primitive("read-line") {
    3805         public LispObject execute(LispObject[] args) throws Condition
     3805        public LispObject execute(LispObject[] args) throws ConditionThrowable
    38063806        {
    38073807            int length = args.length;
     
    38293829    private static final Primitive _READ_FROM_STRING =
    38303830        new Primitive("%read-from-string", PACKAGE_SYS, false) {
    3831         public LispObject execute(LispObject[] args) throws Condition
     3831        public LispObject execute(LispObject[] args) throws ConditionThrowable
    38323832        {
    38333833            if (args.length < 6)
     
    40104010    // read &optional input-stream eof-error-p eof-value recursive-p => object
    40114011    private static final Primitive READ = new Primitive("read") {
    4012         public LispObject execute(LispObject[] args) throws Condition
     4012        public LispObject execute(LispObject[] args) throws ConditionThrowable
    40134013        {
    40144014            int length = args.length;
     
    40654065    // random limit &optional random-state => random-number
    40664066    private static final Primitive RANDOM = new Primitive("random") {
    4067         public LispObject execute(LispObject[] args) throws Condition
     4067        public LispObject execute(LispObject[] args) throws ConditionThrowable
    40684068        {
    40694069            int length = args.length;
     
    41034103    private static final Primitive MAKE_RANDOM_STATE =
    41044104        new Primitive("make-random-state") {
    4105         public LispObject execute(LispObject[] args) throws Condition
     4105        public LispObject execute(LispObject[] args) throws ConditionThrowable
    41064106        {
    41074107            // FIXME Ignore arguments (or lack thereof).
     
    41124112    // ### truncate
    41134113    private static final Primitive TRUNCATE = new Primitive("truncate") {
    4114         public LispObject execute(LispObject[] args) throws Condition
     4114        public LispObject execute(LispObject[] args) throws ConditionThrowable
    41154115        {
    41164116            final int length = args.length;
     
    43984398    private static final Primitive2 MAPTREE = new Primitive2("maptree") {
    43994399        public LispObject execute(LispObject fun, LispObject x)
    4400             throws Condition
     4400            throws ConditionThrowable
    44014401        {
    44024402            if (x instanceof Cons) {
     
    44174417        new Primitive2("%make-list", PACKAGE_SYS, false) {
    44184418        public LispObject execute(LispObject first, LispObject second)
    4419             throws Condition
     4419            throws ConditionThrowable
    44204420        {
    44214421            int size = Fixnum.getValue(first);
     
    44484448    private static final Primitive _MEMBER =
    44494449        new Primitive("%member", PACKAGE_SYS, false) {
    4450         public LispObject execute(LispObject[] args) throws Condition
     4450        public LispObject execute(LispObject[] args) throws ConditionThrowable
    44514451        {
    44524452            if (args.length != 5)
     
    45084508        new Primitive2("funcall-key", PACKAGE_SYS, false) {
    45094509        public LispObject execute(LispObject first, LispObject second)
    4510             throws Condition
     4510            throws ConditionThrowable
    45114511        {
    45124512            if (first != NIL)
     
    45194519    private static final Primitive1 COERCE_TO_FUNCTION =
    45204520        new Primitive1("coerce-to-function", PACKAGE_SYS, false) {
    4521         public LispObject execute(LispObject arg) throws Condition
     4521        public LispObject execute(LispObject arg) throws ConditionThrowable
    45224522        {
    45234523            return coerceToFunction(arg);
     
    45284528    private static final Primitive1 ARGLIST =
    45294529        new Primitive1("arglist", PACKAGE_SYS, false) {
    4530         public LispObject execute(LispObject arg) throws Condition
     4530        public LispObject execute(LispObject arg) throws ConditionThrowable
    45314531        {
    45324532            Function function = coerceToFunction(arg);
     
    45484548        new Primitive2("%set-arglist", PACKAGE_SYS, false) {
    45494549        public LispObject execute(LispObject first, LispObject second)
    4550             throws Condition
     4550            throws ConditionThrowable
    45514551        {
    45524552            coerceToFunction(first).setArglist(second);
  • trunk/j/src/org/armedbear/lisp/SimpleCondition.java

    r1000 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SimpleCondition.java,v 1.1 2003-03-03 02:43:34 piso Exp $
     5 * $Id: SimpleCondition.java,v 1.2 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public class SimpleCondition extends Condition
     24public class SimpleCondition extends ConditionThrowable
    2525{
    2626    public SimpleCondition()
  • trunk/j/src/org/armedbear/lisp/SpecialOperator.java

    r3781 r3871  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: SpecialOperator.java,v 1.9 2003-09-14 17:36:12 piso Exp $
     5 * $Id: SpecialOperator.java,v 1.10 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5757
    5858    public LispObject execute(LispObject args, Environment env)
    59         throws Condition
     59        throws ConditionThrowable
    6060    {
    6161        return module.dispatch(args, env, index);
  • trunk/j/src/org/armedbear/lisp/ThreadDestroyed.java

    r1722 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: ThreadDestroyed.java,v 1.1 2003-05-04 04:44:46 piso Exp $
     5 * $Id: ThreadDestroyed.java,v 1.2 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public class ThreadDestroyed extends Condition
     24public class ThreadDestroyed extends ConditionThrowable
    2525{
    2626    public ThreadDestroyed()
  • trunk/j/src/org/armedbear/lisp/Time.java

    r3297 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Time.java,v 1.3 2003-08-10 00:48:23 piso Exp $
     5 * $Id: Time.java,v 1.4 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2929    private static final Primitive1 _TIME =
    3030        new Primitive1("%time", PACKAGE_SYS, true) {
    31         public LispObject execute(LispObject arg) throws Condition
     31        public LispObject execute(LispObject arg) throws ConditionThrowable
    3232        {
    3333            Cons.setCount(0);
     
    5656    private static final Primitive0 GET_INTERNAL_REAL_TIME =
    5757        new Primitive0("get-internal-real-time") {
    58         public LispObject execute() throws Condition
     58        public LispObject execute() throws ConditionThrowable
    5959        {
    6060            return number(System.currentTimeMillis());
  • trunk/j/src/org/armedbear/lisp/coerce.java

    r3761 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: coerce.java,v 1.6 2003-09-14 15:33:05 piso Exp $
     5 * $Id: coerce.java,v 1.7 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2828    private static final Primitive2 COERCE = new Primitive2("coerce") {
    2929        public LispObject execute(LispObject first, LispObject second)
    30             throws Condition
     30            throws ConditionThrowable
    3131        {
    3232            if (second == T)
  • trunk/j/src/org/armedbear/lisp/describe.java

    r3128 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: describe.java,v 1.4 2003-07-27 19:46:51 piso Exp $
     5 * $Id: describe.java,v 1.5 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2727    // Need to support optional second argument specifying output stream.
    2828    private static final Primitive DESCRIBE = new Primitive("describe") {
    29         public LispObject execute(LispObject[] args) throws Condition
     29        public LispObject execute(LispObject[] args) throws ConditionThrowable
    3030        {
    3131            if (args.length != 1)
  • trunk/j/src/org/armedbear/lisp/room.java

    r2453 r3871  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: room.java,v 1.1 2003-06-20 15:59:22 piso Exp $
     5 * $Id: room.java,v 1.2 2003-09-19 00:05:11 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525{
    2626    private static final Primitive ROOM = new Primitive("room") {
    27         public LispObject execute(LispObject[] args) throws Condition
     27        public LispObject execute(LispObject[] args) throws ConditionThrowable
    2828        {
    2929            Runtime runtime = Runtime.getRuntime();
Note: See TracChangeset for help on using the changeset viewer.