Changeset 11711


Ignore:
Timestamp:
03/15/09 15:51:40 (15 years ago)
Author:
ehuelsmann
Message:

Switch our internals over to the new variadic list() function.

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

Legend:

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

    r11575 r11711  
    191191                        for (int j = i + 1; j < dimv.length; j++) {
    192192                            if (dimv[j] != 0) {
    193                                 error(new PrintNotReadable(list2(Keyword.OBJECT,
     193                                error(new PrintNotReadable(list(Keyword.OBJECT,
    194194                                                                  this)));
    195195                                return null; // Not reached.
  • trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

    r11557 r11711  
    168168    error(new TypeError(sb.toString(),
    169169                         new Fixnum(index),
    170                          list3(Symbol.INTEGER,
     170                         list(Symbol.INTEGER,
    171171                               Fixnum.ZERO,
    172172                               new Fixnum(limit - 1))));
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

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

    r11562 r11711  
    6060  public LispObject typeOf()
    6161  {
    62     return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32,
     62    return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32,
    6363                 new Cons(new Fixnum(capacity)));
    6464  }
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

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

    r11647 r11711  
    8484  {
    8585    if (value.signum() > 0)
    86       return list2(Symbol.INTEGER,
     86      return list(Symbol.INTEGER,
    8787                   new Bignum((long)Integer.MAX_VALUE + 1));
    8888    return Symbol.BIGNUM;
  • trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java

    r11488 r11711  
    241241                        continue;
    242242                    } else
    243                         return error(new TypeError(args[i], list2(Symbol.SATISFIES,
     243                        return error(new TypeError(args[i], list(Symbol.SATISFIES,
    244244                                                                   Symbol.OUTPUT_STREAM_P)));
    245245                } else
  • trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java

    r11587 r11711  
    145145
    146146  public static final StructureClass STRUCTURE_OBJECT =
    147     new StructureClass(Symbol.STRUCTURE_OBJECT, list1(CLASS_T));
     147    new StructureClass(Symbol.STRUCTURE_OBJECT, list(CLASS_T));
    148148  static
    149149  {
     
    230230    SIMPLE_ARRAY.setDirectSuperclass(ARRAY);
    231231    SIMPLE_ARRAY.setCPL(SIMPLE_ARRAY, ARRAY, CLASS_T);
    232     SIMPLE_BASE_STRING.setDirectSuperclasses(list2(BASE_STRING, SIMPLE_STRING));
     232    SIMPLE_BASE_STRING.setDirectSuperclasses(list(BASE_STRING, SIMPLE_STRING));
    233233    SIMPLE_BASE_STRING.setCPL(SIMPLE_BASE_STRING, BASE_STRING, SIMPLE_STRING,
    234234                              STRING, VECTOR, SIMPLE_ARRAY, ARRAY, SEQUENCE,
    235235                              CLASS_T);
    236     SIMPLE_BIT_VECTOR.setDirectSuperclasses(list2(BIT_VECTOR, SIMPLE_ARRAY));
     236    SIMPLE_BIT_VECTOR.setDirectSuperclasses(list(BIT_VECTOR, SIMPLE_ARRAY));
    237237    SIMPLE_BIT_VECTOR.setCPL(SIMPLE_BIT_VECTOR, BIT_VECTOR, VECTOR,
    238238                             SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
    239     SIMPLE_STRING.setDirectSuperclasses(list3(BASE_STRING, STRING, SIMPLE_ARRAY));
     239    SIMPLE_STRING.setDirectSuperclasses(list(BASE_STRING, STRING, SIMPLE_ARRAY));
    240240    SIMPLE_STRING.setCPL(SIMPLE_STRING, BASE_STRING, STRING, VECTOR,
    241241                         SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
    242     SIMPLE_VECTOR.setDirectSuperclasses(list2(VECTOR, SIMPLE_ARRAY));
     242    SIMPLE_VECTOR.setDirectSuperclasses(list(VECTOR, SIMPLE_ARRAY));
    243243    SIMPLE_VECTOR.setCPL(SIMPLE_VECTOR, VECTOR, SIMPLE_ARRAY, ARRAY, SEQUENCE,
    244244                         CLASS_T);
     
    274274    TWO_WAY_STREAM.setDirectSuperclass(STREAM);
    275275    TWO_WAY_STREAM.setCPL(TWO_WAY_STREAM, STREAM, CLASS_T);
    276     VECTOR.setDirectSuperclasses(list2(ARRAY, SEQUENCE));
     276    VECTOR.setDirectSuperclasses(list(ARRAY, SEQUENCE));
    277277    VECTOR.setCPL(VECTOR, ARRAY, SEQUENCE, CLASS_T);
    278278  }
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r11698 r11711  
    11421142      public LispObject execute(LispObject arg) throws ConditionThrowable
    11431143      {
    1144         Closure closure = new Closure(list3(Symbol.LAMBDA, arg, NIL), new Environment());
     1144        Closure closure = new Closure(list(Symbol.LAMBDA, arg, NIL), new Environment());
    11451145        return closure.getVariableList();
    11461146      }
  • trunk/abcl/src/org/armedbear/lisp/ClosureTemplateFunction.java

    r11512 r11711  
    4343    throws ConditionThrowable
    4444  {
    45     super(list2(Symbol.LAMBDA, lambdaList), null);
     45    super(list(Symbol.LAMBDA, lambdaList), null);
    4646  }
    4747
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r11562 r11711  
    129129    public LispObject typeOf()
    130130    {
    131         return list3(Symbol.ARRAY, elementType, getDimensions());
     131        return list(Symbol.ARRAY, elementType, getDimensions());
    132132    }
    133133
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r11562 r11711  
    125125    public LispObject typeOf()
    126126    {
    127         return list3(Symbol.ARRAY, UNSIGNED_BYTE_32, getDimensions());
     127        return list(Symbol.ARRAY, UNSIGNED_BYTE_32, getDimensions());
    128128    }
    129129
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r11562 r11711  
    121121    public LispObject typeOf()
    122122    {
    123         return list3(Symbol.ARRAY, UNSIGNED_BYTE_8, getDimensions());
     123        return list(Symbol.ARRAY, UNSIGNED_BYTE_8, getDimensions());
    124124    }
    125125
     
    228228    {
    229229        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
    230             error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     230            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    231231            // Not reached.
    232232            return null;
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11562 r11711  
    6363    public LispObject typeOf()
    6464    {
    65         return list2(Symbol.BIT_VECTOR, new Fixnum(capacity));
     65        return list(Symbol.BIT_VECTOR, new Fixnum(capacity));
    6666    }
    6767
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r11562 r11711  
    6565  public LispObject typeOf()
    6666  {
    67     return list2(Symbol.STRING, number(capacity()));
     67    return list(Symbol.STRING, number(capacity()));
    6868  }
    6969
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

    r11562 r11711  
    6868    public LispObject typeOf()
    6969    {
    70         return list3(Symbol.VECTOR, T, new Fixnum(capacity));
     70        return list(Symbol.VECTOR, T, new Fixnum(capacity));
    7171    }
    7272
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

    r11562 r11711  
    6969    public LispObject typeOf()
    7070    {
    71         return list3(Symbol.VECTOR, UNSIGNED_BYTE_32, new Fixnum(capacity));
     71        return list(Symbol.VECTOR, UNSIGNED_BYTE_32, new Fixnum(capacity));
    7272    }
    7373
  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r11562 r11711  
    6767    public LispObject typeOf()
    6868    {
    69         return list3(Symbol.VECTOR, UNSIGNED_BYTE_8, new Fixnum(capacity));
     69        return list(Symbol.VECTOR, UNSIGNED_BYTE_8, new Fixnum(capacity));
    7070    }
    7171
  • trunk/abcl/src/org/armedbear/lisp/Cons.java

    r11488 r11711  
    185185    if (n < 0)
    186186      return type_error(new Fixnum(n),
    187                              list2(Symbol.INTEGER, Fixnum.ZERO));
     187                             list(Symbol.INTEGER, Fixnum.ZERO));
    188188    LispObject result = this;
    189189    for (int i = n; i-- > 0;)
     
    372372                // Index too large.
    373373                type_error(new Fixnum(index),
    374                                 list3(Symbol.INTEGER, Fixnum.ZERO,
     374                                list(Symbol.INTEGER, Fixnum.ZERO,
    375375                                      new Fixnum(length() - 1)));
    376376              }
     
    607607  private final LispObject signalExecutionError() throws ConditionThrowable
    608608  {
    609     return type_error(this, list3(Symbol.OR, Symbol.FUNCTION,
     609    return type_error(this, list(Symbol.OR, Symbol.FUNCTION,
    610610                                       Symbol.SYMBOL));
    611611  }
  • trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

    r11579 r11711  
    597597        if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
    598598            !memq(Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue(thread),
    599                   list2(Symbol.DOUBLE_FLOAT, Symbol.LONG_FLOAT)))
     599                  list(Symbol.DOUBLE_FLOAT, Symbol.LONG_FLOAT)))
    600600        {
    601601            if (s1.indexOf('E') >= 0)
  • trunk/abcl/src/org/armedbear/lisp/Extensions.java

    r11488 r11711  
    4242  public static final Symbol _ED_FUNCTIONS_ =
    4343    exportSpecial("*ED-FUNCTIONS*", PACKAGE_EXT,
    44                   list1(intern("DEFAULT-ED-FUNCTION", PACKAGE_SYS)));
     44                  list(intern("DEFAULT-ED-FUNCTION", PACKAGE_SYS)));
    4545
    4646  // ### truly-the value-type form => result*
  • trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java

    r11488 r11711  
    6161                    return new FillPointerOutputStream(string);
    6262            }
    63             return type_error(arg, list3(Symbol.AND, Symbol.STRING,
    64                                               list2(Symbol.SATISFIES,
     63            return type_error(arg, list(Symbol.AND, Symbol.STRING,
     64                                              list(Symbol.SATISFIES,
    6565                                                    Symbol.ARRAY_HAS_FILL_POINTER_P)));
    6666        }
  • trunk/abcl/src/org/armedbear/lisp/Fixnum.java

    r11579 r11711  
    8989      return Symbol.BIT;
    9090    if (value > 1)
    91       return list3(Symbol.INTEGER, ZERO, new Fixnum(Integer.MAX_VALUE));
     91      return list(Symbol.INTEGER, ZERO, new Fixnum(Integer.MAX_VALUE));
    9292    return Symbol.FIXNUM;
    9393  }
  • trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

    r11572 r11711  
    8686            if (TRAP_OVERFLOW)
    8787                traps = traps.push(Keyword.OVERFLOW);
    88             return list2(Keyword.TRAPS, traps);
     88            return list(Keyword.TRAPS, traps);
    8989        }
    9090    };
  • trunk/abcl/src/org/armedbear/lisp/HashTable.java

    r11698 r11711  
    230230    if (Symbol.PRINT_READABLY.symbolValue(LispThread.currentThread()) != NIL)
    231231      {
    232         error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     232        error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    233233        return null; // Not reached.
    234234      }
  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r11698 r11711  
    627627        else {
    628628            type_error(instanceArg,
    629                             list3(Symbol.OR, Symbol.STRING, Symbol.JAVA_OBJECT));
     629                            list(Symbol.OR, Symbol.STRING, Symbol.JAVA_OBJECT));
    630630            // Not reached.
    631631            return null;
     
    860860        }
    861861        catch (ClassCastException e) {
    862             type_error(obj, list3(Symbol.OR, Symbol.STRING,
     862            type_error(obj, list(Symbol.OR, Symbol.STRING,
    863863                                       Symbol.JAVA_OBJECT));
    864864            // Not reached.
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r11710 r11711  
    871871    if (arg instanceof LispCharacter)
    872872      return String.valueOf(new char[] {((LispCharacter)arg).value});
    873     type_error(arg, list4(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
     873    type_error(arg, list(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
    874874                               Symbol.CHARACTER));
    875875    // Not reached.
     
    11641164      getf(ctf.getPropertyList(), Symbol.CLASS_BYTES, NIL);
    11651165    if (classBytes != NIL)
    1166       result.setPropertyList(list2(Symbol.CLASS_BYTES, classBytes));
     1166      result.setPropertyList(list(Symbol.CLASS_BYTES, classBytes));
    11671167    return result;
    11681168  }
     
    12001200
    12011201  public static final LispObject FUNCTION_NAME =
    1202     list3(Symbol.OR,
     1202    list(Symbol.OR,
    12031203          Symbol.SYMBOL,
    1204           list3(Symbol.CONS,
    1205                 list2(Symbol.EQL, Symbol.SETF),
    1206                 list3(Symbol.CONS, Symbol.SYMBOL, Symbol.NULL)));
     1204          list(Symbol.CONS,
     1205                list(Symbol.EQL, Symbol.SETF),
     1206                list(Symbol.CONS, Symbol.SYMBOL, Symbol.NULL)));
    12071207
    12081208  public static final LispObject UNSIGNED_BYTE_8 =
    1209     list2(Symbol.UNSIGNED_BYTE, Fixnum.constants[8]);
     1209    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[8]);
    12101210
    12111211  public static final LispObject UNSIGNED_BYTE_16 =
    1212     list2(Symbol.UNSIGNED_BYTE, Fixnum.constants[16]);
     1212    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[16]);
    12131213
    12141214  public static final LispObject UNSIGNED_BYTE_32 =
    1215     list2(Symbol.UNSIGNED_BYTE, Fixnum.constants[32]);
     1215    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[32]);
    12161216
    12171217  public static final LispObject UNSIGNED_BYTE_32_MAX_VALUE =
     
    16191619    if (arg instanceof FileStream)
    16201620      return ((FileStream)arg).getPathname();
    1621     type_error(arg, list4(Symbol.OR, Symbol.PATHNAME,
     1621    type_error(arg, list(Symbol.OR, Symbol.PATHNAME,
    16221622                               Symbol.STRING, Symbol.FILE_STREAM));
    16231623    // Not reached.
     
    21152115    if (osName.startsWith("Linux"))
    21162116      {
    2117         Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
     2117        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21182118                                             Keyword.ABCL,
    21192119                                             Keyword.COMMON_LISP,
     
    21252125    else if (osName.startsWith("SunOS"))
    21262126      {
    2127         Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
     2127        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21282128                                             Keyword.ABCL,
    21292129                                             Keyword.COMMON_LISP,
     
    21352135    else if (osName.startsWith("Mac OS X"))
    21362136      {
    2137         Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
     2137        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21382138                                             Keyword.ABCL,
    21392139                                             Keyword.COMMON_LISP,
     
    21452145    else if (osName.startsWith("FreeBSD"))
    21462146      {
    2147         Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
     2147        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21482148                                             Keyword.ABCL,
    21492149                                             Keyword.COMMON_LISP,
     
    21552155    else if (osName.startsWith("OpenBSD"))
    21562156      {
    2157         Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
     2157        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21582158                                             Keyword.ABCL,
    21592159                                             Keyword.COMMON_LISP,
     
    21652165    else if (osName.startsWith("NetBSD"))
    21662166      {
    2167         Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
     2167        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21682168                                             Keyword.ABCL,
    21692169                                             Keyword.COMMON_LISP,
     
    21752175    else if (osName.startsWith("Windows"))
    21762176      {
    2177         Symbol.FEATURES.setSymbolValue(list6(Keyword.ARMEDBEAR,
     2177        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21782178                                             Keyword.ABCL,
    21792179                                             Keyword.COMMON_LISP,
     
    21842184    else
    21852185      {
    2186         Symbol.FEATURES.setSymbolValue(list5(Keyword.ARMEDBEAR,
     2186        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
    21872187                                             Keyword.ABCL,
    21882188                                             Keyword.COMMON_LISP,
     
    25332533  // ### *bq-vector-flag*
    25342534  public static final Symbol _BQ_VECTOR_FLAG_ =
    2535     internSpecial("*BQ-VECTOR-FLAG*", PACKAGE_SYS, list1(new Symbol("bqv")));
     2535    internSpecial("*BQ-VECTOR-FLAG*", PACKAGE_SYS, list(new Symbol("bqv")));
    25362536
    25372537  // ### *traced-names*
  • trunk/abcl/src/org/armedbear/lisp/LispCharacter.java

    r11573 r11711  
    502502        if (radix < 2 || radix > 36)
    503503          return type_error(second,
    504                                  list3(Symbol.INTEGER, Fixnum.TWO,
     504                                 list(Symbol.INTEGER, Fixnum.TWO,
    505505                                       Fixnum.constants[36]));
    506506        int weight;
     
    564564        catch (ClassCastException e) {}
    565565        return type_error(second,
    566                                list3(Symbol.INTEGER, Fixnum.TWO,
     566                               list(Symbol.INTEGER, Fixnum.TWO,
    567567                                     Fixnum.constants[36]));
    568568      }
  • trunk/abcl/src/org/armedbear/lisp/LispClass.java

    r11488 r11711  
    236236  {
    237237    Debug.assertTrue(obj1 == this);
    238     classPrecedenceList = list2(obj1, obj2);
     238    classPrecedenceList = list(obj1, obj2);
    239239  }
    240240
     
    242242  {
    243243    Debug.assertTrue(obj1 == this);
    244     classPrecedenceList = list3(obj1, obj2, obj3);
     244    classPrecedenceList = list(obj1, obj2, obj3);
    245245  }
    246246
     
    249249  {
    250250    Debug.assertTrue(obj1 == this);
    251     classPrecedenceList = list4(obj1, obj2, obj3, obj4);
     251    classPrecedenceList = list(obj1, obj2, obj3, obj4);
    252252  }
    253253
     
    256256  {
    257257    Debug.assertTrue(obj1 == this);
    258     classPrecedenceList = list5(obj1, obj2, obj3, obj4, obj5);
     258    classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5);
    259259  }
    260260
     
    263263  {
    264264    Debug.assertTrue(obj1 == this);
    265     classPrecedenceList = list6(obj1, obj2, obj3, obj4, obj5, obj6);
     265    classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5, obj6);
    266266  }
    267267
     
    271271  {
    272272    Debug.assertTrue(obj1 == this);
    273     classPrecedenceList = list7(obj1, obj2, obj3, obj4, obj5, obj6, obj7);
     273    classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5, obj6, obj7);
    274274  }
    275275
     
    280280    Debug.assertTrue(obj1 == this);
    281281    classPrecedenceList =
    282       list8(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
     282      list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
    283283  }
    284284
     
    289289    Debug.assertTrue(obj1 == this);
    290290    classPrecedenceList =
    291       list9(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
     291      list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
    292292  }
    293293
  • trunk/abcl/src/org/armedbear/lisp/LispObject.java

    r11698 r11711  
    164164    if (n < 0)
    165165      return type_error(new Fixnum(n),
    166                              list2(Symbol.INTEGER, Fixnum.ZERO));
     166                             list(Symbol.INTEGER, Fixnum.ZERO));
    167167    return type_error(this, Symbol.LIST);
    168168  }
     
    517517  public final LispObject noFillPointer() throws ConditionThrowable
    518518  {
    519     return type_error(this, list3(Symbol.AND, Symbol.VECTOR,
    520                                        list2(Symbol.SATISFIES,
     519    return type_error(this, list(Symbol.AND, Symbol.VECTOR,
     520                                       list(Symbol.SATISFIES,
    521521                                             Symbol.ARRAY_HAS_FILL_POINTER_P)));
    522522  }
  • trunk/abcl/src/org/armedbear/lisp/LispThread.java

    r11553 r11711  
    10701070                ((DoubleFloat)arg.multiplyBy(new DoubleFloat(1000))).getValue();
    10711071            if (d < 0)
    1072                 return type_error(arg, list2(Symbol.REAL, Fixnum.ZERO));
     1072                return type_error(arg, list(Symbol.REAL, Fixnum.ZERO));
    10731073            long millis = d < Long.MAX_VALUE ? (long) d : Long.MAX_VALUE;
    10741074            try {
  • trunk/abcl/src/org/armedbear/lisp/MacroObject.java

    r11488 r11711  
    4444    this.expander = expander;
    4545    if (name instanceof Symbol && name != NIL && expander instanceof Function)
    46       ((Function)expander).setLambdaName(list2(Symbol.MACRO_FUNCTION,
     46      ((Function)expander).setLambdaName(list(Symbol.MACRO_FUNCTION,
    4747                                               name));
    4848  }
  • trunk/abcl/src/org/armedbear/lisp/Nil.java

    r11698 r11711  
    138138        if (n < 0)
    139139            return type_error(new Fixnum(n),
    140                                    list2(Symbol.INTEGER, Fixnum.ZERO));
     140                                   list(Symbol.INTEGER, Fixnum.ZERO));
    141141        return this;
    142142    }
  • trunk/abcl/src/org/armedbear/lisp/NilVector.java

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

    r11581 r11711  
    103103        }
    104104        if (s.equals("..") || s.equals("../")) {
    105             directory = list2(Keyword.RELATIVE, Keyword.UP);
     105            directory = list(Keyword.RELATIVE, Keyword.UP);
    106106            return;
    107107        }
     
    628628    {
    629629        if (arg != Keyword.COMMON && arg != Keyword.LOCAL)
    630             type_error(arg, list3(Symbol.MEMBER, Keyword.COMMON,
     630            type_error(arg, list(Symbol.MEMBER, Keyword.COMMON,
    631631                                       Keyword.LOCAL));
    632632    }
     
    838838            } else if (key == Keyword.DIRECTORY) {
    839839                if (value instanceof AbstractString)
    840                     directory = list2(Keyword.ABSOLUTE, value);
     840                    directory = list(Keyword.ABSOLUTE, value);
    841841                else if (value == Keyword.WILD)
    842                     directory = list2(Keyword.ABSOLUTE, Keyword.WILD);
     842                    directory = list(Keyword.ABSOLUTE, Keyword.WILD);
    843843                else
    844844                    directory = value;
  • trunk/abcl/src/org/armedbear/lisp/Primitive0R.java

    r11488 r11711  
    100100        throws ConditionThrowable
    101101    {
    102         return _execute(list2(first, second));
     102        return _execute(list(first, second));
    103103    }
    104104
     
    108108        throws ConditionThrowable
    109109    {
    110         return _execute(list3(first, second, third));
     110        return _execute(list(first, second, third));
    111111    }
    112112
     
    116116        throws ConditionThrowable
    117117    {
    118         return _execute(list4(first, second, third, fourth));
     118        return _execute(list(first, second, third, fourth));
    119119    }
    120120
     
    125125        throws ConditionThrowable
    126126    {
    127         return _execute(list5(first, second, third, fourth, fifth));
     127        return _execute(list(first, second, third, fourth, fifth));
    128128    }
    129129
     
    134134        throws ConditionThrowable
    135135    {
    136         return _execute(list6(first, second, third, fourth, fifth, sixth));
     136        return _execute(list(first, second, third, fourth, fifth, sixth));
    137137    }
    138138
     
    144144        throws ConditionThrowable
    145145    {
    146         return _execute(list7(first, second, third, fourth, fifth, sixth,
     146        return _execute(list(first, second, third, fourth, fifth, sixth,
    147147                              seventh));
    148148    }
     
    155155        throws ConditionThrowable
    156156    {
    157         return _execute(list8(first, second, third, fourth, fifth, sixth,
     157        return _execute(list(first, second, third, fourth, fifth, sixth,
    158158                              seventh, eighth));
    159159    }
  • trunk/abcl/src/org/armedbear/lisp/Primitive1R.java

    r11488 r11711  
    102102        throws ConditionThrowable
    103103    {
    104         return _execute(first, list2(second, third));
     104        return _execute(first, list(second, third));
    105105    }
    106106
     
    110110        throws ConditionThrowable
    111111    {
    112         return _execute(first, list3(second, third, fourth));
     112        return _execute(first, list(second, third, fourth));
    113113    }
    114114
     
    119119        throws ConditionThrowable
    120120    {
    121         return _execute(first, list4(second, third, fourth, fifth));
     121        return _execute(first, list(second, third, fourth, fifth));
    122122    }
    123123
     
    128128        throws ConditionThrowable
    129129    {
    130         return _execute(first, list5(second, third, fourth, fifth, sixth));
     130        return _execute(first, list(second, third, fourth, fifth, sixth));
    131131    }
    132132
     
    138138        throws ConditionThrowable
    139139    {
    140         return _execute(first, list6(second, third, fourth, fifth, sixth,
     140        return _execute(first, list(second, third, fourth, fifth, sixth,
    141141                                     seventh));
    142142    }
     
    149149        throws ConditionThrowable
    150150    {
    151         return _execute(first, list7(second, third, fourth, fifth, sixth,
     151        return _execute(first, list(second, third, fourth, fifth, sixth,
    152152                                     seventh, eighth));
    153153    }
  • trunk/abcl/src/org/armedbear/lisp/Primitive2R.java

    r11488 r11711  
    104104        throws ConditionThrowable
    105105    {
    106         return _execute(first, second, list2(third, fourth));
     106        return _execute(first, second, list(third, fourth));
    107107    }
    108108
     
    113113        throws ConditionThrowable
    114114    {
    115         return _execute(first, second, list3(third, fourth, fifth));
     115        return _execute(first, second, list(third, fourth, fifth));
    116116    }
    117117
     
    122122        throws ConditionThrowable
    123123    {
    124         return _execute(first, second, list4(third, fourth, fifth, sixth));
     124        return _execute(first, second, list(third, fourth, fifth, sixth));
    125125    }
    126126
     
    132132        throws ConditionThrowable
    133133    {
    134         return _execute(first, second, list5(third, fourth, fifth, sixth,
     134        return _execute(first, second, list(third, fourth, fifth, sixth,
    135135                                             seventh));
    136136    }
     
    143143        throws ConditionThrowable
    144144    {
    145         return _execute(first, second, list6(third, fourth, fifth, sixth,
     145        return _execute(first, second, list(third, fourth, fifth, sixth,
    146146                                             seventh, eighth));
    147147    }
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r11539 r11711  
    15171517        if (index < 0)
    15181518          return type_error(first,
    1519                                  list2(Symbol.INTEGER, Fixnum.ZERO));
     1519                                 list(Symbol.INTEGER, Fixnum.ZERO));
    15201520        for (int i = 0; i < index; i++)
    15211521          {
     
    18331833        LispObject block = new Cons(Symbol.BLOCK, new Cons(symbol, body));
    18341834        LispObject toBeApplied =
    1835           list2(Symbol.FUNCTION, list3(Symbol.LAMBDA, lambdaList, block));
     1835          list(Symbol.FUNCTION, list(Symbol.LAMBDA, lambdaList, block));
    18361836        final LispThread thread = LispThread.currentThread();
    18371837        LispObject formArg = gensym("FORM-", thread);
    18381838        LispObject envArg = gensym("ENV-", thread); // Ignored.
    18391839        LispObject expander =
    1840           list3(Symbol.LAMBDA, list2(formArg, envArg),
    1841                 list3(Symbol.APPLY, toBeApplied,
    1842                       list2(Symbol.CDR, formArg)));
     1840          list(Symbol.LAMBDA, list(formArg, envArg),
     1841                list(Symbol.APPLY, toBeApplied,
     1842                      list(Symbol.CDR, formArg)));
    18431843        Closure expansionFunction = new Closure(expander, env);
    18441844        MacroObject macroObject =
     
    25512551        catch (ClassCastException e)
    25522552          {
    2553             return type_error(arg, list3(Symbol.AND, Symbol.VECTOR,
    2554                                               list2(Symbol.SATISFIES,
     2553            return type_error(arg, list(Symbol.AND, Symbol.VECTOR,
     2554                                              list(Symbol.SATISFIES,
    25552555                                                    Symbol.ARRAY_HAS_FILL_POINTER_P)));
    25562556          }
     
    25772577        catch (ClassCastException e)
    25782578          {
    2579             return type_error(first, list3(Symbol.AND, Symbol.VECTOR,
    2580                                                 list2(Symbol.SATISFIES,
     2579            return type_error(first, list(Symbol.AND, Symbol.VECTOR,
     2580                                                list(Symbol.SATISFIES,
    25812581                                                      Symbol.ARRAY_HAS_FILL_POINTER_P)));
    25822582          }
     
    31933193          return gensym(arg.getStringValue(), LispThread.currentThread());
    31943194        return type_error(arg,
    3195                                list3(Symbol.OR,
     3195                               list(Symbol.OR,
    31963196                                     Symbol.STRING,
    31973197                                     Symbol.UNSIGNED_BYTE));
     
    37343734          new Cons(Symbol.BLOCK, new Cons(symbol, body));
    37353735        LispObject toBeApplied =
    3736           list3(Symbol.LAMBDA, lambdaList, block);
     3736          list(Symbol.LAMBDA, lambdaList, block);
    37373737        final LispThread thread = LispThread.currentThread();
    37383738        LispObject formArg = gensym("WHOLE-", thread);
    37393739        LispObject envArg = gensym("ENVIRONMENT-", thread); // Ignored.
    37403740        LispObject expander =
    3741           list3(Symbol.LAMBDA, list2(formArg, envArg),
    3742                 list3(Symbol.APPLY, toBeApplied,
    3743                       list2(Symbol.CDR, formArg)));
     3741          list(Symbol.LAMBDA, list(formArg, envArg),
     3742                list(Symbol.APPLY, toBeApplied,
     3743                      list(Symbol.CDR, formArg)));
    37443744        return expander;
    37453745      }
     
    48844884        int size = Fixnum.getValue(first);
    48854885        if (size < 0)
    4886           return type_error(first, list3(Symbol.INTEGER, Fixnum.ZERO,
     4886          return type_error(first, list(Symbol.INTEGER, Fixnum.ZERO,
    48874887                                              Symbol.MOST_POSITIVE_FIXNUM.getSymbolValue()));
    48884888        LispObject result = NIL;
  • trunk/abcl/src/org/armedbear/lisp/RandomState.java

    r11488 r11711  
    127127            }
    128128        }
    129         return type_error(arg, list3(Symbol.OR,
    130                                           list2(Symbol.INTEGER, Fixnum.ONE),
    131                                           list2(Symbol.FLOAT, list1(Fixnum.ZERO))));
     129        return type_error(arg, list(Symbol.OR,
     130                                          list(Symbol.INTEGER, Fixnum.ONE),
     131                                          list(Symbol.FLOAT, list(Fixnum.ZERO))));
    132132    }
    133133
  • trunk/abcl/src/org/armedbear/lisp/Readtable.java

    r11698 r11711  
    581581                return second;
    582582              }
    583             return type_error(second, list5(Symbol.MEMBER,
     583            return type_error(second, list(Symbol.MEMBER,
    584584                                                 Keyword.INVERT,
    585585                                                 Keyword.PRESERVE,
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

    r11562 r11711  
    154154  public LispObject typeOf()
    155155  {
    156     return list3(Symbol.SIMPLE_ARRAY, elementType, getDimensions());
     156    return list(Symbol.SIMPLE_ARRAY, elementType, getDimensions());
    157157  }
    158158
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

    r11562 r11711  
    125125    public LispObject typeOf()
    126126    {
    127         return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16, getDimensions());
     127        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16, getDimensions());
    128128    }
    129129
     
    293293    {
    294294        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
    295             error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     295            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    296296            // Not reached.
    297297            return null;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

    r11562 r11711  
    129129    public LispObject typeOf()
    130130    {
    131         return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32, getDimensions());
     131        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32, getDimensions());
    132132    }
    133133
     
    283283    {
    284284        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
    285             error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     285            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    286286            // Not reached.
    287287            return null;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r11562 r11711  
    125125    public LispObject typeOf()
    126126    {
    127         return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, getDimensions());
     127        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, getDimensions());
    128128    }
    129129
     
    280280    {
    281281        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
    282             error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     282            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    283283            // Not reached.
    284284            return null;
  • trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java

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

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

    r11488 r11711  
    7878                LispObject result =
    7979                    Primitives.APPLY.execute(Symbol.FORMAT,
    80                                              Primitives.APPEND.execute(list2(NIL,
     80                                             Primitives.APPEND.execute(list(NIL,
    8181                                                                             formatControl),
    8282                                                                       formatArguments));
  • trunk/abcl/src/org/armedbear/lisp/SimpleVector.java

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

    r11579 r11711  
    586586        if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
    587587            !memq(Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue(thread),
    588                   list2(Symbol.SINGLE_FLOAT, Symbol.SHORT_FLOAT)))
     588                  list(Symbol.SINGLE_FLOAT, Symbol.SHORT_FLOAT)))
    589589        {
    590590            if (s1.indexOf('E') >= 0)
  • trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java

    r11391 r11711  
    4848    public SlotDefinitionClass()
    4949    {
    50         super(Symbol.SLOT_DEFINITION, list1(StandardClass.STANDARD_OBJECT));
     50        super(Symbol.SLOT_DEFINITION, list(StandardClass.STANDARD_OBJECT));
    5151        Package pkg = PACKAGE_SYS;
    5252        LispObject[] instanceSlotNames = {
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r11548 r11711  
    392392          new Cons(Symbol.LAMBDA, new Cons(parameters, body));
    393393        LispObject lambda_name =
    394           list2(recursive ? Symbol.LABELS : Symbol.FLET, name);
     394          list(recursive ? Symbol.LABELS : Symbol.FLET, name);
    395395        Closure closure =
    396396          new Closure(lambda_name, lambda_expression,
     
    535535              }
    536536          }
    537         return error(new UndefinedFunction(list2(Keyword.NAME, arg)));
     537        return error(new UndefinedFunction(list(Keyword.NAME, arg)));
    538538      }
    539539    };
     
    567567                        LispObject expansion =
    568568                          ((SymbolMacro)binding.value).getExpansion();
    569                         LispObject form = list3(Symbol.SETF, expansion, args.car());
     569                        LispObject form = list(Symbol.SETF, expansion, args.car());
    570570                        value = eval(form, env, thread);
    571571                      }
     
    582582                        LispObject expansion =
    583583                          ((SymbolMacro)symbol.getSymbolValue()).getExpansion();
    584                         LispObject form = list3(Symbol.SETF, expansion, args.car());
     584                        LispObject form = list(Symbol.SETF, expansion, args.car());
    585585                        value = eval(form, env, thread);
    586586                      }
     
    602602                        LispObject expansion =
    603603                          ((SymbolMacro)binding.value).getExpansion();
    604                         LispObject form = list3(Symbol.SETF, expansion, args.car());
     604                        LispObject form = list(Symbol.SETF, expansion, args.car());
    605605                        value = eval(form, env, thread);
    606606                      }
     
    617617                        LispObject expansion =
    618618                          ((SymbolMacro)symbol.getSymbolValue()).getExpansion();
    619                         LispObject form = list3(Symbol.SETF, expansion, args.car());
     619                        LispObject form = list(Symbol.SETF, expansion, args.car());
    620620                        value = eval(form, env, thread);
    621621                      }
  • trunk/abcl/src/org/armedbear/lisp/StandardClass.java

    r11590 r11711  
    7878                             new SimpleString("No layout for class ~S."),
    7979                             Keyword.FORMAT_ARGUMENTS,
    80                              list1(this));
     80                             list(this));
    8181      }
    8282    return new StandardObject(this, layout.getLength());
     
    109109  // below.
    110110  public static final StandardClass STANDARD_CLASS =
    111     addStandardClass(Symbol.STANDARD_CLASS, list1(BuiltInClass.CLASS_T));
     111    addStandardClass(Symbol.STANDARD_CLASS, list(BuiltInClass.CLASS_T));
    112112  public static final StandardClass STANDARD_OBJECT =
    113     addStandardClass(Symbol.STANDARD_OBJECT, list1(BuiltInClass.CLASS_T));
     113    addStandardClass(Symbol.STANDARD_OBJECT, list(BuiltInClass.CLASS_T));
    114114
    115115  // BuiltInClass.FUNCTION is also null here (see previous comment).
    116116  public static final StandardClass GENERIC_FUNCTION =
    117     addStandardClass(Symbol.GENERIC_FUNCTION, list2(BuiltInClass.FUNCTION,
     117    addStandardClass(Symbol.GENERIC_FUNCTION, list(BuiltInClass.FUNCTION,
    118118                                                    STANDARD_OBJECT));
    119119
    120120  public static final StandardClass CLASS =
    121     addStandardClass(Symbol.CLASS, list1(STANDARD_OBJECT));
     121    addStandardClass(Symbol.CLASS, list(STANDARD_OBJECT));
    122122
    123123  public static final StandardClass BUILT_IN_CLASS =
    124     addStandardClass(Symbol.BUILT_IN_CLASS, list1(CLASS));
     124    addStandardClass(Symbol.BUILT_IN_CLASS, list(CLASS));
    125125
    126126  public static final StandardClass JAVA_CLASS =
    127       addStandardClass(Symbol.JAVA_CLASS, list1(CLASS));
     127      addStandardClass(Symbol.JAVA_CLASS, list(CLASS));
    128128 
    129129  public static final StandardClass FORWARD_REFERENCED_CLASS =
    130     addStandardClass(Symbol.FORWARD_REFERENCED_CLASS, list1(CLASS));
     130    addStandardClass(Symbol.FORWARD_REFERENCED_CLASS, list(CLASS));
    131131
    132132  public static final StandardClass STRUCTURE_CLASS =
    133     addStandardClass(Symbol.STRUCTURE_CLASS, list1(CLASS));
     133    addStandardClass(Symbol.STRUCTURE_CLASS, list(CLASS));
    134134
    135135  public static final StandardClass CONDITION =
    136     addStandardClass(Symbol.CONDITION, list1(STANDARD_OBJECT));
     136    addStandardClass(Symbol.CONDITION, list(STANDARD_OBJECT));
    137137
    138138  public static final StandardClass SIMPLE_CONDITION =
    139     addStandardClass(Symbol.SIMPLE_CONDITION, list1(CONDITION));
     139    addStandardClass(Symbol.SIMPLE_CONDITION, list(CONDITION));
    140140
    141141  public static final StandardClass WARNING =
    142     addStandardClass(Symbol.WARNING, list1(CONDITION));
     142    addStandardClass(Symbol.WARNING, list(CONDITION));
    143143
    144144  public static final StandardClass SIMPLE_WARNING =
    145     addStandardClass(Symbol.SIMPLE_WARNING, list2(SIMPLE_CONDITION, WARNING));
     145    addStandardClass(Symbol.SIMPLE_WARNING, list(SIMPLE_CONDITION, WARNING));
    146146
    147147  public static final StandardClass STYLE_WARNING =
    148     addStandardClass(Symbol.STYLE_WARNING, list1(WARNING));
     148    addStandardClass(Symbol.STYLE_WARNING, list(WARNING));
    149149
    150150  public static final StandardClass SERIOUS_CONDITION =
    151     addStandardClass(Symbol.SERIOUS_CONDITION, list1(CONDITION));
     151    addStandardClass(Symbol.SERIOUS_CONDITION, list(CONDITION));
    152152
    153153  public static final StandardClass STORAGE_CONDITION =
    154     addStandardClass(Symbol.STORAGE_CONDITION, list1(SERIOUS_CONDITION));
     154    addStandardClass(Symbol.STORAGE_CONDITION, list(SERIOUS_CONDITION));
    155155
    156156  public static final StandardClass ERROR =
    157     addStandardClass(Symbol.ERROR, list1(SERIOUS_CONDITION));
     157    addStandardClass(Symbol.ERROR, list(SERIOUS_CONDITION));
    158158
    159159  public static final StandardClass ARITHMETIC_ERROR =
    160     addStandardClass(Symbol.ARITHMETIC_ERROR, list1(ERROR));
     160    addStandardClass(Symbol.ARITHMETIC_ERROR, list(ERROR));
    161161
    162162  public static final StandardClass CELL_ERROR =
    163     addStandardClass(Symbol.CELL_ERROR, list1(ERROR));
     163    addStandardClass(Symbol.CELL_ERROR, list(ERROR));
    164164
    165165  public static final StandardClass CONTROL_ERROR =
    166     addStandardClass(Symbol.CONTROL_ERROR, list1(ERROR));
     166    addStandardClass(Symbol.CONTROL_ERROR, list(ERROR));
    167167
    168168  public static final StandardClass FILE_ERROR =
    169     addStandardClass(Symbol.FILE_ERROR, list1(ERROR));
     169    addStandardClass(Symbol.FILE_ERROR, list(ERROR));
    170170
    171171  public static final StandardClass DIVISION_BY_ZERO =
    172     addStandardClass(Symbol.DIVISION_BY_ZERO, list1(ARITHMETIC_ERROR));
     172    addStandardClass(Symbol.DIVISION_BY_ZERO, list(ARITHMETIC_ERROR));
    173173
    174174  public static final StandardClass FLOATING_POINT_INEXACT =
    175     addStandardClass(Symbol.FLOATING_POINT_INEXACT, list1(ARITHMETIC_ERROR));
     175    addStandardClass(Symbol.FLOATING_POINT_INEXACT, list(ARITHMETIC_ERROR));
    176176
    177177  public static final StandardClass FLOATING_POINT_INVALID_OPERATION =
    178     addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list1(ARITHMETIC_ERROR));
     178    addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list(ARITHMETIC_ERROR));
    179179
    180180  public static final StandardClass FLOATING_POINT_OVERFLOW =
    181     addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list1(ARITHMETIC_ERROR));
     181    addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list(ARITHMETIC_ERROR));
    182182
    183183  public static final StandardClass FLOATING_POINT_UNDERFLOW =
    184     addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list1(ARITHMETIC_ERROR));
     184    addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list(ARITHMETIC_ERROR));
    185185
    186186  public static final StandardClass PROGRAM_ERROR =
    187     addStandardClass(Symbol.PROGRAM_ERROR, list1(ERROR));
     187    addStandardClass(Symbol.PROGRAM_ERROR, list(ERROR));
    188188
    189189  public static final StandardClass PACKAGE_ERROR =
    190     addStandardClass(Symbol.PACKAGE_ERROR, list1(ERROR));
     190    addStandardClass(Symbol.PACKAGE_ERROR, list(ERROR));
    191191
    192192  public static final StandardClass STREAM_ERROR =
    193     addStandardClass(Symbol.STREAM_ERROR, list1(ERROR));
     193    addStandardClass(Symbol.STREAM_ERROR, list(ERROR));
    194194
    195195  public static final StandardClass PARSE_ERROR =
    196     addStandardClass(Symbol.PARSE_ERROR, list1(ERROR));
     196    addStandardClass(Symbol.PARSE_ERROR, list(ERROR));
    197197
    198198  public static final StandardClass PRINT_NOT_READABLE =
    199     addStandardClass(Symbol.PRINT_NOT_READABLE, list1(ERROR));
     199    addStandardClass(Symbol.PRINT_NOT_READABLE, list(ERROR));
    200200
    201201  public static final StandardClass READER_ERROR =
    202     addStandardClass(Symbol.READER_ERROR, list2(PARSE_ERROR, STREAM_ERROR));
     202    addStandardClass(Symbol.READER_ERROR, list(PARSE_ERROR, STREAM_ERROR));
    203203
    204204  public static final StandardClass END_OF_FILE =
    205     addStandardClass(Symbol.END_OF_FILE, list1(STREAM_ERROR));
     205    addStandardClass(Symbol.END_OF_FILE, list(STREAM_ERROR));
    206206
    207207  public static final StandardClass SIMPLE_ERROR =
    208     addStandardClass(Symbol.SIMPLE_ERROR, list2(SIMPLE_CONDITION, ERROR));
     208    addStandardClass(Symbol.SIMPLE_ERROR, list(SIMPLE_CONDITION, ERROR));
    209209
    210210  public static final StandardClass TYPE_ERROR =
    211     addStandardClass(Symbol.TYPE_ERROR, list1(ERROR));
     211    addStandardClass(Symbol.TYPE_ERROR, list(ERROR));
    212212
    213213  public static final StandardClass SIMPLE_TYPE_ERROR =
    214     addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list2(SIMPLE_CONDITION,
     214    addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list(SIMPLE_CONDITION,
    215215                                                     TYPE_ERROR));
    216216
    217217  public static final StandardClass UNBOUND_SLOT =
    218     addStandardClass(Symbol.UNBOUND_SLOT, list1(CELL_ERROR));
     218    addStandardClass(Symbol.UNBOUND_SLOT, list(CELL_ERROR));
    219219
    220220  public static final StandardClass UNBOUND_VARIABLE =
    221     addStandardClass(Symbol.UNBOUND_VARIABLE, list1(CELL_ERROR));
     221    addStandardClass(Symbol.UNBOUND_VARIABLE, list(CELL_ERROR));
    222222
    223223  public static final StandardClass UNDEFINED_FUNCTION =
    224     addStandardClass(Symbol.UNDEFINED_FUNCTION, list1(CELL_ERROR));
     224    addStandardClass(Symbol.UNDEFINED_FUNCTION, list(CELL_ERROR));
    225225
    226226  public static final StandardClass COMPILER_ERROR =
    227     addStandardClass(Symbol.COMPILER_ERROR, list1(CONDITION));
     227    addStandardClass(Symbol.COMPILER_ERROR, list(CONDITION));
    228228
    229229  public static final StandardClass COMPILER_UNSUPPORTED_FEATURE_ERROR =
    230230    addStandardClass(Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR,
    231                      list1(CONDITION));
     231                     list(CONDITION));
    232232
    233233  public static final StandardClass JAVA_EXCEPTION =
    234     addStandardClass(Symbol.JAVA_EXCEPTION, list1(ERROR));
     234    addStandardClass(Symbol.JAVA_EXCEPTION, list(ERROR));
    235235
    236236  public static final StandardClass METHOD =
    237     addStandardClass(Symbol.METHOD, list1(STANDARD_OBJECT));
     237    addStandardClass(Symbol.METHOD, list(STANDARD_OBJECT));
    238238
    239239  public static final StandardClass STANDARD_METHOD =
     
    272272    STANDARD_CLASS.setDirectSuperclass(CLASS);
    273273    STANDARD_OBJECT.setDirectSuperclass(BuiltInClass.CLASS_T);
    274     GENERIC_FUNCTION.setDirectSuperclasses(list2(BuiltInClass.FUNCTION,
     274    GENERIC_FUNCTION.setDirectSuperclasses(list(BuiltInClass.FUNCTION,
    275275                                                 STANDARD_OBJECT));
    276276
     
    278278                            CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    279279    ARITHMETIC_ERROR.setDirectSlotDefinitions(
    280       list2(new SlotDefinition(Symbol.OPERATION,
    281                                list1(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERATION"))),
     280      list(new SlotDefinition(Symbol.OPERATION,
     281                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERATION"))),
    282282            new SlotDefinition(Symbol.OPERANDS,
    283                                list1(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERANDS")))));
     283                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERANDS")))));
    284284    BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
    285285                          BuiltInClass.CLASS_T);
     
    289289                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
    290290    CELL_ERROR.setDirectSlotDefinitions(
    291       list1(new SlotDefinition(Symbol.NAME,
    292                                list1(Symbol.CELL_ERROR_NAME))));
     291      list(new SlotDefinition(Symbol.NAME,
     292                               list(Symbol.CELL_ERROR_NAME))));
    293293    CLASS.setCPL(CLASS, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    294294    COMPILER_ERROR.setCPL(COMPILER_ERROR, CONDITION, STANDARD_OBJECT,
     
    299299    CONDITION.setCPL(CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    300300    CONDITION.setDirectSlotDefinitions(
    301       list2(new SlotDefinition(Symbol.FORMAT_CONTROL,
    302                                list1(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
     301      list(new SlotDefinition(Symbol.FORMAT_CONTROL,
     302                               list(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
    303303            new SlotDefinition(Symbol.FORMAT_ARGUMENTS,
    304                                list1(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
     304                               list(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
    305305                               NIL)));
    306     CONDITION.setDirectDefaultInitargs(list2(Keyword.FORMAT_ARGUMENTS,
     306    CONDITION.setDirectDefaultInitargs(list(Keyword.FORMAT_ARGUMENTS,
    307307                                             // FIXME
    308                                              new Closure(list3(Symbol.LAMBDA, NIL, NIL),
     308                                             new Closure(list(Symbol.LAMBDA, NIL, NIL),
    309309                                                         new Environment())));
    310310    CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
     
    320320                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
    321321    FILE_ERROR.setDirectSlotDefinitions(
    322       list1(new SlotDefinition(Symbol.PATHNAME,
    323                                list1(PACKAGE_CL.intern("FILE-ERROR-PATHNAME")))));
     322      list(new SlotDefinition(Symbol.PATHNAME,
     323                               list(PACKAGE_CL.intern("FILE-ERROR-PATHNAME")))));
    324324    FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT, ARITHMETIC_ERROR,
    325325                                  ERROR, SERIOUS_CONDITION, CONDITION,
     
    343343                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
    344344    JAVA_EXCEPTION.setDirectSlotDefinitions(
    345       list1(new SlotDefinition(Symbol.CAUSE, list1(Symbol.JAVA_EXCEPTION_CAUSE))));
     345      list(new SlotDefinition(Symbol.CAUSE, list(Symbol.JAVA_EXCEPTION_CAUSE))));
    346346    METHOD.setCPL(METHOD, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    347347    PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
    348348                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
    349349    PACKAGE_ERROR.setDirectSlotDefinitions(
    350       list1(new SlotDefinition(Symbol.PACKAGE,
    351                                list1(PACKAGE_CL.intern("PACKAGE-ERROR-PACKAGE")))));
     350      list(new SlotDefinition(Symbol.PACKAGE,
     351                               list(PACKAGE_CL.intern("PACKAGE-ERROR-PACKAGE")))));
    352352    PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
    353353                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
     
    355355                              CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    356356    PRINT_NOT_READABLE.setDirectSlotDefinitions(
    357       list1(new SlotDefinition(Symbol.OBJECT,
    358                                list1(PACKAGE_CL.intern("PRINT-NOT-READABLE-OBJECT")))));
     357      list(new SlotDefinition(Symbol.OBJECT,
     358                               list(PACKAGE_CL.intern("PRINT-NOT-READABLE-OBJECT")))));
    359359    PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
    360360                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
     
    369369                        SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
    370370                        BuiltInClass.CLASS_T);
    371     SIMPLE_TYPE_ERROR.setDirectSuperclasses(list2(SIMPLE_CONDITION,
     371    SIMPLE_TYPE_ERROR.setDirectSuperclasses(list(SIMPLE_CONDITION,
    372372                                                  TYPE_ERROR));
    373373    SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
    374374                             TYPE_ERROR, ERROR, SERIOUS_CONDITION,
    375375                             CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    376     SIMPLE_WARNING.setDirectSuperclasses(list2(SIMPLE_CONDITION, WARNING));
     376    SIMPLE_WARNING.setDirectSuperclasses(list(SIMPLE_CONDITION, WARNING));
    377377    SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
    378378                          CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     
    385385                        STANDARD_OBJECT, BuiltInClass.CLASS_T);
    386386    STREAM_ERROR.setDirectSlotDefinitions(
    387       list1(new SlotDefinition(Symbol.STREAM,
    388                                list1(PACKAGE_CL.intern("STREAM-ERROR-STREAM")))));
     387      list(new SlotDefinition(Symbol.STREAM,
     388                               list(PACKAGE_CL.intern("STREAM-ERROR-STREAM")))));
    389389    STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
    390390                           BuiltInClass.CLASS_T);
     
    394394                      STANDARD_OBJECT, BuiltInClass.CLASS_T);
    395395    TYPE_ERROR.setDirectSlotDefinitions(
    396       list2(new SlotDefinition(Symbol.DATUM,
    397                                list1(PACKAGE_CL.intern("TYPE-ERROR-DATUM"))),
     396      list(new SlotDefinition(Symbol.DATUM,
     397                               list(PACKAGE_CL.intern("TYPE-ERROR-DATUM"))),
    398398            new SlotDefinition(Symbol.EXPECTED_TYPE,
    399                                list1(PACKAGE_CL.intern("TYPE-ERROR-EXPECTED-TYPE")))));
     399                               list(PACKAGE_CL.intern("TYPE-ERROR-EXPECTED-TYPE")))));
    400400    UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR, SERIOUS_CONDITION,
    401401                        CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
    402402    UNBOUND_SLOT.setDirectSlotDefinitions(
    403       list1(new SlotDefinition(Symbol.INSTANCE,
    404                                list1(PACKAGE_CL.intern("UNBOUND-SLOT-INSTANCE")))));
     403      list(new SlotDefinition(Symbol.INSTANCE,
     404                               list(PACKAGE_CL.intern("UNBOUND-SLOT-INSTANCE")))));
    405405    UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
    406406                            SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
     
    469469    STANDARD_READER_METHOD.setSlotDefinitions(STANDARD_READER_METHOD.getClassLayout().generateSlotDefinitions());
    470470    // All but the last slot are inherited.
    471     STANDARD_READER_METHOD.setDirectSlotDefinitions(list1(STANDARD_READER_METHOD.getSlotDefinitions().reverse().car()));
     471    STANDARD_READER_METHOD.setDirectSlotDefinitions(list(STANDARD_READER_METHOD.getSlotDefinitions().reverse().car()));
    472472
    473473    // STANDARD-GENERIC-FUNCTION
  • trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java

    r11698 r11711  
    7676          new StandardMethod(this, function, lambdaList, specializers);
    7777        slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] =
    78           list1(method);
     78          list(method);
    7979        slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] =
    8080          StandardClass.STANDARD_METHOD;
     
    826826                                true,
    827827                                _GENERIC_FUNCTION_NAME,
    828                                 list1(Symbol.GENERIC_FUNCTION),
    829                                 list1(StandardClass.STANDARD_GENERIC_FUNCTION));
     828                                list(Symbol.GENERIC_FUNCTION),
     829                                list(StandardClass.STANDARD_GENERIC_FUNCTION));
    830830
    831831  private static class CacheEntry
  • trunk/abcl/src/org/armedbear/lisp/StandardGenericFunctionClass.java

    r11488 r11711  
    5050  {
    5151    super(Symbol.STANDARD_GENERIC_FUNCTION,
    52           list1(StandardClass.GENERIC_FUNCTION));
     52          list(StandardClass.GENERIC_FUNCTION));
    5353    Package pkg = PACKAGE_SYS;
    5454    LispObject[] instanceSlotNames =
  • trunk/abcl/src/org/armedbear/lisp/StandardMethod.java

    r11488 r11711  
    384384                                true,
    385385                                _METHOD_SPECIALIZERS,
    386                                 list1(Symbol.METHOD),
    387                                 list1(StandardClass.STANDARD_METHOD));
     386                                list(Symbol.METHOD),
     387                                list(StandardClass.STANDARD_METHOD));
    388388
    389389  private static final StandardGenericFunction METHOD_QUALIFIERS =
     
    392392                                true,
    393393                                _METHOD_QUALIFIERS,
    394                                 list1(Symbol.METHOD),
    395                                 list1(StandardClass.STANDARD_METHOD));
     394                                list(Symbol.METHOD),
     395                                list(StandardClass.STANDARD_METHOD));
    396396
    397397}
  • trunk/abcl/src/org/armedbear/lisp/StandardMethodClass.java

    r11488 r11711  
    4646  public StandardMethodClass()
    4747  {
    48     super(Symbol.STANDARD_METHOD, list1(StandardClass.METHOD));
     48    super(Symbol.STANDARD_METHOD, list(StandardClass.METHOD));
    4949    Package pkg = PACKAGE_SYS;
    5050    LispObject[] instanceSlotNames =
  • trunk/abcl/src/org/armedbear/lisp/StandardObject.java

    r11488 r11711  
    400400          {
    401401            return type_error(second,
    402                                    list3(Symbol.INTEGER, Fixnum.ZERO,
     402                                   list(Symbol.INTEGER, Fixnum.ZERO,
    403403                                         new Fixnum(instance.slots.length)));
    404404          }
     
    411411          {
    412412            return type_error(second,
    413                                    list3(Symbol.INTEGER, Fixnum.ZERO,
     413                                   list(Symbol.INTEGER, Fixnum.ZERO,
    414414                                         new Fixnum(instance.slots.length)));
    415415          }
  • trunk/abcl/src/org/armedbear/lisp/StandardReaderMethodClass.java

    r11488 r11711  
    5151  {
    5252    super(Symbol.STANDARD_READER_METHOD,
    53           list1(StandardClass.STANDARD_READER_METHOD));
     53          list(StandardClass.STANDARD_READER_METHOD));
    5454    Package pkg = PACKAGE_SYS;
    5555    LispObject[] instanceSlotNames =
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r11698 r11711  
    29252925        int end = Fixnum.getValue(fourth);
    29262926        if (!v.getElementType().equal(UNSIGNED_BYTE_8))
    2927           return type_error(first, list2(Symbol.VECTOR,
     2927          return type_error(first, list(Symbol.VECTOR,
    29282928                                              UNSIGNED_BYTE_8));
    29292929        for (int i = start; i < end; i++)
  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r11698 r11711  
    362362    LispObject obj = get(this, Symbol.SETF_FUNCTION, null);
    363363    if (obj == null)
    364       error(new UndefinedFunction(list2(Keyword.NAME,
    365                                          list2(Symbol.SETF,
     364      error(new UndefinedFunction(list(Keyword.NAME,
     365                                         list(Symbol.SETF,
    366366                                               this))));
    367367    return obj;
     
    735735    catch (NullPointerException e)
    736736      {
    737         return handleNPE(e, list1(arg));
     737        return handleNPE(e, list(arg));
    738738      }
    739739  }
     
    749749    catch (NullPointerException e)
    750750      {
    751         return handleNPE(e, list2(first, second));
     751        return handleNPE(e, list(first, second));
    752752      }
    753753  }
     
    764764    catch (NullPointerException e)
    765765      {
    766         return handleNPE(e, list3(first, second, third));
     766        return handleNPE(e, list(first, second, third));
    767767      }
    768768  }
     
    779779    catch (NullPointerException e)
    780780      {
    781         return handleNPE(e, list4(first, second, third, fourth));
     781        return handleNPE(e, list(first, second, third, fourth));
    782782      }
    783783  }
     
    795795    catch (NullPointerException e)
    796796      {
    797         return handleNPE(e, list5(first, second, third, fourth, fifth));
     797        return handleNPE(e, list(first, second, third, fourth, fifth));
    798798      }
    799799  }
     
    811811    catch (NullPointerException e)
    812812      {
    813         return handleNPE(e, list6(first, second, third, fourth, fifth,
     813        return handleNPE(e, list(first, second, third, fourth, fifth,
    814814                                  sixth));
    815815      }
     
    831831      {
    832832        return handleNPE(e,
    833                          list7(first, second, third, fourth, fifth, sixth,
     833                         list(first, second, third, fourth, fifth, sixth,
    834834                               seventh));
    835835      }
     
    851851      {
    852852        return handleNPE(e,
    853                          list8(first, second, third, fourth, fifth, sixth,
     853                         list(first, second, third, fourth, fifth, sixth,
    854854                               seventh, eighth));
    855855      }
  • trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java

    r11488 r11711  
    6060        if (itype.equal(otype))
    6161            return itype;
    62         return list3(Symbol.AND, itype, otype);
     62        return list(Symbol.AND, itype, otype);
    6363    }
    6464
     
    240240            }
    241241            if (!in.isInputStream())
    242                 return type_error(in, list2(Symbol.SATISFIES,
     242                return type_error(in, list(Symbol.SATISFIES,
    243243                                                 Symbol.INPUT_STREAM_P));
    244244            if (!out.isOutputStream())
    245                 return type_error(out, list2(Symbol.SATISFIES,
     245                return type_error(out, list(Symbol.SATISFIES,
    246246                                                  Symbol.OUTPUT_STREAM_P));
    247247            return new TwoWayStream(in, out);
  • trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java

    r11562 r11711  
    5353    {
    5454        if (adjustable)
    55             return list3(Symbol.ARRAY, elementType, NIL);
     55            return list(Symbol.ARRAY, elementType, NIL);
    5656        else
    57             return list3(Symbol.SIMPLE_ARRAY, elementType, NIL);
     57            return list(Symbol.SIMPLE_ARRAY, elementType, NIL);
    5858    }
    5959
     
    139139        if (printReadably) {
    140140            if (elementType != T) {
    141                 error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
     141                error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    142142                // Not reached.
    143143                return null;
Note: See TracChangeset for help on using the changeset viewer.