Changeset 11711

Timestamp:

03/15/09 15:51:40 (14 years ago)

Author:

ehuelsmann

Message:

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

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• AbstractArray.java (modified) (1 diff)
• AbstractVector.java (modified) (1 diff)
• BasicVector_UnsignedByte16.java (modified) (1 diff)
• BasicVector_UnsignedByte32.java (modified) (1 diff)
• BasicVector_UnsignedByte8.java (modified) (1 diff)
• Bignum.java (modified) (1 diff)
• BroadcastStream.java (modified) (1 diff)
• BuiltInClass.java (modified) (3 diffs)
• Closure.java (modified) (1 diff)
• ClosureTemplateFunction.java (modified) (1 diff)
• ComplexArray.java (modified) (1 diff)
• ComplexArray_UnsignedByte32.java (modified) (1 diff)
• ComplexArray_UnsignedByte8.java (modified) (2 diffs)
• ComplexBitVector.java (modified) (1 diff)
• ComplexString.java (modified) (1 diff)
• ComplexVector.java (modified) (1 diff)
• ComplexVector_UnsignedByte32.java (modified) (1 diff)
• ComplexVector_UnsignedByte8.java (modified) (1 diff)
• Cons.java (modified) (3 diffs)
• DoubleFloat.java (modified) (1 diff)
• Extensions.java (modified) (1 diff)
• FillPointerOutputStream.java (modified) (1 diff)
• Fixnum.java (modified) (1 diff)
• FloatFunctions.java (modified) (1 diff)
• HashTable.java (modified) (1 diff)
• Java.java (modified) (2 diffs)
• Lisp.java (modified) (13 diffs)
• LispCharacter.java (modified) (2 diffs)
• LispClass.java (modified) (8 diffs)
• LispObject.java (modified) (2 diffs)
• LispThread.java (modified) (1 diff)
• MacroObject.java (modified) (1 diff)
• Nil.java (modified) (1 diff)
• NilVector.java (modified) (1 diff)
• Pathname.java (modified) (3 diffs)
• Primitive0R.java (modified) (7 diffs)
• Primitive1R.java (modified) (6 diffs)
• Primitive2R.java (modified) (5 diffs)
• Primitives.java (modified) (7 diffs)
• RandomState.java (modified) (1 diff)
• Readtable.java (modified) (1 diff)
• SimpleArray_T.java (modified) (1 diff)
• SimpleArray_UnsignedByte16.java (modified) (2 diffs)
• SimpleArray_UnsignedByte32.java (modified) (2 diffs)
• SimpleArray_UnsignedByte8.java (modified) (2 diffs)
• SimpleBitVector.java (modified) (1 diff)
• SimpleString.java (modified) (1 diff)
• SimpleTypeError.java (modified) (1 diff)
• SimpleVector.java (modified) (1 diff)
• SingleFloat.java (modified) (1 diff)
• SlotDefinitionClass.java (modified) (1 diff)
• SpecialOperators.java (modified) (6 diffs)
• StandardClass.java (modified) (13 diffs)
• StandardGenericFunction.java (modified) (2 diffs)
• StandardGenericFunctionClass.java (modified) (1 diff)
• StandardMethod.java (modified) (2 diffs)
• StandardMethodClass.java (modified) (1 diff)
• StandardObject.java (modified) (2 diffs)
• StandardReaderMethodClass.java (modified) (1 diff)
• Stream.java (modified) (1 diff)
• Symbol.java (modified) (9 diffs)
• TwoWayStream.java (modified) (2 diffs)
• ZeroRankArray.java (modified) (2 diffs)

trunk/abcl/src/org/armedbear/lisp/AbstractArray.java

@@ -191 +191 @@
                         for (int j = i + 1; j < dimv.length; j++) {
                             if (dimv[j] != 0) {
-                                error(new PrintNotReadable(list2(Keyword.OBJECT,
+                                error(new PrintNotReadable(list(Keyword.OBJECT,
                                                                   this)));
                                 return null; // Not reached.

trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

@@ -168 +168 @@
     error(new TypeError(sb.toString(),
                          new Fixnum(index),
-                         list3(Symbol.INTEGER,
+                         list(Symbol.INTEGER,
                                Fixnum.ZERO,
                                new Fixnum(limit - 1))));

trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

@@ -59 +59 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16,
+        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16,
                      new Cons(new Fixnum(capacity)));
     }

trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

@@ -60 +60 @@
   public LispObject typeOf()
   {
-    return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32,
+    return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32,
                  new Cons(new Fixnum(capacity)));
   }

trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

@@ -59 +59 @@
   public LispObject typeOf()
   {
-    return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, new Cons(new Fixnum(capacity)));
+    return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, new Cons(new Fixnum(capacity)));
   }
 

trunk/abcl/src/org/armedbear/lisp/Bignum.java

@@ -84 +84 @@
   {
     if (value.signum() > 0)
-      return list2(Symbol.INTEGER,
+      return list(Symbol.INTEGER,
                    new Bignum((long)Integer.MAX_VALUE + 1));
     return Symbol.BIGNUM;

trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java

@@ -241 +241 @@
                         continue;
                     } else
-                        return error(new TypeError(args[i], list2(Symbol.SATISFIES,
+                        return error(new TypeError(args[i], list(Symbol.SATISFIES,
                                                                    Symbol.OUTPUT_STREAM_P)));
                 } else

trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java

@@ -145 +145 @@
 
   public static final StructureClass STRUCTURE_OBJECT =
-    new StructureClass(Symbol.STRUCTURE_OBJECT, list1(CLASS_T));
+    new StructureClass(Symbol.STRUCTURE_OBJECT, list(CLASS_T));
   static
   {
@@ -230 +230 @@
     SIMPLE_ARRAY.setDirectSuperclass(ARRAY);
     SIMPLE_ARRAY.setCPL(SIMPLE_ARRAY, ARRAY, CLASS_T);
-    SIMPLE_BASE_STRING.setDirectSuperclasses(list2(BASE_STRING, SIMPLE_STRING));
+    SIMPLE_BASE_STRING.setDirectSuperclasses(list(BASE_STRING, SIMPLE_STRING));
     SIMPLE_BASE_STRING.setCPL(SIMPLE_BASE_STRING, BASE_STRING, SIMPLE_STRING,
                               STRING, VECTOR, SIMPLE_ARRAY, ARRAY, SEQUENCE,
                               CLASS_T);
-    SIMPLE_BIT_VECTOR.setDirectSuperclasses(list2(BIT_VECTOR, SIMPLE_ARRAY));
+    SIMPLE_BIT_VECTOR.setDirectSuperclasses(list(BIT_VECTOR, SIMPLE_ARRAY));
     SIMPLE_BIT_VECTOR.setCPL(SIMPLE_BIT_VECTOR, BIT_VECTOR, VECTOR,
                              SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
-    SIMPLE_STRING.setDirectSuperclasses(list3(BASE_STRING, STRING, SIMPLE_ARRAY));
+    SIMPLE_STRING.setDirectSuperclasses(list(BASE_STRING, STRING, SIMPLE_ARRAY));
     SIMPLE_STRING.setCPL(SIMPLE_STRING, BASE_STRING, STRING, VECTOR,
                          SIMPLE_ARRAY, ARRAY, SEQUENCE, CLASS_T);
-    SIMPLE_VECTOR.setDirectSuperclasses(list2(VECTOR, SIMPLE_ARRAY));
+    SIMPLE_VECTOR.setDirectSuperclasses(list(VECTOR, SIMPLE_ARRAY));
     SIMPLE_VECTOR.setCPL(SIMPLE_VECTOR, VECTOR, SIMPLE_ARRAY, ARRAY, SEQUENCE,
                          CLASS_T);
@@ -274 +274 @@
     TWO_WAY_STREAM.setDirectSuperclass(STREAM);
     TWO_WAY_STREAM.setCPL(TWO_WAY_STREAM, STREAM, CLASS_T);
-    VECTOR.setDirectSuperclasses(list2(ARRAY, SEQUENCE));
+    VECTOR.setDirectSuperclasses(list(ARRAY, SEQUENCE));
     VECTOR.setCPL(VECTOR, ARRAY, SEQUENCE, CLASS_T);
   }

trunk/abcl/src/org/armedbear/lisp/Closure.java

@@ -1142 +1142 @@
       public LispObject execute(LispObject arg) throws ConditionThrowable
       {
-        Closure closure = new Closure(list3(Symbol.LAMBDA, arg, NIL), new Environment());
+        Closure closure = new Closure(list(Symbol.LAMBDA, arg, NIL), new Environment());
         return closure.getVariableList();
       }

trunk/abcl/src/org/armedbear/lisp/ClosureTemplateFunction.java

@@ -43 +43 @@
     throws ConditionThrowable
   {
-    super(list2(Symbol.LAMBDA, lambdaList), null);
+    super(list(Symbol.LAMBDA, lambdaList), null);
   }
 

trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

@@ -129 +129 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.ARRAY, elementType, getDimensions());
+        return list(Symbol.ARRAY, elementType, getDimensions());
     }
 

trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

@@ -125 +125 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.ARRAY, UNSIGNED_BYTE_32, getDimensions());
+        return list(Symbol.ARRAY, UNSIGNED_BYTE_32, getDimensions());
     }
 

trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

@@ -121 +121 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.ARRAY, UNSIGNED_BYTE_8, getDimensions());
+        return list(Symbol.ARRAY, UNSIGNED_BYTE_8, getDimensions());
     }
 
