Changeset 12298
- Timestamp:
- 12/18/09 21:50:54 (11 years ago)
- Location:
- trunk/abcl/src/org/armedbear/lisp
- Files:
-
- 33 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
r12288 r12298 295 295 public int psxhash() 296 296 { 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); 314 307 } 315 308 -
trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
r12288 r12298 277 277 public int psxhash() 278 278 { 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); 294 285 } 295 286 -
trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java
r12288 r12298 292 292 static 293 293 { 294 try 295 { 296 StandardClass.initializeStandardClasses(); 297 } 298 catch (Throwable t) 299 { 300 Debug.trace(t); 301 } 294 StandardClass.initializeStandardClasses(); 302 295 } 303 296 } -
trunk/abcl/src/org/armedbear/lisp/Condition.java
r12288 r12298 99 99 super(StandardClass.CONDITION); 100 100 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); 110 103 } 111 104 … … 178 171 if (formatControl != NIL) 179 172 { 180 try 181 { 182 return format(formatControl, getFormatArguments()); 183 } 184 catch (Throwable t) {} 173 return format(formatControl, getFormatArguments()); 185 174 } 186 175 return unreadableString(typeOf().writeToString()); -
trunk/abcl/src/org/armedbear/lisp/Go.java
r12255 r12298 58 58 public LispObject getCondition() 59 59 { 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()); 70 64 } 71 65 } -
trunk/abcl/src/org/armedbear/lisp/Interpreter.java
r12290 r12298 76 76 return null; 77 77 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 103 100 return interpreter; 104 101 } … … 113 110 return null; 114 111 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 124 118 initializeJLisp(); 125 119 initializeTopLevel(); … … 145 139 if (!initialDirectory.endsWith(File.separator)) 146 140 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)); 153 142 } 154 143 … … 171 160 { 172 161 if (!initialized) { 162 Symbol.FEATURES.setSymbolValue(new Cons(Keyword.J, 163 Symbol.FEATURES.getSymbolValue())); 164 Load.loadSystemFile("boot.lisp", false, false, false); 165 173 166 try { 174 Symbol.FEATURES.setSymbolValue(new Cons(Keyword.J,175 Symbol.FEATURES.getSymbolValue()));176 Load.loadSystemFile("boot.lisp", false, false, false);177 167 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 184 173 initialized = true; 185 174 } … … 191 180 { 192 181 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 205 190 topLevelInitialized = true; 206 191 } … … 217 202 } 218 203 } 219 catch ( Throwable t) {220 t.printStackTrace();204 catch (IOException e) { 205 e.printStackTrace(); 221 206 } 222 207 } … … 386 371 private static void reportError(ControlTransfer c, LispThread thread) 387 372 { 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(); 401 381 } 402 382 403 383 private static void reportError(UnhandledCondition c, LispThread thread) 404 384 { 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(); 418 393 } 419 394 … … 501 476 Debug.trace(" " + condition.writeToString()); 502 477 } 503 catch (Throwable t) {} 478 catch (Throwable t) {} // catch any exception to throw below 504 479 finally { 505 480 thread.resetSpecialBindings(mark); … … 512 487 public static final LispObject readFromString(String s) 513 488 { 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()); 521 491 } 522 492 -
trunk/abcl/src/org/armedbear/lisp/Java.java
r12290 r12298 697 697 error(new WrongNumberOfArgumentsException(this)); 698 698 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); 715 706 } 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()); 723 716 } 724 717 }; -
trunk/abcl/src/org/armedbear/lisp/JavaClassLoader.java
r12180 r12298 33 33 34 34 package org.armedbear.lisp; 35 36 import static org.armedbear.lisp.Lisp.*; 35 37 36 38 import java.util.Collections; … … 71 73 72 74 public Class<?> loadClassFromByteArray(byte[] classbytes) { 73 75 return loadClassFromByteArray(null, classbytes); 74 76 } 75 77 … … 88 90 } 89 91 } 90 catch (LinkageError e) {91 throw e;92 }92 catch (LinkageError e) { 93 throw e; 94 } 93 95 catch (Throwable t) { 94 96 Debug.trace(t); … … 107 109 } 108 110 } 111 catch (VerifyError e) 112 { 113 error(new LispError("Class verification failed: " + e.getMessage())); 114 } 109 115 catch (Throwable t) { 110 116 Debug.trace(t); -
trunk/abcl/src/org/armedbear/lisp/Layout.java
r12288 r12298 50 50 this.lispClass = lispClass; 51 51 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(); 62 53 slotNames = new LispObject[length]; 63 54 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 77 62 Debug.assertTrue(i == length); 78 63 this.sharedSlots = sharedSlots; … … 154 139 { 155 140 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 166 144 return list; 167 145 } -
trunk/abcl/src/org/armedbear/lisp/Lisp.java
r12288 r12298 36 36 import java.io.File; 37 37 import java.io.FileInputStream; 38 import java.io.FileNotFoundException; 38 39 import java.io.IOException; 39 40 import java.io.InputStream; 40 import java.lang.reflect.Constructor;41 41 import java.math.BigInteger; 42 42 import java.net.MalformedURLException; … … 96 96 static 97 97 { 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); 144 137 } 145 138 … … 292 285 return error(new StorageCondition("Stack overflow.")); 293 286 } 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; 302 290 } 303 291 catch (Throwable t) … … 1210 1198 public static final LispObject readObjectFromString(String s) 1211 1199 { 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()); 1222 1202 } 1223 1203 … … 1322 1302 } 1323 1303 } 1324 catch (VerifyError e)1325 {1326 return error(new LispError("Class verification failed: " +1327 e.getMessage()));1328 }1329 1304 catch (IOException e) 1330 1305 { 1331 1306 Debug.trace(e); 1332 1307 } 1333 catch (Throwable t)1334 {1335 Debug.trace(t);1336 }1337 1308 } 1338 1309 return error(new LispError("Unable to load " + namestring)); … … 1343 1314 { 1344 1315 // 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) { }; 1350 1346 if (obj != null) 1351 1347 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 { 1385 1358 ZipCache.removeZip(zipFile.getName()); 1386 } 1387 } 1388 catch (Throwable t) 1389 { 1390 Debug.trace(t); 1359 } 1360 catch (IOException ignore) { } // ignore 1391 1361 } 1392 1362 return error(new FileError("File not found: " + namestring, … … 1394 1364 } 1395 1365 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(); 1403 1370 } 1371 catch (InstantiationException ignore) { 1372 // ignore 1373 } 1374 catch (IllegalAccessException ignore) { 1375 // ignore 1376 } 1377 return null; 1404 1378 } 1405 1379 1406 1380 private static final LispObject loadCompiledFunction(InputStream in, int size) 1407 1381 { 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 { 1413 1386 while (bytesRemaining > 0) 1414 1387 { … … 1420 1393 } 1421 1394 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());1436 1395 } 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) { 1439 1410 Class<?> c = cl.loadClassFromByteArray(null, bytes, 0, bytes.length); 1440 1441 1442 1443 1444 1411 LispObject obj = makeCompiledFunctionFromClass(c); 1412 if (obj instanceof Function) { 1413 ((Function)obj).setClassBytes(bytes); 1414 } 1415 return obj; 1445 1416 } 1446 1417 -
trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java
r12288 r12298 122 122 result = unreadableString(LISP_STACK_FRAME + " " 123 123 + toLispString().getStringValue()); 124 } catch (Throwable t) { 124 } catch (Throwable t) { // error while printing stack 125 125 Debug.trace("Serious printing error: "); 126 126 Debug.trace(t); … … 193 193 try { 194 194 result = this.toLispList().writeToString(); 195 } catch (Throwable t) { 195 } catch (Throwable t) { // error while printing stack 196 196 Debug.trace("Serious printing error: "); 197 197 Debug.trace(t); -
trunk/abcl/src/org/armedbear/lisp/LispThread.java
r12288 r12298 91 91 // Might happen. 92 92 } 93 catch (Throwable t) { 93 catch (Throwable t) { // any error: process thread interrupts 94 94 if (isInterrupted()) { 95 95 processThreadInterrupts(); … … 724 724 { 725 725 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(); 731 740 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; 749 744 } 750 745 } … … 756 751 if (stack != null) { 757 752 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(); 769 759 } 770 760 } -
trunk/abcl/src/org/armedbear/lisp/Load.java
r12290 r12298 180 180 zipfile = ZipCache.getZip(zipFileName); 181 181 } 182 catch ( Throwable t) {182 catch (IOException e) { 183 183 return error (new FileError("Zip file not found: " + filename, pathname)); 184 184 } … … 374 374 // Fall through. 375 375 } 376 catch (Throwable t) { 377 Debug.trace(t); 378 in = null; 379 // Fall through. 376 catch (IOException e) { 377 // fall through 380 378 } 381 379 } … … 673 671 && bytes[3] == 0x04); 674 672 } 675 catch (Throwable t) { 673 catch (Throwable t) { // any error probably means 'no' 676 674 return false; 677 675 } … … 681 679 in.close(); 682 680 } 683 catch ( Throwable t) {}681 catch (IOException e) {} // ignore exceptions 684 682 } 685 683 } -
trunk/abcl/src/org/armedbear/lisp/MathFunctions.java
r12290 r12298 269 269 } 270 270 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); 279 273 } 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); 288 276 } 289 277 LispObject result = exp(arg); … … 319 307 } 320 308 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); 329 311 } 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); 338 314 } 339 315 LispObject result = exp(arg); … … 357 333 { 358 334 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); 367 337 } 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); 376 340 } 377 341 return sinh(arg).divideBy(cosh(arg)); … … 577 541 if (number.realp() && !number.minusp() 578 542 && 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); 592 550 } 593 551 return log(number).divideBy(log(base)); -
trunk/abcl/src/org/armedbear/lisp/Package.java
r12288 r12298 264 264 Debug.assertTrue(symbol.getPackage() == this); 265 265 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); 272 267 } 273 268 … … 275 270 { 276 271 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 287 278 return symbol; 288 279 } … … 319 310 // Look in external symbols of used packages. 320 311 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(); 333 319 } 334 320 } … … 350 336 // Look in external symbols of used packages. 351 337 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(); 364 345 } 365 346 } … … 757 738 list.addAll(externalSymbols.getSymbols()); 758 739 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(); 774 750 } 775 751 } … … 799 775 LispObject list = NIL; 800 776 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(); 819 790 } 820 791 } -
trunk/abcl/src/org/armedbear/lisp/Pathname.java
r12288 r12298 498 498 boolean useNamestring; 499 499 String s = null; 500 try { 501 s = getNamestring(); 502 } 503 // ### FIXME exception 504 catch (Throwable t) {} 500 s = getNamestring(); 505 501 if (s != null) { 506 502 useNamestring = true; … … 1389 1385 1390 1386 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)); 1398 1389 } 1399 1390 } -
trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
r12288 r12298 84 84 FastStringBuffer sb = new FastStringBuffer(); 85 85 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); 92 87 if (object != UNBOUND_VALUE) { 93 88 final LispThread thread = LispThread.currentThread(); … … 97 92 try { 98 93 sb.append(object.writeToString()); 99 }100 catch (Throwable t) {101 sb.append("Object");102 94 } 103 95 finally { -
trunk/abcl/src/org/armedbear/lisp/RandomState.java
r12288 r12298 65 65 random = (Random) in.readObject(); 66 66 in.close(); 67 file.delete(); 67 file.delete(); // FIXME: file leak on exception 68 68 } 69 catch (Throwable t) { 69 catch (Throwable t) { // ANY exception gets converted to a lisp error 70 70 error(new LispError("Unable to copy random state.")); 71 71 } -
trunk/abcl/src/org/armedbear/lisp/Return.java
r12255 r12298 72 72 public LispObject getCondition() 73 73 { 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()); 84 78 } 85 79 } -
trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java
r12290 r12298 123 123 e.getMessage())); 124 124 } 125 catch (Throwable t) {126 Debug.trace(t);127 }128 125 return error( 129 126 new LispError("unable to load ".concat(cn))); -
trunk/abcl/src/org/armedbear/lisp/ShellCommand.java
r12290 r12298 205 205 if (s == null) 206 206 return; 207 try { 208 processOutput(s); 209 } 210 catch (Throwable t) { 211 Debug.trace(t); 212 } 207 processOutput(s); 213 208 } 214 209 } … … 233 228 } 234 229 catch (InterruptedException e) { 235 return null;236 }237 catch (Throwable t) {238 230 return null; 239 231 } -
trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java
r12288 r12298 73 73 public String getMessage() 74 74 { 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(); 88 85 } 89 catch (Throwable t) {} 90 return null; 86 return super.getMessage(); 91 87 } 92 88 } -
trunk/abcl/src/org/armedbear/lisp/Site.java
r12291 r12298 84 84 85 85 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)); 94 89 } 95 90 } -
trunk/abcl/src/org/armedbear/lisp/SiteName.java
r12290 r12298 37 37 38 38 import java.net.InetAddress; 39 import java.net.UnknownHostException; 39 40 40 41 public final class SiteName … … 43 44 { 44 45 String hostName = null; 46 InetAddress addr; 45 47 try { 46 InetAddress addr = InetAddress.getLocalHost(); 47 if (addr != null) 48 hostName = addr.getHostName(); 48 addr = InetAddress.getLocalHost(); 49 49 } 50 catch (Throwable t) {} 50 catch (UnknownHostException e) { 51 addr = null; 52 } 53 if (addr != null) 54 hostName = addr.getHostName(); 55 51 56 return hostName != null ? new SimpleString(hostName) : NIL; 52 57 } -
trunk/abcl/src/org/armedbear/lisp/SlimeInputStream.java
r12288 r12298 97 97 { 98 98 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(); 106 101 if (s.length() == 0) 107 102 return -1; -
trunk/abcl/src/org/armedbear/lisp/SlotClass.java
r12288 r12298 124 124 if (isFinalized()) 125 125 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(); 143 142 } 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); 163 159 } 164 160 -
trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java
r12288 r12298 48 48 { 49 49 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; 64 57 } 65 58 … … 68 61 { 69 62 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; 85 71 } 86 72 -
trunk/abcl/src/org/armedbear/lisp/Symbol.java
r12288 r12298 248 248 public final String getName() 249 249 { 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(); 259 251 } 260 252 261 253 public final String getQualifiedName() 262 254 { 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(); 283 267 } 284 268 -
trunk/abcl/src/org/armedbear/lisp/SymbolHashTable.java
r11698 r12298 66 66 HashEntry e = buckets[key.sxhash() & mask]; 67 67 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. 75 70 e = e.next; 76 71 } … … 82 77 HashEntry e = buckets[hash & mask]; 83 78 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. 91 81 e = e.next; 92 82 } … … 99 89 HashEntry e = buckets[index]; 100 90 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; 110 97 } 111 } 112 catch (Throwable t) { 113 Debug.trace(t); // FIXME 98 return; 114 99 } 115 100 e = e.next; … … 131 116 HashEntry e = buckets[index]; 132 117 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. 141 123 } 142 } 143 catch (Throwable t) { 144 Debug.trace(t); // FIXME 124 return; 145 125 } 146 126 e = e.next; … … 165 145 HashEntry last = null; 166 146 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! 179 154 } 180 155 last = e; -
trunk/abcl/src/org/armedbear/lisp/Throw.java
r12255 r12298 57 57 public LispObject getCondition() 58 58 { 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() + "."); 67 61 } 68 62 } -
trunk/abcl/src/org/armedbear/lisp/TypeError.java
r12288 r12298 130 130 public String getMessage() 131 131 { 132 // FIXME 132 final LispThread thread = LispThread.currentThread(); 133 final SpecialBindingsMark mark = thread.markSpecialBindings(); 134 thread.bindSpecial(Symbol.PRINT_ESCAPE, T); 133 135 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 "); 158 149 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); 174 163 } 175 164 } -
trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java
r12288 r12298 55 55 thread.bindSpecial(Symbol.PRINT_ESCAPE, T); 56 56 StringBuffer sb = new StringBuffer("The variable "); 57 // FIXME 58 try 59 { 57 try { 60 58 sb.append(getCellName().writeToString()); 61 } 62 catch (Throwable t) {} 59 } 63 60 finally { 64 61 thread.resetSpecialBindings(mark); -
trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java
r12288 r12298 59 59 if (lambdaName != null && lambdaName != NIL) { 60 60 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()); 67 62 } 68 63 sb.append('.');
Note: See TracChangeset
for help on using the changeset viewer.