Changeset 12481


Ignore:
Timestamp:
02/14/10 21:29:58 (11 years ago)
Author:
ehuelsmann
Message:

Merge 'metaclass' branch, making STANDARD-CLASS have slots to

be inherited by deriving metaclasses.

Note: this does definitely *not* complete the metaclass work.

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

Legend:

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

    r12431 r12481  
    7575  {
    7676    StringBuilder sb = new StringBuilder("#<BUILT-IN-CLASS ");
    77     sb.append(symbol.writeToString());
     77    sb.append(getName().writeToString());
    7878    sb.append('>');
    7979    return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/Condition.java

    r12298 r12481  
    140140    LispClass c = getLispClass();
    141141    if (c != null)
    142       return c.getSymbol();
     142      return c.getName();
    143143    return Symbol.CONDITION;
    144144  }
  • trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java

    r12288 r12481  
    7070        StringBuffer sb =
    7171            new StringBuffer(Symbol.FORWARD_REFERENCED_CLASS.writeToString());
    72         if (symbol != null) {
     72        if (getName() != null) {
    7373            sb.append(' ');
    74             sb.append(symbol.writeToString());
     74            sb.append(getName().writeToString());
    7575        }
    7676        return unreadableString(sb.toString());
  • trunk/abcl/src/org/armedbear/lisp/Layout.java

    r12298 r12481  
    3636import static org.armedbear.lisp.Lisp.*;
    3737
    38 public final class Layout extends LispObject
     38public class Layout extends LispObject
    3939{
    40   public final LispClass lispClass;
     40  private final LispClass lispClass;
    4141  public final EqHashTable slotTable;
    4242
     
    7777  private Layout(Layout oldLayout)
    7878  {
    79     lispClass = oldLayout.lispClass;
     79    lispClass = oldLayout.getLispClass();
    8080    slotNames = oldLayout.slotNames;
    8181    sharedSlots = oldLayout.sharedSlots;
     
    9595  {
    9696    LispObject result = NIL;
    97     result = result.push(new Cons("class", lispClass));
     97    result = result.push(new Cons("class", getLispClass()));
    9898    for (int i = 0; i < slotNames.length; i++)
    9999      {
     
    102102    result = result.push(new Cons("shared slots", sharedSlots));
    103103    return result.nreverse();
     104  }
     105
     106  public LispClass getLispClass()
     107  {
     108    return lispClass;
    104109  }
    105110
     
    168173      public LispObject execute(LispObject arg)
    169174      {
    170           return checkLayout(arg).lispClass;
     175          return checkLayout(arg).getLispClass();
    171176      }
    172177    };
  • trunk/abcl/src/org/armedbear/lisp/LispClass.java

    r12431 r12481  
    8989  private final int sxhash;
    9090
    91   protected Symbol symbol;
     91  private LispObject name;
    9292  private LispObject propertyList;
    9393  private Layout classLayout;
    9494  private LispObject directSuperclasses = NIL;
    9595  private LispObject directSubclasses = NIL;
    96   public LispObject classPrecedenceList = NIL; // FIXME! Should be private!
    97   public LispObject directMethods = NIL; // FIXME! Should be private!
    98   public LispObject documentation = NIL; // FIXME! Should be private!
     96  private LispObject classPrecedenceList = NIL;
     97  private LispObject directMethods = NIL;
     98  private LispObject documentation = NIL;
    9999  private boolean finalized;
    100100
    101   protected LispClass()
    102   {
     101  protected LispClass(Layout layout)
     102  {
     103    super(layout, layout == null ? 0 : layout.getLength());
    103104    sxhash = hashCode() & 0x7fffffff;
    104105  }
     
    106107  protected LispClass(Symbol symbol)
    107108  {
     109    this(null, symbol);
     110  }
     111
     112  protected LispClass(Layout layout, Symbol symbol)
     113  {
     114    super(layout, layout == null ? 0 : layout.getLength());
     115    setName(symbol);
    108116    sxhash = hashCode() & 0x7fffffff;
    109     this.symbol = symbol;
    110     this.directSuperclasses = NIL;
    111   }
    112 
    113   protected LispClass(Symbol symbol, LispObject directSuperclasses)
    114   {
     117  }
     118
     119  protected LispClass(Layout layout,
     120                      Symbol symbol, LispObject directSuperclasses)
     121  {
     122    super(layout, layout == null ? 0 : layout.getLength());
    115123    sxhash = hashCode() & 0x7fffffff;
    116     this.symbol = symbol;
    117     this.directSuperclasses = directSuperclasses;
     124    setName(symbol);
     125    setDirectSuperclasses(directSuperclasses);
    118126  }
    119127
     
    122130  {
    123131    LispObject result = NIL;
    124     result = result.push(new Cons("NAME", symbol != null ? symbol : NIL));
    125     result = result.push(new Cons("LAYOUT", classLayout != null ? classLayout : NIL));
    126     result = result.push(new Cons("DIRECT-SUPERCLASSES", directSuperclasses));
    127     result = result.push(new Cons("DIRECT-SUBCLASSES", directSubclasses));
    128     result = result.push(new Cons("CLASS-PRECEDENCE-LIST", classPrecedenceList));
    129     result = result.push(new Cons("DIRECT-METHODS", directMethods));
    130     result = result.push(new Cons("DOCUMENTATION", documentation));
     132    result = result.push(new Cons("NAME", name != null ? name : NIL));
     133    result = result.push(new Cons("LAYOUT",
     134                                  getClassLayout() != null
     135                                  ? getClassLayout() : NIL));
     136    result = result.push(new Cons("DIRECT-SUPERCLASSES",
     137                                  getDirectSuperclasses()));
     138    result = result.push(new Cons("DIRECT-SUBCLASSES", getDirectSubclasses()));
     139    result = result.push(new Cons("CLASS-PRECEDENCE-LIST", getCPL()));
     140    result = result.push(new Cons("DIRECT-METHODS", getDirectMethods()));
     141    result = result.push(new Cons("DOCUMENTATION", getDocumentation()));
    131142    return result.nreverse();
    132143  }
     
    138149  }
    139150
    140   public final Symbol getSymbol()
    141   {
    142     return symbol;
     151  public LispObject getName()
     152  {
     153    return name;
     154  }
     155
     156  public void setName(LispObject name)
     157  {
     158    this.name = name;
    143159  }
    144160
     
    159175  }
    160176
    161   public final Layout getClassLayout()
     177  public Layout getClassLayout()
    162178  {
    163179    return classLayout;
    164180  }
    165181
    166   public final void setClassLayout(Layout layout)
     182  public void setClassLayout(Layout layout)
    167183  {
    168184    classLayout = layout;
     
    176192  }
    177193
    178   public final LispObject getDirectSuperclasses()
     194  public LispObject getDirectSuperclasses()
    179195  {
    180196    return directSuperclasses;
    181197  }
    182198
    183   public final void setDirectSuperclasses(LispObject directSuperclasses)
     199  public void setDirectSuperclasses(LispObject directSuperclasses)
    184200  {
    185201    this.directSuperclasses = directSuperclasses;
     
    199215  public final void setDirectSuperclass(LispObject superclass)
    200216  {
    201     directSuperclasses = new Cons(superclass);
    202   }
    203 
    204   public final LispObject getDirectSubclasses()
     217    setDirectSuperclasses(new Cons(superclass));
     218  }
     219
     220  public LispObject getDirectSubclasses()
    205221  {
    206222    return directSubclasses;
    207223  }
    208224
    209   public final void setDirectSubclasses(LispObject directSubclasses)
     225  public void setDirectSubclasses(LispObject directSubclasses)
    210226  {
    211227    this.directSubclasses = directSubclasses;
    212228  }
    213229
    214   public final LispObject getCPL()
     230  public LispObject getCPL()
    215231  {
    216232    return classPrecedenceList;
    217233  }
    218234
    219   public final void setCPL(LispObject obj1)
    220   {
    221     if (obj1 instanceof Cons)
     235  public void setCPL(LispObject... cpl)
     236  {
     237    LispObject obj1 = cpl[0];
     238    if (obj1 instanceof Cons && cpl.length == 1)
    222239      classPrecedenceList = obj1;
    223240    else
    224241      {
    225242        Debug.assertTrue(obj1 == this);
    226         classPrecedenceList = new Cons(obj1);
    227       }
    228   }
    229 
    230   public final void setCPL(LispObject obj1, LispObject obj2)
    231   {
    232     Debug.assertTrue(obj1 == this);
    233     classPrecedenceList = list(obj1, obj2);
    234   }
    235 
    236   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3)
    237   {
    238     Debug.assertTrue(obj1 == this);
    239     classPrecedenceList = list(obj1, obj2, obj3);
    240   }
    241 
    242   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3,
    243                            LispObject obj4)
    244   {
    245     Debug.assertTrue(obj1 == this);
    246     classPrecedenceList = list(obj1, obj2, obj3, obj4);
    247   }
    248 
    249   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3,
    250                            LispObject obj4, LispObject obj5)
    251   {
    252     Debug.assertTrue(obj1 == this);
    253     classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5);
    254   }
    255 
    256   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3,
    257                            LispObject obj4, LispObject obj5, LispObject obj6)
    258   {
    259     Debug.assertTrue(obj1 == this);
    260     classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5, obj6);
    261   }
    262 
    263   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3,
    264                            LispObject obj4, LispObject obj5, LispObject obj6,
    265                            LispObject obj7)
    266   {
    267     Debug.assertTrue(obj1 == this);
    268     classPrecedenceList = list(obj1, obj2, obj3, obj4, obj5, obj6, obj7);
    269   }
    270 
    271   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3,
    272                            LispObject obj4, LispObject obj5, LispObject obj6,
    273                            LispObject obj7, LispObject obj8)
    274   {
    275     Debug.assertTrue(obj1 == this);
    276     classPrecedenceList =
    277       list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
    278   }
    279 
    280   public final void setCPL(LispObject obj1, LispObject obj2, LispObject obj3,
    281                            LispObject obj4, LispObject obj5, LispObject obj6,
    282                            LispObject obj7, LispObject obj8, LispObject obj9)
    283   {
    284     Debug.assertTrue(obj1 == this);
    285     classPrecedenceList =
    286       list(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
    287   }
    288 
    289   public String getName()
    290   {
    291     return symbol.getName();
     243        LispObject l = NIL;
     244        for (int i = cpl.length; i-- > 0;)
     245            l = new Cons(cpl[i], l);
     246        classPrecedenceList = l;
     247      }
     248  }
     249
     250  public LispObject getDirectMethods()
     251  {
     252    return directMethods;
     253  }
     254
     255  public void setDirectMethods(LispObject methods)
     256  {
     257    directMethods = methods;
     258  }
     259
     260  public LispObject getDocumentation()
     261  {
     262    return documentation;
     263  }
     264
     265  public void setDocumentation(LispObject doc)
     266  {
     267    documentation = doc;
    292268  }
    293269
     
    316292  public boolean subclassp(LispObject obj)
    317293  {
    318     LispObject cpl = classPrecedenceList;
     294    LispObject cpl = getCPL();
    319295    while (cpl != NIL)
    320296      {
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r12458 r12481  
    53175317        @Override
    53185318        public LispObject execute(LispObject arg) {
    5319             return checkClass(arg).symbol;
     5319            return checkClass(arg).getName();
    53205320        }
    53215321    };
     
    53325332
    53335333        {
    5334             checkClass(first).symbol = checkSymbol(second);
     5334            checkClass(first).setName(checkSymbol(second));
    53355335            return second;
    53365336        }
     
    54535453
    54545454        {
    5455             checkClass(first).classPrecedenceList = second;
     5455            checkClass(first).setCPL(second);
    54565456            return second;
    54575457        }
     
    54695469
    54705470        {
    5471             return checkClass(arg).directMethods;
     5471            return checkClass(arg).getDirectMethods();
    54725472        }
    54735473    };
     
    54845484
    54855485        {
    5486             checkClass(first).directMethods = second;
     5486            checkClass(first).setDirectMethods(second);
    54875487            return second;
    54885488        }
     
    54905490
    54915491    // ### class-documentation
    5492     private static final Primitive CLASS_DOCUMENTATION = new pf_class_documentation();
     5492    private static final Primitive CLASS_DOCUMENTATION
     5493        = new pf_class_documentation();
    54935494    private static final class pf_class_documentation extends Primitive {
    54945495        pf_class_documentation() {
     
    55005501
    55015502        {
    5502             return checkClass(arg).documentation;
     5503            return checkClass(arg).getDocumentation();
    55035504        }
    55045505    };
    55055506
    55065507    // ### %set-class-documentation
    5507     private static final Primitive _SET_CLASS_DOCUMENTATION = new pf__set_class_documentation();
     5508    private static final Primitive _SET_CLASS_DOCUMENTATION
     5509        = new pf__set_class_documentation();
    55085510    private static final class pf__set_class_documentation extends Primitive {
    55095511        pf__set_class_documentation() {
     
    55155517
    55165518        {
    5517             checkClass(first).documentation = second;
     5519            checkClass(first).setDocumentation(second);
    55185520            return second;
    55195521        }
  • trunk/abcl/src/org/armedbear/lisp/SlotClass.java

    r12298 r12481  
    4343    private LispObject defaultInitargs = NIL;
    4444
    45     public SlotClass()
    46     {
     45    public SlotClass(Layout layout)
     46    {
     47      super(layout);
    4748    }
    4849
    4950    public SlotClass(Symbol symbol, LispObject directSuperclasses)
    50     {
    51         super(symbol, directSuperclasses);
     51
     52
     53    {
     54        this(null, symbol, directSuperclasses);
     55    }
     56
     57    public SlotClass(Layout layout,
     58                     Symbol symbol, LispObject directSuperclasses)
     59    {
     60        super(layout, symbol, directSuperclasses);
    5261    }
    5362
     
    5665    {
    5766        LispObject result = super.getParts().nreverse();
    58         result = result.push(new Cons("DIRECT-SLOTS", directSlotDefinitions));
    59         result = result.push(new Cons("SLOTS", slotDefinitions));
    60         result = result.push(new Cons("DIRECT-DEFAULT-INITARGS", directDefaultInitargs));
    61         result = result.push(new Cons("DEFAULT-INITARGS", defaultInitargs));
     67        result = result.push(new Cons("DIRECT-SLOTS",
     68                                      getDirectSlotDefinitions()));
     69        result = result.push(new Cons("SLOTS", getSlotDefinitions()));
     70        result = result.push(new Cons("DIRECT-DEFAULT-INITARGS",
     71                                      getDirectDefaultInitargs()));
     72        result = result.push(new Cons("DEFAULT-INITARGS",
     73                                      getDefaultInitargs()));
    6274        return result.nreverse();
    6375    }
     
    7991    }
    8092
    81     public final LispObject getSlotDefinitions()
     93    public LispObject getSlotDefinitions()
    8294    {
    8395        return slotDefinitions;
     
    97109    {
    98110        this.directDefaultInitargs = directDefaultInitargs;
     111    }
     112
     113    public LispObject getDefaultInitargs()
     114    {
     115        return defaultInitargs;
    99116    }
    100117
     
    125142            return;
    126143
    127         Debug.assertTrue(slotDefinitions == NIL);
     144        LispObject defs = getSlotDefinitions();
     145        Debug.assertTrue(defs == NIL);
    128146        LispObject cpl = getCPL();
    129147        Debug.assertTrue(cpl != null);
     
    134152            if (car instanceof StandardClass) {
    135153                StandardClass cls = (StandardClass) car;
    136                 LispObject defs = cls.getDirectSlotDefinitions();
    137                 Debug.assertTrue(defs != null);
    138                 Debug.assertTrue(defs.listp());
    139                 while (defs != NIL) {
    140                     slotDefinitions = slotDefinitions.push(defs.car());
    141                     defs = defs.cdr();
     154                LispObject directDefs = cls.getDirectSlotDefinitions();
     155                Debug.assertTrue(directDefs != null);
     156                Debug.assertTrue(directDefs.listp());
     157                while (directDefs != NIL) {
     158                    defs = defs.push(directDefs.car());
     159                    directDefs = directDefs.cdr();
    142160                }
    143161            }
    144162            cpl = cpl.cdr();
    145163        }
    146         slotDefinitions = slotDefinitions.nreverse();
    147         LispObject[] instanceSlotNames = new LispObject[slotDefinitions.length()];
     164        setSlotDefinitions(defs.nreverse());
     165        LispObject[] instanceSlotNames = new LispObject[defs.length()];
    148166        int i = 0;
    149         LispObject tail = slotDefinitions;
     167        LispObject tail = getSlotDefinitions();
    150168        while (tail != NIL) {
    151169            SlotDefinition slotDefinition = (SlotDefinition) tail.car();
     
    168186        {
    169187            if (arg instanceof SlotClass)
    170                 return ((SlotClass)arg).directSlotDefinitions;
     188                return ((SlotClass)arg).getDirectSlotDefinitions();
    171189            if (arg instanceof BuiltInClass)
    172190                return NIL;
     
    184202        {
    185203                if (first instanceof SlotClass) {
    186                 ((SlotClass)first).directSlotDefinitions = second;
     204                  ((SlotClass)first).setDirectSlotDefinitions(second);
    187205                return second;
    188206            }
     
    202220        {
    203221            if (arg instanceof SlotClass)
    204                 return ((SlotClass)arg).slotDefinitions;
     222                return ((SlotClass)arg).getSlotDefinitions();
    205223            if (arg instanceof BuiltInClass)
    206224                return NIL;
     
    217235
    218236        {
    219                 if (first instanceof SlotClass) {
    220                 ((SlotClass)first).slotDefinitions = second;
    221                 return second;
    222             }
    223                 else {
    224                 return type_error(first, Symbol.STANDARD_CLASS);
     237            if (first instanceof SlotClass) {
     238              ((SlotClass)first).setSlotDefinitions(second);
     239              return second;
     240            }
     241            else {
     242              return type_error(first, Symbol.STANDARD_CLASS);
    225243            }
    226244        }
     
    236254        {
    237255            if (arg instanceof SlotClass)
    238                 return ((SlotClass)arg).directDefaultInitargs;
     256                return ((SlotClass)arg).getDirectDefaultInitargs();
    239257            if (arg instanceof BuiltInClass)
    240258                return NIL;
     
    251269
    252270        {
    253                    if (first instanceof SlotClass) {               
    254                            ((SlotClass)first).directDefaultInitargs = second;               
    255                            return second;
    256                    }
    257                    return type_error(first, Symbol.STANDARD_CLASS);
     271            if (first instanceof SlotClass) {
     272              ((SlotClass)first).setDirectDefaultInitargs(second);
     273              return second;
     274            }
     275            return type_error(first, Symbol.STANDARD_CLASS);
    258276        }
    259277    };
     
    268286        {
    269287            if (arg instanceof SlotClass)
    270                 return ((SlotClass)arg).defaultInitargs;
     288                return ((SlotClass)arg).getDefaultInitargs();
    271289            if (arg instanceof BuiltInClass)
    272290                return NIL;
     
    284302        {
    285303            if (first instanceof SlotClass) {
    286                 ((SlotClass)first).defaultInitargs = second;
     304                ((SlotClass)first).setDefaultInitargs(second);
    287305                return second;
    288306            }
  • trunk/abcl/src/org/armedbear/lisp/StandardClass.java

    r12431 r12481  
    3838public class StandardClass extends SlotClass
    3939{
     40
     41  private static Symbol symName = PACKAGE_MOP.intern("NAME");
     42  private static Symbol symLayout = PACKAGE_MOP.intern("LAYOUT");
     43  private static Symbol symDirectSuperclasses
     44    = PACKAGE_MOP.intern("DIRECT-SUPERCLASSES");
     45  private static Symbol symDirectSubclasses
     46    = PACKAGE_MOP.intern("DIRECT-SUBCLASSES");
     47  private static Symbol symClassPrecedenceList
     48    = PACKAGE_MOP.intern("CLASS-PRECEDENCE-LIST");
     49  private static Symbol symDirectMethods
     50    = PACKAGE_MOP.intern("DIRECT-METHODS");
     51  private static Symbol symDocumentation
     52    = PACKAGE_MOP.intern("DOCUMENTATION");
     53  private static Symbol symDirectSlots
     54    = PACKAGE_MOP.intern("DIRECT-SLOTS");
     55  private static Symbol symSlots
     56    = PACKAGE_MOP.intern("SLOTS");
     57  private static Symbol symDirectDefaultInitargs
     58    = PACKAGE_MOP.intern("DIRECT-DEFAULT-INITARGS");
     59  private static Symbol symDefaultInitargs
     60    = PACKAGE_MOP.intern("DEFAULT-INITARGS");
     61
     62  static Layout layoutStandardClass =
     63      new Layout(null,
     64                 list(symName,
     65                      symLayout,
     66                      symDirectSuperclasses,
     67                      symDirectSubclasses,
     68                      symClassPrecedenceList,
     69                      symDirectMethods,
     70                      symDocumentation,
     71                      symDirectSlots,
     72                      symSlots,
     73                      symDirectDefaultInitargs,
     74                      symDefaultInitargs),
     75                 NIL)
     76      {
     77        @Override
     78        public LispClass getLispClass()
     79        {
     80          return STANDARD_CLASS;
     81        }
     82      };
     83
    4084  public StandardClass()
    4185  {
    42     setClassLayout(new Layout(this, NIL, NIL));
     86      super(layoutStandardClass);
     87      setDirectSuperclasses(NIL);
     88      setDirectSubclasses(NIL);
     89      setCPL(NIL);
     90      setDirectMethods(NIL);
     91      setDocumentation(NIL);
     92      setDirectSlotDefinitions(NIL);
     93      setSlotDefinitions(NIL);
     94      setDirectDefaultInitargs(NIL);
     95      setDefaultInitargs(NIL);
    4396  }
    4497
    4598  public StandardClass(Symbol symbol, LispObject directSuperclasses)
    4699  {
    47     super(symbol, directSuperclasses);
    48     setClassLayout(new Layout(this, NIL, NIL));
    49   }
    50 
    51   @Override
    52   public LispObject typeOf()
    53   {
    54     return Symbol.STANDARD_CLASS;
    55   }
     100      super(layoutStandardClass,
     101            symbol, directSuperclasses);
     102      setDirectSubclasses(NIL);
     103      setCPL(NIL);
     104      setDirectMethods(NIL);
     105      setDocumentation(NIL);
     106      setDirectSlotDefinitions(NIL);
     107      setSlotDefinitions(NIL);
     108      setDirectDefaultInitargs(NIL);
     109      setDefaultInitargs(NIL);
     110  }
     111
     112  @Override
     113  public LispObject getName()
     114  {
     115    return getInstanceSlotValue(symName);
     116  }
     117
     118  @Override
     119  public void setName(LispObject newName)
     120  {
     121    setInstanceSlotValue(symName, newName);
     122  }
     123
     124  @Override
     125  public Layout getClassLayout()
     126  {
     127    LispObject layout = getInstanceSlotValue(symLayout);
     128    return (layout == UNBOUND_VALUE) ? null : (Layout)layout;
     129  }
     130
     131  @Override
     132  public void setClassLayout(Layout newLayout)
     133  {
     134    setInstanceSlotValue(symLayout, newLayout);
     135  }
     136
     137  @Override
     138  public LispObject getDirectSuperclasses()
     139  {
     140    return getInstanceSlotValue(symDirectSuperclasses);
     141  }
     142
     143  @Override
     144  public void setDirectSuperclasses(LispObject directSuperclasses)
     145  {
     146    setInstanceSlotValue(symDirectSuperclasses, directSuperclasses);
     147  }
     148
     149  @Override
     150  public LispObject getDirectSubclasses()
     151  {
     152    return getInstanceSlotValue(symDirectSubclasses);
     153  }
     154
     155  @Override
     156  public void setDirectSubclasses(LispObject directSubclasses)
     157  {
     158    setInstanceSlotValue(symDirectSubclasses, directSubclasses);
     159  }
     160
     161  @Override
     162  public LispObject getCPL()
     163  {
     164    return getInstanceSlotValue(symClassPrecedenceList);
     165  }
     166
     167  @Override
     168  public void setCPL(LispObject... cpl)
     169  {
     170    LispObject obj1 = cpl[0];
     171    if (obj1.listp() && cpl.length == 1)
     172      setInstanceSlotValue(symClassPrecedenceList, obj1);
     173    else
     174      {
     175        Debug.assertTrue(obj1 == this);
     176        LispObject l = NIL;
     177        for (int i = cpl.length; i-- > 0;)
     178            l = new Cons(cpl[i], l);
     179        setInstanceSlotValue(symClassPrecedenceList, l);
     180      }
     181  }
     182
     183  @Override
     184  public LispObject getDirectMethods()
     185  {
     186    return getInstanceSlotValue(symDirectMethods);
     187  }
     188
     189  @Override
     190  public void setDirectMethods(LispObject methods)
     191  {
     192    setInstanceSlotValue(symDirectMethods, methods);
     193  }
     194
     195  @Override
     196  public LispObject getDocumentation()
     197  {
     198    return getInstanceSlotValue(symDocumentation);
     199  }
     200
     201  @Override
     202  public void setDocumentation(LispObject doc)
     203  {
     204    setInstanceSlotValue(symDocumentation, doc);
     205  }
     206
     207  @Override
     208  public LispObject getDirectSlotDefinitions()
     209  {
     210    return getInstanceSlotValue(symDirectSlots);
     211  }
     212
     213  @Override
     214  public void setDirectSlotDefinitions(LispObject directSlotDefinitions)
     215  {
     216    setInstanceSlotValue(symDirectSlots, directSlotDefinitions);
     217  }
     218
     219  @Override
     220  public LispObject getSlotDefinitions()
     221  {
     222    return getInstanceSlotValue(symSlots);
     223  }
     224
     225  @Override
     226  public void setSlotDefinitions(LispObject slotDefinitions)
     227  {
     228     setInstanceSlotValue(symSlots, slotDefinitions);
     229  }
     230
     231  @Override
     232  public LispObject getDirectDefaultInitargs()
     233  {
     234    return getInstanceSlotValue(symDirectDefaultInitargs);
     235  }
     236
     237  @Override
     238  public void setDirectDefaultInitargs(LispObject directDefaultInitargs)
     239  {
     240    setInstanceSlotValue(symDirectDefaultInitargs, directDefaultInitargs);
     241  }
     242
     243  @Override
     244  public LispObject getDefaultInitargs()
     245  {
     246    return getInstanceSlotValue(symDefaultInitargs);
     247  }
     248
     249  @Override
     250  public void setDefaultInitargs(LispObject defaultInitargs)
     251  {
     252    setInstanceSlotValue(symDefaultInitargs, defaultInitargs);
     253  }
     254
     255
    56256
    57257  @Override
     
    90290    StringBuilder sb =
    91291      new StringBuilder(Symbol.STANDARD_CLASS.writeToString());
    92     if (symbol != null)
     292    if (getName() != null)
    93293      {
    94294        sb.append(' ');
    95         sb.append(symbol.writeToString());
     295        sb.append(getName().writeToString());
    96296      }
    97297    return unreadableString(sb.toString());
     
    115315    addStandardClass(Symbol.STANDARD_OBJECT, list(BuiltInClass.CLASS_T));
    116316
     317  public static final StandardClass SLOT_DEFINITION =
     318    new SlotDefinitionClass();
     319  static
     320  {
     321    addClass(Symbol.SLOT_DEFINITION, SLOT_DEFINITION);
     322
     323    STANDARD_CLASS.setClassLayout(layoutStandardClass);
     324    STANDARD_CLASS.setDirectSlotDefinitions(STANDARD_CLASS.getClassLayout().generateSlotDefinitions());
     325  }
     326
    117327  // BuiltInClass.FUNCTION is also null here (see previous comment).
    118328  public static final StandardClass GENERIC_FUNCTION =
     
    258468  {
    259469    addClass(Symbol.STANDARD_GENERIC_FUNCTION, STANDARD_GENERIC_FUNCTION);
    260   }
    261 
    262   public static final StandardClass SLOT_DEFINITION =
    263     new SlotDefinitionClass();
    264   static
    265   {
    266     addClass(Symbol.SLOT_DEFINITION, SLOT_DEFINITION);
    267470  }
    268471
  • trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java

    r12431 r12481  
    210210      {
    211211        StringBuilder sb = new StringBuilder();
    212         sb.append(getLispClass().getSymbol().writeToString());
     212        sb.append(getLispClass().getName().writeToString());
    213213        sb.append(' ');
    214214        sb.append(name.writeToString());
  • trunk/abcl/src/org/armedbear/lisp/StandardMethod.java

    r12431 r12481  
    157157          {
    158158            StringBuilder sb = new StringBuilder();
    159             sb.append(getLispClass().getSymbol().writeToString());
     159            sb.append(getLispClass().getName().writeToString());
    160160            sb.append(' ');
    161161            sb.append(name.writeToString());
     
    170170                    LispObject spec = specs.car();
    171171                    if (spec instanceof LispClass)
    172                       names = names.push(((LispClass)spec).getSymbol());
     172                      names = names.push(((LispClass)spec).getName());
    173173                    else
    174174                      names = names.push(spec);
  • trunk/abcl/src/org/armedbear/lisp/StandardObject.java

    r12288 r12481  
    4646  }
    4747
    48   protected StandardObject(LispClass cls, int length)
    49   {
    50     layout = cls.getClassLayout();
     48
     49  protected StandardObject(Layout layout, int length)
     50  {
     51    this.layout = layout;
    5152    slots = new LispObject[length];
    5253    for (int i = slots.length; i-- > 0;)
     
    5455  }
    5556
     57
     58  protected StandardObject(LispClass cls, int length)
     59  {
     60    layout = cls == null ? null : cls.getClassLayout();
     61    slots = new LispObject[length];
     62    for (int i = slots.length; i-- > 0;)
     63      slots[i] = UNBOUND_VALUE;
     64  }
     65
    5666  protected StandardObject(LispClass cls)
    5767  {
    58     layout = cls.getClassLayout();
    59     slots = new LispObject[layout.getLength()];
     68    layout = cls == null ? null : cls.getClassLayout();
     69    slots = new LispObject[layout == null ? 0 : layout.getLength()];
    6070    for (int i = slots.length; i-- > 0;)
    6171      slots[i] = UNBOUND_VALUE;
     
    91101  public final LispClass getLispClass()
    92102  {
    93     return layout.lispClass;
     103    return layout.getLispClass();
    94104  }
    95105
     
    101111    // CLASS-OF if it has a proper name, and otherwise returns the class
    102112    // itself."
    103     final LispClass c1 = layout.lispClass;
     113    final LispClass c1 = layout.getLispClass();
    104114    // The proper name of a class is "a symbol that names the class whose
    105115    // name is that symbol".
    106     final Symbol symbol = c1.getSymbol();
    107     if (symbol != NIL)
     116    final LispObject name = c1.getName();
     117    if (name != NIL && name != UNBOUND_VALUE)
    108118      {
    109119        // TYPE-OF.9
    110         final LispObject c2 = LispClass.findClass(symbol);
     120        final LispObject c2 = LispClass.findClass(checkSymbol(name));
    111121        if (c2 == c1)
    112           return symbol;
     122          return name;
    113123      }
    114124    return c1;
     
    118128  public LispObject classOf()
    119129  {
    120     return layout.lispClass;
     130    return layout.getLispClass();
    121131  }
    122132
     
    128138    if (type == StandardClass.STANDARD_OBJECT)
    129139      return T;
    130     LispClass cls = layout != null ? layout.lispClass : null;
     140    LispClass cls = layout != null ? layout.getLispClass() : null;
    131141    if (cls != null)
    132142      {
    133143        if (type == cls)
    134144          return T;
    135         if (type == cls.getSymbol())
     145        if (type == cls.getName())
    136146          return T;
    137147        LispObject cpl = cls.getCPL();
     
    140150            if (type == cpl.car())
    141151              return T;
    142             if (type == ((LispClass)cpl.car()).getSymbol())
     152            if (type == ((LispClass)cpl.car()).getName())
    143153              return T;
    144154            cpl = cpl.cdr();
     
    174184    Debug.assertTrue(layout.isInvalid());
    175185    Layout oldLayout = layout;
    176     LispClass cls = oldLayout.lispClass;
     186    LispClass cls = oldLayout.getLispClass();
    177187    Layout newLayout = cls.getClassLayout();
    178188    Debug.assertTrue(!newLayout.isInvalid());
     
    341351      public LispObject execute(LispObject arg)
    342352      {
    343           return checkStandardObject(arg).layout.lispClass;
     353          return checkStandardObject(arg).layout.getLispClass();
    344354      }
    345355    };
  • trunk/abcl/src/org/armedbear/lisp/StructureClass.java

    r12288 r12481  
    8080    {
    8181        StringBuffer sb = new StringBuffer("#<STRUCTURE-CLASS ");
    82         sb.append(symbol.writeToString());
     82        sb.append(getName().writeToString());
    8383        sb.append('>');
    8484        return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/StructureObject.java

    r12431 r12481  
    145145  public LispObject typeOf()
    146146  {
    147     return structureClass.getSymbol();
     147    return structureClass.getName();
    148148  }
    149149
     
    176176    if (type instanceof StructureClass)
    177177      return memq(type, structureClass.getCPL()) ? T : NIL;
    178     if (type == structureClass.getSymbol())
     178    if (type == structureClass.getName())
    179179      return T;
    180180    if (type == Symbol.STRUCTURE_OBJECT)
     
    422422          }
    423423        if (_PRINT_STRUCTURE_.symbolValue(thread) == NIL)
    424           return unreadableString(structureClass.getSymbol().writeToString());
     424          return unreadableString(structureClass.getName().writeToString());
    425425        int maxLevel = Integer.MAX_VALUE;
    426426        LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
     
    433433          return "#";
    434434        StringBuilder sb = new StringBuilder("#S(");
    435         sb.append(structureClass.getSymbol().writeToString());
     435        sb.append(structureClass.getName().writeToString());
    436436        if (currentLevel < maxLevel)
    437437          {
  • trunk/abcl/src/org/armedbear/lisp/clos.lisp

    r12443 r12481  
    17821782
    17831783(fmakunbound 'class-name)
     1784(fmakunbound '(setf class-name))
    17841785
    17851786(defgeneric class-name (class))
     
    18011802  (%class-precedence-list class))
    18021803
     1804
     1805
     1806(fmakunbound 'documentation)
    18031807(defgeneric documentation (x doc-type))
    18041808
     
    23902394(defgeneric function-keywords (method))
    23912395
     2396
    23922397(provide 'clos)
  • trunk/abcl/src/org/armedbear/lisp/make_condition.java

    r12288 r12481  
    5353            symbol = (Symbol) type;
    5454        else if (type instanceof LispClass)
    55             symbol = ((LispClass)type).getSymbol();
     55            symbol = checkSymbol(((LispClass)type).getName());
    5656        else {
    5757            // This function only works on symbols and classes.
Note: See TracChangeset for help on using the changeset viewer.