Changeset 12462

Timestamp:

02/13/10 22:16:55 (13 years ago)

Author:

ehuelsmann

Message:

In order to make StandardClass? use its NAME slot
instead of LispClass?'s 'symbol' field:

• Rename 'symbol' to 'name', making it private
• Rename the 'symbol' java property accessors everywhere
• Add getName() / setName() overrides in StandardClass?

which write to the slot instead of the field

Location:

branches/metaclass/abcl/src/org/armedbear/lisp

Files:

• BuiltInClass.java (modified) (1 diff)
• Condition.java (modified) (1 diff)
• ForwardReferencedClass.java (modified) (1 diff)
• LispClass.java (modified) (5 diffs)
• Primitives.java (modified) (2 diffs)
• SlotClass.java (modified) (1 diff)
• StandardClass.java (modified) (7 diffs)
• StandardGenericFunction.java (modified) (1 diff)
• StandardMethod.java (modified) (2 diffs)
• StandardObject.java (modified) (3 diffs)
• StructureClass.java (modified) (1 diff)
• StructureObject.java (modified) (4 diffs)
• make_condition.java (modified) (1 diff)

branches/metaclass/abcl/src/org/armedbear/lisp/BuiltInClass.java

@@ -75 +75 @@
   {
     StringBuilder sb = new StringBuilder("#<BUILT-IN-CLASS ");
-    sb.append(symbol.writeToString());
+    sb.append(getName().writeToString());
     sb.append('>');
     return sb.toString();

branches/metaclass/abcl/src/org/armedbear/lisp/Condition.java

@@ -140 +140 @@
     LispClass c = getLispClass();
     if (c != null)
-      return c.getSymbol();
+      return c.getName();
     return Symbol.CONDITION;
   }

branches/metaclass/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java

@@ -70 +70 @@
         StringBuffer sb =
             new StringBuffer(Symbol.FORWARD_REFERENCED_CLASS.writeToString());
-        if (symbol != null) {
+        if (getName() != null) {
             sb.append(' ');
-            sb.append(symbol.writeToString());
+            sb.append(getName().writeToString());
         }
         return unreadableString(sb.toString());

branches/metaclass/abcl/src/org/armedbear/lisp/LispClass.java

@@ -89 +89 @@
   private final int sxhash;
 
-  protected Symbol symbol;
+  private LispObject name;
   private LispObject propertyList;
   private Layout classLayout;
@@ -105 +105 @@
   }
 
+  protected LispClass(Symbol symbol)
+  {
+    this(null, symbol);
+  }
+
   protected LispClass(Layout layout, Symbol symbol)
+  {
+    super(layout, layout == null ? 0 : layout.getLength());
+    setName(symbol);
+    sxhash = hashCode() & 0x7fffffff;
+  }
+
+  protected LispClass(Layout layout,
+                      Symbol symbol, LispObject directSuperclasses)
   {
     super(layout, layout == null ? 0 : layout.getLength());
     sxhash = hashCode() & 0x7fffffff;
-    this.symbol = symbol;
-    this.directSuperclasses = NIL;
-  }
-
-  protected LispClass(Layout layout,
-                      Symbol symbol, LispObject directSuperclasses)
-  {
-    super(layout, layout == null ? 0 : layout.getLength());
-    sxhash = hashCode() & 0x7fffffff;
-    this.symbol = symbol;
+    setName(symbol);
     this.directSuperclasses = directSuperclasses;
   }
@@ -126 +130 @@
   {
     LispObject result = NIL;
-    result = result.push(new Cons("NAME", symbol != null ? symbol : NIL));
+    result = result.push(new Cons("NAME", name != null ? name : NIL));
     result = result.push(new Cons("LAYOUT", classLayout != null ? classLayout : NIL));
     result = result.push(new Cons("DIRECT-SUPERCLASSES", directSuperclasses));
@@ -142 +146 @@
   }
 
-  public final Symbol getSymbol()
-  {
-    return symbol;
+  public LispObject getName()
+  {
+    return name;
+  }
+
+  public void setName(LispObject name)
+  {
+    this.name = name;
   }
 
@@ -289 +298 @@
     classPrecedenceList =
       list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
-  }
-
-  public String getName()
-  {
-    return symbol.getName();
   }
 

