Changeset 11754
- Timestamp:
- 04/12/09 10:53:39 (13 years ago)
- Location:
- trunk/abcl/src/org/armedbear/lisp
- Files:
-
- 67 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
r11575 r11754 114 114 public void fill(LispObject obj) throws ConditionThrowable 115 115 { 116 try{116 if (obj instanceof Fixnum) { 117 117 switch (((Fixnum)obj).value) { 118 118 case 0: … … 135 135 return; 136 136 } 137 }138 catch (ClassCastException e) {139 137 // Fall through... 140 138 } … … 202 200 public LispObject AREF(LispObject index) throws ConditionThrowable 203 201 { 204 try { 205 return AREF(((Fixnum)index).value); 206 } 207 catch (ClassCastException e) { 208 return error(new TypeError(index, Symbol.FIXNUM)); 209 } 202 return AREF(Fixnum.getValue(index)); 210 203 } 211 204 -
trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java
r11488 r11754 128 128 public LispObject execute(LispObject arg) throws ConditionThrowable 129 129 { 130 try{130 if (arg instanceof ArithmeticError) { 131 131 return ((ArithmeticError)arg).getOperation(); 132 132 } 133 catch (ClassCastException e){133 else { 134 134 return error(new TypeError(arg, Symbol.ARITHMETIC_ERROR)); 135 135 } … … 143 143 public LispObject execute(LispObject arg) throws ConditionThrowable 144 144 { 145 try{145 if (arg instanceof ArithmeticError) { 146 146 return ((ArithmeticError)arg).getOperands(); 147 147 } 148 catch (ClassCastException e){148 else { 149 149 return error(new TypeError(arg, Symbol.ARITHMETIC_ERROR)); 150 150 } -
trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java
r11714 r11754 159 159 { 160 160 try { 161 return Fixnum.getInstance(elements[((Fixnum)index).value]); 162 } 163 catch (ClassCastException e) { 164 return error(new TypeError(index, Symbol.FIXNUM)); 161 return Fixnum.getInstance(elements[Fixnum.getValue(index)]); 165 162 } 166 163 catch (ArrayIndexOutOfBoundsException e) { … … 184 181 public void aset(int index, LispObject obj) throws ConditionThrowable 185 182 { 186 try { 183 if (obj instanceof Fixnum) { 184 try { 187 185 elements[index] = ((Fixnum)obj).value; 188 186 } … … 190 188 badIndex(index, capacity); 191 189 } 192 catch (ClassCastException e) { 190 } 191 else { 193 192 error(new TypeError(obj, UNSIGNED_BYTE_16)); 194 193 } -
trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java
r11714 r11754 175 175 public LispObject AREF(LispObject index) throws ConditionThrowable 176 176 { 177 try 178 { 179 return number(elements[((Fixnum)index).value]); 180 } 181 catch (ClassCastException e) 182 { 183 return type_error(index, Symbol.FIXNUM); 184 } 185 catch (ArrayIndexOutOfBoundsException e) 186 { 187 badIndex(Fixnum.getValue(index), elements.length); 177 final int idx = Fixnum.getValue(index); 178 try 179 { 180 return number(elements[idx]); 181 } 182 catch (ArrayIndexOutOfBoundsException e) 183 { 184 badIndex(idx, elements.length); 188 185 return NIL; // Not reached. 189 186 } -
trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java
r11714 r11754 160 160 public LispObject AREF(LispObject index) throws ConditionThrowable 161 161 { 162 try 163 { 164 return coerceJavaByteToLispObject(elements[((Fixnum)index).value]); 165 } 166 catch (ClassCastException e) 167 { 168 return error(new TypeError(index, Symbol.FIXNUM)); 169 } 170 catch (ArrayIndexOutOfBoundsException e) 171 { 172 badIndex(Fixnum.getValue(index), elements.length); 162 int idx = Fixnum.getValue(index); 163 try 164 { 165 return coerceJavaByteToLispObject(elements[idx]); 166 } 167 catch (ArrayIndexOutOfBoundsException e) 168 { 169 badIndex(idx, elements.length); 173 170 return NIL; // Not reached. 174 171 } -
trunk/abcl/src/org/armedbear/lisp/Bignum.java
r11722 r11754 317 317 public static BigInteger getValue(LispObject obj) throws ConditionThrowable 318 318 { 319 try 319 320 if (obj instanceof Bignum) 320 321 { 321 322 return ((Bignum)obj).value; 322 323 } 323 catch (ClassCastException e)324 {325 324 type_error(obj, Symbol.BIGNUM); 326 325 // Not reached. 327 326 return null; 328 }329 327 } 330 328 -
trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java
r11711 r11754 258 258 public LispObject execute(LispObject arg) throws ConditionThrowable 259 259 { 260 try{260 if (arg instanceof BroadcastStream) { 261 261 BroadcastStream stream = (BroadcastStream) arg; 262 262 Stream[] streams = stream.streams; … … 266 266 return result; 267 267 } 268 catch (ClassCastException e) { 269 return error(new TypeError(arg, Symbol.BROADCAST_STREAM)); 270 } 268 return error(new TypeError(arg, Symbol.BROADCAST_STREAM)); 271 269 } 272 270 }; -
trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java
r11721 r11754 118 118 public LispObject execute(LispObject arg) throws ConditionThrowable 119 119 { 120 try{120 if (arg instanceof ByteArrayOutputStream) { 121 121 return JavaObject.getInstance(((ByteArrayOutputStream)arg).getByteArray()); 122 122 } 123 catch (ClassCastException e) { 124 return error(new TypeError(this, Symbol.STREAM)); //TODO 125 } 123 return error(new TypeError(this, Symbol.STREAM)); //TODO 126 124 } 127 125 }; -
trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
r11488 r11754 56 56 throws ConditionThrowable 57 57 { 58 try { 59 return ((LispCharacter)first).value == ((LispCharacter)second).value ? T : NIL; 60 } 61 catch (ClassCastException e) { 62 LispObject datum; 63 if (first instanceof LispCharacter) 64 datum = second; 65 else 66 datum = first; 67 return type_error(datum, Symbol.CHARACTER); 68 } 58 return LispCharacter.getValue(first) == LispCharacter.getValue(second) ? T : NIL; 69 59 } 70 60 @Override … … 102 92 { 103 93 final char c1, c2; 104 try { 105 c1 = ((LispCharacter)first).value; 106 } 107 catch (ClassCastException e) { 108 return type_error(first, Symbol.CHARACTER); 109 } 110 try { 111 c2 = ((LispCharacter)second).value; 112 } 113 catch (ClassCastException e) { 114 return type_error(second, Symbol.CHARACTER); 115 } 94 c1 = LispCharacter.getValue(first); 95 c2 = LispCharacter.getValue(second); 116 96 if (c1 == c2) 117 97 return T; … … 239 219 throws ConditionThrowable 240 220 { 241 try { 242 return ((LispCharacter)first).value < ((LispCharacter)second).value ? T : NIL; 243 } 244 catch (ClassCastException e) { 245 LispObject datum; 246 if (first instanceof LispCharacter) 247 datum = second; 248 else 249 datum = first; 250 return type_error(datum, Symbol.CHARACTER); 251 } 252 } 221 return LispCharacter.getValue(first) < LispCharacter.getValue(second) ? T : NIL; 222 } 253 223 @Override 254 224 public LispObject execute(LispObject[] args) throws ConditionThrowable … … 257 227 char[] chars = new char[length]; 258 228 for (int i = 0; i < length; i++) { 259 try { 260 chars[i] = ((LispCharacter)args[i]).value; 261 } 262 catch (ClassCastException e) { 263 return type_error(args[i], Symbol.CHARACTER); 264 } 229 chars[i] = LispCharacter.getValue(args[i]); 265 230 } 266 231 for (int i = 1; i < length; i++) { … … 292 257 throws ConditionThrowable 293 258 { 294 try { 295 return ((LispCharacter)first).value <= ((LispCharacter)second).value ? T : NIL; 296 } 297 catch (ClassCastException e) { 298 LispObject datum; 299 if (first instanceof LispCharacter) 300 datum = second; 301 else 302 datum = first; 303 return type_error(datum, Symbol.CHARACTER); 304 } 259 return LispCharacter.getValue(first) <= LispCharacter.getValue(second) ? T : NIL; 305 260 } 306 261 @Override … … 309 264 throws ConditionThrowable 310 265 { 311 try { 312 if (((LispCharacter)first).value > ((LispCharacter)second).value) 313 return NIL; 314 if (((LispCharacter)second).value > ((LispCharacter)third).value) 315 return NIL; 316 return T; 317 } 318 catch (ClassCastException e) { 319 LispObject datum; 320 if (!(first instanceof LispCharacter)) 321 datum = first; 322 else if (!(second instanceof LispCharacter)) 323 datum = second; 324 else 325 datum = third; 326 return type_error(datum, Symbol.CHARACTER); 327 } 266 if (LispCharacter.getValue(first) > LispCharacter.getValue(second)) 267 return NIL; 268 if (LispCharacter.getValue(second) > LispCharacter.getValue(third)) 269 return NIL; 270 return T; 328 271 } 329 272 @Override … … 333 276 char[] chars = new char[length]; 334 277 for (int i = 0; i < length; i++) { 335 try { 336 chars[i] = ((LispCharacter)args[i]).value; 337 } 338 catch (ClassCastException e) { 339 return type_error(args[i], Symbol.CHARACTER); 340 } 278 chars[i] = LispCharacter.getValue(args[i]); 341 279 } 342 280 for (int i = 1; i < length; i++) { -
trunk/abcl/src/org/armedbear/lisp/Closure.java
r11711 r11754 138 138 } 139 139 Debug.assertTrue(restVar == null); 140 try 141 { 142 restVar = (Symbol) remaining.car(); 143 } 144 catch (ClassCastException e) 140 final LispObject remainingcar = remaining.car(); 141 if (remainingcar instanceof Symbol) 142 { 143 restVar = (Symbol) remainingcar; 144 } 145 else 145 146 { 146 147 error(new LispError( -
trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java
r11714 r11754 165 165 if (index < 0 || index >= capacity) 166 166 badIndex(index, capacity); 167 try{167 if (newValue instanceof Fixnum) { 168 168 switch (((Fixnum)newValue).value) { 169 169 case 0: … … 183 183 } 184 184 } 185 catch (ClassCastException e) {186 185 // Fall through... 187 }188 186 type_error(newValue, Symbol.BIT); 189 187 } -
trunk/abcl/src/org/armedbear/lisp/ComplexString.java
r11714 r11754 158 158 { 159 159 LispObject obj = array.AREF(displacement + i); 160 try 161 { 162 copy[i] = ((LispCharacter)obj).value; 163 } 164 catch (ClassCastException e) 165 { 166 type_error(obj, Symbol.CHARACTER); 167 } 160 copy[i] = LispCharacter.getValue(obj); 168 161 } 169 162 } … … 427 420 public void aset(int index, LispObject newValue) throws ConditionThrowable 428 421 { 429 try 430 { 431 setCharAt(index, ((LispCharacter)newValue).value); 432 } 433 catch (ClassCastException e) 434 { 435 type_error(newValue, Symbol.CHARACTER); 436 } 422 setCharAt(index, LispCharacter.getValue(newValue)); 437 423 } 438 424 … … 450 436 if (chars != null) 451 437 { 452 try 453 { 454 chars[fillPointer] = ((LispCharacter)element).value; 455 } 456 catch (ClassCastException e) 457 { 458 type_error(element, Symbol.CHARACTER); 459 } 438 chars[fillPointer] = LispCharacter.getValue(element); 460 439 } 461 440 else … … 487 466 if (chars != null) 488 467 { 489 try 490 { 491 chars[fillPointer] = ((LispCharacter)element).value; 492 } 493 catch (ClassCastException e) 494 { 495 type_error(element, Symbol.CHARACTER); 496 } 468 chars[fillPointer] = LispCharacter.getValue(element); 497 469 } 498 470 else -
trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java
r11488 r11754 274 274 public LispObject execute(LispObject arg) throws ConditionThrowable 275 275 { 276 try {276 if (arg instanceof ConcatenatedStream) 277 277 return ((ConcatenatedStream)arg).streams; 278 } 279 catch (ClassCastException e) { 280 return error(new TypeError(arg, Symbol.CONCATENATED_STREAM)); 281 } 278 return error(new TypeError(arg, Symbol.CONCATENATED_STREAM)); 282 279 } 283 280 }; -
trunk/abcl/src/org/armedbear/lisp/Cons.java
r11714 r11754 282 282 public final int length() throws ConditionThrowable 283 283 { 284 int length = 0; 285 LispObject obj = this; 286 try 287 { 284 int length = 1; 285 LispObject obj = cdr; 288 286 while (obj != NIL) 289 287 { 290 288 ++length; 291 obj = ((Cons)obj).cdr; 292 } 293 } 294 catch (ClassCastException e) 295 { 296 type_error(obj, Symbol.LIST); 297 } 289 if (obj instanceof Cons) { 290 obj = ((Cons)obj).cdr; 291 } else type_error(obj, Symbol.LIST); 292 } 298 293 return length; 299 294 } … … 321 316 { 322 317 int index; 323 try318 if (arg instanceof Fixnum) 324 319 { 325 320 index = ((Fixnum)arg).value; 326 321 } 327 catch (ClassCastException e)328 {322 else 323 { 329 324 if (arg instanceof Bignum) 330 325 { … … 362 357 if (i == index) 363 358 return cons.car; 364 try 365 { 366 cons = (Cons) cons.cdr; 367 } 368 catch (ClassCastException e) 369 { 370 if (cons.cdr == NIL) 359 LispObject conscdr = cons.cdr; 360 if (conscdr instanceof Cons) 361 { 362 cons = (Cons) conscdr; 363 } 364 else 365 { 366 if (conscdr == NIL) 371 367 { 372 368 // Index too large. … … 378 374 { 379 375 // Dotted list. 380 type_error(cons .cdr, Symbol.LIST);376 type_error(conscdr, Symbol.LIST); 381 377 } 382 378 // Not reached. -
trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
r11714 r11754 226 226 public static double getValue(LispObject obj) throws ConditionThrowable 227 227 { 228 try {228 if (obj instanceof DoubleFloat) 229 229 return ((DoubleFloat)obj).value; 230 }231 catch (ClassCastException e) {232 230 type_error(obj, Symbol.FLOAT); 233 231 // Not reached. 234 232 return 0; 235 }236 233 } 237 234 -
trunk/abcl/src/org/armedbear/lisp/Environment.java
r11551 r11754 337 337 public LispObject execute(LispObject arg) throws ConditionThrowable 338 338 { 339 try 340 { 341 return ((Environment)arg).isEmpty() ? T : NIL; 342 } 343 catch (ClassCastException e) 344 { 345 return type_error(arg, Symbol.ENVIRONMENT); 346 } 339 return checkEnvironment(arg).isEmpty() ? T : NIL; 347 340 } 348 341 }; … … 355 348 public LispObject execute(LispObject arg) throws ConditionThrowable 356 349 { 357 try 358 { 359 Environment env = (Environment) arg; 350 Environment env = checkEnvironment(arg); 360 351 LispObject result = NIL; 361 352 for (Binding binding = env.vars; binding != null; binding = binding.next) … … 363 354 result = result.push(new Cons(binding.symbol, binding.value)); 364 355 return result.nreverse(); 365 }366 catch (ClassCastException e)367 {368 return type_error(arg, Symbol.ENVIRONMENT);369 }370 356 } 371 357 }; -
trunk/abcl/src/org/armedbear/lisp/Extensions.java
r11711 r11754 275 275 { 276 276 AbstractString string; 277 try{277 if (arg instanceof AbstractString) { 278 278 string = (AbstractString) arg; 279 } 280 catch (ClassCastException e) { 279 } else 281 280 return type_error(arg, Symbol.STRING); 282 }283 281 String result = System.getenv(string.getStringValue()); 284 282 if (result != null) -
trunk/abcl/src/org/armedbear/lisp/FileStream.java
r11434 r11754 286 286 { 287 287 final Pathname pathname; 288 try{288 if(first instanceof Pathname) { 289 289 pathname = (Pathname) first; 290 290 } 291 catch (ClassCastException e){291 else { 292 292 return type_error(first, Symbol.PATHNAME); 293 293 } 294 final LispObject namestring; 295 try { 296 namestring = (AbstractString) second; 297 } 298 catch (ClassCastException e) { 299 return type_error(second, Symbol.STRING); 300 } 294 final LispObject namestring = checkString(second); 301 295 LispObject elementType = third; 302 296 LispObject direction = fourth; -
trunk/abcl/src/org/armedbear/lisp/Fixnum.java
r11722 r11754 300 300 public static int getValue(LispObject obj) throws ConditionThrowable 301 301 { 302 try 303 { 304 return ((Fixnum)obj).value; 305 } 306 catch (ClassCastException e) 307 { 308 type_error(obj, Symbol.FIXNUM); 309 // Not reached. 310 return 0; 311 } 302 if (obj instanceof Fixnum) return ((Fixnum)obj).value; 303 type_error(obj, Symbol.FIXNUM); 304 // Not reached. 305 return 0; 312 306 } 313 307 … … 324 318 public static int getInt(LispObject obj) throws ConditionThrowable 325 319 { 326 try 327 { 328 return (int) ((Fixnum)obj).value; 329 } 330 catch (ClassCastException e) 331 { 332 type_error(obj, Symbol.FIXNUM); 333 // Not reached. 334 return 0; 335 } 320 if (obj instanceof Fixnum) return ((Fixnum)obj).value; 321 type_error(obj, Symbol.FIXNUM); 322 // Not reached. 323 return 0; 336 324 } 337 325 338 326 public static BigInteger getBigInteger(LispObject obj) throws ConditionThrowable 339 327 { 340 try 341 { 342 return BigInteger.valueOf(((Fixnum)obj).value); 343 } 344 catch (ClassCastException e) 345 { 346 type_error(obj, Symbol.FIXNUM); 347 // Not reached. 348 return null; 349 } 328 if (obj instanceof Fixnum) return BigInteger.valueOf(((Fixnum)obj).value); 329 type_error(obj, Symbol.FIXNUM); 330 // Not reached. 331 return null; 350 332 } 351 333 -
trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java
r11488 r11754 83 83 throws ConditionThrowable 84 84 { 85 try{85 if (arg instanceof Symbol) { 86 86 Symbol name = (Symbol) arg; 87 87 ForwardReferencedClass c = new ForwardReferencedClass(name); … … 89 89 return c; 90 90 } 91 catch (ClassCastException e) {92 91 return error(new TypeError(arg.writeToString() + 93 92 " is not a valid class name.")); 94 }95 93 } 96 94 }; -
trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java
r11714 r11754 54 54 throws ConditionThrowable 55 55 { 56 final int n; 57 try 58 { 59 n = ((Fixnum)size).value; 60 } 61 catch (ClassCastException e) 62 { 63 return type_error(size, Symbol.FIXNUM); 64 } 56 final int n = Fixnum.getValue(size); 65 57 if (test == FUNCTION_EQL || test == NIL) 66 58 return new EqlHashTable(n, rehashSize, rehashThreshold); … … 84 76 throws ConditionThrowable 85 77 { 86 try 87 { 88 return ((HashTable)ht).gethash(key); 89 } 90 catch (ClassCastException e) 91 { 92 return type_error(ht, Symbol.HASH_TABLE); 93 } 94 } 78 return checkHashTable(ht).gethash(key); 79 } 80 95 81 @Override 96 82 public LispObject execute(LispObject key, LispObject ht, … … 98 84 throws ConditionThrowable 99 85 { 100 try 101 { 102 return ((HashTable)ht).gethash(key, defaultValue); 103 } 104 catch (ClassCastException e) 105 { 106 return type_error(ht, Symbol.HASH_TABLE); 107 } 86 return checkHashTable(ht).gethash(key, defaultValue); 108 87 } 109 88 }; … … 117 96 throws ConditionThrowable 118 97 { 119 final HashTable ht; 120 try 121 { 122 ht = (HashTable) second; 123 } 124 catch (ClassCastException e) 125 { 126 return type_error(second, Symbol.HASH_TABLE); 127 } 98 final HashTable ht = checkHashTable(second); 128 99 synchronized (ht) 129 100 { … … 144 115 throws ConditionThrowable 145 116 { 146 try 147 { 148 return ((HashTable)ht).puthash(key, value); 149 } 150 catch (ClassCastException e) 151 { 152 return type_error(ht, Symbol.HASH_TABLE); 153 } 117 return checkHashTable(ht).puthash(key, value); 154 118 } 155 119 @Override … … 158 122 throws ConditionThrowable 159 123 { 160 try 161 { 162 return ((HashTable)ht).puthash(key, value); 163 } 164 catch (ClassCastException e) 165 { 166 return type_error(ht, Symbol.HASH_TABLE); 167 } 124 return checkHashTable(ht).puthash(key, value); 168 125 } 169 126 }; … … 177 134 throws ConditionThrowable 178 135 { 179 try 180 { 181 return ((HashTable)ht).remhash(key); 182 } 183 catch (ClassCastException e) 184 { 185 return type_error(ht, Symbol.HASH_TABLE); 186 } 136 return checkHashTable(ht).remhash(key); 187 137 } 188 138 }; … … 195 145 public LispObject execute(LispObject ht) throws ConditionThrowable 196 146 { 197 try 198 { 199 ((HashTable)ht).clear(); 200 return ht; 201 } 202 catch (ClassCastException e) 203 { 204 return type_error(ht, Symbol.HASH_TABLE); 205 } 147 checkHashTable(ht).clear(); 148 return ht; 206 149 } 207 150 }; … … 214 157 public LispObject execute(LispObject arg) throws ConditionThrowable 215 158 { 216 try 217 { 218 return Fixnum.getInstance(((HashTable)arg).getCount()); 219 } 220 catch (ClassCastException e) 221 { 222 return type_error(arg, Symbol.HASH_TABLE); 223 } 159 return Fixnum.getInstance(checkHashTable(arg).getCount()); 224 160 } 225 161 }; … … 266 202 public LispObject execute(LispObject arg) throws ConditionThrowable 267 203 { 268 try 269 { 270 return ((HashTable)arg).ENTRIES(); 271 } 272 catch (ClassCastException e) 273 { 274 return type_error(arg, Symbol.HASH_TABLE); 275 } 204 return checkHashTable(arg).ENTRIES(); 276 205 } 277 206 }; … … 284 213 public LispObject execute(LispObject arg) throws ConditionThrowable 285 214 { 286 try 287 { 288 return ((HashTable)arg).getTest(); 289 } 290 catch (ClassCastException e) 291 { 292 return type_error(arg, Symbol.HASH_TABLE); 293 } 215 return checkHashTable(arg).getTest(); 294 216 } 295 217 }; … … 302 224 public LispObject execute(LispObject arg) throws ConditionThrowable 303 225 { 304 try 305 { 306 return Fixnum.getInstance(((HashTable)arg).getSize()); 307 } 308 catch (ClassCastException e) 309 { 310 return type_error(arg, Symbol.HASH_TABLE); 311 } 226 return Fixnum.getInstance(checkHashTable(arg).getSize()); 312 227 } 313 228 }; … … 320 235 public LispObject execute(LispObject arg) throws ConditionThrowable 321 236 { 322 try 323 { 324 return ((HashTable)arg).getRehashSize(); 325 } 326 catch (ClassCastException e) 327 { 328 return type_error(arg, Symbol.HASH_TABLE); 329 } 237 return checkHashTable(arg).getRehashSize(); 330 238 } 331 239 }; … … 338 246 public LispObject execute(LispObject arg) throws ConditionThrowable 339 247 { 340 try 341 { 342 return ((HashTable)arg).getRehashThreshold(); 343 } 344 catch (ClassCastException e) 345 { 346 return type_error(arg, Symbol.HASH_TABLE); 347 } 248 return checkHashTable(arg).getRehashThreshold(); 348 249 } 349 250 }; … … 357 258 throws ConditionThrowable 358 259 { 359 HashTable ht; 360 try 361 { 362 ht = (HashTable) second; 363 } 364 catch (ClassCastException e) 365 { 366 return type_error(second, Symbol.HASH_TABLE); 367 } 368 return ht.MAPHASH(first); 369 } 370 }; 260 return checkHashTable(second).MAPHASH(first); 261 } 262 }; 263 264 protected static HashTable checkHashTable(LispObject ht) throws ConditionThrowable { 265 if (ht instanceof HashTable) return (HashTable)ht; 266 type_error(ht, Symbol.HASH_TABLE); 267 return null; 371 268 } 269 } -
trunk/abcl/src/org/armedbear/lisp/Java.java
r11711 r11754 856 856 // It's not a string, so it must be a JavaObject. 857 857 final JavaObject javaObject; 858 try{858 if (obj instanceof JavaObject) { 859 859 javaObject = (JavaObject) obj; 860 860 } 861 catch (ClassCastException e){861 else { 862 862 type_error(obj, list(Symbol.OR, Symbol.STRING, 863 863 Symbol.JAVA_OBJECT)); … … 865 865 return null; 866 866 } 867 try {868 return (Class) javaObject.getObject();869 }870 catch (ClassCastException e) {867 final Object javaObjectgetObject = javaObject.getObject(); 868 if (javaObjectgetObject instanceof Class) { 869 return (Class) javaObjectgetObject; 870 } 871 871 error(new LispError(obj.writeToString() + " does not designate a Java class.")); 872 872 return null; 873 }874 873 } 875 874 -
trunk/abcl/src/org/armedbear/lisp/JavaObject.java
r11722 r11754 54 54 public LispObject classOf() 55 55 { 56 57 58 59 60 56 if(obj == null) { 57 return BuiltInClass.JAVA_OBJECT; 58 } else { 59 return JavaClass.findJavaClass(obj.getClass()); 60 } 61 61 } 62 62 … … 69 69 return T; 70 70 if(type instanceof JavaClass && obj != null) { 71 71 return ((JavaClass) type).getJavaClass().isAssignableFrom(obj.getClass()) ? T : NIL; 72 72 } 73 73 return super.typep(type); … … 180 180 throws ConditionThrowable 181 181 { 182 try { 183 return ((JavaObject)o).obj; 184 } 185 catch (ClassCastException e) { 186 type_error(o, Symbol.JAVA_OBJECT); 187 // Not reached. 188 return null; 189 } 182 if (o instanceof JavaObject) 183 return ((JavaObject)o).obj; 184 return // Not reached. 185 type_error(o, Symbol.JAVA_OBJECT); 190 186 } 191 187 … … 234 230 if (!(first instanceof JavaObject)) 235 231 return type_error(first, Symbol.JAVA_OBJECT); 236 final Stream stream; 237 try { 238 stream = (Stream) second; 239 } 240 catch (ClassCastException e) { 241 return type_error(second, Symbol.STREAM); 242 } 232 final Stream stream = checkStream(second); 243 233 final JavaObject javaObject = (JavaObject) first; 244 234 final Object obj = javaObject.getObject(); -
trunk/abcl/src/org/armedbear/lisp/Layout.java
r11714 r11754 175 175 throws ConditionThrowable 176 176 { 177 try 178 { 179 return new Layout((LispClass)first, checkList(second), 177 return new Layout(checkClass(first), checkList(second), 180 178 checkList(third)); 181 }182 catch (ClassCastException e)183 {184 return type_error(first, Symbol.CLASS);185 }186 179 } 187 180 … … 195 188 public LispObject execute(LispObject arg) throws ConditionThrowable 196 189 { 197 try 198 { 199 return ((Layout)arg).lispClass; 200 } 201 catch (ClassCastException e) 202 { 203 return type_error(arg, Symbol.LAYOUT); 204 } 190 return checkLayout(arg).lispClass; 205 191 } 206 192 }; … … 213 199 public LispObject execute(LispObject arg) throws ConditionThrowable 214 200 { 215 try 216 { 217 return Fixnum.getInstance(((Layout)arg).slotNames.length); 218 } 219 catch (ClassCastException e) 220 { 221 return type_error(arg, Symbol.LAYOUT); 222 } 201 return Fixnum.getInstance(checkLayout(arg).slotNames.length); 223 202 } 224 203 }; … … 254 233 throws ConditionThrowable 255 234 { 256 try 257 { 258 final LispObject slotNames[] = ((Layout)first).slotNames; 259 for (int i = slotNames.length; i-- > 0;) 260 { 261 if (slotNames[i] == second) 262 return Fixnum.getInstance(i); 263 } 264 return NIL; 265 } 266 catch (ClassCastException e) 267 { 268 return type_error(first, Symbol.LAYOUT); 269 } 235 final LispObject slotNames[] = checkLayout(first).slotNames; 236 for (int i = slotNames.length; i-- > 0;) 237 { 238 if (slotNames[i] == second) 239 return Fixnum.getInstance(i); 240 } 241 return NIL; 270 242 } 271 243 }; … … 279 251 throws ConditionThrowable 280 252 { 281 try 282 { 283 final LispObject slotNames[] = ((Layout)first).slotNames; 253 final Layout layOutFirst = checkLayout(first); 254 final LispObject slotNames[] = layOutFirst.slotNames; 284 255 final int limit = slotNames.length; 285 256 for (int i = 0; i < limit; i++) … … 289 260 } 290 261 // Reaching here, it's not an instance slot. 291 LispObject rest = ((Layout)first).sharedSlots;262 LispObject rest = layOutFirst.sharedSlots; 292 263 while (rest != NIL) 293 264 { … … 299 270 return NIL; 300 271 } 301 catch (ClassCastException e)302 {303 return type_error(first, Symbol.LAYOUT);304 }305 }306 272 }; 307 273 … … 313 279 public LispObject execute(LispObject arg) throws ConditionThrowable 314 280 { 315 final LispClass lispClass; 316 try 317 { 318 lispClass = (LispClass) arg; 319 } 320 catch (ClassCastException e) 321 { 322 return type_error(arg, Symbol.CLASS); 323 } 281 final LispClass lispClass = checkClass(arg); 324 282 Layout oldLayout = lispClass.getClassLayout(); 325 283 Layout newLayout = new Layout(oldLayout); -
trunk/abcl/src/org/armedbear/lisp/Lisp.java
r11750 r11754 563 563 // Environment wrappers. 564 564 private static final boolean isSpecial(Symbol sym, Symbol[] ownSpecials, 565 565 Environment env) 566 566 { 567 567 if (ownSpecials != null) 568 568 { 569 570 571 572 573 574 575 569 if (sym.isSpecialVariable()) 570 return true; 571 for (Symbol special : ownSpecials) 572 { 573 if (sym == special) 574 return true; 575 } 576 576 } 577 577 return false; 578 578 } 579 579 protected static final void bindArg(Symbol[] ownSpecials, 580 581 580 Symbol sym, LispObject value, 581 Environment env, LispThread thread) 582 582 throws ConditionThrowable 583 583 { … … 759 759 760 760 public static Symbol checkSymbol(LispObject obj) throws ConditionThrowable 761 { 762 if (obj == null) 763 throw new NullPointerException(); 764 try 765 { 766 return (Symbol) obj; 767 } 768 catch (ClassCastException e) 769 { 770 type_error(obj, Symbol.SYMBOL); 771 // Not reached. 772 return null; 773 } 761 { 762 if (obj instanceof Symbol) 763 return (Symbol) obj; 764 return (Symbol)// Not reached. 765 type_error(obj, Symbol.SYMBOL); 774 766 } 775 767 … … 785 777 throws ConditionThrowable 786 778 { 787 if (obj == null) 788 throw new NullPointerException(); 789 try 790 { 791 return (AbstractArray) obj; 792 } 793 catch (ClassCastException e) 794 { 779 if (obj instanceof AbstractArray) 780 return (AbstractArray) obj; 781 return (AbstractArray)// Not reached. 795 782 type_error(obj, Symbol.ARRAY); 796 // Not reached.797 return null;798 }799 783 } 800 784 … … 802 786 throws ConditionThrowable 803 787 { 804 if (obj == null) 805 throw new NullPointerException(); 806 try 807 { 808 return (AbstractVector) obj; 809 } 810 catch (ClassCastException e) 811 { 788 if (obj instanceof AbstractVector) 789 return (AbstractVector) obj; 790 return (AbstractVector)// Not reached. 812 791 type_error(obj, Symbol.VECTOR); 813 // Not reached.814 return null;815 }816 792 } 817 793 … … 1020 996 if (zipFileName.length() > 0 && zipFileName.charAt(0) == '/') 1021 997 zipFileName = zipFileName.substring(1); 1022 1023 998 } 999 zipFileName = URLDecoder.decode(zipFileName, "UTF-8"); 1024 1000 ZipFile zipFile = new ZipFile(zipFileName); 1025 1001 try … … 1132 1108 Debug.trace("bytesRemaining = " + bytesRemaining); 1133 1109 1134 1110 return loadCompiledFunction(bytes); 1135 1111 } 1136 1112 catch (Throwable t) … … 1142 1118 1143 1119 public static final LispObject loadCompiledFunction(byte[] bytes) throws Throwable { 1144 1120 Class c = (new JavaClassLoader()).loadClassFromByteArray(null, bytes, 0, bytes.length); 1145 1121 if (c != null) { 1146 1122 Class sc = c.getSuperclass(); 1147 1123 Constructor constructor = c.getConstructor((Class[])null); 1148 1124 LispObject obj = (LispObject) constructor.newInstance((Object[])null); 1149 1125 if (obj instanceof Function) { 1150 1126 ((Function)obj).setClassBytes(bytes); 1151 1127 } 1152 1128 return obj; 1153 1154 1155 1129 } else { 1130 return null; 1131 } 1156 1132 } 1157 1133 … … 1326 1302 throws ConditionThrowable 1327 1303 { 1328 try 1329 { 1330 return (byte) ((Fixnum)obj).value; 1331 } 1332 catch (ClassCastException e) 1333 { 1334 type_error(obj, Symbol.FIXNUM); 1335 // Not reached. 1336 return 0; 1337 } 1304 return (byte)Fixnum.getValue(obj); 1338 1305 } 1339 1306 … … 1346 1313 throws ConditionThrowable 1347 1314 { 1348 if (obj == null) 1349 throw new NullPointerException(); 1350 try 1351 { 1352 return (LispCharacter) obj; 1353 } 1354 catch (ClassCastException e) 1355 { 1315 if (obj instanceof LispCharacter) 1316 return (LispCharacter) obj; 1317 return (LispCharacter) // Not reached. 1356 1318 type_error(obj, Symbol.CHARACTER); 1357 // Not reached.1358 return null;1359 }1360 1319 } 1361 1320 … … 1363 1322 throws ConditionThrowable 1364 1323 { 1365 if (obj == null) 1366 throw new NullPointerException(); 1367 try 1368 { 1369 return (Package) obj; 1370 } 1371 catch (ClassCastException e) 1372 { 1324 if (obj instanceof Package) 1325 return (Package) obj; 1326 return (Package) // Not reached. 1373 1327 type_error(obj, Symbol.PACKAGE); 1374 // Not reached.1375 return null;1376 }1377 1328 } 1378 1329 … … 1380 1331 throws ConditionThrowable 1381 1332 { 1382 if (obj == null) 1383 throw new NullPointerException(); 1384 try 1385 { 1386 return (Function) obj; 1387 } 1388 catch (ClassCastException e) 1389 { 1333 if (obj instanceof Function) 1334 return (Function) obj; 1335 return (Function) // Not reached. 1390 1336 type_error(obj, Symbol.FUNCTION); 1391 // Not reached.1392 return null;1393 }1394 1337 } 1395 1338 … … 1397 1340 throws ConditionThrowable 1398 1341 { 1399 if (obj == null) 1400 throw new NullPointerException(); 1401 try 1402 { 1403 return (Stream) obj; 1404 } 1405 catch (ClassCastException e) 1406 { 1342 if (obj instanceof Stream) 1343 return (Stream) obj; 1344 return (Stream) // Not reached. 1407 1345 type_error(obj, Symbol.STREAM); 1408 // Not reached.1409 return null;1410 }1411 1346 } 1412 1347 … … 1414 1349 throws ConditionThrowable 1415 1350 { 1416 if (obj == null) 1417 throw new NullPointerException(); 1418 try 1419 { 1420 final Stream stream = (Stream) obj; 1421 if (stream.isCharacterInputStream()) 1422 return stream; 1423 error(new TypeError("The value " + obj.writeToString() + 1424 " is not a character input stream.")); 1425 // Not reached. 1426 return null; 1427 } 1428 catch (ClassCastException e) 1429 { 1430 type_error(obj, Symbol.STREAM); 1431 // Not reached. 1432 return null; 1433 } 1351 final Stream stream = checkStream(obj); 1352 if (stream.isCharacterInputStream()) 1353 return stream; 1354 return (Stream) // Not reached. 1355 error(new TypeError("The value " + obj.writeToString() + 1356 " is not a character input stream.")); 1434 1357 } 1435 1358 … … 1437 1360 throws ConditionThrowable 1438 1361 { 1439 if (obj == null) 1440 throw new NullPointerException(); 1441 try 1442 { 1443 final Stream stream = (Stream) obj; 1444 if (stream.isCharacterOutputStream()) 1445 return stream; 1362 final Stream stream = checkStream(obj); 1363 if (stream.isCharacterOutputStream()) 1364 return stream; 1365 return (Stream) // Not reached. 1446 1366 error(new TypeError("The value " + obj.writeToString() + 1447 1367 " is not a character output stream.")); 1448 // Not reached.1449 return null;1450 }1451 catch (ClassCastException e)1452 {1453 type_error(obj, Symbol.STREAM);1454 // Not reached.1455 return null;1456 }1457 1368 } 1458 1369 … … 1460 1371 throws ConditionThrowable 1461 1372 { 1462 if (obj == null) 1463 throw new NullPointerException(); 1464 try 1465 { 1466 final Stream stream = (Stream) obj; 1467 if (stream.isBinaryInputStream()) 1468 return stream; 1373 final Stream stream = checkStream(obj); 1374 if (stream.isBinaryInputStream()) 1375 return stream; 1376 return (Stream) // Not reached. 1469 1377 error(new TypeError("The value " + obj.writeToString() + 1470 1378 " is not a binary input stream.")); 1471 // Not reached. 1472 return null; 1473 } 1474 catch (ClassCastException e) 1475 { 1476 type_error(obj, Symbol.STREAM); 1477 // Not reached. 1478 return null; 1479 } 1379 } 1380 1381 public static final Stream outSynonymOf(LispObject obj) 1382 throws ConditionThrowable 1383 { 1384 if (obj instanceof Stream) 1385 return (Stream) obj; 1386 if (obj == T) 1387 return checkCharacterOutputStream(Symbol.TERMINAL_IO.symbolValue()); 1388 if (obj == NIL) 1389 return checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue()); 1390 return (Stream) // Not reached. 1391 type_error(obj, Symbol.STREAM); 1480 1392 } 1481 1393 … … 1489 1401 if (obj == NIL) 1490 1402 return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue()); 1491 type_error(obj, Symbol.STREAM); 1492 // Not reached. 1493 return null; 1403 return (Stream) // Not reached. 1404 type_error(obj, Symbol.STREAM); 1494 1405 } 1495 1406 … … 1499 1410 if (n < 0 || n > 255) 1500 1411 type_error(Fixnum.getInstance(n), UNSIGNED_BYTE_8); 1501 try 1502 { 1503 ((Stream)obj)._writeByte(n); 1504 } 1505 catch (ClassCastException e) 1506 { 1507 type_error(obj, Symbol.STREAM); 1508 } 1412 checkStream(obj)._writeByte(n); 1509 1413 } 1510 1414 … … 1512 1416 throws ConditionThrowable 1513 1417 { 1514 if (obj == null) 1515 throw new NullPointerException(); 1516 try 1517 { 1518 return (Readtable) obj; 1519 } 1520 catch (ClassCastException e) 1521 { 1522 type_error(obj, Symbol.READTABLE); 1523 // Not reached. 1524 return null; 1525 } 1418 if (obj instanceof Readtable) 1419 return (Readtable) obj; 1420 return (Readtable)// Not reached. 1421 type_error(obj, Symbol.READTABLE); 1422 } 1423 1424 public final static AbstractString checkString(LispObject obj) 1425 throws ConditionThrowable 1426 { 1427 if (obj instanceof AbstractString) 1428 return (AbstractString) obj; 1429 return (AbstractString)// Not reached. 1430 type_error(obj, Symbol.STRING); 1431 } 1432 1433 public final static LispClass checkClass(LispObject obj) 1434 throws ConditionThrowable 1435 { 1436 if (obj instanceof LispClass) 1437 return (LispClass) obj; 1438 return (LispClass)// Not reached. 1439 type_error(obj, Symbol.CLASS); 1440 } 1441 1442 public final static Layout checkLayout(LispObject obj) 1443 throws ConditionThrowable 1444 { 1445 if (obj instanceof Layout) 1446 return (Layout) obj; 1447 return (Layout)// Not reached. 1448 type_error(obj, Symbol.LAYOUT); 1526 1449 } 1527 1450 … … 1529 1452 throws ConditionThrowable 1530 1453 { 1531 if (obj == null)1532 throw new NullPointerException();1533 1454 if (obj == NIL) 1534 1455 obj = STANDARD_READTABLE.symbolValue(); 1535 try 1536 { 1537 return (Readtable) obj; 1538 } 1539 catch (ClassCastException e) 1540 { 1541 type_error(obj, Symbol.READTABLE); 1542 // Not reached. 1543 return null; 1544 } 1456 if (obj == null) 1457 throw new NullPointerException(); 1458 return checkReadtable(obj); 1545 1459 } 1546 1460 … … 1548 1462 throws ConditionThrowable 1549 1463 { 1550 if (obj == null) 1551 throw new NullPointerException(); 1552 try 1553 { 1554 return (Environment) obj; 1555 } 1556 catch (ClassCastException e) 1557 { 1464 if (obj instanceof Environment) 1465 return (Environment) obj; 1466 return (Environment)// Not reached. 1558 1467 type_error(obj, Symbol.ENVIRONMENT); 1559 // Not reached.1560 return null;1561 }1562 1468 } 1563 1469 … … 1697 1603 throws ConditionThrowable 1698 1604 { 1699 LispObject list; 1700 try 1701 { 1702 list = ((Symbol)symbol).getPropertyList(); 1703 } 1704 catch (ClassCastException e) 1705 { 1706 return type_error(symbol, Symbol.SYMBOL); 1707 } 1605 LispObject list = checkSymbol(symbol).getPropertyList(); 1708 1606 while (list != NIL) 1709 1607 { … … 1719 1617 throws ConditionThrowable 1720 1618 { 1721 LispObject list; 1722 try 1723 { 1724 list = ((Symbol)symbol).getPropertyList(); 1725 } 1726 catch (ClassCastException e) 1727 { 1728 return type_error(symbol, Symbol.SYMBOL); 1729 } 1619 LispObject list = checkSymbol(symbol).getPropertyList(); 1730 1620 while (list != NIL) 1731 1621 { … … 2044 1934 { 2045 1935 resetIO(new Stream(System.in, Symbol.CHARACTER, true), 2046 1936 new Stream(System.out, Symbol.CHARACTER, true)); 2047 1937 } 2048 1938 -
trunk/abcl/src/org/armedbear/lisp/LispCharacter.java
r11714 r11754 176 176 177 177 public static char getValue(LispObject obj) throws ConditionThrowable 178 { 179 try 180 { 178 { 179 if (obj instanceof LispCharacter) 181 180 return ((LispCharacter)obj).value; 182 } 183 catch (ClassCastException e) 184 { 185 type_error(obj, Symbol.CHARACTER); 181 type_error(obj, Symbol.CHARACTER); 186 182 // Not reached. 187 return 0; 188 } 183 return 0; 189 184 } 190 185 … … 302 297 public LispObject execute(LispObject arg) throws ConditionThrowable 303 298 { 304 try 305 { 306 return Character.isWhitespace(((LispCharacter)arg).value) ? T : NIL; 307 } 308 catch (ClassCastException e) 309 { 310 return type_error(arg, Symbol.CHARACTER); 311 } 299 return Character.isWhitespace(LispCharacter.getValue(arg)) ? T : NIL; 312 300 } 313 301 }; … … 320 308 public LispObject execute(LispObject arg) throws ConditionThrowable 321 309 { 322 try 323 { 324 int n = ((LispCharacter)arg).value; 325 return Fixnum.getInstance(n); 326 } 327 catch (ClassCastException e) 328 { 329 return type_error(arg, Symbol.CHARACTER); 330 } 310 int n = LispCharacter.getValue(arg); 311 return Fixnum.getInstance(n); 331 312 } 332 313 }; … … 339 320 public LispObject execute(LispObject arg) throws ConditionThrowable 340 321 { 341 try 342 { 343 int n = ((LispCharacter)arg).value; 344 return Fixnum.getInstance(n); 345 } 346 catch (ClassCastException e) 347 { 348 return type_error(arg, Symbol.CHARACTER); 349 } 322 int n = LispCharacter.getValue(arg); 323 return Fixnum.getInstance(n); 350 324 } 351 325 }; … … 358 332 public LispObject execute(LispObject arg) throws ConditionThrowable 359 333 { 360 try 361 { 362 int n = ((Fixnum)arg).value; 363 if (n < CHAR_MAX) 364 return constants[n]; 365 else if (n <= Character.MAX_VALUE) 366 return new LispCharacter((char)n); 367 } 368 catch (ClassCastException e) 369 { 334 int n = Fixnum.getValue(arg); 335 if (n < CHAR_MAX) 336 return constants[n]; 337 else if (n <= Character.MAX_VALUE) 338 return new LispCharacter((char)n); 370 339 // SBCL signals a type-error here: "not of type (UNSIGNED-BYTE 8)" 371 }372 340 return NIL; 373 341 } … … 428 396 public LispObject execute(LispObject arg) throws ConditionThrowable 429 397 { 430 char c; 431 try 432 { 433 c = ((LispCharacter)arg).value; 434 } 435 catch (ClassCastException e) 436 { 437 return type_error(arg, Symbol.CHARACTER); 438 } 439 if (c < 128) 440 return constants[LOWER_CASE_CHARS[c]]; 398 final char c = LispCharacter.getValue(arg); 399 if (c < 128) 400 return constants[LOWER_CASE_CHARS[c]]; 441 401 return LispCharacter.getInstance(toLowerCase(c)); 442 402 } … … 451 411 { 452 412 final char c; 453 try 454 { 455 c = ((LispCharacter)arg).value; 456 } 457 catch (ClassCastException e) 458 { 459 return type_error(arg, Symbol.CHARACTER); 460 } 413 c = LispCharacter.getValue(arg); 461 414 if (c < 128) 462 415 return constants[UPPER_CASE_CHARS[c]]; … … 472 425 public LispObject execute(LispObject arg) throws ConditionThrowable 473 426 { 474 int weight; 475 try 476 { 477 weight = ((Fixnum)arg).value; 478 } 479 catch (ClassCastException e) 480 { 481 if (arg instanceof Bignum) 427 if (arg instanceof Bignum) 482 428 return NIL; 483 return type_error(arg, Symbol.INTEGER); 484 }429 430 int weight = Fixnum.getValue(arg); 485 431 if (weight < 10) 486 return constants['0' +weight];432 return constants['0'+weight]; 487 433 return NIL; 488 434 } … … 492 438 { 493 439 int radix; 494 try 495 { 440 if (second instanceof Fixnum) 496 441 radix = ((Fixnum)second).value; 497 } 498 catch (ClassCastException e) 499 { 442 else 500 443 radix = -1; 501 }444 502 445 if (radix < 2 || radix > 36) 503 446 return type_error(second, 504 447 list(Symbol.INTEGER, Fixnum.TWO, 505 448 Fixnum.constants[36])); 506 int weight; 507 try 508 { 509 weight = ((Fixnum)first).value; 510 } 511 catch (ClassCastException e) 512 { 513 if (first instanceof Bignum) 514 return NIL; 515 return type_error(first, Symbol.INTEGER); 516 } 449 if (first instanceof Bignum) 450 return NIL; 451 int weight = Fixnum.getValue(first); 517 452 if (weight >= radix) 518 453 return NIL; … … 530 465 public LispObject execute(LispObject arg) throws ConditionThrowable 531 466 { 532 try 533 { 534 int n = Character.digit(((LispCharacter)arg).value, 10); 535 return n < 0 ? NIL : Fixnum.constants[n]; 536 } 537 catch (ClassCastException e) 538 { 539 return type_error(arg, Symbol.CHARACTER); 540 } 467 final int n = Character.digit(LispCharacter.getValue(arg), 10); 468 return n < 0 ? NIL : Fixnum.getInstance(n); 541 469 } 542 470 @Override … … 545 473 { 546 474 char c; 547 try 548 { 549 c = ((LispCharacter)first).value; 550 } 551 catch (ClassCastException e) 552 { 553 return type_error(first, Symbol.CHARACTER); 554 } 555 try 475 c = LispCharacter.getValue(first); 476 if (second instanceof Fixnum) 556 477 { 557 478 int radix = ((Fixnum)second).value; … … 562 483 } 563 484 } 564 catch (ClassCastException e) {}565 485 return type_error(second, 566 486 list(Symbol.INTEGER, Fixnum.TWO, … … 576 496 public LispObject execute(LispObject arg) throws ConditionThrowable 577 497 { 578 try 579 { 580 return ((LispCharacter)arg).isStandardChar() ? T : NIL; 581 } 582 catch (ClassCastException e) 583 { 584 return type_error(arg, Symbol.CHARACTER); 585 } 498 return checkCharacter(arg).isStandardChar() ? T : NIL; 586 499 } 587 500 }; … … 594 507 public LispObject execute(LispObject arg) throws ConditionThrowable 595 508 { 596 try 597 { 598 char c = ((LispCharacter)arg).value; 599 if (c >= ' ' && c < 127) 600 return T; 601 return Character.isISOControl(c) ? NIL : T; 602 } 603 catch (ClassCastException e) 604 { 605 return type_error(arg, Symbol.CHARACTER); 606 } 509 char c = LispCharacter.getValue(arg); 510 if (c >= ' ' && c < 127) 511 return T; 512 return Character.isISOControl(c) ? NIL : T; 607 513 } 608 514 }; … … 615 521 public LispObject execute(LispObject arg) throws ConditionThrowable 616 522 { 617 try 618 { 619 return Character.isLetter(((LispCharacter)arg).value) ? T : NIL; 620 } 621 catch (ClassCastException e) 622 { 623 return type_error(arg, Symbol.CHARACTER); 624 } 523 return Character.isLetter(LispCharacter.getValue(arg)) ? T : NIL; 625 524 } 626 525 }; … … 633 532 public LispObject execute(LispObject arg) throws ConditionThrowable 634 533 { 635 try 636 { 637 return Character.isLetterOrDigit(((LispCharacter)arg).value) ? T : NIL; 638 } 639 catch (ClassCastException e) 640 { 641 return type_error(arg, Symbol.CHARACTER); 642 } 534 return Character.isLetterOrDigit(LispCharacter.getValue(arg)) ? T : NIL; 643 535 } 644 536 }; -
trunk/abcl/src/org/armedbear/lisp/LispClass.java
r11711 r11754 65 65 throws ConditionThrowable 66 66 { 67 final Symbol symbol; 68 try 69 { 70 symbol = (Symbol) name; 71 } 72 catch (ClassCastException e) 73 { 74 return type_error(name, Symbol.SYMBOL); 75 } 67 final Symbol symbol = checkSymbol(name); 76 68 final LispClass c; 77 69 synchronized (map) … … 364 356 throws ConditionThrowable 365 357 { 366 final Symbol name; 367 try 368 { 369 name = (Symbol) first; 370 } 371 catch (ClassCastException e) 372 { 373 return type_error(first, Symbol.SYMBOL); 374 } 358 final Symbol name = checkSymbol(first); 375 359 if (second == NIL) 376 360 { … … 378 362 return second; 379 363 } 380 final LispClass c; 381 try 382 { 383 c = (LispClass) second; 384 } 385 catch (ClassCastException e) 386 { 387 return type_error(second, Symbol.CLASS); 388 } 364 final LispClass c = checkClass(second); 389 365 addClass(name, c); 390 366 return second; … … 400 376 throws ConditionThrowable 401 377 { 402 final LispClass c; 403 try 404 { 405 c = (LispClass) first; 406 } 407 catch (ClassCastException e) 408 { 409 return type_error(first, Symbol.CLASS); 410 } 378 final LispClass c = checkClass(first); 411 379 return c.subclassp(second) ? T : NIL; 412 380 } -
trunk/abcl/src/org/armedbear/lisp/LispObject.java
r11714 r11754 102 102 public Object javaInstance() throws ConditionThrowable 103 103 { 104 104 return this; 105 105 /*return error(new LispError("The value " + writeToString() + 106 106 " is not of primitive type."));*/ … … 452 452 public LispObject AREF(LispObject index) throws ConditionThrowable 453 453 { 454 try 455 { 456 return AREF(((Fixnum)index).value); 457 } 458 catch (ClassCastException e) 459 { 460 return type_error(index, Symbol.FIXNUM); 461 } 454 return AREF(Fixnum.getValue(index)); 462 455 } 463 456 464 457 public void aset(int index, int n) 465 458 throws ConditionThrowable 466 { 467 aset(index, Fixnum.getInstance(n));459 { 460 aset(index, Fixnum.getInstance(n)); 468 461 } 469 462 … … 477 470 throws ConditionThrowable 478 471 { 479 try 480 { 481 aset(((Fixnum)index).value, newValue); 482 } 483 catch (ClassCastException e) 484 { 485 type_error(index, Symbol.FIXNUM); 486 } 472 aset(Fixnum.getValue(index), newValue); 487 473 } 488 474 -
trunk/abcl/src/org/armedbear/lisp/LispThread.java
r11711 r11754 1035 1035 { 1036 1036 final LispThread lispThread; 1037 try{1037 if (arg instanceof LispThread) { 1038 1038 lispThread = (LispThread) arg; 1039 1039 } 1040 catch (ClassCastException e){1040 else { 1041 1041 return type_error(arg, Symbol.THREAD); 1042 1042 } … … 1052 1052 public LispObject execute(LispObject arg) throws ConditionThrowable 1053 1053 { 1054 try{1054 if (arg instanceof LispThread) { 1055 1055 return ((LispThread)arg).name; 1056 1056 } 1057 catch (ClassCastException e) { 1058 return type_error(arg, Symbol.THREAD); 1059 } 1057 return type_error(arg, Symbol.THREAD); 1060 1058 } 1061 1059 }; … … 1110 1108 { 1111 1109 final LispThread thread; 1112 try{1110 if (arg instanceof LispThread) { 1113 1111 thread = (LispThread) arg; 1114 1112 } 1115 catch (ClassCastException e){1113 else { 1116 1114 return type_error(arg, Symbol.THREAD); 1117 1115 } … … 1135 1133 return error(new WrongNumberOfArgumentsException(this)); 1136 1134 final LispThread thread; 1137 try{1135 if (args[0] instanceof LispThread) { 1138 1136 thread = (LispThread) args[0]; 1139 1137 } 1140 catch (ClassCastException e){1138 else { 1141 1139 return type_error(args[0], Symbol.THREAD); 1142 1140 } -
trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java
r11539 r11754 284 284 throws ConditionThrowable 285 285 { 286 try { 287 AbstractString s = (AbstractString) arg; 286 AbstractString s = checkString(arg); 288 287 if (s.length() == 0) { 289 288 // "The null string, "", is not a valid value for any … … 293 292 } 294 293 return canonicalizeStringComponent(s); 295 }296 catch (ClassCastException e) {297 return type_error(arg, Symbol.STRING);298 }299 294 } 300 295 }; -
trunk/abcl/src/org/armedbear/lisp/Mutex.java
r11488 r11754 120 120 public LispObject execute(LispObject arg) throws ConditionThrowable 121 121 { 122 try { 123 ((Mutex)arg).acquire(); 124 return T; 125 } 126 catch (ClassCastException e) { 127 return error(new TypeError("The value " + arg.writeToString() + 128 " is not a mutex.")); 129 } 130 catch (InterruptedException e) { 131 return error(new LispError( 132 "The thread " + LispThread.currentThread().writeToString() + 133 " was interrupted.")); 134 } 135 } 122 if (arg instanceof Mutex) 123 try { 124 ((Mutex) arg).acquire(); 125 return T; 126 } catch (InterruptedException e) { 127 return error(new LispError("The thread " 128 + LispThread.currentThread().writeToString() 129 + " was interrupted.")); 130 } 131 return error(new TypeError("The value " + arg.writeToString() 132 + " is not a mutex.")); 133 } 136 134 }; 137 135 … … 143 141 public LispObject execute(LispObject arg) throws ConditionThrowable 144 142 { 145 try{143 if (arg instanceof Mutex) { 146 144 ((Mutex)arg).release(); 147 145 return T; 148 146 } 149 catch (ClassCastException e) {150 147 return error(new TypeError("The value " + arg.writeToString() + 151 148 " is not a mutex.")); 152 }153 149 } 154 150 }; -
trunk/abcl/src/org/armedbear/lisp/Nil.java
r11726 r11754 169 169 { 170 170 int index; 171 try { 172 index = ((Fixnum)arg).value; 173 } 174 catch (ClassCastException e) { 175 if (arg instanceof Bignum) { 176 if (arg.minusp()) 177 return error(new TypeError(arg, Symbol.UNSIGNED_BYTE)); 171 if (arg instanceof Fixnum) { 172 index = ((Fixnum) arg).value; 173 } else if (arg instanceof Bignum) { 174 if (arg.minusp()) 175 return error(new TypeError(arg, Symbol.UNSIGNED_BYTE)); 176 return NIL; 177 } else 178 return error(new TypeError(arg, Symbol.UNSIGNED_BYTE)); 179 if (index < 0) 180 error(new TypeError(arg, Symbol.UNSIGNED_BYTE)); 178 181 return NIL; 179 }180 return error(new TypeError(arg, Symbol.UNSIGNED_BYTE));181 }182 if (index < 0)183 error(new TypeError(arg, Symbol.UNSIGNED_BYTE));184 return NIL;185 182 } 186 183 -
trunk/abcl/src/org/armedbear/lisp/Pathname.java
r11711 r11754 759 759 { 760 760 final LispThread thread = LispThread.currentThread(); 761 final AbstractString namestring; 762 try { 763 namestring = (AbstractString) first; 764 } 765 catch (ClassCastException e) { 766 return type_error(first, Symbol.STRING); 767 } 761 final AbstractString namestring = checkString(first); 768 762 // The HOST parameter must be a string or NIL. 769 763 if (second == NIL) { … … 781 775 } 782 776 Debug.assertTrue(second != NIL); 783 final AbstractString host; 784 try { 785 host = (AbstractString) second; 786 } 787 catch (ClassCastException e) { 788 return type_error(second, Symbol.STRING); 789 } 777 final AbstractString host = checkString(second); 790 778 return thread.setValues(parseNamestring(namestring, host), 791 779 namestring.LENGTH()); -
trunk/abcl/src/org/armedbear/lisp/Primitives.java
r11714 r11754 248 248 public LispObject execute(LispObject arg) throws ConditionThrowable 249 249 { 250 try 251 { 252 return ((AbstractArray)arg).hasFillPointer() ? T : NIL; 253 } 254 catch (ClassCastException e) 255 { 256 return type_error(arg, Symbol.ARRAY); 257 } 258 } 250 return checkArray(arg).hasFillPointer() ? T : NIL; 251 } 259 252 }; 260 253 … … 444 437 throws ConditionThrowable 445 438 { 446 try 447 { 448 return first.elt(((Fixnum)second).value); 449 } 450 catch (ClassCastException e) 451 { 452 return type_error(second, Symbol.FIXNUM); 453 } 439 return first.elt(Fixnum.getValue(second)); 454 440 } 455 441 }; … … 596 582 { 597 583 final LispObject value; 598 try 599 { 600 value = ((Symbol)arg).symbolValue(); 601 } 602 catch (ClassCastException e) 603 { 604 return type_error(arg, Symbol.SYMBOL); 605 } 584 value = checkSymbol(arg).symbolValue(); 606 585 if (value instanceof SymbolMacro) 607 586 return error(new LispError(arg.writeToString() + … … 619 598 throws ConditionThrowable 620 599 { 621 try 622 { 623 return LispThread.currentThread().setSpecialVariable((Symbol)first, 600 return LispThread.currentThread().setSpecialVariable(checkSymbol(first), 624 601 second); 625 }626 catch (ClassCastException e)627 {628 return type_error(first, Symbol.SYMBOL);629 }630 602 } 631 603 }; … … 799 771 throws ConditionThrowable 800 772 { 801 try 802 { 803 ((Stream)second)._writeString(first.writeToString()); 773 checkStream(second)._writeString(first.writeToString()); 804 774 return first; 805 }806 catch (ClassCastException e)807 {808 return type_error(second, Symbol.STREAM);809 }810 775 } 811 776 }; … … 819 784 throws ConditionThrowable 820 785 { 821 final Stream out; 822 try 823 { 786 final LispObject out; 824 787 if (second == T) 825 out = (Stream)Symbol.TERMINAL_IO.symbolValue();788 out = Symbol.TERMINAL_IO.symbolValue(); 826 789 else if (second == NIL) 827 out = (Stream)Symbol.STANDARD_OUTPUT.symbolValue();790 out = Symbol.STANDARD_OUTPUT.symbolValue(); 828 791 else 829 out = (Stream) second; 830 } 831 catch (ClassCastException e) 832 { 833 return type_error(second, Symbol.STREAM); 834 } 835 out._writeString(first.writeToString()); 792 out = second; 793 checkStream(out)._writeString(first.writeToString()); 836 794 return first; 837 795 } … … 856 814 public LispObject execute(LispObject arg) throws ConditionThrowable 857 815 { 858 try 859 { 860 ((Stream)arg)._writeChar('\n'); 816 checkStream(arg)._writeChar('\n'); 861 817 return NIL; 862 }863 catch (ClassCastException e)864 {865 return type_error(arg, Symbol.STREAM);866 }867 818 } 868 819 }; … … 880 831 arg = Symbol.STANDARD_OUTPUT.symbolValue(); 881 832 final Stream stream; 882 try 883 { 884 stream = (Stream) arg; 885 } 886 catch (ClassCastException e) 887 { 888 return type_error(arg, Symbol.STREAM); 889 } 833 stream = checkStream(arg); 890 834 return stream.terpri(); 891 835 } … … 905 849 arg = Symbol.STANDARD_OUTPUT.symbolValue(); 906 850 final Stream stream; 907 try 908 { 909 stream = (Stream) arg; 910 } 911 catch (ClassCastException e) 912 { 913 return type_error(arg, Symbol.STREAM); 914 } 851 stream = checkStream(arg); 915 852 return stream.freshLine(); 916 853 } … … 927 864 { 928 865 final Symbol symbol; 929 try 930 { 931 symbol = (Symbol) arg; 932 } 933 catch (ClassCastException e) 934 { 935 return type_error(arg, Symbol.SYMBOL); 936 } 866 symbol = checkSymbol(arg); 937 867 // PROGV: "If too few values are supplied, the remaining symbols 938 868 // are bound and then made to have no value." So BOUNDP must … … 974 904 if (arg instanceof Symbol) 975 905 { 976 ((Symbol)arg).setSymbolFunction(null);906 checkSymbol(arg).setSymbolFunction(null); 977 907 return arg; 978 908 } … … 1506 1436 throws ConditionThrowable 1507 1437 { 1508 final int index; 1509 try 1510 { 1511 index = ((Fixnum)first).value; 1512 } 1513 catch (ClassCastException e) 1514 { 1515 return type_error(first, Symbol.FIXNUM); 1516 } 1438 final int index = Fixnum.getValue(first); 1517 1439 if (index < 0) 1518 1440 return type_error(first, … … 1648 1570 if (out instanceof Stream) 1649 1571 { 1650 ( (Stream)out)._writeString(s);1572 (out)._writeString(s); 1651 1573 return NIL; 1652 1574 } … … 1888 1810 { 1889 1811 final Symbol symbol; 1890 try 1891 { 1892 symbol = (Symbol) first; 1893 } 1894 catch (ClassCastException e) 1895 { 1896 return type_error(first, Symbol.SYMBOL); 1897 } 1812 symbol = checkSymbol(first); 1898 1813 if (third instanceof AbstractString) 1899 1814 symbol.setDocumentation(Symbol.VARIABLE, third); … … 1913 1828 { 1914 1829 final Symbol symbol; 1915 try 1916 { 1917 symbol = (Symbol) arg; 1918 } 1919 catch (ClassCastException e) 1920 { 1921 return type_error(arg, Symbol.SYMBOL); 1922 } 1830 symbol = checkSymbol(arg); 1923 1831 symbol.setSpecial(true); 1924 1832 return symbol; … … 1929 1837 { 1930 1838 final Symbol symbol; 1931 try 1932 { 1933 symbol = (Symbol) first; 1934 } 1935 catch (ClassCastException e) 1936 { 1937 return type_error(first, Symbol.SYMBOL); 1938 } 1839 symbol = checkSymbol(first); 1939 1840 symbol.initializeSpecial(second); 1940 1841 return symbol; … … 1952 1853 { 1953 1854 final Symbol symbol; 1954 try 1955 { 1956 symbol = (Symbol) first; 1957 } 1958 catch (ClassCastException e) 1959 { 1960 return type_error(first, Symbol.SYMBOL); 1961 } 1855 symbol = checkSymbol(first); 1962 1856 if (third != NIL) 1963 1857 { … … 2142 2036 public LispObject execute(LispObject arg) throws ConditionThrowable 2143 2037 { 2144 try 2145 { 2146 return Fixnum.getInstance(((AbstractArray)arg).getRank()); 2147 } 2148 catch (ClassCastException e) 2149 { 2150 return type_error(arg, Symbol.ARRAY); 2151 } 2038 return Fixnum.getInstance(checkArray(arg).getRank()); 2039 2152 2040 } 2153 2041 }; … … 2161 2049 public LispObject execute(LispObject arg) throws ConditionThrowable 2162 2050 { 2163 try 2164 { 2165 return ((AbstractArray)arg).getDimensions(); 2166 } 2167 catch (ClassCastException e) 2168 { 2169 return type_error(arg, Symbol.ARRAY); 2170 } 2051 return checkArray(arg).getDimensions(); 2171 2052 } 2172 2053 }; … … 2180 2061 throws ConditionThrowable 2181 2062 { 2182 final AbstractArray array; 2183 try 2184 { 2185 array = (AbstractArray) first; 2186 } 2187 catch (ClassCastException e) 2188 { 2189 return type_error(first, Symbol.ARRAY); 2190 } 2191 final int n; 2192 try 2193 { 2194 n = ((Fixnum)second).value; 2195 } 2196 catch (ClassCastException e) 2197 { 2198 return type_error(second, Symbol.FIXNUM); 2199 } 2200 return Fixnum.getInstance(array.getDimension(n)); 2063 final AbstractArray array = checkArray(first); 2064 return Fixnum.getInstance(array.getDimension(Fixnum.getValue(second))); 2201 2065 } 2202 2066 }; … … 2209 2073 public LispObject execute(LispObject arg) throws ConditionThrowable 2210 2074 { 2211 try 2212 { 2213 return Fixnum.getInstance(((AbstractArray)arg).getTotalSize()); 2214 } 2215 catch (ClassCastException e) 2216 { 2217 return type_error(arg, Symbol.ARRAY); 2218 } 2075 return Fixnum.getInstance(checkArray(arg).getTotalSize()); 2219 2076 } 2220 2077 }; … … 2229 2086 public LispObject execute(LispObject arg) throws ConditionThrowable 2230 2087 { 2231 try 2232 { 2233 return ((AbstractArray)arg).getElementType(); 2234 } 2235 catch (ClassCastException e) 2236 { 2237 return type_error(arg, Symbol.ARRAY); 2238 } 2088 return checkArray(arg).getElementType(); 2239 2089 } 2240 2090 }; … … 2247 2097 public LispObject execute(LispObject arg) throws ConditionThrowable 2248 2098 { 2249 try 2250 { 2251 return ((AbstractArray)arg).isAdjustable() ? T : NIL; 2252 } 2253 catch (ClassCastException e) 2254 { 2255 return type_error(arg, Symbol.ARRAY); 2256 } 2099 return checkArray(arg).isAdjustable() ? T : NIL; 2257 2100 } 2258 2101 }; … … 2265 2108 public LispObject execute(LispObject arg) throws ConditionThrowable 2266 2109 { 2267 try 2268 { 2269 return ((AbstractArray)arg).arrayDisplacement(); 2270 } 2271 catch (ClassCastException e) 2272 { 2273 return type_error(arg, Symbol.ARRAY); 2274 } 2110 return checkArray(arg).arrayDisplacement(); 2111 2275 2112 } 2276 2113 }; … … 2286 2123 return error(new WrongNumberOfArgumentsException(this)); 2287 2124 final AbstractArray array; 2288 try 2289 { 2290 array = (AbstractArray) args[0]; 2291 } 2292 catch (ClassCastException e) 2293 { 2294 return type_error(args[0], Symbol.ARRAY); 2295 } 2125 LispObject r = args[0]; 2126 array = checkArray(r); 2296 2127 int rank = array.getRank(); 2297 2128 if (rank != args.length - 1) … … 2332 2163 { 2333 2164 final AbstractArray array; 2334 try 2335 { 2336 array = (AbstractArray) first; 2337 } 2338 catch (ClassCastException e) 2339 { 2340 return type_error(first, Symbol.ARRAY); 2341 } 2165 array = checkArray(first); 2342 2166 LispObject[] subscripts = second.copyToArray(); 2343 2167 return number(array.getRowMajorIndex(subscripts)); … … 2358 2182 { 2359 2183 final AbstractArray array; 2360 try 2361 { 2362 array = (AbstractArray) arg; 2363 } 2364 catch (ClassCastException e) 2365 { 2366 return type_error(arg, Symbol.ARRAY); 2367 } 2184 array = checkArray( arg); 2368 2185 if (array.getRank() == 0) 2369 2186 return array.AREF(0); … … 2385 2202 throws ConditionThrowable 2386 2203 { 2387 final AbstractArray array; 2388 try 2389 { 2390 array = (AbstractArray) first; 2391 } 2392 catch (ClassCastException e) 2393 { 2394 return type_error(first, Symbol.ARRAY); 2395 } 2396 final int[] subs = new int[2]; 2397 try 2398 { 2399 subs[0] = ((Fixnum)second).value; 2400 } 2401 catch (ClassCastException e) 2402 { 2403 return type_error(second, Symbol.FIXNUM); 2404 } 2405 try 2406 { 2407 subs[1] = ((Fixnum)third).value; 2408 } 2409 catch (ClassCastException e) 2410 { 2411 return type_error(third, Symbol.FIXNUM); 2412 } 2413 return array.get(subs); 2204 return checkArray(first).get(new int[]{Fixnum.getValue(second),Fixnum.getValue(third)} ); 2414 2205 } 2415 2206 @Override 2416 2207 public LispObject execute(LispObject[] args) throws ConditionThrowable 2417 2208 { 2418 final AbstractArray array; 2419 try 2420 { 2421 array = (AbstractArray) args[0]; 2422 } 2423 catch (ClassCastException e) 2424 { 2425 return type_error(args[0], Symbol.ARRAY); 2426 } 2209 final AbstractArray array = checkArray(args[0]); 2427 2210 final int[] subs = new int[args.length - 1]; 2428 2211 for (int i = subs.length; i-- > 0;) 2429 2212 { 2430 try 2431 { 2432 subs[i] = ((Fixnum)args[i+1]).value; 2433 } 2434 catch (ClassCastException e) 2435 { 2436 return type_error(args[i+i], Symbol.FIXNUM); 2437 } 2213 subs[i] = Fixnum.getValue(args[i+1]); 2438 2214 } 2439 2215 return array.get(subs); … … 2452 2228 // Rank zero array. 2453 2229 final ZeroRankArray array; 2454 try 2455 { 2230 if (first instanceof ZeroRankArray){ 2456 2231 array = (ZeroRankArray) first; 2457 2232 } 2458 catch (ClassCastException e)2233 else 2459 2234 { 2460 2235 return error(new TypeError("The value " + … … 2476 2251 public LispObject execute(LispObject[] args) throws ConditionThrowable 2477 2252 { 2478 final AbstractArray array; 2479 try 2480 { 2481 array = (AbstractArray) args[0]; 2482 } 2483 catch (ClassCastException e) 2484 { 2485 return type_error(args[0], Symbol.ARRAY); 2486 } 2253 final AbstractArray array = checkArray(args[0]); 2487 2254 final int nsubs = args.length - 2; 2488 2255 final int[] subs = new int[nsubs]; 2489 2256 for (int i = nsubs; i-- > 0;) 2490 { 2491 try 2492 { 2493 subs[i] = ((Fixnum)args[i+1]).value; 2494 } 2495 catch (ClassCastException e) 2496 { 2497 type_error(args[i+1], Symbol.FIXNUM); 2498 } 2499 } 2257 subs[i] = Fixnum.getValue(args[i+1]); 2500 2258 final LispObject newValue = args[args.length - 1]; 2501 2259 array.set(subs, newValue); … … 2511 2269 public LispObject execute(LispObject first, LispObject second) 2512 2270 throws ConditionThrowable 2513 { 2514 try 2515 { 2516 return ((AbstractArray)first).AREF(((Fixnum)second).value); 2517 } 2518 catch (ClassCastException e) 2519 { 2520 if (first instanceof AbstractArray) 2521 return type_error(second, Symbol.FIXNUM); 2522 else 2523 return type_error(first, Symbol.ARRAY); 2524 } 2271 { 2272 return checkArray(first).AREF(Fixnum.getValue(second)); 2525 2273 } 2526 2274 }; … … 2545 2293 throws ConditionThrowable 2546 2294 { 2547 try 2548 { 2549 return Fixnum.getInstance(((AbstractArray)arg).getFillPointer()); 2550 } 2551 catch (ClassCastException e) 2552 { 2295 if (arg instanceof AbstractArray) { 2296 AbstractArray aa = (AbstractArray)arg; 2297 if (aa.hasFillPointer()) 2298 return Fixnum.getInstance(aa.getFillPointer()); 2299 } 2553 2300 return type_error(arg, list(Symbol.AND, Symbol.VECTOR, 2554 2301 list(Symbol.SATISFIES, 2555 2302 Symbol.ARRAY_HAS_FILL_POINTER_P))); 2556 }2557 2303 } 2558 2304 }; … … 2566 2312 throws ConditionThrowable 2567 2313 { 2568 try 2569 {2314 2315 if (first instanceof AbstractVector) { 2570 2316 AbstractVector v = (AbstractVector) first; 2571 2317 if (v.hasFillPointer()) … … 2575 2321 return second; 2576 2322 } 2577 catch (ClassCastException e) 2578 { 2323 2579 2324 return type_error(first, list(Symbol.AND, Symbol.VECTOR, 2580 2325 list(Symbol.SATISFIES, 2581 Symbol.ARRAY_HAS_FILL_POINTER_P))); 2582 } 2326 Symbol.ARRAY_HAS_FILL_POINTER_P))); 2583 2327 } 2584 2328 }; … … 2592 2336 throws ConditionThrowable 2593 2337 { 2594 final AbstractVector v; 2595 try 2596 { 2597 v = (AbstractVector) second; 2598 } 2599 catch (ClassCastException e) 2600 { 2601 return type_error(second, Symbol.VECTOR); 2602 } 2338 final AbstractVector v = checkVector(second); 2603 2339 int fillPointer = v.getFillPointer(); 2604 2340 if (fillPointer < 0) … … 2641 2377 public LispObject execute(LispObject arg) throws ConditionThrowable 2642 2378 { 2643 final AbstractVector v; 2644 try 2645 { 2646 v = (AbstractVector) arg; 2647 } 2648 catch (ClassCastException e) 2649 { 2650 return type_error(arg, Symbol.VECTOR); 2651 } 2379 final AbstractVector v = checkVector( arg); 2652 2380 int fillPointer = v.getFillPointer(); 2653 2381 if (fillPointer < 0) … … 2946 2674 { 2947 2675 Cons cons; 2948 try 2949 { 2676 if (list instanceof Cons) 2950 2677 cons = (Cons) list; 2951 } 2952 catch (ClassCastException e) 2953 { 2678 else 2954 2679 return type_error(list, Symbol.LIST); 2955 }2956 2680 LispObject obj = thread.execute(fun, cons.car); 2957 2681 if (splice == null) … … 3051 2775 { 3052 2776 Cons cons; 3053 try 3054 { 2777 if (list instanceof Cons) 3055 2778 cons = (Cons) list; 3056 } 3057 catch (ClassCastException e) 3058 { 2779 else 3059 2780 return type_error(list, Symbol.LIST); 3060 }3061 2781 thread.execute(fun, cons.car); 3062 2782 list = cons.cdr; … … 3279 2999 if (arg instanceof Symbol) 3280 3000 { 3281 Package pkg = Packages.findPackage( ((Symbol)arg).getName());3001 Package pkg = Packages.findPackage(checkSymbol(arg).getName()); 3282 3002 return pkg != null ? pkg : NIL; 3283 3003 } … … 3561 3281 { 3562 3282 checkRedefinition(first); 3563 Symbol symbol = (Symbol) first;3283 Symbol symbol = checkSymbol(first); 3564 3284 symbol.setSymbolFunction(second); 3565 3285 final LispThread thread = LispThread.currentThread(); … … 3657 3377 throws ConditionThrowable 3658 3378 { 3659 try 3660 { 3661 return put((Symbol)symbol, indicator, value); 3662 } 3663 catch (ClassCastException e) 3664 { 3665 return type_error(symbol, Symbol.SYMBOL); 3666 } 3379 return put(checkSymbol(symbol), indicator, value); 3667 3380 } 3668 3381 @Override … … 3671 3384 throws ConditionThrowable 3672 3385 { 3673 try 3674 { 3675 return put((Symbol)symbol, indicator, value); 3676 } 3677 catch (ClassCastException e) 3678 { 3679 return type_error(symbol, Symbol.SYMBOL); 3680 } 3386 return put(checkSymbol(symbol), indicator, value); 3681 3387 } 3682 3388 }; … … 3849 3555 return error(new WrongNumberOfArgumentsException(this)); 3850 3556 LispObject tag; 3851 try 3852 { 3853 tag = (Symbol) args.car(); 3854 } 3855 catch (ClassCastException e) 3856 { 3857 return type_error(args.car(), Symbol.SYMBOL); 3858 } 3557 tag = checkSymbol(args.car()); 3859 3558 LispObject body = ((Cons)args).cdr(); 3860 3559 Environment ext = new Environment(env); … … 3892 3591 return error(new WrongNumberOfArgumentsException(this)); 3893 3592 Symbol symbol; 3894 try 3895 { 3896 symbol = (Symbol) args.car(); 3897 } 3898 catch (ClassCastException e) 3899 { 3900 return type_error(args.car(), Symbol.SYMBOL); 3901 } 3593 symbol = checkSymbol(args.car()); 3594 3902 3595 LispObject block = env.lookupBlock(symbol); 3903 3596 if (block == null) … … 4087 3780 { 4088 3781 final Symbol sym; 4089 try 4090 { 4091 sym = (Symbol) var; 4092 } 4093 catch (ClassCastException e) 4094 { 4095 return type_error(var, Symbol.SYMBOL); 4096 } 3782 3783 sym = checkSymbol(var); 3784 4097 3785 LispObject val = i < values.length ? values[i] : NIL; 4098 3786 if (specials != NIL && memq(sym, specials)) … … 4413 4101 throws ConditionThrowable 4414 4102 { 4415 final int start; 4416 try 4417 { 4418 start = ((Fixnum)second).value; 4419 } 4420 catch (ClassCastException e) 4421 { 4422 return type_error(second, Symbol.FIXNUM); 4423 } 4103 final int start = Fixnum.getValue(second); 4424 4104 if (start < 0) 4425 4105 { … … 4443 4123 throws ConditionThrowable 4444 4124 { 4445 final int start; 4446 try 4447 { 4448 start = ((Fixnum)second).value; 4449 } 4450 catch (ClassCastException e) 4451 { 4452 return type_error(second, Symbol.FIXNUM); 4453 } 4125 final int start = Fixnum.getValue(second); 4454 4126 if (start < 0) 4455 4127 { … … 4803 4475 throws ConditionThrowable 4804 4476 { 4805 try 4806 { 4807 ((AbstractVector)vector).deleteEq(item); 4808 return vector; 4809 } 4810 catch (ClassCastException e) 4811 { 4812 return type_error(vector, Symbol.VECTOR); 4813 } 4477 checkVector(vector).deleteEq(item); 4478 return vector; 4814 4479 } 4815 4480 }; … … 4823 4488 throws ConditionThrowable 4824 4489 { 4825 try 4826 { 4827 ((AbstractVector)vector).deleteEql(item); 4828 return vector; 4829 } 4830 catch (ClassCastException e) 4831 { 4832 return type_error(vector, Symbol.VECTOR); 4833 } 4490 checkVector(vector).deleteEql(item); 4491 return vector; 4834 4492 } 4835 4493 }; … … 5331 4989 public LispObject execute(LispObject arg) throws ConditionThrowable 5332 4990 { 5333 try 5334 { 5335 return ((Symbol)arg).isBuiltInFunction() ? T : NIL; 5336 } 5337 catch (ClassCastException e) 5338 { 5339 return type_error(arg, Symbol.SYMBOL); 5340 } 4991 return checkSymbol(arg).isBuiltInFunction() ? T : NIL; 5341 4992 } 5342 4993 }; … … 5371 5022 public LispObject execute(LispObject arg) throws ConditionThrowable 5372 5023 { 5373 try 5374 { 5375 return ((Symbol)arg).name; 5376 } 5377 catch (ClassCastException e) 5378 { 5379 return type_error(arg, Symbol.SYMBOL); 5380 } 5024 return checkSymbol(arg).name; 5381 5025 } 5382 5026 }; … … 5389 5033 public LispObject execute(LispObject arg) throws ConditionThrowable 5390 5034 { 5391 try 5392 { 5393 return ((Symbol)arg).getPackage(); 5394 } 5395 catch (ClassCastException e) 5396 { 5397 return type_error(arg, Symbol.SYMBOL); 5398 } 5035 return checkSymbol(arg).getPackage(); 5399 5036 } 5400 5037 }; … … 5407 5044 public LispObject execute(LispObject arg) throws ConditionThrowable 5408 5045 { 5409 try 5410 { 5411 LispObject function = ((Symbol)arg).getSymbolFunction(); 5046 LispObject function = checkSymbol(arg).getSymbolFunction(); 5412 5047 if (function != null) 5413 5048 return function; 5414 5049 return error(new UndefinedFunction(arg)); 5415 } 5416 catch (ClassCastException e) 5417 { 5418 return type_error(arg, Symbol.SYMBOL); 5419 } 5050 5420 5051 } 5421 5052 }; … … 5429 5060 throws ConditionThrowable 5430 5061 { 5431 try 5432 { 5433 ((Symbol)first).setSymbolFunction(second); 5062 checkSymbol(first).setSymbolFunction(second); 5434 5063 return second; 5435 }5436 catch (ClassCastException e)5437 {5438 return type_error(first, Symbol.SYMBOL);5439 }5440 5064 } 5441 5065 }; … … 5448 5072 public LispObject execute(LispObject arg) throws ConditionThrowable 5449 5073 { 5450 try 5451 { 5452 return ((Symbol)arg).getPropertyList(); 5453 } 5454 catch (ClassCastException e) 5455 { 5456 return type_error(arg, Symbol.SYMBOL); 5457 } 5074 return checkSymbol(arg).getPropertyList(); 5458 5075 } 5459 5076 }; … … 5468 5085 if (arg instanceof Symbol) 5469 5086 { 5470 if ( ((Symbol)arg).getPackage() == PACKAGE_KEYWORD)5087 if (checkSymbol(arg).getPackage() == PACKAGE_KEYWORD) 5471 5088 return T; 5472 5089 } … … 5498 5115 public LispObject execute(LispObject arg) throws ConditionThrowable 5499 5116 { 5500 try 5501 { 5502 ((Symbol)arg).setSymbolValue(null); 5117 checkSymbol(arg).setSymbolValue(null); 5503 5118 return arg; 5504 }5505 catch (ClassCastException e)5506 {5507 return type_error(arg, Symbol.SYMBOL);5508 }5509 5119 } 5510 5120 }; … … 5517 5127 public LispObject execute(LispObject arg) throws ConditionThrowable 5518 5128 { 5519 try 5520 { 5521 return ((LispClass)arg).symbol; 5522 } 5523 catch (ClassCastException e) 5524 { 5525 return type_error(arg, Symbol.CLASS); 5526 } 5129 return checkClass(arg).symbol; 5527 5130 } 5528 5131 }; … … 5536 5139 throws ConditionThrowable 5537 5140 { 5538 try 5539 { 5540 ((LispClass)first).symbol = checkSymbol(second); 5541 return second; 5542 } 5543 catch (ClassCastException e) 5544 { 5545 return type_error(first, Symbol.CLASS); 5546 } 5141 checkClass(first).symbol = checkSymbol(second); 5142 return second; 5547 5143 } 5548 5144 }; … … 5555 5151 public LispObject execute(LispObject arg) throws ConditionThrowable 5556 5152 { 5557 try 5558 { 5559 Layout layout = ((LispClass)arg).getClassLayout(); 5560 return layout != null ? layout : NIL; 5561 } 5562 catch (ClassCastException e) 5563 { 5564 return type_error(arg, Symbol.CLASS); 5565 } 5153 Layout layout = checkClass(arg).getClassLayout(); 5154 return layout != null ? layout : NIL; 5566 5155 } 5567 5156 }; … … 5575 5164 throws ConditionThrowable 5576 5165 { 5577 try5578 { 5579 ((LispClass)first).setClassLayout((Layout)second);5166 if (second instanceof Layout) 5167 { 5168 checkClass(first).setClassLayout((Layout)second); 5580 5169 return second; 5581 5170 } 5582 catch (ClassCastException e) 5583 { 5584 if (!(first instanceof LispClass)) 5585 return type_error(first, Symbol.CLASS); 5586 if (!(second instanceof Layout)) 5587 return type_error(second, Symbol.LAYOUT); 5588 // Not reached. 5589 return NIL; 5590 } 5171 return type_error(second, Symbol.LAYOUT); 5591 5172 } 5592 5173 }; … … 5599 5180 public LispObject execute(LispObject arg) throws ConditionThrowable 5600 5181 { 5601 try 5602 { 5603 return ((LispClass)arg).getDirectSuperclasses(); 5604 } 5605 catch (ClassCastException e) 5606 { 5607 return type_error(arg, Symbol.CLASS); 5608 } 5182 return checkClass(arg).getDirectSuperclasses(); 5609 5183 } 5610 5184 }; … … 5618 5192 throws ConditionThrowable 5619 5193 { 5620 try 5621 { 5622 ((LispClass)first).setDirectSuperclasses(second); 5194 checkClass(first).setDirectSuperclasses(second); 5623 5195 return second; 5624 }5625 catch (ClassCastException e)5626 {5627 return type_error(first, Symbol.CLASS);5628 }5629 5196 } 5630 5197 }; … … 5637 5204 public LispObject execute(LispObject arg) throws ConditionThrowable 5638 5205 { 5639 try 5640 { 5641 return ((LispClass)arg).getDirectSubclasses(); 5642 } 5643 catch (ClassCastException e) 5644 { 5645 return type_error(arg, Symbol.CLASS); 5646 } 5206 return checkClass(arg).getDirectSubclasses(); 5647 5207 } 5648 5208 }; … … 5657 5217 throws ConditionThrowable 5658 5218 { 5659 try 5660 { 5661 ((LispClass)first).setDirectSubclasses(second); 5662 return second; 5663 } 5664 catch (ClassCastException e) 5665 { 5666 return type_error(first, Symbol.CLASS); 5667 } 5219 checkClass(first).setDirectSubclasses(second); 5220 return second; 5668 5221 } 5669 5222 }; … … 5676 5229 public LispObject execute(LispObject arg) throws ConditionThrowable 5677 5230 { 5678 try 5679 { 5680 return ((LispClass)arg).getCPL(); 5681 } 5682 catch (ClassCastException e) 5683 { 5684 return type_error(arg, Symbol.CLASS); 5685 } 5231 return checkClass(arg).getCPL(); 5686 5232 } 5687 5233 }; … … 5695 5241 throws ConditionThrowable 5696 5242 { 5697 try 5698 { 5699 ((LispClass)first).classPrecedenceList = second; 5700 return second; 5701 } 5702 catch (ClassCastException e) 5703 { 5704 return type_error(first, Symbol.CLASS); 5705 } 5243 checkClass(first).classPrecedenceList = second; 5244 return second; 5706 5245 } 5707 5246 }; … … 5715 5254 throws ConditionThrowable 5716 5255 { 5717 try 5718 { 5719 return ((LispClass)arg).directMethods; 5720 } 5721 catch (ClassCastException e) 5722 { 5723 return type_error(arg, Symbol.CLASS); 5724 } 5256 return checkClass(arg).directMethods; 5725 5257 } 5726 5258 }; … … 5734 5266 throws ConditionThrowable 5735 5267 { 5736 try 5737 { 5738 ((LispClass)first).directMethods = second; 5739 return second; 5740 } 5741 catch (ClassCastException e) 5742 { 5743 return type_error(first, Symbol.CLASS); 5744 } 5268 checkClass(first).directMethods = second; 5269 return second; 5745 5270 } 5746 5271 }; … … 5754 5279 throws ConditionThrowable 5755 5280 { 5756 try 5757 { 5758 return ((LispClass)arg).documentation; 5759 } 5760 catch (ClassCastException e) 5761 { 5762 return type_error(arg, Symbol.CLASS); 5763 } 5281 return checkClass(arg).documentation; 5764 5282 } 5765 5283 }; … … 5773 5291 throws ConditionThrowable 5774 5292 { 5775 try 5776 { 5777 ((LispClass)first).documentation = second; 5778 return second; 5779 } 5780 catch (ClassCastException e) 5781 { 5782 return type_error(first, Symbol.CLASS); 5783 } 5293 checkClass(first).documentation = second; 5294 return second; 5784 5295 } 5785 5296 }; … … 5792 5303 public LispObject execute(LispObject arg) throws ConditionThrowable 5793 5304 { 5794 try 5795 { 5796 return ((LispClass)arg).isFinalized() ? T : NIL; 5797 } 5798 catch (ClassCastException e) 5799 { 5800 return type_error(arg, Symbol.CLASS); 5801 } 5305 return checkClass(arg).isFinalized() ? T : NIL; 5802 5306 } 5803 5307 }; … … 5811 5315 throws ConditionThrowable 5812 5316 { 5813 try 5814 { 5815 ((LispClass)first).setFinalized(second != NIL); 5816 return second; 5817 } 5818 catch (ClassCastException e) 5819 { 5820 return type_error(first, Symbol.CLASS); 5821 } 5317 checkClass(first).setFinalized(second != NIL); 5318 return second; 5822 5319 } 5823 5320 }; … … 5842 5339 { 5843 5340 final LispCharacter c; 5844 try 5845 { 5846 c = (LispCharacter) arg; 5847 } 5848 catch (ClassCastException e) 5849 { 5850 return type_error(arg, Symbol.CHARACTER); 5851 } 5341 c = checkCharacter( arg); 5852 5342 char[] chars = new char[1]; 5853 5343 chars[0] = c.value; … … 5933 5423 public LispObject execute(LispObject arg) throws ConditionThrowable 5934 5424 { 5935 try 5936 { 5937 return ((Function)arg).getPropertyList(); 5938 } 5939 catch (ClassCastException e) 5940 { 5941 return type_error(arg, Symbol.FUNCTION); 5942 } 5425 return checkFunction(arg).getPropertyList(); 5943 5426 } 5944 5427 }; … … 5951 5434 public LispObject execute(LispObject arg) throws ConditionThrowable 5952 5435 { 5953 try 5954 { 5955 return PACKAGE_KEYWORD.intern(((Symbol)arg).name); 5956 } 5957 catch (ClassCastException e) 5958 { 5959 return type_error(arg, Symbol.SYMBOL); 5960 } 5436 return PACKAGE_KEYWORD.intern(checkSymbol(arg).name); 5961 5437 } 5962 5438 }; … … 5989 5465 } 5990 5466 }; 5467 5991 5468 } -
trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java
r11488 r11754 115 115 public LispObject execute(LispObject arg) throws ConditionThrowable 116 116 { 117 try { 118 return ((PrintNotReadable)arg).getInstanceSlotValue(Symbol.OBJECT); 119 } 120 catch (ClassCastException e) { 117 if (arg instanceof PrintNotReadable) return ((PrintNotReadable)arg).getInstanceSlotValue(Symbol.OBJECT); 121 118 return type_error(arg, Symbol.PRINT_NOT_READABLE); 122 } 119 123 120 } 124 121 }; -
trunk/abcl/src/org/armedbear/lisp/Readtable.java
r11711 r11754 552 552 public LispObject execute(LispObject arg) throws ConditionThrowable 553 553 { 554 try 555 { 556 return ((Readtable)arg).readtableCase; 557 } 558 catch (ClassCastException e) 559 { 560 return type_error(arg, Symbol.READTABLE); 561 } 554 return checkReadtable(arg).readtableCase; 562 555 } 563 556 }; … … 572 565 throws ConditionThrowable 573 566 { 574 try 575 { 576 Readtable readtable = (Readtable) first; 567 final Readtable readtable = checkReadtable(first); 577 568 if (second == Keyword.UPCASE || second == Keyword.DOWNCASE || 578 569 second == Keyword.INVERT || second == Keyword.PRESERVE) … … 586 577 Keyword.DOWNCASE, 587 578 Keyword.UPCASE)); 588 }589 catch (ClassCastException e)590 {591 return type_error(first, Symbol.READTABLE);592 }593 579 } 594 580 }; -
trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java
r11714 r11754 137 137 badIndex(index, capacity); 138 138 final int offset = index >> 6; 139 try{139 if (newValue instanceof Fixnum) { 140 140 switch (((Fixnum)newValue).value) { 141 141 case 0: … … 147 147 } 148 148 } 149 catch (ClassCastException e) { 150 // Fall through... 151 } 152 error(new TypeError(newValue, Symbol.BIT)); 149 // Fall through... 150 type_error(newValue, Symbol.BIT); 153 151 } 154 152 -
trunk/abcl/src/org/armedbear/lisp/SimpleString.java
r11714 r11754 404 404 { 405 405 try { 406 return LispCharacter.getInstance(chars[((Fixnum)index).value]); 407 } 408 catch (ClassCastException e) { 409 return type_error(index, Symbol.FIXNUM); 406 return LispCharacter.getInstance(chars[Fixnum.getValue(index)]); 410 407 } 411 408 catch (ArrayIndexOutOfBoundsException e) { … … 419 416 { 420 417 try { 421 chars[index] = ((LispCharacter)obj).value; 422 } 423 catch (ArrayIndexOutOfBoundsException e) { 424 badIndex(index, capacity); 425 } 426 catch (ClassCastException e) { 427 type_error(obj, Symbol.CHARACTER); 418 chars[index] = LispCharacter.getValue(obj); 419 } 420 catch (ArrayIndexOutOfBoundsException e) { 421 badIndex(index, capacity); 428 422 } 429 423 } -
trunk/abcl/src/org/armedbear/lisp/SimpleVector.java
r11714 r11754 176 176 public LispObject AREF(LispObject index) throws ConditionThrowable 177 177 { 178 try 179 { 180 return data[((Fixnum)index).value]; 181 } 182 catch (ClassCastException e) 183 { 184 return error(new TypeError(index, Symbol.FIXNUM)); 185 } 186 catch (ArrayIndexOutOfBoundsException e) 187 { 188 badIndex(((Fixnum)index).value, data.length); 178 int idx = Fixnum.getValue(index); 179 try 180 { 181 return data[idx]; 182 } 183 catch (ArrayIndexOutOfBoundsException e) 184 { 185 badIndex(idx, data.length); 189 186 return NIL; // Not reached. 190 187 } … … 389 386 throws ConditionThrowable 390 387 { 391 try 392 { 393 return ((SimpleVector)first).data[((Fixnum)second).value]; 394 } 395 catch (ClassCastException e) 396 { 397 if (first instanceof SimpleVector) 398 return error(new TypeError(second, Symbol.FIXNUM)); 399 else 400 return error(new TypeError(first, Symbol.SIMPLE_VECTOR)); 401 } 402 } 388 if (first instanceof SimpleVector) { 389 final SimpleVector sv = (SimpleVector)first; 390 int index = Fixnum.getValue(second); 391 try { 392 return sv.data[index]; 393 } catch (ArrayIndexOutOfBoundsException e) { 394 int capacity = sv.capacity; 395 sv.badIndex(index, capacity); 396 // Not reached. 397 return NIL; 398 } 399 } 400 return type_error(first, Symbol.SIMPLE_VECTOR); 401 } 403 402 }; 404 403 … … 412 411 throws ConditionThrowable 413 412 { 414 try 415 { 416 ((SimpleVector)first).data[((Fixnum)second).value] = third; 417 return third; 418 } 419 catch (ClassCastException e) 420 { 421 if (first instanceof SimpleVector) 422 return error(new TypeError(second, Symbol.FIXNUM)); 423 else 424 return error(new TypeError(first, Symbol.SIMPLE_VECTOR)); 425 } 426 catch (ArrayIndexOutOfBoundsException e) 427 { 428 int index = ((Fixnum)second).value; 429 int capacity = ((SimpleVector)first).capacity; 430 ((SimpleVector)first).badIndex(index, capacity); 431 // Not reached. 432 return NIL; 433 } 413 if (first instanceof SimpleVector) { 414 final SimpleVector sv = (SimpleVector)first; 415 int index = Fixnum.getValue(second); 416 try { 417 sv.data[index] = third; 418 return third; 419 } catch (ArrayIndexOutOfBoundsException e) { 420 int capacity = sv.capacity; 421 sv.badIndex(index, capacity); 422 // Not reached. 423 return NIL; 424 } 425 } 426 return type_error(first, Symbol.SIMPLE_VECTOR); 434 427 } 435 428 }; -
trunk/abcl/src/org/armedbear/lisp/SingleFloat.java
r11714 r11754 226 226 public static double getValue(LispObject obj) throws ConditionThrowable 227 227 { 228 try {228 if (obj instanceof SingleFloat) 229 229 return ((SingleFloat)obj).value; 230 } 231 catch (ClassCastException e) { 232 error(new TypeError(obj, Symbol.FLOAT)); 233 // Not reached. 234 return 0; 235 } 230 type_error(obj, Symbol.FLOAT); 231 // not reached 232 return 0.0D; 236 233 } 237 234 -
trunk/abcl/src/org/armedbear/lisp/SlotClass.java
r11488 r11754 185 185 throws ConditionThrowable 186 186 { 187 try{187 if (first instanceof SlotClass) { 188 188 ((SlotClass)first).directSlotDefinitions = second; 189 189 return second; 190 190 } 191 catch (ClassCastException e){191 else { 192 192 return type_error(first, Symbol.STANDARD_CLASS); 193 193 } … … 219 219 throws ConditionThrowable 220 220 { 221 try{221 if (first instanceof SlotClass) { 222 222 ((SlotClass)first).slotDefinitions = second; 223 223 return second; 224 224 } 225 catch (ClassCastException e){225 else { 226 226 return type_error(first, Symbol.STANDARD_CLASS); 227 227 } … … 253 253 throws ConditionThrowable 254 254 { 255 try { 256 ((SlotClass)first).directDefaultInitargs = second; 257 return second; 258 } 259 catch (ClassCastException e) { 260 return type_error(first, Symbol.STANDARD_CLASS); 261 } 255 if (first instanceof SlotClass) { 256 ((SlotClass)first).directDefaultInitargs = second; 257 return second; 258 } 259 return type_error(first, Symbol.STANDARD_CLASS); 262 260 } 263 261 }; … … 304 302 { 305 303 final SlotClass c; 306 try{304 if (arg instanceof SlotClass) { 307 305 c = (SlotClass) arg; 308 306 } 309 catch (ClassCastException e){307 else { 310 308 return type_error(arg, Symbol.STANDARD_CLASS); 311 309 } -
trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java
r11714 r11754 82 82 } 83 83 } 84 85 public static SlotDefinition checkSlotDefination(LispObject obj) throws ConditionThrowable { 86 if (obj instanceof SlotDefinition) return (SlotDefinition)obj; 87 return (SlotDefinition)type_error(obj, Symbol.SLOT_DEFINITION); 88 } 84 89 85 90 public final LispObject getName() … … 125 130 public LispObject execute(LispObject arg) throws ConditionThrowable 126 131 { 127 try 128 { 129 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_NAME]; 130 } 131 catch (ClassCastException e) 132 { 133 return type_error(arg, Symbol.SLOT_DEFINITION); 134 } 132 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_NAME]; 135 133 } 136 134 }; … … 145 143 throws ConditionThrowable 146 144 { 147 try 148 { 149 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_NAME] = second; 150 return second; 151 } 152 catch (ClassCastException e) 153 { 154 return type_error(first, Symbol.SLOT_DEFINITION); 155 } 145 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_NAME] = second; 146 return second; 156 147 } 157 148 }; … … 164 155 public LispObject execute(LispObject arg) throws ConditionThrowable 165 156 { 166 try 167 { 168 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION]; 169 } 170 catch (ClassCastException e) 171 { 172 return type_error(arg, Symbol.SLOT_DEFINITION); 173 } 157 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION]; 174 158 } 175 159 }; … … 184 168 throws ConditionThrowable 185 169 { 186 try 187 { 188 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = second; 189 return second; 190 } 191 catch (ClassCastException e) 192 { 193 return type_error(first, Symbol.SLOT_DEFINITION); 194 } 170 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = second; 171 return second; 195 172 } 196 173 }; … … 204 181 public LispObject execute(LispObject arg) throws ConditionThrowable 205 182 { 206 try 207 { 208 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM]; 209 } 210 catch (ClassCastException e) 211 { 212 return type_error(arg, Symbol.SLOT_DEFINITION); 213 } 183 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM]; 214 184 } 215 185 }; … … 224 194 throws ConditionThrowable 225 195 { 226 try 227 { 228 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = second; 229 return second; 230 } 231 catch (ClassCastException e) 232 { 233 return type_error(first, Symbol.SLOT_DEFINITION); 234 } 196 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = second; 197 return second; 235 198 } 236 199 }; … … 243 206 public LispObject execute(LispObject arg) throws ConditionThrowable 244 207 { 245 try 246 { 247 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS]; 248 } 249 catch (ClassCastException e) 250 { 251 return type_error(arg, Symbol.SLOT_DEFINITION); 252 } 208 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS]; 253 209 } 254 210 }; … … 263 219 throws ConditionThrowable 264 220 { 265 try 266 { 267 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] = second; 268 return second; 269 } 270 catch (ClassCastException e) 271 { 272 return type_error(first, Symbol.SLOT_DEFINITION); 273 } 221 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] = second; 222 return second; 274 223 } 275 224 }; … … 283 232 public LispObject execute(LispObject arg) throws ConditionThrowable 284 233 { 285 try 286 { 287 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_READERS]; 288 } 289 catch (ClassCastException e) 290 { 291 return type_error(arg, Symbol.SLOT_DEFINITION); 292 } 234 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_READERS]; 293 235 } 294 236 }; … … 303 245 throws ConditionThrowable 304 246 { 305 try 306 { 307 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_READERS] = second; 308 return second; 309 } 310 catch (ClassCastException e) 311 { 312 return type_error(first, Symbol.SLOT_DEFINITION); 313 } 247 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_READERS] = second; 248 return second; 314 249 } 315 250 }; … … 323 258 public LispObject execute(LispObject arg) throws ConditionThrowable 324 259 { 325 try 326 { 327 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS]; 328 } 329 catch (ClassCastException e) 330 { 331 return type_error(arg, Symbol.SLOT_DEFINITION); 332 } 260 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS]; 333 261 } 334 262 }; … … 343 271 throws ConditionThrowable 344 272 { 345 try 346 { 347 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS] = second; 348 return second; 349 } 350 catch (ClassCastException e) 351 { 352 return type_error(first, Symbol.SLOT_DEFINITION); 353 } 273 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS] = second; 274 return second; 354 275 } 355 276 }; … … 363 284 public LispObject execute(LispObject arg) throws ConditionThrowable 364 285 { 365 try 366 { 367 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION]; 368 } 369 catch (ClassCastException e) 370 { 371 return type_error(arg, Symbol.SLOT_DEFINITION); 372 } 286 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION]; 373 287 } 374 288 }; … … 383 297 throws ConditionThrowable 384 298 { 385 try 386 { 387 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = second; 388 return second; 389 } 390 catch (ClassCastException e) 391 { 392 return type_error(first, Symbol.SLOT_DEFINITION); 393 } 299 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = second; 300 return second; 394 301 } 395 302 }; … … 403 310 public LispObject execute(LispObject arg) throws ConditionThrowable 404 311 { 405 try 406 { 407 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS]; 408 } 409 catch (ClassCastException e) 410 { 411 return type_error(arg, Symbol.SLOT_DEFINITION); 412 } 312 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS]; 413 313 } 414 314 }; … … 423 323 throws ConditionThrowable 424 324 { 425 try 426 { 427 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS] = second; 428 return second; 429 } 430 catch (ClassCastException e) 431 { 432 return type_error(first, Symbol.SLOT_DEFINITION); 433 } 325 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS] = second; 326 return second; 434 327 } 435 328 }; … … 442 335 public LispObject execute(LispObject arg) throws ConditionThrowable 443 336 { 444 try 445 { 446 return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION]; 447 } 448 catch (ClassCastException e) 449 { 450 return type_error(arg, Symbol.SLOT_DEFINITION); 451 } 337 return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION]; 452 338 } 453 339 }; … … 461 347 throws ConditionThrowable 462 348 { 463 try 464 { 465 ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = second; 466 return second; 467 } 468 catch (ClassCastException e) 469 { 470 return type_error(first, Symbol.SLOT_DEFINITION); 471 } 349 checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = second; 350 return second; 472 351 } 473 352 }; -
trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java
r11711 r11754 136 136 while (vars != NIL) 137 137 { 138 138 specials.add(0, (Symbol) vars.car()); 139 139 vars = ((Cons)vars).cdr; 140 140 } … … 148 148 } 149 149 Environment ext = new Environment(env); 150 151 150 LinkedList<Cons> nonSequentialVars = new LinkedList<Cons>(); 151 Symbol[] arrayToUseForSpecials = new Symbol[0]; 152 152 while (varList != NIL) 153 153 { … … 161 161 + " binding specification " + 162 162 obj.writeToString() + " is invalid.")); 163 try 164 { 165 symbol = (Symbol) ((Cons)obj).car; 166 } 167 catch (ClassCastException e) 168 { 169 return type_error(((Cons)obj).car, Symbol.SYMBOL); 170 } 163 symbol = checkSymbol(((Cons)obj).car); 171 164 value = eval(obj.cadr(), sequential ? ext : env, thread); 172 165 } 173 166 else 174 167 { 175 try 176 { 177 symbol = (Symbol) obj; 178 } 179 catch (ClassCastException e) 180 { 181 return type_error(obj, Symbol.SYMBOL); 182 } 168 symbol = checkSymbol(obj); 183 169 value = NIL; 184 170 } 185 186 187 188 189 171 if (sequential) 172 bindArg(specials.toArray(arrayToUseForSpecials), 173 symbol, value, ext, thread); 174 else 175 nonSequentialVars.add(new Cons(symbol, value)); 190 176 varList = ((Cons)varList).cdr; 191 177 } 192 193 194 195 196 197 198 199 178 if (!sequential) 179 { 180 for (Cons x : nonSequentialVars) 181 { 182 bindArg(specials.toArray(arrayToUseForSpecials), 183 (Symbol)x.car(), x.cdr(), ext, thread); 184 } 185 } 200 186 // Make sure free special declarations are visible in the body. 201 187 // "The scope of free declarations specifically does not include -
trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java
r11711 r11754 260 260 public LispObject execute(LispObject arg) throws ConditionThrowable 261 261 { 262 try 263 { 264 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME]; 265 } 266 catch (ClassCastException e) 267 { 268 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 269 } 262 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME]; 270 263 } 271 264 }; … … 279 272 throws ConditionThrowable 280 273 { 281 try 282 { 283 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = second; 284 return second; 285 } 286 catch (ClassCastException e) 287 { 288 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 289 } 274 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = second; 275 return second; 290 276 } 291 277 }; … … 298 284 public LispObject execute(LispObject arg) throws ConditionThrowable 299 285 { 300 try 301 { 302 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST]; 303 } 304 catch (ClassCastException e) 305 { 306 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 307 } 286 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST]; 308 287 } 309 288 }; … … 317 296 throws ConditionThrowable 318 297 { 319 try 320 { 321 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] = second; 322 return second; 323 } 324 catch (ClassCastException e) 325 { 326 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 327 } 298 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] = second; 299 return second; 328 300 } 329 301 }; … … 338 310 throws ConditionThrowable 339 311 { 340 try 341 { 342 return ((StandardGenericFunction)arg).function; 343 } 344 catch (ClassCastException e) 345 { 346 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 347 } 312 return checkStandardGenericFunction(arg).function; 348 313 } 349 314 }; … … 359 324 throws ConditionThrowable 360 325 { 361 try 362 { 363 ((StandardGenericFunction)first).function = second; 364 return second; 365 } 366 catch (ClassCastException e) 367 { 368 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 369 } 326 checkStandardGenericFunction(first).function = second; 327 return second; 370 328 } 371 329 }; … … 378 336 public LispObject execute(LispObject arg) throws ConditionThrowable 379 337 { 380 try 381 { 382 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS]; 383 } 384 catch (ClassCastException e) 385 { 386 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 387 } 338 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS]; 388 339 } 389 340 }; … … 397 348 throws ConditionThrowable 398 349 { 399 final StandardGenericFunction gf; 400 try 401 { 402 gf = (StandardGenericFunction) first; 403 } 404 catch (ClassCastException e) 405 { 406 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 407 } 350 final StandardGenericFunction gf = checkStandardGenericFunction(first); 408 351 gf.slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS] = second; 409 352 gf.numberOfRequiredArgs = second.length(); … … 419 362 public LispObject execute(LispObject arg) throws ConditionThrowable 420 363 { 421 try 422 { 423 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS]; 424 } 425 catch (ClassCastException e) 426 { 427 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 428 } 364 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS]; 429 365 } 430 366 }; … … 438 374 throws ConditionThrowable 439 375 { 440 try 441 { 442 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] = second; 443 return second; 444 } 445 catch (ClassCastException e) 446 { 447 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 448 } 376 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] = second; 377 return second; 449 378 } 450 379 }; … … 457 386 public LispObject execute(LispObject arg) throws ConditionThrowable 458 387 { 459 try 460 { 461 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS]; 462 } 463 catch (ClassCastException e) 464 { 465 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 466 } 388 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS]; 467 389 } 468 390 }; … … 476 398 throws ConditionThrowable 477 399 { 478 try 479 { 480 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] = second; 481 return second; 482 } 483 catch (ClassCastException e) 484 { 485 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 486 } 400 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] = second; 401 return second; 487 402 } 488 403 }; … … 495 410 public LispObject execute(LispObject arg) throws ConditionThrowable 496 411 { 497 try 498 { 499 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS]; 500 } 501 catch (ClassCastException e) 502 { 503 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 504 } 412 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS]; 505 413 } 506 414 }; … … 514 422 throws ConditionThrowable 515 423 { 516 try 517 { 518 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] = second; 519 return second; 520 } 521 catch (ClassCastException e) 522 { 523 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 524 } 424 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] = second; 425 return second; 525 426 } 526 427 }; … … 533 434 public LispObject execute(LispObject arg) throws ConditionThrowable 534 435 { 535 try 536 { 537 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION]; 538 } 539 catch (ClassCastException e) 540 { 541 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 542 } 436 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION]; 543 437 } 544 438 }; … … 552 446 throws ConditionThrowable 553 447 { 554 try 555 { 556 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] = second; 557 return second; 558 } 559 catch (ClassCastException e) 560 { 561 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 562 } 448 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] = second; 449 return second; 563 450 } 564 451 }; … … 571 458 public LispObject execute(LispObject arg) throws ConditionThrowable 572 459 { 573 try 574 { 575 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER]; 576 } 577 catch (ClassCastException e) 578 { 579 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 580 } 460 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER]; 581 461 } 582 462 }; … … 590 470 throws ConditionThrowable 591 471 { 592 try 593 { 594 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] = second; 595 return second; 596 } 597 catch (ClassCastException e) 598 { 599 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 600 } 472 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] = second; 473 return second; 601 474 } 602 475 }; … … 609 482 public LispObject execute(LispObject arg) throws ConditionThrowable 610 483 { 611 try 612 { 613 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE]; 614 } 615 catch (ClassCastException e) 616 { 617 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 618 } 484 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE]; 619 485 } 620 486 }; … … 628 494 throws ConditionThrowable 629 495 { 630 try 631 { 632 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] = second; 633 return second; 634 } 635 catch (ClassCastException e) 636 { 637 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 638 } 496 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] = second; 497 return second; 639 498 } 640 499 }; … … 647 506 public LispObject execute(LispObject arg) throws ConditionThrowable 648 507 { 649 try 650 { 651 return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION]; 652 } 653 catch (ClassCastException e) 654 { 655 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 656 } 508 return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION]; 657 509 } 658 510 }; … … 666 518 throws ConditionThrowable 667 519 { 668 try 669 { 670 ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] = second; 671 return second; 672 } 673 catch (ClassCastException e) 674 { 675 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 676 } 520 checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] = second; 521 return second; 677 522 } 678 523 }; … … 686 531 public LispObject execute(LispObject arg) throws ConditionThrowable 687 532 { 688 final StandardGenericFunction gf; 689 try 690 { 691 gf = (StandardGenericFunction) arg; 692 } 693 catch (ClassCastException e) 694 { 695 return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION); 696 } 697 gf.finalizeInternal(); 698 return T; 533 final StandardGenericFunction gf = checkStandardGenericFunction(arg); 534 gf.finalizeInternal(); 535 return T; 699 536 } 700 537 }; … … 709 546 throws ConditionThrowable 710 547 { 711 final StandardGenericFunction gf; 712 try 713 { 714 gf = (StandardGenericFunction) first; 715 } 716 catch (ClassCastException e) 717 { 718 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 719 } 548 final StandardGenericFunction gf = checkStandardGenericFunction(first); 720 549 LispObject args = second; 721 550 LispObject[] array = new LispObject[gf.numberOfRequiredArgs]; … … 742 571 throws ConditionThrowable 743 572 { 744 final StandardGenericFunction gf; 745 try 746 { 747 gf = (StandardGenericFunction) first; 748 } 749 catch (ClassCastException e) 750 { 751 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 752 } 573 final StandardGenericFunction gf = checkStandardGenericFunction(first); 753 574 LispObject args = second; 754 575 LispObject[] array = new LispObject[gf.numberOfRequiredArgs]; … … 776 597 throws ConditionThrowable 777 598 { 778 final StandardGenericFunction gf; 779 try 780 { 781 gf = (StandardGenericFunction) first; 782 } 783 catch (ClassCastException e) 784 { 785 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 786 } 599 final StandardGenericFunction gf = checkStandardGenericFunction(first); 787 600 LispObject layout = second; 788 601 LispObject location = third; … … 803 616 throws ConditionThrowable 804 617 { 805 final StandardGenericFunction gf; 806 try 807 { 808 gf = (StandardGenericFunction) first; 809 } 810 catch (ClassCastException e) 811 { 812 return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION); 813 } 618 final StandardGenericFunction gf = checkStandardGenericFunction(first); 814 619 LispObject layout = second; 815 620 HashMap<LispObject,LispObject> ht = gf.slotCache; … … 862 667 } 863 668 } 669 670 public static final StandardGenericFunction checkStandardGenericFunction(LispObject obj) 671 throws ConditionThrowable 672 { 673 if (obj instanceof StandardGenericFunction) 674 return (StandardGenericFunction) obj; 675 return (StandardGenericFunction) // Not reached. 676 type_error(obj, Symbol.STANDARD_GENERIC_FUNCTION); 677 } 864 678 } -
trunk/abcl/src/org/armedbear/lisp/StandardMethod.java
r11711 r11754 70 70 public LispObject execute(LispObject arg) throws ConditionThrowable 71 71 { 72 try 73 { 74 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST]; 75 } 76 catch (ClassCastException e) 77 { 78 return type_error(arg, Symbol.STANDARD_METHOD); 79 } 72 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST]; 80 73 } 81 74 }; … … 90 83 throws ConditionThrowable 91 84 { 92 try 93 { 94 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST] = second; 95 return second; 96 } 97 catch (ClassCastException e) 98 { 99 return type_error(first, Symbol.STANDARD_METHOD); 100 } 85 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST] = second; 86 return second; 101 87 } 102 88 }; … … 109 95 public LispObject execute(LispObject arg) throws ConditionThrowable 110 96 { 111 try 112 { 113 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS]; 114 } 115 catch (ClassCastException e) 116 { 117 return type_error(arg, Symbol.STANDARD_METHOD); 118 } 97 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS]; 119 98 } 120 99 }; … … 128 107 public LispObject execute(LispObject first, LispObject second) 129 108 throws ConditionThrowable 130 { 131 try 132 { 133 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS] = second; 134 return second; 135 } 136 catch (ClassCastException e) 137 { 138 return type_error(first, Symbol.STANDARD_METHOD); 139 } 109 { 110 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS] = second; 111 return second; 140 112 } 141 113 }; … … 148 120 public LispObject execute(LispObject arg) throws ConditionThrowable 149 121 { 150 try 151 { 152 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION]; 153 } 154 catch (ClassCastException e) 155 { 156 return type_error(arg, Symbol.STANDARD_METHOD); 157 } 122 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION]; 158 123 } 159 124 }; … … 168 133 throws ConditionThrowable 169 134 { 170 try 171 { 172 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION] = second; 173 return second; 174 } 175 catch (ClassCastException e) 176 { 177 return type_error(first, Symbol.STANDARD_METHOD); 178 } 135 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION] = second; 136 return second; 179 137 } 180 138 }; … … 231 189 public LispObject execute(LispObject arg) throws ConditionThrowable 232 190 { 233 try 234 { 235 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION]; 236 } 237 catch (ClassCastException e) 238 { 239 return type_error(arg, Symbol.METHOD); 240 } 191 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION]; 241 192 } 242 193 }; … … 250 201 throws ConditionThrowable 251 202 { 252 try 253 { 254 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION] = second; 255 return second; 256 } 257 catch (ClassCastException e) 258 { 259 return type_error(first, Symbol.METHOD); 260 } 203 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION] = second; 204 return second; 261 205 } 262 206 }; … … 269 213 public LispObject execute(LispObject arg) throws ConditionThrowable 270 214 { 271 try 272 { 273 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_FUNCTION]; 274 } 275 catch (ClassCastException e) 276 { 277 return type_error(arg, Symbol.METHOD); 278 } 215 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_FUNCTION]; 279 216 } 280 217 }; … … 289 226 throws ConditionThrowable 290 227 { 291 try 292 { 293 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_FUNCTION] = second; 294 return second; 295 } 296 catch (ClassCastException e) 297 { 298 return type_error(first, Symbol.METHOD); 299 } 228 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_FUNCTION] = second; 229 return second; 300 230 } 301 231 }; … … 308 238 public LispObject execute(LispObject arg) throws ConditionThrowable 309 239 { 310 try 311 { 312 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION]; 313 } 314 catch (ClassCastException e) 315 { 316 return type_error(arg, Symbol.METHOD); 317 } 240 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION]; 318 241 } 319 242 }; … … 328 251 throws ConditionThrowable 329 252 { 330 try 331 { 332 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION] = second; 333 return second; 334 } 335 catch (ClassCastException e) 336 { 337 return type_error(first, Symbol.METHOD); 338 } 253 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION] = second; 254 return second; 339 255 } 340 256 }; … … 347 263 public LispObject execute(LispObject arg) throws ConditionThrowable 348 264 { 349 try 350 { 351 return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS]; 352 } 353 catch (ClassCastException e) 354 { 355 return type_error(arg, Symbol.METHOD); 356 } 265 return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS]; 357 266 } 358 267 }; … … 367 276 throws ConditionThrowable 368 277 { 369 try 370 { 371 ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS] = second; 372 return second; 373 } 374 catch (ClassCastException e) 375 { 376 return type_error(first, Symbol.METHOD); 377 } 278 checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS] = second; 279 return second; 378 280 } 379 281 }; … … 395 297 list(StandardClass.STANDARD_METHOD)); 396 298 299 final public static StandardMethod checkStandardMethod(LispObject first) throws ConditionThrowable 300 { 301 if (first instanceof StandardMethod) 302 return (StandardMethod) first; 303 return (StandardMethod) type_error(first, Symbol.METHOD); 304 } 305 397 306 } -
trunk/abcl/src/org/armedbear/lisp/StandardObject.java
r11714 r11754 273 273 } 274 274 275 final public static StandardObject checkStandardObject(LispObject first) throws ConditionThrowable 276 { 277 if (first instanceof StandardObject) 278 return (StandardObject) first; 279 return (StandardObject) type_error(first, Symbol.STANDARD_OBJECT); 280 } 281 275 282 // ### swap-slots instance-1 instance-2 => nil 276 283 private static final Primitive SWAP_SLOTS = … … 281 288 throws ConditionThrowable 282 289 { 283 StandardObject obj1, obj2; 284 try 285 { 286 obj1 = (StandardObject) first; 287 } 288 catch (ClassCastException e) 289 { 290 return type_error(first, Symbol.STANDARD_OBJECT); 291 } 292 try 293 { 294 obj2 = (StandardObject) second; 295 } 296 catch (ClassCastException e) 297 { 298 return type_error(second, Symbol.STANDARD_OBJECT); 299 } 290 final StandardObject obj1 = checkStandardObject(first); 291 final StandardObject obj2 = checkStandardObject(second); 300 292 LispObject[] temp = obj1.slots; 301 293 obj1.slots = obj2.slots; … … 312 304 public LispObject execute(LispObject arg) throws ConditionThrowable 313 305 { 314 final StandardObject instance; 315 try 316 { 317 instance = (StandardObject) arg; 318 } 319 catch (ClassCastException e) 320 { 321 return type_error(arg, Symbol.STANDARD_OBJECT); 322 } 306 final StandardObject instance = checkStandardObject(arg); 323 307 Layout layout = instance.layout; 324 308 if (layout.isInvalid()) … … 339 323 throws ConditionThrowable 340 324 { 341 try 342 { 343 ((StandardObject)first).layout = (Layout) second; 344 return second; 345 } 346 catch (ClassCastException e) 347 { 348 if (!(first instanceof StandardObject)) 349 return type_error(first, Symbol.STANDARD_OBJECT); 350 if (!(second instanceof Layout)) 351 return type_error(second, Symbol.LAYOUT); 352 // Not reached. 353 return NIL; 354 } 325 checkStandardObject(first).layout = checkLayout(second); 326 return second; 355 327 } 356 328 }; … … 363 335 public LispObject execute(LispObject arg) throws ConditionThrowable 364 336 { 365 try 366 { 367 return ((StandardObject)arg).layout.lispClass; 368 } 369 catch (ClassCastException e) 370 { 371 return type_error(arg, Symbol.STANDARD_OBJECT); 372 } 337 return checkStandardObject(arg).layout.lispClass; 373 338 } 374 339 }; … … 383 348 throws ConditionThrowable 384 349 { 385 final StandardObject instance; 386 try 387 { 388 instance = (StandardObject) first; 389 } 390 catch (ClassCastException e) 391 { 392 return type_error(first, Symbol.STANDARD_OBJECT); 393 } 350 final StandardObject instance = checkStandardObject(first); 394 351 final int index; 395 try352 if (second instanceof Fixnum) 396 353 { 397 354 index = ((Fixnum)second).value; 398 355 } 399 catch (ClassCastException e)356 else 400 357 { 401 358 return type_error(second, … … 434 391 throws ConditionThrowable 435 392 { 436 try 437 { 438 ((StandardObject)first).slots[Fixnum.getValue(second)] = third; // FIXME 439 return third; 440 } 441 catch (ClassCastException e) 442 { 443 return type_error(first, Symbol.STANDARD_OBJECT); 444 } 393 checkStandardObject(first).slots[Fixnum.getValue(second)] = third; // FIXME 394 return third; 445 395 } 446 396 }; … … 454 404 throws ConditionThrowable 455 405 { 456 final StandardObject instance; 457 try 458 { 459 instance = (StandardObject) first; 460 } 461 catch (ClassCastException e) 462 { 463 return type_error(first, Symbol.STANDARD_OBJECT); 464 } 406 final StandardObject instance = checkStandardObject(first); 465 407 Layout layout = instance.layout; 466 408 if (layout.isInvalid()) -
trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java
r11488 r11754 45 45 if (arg == StandardClass.STANDARD_CLASS) 46 46 return new StandardClass(); 47 final StandardClass c; 48 try 49 { 50 c = (StandardClass) arg; 51 } 52 catch (ClassCastException e) 53 { 54 return type_error(arg, Symbol.STANDARD_CLASS); 55 } 56 return c.allocateInstance(); 47 if (arg instanceof StandardClass) 48 return ((StandardClass)arg).allocateInstance(); 49 return type_error(arg, Symbol.STANDARD_CLASS); 57 50 } 58 51 }; -
trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java
r11488 r11754 49 49 public LispObject execute(LispObject arg) throws ConditionThrowable 50 50 { 51 try 52 { 51 if (arg instanceof StandardReaderMethod) 53 52 return ((StandardReaderMethod)arg).slots[StandardReaderMethodClass.SLOT_INDEX_SLOT_NAME]; 54 } 55 catch (ClassCastException e) 56 { 57 return type_error(arg, Symbol.STANDARD_READER_METHOD); 58 } 53 return type_error(arg, Symbol.STANDARD_READER_METHOD); 59 54 } 60 55 }; … … 69 64 throws ConditionThrowable 70 65 { 71 try66 if (first instanceof StandardReaderMethod) 72 67 { 73 68 ((StandardReaderMethod)first).slots[StandardReaderMethodClass.SLOT_INDEX_SLOT_NAME] = second; 74 69 return second; 75 70 } 76 catch (ClassCastException e)77 {78 71 return type_error(first, Symbol.STANDARD_READER_METHOD); 79 }80 72 } 81 73 }; -
trunk/abcl/src/org/armedbear/lisp/Stream.java
r11748 r11754 145 145 isBinaryStream = true; 146 146 InputStream stream = new BufferedInputStream(inputStream); 147 147 initAsBinaryInputStream(stream); 148 148 } 149 149 } … … 167 167 if (elementType == Symbol.CHARACTER || elementType == Symbol.BASE_CHAR) 168 168 { 169 169 Writer w = 170 170 (encoding == null) ? 171 171 new OutputStreamWriter(outputStream) 172 172 : new OutputStreamWriter(outputStream, 173 173 Charset.forName(encoding).newEncoder()); 174 174 initAsCharacterOutputStream(w); 175 175 } 176 176 else 177 177 { 178 178 OutputStream stream = new BufferedOutputStream(outputStream); 179 179 initAsBinaryOutputStream(stream); 180 180 } 181 181 } … … 1281 1281 { 1282 1282 final int readBase; 1283 try 1284 { 1285 readBase = ((Fixnum)Symbol.READ_BASE.symbolValue(thread)).value; 1286 } 1287 catch (ClassCastException e) 1288 { 1283 final LispObject readBaseObject = Symbol.READ_BASE.symbolValue(thread); 1284 if (readBaseObject instanceof Fixnum) { 1285 readBase = ((Fixnum)readBaseObject).value; 1286 } else { 1289 1287 // The value of *READ-BASE* is not a Fixnum. 1290 1288 error(new LispError("The value of *READ-BASE* is not of type '(INTEGER 2 36).")); 1291 1289 // Not reached. 1292 return 10; 1293 1290 return 10; 1291 } 1294 1292 if (readBase < 2 || readBase > 36) 1295 1293 { … … 1892 1890 { 1893 1891 if (c == '\n') { 1894 1892 if (eolStyle == EolStyle.CRLF && lastChar != '\r') 1895 1893 writer.write('\r'); 1896 1894 … … 1948 1946 index = i; 1949 1947 break; 1950 1951 1948 } 1949 } 1952 1950 if (index < 0) 1953 1951 { 1954 1952 // No newline. 1955 1953 charPos += (end - start); 1956 1954 } 1957 1955 else 1958 1956 { 1959 1957 charPos = end - (index + 1); 1960 1958 writer.flush(); 1961 1962 1959 } 1960 } 1963 1961 catch (NullPointerException e) 1964 1962 { … … 1984 1982 try 1985 1983 { 1986 1984 _writeChars(s.toCharArray(), 0, s.length()); 1987 1985 } 1988 1986 catch (NullPointerException e) … … 2213 2211 throws ConditionThrowable 2214 2212 { 2215 try 2216 { 2217 ((Stream)second)._writeChar(((LispCharacter)first).value); 2218 } 2219 catch (ClassCastException e) 2220 { 2221 if (second instanceof Stream) 2222 return type_error(first, Symbol.CHARACTER); 2223 else 2224 return type_error(second, Symbol.STREAM); 2225 } 2226 return first; 2213 checkStream(second)._writeChar(LispCharacter.getValue(first)); 2214 return first; 2227 2215 } 2228 2216 }; … … 2237 2225 throws ConditionThrowable 2238 2226 { 2239 final char c; 2240 try 2241 { 2242 c = ((LispCharacter)first).value; 2243 } 2244 catch (ClassCastException e) 2245 { 2246 return type_error(first, Symbol.CHARACTER); 2247 } 2227 final char c = LispCharacter.getValue(first); 2248 2228 if (second == T) 2249 2229 second = Symbol.TERMINAL_IO.symbolValue(); 2250 2230 else if (second == NIL) 2251 2231 second = Symbol.STANDARD_OUTPUT.symbolValue(); 2252 final Stream stream; 2253 try 2254 { 2255 stream = (Stream) second; 2256 } 2257 catch (ClassCastException e) 2258 { 2259 return type_error(second, Symbol.STREAM); 2260 } 2232 final Stream stream = checkStream(second); 2261 2233 stream._writeChar(c); 2262 2234 return first; … … 2274 2246 throws ConditionThrowable 2275 2247 { 2276 final AbstractString s; 2277 try 2278 { 2279 s = (AbstractString) first; 2280 } 2281 catch (ClassCastException e) 2282 { 2283 return type_error(first, Symbol.STRING); 2284 } 2248 final AbstractString s = checkString(first); 2285 2249 char[] chars = s.chars(); 2286 final Stream out; 2287 try 2288 { 2289 if (second == T) 2290 out = (Stream) Symbol.TERMINAL_IO.symbolValue(); 2291 else if (second == NIL) 2292 out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue(); 2293 else 2294 out = (Stream) second; 2295 } 2296 catch (ClassCastException e) 2297 { 2298 return type_error(second, Symbol.STREAM); 2299 } 2300 final int start; 2301 try 2302 { 2303 start = ((Fixnum)third).value; 2304 } 2305 catch (ClassCastException e) 2306 { 2307 return type_error(third, Symbol.FIXNUM); 2308 } 2250 final Stream out = outSynonymOf(second); 2251 final int start = Fixnum.getValue(third); 2309 2252 final int end; 2310 2253 if (fourth == NIL) … … 2312 2255 else 2313 2256 { 2314 try 2315 { 2316 end = ((Fixnum)fourth).value; 2317 } 2318 catch (ClassCastException e) 2319 { 2320 return type_error(fourth, Symbol.FIXNUM); 2321 } 2257 end = Fixnum.getValue(fourth); 2322 2258 } 2323 2259 checkBounds(start, end, chars.length); … … 2352 2288 throws ConditionThrowable 2353 2289 { 2354 final Stream out; 2355 try 2356 { 2290 final LispObject out; 2357 2291 if (arg == T) 2358 out = (Stream)Symbol.TERMINAL_IO.symbolValue();2292 out = Symbol.TERMINAL_IO.symbolValue(); 2359 2293 else if (arg == NIL) 2360 out = (Stream)Symbol.STANDARD_OUTPUT.symbolValue();2294 out = Symbol.STANDARD_OUTPUT.symbolValue(); 2361 2295 else 2362 out = (Stream) arg; 2363 } 2364 catch (ClassCastException e) 2365 { 2366 return type_error(arg, Symbol.STREAM); 2367 } 2368 return out.finishOutput(); 2296 out = arg; 2297 return checkStream(out).finishOutput(); 2369 2298 } 2370 2299 … … 2414 2343 public LispObject execute(LispObject arg) throws ConditionThrowable 2415 2344 { 2416 try 2417 { 2418 return ((Stream)arg).close(NIL); 2419 } 2420 catch (ClassCastException e) 2421 { 2422 return type_error(arg, Symbol.STREAM); 2423 } 2345 return checkStream(arg).close(NIL); 2424 2346 } 2425 2347 … … 2429 2351 throws ConditionThrowable 2430 2352 { 2431 final Stream stream; 2432 try 2433 { 2434 stream = (Stream) first; 2435 } 2436 catch (ClassCastException e) 2437 { 2438 return type_error(first, Symbol.STREAM); 2439 } 2440 if (second == Keyword.ABORT) 2441 return stream.close(third); 2442 return error(new ProgramError("Unrecognized keyword argument " + 2443 second.writeToString() + ".")); 2353 final Stream stream = checkStream(first); 2354 if (second == Keyword.ABORT) 2355 return stream.close(third); 2356 return error(new ProgramError("Unrecognized keyword argument " + 2357 second.writeToString() + ".")); 2444 2358 } 2445 2359 }; … … 2471 2385 throws ConditionThrowable 2472 2386 { 2473 int n; 2474 try 2475 { 2476 n = ((Fixnum)first).value; 2477 } 2478 catch (ClassCastException e) 2479 { 2480 return type_error(first, Symbol.FIXNUM); 2481 } 2387 int n = Fixnum.getValue(first); 2482 2388 if (n < 0 || n > 255) 2483 2389 return t