Changeset 12254


Ignore:
Timestamp:
11/06/09 20:07:54 (12 years ago)
Author:
ehuelsmann
Message:

Remove 'throws ConditionThrowable?' method annotations:

it's an unchecked exception now, so no need to declare it thrown.

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

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/AbstractArray.java

    r11711 r12254  
    3737{
    3838    @Override
    39     public LispObject typep(LispObject type) throws ConditionThrowable
     39    public LispObject typep(LispObject type)
    4040    {
    4141        if (type == Symbol.ARRAY)
     
    4747
    4848    @Override
    49     public boolean equalp(LispObject obj) throws ConditionThrowable
     49    public boolean equalp(LispObject obj)
    5050    {
    5151        if (obj instanceof AbstractArray) {
     
    7171    }
    7272
    73     public LispObject arrayDisplacement() throws ConditionThrowable
     73    public LispObject arrayDisplacement()
    7474    {
    7575        return LispThread.currentThread().setValues(NIL, Fixnum.ZERO);
     
    8181    }
    8282
    83     public int getFillPointer() throws ConditionThrowable
     83    public int getFillPointer()
    8484    {
    8585        noFillPointer();
     
    8787    }
    8888
    89     public void setFillPointer(LispObject fillPointer) throws ConditionThrowable
     89    public void setFillPointer(LispObject fillPointer)
    9090    {
    9191        setFillPointer(fillPointer.intValue());
    9292    }
    9393
    94     public void setFillPointer(int fillPointer) throws ConditionThrowable
     94    public void setFillPointer(int fillPointer)
    9595    {
    9696        noFillPointer();
     
    106106    public abstract LispObject getDimensions();
    107107
    108     public abstract int getDimension(int n) throws ConditionThrowable;
     108    public abstract int getDimension(int n);
    109109
    110110    public abstract LispObject getElementType();
     
    114114    @Override
    115115    public abstract void aset(int index, LispObject newValue)
    116         throws ConditionThrowable;
     116       ;
    117117
    118118    // FIXME Detect overflow!
     
    126126
    127127    public int getRowMajorIndex(LispObject[] subscripts)
    128         throws ConditionThrowable
     128
    129129    {
    130130        int[] subs = new int[subscripts.length];
     
    139139    }
    140140
    141     public int getRowMajorIndex(int[] subscripts) throws ConditionThrowable
     141    public int getRowMajorIndex(int[] subscripts)
    142142    {
    143143        final int rank = getRank();
     
    166166    }
    167167
    168     public LispObject get(int[] subscripts) throws ConditionThrowable
     168    public LispObject get(int[] subscripts)
    169169    {
    170170        return AREF(getRowMajorIndex(subscripts));
     
    172172
    173173    public void set(int[] subscripts, LispObject newValue)
    174         throws ConditionThrowable
     174
    175175    {
    176176        aset(getRowMajorIndex(subscripts), newValue);
    177177    }
    178178
    179     public abstract void fill(LispObject obj) throws ConditionThrowable;
    180 
    181     public String writeToString(int[] dimv) throws ConditionThrowable
     179    public abstract void fill(LispObject obj);
     180
     181    public String writeToString(int[] dimv)
    182182    {
    183183        StringBuilder sb = new StringBuilder();
     
    230230    private void appendContents(int[] dimensions, int index, StringBuilder sb,
    231231                                LispThread thread)
    232         throws ConditionThrowable
     232
    233233    {
    234234        if (dimensions.length == 0) {
     
    319319     * @param initialContents @c null if none
    320320     * @return @c this or a new array
    321      * @throws org.armedbear.lisp.ConditionThrowable
    322321     */
    323322    public abstract AbstractArray adjustArray(int[] dims,
    324323                                              LispObject initialElement,
    325                                               LispObject initialContents)
    326         throws ConditionThrowable;
     324                                              LispObject initialContents);
    327325
    328326    /**
     
    332330     * @param displacement
    333331     * @return
    334      * @throws org.armedbear.lisp.ConditionThrowable
    335332     */
    336333    public abstract AbstractArray adjustArray(int[] dims,
    337334                                              AbstractArray displacedTo,
    338                                               int displacement)
    339         throws ConditionThrowable;
     335                                              int displacement);
    340336}
  • trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java

    r12252 r12254  
    4444
    4545    @Override
    46     public LispObject typep(LispObject type) throws ConditionThrowable
     46    public LispObject typep(LispObject type)
    4747    {
    4848        if (type == Symbol.BIT_VECTOR)
     
    7272
    7373    @Override
    74     public boolean equal(LispObject obj) throws ConditionThrowable
     74    public boolean equal(LispObject obj)
    7575    {
    7676        if (this == obj)
     
    9090
    9191    @Override
    92     public boolean equalp(LispObject obj) throws ConditionThrowable
     92    public boolean equalp(LispObject obj)
    9393    {
    9494        if (this == obj)
     
    112112
    113113    @Override
    114     public void fill(LispObject obj) throws ConditionThrowable
     114    public void fill(LispObject obj)
    115115    {
    116116        if (obj instanceof Fixnum) {
     
    141141
    142142    @Override
    143     public LispObject subseq(int start, int end) throws ConditionThrowable
     143    public LispObject subseq(int start, int end)
    144144    {
    145145        SimpleBitVector v = new SimpleBitVector(end - start);
     
    178178
    179179    @Override
    180     public String writeToString() throws ConditionThrowable
     180    public String writeToString()
    181181    {
    182182        final LispThread thread = LispThread.currentThread();
     
    199199    // Ignores fill pointer.
    200200    @Override
    201     public LispObject AREF(LispObject index) throws ConditionThrowable
     201    public LispObject AREF(LispObject index)
    202202    {
    203203        return AREF(Fixnum.getValue(index));
     
    205205
    206206    @Override
    207     public LispObject reverse() throws ConditionThrowable
     207    public LispObject reverse()
    208208    {
    209209        int length = length();
     
    219219    }
    220220
    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);
    226226}
  • trunk/abcl/src/org/armedbear/lisp/AbstractString.java

    r12252 r12254  
    3737{
    3838    @Override
    39     public LispObject typep(LispObject type) throws ConditionThrowable
     39    public LispObject typep(LispObject type)
    4040    {
    4141        if (type instanceof Symbol) {
     
    8282    }
    8383
    84     public abstract void fill(char c) throws ConditionThrowable;
     84    public abstract void fill(char c);
    8585
    86     public abstract char charAt(int index) throws ConditionThrowable;
     86    public abstract char charAt(int index);
    8787
    88     public abstract void setCharAt(int index, char c) throws ConditionThrowable;
     88    public abstract void setCharAt(int index, char c);
    8989
    9090    public final String writeToString(int beginIndex, int endIndex)
    91         throws ConditionThrowable
     91
    9292    {
    9393        if (beginIndex < 0)
     
    115115
    116116    @Override
    117     public String writeToString() throws ConditionThrowable
     117    public String writeToString()
    118118    {
    119119        return writeToString(0, length());
  • trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

    r11714 r12254  
    3636{
    3737  @Override
    38   public LispObject typep(LispObject type) throws ConditionThrowable
     38  public LispObject typep(LispObject type)
    3939  {
    4040    if (type == Symbol.VECTOR)
     
    6262
    6363  @Override
    64   public boolean equalp(LispObject obj) throws ConditionThrowable
     64  public boolean equalp(LispObject obj)
    6565  {
    6666    if (obj instanceof AbstractVector)
     
    9090
    9191  @Override
    92   public final int getDimension(int n) throws ConditionThrowable
     92  public final int getDimension(int n)
    9393  {
    9494    if (n != 0)
     
    109109  public abstract int capacity();
    110110
    111   public abstract LispObject subseq(int start, int end) throws ConditionThrowable;
    112 
    113   public LispObject deleteEq(LispObject item) throws ConditionThrowable
     111  public abstract LispObject subseq(int start, int end);
     112
     113  public LispObject deleteEq(LispObject item)
    114114  {
    115115    final int limit = length();
     
    128128  }
    129129
    130   public LispObject deleteEql(LispObject item) throws ConditionThrowable
     130  public LispObject deleteEql(LispObject item)
    131131  {
    132132    final int limit = length();
     
    145145  }
    146146
    147   public abstract void shrink(int n) throws ConditionThrowable;
    148 
    149   public int checkIndex(int index) throws ConditionThrowable
     147  public abstract void shrink(int n);
     148
     149  public int checkIndex(int index)
    150150  {
    151151    if (index < 0 || index >= capacity())
     
    154154  }
    155155
    156   protected void badIndex(int index, int limit) throws ConditionThrowable
     156  protected void badIndex(int index, int limit)
    157157  {
    158158    FastStringBuffer sb = new FastStringBuffer("Invalid array index ");
     
    174174  }
    175175
    176   public void setFillPointer(int n) throws ConditionThrowable
     176  public void setFillPointer(int n)
    177177  {
    178178    noFillPointer();
    179179  }
    180180
    181   public void setFillPointer(LispObject obj) throws ConditionThrowable
     181  public void setFillPointer(LispObject obj)
    182182  {
    183183    noFillPointer();
     
    190190
    191191  @Override
    192   public abstract LispObject reverse() throws ConditionThrowable;
    193 
    194   @Override
    195   public LispObject nreverse() throws ConditionThrowable
     192  public abstract LispObject reverse();
     193
     194  @Override
     195  public LispObject nreverse()
    196196  {
    197197    int i = 0;
     
    209209
    210210  @Override
    211   public String writeToString() throws ConditionThrowable
     211  public String writeToString()
    212212  {
    213213    final LispThread thread = LispThread.currentThread();
     
    301301                                              LispObject initialElement,
    302302                                              LispObject initialContents)
    303     throws ConditionThrowable;
     303   ;
    304304  public abstract AbstractArray adjustArray(int size,
    305305                                              AbstractArray displacedTo,
    306306                                              int displacement)
    307     throws ConditionThrowable;
     307   ;
    308308
    309309
     
    311311                                              LispObject initialElement,
    312312                                              LispObject initialContents)
    313     throws ConditionThrowable {
     313    {
    314314      return adjustArray(dims[0], initialElement, initialContents);
    315315  }
     
    318318                                              AbstractArray displacedTo,
    319319                                              int displacement)
    320     throws ConditionThrowable {
     320    {
    321321      return adjustArray(dims[0], displacedTo, displacement);
    322322  }
  • trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java

    r11754 r12254  
    3636public class ArithmeticError extends LispError
    3737{
    38     protected ArithmeticError(LispClass cls) throws ConditionThrowable
     38    protected ArithmeticError(LispClass cls)
    3939    {
    4040        super(cls);
    4141    }
    4242
    43     public ArithmeticError(LispObject initArgs) throws ConditionThrowable
     43    public ArithmeticError(LispObject initArgs)
    4444    {
    4545        super(StandardClass.ARITHMETIC_ERROR);
     
    4848
    4949    @Override
    50     protected void initialize(LispObject initArgs) throws ConditionThrowable
     50    protected void initialize(LispObject initArgs)
    5151    {
    5252        super.initialize(initArgs);
     
    6868    }
    6969
    70     public ArithmeticError(String message) throws ConditionThrowable
     70    public ArithmeticError(String message)
    7171    {
    7272        super(StandardClass.ARITHMETIC_ERROR);
     
    9090
    9191    @Override
    92     public LispObject typep(LispObject type) throws ConditionThrowable
     92    public LispObject typep(LispObject type)
    9393    {
    9494        if (type == Symbol.ARITHMETIC_ERROR)
     
    9999    }
    100100
    101     private final LispObject getOperation() throws ConditionThrowable
     101    private final LispObject getOperation()
    102102    {
    103103        return getInstanceSlotValue(Symbol.OPERATION);
     
    105105
    106106    private final void setOperation(LispObject operation)
    107         throws ConditionThrowable
     107
    108108    {
    109109        setInstanceSlotValue(Symbol.OPERATION, operation);
    110110    }
    111111
    112     private final LispObject getOperands() throws ConditionThrowable
     112    private final LispObject getOperands()
    113113    {
    114114        return getInstanceSlotValue(Symbol.OPERANDS);
     
    116116
    117117    private final void setOperands(LispObject operands)
    118         throws ConditionThrowable
     118
    119119    {
    120120        setInstanceSlotValue(Symbol.OPERANDS, operands);
     
    126126    {
    127127        @Override
    128         public LispObject execute(LispObject arg) throws ConditionThrowable
     128        public LispObject execute(LispObject arg)
    129129        {
    130130            if (arg instanceof ArithmeticError) {
     
    141141    {
    142142        @Override
    143         public LispObject execute(LispObject arg) throws ConditionThrowable
     143        public LispObject execute(LispObject arg)
    144144        {
    145145            if (arg instanceof ArithmeticError) {
  • trunk/abcl/src/org/armedbear/lisp/Autoload.java

    r12252 r12254  
    100100    }
    101101
    102     public void load() throws ConditionThrowable
     102    public void load()
    103103    {
    104104        if (className != null) {
     
    157157
    158158    @Override
    159     public LispObject execute() throws ConditionThrowable
     159    public LispObject execute()
    160160    {
    161161        load();
     
    164164
    165165    @Override
    166     public LispObject execute(LispObject arg) throws ConditionThrowable
     166    public LispObject execute(LispObject arg)
    167167    {
    168168        load();
     
    172172    @Override
    173173    public LispObject execute(LispObject first, LispObject second)
    174         throws ConditionThrowable
     174
    175175    {
    176176        load();
     
    181181    public LispObject execute(LispObject first, LispObject second,
    182182                              LispObject third)
    183         throws ConditionThrowable
     183
    184184    {
    185185        load();
     
    190190    public LispObject execute(LispObject first, LispObject second,
    191191                              LispObject third, LispObject fourth)
    192         throws ConditionThrowable
     192
    193193    {
    194194        load();
     
    200200                              LispObject third, LispObject fourth,
    201201                              LispObject fifth)
    202         throws ConditionThrowable
     202
    203203    {
    204204        load();
     
    210210                              LispObject third, LispObject fourth,
    211211                              LispObject fifth, LispObject sixth)
    212         throws ConditionThrowable
     212
    213213    {
    214214        load();
     
    221221                              LispObject fifth, LispObject sixth,
    222222                              LispObject seventh)
    223         throws ConditionThrowable
     223
    224224    {
    225225        load();
     
    233233                              LispObject fifth, LispObject sixth,
    234234                              LispObject seventh, LispObject eighth)
    235         throws ConditionThrowable
     235
    236236    {
    237237        load();
     
    241241
    242242    @Override
    243     public LispObject execute(LispObject[] args) throws ConditionThrowable
     243    public LispObject execute(LispObject[] args)
    244244    {
    245245        load();
     
    248248
    249249    @Override
    250     public String writeToString() throws ConditionThrowable
     250    public String writeToString()
    251251    {
    252252        StringBuffer sb = new StringBuffer("#<AUTOLOAD ");
     
    271271    {
    272272        @Override
    273         public LispObject execute(LispObject first) throws ConditionThrowable
     273        public LispObject execute(LispObject first)
    274274        {
    275275            if (first instanceof Symbol) {
     
    289289        @Override
    290290        public LispObject execute(LispObject first, LispObject second)
    291             throws ConditionThrowable
     291
    292292        {
    293293            final String fileName = second.getStringValue();
     
    314314    {
    315315        @Override
    316         public LispObject execute(LispObject arg) throws ConditionThrowable
     316        public LispObject execute(LispObject arg)
    317317        {
    318318            Symbol symbol = checkSymbol(arg);
     
    332332    {
    333333        @Override
    334         public LispObject execute(LispObject arg) throws ConditionThrowable
     334        public LispObject execute(LispObject arg)
    335335        {
    336336            if (arg instanceof Symbol) {
  • trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java

    r11488 r12254  
    4747
    4848    private static void installAutoloadMacro(Symbol symbol, String fileName)
    49         throws ConditionThrowable
     49
    5050    {
    5151        AutoloadMacro am = new AutoloadMacro(symbol, fileName);
     
    5757
    5858    @Override
    59     public void load() throws ConditionThrowable
     59    public void load()
    6060    {
    6161        Load.loadSystemFile(getFileName(), true);
     
    6363
    6464    @Override
    65     public String writeToString() throws ConditionThrowable
     65    public String writeToString()
    6666    {
    6767        StringBuffer sb = new StringBuffer("#<AUTOLOAD-MACRO ");
     
    7878    {
    7979        @Override
    80         public LispObject execute(LispObject first) throws ConditionThrowable
     80        public LispObject execute(LispObject first)
    8181        {
    8282            if (first instanceof Symbol) {
     
    9696        @Override
    9797        public LispObject execute(LispObject first, LispObject second)
    98             throws ConditionThrowable
     98
    9999        {
    100100            final String fileName = second.getStringValue();
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r11754 r12254  
    4848
    4949    private BasicVector_UnsignedByte16(LispObject[] array)
    50         throws ConditionThrowable
     50
    5151    {
    5252        capacity = array.length;
     
    7070
    7171    @Override
    72     public LispObject typep(LispObject type) throws ConditionThrowable
     72    public LispObject typep(LispObject type)
    7373    {
    7474        if (type == Symbol.SIMPLE_ARRAY)
     
    116116
    117117    @Override
    118     public LispObject elt(int index) throws ConditionThrowable
     118    public LispObject elt(int index)
    119119    {
    120120        try {
     
    129129    // Ignores fill pointer.
    130130    @Override
    131     public int aref(int index) throws ConditionThrowable
     131    public int aref(int index)
    132132    {
    133133        try {
     
    143143    // Ignores fill pointer.
    144144    @Override
    145     public LispObject AREF(int index) throws ConditionThrowable
     145    public LispObject AREF(int index)
    146146    {
    147147        try {
     
    156156    // Ignores fill pointer.
    157157    @Override
    158     public LispObject AREF(LispObject index) throws ConditionThrowable
     158    public LispObject AREF(LispObject index)
    159159    {
    160160        try {
     
    168168
    169169    @Override
    170     public void aset(int index, int n) throws ConditionThrowable
     170    public void aset(int index, int n)
    171171    {
    172172        try {
     
    179179
    180180    @Override
    181     public void aset(int index, LispObject obj) throws ConditionThrowable
     181    public void aset(int index, LispObject obj)
    182182    {
    183183        if (obj instanceof Fixnum) {
     
    195195
    196196    @Override
    197     public LispObject subseq(int start, int end) throws ConditionThrowable
     197    public LispObject subseq(int start, int end)
    198198    {
    199199        BasicVector_UnsignedByte16 v = new BasicVector_UnsignedByte16(end - start);
     
    210210
    211211    @Override
    212     public void fill(LispObject obj) throws ConditionThrowable
     212    public void fill(LispObject obj)
    213213    {
    214214        int n = Fixnum.getValue(obj);
     
    218218
    219219    @Override
    220     public void shrink(int n) throws ConditionThrowable
     220    public void shrink(int n)
    221221    {
    222222        if (n < capacity) {
     
    233233
    234234    @Override
    235     public LispObject reverse() throws ConditionThrowable
     235    public LispObject reverse()
    236236    {
    237237        BasicVector_UnsignedByte16 result = new BasicVector_UnsignedByte16(capacity);
     
    243243
    244244    @Override
    245     public LispObject nreverse() throws ConditionThrowable
     245    public LispObject nreverse()
    246246    {
    247247        int i = 0;
     
    261261                                       LispObject initialElement,
    262262                                       LispObject initialContents)
    263         throws ConditionThrowable
     263
    264264    {
    265265        if (initialContents != null) {
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r11754 r12254  
    4949
    5050  public BasicVector_UnsignedByte32(LispObject[] array)
    51     throws ConditionThrowable
     51
    5252  {
    5353    capacity = array.length;
     
    7171
    7272  @Override
    73   public LispObject typep(LispObject type) throws ConditionThrowable
     73  public LispObject typep(LispObject type)
    7474  {
    7575    if (type == Symbol.SIMPLE_ARRAY)
     
    117117
    118118  @Override
    119   public LispObject elt(int index) throws ConditionThrowable
     119  public LispObject elt(int index)
    120120  {
    121121    try
     
    131131
    132132  @Override
    133   public int aref(int index) throws ConditionThrowable
     133  public int aref(int index)
    134134  {
    135135    try
     
    145145
    146146  @Override
    147   public long aref_long(int index) throws ConditionThrowable
     147  public long aref_long(int index)
    148148  {
    149149    try
     
    159159
    160160  @Override
    161   public LispObject AREF(int index) throws ConditionThrowable
     161  public LispObject AREF(int index)
    162162  {
    163163    try
     
    173173
    174174  @Override
    175   public LispObject AREF(LispObject index) throws ConditionThrowable
     175  public LispObject AREF(LispObject index)
    176176  {
    177177        final int idx = Fixnum.getValue(index);
     
    188188
    189189  @Override
    190   public void aset(int index, LispObject newValue) throws ConditionThrowable
     190  public void aset(int index, LispObject newValue)
    191191  {
    192192    try
     
    201201
    202202  @Override
    203   public LispObject subseq(int start, int end) throws ConditionThrowable
     203  public LispObject subseq(int start, int end)
    204204  {
    205205    BasicVector_UnsignedByte32 v = new BasicVector_UnsignedByte32(end - start);
     
    219219
    220220  @Override
    221   public void fill(LispObject obj) throws ConditionThrowable
     221  public void fill(LispObject obj)
    222222  {
    223223    for (int i = capacity; i-- > 0;)
     
    226226
    227227  @Override
    228   public void shrink(int n) throws ConditionThrowable
     228  public void shrink(int n)
    229229  {
    230230    if (n < capacity)
     
    242242
    243243  @Override
    244   public LispObject reverse() throws ConditionThrowable
     244  public LispObject reverse()
    245245  {
    246246    BasicVector_UnsignedByte32 result = new BasicVector_UnsignedByte32(capacity);
     
    252252
    253253  @Override
    254   public LispObject nreverse() throws ConditionThrowable
     254  public LispObject nreverse()
    255255  {
    256256    int i = 0;
     
    271271                                     LispObject initialElement,
    272272                                     LispObject initialContents)
    273     throws ConditionThrowable
     273
    274274  {
    275275    if (initialContents != null)
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r11754 r12254  
    4848
    4949  public BasicVector_UnsignedByte8(LispObject[] array)
    50     throws ConditionThrowable
     50
    5151  {
    5252    capacity = array.length;
     
    6969
    7070  @Override
    71   public LispObject typep(LispObject type) throws ConditionThrowable
     71  public LispObject typep(LispObject type)
    7272  {
    7373    if (type == Symbol.SIMPLE_ARRAY)
     
    115115
    116116  @Override
    117   public LispObject elt(int index) throws ConditionThrowable
     117  public LispObject elt(int index)
    118118  {
    119119    try
     
    129129
    130130  @Override
    131   public int aref(int index) throws ConditionThrowable
     131  public int aref(int index)
    132132  {
    133133    try
     
    144144
    145145  @Override
    146   public LispObject AREF(int index) throws ConditionThrowable
     146  public LispObject AREF(int index)
    147147  {
    148148    try
     
    158158
    159159  @Override
    160   public LispObject AREF(LispObject index) throws ConditionThrowable
     160  public LispObject AREF(LispObject index)
    161161  {
    162162          int idx = Fixnum.getValue(index);
     
    173173
    174174  @Override
    175   public void aset(int index, int n) throws ConditionThrowable
     175  public void aset(int index, int n)
    176176  {
    177177    try
     
    186186
    187187  @Override
    188   public void aset(int index, LispObject value) throws ConditionThrowable
     188  public void aset(int index, LispObject value)
    189189  {
    190190    try
     
    199199
    200200  @Override
    201   public LispObject subseq(int start, int end) throws ConditionThrowable
     201  public LispObject subseq(int start, int end)
    202202  {
    203203    BasicVector_UnsignedByte8 v = new BasicVector_UnsignedByte8(end - start);
     
    216216
    217217  @Override
    218   public void fill(LispObject obj) throws ConditionThrowable
     218  public void fill(LispObject obj)
    219219  {
    220220    byte b = coerceLispObjectToJavaByte(obj);
     
    224224
    225225  @Override
    226   public void shrink(int n) throws ConditionThrowable
     226  public void shrink(int n)
    227227  {
    228228    if (n < capacity)
     
    240240
    241241  @Override
    242   public LispObject reverse() throws ConditionThrowable
     242  public LispObject reverse()
    243243  {
    244244    BasicVector_UnsignedByte8 result = new BasicVector_UnsignedByte8(capacity);
     
    250250
    251251  @Override
    252   public LispObject nreverse() throws ConditionThrowable
     252  public LispObject nreverse()
    253253  {
    254254    int i = 0;
     
    269269                                     LispObject initialElement,
    270270                                     LispObject initialContents)
    271     throws ConditionThrowable
     271
    272272  {
    273273    if (initialContents != null)
  • trunk/abcl/src/org/armedbear/lisp/Bignum.java

    r11754 r12254  
    113113
    114114  @Override
    115   public LispObject typep(LispObject type) throws ConditionThrowable
     115  public LispObject typep(LispObject type)
    116116  {
    117117    if (type instanceof Symbol)
     
    222222
    223223  @Override
    224   public boolean equalp(LispObject obj) throws ConditionThrowable
     224  public boolean equalp(LispObject obj)
    225225  {
    226226    if (obj instanceof Bignum)
     
    254254
    255255  @Override
    256   public boolean evenp() throws ConditionThrowable
     256  public boolean evenp()
    257257  {
    258258    return !value.testBit(0);
     
    260260
    261261  @Override
    262   public boolean oddp() throws ConditionThrowable
     262  public boolean oddp()
    263263  {
    264264    return value.testBit(0);
     
    296296
    297297  @Override
    298   public float floatValue() throws ConditionThrowable
     298  public float floatValue()
    299299  {
    300300    float f = value.floatValue();
     
    306306
    307307  @Override
    308   public double doubleValue() throws ConditionThrowable
     308  public double doubleValue()
    309309  {
    310310    double d = value.doubleValue();
     
    315315  }
    316316
    317   public static BigInteger getValue(LispObject obj) throws ConditionThrowable
     317  public static BigInteger getValue(LispObject obj)
    318318  {
    319319         
     
    340340
    341341  @Override
    342   public LispObject add(int n) throws ConditionThrowable
     342  public LispObject add(int n)
    343343  {
    344344    return number(value.add(BigInteger.valueOf(n)));
     
    346346
    347347  @Override
    348   public LispObject add(LispObject obj) throws ConditionThrowable
     348  public LispObject add(LispObject obj)
    349349  {
    350350    if (obj instanceof Fixnum)
     
    372372
    373373  @Override
    374   public LispObject subtract(LispObject obj) throws ConditionThrowable
     374  public LispObject subtract(LispObject obj)
    375375  {
    376376    if (obj instanceof Fixnum)
     
    399399
    400400  @Override
    401   public LispObject multiplyBy(int n) throws ConditionThrowable
     401  public LispObject multiplyBy(int n)
    402402  {
    403403    if (n == 0)
     
    409409
    410410  @Override
    411   public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
     411  public LispObject multiplyBy(LispObject obj)
    412412  {
    413413    if (obj instanceof Fixnum)
     
    441441
    442442  @Override
    443   public LispObject divideBy(LispObject obj) throws ConditionThrowable
     443  public LispObject divideBy(LispObject obj)
    444444  {
    445445    if (obj instanceof Fixnum)
     
    470470
    471471  @Override
    472   public boolean isEqualTo(LispObject obj) throws ConditionThrowable
     472  public boolean isEqualTo(LispObject obj)
    473473  {
    474474    if (obj instanceof Bignum)
     
    486486
    487487  @Override
    488   public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
     488  public boolean isNotEqualTo(LispObject obj)
    489489  {
    490490    if (obj instanceof Bignum)
     
    502502
    503503  @Override
    504   public boolean isLessThan(LispObject obj) throws ConditionThrowable
     504  public boolean isLessThan(LispObject obj)
    505505  {
    506506    if (obj instanceof Fixnum)
     
    523523
    524524  @Override
    525   public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
     525  public boolean isGreaterThan(LispObject obj)
    526526  {
    527527    if (obj instanceof Fixnum)
     
    544544
    545545  @Override
    546   public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
     546  public boolean isLessThanOrEqualTo(LispObject obj)
    547547  {
    548548    if (obj instanceof Fixnum)
     
    565565
    566566  @Override
    567   public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
     567  public boolean isGreaterThanOrEqualTo(LispObject obj)
    568568  {
    569569    if (obj instanceof Fixnum)
     
    586586
    587587  @Override
    588   public LispObject truncate(LispObject obj) throws ConditionThrowable
     588  public LispObject truncate(LispObject obj)
    589589  {
    590590    final LispThread thread = LispThread.currentThread();
     
    648648
    649649  @Override
    650   public LispObject ash(LispObject obj) throws ConditionThrowable
     650  public LispObject ash(LispObject obj)
    651651  {
    652652    BigInteger n = value;
     
    681681
    682682  @Override
    683   public LispObject LOGAND(int n) throws ConditionThrowable
     683  public LispObject LOGAND(int n)
    684684  {
    685685    if (n >= 0)
     
    690690
    691691  @Override
    692   public LispObject LOGAND(LispObject obj) throws ConditionThrowable
     692  public LispObject LOGAND(LispObject obj)
    693693  {
    694694    if (obj instanceof Fixnum)
     
    710710
    711711  @Override
    712   public LispObject LOGIOR(int n) throws ConditionThrowable
     712  public LispObject LOGIOR(int n)
    713713  {
    714714    return number(value.or(BigInteger.valueOf(n)));
     
    716716
    717717  @Override
    718   public LispObject LOGIOR(LispObject obj) throws ConditionThrowable
     718  public LispObject LOGIOR(LispObject obj)
    719719  {
    720720    if (obj instanceof Fixnum)
     
    733733
    734734  @Override
    735   public LispObject LOGXOR(int n) throws ConditionThrowable
     735  public LispObject LOGXOR(int n)
    736736  {
    737737    return number(value.xor(BigInteger.valueOf(n)));
     
    739739
    740740  @Override
    741   public LispObject LOGXOR(LispObject obj) throws ConditionThrowable
     741  public LispObject LOGXOR(LispObject obj)
    742742  {
    743743    final BigInteger n;
     
    766766
    767767  @Override
    768   public String writeToString() throws ConditionThrowable
     768  public String writeToString()
    769769  {
    770770    final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java

    r11754 r12254  
    3838    private final Stream[] streams;
    3939
    40     private BroadcastStream(Stream[] streams) throws ConditionThrowable
     40    private BroadcastStream(Stream[] streams)
    4141    {
    4242        this.streams = streams;
     
    7373
    7474    @Override
    75     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     75    public LispObject typep(LispObject typeSpecifier)
    7676    {
    7777        if (typeSpecifier == Symbol.BROADCAST_STREAM)
     
    8383
    8484    @Override
    85     public LispObject listen() throws ConditionThrowable
     85    public LispObject listen()
    8686    {
    8787        notSupported();
     
    9191
    9292    @Override
    93     public LispObject fileLength() throws ConditionThrowable
     93    public LispObject fileLength()
    9494    {
    9595        if (streams.length > 0)
     
    100100
    101101    @Override
    102     public LispObject fileStringLength(LispObject arg) throws ConditionThrowable
     102    public LispObject fileStringLength(LispObject arg)
    103103    {
    104104        if (streams.length > 0)
     
    110110    // Returns -1 at end of file.
    111111    @Override
    112     protected int _readChar() throws ConditionThrowable
     112    protected int _readChar()
    113113    {
    114114        notSupported();
     
    118118
    119119    @Override
    120     protected void _unreadChar(int n) throws ConditionThrowable
    121     {
    122         notSupported();
    123     }
    124 
    125     @Override
    126     protected boolean _charReady() throws ConditionThrowable
     120    protected void _unreadChar(int n)
     121    {
     122        notSupported();
     123    }
     124
     125    @Override
     126    protected boolean _charReady()
    127127    {
    128128        notSupported();
     
    132132
    133133    @Override
    134     public void _writeChar(char c) throws ConditionThrowable
     134    public void _writeChar(char c)
    135135    {
    136136        for (int i = 0; i < streams.length; i++)
     
    140140    @Override
    141141    public void _writeChars(char[] chars, int start, int end)
    142         throws ConditionThrowable
     142
    143143    {
    144144        for (int i = 0; i < streams.length; i++)
     
    147147
    148148    @Override
    149     public void _writeString(String s) throws ConditionThrowable
     149    public void _writeString(String s)
    150150    {
    151151        for (int i = 0; i < streams.length; i++)
     
    154154
    155155    @Override
    156     public void _writeLine(String s) throws ConditionThrowable
     156    public void _writeLine(String s)
    157157    {
    158158        for (int i = 0; i < streams.length; i++)
     
    162162    // Reads an 8-bit byte.
    163163    @Override
    164     public int _readByte() throws ConditionThrowable
     164    public int _readByte()
    165165    {
    166166        notSupported();
     
    171171    // Writes an 8-bit byte.
    172172    @Override
    173     public void _writeByte(int n) throws ConditionThrowable
     173    public void _writeByte(int n)
    174174    {
    175175        for (int i = 0; i < streams.length; i++)
     
    178178
    179179    @Override
    180     public void _finishOutput() throws ConditionThrowable
     180    public void _finishOutput()
    181181    {
    182182        for (int i = 0; i < streams.length; i++)
     
    185185
    186186    @Override
    187     public void _clearInput() throws ConditionThrowable
    188     {
    189         notSupported();
    190     }
    191 
    192     @Override
    193     protected long _getFilePosition() throws ConditionThrowable
     187    public void _clearInput()
     188    {
     189        notSupported();
     190    }
     191
     192    @Override
     193    protected long _getFilePosition()
    194194    {
    195195        if (streams.length == 0)
     
    200200
    201201    @Override
    202     protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
     202    protected boolean _setFilePosition(LispObject arg)
    203203    {
    204204        return false;
     
    206206
    207207    @Override
    208     public void _close() throws ConditionThrowable
     208    public void _close()
    209209    {
    210210        setOpen(false);
    211211    }
    212212
    213     private void notSupported() throws ConditionThrowable
     213    private void notSupported()
    214214    {
    215215        error(new TypeError("Operation is not supported for streams of type BROADCAST-STREAM."));
     
    227227    {
    228228        @Override
    229         public LispObject execute() throws ConditionThrowable
     229        public LispObject execute()
    230230        {
    231231            return new BroadcastStream(new Stream[0]);
    232232        }
    233233        @Override
    234         public LispObject execute(LispObject[] args) throws ConditionThrowable
     234        public LispObject execute(LispObject[] args)
    235235        {
    236236            Stream[] streams = new Stream[args.length];
     
    256256    {
    257257        @Override
    258         public LispObject execute(LispObject arg) throws ConditionThrowable
     258        public LispObject execute(LispObject arg)
    259259        {
    260260            if (arg instanceof BroadcastStream) {
  • trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java

    r12105 r12254  
    5454
    5555  @Override
    56   public LispObject typep(LispObject type) throws ConditionThrowable
     56  public LispObject typep(LispObject type)
    5757  {
    5858    if (type == Symbol.BUILT_IN_CLASS)
     
    6464
    6565  @Override
    66   public LispObject getDescription() throws ConditionThrowable
     66  public LispObject getDescription()
    6767  {
    6868    return new SimpleString(writeToString());
     
    7070
    7171  @Override
    72   public String writeToString() throws ConditionThrowable
     72  public String writeToString()
    7373  {
    7474    FastStringBuffer sb = new FastStringBuffer("#<BUILT-IN-CLASS ");
  • trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java

    r11754 r12254  
    6262
    6363    @Override
    64     public LispObject typep(LispObject type) throws ConditionThrowable
     64    public LispObject typep(LispObject type)
    6565    {
    6666        return super.typep(type); //TODO
     
    6868
    6969    @Override
    70     protected long _getFilePosition() throws ConditionThrowable
     70    protected long _getFilePosition()
    7171    {
    7272        if (elementType == NIL)
     
    7575    }
    7676
    77     public byte[] getByteArray() throws ConditionThrowable
     77    public byte[] getByteArray()
    7878    {
    7979        if (elementType == NIL) {
     
    9898
    9999        @Override
    100         public LispObject execute() throws ConditionThrowable {
     100        public LispObject execute() {
    101101            return new ByteArrayOutputStream();
    102102        }
    103103
    104104        @Override
    105         public LispObject execute(LispObject arg) throws ConditionThrowable
     105        public LispObject execute(LispObject arg)
    106106        {
    107107            return new ByteArrayOutputStream(arg);
     
    116116    {
    117117        @Override
    118         public LispObject execute(LispObject arg) throws ConditionThrowable
     118        public LispObject execute(LispObject arg)
    119119        {
    120120            if (arg instanceof ByteArrayOutputStream) {
  • trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java

    r11488 r12254  
    3838    boolean virgin = true;
    3939
    40     public CapitalizeFirstStream(Stream target) throws ConditionThrowable
     40    public CapitalizeFirstStream(Stream target)
    4141    {
    4242        super(target);
     
    4444
    4545    @Override
    46     public void _writeChar(char c) throws ConditionThrowable
     46    public void _writeChar(char c)
    4747    {
    4848        if (virgin) {
     
    5757
    5858    @Override
    59     public void _writeString(String s) throws ConditionThrowable
     59    public void _writeString(String s)
    6060    {
    6161        final int length = s.length();
     
    6565
    6666    @Override
    67     public void _writeLine(String s) throws ConditionThrowable
     67    public void _writeLine(String s)
    6868    {
    6969        _writeString(s);
  • trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java

    r11488 r12254  
    3838    private boolean inWord;
    3939
    40     public CapitalizeStream(Stream target) throws ConditionThrowable
     40    public CapitalizeStream(Stream target)
    4141    {
    4242        super(target);
     
    4444
    4545    @Override
    46     public void _writeChar(char c) throws ConditionThrowable
     46    public void _writeChar(char c)
    4747    {
    4848        if (inWord) {
     
    6767
    6868    @Override
    69     public void _writeString(String s) throws ConditionThrowable
     69    public void _writeString(String s)
    7070    {
    7171        final int limit = s.length();
     
    7575
    7676    @Override
    77     public void _writeLine(String s) throws ConditionThrowable
     77    public void _writeLine(String s)
    7878    {
    7979        target._writeString(s);
  • trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java

    r11488 r12254  
    3939
    4040    protected CaseFrobStream(Stream target)
    41         throws ConditionThrowable
     41
    4242    {
    4343        Debug.assertTrue(target.isCharacterOutputStream());
     
    4646
    4747    @Override
    48     public LispObject getElementType() throws ConditionThrowable
     48    public LispObject getElementType()
    4949    {
    5050        return target.getElementType();
     
    6464
    6565    @Override
    66     public LispObject typep(LispObject type) throws ConditionThrowable
     66    public LispObject typep(LispObject type)
    6767    {
    6868        if (type == Symbol.CASE_FROB_STREAM)
     
    8686
    8787    @Override
    88     public boolean isCharacterInputStream() throws ConditionThrowable
    89     {
    90         return false;
    91     }
    92 
    93     @Override
    94     public boolean isBinaryInputStream() throws ConditionThrowable
    95     {
    96         return false;
    97     }
    98 
    99     @Override
    100     public boolean isCharacterOutputStream() throws ConditionThrowable
     88    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()
    101101    {
    102102        return true;
     
    104104
    105105    @Override
    106     public boolean isBinaryOutputStream() throws ConditionThrowable
     106    public boolean isBinaryOutputStream()
    107107    {
    108108        return false;
     
    123123    // Returns -1 at end of file.
    124124    @Override
    125     protected int _readChar() throws ConditionThrowable
     125    protected int _readChar()
    126126    {
    127127        notSupported();
     
    131131
    132132    @Override
    133     protected void _unreadChar(int n) throws ConditionThrowable
    134     {
    135         notSupported();
    136     }
    137 
    138     @Override
    139     protected boolean _charReady() throws ConditionThrowable
     133    protected void _unreadChar(int n)
     134    {
     135        notSupported();
     136    }
     137
     138    @Override
     139    protected boolean _charReady()
    140140    {
    141141        notSupported();
     
    146146    @Override
    147147    public void _writeChars(char[] chars, int start, int end)
    148         throws ConditionThrowable
     148
    149149    {
    150150        _writeString(new String(chars, start, end));
     
    153153    // Reads an 8-bit byte.
    154154    @Override
    155     public int _readByte() throws ConditionThrowable
     155    public int _readByte()
    156156    {
    157157        notSupported();
     
    162162    // Writes an 8-bit byte.
    163163    @Override
    164     public void _writeByte(int n) throws ConditionThrowable
    165     {
    166         notSupported();
    167     }
    168 
    169     @Override
    170     public void _finishOutput() throws ConditionThrowable
     164    public void _writeByte(int n)
     165    {
     166        notSupported();
     167    }
     168
     169    @Override
     170    public void _finishOutput()
    171171    {
    172172        target._finishOutput();
     
    174174
    175175    @Override
    176     public void _clearInput() throws ConditionThrowable
    177     {
    178         notSupported();
    179     }
    180 
    181     @Override
    182     public LispObject close(LispObject abort) throws ConditionThrowable
     176    public void _clearInput()
     177    {
     178        notSupported();
     179    }
     180
     181    @Override
     182    public LispObject close(LispObject abort)
    183183    {
    184184        setOpen(false);
     
    187187
    188188    @Override
    189     public LispObject listen() throws ConditionThrowable
     189    public LispObject listen()
    190190    {
    191191        notSupported();
     
    195195
    196196    @Override
    197     public LispObject terpri() throws ConditionThrowable
     197    public LispObject terpri()
    198198    {
    199199        return target.terpri();
     
    201201
    202202    @Override
    203     public LispObject freshLine() throws ConditionThrowable
     203    public LispObject freshLine()
    204204    {
    205205        return target.freshLine();
     
    212212    }
    213213
    214     private void notSupported() throws ConditionThrowable
     214    private void notSupported()
    215215    {
    216216        error(new TypeError("Operation is not supported for streams of type CASE-FROB-STREAM."));
     
    223223        @Override
    224224        public LispObject execute(LispObject first, LispObject second)
    225             throws ConditionThrowable
     225
    226226        {
    227227            Stream target = checkCharacterOutputStream(first);
  • trunk/abcl/src/org/armedbear/lisp/CellError.java

    r11539 r12254  
    3636public class CellError extends LispError
    3737{
    38     protected CellError(LispClass cls) throws ConditionThrowable
     38    protected CellError(LispClass cls)
    3939    {
    4040        super(cls);
    4141    }
    4242
    43     public CellError(LispObject initArgs) throws ConditionThrowable
     43    public CellError(LispObject initArgs)
    4444    {
    4545        super(StandardClass.CELL_ERROR);
     
    4848
    4949    @Override
    50     protected void initialize(LispObject initArgs) throws ConditionThrowable
     50    protected void initialize(LispObject initArgs)
    5151    {
    5252        super.initialize(initArgs);
     
    6464    }
    6565
    66     public final LispObject getCellName() throws ConditionThrowable
     66    public final LispObject getCellName()
    6767    {
    6868        return getInstanceSlotValue(Symbol.NAME);
    6969    }
    7070
    71     protected final void setCellName(LispObject name) throws ConditionThrowable
     71    protected final void setCellName(LispObject name)
    7272    {
    7373        setInstanceSlotValue(Symbol.NAME, name);
     
    8787
    8888    @Override
    89     public LispObject typep(LispObject type) throws ConditionThrowable
     89    public LispObject typep(LispObject type)
    9090    {
    9191        if (type == Symbol.CELL_ERROR)
     
    9797
    9898    @Override
    99     public String writeToString() throws ConditionThrowable
     99    public String writeToString()
    100100    {
    101101        if (Symbol.PRINT_ESCAPE.symbolValue() == NIL)
  • trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java

    r11754 r12254  
    4141    {
    4242        @Override
    43         public LispObject execute() throws ConditionThrowable
    44         {
    45             return error(new WrongNumberOfArgumentsException(this));
    46         }
    47         @Override
    48         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    5757        {
    5858            return LispCharacter.getValue(first) == LispCharacter.getValue(second) ? T : NIL;
    5959        }
    6060        @Override
    61         public LispObject execute(LispObject[] array) throws ConditionThrowable
     61        public LispObject execute(LispObject[] array)
    6262        {
    6363            final int length = array.length;
     
    7676    {
    7777        @Override
    78         public LispObject execute() throws ConditionThrowable
    79         {
    80             return error(new WrongNumberOfArgumentsException(this));
    81         }
    82         @Override
    83         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    9292        {
    9393            final char c1, c2;
     
    103103        }
    104104        @Override
    105         public LispObject execute(LispObject[] array) throws ConditionThrowable
     105        public LispObject execute(LispObject[] array)
    106106        {
    107107            final int length = array.length;
     
    126126    {
    127127        @Override
    128         public LispObject execute() throws ConditionThrowable
    129         {
    130             return error(new WrongNumberOfArgumentsException(this));
    131         }
    132         @Override
    133         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    142142        {
    143143            char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
     
    146146        }
    147147        @Override
    148         public LispObject execute(LispObject[] array) throws ConditionThrowable
     148        public LispObject execute(LispObject[] array)
    149149        {
    150150            final int length = array.length;
     
    165165    {
    166166        @Override
    167         public LispObject execute() throws ConditionThrowable
    168         {
    169             return error(new WrongNumberOfArgumentsException(this));
    170         }
    171         @Override
    172         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    181181        {
    182182            char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
     
    185185        }
    186186        @Override
    187         public LispObject execute(LispObject[] array) throws ConditionThrowable
     187        public LispObject execute(LispObject[] array)
    188188        {
    189189            final int length = array.length;
     
    204204    {
    205205        @Override
    206         public LispObject execute() throws ConditionThrowable
    207         {
    208             return error(new WrongNumberOfArgumentsException(this));
    209         }
    210         @Override
    211         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    220220        {
    221221            return LispCharacter.getValue(first) < LispCharacter.getValue(second) ? T : NIL;
    222222       }
    223223        @Override
    224         public LispObject execute(LispObject[] args) throws ConditionThrowable
     224        public LispObject execute(LispObject[] args)
    225225        {
    226226            final int length = args.length;
     
    242242    {
    243243        @Override
    244         public LispObject execute() throws ConditionThrowable
    245         {
    246             return error(new WrongNumberOfArgumentsException(this));
    247         }
    248         @Override
    249         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    258258        {
    259259            return LispCharacter.getValue(first) <= LispCharacter.getValue(second) ? T : NIL;
     
    262262        public LispObject execute(LispObject first, LispObject second,
    263263                                  LispObject third)
    264             throws ConditionThrowable
     264
    265265        {
    266266            if (LispCharacter.getValue(first) > LispCharacter.getValue(second))
     
    271271        }
    272272        @Override
    273         public LispObject execute(LispObject[] args) throws ConditionThrowable
     273        public LispObject execute(LispObject[] args)
    274274        {
    275275            final int length = args.length;
     
    291291    {
    292292        @Override
    293         public LispObject execute() throws ConditionThrowable
    294         {
    295             return error(new WrongNumberOfArgumentsException(this));
    296         }
    297         @Override
    298         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    307307        {
    308308            char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
     
    311311        }
    312312        @Override
    313         public LispObject execute(LispObject[] array) throws ConditionThrowable
     313        public LispObject execute(LispObject[] array)
    314314        {
    315315            final int length = array.length;
     
    330330    {
    331331        @Override
    332         public LispObject execute() throws ConditionThrowable
    333         {
    334             return error(new WrongNumberOfArgumentsException(this));
    335         }
    336         @Override
    337         public LispObject execute(LispObject arg) throws ConditionThrowable
    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             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
    346346        {
    347347            char c1 = LispCharacter.toUpperCase(LispCharacter.getValue(first));
     
    350350        }
    351351        @Override
    352         public LispObject execute(LispObject[] array) throws ConditionThrowable
     352        public LispObject execute(LispObject[] array)
    353353        {
    354354            final int length = array.length;
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r11778 r12254  
    8585
    8686  public Closure(LispObject lambdaExpression, Environment env)
    87     throws ConditionThrowable
     87
    8888  {
    8989    this(null, lambdaExpression, env);
     
    9292  public Closure(final LispObject name, final LispObject lambdaExpression,
    9393                 final Environment env)
    94     throws ConditionThrowable
     94
    9595  {
    9696    super(name, lambdaExpression.cadr());
     
    339339
    340340  private static final void invalidParameter(LispObject obj)
    341     throws ConditionThrowable
     341
    342342  {
    343343    error(new LispError(obj.writeToString() +
     
    346346
    347347  @Override
    348   public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     348  public LispObject typep(LispObject typeSpecifier)
    349349  {
    350350    if (typeSpecifier == Symbol.COMPILED_FUNCTION)
     
    373373
    374374  @Override
    375   public LispObject execute() throws ConditionThrowable
     375  public LispObject execute()
    376376  {
    377377    if (arity == 0)
     
    385385   
    386386  private final LispObject bindParametersAndExecute(LispObject... objects)
    387   throws ConditionThrowable
     387
    388388  {
    389389    final LispThread thread = LispThread.currentThread();
     
    413413                                            LispThread thread,
    414414                                            LispObject[] objects)
    415   throws ConditionThrowable
     415
    416416  {
    417417    // &whole and &environment before anything
     
    425425
    426426  public final LispObject invokeArrayExecute(LispObject... objects)
    427   throws ConditionThrowable
     427
    428428  {
    429429    return execute(objects);
     
    431431
    432432  @Override
    433   public LispObject execute(LispObject arg) throws ConditionThrowable
     433  public LispObject execute(LispObject arg)
    434434  {
    435435    if (minArgs == 1)
     
    445445  @Override
    446446  public LispObject execute(LispObject first, LispObject second)
    447     throws ConditionThrowable
     447
    448448  {
    449449    if (minArgs == 2)
     
    460460  public LispObject execute(LispObject first, LispObject second,
    461461                            LispObject third)
    462     throws ConditionThrowable
     462
    463463  {
    464464    if (minArgs == 3)
     
    475475  public LispObject execute(LispObject first, LispObject second,
    476476                            LispObject third, LispObject fourth)
    477     throws ConditionThrowable
     477
    478478  {
    479479    if (minArgs == 4)
     
    491491                            LispObject third, LispObject fourth,
    492492                            LispObject fifth)
    493     throws ConditionThrowable
     493
    494494  {
    495495    if (minArgs == 5)
     
    508508                            LispObject third, LispObject fourth,
    509509                            LispObject fifth, LispObject sixth)
    510     throws ConditionThrowable
     510
    511511  {
    512512    if (minArgs == 6)
     
    527527                            LispObject fifth, LispObject sixth,
    528528                            LispObject seventh)
    529     throws ConditionThrowable
     529
    530530  {
    531531    if (minArgs == 7)
     
    546546                            LispObject fifth, LispObject sixth,
    547547                            LispObject seventh, LispObject eighth)
    548     throws ConditionThrowable
     548
    549549  {
    550550    if (minArgs == 8)
     
    561561
    562562  private final void declareFreeSpecials(Environment ext)
    563     throws ConditionThrowable
     563
    564564  {
    565565    LispObject s = specials;
     
    579579
    580580  @Override
    581   public LispObject execute(LispObject[] args) throws ConditionThrowable
     581  public LispObject execute(LispObject[] args)
    582582  {
    583583    final LispThread thread = LispThread.currentThread();
     
    611611
    612612  protected final LispObject[] processArgs(LispObject[] args, LispThread thread)
    613     throws ConditionThrowable
     613
    614614  {
    615615    if (optionalParameters.length == 0 && keywordParameters.length == 0)
     
    872872  // No optional or keyword parameters.
    873873  protected final LispObject[] fastProcessArgs(LispObject[] args)
    874     throws ConditionThrowable
     874
    875875  {
    876876    final int argsLength = args.length;
     
    950950                                           Environment env,
    951951                                           LispThread thread)
    952     throws ConditionThrowable
     952
    953953  {
    954954    for (Parameter parameter : parameters)
     
    966966
    967967  private final void bindAuxVars(Environment env, LispThread thread)
    968     throws ConditionThrowable
     968
    969969  {
    970970    // Aux variable processing is analogous to LET* processing.
     
    10031003
    10041004    public Parameter(Symbol var, LispObject initForm, int type)
    1005       throws ConditionThrowable
     1005
    10061006    {
    10071007      this.var = var;
     
    10161016    public Parameter(Symbol var, LispObject initForm, LispObject svar,
    10171017                     int type)
    1018       throws ConditionThrowable
     1018
    10191019    {
    10201020      this.var = var;
     
    10291029    public Parameter(Symbol keyword, Symbol var, LispObject initForm,
    10301030                     LispObject svar)
    1031       throws ConditionThrowable
     1031
    10321032    {
    10331033      this.var = var;
     
    10591059
    10601060    private static final LispObject processInitForm(LispObject initForm)
    1061       throws ConditionThrowable
     1061
    10621062    {
    10631063      if (initForm.constantp())
     
    10811081    {
    10821082      @Override
    1083       public LispObject execute(LispObject arg) throws ConditionThrowable
     1083      public LispObject execute(LispObject arg)
    10841084      {
    10851085        Closure closure = new Closure(list(Symbol.LAMBDA, arg, NIL), new Environment());
  • trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java

    r12180 r12254  
    4141
    4242  public CompiledClosure(LispObject lambdaList)
    43     throws ConditionThrowable
     43
    4444  {
    4545    super(list(Symbol.LAMBDA, lambdaList), null);
     
    6363
    6464  @Override
    65   public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     65  public LispObject typep(LispObject typeSpecifier)
    6666  {
    6767    if (typeSpecifier == Symbol.COMPILED_FUNCTION)
     
    7070  }
    7171
    72   private final LispObject notImplemented() throws ConditionThrowable
     72  private final LispObject notImplemented()
    7373  {
    7474    return error(new WrongNumberOfArgumentsException(this));
     
    7777
    7878  // Zero args.
    79   public LispObject execute() throws ConditionThrowable
     79  public LispObject execute()
    8080  {
    8181    LispObject[] args = new LispObject[0];
     
    8585  // One arg.
    8686  public LispObject execute( LispObject first)
    87     throws ConditionThrowable
     87
    8888  {
    8989    LispObject[] args = new LispObject[1];
     
    9595  public LispObject execute( LispObject first,
    9696                            LispObject second)
    97     throws ConditionThrowable
     97
    9898  {
    9999    LispObject[] args = new LispObject[2];
     
    106106  public LispObject execute( LispObject first,
    107107                            LispObject second, LispObject third)
    108     throws ConditionThrowable
     108
    109109  {
    110110    LispObject[] args = new LispObject[3];
     
    119119                            LispObject second, LispObject third,
    120120                            LispObject fourth)
    121     throws ConditionThrowable
     121
    122122  {
    123123    LispObject[] args = new LispObject[4];
     
    133133                            LispObject second, LispObject third,
    134134                            LispObject fourth, LispObject fifth)
    135     throws ConditionThrowable
     135
    136136  {
    137137    LispObject[] args = new LispObject[5];
     
    149149                            LispObject fourth, LispObject fifth,
    150150                            LispObject sixth)
    151     throws ConditionThrowable
     151
    152152  {
    153153    LispObject[] args = new LispObject[6];
     
    166166                            LispObject fourth, LispObject fifth,
    167167                            LispObject sixth, LispObject seventh)
    168     throws ConditionThrowable
     168
    169169  {
    170170    LispObject[] args = new LispObject[7];
     
    185185                            LispObject sixth, LispObject seventh,
    186186                            LispObject eighth)
    187     throws ConditionThrowable
     187
    188188  {
    189189    LispObject[] args = new LispObject[8];
     
    201201  // Arg array.
    202202  public LispObject execute(LispObject[] args)
    203     throws ConditionThrowable
     203
    204204  {
    205205    return notImplemented();
     
    211211  {
    212212    @Override
    213     public LispObject execute(LispObject arg) throws ConditionThrowable
     213    public LispObject execute(LispObject arg)
    214214    {
    215215      String namestring = null;
     
    237237  {
    238238    @Override
    239     public LispObject execute(LispObject arg) throws ConditionThrowable
     239    public LispObject execute(LispObject arg)
    240240    {
    241241      if (arg instanceof Closure)
  • trunk/abcl/src/org/armedbear/lisp/CompilerError.java

    r11488 r12254  
    3636public class CompilerError extends Condition
    3737{
    38     public CompilerError(LispObject initArgs) throws ConditionThrowable
     38    public CompilerError(LispObject initArgs)
    3939    {
    4040        super(initArgs);
     
    5454
    5555    @Override
    56     public LispObject typep(LispObject type) throws ConditionThrowable
     56    public LispObject typep(LispObject type)
    5757    {
    5858        if (type == Symbol.COMPILER_ERROR)
  • trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java

    r11488 r12254  
    3636public class CompilerUnsupportedFeatureError extends Condition
    3737{
    38     public CompilerUnsupportedFeatureError(LispObject initArgs) throws ConditionThrowable
     38    public CompilerUnsupportedFeatureError(LispObject initArgs)
    3939    {
    4040        super(initArgs);
     
    5454
    5555    @Override
    56     public LispObject typep(LispObject type) throws ConditionThrowable
     56    public LispObject typep(LispObject type)
    5757    {
    5858        if (type == Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR)
  • trunk/abcl/src/org/armedbear/lisp/Complex.java

    r11954 r12254  
    4747  public static LispObject getInstance(LispObject realpart,
    4848                                       LispObject imagpart)
    49     throws ConditionThrowable
     49
    5050  {
    5151    if (!realpart.realp())
     
    9292
    9393  @Override
    94   public LispObject typep(LispObject type) throws ConditionThrowable
     94  public LispObject typep(LispObject type)
    9595  {
    9696    if (type == Symbol.COMPLEX)
     
    137137
    138138  @Override
    139   public boolean equalp(LispObject obj) throws ConditionThrowable
     139  public boolean equalp(LispObject obj)
    140140  {
    141141    if (this == obj)
     
    175175
    176176  @Override
    177   public final LispObject incr() throws ConditionThrowable
     177  public final LispObject incr()
    178178  {
    179179    return new Complex(realpart.add(Fixnum.ONE), imagpart);
     
    181181
    182182  @Override
    183   public final LispObject decr() throws ConditionThrowable
     183  public final LispObject decr()
    184184  {
    185185    return new Complex(realpart.subtract(Fixnum.ONE), imagpart);
     
    187187
    188188  @Override
    189   public LispObject add(LispObject obj) throws ConditionThrowable
     189  public LispObject add(LispObject obj)
    190190  {
    191191    if (obj instanceof Complex)
     
    198198
    199199  @Override
    200   public LispObject subtract(LispObject obj) throws ConditionThrowable
     200  public LispObject subtract(LispObject obj)
    201201  {
    202202    if (obj instanceof Complex)
     
    210210
    211211  @Override
    212   public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
     212  public LispObject multiplyBy(LispObject obj)
    213213  {
    214214    if (obj instanceof Complex)
     
    232232
    233233  @Override
    234   public LispObject divideBy(LispObject obj) throws ConditionThrowable
     234  public LispObject divideBy(LispObject obj)
    235235  {
    236236    if (obj instanceof Complex)
     
    253253
    254254  @Override
    255   public boolean isEqualTo(LispObject obj) throws ConditionThrowable
     255  public boolean isEqualTo(LispObject obj)
    256256  {
    257257    if (obj instanceof Complex)
     
    296296
    297297  @Override
    298   public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
     298  public boolean isNotEqualTo(LispObject obj)
    299299  {
    300300    return !isEqualTo(obj);
     
    302302
    303303  @Override
    304   public LispObject ABS() throws ConditionThrowable
     304  public LispObject ABS()
    305305  {
    306306    if (realpart.zerop())
     
    315315
    316316  @Override
    317   public boolean zerop() throws ConditionThrowable
     317  public boolean zerop()
    318318  {
    319319    return realpart.zerop() && imagpart.zerop();
     
    339339
    340340  @Override
    341   public String writeToString() throws ConditionThrowable
     341  public String writeToString()
    342342  {
    343343    FastStringBuffer sb = new FastStringBuffer("#C(");
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r11714 r12254  
    6060                        LispObject elementType,
    6161                        LispObject initialContents)
    62         throws ConditionThrowable
     62
    6363    {
    6464        this.dimv = dimv;
     
    8686    private int setInitialContents(int axis, int[] dims, LispObject contents,
    8787                                   int index)
    88         throws ConditionThrowable
     88
    8989    {
    9090        if (dims.length == 0) {
     
    154154
    155155    @Override
    156     public int getDimension(int n) throws ConditionThrowable
     156    public int getDimension(int n)
    157157    {
    158158        try {
     
    178178
    179179    @Override
    180     public LispObject arrayDisplacement() throws ConditionThrowable
     180    public LispObject arrayDisplacement()
    181181    {
    182182        LispObject value1, value2;
     
    192192
    193193    @Override
    194     public LispObject AREF(int index) throws ConditionThrowable
     194    public LispObject AREF(int index)
    195195    {
    196196        if (data != null) {
     
    206206
    207207    @Override
    208     public void aset(int index, LispObject newValue) throws ConditionThrowable
     208    public void aset(int index, LispObject newValue)
    209209    {
    210210        if (data != null) {
     
    220220
    221221    @Override
    222     public void fill(LispObject obj) throws ConditionThrowable
     222    public void fill(LispObject obj)
    223223    {
    224224        if (data != null) {
     
    232232
    233233    @Override
    234     public String writeToString() throws ConditionThrowable
     234    public String writeToString()
    235235    {
    236236        return writeToString(dimv);
     
    241241                                              LispObject initialElement,
    242242                                              LispObject initialContents)
    243             throws ConditionThrowable {
     243            {
    244244        if (isAdjustable()) {
    245245            if (initialContents != null)
     
    274274                                              AbstractArray displacedTo,
    275275                                              int displacement)
    276             throws ConditionThrowable {
     276            {
    277277        if (isAdjustable()) {
    278278            for (int i = 0; i < dims.length; i++)
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r11714 r12254  
    5757
    5858    public ComplexArray_UnsignedByte32(int[] dimv, LispObject initialContents)
    59         throws ConditionThrowable
     59
    6060    {
    6161        this.dimv = dimv;
     
    8282    private int setInitialContents(int axis, int[] dims, LispObject contents,
    8383                                   int index)
    84         throws ConditionThrowable
     84
    8585    {
    8686        if (dims.length == 0) {
     
    150150
    151151    @Override
    152     public int getDimension(int n) throws ConditionThrowable
     152    public int getDimension(int n)
    153153    {
    154154        try {
     
    174174
    175175    @Override
    176     public LispObject arrayDisplacement() throws ConditionThrowable
     176    public LispObject arrayDisplacement()
    177177    {
    178178        LispObject value1, value2;
     
    188188
    189189    @Override
    190     public LispObject AREF(int index) throws ConditionThrowable
     190    public LispObject AREF(int index)
    191191    {
    192192        if (data != null) {
     
    202202
    203203    @Override
    204     public void aset(int index, LispObject newValue) throws ConditionThrowable
     204    public void aset(int index, LispObject newValue)
    205205    {
    206206        if (data != null) {
     
    216216
    217217    @Override
    218     public void fill(LispObject obj) throws ConditionThrowable
     218    public void fill(LispObject obj)
    219219    {
    220220        if (data != null) {
     
    228228
    229229    @Override
    230     public String writeToString() throws ConditionThrowable
     230    public String writeToString()
    231231    {
    232232        return writeToString(dimv);
     
    238238                                              LispObject initialElement,
    239239                                              LispObject initialContents)
    240             throws ConditionThrowable {
     240            {
    241241        if (isAdjustable()) {
    242242            if (initialContents != null)
     
    271271                                              AbstractArray displacedTo,
    272272                                              int displacement)
    273             throws ConditionThrowable {
     273            {
    274274        if (isAdjustable()) {
    275275            for (int i = 0; i < dims.length; i++)
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r11714 r12254  
    5454
    5555    public ComplexArray_UnsignedByte8(int[] dimv, LispObject initialContents)
    56         throws ConditionThrowable
     56
    5757    {
    5858        this.dimv = dimv;
     
    7878    private int setInitialContents(int axis, int[] dims, LispObject contents,
    7979                                   int index)
    80         throws ConditionThrowable
     80
    8181    {
    8282        if (dims.length == 0) {
     
    146146
    147147    @Override
    148     public int getDimension(int n) throws ConditionThrowable
     148    public int getDimension(int n)
    149149    {
    150150        try {
     
    170170
    171171    @Override
    172     public LispObject arrayDisplacement() throws ConditionThrowable
     172    public LispObject arrayDisplacement()
    173173    {
    174174        LispObject value1, value2;
     
    184184
    185185    @Override
    186     public LispObject AREF(int index) throws ConditionThrowable
     186    public LispObject AREF(int index)
    187187    {
    188188        if (data != null) {
     
    198198
    199199    @Override
    200     public void aset(int index, LispObject newValue) throws ConditionThrowable
     200    public void aset(int index, LispObject newValue)
    201201    {
    202202        if (data != null) {
     
    212212
    213213    @Override
    214     public void fill(LispObject obj) throws ConditionThrowable
     214    public void fill(LispObject obj)
    215215    {
    216216        if (data != null) {
     
    225225
    226226    @Override
    227     public String writeToString() throws ConditionThrowable
     227    public String writeToString()
    228228    {
    229229        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
     
    240240                                              LispObject initialElement,
    241241                                              LispObject initialContents)
    242             throws ConditionThrowable {
     242            {
    243243        if (isAdjustable()) {
    244244            if (initialContents != null)
     
    273273                                              AbstractArray displacedTo,
    274274                                              int displacement)
    275             throws ConditionThrowable {
     275            {
    276276        if (isAdjustable()) {
    277277            for (int i = 0; i < dims.length; i++)
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11754 r12254  
    4343    private int displacement;
    4444
    45     public ComplexBitVector(int capacity) throws ConditionThrowable
     45    public ComplexBitVector(int capacity)
    4646    {
    4747        this.capacity = capacity;
     
    8585
    8686    @Override
    87     public void setFillPointer(LispObject obj) throws ConditionThrowable
     87    public void setFillPointer(LispObject obj)
    8888    {
    8989        if (obj == T)
     
    109109
    110110    @Override
    111     public LispObject arrayDisplacement() throws ConditionThrowable
     111    public LispObject arrayDisplacement()
    112112    {
    113113        LispObject value1, value2;
     
    129129
    130130    @Override
    131     public LispObject elt(int index) throws ConditionThrowable
     131    public LispObject elt(int index)
    132132    {
    133133        if (index >= length())
     
    137137
    138138    @Override
    139     public LispObject AREF(int index) throws ConditionThrowable
     139    public LispObject AREF(int index)
    140140    {
    141141        if (index < 0 || index >= capacity)
     
    151151
    152152    @Override
    153     protected int getBit(int index) throws ConditionThrowable
     153    protected int getBit(int index)
    154154    {
    155155        if (bits != null) {
     
    161161
    162162    @Override
    163     public void aset(int index, LispObject newValue) throws ConditionThrowable
     163    public void aset(int index, LispObject newValue)
    164164    {
    165165        if (index < 0 || index >= capacity)
     
    188188
    189189    @Override
    190     protected void setBit(int index) throws ConditionThrowable
     190    protected void setBit(int index)
    191191    {
    192192        if (bits != null) {
     
    198198
    199199    @Override
    200     protected void clearBit(int index) throws ConditionThrowable
     200    protected void clearBit(int index)
    201201    {
    202202        if (bits != null) {
     
    208208
    209209    @Override
    210     public void shrink(int n) throws ConditionThrowable
     210    public void shrink(int n)
    211211    {
    212212        if (bits != null) {
     
    237237    // FIXME
    238238    @Override
    239     public void vectorPushExtend(LispObject element) throws ConditionThrowable
     239    public void vectorPushExtend(LispObject element)
    240240    {
    241241        final int fp = getFillPointer();
     
    253253    @Override
    254254    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    255         throws ConditionThrowable
     255
    256256    {
    257257        vectorPushExtend(element);
     
    262262    @Override
    263263    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    264         throws ConditionThrowable
     264
    265265    {
    266266        int ext = Fixnum.getValue(extension);
     
    278278    }
    279279
    280     private final void ensureCapacity(int minCapacity) throws ConditionThrowable
     280    private final void ensureCapacity(int minCapacity)
    281281    {
    282282        if (bits != null) {
     
    321321                                       LispObject initialElement,
    322322                                       LispObject initialContents)
    323         throws ConditionThrowable
     323
    324324    {
    325325        if (bits == null) {
     
    381381    public AbstractVector adjustArray(int size, AbstractArray displacedTo,
    382382                                       int displacement)
    383         throws ConditionThrowable
     383
    384384    {
    385385        capacity = size;
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r12252 r12254  
    9393
    9494  @Override
    95   public void setFillPointer(LispObject obj) throws ConditionThrowable
     95  public void setFillPointer(LispObject obj)
    9696  {
    9797    if (obj == T)
     
    128128
    129129  @Override
    130   public LispObject arrayDisplacement() throws ConditionThrowable
     130  public LispObject arrayDisplacement()
    131131  {
    132132    LispObject value1, value2;
     
    145145
    146146  @Override
    147   public char[] chars() throws ConditionThrowable
     147  public char[] chars()
    148148  {
    149149    if (chars != null)
     
    167167
    168168  @Override
    169   public char[] getStringChars() throws ConditionThrowable
     169  public char[] getStringChars()
    170170  {
    171171    if (fillPointer < 0)
     
    177177
    178178  @Override
    179   public boolean equal(LispObject obj) throws ConditionThrowable
     179  public boolean equal(LispObject obj)
    180180  {
    181181    if (this == obj)
     
    197197
    198198  @Override
    199   public boolean equalp(LispObject obj) throws ConditionThrowable
     199  public boolean equalp(LispObject obj)
    200200  {
    201201    if (this == obj)
     
    224224
    225225  @Override
    226   public LispObject subseq(int start, int end) throws ConditionThrowable
     226  public LispObject subseq(int start, int end)
    227227  {
    228228    SimpleString s = new SimpleString(end - start);
     
    234234
    235235  @Override
    236   public void fill(LispObject obj) throws ConditionThrowable
     236  public void fill(LispObject obj)
    237237  {
    238238    fill(LispCharacter.getValue(obj));
     
    240240
    241241  @Override
    242   public void fill(char c) throws ConditionThrowable
     242  public void fill(char c)
    243243  {
    244244    for (int i = length(); i-- > 0;)
     
    247247
    248248  @Override
    249   public void shrink(int n) throws ConditionThrowable
     249  public void shrink(int n)
    250250  {
    251251    if (chars != null)
     
    291291
    292292  @Override
    293   public LispObject reverse() throws ConditionThrowable
     293  public LispObject reverse()
    294294  {
    295295    int length = length();
     
    302302
    303303  @Override
    304   public LispObject nreverse() throws ConditionThrowable
     304  public LispObject nreverse()
    305305  {
    306306    int i = 0;
     
    318318
    319319  @Override
    320   public String getStringValue() throws ConditionThrowable
     320  public String getStringValue()
    321321  {
    322322    if (fillPointer >= 0)
     
    327327
    328328  @Override
    329   public Object javaInstance() throws ConditionThrowable
     329  public Object javaInstance()
    330330  {
    331331    return new String(chars());
     
    333333
    334334  @Override
    335   public Object javaInstance(Class c) throws ConditionThrowable
     335  public Object javaInstance(Class c)
    336336  {
    337337    return javaInstance();
     
    351351
    352352  @Override
    353   public char charAt(int index) throws ConditionThrowable
     353  public char charAt(int index)
    354354  {
    355355    if (chars != null)
     
    370370
    371371  @Override
    372   public void setCharAt(int index, char c) throws ConditionThrowable
     372  public void setCharAt(int index, char c)
    373373  {
    374374    if (chars != null)
     
    388388
    389389  @Override
    390   public LispObject elt(int index) throws ConditionThrowable
     390  public LispObject elt(int index)
    391391  {
    392392    final int limit = length();
     
    398398  // Ignores fill pointer.
    399399  @Override
    400   public LispObject CHAR(int index) throws ConditionThrowable
     400  public LispObject CHAR(int index)
    401401  {
    402402    return LispCharacter.getInstance(charAt(index));
     
    405405  // Ignores fill pointer.
    406406  @Override
    407   public LispObject AREF(int index) throws ConditionThrowable
     407  public LispObject AREF(int index)
    408408  {
    409409    return LispCharacter.getInstance(charAt(index));
     
    412412  // Ignores fill pointer.
    413413  @Override
    414   public LispObject AREF(LispObject index) throws ConditionThrowable
     414  public LispObject AREF(LispObject index)
    415415  {
    416416    return LispCharacter.getInstance(charAt(Fixnum.getValue(index)));
     
    418418
    419419  @Override
    420   public void aset(int index, LispObject newValue) throws ConditionThrowable
     420  public void aset(int index, LispObject newValue)
    421421  {
    422422      setCharAt(index, LispCharacter.getValue(newValue));
     
    425425  @Override
    426426  public void vectorPushExtend(LispObject element)
    427     throws ConditionThrowable
     427
    428428  {
    429429    if (fillPointer < 0)
     
    445445  @Override
    446446  public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    447     throws ConditionThrowable
     447
    448448  {
    449449    vectorPushExtend(element);
     
    453453  @Override
    454454  public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    455     throws ConditionThrowable
     455
    456456  {
    457457    int ext = Fixnum.getValue(extension);
     
    473473  }
    474474
    475   public final void ensureCapacity(int minCapacity) throws ConditionThrowable
     475  public final void ensureCapacity(int minCapacity)
    476476  {
    477477    if (chars != null)
     
    575575                                     LispObject initialElement,
    576576                                     LispObject initialContents)
    577     throws ConditionThrowable
     577
    578578  {
    579579    if (initialContents != null)
     
    652652                                     AbstractArray displacedTo,
    653653                                     int displacement)
    654     throws ConditionThrowable
     654
    655655  {
    656656    capacity = newCapacity;
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

    r11714 r12254  
    9696
    9797    @Override
    98     public void setFillPointer(LispObject obj) throws ConditionThrowable
     98    public void setFillPointer(LispObject obj)
    9999    {
    100100        if (obj == T)
     
    126126
    127127    @Override
    128     public LispObject arrayDisplacement() throws ConditionThrowable
     128    public LispObject arrayDisplacement()
    129129    {
    130130        LispObject value1, value2;
     
    164164
    165165    @Override
    166     public LispObject elt(int index) throws ConditionThrowable
     166    public LispObject elt(int index)
    167167    {
    168168        final int limit = length();
     
    174174    // Ignores fill pointer.
    175175    @Override
    176     public LispObject AREF(int index) throws ConditionThrowable
     176    public LispObject AREF(int index)
    177177    {
    178178        if (elements != null) {
     
    195195    // FIXME inline
    196196    @Override
    197     public LispObject AREF(LispObject index) throws ConditionThrowable
     197    public LispObject AREF(LispObject index)
    198198    {
    199199        return AREF(Fixnum.getValue(index));
     
    201201
    202202    @Override
    203     public void aset(int index, LispObject newValue) throws ConditionThrowable
     203    public void aset(int index, LispObject newValue)
    204204    {
    205205        if (elements != null) {
     
    220220
    221221    @Override
    222     public LispObject subseq(int start, int end) throws ConditionThrowable
     222    public LispObject subseq(int start, int end)
    223223    {
    224224        SimpleVector v = new SimpleVector(end - start);
     
    235235
    236236    @Override
    237     public void fill(LispObject obj) throws ConditionThrowable
     237    public void fill(LispObject obj)
    238238    {
    239239        for (int i = capacity; i-- > 0;)
     
    242242
    243243    @Override
    244     public void shrink(int n) throws ConditionThrowable
     244    public void shrink(int n)
    245245    {
    246246        if (elements != null) {
     
    259259
    260260    @Override
    261     public LispObject reverse() throws ConditionThrowable
     261    public LispObject reverse()
    262262    {
    263263        int length = length();
     
    270270
    271271    @Override
    272     public LispObject nreverse() throws ConditionThrowable
     272    public LispObject nreverse()
    273273    {
    274274        if (elements != null) {
     
    301301    @Override
    302302    public void vectorPushExtend(LispObject element)
    303         throws ConditionThrowable
     303
    304304    {
    305305        if (fillPointer < 0)
     
    314314    @Override
    315315    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    316         throws ConditionThrowable
     316
    317317    {
    318318        vectorPushExtend(element);
     
    322322    @Override
    323323    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    324         throws ConditionThrowable
     324
    325325    {
    326326        int ext = Fixnum.getValue(extension);
     
    336336    }
    337337
    338     private final void ensureCapacity(int minCapacity) throws ConditionThrowable
     338    private final void ensureCapacity(int minCapacity)
    339339    {
    340340        if (elements != null) {
     
    369369                                       LispObject initialElement,
    370370                                       LispObject initialContents)
    371         throws ConditionThrowable
     371
    372372    {
    373373        if (initialContents != null) {
     
    417417                                       AbstractArray displacedTo,
    418418                                       int displacement)
    419         throws ConditionThrowable
     419
    420420    {
    421421        capacity = newCapacity;
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r11714 r12254  
    9797
    9898    @Override
    99     public void setFillPointer(LispObject obj) throws ConditionThrowable
     99    public void setFillPointer(LispObject obj)
    100100    {
    101101        if (obj == T)
     
    127127
    128128    @Override
    129     public LispObject arrayDisplacement() throws ConditionThrowable
     129    public LispObject arrayDisplacement()
    130130    {
    131131        LispObject value1, value2;
     
    165165
    166166    @Override
    167     public LispObject elt(int index) throws ConditionThrowable
     167    public LispObject elt(int index)
    168168    {
    169169        final int limit = length();
     
    175175    // Ignores fill pointer.
    176176    @Override
    177     public LispObject AREF(int index) throws ConditionThrowable
     177    public LispObject AREF(int index)
    178178    {
    179179        if (elements != null) {
     
    196196    // FIXME inline
    197197    @Override
    198     public LispObject AREF(LispObject index) throws ConditionThrowable
     198    public LispObject AREF(LispObject index)
    199199    {
    200200        return AREF(Fixnum.getValue(index));
     
    202202
    203203    @Override
    204     public void aset(int index, LispObject newValue) throws ConditionThrowable
     204    public void aset(int index, LispObject newValue)
    205205    {
    206206        if (elements != null) {
     
    221221
    222222    @Override
    223     public LispObject subseq(int start, int end) throws ConditionThrowable
     223    public LispObject subseq(int start, int end)
    224224    {
    225225        SimpleVector v = new SimpleVector(end - start);
     
    236236
    237237    @Override
    238     public void fill(LispObject obj) throws ConditionThrowable
     238    public void fill(LispObject obj)
    239239    {
    240240        for (int i = capacity; i-- > 0;)
     
    243243
    244244    @Override
    245     public void shrink(int n) throws ConditionThrowable
     245    public void shrink(int n)
    246246    {
    247247        if (elements != null) {
     
    260260
    261261    @Override
    262     public LispObject reverse() throws ConditionThrowable
     262    public LispObject reverse()
    263263    {
    264264        int length = length();
     
    271271
    272272    @Override
    273     public LispObject nreverse() throws ConditionThrowable
     273    public LispObject nreverse()
    274274    {
    275275        if (elements != null) {
     
    302302    @Override
    303303    public void vectorPushExtend(LispObject element)
    304         throws ConditionThrowable
     304
    305305    {
    306306        if (fillPointer < 0)
     
    316316    @Override
    317317    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    318         throws ConditionThrowable
     318
    319319    {
    320320        vectorPushExtend(element);
     
    324324    @Override
    325325    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    326         throws ConditionThrowable
     326
    327327    {
    328328        int ext = Fixnum.getValue(extension);
     
    338338    }
    339339
    340     private final void ensureCapacity(int minCapacity) throws ConditionThrowable
     340    private final void ensureCapacity(int minCapacity)
    341341    {
    342342        if (elements != null) {
     
    371371                                       LispObject initialElement,
    372372                                       LispObject initialContents)
    373         throws ConditionThrowable
     373
    374374    {
    375375        if (initialContents != null) {
     
    420420                                       AbstractArray displacedTo,
    421421                                       int displacement)
    422         throws ConditionThrowable
     422
    423423    {
    424424        capacity = newCapacity;
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r11714 r12254  
    9595
    9696    @Override
    97     public void setFillPointer(LispObject obj) throws ConditionThrowable
     97    public void setFillPointer(LispObject obj)
    9898    {
    9999        if (obj == T)
     
    125125
    126126    @Override
    127     public LispObject arrayDisplacement() throws ConditionThrowable
     127    public LispObject arrayDisplacement()
    128128    {
    129129        LispObject value1, value2;
     
    163163
    164164    @Override
    165     public LispObject elt(int index) throws ConditionThrowable
     165    public LispObject elt(int index)
    166166    {
    167167        final int limit = length();
     
    173173    // Ignores fill pointer.
    174174    @Override
    175     public LispObject AREF(int index) throws ConditionThrowable
     175    public LispObject AREF(int index)
    176176    {
    177177        if (elements != null) {
     
    194194    // FIXME inline
    195195    @Override
    196     public LispObject AREF(LispObject index) throws ConditionThrowable
     196    public LispObject AREF(LispObject index)
    197197    {
    198198        return AREF(Fixnum.getValue(index));
     
    200200
    201201    @Override
    202     public void aset(int index, int n) throws ConditionThrowable
     202    public void aset(int index, int n)
    203203    {
    204204        if (elements != null) {
     
    219219
    220220    @Override
    221     public void aset(int index, LispObject newValue) throws ConditionThrowable
     221    public void aset(int index, LispObject newValue)
    222222    {
    223223        if (elements != null) {
     
    233233
    234234    @Override
    235     public LispObject subseq(int start, int end) throws ConditionThrowable
     235    public LispObject subseq(int start, int end)
    236236    {
    237237        SimpleVector v = new SimpleVector(end - start);
     
    248248
    249249    @Override
    250     public void fill(LispObject obj) throws ConditionThrowable
     250    public void fill(LispObject obj)
    251251    {
    252252        byte b = (byte) Fixnum.getValue(obj);
     
    256256
    257257    @Override
    258     public void shrink(int n) throws ConditionThrowable
     258    public void shrink(int n)
    259259    {
    260260        if (elements != null) {
     
    273273
    274274    @Override
    275     public LispObject reverse() throws ConditionThrowable
     275    public LispObject reverse()
    276276    {
    277277        int length = length();
     
    284284
    285285    @Override
    286     public LispObject nreverse() throws ConditionThrowable
     286    public LispObject nreverse()
    287287    {
    288288        if (elements != null) {
     
    314314
    315315    @Override
    316     public void vectorPushExtend(LispObject element) throws ConditionThrowable
     316    public void vectorPushExtend(LispObject element)
    317317    {
    318318        if (fillPointer < 0)
     
    328328    @Override
    329329    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    330         throws ConditionThrowable
     330
    331331    {
    332332        vectorPushExtend(element);
     
    336336    @Override
    337337    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    338         throws ConditionThrowable
     338
    339339    {
    340340        int ext = Fixnum.getValue(extension);
     
    350350    }
    351351
    352     private final void ensureCapacity(int minCapacity) throws ConditionThrowable
     352    private final void ensureCapacity(int minCapacity)
    353353    {
    354354        if (elements != null) {
     
    383383                                       LispObject initialElement,
    384384                                       LispObject initialContents)
    385         throws ConditionThrowable
     385
    386386    {
    387387        if (initialContents != null) {
     
    433433                                       AbstractArray displacedTo,
    434434                                       int displacement)
    435         throws ConditionThrowable
     435
    436436    {
    437437        capacity = newCapacity;
  • trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java

    r11991 r12254  
    3838    private LispObject streams;
    3939
    40     private ConcatenatedStream(LispObject streams) throws ConditionThrowable
     40    private ConcatenatedStream(LispObject streams)
    4141    {
    4242        this.streams = streams;
     
    4545
    4646    @Override
    47     public boolean isCharacterInputStream() throws ConditionThrowable
     47    public boolean isCharacterInputStream()
    4848    {
    4949        if (streams == NIL)
     
    5353
    5454    @Override
    55     public boolean isBinaryInputStream() throws ConditionThrowable
     55    public boolean isBinaryInputStream()
    5656    {
    5757        if (streams == NIL)
     
    6161
    6262    @Override
    63     public boolean isCharacterOutputStream() throws ConditionThrowable
     63    public boolean isCharacterOutputStream()
    6464    {
    6565        return false;
     
    6767
    6868    @Override
    69     public boolean isBinaryOutputStream() throws ConditionThrowable
     69    public boolean isBinaryOutputStream()
    7070    {
    7171        return false;
     
    8585
    8686    @Override
    87     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     87    public LispObject typep(LispObject typeSpecifier)
    8888    {
    8989        if (typeSpecifier == Symbol.CONCATENATED_STREAM)
     
    9595
    9696    @Override
    97     public LispObject getElementType() throws ConditionThrowable
     97    public LispObject getElementType()
    9898    {
    9999        if (streams == NIL)
     
    104104    @Override
    105105    public LispObject readCharNoHang(boolean eofError, LispObject eofValue)
    106         throws ConditionThrowable
     106
    107107    {
    108108        if (streams == NIL) {
     
    123123
    124124    @Override
    125     public LispObject listen() throws ConditionThrowable
     125    public LispObject listen()
    126126    {
    127127        if (unreadChar >= 0)
     
    140140    // Returns -1 at end of file.
    141141    @Override
    142     protected int _readChar() throws ConditionThrowable, java.io.IOException
     142    protected int _readChar() throws java.io.IOException
    143143    {
    144144        int n;
     
    159159
    160160    @Override
    161     protected void _unreadChar(int n) throws ConditionThrowable
     161    protected void _unreadChar(int n)
    162162    {
    163163        if (unreadChar >= 0)
     
    167167
    168168    @Override
    169     protected boolean _charReady() throws ConditionThrowable, java.io.IOException
     169    protected boolean _charReady() throws java.io.IOException
    170170    {
    171171        if (unreadChar >= 0)
     
    187187
    188188    @Override
    189     public void _writeChar(char c) throws ConditionThrowable
     189    public void _writeChar(char c)
    190190    {
    191191        outputStreamError();
     
    194194    @Override
    195195    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 ConditionThrowable
    203     {
    204         outputStreamError();
    205     }
    206 
    207     @Override
    208     public void _writeLine(String s) throws ConditionThrowable
     196
     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)
    209209    {
    210210        outputStreamError();
     
    213213    // Reads an 8-bit byte.
    214214    @Override
    215     public int _readByte() throws ConditionThrowable
     215    public int _readByte()
    216216    {
    217217        if (streams == NIL)
     
    227227    // Writes an 8-bit byte.
    228228    @Override
    229     public void _writeByte(int n) throws ConditionThrowable
    230     {
    231         outputStreamError();
    232     }
    233 
    234     @Override
    235     public void _finishOutput() throws ConditionThrowable
    236     {
    237         outputStreamError();
    238     }
    239 
    240     @Override
    241     public void _clearInput() throws ConditionThrowable
     229    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()
    242242    {
    243243        // FIXME
    244244    }
    245245
    246     private void outputStreamError() throws ConditionThrowable
     246    private void outputStreamError()
    247247    {
    248248        error(new StreamError(this,
     
    255255    {
    256256        @Override
    257         public LispObject execute(LispObject[] args) throws ConditionThrowable
     257        public LispObject execute(LispObject[] args)
    258258        {
    259259            LispObject streams = NIL;
     
    279279    {
    280280        @Override
    281         public LispObject execute(LispObject arg) throws ConditionThrowable
     281        public LispObject execute(LispObject arg)
    282282        {
    283283            if (arg instanceof ConcatenatedStream)
  • trunk/abcl/src/org/armedbear/lisp/Condition.java

    r11488 r12254  
    3838  protected String message;
    3939
    40   public Condition() throws ConditionThrowable
     40  public Condition()
    4141  {
    4242    super(StandardClass.CONDITION);
     
    4545  }
    4646
    47   protected Condition(LispClass cls) throws ConditionThrowable
     47  protected Condition(LispClass cls)
    4848  {
    4949    super(cls);
     
    5757  }
    5858
    59   public Condition(LispObject initArgs) throws ConditionThrowable
     59  public Condition(LispObject initArgs)
    6060  {
    6161    super(StandardClass.CONDITION);
     
    6464  }
    6565
    66   protected void initialize(LispObject initArgs) throws ConditionThrowable
     66  protected void initialize(LispObject initArgs)
    6767  {
    6868    LispObject control = null;
     
    108108  }
    109109
    110   public final LispObject getFormatControl() throws ConditionThrowable
     110  public final LispObject getFormatControl()
    111111  {
    112112    return getInstanceSlotValue(Symbol.FORMAT_CONTROL);
     
    114114
    115115  public final void setFormatControl(LispObject formatControl)
    116     throws ConditionThrowable
     116
    117117  {
    118118    setInstanceSlotValue(Symbol.FORMAT_CONTROL, formatControl);
    119119  }
    120120
    121   public final void setFormatControl(String s) throws ConditionThrowable
     121  public final void setFormatControl(String s)
    122122  {
    123123    setFormatControl(new SimpleString(s));
    124124  }
    125125
    126   public final LispObject getFormatArguments() throws ConditionThrowable
     126  public final LispObject getFormatArguments()
    127127  {
    128128    return getInstanceSlotValue(Symbol.FORMAT_ARGUMENTS);
     
    130130
    131131  public final void setFormatArguments(LispObject formatArguments)
    132     throws ConditionThrowable
     132
    133133  {
    134134    setInstanceSlotValue(Symbol.FORMAT_ARGUMENTS, formatArguments);
    135135  }
    136136
    137   public String getMessage() throws ConditionThrowable
     137  public String getMessage()
    138138  {
    139139    return message;
     
    159159
    160160  @Override
    161   public LispObject typep(LispObject type) throws ConditionThrowable
     161  public LispObject typep(LispObject type)
    162162  {
    163163    if (type == Symbol.CONDITION)
     
    168168  }
    169169
    170   public String getConditionReport() throws ConditionThrowable
     170  public String getConditionReport()
    171171  {
    172172    String s = getMessage();
     
    186186
    187187  @Override
    188   public String writeToString() throws ConditionThrowable
     188  public String writeToString()
    189189  {
    190190    final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/ConditionThrowable.java

    r12253 r12254  
    5454    }
    5555
    56     public abstract LispObject getCondition() throws ConditionThrowable;
     56    public abstract LispObject getCondition();
    5757}
  • trunk/abcl/src/org/armedbear/lisp/Cons.java

    r11754 r12254  
    7373
    7474  @Override
    75   public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     75  public LispObject typep(LispObject typeSpecifier)
    7676  {
    7777    if (typeSpecifier instanceof Symbol)
     
    143143
    144144  @Override
    145   public LispObject RPLACA(LispObject obj) throws ConditionThrowable
     145  public LispObject RPLACA(LispObject obj)
    146146  {
    147147    car = obj;
     
    156156
    157157  @Override
    158   public LispObject RPLACD(LispObject obj) throws ConditionThrowable
     158  public LispObject RPLACD(LispObject obj)
    159159  {
    160160    cdr = obj;
     
    163163
    164164  @Override
    165   public final LispObject cadr() throws ConditionThrowable
     165  public final LispObject cadr()
    166166  {
    167167    return cdr.car();
     
    169169
    170170  @Override
    171   public final LispObject cddr() throws ConditionThrowable
     171  public final LispObject cddr()
    172172  {
    173173    return cdr.cdr();
     
    175175
    176176  @Override
    177   public final LispObject caddr() throws ConditionThrowable
     177  public final LispObject caddr()
    178178  {
    179179    return cdr.cadr();
     
    181181
    182182  @Override
    183   public LispObject nthcdr(int n) throws ConditionThrowable
     183  public LispObject nthcdr(int n)
    184184  {
    185185    if (n < 0)
     
    231231
    232232  @Override
    233   public final int psxhash() //throws ConditionThrowable
     233  public final int psxhash()
    234234  {
    235235    return computeEqualpHash(this, 4);
     
    254254
    255255  @Override
    256   public final boolean equal(LispObject obj) throws ConditionThrowable
     256  public final boolean equal(LispObject obj)
    257257  {
    258258    if (this == obj)
     
    267267
    268268  @Override
    269   public final boolean equalp(LispObject obj) throws ConditionThrowable
     269  public final boolean equalp(LispObject obj)
    270270  {
    271271    if (this == obj)
     
    280280
    281281  @Override
    282   public final int length() throws ConditionThrowable
     282  public final int length()
    283283  {
    284284    int length = 1;
     
    295295
    296296  @Override
    297   public LispObject NTH(int index) throws ConditionThrowable
     297  public LispObject NTH(int index)
    298298  {
    299299    if (index < 0)
     
    313313
    314314  @Override
    315   public LispObject NTH(LispObject arg) throws ConditionThrowable
     315  public LispObject NTH(LispObject arg)
    316316  {
    317317    int index;
     
    347347
    348348  @Override
    349   public LispObject elt(int index) throws ConditionThrowable
     349  public LispObject elt(int index)
    350350  {
    351351    if (index < 0)
     
    384384
    385385  @Override
    386   public LispObject reverse() throws ConditionThrowable
     386  public LispObject reverse()
    387387  {
    388388    Cons cons = this;
     
    399399
    400400  @Override
    401   public final LispObject nreverse() throws ConditionThrowable
     401  public final LispObject nreverse()
    402402  {
    403403    if (cdr instanceof Cons)
     
    457457
    458458  @Override
    459   public final LispObject[] copyToArray() throws ConditionThrowable
     459  public final LispObject[] copyToArray()
    460460  {
    461461    final int length = length();
     
    471471
    472472  @Override
    473   public LispObject execute() throws ConditionThrowable
     473  public LispObject execute()
    474474  {
    475475    if (car == Symbol.LAMBDA)
     
    482482
    483483  @Override
    484   public LispObject execute(LispObject arg) throws ConditionThrowable
     484  public LispObject execute(LispObject arg)
    485485  {
    486486    if (car == Symbol.LAMBDA)
     
    494494  @Override
    495495  public LispObject execute(LispObject first, LispObject second)
    496     throws ConditionThrowable
     496
    497497  {
    498498    if (car == Symbol.LAMBDA)
     
    507507  public LispObject execute(LispObject first, LispObject second,
    508508                            LispObject third)
    509     throws ConditionThrowable
     509
    510510  {
    511511    if (car == Symbol.LAMBDA)
     
    520520  public LispObject execute(LispObject first, LispObject second,
    521521                            LispObject third, LispObject fourth)
    522     throws ConditionThrowable
     522
    523523  {
    524524    if (car == Symbol.LAMBDA)
     
    534534                            LispObject third, LispObject fourth,
    535535                            LispObject fifth)
    536     throws ConditionThrowable
     536
    537537  {
    538538    if (car == Symbol.LAMBDA)
     
    548548                            LispObject third, LispObject fourth,
    549549                            LispObject fifth, LispObject sixth)
    550     throws ConditionThrowable
     550
    551551  {
    552552    if (car == Symbol.LAMBDA)
     
    563563                            LispObject fifth, LispObject sixth,
    564564                            LispObject seventh)
    565     throws ConditionThrowable
     565
    566566  {
    567567    if (car == Symbol.LAMBDA)
     
    579579                            LispObject fifth, LispObject sixth,
    580580                            LispObject seventh, LispObject eighth)
    581     throws ConditionThrowable
     581
    582582  {
    583583    if (car == Symbol.LAMBDA)
     
    591591
    592592  @Override
    593   public LispObject execute(LispObject[] args) throws ConditionThrowable
     593  public LispObject execute(LispObject[] args)
    594594  {
    595595    if (car == Symbol.LAMBDA)
     
    601601  }
    602602
    603   private final LispObject signalExecutionError() throws ConditionThrowable
     603  private final LispObject signalExecutionError()
    604604  {
    605605    return type_error(this, list(Symbol.OR, Symbol.FUNCTION,
     
    608608
    609609  @Override
    610   public String writeToString() throws ConditionThrowable
     610  public String writeToString()
    611611  {
    612612    final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/ControlError.java

    r11488 r12254  
    3636public final class ControlError extends LispError
    3737{
    38     public ControlError(LispObject initArgs) throws ConditionThrowable
     38    public ControlError(LispObject initArgs)
    3939    {
    4040        super(StandardClass.CONTROL_ERROR);
     
    4242    }
    4343
    44     public ControlError(String message) throws ConditionThrowable
     44    public ControlError(String message)
    4545    {
    4646        super(StandardClass.CONTROL_ERROR);
     
    6262
    6363    @Override
    64     public LispObject typep(LispObject type) throws ConditionThrowable
     64    public LispObject typep(LispObject type)
    6565    {
    6666        if (type == Symbol.CONTROL_ERROR)
  • trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java

    r11488 r12254  
    6565    public LispObject execute(LispObject first, LispObject second,
    6666                              LispObject third)
    67         throws ConditionThrowable
     67
    6868    {
    6969        Stream stream = inSynonymOf(first);
     
    7878
    7979    public abstract LispObject execute(Stream stream, char c, int n)
    80         throws ConditionThrowable;
     80       ;
    8181}
  • trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java

    r11488 r12254  
    3636public final class DivisionByZero extends ArithmeticError
    3737{
    38     public DivisionByZero() throws ConditionThrowable
     38    public DivisionByZero()
    3939    {
    4040        super(StandardClass.DIVISION_BY_ZERO);
     
    4242    }
    4343
    44     public DivisionByZero(LispObject initArgs) throws ConditionThrowable
     44    public DivisionByZero(LispObject initArgs)
    4545    {
    4646        super(StandardClass.DIVISION_BY_ZERO);
     
    6161
    6262    @Override
    63     public LispObject typep(LispObject type) throws ConditionThrowable
     63    public LispObject typep(LispObject type)
    6464    {
    6565        if (type == Symbol.DIVISION_BY_ZERO)
  • trunk/abcl/src/org/armedbear/lisp/Do.java

    r12170 r12254  
    4242      @Override
    4343      public LispObject execute(LispObject args, Environment env)
    44         throws ConditionThrowable
     44
    4545      {
    4646        return _do(args, env, false);
     
    5454      @Override
    5555      public LispObject execute(LispObject args, Environment env)
    56         throws ConditionThrowable
     56
    5757      {
    5858        return _do(args, env, true);
     
    6262  private static final LispObject _do(LispObject args, Environment env,
    6363                                      boolean sequential)
    64     throws ConditionThrowable
     64
    6565  {
    6666    LispObject varlist = args.car();
  • trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

    r12018 r12254  
    8787
    8888    @Override
    89     public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     89    public LispObject typep(LispObject typeSpecifier)
    9090    {
    9191        if (typeSpecifier == Symbol.FLOAT)
     
    169169
    170170    @Override
    171     public boolean equalp(LispObject obj) throws ConditionThrowable
     171    public boolean equalp(LispObject obj)
    172172    {
    173173        if (obj instanceof SingleFloat)
     
    224224    }
    225225
    226     public static double getValue(LispObject obj) throws ConditionThrowable
     226    public static double getValue(LispObject obj)
    227227    {
    228228        if (obj instanceof DoubleFloat)
     
    281281
    282282    @Override
    283     public LispObject add(LispObject obj) throws ConditionThrowable
     283    public LispObject add(LispObject obj)
    284284    {
    285285        if (obj instanceof Fixnum)
     
    301301
    302302    @Override
    303     public LispObject subtract(LispObject obj) throws ConditionThrowable
     303    public LispObject subtract(LispObject obj)
    304304    {
    305305        if (obj instanceof Fixnum)
     
    322322
    323323    @Override
    324     public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
     324    public LispObject multiplyBy(LispObject obj)
    325325    {
    326326        if (obj instanceof Fixnum)
     
    343343
    344344    @Override
    345     public LispObject divideBy(LispObject obj) throws ConditionThrowable
     345    public LispObject divideBy(LispObject obj)
    346346    {
    347347        if (obj instanceof Fixnum)
     
    369369
    370370    @Override
    371     public boolean isEqualTo(LispObject obj) throws ConditionThrowable
     371    public boolean isEqualTo(LispObject obj)
    372372    {
    373373        if (obj instanceof Fixnum)
     
    389389
    390390    @Override
    391     public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
     391    public boolean isNotEqualTo(LispObject obj)
    392392    {
    393393        return !isEqualTo(obj);
     
    395395
    396396    @Override
    397     public boolean isLessThan(LispObject obj) throws ConditionThrowable
     397    public boolean isLessThan(LispObject obj)
    398398    {
    399399        if (obj instanceof Fixnum)
     
    413413
    414414    @Override
    415     public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
     415    public boolean isGreaterThan(LispObject obj)
    416416    {
    417417        if (obj instanceof Fixnum)
     
    431431
    432432    @Override
    433     public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
     433    public boolean isLessThanOrEqualTo(LispObject obj)
    434434    {
    435435        if (obj instanceof Fixnum)
     
    449449
    450450    @Override
    451     public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
     451    public boolean isGreaterThanOrEqualTo(LispObject obj)
    452452    {
    453453        if (obj instanceof Fixnum)
     
    467467
    468468    @Override
    469     public LispObject truncate(LispObject obj) throws ConditionThrowable
     469    public LispObject truncate(LispObject obj)
    470470    {
    471471        // "When rationals and floats are combined by a numerical function,
     
    580580
    581581    @Override
    582     public String writeToString() throws ConditionThrowable
     582    public String writeToString()
    583583    {
    584584        if (value == Double.POSITIVE_INFINITY) {
     
    615615    }
    616616
    617     public LispObject rational() throws ConditionThrowable
     617    public LispObject rational()
    618618    {
    619619        final long bits = Double.doubleToRawLongBits(value);
     
    642642    }
    643643
    644     public static DoubleFloat coerceToFloat(LispObject obj) throws ConditionThrowable
     644    public static DoubleFloat coerceToFloat(LispObject obj)
    645645    {
    646646        if (obj instanceof DoubleFloat)
  • trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java

    r11488 r12254  
    3636public final class DowncaseStream extends CaseFrobStream
    3737{
    38     public DowncaseStream(Stream target) throws ConditionThrowable
     38    public DowncaseStream(Stream target)
    3939    {
    4040        super(target);
     
    4242
    4343    @Override
    44     public void _writeChar(char c) throws ConditionThrowable
     44    public void _writeChar(char c)
    4545    {
    4646        target._writeChar(LispCharacter.toLowerCase(c));
     
    4848
    4949    @Override
    50     public void _writeString(String s) throws ConditionThrowable
     50    public void _writeString(String s)
    5151    {
    5252        target._writeString(s.toLowerCase());
     
    5454
    5555    @Override
    56     public void _writeLine(String s) throws ConditionThrowable
     56    public void _writeLine(String s)
    5757    {
    5858        target._writeLine(s.toLowerCase());
  • trunk/abcl/src/org/armedbear/lisp/EchoStream.java

    r11991 r12254  
    5555
    5656    @Override
    57     public LispObject getElementType() throws ConditionThrowable
     57    public LispObject getElementType()
    5858    {
    5959        LispObject itype = in.getElementType();
     
    8787
    8888    @Override
    89     public LispObject typep(LispObject type) throws ConditionThrowable
     89    public LispObject typep(LispObject type)
    9090    {
    9191        if (type == Symbol.ECHO_STREAM)
     
    109109
    110110    @Override
    111     public boolean isCharacterInputStream() throws ConditionThrowable
     111    public boolean isCharacterInputStream()
    112112    {
    113113        return in.isCharacterInputStream();
     
    115115
    116116    @Override
    117     public boolean isBinaryInputStream() throws ConditionThrowable
     117    public boolean isBinaryInputStream()
    118118    {
    119119        return in.isBinaryInputStream();
     
    121121
    122122    @Override
    123     public boolean isCharacterOutputStream() throws ConditionThrowable
     123    public boolean isCharacterOutputStream()
    124124    {
    125125        return out.isCharacterOutputStream();
     
    127127
    128128    @Override
    129     public boolean isBinaryOutputStream() throws ConditionThrowable
     129    public boolean isBinaryOutputStream()
    130130    {
    131131        return out.isBinaryOutputStream();
     
    134134    // Returns -1 at end of file.
    135135    @Override
    136     protected int _readChar() throws ConditionThrowable, java.io.IOException
     136    protected int _readChar() throws java.io.IOException
    137137    {
    138138        int n = in._readChar();
     
    148148
    149149    @Override
    150     protected void _unreadChar(int n) throws ConditionThrowable, java.io.IOException
     150    protected void _unreadChar(int n) throws java.io.IOException
    151151    {
    152152        in._unreadChar(n);
     
    155155
    156156    @Override
    157     protected boolean _charReady() throws ConditionThrowable, java.io.IOException
     157    protected boolean _charReady() throws java.io.IOException
    158158    {
    159159        return in._charReady();
     
    161161
    162162    @Override
    163     public void _writeChar(char c) throws ConditionThrowable
     163    public void _writeChar(char c)
    164164    {
    165165        out._writeChar(c);
     
    168168    @Override
    169169    public void _writeChars(char[] chars, int start, int end)
    170         throws ConditionThrowable
     170
    171171    {
    172172        out._writeChars(chars, start, end);
     
    174174
    175175    @Override
    176     public void _writeString(String s) throws ConditionThrowable
     176    public void _writeString(String s)
    177177    {
    178178        out._writeString(s);
     
    180180
    181181    @Override
    182     public void _writeLine(String s) throws ConditionThrowable
     182    public void _writeLine(String s)
    183183    {
    184184        out._writeLine(s);
     
    187187    // Reads an 8-bit byte.
    188188    @Override
    189     public int _readByte() throws ConditionThrowable
     189    public int _readByte()
    190190    {
    191191        int n = in._readByte();
     
    197197    // Writes an 8-bit byte.
    198198    @Override
    199     public void _writeByte(int n) throws ConditionThrowable
     199    public void _writeByte(int n)
    200200    {
    201201        out._writeByte(n);
     
    203203
    204204    @Override
    205     public void _finishOutput() throws ConditionThrowable
     205    public void _finishOutput()
    206206    {
    207207        out._finishOutput();
     
    209209
    210210    @Override
    211     public void _clearInput() throws ConditionThrowable
     211    public void _clearInput()
    212212    {
    213213        in._clearInput();
     
    215215
    216216    @Override
    217     public LispObject close(LispObject abort) throws ConditionThrowable
     217    public LispObject close(LispObject abort)
    218218    {
    219219        // "The effect of CLOSE on a constructed stream is to close the
     
    225225
    226226    @Override
    227     public LispObject listen() throws ConditionThrowable
     227    public LispObject listen()
    228228    {
    229229        return in.listen();
     
    231231
    232232    @Override
    233     public LispObject freshLine() throws ConditionThrowable
     233    public LispObject freshLine()
    234234    {
    235235        return out.freshLine();
     
    249249        @Override
    250250        public LispObject execute(LispObject first, LispObject second)
    251             throws ConditionThrowable
     251
    252252        {
    253253            if (!(first instanceof Stream))
     
    265265    {
    266266        @Override
    267         public LispObject execute(LispObject arg) throws ConditionThrowable
     267        public LispObject execute(LispObject arg)
    268268        {
    269269            if (arg instanceof EchoStream)
     
    279279    {
    280280        @Override
    281         public LispObject execute(LispObject arg) throws ConditionThrowable
     281        public LispObject execute(LispObject arg)
    282282        {
    283283            if (arg instanceof EchoStream)
  • trunk/abcl/src/org/armedbear/lisp/EndOfFile.java

    r11488 r12254  
    3636public final class EndOfFile extends StreamError
    3737{
    38     public EndOfFile(Stream stream) throws ConditionThrowable
     38    public EndOfFile(Stream stream)
    3939    {
    4040        super(StandardClass.END_OF_FILE);
     
    4242    }
    4343
    44     public EndOfFile(LispObject initArgs) throws ConditionThrowable
     44    public EndOfFile(LispObject initArgs)
    4545    {
    4646        super(StandardClass.END_OF_FILE);
     
    6161
    6262    @Override
    63     public LispObject typep(LispObject type) throws ConditionThrowable
     63    public LispObject typep(LispObject type)
    6464    {
    6565        if (type == Symbol.END_OF_FILE)
     
    7171
    7272    @Override
    73     public String writeToString() throws ConditionThrowable
     73    public String writeToString()
    7474    {
    7575        return unreadableString(Symbol.END_OF_FILE);
  • trunk/abcl/src/org/armedbear/lisp/Environment.java

    r12171 r12254  
    7676
    7777  @Override
    78   public LispObject typep(LispObject type) throws ConditionThrowable
     78  public LispObject typep(LispObject type)
    7979  {
    8080    if (type == Symbol.ENVIRONMENT)
     
    141141
    142142  public LispObject lookupFunction(LispObject name)
    143     throws ConditionThrowable
     143
    144144  {
    145145    FunctionBinding binding = lastFunctionBinding;
     
    215215  // Returns body with declarations removed.
    216216  public LispObject processDeclarations(LispObject body)
    217     throws ConditionThrowable
     217
    218218  {
    219219    LispObject bodyAndDecls = parseBody(body, false);
     
    244244
    245245  @Override
    246   public String writeToString() throws ConditionThrowable
     246  public String writeToString()
    247247  {
    248248    return unreadableString(Symbol.ENVIRONMENT);
     
    260260      }
    261261      @Override
    262       public LispObject execute(LispObject arg) throws ConditionThrowable
     262      public LispObject execute(LispObject arg)
    263263      {
    264264        if (arg == NIL)
     
    276276      public LispObject execute(LispObject first, LispObject second,
    277277                                LispObject third)
    278         throws ConditionThrowable
     278
    279279      {
    280280        Environment env = checkEnvironment(first);
     
    294294      public LispObject execute(LispObject first, LispObject second,
    295295                                LispObject third)
    296         throws ConditionThrowable
     296
    297297      {
    298298        checkEnvironment(first).addFunctionBinding(second, third);
     
    309309      public LispObject execute(LispObject first, LispObject second,
    310310                                LispObject third)
    311         throws ConditionThrowable
     311
    312312      {
    313313        checkEnvironment(first).bind(checkSymbol(second), third);
     
    321321    {
    322322      @Override
    323       public LispObject execute(LispObject arg) throws ConditionThrowable
     323      public LispObject execute(LispObject arg)
    324324      {
    325325          return checkEnvironment(arg).isEmpty() ? T : NIL;
     
    332332    {
    333333      @Override
    334       public LispObject execute(LispObject arg) throws ConditionThrowable
     334      public LispObject execute(LispObject arg)
    335335      {
    336336            Environment env = checkEnvironment(arg);
     
    348348    {
    349349      @Override
    350       public LispObject execute(LispObject arg) throws ConditionThrowable
     350      public LispObject execute(LispObject arg)
    351351      {
    352352            Environment env = checkEnvironment(arg);
     
    367367    {
    368368      @Override
    369       public LispObject execute(LispObject arg) throws ConditionThrowable
     369      public LispObject execute(LispObject arg)
    370370      {
    371371            Environment env = checkEnvironment(arg);
  • trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java

    r12252 r12254  
    7373
    7474  @Override
    75   public void put(LispObject key, LispObject value) throws ConditionThrowable
     75  public void put(LispObject key, LispObject value)
    7676  {
    7777    int index = key.sxhash() & mask;
     
    9999
    100100  @Override
    101   public LispObject remove(LispObject key) throws ConditionThrowable
     101  public LispObject remove(LispObject key)
    102102  {
    103103    final int index = key.sxhash() & mask;
  • trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java

    r12252 r12254  
    7171
    7272  @Override
    73   public void put(LispObject key, LispObject value) throws ConditionThrowable
     73  public void put(LispObject key, LispObject value)
    7474  {
    7575    int index = key.psxhash() % buckets.length;
     
    9797
    9898  @Override
    99   public LispObject remove(LispObject key) throws ConditionThrowable
     99  public LispObject remove(LispObject key)
    100100  {
    101101    final int index = key.psxhash() % buckets.length;
  • trunk/abcl/src/org/armedbear/lisp/Extensions.java

    r11754 r12254  
    5050      @Override
    5151      public LispObject execute(LispObject args, Environment env)
    52         throws ConditionThrowable
     52
    5353      {
    5454        if (args.length() != 2)
     
    6464      @Override
    6565      public LispObject execute(LispObject first, LispObject second)
    66         throws ConditionThrowable
     66
    6767      {
    6868        return first != second ? T : NIL;
     
    7676      @Override
    7777      public LispObject execute(LispObject item, LispObject list)
    78         throws ConditionThrowable
     78
    7979      {
    8080        while (list instanceof Cons)
     
    9696      @Override
    9797      public LispObject execute(LispObject item, LispObject list)
    98         throws ConditionThrowable
     98
    9999      {
    100100        while (list instanceof Cons)
     
    116116      @Override
    117117      public LispObject execute(LispObject item, LispObject list)
    118         throws ConditionThrowable
     118
    119119      {
    120120        return memql(item, list) ? list : new Cons(item, list);
     
    127127    {
    128128      @Override
    129       public LispObject execute(LispObject arg) throws ConditionThrowable
     129      public LispObject execute(LispObject arg)
    130130      {
    131131        return arg.isSpecialVariable() ? T : NIL;
     
    138138    {
    139