@@ -228 +228 @@
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
-            error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
+            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
             // Not reached.
             return null;

trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

@@ -63 +63 @@
     public LispObject typeOf()
     {
-        return list2(Symbol.BIT_VECTOR, new Fixnum(capacity));
+        return list(Symbol.BIT_VECTOR, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/ComplexString.java

@@ -65 +65 @@
   public LispObject typeOf()
   {
-    return list2(Symbol.STRING, number(capacity()));
+    return list(Symbol.STRING, number(capacity()));
   }
 

trunk/abcl/src/org/armedbear/lisp/ComplexVector.java

@@ -68 +68 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.VECTOR, T, new Fixnum(capacity));
+        return list(Symbol.VECTOR, T, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte32.java

@@ -69 +69 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.VECTOR, UNSIGNED_BYTE_32, new Fixnum(capacity));
+        return list(Symbol.VECTOR, UNSIGNED_BYTE_32, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

@@ -67 +67 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.VECTOR, UNSIGNED_BYTE_8, new Fixnum(capacity));
+        return list(Symbol.VECTOR, UNSIGNED_BYTE_8, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/Cons.java

@@ -185 +185 @@
     if (n < 0)
       return type_error(new Fixnum(n),
-                             list2(Symbol.INTEGER, Fixnum.ZERO));
+                             list(Symbol.INTEGER, Fixnum.ZERO));
     LispObject result = this;
     for (int i = n; i-- > 0;)
@@ -372 +372 @@
                 // Index too large.
                 type_error(new Fixnum(index),
-                                list3(Symbol.INTEGER, Fixnum.ZERO,
+                                list(Symbol.INTEGER, Fixnum.ZERO,
                                       new Fixnum(length() - 1)));
               }
@@ -607 +607 @@
   private final LispObject signalExecutionError() throws ConditionThrowable
   {
-    return type_error(this, list3(Symbol.OR, Symbol.FUNCTION,
+    return type_error(this, list(Symbol.OR, Symbol.FUNCTION,
                                        Symbol.SYMBOL));
   }

trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

@@ -597 +597 @@
         if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
             !memq(Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue(thread),
-                  list2(Symbol.DOUBLE_FLOAT, Symbol.LONG_FLOAT)))
+                  list(Symbol.DOUBLE_FLOAT, Symbol.LONG_FLOAT)))
         {
             if (s1.indexOf('E') >= 0)

trunk/abcl/src/org/armedbear/lisp/Extensions.java

@@ -42 +42 @@
   public static final Symbol _ED_FUNCTIONS_ =
     exportSpecial("*ED-FUNCTIONS*", PACKAGE_EXT,
-                  list1(intern("DEFAULT-ED-FUNCTION", PACKAGE_SYS)));
+                  list(intern("DEFAULT-ED-FUNCTION", PACKAGE_SYS)));
 
   // ### truly-the value-type form => result*

trunk/abcl/src/org/armedbear/lisp/FillPointerOutputStream.java

@@ -61 +61 @@
                     return new FillPointerOutputStream(string);
             }
-            return type_error(arg, list3(Symbol.AND, Symbol.STRING,
-                                              list2(Symbol.SATISFIES,
+            return type_error(arg, list(Symbol.AND, Symbol.STRING,
+                                              list(Symbol.SATISFIES,
                                                     Symbol.ARRAY_HAS_FILL_POINTER_P)));
         }

trunk/abcl/src/org/armedbear/lisp/Fixnum.java

@@ -89 +89 @@
       return Symbol.BIT;
     if (value > 1)
-      return list3(Symbol.INTEGER, ZERO, new Fixnum(Integer.MAX_VALUE));
+      return list(Symbol.INTEGER, ZERO, new Fixnum(Integer.MAX_VALUE));
     return Symbol.FIXNUM;
   }

trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

@@ -86 +86 @@
             if (TRAP_OVERFLOW)
                 traps = traps.push(Keyword.OVERFLOW);
-            return list2(Keyword.TRAPS, traps);
+            return list(Keyword.TRAPS, traps);
         }
     };

trunk/abcl/src/org/armedbear/lisp/HashTable.java

@@ -230 +230 @@
     if (Symbol.PRINT_READABLY.symbolValue(LispThread.currentThread()) != NIL)
       {
-        error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
+        error(new PrintNotReadable(list(Keyword.OBJECT, this)));
         return null; // Not reached.
       }

trunk/abcl/src/org/armedbear/lisp/Java.java

@@ -627 +627 @@
         else {
             type_error(instanceArg,
-                            list3(Symbol.OR, Symbol.STRING, Symbol.JAVA_OBJECT));
+                            list(Symbol.OR, Symbol.STRING, Symbol.JAVA_OBJECT));
             // Not reached.
             return null;