branches/metaclass/abcl/src/org/armedbear/lisp/Primitives.java

@@ -5133 +5133 @@
       public LispObject execute(LispObject arg)
       {
-          return checkClass(arg).symbol;
+          return checkClass(arg).getName();
       }
     };
@@ -5145 +5145 @@
 
       {
-          checkClass(first).symbol = checkSymbol(second);
+          checkClass(first).setName(checkSymbol(second));
           return second;
       }

branches/metaclass/abcl/src/org/armedbear/lisp/SlotClass.java

@@ -46 +46 @@
     {
       super(layout);
+    }
+
+    public SlotClass(Symbol symbol, LispObject directSuperclasses)
+
+
+    {
+        this(null, symbol, directSuperclasses);
     }
 

branches/metaclass/abcl/src/org/armedbear/lisp/StandardClass.java

@@ -39 +39 @@
 {
 
+  private static Symbol name = PACKAGE_MOP.intern("NAME");
+
   static Layout layoutStandardClass =
       new Layout(null,
-                 list(PACKAGE_MOP.intern("NAME"),
+                 list(name,
                       PACKAGE_MOP.intern("LAYOUT"),
                       PACKAGE_MOP.intern("DIRECT-SUPERCLASSES"),
@@ -69 +71 @@
   {
       super(layoutStandardClass,
-          symbol, directSuperclasses);
+            symbol, directSuperclasses);
+  }
+
+  @Override
+  public LispObject getName()
+  {
+    return getInstanceSlotValue(name);
+  }
+
+  @Override
+  public void setName(LispObject newName)
+  {
+    setInstanceSlotValue(name, newName);
   }
 
@@ -107 +121 @@
     StringBuilder sb =
       new StringBuilder(Symbol.STANDARD_CLASS.writeToString());
-    if (symbol != null)
+    if (getName() != null)
       {
         sb.append(' ');
-        sb.append(symbol.writeToString());
+        sb.append(getName().writeToString());
       }
     return unreadableString(sb.toString());
@@ -296 +310 @@
     GENERIC_FUNCTION.setDirectSuperclasses(list(BuiltInClass.FUNCTION,
                                                  STANDARD_OBJECT));
+    //    GENERIC_FUNCTION.setSlots();
 
     ARITHMETIC_ERROR.setCPL(ARITHMETIC_ERROR, ERROR, SERIOUS_CONDITION,
@@ -306 +321 @@
     BUILT_IN_CLASS.setCPL(BUILT_IN_CLASS, CLASS, STANDARD_OBJECT,
                           BuiltInClass.CLASS_T);
+    //    BUILT_IN_CLASS.setSlots();
     JAVA_CLASS.setCPL(JAVA_CLASS, CLASS, STANDARD_OBJECT,
             BuiltInClass.CLASS_T);
+    //    JAVA_CLASS.setSlots();
     CELL_ERROR.setCPL(CELL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
                       STANDARD_OBJECT, BuiltInClass.CLASS_T);
@@ -316 +333 @@
     COMPILER_ERROR.setCPL(COMPILER_ERROR, CONDITION, STANDARD_OBJECT,
                           BuiltInClass.CLASS_T);
+//    COMPILER_ERROR.setSlots();
     COMPILER_UNSUPPORTED_FEATURE_ERROR.setCPL(COMPILER_UNSUPPORTED_FEATURE_ERROR,
                                               CONDITION, STANDARD_OBJECT,
                                               BuiltInClass.CLASS_T);
+//    COMPILER_UNSUPPORTED_FEATURE_ERROR.setSlots();
     CONDITION.setCPL(CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);
     CONDITION.setDirectSlotDefinitions(
@@ -332 +351 @@
     CONTROL_ERROR.setCPL(CONTROL_ERROR, ERROR, SERIOUS_CONDITION, CONDITION,
                          STANDARD_OBJECT, BuiltInClass.CLASS_T);
+//    CONTROL_ERROR.setSlots();
     DIVISION_BY_ZERO.setCPL(DIVISION_BY_ZERO, ARITHMETIC_ERROR, ERROR,
                             SERIOUS_CONDITION, CONDITION, STANDARD_OBJECT,
                             BuiltInClass.CLASS_T);
+//    DIVISION_BY_ZERO.setSlots();
     END_OF_FILE.setCPL(END_OF_FILE, STREAM_ERROR, ERROR, SERIOUS_CONDITION,
                        CONDITION, STANDARD_OBJECT, BuiltInClass.CLASS_T);

branches/metaclass/abcl/src/org/armedbear/lisp/StandardGenericFunction.java

@@ -210 +210 @@
       {
         StringBuilder sb = new StringBuilder();
-        sb.append(getLispClass().getSymbol().writeToString());
+        sb.append(getLispClass().getName().writeToString());
         sb.append(' ');
         sb.append(name.writeToString());

branches/metaclass/abcl/src/org/armedbear/lisp/StandardMethod.java

@@ -157 +157 @@
           {
             StringBuilder sb = new StringBuilder();
-            sb.append(getLispClass().getSymbol().writeToString());
+            sb.append(getLispClass().getName().writeToString());
             sb.append(' ');
             sb.append(name.writeToString());
@@ -170 +170 @@
                     LispObject spec = specs.car();
                     if (spec instanceof LispClass)
-                      names = names.push(((LispClass)spec).getSymbol());
+                      names = names.push(((LispClass)spec).getName());
                     else
                       names = names.push(spec);

branches/metaclass/abcl/src/org/armedbear/lisp/StandardObject.java

@@ -114 +114 @@
     // The proper name of a class is "a symbol that names the class whose
     // name is that symbol".
-    final Symbol symbol = c1.getSymbol();
-    if (symbol != NIL)
+    final LispObject name = c1.getName();
+    if (name != NIL && name != UNBOUND_VALUE)
       {
         // TYPE-OF.9
-        final LispObject c2 = LispClass.findClass(symbol);
+        final LispObject c2 = LispClass.findClass(checkSymbol(name));
         if (c2 == c1)
-          return symbol;
+          return name;
       }
     return c1;
@@ -143 +143 @@
         if (type == cls)
           return T;
-        if (type == cls.getSymbol())
+        if (type == cls.getName())
           return T;
         LispObject cpl = cls.getCPL();
@@ -150 +150 @@
             if (type == cpl.car())
               return T;
-            if (type == ((LispClass)cpl.car()).getSymbol())
+            if (type == ((LispClass)cpl.car()).getName())
               return T;
             cpl = cpl.cdr();

branches/metaclass/abcl/src/org/armedbear/lisp/StructureClass.java

@@ -80 +80 @@
     {
         StringBuffer sb = new StringBuffer("#<STRUCTURE-CLASS ");
-        sb.append(symbol.writeToString());
+        sb.append(getName().writeToString());
         sb.append('>');
         return sb.toString();

branches/metaclass/abcl/src/org/armedbear/lisp/StructureObject.java

@@ -145 +145 @@
   public LispObject typeOf()
   {
-    return structureClass.getSymbol();
+    return structureClass.getName();
   }
 
@@ -176 +176 @@
     if (type instanceof StructureClass)
       return memq(type, structureClass.getCPL()) ? T : NIL;
-    if (type == structureClass.getSymbol())
+    if (type == structureClass.getName())
       return T;
     if (type == Symbol.STRUCTURE_OBJECT)
@@ -422 +422 @@
           }
         if (_PRINT_STRUCTURE_.symbolValue(thread) == NIL)
-          return unreadableString(structureClass.getSymbol().writeToString());
+          return unreadableString(structureClass.getName().writeToString());
         int maxLevel = Integer.MAX_VALUE;
         LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
@@ -433 +433 @@
           return "#";
         StringBuilder sb = new StringBuilder("#S(");
-        sb.append(structureClass.getSymbol().writeToString());
+        sb.append(structureClass.getName().writeToString());
         if (currentLevel < maxLevel)
           {

branches/metaclass/abcl/src/org/armedbear/lisp/make_condition.java

@@ -53 +53 @@
             symbol = (Symbol) type;
         else if (type instanceof LispClass)
-            symbol = ((LispClass)type).getSymbol();
+            symbol = checkSymbol(((LispClass)type).getName());
         else {
             // This function only works on symbols and classes.