Changeset 11714


Ignore:
Timestamp:
03/23/09 20:05:37 (13 years ago)
Author:
ehuelsmann
Message:

Use the Fixnum factory instead of creating new Fixnums all over the place.

Patch by: Douglas Miles (logicmoo at gmail.com)

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

Legend:

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

    r11711 r11714  
    8686  public final LispObject getDimensions()
    8787  {
    88     return new Cons(new Fixnum(capacity()));
     88    return new Cons(Fixnum.getInstance(capacity()));
    8989  }
    9090
     
    167167      }
    168168    error(new TypeError(sb.toString(),
    169                          new Fixnum(index),
     169                         Fixnum.getInstance(index),
    170170                         list(Symbol.INTEGER,
    171171                               Fixnum.ZERO,
    172                                new Fixnum(limit - 1))));
     172                               Fixnum.getInstance(limit - 1))));
    173173
    174174  }
  • trunk/abcl/src/org/armedbear/lisp/Autoload.java

    r11698 r11714  
    105105            final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    106106            int loadDepth = Fixnum.getValue(_LOAD_DEPTH_.symbolValue());
    107             thread.bindSpecial(_LOAD_DEPTH_, new Fixnum(++loadDepth));
     107            thread.bindSpecial(_LOAD_DEPTH_, Fixnum.getInstance(++loadDepth));
    108108            try {
    109109                if (_AUTOLOAD_VERBOSE_.symbolValue(thread) != NIL) {
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r11711 r11714  
    6060    {
    6161        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16,
    62                      new Cons(new Fixnum(capacity)));
     62                     new Cons(Fixnum.getInstance(capacity)));
    6363    }
    6464
     
    119119    {
    120120        try {
    121             return new Fixnum(elements[index]);
     121            return Fixnum.getInstance(elements[index]);
    122122        }
    123123        catch (ArrayIndexOutOfBoundsException e) {
     
    146146    {
    147147        try {
    148             return new Fixnum(elements[index]);
     148            return Fixnum.getInstance(elements[index]);
    149149        }
    150150        catch (ArrayIndexOutOfBoundsException e) {
     
    159159    {
    160160        try {
    161             return new Fixnum(elements[((Fixnum)index).value]);
     161            return Fixnum.getInstance(elements[((Fixnum)index).value]);
    162162        }
    163163        catch (ClassCastException e) {
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r11711 r11714  
    6161  {
    6262    return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32,
    63                  new Cons(new Fixnum(capacity)));
     63                 new Cons(Fixnum.getInstance(capacity)));
    6464  }
    6565
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r11711 r11714  
    5959  public LispObject typeOf()
    6060  {
    61     return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, new Cons(new Fixnum(capacity)));
     61    return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, new Cons(Fixnum.getInstance(capacity)));
    6262  }
    6363
  • trunk/abcl/src/org/armedbear/lisp/Bignum.java

    r11711 r11714  
    669669  {
    670670    if (n >= 0)
    671       return new Fixnum(value.intValue() & n);
     671      return Fixnum.getInstance(value.intValue() & n);
    672672    else
    673673      return number(value.and(BigInteger.valueOf(n)));
     
    681681        int n = ((Fixnum)obj).value;
    682682        if (n >= 0)
    683           return new Fixnum(value.intValue() & n);
     683          return Fixnum.getInstance(value.intValue() & n);
    684684        else
    685685          return number(value.and(BigInteger.valueOf(n)));
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r11711 r11714  
    149149        LispObject result = NIL;
    150150        for (int i = dimv.length; i-- > 0;)
    151             result = new Cons(new Fixnum(dimv[i]), result);
     151            result = new Cons(Fixnum.getInstance(dimv[i]), result);
    152152        return result;
    153153    }
     
    183183        if (array != null) {
    184184            value1 = array;
    185             value2 = new Fixnum(displacement);
     185            value2 = Fixnum.getInstance(displacement);
    186186        } else {
    187187            value1 = NIL;
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r11711 r11714  
    145145        LispObject result = NIL;
    146146        for (int i = dimv.length; i-- > 0;)
    147             result = new Cons(new Fixnum(dimv[i]), result);
     147            result = new Cons(Fixnum.getInstance(dimv[i]), result);
    148148        return result;
    149149    }
     
    179179        if (array != null) {
    180180            value1 = array;
    181             value2 = new Fixnum(displacement);
     181            value2 = Fixnum.getInstance(displacement);
    182182        } else {
    183183            value1 = NIL;
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r11711 r11714  
    141141        LispObject result = NIL;
    142142        for (int i = dimv.length; i-- > 0;)
    143             result = new Cons(new Fixnum(dimv[i]), result);
     143            result = new Cons(Fixnum.getInstance(dimv[i]), result);
    144144        return result;
    145145    }
     
    175175        if (array != null) {
    176176            value1 = array;
    177             value2 = new Fixnum(displacement);
     177            value2 = Fixnum.getInstance(displacement);
    178178        } else {
    179179            value1 = NIL;
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11711 r11714  
    6363    public LispObject typeOf()
    6464    {
    65         return list(Symbol.BIT_VECTOR, new Fixnum(capacity));
     65        return list(Symbol.BIT_VECTOR, Fixnum.getInstance(capacity));
    6666    }
    6767
     
    114114        if (array != null) {
    115115            value1 = array;
    116             value2 = new Fixnum(displacement);
     116            value2 = Fixnum.getInstance(displacement);
    117117        } else {
    118118            value1 = NIL;
     
    258258    {
    259259        vectorPushExtend(element);
    260         return new Fixnum(getFillPointer() - 1);
     260        return Fixnum.getInstance(getFillPointer() - 1);
    261261    }
    262262
     
    277277        aset(fp, element);
    278278        setFillPointer(fp + 1);
    279         return new Fixnum(fp);
     279        return Fixnum.getInstance(fp);
    280280    }
    281281
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r11711 r11714  
    134134      {
    135135        value1 = array;
    136         value2 = new Fixnum(displacement);
     136        value2 = Fixnum.getInstance(displacement);
    137137      }
    138138    else
     
    469469  {
    470470    vectorPushExtend(element);
    471     return new Fixnum(fillPointer - 1);
     471    return Fixnum.getInstance(fillPointer - 1);
    472472  }
    473473
     
    498498    else
    499499      array.aset(fillPointer + displacement, element);
    500     return new Fixnum(fillPointer++);
     500    return Fixnum.getInstance(fillPointer++);
    501501  }
    502502
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

    r11711 r11714  
    6868    public LispObject typeOf()
    6969    {
    70         return list(Symbol.VECTOR, T, new Fixnum(capacity));
     70        return list(Symbol.VECTOR, T, Fixnum.getInstance(capacity));
    7171    }
    7272
     
    131131        if (array != null) {
    132132            value1 = array;
    133             value2 = new Fixnum(displacement);
     133            value2 = Fixnum.getInstance(displacement);
    134134        } else {
    135135            value1 = NIL;
     
    317317    {
    318318        vectorPushExtend(element);
    319         return new Fixnum(fillPointer - 1);
     319        return Fixnum.getInstance(fillPointer - 1);
    320320    }
    321321
     
    333333        }
    334334        aset(fillPointer, element);
    335         return new Fixnum(fillPointer++);
     335        return Fixnum.getInstance(fillPointer++);
    336336    }
    337337
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r11711 r11714  
    6969    public LispObject typeOf()
    7070    {
    71         return list(Symbol.VECTOR, UNSIGNED_BYTE_32, new Fixnum(capacity));
     71        return list(Symbol.VECTOR, UNSIGNED_BYTE_32, Fixnum.getInstance(capacity));
    7272    }
    7373
     
    132132        if (array != null) {
    133133            value1 = array;
    134             value2 = new Fixnum(displacement);
     134            value2 = Fixnum.getInstance(displacement);
    135135        } else {
    136136            value1 = NIL;
     
    319319    {
    320320        vectorPushExtend(element);
    321         return new Fixnum(fillPointer - 1);
     321        return Fixnum.getInstance(fillPointer - 1);
    322322    }
    323323
     
    335335        }
    336336        aset(fillPointer, element);
    337         return new Fixnum(fillPointer++);
     337        return Fixnum.getInstance(fillPointer++);
    338338    }
    339339
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r11711 r11714  
    6767    public LispObject typeOf()
    6868    {
    69         return list(Symbol.VECTOR, UNSIGNED_BYTE_8, new Fixnum(capacity));
     69        return list(Symbol.VECTOR, UNSIGNED_BYTE_8, Fixnum.getInstance(capacity));
    7070    }
    7171
     
    130130        if (array != null) {
    131131            value1 = array;
    132             value2 = new Fixnum(displacement);
     132            value2 = Fixnum.getInstance(displacement);
    133133        } else {
    134134            value1 = NIL;
     
    331331    {
    332332        vectorPushExtend(element);
    333         return new Fixnum(fillPointer - 1);
     333        return Fixnum.getInstance(fillPointer - 1);
    334334    }
    335335
     
    347347        }
    348348        aset(fillPointer, element);
    349         return new Fixnum(fillPointer++);
     349        return Fixnum.getInstance(fillPointer++);
    350350    }
    351351
  • trunk/abcl/src/org/armedbear/lisp/Cons.java

    r11711 r11714  
    184184  {
    185185    if (n < 0)
    186       return type_error(new Fixnum(n),
     186      return type_error(Fixnum.getInstance(n),
    187187                             list(Symbol.INTEGER, Fixnum.ZERO));
    188188    LispObject result = this;
     
    303303  {
    304304    if (index < 0)
    305       type_error(new Fixnum(index), Symbol.UNSIGNED_BYTE);
     305      type_error(Fixnum.getInstance(index), Symbol.UNSIGNED_BYTE);
    306306    int i = 0;
    307307    LispObject obj = this;
     
    355355  {
    356356    if (index < 0)
    357       type_error(new Fixnum(index), Symbol.UNSIGNED_BYTE);
     357      type_error(Fixnum.getInstance(index), Symbol.UNSIGNED_BYTE);
    358358    int i = 0;
    359359    Cons cons = this;
     
    371371              {
    372372                // Index too large.
    373                 type_error(new Fixnum(index),
     373                type_error(Fixnum.getInstance(index),
    374374                                list(Symbol.INTEGER, Fixnum.ZERO,
    375                                       new Fixnum(length() - 1)));
     375                                      Fixnum.getInstance(length() - 1)));
    376376              }
    377377            else
  • trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

    r11711 r11714  
    490490            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    491491                int q = (int) quotient;
    492                 return thread.setValues(new Fixnum(q),
     492                return thread.setValues(Fixnum.getInstance(q),
    493493                                        new DoubleFloat(value - q * divisor));
    494494            }
     
    503503                m = (bits & 0xfffffffffffffL) | 0x10000000000000L;
    504504            LispObject significand = number(m);
    505             Fixnum exponent = new Fixnum(e - 1075);
    506             Fixnum sign = new Fixnum(s);
     505            Fixnum exponent = Fixnum.getInstance(e - 1075);
     506            Fixnum sign = Fixnum.getInstance(s);
    507507            LispObject result = significand;
    508508            result =
     
    523523            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    524524                int q = (int) quotient;
    525                 return thread.setValues(new Fixnum(q),
     525                return thread.setValues(Fixnum.getInstance(q),
    526526                                        new DoubleFloat(value - q * divisor));
    527527            }
     
    537537            LispObject significand = number(m);
    538538//             Debug.trace("significand = " + significand.writeToString());
    539             Fixnum exponent = new Fixnum(e - 1075);
     539            Fixnum exponent = Fixnum.getInstance(e - 1075);
    540540//             Debug.trace("exponent = " + exponent.writeToString());
    541             Fixnum sign = new Fixnum(s);
     541            Fixnum sign = Fixnum.getInstance(s);
    542542//             Debug.trace("sign = " + sign.writeToString());
    543543            LispObject result = significand;
  • trunk/abcl/src/org/armedbear/lisp/Fixnum.java

    r11711 r11714  
    3838public final class Fixnum extends LispInteger
    3939{
    40   public static final Fixnum[] constants = new Fixnum[256];
     40  public static final int MAX_POS_CACHE = 256;//just like before - however never set this to less than 256
     41  public static final Fixnum[] constants = new Fixnum[MAX_POS_CACHE];
    4142  static
    4243  {
    43     for (int i = 0; i < 256; i++)
     44    for (int i = 0; i < MAX_POS_CACHE; i++)
    4445      constants[i] = new Fixnum(i);
    4546  }
     
    5051  public static final Fixnum THREE     = constants[3];
    5152
    52   public static final Fixnum MINUS_ONE = new Fixnum(-1);
     53  public static final Fixnum MINUS_ONE = Fixnum.getInstance(-1);
    5354
    5455  public static Fixnum getInstance(int n)
    5556  {
    56     return (n >= 0 && n < 256) ? constants[n] : new Fixnum(n);
     57    return (n >= 0 && n < MAX_POS_CACHE) ? constants[n] : new Fixnum(n);
    5758  }
    5859
    5960  public final int value;
    6061
    61   public Fixnum(int value)
     62  // set to private to hunt down sneaky creators
     63  private Fixnum(int value)
    6264  {
    6365    this.value = value;
     
    8991      return Symbol.BIT;
    9092    if (value > 1)
    91       return list(Symbol.INTEGER, ZERO, new Fixnum(Integer.MAX_VALUE));
     93      return list(Symbol.INTEGER, ZERO, Fixnum.getInstance(Integer.MAX_VALUE));
    9294    return Symbol.FIXNUM;
    9395  }
     
    252254      return this;
    253255    if (value > Integer.MIN_VALUE)
    254       return new Fixnum(-value);
     256      return Fixnum.getInstance(-value);
    255257    return new Bignum(-((long)Integer.MIN_VALUE));
    256258  }
     
    371373  {
    372374    if (value < Integer.MAX_VALUE)
    373       return new Fixnum(value + 1);
     375      return Fixnum.getInstance(value + 1);
    374376    return new Bignum((long) value + 1);
    375377  }
     
    379381  {
    380382    if (value > Integer.MIN_VALUE)
    381       return new Fixnum(value - 1);
     383      return Fixnum.getInstance(value - 1);
    382384    return new Bignum((long) value - 1);
    383385  }
     
    388390    long result = 0L - value;
    389391    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
    390       return new Fixnum((int)result);
     392      return Fixnum.getInstance((int)result);
    391393    else
    392394      return new Bignum(result);
     
    398400    long result = (long) value + n;
    399401    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
    400       return new Fixnum((int)result);
     402      return Fixnum.getInstance((int)result);
    401403    else
    402404      return new Bignum(result);
     
    410412        long result = (long) value + ((Fixnum)obj).value;
    411413        if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
    412           return new Fixnum((int)result);
     414          return Fixnum.getInstance((int)result);
    413415        else
    414416          return new Bignum(result);
     
    440442    long result = (long) value - n;
    441443    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
    442       return new Fixnum((int)result);
     444      return Fixnum.getInstance((int)result);
    443445    else
    444446      return new Bignum(result);
     
    478480    long result = (long) value * n;
    479481    if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
    480       return new Fixnum((int)result);
     482      return Fixnum.getInstance((int)result);
    481483    else
    482484      return new Bignum(result);
     
    490492        long result = (long) value * ((Fixnum)obj).value;
    491493        if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE)
    492           return new Fixnum((int)result);
     494          return Fixnum.getInstance((int)result);
    493495        else
    494496          return new Bignum(result);
     
    528530            if (value > Integer.MIN_VALUE)
    529531              if (value % divisor == 0)
    530                 return new Fixnum(value / divisor);
     532                return Fixnum.getInstance(value / divisor);
    531533            return number(BigInteger.valueOf(value),
    532534                          BigInteger.valueOf(divisor));
     
    734736            int quotient = value / divisor;
    735737            int remainder = value % divisor;
    736             value1 = new Fixnum(quotient);
    737             value2 = remainder == 0 ? Fixnum.ZERO : new Fixnum(remainder);
     738            value1 = Fixnum.getInstance(quotient);
     739            value2 = remainder == 0 ? Fixnum.ZERO : Fixnum.getInstance(remainder);
    738740          }
    739741        else if (obj instanceof Bignum)
     
    809811      {
    810812        if (value > 0)
    811           return new Fixnum(r + divisor);
     813          return Fixnum.getInstance(r + divisor);
    812814      }
    813815    else
    814816      {
    815817        if (value < 0)
    816           return new Fixnum(r + divisor);
    817       }
    818     return new Fixnum(r);
     818          return Fixnum.getInstance(r + divisor);
     819      }
     820    return Fixnum.getInstance(r);
    819821  }
    820822
     
    833835      }
    834836    if (shift < 0)
    835       return new Fixnum((int)(n >> -shift));
     837      return Fixnum.getInstance((int)(n >> -shift));
    836838    if (shift <= 32)
    837839      {
    838840        n = n << shift;
    839841        if (n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE)
    840           return new Fixnum((int)n);
     842          return Fixnum.getInstance((int)n);
    841843        else
    842844          return new Bignum(n);
     
    872874  public LispObject LOGNOT()
    873875  {
    874     return new Fixnum(~value);
     876    return Fixnum.getInstance(~value);
    875877  }
    876878
     
    878880  public LispObject LOGAND(int n) throws ConditionThrowable
    879881  {
    880     return new Fixnum(value & n);
     882    return Fixnum.getInstance(value & n);
    881883  }
    882884
     
    885887  {
    886888    if (obj instanceof Fixnum)
    887       return new Fixnum(value & ((Fixnum)obj).value);
     889      return Fixnum.getInstance(value & ((Fixnum)obj).value);
    888890    if (obj instanceof Bignum)
    889891      {
     
    891893          {
    892894            int n2 = (((Bignum)obj).value).intValue();
    893             return new Fixnum(value & n2);
     895            return Fixnum.getInstance(value & n2);
    894896          }
    895897        else
     
    906908  public LispObject LOGIOR(int n) throws ConditionThrowable
    907909  {
    908     return new Fixnum(value | n);
     910    return Fixnum.getInstance(value | n);
    909911  }
    910912
     
    913915  {
    914916    if (obj instanceof Fixnum)
    915       return new Fixnum(value | ((Fixnum)obj).value);
     917      return Fixnum.getInstance(value | ((Fixnum)obj).value);
    916918    if (obj instanceof Bignum)
    917919      {
     
    926928  public LispObject LOGXOR(int n) throws ConditionThrowable
    927929  {
    928     return new Fixnum(value ^ n);
     930    return Fixnum.getInstance(value ^ n);
    929931  }
    930932
     
    933935  {
    934936    if (obj instanceof Fixnum)
    935       return new Fixnum(value ^ ((Fixnum)obj).value);
     937      return Fixnum.getInstance(value ^ ((Fixnum)obj).value);
    936938    if (obj instanceof Bignum)
    937939      {
     
    960962
    961963    if (y.compareTo (BigInteger.ZERO) < 0)
    962       return (new Fixnum(1)).divideBy(this.pow(new Bignum(y.negate())));
     964      return (Fixnum.getInstance(1)).divideBy(this.pow(new Bignum(y.negate())));
    963965
    964966    if (y.compareTo(BigInteger.ZERO) == 0)
    965967      // No need to test base here; CLHS says 0^0 == 1.
    966       return new Fixnum(1);
     968      return Fixnum.getInstance(1);
    967969     
    968970    int x = this.value;
    969971
    970972    if (x == 0)
    971       return new Fixnum(0);
     973      return Fixnum.getInstance(0);
    972974
    973975    if (x == 1)
    974       return new Fixnum(1);
     976      return Fixnum.getInstance(1);
    975977
    976978    BigInteger xy = BigInteger.ONE;
  • trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

    r11711 r11714  
    118118                    m = (bits & 0x7fffff) | 0x800000;
    119119                LispObject significand = number(m);
    120                 Fixnum exponent = new Fixnum(e - 150);
    121                 Fixnum sign = new Fixnum(s);
     120                Fixnum exponent = Fixnum.getInstance(e - 150);
     121                Fixnum sign = Fixnum.getInstance(s);
    122122                return LispThread.currentThread().setValues(significand,
    123123                                                            exponent,
     
    135135                    m = (bits & 0xfffffffffffffL) | 0x10000000000000L;
    136136                LispObject significand = number(m);
    137                 Fixnum exponent = new Fixnum(e - 1075);
    138                 Fixnum sign = new Fixnum(s);
     137                Fixnum exponent = Fixnum.getInstance(e - 1075);
     138                Fixnum sign = Fixnum.getInstance(s);
    139139                return LispThread.currentThread().setValues(significand,
    140140                                                            exponent,
     
    197197    };
    198198
    199     private static final Fixnum FIXNUM_24 = new Fixnum(24);
    200     private static final Fixnum FIXNUM_53 = new Fixnum(53);
     199    private static final Fixnum FIXNUM_24 = Fixnum.getInstance(24);
     200    private static final Fixnum FIXNUM_53 = Fixnum.getInstance(53);
    201201
    202202    // ### float-digits
     
    308308            if (arg instanceof SingleFloat) {
    309309                SingleFloat f = (SingleFloat) arg;
    310                 return new Fixnum(Float.floatToIntBits(f.value));
     310                return Fixnum.getInstance(Float.floatToIntBits(f.value));
    311311            }
    312312            return type_error(arg, Symbol.FLOAT);
  • trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java

    r11488 r11714  
    216216        try
    217217          {
    218             return new Fixnum(((HashTable)arg).getCount());
     218            return Fixnum.getInstance(((HashTable)arg).getCount());
    219219          }
    220220        catch (ClassCastException e)
     
    232232      public LispObject execute(LispObject arg) throws ConditionThrowable
    233233      {
    234         return new Fixnum(arg.sxhash());
     234        return Fixnum.getInstance(arg.sxhash());
    235235      }
    236236    };
     
    244244      public LispObject execute(LispObject arg) throws ConditionThrowable
    245245      {
    246         return new Fixnum(arg.psxhash());
     246        return Fixnum.getInstance(arg.psxhash());
    247247      }
    248248    };
     
    304304        try
    305305          {
    306             return new Fixnum(((HashTable)arg).getSize());
     306            return Fixnum.getInstance(((HashTable)arg).getSize());
    307307          }
    308308        catch (ClassCastException e)
  • trunk/abcl/src/org/armedbear/lisp/JHandler.java

    r11488 r11714  
    7272                Fixnum[] lispAi = new Fixnum[ai.length];
    7373                for (int i = 0; i < ai.length; i++) {
    74                     lispAi[i] = new Fixnum(ai[i]);
     74                    lispAi[i] = Fixnum.getInstance(ai[i]);
    7575                }
    7676                LispObject lispAiVector = new SimpleVector(lispAi);
     
    159159            if (count == 0)
    160160                entryTable.remove(event);
    161             return (new Fixnum (count--));
     161            return (Fixnum.getInstance (count--));
    162162        }
    163163    }
  • trunk/abcl/src/org/armedbear/lisp/Layout.java

    r11488 r11714  
    100100    EqHashTable ht = new EqHashTable(slotNames.length, NIL, NIL);
    101101    for (int i = slotNames.length; i-- > 0;)
    102       ht.put(slotNames[i], i < 256 ? Fixnum.constants[i] : new Fixnum(i));
     102      ht.put(slotNames[i], Fixnum.getInstance(i));
    103103    return ht;
    104104  }
     
    215215        try
    216216          {
    217             return new Fixnum(((Layout)arg).slotNames.length);
     217            return Fixnum.getInstance(((Layout)arg).slotNames.length);
    218218          }
    219219        catch (ClassCastException e)
     
    260260              {
    261261                if (slotNames[i] == second)
    262                   return new Fixnum(i);
     262                  return Fixnum.getInstance(i);
    263263              }
    264264            return NIL;
     
    286286              {
    287287                if (slotNames[i] == second)
    288                   return new Fixnum(i);
     288                  return Fixnum.getInstance(i);
    289289              }
    290290            // Reaching here, it's not an instance slot.
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r11711 r11714  
    880880  {
    881881    if (n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE)
    882       return new Fixnum((int)n);
     882      return Fixnum.getInstance((int)n);
    883883    else
    884884      return new Bignum(n);
     
    914914  {
    915915    if (n.compareTo(INT_MIN) >= 0 && n.compareTo(INT_MAX) <= 0)
    916       return new Fixnum(n.intValue());
     916      return Fixnum.getInstance(n.intValue());
    917917    else
    918918      return new Bignum(n);
     
    14961496  {
    14971497    if (n < 0 || n > 255)
    1498       type_error(new Fixnum(n), UNSIGNED_BYTE_8);
     1498      type_error(Fixnum.getInstance(n), UNSIGNED_BYTE_8);
    14991499    try
    15001500      {
     
    20832083  static
    20842084  {
    2085     Symbol.MOST_POSITIVE_FIXNUM.initializeConstant(new Fixnum(Integer.MAX_VALUE));
    2086     Symbol.MOST_NEGATIVE_FIXNUM.initializeConstant(new Fixnum(Integer.MIN_VALUE));
     2085    Symbol.MOST_POSITIVE_FIXNUM.initializeConstant(Fixnum.getInstance(Integer.MAX_VALUE));
     2086    Symbol.MOST_NEGATIVE_FIXNUM.initializeConstant(Fixnum.getInstance(Integer.MIN_VALUE));
    20872087    Symbol.MOST_POSITIVE_JAVA_LONG.initializeConstant(new Bignum(Long.MAX_VALUE));
    20882088    Symbol.MOST_NEGATIVE_JAVA_LONG.initializeConstant(new Bignum(Long.MIN_VALUE));
     
    22822282  {
    22832283    // ### array-dimension-limit
    2284     Symbol.ARRAY_DIMENSION_LIMIT.initializeConstant(new Fixnum(ARRAY_DIMENSION_MAX));
     2284    Symbol.ARRAY_DIMENSION_LIMIT.initializeConstant(Fixnum.getInstance(ARRAY_DIMENSION_MAX));
    22852285  }
    22862286
     
    22902290  static
    22912291  {
    2292     Symbol.CHAR_CODE_LIMIT.initializeConstant(new Fixnum(CHAR_MAX));
     2292    Symbol.CHAR_CODE_LIMIT.initializeConstant(Fixnum.getInstance(CHAR_MAX));
    22932293  }
    22942294
     
    24352435  {
    24362436    // ### internal-time-units-per-second
    2437     Symbol.INTERNAL_TIME_UNITS_PER_SECOND.initializeConstant(new Fixnum(1000));
     2437    Symbol.INTERNAL_TIME_UNITS_PER_SECOND.initializeConstant(Fixnum.getInstance(1000));
    24382438  }
    24392439
  • trunk/abcl/src/org/armedbear/lisp/LispCharacter.java

    r11711 r11714  
    323323          {
    324324            int n = ((LispCharacter)arg).value;
    325             return n < 256 ? Fixnum.constants[n] : new Fixnum(n);
     325            return Fixnum.getInstance(n);
    326326          }
    327327        catch (ClassCastException e)
     
    342342          {
    343343            int n = ((LispCharacter)arg).value;
    344             return n < 256 ? Fixnum.constants[n] : new Fixnum(n);
     344            return Fixnum.getInstance(n);
    345345          }
    346346        catch (ClassCastException e)
  • trunk/abcl/src/org/armedbear/lisp/LispObject.java

    r11711 r11714  
    163163  {
    164164    if (n < 0)
    165       return type_error(new Fixnum(n),
     165      return type_error(Fixnum.getInstance(n),
    166166                             list(Symbol.INTEGER, Fixnum.ZERO));
    167167    return type_error(this, Symbol.LIST);
     
    397397  public final LispObject LENGTH() throws ConditionThrowable
    398398  {
    399     return new Fixnum(length());
     399    return Fixnum.getInstance(length());
    400400  }
    401401
     
    465465    throws ConditionThrowable
    466466  {
    467     aset(index, new Fixnum(n));
     467    aset(index, Fixnum.getInstance(n));
    468468  }
    469469
     
    808808  public LispObject add(int n) throws ConditionThrowable
    809809  {
    810     return add(new Fixnum(n));
     810    return add(Fixnum.getInstance(n));
    811811  }
    812812
     
    818818  public LispObject subtract(int n) throws ConditionThrowable
    819819  {
    820     return subtract(new Fixnum(n));
     820    return subtract(Fixnum.getInstance(n));
    821821  }
    822822
     
    828828  public LispObject multiplyBy(int n) throws ConditionThrowable
    829829  {
    830     return multiplyBy(new Fixnum(n));
     830    return multiplyBy(Fixnum.getInstance(n));
    831831  }
    832832
     
    843843  public boolean isEqualTo(int n) throws ConditionThrowable
    844844  {
    845     return isEqualTo(new Fixnum(n));
     845    return isEqualTo(Fixnum.getInstance(n));
    846846  }
    847847
     
    860860  public boolean isNotEqualTo(int n) throws ConditionThrowable
    861861  {
    862     return isNotEqualTo(new Fixnum(n));
     862    return isNotEqualTo(Fixnum.getInstance(n));
    863863  }
    864864
     
    877877  public boolean isLessThan(int n) throws ConditionThrowable
    878878  {
    879     return isLessThan(new Fixnum(n));
     879    return isLessThan(Fixnum.getInstance(n));
    880880  }
    881881
     
    894894  public boolean isGreaterThan(int n) throws ConditionThrowable
    895895  {
    896     return isGreaterThan(new Fixnum(n));
     896    return isGreaterThan(Fixnum.getInstance(n));
    897897  }
    898898
     
    911911  public boolean isLessThanOrEqualTo(int n) throws ConditionThrowable
    912912  {
    913     return isLessThanOrEqualTo(new Fixnum(n));
     913    return isLessThanOrEqualTo(Fixnum.getInstance(n));
    914914  }
    915915
     
    928928  public boolean isGreaterThanOrEqualTo(int n) throws ConditionThrowable
    929929  {
    930     return isGreaterThanOrEqualTo(new Fixnum(n));
     930    return isGreaterThanOrEqualTo(Fixnum.getInstance(n));
    931931  }
    932932
     
    972972  public LispObject MOD(int divisor) throws ConditionThrowable
    973973  {
    974     return MOD(new Fixnum(divisor));
     974    return MOD(Fixnum.getInstance(divisor));
    975975  }
    976976
    977977  public LispObject ash(int shift) throws ConditionThrowable
    978978  {
    979     return ash(new Fixnum(shift));
     979    return ash(Fixnum.getInstance(shift));
    980980  }
    981981
     
    992992  public LispObject LOGAND(int n) throws ConditionThrowable
    993993  {
    994     return LOGAND(new Fixnum(n));
     994    return LOGAND(Fixnum.getInstance(n));
    995995  }
    996996
     
    10021002  public LispObject LOGIOR(int n) throws ConditionThrowable
    10031003  {
    1004     return LOGIOR(new Fixnum(n));
     1004    return LOGIOR(Fixnum.getInstance(n));
    10051005  }
    10061006
     
    10121012  public LispObject LOGXOR(int n) throws ConditionThrowable
    10131013  {
    1014     return LOGXOR(new Fixnum(n));
     1014    return LOGXOR(Fixnum.getInstance(n));
    10151015  }
    10161016
  • trunk/abcl/src/org/armedbear/lisp/Load.java

    r11698 r11714  
    341341    // internal symbol
    342342    private static final Symbol _FASL_VERSION_ =
    343         exportConstant("*FASL-VERSION*", PACKAGE_SYS, new Fixnum(29));
     343        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(29));
    344344
    345345    // ### *fasl-anonymous-package*
     
    385385        thread.bindSpecialToCurrentValue(Symbol._PACKAGE_);
    386386        int loadDepth = Fixnum.getValue(_LOAD_DEPTH_.symbolValue(thread));
    387         thread.bindSpecial(_LOAD_DEPTH_, new Fixnum(++loadDepth));
     387        thread.bindSpecial(_LOAD_DEPTH_, Fixnum.getInstance(++loadDepth));
    388388        // Compiler policy.
    389389        thread.bindSpecialToCurrentValue(_SPEED_);
     
    450450            final Environment env = new Environment();
    451451            while (true) {
    452                 sourcePositionBinding.value = new Fixnum(in.getOffset());
     452                sourcePositionBinding.value = Fixnum.getInstance(in.getOffset());
    453453                LispObject obj = in.read(false, EOF, false, thread);
    454454                if (obj == EOF)
  • trunk/abcl/src/org/armedbear/lisp/MathFunctions.java

    r11713 r11714  
    657657            throws ConditionThrowable
    658658        {
    659             if (number.realp() && !number.minusp() && base.isEqualTo(new Fixnum(10))) {
     659            if (number.realp() && !number.minusp() && base.isEqualTo(Fixnum.getInstance(10))) {
    660660                double d = DoubleFloat.coerceToFloat(number).value;
    661661                try {
  • trunk/abcl/src/org/armedbear/lisp/Nil.java

    r11711 r11714  
    137137    {
    138138        if (n < 0)
    139             return type_error(new Fixnum(n),
     139            return type_error(Fixnum.getInstance(n),
    140140                                   list(Symbol.INTEGER, Fixnum.ZERO));
    141141        return this;
  • trunk/abcl/src/org/armedbear/lisp/NilVector.java

    r11711 r11714  
    7070    public LispObject typeOf()
    7171    {
    72         return list(Symbol.NIL_VECTOR, new Fixnum(capacity));
     72        return list(Symbol.NIL_VECTOR, Fixnum.getInstance(capacity));
    7373    }
    7474
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r11711 r11714  
    21442144        try
    21452145          {
    2146             return new Fixnum(((AbstractArray)arg).getRank());
     2146            return Fixnum.getInstance(((AbstractArray)arg).getRank());
    21472147          }
    21482148        catch (ClassCastException e)
     
    21982198            return type_error(second, Symbol.FIXNUM);
    21992199          }
    2200         return new Fixnum(array.getDimension(n));
     2200        return Fixnum.getInstance(array.getDimension(n));
    22012201      }
    22022202    };
     
    22112211        try
    22122212          {
    2213             return new Fixnum(((AbstractArray)arg).getTotalSize());
     2213            return Fixnum.getInstance(((AbstractArray)arg).getTotalSize());
    22142214          }
    22152215        catch (ClassCastException e)
     
    25472547        try
    25482548          {
    2549             return new Fixnum(((AbstractArray)arg).getFillPointer());
     2549            return Fixnum.getInstance(((AbstractArray)arg).getFillPointer());
    25502550          }
    25512551        catch (ClassCastException e)
     
    26082608        v.aset(fillPointer, first);
    26092609        v.setFillPointer(fillPointer + 1);
    2610         return new Fixnum(fillPointer);
     2610        return Fixnum.getInstance(fillPointer);
    26112611      }
    26122612    };
     
    43314331      public LispObject execute(LispObject arg) throws ConditionThrowable
    43324332      {
    4333         return new Fixnum(arg.getCallCount());
     4333        return Fixnum.getInstance(arg.getCallCount());
    43344334      }
    43354335    };
     
    51935193                ++count;
    51945194              }
    5195             return new Fixnum(count);
     5195            return Fixnum.getInstance(count);
    51965196          }
    51975197        if (arg instanceof Bignum)
    5198           return new Fixnum(((Bignum)arg).value.bitLength());
     5198          return Fixnum.getInstance(((Bignum)arg).value.bitLength());
    51995199        return type_error(arg, Symbol.INTEGER);
    52005200      }
     
    52335233      public LispObject execute(LispObject arg) throws ConditionThrowable
    52345234      {
    5235         return new Fixnum(System.identityHashCode(arg));
     5235        return Fixnum.getInstance(System.identityHashCode(arg));
    52365236      }
    52375237    };
     
    52765276                      }
    52775277                    if (match)
    5278                       return new Fixnum(i);
     5278                      return Fixnum.getInstance(i);
    52795279                  }
    52805280              }
     
    53055305                      }
    53065306                    if (match)
    5307                       return new Fixnum(i);
     5307                      return Fixnum.getInstance(i);
    53085308                  }
    53095309              }
     
    58685868            if (n < 0)
    58695869              n += 256;
    5870             objects[i] = new Fixnum(n);
     5870            objects[i] = Fixnum.getInstance(n);
    58715871          }
    58725872        return new SimpleVector(objects);
  • trunk/abcl/src/org/armedbear/lisp/RandomState.java

    r11711 r11714  
    104104            if (limit > 0) {
    105105                int n = random.nextInt((int)limit);
    106                 return new Fixnum(n);
     106                return Fixnum.getInstance(n);
    107107            }
    108108        } else if (arg instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/RuntimeClass.java

    r11488 r11714  
    157157    public static final Fixnum makeLispObject(byte i) throws ConditionThrowable
    158158    {
    159         return new Fixnum(i);
     159        return Fixnum.getInstance(i);
    160160    }
    161161
    162162    public static final Fixnum makeLispObject(short i) throws ConditionThrowable
    163163    {
    164         return new Fixnum(i);
     164        return Fixnum.getInstance(i);
    165165    }
    166166
    167167    public static final Fixnum makeLispObject(int i) throws ConditionThrowable
    168168    {
    169         return new Fixnum(i);
     169        return Fixnum.getInstance(i);
    170170    }
    171171
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

    r11711 r11714  
    184184    LispObject result = NIL;
    185185    for (int i = dimv.length; i-- > 0;)
    186       result = new Cons(new Fixnum(dimv[i]), result);
     186      result = new Cons(Fixnum.getInstance(dimv[i]), result);
    187187    return result;
    188188  }
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

    r11711 r11714  
    155155        LispObject result = NIL;
    156156        for (int i = dimv.length; i-- > 0;)
    157             result = new Cons(new Fixnum(dimv[i]), result);
     157            result = new Cons(Fixnum.getInstance(dimv[i]), result);
    158158        return result;
    159159    }
     
    206206    {
    207207        try {
    208             return new Fixnum(data[index]);
     208            return Fixnum.getInstance(data[index]);
    209209        }
    210210        catch (ArrayIndexOutOfBoundsException e) {
     
    260260    {
    261261        try {
    262             return new Fixnum(data[getRowMajorIndex(subscripts)]);
     262            return Fixnum.getInstance(data[getRowMajorIndex(subscripts)]);
    263263        }
    264264        catch (ArrayIndexOutOfBoundsException e) {
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

    r11711 r11714  
    159159        LispObject result = NIL;
    160160        for (int i = dimv.length; i-- > 0;)
    161             result = new Cons(new Fixnum(dimv[i]), result);
     161            result = new Cons(Fixnum.getInstance(dimv[i]), result);
    162162        return result;
    163163    }
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r11711 r11714  
    155155        LispObject result = NIL;
    156156        for (int i = dimv.length; i-- > 0;)
    157             result = new Cons(new Fixnum(dimv[i]), result);
     157            result = new Cons(Fixnum.getInstance(dimv[i]), result);
    158158        return result;
    159159    }
  • trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java

    r11711 r11714  
    6666    public LispObject typeOf()
    6767    {
    68         return list(Symbol.SIMPLE_BIT_VECTOR, new Fixnum(capacity));
     68        return list(Symbol.SIMPLE_BIT_VECTOR, Fixnum.getInstance(capacity));
    6969    }
    7070
  • trunk/abcl/src/org/armedbear/lisp/SimpleString.java

    r11711 r11714  
    9898    public LispObject typeOf()
    9999    {
    100         return list(Symbol.SIMPLE_BASE_STRING, new Fixnum(capacity));
     100        return list(Symbol.SIMPLE_BASE_STRING, Fixnum.getInstance(capacity));
    101101    }
    102102
  • trunk/abcl/src/org/armedbear/lisp/SimpleVector.java

    r11711 r11714  
    7777  public LispObject typeOf()
    7878  {
    79     return list(Symbol.SIMPLE_VECTOR, new Fixnum(capacity));
     79    return list(Symbol.SIMPLE_VECTOR, Fixnum.getInstance(capacity));
    8080  }
    8181
  • trunk/abcl/src/org/armedbear/lisp/SingleFloat.java

    r11711 r11714  
    495495            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    496496                int q = (int) quotient;
    497                 return thread.setValues(new Fixnum(q),
     497                return thread.setValues(Fixnum.getInstance(q),
    498498                                        new SingleFloat(value - q * divisor));
    499499            }
     
    508508                m = (bits & 0x7fffff) | 0x800000;
    509509            LispObject significand = number(m);
    510             Fixnum exponent = new Fixnum(e - 150);
    511             Fixnum sign = new Fixnum(s);
     510            Fixnum exponent = Fixnum.getInstance(e - 150);
     511            Fixnum sign = Fixnum.getInstance(s);
    512512            LispObject result = significand;
    513513            result =
     
    525525            if (quotient >= Integer.MIN_VALUE && quotient <= Integer.MAX_VALUE) {
    526526                int q = (int) quotient;
    527                 return thread.setValues(new Fixnum(q),
     527                return thread.setValues(Fixnum.getInstance(q),
    528528                                        new DoubleFloat(value - q * divisor));
    529529            }
     
    538538                m = (bits & 0xfffffffffffffL) | 0x10000000000000L;
    539539            LispObject significand = number(m);
    540             Fixnum exponent = new Fixnum(e - 1075);
    541             Fixnum sign = new Fixnum(s);
     540            Fixnum exponent = Fixnum.getInstance(e - 1075);
     541            Fixnum sign = Fixnum.getInstance(s);
    542542            LispObject result = significand;
    543543            result =
  • trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java

    r11488 r11714  
    9090  public final void setLocation(int i)
    9191  {
    92     slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = new Fixnum(i);
     92    slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = Fixnum.getInstance(i);
    9393  }
    9494
  • trunk/abcl/src/org/armedbear/lisp/StandardObject.java

    r11711 r11714  
    401401            return type_error(second,
    402402                                   list(Symbol.INTEGER, Fixnum.ZERO,
    403                                          new Fixnum(instance.slots.length)));
     403                                         Fixnum.getInstance(instance.slots.length)));
    404404          }
    405405        LispObject value;
     
    412412            return type_error(second,
    413413                                   list(Symbol.INTEGER, Fixnum.ZERO,
    414                                          new Fixnum(instance.slots.length)));
     414                                         Fixnum.getInstance(instance.slots.length)));
    415415          }
    416416        if (value == UNBOUND_VALUE)
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r11711 r11714  
    786786        LispObject result =
    787787          thread.execute(fun, this, LispCharacter.getInstance(c),
    788                          (numArg < 0) ? NIL : new Fixnum(numArg));
     788                         (numArg < 0) ? NIL : Fixnum.getInstance(numArg));
    789789        LispObject[] values = thread._values;
    790790        if (values != null && values.length == 0)
     
    13511351      {
    13521352        int n = Integer.parseInt(token, radix);
    1353         return (n >= 0 && n <= 255) ? Fixnum.constants[n] : new Fixnum(n);
     1353        return (n >= 0 && n <= 255) ? Fixnum.constants[n] : Fixnum.getInstance(n);
    13541354      }
    13551355    catch (NumberFormatException e) {}
     
    14881488      {
    14891489        int n = Integer.parseInt(s, radix);
    1490         return (n >= 0 && n <= 255) ? Fixnum.constants[n] : new Fixnum(n);
     1490        return (n >= 0 && n <= 255) ? Fixnum.constants[n] : Fixnum.getInstance(n);
    14911491      }
    14921492    catch (NumberFormatException e) {}
     
    15171517      {
    15181518        int n = Integer.parseInt(s, radix);
    1519         return (n >= 0 && n <= 255) ? Fixnum.constants[n] : new Fixnum(n);
     1519        return (n >= 0 && n <= 255) ? Fixnum.constants[n] : Fixnum.getInstance(n);
    15201520      }
    15211521    catch (NumberFormatException e) {}
     
    26562656        else
    26572657          result = in.read(eofError, third, false, thread);
    2658         return thread.setValues(result, new Fixnum(in.getOffset()));
     2658        return thread.setValues(result, Fixnum.getInstance(in.getOffset()));
    26592659      }
    26602660    };
     
    29332933              {
    29342934                // End of file.
    2935                 return new Fixnum(i);
     2935                return Fixnum.getInstance(i);
    29362936              }
    29372937            v.aset(i, n);
     
    29842984      {
    29852985        Stream stream = checkStream(arg);
    2986         return new Fixnum(stream.getLineNumber() + 1);
     2986        return Fixnum.getInstance(stream.getLineNumber() + 1);
    29872987      }
    29882988    };
     
    30083008      {
    30093009        Stream stream = checkCharacterOutputStream(arg);
    3010         return new Fixnum(stream.getCharPos());
     3010        return Fixnum.getInstance(stream.getCharPos());
    30113011      }
    30123012    };
  • trunk/abcl/src/org/armedbear/lisp/StringFunctions.java

    r11488 r11714  
    143143                    if (j == end2)
    144144                        return NIL; // Strings are identical.
    145                     return new Fixnum(i);
     145                    return Fixnum.getInstance(i);
    146146                }
    147147                if (j == end2) {
    148148                    // Reached end of string2 before end of string1.
    149                     return new Fixnum(i);
     149                    return Fixnum.getInstance(i);
    150150                }
    151151                if (array1[i] != array2[j])
    152                     return new Fixnum(i);
     152                    return Fixnum.getInstance(i);
    153153                ++i;
    154154                ++j;
     
    215215                    if (j == end2)
    216216                        return NIL; // Strings are identical.
    217                     return new Fixnum(i);
     217                    return Fixnum.getInstance(i);
    218218                }
    219219                if (j == end2) {
    220220                    // Reached end of string2.
    221                     return new Fixnum(i);
     221                    return Fixnum.getInstance(i);
    222222                }
    223223                char c1 = array1[i];
     
    231231                    continue;
    232232                }
    233                 return new Fixnum(i);
     233                return Fixnum.getInstance(i);
    234234            }
    235235        }
     
    259259                    if (j == end2)
    260260                        return NIL; // Strings are identical.
    261                     return new Fixnum(i);
     261                    return Fixnum.getInstance(i);
    262262                }
    263263                if (j == end2) {
     
    273273                }
    274274                if (c1 < c2)
    275                     return new Fixnum(i);
     275                    return Fixnum.getInstance(i);
    276276                // c1 > c2
    277277                return NIL;
     
    305305                if (j == end2) {
    306306                    // Reached end of string2.
    307                     return new Fixnum(i);
     307                    return Fixnum.getInstance(i);
    308308                }
    309309                char c1 = array1[i];
     
    317317                    return NIL;
    318318                // c1 > c2
    319                 return new Fixnum(i);
     319                return Fixnum.getInstance(i);
    320320            }
    321321        }
     
    343343                if (i == end1) {
    344344                    // Reached end of string1.
    345                     return new Fixnum(i);
     345                    return Fixnum.getInstance(i);
    346346                }
    347347                if (j == end2) {
     
    359359                    return NIL;
    360360                // c1 < c2
    361                 return new Fixnum(i);
     361                return Fixnum.getInstance(i);
    362362            }
    363363        }
     
    386386                    // Reached end of string1.
    387387                    if (j == end2)
    388                         return new Fixnum(i); // Strings are identical.
     388                        return Fixnum.getInstance(i); // Strings are identical.
    389389                    return NIL;
    390390                }
    391391                if (j == end2) {
    392392                    // Reached end of string2.
    393                     return new Fixnum(i);
     393                    return Fixnum.getInstance(i);
    394394                }
    395395                char c1 = array1[i];
     
    403403                    return NIL;
    404404                // c1 > c2
    405                 return new Fixnum(i);
     405                return Fixnum.getInstance(i);
    406406            }
    407407        }
     
    431431                    if (j == end2)
    432432                        return NIL; // Strings are identical.
    433                     return new Fixnum(i);
     433                    return Fixnum.getInstance(i);
    434434                }
    435435                if (j == end2) {
     
    447447                    return NIL;
    448448                // c1 < c2
    449                 return new Fixnum(i);
     449                return Fixnum.getInstance(i);
    450450            }
    451451        }
     
    477477                if (j == end2) {
    478478                    // Reached end of string2.
    479                     return new Fixnum(i);
     479                    return Fixnum.getInstance(i);
    480480                }
    481481                char c1 = LispCharacter.toUpperCase(array1[i]);
     
    489489                    return NIL;
    490490                // c1 > c2
    491                 return new Fixnum(i);
     491                return Fixnum.getInstance(i);
    492492            }
    493493        }
     
    516516                    // Reached end of string1.
    517517                    if (j == end2)
    518                         return new Fixnum(i); // Strings are identical.
     518                        return Fixnum.getInstance(i); // Strings are identical.
    519519                    return NIL;
    520520                }
    521521                if (j == end2) {
    522522                    // Reached end of string2.
    523                     return new Fixnum(i);
     523                    return Fixnum.getInstance(i);
    524524                }
    525525                char c1 = LispCharacter.toUpperCase(array1[i]);
     
    531531                }
    532532                if (c1 > c2)
    533                     return new Fixnum(i);
     533                    return Fixnum.getInstance(i);
    534534                // c1 < c2
    535535                return NIL;
     
    559559                if (i == end1) {
    560560                    // Reached end of string1.
    561                     return new Fixnum(i);
     561                    return Fixnum.getInstance(i);
    562562                }
    563563                if (j == end2) {
     
    575575                    return NIL;
    576576                // c1 < c2
    577                 return new Fixnum(i);
     577                return Fixnum.getInstance(i);
    578578            }
    579579        }
     
    10251025            // FIXME Don't call getStringValue() here! (Just look at the chars.)
    10261026            int index = second.getStringValue().indexOf(first.getStringValue());
    1027             return index >= 0 ? new Fixnum(index) : NIL;
     1027            return index >= 0 ? Fixnum.getInstance(index) : NIL;
    10281028        }
    10291029    };
  • trunk/abcl/src/org/armedbear/lisp/StringInputStream.java

    r11434 r11714  
    142142        {
    143143            if (arg instanceof StringInputStream)
    144                 return new Fixnum(((StringInputStream)arg).getOffset());
     144                return Fixnum.getInstance(((StringInputStream)arg).getOffset());
    145145            return error(new TypeError(String.valueOf(arg) +
    146146                                        " is not a string input stream."));
  • trunk/abcl/src/org/armedbear/lisp/StructureObject.java

    r11488 r11714  
    492492        try
    493493          {
    494             return new Fixnum(((StructureObject)arg).slots.length);
     494            return Fixnum.getInstance(((StructureObject)arg).slots.length);
    495495          }
    496496        catch (ClassCastException e)
  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r11711 r11714  
    150150    parts = parts.push(new Cons("function", function));
    151151    parts = parts.push(new Cons("plist", propertyList));
    152     parts = parts.push(new Cons("flags", new Fixnum(flags)));
    153     parts = parts.push(new Cons("hash", new Fixnum(hash)));
     152    parts = parts.push(new Cons("flags", Fixnum.getInstance(flags)));
     153    parts = parts.push(new Cons("hash", Fixnum.getInstance(hash)));
    154154    return parts.nreverse();
    155155  }
  • trunk/abcl/src/org/armedbear/lisp/Time.java

    r11488 r11714  
    196196        // Convert milliseconds to hours.
    197197        return LispThread.currentThread().setValues(
    198           new Fixnum(- rawOffset).divideBy(new Fixnum(3600000)),
     198          Fixnum.getInstance(- rawOffset).divideBy(Fixnum.getInstance(3600000)),
    199199          inDaylightTime ? T : NIL);
    200200      }
  • trunk/abcl/src/org/armedbear/lisp/dotimes.java

    r11488 r11714  
    130130              {
    131131                if (binding instanceof SpecialBinding)
    132                   ((SpecialBinding)binding).value = new Fixnum(i);
     132                  ((SpecialBinding)binding).value = Fixnum.getInstance(i);
    133133                else
    134                   ((Binding)binding).value = new Fixnum(i);
     134                  ((Binding)binding).value = Fixnum.getInstance(i);
    135135                LispObject body = bodyForm;
    136136                while (body != NIL)
     
    180180              }
    181181            if (binding instanceof SpecialBinding)
    182               ((SpecialBinding)binding).value = new Fixnum(i);
     182              ((SpecialBinding)binding).value = Fixnum.getInstance(i);
    183183            else
    184               ((Binding)binding).value = new Fixnum(i);
     184              ((Binding)binding).value = Fixnum.getInstance(i);
    185185            result = eval(resultForm, ext, thread);
    186186          }
  • trunk/abcl/src/org/armedbear/lisp/logandc1.java

    r11488 r11714  
    4949        if (first instanceof Fixnum) {
    5050            if (second instanceof Fixnum)
    51                 return new Fixnum(~((Fixnum)first).value &
     51                return Fixnum.getInstance(~((Fixnum)first).value &
    5252                                  ((Fixnum)second).value);
    5353            if (second instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/logandc2.java

    r11488 r11714  
    5252        if (first instanceof Fixnum) {
    5353            if (second instanceof Fixnum)
    54                 return new Fixnum(((Fixnum)first).value &
     54                return Fixnum.getInstance(((Fixnum)first).value &
    5555                                  ~((Fixnum)second).value);
    5656            if (second instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/logcount.java

    r11488 r11714  
    5555        else
    5656            return type_error(arg, Symbol.INTEGER);
    57         return new Fixnum(n.bitCount());
     57        return Fixnum.getInstance(n.bitCount());
    5858    }
    5959
  • trunk/abcl/src/org/armedbear/lisp/lognand.java

    r11488 r11714  
    4949        if (first instanceof Fixnum) {
    5050            if (second instanceof Fixnum)
    51                 return new Fixnum(~(((Fixnum)first).value &
     51                return Fixnum.getInstance(~(((Fixnum)first).value &
    5252                                    ((Fixnum)second).value));
    5353            if (second instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/lognor.java

    r11488 r11714  
    4949        if (first instanceof Fixnum) {
    5050            if (second instanceof Fixnum)
    51                 return new Fixnum(~(((Fixnum)first).value |
     51                return Fixnum.getInstance(~(((Fixnum)first).value |
    5252                                    ((Fixnum)second).value));
    5353            if (second instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/logorc1.java

    r11488 r11714  
    5252        if (first instanceof Fixnum) {
    5353            if (second instanceof Fixnum)
    54                 return new Fixnum(~((Fixnum)first).value |
     54                return Fixnum.getInstance(~((Fixnum)first).value |
    5555                                  ((Fixnum)second).value);
    5656            if (second instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/logorc2.java

    r11488 r11714  
    5252        if (first instanceof Fixnum) {
    5353            if (second instanceof Fixnum)
    54                 return new Fixnum(((Fixnum)first).value |
     54                return Fixnum.getInstance(((Fixnum)first).value |
    5555                                  ~((Fixnum)second).value);
    5656            if (second instanceof Bignum) {
  • trunk/abcl/src/org/armedbear/lisp/scripting/AbclScriptEngine.java

    r11685 r11714  
    306306            return ((Boolean)javaObject).booleanValue() ? Lisp.T : Lisp.NIL;
    307307    } else if(javaObject instanceof Byte) {
    308             return new Fixnum(((Byte)javaObject).intValue());
     308            return Fixnum.getInstance(((Byte)javaObject).intValue());
    309309    } else if(javaObject instanceof Integer) {
    310             return new Fixnum(((Integer)javaObject).intValue());
     310            return Fixnum.getInstance(((Integer)javaObject).intValue());
    311311    } else if(javaObject instanceof Short) {
    312             return new Fixnum(((Short)javaObject).shortValue());
     312            return Fixnum.getInstance(((Short)javaObject).shortValue());
    313313    } else if(javaObject instanceof Long) {
    314314            return new Bignum((Long)javaObject);
Note: See TracChangeset for help on using the changeset viewer.