@@ -860 +860 @@
         }
         catch (ClassCastException e) {
-            type_error(obj, list3(Symbol.OR, Symbol.STRING,
+            type_error(obj, list(Symbol.OR, Symbol.STRING,
                                        Symbol.JAVA_OBJECT));
             // Not reached.

trunk/abcl/src/org/armedbear/lisp/Lisp.java

@@ -871 +871 @@
     if (arg instanceof LispCharacter)
       return String.valueOf(new char[] {((LispCharacter)arg).value});
-    type_error(arg, list4(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
+    type_error(arg, list(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
                                Symbol.CHARACTER));
     // Not reached.
@@ -1164 +1164 @@
       getf(ctf.getPropertyList(), Symbol.CLASS_BYTES, NIL);
     if (classBytes != NIL)
-      result.setPropertyList(list2(Symbol.CLASS_BYTES, classBytes));
+      result.setPropertyList(list(Symbol.CLASS_BYTES, classBytes));
     return result;
   }
@@ -1200 +1200 @@
 
   public static final LispObject FUNCTION_NAME =
-    list3(Symbol.OR,
+    list(Symbol.OR,
           Symbol.SYMBOL,
-          list3(Symbol.CONS,
-                list2(Symbol.EQL, Symbol.SETF),
-                list3(Symbol.CONS, Symbol.SYMBOL, Symbol.NULL)));
+          list(Symbol.CONS,
+                list(Symbol.EQL, Symbol.SETF),
+                list(Symbol.CONS, Symbol.SYMBOL, Symbol.NULL)));
 
   public static final LispObject UNSIGNED_BYTE_8 =
-    list2(Symbol.UNSIGNED_BYTE, Fixnum.constants[8]);
+    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[8]);
 
   public static final LispObject UNSIGNED_BYTE_16 =
-    list2(Symbol.UNSIGNED_BYTE, Fixnum.constants[16]);
+    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[16]);
 
   public static final LispObject UNSIGNED_BYTE_32 =
-    list2(Symbol.UNSIGNED_BYTE, Fixnum.constants[32]);
+    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[32]);
 
   public static final LispObject UNSIGNED_BYTE_32_MAX_VALUE =
@@ -1619 +1619 @@
     if (arg instanceof FileStream)
       return ((FileStream)arg).getPathname();
-    type_error(arg, list4(Symbol.OR, Symbol.PATHNAME,
+    type_error(arg, list(Symbol.OR, Symbol.PATHNAME,
                                Symbol.STRING, Symbol.FILE_STREAM));
     // Not reached.
@@ -2115 +2115 @@
     if (osName.startsWith("Linux"))
       {
-        Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2125 +2125 @@
     else if (osName.startsWith("SunOS"))
       {
-        Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2135 +2135 @@
     else if (osName.startsWith("Mac OS X"))
       {
-        Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2145 +2145 @@
     else if (osName.startsWith("FreeBSD"))
       {
-        Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2155 +2155 @@
     else if (osName.startsWith("OpenBSD"))
       {
-        Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2165 +2165 @@
     else if (osName.startsWith("NetBSD"))
       {
-        Symbol.FEATURES.setSymbolValue(list7(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2175 +2175 @@
     else if (osName.startsWith("Windows"))
       {
-        Symbol.FEATURES.setSymbolValue(list6(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2184 +2184 @@
     else
       {
-        Symbol.FEATURES.setSymbolValue(list5(Keyword.ARMEDBEAR,
+        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
                                              Keyword.ABCL,
                                              Keyword.COMMON_LISP,
@@ -2533 +2533 @@
   // ### *bq-vector-flag*
   public static final Symbol _BQ_VECTOR_FLAG_ =
-    internSpecial("*BQ-VECTOR-FLAG*", PACKAGE_SYS, list1(new Symbol("bqv")));
+    internSpecial("*BQ-VECTOR-FLAG*", PACKAGE_SYS, list(new Symbol("bqv")));
 
   // ### *traced-names*

trunk/abcl/src/org/armedbear/lisp/LispCharacter.java

@@ -502 +502 @@
         if (radix < 2 || radix > 36)
           return type_error(second,
-                                 list3(Symbol.INTEGER, Fixnum.TWO,
+                                 list(Symbol.INTEGER, Fixnum.TWO,
                                        Fixnum.constants[36]));
         int weight;
@@ -564 +564 @@
         catch (ClassCastException e) {}
         return type_error(second,
-                               list3(Symbol.INTEGER, Fixnum.TWO,
+                               list(Symbol.INTEGER, Fixnum.TWO,
                                      Fixnum.constants[36]));
       }

trunk/abcl/src/org/armedbear/lisp/LispClass.java

@@ -236 +236 @@
   {
     Debug.assertTrue(obj1 == this);
-    classPrecedenceList = list2(obj1, obj2);
+    classPrecedenceList = list(obj1, obj2);
   }
 
@@ -242 +242 @@
   {
     Debug.assertTrue(obj1 == this);
-    classPrecedenceList = list3(obj1, obj2, obj3);
+    classPrecedenceList = list(obj1, obj2, obj3);
   }
 
@@ -249 +249 @@
   {
     Debug.assertTrue(obj1 == this);
-    classPrecedenceList = list4(obj1, obj2, obj3, obj4);
+    classPrecedenceList = list(obj1, obj2, obj3, obj4);
   }
 
@@ -256 +256 @@
   {
     Debug.assertTrue(obj1 == this);
-    classPrecedenceList = list5(obj1, obj2, obj3, obj4, obj5);
+    classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5);
   }
 
@@ -263 +263 @@
   {
     Debug.assertTrue(obj1 == this);
-    classPrecedenceList = list6(obj1, obj2, obj3, obj4, obj5, obj6);
+    classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5, obj6);
   }
 
@@ -271 +271 @@
   {
     Debug.assertTrue(obj1 == this);
-    classPrecedenceList = list7(obj1, obj2, obj3, obj4, obj5, obj6, obj7);
+    classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5, obj6, obj7);
   }
 
@@ -280 +280 @@
     Debug.assertTrue(obj1 == this);
     classPrecedenceList =
-      list8(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+      list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
   }
 
@@ -289 +289 @@
     Debug.assertTrue(obj1 == this);
     classPrecedenceList =
-      list9(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
+      list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
   }
 

trunk/abcl/src/org/armedbear/lisp/LispObject.java

@@ -164 +164 @@
     if (n < 0)
       return type_error(new Fixnum(n),
-                             list2(Symbol.INTEGER, Fixnum.ZERO));
+                             list(Symbol.INTEGER, Fixnum.ZERO));
     return type_error(this, Symbol.LIST);
   }
@@ -517 +517 @@
   public final LispObject noFillPointer() throws ConditionThrowable
   {
-    return type_error(this, list3(Symbol.AND, Symbol.VECTOR,
-                                       list2(Symbol.SATISFIES,
+    return type_error(this, list(Symbol.AND, Symbol.VECTOR,
+                                       list(Symbol.SATISFIES,
                                              Symbol.ARRAY_HAS_FILL_POINTER_P)));
   }

trunk/abcl/src/org/armedbear/lisp/LispThread.java

@@ -1070 +1070 @@
                 ((DoubleFloat)arg.multiplyBy(new DoubleFloat(1000))).getValue();
             if (d < 0)
-                return type_error(arg, list2(Symbol.REAL, Fixnum.ZERO));
+                return type_error(arg, list(Symbol.REAL, Fixnum.ZERO));
             long millis = d < Long.MAX_VALUE ? (long) d : Long.MAX_VALUE;
             try {

trunk/abcl/src/org/armedbear/lisp/MacroObject.java

@@ -44 +44 @@
     this.expander = expander;
     if (name instanceof Symbol && name != NIL && expander instanceof Function)
-      ((Function)expander).setLambdaName(list2(Symbol.MACRO_FUNCTION,
+      ((Function)expander).setLambdaName(list(Symbol.MACRO_FUNCTION,
                                                name));
   }

trunk/abcl/src/org/armedbear/lisp/Nil.java

@@ -138 +138 @@
         if (n < 0)
             return type_error(new Fixnum(n),
-                                   list2(Symbol.INTEGER, Fixnum.ZERO));
+                                   list(Symbol.INTEGER, Fixnum.ZERO));
         return this;
     }

trunk/abcl/src/org/armedbear/lisp/NilVector.java

@@ -70 +70 @@
     public LispObject typeOf()
     {
-        return list2(Symbol.NIL_VECTOR, new Fixnum(capacity));
+        return list(Symbol.NIL_VECTOR, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/Pathname.java

@@ -103 +103 @@
         }
         if (s.equals("..") || s.equals("../")) {
-            directory = list2(Keyword.RELATIVE, Keyword.UP);
+            directory = list(Keyword.RELATIVE, Keyword.UP);
             return;
         }
@@ -628 +628 @@
     {
         if (arg != Keyword.COMMON && arg != Keyword.LOCAL)
-            type_error(arg, list3(Symbol.MEMBER, Keyword.COMMON,
+            type_error(arg, list(Symbol.MEMBER, Keyword.COMMON,
                                        Keyword.LOCAL));
     }
@@ -838 +838 @@
             } else if (key == Keyword.DIRECTORY) {
                 if (value instanceof AbstractString)
-                    directory = list2(Keyword.ABSOLUTE, value);
+                    directory = list(Keyword.ABSOLUTE, value);
                 else if (value == Keyword.WILD)
-                    directory = list2(Keyword.ABSOLUTE, Keyword.WILD);
+                    directory = list(Keyword.ABSOLUTE, Keyword.WILD);
                 else
                     directory = value;

trunk/abcl/src/org/armedbear/lisp/Primitive0R.java

@@ -100 +100 @@
         throws ConditionThrowable
     {
-        return _execute(list2(first, second));
+        return _execute(list(first, second));
     }
 
@@ -108 +108 @@
         throws ConditionThrowable
     {
-        return _execute(list3(first, second, third));
+        return _execute(list(first, second, third));
     }
 
@@ -116 +116 @@
         throws ConditionThrowable
     {
-        return _execute(list4(first, second, third, fourth));
+        return _execute(list(first, second, third, fourth));
     }
 
@@ -125 +125 @@
         throws ConditionThrowable
     {
-        return _execute(list5(first, second, third, fourth, fifth));
+        return _execute(list(first, second, third, fourth, fifth));
     }
 
@@ -134 +134 @@
         throws ConditionThrowable
     {
-        return _execute(list6(first, second, third, fourth, fifth, sixth));
+        return _execute(list(first, second, third, fourth, fifth, sixth));
     }
 
@@ -144 +144 @@
         throws ConditionThrowable
     {
-        return _execute(list7(first, second, third, fourth, fifth, sixth,
+        return _execute(list(first, second, third, fourth, fifth, sixth,
                               seventh));
     }
@@ -155 +155 @@
         throws ConditionThrowable
     {
-        return _execute(list8(first, second, third, fourth, fifth, sixth,
+        return _execute(list(first, second, third, fourth, fifth, sixth,
                               seventh, eighth));
     }

trunk/abcl/src/org/armedbear/lisp/Primitive1R.java

@@ -102 +102 @@
         throws ConditionThrowable
     {
-        return _execute(first, list2(second, third));
+        return _execute(first, list(second, third));
     }
 
@@ -110 +110 @@
         throws ConditionThrowable
     {
-        return _execute(first, list3(second, third, fourth));
+        return _execute(first, list(second, third, fourth));
     }
 
@@ -119 +119 @@
         throws ConditionThrowable
     {
-        return _execute(first, list4(second, third, fourth, fifth));
+        return _execute(first, list(second, third, fourth, fifth));
     }
 
@@ -128 +128 @@
         throws ConditionThrowable
     {
-        return _execute(first, list5(second, third, fourth, fifth, sixth));
+        return _execute(first, list(second, third, fourth, fifth, sixth));
     }
 
@@ -138 +138 @@
         throws ConditionThrowable
     {
-        return _execute(first, list6(second, third, fourth, fifth, sixth,
+        return _execute(first, list(second, third, fourth, fifth, sixth,
                                      seventh));
     }
@@ -149 +149 @@
         throws ConditionThrowable
     {
-        return _execute(first, list7(second, third, fourth, fifth, sixth,
+        return _execute(first, list(second, third, fourth, fifth, sixth,
                                      seventh, eighth));
     }

trunk/abcl/src/org/armedbear/lisp/Primitive2R.java

@@ -104 +104 @@
         throws ConditionThrowable
     {
-        return _execute(first, second, list2(third, fourth));
+        return _execute(first, second, list(third, fourth));
     }
 
@@ -113 +113 @@
         throws ConditionThrowable
     {
-        return _execute(first, second, list3(third, fourth, fifth));
+        return _execute(first, second, list(third, fourth, fifth));
     }
 
@@ -122 +122 @@
         throws ConditionThrowable
     {
-        return _execute(first, second, list4(third, fourth, fifth, sixth));
+        return _execute(first, second, list(third, fourth, fifth, sixth));
     }
 
@@ -132 +132 @@
         throws ConditionThrowable
     {
-        return _execute(first, second, list5(third, fourth, fifth, sixth,
+        return _execute(first, second, list(third, fourth, fifth, sixth,
                                              seventh));
     }
@@ -143 +143 @@
         throws ConditionThrowable
     {
-        return _execute(first, second, list6(third, fourth, fifth, sixth,
+        return _execute(first, second, list(third, fourth, fifth, sixth,
                                              seventh, eighth));
     }

trunk/abcl/src/org/armedbear/lisp/Primitives.java

@@ -1517 +1517 @@
         if (index < 0)
           return type_error(first,
-                                 list2(Symbol.INTEGER, Fixnum.ZERO));
+                                 list(Symbol.INTEGER, Fixnum.ZERO));
         for (int i = 0; i < index; i++)
           {
@@ -1833 +1833 @@
         LispObject block = new Cons(Symbol.BLOCK, new Cons(symbol, body));
         LispObject toBeApplied =
-          list2(Symbol.FUNCTION, list3(Symbol.LAMBDA, lambdaList, block));
+          list(Symbol.FUNCTION, list(Symbol.LAMBDA, lambdaList, block));
         final LispThread thread = LispThread.currentThread();
         LispObject formArg = gensym("FORM-", thread);
         LispObject envArg = gensym("ENV-", thread); // Ignored.
         LispObject expander =
-          list3(Symbol.LAMBDA, list2(formArg, envArg),
-                list3(Symbol.APPLY, toBeApplied,
-                      list2(Symbol.CDR, formArg)));
+          list(Symbol.LAMBDA, list(formArg, envArg),
+                list(Symbol.APPLY, toBeApplied,
+                      list(Symbol.CDR, formArg)));
         Closure expansionFunction = new Closure(expander, env);
         MacroObject macroObject =
@@ -2551 +2551 @@
         catch (ClassCastException e)
           {
-            return type_error(arg, list3(Symbol.AND, Symbol.VECTOR,
-                                              list2(Symbol.SATISFIES,
+            return type_error(arg, list(Symbol.AND, Symbol.VECTOR,
+                                              list(Symbol.SATISFIES,
                                                     Symbol.ARRAY_HAS_FILL_POINTER_P)));
           }
@@ -2577 +2577 @@
         catch (ClassCastException e)
           {
-            return type_error(first, list3(Symbol.AND, Symbol.VECTOR,
-                                                list2(Symbol.SATISFIES,
+            return type_error(first, list(Symbol.AND, Symbol.VECTOR,
+                                                list(Symbol.SATISFIES,
                                                       Symbol.ARRAY_HAS_FILL_POINTER_P)));
           }
@@ -3193 +3193 @@
           return gensym(arg.getStringValue(), LispThread.currentThread());
         return type_error(arg,
-                               list3(Symbol.OR,
+                               list(Symbol.OR,
                                      Symbol.STRING,
                                      Symbol.UNSIGNED_BYTE));
@@ -3734 +3734 @@
           new Cons(Symbol.BLOCK, new Cons(symbol, body));
         LispObject toBeApplied =
-          list3(Symbol.LAMBDA, lambdaList, block);
+          list(Symbol.LAMBDA, lambdaList, block);
         final LispThread thread = LispThread.currentThread();
         LispObject formArg = gensym("WHOLE-", thread);
         LispObject envArg = gensym("ENVIRONMENT-", thread); // Ignored.
         LispObject expander =
-          list3(Symbol.LAMBDA, list2(formArg, envArg),
-                list3(Symbol.APPLY, toBeApplied,
-                      list2(Symbol.CDR, formArg)));
+          list(Symbol.LAMBDA, list(formArg, envArg),
+                list(Symbol.APPLY, toBeApplied,
+                      list(Symbol.CDR, formArg)));
         return expander;
       }
@@ -4884 +4884 @@
         int size = Fixnum.getValue(first);
         if (size < 0)
-          return type_error(first, list3(Symbol.INTEGER, Fixnum.ZERO,
+          return type_error(first, list(Symbol.INTEGER, Fixnum.ZERO,
                                               Symbol.MOST_POSITIVE_FIXNUM.getSymbolValue()));
         LispObject result = NIL;

trunk/abcl/src/org/armedbear/lisp/RandomState.java

@@ -127 +127 @@
             }
         }
-        return type_error(arg, list3(Symbol.OR,
-                                          list2(Symbol.INTEGER, Fixnum.ONE),
-                                          list2(Symbol.FLOAT, list1(Fixnum.ZERO))));
+        return type_error(arg, list(Symbol.OR,
+                                          list(Symbol.INTEGER, Fixnum.ONE),
+                                          list(Symbol.FLOAT, list(Fixnum.ZERO))));
     }
 

trunk/abcl/src/org/armedbear/lisp/Readtable.java

@@ -581 +581 @@
                 return second;
               }
-            return type_error(second, list5(Symbol.MEMBER,
+            return type_error(second, list(Symbol.MEMBER,
                                                  Keyword.INVERT,
                                                  Keyword.PRESERVE,

trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

@@ -154 +154 @@
   public LispObject typeOf()
   {
-    return list3(Symbol.SIMPLE_ARRAY, elementType, getDimensions());
+    return list(Symbol.SIMPLE_ARRAY, elementType, getDimensions());
   }
 

trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

@@ -125 +125 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16, getDimensions());
+        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_16, getDimensions());
     }
 
@@ -293 +293 @@
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
-            error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
+            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
             // Not reached.
             return null;

trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

@@ -129 +129 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32, getDimensions());
+        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_32, getDimensions());
     }
 
@@ -283 +283 @@
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
-            error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
+            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
             // Not reached.
             return null;

trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

@@ -125 +125 @@
     public LispObject typeOf()
     {
-        return list3(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, getDimensions());
+        return list(Symbol.SIMPLE_ARRAY, UNSIGNED_BYTE_8, getDimensions());
     }
 
@@ -280 +280 @@
     {
         if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
-            error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
+            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
             // Not reached.
             return null;

trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java

@@ -66 +66 @@
     public LispObject typeOf()
     {
-        return list2(Symbol.SIMPLE_BIT_VECTOR, new Fixnum(capacity));
+        return list(Symbol.SIMPLE_BIT_VECTOR, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/SimpleString.java

@@ -98 +98 @@
     public LispObject typeOf()
     {
-        return list2(Symbol.SIMPLE_BASE_STRING, new Fixnum(capacity));
+        return list(Symbol.SIMPLE_BASE_STRING, new Fixnum(capacity));
     }
 

trunk/abcl/src/org/armedbear/lisp/SimpleTypeError.java

@@ -78 +78 @@
                 LispObject result =
                     Primitives.APPLY.execute(Symbol.FORMAT,
-                                             Primitives.APPEND.execute(list2(NIL,
+                                             Primitives.APPEND.execute(list(NIL,
                                                                              formatControl),
                                                                        formatArguments));

trunk/abcl/src/org/armedbear/lisp/SimpleVector.java

@@ -77 +77 @@
   public LispObject typeOf()
   {
-    return list2(Symbol.SIMPLE_VECTOR, new Fixnum(capacity));
+    return list(Symbol.SIMPLE_VECTOR, new Fixnum(capacity));
   }
 

trunk/abcl/src/org/armedbear/lisp/SingleFloat.java

@@ -586 +586 @@
         if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
             !memq(Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue(thread),
-                  list2(Symbol.SINGLE_FLOAT, Symbol.SHORT_FLOAT)))
+                  list(Symbol.SINGLE_FLOAT, Symbol.SHORT_FLOAT)))
         {
             if (s1.indexOf('E') >= 0)

trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java

@@ -48 +48 @@
     public SlotDefinitionClass()
     {
-        super(Symbol.SLOT_DEFINITION, list1(StandardClass.STANDARD_OBJECT));
+        super(Symbol.SLOT_DEFINITION, list(StandardClass.STANDARD_OBJECT));
         Package pkg = PACKAGE_SYS;
         LispObject[] instanceSlotNames = {

trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

@@ -392 +392 @@
           new Cons(Symbol.LAMBDA, new Cons(parameters, body));
         LispObject lambda_name =
-          list2(recursive ? Symbol.LABELS : Symbol.FLET, name);
+          list(recursive ? Symbol.LABELS : Symbol.FLET, name);
         Closure closure =
           new Closure(lambda_name, lambda_expression,
@@ -535 +535 @@
               }
           }
-        return error(new UndefinedFunction(list2(Keyword.NAME, arg)));
+        return error(new UndefinedFunction(list(Keyword.NAME, arg)));
       }
     };
@@ -567 +567 @@
                         LispObject expansion =
                           ((SymbolMacro)binding.value).getExpansion();
-                        LispObject form = list3(Symbol.SETF, expansion, args.car());
+                        LispObject form = list(Symbol.SETF, expansion, args.car());
                         value = eval(form, env, thread);
                       }
@@ -582 +582 @@
                         LispObject expansion =
                           ((SymbolMacro)symbol.getSymbolValue()).getExpansion();
-                        LispObject form = list3(Symbol.SETF, expansion, args.car());
+                        LispObject form = list(Symbol.SETF, expansion, args.car());
                         value = eval(form, env, thread);
                       }
@@ -602 +602 @@
                         LispObject expansion =
                           ((SymbolMacro)binding.value).getExpansion();
-                        LispObject form = list3(Symbol.SETF, expansion, args.car());
+                        LispObject form = list(Symbol.SETF, expansion, args.car());
                         value = eval(form, env, thread);
                       }
@@ -617 +617 @@
                         LispObject expansion =
                           ((SymbolMacro)symbol.getSymbolValue()).getExpansion();
-                        LispObject form = list3(Symbol.SETF, expansion, args.car());
+                        LispObject form = list(Symbol.SETF, expansion, args.car());
                         value = eval(form, env, thread);
                       }

trunk/abcl/src/org/armedbear/lisp/StandardClass.java

@@ -78 +78 @@
                              new SimpleString("No layout for class ~S."),
                              Keyword.FORMAT_ARGUMENTS,
-                             list1(this));
+                             list(this));
       }
     return new StandardObject(this, layout.getLength());
@@ -109 +109 @@
   // below.
   public static final StandardClass STANDARD_CLASS =
-    addStandardClass(Symbol.STANDARD_CLASS, list1(BuiltInClass.CLASS_T));
+    addStandardClass(Symbol.STANDARD_CLASS, list(BuiltInClass.CLASS_T));
   public static final StandardClass STANDARD_OBJECT =
-    addStandardClass(Symbol.STANDARD_OBJECT, list1(BuiltInClass.CLASS_T));
+    addStandardClass(Symbol.STANDARD_OBJECT, list(BuiltInClass.CLASS_T));
 
   // BuiltInClass.FUNCTION is also null here (see previous comment).
   public static final StandardClass GENERIC_FUNCTION =
-    addStandardClass(Symbol.GENERIC_FUNCTION, list2(BuiltInClass.FUNCTION,
+    addStandardClass(Symbol.GENERIC_FUNCTION, list(BuiltInClass.FUNCTION,
                                                     STANDARD_OBJECT));
 
   public static final StandardClass CLASS =
-    addStandardClass(Symbol.CLASS, list1(STANDARD_OBJECT));
+    addStandardClass(Symbol.CLASS, list(STANDARD_OBJECT));
 
   public static final StandardClass BUILT_IN_CLASS =
-    addStandardClass(Symbol.BUILT_IN_CLASS, list1(CLASS));
+    addStandardClass(Symbol.BUILT_IN_CLASS, list(CLASS));
 
   public static final StandardClass JAVA_CLASS =
-      addStandardClass(Symbol.JAVA_CLASS, list1(CLASS));
+      addStandardClass(Symbol.JAVA_CLASS, list(CLASS));
   
   public static final StandardClass FORWARD_REFERENCED_CLASS =
-    addStandardClass(Symbol.FORWARD_REFERENCED_CLASS, list1(CLASS));
+    addStandardClass(Symbol.FORWARD_REFERENCED_CLASS, list(CLASS));
 
   public static final StandardClass STRUCTURE_CLASS =
-    addStandardClass(Symbol.STRUCTURE_CLASS, list1(CLASS));
+    addStandardClass(Symbol.STRUCTURE_CLASS, list(CLASS));
 
   public static final StandardClass CONDITION =
-    addStandardClass(Symbol.CONDITION, list1(STANDARD_OBJECT));
+    addStandardClass(Symbol.CONDITION, list(STANDARD_OBJECT));
 
   public static final StandardClass SIMPLE_CONDITION =
-    addStandardClass(Symbol.SIMPLE_CONDITION, list1(CONDITION));
+    addStandardClass(Symbol.SIMPLE_CONDITION, list(CONDITION));
 
   public static final StandardClass WARNING =
-    addStandardClass(Symbol.WARNING, list1(CONDITION));
+    addStandardClass(Symbol.WARNING, list(CONDITION));
 
   public static final StandardClass SIMPLE_WARNING =
-    addStandardClass(Symbol.SIMPLE_WARNING, list2(SIMPLE_CONDITION, WARNING));
+    addStandardClass(Symbol.SIMPLE_WARNING, list(SIMPLE_CONDITION, WARNING));
 
   public static final StandardClass STYLE_WARNING =
-    addStandardClass(Symbol.STYLE_WARNING, list1(WARNING));
+    addStandardClass(Symbol.STYLE_WARNING, list(WARNING));
 
   public static final StandardClass SERIOUS_CONDITION =
-    addStandardClass(Symbol.SERIOUS_CONDITION, list1(CONDITION));
+    addStandardClass(Symbol.SERIOUS_CONDITION, list(CONDITION));
 
   public static final StandardClass STORAGE_CONDITION =
-    addStandardClass(Symbol.STORAGE_CONDITION, list1(SERIOUS_CONDITION));
+    addStandardClass(Symbol.STORAGE_CONDITION, list(SERIOUS_CONDITION));
 
   public static final StandardClass ERROR =
-    addStandardClass(Symbol.ERROR, list1(SERIOUS_CONDITION));
+    addStandardClass(Symbol.ERROR, list(SERIOUS_CONDITION));
 
   public static final StandardClass ARITHMETIC_ERROR =
-    addStandardClass(Symbol.ARITHMETIC_ERROR, list1(ERROR));
+    addStandardClass(Symbol.ARITHMETIC_ERROR, list(ERROR));
 
   public static final StandardClass CELL_ERROR =
-    addStandardClass(Symbol.CELL_ERROR, list1(ERROR));
+    addStandardClass(Symbol.CELL_ERROR, list(ERROR));
 
   public static final StandardClass CONTROL_ERROR =
-    addStandardClass(Symbol.CONTROL_ERROR, list1(ERROR));
+    addStandardClass(Symbol.CONTROL_ERROR, list(ERROR));
 
   public static final StandardClass FILE_ERROR =
-    addStandardClass(Symbol.FILE_ERROR, list1(ERROR));
+    addStandardClass(Symbol.FILE_ERROR, list(ERROR));
 
   public static final StandardClass DIVISION_BY_ZERO =
-    addStandardClass(Symbol.DIVISION_BY_ZERO, list1(ARITHMETIC_ERROR));
+    addStandardClass(Symbol.DIVISION_BY_ZERO, list(ARITHMETIC_ERROR));
 
   public static final StandardClass FLOATING_POINT_INEXACT =
-    addStandardClass(Symbol.FLOATING_POINT_INEXACT, list1(ARITHMETIC_ERROR));
+    addStandardClass(Symbol.FLOATING_POINT_INEXACT, list(ARITHMETIC_ERROR));
 
   public static final StandardClass FLOATING_POINT_INVALID_OPERATION =
-    addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list1(ARITHMETIC_ERROR));
+    addStandardClass(Symbol.FLOATING_POINT_INVALID_OPERATION, list(ARITHMETIC_ERROR));
 
   public static final StandardClass FLOATING_POINT_OVERFLOW =
-    addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list1(ARITHMETIC_ERROR));
+    addStandardClass(Symbol.FLOATING_POINT_OVERFLOW, list(ARITHMETIC_ERROR));
 
   public static final StandardClass FLOATING_POINT_UNDERFLOW =
-    addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list1(ARITHMETIC_ERROR));
+    addStandardClass(Symbol.FLOATING_POINT_UNDERFLOW, list(ARITHMETIC_ERROR));
 
   public static final StandardClass PROGRAM_ERROR =
-    addStandardClass(Symbol.PROGRAM_ERROR, list1(ERROR));
+    addStandardClass(Symbol.PROGRAM_ERROR, list(ERROR));
 
   public static final StandardClass PACKAGE_ERROR =
-    addStandardClass(Symbol.PACKAGE_ERROR, list1(ERROR));
+    addStandardClass(Symbol.PACKAGE_ERROR, list(ERROR));
 
   public static final StandardClass STREAM_ERROR =
-    addStandardClass(Symbol.STREAM_ERROR, list1(ERROR));
+    addStandardClass(Symbol.STREAM_ERROR, list(ERROR));
 
   public static final StandardClass PARSE_ERROR =
-    addStandardClass(Symbol.PARSE_ERROR, list1(ERROR));
+    addStandardClass(Symbol.PARSE_ERROR, list(ERROR));
 
   public static final StandardClass PRINT_NOT_READABLE =
-    addStandardClass(Symbol.PRINT_NOT_READABLE, list1(ERROR));
+    addStandardClass(Symbol.PRINT_NOT_READABLE, list(ERROR));
 
   public static final StandardClass READER_ERROR =
-    addStandardClass(Symbol.READER_ERROR, list2(PARSE_ERROR, STREAM_ERROR));
+    addStandardClass(Symbol.READER_ERROR, list(PARSE_ERROR, STREAM_ERROR));
 
   public static final StandardClass END_OF_FILE =
-    addStandardClass(Symbol.END_OF_FILE, list1(STREAM_ERROR));
+    addStandardClass(Symbol.END_OF_FILE, list(STREAM_ERROR));
 
   public static final StandardClass SIMPLE_ERROR =
-    addStandardClass(Symbol.SIMPLE_ERROR, list2(SIMPLE_CONDITION, ERROR));
+    addStandardClass(Symbol.SIMPLE_ERROR, list(SIMPLE_CONDITION, ERROR));
 
   public static final StandardClass TYPE_ERROR =
-    addStandardClass(Symbol.TYPE_ERROR, list1(ERROR));
+    addStandardClass(Symbol.TYPE_ERROR, list(ERROR));
 
   public static final StandardClass SIMPLE_TYPE_ERROR =
-    addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list2(SIMPLE_CONDITION,
+    addStandardClass(Symbol.SIMPLE_TYPE_ERROR, list(SIMPLE_CONDITION,
                                                      TYPE_ERROR));
 
   public static final StandardClass UNBOUND_SLOT =
-    addStandardClass(Symbol.UNBOUND_SLOT, list1(CELL_ERROR));
+    addStandardClass(Symbol.UNBOUND_SLOT, list(CELL_ERROR));
 
   public static final StandardClass UNBOUND_VARIABLE =
-    addStandardClass(Symbol.UNBOUND_VARIABLE, list1(CELL_ERROR));
+    addStandardClass(Symbol.UNBOUND_VARIABLE, list(CELL_ERROR));
 
   public static final StandardClass UNDEFINED_FUNCTION =
-    addStandardClass(Symbol.UNDEFINED_FUNCTION, list1(CELL_ERROR));
+    addStandardClass(Symbol.UNDEFINED_FUNCTION, list(CELL_ERROR));
 
   public static final StandardClass COMPILER_ERROR =
-    addStandardClass(Symbol.COMPILER_ERROR, list1(CONDITION));
+    addStandardClass(Symbol.COMPILER_ERROR, list(CONDITION));
 
   public static final StandardClass COMPILER_UNSUPPORTED_FEATURE_ERROR =
     addStandardClass(Symbol.COMPILER_UNSUPPORTED_FEATURE_ERROR,
-                     list1(CONDITION));
+                     list(CONDITION));
 
   public static final StandardClass JAVA_EXCEPTION =
-    addStandardClass(Symbol.JAVA_EXCEPTION, list1(ERROR));
+    addStandardClass(Symbol.JAVA_EXCEPTION, list(ERROR));
 
   public static final StandardClass METHOD =
-    addStandardClass(Symbol.METHOD, list1(STANDARD_OBJECT));
+    addStandardClass(Symbol.METHOD, list(STANDARD_OBJECT));
 
   public static final StandardClass STANDARD_METHOD =
@@ -272 +272 @@
     STANDARD_CLASS.setDirectSuperclass(CLASS);
     STANDARD_OBJECT.setDirectSuperclass(BuiltInClass.CLASS_T);
-    GENERIC_FUNCTION.setDirectSuperclasses(list2(BuiltInClass.FUNCTION,
+    GENERIC_FUNCTION.setDirectSuperclasses(list(BuiltInClass.FUNCTION,
                                                  STANDARD_OBJECT));
 
@@ -278 +278 @@
                             CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     ARITHMETIC_ERROR.setDirectSlotDefinitions(
-      list2(new SlotDefinition(Symbol.OPERATION,
-                               list1(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERATION"))),
+      list(new SlotDefinition(Symbol.OPERATION,
+                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERATION"))),
             new SlotDefinition(Symbol.OPERANDS,
-                               list1(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERANDS")))));
+                               list(PACKAGE_CL.intern("ARITHMETIC-ERROR-OPERANDS")))));
     BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
                           BuiltInClass.CLASS_T);
@@ -289 +289 @@
                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
     CELL_ERROR.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.NAME,
-                               list1(Symbol.CELL_ERROR_NAME))));
+      list(new SlotDefinition(Symbol.NAME,
+                               list(Symbol.CELL_ERROR_NAME))));
     CLASS.setCPL(CLASS, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     COMPILER_ERROR.setCPL(COMPILER_ERROR, CONDITION, STANDARD_OBJECT,
@@ -299 +299 @@
     CONDITION.setCPL(CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     CONDITION.setDirectSlotDefinitions(
-      list2(new SlotDefinition(Symbol.FORMAT_CONTROL,
-                               list1(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
+      list(new SlotDefinition(Symbol.FORMAT_CONTROL,
+                               list(Symbol.SIMPLE_CONDITION_FORMAT_CONTROL)),
             new SlotDefinition(Symbol.FORMAT_ARGUMENTS,
-                               list1(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
+                               list(Symbol.SIMPLE_CONDITION_FORMAT_ARGUMENTS),
                                NIL)));
-    CONDITION.setDirectDefaultInitargs(list2(Keyword.FORMAT_ARGUMENTS,
+    CONDITION.setDirectDefaultInitargs(list(Keyword.FORMAT_ARGUMENTS,
                                              // FIXME
-                                             new Closure(list3(Symbol.LAMBDA, NIL, NIL),
+                                             new Closure(list(Symbol.LAMBDA, NIL, NIL),
                                                          new Environment())));
     CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
@@ -320 +320 @@
                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
     FILE_ERROR.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.PATHNAME,
-                               list1(PACKAGE_CL.intern("FILE-ERROR-PATHNAME")))));
+      list(new SlotDefinition(Symbol.PATHNAME,
+                               list(PACKAGE_CL.intern("FILE-ERROR-PATHNAME")))));
     FLOATING_POINT_INEXACT.setCPL(FLOATING_POINT_INEXACT, ARITHMETIC_ERROR,
                                   ERROR, SERIOUS_CONDITION, CONDITION,
@@ -343 +343 @@
                           STANDARD_OBJECT, BuiltInClass.CLASS_T);
     JAVA_EXCEPTION.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.CAUSE, list1(Symbol.JAVA_EXCEPTION_CAUSE))));
+      list(new SlotDefinition(Symbol.CAUSE, list(Symbol.JAVA_EXCEPTION_CAUSE))));
     METHOD.setCPL(METHOD, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     PACKAGE_ERROR.setCPL(PACKAGE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
     PACKAGE_ERROR.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.PACKAGE,
-                               list1(PACKAGE_CL.intern("PACKAGE-ERROR-PACKAGE")))));
+      list(new SlotDefinition(Symbol.PACKAGE,
+                               list(PACKAGE_CL.intern("PACKAGE-ERROR-PACKAGE")))));
     PARSE_ERROR.setCPL(PARSE_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
                        STANDARD_OBJECT, BuiltInClass.CLASS_T);
@@ -355 +355 @@
                               CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     PRINT_NOT_READABLE.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.OBJECT,
-                               list1(PACKAGE_CL.intern("PRINT-NOT-READABLE-OBJECT")))));
+      list(new SlotDefinition(Symbol.OBJECT,
+                               list(PACKAGE_CL.intern("PRINT-NOT-READABLE-OBJECT")))));
     PROGRAM_ERROR.setCPL(PROGRAM_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
@@ -369 +369 @@
                         SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
                         BuiltInClass.CLASS_T);
-    SIMPLE_TYPE_ERROR.setDirectSuperclasses(list2(SIMPLE_CONDITION,
+    SIMPLE_TYPE_ERROR.setDirectSuperclasses(list(SIMPLE_CONDITION,
                                                   TYPE_ERROR));
     SIMPLE_TYPE_ERROR.setCPL(SIMPLE_TYPE_ERROR, SIMPLE_CONDITION,
                              TYPE_ERROR, ERROR, SERIOUS_CONDITION,
                              CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
-    SIMPLE_WARNING.setDirectSuperclasses(list2(SIMPLE_CONDITION, WARNING));
+    SIMPLE_WARNING.setDirectSuperclasses(list(SIMPLE_CONDITION, WARNING));
     SIMPLE_WARNING.setCPL(SIMPLE_WARNING, SIMPLE_CONDITION, WARNING,
                           CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
@@ -385 +385 @@
                         STANDARD_OBJECT, BuiltInClass.CLASS_T);
     STREAM_ERROR.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.STREAM,
-                               list1(PACKAGE_CL.intern("STREAM-ERROR-STREAM")))));
+      list(new SlotDefinition(Symbol.STREAM,
+                               list(PACKAGE_CL.intern("STREAM-ERROR-STREAM")))));
     STRUCTURE_CLASS.setCPL(STRUCTURE_CLASS, CLASS, STANDARD_OBJECT,
                            BuiltInClass.CLASS_T);
@@ -394 +394 @@
                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
     TYPE_ERROR.setDirectSlotDefinitions(
-      list2(new SlotDefinition(Symbol.DATUM,
-                               list1(PACKAGE_CL.intern("TYPE-ERROR-DATUM"))),
+      list(new SlotDefinition(Symbol.DATUM,
+                               list(PACKAGE_CL.intern("TYPE-ERROR-DATUM"))),
             new SlotDefinition(Symbol.EXPECTED_TYPE,
-                               list1(PACKAGE_CL.intern("TYPE-ERROR-EXPECTED-TYPE")))));
+                               list(PACKAGE_CL.intern("TYPE-ERROR-EXPECTED-TYPE")))));
     UNBOUND_SLOT.setCPL(UNBOUND_SLOT, CELL_ERROR, ERROR, SERIOUS_CONDITION,
                         CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     UNBOUND_SLOT.setDirectSlotDefinitions(
-      list1(new SlotDefinition(Symbol.INSTANCE,
-                               list1(PACKAGE_CL.intern("UNBOUND-SLOT-INSTANCE")))));
+      list(new SlotDefinition(Symbol.INSTANCE,
+                               list(PACKAGE_CL.intern("UNBOUND-SLOT-INSTANCE")))));
     UNBOUND_VARIABLE.setCPL(UNBOUND_VARIABLE, CELL_ERROR, ERROR,
                             SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
@@ -469 +469 @@
     STANDARD_READER_METHOD.setSlotDefinitions(STANDARD_READER_METHOD.getClassLayout().generateSlotDefinitions());
     // All but the last slot are inherited.
-    STANDARD_READER_METHOD.setDirectSlotDefinitions(list1(STANDARD_READER_METHOD.getSlotDefinitions().reverse().car()));
+    STANDARD_READER_METHOD.setDirectSlotDefinitions(list(STANDARD_READER_METHOD.getSlotDefinitions().reverse().car()));
 
     // STANDARD-GENERIC-FUNCTION

trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java

@@ -76 +76 @@
           new StandardMethod(this, function, lambdaList, specializers);
         slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] =
-          list1(method);
+          list(method);
         slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] =
           StandardClass.STANDARD_METHOD;
@@ -826 +826 @@
                                 true,
                                 _GENERIC_FUNCTION_NAME,
-                                list1(Symbol.GENERIC_FUNCTION),
-                                list1(StandardClass.STANDARD_GENERIC_FUNCTION));
+                                list(Symbol.GENERIC_FUNCTION),
+                                list(StandardClass.STANDARD_GENERIC_FUNCTION));
 
   private static class CacheEntry

trunk/abcl/src/org/armedbear/lisp/StandardGenericFunctionClass.java

@@ -50 +50 @@
   {
     super(Symbol.STANDARD_GENERIC_FUNCTION,
-          list1(StandardClass.GENERIC_FUNCTION));
+          list(StandardClass.GENERIC_FUNCTION));
     Package pkg = PACKAGE_SYS;
     LispObject[] instanceSlotNames =

trunk/abcl/src/org/armedbear/lisp/StandardMethod.java

@@ -384 +384 @@
                                 true,
                                 _METHOD_SPECIALIZERS,
-                                list1(Symbol.METHOD),
-                                list1(StandardClass.STANDARD_METHOD));
+                                list(Symbol.METHOD),
+                                list(StandardClass.STANDARD_METHOD));
 
   private static final StandardGenericFunction METHOD_QUALIFIERS =
@@ -392 +392 @@
                                 true,
                                 _METHOD_QUALIFIERS,
-                                list1(Symbol.METHOD),
-                                list1(StandardClass.STANDARD_METHOD));
+                                list(Symbol.METHOD),
+                                list(StandardClass.STANDARD_METHOD));
 
 }

trunk/abcl/src/org/armedbear/lisp/StandardMethodClass.java

@@ -46 +46 @@
   public StandardMethodClass()
   {
-    super(Symbol.STANDARD_METHOD, list1(StandardClass.METHOD));
+    super(Symbol.STANDARD_METHOD, list(StandardClass.METHOD));
     Package pkg = PACKAGE_SYS;
     LispObject[] instanceSlotNames =

trunk/abcl/src/org/armedbear/lisp/StandardObject.java

@@ -400 +400 @@
           {
             return type_error(second,
-                                   list3(Symbol.INTEGER, Fixnum.ZERO,
+                                   list(Symbol.INTEGER, Fixnum.ZERO,
                                          new Fixnum(instance.slots.length)));
           }
@@ -411 +411 @@
           {
             return type_error(second,
-                                   list3(Symbol.INTEGER, Fixnum.ZERO,
+                                   list(Symbol.INTEGER, Fixnum.ZERO,
                                          new Fixnum(instance.slots.length)));
           }

trunk/abcl/src/org/armedbear/lisp/StandardReaderMethodClass.java

@@ -51 +51 @@
   {
     super(Symbol.STANDARD_READER_METHOD,
-          list1(StandardClass.STANDARD_READER_METHOD));
+          list(StandardClass.STANDARD_READER_METHOD));
     Package pkg = PACKAGE_SYS;
     LispObject[] instanceSlotNames =

trunk/abcl/src/org/armedbear/lisp/Stream.java

@@ -2925 +2925 @@
         int end = Fixnum.getValue(fourth);
         if (!v.getElementType().equal(UNSIGNED_BYTE_8))
-          return type_error(first, list2(Symbol.VECTOR,
+          return type_error(first, list(Symbol.VECTOR,
                                               UNSIGNED_BYTE_8));
         for (int i = start; i < end; i++)

trunk/abcl/src/org/armedbear/lisp/Symbol.java

@@ -362 +362 @@
     LispObject obj = get(this, Symbol.SETF_FUNCTION, null);
     if (obj == null)
-      error(new UndefinedFunction(list2(Keyword.NAME,
-                                         list2(Symbol.SETF,
+      error(new UndefinedFunction(list(Keyword.NAME,
+                                         list(Symbol.SETF,
                                                this))));
     return obj;
@@ -735 +735 @@
     catch (NullPointerException e)
       {
-        return handleNPE(e, list1(arg));
+        return handleNPE(e, list(arg));
       }
   }
@@ -749 +749 @@
     catch (NullPointerException e)
       {
-        return handleNPE(e, list2(first, second));
+        return handleNPE(e, list(first, second));
       }
   }
@@ -764 +764 @@
     catch (NullPointerException e)
       {
-        return handleNPE(e, list3(first, second, third));
+        return handleNPE(e, list(first, second, third));
       }
   }
@@ -779 +779 @@
     catch (NullPointerException e)
       {
-        return handleNPE(e, list4(first, second, third, fourth));
+        return handleNPE(e, list(first, second, third, fourth));
       }
   }
@@ -795 +795 @@
     catch (NullPointerException e)
       {
-        return handleNPE(e, list5(first, second, third, fourth, fifth));
+        return handleNPE(e, list(first, second, third, fourth, fifth));
       }
   }
@@ -811 +811 @@
     catch (NullPointerException e)
       {
-        return handleNPE(e, list6(first, second, third, fourth, fifth,
+        return handleNPE(e, list(first, second, third, fourth, fifth,
                                   sixth));
       }
@@ -831 +831 @@
       {
         return handleNPE(e,
-                         list7(first, second, third, fourth, fifth, sixth,
+                         list(first, second, third, fourth, fifth, sixth,
                                seventh));
       }
@@ -851 +851 @@
       {
         return handleNPE(e,
-                         list8(first, second, third, fourth, fifth, sixth,
+                         list(first, second, third, fourth, fifth, sixth,
                                seventh, eighth));
       }

trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java

@@ -60 +60 @@
         if (itype.equal(otype))
             return itype;
-        return list3(Symbol.AND, itype, otype);
+        return list(Symbol.AND, itype, otype);
     }
 
@@ -240 +240 @@
             }
             if (!in.isInputStream())
-                return type_error(in, list2(Symbol.SATISFIES,
+                return type_error(in, list(Symbol.SATISFIES,
                                                  Symbol.INPUT_STREAM_P));
             if (!out.isOutputStream())
-                return type_error(out, list2(Symbol.SATISFIES,
+                return type_error(out, list(Symbol.SATISFIES,
                                                   Symbol.OUTPUT_STREAM_P));
             return new TwoWayStream(in, out);

trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java

@@ -53 +53 @@
     {
         if (adjustable)
-            return list3(Symbol.ARRAY, elementType, NIL);
+            return list(Symbol.ARRAY, elementType, NIL);
         else
-            return list3(Symbol.SIMPLE_ARRAY, elementType, NIL);
+            return list(Symbol.SIMPLE_ARRAY, elementType, NIL);
     }
 
@@ -139 +139 @@
         if (printReadably) {
             if (elementType != T) {
-                error(new PrintNotReadable(list2(Keyword.OBJECT, this)));
+                error(new PrintNotReadable(list(Keyword.OBJECT, this)));
                 // Not reached.
                 return null;