Changeset 11488


Ignore:
Timestamp:
12/27/08 10:50:33 (12 years ago)
Author:
ehuelsmann
Message:

Add @Override annotations.

Patch by: Douglas Miles

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

Legend:

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

    r11391 r11488  
    3636public abstract class AbstractArray extends LispObject
    3737{
     38    @Override
    3839    public LispObject typep(LispObject type) throws ConditionThrowable
    3940    {
     
    4546    }
    4647
     48    @Override
    4749    public boolean equalp(LispObject obj) throws ConditionThrowable
    4850    {
     
    100102    public abstract int getTotalSize();
    101103
     104    @Override
    102105    public abstract void aset(int index, LispObject newValue)
    103106        throws ConditionThrowable;
     
    282285
    283286    // For EQUALP hash tables.
     287    @Override
    284288    public int psxhash()
    285289    {
  • trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java

    r11391 r11488  
    4343    protected long[] bits;
    4444
     45    @Override
    4546    public LispObject typep(LispObject type) throws ConditionThrowable
    4647    {
     
    5253    }
    5354
     55    @Override
    5456    public LispObject classOf()
    5557    {
     
    5759    }
    5860
     61    @Override
    5962    public final int capacity()
    6063    {
     
    6265    }
    6366
     67    @Override
    6468    public final LispObject getElementType()
    6569    {
     
    6771    }
    6872
     73    @Override
    6974    public boolean equal(LispObject obj) throws ConditionThrowable
    7075    {
     
    8489    }
    8590
     91    @Override
    8692    public boolean equalp(LispObject obj) throws ConditionThrowable
    8793    {
     
    105111    }
    106112
     113    @Override
    107114    public void fill(LispObject obj) throws ConditionThrowable
    108115    {
     
    135142    }
    136143
     144    @Override
    137145    public LispObject subseq(int start, int end) throws ConditionThrowable
    138146    {
     
    153161    }
    154162
     163    @Override
    155164    public int hashCode()
    156165    {
     
    169178    }
    170179
     180    @Override
    171181    public String writeToString() throws ConditionThrowable
    172182    {
     
    193203
    194204    // Ignores fill pointer.
     205    @Override
    195206    public LispObject AREF(LispObject index) throws ConditionThrowable
    196207    {
     
    203214    }
    204215
     216    @Override
    205217    public LispObject reverse() throws ConditionThrowable
    206218    {
  • trunk/abcl/src/org/armedbear/lisp/AbstractString.java

    r11433 r11488  
    3636public abstract class AbstractString extends AbstractVector
    3737{
     38    @Override
    3839    public LispObject typep(LispObject type) throws ConditionThrowable
    3940    {
     
    5152    }
    5253
     54    @Override
    5355    public final LispObject STRINGP()
    5456    {
     
    5658    }
    5759
     60    @Override
    5861    public final boolean stringp()
    5962    {
     
    6164    }
    6265
     66    @Override
    6367    public LispObject getElementType()
    6468    {
     
    6670    }
    6771
     72    @Override
    6873    public final boolean isSimpleVector()
    6974    {
     
    7176    }
    7277
     78    @Override
    7379    public final LispObject STRING()
    7480    {
     
    108114    }
    109115
     116    @Override
    110117    public String writeToString() throws ConditionThrowable
    111118    {
  • trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

    r11391 r11488  
    3535public abstract class AbstractVector extends AbstractArray
    3636{
     37  @Override
    3738  public LispObject typep(LispObject type) throws ConditionThrowable
    3839  {
     
    4849  }
    4950
     51  @Override
    5052  public final LispObject VECTORP()
    5153  {
     
    5355  }
    5456
     57  @Override
    5558  public final boolean vectorp()
    5659  {
     
    5861  }
    5962
     63  @Override
    6064  public boolean equalp(LispObject obj) throws ConditionThrowable
    6165  {
     
    7377  }
    7478
     79  @Override
    7580  public final int getRank()
    7681  {
     
    7883  }
    7984
     85  @Override
    8086  public final LispObject getDimensions()
    8187  {
     
    8389  }
    8490
     91  @Override
    8592  public final int getDimension(int n) throws ConditionThrowable
    8693  {
     
    94101  }
    95102
     103  @Override
    96104  public final int getTotalSize()
    97105  {
     
    181189  }
    182190
     191  @Override
    183192  public abstract LispObject reverse() throws ConditionThrowable;
    184193
     194  @Override
    185195  public LispObject nreverse() throws ConditionThrowable
    186196  {
     
    198208  }
    199209
     210  @Override
    200211  public String writeToString() throws ConditionThrowable
    201212  {
     
    267278
    268279  // For EQUALP hash tables.
     280  @Override
    269281  public int psxhash()
    270282  {
  • trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java

    r11391 r11488  
    4747    }
    4848
     49    @Override
    4950    protected void initialize(LispObject initArgs) throws ConditionThrowable
    5051    {
     
    7677    }
    7778
     79    @Override
    7880    public LispObject typeOf()
    7981    {
     
    8183    }
    8284
     85    @Override
    8386    public LispObject classOf()
    8487    {
     
    8689    }
    8790
     91    @Override
    8892    public LispObject typep(LispObject type) throws ConditionThrowable
    8993    {
     
    121125        new Primitive("arithmetic-error-operation", "condition")
    122126    {
     127        @Override
    123128        public LispObject execute(LispObject arg) throws ConditionThrowable
    124129        {
     
    135140        new Primitive("arithmetic-error-operands", "condition")
    136141    {
     142        @Override
    137143        public LispObject execute(LispObject arg) throws ConditionThrowable
    138144        {
  • trunk/abcl/src/org/armedbear/lisp/Autoload.java

    r11391 r11488  
    153153    }
    154154
     155    @Override
    155156    public LispObject execute() throws ConditionThrowable
    156157    {
     
    159160    }
    160161
     162    @Override
    161163    public LispObject execute(LispObject arg) throws ConditionThrowable
    162164    {
     
    165167    }
    166168
     169    @Override
    167170    public LispObject execute(LispObject first, LispObject second)
    168171        throws ConditionThrowable
     
    172175    }
    173176
     177    @Override
    174178    public LispObject execute(LispObject first, LispObject second,
    175179                              LispObject third)
     
    180184    }
    181185
     186    @Override
    182187    public LispObject execute(LispObject first, LispObject second,
    183188                              LispObject third, LispObject fourth)
     
    188193    }
    189194
     195    @Override
    190196    public LispObject execute(LispObject first, LispObject second,
    191197                              LispObject third, LispObject fourth,
     
    197203    }
    198204
     205    @Override
    199206    public LispObject execute(LispObject first, LispObject second,
    200207                              LispObject third, LispObject fourth,
     
    206213    }
    207214
     215    @Override
    208216    public LispObject execute(LispObject first, LispObject second,
    209217                              LispObject third, LispObject fourth,
     
    217225    }
    218226
     227    @Override
    219228    public LispObject execute(LispObject first, LispObject second,
    220229                              LispObject third, LispObject fourth,
     
    228237    }
    229238
     239    @Override
    230240    public LispObject execute(LispObject[] args) throws ConditionThrowable
    231241    {
     
    234244    }
    235245
     246    @Override
    236247    public String writeToString() throws ConditionThrowable
    237248    {
     
    256267        new Primitive("autoload", PACKAGE_EXT, true)
    257268    {
     269        @Override
    258270        public LispObject execute(LispObject first) throws ConditionThrowable
    259271        {
     
    272284            return error(new TypeError(first));
    273285        }
     286        @Override
    274287        public LispObject execute(LispObject first, LispObject second)
    275288            throws ConditionThrowable
     
    297310        new Primitive("resolve", PACKAGE_EXT, true, "symbol")
    298311    {
     312        @Override
    299313        public LispObject execute(LispObject arg) throws ConditionThrowable
    300314        {
     
    314328        new Primitive("autoloadp", PACKAGE_EXT, true, "symbol")
    315329    {
     330        @Override
    316331        public LispObject execute(LispObject arg) throws ConditionThrowable
    317332        {
  • trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java

    r11391 r11488  
    5656    }
    5757
     58    @Override
    5859    public void load() throws ConditionThrowable
    5960    {
     
    6162    }
    6263
     64    @Override
    6365    public String writeToString() throws ConditionThrowable
    6466    {
     
    7577        new Primitive("autoload-macro", PACKAGE_EXT, true)
    7678    {
     79        @Override
    7780        public LispObject execute(LispObject first) throws ConditionThrowable
    7881        {
     
    9194            return error(new TypeError(first));
    9295        }
     96        @Override
    9397        public LispObject execute(LispObject first, LispObject second)
    9498            throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r11391 r11488  
    5656    }
    5757
     58    @Override
    5859    public LispObject typeOf()
    5960    {
     
    6263    }
    6364
     65    @Override
    6466    public LispObject classOf()
    6567    {
     
    6769    }
    6870
     71    @Override
    6972    public LispObject typep(LispObject type) throws ConditionThrowable
    7073    {
     
    7679    }
    7780
     81    @Override
    7882    public LispObject getElementType()
    7983    {
     
    8185    }
    8286
     87    @Override
    8388    public boolean isSimpleVector()
    8489    {
     
    8691    }
    8792
     93    @Override
    8894    public boolean hasFillPointer()
    8995    {
     
    9197    }
    9298
     99    @Override
    93100    public boolean isAdjustable()
    94101    {
     
    96103    }
    97104
     105    @Override
    98106    public int capacity()
    99107    {
     
    101109    }
    102110
     111    @Override
    103112    public int length()
    104113    {
     
    106115    }
    107116
     117    @Override
    108118    public LispObject elt(int index) throws ConditionThrowable
    109119    {
     
    118128
    119129    // Ignores fill pointer.
     130    @Override
    120131    public int aref(int index) throws ConditionThrowable
    121132    {
     
    131142
    132143    // Ignores fill pointer.
     144    @Override
    133145    public LispObject AREF(int index) throws ConditionThrowable
    134146    {
     
    143155
    144156    // Ignores fill pointer.
     157    @Override
    145158    public LispObject AREF(LispObject index) throws ConditionThrowable
    146159    {
     
    157170    }
    158171
     172    @Override
    159173    public void aset(int index, int n) throws ConditionThrowable
    160174    {
     
    167181    }
    168182
     183    @Override
    169184    public void aset(int index, LispObject obj) throws ConditionThrowable
    170185    {
     
    180195    }
    181196
     197    @Override
    182198    public LispObject subseq(int start, int end) throws ConditionThrowable
    183199    {
     
    194210    }
    195211
     212    @Override
    196213    public void fill(LispObject obj) throws ConditionThrowable
    197214    {
     
    201218    }
    202219
     220    @Override
    203221    public void shrink(int n) throws ConditionThrowable
    204222    {
     
    215233    }
    216234
     235    @Override
    217236    public LispObject reverse() throws ConditionThrowable
    218237    {
     
    224243    }
    225244
     245    @Override
    226246    public LispObject nreverse() throws ConditionThrowable
    227247    {
     
    238258    }
    239259
     260    @Override
    240261    public AbstractVector adjustVector(int newCapacity,
    241262                                       LispObject initialElement,
     
    270291    }
    271292
     293    @Override
    272294    public AbstractVector adjustVector(int newCapacity,
    273295                                       AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r11391 r11488  
    5757  }
    5858
     59  @Override
    5960  public LispObject typeOf()
    6061  {
     
    6364  }
    6465
     66  @Override
    6567  public LispObject classOf()
    6668  {
     
    6870  }
    6971
     72  @Override
    7073  public LispObject typep(LispObject type) throws ConditionThrowable
    7174  {
     
    7780  }
    7881
     82  @Override
    7983  public LispObject getElementType()
    8084  {
     
    8286  }
    8387
     88  @Override
    8489  public boolean isSimpleVector()
    8590  {
     
    8792  }
    8893
     94  @Override
    8995  public boolean hasFillPointer()
    9096  {
     
    9298  }
    9399
     100  @Override
    94101  public boolean isAdjustable()
    95102  {
     
    97104  }
    98105
     106  @Override
    99107  public int capacity()
    100108  {
     
    102110  }
    103111
     112  @Override
    104113  public int length()
    105114  {
     
    107116  }
    108117
     118  @Override
    109119  public LispObject elt(int index) throws ConditionThrowable
    110120  {
     
    120130  }
    121131
     132  @Override
    122133  public int aref(int index) throws ConditionThrowable
    123134  {
     
    133144  }
    134145
     146  @Override
    135147  public long aref_long(int index) throws ConditionThrowable
    136148  {
     
    146158  }
    147159
     160  @Override
    148161  public LispObject AREF(int index) throws ConditionThrowable
    149162  {
     
    159172  }
    160173
     174  @Override
    161175  public LispObject AREF(LispObject index) throws ConditionThrowable
    162176  {
     
    176190  }
    177191
     192  @Override
    178193  public void aset(int index, LispObject newValue) throws ConditionThrowable
    179194  {
     
    188203  }
    189204
     205  @Override
    190206  public LispObject subseq(int start, int end) throws ConditionThrowable
    191207  {
     
    205221  }
    206222
     223  @Override
    207224  public void fill(LispObject obj) throws ConditionThrowable
    208225  {
     
    211228  }
    212229
     230  @Override
    213231  public void shrink(int n) throws ConditionThrowable
    214232  {
     
    226244  }
    227245
     246  @Override
    228247  public LispObject reverse() throws ConditionThrowable
    229248  {
     
    235254  }
    236255
     256  @Override
    237257  public LispObject nreverse() throws ConditionThrowable
    238258  {
     
    250270  }
    251271
     272  @Override
    252273  public AbstractVector adjustVector(int newCapacity,
    253274                                     LispObject initialElement,
     
    289310  }
    290311
     312  @Override
    291313  public AbstractVector adjustVector(int newCapacity,
    292314                                     AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r11391 r11488  
    5656  }
    5757
     58  @Override
    5859  public LispObject typeOf()
    5960  {
     
    6162  }
    6263
     64  @Override
    6365  public LispObject classOf()
    6466  {
     
    6668  }
    6769
     70  @Override
    6871  public LispObject typep(LispObject type) throws ConditionThrowable
    6972  {
     
    7578  }
    7679
     80  @Override
    7781  public LispObject getElementType()
    7882  {
     
    8084  }
    8185
     86  @Override
    8287  public boolean isSimpleVector()
    8388  {
     
    8590  }
    8691
     92  @Override
    8793  public boolean hasFillPointer()
    8894  {
     
    9096  }
    9197
     98  @Override
    9299  public boolean isAdjustable()
    93100  {
     
    95102  }
    96103
     104  @Override
    97105  public int capacity()
    98106  {
     
    100108  }
    101109
     110  @Override
    102111  public int length()
    103112  {
     
    105114  }
    106115
     116  @Override
    107117  public LispObject elt(int index) throws ConditionThrowable
    108118  {
     
    118128  }
    119129
     130  @Override
    120131  public int aref(int index) throws ConditionThrowable
    121132  {
     
    132143  }
    133144
     145  @Override
    134146  public LispObject AREF(int index) throws ConditionThrowable
    135147  {
     
    145157  }
    146158
     159  @Override
    147160  public LispObject AREF(LispObject index) throws ConditionThrowable
    148161  {
     
    162175  }
    163176
     177  @Override
    164178  public void aset(int index, int n) throws ConditionThrowable
    165179  {
     
    174188  }
    175189
     190  @Override
    176191  public void aset(int index, LispObject value) throws ConditionThrowable
    177192  {
     
    186201  }
    187202
     203  @Override
    188204  public LispObject subseq(int start, int end) throws ConditionThrowable
    189205  {
     
    202218  }
    203219
     220  @Override
    204221  public void fill(LispObject obj) throws ConditionThrowable
    205222  {
     
    209226  }
    210227
     228  @Override
    211229  public void shrink(int n) throws ConditionThrowable
    212230  {
     
    224242  }
    225243
     244  @Override
    226245  public LispObject reverse() throws ConditionThrowable
    227246  {
     
    233252  }
    234253
     254  @Override
    235255  public LispObject nreverse() throws ConditionThrowable
    236256  {
     
    248268  }
    249269
     270  @Override
    250271  public AbstractVector adjustVector(int newCapacity,
    251272                                     LispObject initialElement,
     
    287308  }
    288309
     310  @Override
    289311  public AbstractVector adjustVector(int newCapacity,
    290312                                     AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java

    r11391 r11488  
    6060    }
    6161
     62    @Override
    6263    public LispObject typeOf()
    6364    {
     
    6566    }
    6667
     68    @Override
    6769    public LispObject classOf()
    6870    {
     
    7072    }
    7173
     74    @Override
    7275    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    7376    {
     
    7982    }
    8083
     84    @Override
    8185    public LispObject listen() throws ConditionThrowable
    8286    {
     
    8690    }
    8791
     92    @Override
    8893    public LispObject fileLength() throws ConditionThrowable
    8994    {
     
    9499    }
    95100
     101    @Override
    96102    public LispObject fileStringLength(LispObject arg) throws ConditionThrowable
    97103    {
     
    103109
    104110    // Returns -1 at end of file.
     111    @Override
    105112    protected int _readChar() throws ConditionThrowable
    106113    {
     
    110117    }
    111118
     119    @Override
    112120    protected void _unreadChar(int n) throws ConditionThrowable
    113121    {
     
    115123    }
    116124
     125    @Override
    117126    protected boolean _charReady() throws ConditionThrowable
    118127    {
     
    122131    }
    123132
     133    @Override
    124134    public void _writeChar(char c) throws ConditionThrowable
    125135    {
     
    128138    }
    129139
     140    @Override
    130141    public void _writeChars(char[] chars, int start, int end)
    131142        throws ConditionThrowable
     
    135146    }
    136147
     148    @Override
    137149    public void _writeString(String s) throws ConditionThrowable
    138150    {
     
    141153    }
    142154
     155    @Override
    143156    public void _writeLine(String s) throws ConditionThrowable
    144157    {
     
    148161
    149162    // Reads an 8-bit byte.
     163    @Override
    150164    public int _readByte() throws ConditionThrowable
    151165    {
     
    156170
    157171    // Writes an 8-bit byte.
     172    @Override
    158173    public void _writeByte(int n) throws ConditionThrowable
    159174    {
     
    162177    }
    163178
     179    @Override
    164180    public void _finishOutput() throws ConditionThrowable
    165181    {
     
    168184    }
    169185
     186    @Override
    170187    public void _clearInput() throws ConditionThrowable
    171188    {
     
    173190    }
    174191
     192    @Override
    175193    protected long _getFilePosition() throws ConditionThrowable
    176194    {
     
    181199    }
    182200
     201    @Override
    183202    protected boolean _setFilePosition(LispObject arg) throws ConditionThrowable
    184203    {
     
    186205    }
    187206
     207    @Override
    188208    public void _close() throws ConditionThrowable
    189209    {
     
    196216    }
    197217
     218    @Override
    198219    public String writeToString()
    199220    {
     
    205226        new Primitive("make-broadcast-stream", "&rest streams")
    206227    {
     228        @Override
    207229        public LispObject execute() throws ConditionThrowable
    208230        {
    209231            return new BroadcastStream(new Stream[0]);
    210232        }
     233        @Override
    211234        public LispObject execute(LispObject[] args) throws ConditionThrowable
    212235        {
     
    232255        new Primitive("broadcast-stream-streams", "broadcast-stream")
    233256    {
     257        @Override
    234258        public LispObject execute(LispObject arg) throws ConditionThrowable
    235259        {
  • trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java

    r11391 r11488  
    4141  }
    4242
     43  @Override
    4344  public LispObject typeOf()
    4445  {
     
    4647  }
    4748
     49  @Override
    4850  public LispObject classOf()
    4951  {
     
    5153  }
    5254
     55  @Override
    5356  public LispObject typep(LispObject type) throws ConditionThrowable
    5457  {
     
    6063  }
    6164
     65  @Override
    6266  public LispObject getDescription() throws ConditionThrowable
    6367  {
     
    6569  }
    6670
     71  @Override
    6772  public String writeToString() throws ConditionThrowable
    6873  {
  • trunk/abcl/src/org/armedbear/lisp/CapitalizeFirstStream.java

    r11391 r11488  
    4343    }
    4444
     45    @Override
    4546    public void _writeChar(char c) throws ConditionThrowable
    4647    {
     
    5556    }
    5657
     58    @Override
    5759    public void _writeString(String s) throws ConditionThrowable
    5860    {
     
    6264    }
    6365
     66    @Override
    6467    public void _writeLine(String s) throws ConditionThrowable
    6568    {
  • trunk/abcl/src/org/armedbear/lisp/CapitalizeStream.java

    r11391 r11488  
    4343    }
    4444
     45    @Override
    4546    public void _writeChar(char c) throws ConditionThrowable
    4647    {
     
    6566    }
    6667
     68    @Override
    6769    public void _writeString(String s) throws ConditionThrowable
    6870    {
     
    7274    }
    7375
     76    @Override
    7477    public void _writeLine(String s) throws ConditionThrowable
    7578    {
  • trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java

    r11391 r11488  
    4545    }
    4646
     47    @Override
    4748    public LispObject getElementType() throws ConditionThrowable
    4849    {
     
    5051    }
    5152
     53    @Override
    5254    public LispObject typeOf()
    5355    {
     
    5557    }
    5658
     59    @Override
    5760    public LispObject classOf()
    5861    {
     
    6063    }
    6164
     65    @Override
    6266    public LispObject typep(LispObject type) throws ConditionThrowable
    6367    {
     
    6973    }
    7074
     75    @Override
    7176    public boolean isInputStream()
    7277    {
     
    7479    }
    7580
     81    @Override
    7682    public boolean isOutputStream()
    7783    {
     
    7985    }
    8086
     87    @Override
    8188    public boolean isCharacterInputStream() throws ConditionThrowable
    8289    {
     
    8491    }
    8592
     93    @Override
    8694    public boolean isBinaryInputStream() throws ConditionThrowable
    8795    {
     
    8997    }
    9098
     99    @Override
    91100    public boolean isCharacterOutputStream() throws ConditionThrowable
    92101    {
     
    94103    }
    95104
     105    @Override
    96106    public boolean isBinaryOutputStream() throws ConditionThrowable
    97107    {
     
    99109    }
    100110
     111    @Override
    101112    public int getCharPos()
    102113    {
     
    104115    }
    105116
     117    @Override
    106118    public void setCharPos(int n)
    107119    {
     
    110122
    111123    // Returns -1 at end of file.
     124    @Override
    112125    protected int _readChar() throws ConditionThrowable
    113126    {
     
    117130    }
    118131
     132    @Override
    119133    protected void _unreadChar(int n) throws ConditionThrowable
    120134    {
     
    122136    }
    123137
     138    @Override
    124139    protected boolean _charReady() throws ConditionThrowable
    125140    {
     
    129144    }
    130145
     146    @Override
    131147    public void _writeChars(char[] chars, int start, int end)
    132148        throws ConditionThrowable
     
    136152
    137153    // Reads an 8-bit byte.
     154    @Override
    138155    public int _readByte() throws ConditionThrowable
    139156    {
     
    144161
    145162    // Writes an 8-bit byte.
     163    @Override
    146164    public void _writeByte(int n) throws ConditionThrowable
    147165    {
     
    149167    }
    150168
     169    @Override
    151170    public void _finishOutput() throws ConditionThrowable
    152171    {
     
    154173    }
    155174
     175    @Override
    156176    public void _clearInput() throws ConditionThrowable
    157177    {
     
    159179    }
    160180
     181    @Override
    161182    public LispObject close(LispObject abort) throws ConditionThrowable
    162183    {
     
    165186    }
    166187
     188    @Override
    167189    public LispObject listen() throws ConditionThrowable
    168190    {
     
    172194    }
    173195
     196    @Override
    174197    public LispObject terpri() throws ConditionThrowable
    175198    {
     
    177200    }
    178201
     202    @Override
    179203    public LispObject freshLine() throws ConditionThrowable
    180204    {
     
    182206    }
    183207
     208    @Override
    184209    public String writeToString()
    185210    {
     
    196221        new Primitive("make-case-frob-stream", PACKAGE_SYS, false, "target kind")
    197222    {
     223        @Override
    198224        public LispObject execute(LispObject first, LispObject second)
    199225            throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/CellError.java

    r11391 r11488  
    4747    }
    4848
     49    @Override
    4950    protected void initialize(LispObject initArgs) throws ConditionThrowable
    5051    {
     
    7374    }
    7475
     76    @Override
    7577    public LispObject typeOf()
    7678    {
     
    7880    }
    7981
     82    @Override
    8083    public LispObject classOf()
    8184    {
     
    8386    }
    8487
     88    @Override
    8589    public LispObject typep(LispObject type) throws ConditionThrowable
    8690    {
     
    9296    }
    9397
     98    @Override
    9499    public String writeToString() throws ConditionThrowable
    95100    {
  • trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java

    r11391 r11488  
    4040        new Primitive("char=", "&rest characters")
    4141    {
    42         public LispObject execute() throws ConditionThrowable
    43         {
    44             return error(new WrongNumberOfArgumentsException(this));
    45         }
    46         public LispObject execute(LispObject arg) throws ConditionThrowable
    47         {
    48             if (arg instanceof LispCharacter)
    49                 return T;
    50             return type_error(arg, Symbol.CHARACTER);
    51         }
     42        @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
    5255        public LispObject execute(LispObject first, LispObject second)
    5356            throws ConditionThrowable
     
    6568            }
    6669        }
     70        @Override
    6771        public LispObject execute(LispObject[] array) throws ConditionThrowable
    6872        {
     
    8185        new Primitive("char-equal", "&rest characters")
    8286    {
    83         public LispObject execute() throws ConditionThrowable
    84         {
    85             return error(new WrongNumberOfArgumentsException(this));
    86         }
    87         public LispObject execute(LispObject arg) throws ConditionThrowable
    88         {
    89             if (arg instanceof LispCharacter)
    90                 return T;
    91             return type_error(arg, Symbol.CHARACTER);
    92         }
     87        @Override
     88        public LispObject execute() throws ConditionThrowable
     89        {
     90            return error(new WrongNumberOfArgumentsException(this));
     91        }
     92        @Override
     93        public LispObject execute(LispObject arg) throws ConditionThrowable
     94        {
     95            if (arg instanceof LispCharacter)
     96                return T;
     97            return type_error(arg, Symbol.CHARACTER);
     98        }
     99        @Override
    93100        public LispObject execute(LispObject first, LispObject second)
    94101            throws ConditionThrowable
     
    115122            return NIL;
    116123        }
     124        @Override
    117125        public LispObject execute(LispObject[] array) throws ConditionThrowable
    118126        {
     
    137145        new Primitive("char-greaterp", "&rest characters")
    138146    {
    139         public LispObject execute() throws ConditionThrowable
    140         {
    141             return error(new WrongNumberOfArgumentsException(this));
    142         }
    143         public LispObject execute(LispObject arg) throws ConditionThrowable
    144         {
    145             if (arg instanceof LispCharacter)
    146                 return T;
    147             return type_error(arg, Symbol.CHARACTER);
    148         }
     147        @Override
     148        public LispObject execute() throws ConditionThrowable
     149        {
     150            return error(new WrongNumberOfArgumentsException(this));
     151        }
     152        @Override
     153        public LispObject execute(LispObject arg) throws ConditionThrowable
     154        {
     155            if (arg instanceof LispCharacter)
     156                return T;
     157            return type_error(arg, Symbol.CHARACTER);
     158        }
     159        @Override
    149160        public LispObject execute(LispObject first, LispObject second)
    150161            throws ConditionThrowable
     
    154165            return c1 > c2 ? T : NIL;
    155166        }
     167        @Override
    156168        public LispObject execute(LispObject[] array) throws ConditionThrowable
    157169        {
     
    172184        new Primitive("char-not-greaterp", "&rest characters")
    173185    {
    174         public LispObject execute() throws ConditionThrowable
    175         {
    176             return error(new WrongNumberOfArgumentsException(this));
    177         }
    178         public LispObject execute(LispObject arg) throws ConditionThrowable
    179         {
    180             if (arg instanceof LispCharacter)
    181                 return T;
    182             return type_error(arg, Symbol.CHARACTER);
    183         }
     186        @Override
     187        public LispObject execute() throws ConditionThrowable
     188        {
     189            return error(new WrongNumberOfArgumentsException(this));
     190        }
     191        @Override
     192        public LispObject execute(LispObject arg) throws ConditionThrowable
     193        {
     194            if (arg instanceof LispCharacter)
     195                return T;
     196            return type_error(arg, Symbol.CHARACTER);
     197        }
     198        @Override
    184199        public LispObject execute(LispObject first, LispObject second)
    185200            throws ConditionThrowable
     
    189204            return c1 <= c2 ? T : NIL;
    190205        }
     206        @Override
    191207        public LispObject execute(LispObject[] array) throws ConditionThrowable
    192208        {
     
    207223        new Primitive("char<", "&rest characters")
    208224    {
    209         public LispObject execute() throws ConditionThrowable
    210         {
    211             return error(new WrongNumberOfArgumentsException(this));
    212         }
    213         public LispObject execute(LispObject arg) throws ConditionThrowable
    214         {
    215             if (arg instanceof LispCharacter)
    216                 return T;
    217             return type_error(arg, Symbol.CHARACTER);
    218         }
     225        @Override
     226        public LispObject execute() throws ConditionThrowable
     227        {
     228            return error(new WrongNumberOfArgumentsException(this));
     229        }
     230        @Override
     231        public LispObject execute(LispObject arg) throws ConditionThrowable
     232        {
     233            if (arg instanceof LispCharacter)
     234                return T;
     235            return type_error(arg, Symbol.CHARACTER);
     236        }
     237        @Override
    219238        public LispObject execute(LispObject first, LispObject second)
    220239            throws ConditionThrowable
     
    232251            }
    233252        }
     253        @Override
    234254        public LispObject execute(LispObject[] args) throws ConditionThrowable
    235255        {
     
    256276        new Primitive("char<=", "&rest characters")
    257277    {
    258         public LispObject execute() throws ConditionThrowable
    259         {
    260             return error(new WrongNumberOfArgumentsException(this));
    261         }
    262         public LispObject execute(LispObject arg) throws ConditionThrowable
    263         {
    264             if (arg instanceof LispCharacter)
    265                 return T;
    266             return type_error(arg, Symbol.CHARACTER);
    267         }
     278        @Override
     279        public LispObject execute() throws ConditionThrowable
     280        {
     281            return error(new WrongNumberOfArgumentsException(this));
     282        }
     283        @Override
     284        public LispObject execute(LispObject arg) throws ConditionThrowable
     285        {
     286            if (arg instanceof LispCharacter)
     287                return T;
     288            return type_error(arg, Symbol.CHARACTER);
     289        }
     290        @Override
    268291        public LispObject execute(LispObject first, LispObject second)
    269292            throws ConditionThrowable
     
    281304            }
    282305        }
     306        @Override
    283307        public LispObject execute(LispObject first, LispObject second,
    284308                                  LispObject third)
     
    303327            }
    304328        }
     329        @Override
    305330        public LispObject execute(LispObject[] args) throws ConditionThrowable
    306331        {
     
    327352        new Primitive("char-lessp", "&rest characters")
    328353    {
    329         public LispObject execute() throws ConditionThrowable
    330         {
    331             return error(new WrongNumberOfArgumentsException(this));
    332         }
    333         public LispObject execute(LispObject arg) throws ConditionThrowable
    334         {
    335             if (arg instanceof LispCharacter)
    336                 return T;
    337             return type_error(arg, Symbol.CHARACTER);
    338         }
     354        @Override
     355        public LispObject execute() throws ConditionThrowable
     356        {
     357            return error(new WrongNumberOfArgumentsException(this));
     358        }
     359        @Override
     360        public LispObject execute(LispObject arg) throws ConditionThrowable
     361        {
     362            if (arg instanceof LispCharacter)
     363                return T;
     364            return type_error(arg, Symbol.CHARACTER);
     365        }
     366        @Override
    339367        public LispObject execute(LispObject first, LispObject second)
    340368            throws ConditionThrowable
     
    344372            return c1 < c2 ? T : NIL;
    345373        }
     374        @Override
    346375        public LispObject execute(LispObject[] array) throws ConditionThrowable
    347376        {
     
    362391        new Primitive("char-not-lessp", "&rest characters")
    363392    {
    364         public LispObject execute() throws ConditionThrowable
    365         {
    366             return error(new WrongNumberOfArgumentsException(this));
    367         }
    368         public LispObject execute(LispObject arg) throws ConditionThrowable
    369         {
    370             if (arg instanceof LispCharacter)
    371                 return T;
    372             return type_error(arg, Symbol.CHARACTER);
    373         }
     393        @Override
     394        public LispObject execute() throws ConditionThrowable
     395        {
     396            return error(new WrongNumberOfArgumentsException(this));
     397        }
     398        @Override
     399        public LispObject execute(LispObject arg) throws ConditionThrowable
     400        {
     401            if (arg instanceof LispCharacter)
     402                return T;
     403            return type_error(arg, Symbol.CHARACTER);
     404        }
     405        @Override
    374406        public LispObject execute(LispObject first, LispObject second)
    375407            throws ConditionThrowable
     
    379411            return c1 >= c2 ? T : NIL;
    380412        }
     413        @Override
    381414        public LispObject execute(LispObject[] array) throws ConditionThrowable
    382415        {
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r11391 r11488  
    379379  }
    380380
     381  @Override
    381382  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    382383  {
     
    405406  }
    406407
     408  @Override
    407409  public LispObject execute() throws ConditionThrowable
    408410  {
     
    460462  }
    461463
     464  @Override
    462465  public LispObject execute(LispObject arg) throws ConditionThrowable
    463466  {
     
    477480  }
    478481
     482  @Override
    479483  public LispObject execute(LispObject first, LispObject second)
    480484    throws ConditionThrowable
     
    495499  }
    496500
     501  @Override
    497502  public LispObject execute(LispObject first, LispObject second,
    498503                            LispObject third)
     
    514519  }
    515520
     521  @Override
    516522  public LispObject execute(LispObject first, LispObject second,
    517523                            LispObject third, LispObject fourth)
     
    533539  }
    534540
     541  @Override
    535542  public LispObject execute(LispObject first, LispObject second,
    536543                            LispObject third, LispObject fourth,
     
    554561  }
    555562
     563  @Override
    556564  public LispObject execute(LispObject first, LispObject second,
    557565                            LispObject third, LispObject fourth,
     
    576584  }
    577585
     586  @Override
    578587  public LispObject execute(LispObject first, LispObject second,
    579588                            LispObject third, LispObject fourth,
     
    599608  }
    600609
     610  @Override
    601611  public LispObject execute(LispObject first, LispObject second,
    602612                            LispObject third, LispObject fourth,
     
    622632  }
    623633
     634  @Override
    624635  public LispObject execute(LispObject[] args) throws ConditionThrowable
    625636  {
     
    11111122    }
    11121123
     1124    @Override
    11131125    public String toString()
    11141126    {
     
    11511163      new Primitive("lambda-list-names", PACKAGE_SYS, true)
    11521164    {
     1165      @Override
    11531166      public LispObject execute(LispObject arg) throws ConditionThrowable
    11541167      {
  • trunk/abcl/src/org/armedbear/lisp/ClosureTemplateFunction.java

    r11476 r11488  
    6262    // execute methods have the semantic meaning
    6363    // "evaluate this object"
     64  @Override
    6465  public final LispObject execute() throws ConditionThrowable
    6566  {
     
    6768  }
    6869
     70  @Override
    6971  public final LispObject execute(LispObject arg) throws ConditionThrowable
    7072  {
     
    7274  }
    7375
     76  @Override
    7477  public final LispObject execute(LispObject first, LispObject second)
    7578    throws ConditionThrowable
     
    7881  }
    7982
     83  @Override
    8084  public final LispObject execute(LispObject first, LispObject second,
    8185                                  LispObject third)
     
    8589  }
    8690
     91  @Override
    8792  public final LispObject execute(LispObject first, LispObject second,
    8893                                  LispObject third, LispObject fourth)
     
    9297  }
    9398
     99  @Override
    94100  public final LispObject execute(LispObject first, LispObject second,
    95101                                  LispObject third, LispObject fourth,
     
    100106  }
    101107
     108  @Override
    102109  public final LispObject execute(LispObject first, LispObject second,
    103110                                  LispObject third, LispObject fourth,
     
    108115  }
    109116
     117  @Override
    110118  public final LispObject execute(LispObject first, LispObject second,
    111119                                  LispObject third, LispObject fourth,
     
    117125  }
    118126
     127  @Override
    119128  public final LispObject execute(LispObject first, LispObject second,
    120129                                  LispObject third, LispObject fourth,
     
    127136  }
    128137
     138  @Override
    129139  public final LispObject execute(LispObject[] args)
    130140    throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java

    r11465 r11488  
    5252    }
    5353
     54    @Override
    5455    public LispObject execute() throws ConditionThrowable
    5556    {
     
    5758    }
    5859
     60    @Override
    5961    public LispObject execute(LispObject arg) throws ConditionThrowable
    6062    {
     
    6264    }
    6365
     66    @Override
    6467    public LispObject execute(LispObject first, LispObject second)
    6568        throws ConditionThrowable
     
    6871    }
    6972
     73    @Override
    7074    public LispObject execute(LispObject first, LispObject second,
    7175                              LispObject third)
     
    7579    }
    7680
     81    @Override
    7782    public LispObject execute(LispObject first, LispObject second,
    7883                              LispObject third, LispObject fourth)
     
    8287    }
    8388
     89    @Override
    8490    public LispObject execute(LispObject first, LispObject second,
    8591                              LispObject third, LispObject fourth,
     
    9096    }
    9197
     98    @Override
    9299    public LispObject execute(LispObject first, LispObject second,
    93100                              LispObject third, LispObject fourth,
     
    98105    }
    99106
     107    @Override
    100108    public LispObject execute(LispObject first, LispObject second,
    101109                              LispObject third, LispObject fourth,
     
    108116    }
    109117
     118    @Override
    110119    public LispObject execute(LispObject first, LispObject second,
    111120                              LispObject third, LispObject fourth,
     
    118127    }
    119128
     129    @Override
    120130    public LispObject execute(LispObject[] args) throws ConditionThrowable
    121131    {
  • trunk/abcl/src/org/armedbear/lisp/CompiledFunction.java

    r11391 r11488  
    4646    }
    4747
     48    @Override
    4849    public LispObject typeOf()
    4950    {
     
    5152    }
    5253
     54    @Override
    5355    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    5456    {
     
    5860    }
    5961
     62    @Override
    6063    public LispObject execute() throws ConditionThrowable
    6164    {
     
    6467    }
    6568
     69    @Override
    6670    public LispObject execute(LispObject arg) throws ConditionThrowable
    6771    {
     
    7175    }
    7276
     77    @Override
    7378    public LispObject execute(LispObject first, LispObject second)
    7479        throws ConditionThrowable
     
    8085    }
    8186
     87    @Override
    8288    public LispObject execute(LispObject first, LispObject second,
    8389                              LispObject third)
     
    9197    }
    9298
     99    @Override
    93100    public LispObject execute(LispObject first, LispObject second,
    94101                              LispObject third, LispObject fourth)
     
    103110    }
    104111
     112    @Override
    105113    public LispObject execute(LispObject first, LispObject second,
    106114                              LispObject third, LispObject fourth,
     
    117125    }
    118126
     127    @Override
    119128    public LispObject execute(LispObject first, LispObject second,
    120129                              LispObject third, LispObject fourth,
     
    132141    }
    133142
     143    @Override
    134144    public LispObject execute(LispObject first, LispObject second,
    135145                              LispObject third, LispObject fourth,
     
    149159    }
    150160
     161    @Override
    151162    public LispObject execute(LispObject first, LispObject second,
    152163                              LispObject third, LispObject fourth,
     
    167178    }
    168179
     180    @Override
    169181    public LispObject execute(LispObject[] args) throws ConditionThrowable
    170182    {
     
    176188        new Primitive("load-compiled-function", PACKAGE_SYS, true, "pathname")
    177189    {
     190        @Override
    178191        public LispObject execute(LispObject arg) throws ConditionThrowable
    179192        {
     
    193206        new Primitive("varlist", PACKAGE_SYS, false)
    194207    {
     208        @Override
    195209        public LispObject execute(LispObject arg) throws ConditionThrowable
    196210        {
  • trunk/abcl/src/org/armedbear/lisp/CompilerError.java

    r11391 r11488  
    4141    }
    4242
     43    @Override
    4344    public LispObject typeOf()
    4445    {
     
    4647    }
    4748
     49    @Override
    4850    public LispObject classOf()
    4951    {
     
    5153    }
    5254
     55    @Override
    5356    public LispObject typep(LispObject type) throws ConditionThrowable
    5457    {
  • trunk/abcl/src/org/armedbear/lisp/CompilerUnsupportedFeatureError.java

    r11391 r11488  
    4141    }
    4242
     43    @Override
    4344    public LispObject typeOf()
    4445    {
     
    4647    }
    4748
     49    @Override
    4850    public LispObject classOf()
    4951    {
     
    5153    }
    5254
     55    @Override
    5356    public LispObject typep(LispObject type) throws ConditionThrowable
    5457    {
  • trunk/abcl/src/org/armedbear/lisp/Complex.java

    r11391 r11488  
    8181  }
    8282
     83  @Override
    8384  public LispObject typeOf()
    8485  {
     
    8687  }
    8788
     89  @Override
    8890  public LispObject classOf()
    8991  {
     
    9193  }
    9294
     95  @Override
    9396  public LispObject typep(LispObject type) throws ConditionThrowable
    9497  {
     
    104107  }
    105108
     109  @Override
    106110  public LispObject NUMBERP()
    107111  {
     
    109113  }
    110114
     115  @Override
    111116  public boolean numberp()
    112117  {
     
    114119  }
    115120
     121  @Override
    116122  public boolean eql(LispObject obj)
    117123  {
     
    126132  }
    127133
     134  @Override
    128135  public boolean equal(LispObject obj)
    129136  {
     
    131138  }
    132139
     140  @Override
    133141  public boolean equalp(LispObject obj) throws ConditionThrowable
    134142  {
     
    168176  }
    169177
     178  @Override
    170179  public final LispObject incr() throws ConditionThrowable
    171180  {
     
    173182  }
    174183
     184  @Override
    175185  public final LispObject decr() throws ConditionThrowable
    176186  {
     
    178188  }
    179189
     190  @Override
    180191  public LispObject add(LispObject obj) throws ConditionThrowable
    181192  {
     
    188199  }
    189200
     201  @Override
    190202  public LispObject subtract(LispObject obj) throws ConditionThrowable
    191203  {
     
    199211  }
    200212
     213  @Override
    201214  public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
    202215  {
     
    219232  }
    220233
     234  @Override
    221235  public LispObject divideBy(LispObject obj) throws ConditionThrowable
    222236  {
     
    239253  }
    240254
     255  @Override
    241256  public boolean isEqualTo(LispObject obj) throws ConditionThrowable
    242257  {
     
    281296  }
    282297
     298  @Override
    283299  public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
    284300  {
     
    295311  }
    296312
     313  @Override
    297314  public LispObject ABS() throws ConditionThrowable
    298315  {
     
    328345  }
    329346
     347  @Override
    330348  public boolean zerop() throws ConditionThrowable
    331349  {
     
    333351  }
    334352
     353  @Override
    335354  public LispObject COMPLEXP()
    336355  {
     
    338357  }
    339358
     359  @Override
    340360  public int sxhash()
    341361  {
     
    343363  }
    344364
     365  @Override
    345366  public int psxhash()
    346367  {
     
    348369  }
    349370
     371  @Override
    350372  public String writeToString() throws ConditionThrowable
    351373  {
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r11391 r11488  
    126126    }
    127127
     128    @Override
    128129    public LispObject typeOf()
    129130    {
     
    131132    }
    132133
     134    @Override
    133135    public LispObject classOf()
    134136    {
     
    136138    }
    137139
     140    @Override
    138141    public int getRank()
    139142    {
     
    141144    }
    142145
     146    @Override
    143147    public LispObject getDimensions()
    144148    {
     
    149153    }
    150154
     155    @Override
    151156    public int getDimension(int n) throws ConditionThrowable
    152157    {
     
    160165    }
    161166
     167    @Override
    162168    public LispObject getElementType()
    163169    {
     
    165171    }
    166172
     173    @Override
    167174    public int getTotalSize()
    168175    {
     
    170177    }
    171178
     179    @Override
    172180    public LispObject arrayDisplacement() throws ConditionThrowable
    173181    {
     
    183191    }
    184192
     193    @Override
    185194    public LispObject AREF(int index) throws ConditionThrowable
    186195    {
     
    196205    }
    197206
     207    @Override
    198208    public void aset(int index, LispObject newValue) throws ConditionThrowable
    199209    {
     
    209219    }
    210220
     221    @Override
    211222    public void fill(LispObject obj) throws ConditionThrowable
    212223    {
     
    220231    }
    221232
     233    @Override
    222234    public String writeToString() throws ConditionThrowable
    223235    {
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r11391 r11488  
    122122    }
    123123
     124    @Override
    124125    public LispObject typeOf()
    125126    {
     
    127128    }
    128129
     130    @Override
    129131    public LispObject classOf()
    130132    {
     
    132134    }
    133135
     136    @Override
    134137    public int getRank()
    135138    {
     
    137140    }
    138141
     142    @Override
    139143    public LispObject getDimensions()
    140144    {
     
    145149    }
    146150
     151    @Override
    147152    public int getDimension(int n) throws ConditionThrowable
    148153    {
     
    156161    }
    157162
     163    @Override
    158164    public LispObject getElementType()
    159165    {
     
    161167    }
    162168
     169    @Override
    163170    public int getTotalSize()
    164171    {
     
    166173    }
    167174
     175    @Override
    168176    public LispObject arrayDisplacement() throws ConditionThrowable
    169177    {
     
    179187    }
    180188
     189    @Override
    181190    public LispObject AREF(int index) throws ConditionThrowable
    182191    {
     
    192201    }
    193202
     203    @Override
    194204    public void aset(int index, LispObject newValue) throws ConditionThrowable
    195205    {
     
    205215    }
    206216
     217    @Override
    207218    public void fill(LispObject obj) throws ConditionThrowable
    208219    {
     
    216227    }
    217228
     229    @Override
    218230    public String writeToString() throws ConditionThrowable
    219231    {
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r11391 r11488  
    118118    }
    119119
     120    @Override
    120121    public LispObject typeOf()
    121122    {
     
    123124    }
    124125
     126    @Override
    125127    public LispObject classOf()
    126128    {
     
    128130    }
    129131
     132    @Override
    130133    public int getRank()
    131134    {
     
    133136    }
    134137
     138    @Override
    135139    public LispObject getDimensions()
    136140    {
     
    141145    }
    142146
     147    @Override
    143148    public int getDimension(int n) throws ConditionThrowable
    144149    {
     
    152157    }
    153158
     159    @Override
    154160    public LispObject getElementType()
    155161    {
     
    157163    }
    158164
     165    @Override
    159166    public int getTotalSize()
    160167    {
     
    162169    }
    163170
     171    @Override
    164172    public LispObject arrayDisplacement() throws ConditionThrowable
    165173    {
     
    175183    }
    176184
     185    @Override
    177186    public LispObject AREF(int index) throws ConditionThrowable
    178187    {
     
    188197    }
    189198
     199    @Override
    190200    public void aset(int index, LispObject newValue) throws ConditionThrowable
    191201    {
     
    201211    }
    202212
     213    @Override
    203214    public void fill(LispObject obj) throws ConditionThrowable
    204215    {
     
    213224    }
    214225
     226    @Override
    215227    public String writeToString() throws ConditionThrowable
    216228    {
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11391 r11488  
    6060    }
    6161
     62    @Override
    6263    public LispObject typeOf()
    6364    {
     
    6566    }
    6667
     68    @Override
    6769    public boolean hasFillPointer()
    6870    {
     
    7072    }
    7173
     74    @Override
    7275    public int getFillPointer()
    7376    {
     
    7578    }
    7679
     80    @Override
    7781    public void setFillPointer(int n)
    7882    {
     
    8084    }
    8185
     86    @Override
    8287    public void setFillPointer(LispObject obj) throws ConditionThrowable
    8388    {
     
    103108    }
    104109
     110    @Override
    105111    public LispObject arrayDisplacement() throws ConditionThrowable
    106112    {
     
    116122    }
    117123
     124    @Override
    118125    public int length()
    119126    {
     
    121128    }
    122129
     130    @Override
    123131    public LispObject elt(int index) throws ConditionThrowable
    124132    {
     
    128136    }
    129137
     138    @Override
    130139    public LispObject AREF(int index) throws ConditionThrowable
    131140    {
     
    141150    }
    142151
     152    @Override
    143153    protected int getBit(int index) throws ConditionThrowable
    144154    {
     
    150160    }
    151161
     162    @Override
    152163    public void aset(int index, LispObject newValue) throws ConditionThrowable
    153164    {
     
    178189    }
    179190
     191    @Override
    180192    protected void setBit(int index) throws ConditionThrowable
    181193    {
     
    187199    }
    188200
     201    @Override
    189202    protected void clearBit(int index) throws ConditionThrowable
    190203    {
     
    196209    }
    197210
     211    @Override
    198212    public void shrink(int n) throws ConditionThrowable
    199213    {
     
    217231    }
    218232
     233    @Override
    219234    public boolean isSimpleVector()
    220235    {
     
    223238
    224239    // FIXME
     240    @Override
    225241    public void vectorPushExtend(LispObject element) throws ConditionThrowable
    226242    {
     
    237253
    238254    // FIXME
     255    @Override
    239256    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    240257        throws ConditionThrowable
     
    245262
    246263    // FIXME
     264    @Override
    247265    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    248266        throws ConditionThrowable
     
    301319    }
    302320
     321    @Override
    303322    public AbstractVector adjustVector(int newCapacity,
    304323                                       LispObject initialElement,
     
    361380    }
    362381
     382    @Override
    363383    public AbstractVector adjustVector(int size, AbstractArray displacedTo,
    364384                                       int displacement)
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r11391 r11488  
    6262  }
    6363
     64  @Override
    6465  public LispObject typeOf()
    6566  {
     
    6768  }
    6869
     70  @Override
    6971  public LispObject classOf()
    7072  {
     
    7274  }
    7375
     76  @Override
    7477  public boolean hasFillPointer()
    7578  {
     
    7780  }
    7881
     82  @Override
    7983  public int getFillPointer()
    8084  {
     
    8286  }
    8387
     88  @Override
    8489  public void setFillPointer(int n)
    8590  {
     
    8792  }
    8893
     94  @Override
    8995  public void setFillPointer(LispObject obj) throws ConditionThrowable
    9096  {
     
    115121  }
    116122
     123  @Override
    117124  public boolean isDisplaced()
    118125  {
     
    120127  }
    121128
     129  @Override
    122130  public LispObject arrayDisplacement() throws ConditionThrowable
    123131  {
     
    136144  }
    137145
     146  @Override
    138147  public char[] chars() throws ConditionThrowable
    139148  {
     
    164173  }
    165174
     175  @Override
    166176  public char[] getStringChars() throws ConditionThrowable
    167177  {
     
    173183  }
    174184
     185  @Override
    175186  public boolean equal(LispObject obj) throws ConditionThrowable
    176187  {
     
    192203  }
    193204
     205  @Override
    194206  public boolean equalp(LispObject obj) throws ConditionThrowable
    195207  {
     
    218230  }
    219231
     232  @Override
    220233  public LispObject subseq(int start, int end) throws ConditionThrowable
    221234  {
     
    227240  }
    228241
     242  @Override
    229243  public void fill(LispObject obj) throws ConditionThrowable
    230244  {
     
    232246  }
    233247
     248  @Override
    234249  public void fill(char c) throws ConditionThrowable
    235250  {
     
    238253  }
    239254
     255  @Override
    240256  public void shrink(int n) throws ConditionThrowable
    241257  {
     
    281297  }
    282298
     299  @Override
    283300  public LispObject reverse() throws ConditionThrowable
    284301  {
     
    291308  }
    292309
     310  @Override
    293311  public LispObject nreverse() throws ConditionThrowable
    294312  {
     
    306324  }
    307325
     326  @Override
    308327  public String getStringValue() throws ConditionThrowable
    309328  {
     
    314333  }
    315334
     335  @Override
    316336  public Object javaInstance() throws ConditionThrowable
    317337  {
     
    319339  }
    320340
     341  @Override
    321342  public Object javaInstance(Class c) throws ConditionThrowable
    322343  {
     
    324345  }
    325346
     347  @Override
    326348  public final int capacity()
    327349  {
     
    329351  }
    330352
     353  @Override
    331354  public final int length()
    332355  {
     
    334357  }
    335358
     359  @Override
    336360  public char charAt(int index) throws ConditionThrowable
    337361  {
     
    352376  }
    353377
     378  @Override
    354379  public void setCharAt(int index, char c) throws ConditionThrowable
    355380  {
     
    369394  }
    370395
     396  @Override
    371397  public LispObject elt(int index) throws ConditionThrowable
    372398  {
     
    378404
    379405  // Ignores fill pointer.
     406  @Override
    380407  public LispObject CHAR(int index) throws ConditionThrowable
    381408  {
     
    384411
    385412  // Ignores fill pointer.
     413  @Override
    386414  public LispObject AREF(int index) throws ConditionThrowable
    387415  {
     
    390418
    391419  // Ignores fill pointer.
     420  @Override
    392421  public LispObject AREF(LispObject index) throws ConditionThrowable
    393422  {
     
    395424  }
    396425
     426  @Override
    397427  public void aset(int index, LispObject newValue) throws ConditionThrowable
    398428  {
     
    407437  }
    408438
     439  @Override
    409440  public void vectorPushExtend(LispObject element)
    410441    throws ConditionThrowable
     
    433464  }
    434465
     466  @Override
    435467  public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    436468    throws ConditionThrowable
     
    440472  }
    441473
     474  @Override
    442475  public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    443476    throws ConditionThrowable
     
    515548  }
    516549
     550  @Override
    517551  public int sxhash()
    518552  {
     
    539573
    540574  // For EQUALP hash tables.
     575  @Override
    541576  public int psxhash()
    542577  {
     
    562597  }
    563598
     599  @Override
    564600  public AbstractVector adjustVector(int newCapacity,
    565601                                     LispObject initialElement,
     
    638674  }
    639675
     676  @Override
    640677  public AbstractVector adjustVector(int newCapacity,
    641678                                     AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

    r11391 r11488  
    6565    }
    6666
     67    @Override
    6768    public LispObject typeOf()
    6869    {
     
    7071    }
    7172
     73    @Override
    7274    public LispObject classOf()
    7375    {
     
    7577    }
    7678
     79    @Override
    7780    public boolean hasFillPointer()
    7881    {
     
    8083    }
    8184
     85    @Override
    8286    public int getFillPointer()
    8387    {
     
    8589    }
    8690
     91    @Override
    8792    public void setFillPointer(int n)
    8893    {
     
    9095    }
    9196
     97    @Override
    9298    public void setFillPointer(LispObject obj) throws ConditionThrowable
    9399    {
     
    113119    }
    114120
     121    @Override
    115122    public boolean isDisplaced()
    116123    {
     
    118125    }
    119126
     127    @Override
    120128    public LispObject arrayDisplacement() throws ConditionThrowable
    121129    {
     
    131139    }
    132140
     141    @Override
    133142    public LispObject getElementType()
    134143    {
     
    136145    }
    137146
     147    @Override
    138148    public boolean isSimpleVector()
    139149    {
     
    141151    }
    142152
     153    @Override
    143154    public int capacity()
    144155    {
     
    146157    }
    147158
     159    @Override
    148160    public int length()
    149161    {
     
    151163    }
    152164
     165    @Override
    153166    public LispObject elt(int index) throws ConditionThrowable
    154167    {
     
    160173
    161174    // Ignores fill pointer.
     175    @Override
    162176    public LispObject AREF(int index) throws ConditionThrowable
    163177    {
     
    180194    // Ignores fill pointer.
    181195    // FIXME inline
     196    @Override
    182197    public LispObject AREF(LispObject index) throws ConditionThrowable
    183198    {
     
    185200    }
    186201
     202    @Override
    187203    public void aset(int index, LispObject newValue) throws ConditionThrowable
    188204    {
     
    203219    }
    204220
     221    @Override
    205222    public LispObject subseq(int start, int end) throws ConditionThrowable
    206223    {
     
    217234    }
    218235
     236    @Override
    219237    public void fill(LispObject obj) throws ConditionThrowable
    220238    {
     
    223241    }
    224242
     243    @Override
    225244    public void shrink(int n) throws ConditionThrowable
    226245    {
     
    239258    }
    240259
     260    @Override
    241261    public LispObject reverse() throws ConditionThrowable
    242262    {
     
    249269    }
    250270
     271    @Override
    251272    public LispObject nreverse() throws ConditionThrowable
    252273    {
     
    278299    }
    279300
     301    @Override
    280302    public void vectorPushExtend(LispObject element)
    281303        throws ConditionThrowable
     
    290312    }
    291313
     314    @Override
    292315    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    293316        throws ConditionThrowable
     
    297320    }
    298321
     322    @Override
    299323    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    300324        throws ConditionThrowable
     
    341365    }
    342366
     367    @Override
    343368    public AbstractVector adjustVector(int newCapacity,
    344369                                       LispObject initialElement,
     
    387412    }
    388413
     414    @Override
    389415    public AbstractVector adjustVector(int newCapacity,
    390416                                       AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r11391 r11488  
    6666    }
    6767
     68    @Override
    6869    public LispObject typeOf()
    6970    {
     
    7172    }
    7273
     74    @Override
    7375    public LispObject classOf()
    7476    {
     
    7678    }
    7779
     80    @Override
    7881    public boolean hasFillPointer()
    7982    {
     
    8184    }
    8285
     86    @Override
    8387    public int getFillPointer()
    8488    {
     
    8690    }
    8791
     92    @Override
    8893    public void setFillPointer(int n)
    8994    {
     
    9196    }
    9297
     98    @Override
    9399    public void setFillPointer(LispObject obj) throws ConditionThrowable
    94100    {
     
    114120    }
    115121
     122    @Override
    116123    public boolean isDisplaced()
    117124    {
     
    119126    }
    120127
     128    @Override
    121129    public LispObject arrayDisplacement() throws ConditionThrowable
    122130    {
     
    132140    }
    133141
     142    @Override
    134143    public LispObject getElementType()
    135144    {
     
    137146    }
    138147
     148    @Override
    139149    public boolean isSimpleVector()
    140150    {
     
    142152    }
    143153
     154    @Override
    144155    public int capacity()
    145156    {
     
    147158    }
    148159
     160    @Override
    149161    public int length()
    150162    {
     
    152164    }
    153165
     166    @Override
    154167    public LispObject elt(int index) throws ConditionThrowable
    155168    {
     
    161174
    162175    // Ignores fill pointer.
     176    @Override
    163177    public LispObject AREF(int index) throws ConditionThrowable
    164178    {
     
    181195    // Ignores fill pointer.
    182196    // FIXME inline
     197    @Override
    183198    public LispObject AREF(LispObject index) throws ConditionThrowable
    184199    {
     
    186201    }
    187202
     203    @Override
    188204    public void aset(int index, LispObject newValue) throws ConditionThrowable
    189205    {
     
    204220    }
    205221
     222    @Override
    206223    public LispObject subseq(int start, int end) throws ConditionThrowable
    207224    {
     
    218235    }
    219236
     237    @Override
    220238    public void fill(LispObject obj) throws ConditionThrowable
    221239    {
     
    224242    }
    225243
     244    @Override
    226245    public void shrink(int n) throws ConditionThrowable
    227246    {
     
    240259    }
    241260
     261    @Override
    242262    public LispObject reverse() throws ConditionThrowable
    243263    {
     
    250270    }
    251271
     272    @Override
    252273    public LispObject nreverse() throws ConditionThrowable
    253274    {
     
    279300    }
    280301
     302    @Override
    281303    public void vectorPushExtend(LispObject element)
    282304        throws ConditionThrowable
     
    292314    }
    293315
     316    @Override
    294317    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    295318        throws ConditionThrowable
     
    299322    }
    300323
     324    @Override
    301325    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    302326        throws ConditionThrowable
     
    343367    }
    344368
     369    @Override
    345370    public AbstractVector adjustVector(int newCapacity,
    346371                                       LispObject initialElement,
     
    391416    }
    392417
     418    @Override
    393419    public AbstractVector adjustVector(int newCapacity,
    394420                                       AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r11391 r11488  
    6464    }
    6565
     66    @Override
    6667    public LispObject typeOf()
    6768    {
     
    6970    }
    7071
     72    @Override
    7173    public LispObject classOf()
    7274    {
     
    7476    }
    7577
     78    @Override
    7679    public boolean hasFillPointer()
    7780    {
     
    7982    }
    8083
     84    @Override
    8185    public int getFillPointer()
    8286    {
     
    8488    }
    8589
     90    @Override
    8691    public void setFillPointer(int n)
    8792    {
     
    8994    }
    9095
     96    @Override
    9197    public void setFillPointer(LispObject obj) throws ConditionThrowable
    9298    {
     
    112118    }
    113119
     120    @Override
    114121    public boolean isDisplaced()
    115122    {
     
    117124    }
    118125
     126    @Override
    119127    public LispObject arrayDisplacement() throws ConditionThrowable
    120128    {
     
    130138    }
    131139
     140    @Override
    132141    public LispObject getElementType()
    133142    {
     
    135144    }
    136145
     146    @Override
    137147    public boolean isSimpleVector()
    138148    {
     
    140150    }
    141151
     152    @Override
    142153    public int capacity()
    143154    {
     
    145156    }
    146157
     158    @Override
    147159    public int length()
    148160    {
     
    150162    }
    151163
     164    @Override
    152165    public LispObject elt(int index) throws ConditionThrowable
    153166    {
     
    159172
    160173    // Ignores fill pointer.
     174    @Override
    161175    public LispObject AREF(int index) throws ConditionThrowable
    162176    {
     
    179193    // Ignores fill pointer.
    180194    // FIXME inline
     195    @Override
    181196    public LispObject AREF(LispObject index) throws ConditionThrowable
    182197    {
     
    184199    }
    185200
     201    @Override
    186202    public void aset(int index, int n) throws ConditionThrowable
    187203    {
     
    202218    }
    203219
     220    @Override
    204221    public void aset(int index, LispObject newValue) throws ConditionThrowable
    205222    {
     
    215232    }
    216233
     234    @Override
    217235    public LispObject subseq(int start, int end) throws ConditionThrowable
    218236    {
     
    229247    }
    230248
     249    @Override
    231250    public void fill(LispObject obj) throws ConditionThrowable
    232251    {
     
    236255    }
    237256
     257    @Override
    238258    public void shrink(int n) throws ConditionThrowable
    239259    {
     
    252272    }
    253273
     274    @Override
    254275    public LispObject reverse() throws ConditionThrowable
    255276    {
     
    262283    }
    263284
     285    @Override
    264286    public LispObject nreverse() throws ConditionThrowable
    265287    {
     
    291313    }
    292314
     315    @Override
    293316    public void vectorPushExtend(LispObject element) throws ConditionThrowable
    294317    {
     
    303326    }
    304327
     328    @Override
    305329    public LispObject VECTOR_PUSH_EXTEND(LispObject element)
    306330        throws ConditionThrowable
     
    310334    }
    311335
     336    @Override
    312337    public LispObject VECTOR_PUSH_EXTEND(LispObject element, LispObject extension)
    313338        throws ConditionThrowable
     
    354379    }
    355380
     381    @Override
    356382    public AbstractVector adjustVector(int newCapacity,
    357383                                       LispObject initialElement,
     
    403429    }
    404430
     431    @Override
    405432    public AbstractVector adjustVector(int newCapacity,
    406433                                       AbstractArray displacedTo,
  • trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java

    r11391 r11488  
    4444    }
    4545
     46    @Override
    4647    public boolean isCharacterInputStream() throws ConditionThrowable
    4748    {
     
    5152    }
    5253
     54    @Override
    5355    public boolean isBinaryInputStream() throws ConditionThrowable
    5456    {
     
    5860    }
    5961
     62    @Override
    6063    public boolean isCharacterOutputStream() throws ConditionThrowable
    6164    {
     
    6366    }
    6467
     68    @Override
    6569    public boolean isBinaryOutputStream() throws ConditionThrowable
    6670    {
     
    6872    }
    6973
     74    @Override
    7075    public LispObject typeOf()
    7176    {
     
    7378    }
    7479
     80    @Override
    7581    public LispObject classOf()
    7682    {
     
    7884    }
    7985
     86    @Override
    8087    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    8188    {
     
    8794    }
    8895
     96    @Override
    8997    public LispObject getElementType() throws ConditionThrowable
    9098    {
     
    94102    }
    95103
     104    @Override
    96105    public LispObject readCharNoHang(boolean eofError, LispObject eofValue)
    97106        throws ConditionThrowable
     
    106115    }
    107116
     117    @Override
    108118    public LispObject listen() throws ConditionThrowable
    109119    {
     
    122132
    123133    // Returns -1 at end of file.
     134    @Override
    124135    protected int _readChar() throws ConditionThrowable
    125136    {
     
    140151    }
    141152
     153    @Override
    142154    protected void _unreadChar(int n) throws ConditionThrowable
    143155    {
     
    147159    }
    148160
     161    @Override
    149162    protected boolean _charReady() throws ConditionThrowable
    150163    {
     
    166179    }
    167180
     181    @Override
    168182    public void _writeChar(char c) throws ConditionThrowable
    169183    {
     
    171185    }
    172186
     187    @Override
    173188    public void _writeChars(char[] chars, int start, int end)
    174189        throws ConditionThrowable
     
    177192    }
    178193
     194    @Override
    179195    public void _writeString(String s) throws ConditionThrowable
    180196    {
     
    182198    }
    183199
     200    @Override
    184201    public void _writeLine(String s) throws ConditionThrowable
    185202    {
     
    188205
    189206    // Reads an 8-bit byte.
     207    @Override
    190208    public int _readByte() throws ConditionThrowable
    191209    {
     
    201219
    202220    // Writes an 8-bit byte.
     221    @Override
    203222    public void _writeByte(int n) throws ConditionThrowable
    204223    {
     
    206225    }
    207226
     227    @Override
    208228    public void _finishOutput() throws ConditionThrowable
    209229    {
     
    211231    }
    212232
     233    @Override
    213234    public void _clearInput() throws ConditionThrowable
    214235    {
     
    226247        new Primitive("make-concatenated-stream", "&rest streams")
    227248    {
     249        @Override
    228250        public LispObject execute(LispObject[] args) throws ConditionThrowable
    229251        {
     
    249271        new Primitive("concatenated-stream-streams", "concatenated-stream")
    250272    {
     273        @Override
    251274        public LispObject execute(LispObject arg) throws ConditionThrowable
    252275        {
  • trunk/abcl/src/org/armedbear/lisp/Condition.java

    r11391 r11488  
    140140  }
    141141
     142  @Override
    142143  public LispObject typeOf()
    143144  {
     
    148149  }
    149150
     151  @Override
    150152  public LispObject classOf()
    151153  {
     
    156158  }
    157159
     160  @Override
    158161  public LispObject typep(LispObject type) throws ConditionThrowable
    159162  {
     
    182185  }
    183186
     187  @Override
    184188  public String writeToString() throws ConditionThrowable
    185189  {
  • trunk/abcl/src/org/armedbear/lisp/Cons.java

    r11391 r11488  
    6060  }
    6161
     62  @Override
    6263  public LispObject typeOf()
    6364  {
     
    6566  }
    6667
     68  @Override
    6769  public LispObject classOf()
    6870  {
     
    7072  }
    7173
     74  @Override
    7275  public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    7376  {
     
    97100  }
    98101
     102  @Override
    99103  public final boolean constantp()
    100104  {
     
    108112  }
    109113
     114  @Override
    110115  public LispObject ATOM()
    111116  {
     
    113118  }
    114119
     120  @Override
    115121  public boolean atom()
    116122  {
     
    118124  }
    119125
     126  @Override
    120127  public final LispObject car()
    121128  {
     
    123130  }
    124131
     132  @Override
    125133  public final LispObject cdr()
    126134  {
     
    128136  }
    129137
     138  @Override
    130139  public final void setCar(LispObject obj)
    131140  {
     
    133142  }
    134143
     144  @Override
    135145  public LispObject RPLACA(LispObject obj) throws ConditionThrowable
    136146  {
     
    139149  }
    140150
     151  @Override
    141152  public final void setCdr(LispObject obj)
    142153  {
     
    144155  }
    145156
     157  @Override
    146158  public LispObject RPLACD(LispObject obj) throws ConditionThrowable
    147159  {
     
    150162  }
    151163
     164  @Override
    152165  public final LispObject cadr() throws ConditionThrowable
    153166  {
     
    155168  }
    156169
     170  @Override
    157171  public final LispObject cddr() throws ConditionThrowable
    158172  {
     
    160174  }
    161175
     176  @Override
    162177  public final LispObject caddr() throws ConditionThrowable
    163178  {
     
    165180  }
    166181
     182  @Override
    167183  public LispObject nthcdr(int n) throws ConditionThrowable
    168184  {
     
    180196  }
    181197
     198  @Override
    182199  public final LispObject push(LispObject obj)
    183200  {
     
    185202  }
    186203
     204  @Override
    187205  public final int sxhash()
    188206  {
     
    212230  }
    213231
     232  @Override
    214233  public final int psxhash() //throws ConditionThrowable
    215234  {
     
    234253  }
    235254
     255  @Override
    236256  public final boolean equal(LispObject obj) throws ConditionThrowable
    237257  {
     
    246266  }
    247267
     268  @Override
    248269  public final boolean equalp(LispObject obj) throws ConditionThrowable
    249270  {
     
    258279  }
    259280
     281  @Override
    260282  public final int length() throws ConditionThrowable
    261283  {
     
    277299  }
    278300
     301  @Override
    279302  public LispObject NTH(int index) throws ConditionThrowable
    280303  {
     
    294317  }
    295318
     319  @Override
    296320  public LispObject NTH(LispObject arg) throws ConditionThrowable
    297321  {
     
    327351  }
    328352
     353  @Override
    329354  public LispObject elt(int index) throws ConditionThrowable
    330355  {
     
    362387  }
    363388
     389  @Override
    364390  public LispObject reverse() throws ConditionThrowable
    365391  {
     
    376402  }
    377403
     404  @Override
    378405  public final LispObject nreverse() throws ConditionThrowable
    379406  {
     
    409436  }
    410437
     438  @Override
    411439  public final boolean listp()
    412440  {
     
    414442  }
    415443
     444  @Override
    416445  public final LispObject LISTP()
    417446  {
     
    419448  }
    420449
     450  @Override
    421451  public final boolean endp()
    422452  {
     
    424454  }
    425455
     456  @Override
    426457  public final LispObject ENDP()
    427458  {
     
    429460  }
    430461
     462  @Override
    431463  public final LispObject[] copyToArray() throws ConditionThrowable
    432464  {
     
    442474  }
    443475
     476  @Override
    444477  public LispObject execute() throws ConditionThrowable
    445478  {
     
    452485  }
    453486
     487  @Override
    454488  public LispObject execute(LispObject arg) throws ConditionThrowable
    455489  {
     
    462496  }
    463497
     498  @Override
    464499  public LispObject execute(LispObject first, LispObject second)
    465500    throws ConditionThrowable
     
    473508  }
    474509
     510  @Override
    475511  public LispObject execute(LispObject first, LispObject second,
    476512                            LispObject third)
     
    485521  }
    486522
     523  @Override
    487524  public LispObject execute(LispObject first, LispObject second,
    488525                            LispObject third, LispObject fourth)
     
    497534  }
    498535
     536  @Override
    499537  public LispObject execute(LispObject first, LispObject second,
    500538                            LispObject third, LispObject fourth,
     
    510548  }
    511549
     550  @Override
    512551  public LispObject execute(LispObject first, LispObject second,
    513552                            LispObject third, LispObject fourth,
     
    523562  }
    524563
     564  @Override
    525565  public LispObject execute(LispObject first, LispObject second,
    526566                            LispObject third, LispObject fourth,
     
    538578  }
    539579
     580  @Override
    540581  public LispObject execute(LispObject first, LispObject second,
    541582                            LispObject third, LispObject fourth,
     
    553594  }
    554595
     596  @Override
    555597  public LispObject execute(LispObject[] args) throws ConditionThrowable
    556598  {
     
    569611  }
    570612
     613  @Override
    571614  public String writeToString() throws ConditionThrowable
    572615  {
  • trunk/abcl/src/org/armedbear/lisp/ControlError.java

    r11391 r11488  
    4949    }
    5050
     51    @Override
    5152    public LispObject typeOf()
    5253    {
     
    5455    }
    5556
     57    @Override
    5658    public LispObject classOf()
    5759    {
     
    5961    }
    6062
     63    @Override
    6164    public LispObject typep(LispObject type) throws ConditionThrowable
    6265    {
  • trunk/abcl/src/org/armedbear/lisp/DispatchMacroFunction.java

    r11391 r11488  
    6262    }
    6363
     64    @Override
    6465    public LispObject execute(LispObject first, LispObject second,
    6566                              LispObject third)
  • trunk/abcl/src/org/armedbear/lisp/DivisionByZero.java

    r11391 r11488  
    4848    }
    4949
     50    @Override
    5051    public LispObject typeOf()
    5152    {
     
    5354    }
    5455
     56    @Override
    5557    public LispObject classOf()
    5658    {
     
    5860    }
    5961
     62    @Override
    6063    public LispObject typep(LispObject type) throws ConditionThrowable
    6164    {
  • trunk/abcl/src/org/armedbear/lisp/Do.java

    r11391 r11488  
    4040    new SpecialOperator(Symbol.DO, "varlist endlist &body body")
    4141    {
     42      @Override
    4243      public LispObject execute(LispObject args, Environment env)
    4344        throws ConditionThrowable
     
    5152    new SpecialOperator(Symbol.DO_STAR, "varlist endlist &body body")
    5253    {
     54      @Override
    5355      public LispObject execute(LispObject args, Environment env)
    5456        throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

    r11391 r11488  
    6161    }
    6262
     63    @Override
    6364    public LispObject typeOf()
    6465    {
     
    6667    }
    6768
     69    @Override
    6870    public LispObject classOf()
    6971    {
     
    7173    }
    7274
     75    @Override
    7376    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
    7477    {
     
    9093    }
    9194
     95    @Override
    9296    public LispObject NUMBERP()
    9397    {
     
    9599    }
    96100
     101    @Override
    97102    public boolean numberp()
    98103    {
     
    100105    }
    101106
     107    @Override
    102108    public boolean realp()
    103109    {
     
    105111    }
    106112
     113    @Override
    107114    public boolean eql(LispObject obj)
    108115    {
     
    123130    }
    124131
     132    @Override
    125133    public boolean equal(LispObject obj)
    126134    {
     
    140148    }
    141149
     150    @Override
    142151    public boolean equalp(int n)
    143152    {
     
    146155    }
    147156
     157    @Override
    148158    public boolean equalp(LispObject obj) throws ConditionThrowable
    149159    {
     
    161171    }
    162172
     173    @Override
    163174    public LispObject ABS()
    164175    {
     
    170181    }
    171182
     183    @Override
    172184    public boolean plusp()
    173185    {
     
    175187    }
    176188
     189    @Override
    177190    public boolean minusp()
    178191    {
     
    180193    }
    181194
     195    @Override
    182196    public boolean zerop()
    183197    {
     
    185199    }
    186200
     201    @Override
    187202    public LispObject FLOATP()
    188203    {
     
    190205    }
    191206
     207    @Override
    192208    public boolean floatp()
    193209    {
     
    212228    }
    213229
     230    @Override
    214231    public Object javaInstance()
    215232    {
     
    217234    }
    218235
     236    @Override
    219237    public Object javaInstance(Class c)
    220238    {
     
    225243    }
    226244
     245    @Override
    227246    public final LispObject incr()
    228247    {
     
    230249    }
    231250
     251    @Override
    232252    public final LispObject decr()
    233253    {
     
    235255    }
    236256
     257    @Override
    237258    public LispObject negate()
    238259    {
     
    244265    }
    245266
     267    @Override
    246268    public LispObject add(LispObject obj) throws ConditionThrowable
    247269    {
     
    263285    }
    264286
     287    @Override
    265288    public LispObject subtract(LispObject obj) throws ConditionThrowable
    266289    {
     
    283306    }
    284307
     308    @Override
    285309    public LispObject multiplyBy(LispObject obj) throws ConditionThrowable
    286310    {
     
    303327    }
    304328
     329    @Override
    305330    public LispObject divideBy(LispObject obj) throws ConditionThrowable
    306331    {
     
    328353    }
    329354
     355    @Override
    330356    public boolean isEqualTo(LispObject obj) throws ConditionThrowable
    331357    {
     
    347373    }
    348374
     375    @Override
    349376    public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable
    350377    {
     
    352379    }
    353380
     381    @Override
    354382    public boolean isLessThan(LispObject obj) throws ConditionThrowable
    355383    {
     
    369397    }
    370398
     399    @Override
    371400    public boolean isGreaterThan(LispObject obj) throws ConditionThrowable
    372401    {
     
    386415    }
    387416
     417    @Override
    388418    public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable
    389419    {
     
    403433    }
    404434
     435    @Override
    405436    public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable
    406437    {
     
    420451    }
    421452
     453    @Override
    422454    public LispObject truncate(LispObject obj) throws ConditionThrowable
    423455    {
     
    512544    }
    513545
     546    @Override
    514547    public int hashCode()
    515548    {
     
    518551    }
    519552
     553    @Override
    520554    public int psxhash()
    521555    {
     
    526560    }
    527561
     562    @Override
    528563    public String writeToString() throws ConditionThrowable
    529564    {
  • trunk/abcl/src/org/armedbear/lisp/DowncaseStream.java

    r11391 r11488  
    4141    }
    4242
     43    @Override
    4344    public void _writeChar(char c) throws ConditionThrowable
    4445    {
     
    4647    }
    4748
     49    @Override
    4850    public void _writeString(String s) throws ConditionThrowable
    4951    {
     
    5153    }
    5254
     55    @Override
    5356    public void _writeLine(String s) throws ConditionThrowable
    5457    {
  • trunk/abcl/src/org/armedbear/lisp/EchoStream.java

    r11391 r11488  
    5454    }
    5555
     56    @Override
    5657    public LispObject getElementType() throws ConditionThrowable
    5758    {
     
    7374    }
    7475
     76    @Override
    7577    public LispObject typeOf()
    7678    {
     
    7880    }
    7981
     82    @Override
    8083    public LispObject classOf()
    8184    {
     
    8386    }
    8487
     88    @Override
    8589    public LispObject typep(LispObject type) throws ConditionThrowable
    8690    {
     
    9296    }
    9397
     98    @Override
    9499    public boolean isInputStream()
    95100    {
     
    97102    }
    98103
     104    @Override
    99105    public boolean isOutputStream()
    100106    {
     
    102108    }
    103109
     110    @Override
    104111    public boolean isCharacterInputStream() throws ConditionThrowable
    105112    {
     
    107114    }
    108115
     116    @Override
    109117    public boolean isBinaryInputStream() throws ConditionThrowable
    110118    {
     
    112120    }
    113121
     122    @Override
    114123    public boolean isCharacterOutputStream() throws ConditionThrowable
    115124    {
     
    117126    }
    118127
     128    @Override
    119129    public boolean isBinaryOutputStream() throws ConditionThrowable
    120130    {
     
    123133
    124134    // Returns -1 at end of file.
     135    @Override
    125136    protected int _readChar() throws ConditionThrowable
    126137    {
     
    136147    }
    137148
     149    @Override
    138150    protected void _unreadChar(int n) throws ConditionThrowable
    139151    {
     
    142154    }
    143155
     156    @Override
    144157    protected boolean _charReady() throws ConditionThrowable
    145158    {
     
    147160    }
    148161
     162    @Override
    149163    public void _writeChar(char c) throws ConditionThrowable
    150164    {
     
    152166    }
    153167
     168    @Override
    154169    public void _writeChars(char[] chars, int start, int end)
    155170        throws ConditionThrowable
     
    158173    }
    159174
     175    @Override
    160176    public void _writeString(String s) throws ConditionThrowable
    161177    {
     
    163179    }
    164180
     181    @Override
    165182    public void _writeLine(String s) throws ConditionThrowable
    166183    {
     
    169186
    170187    // Reads an 8-bit byte.
     188    @Override
    171189    public int _readByte() throws ConditionThrowable
    172190    {
     
    178196
    179197    // Writes an 8-bit byte.
     198    @Override
    180199    public void _writeByte(int n) throws ConditionThrowable
    181200    {
     
    183202    }
    184203
     204    @Override
    185205    public void _finishOutput() throws ConditionThrowable
    186206    {
     
    188208    }
    189209
     210    @Override
    190211    public void _clearInput() throws ConditionThrowable
    191212    {
     
    193214    }
    194215
     216    @Override
    195217    public LispObject close(LispObject abort) throws ConditionThrowable
    196218    {
     
    202224    }
    203225
     226    @Override
    204227    public LispObject listen() throws ConditionThrowable
    205228    {
     
    207230    }
    208231
     232    @Override
    209233    public LispObject freshLine() throws ConditionThrowable
    210234    {
     
    212236    }
    213237
     238    @Override
    214239    public String toString()
    215240    {
     
    222247        new Primitive("make-echo-stream", "input-stream output-stream")
    223248    {
     249        @Override
    224250        public LispObject execute(LispObject first, LispObject second)
    225251            throws ConditionThrowable
     
    238264        new Primitive("echo-stream-input-stream", "echo-stream")
    239265    {
     266        @Override
    240267        public LispObject execute(LispObject arg) throws ConditionThrowable
    241268        {
     
    251278        new Primitive("echo-stream-output-stream", "echo-stream")
    252279    {
     280        @Override
    253281        public LispObject execute(LispObject arg) throws ConditionThrowable
    254282        {
  • trunk/abcl/src/org/armedbear/lisp/EndOfFile.java

    r11391 r11488  
    4848    }
    4949
     50    @Override
    5051    public LispObject typeOf()
    5152    {
     
    5354    }
    5455
     56    @Override
    5557    public LispObject classOf()
    5658    {
     
    5860    }
    5961
     62    @Override
    6063    public LispObject typep(LispObject type) throws ConditionThrowable
    6164    {
     
    6770    }
    6871
     72    @Override
    6973    public String writeToString() throws ConditionThrowable
    7074    {
  • trunk/abcl/src/org/armedbear/lisp/EqHashTable.java

    r11391 r11488  
    4848    }
    4949
     50    @Override
    5051    public Symbol getTest()
    5152    {
     
    5354    }
    5455
     56    @Override
    5557    public LispObject get(LispObject key)
    5658    {
     
    7274    }
    7375
     76    @Override
    7477    public void put(LispObject key, LispObject value)
    7578    {
     
    103106    }
    104107
     108    @Override
    105109    public LispObject remove(LispObject key)
    106110    {
     
    130134    }
    131135
     136    @Override
    132137    protected void rehash()
    133138    {
  • trunk/abcl/src/org/armedbear/lisp/EqlHashTable.java

    r11391 r11488  
    4949  }
    5050
     51  @Override
    5152  public Symbol getTest()
    5253  {
     
    5455  }
    5556
     57  @Override
    5658  public LispObject get(LispObject key)
    5759  {
     
    6668  }
    6769
     70  @Override
    6871  public void put(LispObject key, LispObject value)
    6972  {
     
    9194  }
    9295
     96  @Override
    9397  public LispObject remove(LispObject key)
    9498  {
     
    113117  }
    114118
     119  @Override
    115120  protected void rehash()
    116121  {
  • trunk/abcl/src/org/armedbear/lisp/EqualHashTable.java

    r11391 r11488  
    4545  }
    4646
     47  @Override
    4748  public Symbol getTest()
    4849  {
     
    5051  }
    5152
     53  @Override
    5254  public LispObject get(LispObject key)
    5355  {
     
    6971  }
    7072
     73  @Override
    7174  public void put(LispObject key, LispObject value) throws ConditionThrowable
    7275  {
     
    9497  }
    9598
     99  @Override
    96100  public LispObject remove(LispObject key) throws ConditionThrowable
    97101  {
     
    116120  }
    117121
     122  @Override
    118123  protected void rehash()
    119124  {
  • trunk/abcl/src/org/armedbear/lisp/EqualpHashTable.java

    r11391 r11488  
    4242  }
    4343
     44  @Override
    4445  public Symbol getTest()
    4546  {
     
    4748  }
    4849
     50  @Override
    4951  public LispObject get(LispObject key)
    5052  {
     
    6769  }
    6870
     71  @Override
    6972  public void put(LispObject key, LispObject value) throws ConditionThrowable
    7073  {
     
    9295  }
    9396
     97  @Override
    9498  public LispObject remove(LispObject key) throws ConditionThrowable
    9599  {
     
    114118  }
    115119
     120  @Override
    116121  protected void rehash()
    117122  {
  • trunk/abcl/src/org/armedbear/lisp/Extensions.java

    r11391 r11488  
    4848    new SpecialOperator("truly-the", PACKAGE_EXT, true, "type value")
    4949    {
     50      @Override
    5051      public LispObject execute(LispObject args, Environment env)
    5152        throws ConditionThrowable
     
    6162    new Primitive(Symbol.NEQ, "obj1 obj2")
    6263    {
     64      @Override
    6365      public LispObject execute(LispObject first, LispObject second)
    6466        throws ConditionThrowable
     
    7274    new Primitive(Symbol.MEMQ, "item list")
    7375    {
     76      @Override
    7477      public LispObject execute(LispObject item, LispObject list)
    7578        throws ConditionThrowable
     
    9194    new Primitive(Symbol.MEMQL, "item list")
    9295    {
     96      @Override
    9397      public LispObject execute(LispObject item, LispObject list)
    9498        throws ConditionThrowable
     
    110114    new Primitive(Symbol.ADJOIN_EQL, "item list")
    111115    {
     116      @Override
    112117      public LispObject execute(LispObject item, LispObject list)
    113118        throws ConditionThrowable
     
    121126    new Primitive("special-variable-p", PACKAGE_EXT, true)
    122127    {
     128      @Override
    123129      public LispObject execute(LispObject arg) throws ConditionThrowable
    124130      {
     
    131137    new Primitive("source", PACKAGE_EXT, true)
    132138    {
     139      @Override
    133140      public LispObject execute(LispObject arg) throws ConditionThrowable
    134141      {
     
    141148    new Primitive("source-file-position", PACKAGE_EXT, true)
    142149    {
     150      @Override
    143151      public LispObject execute(LispObject arg) throws ConditionThrowable
    144152      {
     
    154162    new Primitive("source-pathname", PACKAGE_EXT, true)
    155163    {
     164      @Override
    156165      public LispObject execute(LispObject arg) throws ConditionThrowable
    157166      {
     
    167176    new Primitive("exit", PACKAGE_EXT, true, "&key status")
    168177    {
     178      @Override
    169179      public LispObject execute() throws ConditionThrowable
    170180      {
     
    172182        return LispThread.currentThread().nothing();
    173183      }
     184      @Override
    174185      public LispObject execute(LispObject first, LispObject second)
    175186        throws ConditionThrowable
     
    190201    new Primitive("quit", PACKAGE_EXT, true, "&key status")
    191202    {
     203      @Override
    192204      public LispObject execute() throws ConditionThrowable
    193205      {
     
    195207        return LispThread.currentThread().nothing();
    196208      }
     209      @Override
    197210      public LispObject execute(LispObject first, LispObject second)
    198211        throws ConditionThrowable
     
    213226    new Primitive("dump-java-stack", PACKAGE_EXT, true)
    214227    {
     228      @Override
    215229      public LispObject execute() throws ConditionThrowable
    216230      {
     
    224238    new Primitive("make-temp-file", PACKAGE_EXT, true, "")
    225239    {
     240      @Override
    226241      public LispObject execute() throws ConditionThrowable
    227242      {
     
    244259    new Primitive("interrupt-lisp", PACKAGE_EXT, true, "")
    245260    {
     261      @Override
    246262      public LispObject execute() throws ConditionThrowable
    247263      {
     
    255271      new Primitive("getenv", PACKAGE_EXT, true)
    256272  {
     273    @Override
    257274    public LispObject execute(LispObject arg) throws ConditionThrowable
    258275    {
  • trunk/abcl/src/org/armedbear/lisp/FaslReader.java

    r11391 r11488  
    4141                                "stream character")
    4242    {
     43        @Override
    4344        public LispObject execute(Stream stream, char ignored)
    4445            throws ConditionThrowable
     
    5960                                "stream character")
    6061    {
     62        @Override
    6163        public LispObject execute(Stream stream, char terminator)
    6264            throws ConditionThrowable
     
    115117                                "stream character")
    116118    {
     119        @Override
    117120        public LispObject execute(Stream stream, char ignored)
    118121            throws ConditionThrowable
     
    127130                                "stream character")
    128131    {
     132        @Override
    129133        public LispObject execute(Stream stream, char ignored)
    130134            throws ConditionThrowable
     
    139143                                "stream character")
    140144    {
     145        @Override
    141146        public LispObject execute(Stream stream, char ignored)
    142147            throws ConditionThrowable
     
    153158                                "stream character")
    154159    {
     160        @Override
    155161        public LispObject execute(Stream stream, char c)
    156162            throws ConditionThrowable
     
    165171                                  "stream sub-char numarg")
    166172    {
     173        @Override
    167174        public LispObject execute(Stream stream, char c, int n)
    168175            throws ConditionThrowable
     
    191198                                  "stream sub-char numarg")
    192199    {
     200        @Override
    193201        public LispObject execute(Stream stream, char ignored, int n)
    194202            throws ConditionThrowable
     
    251259                                  "stream sub-char numarg")
    252260    {
     261        @Override
    253262        public LispObject execute(Stream stream, char c, int n)
    254263            throws ConditionThrowable
     
    269278                                  "stream sub-char numarg")
    270279    {
     280        @Override
    271281        public LispObject execute(Stream stream, char c, int n)
    272282            throws ConditionThrowable
     
    290300                                  "stream sub-char numarg")
    291301    {
     302        @Override
    292303        public LispObject execute(Stream stream, char c, int n)
    293304            throws ConditionThrowable
     
    302313                                  "stream sub-char numarg")
    303314    {
     315        @Override
    304316        public LispObject execute(Stream stream, char c, int n)
    305317            throws ConditionThrowable
     
    314326                                  "stream sub-char numarg")
    315327    {
     328        @Override
    316329        public LispObject execute(Stream stream, char c, int n)
    317330            throws ConditionThrowable
     
    326339                                  "stream sub-char numarg")
    327340    {
     341        @Override
    328342        public LispObject execute(Stream stream, char c, int n)
    329343            throws ConditionThrowable
     
    338352                                  "stream sub-char numarg")
    339353    {
     354        @Override
    340355        public LispObject execute(Stream stream, char c, int n)
    341356            throws ConditionThrowable
     
    350365                                  "stream sub-char numarg")
    351366    {
     367        @Override
    352368        public LispObject execute(Stream stream, char c, int n)
    353369            throws ConditionThrowable
     
    362378                                  "stream sub-char numarg")
    363379    {
     380        @Override
    364381        public LispObject execute(Stream stream, char c, int n)
    365382            throws ConditionThrowable
     
    374391                                  "stream sub-char numarg")
    375392    {
     393        @Override
    376394        public LispObject execute(Stream stream, char c, int n)
    377395            throws ConditionThrowable
     
    386404                                  "stream sub-char numarg")
    387405    {
     406        @Override
    388407        public LispObject execute(Stream stream, char c, int n)
    389408            throws ConditionThrowable
     
    400419                                  "stream sub-char numarg")
    401420    {
     421        @Override
    402422        public LispObject execute(Stream stream, char c, int n)
    403423            throws ConditionThrowable
     
    413433                                  "stream sub-char numarg")
    414434    {
     435        @Override
    415436        public LispObject execute(Stream stream, char c, int n)
    416437            throws ConditionThrowable
     
    426447                                  "stream sub-char numarg")
    427448    {
     449        @Override
    428450        public LispObject execute(Stream stream, char c, int n)
    429451            throws ConditionThrowable
  • trunk/abcl/src/org/armedbear/lisp/FaslReadtable.java

    r11391 r11488  
    4141    }
    4242
     43    @Override
    4344    protected void initialize()
    4445    {
  • trunk/abcl/src/org/armedbear/lisp/FastStringBuffer.java

    r11391 r11488  
    202202  }
    203203
     204  @Override
    204205  public final String toString()
    205206  {
  • trunk/abcl/src/org/armedbear/lisp/FileError.java

    r11391 r11488  
    4646    }
    4747
     48    @Override
    4849    protected void initialize(LispObject initArgs) throws ConditionThrowable
    4950    {
     
    8889    }
    8990
     91    @Override
    9092    public LispObject typeOf()
    9193    {
     
    9395    }
    9496
     97    @Override
    9598    public LispObject classOf()
    9699    {
     
    98101    }
    99102
     103    @Override
    100104    public LispObject typep(LispObject type) throws ConditionThrowable
    101105    {
  • trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java

    r11391 r11488  
    5353        new Primitive("make-fill-pointer-output-stream", PACKAGE_SYS, true)
    5454    {
     55        @Override
    5556        public LispObject execute(LispObject arg) throws ConditionThrowable
    5657        {
     
    6869    private class Writer extends java.io.Writer
    6970    {
     71        @Override
    7072        public void write(char cbuf[], int off, int len)
    7173        {
     
    9496        }
    9597
     98        @Override
    9699        public void flush()
    97100        {
    98101        }
    99102
     103        @Override
    100104        public void close()
    101105        {
  • trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

    r11391 r11488  
    4141                      "&key traps")
    4242    {
     43        @Override
    4344        public LispObject execute(LispObject[] args) throws ConditionThrowable
    4445        {
     
    7576        new Primitive("get-floating-point-modes", PACKAGE_EXT, true, "")
    7677    {
     78        @Override
    7779        public LispObject execute() throws ConditionThrowable
    7880        {
     
    100102        // See also: http://paste.lisp.org/display/10847
    101103
     104        @Override
    102105        public LispObject execute(LispObject arg) throws ConditionThrowable
    103106        {
     
    144147        new Primitive("rational", "number")
    145148    {
     149        @Override
    146150        public LispObject execute(LispObject arg) throws ConditionThrowable
    147151        {
     
    161165        new Primitive("float-radix", "float")
    162166    {
     167        @Override
    163168        public LispObject execute(LispObject arg) throws ConditionThrowable
    164169        {
     
    177182        new Primitive("float-digits", "float")
    178183    {
     184        @Override
    179185        public LispObject execute(LispObject arg) throws ConditionThrowable
    180186        {
     
    191197        new Primitive("scale-float", "float integer")
    192198    {
     199        @Override
    193200        public LispObject execute(LispObject first, LispObject second)
    194201            throws ConditionThrowable
     
    212219        new Primitive("coerce-to-single-float", PACKAGE_SYS, false)
    213220    {
     221        @Override
    214222        public LispObject execute(LispObject arg) throws ConditionThrowable
    215223        {
     
    222230        new Primitive("coerce-to-double-float", PACKAGE_SYS, false)
    223231    {
     232        @Override
    224233        public LispObject execute(LispObject arg) throws ConditionThrowable
    225234        {
     
    233242        new Primitive("float", "number &optional prototype")
    234243    {
     244        @Override
    235245        public LispObject execute(LispObject arg) throws ConditionThrowable
    236246        {
     
    239249            return SingleFloat.coerceToFloat(arg);
    240250        }
     251        @Override
    241252        public LispObject execute(LispObject first, LispObject second)
    242253            throws ConditionThrowable
     
    254265    private static final Primitive FLOATP = new Primitive("floatp", "object")
    255266    {
     267        @Override
    256268        public LispObject execute(LispObject arg) throws ConditionThrowable
    257269        {