Changeset 12298


Ignore:
Timestamp:
12/18/09 21:50:54 (11 years ago)
Author:
ehuelsmann
Message:

Full source scan of "catch (Throwable";

remove lots of instances, or make the catch statement more
specific, e.g. replace Throwable by IOException.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • trunk/abcl/src/org/armedbear/lisp/AbstractArray.java

    r12288 r12298  
    295295    public int psxhash()
    296296    {
    297         try {
    298             long result = 128387; // Chosen at random.
    299             final int rank = getRank();
    300             int limit = rank < 4 ? rank : 4;
    301             for (int i = 0; i < limit; i++)
    302                 result = mix(result, getDimension(i));
    303             final int length = getTotalSize();
    304             limit = length < 4 ? length : 4;
    305             for (int i = 0; i < length; i++)
    306                 result = mix(result, AREF(i).psxhash());
    307             return (int) (result & 0x7fffffff);
    308         }
    309         catch (Throwable t) {
    310             // Shouldn't happen.
    311             Debug.trace(t);
    312             return 0;
    313         }
     297        long result = 128387; // Chosen at random.
     298        final int rank = getRank();
     299        int limit = rank < 4 ? rank : 4;
     300        for (int i = 0; i < limit; i++)
     301            result = mix(result, getDimension(i));
     302        final int length = getTotalSize();
     303        limit = length < 4 ? length : 4;
     304        for (int i = 0; i < length; i++)
     305            result = mix(result, AREF(i).psxhash());
     306        return (int) (result & 0x7fffffff);
    314307    }
    315308

  • trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

    r12288 r12298  
    277277  public int psxhash()
    278278  {
    279     try
    280       {
    281         final int length = length();
    282         final int limit = length < 4 ? length : 4;
    283         long result = 48920713; // Chosen at random.
    284         for (int i = 0; i < limit; i++)
    285           result = mix(result, AREF(i).psxhash());
    286         return (int) (result & 0x7fffffff);
    287       }
    288     catch (Throwable t)
    289       {
    290         // Shouldn't happen.
    291         Debug.trace(t);
    292         return 0;
    293       }
     279    final int length = length();
     280    final int limit = length < 4 ? length : 4;
     281    long result = 48920713; // Chosen at random.
     282    for (int i = 0; i < limit; i++)
     283      result = mix(result, AREF(i).psxhash());
     284    return (int) (result & 0x7fffffff);
    294285  }
    295286

  • trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java

    r12288 r12298  
    292292  static
    293293  {
    294     try
    295       {
    296         StandardClass.initializeStandardClasses();
    297       }
    298     catch (Throwable t)
    299       {
    300         Debug.trace(t);
    301       }
     294    StandardClass.initializeStandardClasses();
    302295  }
    303296}

  • trunk/abcl/src/org/armedbear/lisp/Condition.java

    r12288 r12298  
    9999    super(StandardClass.CONDITION);
    100100    Debug.assertTrue(slots.length == 2);
    101     try
    102       {
    103         setFormatControl(message);
    104         setFormatArguments(NIL);
    105       }
    106     catch (Throwable t)
    107       {
    108         Debug.trace(t);
    109       }
     101    setFormatControl(message);
     102    setFormatArguments(NIL);
    110103  }
    111104
    … …  
    178171    if (formatControl != NIL)
    179172      {
    180         try
    181           {
    182             return format(formatControl, getFormatArguments());
    183           }
    184         catch (Throwable t) {}
     173        return format(formatControl, getFormatArguments());
    185174      }
    186175    return unreadableString(typeOf().writeToString());

  • trunk/abcl/src/org/armedbear/lisp/Go.java

    r12255 r12298  
    5858    public LispObject getCondition()
    5959    {
    60         try {
    61             StringBuffer sb = new StringBuffer("No tag named ");
    62             sb.append(tag.writeToString());
    63             sb.append(" is currently visible");
    64             return new ControlError(sb.toString());
    65         }
    66         catch (Throwable t) {
    67             Debug.trace(t);
    68             return new Condition();
    69         }
     60        StringBuffer sb = new StringBuffer("No tag named ");
     61        sb.append(tag.writeToString());
     62        sb.append(" is currently visible");
     63        return new ControlError(sb.toString());
    7064    }
    7165}

  • trunk/abcl/src/org/armedbear/lisp/Interpreter.java

    r12290 r12298  
    7676            return null;
    7777        interpreter = new Interpreter();
    78         try {
    79             if (args != null)
    80                 preprocessCommandLineArguments(args);
    81             if (!noinform) {
    82                 Stream out = getStandardOutput();
    83                 out._writeString(banner());
    84                 out._finishOutput();
    85             }
    86             if (noinform)
    87                 _NOINFORM_.setSymbolValue(T);
    88             else {
    89                 double uptime = (System.currentTimeMillis() - Main.startTimeMillis) / 1000.0;
    90                 getStandardOutput()._writeString("Low-level initialization completed in " +
    91                                                  uptime + " seconds.\n");
    92             }
    93             initializeLisp();
    94             initializeTopLevel();
    95             if (!noinit)
    96                 processInitializationFile();
    97             if (args != null)
    98                 postprocessCommandLineArguments(args);
    99         }
    100         catch (Throwable t) {
    101             t.printStackTrace();
    102         }
     78
     79        if (args != null)
     80            preprocessCommandLineArguments(args);
     81        if (!noinform) {
     82            Stream out = getStandardOutput();
     83            out._writeString(banner());
     84            out._finishOutput();
     85        }
     86        if (noinform)
     87            _NOINFORM_.setSymbolValue(T);
     88        else {
     89            double uptime = (System.currentTimeMillis() - Main.startTimeMillis) / 1000.0;
     90            getStandardOutput()._writeString("Low-level initialization completed in " +
     91                                             uptime + " seconds.\n");
     92        }
     93        initializeLisp();
     94        initializeTopLevel();
     95        if (!noinit)
     96            processInitializationFile();
     97        if (args != null)
     98            postprocessCommandLineArguments(args);
     99
    103100        return interpreter;
    104101    }
    … …  
    113110            return null;
    114111        interpreter = new Interpreter(in, out, initialDirectory);
    115         try {
    116             Stream stdout = getStandardOutput();
    117             stdout._writeLine(version);
    118             stdout._writeString(banner());
    119             stdout._finishOutput();
    120         }
    121         catch (Throwable t) {
    122             t.printStackTrace();
    123         }
     112
     113        Stream stdout = getStandardOutput();
     114        stdout._writeLine(version);
     115        stdout._writeString(banner());
     116        stdout._finishOutput();
     117
    124118        initializeJLisp();
    125119        initializeTopLevel();
    … …  
    145139        if (!initialDirectory.endsWith(File.separator))
    146140            initialDirectory = initialDirectory.concat(File.separator);
    147         try {
    148             Symbol.DEFAULT_PATHNAME_DEFAULTS.setSymbolValue(new Pathname(initialDirectory));
    149         }
    150         catch (Throwable t) {
    151             Debug.trace(t);
    152         }
     141        Symbol.DEFAULT_PATHNAME_DEFAULTS.setSymbolValue(new Pathname(initialDirectory));
    153142    }
    154143
    … …  
    171160    {
    172161        if (!initialized) {
     162            Symbol.FEATURES.setSymbolValue(new Cons(Keyword.J,
     163                                               Symbol.FEATURES.getSymbolValue()));
     164            Load.loadSystemFile("boot.lisp", false, false, false);
     165
    173166            try {
    174                 Symbol.FEATURES.setSymbolValue(new Cons(Keyword.J,
    175                                                    Symbol.FEATURES.getSymbolValue()));
    176                 Load.loadSystemFile("boot.lisp", false, false, false);
    177167                Class.forName("org.armedbear.j.LispAPI");
    178                 Load.loadSystemFile("j.lisp");
    179             }
    180             catch (Throwable t) {
    181                 // ### FIXME exception
    182                 t.printStackTrace();
    183             }
     168            }
     169            catch (ClassNotFoundException e) { } // FIXME: what to do?
     170
     171            Load.loadSystemFile("j.lisp");
     172
    184173            initialized = true;
    185174        }
    … …  
    191180    {
    192181        if (!topLevelInitialized) {
    193             try {
    194                 // Resolve top-level-loop autoload.
    195                 Symbol TOP_LEVEL_LOOP = intern("TOP-LEVEL-LOOP", PACKAGE_TPL);
    196                 LispObject tplFun = TOP_LEVEL_LOOP.getSymbolFunction();
    197                 if (tplFun instanceof Autoload) {
    198                     Autoload autoload = (Autoload) tplFun;
    199                     autoload.load();
    200                 }
    201             }
    202             catch (Throwable t) {
    203                 t.printStackTrace();
    204             }
     182            // Resolve top-level-loop autoload.
     183            Symbol TOP_LEVEL_LOOP = intern("TOP-LEVEL-LOOP", PACKAGE_TPL);
     184            LispObject tplFun = TOP_LEVEL_LOOP.getSymbolFunction();
     185            if (tplFun instanceof Autoload) {
     186                Autoload autoload = (Autoload) tplFun;
     187                autoload.load();
     188            }
     189
    205190            topLevelInitialized = true;
    206191        }
    … …  
    217202            }
    218203        }
    219         catch (Throwable t) {
    220             t.printStackTrace();
     204        catch (IOException e) {
     205            e.printStackTrace();
    221206        }
    222207    }
    … …  
    386371    private static void reportError(ControlTransfer c, LispThread thread)
    387372    {
    388         try {
    389             getStandardInput().clearInput();
    390             Stream out = getStandardOutput();
    391             out.freshLine();
    392             Condition condition = (Condition) c.getCondition();
    393             out._writeLine("Error: unhandled condition: " +
    394                            condition.writeToString());
    395             if (thread != null)
    396                 thread.printBacktrace();
    397         }
    398         catch (Throwable t) {
    399            
    400         }
     373        getStandardInput().clearInput();
     374        Stream out = getStandardOutput();
     375        out.freshLine();
     376        Condition condition = (Condition) c.getCondition();
     377        out._writeLine("Error: unhandled condition: " +
     378                       condition.writeToString());
     379        if (thread != null)
     380            thread.printBacktrace();
    401381    }
    402382
    403383    private static void reportError(UnhandledCondition c, LispThread thread)
    404384    {
    405         try {
    406             getStandardInput().clearInput();
    407             Stream out = getStandardOutput();
    408             out.freshLine();
    409             Condition condition = (Condition) c.getCondition();
    410             out._writeLine("Error: unhandled condition: " +
    411                            condition.writeToString());
    412             if (thread != null)
    413                 thread.printBacktrace();
    414         }
    415         catch (Throwable t) {
    416            
    417         }
     385        getStandardInput().clearInput();
     386        Stream out = getStandardOutput();
     387        out.freshLine();
     388        Condition condition = (Condition) c.getCondition();
     389        out._writeLine("Error: unhandled condition: " +
     390                       condition.writeToString());
     391        if (thread != null)
     392            thread.printBacktrace();
    418393    }
    419394
    … …  
    501476                    Debug.trace("  " + condition.writeToString());
    502477                }
    503                 catch (Throwable t) {}
     478                catch (Throwable t) {} // catch any exception to throw below
    504479                finally {
    505480                    thread.resetSpecialBindings(mark);
    … …  
    512487    public static final LispObject readFromString(String s)
    513488    {
    514         try {
    515             return new StringInputStream(s).read(true, NIL, false,
    516                                                  LispThread.currentThread());
    517         }
    518         catch (Throwable t) {
    519             return null;
    520         }
     489        return new StringInputStream(s).read(true, NIL, false,
     490                                             LispThread.currentThread());
    521491    }
    522492

  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r12290 r12298  
    697697                error(new WrongNumberOfArgumentsException(this));
    698698            LispObject object = args[0];
    699             try {
    700                 if (args.length > 1) {
    701                     LispObject type = args[1];
    702                     if (type == Keyword.BOOLEAN) {
    703                         if (object == NIL)
    704                             return JavaObject.getInstance(Boolean.FALSE);
    705                         else
    706                             return JavaObject.getInstance(Boolean.TRUE);
    707                     }
    708                     if (type == Keyword.REF) {
    709                         if (object == NIL)
    710                             return JavaObject.getInstance(null);
    711                         else
    712                             throw new Error();
    713                     }
    714                     // other special cases come here
     699            if (args.length > 1) {
     700                LispObject type = args[1];
     701                if (type == Keyword.BOOLEAN) {
     702                    if (object == NIL)
     703                        return JavaObject.getInstance(Boolean.FALSE);
     704                    else
     705                        return JavaObject.getInstance(Boolean.TRUE);
    715706                }
    716                 return JavaObject.getInstance(object.javaInstance());
    717             }
    718             catch (Throwable t) {
    719                 error(new LispError("MAKE-IMMEDIATE-OBJECT: not implemented"));
    720             }
    721             // Not reached.
    722             return NIL;
     707                if (type == Keyword.REF) {
     708                    if (object == NIL)
     709                        return JavaObject.getInstance(null);
     710                    else
     711                        error(new LispError("MAKE-IMMEDIATE-OBJECT: not implemented"));
     712                }
     713                // other special cases come here
     714            }
     715            return JavaObject.getInstance(object.javaInstance());
    723716        }
    724717    };

  • trunk/abcl/src/org/armedbear/lisp/JavaClassLoader.java

    r12180 r12298  
    3333
    3434package org.armedbear.lisp;
     35
     36import static org.armedbear.lisp.Lisp.*;
    3537
    3638import java.util.Collections;
    … …  
    7173
    7274    public Class<?> loadClassFromByteArray(byte[] classbytes) {
    73   return loadClassFromByteArray(null, classbytes);
     75        return loadClassFromByteArray(null, classbytes);
    7476    }
    7577
    … …  
    8890            }
    8991        }
    90   catch (LinkageError e) {
    91             throw e;
    92   }
     92      catch (LinkageError e) {
     93                throw e;
     94      }
    9395        catch (Throwable t) {
    9496            Debug.trace(t);
    … …  
    107109            }
    108110        }
     111        catch (VerifyError e)
     112          {
     113            error(new LispError("Class verification failed: " + e.getMessage()));
     114          }
    109115        catch (Throwable t) {
    110116            Debug.trace(t);

  • trunk/abcl/src/org/armedbear/lisp/Layout.java

    r12288 r12298  
    5050    this.lispClass = lispClass;
    5151    Debug.assertTrue(instanceSlots.listp());
    52     int length = 0;
    53     try
    54       {
    55         length = instanceSlots.length();
    56       }
    57     catch (Throwable t)
    58       {
    59         // Shouldn't happen.
    60         Debug.trace(t);
    61       }
     52    int length = instanceSlots.length();
    6253    slotNames = new LispObject[length];
    6354    int i = 0;
    64     try
    65       {
    66         while (instanceSlots != NIL)
    67           {
    68             slotNames[i++] = instanceSlots.car();
    69             instanceSlots = instanceSlots.cdr();
    70           }
    71       }
    72     catch (Throwable t)
    73       {
    74         // Shouldn't happen.
    75         Debug.trace(t);
    76       }
     55
     56    while (instanceSlots != NIL)
     57      {
     58        slotNames[i++] = instanceSlots.car();
     59        instanceSlots = instanceSlots.cdr();
     60      }
     61
    7762    Debug.assertTrue(i == length);
    7863    this.sharedSlots = sharedSlots;
    … …  
    154139  {
    155140    LispObject list = NIL;
    156     try
    157       {
    158         for (int i = slotNames.length; i-- > 0;)
    159           list = list.push(new SlotDefinition(slotNames[i], NIL));
    160       }
    161     catch (Throwable t)
    162       {
    163         // Shouldn't happen.
    164         Debug.trace(t);
    165       }
     141    for (int i = slotNames.length; i-- > 0;)
     142      list = list.push(new SlotDefinition(slotNames[i], NIL));
     143
    166144    return list;
    167145  }

  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r12288 r12298  
    3636import java.io.File;
    3737import java.io.FileInputStream;
     38import java.io.FileNotFoundException;
    3839import java.io.IOException;
    3940import java.io.InputStream;
    40 import java.lang.reflect.Constructor;
    4141import java.math.BigInteger;
    4242import java.net.MalformedURLException;
    … …  
    9696  static
    9797  {
    98     try
    99       {
    100         PACKAGE_CL.addNickname("CL");
    101         PACKAGE_CL_USER.addNickname("CL-USER");
    102         PACKAGE_CL_USER.usePackage(PACKAGE_CL);
    103         PACKAGE_CL_USER.usePackage(PACKAGE_EXT);
    104         PACKAGE_CL_USER.usePackage(PACKAGE_JAVA);
    105         PACKAGE_SYS.addNickname("SYS");
    106         PACKAGE_SYS.usePackage(PACKAGE_CL);
    107         PACKAGE_SYS.usePackage(PACKAGE_EXT);
    108         PACKAGE_MOP.usePackage(PACKAGE_CL);
    109         PACKAGE_MOP.usePackage(PACKAGE_EXT);
    110         PACKAGE_MOP.usePackage(PACKAGE_SYS);
    111         PACKAGE_TPL.addNickname("TPL");
    112         PACKAGE_TPL.usePackage(PACKAGE_CL);
    113         PACKAGE_TPL.usePackage(PACKAGE_EXT);
    114         PACKAGE_EXT.addNickname("EXT");
    115         PACKAGE_EXT.usePackage(PACKAGE_CL);
    116         PACKAGE_EXT.usePackage(PACKAGE_THREADS);
    117         PACKAGE_JVM.usePackage(PACKAGE_CL);
    118         PACKAGE_JVM.usePackage(PACKAGE_EXT);
    119         PACKAGE_JVM.usePackage(PACKAGE_SYS);
    120         PACKAGE_LOOP.usePackage(PACKAGE_CL);
    121         PACKAGE_PROF.addNickname("PROF");
    122         PACKAGE_PROF.usePackage(PACKAGE_CL);
    123         PACKAGE_PROF.usePackage(PACKAGE_EXT);
    124         PACKAGE_JAVA.usePackage(PACKAGE_CL);
    125         PACKAGE_JAVA.usePackage(PACKAGE_EXT);
    126         PACKAGE_LISP.usePackage(PACKAGE_CL);
    127         PACKAGE_LISP.usePackage(PACKAGE_EXT);
    128         PACKAGE_LISP.usePackage(PACKAGE_SYS);
    129         PACKAGE_THREADS.usePackage(PACKAGE_CL);
    130         PACKAGE_THREADS.usePackage(PACKAGE_EXT);
    131         PACKAGE_THREADS.usePackage(PACKAGE_SYS);
    132         PACKAGE_FORMAT.usePackage(PACKAGE_CL);
    133         PACKAGE_FORMAT.usePackage(PACKAGE_EXT);
    134         PACKAGE_XP.usePackage(PACKAGE_CL);
    135         PACKAGE_PRECOMPILER.addNickname("PRE");
    136         PACKAGE_PRECOMPILER.usePackage(PACKAGE_CL);
    137         PACKAGE_PRECOMPILER.usePackage(PACKAGE_EXT);
    138         PACKAGE_PRECOMPILER.usePackage(PACKAGE_SYS);
    139       }
    140     catch (Throwable t)
    141       {
    142         Debug.trace(t);
    143       }
     98    PACKAGE_CL.addNickname("CL");
     99    PACKAGE_CL_USER.addNickname("CL-USER");
     100    PACKAGE_CL_USER.usePackage(PACKAGE_CL);
     101    PACKAGE_CL_USER.usePackage(PACKAGE_EXT);
     102    PACKAGE_CL_USER.usePackage(PACKAGE_JAVA);
     103    PACKAGE_SYS.addNickname("SYS");
     104    PACKAGE_SYS.usePackage(PACKAGE_CL);
     105    PACKAGE_SYS.usePackage(PACKAGE_EXT);
     106    PACKAGE_MOP.usePackage(PACKAGE_CL);
     107    PACKAGE_MOP.usePackage(PACKAGE_EXT);
     108    PACKAGE_MOP.usePackage(PACKAGE_SYS);
     109    PACKAGE_TPL.addNickname("TPL");
     110    PACKAGE_TPL.usePackage(PACKAGE_CL);
     111    PACKAGE_TPL.usePackage(PACKAGE_EXT);
     112    PACKAGE_EXT.addNickname("EXT");
     113    PACKAGE_EXT.usePackage(PACKAGE_CL);
     114    PACKAGE_EXT.usePackage(PACKAGE_THREADS);
     115    PACKAGE_JVM.usePackage(PACKAGE_CL);
     116    PACKAGE_JVM.usePackage(PACKAGE_EXT);
     117    PACKAGE_JVM.usePackage(PACKAGE_SYS);
     118    PACKAGE_LOOP.usePackage(PACKAGE_CL);
     119    PACKAGE_PROF.addNickname("PROF");
     120    PACKAGE_PROF.usePackage(PACKAGE_CL);
     121    PACKAGE_PROF.usePackage(PACKAGE_EXT);
     122    PACKAGE_JAVA.usePackage(PACKAGE_CL);
     123    PACKAGE_JAVA.usePackage(PACKAGE_EXT);
     124    PACKAGE_LISP.usePackage(PACKAGE_CL);
     125    PACKAGE_LISP.usePackage(PACKAGE_EXT);
     126    PACKAGE_LISP.usePackage(PACKAGE_SYS);
     127    PACKAGE_THREADS.usePackage(PACKAGE_CL);
     128    PACKAGE_THREADS.usePackage(PACKAGE_EXT);
     129    PACKAGE_THREADS.usePackage(PACKAGE_SYS);
     130    PACKAGE_FORMAT.usePackage(PACKAGE_CL);
     131    PACKAGE_FORMAT.usePackage(PACKAGE_EXT);
     132    PACKAGE_XP.usePackage(PACKAGE_CL);
     133    PACKAGE_PRECOMPILER.addNickname("PRE");
     134    PACKAGE_PRECOMPILER.usePackage(PACKAGE_CL);
     135    PACKAGE_PRECOMPILER.usePackage(PACKAGE_EXT);
     136    PACKAGE_PRECOMPILER.usePackage(PACKAGE_SYS);
    144137  }
    145138
    … …  
    292285            return error(new StorageCondition("Stack overflow."));
    293286          }
    294         catch (Go go)
    295           {
    296             throw go;
    297           }
    298         catch (Throw t)
    299           {
    300             return error(new ControlError("Attempt to throw to the nonexistent tag " +
    301                                            t.tag.writeToString() + "."));
     287        catch (ControlTransfer c)
     288          {
     289            throw c;
    302290          }
    303291        catch (Throwable t)
    … …  
    12101198  public static final LispObject readObjectFromString(String s)
    12111199  {
    1212     try
    1213       {
    1214         return new StringInputStream(s).faslRead(true, NIL, false,
    1215                                                  LispThread.currentThread());
    1216       }
    1217     catch (Throwable t)
    1218       {
    1219         Debug.trace(t);
    1220         return null;
    1221       }
     1200    return new StringInputStream(s).faslRead(true, NIL, false,
     1201                                             LispThread.currentThread());
    12221202  }
    12231203
    … …  
    13221302                  }
    13231303              }
    1324             catch (VerifyError e)
    1325               {
    1326                 return error(new LispError("Class verification failed: " +
    1327                                             e.getMessage()));
    1328               }
    13291304            catch (IOException e)
    13301305              {
    13311306                Debug.trace(e);
    13321307              }
    1333             catch (Throwable t)
    1334               {
    1335                 Debug.trace(t);
    1336               }
    13371308          }
    13381309        return error(new LispError("Unable to load " + namestring));
    … …  
    13431314      {
    13441315        // The .cls file exists.
    1345         try
    1346           {
    1347             LispObject obj = loadCompiledFunction(new FileInputStream(file),
    1348                                                   (int) file.length());
    1349             // FIXME close stream!
     1316        LispObject obj = null;
     1317        try {
     1318            obj = loadCompiledFunction(new FileInputStream(file),
     1319                                       (int) file.length());
     1320        }
     1321        catch (FileNotFoundException e) {
     1322            return error(new LispError("Unable to load " +
     1323                         pathname.writeToString() + ": Not found."));
     1324        }
     1325        // FIXME close stream!
     1326        if (obj != null)
     1327          return obj;
     1328        return error(new LispError("Unable to load " +
     1329                                    pathname.writeToString()));
     1330      }
     1331    LispObject loadTruename = Symbol.LOAD_TRUENAME.symbolValue(thread);
     1332    String zipFileName = ((Pathname)loadTruename).getNamestring();
     1333    ZipFile zipFile = null;
     1334    try
     1335      {
     1336        zipFile = ZipCache.getZip(zipFileName);
     1337        ZipEntry entry = zipFile.getEntry(namestring);
     1338        if (entry != null)
     1339          {
     1340            LispObject obj = null;
     1341            try {
     1342                obj = loadCompiledFunction(zipFile.getInputStream(entry),
     1343                                                  (int) entry.getSize());
     1344            }
     1345            catch (IOException ignore) { };
    13501346            if (obj != null)
    13511347              return obj;
    1352           }
    1353         catch (VerifyError e)
    1354           {
    1355             return error(new LispError("Class verification failed: " +
    1356                                         e.getMessage()));
    1357           }
    1358         catch (Throwable t)
    1359           {
    1360             Debug.trace(t);
    1361           }
    1362         return error(new LispError("Unable to load " +
    1363                                     pathname.writeToString()));
    1364       }
    1365     try
    1366       {
    1367         LispObject loadTruename = Symbol.LOAD_TRUENAME.symbolValue(thread);
    1368         String zipFileName = ((Pathname)loadTruename).getNamestring();
    1369         ZipFile zipFile = ZipCache.getZip(zipFileName);
    1370         try
    1371           {
    1372             ZipEntry entry = zipFile.getEntry(namestring);
    1373             if (entry != null)
    1374               {
    1375                 LispObject obj = loadCompiledFunction(zipFile.getInputStream(entry),
    1376                                                       (int) entry.getSize());
    1377                 if (obj != null)
    1378                   return obj;
    1379                 Debug.trace("Unable to load " + namestring);
    1380                 return error(new LispError("Unable to load " + namestring));
    1381               }
    1382           }
    1383         finally
    1384           {
     1348            Debug.trace("Unable to load " + namestring);
     1349            return error(new LispError("Unable to load " + namestring));
     1350          }
     1351      }
     1352    catch (IOException ignore) {
     1353        //ignore IOException from ZipCache.getZip()
     1354    }
     1355    finally
     1356      {
     1357        try {
    13851358            ZipCache.removeZip(zipFile.getName());
    1386           }
    1387       }
    1388     catch (Throwable t)
    1389       {
    1390         Debug.trace(t);
     1359        }
     1360        catch (IOException ignore) { } // ignore
    13911361      }
    13921362    return error(new FileError("File not found: " + namestring,
    … …  
    13941364  }
    13951365
    1396     public static final LispObject makeCompiledFunctionFromClass(Class<?> c)
    1397   throws Exception {
    1398   if (c != null) {
    1399       LispObject obj = (LispObject)c.newInstance();
    1400       return obj;
    1401         } else {
    1402             return null;
     1366    public static final LispObject makeCompiledFunctionFromClass(Class<?> c) {
     1367  if (c != null)
     1368        try {
     1369            return (LispObject)c.newInstance();
    14031370        }
     1371        catch (InstantiationException ignore) {
     1372            // ignore
     1373        }
     1374        catch (IllegalAccessException ignore) {
     1375            // ignore
     1376        }
     1377    return null;
    14041378    }
    14051379
    14061380  private static final LispObject loadCompiledFunction(InputStream in, int size)
    14071381  {
    1408     try
    1409       {
    1410         byte[] bytes = new byte[size];
    1411         int bytesRemaining = size;
    1412         int bytesRead = 0;
     1382    byte[] bytes = new byte[size];
     1383    int bytesRemaining = size;
     1384    int bytesRead = 0;
     1385    try {
    14131386        while (bytesRemaining > 0)
    14141387          {
    … …  
    14201393          }
    14211394        in.close();
    1422         if (bytesRemaining > 0)
    1423           Debug.trace("bytesRemaining = " + bytesRemaining);
    1424 
    1425         return loadCompiledFunction(bytes);
    1426       }
    1427     catch (Throwable t)
    1428       {
    1429         Debug.trace(t);
    1430       }
    1431     return null;
    1432   }
    1433 
    1434     public static final LispObject loadCompiledFunction(byte[] bytes) throws Throwable {
    1435   return loadCompiledFunction(bytes, new JavaClassLoader());
    14361395    }
    1437 
    1438     public static final LispObject loadCompiledFunction(byte[] bytes, JavaClassLoader cl) throws Throwable {
     1396    catch (IOException e) {
     1397        return null; // fixme: return an error?
     1398    }
     1399    if (bytesRemaining > 0)
     1400      Debug.trace("bytesRemaining = " + bytesRemaining);
     1401
     1402    return loadCompiledFunction(bytes);
     1403  }
     1404
     1405    public static final LispObject loadCompiledFunction(byte[] bytes) {
     1406        return loadCompiledFunction(bytes, new JavaClassLoader());
     1407    }
     1408
     1409    public static final LispObject loadCompiledFunction(byte[] bytes, JavaClassLoader cl) {
    14391410        Class<?> c = cl.loadClassFromByteArray(null, bytes, 0, bytes.length);
    1440   LispObject obj = makeCompiledFunctionFromClass(c);
    1441   if (obj instanceof Function) {
    1442       ((Function)obj).setClassBytes(bytes);
    1443   }
    1444   return obj;
     1411        LispObject obj = makeCompiledFunctionFromClass(c);
     1412        if (obj instanceof Function) {
     1413            ((Function)obj).setClassBytes(bytes);
     1414        }
     1415        return obj;
    14451416    }
    14461417

  • trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java

    r12288 r12298  
    122122       result =  unreadableString(LISP_STACK_FRAME + " "
    123123          + toLispString().getStringValue());
    124      } catch (Throwable t) {
     124     } catch (Throwable t) { // error while printing stack
    125125       Debug.trace("Serious printing error: ");
    126126       Debug.trace(t);
    … …  
    193193    try {
    194194      result = this.toLispList().writeToString();
    195     } catch (Throwable t) {
     195    } catch (Throwable t) { // error while printing stack
    196196      Debug.trace("Serious printing error: ");
    197197      Debug.trace(t);

  • trunk/abcl/src/org/armedbear/lisp/LispThread.java

    r12288 r12298  
    9191                      // Might happen.
    9292                }
    93                 catch (Throwable t) {
     93                catch (Throwable t) { // any error: process thread interrupts
    9494                    if (isInterrupted()) {
    9595                        processThreadInterrupts();
    … …  
    724724    {
    725725        if (stack != null) {
    726             try {
    727                 int count = 0;
    728                 Stream out =
    729                     checkCharacterOutputStream(Symbol.TRACE_OUTPUT.symbolValue());
    730                 out._writeLine("Evaluation stack:");
     726            int count = 0;
     727            Stream out =
     728                checkCharacterOutputStream(Symbol.TRACE_OUTPUT.symbolValue());
     729            out._writeLine("Evaluation stack:");
     730            out._finishOutput();
     731
     732            StackFrame s = stack;
     733            while (s != null) {
     734                out._writeString("  ");
     735                out._writeString(String.valueOf(count));
     736                out._writeString(": ");
     737
     738                pprint(s.toLispList(), out.getCharPos(), out);
     739                out.terpri();
    731740                out._finishOutput();
    732 
    733                 StackFrame s = stack;
    734                 while (s != null) {
    735                     out._writeString("  ");
    736                     out._writeString(String.valueOf(count));
    737                     out._writeString(": ");
    738                    
    739                     pprint(s.toLispList(), out.getCharPos(), out);
    740                     out.terpri();
    741                     out._finishOutput();
    742                     if (limit > 0 && ++count == limit)
    743                         break;
    744                     s = s.next;
    745                 }
    746             }
    747             catch (Throwable t) {
    748                 t.printStackTrace();
     741                if (limit > 0 && ++count == limit)
     742                    break;
     743                s = s.next;
    749744            }
    750745        }
    … …  
    756751        if (stack != null) {
    757752            int count = 0;
    758             try {
    759                 StackFrame s = stack;
    760                 while (s != null) {
    761                     result = result.push(s);
    762                     if (limit > 0 && ++count == limit)
    763                         break;
    764                     s = s.getNext();
    765                 }
    766             }
    767             catch (Throwable t) {
    768                 t.printStackTrace();
     753            StackFrame s = stack;
     754            while (s != null) {
     755                result = result.push(s);
     756                if (limit > 0 && ++count == limit)
     757                    break;
     758                s = s.getNext();
    769759            }
    770760        }

  • trunk/abcl/src/org/armedbear/lisp/Load.java

    r12290 r12298  
    180180                zipfile = ZipCache.getZip(zipFileName);
    181181            }
    182             catch (Throwable t) {
     182            catch (IOException e) {
    183183                return error (new FileError("Zip file not found: " + filename, pathname));
    184184            }
    … …  
    374374                                // Fall through.
    375375                            }
    376                             catch (Throwable t) {
    377                                 Debug.trace(t);
    378                                 in = null;
    379                                 // Fall through.
     376                            catch (IOException e) {
     377                                // fall through
    380378                            }
    381379                        }
    … …  
    673671                    && bytes[3] == 0x04);
    674672        }
    675         catch (Throwable t) {
     673        catch (Throwable t) { // any error probably means 'no'
    676674            return false;
    677675        }
    … …  
    681679                    in.close();
    682680                }
    683                 catch (Throwable t) {}
     681                catch (IOException e) {} // ignore exceptions
    684682            }
    685683        }

  • trunk/abcl/src/org/armedbear/lisp/MathFunctions.java

    r12290 r12298  
    269269        }
    270270        if (arg instanceof SingleFloat) {
    271             try {
    272                 double d = Math.sinh(((SingleFloat)arg).value);
    273                 return new SingleFloat((float)d);
    274             }
    275             catch (Throwable t) {
    276                 Debug.trace(t);
    277                 // Fall through...
    278             }
     271            double d = Math.sinh(((SingleFloat)arg).value);
     272            return new SingleFloat((float)d);
    279273        } else if (arg instanceof DoubleFloat) {
    280             try {
    281                 double d = Math.sinh(((DoubleFloat)arg).value);
    282                 return new DoubleFloat(d);
    283             }
    284             catch (Throwable t) {
    285                 Debug.trace(t);
    286                 // Fall through...
    287             }
     274            double d = Math.sinh(((DoubleFloat)arg).value);
     275            return new DoubleFloat(d);
    288276        }
    289277        LispObject result = exp(arg);
    … …  
    319307        }
    320308        if (arg instanceof SingleFloat) {
    321             try {
    322                 double d = Math.cosh(((SingleFloat)arg).value);
    323                 return new SingleFloat((float)d);
    324             }
    325             catch (Throwable t) {
    326                 Debug.trace(t);
    327                 // Fall through...
    328             }
     309            double d = Math.cosh(((SingleFloat)arg).value);
     310            return new SingleFloat((float)d);
    329311        } else if (arg instanceof DoubleFloat) {
    330             try {
    331                 double d = Math.cosh(((DoubleFloat)arg).value);
    332                 return new DoubleFloat(d);
    333             }
    334             catch (Throwable t) {
    335                 Debug.trace(t);
    336                 // Fall through...
    337             }
     312            double d = Math.cosh(((DoubleFloat)arg).value);
     313            return new DoubleFloat(d);
    338314        }
    339315        LispObject result = exp(arg);
    … …  
    357333        {
    358334            if (arg instanceof SingleFloat) {
    359                 try {
    360                     double d = Math.tanh(((SingleFloat)arg).value);
    361                     return new SingleFloat((float)d);
    362                 }
    363                 catch (Throwable t) {
    364                     Debug.trace(t);
    365                     // Fall through...
    366                 }
     335                double d = Math.tanh(((SingleFloat)arg).value);
     336                return new SingleFloat((float)d);
    367337            } else if (arg instanceof DoubleFloat) {
    368                 try {
    369                     double d = Math.tanh(((DoubleFloat)arg).value);
    370                     return new DoubleFloat(d);
    371                 }
    372                 catch (Throwable t) {
    373                     Debug.trace(t);
    374                     // Fall through...
    375                 }
     338                double d = Math.tanh(((DoubleFloat)arg).value);
     339                return new DoubleFloat(d);
    376340            }
    377341            return sinh(arg).divideBy(cosh(arg));
    … …  
    577541            if (number.realp() && !number.minusp()
    578542                && base.isEqualTo(Fixnum.getInstance(10))) {
    579                 try {
    580                     double d =
    581                         Math.log10(DoubleFloat.coerceToFloat(number).value);
    582                     if (number instanceof DoubleFloat
    583                         || base instanceof DoubleFloat)
    584                         return new DoubleFloat(d);
    585                     else
    586                         return new SingleFloat((float)d);
    587                 }
    588                 catch (Throwable t) {
    589                     Debug.trace(t);
    590                     // Fall through...
    591                 }
     543                double d =
     544                    Math.log10(DoubleFloat.coerceToFloat(number).value);
     545                if (number instanceof DoubleFloat
     546                    || base instanceof DoubleFloat)
     547                    return new DoubleFloat(d);
     548                else
     549                    return new SingleFloat((float)d);
    592550            }
    593551            return log(number).divideBy(log(base));

  • trunk/abcl/src/org/armedbear/lisp/Package.java

    r12288 r12298  
    264264        Debug.assertTrue(symbol.getPackage() == this);
    265265        Debug.assertTrue(symbol.getName().equals("NIL"));
    266         try {
    267             externalSymbols.put(symbol.name, symbol);
    268         }
    269         catch (Throwable t) {
    270             Debug.trace(t); // FIXME
    271         }
     266        externalSymbols.put(symbol.name, symbol);
    272267    }
    273268
    … …  
    275270    {
    276271        Symbol symbol = new Symbol(name, hash, this);
    277         try {
    278             if (this == PACKAGE_KEYWORD) {
    279                 symbol.initializeConstant(symbol);
    280                 externalSymbols.put(name, symbol);
    281             } else
    282                 internalSymbols.put(name, symbol);
    283         }
    284         catch (Throwable t) {
    285             Debug.trace(t); // FIXME
    286         }
     272        if (this == PACKAGE_KEYWORD) {
     273            symbol.initializeConstant(symbol);
     274            externalSymbols.put(name, symbol);
     275        } else
     276            internalSymbols.put(name, symbol);
     277       
    287278        return symbol;
    288279    }
    … …  
    319310        // Look in external symbols of used packages.
    320311        if (useList instanceof Cons) {
    321             try {
    322                 LispObject usedPackages = useList;
    323                 while (usedPackages != NIL) {
    324                     Package pkg = (Package) usedPackages.car();
    325                     symbol = pkg.findExternalSymbol(symbolName, hash);
    326                     if (symbol != null)
    327                         return symbol;
    328                     usedPackages = usedPackages.cdr();
    329                 }
    330             }
    331             catch (Throwable t) {
    332                 Debug.trace(t);
     312            LispObject usedPackages = useList;
     313            while (usedPackages != NIL) {
     314                Package pkg = (Package) usedPackages.car();
     315                symbol = pkg.findExternalSymbol(symbolName, hash);
     316                if (symbol != null)
     317                    return symbol;
     318                usedPackages = usedPackages.cdr();
    333319            }
    334320        }
    … …  
    350336        // Look in external symbols of used packages.
    351337        if (useList instanceof Cons) {
    352             try {
    353                 LispObject usedPackages = useList;
    354                 while (usedPackages != NIL) {
    355                     Package pkg = (Package) usedPackages.car();
    356                     symbol = pkg.findExternalSymbol(s, hash);
    357                     if (symbol != null)
    358                         return (Symbol) thread.setValues(symbol, Keyword.INHERITED);
    359                     usedPackages = usedPackages.cdr();
    360                 }
    361             }
    362             catch (Throwable t) {
    363                 Debug.trace(t);
     338            LispObject usedPackages = useList;
     339            while (usedPackages != NIL) {
     340                Package pkg = (Package) usedPackages.car();
     341                symbol = pkg.findExternalSymbol(s, hash);
     342                if (symbol != null)
     343                    return (Symbol) thread.setValues(symbol, Keyword.INHERITED);
     344                usedPackages = usedPackages.cdr();
    364345            }
    365346        }
    … …  
    757738        list.addAll(externalSymbols.getSymbols());
    758739        if (useList instanceof Cons) {
    759             try {
    760                 LispObject usedPackages = useList;
    761                 while (usedPackages != NIL) {
    762                     Package pkg = (Package) usedPackages.car();
    763                     List<Symbol> symbols = pkg.externalSymbols.getSymbols();
    764                     for (int i = 0; i < symbols.size(); i++) {
    765                         Symbol symbol = (Symbol) symbols.get(i);
    766                         if (shadowingSymbols == null || shadowingSymbols.get(symbol.getName()) == null)
    767                             list.add(symbol);
    768                     }
    769                     usedPackages = usedPackages.cdr();
    770                 }
    771             }
    772             catch (Throwable t) {
    773                 Debug.trace(t);
     740            LispObject usedPackages = useList;
     741            while (usedPackages != NIL) {
     742                Package pkg = (Package) usedPackages.car();
     743                List<Symbol> symbols = pkg.externalSymbols.getSymbols();
     744                for (int i = 0; i < symbols.size(); i++) {
     745                    Symbol symbol = (Symbol) symbols.get(i);
     746                    if (shadowingSymbols == null || shadowingSymbols.get(symbol.getName()) == null)
     747                        list.add(symbol);
     748                }
     749                usedPackages = usedPackages.cdr();
    774750            }
    775751        }
    … …  
    799775        LispObject list = NIL;
    800776        if (useList instanceof Cons) {
    801             try {
    802                 LispObject usedPackages = useList;
    803                 while (usedPackages != NIL) {
    804                     Package pkg = (Package) usedPackages.car();
    805                     List externals = pkg.getExternalSymbols();
    806                     for (int i = externals.size(); i-- > 0;) {
    807                         Symbol symbol = (Symbol) externals.get(i);
    808                         if (shadowingSymbols != null && shadowingSymbols.get(symbol.getName()) != null)
    809                             continue;
    810                         if (externalSymbols.get(symbol.name) == symbol)
    811                             continue;
    812                         list = new Cons(symbol, list);
    813                     }
    814                     usedPackages = usedPackages.cdr();
    815                 }
    816             }
    817             catch (Throwable t) {
    818                 Debug.trace(t);
     777            LispObject usedPackages = useList;
     778            while (usedPackages != NIL) {
     779                Package pkg = (Package) usedPackages.car();
     780                List externals = pkg.getExternalSymbols();
     781                for (int i = externals.size(); i-- > 0;) {
     782                    Symbol symbol = (Symbol) externals.get(i);
     783                    if (shadowingSymbols != null && shadowingSymbols.get(symbol.getName()) != null)
     784                        continue;
     785                    if (externalSymbols.get(symbol.name) == symbol)
     786                        continue;
     787                    list = new Cons(symbol, list);
     788                }
     789                usedPackages = usedPackages.cdr();
    819790            }
    820791        }

  • trunk/abcl/src/org/armedbear/lisp/Pathname.java

    r12288 r12298  
    498498        boolean useNamestring;
    499499        String s = null;
    500         try {
    501             s = getNamestring();
    502         }
    503         // ### FIXME exception
    504         catch (Throwable t) {}
     500        s = getNamestring();
    505501        if (s != null) {
    506502            useNamestring = true;
    … …  
    13891385
    13901386    static {
    1391         try {
    1392             LispObject obj = Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue();
    1393             Symbol.DEFAULT_PATHNAME_DEFAULTS.setSymbolValue(coerceToPathname(obj));
    1394         }
    1395         catch (Throwable t) {
    1396             Debug.trace(t);
    1397         }
     1387        LispObject obj = Symbol.DEFAULT_PATHNAME_DEFAULTS.getSymbolValue();
     1388        Symbol.DEFAULT_PATHNAME_DEFAULTS.setSymbolValue(coerceToPathname(obj));
    13981389    }
    13991390}

  • trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java

    r12288 r12298  
    8484        FastStringBuffer sb = new FastStringBuffer();
    8585        LispObject object = UNBOUND_VALUE;
    86         try {
    87             object = getInstanceSlotValue(Symbol.OBJECT);
    88         }
    89         catch (Throwable t) {
    90             Debug.trace(t);
    91         }
     86        object = getInstanceSlotValue(Symbol.OBJECT);
    9287        if (object != UNBOUND_VALUE) {
    9388            final LispThread thread = LispThread.currentThread();
    … …  
    9792            try {
    9893                sb.append(object.writeToString());
    99             }
    100             catch (Throwable t) {
    101                 sb.append("Object");
    10294            }
    10395            finally {

  • trunk/abcl/src/org/armedbear/lisp/RandomState.java

    r12288 r12298  
    6565            random = (Random) in.readObject();
    6666            in.close();
    67             file.delete();
     67            file.delete(); // FIXME: file leak on exception
    6868        }
    69         catch (Throwable t) {
     69        catch (Throwable t) { // ANY exception gets converted to a lisp error
    7070            error(new LispError("Unable to copy random state."));
    7171        }

  • trunk/abcl/src/org/armedbear/lisp/Return.java

    r12255 r12298  
    7272    public LispObject getCondition()
    7373    {
    74         try {
    75             FastStringBuffer sb = new FastStringBuffer("No block named ");
    76             sb.append(tag.writeToString());
    77             sb.append(" is currently visible.");
    78             return new ControlError(sb.toString());
    79         }
    80         catch (Throwable t) {
    81             Debug.trace(t);
    82             return new Condition();
    83         }
     74        FastStringBuffer sb = new FastStringBuffer("No block named ");
     75        sb.append(tag.writeToString());
     76        sb.append(" is currently visible.");
     77        return new ControlError(sb.toString());
    8478    }
    8579}

  • trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java

    r12290 r12298  
    123123                                            e.getMessage()));
    124124            }
    125             catch (Throwable t) {
    126                 Debug.trace(t);
    127             }
    128125            return error(
    129126                new LispError("unable to load ".concat(cn)));

  • trunk/abcl/src/org/armedbear/lisp/ShellCommand.java

    r12290 r12298  
    205205                if (s == null)
    206206                    return;
    207                 try {
    208                     processOutput(s);
    209                 }
    210                 catch (Throwable t) {
    211                     Debug.trace(t);
    212                 }
     207                processOutput(s);
    213208            }
    214209        }
    … …  
    233228            }
    234229            catch (InterruptedException e) {
    235                 return null;
    236             }
    237             catch (Throwable t) {
    238230                return null;
    239231            }

  • trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java

    r12288 r12298  
    7373    public String getMessage()
    7474    {
    75         try {
    76             LispObject formatControl = getFormatControl();
    77             if (formatControl != NIL) {
    78                 LispObject formatArguments = getFormatArguments();
    79                 // (apply 'format (append '(nil format-control) format-arguments))
    80                 LispObject result =
    81                     Primitives.APPLY.execute(Symbol.FORMAT,
    82                                              Primitives.APPEND.execute(list(NIL,
    83                                                                              formatControl),
    84                                                                        formatArguments));
    85                 return result.getStringValue();
    86             }
    87             return super.getMessage();
     75        LispObject formatControl = getFormatControl();
     76        if (formatControl != NIL) {
     77            LispObject formatArguments = getFormatArguments();
     78            // (apply 'format (append '(nil format-control) format-arguments))
     79            LispObject result =
     80                Primitives.APPLY.execute(Symbol.FORMAT,
     81                                         Primitives.APPEND.execute(list(NIL,
     82                                                                         formatControl),
     83                                                                   formatArguments));
     84            return result.getStringValue();
    8885        }
    89         catch (Throwable t) {}
    90         return null;
     86        return super.getMessage();
    9187    }
    9288}

  • trunk/abcl/src/org/armedbear/lisp/Site.java

    r12291 r12298  
    8484
    8585    static {
    86         try {
    87             String s = Site.getLispHome();
    88             if (s != null)
    89                 _LISP_HOME_.setSymbolValue(new Pathname(s));
    90         }
    91         catch (Throwable t) {
    92             Debug.trace(t);
    93         }
     86        String s = Site.getLispHome();
     87        if (s != null)
     88            _LISP_HOME_.setSymbolValue(new Pathname(s));
    9489    }
    9590}

  • trunk/abcl/src/org/armedbear/lisp/SiteName.java

    r12290 r12298  
    3737
    3838import java.net.InetAddress;
     39import java.net.UnknownHostException;
    3940
    4041public final class SiteName
    … …  
    4344    {
    4445        String hostName = null;
     46        InetAddress addr;
    4547        try {
    46             InetAddress addr = InetAddress.getLocalHost();
    47             if (addr != null)
    48                 hostName = addr.getHostName();
     48            addr = InetAddress.getLocalHost();
    4949        }
    50         catch (Throwable t) {}
     50        catch (UnknownHostException e) {
     51            addr = null;
     52        }
     53        if (addr != null)
     54            hostName = addr.getHostName();
     55
    5156        return hostName != null ? new SimpleString(hostName) : NIL;
    5257    }

  • trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java

    r12288 r12298  
    9797    {
    9898        if (offset >= length) {
    99             try {
    100                 ostream.finishOutput();
    101                 s = LispThread.currentThread().execute(f).getStringValue();
    102             }
    103             catch (Throwable t) {
    104                 return -1;
    105             }
     99            ostream.finishOutput();
     100            s = LispThread.currentThread().execute(f).getStringValue();
    106101            if (s.length() == 0)
    107102                return -1;

  • trunk/abcl/src/org/armedbear/lisp/SlotClass.java

    r12288 r12298  
    124124        if (isFinalized())
    125125            return;
    126         try {
    127             Debug.assertTrue(slotDefinitions == NIL);
    128             LispObject cpl = getCPL();
    129             Debug.assertTrue(cpl != null);
    130             Debug.assertTrue(cpl.listp());
    131             cpl = cpl.reverse();
    132             while (cpl != NIL) {
    133                 LispObject car = cpl.car();
    134                 if (car instanceof StandardClass) {
    135                     StandardClass cls = (StandardClass) car;
    136                     LispObject defs = cls.getDirectSlotDefinitions();
    137                     Debug.assertTrue(defs != null);
    138                     Debug.assertTrue(defs.listp());
    139                     while (defs != NIL) {
    140                         slotDefinitions = slotDefinitions.push(defs.car());
    141                         defs = defs.cdr();
    142                     }
     126
     127        Debug.assertTrue(slotDefinitions == NIL);
     128        LispObject cpl = getCPL();
     129        Debug.assertTrue(cpl != null);
     130        Debug.assertTrue(cpl.listp());
     131        cpl = cpl.reverse();
     132        while (cpl != NIL) {
     133            LispObject car = cpl.car();
     134            if (car instanceof StandardClass) {
     135                StandardClass cls = (StandardClass) car;
     136                LispObject defs = cls.getDirectSlotDefinitions();
     137                Debug.assertTrue(defs != null);
     138                Debug.assertTrue(defs.listp());
     139                while (defs != NIL) {
     140                    slotDefinitions = slotDefinitions.push(defs.car());
     141                    defs = defs.cdr();
    143142                }
    144                 cpl = cpl.cdr();
    145             }
    146             slotDefinitions = slotDefinitions.nreverse();
    147             LispObject[] instanceSlotNames = new LispObject[slotDefinitions.length()];
    148             int i = 0;
    149             LispObject tail = slotDefinitions;
    150             while (tail != NIL) {
    151                 SlotDefinition slotDefinition = (SlotDefinition) tail.car();
    152                 slotDefinition.setLocation(i);
    153                 instanceSlotNames[i++] = slotDefinition.getName();
    154                 tail = tail.cdr();
    155             }
    156             setClassLayout(new Layout(this, instanceSlotNames, NIL));
    157             setDefaultInitargs(computeDefaultInitargs());
    158             setFinalized(true);
    159         }
    160         catch (Throwable t) {
    161             Debug.trace(t);
    162         }
     143            }
     144            cpl = cpl.cdr();
     145        }
     146        slotDefinitions = slotDefinitions.nreverse();
     147        LispObject[] instanceSlotNames = new LispObject[slotDefinitions.length()];
     148        int i = 0;
     149        LispObject tail = slotDefinitions;
     150        while (tail != NIL) {
     151            SlotDefinition slotDefinition = (SlotDefinition) tail.car();
     152            slotDefinition.setLocation(i);
     153            instanceSlotNames[i++] = slotDefinition.getName();
     154            tail = tail.cdr();
     155        }
     156        setClassLayout(new Layout(this, instanceSlotNames, NIL));
     157        setDefaultInitargs(computeDefaultInitargs());
     158        setFinalized(true);
    163159    }
    164160

  • trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java

    r12288 r12298  
    4848  {
    4949    this();
    50     try
    51       {
    52         Debug.assertTrue(name instanceof Symbol);
    53         slots[SlotDefinitionClass.SLOT_INDEX_NAME] = name;
    54         slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = NIL;
    55         slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] =
    56           new Cons(PACKAGE_KEYWORD.intern(((Symbol)name).getName()));
    57         slots[SlotDefinitionClass.SLOT_INDEX_READERS] = readers;
    58         slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = Keyword.INSTANCE;
    59       }
    60     catch (Throwable t)
    61       {
    62         Debug.trace(t);
    63       }
     50    Debug.assertTrue(name instanceof Symbol);
     51    slots[SlotDefinitionClass.SLOT_INDEX_NAME] = name;
     52    slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = NIL;
     53    slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] =
     54      new Cons(PACKAGE_KEYWORD.intern(((Symbol)name).getName()));
     55    slots[SlotDefinitionClass.SLOT_INDEX_READERS] = readers;
     56    slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = Keyword.INSTANCE;
    6457  }
    6558
    … …  
    6861  {
    6962    this();
    70     try
    71       {
    72         Debug.assertTrue(name instanceof Symbol);
    73         slots[SlotDefinitionClass.SLOT_INDEX_NAME] = name;
    74         slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = NIL;
    75         slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = initForm;
    76         slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] =
    77           new Cons(PACKAGE_KEYWORD.intern(((Symbol)name).getName()));
    78         slots[SlotDefinitionClass.SLOT_INDEX_READERS] = readers;
    79         slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = Keyword.INSTANCE;
    80       }
    81     catch (Throwable t)
    82       {
    83         Debug.trace(t);
    84       }
     63    Debug.assertTrue(name instanceof Symbol);
     64    slots[SlotDefinitionClass.SLOT_INDEX_NAME] = name;
     65    slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = NIL;
     66    slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = initForm;
     67    slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] =
     68      new Cons(PACKAGE_KEYWORD.intern(((Symbol)name).getName()));
     69    slots[SlotDefinitionClass.SLOT_INDEX_READERS] = readers;
     70    slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = Keyword.INSTANCE;
    8571  }
    8672 

  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r12288 r12298  
    248248  public final String getName()
    249249  {
    250     try
    251       {
    252         return name.getStringValue();
    253       }
    254     catch (Throwable t)
    255       {
    256         Debug.trace(t);
    257         return null;
    258       }
     250    return name.getStringValue();
    259251  }
    260252
    261253  public final String getQualifiedName()
    262254  {
    263     try
    264       {
    265         final String n = name.getStringValue();
    266         if (pkg == NIL)
    267           return("#:".concat(n));
    268         if (pkg == PACKAGE_KEYWORD)
    269           return ":".concat(n);
    270         FastStringBuffer sb = new FastStringBuffer(((Package)pkg).getName());
    271         if (((Package)pkg).findExternalSymbol(name) != null)
    272           sb.append(':');
    273         else
    274           sb.append("::");
    275         sb.append(n);
    276         return sb.toString();
    277       }
    278     catch (Throwable t)
    279       {
    280         Debug.trace(t);
    281         return null;
    282       }
     255    final String n = name.getStringValue();
     256    if (pkg == NIL)
     257      return("#:".concat(n));
     258    if (pkg == PACKAGE_KEYWORD)
     259      return ":".concat(n);
     260    FastStringBuffer sb = new FastStringBuffer(((Package)pkg).getName());
     261    if (((Package)pkg).findExternalSymbol(name) != null)
     262      sb.append(':');
     263    else
     264      sb.append("::");
     265    sb.append(n);
     266    return sb.toString();
    283267  }
    284268

  • trunk/abcl/src/org/armedbear/lisp/SymbolHashTable.java

    r11698 r12298  
    6666        HashEntry e = buckets[key.sxhash() & mask];
    6767        while (e != null) {
    68             try {
    69                 if (key.equal(e.symbol.name))
    70                     return e.symbol; // Return the symbol.
    71             }
    72             catch (Throwable t) {
    73                 Debug.trace(t); // Shouldn't happen.
    74             }
     68            if (key.equal(e.symbol.name))
     69                return e.symbol; // Return the symbol.
    7570            e = e.next;
    7671        }
    … …  
    8277        HashEntry e = buckets[hash & mask];
    8378        while (e != null) {
    84             try {
    85                 if (key.equal(e.symbol.name))
    86                     return e.symbol; // Return the symbol.
    87             }
    88             catch (Throwable t) {
    89                 Debug.trace(t); // Shouldn't happen.
    90             }
     79            if (key.equal(e.symbol.name))
     80                return e.symbol; // Return the symbol.
    9181            e = e.next;
    9282        }
    … …  
    9989        HashEntry e = buckets[index];
    10090        while (e != null) {
    101             try {
    102                 if (key.equal(e.symbol.name)) {
    103                     if (e.symbol != symbol) {
    104                         Debug.trace("replacing existing key for " + key.getStringValue() +
    105                                     " in package " + e.symbol.getPackage().writeToString());
    106                         Thread.dumpStack();
    107                         e.symbol = symbol;
    108                     }
    109                     return;
     91            if (key.equal(e.symbol.name)) {
     92                if (e.symbol != symbol) {
     93                    Debug.trace("replacing existing key for " + key.getStringValue() +
     94                                " in package " + e.symbol.getPackage().writeToString());
     95                    Thread.dumpStack();
     96                    e.symbol = symbol;
    11097                }
    111             }
    112             catch (Throwable t) {
    113                 Debug.trace(t); // FIXME
     98                return;
    11499            }
    115100            e = e.next;
    … …  
    131116        HashEntry e = buckets[index];
    132117        while (e != null) {
    133             try {
    134                 if (symbol.name.equal(e.symbol.name)) {
    135                     if (e.symbol != symbol) {
    136                         Debug.trace("replacing existing key for " + symbol.getName());
    137                         Thread.dumpStack();
    138                         e.symbol = symbol; // Replace existing key.
    139                     }
    140                     return;
     118            if (symbol.name.equal(e.symbol.name)) {
     119                if (e.symbol != symbol) {
     120                    Debug.trace("replacing existing key for " + symbol.getName());
     121                    Thread.dumpStack();
     122                    e.symbol = symbol; // Replace existing key.
    141123                }
    142             }
    143             catch (Throwable t) {
    144                 Debug.trace(t); // FIXME
     124                return;
    145125            }
    146126            e = e.next;
    … …  
    165145        HashEntry last = null;
    166146        while (e != null) {
    167             try {
    168                 if (key.equal(e.symbol.name)) {
    169                     if (last == null)
    170                         buckets[index] = e.next;
    171                     else
    172                         last.next = e.next;
    173                     --count;
    174                     return e.symbol; // The key is the value!
    175                 }
    176             }
    177             catch (Throwable t) {
    178                 Debug.trace(t); // FIXME
     147            if (key.equal(e.symbol.name)) {
     148                if (last == null)
     149                    buckets[index] = e.next;
     150                else
     151                    last.next = e.next;
     152                --count;
     153                return e.symbol; // The key is the value!
    179154            }
    180155            last = e;

  • trunk/abcl/src/org/armedbear/lisp/Throw.java

    r12255 r12298  
    5757    public LispObject getCondition()
    5858    {
    59         try {
    60             return new ControlError("Attempt to throw to the nonexistent tag " +
    61                                     tag.writeToString() + ".");
    62         }
    63         catch (Throwable t) {
    64             Debug.trace(t);
    65             return new Condition();
    66         }
     59        return new ControlError("Attempt to throw to the nonexistent tag " +
     60                                tag.writeToString() + ".");
    6761    }
    6862}

  • trunk/abcl/src/org/armedbear/lisp/TypeError.java

    r12288 r12298  
    130130    public String getMessage()
    131131    {
    132         // FIXME
     132        final LispThread thread = LispThread.currentThread();
     133        final SpecialBindingsMark mark = thread.markSpecialBindings();
     134        thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
    133135        try {
    134             final LispThread thread = LispThread.currentThread();
    135             final SpecialBindingsMark mark = thread.markSpecialBindings();
    136             thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
    137             try {
    138                 String s = super.getMessage();
    139                 if (s != null)
    140                     return s;
    141                 final LispObject datum = getDatum();
    142                 final LispObject expectedType = getExpectedType();
    143                 FastStringBuffer sb = new FastStringBuffer();
    144                 String name = datum != null ? datum.writeToString() : null;
    145                 String type = null;
    146                 if (expectedType != null)
    147                     type = expectedType.writeToString();
    148                 if (type != null) {
    149                     if (name != null) {
    150                         sb.append("The value ");
    151                         sb.append(name);
    152                     } else
    153                         sb.append("Value");
    154                     sb.append(" is not of type ");
    155                     sb.append(type);
    156                 } else if (name != null) {
    157                     sb.append("Wrong type: ");
     136            String s = super.getMessage();
     137            if (s != null)
     138                return s;
     139            final LispObject datum = getDatum();
     140            final LispObject expectedType = getExpectedType();
     141            FastStringBuffer sb = new FastStringBuffer();
     142            String name = datum != null ? datum.writeToString() : null;
     143            String type = null;
     144            if (expectedType != null)
     145                type = expectedType.writeToString();
     146            if (type != null) {
     147                if (name != null) {
     148                    sb.append("The value ");
    158149                    sb.append(name);
    159                 }
    160                 sb.append('.');
    161                 return sb.toString();
    162             }
    163             catch (Throwable t) {
    164                 // FIXME
    165                 Debug.trace(t);
    166                 return toString();
    167             }
    168             finally {
    169                 thread.resetSpecialBindings(mark);
    170             }
    171         }
    172         catch (Throwable t) {
    173             return toString();
     150                } else
     151                    sb.append("Value");
     152                sb.append(" is not of type ");
     153                sb.append(type);
     154            } else if (name != null) {
     155                sb.append("Wrong type: ");
     156                sb.append(name);
     157            }
     158            sb.append('.');
     159            return sb.toString();
     160        }
     161        finally {
     162            thread.resetSpecialBindings(mark);
    174163        }
    175164    }

  • trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java

    r12288 r12298  
    5555    thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
    5656    StringBuffer sb = new StringBuffer("The variable ");
    57     // FIXME
    58     try
    59       {
     57    try {
    6058        sb.append(getCellName().writeToString());
    61       }
    62     catch (Throwable t) {}
     59    }
    6360    finally {
    6461        thread.resetSpecialBindings(mark);

  • trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java

    r12288 r12298  
    5959        if (lambdaName != null && lambdaName != NIL) {
    6060            sb.append(" for ");
    61             try {
    62                 sb.append(operator.getLambdaName().writeToString());
    63             }
    64             catch (Throwable t) {
    65                 Debug.trace(t);
    66             }
     61            sb.append(operator.getLambdaName().writeToString());
    6762        }
    6863        sb.append('.');
Note: See TracChangeset for help on using the changeset viewer.