Changeset 12254
- Timestamp:
- 11/06/09 20:07:54 (11 years ago)
- Location:
- trunk/abcl/src/org/armedbear/lisp
- Files:
-
- 231 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/abcl/src/org/armedbear/lisp/AbstractArray.java
r11711 r12254 37 37 { 38 38 @Override 39 public LispObject typep(LispObject type) throws ConditionThrowable39 public LispObject typep(LispObject type) 40 40 { 41 41 if (type == Symbol.ARRAY) … … 47 47 48 48 @Override 49 public boolean equalp(LispObject obj) throws ConditionThrowable49 public boolean equalp(LispObject obj) 50 50 { 51 51 if (obj instanceof AbstractArray) { … … 71 71 } 72 72 73 public LispObject arrayDisplacement() throws ConditionThrowable73 public LispObject arrayDisplacement() 74 74 { 75 75 return LispThread.currentThread().setValues(NIL, Fixnum.ZERO); … … 81 81 } 82 82 83 public int getFillPointer() throws ConditionThrowable83 public int getFillPointer() 84 84 { 85 85 noFillPointer(); … … 87 87 } 88 88 89 public void setFillPointer(LispObject fillPointer) throws ConditionThrowable89 public void setFillPointer(LispObject fillPointer) 90 90 { 91 91 setFillPointer(fillPointer.intValue()); 92 92 } 93 93 94 public void setFillPointer(int fillPointer) throws ConditionThrowable94 public void setFillPointer(int fillPointer) 95 95 { 96 96 noFillPointer(); … … 106 106 public abstract LispObject getDimensions(); 107 107 108 public abstract int getDimension(int n) throws ConditionThrowable;108 public abstract int getDimension(int n); 109 109 110 110 public abstract LispObject getElementType(); … … 114 114 @Override 115 115 public abstract void aset(int index, LispObject newValue) 116 throws ConditionThrowable;116 ; 117 117 118 118 // FIXME Detect overflow! … … 126 126 127 127 public int getRowMajorIndex(LispObject[] subscripts) 128 throws ConditionThrowable 128 129 129 { 130 130 int[] subs = new int[subscripts.length]; … … 139 139 } 140 140 141 public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable141 public int getRowMajorIndex(int[] subscripts) 142 142 { 143 143 final int rank = getRank(); … … 166 166 } 167 167 168 public LispObject get(int[] subscripts) throws ConditionThrowable168 public LispObject get(int[] subscripts) 169 169 { 170 170 return AREF(getRowMajorIndex(subscripts)); … … 172 172 173 173 public void set(int[] subscripts, LispObject newValue) 174 throws ConditionThrowable 174 175 175 { 176 176 aset(getRowMajorIndex(subscripts), newValue); 177 177 } 178 178 179 public abstract void fill(LispObject obj) throws ConditionThrowable;180 181 public String writeToString(int[] dimv) throws ConditionThrowable179 public abstract void fill(LispObject obj); 180 181 public String writeToString(int[] dimv) 182 182 { 183 183 StringBuilder sb = new StringBuilder(); … … 230 230 private void appendContents(int[] dimensions, int index, StringBuilder sb, 231 231 LispThread thread) 232 throws ConditionThrowable 232 233 233 { 234 234 if (dimensions.length == 0) { … … 319 319 * @param initialContents @c null if none 320 320 * @return @c this or a new array 321 * @throws org.armedbear.lisp.ConditionThrowable322 321 */ 323 322 public abstract AbstractArray adjustArray(int[] dims, 324 323 LispObject initialElement, 325 LispObject initialContents) 326 throws ConditionThrowable; 324 LispObject initialContents); 327 325 328 326 /** … … 332 330 * @param displacement 333 331 * @return 334 * @throws org.armedbear.lisp.ConditionThrowable335 332 */ 336 333 public abstract AbstractArray adjustArray(int[] dims, 337 334 AbstractArray displacedTo, 338 int displacement) 339 throws ConditionThrowable; 335 int displacement); 340 336 } -
trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java
r12252 r12254 44 44 45 45 @Override 46 public LispObject typep(LispObject type) throws ConditionThrowable46 public LispObject typep(LispObject type) 47 47 { 48 48 if (type == Symbol.BIT_VECTOR) … … 72 72 73 73 @Override 74 public boolean equal(LispObject obj) throws ConditionThrowable74 public boolean equal(LispObject obj) 75 75 { 76 76 if (this == obj) … … 90 90 91 91 @Override 92 public boolean equalp(LispObject obj) throws ConditionThrowable92 public boolean equalp(LispObject obj) 93 93 { 94 94 if (this == obj) … … 112 112 113 113 @Override 114 public void fill(LispObject obj) throws ConditionThrowable114 public void fill(LispObject obj) 115 115 { 116 116 if (obj instanceof Fixnum) { … … 141 141 142 142 @Override 143 public LispObject subseq(int start, int end) throws ConditionThrowable143 public LispObject subseq(int start, int end) 144 144 { 145 145 SimpleBitVector v = new SimpleBitVector(end - start); … … 178 178 179 179 @Override 180 public String writeToString() throws ConditionThrowable180 public String writeToString() 181 181 { 182 182 final LispThread thread = LispThread.currentThread(); … … 199 199 // Ignores fill pointer. 200 200 @Override 201 public LispObject AREF(LispObject index) throws ConditionThrowable201 public LispObject AREF(LispObject index) 202 202 { 203 203 return AREF(Fixnum.getValue(index)); … … 205 205 206 206 @Override 207 public LispObject reverse() throws ConditionThrowable207 public LispObject reverse() 208 208 { 209 209 int length = length(); … … 219 219 } 220 220 221 protected abstract int getBit(int index) throws ConditionThrowable;222 223 protected abstract void setBit(int index) throws ConditionThrowable;224 225 protected abstract void clearBit(int index) throws ConditionThrowable;221 protected abstract int getBit(int index); 222 223 protected abstract void setBit(int index); 224 225 protected abstract void clearBit(int index); 226 226 } -
trunk/abcl/src/org/armedbear/lisp/AbstractString.java
r12252 r12254 37 37 { 38 38 @Override 39 public LispObject typep(LispObject type) throws ConditionThrowable39 public LispObject typep(LispObject type) 40 40 { 41 41 if (type instanceof Symbol) { … … 82 82 } 83 83 84 public abstract void fill(char c) throws ConditionThrowable;84 public abstract void fill(char c); 85 85 86 public abstract char charAt(int index) throws ConditionThrowable;86 public abstract char charAt(int index); 87 87 88 public abstract void setCharAt(int index, char c) throws ConditionThrowable;88 public abstract void setCharAt(int index, char c); 89 89 90 90 public final String writeToString(int beginIndex, int endIndex) 91 throws ConditionThrowable 91 92 92 { 93 93 if (beginIndex < 0) … … 115 115 116 116 @Override 117 public String writeToString() throws ConditionThrowable117 public String writeToString() 118 118 { 119 119 return writeToString(0, length()); -
trunk/abcl/src/org/armedbear/lisp/AbstractVector.java
r11714 r12254 36 36 { 37 37 @Override 38 public LispObject typep(LispObject type) throws ConditionThrowable38 public LispObject typep(LispObject type) 39 39 { 40 40 if (type == Symbol.VECTOR) … … 62 62 63 63 @Override 64 public boolean equalp(LispObject obj) throws ConditionThrowable64 public boolean equalp(LispObject obj) 65 65 { 66 66 if (obj instanceof AbstractVector) … … 90 90 91 91 @Override 92 public final int getDimension(int n) throws ConditionThrowable92 public final int getDimension(int n) 93 93 { 94 94 if (n != 0) … … 109 109 public abstract int capacity(); 110 110 111 public abstract LispObject subseq(int start, int end) throws ConditionThrowable;112 113 public LispObject deleteEq(LispObject item) throws ConditionThrowable111 public abstract LispObject subseq(int start, int end); 112 113 public LispObject deleteEq(LispObject item) 114 114 { 115 115 final int limit = length(); … … 128 128 } 129 129 130 public LispObject deleteEql(LispObject item) throws ConditionThrowable130 public LispObject deleteEql(LispObject item) 131 131 { 132 132 final int limit = length(); … … 145 145 } 146 146 147 public abstract void shrink(int n) throws ConditionThrowable;148 149 public int checkIndex(int index) throws ConditionThrowable147 public abstract void shrink(int n); 148 149 public int checkIndex(int index) 150 150 { 151 151 if (index < 0 || index >= capacity()) … … 154 154 } 155 155 156 protected void badIndex(int index, int limit) throws ConditionThrowable156 protected void badIndex(int index, int limit) 157 157 { 158 158 FastStringBuffer sb = new FastStringBuffer("Invalid array index "); … … 174 174 } 175 175 176 public void setFillPointer(int n) throws ConditionThrowable176 public void setFillPointer(int n) 177 177 { 178 178 noFillPointer(); 179 179 } 180 180 181 public void setFillPointer(LispObject obj) throws ConditionThrowable181 public void setFillPointer(LispObject obj) 182 182 { 183 183 noFillPointer(); … … 190 190 191 191 @Override 192 public abstract LispObject reverse() throws ConditionThrowable;193 194 @Override 195 public LispObject nreverse() throws ConditionThrowable192 public abstract LispObject reverse(); 193 194 @Override 195 public LispObject nreverse() 196 196 { 197 197 int i = 0; … … 209 209 210 210 @Override 211 public String writeToString() throws ConditionThrowable211 public String writeToString() 212 212 { 213 213 final LispThread thread = LispThread.currentThread(); … … 301 301 LispObject initialElement, 302 302 LispObject initialContents) 303 throws ConditionThrowable;303 ; 304 304 public abstract AbstractArray adjustArray(int size, 305 305 AbstractArray displacedTo, 306 306 int displacement) 307 throws ConditionThrowable;307 ; 308 308 309 309 … … 311 311 LispObject initialElement, 312 312 LispObject initialContents) 313 throws ConditionThrowable{313 { 314 314 return adjustArray(dims[0], initialElement, initialContents); 315 315 } … … 318 318 AbstractArray displacedTo, 319 319 int displacement) 320 throws ConditionThrowable{320 { 321 321 return adjustArray(dims[0], displacedTo, displacement); 322 322 } -
trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java
r11754 r12254 36 36 public class ArithmeticError extends LispError 37 37 { 38 protected ArithmeticError(LispClass cls) throws ConditionThrowable38 protected ArithmeticError(LispClass cls) 39 39 { 40 40 super(cls); 41 41 } 42 42 43 public ArithmeticError(LispObject initArgs) throws ConditionThrowable43 public ArithmeticError(LispObject initArgs) 44 44 { 45 45 super(StandardClass.ARITHMETIC_ERROR); … … 48 48 49 49 @Override 50 protected void initialize(LispObject initArgs) throws ConditionThrowable50 protected void initialize(LispObject initArgs) 51 51 { 52 52 super.initialize(initArgs); … … 68 68 } 69 69 70 public ArithmeticError(String message) throws ConditionThrowable70 public ArithmeticError(String message) 71 71 { 72 72 super(StandardClass.ARITHMETIC_ERROR); … … 90 90 91 91 @Override 92 public LispObject typep(LispObject type) throws ConditionThrowable92 public LispObject typep(LispObject type) 93 93 { 94 94 if (type == Symbol.ARITHMETIC_ERROR) … … 99 99 } 100 100 101 private final LispObject getOperation() throws ConditionThrowable101 private final LispObject getOperation() 102 102 { 103 103 return getInstanceSlotValue(Symbol.OPERATION); … … 105 105 106 106 private final void setOperation(LispObject operation) 107 throws ConditionThrowable 107 108 108 { 109 109 setInstanceSlotValue(Symbol.OPERATION, operation); 110 110 } 111 111 112 private final LispObject getOperands() throws ConditionThrowable112 private final LispObject getOperands() 113 113 { 114 114 return getInstanceSlotValue(Symbol.OPERANDS); … … 116 116 117 117 private final void setOperands(LispObject operands) 118 throws ConditionThrowable 118 119 119 { 120 120 setInstanceSlotValue(Symbol.OPERANDS, operands); … … 126 126 { 127 127 @Override 128 public LispObject execute(LispObject arg) throws ConditionThrowable128 public LispObject execute(LispObject arg) 129 129 { 130 130 if (arg instanceof ArithmeticError) { … … 141 141 { 142 142 @Override 143 public LispObject execute(LispObject arg) throws ConditionThrowable143 public LispObject execute(LispObject arg) 144 144 { 145 145 if (arg instanceof ArithmeticError) { -
trunk/abcl/src/org/armedbear/lisp/Autoload.java
r12252 r12254 100 100 } 101 101 102 public void load() throws ConditionThrowable102 public void load() 103 103 { 104 104 if (className != null) { … … 157 157 158 158 @Override 159 public LispObject execute() throws ConditionThrowable159 public LispObject execute() 160 160 { 161 161 load(); … … 164 164 165 165 @Override 166 public LispObject execute(LispObject arg) throws ConditionThrowable166 public LispObject execute(LispObject arg) 167 167 { 168 168 load(); … … 172 172 @Override 173 173 public LispObject execute(LispObject first, LispObject second) 174 throws ConditionThrowable 174 175 175 { 176 176 load(); … … 181 181 public LispObject execute(LispObject first, LispObject second, 182 182 LispObject third) 183 throws ConditionThrowable 183 184 184 { 185 185 load(); … … 190 190 public LispObject execute(LispObject first, LispObject second, 191 191 LispObject third, LispObject fourth) 192 throws ConditionThrowable 192 193 193 { 194 194 load(); … … 200 200 LispObject third, LispObject fourth, 201 201 LispObject fifth) 202 throws ConditionThrowable 202 203 203 { 204 204 load(); … … 210 210 LispObject third, LispObject fourth, 211 211 LispObject fifth, LispObject sixth) 212 throws ConditionThrowable 212 213 213 { 214 214 load(); … … 221 221 LispObject fifth, LispObject sixth, 222 222 LispObject seventh) 223 throws ConditionThrowable 223 224 224 { 225 225 load(); … … 233 233 LispObject fifth, LispObject sixth, 234 234 LispObject seventh, LispObject eighth) 235 throws ConditionThrowable 235 236 236 { 237 237 load(); … … 241 241 242 242 @Override 243 public LispObject execute(LispObject[] args) throws ConditionThrowable243 public LispObject execute(LispObject[] args) 244 244 { 245 245 load(); … … 248 248 249 249 @Override 250 public String writeToString() throws ConditionThrowable250 public String writeToString() 251 251 { 252 252 StringBuffer sb = new StringBuffer("#<AUTOLOAD "); … … 271 271 { 272 272 @Override 273 public LispObject execute(LispObject first) throws ConditionThrowable273 public LispObject execute(LispObject first) 274 274 { 275 275 if (first instanceof Symbol) { … … 289 289 @Override 290 290 public LispObject execute(LispObject first, LispObject second) 291 throws ConditionThrowable 291 292 292 { 293 293 final String fileName = second.getStringValue(); … … 314 314 { 315 315 @Override 316 public LispObject execute(LispObject arg) throws ConditionThrowable316 public LispObject execute(LispObject arg) 317 317 { 318 318 Symbol symbol = checkSymbol(arg); … … 332 332 { 333 333 @Override 334 public LispObject execute(LispObject arg) throws ConditionThrowable334 public LispObject execute(LispObject arg) 335 335 { 336 336 if (arg instanceof Symbol) { -
trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java
r11488 r12254 47 47 48 48 private static void installAutoloadMacro(Symbol symbol, String fileName) 49 throws ConditionThrowable 49 50 50 { 51 51 AutoloadMacro am = new AutoloadMacro(symbol, fileName); … … 57 57 58 58 @Override 59 public void load() throws ConditionThrowable59 public void load() 60 60 { 61 61 Load.loadSystemFile(getFileName(), true); … … 63 63 64 64 @Override 65 public String writeToString() throws ConditionThrowable65 public String writeToString() 66 66 { 67 67 StringBuffer sb = new StringBuffer("#<AUTOLOAD-MACRO "); … … 78 78 { 79 79 @Override 80 public LispObject execute(LispObject first) throws ConditionThrowable80 public LispObject execute(LispObject first) 81 81 { 82 82 if (first instanceof Symbol) { … … 96 96 @Override 97 97 public LispObject execute(LispObject first, LispObject second) 98 throws ConditionThrowable 98 99 99 { 100 100 final String fileName = second.getStringValue(); -
trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java
r11754 r12254 48 48 49 49 private BasicVector_UnsignedByte16(LispObject[] array) 50 throws ConditionThrowable 50 51 51 { 52 52 capacity = array.length; … … 70 70 71 71 @Override 72 public LispObject typep(LispObject type) throws ConditionThrowable72 public LispObject typep(LispObject type) 73 73 { 74 74 if (type == Symbol.SIMPLE_ARRAY) … … 116 116 117 117 @Override 118 public LispObject elt(int index) throws ConditionThrowable118 public LispObject elt(int index) 119 119 { 120 120 try { … … 129 129 // Ignores fill pointer. 130 130 @Override 131 public int aref(int index) throws ConditionThrowable131 public int aref(int index) 132 132 { 133 133 try { … … 143 143 // Ignores fill pointer. 144 144 @Override 145 public LispObject AREF(int index) throws ConditionThrowable145 public LispObject AREF(int index) 146 146 { 147 147 try { … … 156 156 // Ignores fill pointer. 157 157 @Override 158 public LispObject AREF(LispObject index) throws ConditionThrowable158 public LispObject AREF(LispObject index) 159 159 { 160 160 try { … … 168 168 169 169 @Override 170 public void aset(int index, int n) throws ConditionThrowable170 public void aset(int index, int n) 171 171 { 172 172 try { … … 179 179 180 180 @Override 181 public void aset(int index, LispObject obj) throws ConditionThrowable181 public void aset(int index, LispObject obj) 182 182 { 183 183 if (obj instanceof Fixnum) { … … 195 195 196 196 @Override 197 public LispObject subseq(int start, int end) throws ConditionThrowable197 public LispObject subseq(int start, int end) 198 198 { 199 199 BasicVector_UnsignedByte16 v = new BasicVector_UnsignedByte16(end - start); … … 210 210 211 211 @Override 212 public void fill(LispObject obj) throws ConditionThrowable212 public void fill(LispObject obj) 213 213 { 214 214 int n = Fixnum.getValue(obj); … … 218 218 219 219 @Override 220 public void shrink(int n) throws ConditionThrowable220 public void shrink(int n) 221 221 { 222 222 if (n < capacity) { … … 233 233 234 234 @Override 235 public LispObject reverse() throws ConditionThrowable235 public LispObject reverse() 236 236 { 237 237 BasicVector_UnsignedByte16 result = new BasicVector_UnsignedByte16(capacity); … … 243 243 244 244 @Override 245 public LispObject nreverse() throws ConditionThrowable245 public LispObject nreverse() 246 246 { 247 247 int i = 0; … … 261 261 LispObject initialElement, 262 262 LispObject initialContents) 263 throws ConditionThrowable 263 264 264 { 265 265 if (initialContents != null) { -
trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java
r11754 r12254 49 49 50 50 public BasicVector_UnsignedByte32(LispObject[] array) 51 throws ConditionThrowable 51 52 52 { 53 53 capacity = array.length; … … 71 71 72 72 @Override 73 public LispObject typep(LispObject type) throws ConditionThrowable73 public LispObject typep(LispObject type) 74 74 { 75 75 if (type == Symbol.SIMPLE_ARRAY) … … 117 117 118 118 @Override 119 public LispObject elt(int index) throws ConditionThrowable119 public LispObject elt(int index) 120 120 { 121 121 try … … 131 131 132 132 @Override 133 public int aref(int index) throws ConditionThrowable133 public int aref(int index) 134 134 { 135 135 try … … 145 145 146 146 @Override 147 public long aref_long(int index) throws ConditionThrowable147 public long aref_long(int index) 148 148 { 149 149 try … … 159 159 160 160 @Override 161 public LispObject AREF(int index) throws ConditionThrowable161 public LispObject AREF(int index) 162 162 { 163 163 try … … 173 173 174 174 @Override 175 public LispObject AREF(LispObject index) throws ConditionThrowable175 public LispObject AREF(LispObject index) 176 176 { 177 177 final int idx = Fixnum.getValue(index); … … 188 188 189 189 @Override 190 public void aset(int index, LispObject newValue) throws ConditionThrowable190 public void aset(int index, LispObject newValue) 191 191 { 192 192 try … … 201 201 202 202 @Override 203 public LispObject subseq(int start, int end) throws ConditionThrowable203 public LispObject subseq(int start, int end) 204 204 { 205 205 BasicVector_UnsignedByte32 v = new BasicVector_UnsignedByte32(end - start); … … 219 219 220 220 @Override 221 public void fill(LispObject obj) throws ConditionThrowable221 public void fill(LispObject obj) 222 222 { 223 223 for (int i = capacity; i-- > 0;) … … 226 226 227 227 @Override 228 public void shrink(int n) throws ConditionThrowable228 public void shrink(int n) 229 229 { 230 230 if (n < capacity) … … 242 242 243 243 @Override 244 public LispObject reverse() throws ConditionThrowable244 public LispObject reverse() 245 245 { 246 246 BasicVector_UnsignedByte32 result = new BasicVector_UnsignedByte32(capacity); … … 252 252 253 253 @Override 254 public LispObject nreverse() throws ConditionThrowable254 public LispObject nreverse() 255 255 { 256 256 int i = 0; … … 271 271 LispObject initialElement, 272 272 LispObject initialContents) 273 throws ConditionThrowable 273 274 274 { 275 275 if (initialContents != null) -
trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java
r11754 r12254 48 48 49 49 public BasicVector_UnsignedByte8(LispObject[] array) 50 throws ConditionThrowable 50 51 51 { 52 52 capacity = array.length; … … 69 69 70 70 @Override 71 public LispObject typep(LispObject type) throws ConditionThrowable71 public LispObject typep(LispObject type) 72 72 { 73 73 if (type == Symbol.SIMPLE_ARRAY) … … 115 115 116 116 @Override 117 public LispObject elt(int index) throws ConditionThrowable117 public LispObject elt(int index) 118 118 { 119 119 try … … 129 129 130 130 @Override 131 public int aref(int index) throws ConditionThrowable131 public int aref(int index) 132 132 { 133 133 try … … 144 144 145 145 @Override 146 public LispObject AREF(int index) throws ConditionThrowable146 public LispObject AREF(int index) 147 147 { 148 148 try … … 158 158 159 159 @Override 160 public LispObject AREF(LispObject index) throws ConditionThrowable160 public LispObject AREF(LispObject index) 161 161 { 162 162 int idx = Fixnum.getValue(index); … … 173 173 174 174 @Override 175 public void aset(int index, int n) throws ConditionThrowable175 public void aset(int index, int n) 176 176 { 177 177 try … … 186 186 187 187 @Override 188 public void aset(int index, LispObject value) throws ConditionThrowable188 public void aset(int index, LispObject value) 189 189 { 190 190 try … … 199 199 200 200 @Override 201 public LispObject subseq(int start, int end) throws ConditionThrowable201 public LispObject subseq(int start, int end) 202 202 { 203 203 BasicVector_UnsignedByte8 v = new BasicVector_UnsignedByte8(end - start); … … 216 216 217 217 @Override 218 public void fill(LispObject obj) throws ConditionThrowable218 public void fill(LispObject obj) 219 219 { 220 220 byte b = coerceLispObjectToJavaByte(obj); … … 224 224 225 225 @Override 226 public void shrink(int n) throws ConditionThrowable226 public void shrink(int n) 227 227 { 228 228 if (n < capacity) … … 240 240 241 241 @Override 242 public LispObject reverse() throws ConditionThrowable242 public LispObject reverse() 243 243 { 244 244 BasicVector_UnsignedByte8 result = new BasicVector_UnsignedByte8(capacity); … … 250 250 251 251 @Override 252 public LispObject nreverse() throws ConditionThrowable252 public LispObject nreverse() 253 253 { 254 254 int i = 0; … … 269 269 LispObject initialElement, 270 270 LispObject initialContents) 271 throws ConditionThrowable 271 272 272 { 273 273 if (initialContents != null) -
trunk/abcl/src/org/armedbear/lisp/Bignum.java
r11754 r12254 113 113 114 114 @Override 115 public LispObject typep(LispObject type) throws ConditionThrowable115 public LispObject typep(LispObject type) 116 116 { 117 117 if (type instanceof Symbol) … … 222 222 223 223 @Override 224 public boolean equalp(LispObject obj) throws ConditionThrowable224 public boolean equalp(LispObject obj) 225 225 { 226 226 if (obj instanceof Bignum) … … 254 254 255 255 @Override 256 public boolean evenp() throws ConditionThrowable256 public boolean evenp() 257 257 { 258 258 return !value.testBit(0); … … 260 260 261 261 @Override 262 public boolean oddp() throws ConditionThrowable262 public boolean oddp() 263 263 { 264 264 return value.testBit(0); … … 296 296 297 297 @Override 298 public float floatValue() throws ConditionThrowable298 public float floatValue() 299 299 { 300 300 float f = value.floatValue(); … … 306 306 307 307 @Override 308 public double doubleValue() throws ConditionThrowable308 public double doubleValue() 309 309 { 310 310 double d = value.doubleValue(); … … 315 315 } 316 316 317 public static BigInteger getValue(LispObject obj) throws ConditionThrowable317 public static BigInteger getValue(LispObject obj) 318 318 { 319 319 … … 340 340 341 341 @Override 342 public LispObject add(int n) throws ConditionThrowable342 public LispObject add(int n) 343 343 { 344 344 return number(value.add(BigInteger.valueOf(n))); … … 346 346 347 347 @Override 348 public LispObject add(LispObject obj) throws ConditionThrowable348 public LispObject add(LispObject obj) 349 349 { 350 350 if (obj instanceof Fixnum) … … 372 372 373 373 @Override 374 public LispObject subtract(LispObject obj) throws ConditionThrowable374 public LispObject subtract(LispObject obj) 375 375 { 376 376 if (obj instanceof Fixnum) … … 399 399 400 400 @Override 401 public LispObject multiplyBy(int n) throws ConditionThrowable401 public LispObject multiplyBy(int n) 402 402 { 403 403 if (n == 0) … … 409 409 410 410 @Override 411 public LispObject multiplyBy(LispObject obj) throws ConditionThrowable411 public LispObject multiplyBy(LispObject obj) 412 412 { 413 413 if (obj instanceof Fixnum) … … 441 441 442 442 @Override 443 public LispObject divideBy(LispObject obj) throws ConditionThrowable443 public LispObject divideBy(LispObject obj) 444 444 { 445 445 if (obj instanceof Fixnum) … … 470 470 471 471 @Override 472 public boolean isEqualTo(LispObject obj) throws ConditionThrowable472 public boolean isEqualTo(LispObject obj) 473 473 { 474 474 if (obj instanceof Bignum) … … 486 486 487 487 @Override 488 public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable488 public boolean isNotEqualTo(LispObject obj) 489 489 { 490 490 if (obj instanceof Bignum) … … 502 502 503 503 @Override 504 public boolean isLessThan(LispObject obj) throws ConditionThrowable504 public boolean isLessThan(LispObject obj) 505 505 { 506 506 if (obj instanceof Fixnum) … … 523 523 524 524 @Override 525 public boolean isGreaterThan(LispObject obj) throws ConditionThrowable525 public boolean isGreaterThan(LispObject obj) 526 526 { 527 527 if (obj instanceof Fixnum) … … 544 544 545 545 @Override 546 public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable546 public boolean isLessThanOrEqualTo(LispObject obj) 547 547 { 548 548 if (obj instanceof Fixnum) … … 565 565 566 566 @Override 567 public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable567 public boolean isGreaterThanOrEqualTo(LispObject obj) 568 568 { 569 569 if (obj instanceof Fixnum) … … 586 586 587 587 @Override 588 public LispObject truncate(LispObject obj) throws ConditionThrowable588 public LispObject truncate(LispObject obj) 589 589 { 590 590 final LispThread thread = LispThread.currentThread(); … … 648 648 649 649 @Override 650 public LispObject ash(LispObject obj) throws ConditionThrowable650 public LispObject ash(LispObject obj) 651 651 { 652 652 BigInteger n = value; … … 681 681 682 682 @Override 683 public LispObject LOGAND(int n) throws ConditionThrowable683 public LispObject LOGAND(int n) 684 684 { 685 685 if (n >= 0) … … 690 690 691 691 @Override 692 public LispObject LOGAND(LispObject obj) throws ConditionThrowable692 public LispObject LOGAND(LispObject obj) 693 693 { 694 694 if (obj instanceof Fixnum) … … 710 710 711 711 @Override 712 public LispObject LOGIOR(int n) throws ConditionThrowable712 public LispObject LOGIOR(int n) 713 713 { 714 714 return number(value.or(BigInteger.valueOf(n))); … … 716 716 717 717 @Override 718 public LispObject LOGIOR(LispObject obj) throws ConditionThrowable718 public LispObject LOGIOR(LispObject obj) 719 719 { 720 720 if (obj instanceof Fixnum) … … 733 733 734 734 @Override 735 public LispObject LOGXOR(int n) throws ConditionThrowable735 public LispObject LOGXOR(int n) 736 736 { 737 737 return number(value.xor(BigInteger.valueOf(n))); … … 739 739 740 740 @Override 741 public LispObject LOGXOR(LispObject obj) throws ConditionThrowable741 public LispObject LOGXOR(LispObject obj) 742 742 { 743 743 final BigInteger n; … … 766 766 767 767 @Override 768 public String writeToString() throws ConditionThrowable768 public String writeToString() 769 769 { 770 770 final LispThread thread = LispThread.currentThread(); -
trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java
r11754 r12254 38 38 private final Stream[] streams; 39 39 40 private BroadcastStream(Stream[] streams) throws ConditionThrowable40 private BroadcastStream(Stream[] streams) 41 41 { 42 42 this.streams = streams; … … 73 73 74 74 @Override 75 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable75 public LispObject typep(LispObject typeSpecifier) 76 76 { 77 77 if (typeSpecifier == Symbol.BROADCAST_STREAM) … … 83 83 84 84 @Override 85 public LispObject listen() throws ConditionThrowable85 public LispObject listen() 86 86 { 87 87 notSupported(); … … 91 91 92 92 @Override 93 public LispObject fileLength() throws ConditionThrowable93 public LispObject fileLength() 94 94 { 95 95 if (streams.length > 0) … … 100 100 101 101 @Override 102 public LispObject fileStringLength(LispObject arg) throws ConditionThrowable102 public LispObject fileStringLength(LispObject arg) 103 103 { 104 104 if (streams.length > 0) … … 110 110 // Returns -1 at end of file. 111 111 @Override 112 protected int _readChar() throws ConditionThrowable112 protected int _readChar() 113 113 { 114 114 notSupported(); … … 118 118 119 119 @Override 120 protected void _unreadChar(int n) throws ConditionThrowable121 { 122 notSupported(); 123 } 124 125 @Override 126 protected boolean _charReady() throws ConditionThrowable120 protected void _unreadChar(int n) 121 { 122 notSupported(); 123 } 124 125 @Override 126 protected boolean _charReady() 127 127 { 128 128 notSupported(); … … 132 132 133 133 @Override 134 public void _writeChar(char c) throws ConditionThrowable134 public void _writeChar(char c) 135 135 { 136 136 for (int i = 0; i < streams.length; i++) … … 140 140 @Override 141 141 public void _writeChars(char[] chars, int start, int end) 142 throws ConditionThrowable 142 143 143 { 144 144 for (int i = 0; i < streams.length; i++) … … 147 147 148 148 @Override 149 public void _writeString(String s) throws ConditionThrowable149 public void _writeString(String s) 150 150 { 151 151 for (int i = 0; i < streams.length; i++) … … 154 154 155 155 @Override 156 public void _writeLine(String s) throws ConditionThrowable156 public void _writeLine(String s) 157 157 { 158 158 for (int i = 0; i < streams.length; i++) … … 162 162 // Reads an 8-bit byte. 163 163 @Override 164 public int _readByte() throws ConditionThrowable164 public int _readByte() 165 165 { 166 166 notSupported(); … … 171 171 // Writes an 8-bit byte. 172 172 @Override 173 public void _writeByte(int n) throws ConditionThrowable173 public void _writeByte(int n) 174 174 { 175 175 for (int i = 0; i < streams.length; i++) … … 178 178 179 179 @Override 180 public void _finishOutput() throws ConditionThrowable180 public void _finishOutput() 181 181 { 182 182 for (int i = 0; i < streams.length; i++) … … 185 185 186 186 @Override 187 public void _clearInput() throws ConditionThrowable188 { 189 notSupported(); 190 } 191 192 @Override 193 protected long _getFilePosition() throws ConditionThrowable187 public void _clearInput() 188 { 189 notSupported(); 190 } 191 192 @Override 193 protected long _getFilePosition() 194 194 { 195 195 if (streams.length == 0) … … 200 200 201 201 @Override 202 protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable202 protected boolean _setFilePosition(LispObject arg) 203 203 { 204 204 return false; … … 206 206 207 207 @Override 208 public void _close() throws ConditionThrowable208 public void _close() 209 209 { 210 210 setOpen(false); 211 211 } 212 212 213 private void notSupported() throws ConditionThrowable213 private void notSupported() 214 214 { 215 215 error(new TypeError("Operation is not supported for streams of type BROADCAST-STREAM.")); … … 227 227 { 228 228 @Override 229 public LispObject execute() throws ConditionThrowable229 public LispObject execute() 230 230 { 231 231 return new BroadcastStream(new Stream[0]); 232 232 } 233 233 @Override 234 public LispObject execute(LispObject[] args) throws ConditionThrowable234 public LispObject execute(LispObject[] args) 235 235 { 236 236 Stream[] streams = new Stream[args.length]; … … 256 256 { 257 257 @Override 258 public LispObject execute(LispObject arg) throws ConditionThrowable258 public LispObject execute(LispObject arg) 259 259 { 260 260 if (arg instanceof BroadcastStream) { -
trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java
r12105 r12254 54 54 55 55 @Override 56 public LispObject typep(LispObject type) throws ConditionThrowable56 public LispObject typep(LispObject type) 57 57 { 58 58 if (type == Symbol.BUILT_IN_CLASS) … … 64 64 65 65 @Override 66 public LispObject getDescription() throws ConditionThrowable66 public LispObject getDescription() 67 67 { 68 68 return new SimpleString(writeToString()); … … 70 70 71 71 @Override 72 public String writeToString() throws ConditionThrowable72 public String writeToString() 73 73 { 74 74 FastStringBuffer sb = new FastStringBuffer("#<BUILT-IN-CLASS "); -
trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java
r11754 r12254 62 62 63 63 @Override 64 public LispObject typep(LispObject type) throws ConditionThrowable64 public LispObject typep(LispObject type) 65 65 { 66 66 return super.typep(type); //TODO … … 68 68 69 69 @Override 70 protected long _getFilePosition() throws ConditionThrowable70 protected long _getFilePosition() 71 71 { 72 72 if (elementType == NIL) … … 75 75 } 76 76 77 public byte[] getByteArray() throws ConditionThrowable77 public byte[] getByteArray() 78 78 { 79 79 if (elementType == NIL) { … … 98 98 99 99 @Override 100 public LispObject execute() throws ConditionThrowable{100 public LispObject execute() { 101 101 return new ByteArrayOutputStream(); 102 102 } 103 103 104 104 @Override 105 public LispObject execute(LispObject arg) throws ConditionThrowable105 public LispObject execute(LispObject arg) 106 106 { 107 107 return new ByteArrayOutputStream(arg); … … 116 116 { 117 117 @Override 118 public LispObject execute(LispObject arg) throws ConditionThrowable118 public LispObject execute(LispObject arg) 119 119 { 120 120 if (arg instanceof ByteArrayOutputStream) { -
trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java
r11488 r12254 38 38 boolean virgin = true; 39 39 40 public CapitalizeFirstStream(Stream target) throws ConditionThrowable40 public CapitalizeFirstStream(Stream target) 41 41 { 42 42 super(target); … … 44 44 45 45 @Override 46 public void _writeChar(char c) throws ConditionThrowable46 public void _writeChar(char c) 47 47 { 48 48 if (virgin) { … … 57 57 58 58 @Override 59 public void _writeString(String s) throws ConditionThrowable59 public void _writeString(String s) 60 60 { 61 61 final int length = s.length(); … … 65 65 66 66 @Override 67 public void _writeLine(String s) throws ConditionThrowable67 public void _writeLine(String s) 68 68 { 69 69 _writeString(s); -
trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java
r11488 r12254 38 38 private boolean inWord; 39 39 40 public CapitalizeStream(Stream target) throws ConditionThrowable40 public CapitalizeStream(Stream target) 41 41 { 42 42 super(target); … … 44 44 45 45 @Override 46 public void _writeChar(char c) throws ConditionThrowable46 public void _writeChar(char c) 47 47 { 48 48 if (inWord) { … … 67 67 68 68 @Override 69 public void _writeString(String s) throws ConditionThrowable69 public void _writeString(String s) 70 70 { 71 71 final int limit = s.length(); … … 75 75 76 76 @Override 77 public void _writeLine(String s) throws ConditionThrowable77 public void _writeLine(String s) 78 78 { 79 79 target._writeString(s); -
trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java
r11488 r12254 39 39 40 40 protected CaseFrobStream(Stream target) 41 throws ConditionThrowable 41 42 42 { 43 43 Debug.assertTrue(target.isCharacterOutputStream()); … … 46 46 47 47 @Override 48 public LispObject getElementType() throws ConditionThrowable48 public LispObject getElementType() 49 49 { 50 50 return target.getElementType(); … … 64 64 65 65 @Override 66 public LispObject typep(LispObject type) throws ConditionThrowable66 public LispObject typep(LispObject type) 67 67 { 68 68 if (type == Symbol.CASE_FROB_STREAM) … … 86 86 87 87 @Override 88 public boolean isCharacterInputStream() throws ConditionThrowable89 { 90 return false; 91 } 92 93 @Override 94 public boolean isBinaryInputStream() throws ConditionThrowable95 { 96 return false; 97 } 98 99 @Override 100 public boolean isCharacterOutputStream() throws ConditionThrowable88 public boolean isCharacterInputStream() 89 { 90 return false; 91 } 92 93 @Override 94 public boolean isBinaryInputStream() 95 { 96 return false; 97 } 98 99 @Override 100 public boolean isCharacterOutputStream() 101 101 { 102 102 return true; … … 104 104 105 105 @Override 106 public boolean isBinaryOutputStream() throws ConditionThrowable106 public boolean isBinaryOutputStream() 107 107 { 108 108 return false; … … 123 123 // Returns -1 at end of file. 124 124 @Override 125 protected int _readChar() throws ConditionThrowable125 protected int _readChar() 126 126 { 127 127 notSupported(); … … 131 131 132 132 @Override 133 protected void _unreadChar(int n) throws ConditionThrowable134 { 135 notSupported(); 136 } 137 138 @Override 139 protected boolean _charReady() throws ConditionThrowable133 protected void _unreadChar(int n) 134 { 135 notSupported(); 136 } 137 138 @Override 139 protected boolean _charReady() 140 140 { 141 141 notSupported(); … … 146 146 @Override 147 147 public void _writeChars(char[] chars, int start, int end) 148 throws ConditionThrowable 148 149 149 { 150 150 _writeString(new String(chars, start, end)); … … 153 153 // Reads an 8-bit byte. 154 154 @Override 155 public int _readByte() throws ConditionThrowable155 public int _readByte() 156 156 { 157 157 notSupported(); … … 162 162 // Writes an 8-bit byte. 163 163 @Override 164 public void _writeByte(int n) throws ConditionThrowable165 { 166 notSupported(); 167 } 168 169 @Override 170 public void _finishOutput() throws ConditionThrowable164 public void _writeByte(int n) 165 { 166 notSupported(); 167 } 168 169 @Override 170 public void _finishOutput() 171 171 { 172 172 target._finishOutput(); … … 174 174 175 175 @Override 176 public void _clearInput() throws ConditionThrowable177 { 178 notSupported(); 179 } 180 181 @Override 182 public LispObject close(LispObject abort) throws ConditionThrowable176 public void _clearInput() 177 { 178 notSupported(); 179 } 180 181 @Override 182 public LispObject close(LispObject abort) 183 183 { 184 184 setOpen(false); … … 187 187 188 188 @Override 189 public LispObject listen() throws ConditionThrowable189 public LispObject listen() 190 190 { 191 191 notSupported(); … … 195 195 196 196 @Override 197 public LispObject terpri() throws ConditionThrowable197 public LispObject terpri() 198 198 { 199 199 return target.terpri(); … … 201 201 202 202 @Override 203 public LispObject freshLine() throws ConditionThrowable203 public LispObject freshLine() 204 204 { 205 205 return target.freshLine(); … … 212 212 } 213 213 214 private void notSupported() throws ConditionThrowable214 private void notSupported() 215 215 { 216 216 error(new TypeError("Operation is not supported for streams of type CASE-FROB-STREAM.")); … … 223 223 @Override 224 224 public LispObject execute(LispObject first, LispObject second) 225 throws ConditionThrowable 225 226 226 { 227 227 Stream target = checkCharacterOutputStream(first); -
trunk/abcl/src/org/armedbear/lisp/CellError.java
r11539 r12254 36 36 public class CellError extends LispError 37 37 { 38 protected CellError(LispClass cls) throws ConditionThrowable38 protected CellError(LispClass cls) 39 39 { 40 40 super(cls); 41 41 } 42 42 43 public CellError(LispObject initArgs) throws ConditionThrowable43 public CellError(LispObject initArgs) 44 44 { 45 45 super(StandardClass.CELL_ERROR); … … 48 48 49 49 @Override 50 protected void initialize(LispObject initArgs) throws ConditionThrowable50 protected void initialize(LispObject initArgs) 51 51 { 52 52 super.initialize(initArgs); … … 64 64 } 65 65 66 public final LispObject getCellName() throws ConditionThrowable66 public final LispObject getCellName() 67 67 { 68 68 return getInstanceSlotValue(Symbol.NAME); 69 69 } 70 70 71 protected final void setCellName(LispObject name) throws ConditionThrowable71 protected final void setCellName(LispObject name) 72 72 { 73 73 setInstanceSlotValue(Symbol.NAME, name); … … 87 87 88 88 @Override 89 public LispObject typep(LispObject type) throws ConditionThrowable89 public LispObject typep(LispObject type) 90 90 { 91 91 if (type == Symbol.CELL_ERROR) … … 97 97 98 98 @Override 99 public String writeToString() throws ConditionThrowable99 public String writeToString() 100 100 { 101 101 if (Symbol.PRINT_ESCAPE.symbolValue() == NIL) -
trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java
r11754 r12254 41 41 { 42 42 @Override 43 public LispObject execute() throws ConditionThrowable44 { 45 return error(new WrongNumberOfArgumentsException(this)); 46 } 47 @Override 48 public LispObject execute(LispObject arg) throws ConditionThrowable49 { 50 if (arg instanceof LispCharacter) 51 return T; 52 return type_error(arg, Symbol.CHARACTER); 53 } 54 @Override 55 public LispObject execute(LispObject first, LispObject second) 56 throws ConditionThrowable 43 public LispObject execute() 44 { 45 return error(new WrongNumberOfArgumentsException(this)); 46 } 47 @Override 48 public LispObject execute(LispObject arg) 49 { 50 if (arg instanceof LispCharacter) 51 return T; 52 return type_error(arg, Symbol.CHARACTER); 53 } 54 @Override 55 public LispObject execute(LispObject first, LispObject second) 56 57 57 { 58 58 return LispCharacter.getValue(first) == LispCharacter.getValue(second) ? T : NIL; 59 59 } 60 60 @Override 61 public LispObject execute(LispObject[] array) throws ConditionThrowable61 public LispObject execute(LispObject[] array) 62 62 { 63 63 final int length = array.length; … … 76 76 { 77 77 @Override 78 public LispObject execute() throws ConditionThrowable79 { 80 return error(new WrongNumberOfArgumentsException(this)); 81 } 82 @Override 83 public LispObject execute(LispObject arg) throws ConditionThrowable84 { 85 if (arg instanceof LispCharacter) 86 return T; 87 return type_error(arg, Symbol.CHARACTER); 88 } 89 @Override 90 public LispObject execute(LispObject first, LispObject second) 91 throws ConditionThrowable 78 public LispObject execute() 79 { 80 return error(new WrongNumberOfArgumentsException(this)); 81 } 82 @Override 83 public LispObject execute(LispObject arg) 84 { 85 if (arg instanceof LispCharacter) 86 return T; 87 return type_error(arg, Symbol.CHARACTER); 88 } 89 @Override 90 public LispObject execute(LispObject first, LispObject second) 91 92 92 { 93 93 final char c1, c2; … … 103 103 } 104 104 @Override 105 public LispObject execute(LispObject[] array) throws ConditionThrowable105 public LispObject execute(LispObject[] array) 106 106 { 107 107 final int length = array.length; … … 126 126 { 127 127 @Override 128 public LispObject execute() throws ConditionThrowable129 { 130 return error(new WrongNumberOfArgumentsException(this)); 131 } 132 @Override 133 public LispObject execute(LispObject arg) throws ConditionThrowable134 { 135 if (arg instanceof LispCharacter) 136 return T; 137 return type_error(arg, Symbol.CHARACTER); 138 } 139 @Override 140 public LispObject execute(LispObject first, LispObject second) 141 throws ConditionThrowable 128 public LispObject execute() 129 { 130 return error(new WrongNumberOfArgumentsException(this)); 131 } 132 @Override 133 public LispObject execute(LispObject arg) 134 { 135 if (arg instanceof LispCharacter) 136 return T; 137 return type_error(arg, Symbol.CHARACTER); 138 } 139 @Override 140 public LispObject execute(LispObject first, LispObject second) 141 142 142 { 143 143 char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first)); … … 146 146 } 147 147 @Override 148 public LispObject execute(LispObject[] array) throws ConditionThrowable148 public LispObject execute(LispObject[] array) 149 149 { 150 150 final int length = array.length; … … 165 165 { 166 166 @Override 167 public LispObject execute() throws ConditionThrowable168 { 169 return error(new WrongNumberOfArgumentsException(this)); 170 } 171 @Override 172 public LispObject execute(LispObject arg) throws ConditionThrowable173 { 174 if (arg instanceof LispCharacter) 175 return T; 176 return type_error(arg, Symbol.CHARACTER); 177 } 178 @Override 179 public LispObject execute(LispObject first, LispObject second) 180 throws ConditionThrowable 167 public LispObject execute() 168 { 169 return error(new WrongNumberOfArgumentsException(this)); 170 } 171 @Override 172 public LispObject execute(LispObject arg) 173 { 174 if (arg instanceof LispCharacter) 175 return T; 176 return type_error(arg, Symbol.CHARACTER); 177 } 178 @Override 179 public LispObject execute(LispObject first, LispObject second) 180 181 181 { 182 182 char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first)); … … 185 185 } 186 186 @Override 187 public LispObject execute(LispObject[] array) throws ConditionThrowable187 public LispObject execute(LispObject[] array) 188 188 { 189 189 final int length = array.length; … … 204 204 { 205 205 @Override 206 public LispObject execute() throws ConditionThrowable207 { 208 return error(new WrongNumberOfArgumentsException(this)); 209 } 210 @Override 211 public LispObject execute(LispObject arg) throws ConditionThrowable212 { 213 if (arg instanceof LispCharacter) 214 return T; 215 return type_error(arg, Symbol.CHARACTER); 216 } 217 @Override 218 public LispObject execute(LispObject first, LispObject second) 219 throws ConditionThrowable 206 public LispObject execute() 207 { 208 return error(new WrongNumberOfArgumentsException(this)); 209 } 210 @Override 211 public LispObject execute(LispObject arg) 212 { 213 if (arg instanceof LispCharacter) 214 return T; 215 return type_error(arg, Symbol.CHARACTER); 216 } 217 @Override 218 public LispObject execute(LispObject first, LispObject second) 219 220 220 { 221 221 return LispCharacter.getValue(first) < LispCharacter.getValue(second) ? T : NIL; 222 222 } 223 223 @Override 224 public LispObject execute(LispObject[] args) throws ConditionThrowable224 public LispObject execute(LispObject[] args) 225 225 { 226 226 final int length = args.length; … … 242 242 { 243 243 @Override 244 public LispObject execute() throws ConditionThrowable245 { 246 return error(new WrongNumberOfArgumentsException(this)); 247 } 248 @Override 249 public LispObject execute(LispObject arg) throws ConditionThrowable250 { 251 if (arg instanceof LispCharacter) 252 return T; 253 return type_error(arg, Symbol.CHARACTER); 254 } 255 @Override 256 public LispObject execute(LispObject first, LispObject second) 257 throws ConditionThrowable 244 public LispObject execute() 245 { 246 return error(new WrongNumberOfArgumentsException(this)); 247 } 248 @Override 249 public LispObject execute(LispObject arg) 250 { 251 if (arg instanceof LispCharacter) 252 return T; 253 return type_error(arg, Symbol.CHARACTER); 254 } 255 @Override 256 public LispObject execute(LispObject first, LispObject second) 257 258 258 { 259 259 return LispCharacter.getValue(first) <= LispCharacter.getValue(second) ? T : NIL; … … 262 262 public LispObject execute(LispObject first, LispObject second, 263 263 LispObject third) 264 throws ConditionThrowable 264 265 265 { 266 266 if (LispCharacter.getValue(first) > LispCharacter.getValue(second)) … … 271 271 } 272 272 @Override 273 public LispObject execute(LispObject[] args) throws ConditionThrowable273 public LispObject execute(LispObject[] args) 274 274 { 275 275 final int length = args.length; … … 291 291 { 292 292 @Override 293 public LispObject execute() throws ConditionThrowable294 { 295 return error(new WrongNumberOfArgumentsException(this)); 296 } 297 @Override 298 public LispObject execute(LispObject arg) throws ConditionThrowable299 { 300 if (arg instanceof LispCharacter) 301 return T; 302 return type_error(arg, Symbol.CHARACTER); 303 } 304 @Override 305 public LispObject execute(LispObject first, LispObject second) 306 throws ConditionThrowable 293 public LispObject execute() 294 { 295 return error(new WrongNumberOfArgumentsException(this)); 296 } 297 @Override 298 public LispObject execute(LispObject arg) 299 { 300 if (arg instanceof LispCharacter) 301 return T; 302 return type_error(arg, Symbol.CHARACTER); 303 } 304 @Override 305 public LispObject execute(LispObject first, LispObject second) 306 307 307 { 308 308 char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first)); … … 311 311 } 312 312 @Override 313 public LispObject execute(LispObject[] array) throws ConditionThrowable313 public LispObject execute(LispObject[] array) 314 314 { 315 315 final int length = array.length; … … 330 330 { 331 331 @Override 332 public LispObject execute() throws ConditionThrowable333 { 334 return error(new WrongNumberOfArgumentsException(this)); 335 } 336 @Override 337 public LispObject execute(LispObject arg) throws ConditionThrowable338 { 339 if (arg instanceof LispCharacter) 340 return T; 341 return type_error(arg, Symbol.CHARACTER); 342 } 343 @Override 344 public LispObject execute(LispObject first, LispObject second) 345 throws ConditionThrowable 332 public LispObject execute() 333 { 334 return error(new WrongNumberOfArgumentsException(this)); 335 } 336 @Override 337 public LispObject execute(LispObject arg) 338 { 339 if (arg instanceof LispCharacter) 340 return T; 341 return type_error(arg, Symbol.CHARACTER); 342 } 343 @Override 344 public LispObject execute(LispObject first, LispObject second) 345 346 346 { 347 347 char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first)); … … 350 350 } 351 351 @Override 352 public LispObject execute(LispObject[] array) throws ConditionThrowable352 public LispObject execute(LispObject[] array) 353 353 { 354 354 final int length = array.length; -
trunk/abcl/src/org/armedbear/lisp/Closure.java
r11778 r12254 85 85 86 86 public Closure(LispObject lambdaExpression, Environment env) 87 throws ConditionThrowable 87 88 88 { 89 89 this(null, lambdaExpression, env); … … 92 92 public Closure(final LispObject name, final LispObject lambdaExpression, 93 93 final Environment env) 94 throws ConditionThrowable 94 95 95 { 96 96 super(name, lambdaExpression.cadr()); … … 339 339 340 340 private static final void invalidParameter(LispObject obj) 341 throws ConditionThrowable 341 342 342 { 343 343 error(new LispError(obj.writeToString() + … … 346 346 347 347 @Override 348 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable348 public LispObject typep(LispObject typeSpecifier) 349 349 { 350 350 if (typeSpecifier == Symbol.COMPILED_FUNCTION) … … 373 373 374 374 @Override 375 public LispObject execute() throws ConditionThrowable375 public LispObject execute() 376 376 { 377 377 if (arity == 0) … … 385 385 386 386 private final LispObject bindParametersAndExecute(LispObject... objects) 387 throws ConditionThrowable 387 388 388 { 389 389 final LispThread thread = LispThread.currentThread(); … … 413 413 LispThread thread, 414 414 LispObject[] objects) 415 throws ConditionThrowable 415 416 416 { 417 417 // &whole and &environment before anything … … 425 425 426 426 public final LispObject invokeArrayExecute(LispObject... objects) 427 throws ConditionThrowable 427 428 428 { 429 429 return execute(objects); … … 431 431 432 432 @Override 433 public LispObject execute(LispObject arg) throws ConditionThrowable433 public LispObject execute(LispObject arg) 434 434 { 435 435 if (minArgs == 1) … … 445 445 @Override 446 446 public LispObject execute(LispObject first, LispObject second) 447 throws ConditionThrowable 447 448 448 { 449 449 if (minArgs == 2) … … 460 460 public LispObject execute(LispObject first, LispObject second, 461 461 LispObject third) 462 throws ConditionThrowable 462 463 463 { 464 464 if (minArgs == 3) … … 475 475 public LispObject execute(LispObject first, LispObject second, 476 476 LispObject third, LispObject fourth) 477 throws ConditionThrowable 477 478 478 { 479 479 if (minArgs == 4) … … 491 491 LispObject third, LispObject fourth, 492 492 LispObject fifth) 493 throws ConditionThrowable 493 494 494 { 495 495 if (minArgs == 5) … … 508 508 LispObject third, LispObject fourth, 509 509 LispObject fifth, LispObject sixth) 510 throws ConditionThrowable 510 511 511 { 512 512 if (minArgs == 6) … … 527 527 LispObject fifth, LispObject sixth, 528 528 LispObject seventh) 529 throws ConditionThrowable 529 530 530 { 531 531 if (minArgs == 7) … … 546 546 LispObject fifth, LispObject sixth, 547 547 LispObject seventh, LispObject eighth) 548 throws ConditionThrowable 548 549 549 { 550 550 if (minArgs == 8) … … 561 561 562 562 private final void declareFreeSpecials(Environment ext) 563 throws ConditionThrowable 563 564 564 { 565 565 LispObject s = specials; … … 579 579 580 580 @Override 581 public LispObject execute(LispObject[] args) throws ConditionThrowable581 public LispObject execute(LispObject[] args) 582 582 { 583 583 final LispThread thread = LispThread.currentThread(); … … 611 611 612 612 protected final LispObject[] processArgs(LispObject[] args, LispThread thread) 613 throws ConditionThrowable 613 614 614 { 615 615 if (optionalParameters.length == 0 && keywordParameters.length == 0) … … 872 872 // No optional or keyword parameters. 873 873 protected final LispObject[] fastProcessArgs(LispObject[] args) 874 throws ConditionThrowable 874 875 875 { 876 876 final int argsLength = args.length; … … 950 950 Environment env, 951 951 LispThread thread) 952 throws ConditionThrowable 952 953 953 { 954 954 for (Parameter parameter : parameters) … … 966 966 967 967 private final void bindAuxVars(Environment env, LispThread thread) 968 throws ConditionThrowable 968 969 969 { 970 970 // Aux variable processing is analogous to LET* processing. … … 1003 1003 1004 1004 public Parameter(Symbol var, LispObject initForm, int type) 1005 throws ConditionThrowable 1005 1006 1006 { 1007 1007 this.var = var; … … 1016 1016 public Parameter(Symbol var, LispObject initForm, LispObject svar, 1017 1017 int type) 1018 throws ConditionThrowable 1018 1019 1019 { 1020 1020 this.var = var; … … 1029 1029 public Parameter(Symbol keyword, Symbol var, LispObject initForm, 1030 1030 LispObject svar) 1031 throws ConditionThrowable 1031 1032 1032 { 1033 1033 this.var = var; … … 1059 1059 1060 1060 private static final LispObject processInitForm(LispObject initForm) 1061 throws ConditionThrowable 1061 1062 1062 { 1063 1063 if (initForm.constantp()) … … 1081 1081 { 1082 1082 @Override 1083 public LispObject execute(LispObject arg) throws ConditionThrowable1083 public LispObject execute(LispObject arg) 1084 1084 { 1085 1085 Closure closure = new Closure(list(Symbol.LAMBDA, arg, NIL), new Environment()); -
trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java
r12180 r12254 41 41 42 42 public CompiledClosure(LispObject lambdaList) 43 throws ConditionThrowable 43 44 44 { 45 45 super(list(Symbol.LAMBDA, lambdaList), null); … … 63 63 64 64 @Override 65 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable65 public LispObject typep(LispObject typeSpecifier) 66 66 { 67 67 if (typeSpecifier == Symbol.COMPILED_FUNCTION) … … 70 70 } 71 71 72 private final LispObject notImplemented() throws ConditionThrowable72 private final LispObject notImplemented() 73 73 { 74 74 return error(new WrongNumberOfArgumentsException(this)); … … 77 77 78 78 // Zero args. 79 public LispObject execute() throws ConditionThrowable79 public LispObject execute() 80 80 { 81 81 LispObject[] args = new LispObject[0]; … … 85 85 // One arg. 86 86 public LispObject execute( LispObject first) 87 throws ConditionThrowable 87 88 88 { 89 89 LispObject[] args = new LispObject[1]; … … 95 95 public LispObject execute( LispObject first, 96 96 LispObject second) 97 throws ConditionThrowable 97 98 98 { 99 99 LispObject[] args = new LispObject[2]; … … 106 106 public LispObject execute( LispObject first, 107 107 LispObject second, LispObject third) 108 throws ConditionThrowable 108 109 109 { 110 110 LispObject[] args = new LispObject[3]; … … 119 119 LispObject second, LispObject third, 120 120 LispObject fourth) 121 throws ConditionThrowable 121 122 122 { 123 123 LispObject[] args = new LispObject[4]; … … 133 133 LispObject second, LispObject third, 134 134 LispObject fourth, LispObject fifth) 135 throws ConditionThrowable 135 136 136 { 137 137 LispObject[] args = new LispObject[5]; … … 149 149 LispObject fourth, LispObject fifth, 150 150 LispObject sixth) 151 throws ConditionThrowable 151 152 152 { 153 153 LispObject[] args = new LispObject[6]; … … 166 166 LispObject fourth, LispObject fifth, 167 167 LispObject sixth, LispObject seventh) 168 throws ConditionThrowable 168 169 169 { 170 170 LispObject[] args = new LispObject[7]; … … 185 185 LispObject sixth, LispObject seventh, 186 186 LispObject eighth) 187 throws ConditionThrowable 187 188 188 { 189 189 LispObject[] args = new LispObject[8]; … … 201 201 // Arg array. 202 202 public LispObject execute(LispObject[] args) 203 throws ConditionThrowable 203 204 204 { 205 205 return notImplemented(); … … 211 211 { 212 212 @Override 213 public LispObject execute(LispObject arg) throws ConditionThrowable213 public LispObject execute(LispObject arg) 214 214 { 215 215 String namestring = null; … … 237 237 { 238 238 @Override 239 public LispObject execute(LispObject arg) throws ConditionThrowable239 public LispObject execute(LispObject arg) 240 240 { 241 241 if (arg instanceof Closure) -
trunk/abcl/src/org/armedbear/lisp/CompilerError.java
r11488 r12254 36 36 public class CompilerError extends Condition 37 37 { 38 public CompilerError(LispObject initArgs) throws ConditionThrowable38 public CompilerError(LispObject initArgs) 39 39 { 40 40 super(initArgs); … … 54 54 55 55 @Override 56 public LispObject typep(LispObject type) throws ConditionThrowable56 public LispObject typep(LispObject type) 57 57 { 58 58 if (type == Symbol.COMPILER_ERROR) -
trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java
r11488 r12254 36 36 public class CompilerUnsupportedFeatureError extends Condition 37 37 { 38 public CompilerUnsupportedFeatureError(LispObject initArgs) throws ConditionThrowable38 public CompilerUnsupportedFeatureError(LispObject initArgs) 39 39 { 40 40 super(initArgs); … … 54 54 55 55 @Override 56 public LispObject typep(LispObject type) throws ConditionThrowable56 public LispObject typep(LispObject type) 57 57 { 58 58 if (type == Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR) -
trunk/abcl/src/org/armedbear/lisp/Complex.java
r11954 r12254 47 47 public static LispObject getInstance(LispObject realpart, 48 48 LispObject imagpart) 49 throws ConditionThrowable 49 50 50 { 51 51 if (!realpart.realp()) … … 92 92 93 93 @Override 94 public LispObject typep(LispObject type) throws ConditionThrowable94 public LispObject typep(LispObject type) 95 95 { 96 96 if (type == Symbol.COMPLEX) … … 137 137 138 138 @Override 139 public boolean equalp(LispObject obj) throws ConditionThrowable139 public boolean equalp(LispObject obj) 140 140 { 141 141 if (this == obj) … … 175 175 176 176 @Override 177 public final LispObject incr() throws ConditionThrowable177 public final LispObject incr() 178 178 { 179 179 return new Complex(realpart.add(Fixnum.ONE), imagpart); … … 181 181 182 182 @Override 183 public final LispObject decr() throws ConditionThrowable183 public final LispObject decr() 184 184 { 185 185 return new Complex(realpart.subtract(Fixnum.ONE), imagpart); … … 187 187 188 188 @Override 189 public LispObject add(LispObject obj) throws ConditionThrowable189 public LispObject add(LispObject obj) 190 190 { 191 191 if (obj instanceof Complex) … … 198 198 199 199 @Override 200 public LispObject subtract(LispObject obj) throws ConditionThrowable200 public LispObject subtract(LispObject obj) 201 201 { 202 202 if (obj instanceof Complex) … … 210 210 211 211 @Override 212 public LispObject multiplyBy(LispObject obj) throws ConditionThrowable212 public LispObject multiplyBy(LispObject obj) 213 213 { 214 214 if (obj instanceof Complex) … … 232 232 233 233 @Override 234 public LispObject divideBy(LispObject obj) throws ConditionThrowable234 public LispObject divideBy(LispObject obj) 235 235 { 236 236 if (obj instanceof Complex) … … 253 253 254 254 @Override 255 public boolean isEqualTo(LispObject obj) throws ConditionThrowable255 public boolean isEqualTo(LispObject obj) 256 256 { 257 257 if (obj instanceof Complex) … … 296 296 297 297 @Override 298 public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable298 public boolean isNotEqualTo(LispObject obj) 299 299 { 300 300 return !isEqualTo(obj); … … 302 302 303 303 @Override 304 public LispObject ABS() throws ConditionThrowable304 public LispObject ABS() 305 305 { 306 306 if (realpart.zerop()) … … 315 315 316 316 @Override 317 public boolean zerop() throws ConditionThrowable317 public boolean zerop() 318 318 { 319 319 return realpart.zerop() && imagpart.zerop(); … … 339 339 340 340 @Override 341 public String writeToString() throws ConditionThrowable341 public String writeToString() 342 342 { 343 343 FastStringBuffer sb = new FastStringBuffer("#C("); -
trunk/abcl/src/org/armedbear/lisp/ComplexArray.java
r11714 r12254 60 60 LispObject elementType, 61 61 LispObject initialContents) 62 throws ConditionThrowable 62 63 63 { 64 64 this.dimv = dimv; … … 86 86 private int setInitialContents(int axis, int[] dims, LispObject contents, 87 87 int index) 88 throws ConditionThrowable 88 89 89 { 90 90 if (dims.length == 0) { … … 154 154 155 155 @Override 156 public int getDimension(int n) throws ConditionThrowable156 public int getDimension(int n) 157 157 { 158 158 try { … … 178 178 179 179 @Override 180 public LispObject arrayDisplacement() throws ConditionThrowable180 public LispObject arrayDisplacement() 181 181 { 182 182 LispObject value1, value2; … … 192 192 193 193 @Override 194 public LispObject AREF(int index) throws ConditionThrowable194 public LispObject AREF(int index) 195 195 { 196 196 if (data != null) { … … 206 206 207 207 @Override 208 public void aset(int index, LispObject newValue) throws ConditionThrowable208 public void aset(int index, LispObject newValue) 209 209 { 210 210 if (data != null) { … … 220 220 221 221 @Override 222 public void fill(LispObject obj) throws ConditionThrowable222 public void fill(LispObject obj) 223 223 { 224 224 if (data != null) { … … 232 232 233 233 @Override 234 public String writeToString() throws ConditionThrowable234 public String writeToString() 235 235 { 236 236 return writeToString(dimv); … … 241 241 LispObject initialElement, 242 242 LispObject initialContents) 243 throws ConditionThrowable{243 { 244 244 if (isAdjustable()) { 245 245 if (initialContents != null) … … 274 274 AbstractArray displacedTo, 275 275 int displacement) 276 throws ConditionThrowable{276 { 277 277 if (isAdjustable()) { 278 278 for (int i = 0; i < dims.length; i++) -
trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java
r11714 r12254 57 57 58 58 public ComplexArray_UnsignedByte32(int[] dimv, LispObject initialContents) 59 throws ConditionThrowable 59 60 60 { 61 61 this.dimv = dimv; … … 82 82 private int setInitialContents(int axis, int[] dims, LispObject contents, 83 83 int index) 84 throws ConditionThrowable 84 85 85 { 86 86 if (dims.length == 0) { … … 150 150 151 151 @Override 152 public int getDimension(int n) throws ConditionThrowable152 public int getDimension(int n) 153 153 { 154 154 try { … … 174 174 175 175 @Override 176 public LispObject arrayDisplacement() throws ConditionThrowable176 public LispObject arrayDisplacement() 177 177 { 178 178 LispObject value1, value2; … … 188 188 189 189 @Override 190 public LispObject AREF(int index) throws ConditionThrowable190 public LispObject AREF(int index) 191 191 { 192 192 if (data != null) { … … 202 202 203 203 @Override 204 public void aset(int index, LispObject newValue) throws ConditionThrowable204 public void aset(int index, LispObject newValue) 205 205 { 206 206 if (data != null) { … … 216 216 217 217 @Override 218 public void fill(LispObject obj) throws ConditionThrowable218 public void fill(LispObject obj) 219 219 { 220 220 if (data != null) { … … 228 228 229 229 @Override 230 public String writeToString() throws ConditionThrowable230 public String writeToString() 231 231 { 232 232 return writeToString(dimv); … … 238 238 LispObject initialElement, 239 239 LispObject initialContents) 240 throws ConditionThrowable{240 { 241 241 if (isAdjustable()) { 242 242 if (initialContents != null) … … 271 271 AbstractArray displacedTo, 272 272 int displacement) 273 throws ConditionThrowable{273 { 274 274 if (isAdjustable()) { 275 275 for (int i = 0; i < dims.length; i++) -
trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java
r11714 r12254 54 54 55 55 public ComplexArray_UnsignedByte8(int[] dimv, LispObject initialContents) 56 throws ConditionThrowable 56 57 57 { 58 58 this.dimv = dimv; … … 78 78 private int setInitialContents(int axis, int[] dims, LispObject contents, 79 79 int index) 80 throws ConditionThrowable 80 81 81 { 82 82 if (dims.length == 0) { … … 146 146 147 147 @Override 148 public int getDimension(int n) throws ConditionThrowable148 public int getDimension(int n) 149 149 { 150 150 try { … … 170 170 171 171 @Override 172 public LispObject arrayDisplacement() throws ConditionThrowable172 public LispObject arrayDisplacement() 173 173 { 174 174 LispObject value1, value2; … … 184 184 185 185 @Override 186 public LispObject AREF(int index) throws ConditionThrowable186 public LispObject AREF(int index) 187 187 { 188 188 if (data != null) { … … 198 198 199 199 @Override 200 public void aset(int index, LispObject newValue) throws ConditionThrowable200 public void aset(int index, LispObject newValue) 201 201 { 202 202 if (data != null) { … … 212 212 213 213 @Override 214 public void fill(LispObject obj) throws ConditionThrowable214 public void fill(LispObject obj) 215 215 { 216 216 if (data != null) { … … 225 225 226 226 @Override 227 public String writeToString() throws ConditionThrowable227 public String writeToString() 228 228 { 229 229 if (Symbol.PRINT_READABLY.symbolValue() != NIL) { … … 240 240 LispObject initialElement, 241 241 LispObject initialContents) 242 throws ConditionThrowable{242 { 243 243 if (isAdjustable()) { 244 244 if (initialContents != null) … … 273 273 AbstractArray displacedTo, 274 274 int displacement) 275 throws ConditionThrowable{275 { 276 276 if (isAdjustable()) { 277 277 for (int i = 0; i < dims.length; i++) -
trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java
r11754 r12254 43 43 private int displacement; 44 44 45 public ComplexBitVector(int capacity) throws ConditionThrowable45 public ComplexBitVector(int capacity) 46 46 { 47 47 this.capacity = capacity; … … 85 85 86 86 @Override 87 public void setFillPointer(LispObject obj) throws ConditionThrowable87 public void setFillPointer(LispObject obj) 88 88 { 89 89 if (obj == T) … … 109 109 110 110 @Override 111 public LispObject arrayDisplacement() throws ConditionThrowable111 public LispObject arrayDisplacement() 112 112 { 113 113 LispObject value1, value2; … … 129 129 130 130 @Override 131 public LispObject elt(int index) throws ConditionThrowable131 public LispObject elt(int index) 132 132 { 133 133 if (index >= length()) … … 137 137 138 138 @Override 139 public LispObject AREF(int index) throws ConditionThrowable139 public LispObject AREF(int index) 140 140 { 141 141 if (index < 0 || index >= capacity) … … 151 151 152 152 @Override 153 protected int getBit(int index) throws ConditionThrowable153 protected int getBit(int index) 154 154 { 155 155 if (bits != null) { … … 161 161 162 162 @Override 163 public void aset(int index, LispObject newValue) throws ConditionThrowable163 public void aset(int index, LispObject newValue) 164 164 { 165 165 if (index < 0 || index >= capacity) … … 188 188 189 189 @Override 190 protected void setBit(int index) throws ConditionThrowable190 protected void setBit(int index) 191 191 { 192 192 if (bits != null) { … … 198 198 199 199 @Override 200 protected void clearBit(int index) throws ConditionThrowable200 protected void clearBit(int index) 201 201 { 202 202 if (bits != null) { … … 208 208 209 209 @Override 210 public void shrink(int n) throws ConditionThrowable210 public void shrink(int n) 211 211 { 212 212 if (bits != null) { … … 237 237 // FIXME 238 238 @Override 239 public void vectorPushExtend(LispObject element) throws ConditionThrowable239 public void vectorPushExtend(LispObject element) 240 240 { 241 241 final int fp = getFillPointer(); … … 253 253 @Override 254 254 public LispObject VECTOR_PUSH_EXTEND(LispObject element) 255 throws ConditionThrowable 255 256 256 { 257 257 vectorPushExtend(element); … … 262 262 @Override 263 263 public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension) 264 throws ConditionThrowable 264 265 265 { 266 266 int ext = Fixnum.getValue(extension); … … 278 278 } 279 279 280 private final void ensureCapacity(int minCapacity) throws ConditionThrowable280 private final void ensureCapacity(int minCapacity) 281 281 { 282 282 if (bits != null) { … … 321 321 LispObject initialElement, 322 322 LispObject initialContents) 323 throws ConditionThrowable 323 324 324 { 325 325 if (bits == null) { … … 381 381 public AbstractVector adjustArray(int size, AbstractArray displacedTo, 382 382 int displacement) 383 throws ConditionThrowable 383 384 384 { 385 385 capacity = size; -
trunk/abcl/src/org/armedbear/lisp/ComplexString.java
r12252 r12254 93 93 94 94 @Override 95 public void setFillPointer(LispObject obj) throws ConditionThrowable95 public void setFillPointer(LispObject obj) 96 96 { 97 97 if (obj == T) … … 128 128 129 129 @Override 130 public LispObject arrayDisplacement() throws ConditionThrowable130 public LispObject arrayDisplacement() 131 131 { 132 132 LispObject value1, value2; … … 145 145 146 146 @Override 147 public char[] chars() throws ConditionThrowable147 public char[] chars() 148 148 { 149 149 if (chars != null) … … 167 167 168 168 @Override 169 public char[] getStringChars() throws ConditionThrowable169 public char[] getStringChars() 170 170 { 171 171 if (fillPointer < 0) … … 177 177 178 178 @Override 179 public boolean equal(LispObject obj) throws ConditionThrowable179 public boolean equal(LispObject obj) 180 180 { 181 181 if (this == obj) … … 197 197 198 198 @Override 199 public boolean equalp(LispObject obj) throws ConditionThrowable199 public boolean equalp(LispObject obj) 200 200 { 201 201 if (this == obj) … … 224 224 225 225 @Override 226 public LispObject subseq(int start, int end) throws ConditionThrowable226 public LispObject subseq(int start, int end) 227 227 { 228 228 SimpleString s = new SimpleString(end - start); … … 234 234 235 235 @Override 236 public void fill(LispObject obj) throws ConditionThrowable236 public void fill(LispObject obj) 237 237 { 238 238 fill(LispCharacter.getValue(obj)); … … 240 240 241 241 @Override 242 public void fill(char c) throws ConditionThrowable242 public void fill(char c) 243 243 { 244 244 for (int i = length(); i-- > 0;) … … 247 247 248 248 @Override 249 public void shrink(int n) throws ConditionThrowable249 public void shrink(int n) 250 250 { 251 251 if (chars != null) … … 291 291 292 292 @Override 293 public LispObject reverse() throws ConditionThrowable293 public LispObject reverse() 294 294 { 295 295 int length = length(); … … 302 302 303 303 @Override 304 public LispObject nreverse() throws ConditionThrowable304 public LispObject nreverse() 305 305 { 306 306 int i = 0; … … 318 318 319 319 @Override 320 public String getStringValue() throws ConditionThrowable320 public String getStringValue() 321 321 { 322 322 if (fillPointer >= 0) … … 327 327 328 328 @Override 329 public Object javaInstance() throws ConditionThrowable329 public Object javaInstance() 330 330 { 331 331 return new String(chars()); … … 333 333 334 334 @Override 335 public Object javaInstance(Class c) throws ConditionThrowable335 public Object javaInstance(Class c) 336 336 { 337 337 return javaInstance(); … … 351 351 352 352 @Override 353 public char charAt(int index) throws ConditionThrowable353 public char charAt(int index) 354 354 { 355 355 if (chars != null) … … 370 370 371 371 @Override 372 public void setCharAt(int index, char c) throws ConditionThrowable372 public void setCharAt(int index, char c) 373 373 { 374 374 if (chars != null) … … 388 388 389 389 @Override 390 public LispObject elt(int index) throws ConditionThrowable390 public LispObject elt(int index) 391 391 { 392 392 final int limit = length(); … … 398 398 // Ignores fill pointer. 399 399 @Override 400 public LispObject CHAR(int index) throws ConditionThrowable400 public LispObject CHAR(int index) 401 401 { 402 402 return LispCharacter.getInstance(charAt(index)); … … 405 405 // Ignores fill pointer. 406 406 @Override 407 public LispObject AREF(int index) throws ConditionThrowable407 public LispObject AREF(int index) 408 408 { 409 409 return LispCharacter.getInstance(charAt(index)); … … 412 412 // Ignores fill pointer. 413 413 @Override 414 public LispObject AREF(LispObject index) throws ConditionThrowable414 public LispObject AREF(LispObject index) 415 415 { 416 416 return LispCharacter.getInstance(charAt(Fixnum.getValue(index))); … … 418 418 419 419 @Override 420 public void aset(int index, LispObject newValue) throws ConditionThrowable420 public void aset(int index, LispObject newValue) 421 421 { 422 422 setCharAt(index, LispCharacter.getValue(newValue)); … … 425 425 @Override 426 426 public void vectorPushExtend(LispObject element) 427 throws ConditionThrowable 427 428 428 { 429 429 if (fillPointer < 0) … … 445 445 @Override 446 446 public LispObject VECTOR_PUSH_EXTEND(LispObject element) 447 throws ConditionThrowable 447 448 448 { 449 449 vectorPushExtend(element); … … 453 453 @Override 454 454 public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension) 455 throws ConditionThrowable 455 456 456 { 457 457 int ext = Fixnum.getValue(extension); … … 473 473 } 474 474 475 public final void ensureCapacity(int minCapacity) throws ConditionThrowable475 public final void ensureCapacity(int minCapacity) 476 476 { 477 477 if (chars != null) … … 575 575 LispObject initialElement, 576 576 LispObject initialContents) 577 throws ConditionThrowable 577 578 578 { 579 579 if (initialContents != null) … … 652 652 AbstractArray displacedTo, 653 653 int displacement) 654 throws ConditionThrowable 654 655 655 { 656 656 capacity = newCapacity; -
trunk/abcl/src/org/armedbear/lisp/ComplexVector.java
r11714 r12254 96 96 97 97 @Override 98 public void setFillPointer(LispObject obj) throws ConditionThrowable98 public void setFillPointer(LispObject obj) 99 99 { 100 100 if (obj == T) … … 126 126 127 127 @Override 128 public LispObject arrayDisplacement() throws ConditionThrowable128 public LispObject arrayDisplacement() 129 129 { 130 130 LispObject value1, value2; … … 164 164 165 165 @Override 166 public LispObject elt(int index) throws ConditionThrowable166 public LispObject elt(int index) 167 167 { 168 168 final int limit = length(); … … 174 174 // Ignores fill pointer. 175 175 @Override 176 public LispObject AREF(int index) throws ConditionThrowable176 public LispObject AREF(int index) 177 177 { 178 178 if (elements != null) { … … 195 195 // FIXME inline 196 196 @Override 197 public LispObject AREF(LispObject index) throws ConditionThrowable197 public LispObject AREF(LispObject index) 198 198 { 199 199 return AREF(Fixnum.getValue(index)); … … 201 201 202 202 @Override 203 public void aset(int index, LispObject newValue) throws ConditionThrowable203 public void aset(int index, LispObject newValue) 204 204 { 205 205 if (elements != null) { … … 220 220 221 221 @Override 222 public LispObject subseq(int start, int end) throws ConditionThrowable222 public LispObject subseq(int start, int end) 223 223 { 224 224 SimpleVector v = new SimpleVector(end - start); … … 235 235 236 236 @Override 237 public void fill(LispObject obj) throws ConditionThrowable237 public void fill(LispObject obj) 238 238 { 239 239 for (int i = capacity; i-- > 0;) … … 242 242 243 243 @Override 244 public void shrink(int n) throws ConditionThrowable244 public void shrink(int n) 245 245 { 246 246 if (elements != null) { … … 259 259 260 260 @Override 261 public LispObject reverse() throws ConditionThrowable261 public LispObject reverse() 262 262 { 263 263 int length = length(); … … 270 270 271 271 @Override 272 public LispObject nreverse() throws ConditionThrowable272 public LispObject nreverse() 273 273 { 274 274 if (elements != null) { … … 301 301 @Override 302 302 public void vectorPushExtend(LispObject element) 303 throws ConditionThrowable 303 304 304 { 305 305 if (fillPointer < 0) … … 314 314 @Override 315 315 public LispObject VECTOR_PUSH_EXTEND(LispObject element) 316 throws ConditionThrowable 316 317 317 { 318 318 vectorPushExtend(element); … … 322 322 @Override 323 323 public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension) 324 throws ConditionThrowable 324 325 325 { 326 326 int ext = Fixnum.getValue(extension); … … 336 336 } 337 337 338 private final void ensureCapacity(int minCapacity) throws ConditionThrowable338 private final void ensureCapacity(int minCapacity) 339 339 { 340 340 if (elements != null) { … … 369 369 LispObject initialElement, 370 370 LispObject initialContents) 371 throws ConditionThrowable 371 372 372 { 373 373 if (initialContents != null) { … … 417 417 AbstractArray displacedTo, 418 418 int displacement) 419 throws ConditionThrowable 419 420 420 { 421 421 capacity = newCapacity; -
trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java
r11714 r12254 97 97 98 98 @Override 99 public void setFillPointer(LispObject obj) throws ConditionThrowable99 public void setFillPointer(LispObject obj) 100 100 { 101 101 if (obj == T) … … 127 127 128 128 @Override 129 public LispObject arrayDisplacement() throws ConditionThrowable129 public LispObject arrayDisplacement() 130 130 { 131 131 LispObject value1, value2; … … 165 165 166 166 @Override 167 public LispObject elt(int index) throws ConditionThrowable167 public LispObject elt(int index) 168 168 { 169 169 final int limit = length(); … … 175 175 // Ignores fill pointer. 176 176 @Override 177 public LispObject AREF(int index) throws ConditionThrowable177 public LispObject AREF(int index) 178 178 { 179 179 if (elements != null) { … … 196 196 // FIXME inline 197 197 @Override 198 public LispObject AREF(LispObject index) throws ConditionThrowable198 public LispObject AREF(LispObject index) 199 199 { 200 200 return AREF(Fixnum.getValue(index)); … … 202 202 203 203 @Override 204 public void aset(int index, LispObject newValue) throws ConditionThrowable204 public void aset(int index, LispObject newValue) 205 205 { 206 206 if (elements != null) { … … 221 221 222 222 @Override 223 public LispObject subseq(int start, int end) throws ConditionThrowable223 public LispObject subseq(int start, int end) 224 224 { 225 225 SimpleVector v = new SimpleVector(end - start); … … 236 236 237 237 @Override 238 public void fill(LispObject obj) throws ConditionThrowable238 public void fill(LispObject obj) 239 239 { 240 240 for (int i = capacity; i-- > 0;) … … 243 243 244 244 @Override 245 public void shrink(int n) throws ConditionThrowable245 public void shrink(int n) 246 246 { 247 247 if (elements != null) { … … 260 260 261 261 @Override 262 public LispObject reverse() throws ConditionThrowable262 public LispObject reverse() 263 263 { 264 264 int length = length(); … … 271 271 272 272 @Override 273 public LispObject nreverse() throws ConditionThrowable273 public LispObject nreverse() 274 274 { 275 275 if (elements != null) { … … 302 302 @Override 303 303 public void vectorPushExtend(LispObject element) 304 throws ConditionThrowable 304 305 305 { 306 306 if (fillPointer < 0) … … 316 316 @Override 317 317 public LispObject VECTOR_PUSH_EXTEND(LispObject element) 318 throws ConditionThrowable 318 319 319 { 320 320 vectorPushExtend(element); … … 324 324 @Override 325 325 public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension) 326 throws ConditionThrowable 326 327 327 { 328 328 int ext = Fixnum.getValue(extension); … … 338 338 } 339 339 340 private final void ensureCapacity(int minCapacity) throws ConditionThrowable340 private final void ensureCapacity(int minCapacity) 341 341 { 342 342 if (elements != null) { … … 371 371 LispObject initialElement, 372 372 LispObject initialContents) 373 throws ConditionThrowable 373 374 374 { 375 375 if (initialContents != null) { … … 420 420 AbstractArray displacedTo, 421 421 int displacement) 422 throws ConditionThrowable 422 423 423 { 424 424 capacity = newCapacity; -
trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java
r11714 r12254 95 95 96 96 @Override 97 public void setFillPointer(LispObject obj) throws ConditionThrowable97 public void setFillPointer(LispObject obj) 98 98 { 99 99 if (obj == T) … … 125 125 126 126 @Override 127 public LispObject arrayDisplacement() throws ConditionThrowable127 public LispObject arrayDisplacement() 128 128 { 129 129 LispObject value1, value2; … … 163 163 164 164 @Override 165 public LispObject elt(int index) throws ConditionThrowable165 public LispObject elt(int index) 166 166 { 167 167 final int limit = length(); … … 173 173 // Ignores fill pointer. 174 174 @Override 175 public LispObject AREF(int index) throws ConditionThrowable175 public LispObject AREF(int index) 176 176 { 177 177 if (elements != null) { … … 194 194 // FIXME inline 195 195 @Override 196 public LispObject AREF(LispObject index) throws ConditionThrowable196 public LispObject AREF(LispObject index) 197 197 { 198 198 return AREF(Fixnum.getValue(index)); … … 200 200 201 201 @Override 202 public void aset(int index, int n) throws ConditionThrowable202 public void aset(int index, int n) 203 203 { 204 204 if (elements != null) { … … 219 219 220 220 @Override 221 public void aset(int index, LispObject newValue) throws ConditionThrowable221 public void aset(int index, LispObject newValue) 222 222 { 223 223 if (elements != null) { … … 233 233 234 234 @Override 235 public LispObject subseq(int start, int end) throws ConditionThrowable235 public LispObject subseq(int start, int end) 236 236 { 237 237 SimpleVector v = new SimpleVector(end - start); … … 248 248 249 249 @Override 250 public void fill(LispObject obj) throws ConditionThrowable250 public void fill(LispObject obj) 251 251 { 252 252 byte b = (byte) Fixnum.getValue(obj); … … 256 256 257 257 @Override 258 public void shrink(int n) throws ConditionThrowable258 public void shrink(int n) 259 259 { 260 260 if (elements != null) { … … 273 273 274 274 @Override 275 public LispObject reverse() throws ConditionThrowable275 public LispObject reverse() 276 276 { 277 277 int length = length(); … … 284 284 285 285 @Override 286 public LispObject nreverse() throws ConditionThrowable286 public LispObject nreverse() 287 287 { 288 288 if (elements != null) { … … 314 314 315 315 @Override 316 public void vectorPushExtend(LispObject element) throws ConditionThrowable316 public void vectorPushExtend(LispObject element) 317 317 { 318 318 if (fillPointer < 0) … … 328 328 @Override 329 329 public LispObject VECTOR_PUSH_EXTEND(LispObject element) 330 throws ConditionThrowable 330 331 331 { 332 332 vectorPushExtend(element); … … 336 336 @Override 337 337 public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension) 338 throws ConditionThrowable 338 339 339 { 340 340 int ext = Fixnum.getValue(extension); … … 350 350 } 351 351 352 private final void ensureCapacity(int minCapacity) throws ConditionThrowable352 private final void ensureCapacity(int minCapacity) 353 353 { 354 354 if (elements != null) { … … 383 383 LispObject initialElement, 384 384 LispObject initialContents) 385 throws ConditionThrowable 385 386 386 { 387 387 if (initialContents != null) { … … 433 433 AbstractArray displacedTo, 434 434 int displacement) 435 throws ConditionThrowable 435 436 436 { 437 437 capacity = newCapacity; -
trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java
r11991 r12254 38 38 private LispObject streams; 39 39 40 private ConcatenatedStream(LispObject streams) throws ConditionThrowable40 private ConcatenatedStream(LispObject streams) 41 41 { 42 42 this.streams = streams; … … 45 45 46 46 @Override 47 public boolean isCharacterInputStream() throws ConditionThrowable47 public boolean isCharacterInputStream() 48 48 { 49 49 if (streams == NIL) … … 53 53 54 54 @Override 55 public boolean isBinaryInputStream() throws ConditionThrowable55 public boolean isBinaryInputStream() 56 56 { 57 57 if (streams == NIL) … … 61 61 62 62 @Override 63 public boolean isCharacterOutputStream() throws ConditionThrowable63 public boolean isCharacterOutputStream() 64 64 { 65 65 return false; … … 67 67 68 68 @Override 69 public boolean isBinaryOutputStream() throws ConditionThrowable69 public boolean isBinaryOutputStream() 70 70 { 71 71 return false; … … 85 85 86 86 @Override 87 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable87 public LispObject typep(LispObject typeSpecifier) 88 88 { 89 89 if (typeSpecifier == Symbol.CONCATENATED_STREAM) … … 95 95 96 96 @Override 97 public LispObject getElementType() throws ConditionThrowable97 public LispObject getElementType() 98 98 { 99 99 if (streams == NIL) … … 104 104 @Override 105 105 public LispObject readCharNoHang(boolean eofError, LispObject eofValue) 106 throws ConditionThrowable 106 107 107 { 108 108 if (streams == NIL) { … … 123 123 124 124 @Override 125 public LispObject listen() throws ConditionThrowable125 public LispObject listen() 126 126 { 127 127 if (unreadChar >= 0) … … 140 140 // Returns -1 at end of file. 141 141 @Override 142 protected int _readChar() throws ConditionThrowable,java.io.IOException142 protected int _readChar() throws java.io.IOException 143 143 { 144 144 int n; … … 159 159 160 160 @Override 161 protected void _unreadChar(int n) throws ConditionThrowable161 protected void _unreadChar(int n) 162 162 { 163 163 if (unreadChar >= 0) … … 167 167 168 168 @Override 169 protected boolean _charReady() throws ConditionThrowable,java.io.IOException169 protected boolean _charReady() throws java.io.IOException 170 170 { 171 171 if (unreadChar >= 0) … … 187 187 188 188 @Override 189 public void _writeChar(char c) throws ConditionThrowable189 public void _writeChar(char c) 190 190 { 191 191 outputStreamError(); … … 194 194 @Override 195 195 public void _writeChars(char[] chars, int start, int end) 196 throws ConditionThrowable 197 { 198 outputStreamError(); 199 } 200 201 @Override 202 public void _writeString(String s) throws ConditionThrowable203 { 204 outputStreamError(); 205 } 206 207 @Override 208 public void _writeLine(String s) throws ConditionThrowable196 197 { 198 outputStreamError(); 199 } 200 201 @Override 202 public void _writeString(String s) 203 { 204 outputStreamError(); 205 } 206 207 @Override 208 public void _writeLine(String s) 209 209 { 210 210 outputStreamError(); … … 213 213 // Reads an 8-bit byte. 214 214 @Override 215 public int _readByte() throws ConditionThrowable215 public int _readByte() 216 216 { 217 217 if (streams == NIL) … … 227 227 // Writes an 8-bit byte. 228 228 @Override 229 public void _writeByte(int n) throws ConditionThrowable230 { 231 outputStreamError(); 232 } 233 234 @Override 235 public void _finishOutput() throws ConditionThrowable236 { 237 outputStreamError(); 238 } 239 240 @Override 241 public void _clearInput() throws ConditionThrowable229 public void _writeByte(int n) 230 { 231 outputStreamError(); 232 } 233 234 @Override 235 public void _finishOutput() 236 { 237 outputStreamError(); 238 } 239 240 @Override 241 public void _clearInput() 242 242 { 243 243 // FIXME 244 244 } 245 245 246 private void outputStreamError() throws ConditionThrowable246 private void outputStreamError() 247 247 { 248 248 error(new StreamError(this, … … 255 255 { 256 256 @Override 257 public LispObject execute(LispObject[] args) throws ConditionThrowable257 public LispObject execute(LispObject[] args) 258 258 { 259 259 LispObject streams = NIL; … … 279 279 { 280 280 @Override 281 public LispObject execute(LispObject arg) throws ConditionThrowable281 public LispObject execute(LispObject arg) 282 282 { 283 283 if (arg instanceof ConcatenatedStream) -
trunk/abcl/src/org/armedbear/lisp/Condition.java
r11488 r12254 38 38 protected String message; 39 39 40 public Condition() throws ConditionThrowable40 public Condition() 41 41 { 42 42 super(StandardClass.CONDITION); … … 45 45 } 46 46 47 protected Condition(LispClass cls) throws ConditionThrowable47 protected Condition(LispClass cls) 48 48 { 49 49 super(cls); … … 57 57 } 58 58 59 public Condition(LispObject initArgs) throws ConditionThrowable59 public Condition(LispObject initArgs) 60 60 { 61 61 super(StandardClass.CONDITION); … … 64 64 } 65 65 66 protected void initialize(LispObject initArgs) throws ConditionThrowable66 protected void initialize(LispObject initArgs) 67 67 { 68 68 LispObject control = null; … … 108 108 } 109 109 110 public final LispObject getFormatControl() throws ConditionThrowable110 public final LispObject getFormatControl() 111 111 { 112 112 return getInstanceSlotValue(Symbol.FORMAT_CONTROL); … … 114 114 115 115 public final void setFormatControl(LispObject formatControl) 116 throws ConditionThrowable 116 117 117 { 118 118 setInstanceSlotValue(Symbol.FORMAT_CONTROL, formatControl); 119 119 } 120 120 121 public final void setFormatControl(String s) throws ConditionThrowable121 public final void setFormatControl(String s) 122 122 { 123 123 setFormatControl(new SimpleString(s)); 124 124 } 125 125 126 public final LispObject getFormatArguments() throws ConditionThrowable126 public final LispObject getFormatArguments() 127 127 { 128 128 return getInstanceSlotValue(Symbol.FORMAT_ARGUMENTS); … … 130 130 131 131 public final void setFormatArguments(LispObject formatArguments) 132 throws ConditionThrowable 132 133 133 { 134 134 setInstanceSlotValue(Symbol.FORMAT_ARGUMENTS, formatArguments); 135 135 } 136 136 137 public String getMessage() throws ConditionThrowable137 public String getMessage() 138 138 { 139 139 return message; … … 159 159 160 160 @Override 161 public LispObject typep(LispObject type) throws ConditionThrowable161 public LispObject typep(LispObject type) 162 162 { 163 163 if (type == Symbol.CONDITION) … … 168 168 } 169 169 170 public String getConditionReport() throws ConditionThrowable170 public String getConditionReport() 171 171 { 172 172 String s = getMessage(); … … 186 186 187 187 @Override 188 public String writeToString() throws ConditionThrowable188 public String writeToString() 189 189 { 190 190 final LispThread thread = LispThread.currentThread(); -
trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java
r12253 r12254 54 54 } 55 55 56 public abstract LispObject getCondition() throws ConditionThrowable;56 public abstract LispObject getCondition(); 57 57 } -
trunk/abcl/src/org/armedbear/lisp/Cons.java
r11754 r12254 73 73 74 74 @Override 75 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable75 public LispObject typep(LispObject typeSpecifier) 76 76 { 77 77 if (typeSpecifier instanceof Symbol) … … 143 143 144 144 @Override 145 public LispObject RPLACA(LispObject obj) throws ConditionThrowable145 public LispObject RPLACA(LispObject obj) 146 146 { 147 147 car = obj; … … 156 156 157 157 @Override 158 public LispObject RPLACD(LispObject obj) throws ConditionThrowable158 public LispObject RPLACD(LispObject obj) 159 159 { 160 160 cdr = obj; … … 163 163 164 164 @Override 165 public final LispObject cadr() throws ConditionThrowable165 public final LispObject cadr() 166 166 { 167 167 return cdr.car(); … … 169 169 170 170 @Override 171 public final LispObject cddr() throws ConditionThrowable171 public final LispObject cddr() 172 172 { 173 173 return cdr.cdr(); … … 175 175 176 176 @Override 177 public final LispObject caddr() throws ConditionThrowable177 public final LispObject caddr() 178 178 { 179 179 return cdr.cadr(); … … 181 181 182 182 @Override 183 public LispObject nthcdr(int n) throws ConditionThrowable183 public LispObject nthcdr(int n) 184 184 { 185 185 if (n < 0) … … 231 231 232 232 @Override 233 public final int psxhash() //throws ConditionThrowable233 public final int psxhash() 234 234 { 235 235 return computeEqualpHash(this, 4); … … 254 254 255 255 @Override 256 public final boolean equal(LispObject obj) throws ConditionThrowable256 public final boolean equal(LispObject obj) 257 257 { 258 258 if (this == obj) … … 267 267 268 268 @Override 269 public final boolean equalp(LispObject obj) throws ConditionThrowable269 public final boolean equalp(LispObject obj) 270 270 { 271 271 if (this == obj) … … 280 280 281 281 @Override 282 public final int length() throws ConditionThrowable282 public final int length() 283 283 { 284 284 int length = 1; … … 295 295 296 296 @Override 297 public LispObject NTH(int index) throws ConditionThrowable297 public LispObject NTH(int index) 298 298 { 299 299 if (index < 0) … … 313 313 314 314 @Override 315 public LispObject NTH(LispObject arg) throws ConditionThrowable315 public LispObject NTH(LispObject arg) 316 316 { 317 317 int index; … … 347 347 348 348 @Override 349 public LispObject elt(int index) throws ConditionThrowable349 public LispObject elt(int index) 350 350 { 351 351 if (index < 0) … … 384 384 385 385 @Override 386 public LispObject reverse() throws ConditionThrowable386 public LispObject reverse() 387 387 { 388 388 Cons cons = this; … … 399 399 400 400 @Override 401 public final LispObject nreverse() throws ConditionThrowable401 public final LispObject nreverse() 402 402 { 403 403 if (cdr instanceof Cons) … … 457 457 458 458 @Override 459 public final LispObject[] copyToArray() throws ConditionThrowable459 public final LispObject[] copyToArray() 460 460 { 461 461 final int length = length(); … … 471 471 472 472 @Override 473 public LispObject execute() throws ConditionThrowable473 public LispObject execute() 474 474 { 475 475 if (car == Symbol.LAMBDA) … … 482 482 483 483 @Override 484 public LispObject execute(LispObject arg) throws ConditionThrowable484 public LispObject execute(LispObject arg) 485 485 { 486 486 if (car == Symbol.LAMBDA) … … 494 494 @Override 495 495 public LispObject execute(LispObject first, LispObject second) 496 throws ConditionThrowable 496 497 497 { 498 498 if (car == Symbol.LAMBDA) … … 507 507 public LispObject execute(LispObject first, LispObject second, 508 508 LispObject third) 509 throws ConditionThrowable 509 510 510 { 511 511 if (car == Symbol.LAMBDA) … … 520 520 public LispObject execute(LispObject first, LispObject second, 521 521 LispObject third, LispObject fourth) 522 throws ConditionThrowable 522 523 523 { 524 524 if (car == Symbol.LAMBDA) … … 534 534 LispObject third, LispObject fourth, 535 535 LispObject fifth) 536 throws ConditionThrowable 536 537 537 { 538 538 if (car == Symbol.LAMBDA) … … 548 548 LispObject third, LispObject fourth, 549 549 LispObject fifth, LispObject sixth) 550 throws ConditionThrowable 550 551 551 { 552 552 if (car == Symbol.LAMBDA) … … 563 563 LispObject fifth, LispObject sixth, 564 564 LispObject seventh) 565 throws ConditionThrowable 565 566 566 { 567 567 if (car == Symbol.LAMBDA) … … 579 579 LispObject fifth, LispObject sixth, 580 580 LispObject seventh, LispObject eighth) 581 throws ConditionThrowable 581 582 582 { 583 583 if (car == Symbol.LAMBDA) … … 591 591 592 592 @Override 593 public LispObject execute(LispObject[] args) throws ConditionThrowable593 public LispObject execute(LispObject[] args) 594 594 { 595 595 if (car == Symbol.LAMBDA) … … 601 601 } 602 602 603 private final LispObject signalExecutionError() throws ConditionThrowable603 private final LispObject signalExecutionError() 604 604 { 605 605 return type_error(this, list(Symbol.OR, Symbol.FUNCTION, … … 608 608 609 609 @Override 610 public String writeToString() throws ConditionThrowable610 public String writeToString() 611 611 { 612 612 final LispThread thread = LispThread.currentThread(); -
trunk/abcl/src/org/armedbear/lisp/ControlError.java
r11488 r12254 36 36 public final class ControlError extends LispError 37 37 { 38 public ControlError(LispObject initArgs) throws ConditionThrowable38 public ControlError(LispObject initArgs) 39 39 { 40 40 super(StandardClass.CONTROL_ERROR); … … 42 42 } 43 43 44 public ControlError(String message) throws ConditionThrowable44 public ControlError(String message) 45 45 { 46 46 super(StandardClass.CONTROL_ERROR); … … 62 62 63 63 @Override 64 public LispObject typep(LispObject type) throws ConditionThrowable64 public LispObject typep(LispObject type) 65 65 { 66 66 if (type == Symbol.CONTROL_ERROR) -
trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java
r11488 r12254 65 65 public LispObject execute(LispObject first, LispObject second, 66 66 LispObject third) 67 throws ConditionThrowable 67 68 68 { 69 69 Stream stream = inSynonymOf(first); … … 78 78 79 79 public abstract LispObject execute(Stream stream, char c, int n) 80 throws ConditionThrowable;80 ; 81 81 } -
trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java
r11488 r12254 36 36 public final class DivisionByZero extends ArithmeticError 37 37 { 38 public DivisionByZero() throws ConditionThrowable38 public DivisionByZero() 39 39 { 40 40 super(StandardClass.DIVISION_BY_ZERO); … … 42 42 } 43 43 44 public DivisionByZero(LispObject initArgs) throws ConditionThrowable44 public DivisionByZero(LispObject initArgs) 45 45 { 46 46 super(StandardClass.DIVISION_BY_ZERO); … … 61 61 62 62 @Override 63 public LispObject typep(LispObject type) throws ConditionThrowable63 public LispObject typep(LispObject type) 64 64 { 65 65 if (type == Symbol.DIVISION_BY_ZERO) -
trunk/abcl/src/org/armedbear/lisp/Do.java
r12170 r12254 42 42 @Override 43 43 public LispObject execute(LispObject args, Environment env) 44 throws ConditionThrowable 44 45 45 { 46 46 return _do(args, env, false); … … 54 54 @Override 55 55 public LispObject execute(LispObject args, Environment env) 56 throws ConditionThrowable 56 57 57 { 58 58 return _do(args, env, true); … … 62 62 private static final LispObject _do(LispObject args, Environment env, 63 63 boolean sequential) 64 throws ConditionThrowable 64 65 65 { 66 66 LispObject varlist = args.car(); -
trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java
r12018 r12254 87 87 88 88 @Override 89 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable89 public LispObject typep(LispObject typeSpecifier) 90 90 { 91 91 if (typeSpecifier == Symbol.FLOAT) … … 169 169 170 170 @Override 171 public boolean equalp(LispObject obj) throws ConditionThrowable171 public boolean equalp(LispObject obj) 172 172 { 173 173 if (obj instanceof SingleFloat) … … 224 224 } 225 225 226 public static double getValue(LispObject obj) throws ConditionThrowable226 public static double getValue(LispObject obj) 227 227 { 228 228 if (obj instanceof DoubleFloat) … … 281 281 282 282 @Override 283 public LispObject add(LispObject obj) throws ConditionThrowable283 public LispObject add(LispObject obj) 284 284 { 285 285 if (obj instanceof Fixnum) … … 301 301 302 302 @Override 303 public LispObject subtract(LispObject obj) throws ConditionThrowable303 public LispObject subtract(LispObject obj) 304 304 { 305 305 if (obj instanceof Fixnum) … … 322 322 323 323 @Override 324 public LispObject multiplyBy(LispObject obj) throws ConditionThrowable324 public LispObject multiplyBy(LispObject obj) 325 325 { 326 326 if (obj instanceof Fixnum) … … 343 343 344 344 @Override 345 public LispObject divideBy(LispObject obj) throws ConditionThrowable345 public LispObject divideBy(LispObject obj) 346 346 { 347 347 if (obj instanceof Fixnum) … … 369 369 370 370 @Override 371 public boolean isEqualTo(LispObject obj) throws ConditionThrowable371 public boolean isEqualTo(LispObject obj) 372 372 { 373 373 if (obj instanceof Fixnum) … … 389 389 390 390 @Override 391 public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable391 public boolean isNotEqualTo(LispObject obj) 392 392 { 393 393 return !isEqualTo(obj); … … 395 395 396 396 @Override 397 public boolean isLessThan(LispObject obj) throws ConditionThrowable397 public boolean isLessThan(LispObject obj) 398 398 { 399 399 if (obj instanceof Fixnum) … … 413 413 414 414 @Override 415 public boolean isGreaterThan(LispObject obj) throws ConditionThrowable415 public boolean isGreaterThan(LispObject obj) 416 416 { 417 417 if (obj instanceof Fixnum) … … 431 431 432 432 @Override 433 public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable433 public boolean isLessThanOrEqualTo(LispObject obj) 434 434 { 435 435 if (obj instanceof Fixnum) … … 449 449 450 450 @Override 451 public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable451 public boolean isGreaterThanOrEqualTo(LispObject obj) 452 452 { 453 453 if (obj instanceof Fixnum) … … 467 467 468 468 @Override 469 public LispObject truncate(LispObject obj) throws ConditionThrowable469 public LispObject truncate(LispObject obj) 470 470 { 471 471 // "When rationals and floats are combined by a numerical function, … … 580 580 581 581 @Override 582 public String writeToString() throws ConditionThrowable582 public String writeToString() 583 583 { 584 584 if (value == Double.POSITIVE_INFINITY) { … … 615 615 } 616 616 617 public LispObject rational() throws ConditionThrowable617 public LispObject rational() 618 618 { 619 619 final long bits = Double.doubleToRawLongBits(value); … … 642 642 } 643 643 644 public static DoubleFloat coerceToFloat(LispObject obj) throws ConditionThrowable644 public static DoubleFloat coerceToFloat(LispObject obj) 645 645 { 646 646 if (obj instanceof DoubleFloat) -
trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java
r11488 r12254 36 36 public final class DowncaseStream extends CaseFrobStream 37 37 { 38 public DowncaseStream(Stream target) throws ConditionThrowable38 public DowncaseStream(Stream target) 39 39 { 40 40 super(target); … … 42 42 43 43 @Override 44 public void _writeChar(char c) throws ConditionThrowable44 public void _writeChar(char c) 45 45 { 46 46 target._writeChar(LispCharacter.toLowerCase(c)); … … 48 48 49 49 @Override 50 public void _writeString(String s) throws ConditionThrowable50 public void _writeString(String s) 51 51 { 52 52 target._writeString(s.toLowerCase()); … … 54 54 55 55 @Override 56 public void _writeLine(String s) throws ConditionThrowable56 public void _writeLine(String s) 57 57 { 58 58 target._writeLine(s.toLowerCase()); -
trunk/abcl/src/org/armedbear/lisp/EchoStream.java
r11991 r12254 55 55 56 56 @Override 57 public LispObject getElementType() throws ConditionThrowable57 public LispObject getElementType() 58 58 { 59 59 LispObject itype = in.getElementType(); … … 87 87 88 88 @Override 89 public LispObject typep(LispObject type) throws ConditionThrowable89 public LispObject typep(LispObject type) 90 90 { 91 91 if (type == Symbol.ECHO_STREAM) … … 109 109 110 110 @Override 111 public boolean isCharacterInputStream() throws ConditionThrowable111 public boolean isCharacterInputStream() 112 112 { 113 113 return in.isCharacterInputStream(); … … 115 115 116 116 @Override 117 public boolean isBinaryInputStream() throws ConditionThrowable117 public boolean isBinaryInputStream() 118 118 { 119 119 return in.isBinaryInputStream(); … … 121 121 122 122 @Override 123 public boolean isCharacterOutputStream() throws ConditionThrowable123 public boolean isCharacterOutputStream() 124 124 { 125 125 return out.isCharacterOutputStream(); … … 127 127 128 128 @Override 129 public boolean isBinaryOutputStream() throws ConditionThrowable129 public boolean isBinaryOutputStream() 130 130 { 131 131 return out.isBinaryOutputStream(); … … 134 134 // Returns -1 at end of file. 135 135 @Override 136 protected int _readChar() throws ConditionThrowable,java.io.IOException136 protected int _readChar() throws java.io.IOException 137 137 { 138 138 int n = in._readChar(); … … 148 148 149 149 @Override 150 protected void _unreadChar(int n) throws ConditionThrowable,java.io.IOException150 protected void _unreadChar(int n) throws java.io.IOException 151 151 { 152 152 in._unreadChar(n); … … 155 155 156 156 @Override 157 protected boolean _charReady() throws ConditionThrowable,java.io.IOException157 protected boolean _charReady() throws java.io.IOException 158 158 { 159 159 return in._charReady(); … … 161 161 162 162 @Override 163 public void _writeChar(char c) throws ConditionThrowable163 public void _writeChar(char c) 164 164 { 165 165 out._writeChar(c); … … 168 168 @Override 169 169 public void _writeChars(char[] chars, int start, int end) 170 throws ConditionThrowable 170 171 171 { 172 172 out._writeChars(chars, start, end); … … 174 174 175 175 @Override 176 public void _writeString(String s) throws ConditionThrowable176 public void _writeString(String s) 177 177 { 178 178 out._writeString(s); … … 180 180 181 181 @Override 182 public void _writeLine(String s) throws ConditionThrowable182 public void _writeLine(String s) 183 183 { 184 184 out._writeLine(s); … … 187 187 // Reads an 8-bit byte. 188 188 @Override 189 public int _readByte() throws ConditionThrowable189 public int _readByte() 190 190 { 191 191 int n = in._readByte(); … … 197 197 // Writes an 8-bit byte. 198 198 @Override 199 public void _writeByte(int n) throws ConditionThrowable199 public void _writeByte(int n) 200 200 { 201 201 out._writeByte(n); … … 203 203 204 204 @Override 205 public void _finishOutput() throws ConditionThrowable205 public void _finishOutput() 206 206 { 207 207 out._finishOutput(); … … 209 209 210 210 @Override 211 public void _clearInput() throws ConditionThrowable211 public void _clearInput() 212 212 { 213 213 in._clearInput(); … … 215 215 216 216 @Override 217 public LispObject close(LispObject abort) throws ConditionThrowable217 public LispObject close(LispObject abort) 218 218 { 219 219 // "The effect of CLOSE on a constructed stream is to close the … … 225 225 226 226 @Override 227 public LispObject listen() throws ConditionThrowable227 public LispObject listen() 228 228 { 229 229 return in.listen(); … … 231 231 232 232 @Override 233 public LispObject freshLine() throws ConditionThrowable233 public LispObject freshLine() 234 234 { 235 235 return out.freshLine(); … … 249 249 @Override 250 250 public LispObject execute(LispObject first, LispObject second) 251 throws ConditionThrowable 251 252 252 { 253 253 if (!(first instanceof Stream)) … … 265 265 { 266 266 @Override 267 public LispObject execute(LispObject arg) throws ConditionThrowable267 public LispObject execute(LispObject arg) 268 268 { 269 269 if (arg instanceof EchoStream) … … 279 279 { 280 280 @Override 281 public LispObject execute(LispObject arg) throws ConditionThrowable281 public LispObject execute(LispObject arg) 282 282 { 283 283 if (arg instanceof EchoStream) -
trunk/abcl/src/org/armedbear/lisp/EndOfFile.java
r11488 r12254 36 36 public final class EndOfFile extends StreamError 37 37 { 38 public EndOfFile(Stream stream) throws ConditionThrowable38 public EndOfFile(Stream stream) 39 39 { 40 40 super(StandardClass.END_OF_FILE); … … 42 42 } 43 43 44 public EndOfFile(LispObject initArgs) throws ConditionThrowable44 public EndOfFile(LispObject initArgs) 45 45 { 46 46 super(StandardClass.END_OF_FILE); … … 61 61 62 62 @Override 63 public LispObject typep(LispObject type) throws ConditionThrowable63 public LispObject typep(LispObject type) 64 64 { 65 65 if (type == Symbol.END_OF_FILE) … … 71 71 72 72 @Override 73 public String writeToString() throws ConditionThrowable73 public String writeToString() 74 74 { 75 75 return unreadableString(Symbol.END_OF_FILE); -
trunk/abcl/src/org/armedbear/lisp/Environment.java
r12171 r12254 76 76 77 77 @Override 78 public LispObject typep(LispObject type) throws ConditionThrowable78 public LispObject typep(LispObject type) 79 79 { 80 80 if (type == Symbol.ENVIRONMENT) … … 141 141 142 142 public LispObject lookupFunction(LispObject name) 143 throws ConditionThrowable 143 144 144 { 145 145 FunctionBinding binding = lastFunctionBinding; … … 215 215 // Returns body with declarations removed. 216 216 public LispObject processDeclarations(LispObject body) 217 throws ConditionThrowable 217 218 218 { 219 219 LispObject bodyAndDecls = parseBody(body, false); … … 244 244 245 245 @Override 246 public String writeToString() throws ConditionThrowable246 public String writeToString() 247 247 { 248 248 return unreadableString(Symbol.ENVIRONMENT); … … 260 260 } 261 261 @Override 262 public LispObject execute(LispObject arg) throws ConditionThrowable262 public LispObject execute(LispObject arg) 263 263 { 264 264 if (arg == NIL) … … 276 276 public LispObject execute(LispObject first, LispObject second, 277 277 LispObject third) 278 throws ConditionThrowable 278 279 279 { 280 280 Environment env = checkEnvironment(first); … … 294 294 public LispObject execute(LispObject first, LispObject second, 295 295 LispObject third) 296 throws ConditionThrowable 296 297 297 { 298 298 checkEnvironment(first).addFunctionBinding(second, third); … … 309 309 public LispObject execute(LispObject first, LispObject second, 310 310 LispObject third) 311 throws ConditionThrowable 311 312 312 { 313 313 checkEnvironment(first).bind(checkSymbol(second), third); … … 321 321 { 322 322 @Override 323 public LispObject execute(LispObject arg) throws ConditionThrowable323 public LispObject execute(LispObject arg) 324 324 { 325 325 return checkEnvironment(arg).isEmpty() ? T : NIL; … … 332 332 { 333 333 @Override 334 public LispObject execute(LispObject arg) throws ConditionThrowable334 public LispObject execute(LispObject arg) 335 335 { 336 336 Environment env = checkEnvironment(arg); … … 348 348 { 349 349 @Override 350 public LispObject execute(LispObject arg) throws ConditionThrowable350 public LispObject execute(LispObject arg) 351 351 { 352 352 Environment env = checkEnvironment(arg); … … 367 367 { 368 368 @Override 369 public LispObject execute(LispObject arg) throws ConditionThrowable369 public LispObject execute(LispObject arg) 370 370 { 371 371 Environment env = checkEnvironment(arg); -
trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java
r12252 r12254 73 73 74 74 @Override 75 public void put(LispObject key, LispObject value) throws ConditionThrowable75 public void put(LispObject key, LispObject value) 76 76 { 77 77 int index = key.sxhash() & mask; … … 99 99 100 100 @Override 101 public LispObject remove(LispObject key) throws ConditionThrowable101 public LispObject remove(LispObject key) 102 102 { 103 103 final int index = key.sxhash() & mask; -
trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java
r12252 r12254 71 71 72 72 @Override 73 public void put(LispObject key, LispObject value) throws ConditionThrowable73 public void put(LispObject key, LispObject value) 74 74 { 75 75 int index = key.psxhash() % buckets.length; … … 97 97 98 98 @Override 99 public LispObject remove(LispObject key) throws ConditionThrowable99 public LispObject remove(LispObject key) 100 100 { 101 101 final int index = key.psxhash() % buckets.length; -
trunk/abcl/src/org/armedbear/lisp/Extensions.java
r11754 r12254 50 50 @Override 51 51 public LispObject execute(LispObject args, Environment env) 52 throws ConditionThrowable 52 53 53 { 54 54 if (args.length() != 2) … … 64 64 @Override 65 65 public LispObject execute(LispObject first, LispObject second) 66 throws ConditionThrowable 66 67 67 { 68 68 return first != second ? T : NIL; … … 76 76 @Override 77 77 public LispObject execute(LispObject item, LispObject list) 78 throws ConditionThrowable 78 79 79 { 80 80 while (list instanceof Cons) … … 96 96 @Override 97 97 public LispObject execute(LispObject item, LispObject list) 98 throws ConditionThrowable 98 99 99 { 100 100 while (list instanceof Cons) … … 116 116 @Override 117 117 public LispObject execute(LispObject item, LispObject list) 118 throws ConditionThrowable 118 119 119 { 120 120 return memql(item, list) ? list : new Cons(item, list); … … 127 127 { 128 128 @Override 129 public LispObject execute(LispObject arg) throws ConditionThrowable129 public LispObject execute(LispObject arg) 130 130 { 131 131 return arg.isSpecialVariable() ? T : NIL; … … 138 138 { 139