Changeset 14478


Ignore:
Timestamp:
04/24/13 12:51:14 (10 years ago)
Author:
rschlatte
Message:

remove Java-side accessor primitives from SlotDefinition?.java

  • Replaced %slot-definition-name, %slot-definition-initfunction, %slot-definition-initform, %slot-definition-initargs, %slot-definition-readers, %slot-definition-writers, %slot-definition-allocation, %slot-definition-allocation-class, %slot-definition-location, %slot-definition-type, %slot-definition-documentation and the corresponding writers with direct slot accesses
  • *FASL-VERSION* increased since old fasls contain calls to slot accessors
Location:
trunk/abcl/src/org/armedbear/lisp
Files:
10 edited

Legend:

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

    r14454 r14478  
    592592        autoload(PACKAGE_SYS, "%simple-bit-vector-bit-orc2", "SimpleBitVector");
    593593        autoload(PACKAGE_SYS, "%simple-bit-vector-bit-xor", "SimpleBitVector");
    594         autoload(PACKAGE_SYS, "%slot-definition-allocation", "SlotDefinition", true);
    595         autoload(PACKAGE_SYS, "%slot-definition-allocation-class", "SlotDefinition", true);
    596         autoload(PACKAGE_SYS, "%slot-definition-initargs", "SlotDefinition", true);
    597         autoload(PACKAGE_SYS, "%slot-definition-initform", "SlotDefinition", true);
    598         autoload(PACKAGE_SYS, "%slot-definition-initfunction", "SlotDefinition", true);
    599         autoload(PACKAGE_SYS, "%slot-definition-location", "SlotDefinition", true);
    600         autoload(PACKAGE_SYS, "%slot-definition-name", "SlotDefinition", true);
    601         autoload(PACKAGE_SYS, "%slot-definition-readers", "SlotDefinition", true);
    602         autoload(PACKAGE_SYS, "%slot-definition-writers", "SlotDefinition", true);
    603594        autoload(PACKAGE_SYS, "%socket-accept", "socket_accept");
    604595        autoload(PACKAGE_SYS, "%socket-close", "socket_close");
     
    660651        autoload(PACKAGE_SYS, "remove-zip-cache-entry", "ZipCache");
    661652        autoload(PACKAGE_SYS, "set-function-info-value", "function_info");
    662         autoload(PACKAGE_SYS, "set-slot-definition-allocation", "SlotDefinition", true);
    663         autoload(PACKAGE_SYS, "set-slot-definition-allocation-class", "SlotDefinition", true);
    664         autoload(PACKAGE_SYS, "set-slot-definition-initargs", "SlotDefinition", true);
    665         autoload(PACKAGE_SYS, "set-slot-definition-initform", "SlotDefinition", true);
    666         autoload(PACKAGE_SYS, "set-slot-definition-initfunction", "SlotDefinition", true);
    667         autoload(PACKAGE_SYS, "set-slot-definition-location", "SlotDefinition", true);
    668         autoload(PACKAGE_SYS, "set-slot-definition-name", "SlotDefinition", true);
    669         autoload(PACKAGE_SYS, "set-slot-definition-readers", "SlotDefinition", true);
    670         autoload(PACKAGE_SYS, "set-slot-definition-writers", "SlotDefinition", true);
    671653        autoload(PACKAGE_SYS, "simple-list-remove-duplicates", "simple_list_remove_duplicates");
    672654        autoload(PACKAGE_SYS, "single-float-bits", "FloatFunctions", true);
  • trunk/abcl/src/org/armedbear/lisp/Load.java

    r14460 r14478  
    377377    // internal symbol
    378378    static final Symbol _FASL_VERSION_ =
    379         exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(41));
     379        exportConstant("*FASL-VERSION*", PACKAGE_SYS, Fixnum.getInstance(42));
    380380
    381381    // ### *fasl-external-format*
  • trunk/abcl/src/org/armedbear/lisp/SlotClass.java

    r14134 r14478  
    171171        while (tail != NIL) {
    172172            SlotDefinition slotDefinition = (SlotDefinition) tail.car();
    173             SlotDefinition.SET_SLOT_DEFINITION_LOCATION
    174               .execute(slotDefinition, Fixnum.getInstance(i));
    175             instanceSlotNames[i++] = SlotDefinition._SLOT_DEFINITION_NAME
    176               .execute(slotDefinition);
     173            slotDefinition.setInstanceSlotValue(Symbol.LOCATION,
     174                                                Fixnum.getInstance(i));
     175            instanceSlotNames[i++] =
     176              slotDefinition.getInstanceSlotValue(Symbol.NAME);
    177177            tail = tail.cdr();
    178178        }
  • trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java

    r14477 r14478  
    164164  };
    165165
    166   static final Primitive _SLOT_DEFINITION_NAME
    167     = new pf__slot_definition_name();
    168   @DocString(name="%slot-definition-name")
    169   private static final class pf__slot_definition_name extends Primitive
    170   {
    171     pf__slot_definition_name()
    172     {
    173       super(Symbol._SLOT_DEFINITION_NAME, "slot-definition");
    174     }
    175     @Override
    176     public LispObject execute(LispObject arg)
    177     {
    178       StandardObject o = checkSlotDefinition(arg);
    179       return o.getInstanceSlotValue(Symbol.NAME);
    180     }
    181   };
    182 
    183   private static final Primitive SET_SLOT_DEFINITION_NAME
    184     = new pf_set_slot_definition_name();
    185   @DocString(name="set-slot-definition-name",
    186              args="slot-definition name")
    187   private static final class pf_set_slot_definition_name extends Primitive
    188   {
    189     pf_set_slot_definition_name()
    190     {
    191       super("set-slot-definition-name", PACKAGE_SYS, true,
    192             "slot-definition name");
    193     }
    194     @Override
    195     public LispObject execute(LispObject first, LispObject second)
    196     {
    197       StandardObject o = checkSlotDefinition(first);
    198       o.setInstanceSlotValue(Symbol.NAME, second);
    199       return second;
    200     }
    201   };
    202 
    203   private static final Primitive _SLOT_DEFINITION_INITFUNCTION
    204     = new pf__slot_definition_initfunction();
    205   @DocString(name="%slot-definition-initfunction")
    206   private static final class pf__slot_definition_initfunction extends Primitive
    207   {
    208     pf__slot_definition_initfunction()
    209     {
    210       super(Symbol._SLOT_DEFINITION_INITFUNCTION, "slot-definition");
    211     }
    212     @Override
    213     public LispObject execute(LispObject arg)
    214     {
    215       StandardObject o = checkSlotDefinition(arg);
    216       return o.getInstanceSlotValue(Symbol.INITFUNCTION);
    217     }
    218   };
    219 
    220   static final Primitive SET_SLOT_DEFINITION_INITFUNCTION
    221     = new pf_set_slot_definition_initfunction();
    222   @DocString(name="set-slot-definition-initfunction",
    223              args="slot-definition initfunction")
    224   static final class pf_set_slot_definition_initfunction extends Primitive
    225   {
    226     pf_set_slot_definition_initfunction()
    227     {
    228       super("set-slot-definition-initfunction", PACKAGE_SYS, true,
    229             "slot-definition initfunction");
    230     }
    231     @Override
    232     public LispObject execute(LispObject first, LispObject second)
    233     {
    234       StandardObject o = checkSlotDefinition(first);
    235       o.setInstanceSlotValue(Symbol.INITFUNCTION, second);
    236       return second;
    237     }
    238   };
    239 
    240   private static final Primitive _SLOT_DEFINITION_INITFORM
    241     = new pf__slot_definition_initform();
    242   @DocString(name="%slot-definition-initform",
    243              args="slot-definition")
    244   private static final class pf__slot_definition_initform extends Primitive
    245   {
    246     pf__slot_definition_initform()
    247     {
    248       super("%slot-definition-initform", PACKAGE_SYS, true, "slot-definition");
    249     }
    250     @Override
    251     public LispObject execute(LispObject arg)
    252     {
    253       StandardObject o = checkSlotDefinition(arg);
    254       return o.getInstanceSlotValue(Symbol.INITFORM);
    255     }
    256   };
    257 
    258   static final Primitive SET_SLOT_DEFINITION_INITFORM
    259     = new pf_set_slot_definition_initform();
    260   @DocString(name="set-slot-definition-initform",
    261              args="slot-definition initform")
    262   static final class pf_set_slot_definition_initform extends Primitive
    263   {
    264     pf_set_slot_definition_initform()
    265     {
    266       super("set-slot-definition-initform", PACKAGE_SYS, true,
    267             "slot-definition initform");
    268     }
    269     @Override
    270     public LispObject execute(LispObject first, LispObject second)
    271     {
    272       StandardObject o = checkSlotDefinition(first);
    273       o.setInstanceSlotValue(Symbol.INITFORM, second);
    274       return second;
    275     }
    276   };
    277 
    278   private static final Primitive _SLOT_DEFINITION_INITARGS
    279     = new pf__slot_definition_initargs();
    280   @DocString(name="%slot-definition-initargs")
    281   private static final class pf__slot_definition_initargs extends Primitive
    282   {
    283     pf__slot_definition_initargs()
    284     {
    285       super(Symbol._SLOT_DEFINITION_INITARGS, "slot-definition");
    286     }
    287     @Override
    288     public LispObject execute(LispObject arg)
    289     {
    290       StandardObject o = checkSlotDefinition(arg);
    291       return o.getInstanceSlotValue(Symbol.INITARGS);
    292     }
    293   };
    294 
    295   static final Primitive SET_SLOT_DEFINITION_INITARGS
    296     = new pf_set_slot_definition_initargs();
    297   @DocString(name="set-slot-definition-initargs",
    298              args="slot-definition initargs")
    299   private static final class pf_set_slot_definition_initargs extends Primitive
    300   {
    301     pf_set_slot_definition_initargs()
    302     {
    303       super("set-slot-definition-initargs", PACKAGE_SYS, true,
    304             "slot-definition initargs");
    305     }
    306     @Override
    307     public LispObject execute(LispObject first, LispObject second)
    308     {
    309       StandardObject o = checkSlotDefinition(first);
    310       o.setInstanceSlotValue(Symbol.INITARGS, second);
    311       return second;
    312     }
    313   };
    314 
    315   private static final Primitive _SLOT_DEFINITION_READERS
    316     = new pf__slot_definition_readers();
    317   @DocString(name="%slot-definition-readers",
    318              args="slot-definition")
    319   private static final class pf__slot_definition_readers extends Primitive {
    320     pf__slot_definition_readers()
    321     {
    322       super("%slot-definition-readers", PACKAGE_SYS, true,
    323             "slot-definition");
    324     }
    325     @Override
    326     public LispObject execute(LispObject arg)
    327     {
    328       StandardObject o = checkSlotDefinition(arg);
    329       return o.getInstanceSlotValue(Symbol.READERS);
    330     }
    331   };
    332 
    333   private static final Primitive SET_SLOT_DEFINITION_READERS
    334     = new pf_set_slot_definition_readers();
    335   @DocString(name="set-slot-definition-readers",
    336              args="slot-definition readers")
    337   private static final class pf_set_slot_definition_readers extends Primitive
    338   {
    339     pf_set_slot_definition_readers()
    340     {
    341       super("set-slot-definition-readers", PACKAGE_SYS, true,
    342             "slot-definition readers");
    343     }
    344     @Override
    345     public LispObject execute(LispObject first, LispObject second)
    346     {
    347       StandardObject o = checkSlotDefinition(first);
    348       o.setInstanceSlotValue(Symbol.READERS, second);
    349       return second;
    350     }
    351   };
    352 
    353   private static final Primitive _SLOT_DEFINITION_WRITERS
    354     = new pf__slot_definition_writers();
    355   @DocString(name="%slot-definition-writers",
    356              args="slot-definition")
    357   private static final class pf__slot_definition_writers extends Primitive
    358   {
    359     pf__slot_definition_writers()
    360     {
    361       super("%slot-definition-writers", PACKAGE_SYS, true,
    362             "slot-definition");
    363     }
    364     @Override
    365     public LispObject execute(LispObject arg)
    366     {
    367       StandardObject o = checkSlotDefinition(arg);
    368       return o.getInstanceSlotValue(Symbol.WRITERS);
    369     }
    370   };
    371 
    372   private static final Primitive SET_SLOT_DEFINITION_WRITERS
    373     = new pf_set_slot_definition_writers();
    374   @DocString(name="set-slot-definition-writers",
    375              args="slot-definition writers")
    376   private static final class pf_set_slot_definition_writers extends Primitive
    377   {
    378     pf_set_slot_definition_writers()
    379     {
    380       super("set-slot-definition-writers", PACKAGE_SYS, true,
    381             "slot-definition writers");
    382     }
    383     @Override
    384     public LispObject execute(LispObject first, LispObject second)
    385     {
    386       StandardObject o = checkSlotDefinition(first);
    387       o.setInstanceSlotValue(Symbol.WRITERS, second);
    388       return second;
    389     }
    390   };
    391 
    392   private static final Primitive _SLOT_DEFINITION_ALLOCATION
    393     = new pf__slot_definition_allocation();
    394   @DocString(name="%slot-definition-allocation",
    395              args="slot-definition")
    396   private static final class pf__slot_definition_allocation extends Primitive
    397   {
    398     pf__slot_definition_allocation()
    399     {
    400       super("%slot-definition-allocation", PACKAGE_SYS, true,
    401             "slot-definition");
    402     }
    403     @Override
    404     public LispObject execute(LispObject arg)
    405     {
    406       StandardObject o = checkSlotDefinition(arg);
    407       return o.getInstanceSlotValue(Symbol.ALLOCATION);
    408     }
    409   };
    410 
    411   private static final Primitive SET_SLOT_DEFINITION_ALLOCATION
    412     = new pf_set_slot_definition_allocation();
    413   @DocString(name="set-slot-definition-allocation",
    414              args="slot-definition allocation")
    415   private static final class pf_set_slot_definition_allocation extends Primitive
    416   {
    417     pf_set_slot_definition_allocation()
    418     {
    419       super("set-slot-definition-allocation", PACKAGE_SYS, true,
    420             "slot-definition allocation");
    421     }
    422     @Override
    423     public LispObject execute(LispObject first, LispObject second)
    424     {
    425       StandardObject o = checkSlotDefinition(first);
    426       o.setInstanceSlotValue(Symbol.ALLOCATION, second);
    427       return second;
    428     }
    429   };
    430 
    431   private static final Primitive _SLOT_DEFINITION_ALLOCATION_CLASS
    432     = new pf__slot_definition_allocation_class();
    433   @DocString(name="%slot-definition-allocation-class",
    434              args="slot-definition")
    435   private static final class pf__slot_definition_allocation_class extends Primitive
    436   {
    437     pf__slot_definition_allocation_class()
    438     {
    439       super("%slot-definition-allocation-class", PACKAGE_SYS, true,
    440             "slot-definition");
    441     }
    442     @Override
    443     public LispObject execute(LispObject arg)
    444     {
    445       StandardObject o = checkSlotDefinition(arg);
    446       return o.getInstanceSlotValue(Symbol.ALLOCATION_CLASS);
    447     }
    448   };
    449 
    450   private static final Primitive SET_SLOT_DEFINITION_ALLOCATION_CLASS
    451     = new pf_set_slot_definition_allocation_class();
    452   @DocString(name="set-slot-definition-allocation-class",
    453              args="slot-definition allocation-class")
    454   private static final class pf_set_slot_definition_allocation_class extends Primitive
    455   {
    456     pf_set_slot_definition_allocation_class()
    457     {
    458       super("set-slot-definition-allocation-class", PACKAGE_SYS, true,
    459             "slot-definition allocation-class");
    460     }
    461     @Override
    462     public LispObject execute(LispObject first, LispObject second)
    463     {
    464       StandardObject o = checkSlotDefinition(first);
    465       o.setInstanceSlotValue(Symbol.ALLOCATION_CLASS, second);
    466       return second;
    467     }
    468   };
    469 
    470   private static final Primitive _SLOT_DEFINITION_LOCATION
    471     = new pf__slot_definition_location();
    472   @DocString(name="%slot-definition-location")
    473   private static final class pf__slot_definition_location extends Primitive
    474   {
    475     pf__slot_definition_location()
    476     {
    477       super("%slot-definition-location", PACKAGE_SYS, true, "slot-definition");
    478     }
    479     @Override
    480     public LispObject execute(LispObject arg)
    481     {
    482       StandardObject o = checkSlotDefinition(arg);
    483       return o.getInstanceSlotValue(Symbol.LOCATION);
    484     }
    485   };
    486 
    487   static final Primitive SET_SLOT_DEFINITION_LOCATION
    488     = new pf_set_slot_definition_location();
    489   @DocString(name="set-slot-definition-location",
    490              args="slot-definition location")
    491   private static final class pf_set_slot_definition_location extends Primitive
    492   {
    493     pf_set_slot_definition_location()
    494     {
    495       super("set-slot-definition-location", PACKAGE_SYS, true,
    496             "slot-definition location");
    497     }
    498     @Override
    499     public LispObject execute(LispObject first, LispObject second)
    500     {
    501       StandardObject o = checkSlotDefinition(first);
    502       o.setInstanceSlotValue(Symbol.LOCATION, second);
    503       return second;
    504     }
    505   };
    506 
    507   private static final Primitive _SLOT_DEFINITION_TYPE
    508     = new pf__slot_definition_type();
    509   @DocString(name="%slot-definition-type")
    510   private static final class pf__slot_definition_type extends Primitive
    511   {
    512     pf__slot_definition_type()
    513     {
    514       super("%slot-definition-type", PACKAGE_SYS, true, "slot-definition");
    515     }
    516     @Override
    517     public LispObject execute(LispObject arg)
    518     {
    519       StandardObject o = checkSlotDefinition(arg);
    520       return o.getInstanceSlotValue(Symbol._TYPE);
    521     }
    522   };
    523 
    524   private static final Primitive SET_SLOT_DEFINITION_TYPE
    525     = new pf_set_slot_definition_type();
    526   @DocString(name="set-slot-definition-type",
    527              args="slot-definition type")
    528   private static final class pf_set_slot_definition_type extends Primitive
    529   {
    530     pf_set_slot_definition_type()
    531     {
    532       super("set-slot-definition-type", PACKAGE_SYS, true,
    533             "slot-definition type");
    534     }
    535     @Override
    536     public LispObject execute(LispObject first, LispObject second)
    537     {
    538       StandardObject o = checkSlotDefinition(first);
    539       o.setInstanceSlotValue(Symbol._TYPE, second);
    540       return second;
    541     }
    542   };
    543 
    544   private static final Primitive _SLOT_DEFINITION_DOCUMENTATION
    545     = new pf__slot_definition_documentation();
    546   @DocString(name="%slot-definition-documentation")
    547   private static final class pf__slot_definition_documentation extends Primitive
    548   {
    549     pf__slot_definition_documentation()
    550     {
    551       super("%slot-definition-documentation", PACKAGE_SYS, true, "slot-definition");
    552     }
    553     @Override
    554     public LispObject execute(LispObject arg)
    555     {
    556       StandardObject o = checkSlotDefinition(arg);
    557       return o.getInstanceSlotValue(Symbol._DOCUMENTATION);
    558     }
    559   };
    560 
    561   private static final Primitive SET_SLOT_DEFINITION_DOCUMENTATION
    562     = new pf_set_slot_definition_documentation();
    563   @DocString(name="set-slot-definition-documentation",
    564              args="slot-definition documentation")
    565   private static final class pf_set_slot_definition_documentation extends Primitive
    566   {
    567     pf_set_slot_definition_documentation()
    568     {
    569       super("set-slot-definition-documentation", PACKAGE_SYS, true,
    570             "slot-definition documentation");
    571     }
    572     @Override
    573     public LispObject execute(LispObject first, LispObject second)
    574     {
    575       StandardObject o = checkSlotDefinition(first);
    576       o.setInstanceSlotValue(Symbol._DOCUMENTATION, second);
    577       return second;
    578     }
    579   };
    580 
    581166}
  • trunk/abcl/src/org/armedbear/lisp/SlotDefinitionClass.java

    r14477 r14478  
    6262        // in its constructor; here we make Lisp-side subclasses of
    6363        // standard-*-slot-definition do the same.
    64         LispObject locationSlot = slotDefinitions.nthcdr(8).car();
    65         SlotDefinition.SET_SLOT_DEFINITION_INITFORM.execute(locationSlot, NIL);
    66         SlotDefinition.SET_SLOT_DEFINITION_INITFUNCTION.execute(locationSlot, StandardClass.constantlyNil);
     64        StandardObject locationSlot =
     65          SlotDefinition.checkSlotDefinition(slotDefinitions.nthcdr(8).car());
     66        locationSlot.setInstanceSlotValue(Symbol.INITFORM, NIL);
     67        locationSlot.setInstanceSlotValue(Symbol.INITFUNCTION, StandardClass.constantlyNil);
    6768        // Fix initargs of TYPE, DOCUMENTATION slots.
    68         LispObject typeSlot = slotDefinitions.nthcdr(9).car();
    69         SlotDefinition.SET_SLOT_DEFINITION_INITARGS.execute(typeSlot, list(internKeyword("TYPE")));
    70         LispObject documentationSlot = slotDefinitions.nthcdr(10).car();
    71         SlotDefinition.SET_SLOT_DEFINITION_INITARGS.execute(documentationSlot, list(internKeyword("DOCUMENTATION")));
     69        StandardObject typeSlot =
     70          SlotDefinition.checkSlotDefinition(slotDefinitions.nthcdr(9).car());
     71        typeSlot.setInstanceSlotValue(Symbol.INITARGS, list(internKeyword("TYPE")));
     72        StandardObject documentationSlot =
     73          SlotDefinition.checkSlotDefinition(slotDefinitions.nthcdr(10).car());
     74        documentationSlot.setInstanceSlotValue(Symbol.INITARGS, list(internKeyword("DOCUMENTATION")));
    7275        setDirectSlotDefinitions(slotDefinitions);
    7376        setSlotDefinitions(slotDefinitions);
  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r14473 r14478  
    31303130  public static final Symbol SLOT_DEFINITION =
    31313131    PACKAGE_SYS.addExternalSymbol("SLOT-DEFINITION");
    3132   public static final Symbol _SLOT_DEFINITION_NAME =
    3133     PACKAGE_SYS.addExternalSymbol("%SLOT-DEFINITION-NAME");
    3134   public static final Symbol _SLOT_DEFINITION_INITARGS =
    3135     PACKAGE_SYS.addExternalSymbol("%SLOT-DEFINITION-INITARGS");
    3136   public static final Symbol _SLOT_DEFINITION_INITFUNCTION =
    3137     PACKAGE_SYS.addExternalSymbol("%SLOT-DEFINITION-INITFUNCTION");
    31383132  public static final Symbol STD_SLOT_BOUNDP =
    31393133    PACKAGE_SYS.addExternalSymbol("STD-SLOT-BOUNDP");
  • trunk/abcl/src/org/armedbear/lisp/clos.lisp

    r14473 r14478  
    255255      (cons (funcall fun (car x) (cadr x))
    256256            (mapplist fun (cddr x)))))
     257
     258(defsetf std-slot-value set-std-slot-value)
    257259
    258260(defsetf std-instance-layout %set-std-instance-layout)
     
    378380
    379381(defun slot-definition-allocation (slot-definition)
    380   (%slot-definition-allocation slot-definition))
     382  (std-slot-value slot-definition 'sys::allocation))
    381383
    382384(declaim (notinline (setf slot-definition-allocation)))
    383385(defun (setf slot-definition-allocation) (value slot-definition)
    384   (set-slot-definition-allocation slot-definition value))
     386  (setf (std-slot-value slot-definition 'sys::allocation) value))
    385387
    386388(defun slot-definition-initargs (slot-definition)
    387   (%slot-definition-initargs slot-definition))
     389  (std-slot-value slot-definition 'sys::initargs))
    388390
    389391(declaim (notinline (setf slot-definition-initargs)))
    390392(defun (setf slot-definition-initargs) (value slot-definition)
    391   (set-slot-definition-initargs slot-definition value))
     393  (setf (std-slot-value slot-definition 'sys::initargs) value))
    392394
    393395(defun slot-definition-initform (slot-definition)
    394   (%slot-definition-initform slot-definition))
     396  (std-slot-value slot-definition 'sys::initform))
    395397
    396398(declaim (notinline (setf slot-definition-initform)))
    397399(defun (setf slot-definition-initform) (value slot-definition)
    398   (set-slot-definition-initform slot-definition value))
     400  (setf (std-slot-value slot-definition 'sys::initform) value))
    399401
    400402(defun slot-definition-initfunction (slot-definition)
    401   (%slot-definition-initfunction slot-definition))
     403  (std-slot-value slot-definition 'sys::initfunction))
    402404
    403405(declaim (notinline (setf slot-definition-initfunction)))
    404406(defun (setf slot-definition-initfunction) (value slot-definition)
    405   (set-slot-definition-initfunction slot-definition value))
     407  (setf (std-slot-value slot-definition 'sys::initfunction) value))
    406408
    407409(defun slot-definition-name (slot-definition)
    408   (%slot-definition-name slot-definition))
     410  (std-slot-value slot-definition 'sys:name))
    409411
    410412(declaim (notinline (setf slot-definition-name)))
    411413(defun (setf slot-definition-name) (value slot-definition)
    412   (set-slot-definition-name slot-definition value))
     414  (setf (std-slot-value slot-definition 'sys:name) value))
    413415
    414416(defun slot-definition-readers (slot-definition)
    415   (%slot-definition-readers slot-definition))
     417  (std-slot-value slot-definition 'sys::readers))
    416418
    417419(declaim (notinline (setf slot-definition-readers)))
    418420(defun (setf slot-definition-readers) (value slot-definition)
    419   (set-slot-definition-readers slot-definition value))
     421  (setf (std-slot-value slot-definition 'sys::readers) value))
    420422
    421423(defun slot-definition-writers (slot-definition)
    422   (%slot-definition-writers slot-definition))
     424  (std-slot-value slot-definition 'sys::writers))
    423425
    424426(declaim (notinline (setf slot-definition-writers)))
    425427(defun (setf slot-definition-writers) (value slot-definition)
    426   (set-slot-definition-writers slot-definition value))
     428  (setf (std-slot-value slot-definition 'sys::writers) value))
    427429
    428430(defun slot-definition-allocation-class (slot-definition)
    429   (%slot-definition-allocation-class slot-definition))
     431  (std-slot-value slot-definition 'sys::allocation-class))
    430432
    431433(declaim (notinline (setf slot-definition-allocation-class)))
    432434(defun (setf slot-definition-allocation-class) (value slot-definition)
    433   (set-slot-definition-allocation-class slot-definition value))
     435  (setf (std-slot-value slot-definition 'sys::allocation-class) value))
    434436
    435437(defun slot-definition-location (slot-definition)
    436   (%slot-definition-location slot-definition))
     438  (std-slot-value slot-definition 'sys::location))
    437439
    438440(declaim (notinline (setf slot-definition-location-class)))
    439441(defun (setf slot-definition-location) (value slot-definition)
    440   (set-slot-definition-location slot-definition value))
     442  (setf (std-slot-value slot-definition 'sys::location) value))
    441443
    442444(defun slot-definition-type (slot-definition)
    443   (%slot-definition-type slot-definition))
     445  (std-slot-value slot-definition 'sys::%type))
    444446
    445447(declaim (notinline (setf slot-definition-type)))
    446448(defun (setf slot-definition-type) (value slot-definition)
    447   (set-slot-definition-type slot-definition value))
     449  (setf (std-slot-value slot-definition 'sys::%type) value))
    448450
    449451(defun slot-definition-documentation (slot-definition)
    450   (%slot-definition-documentation slot-definition))
     452  (std-slot-value slot-definition 'sys:%documentation))
    451453
    452454(declaim (notinline (setf slot-definition-documentation)))
    453455(defun (setf slot-definition-documentation) (value slot-definition)
    454   (set-slot-definition-documentation slot-definition value))
     456  (setf (std-slot-value slot-definition 'sys:%documentation) value))
    455457
    456458(defun init-slot-definition (slot &key name
     
    759761        (slot-value-using-class class object
    760762                                (find-slot-definition class slot-name)))))
    761 
    762 (defsetf std-slot-value set-std-slot-value)
    763763
    764764(defun %set-slot-value (object slot-name new-value)
     
    39583958  (:method ((slot-definition slot-definition))
    39593959    (slot-definition-dispatch slot-definition
    3960       (%slot-definition-allocation slot-definition)
     3960      (std-slot-value slot-definition 'sys::allocation)
    39613961      (slot-value slot-definition 'sys::allocation))))
    39623962
     
    39643964  (:method (value (slot-definition slot-definition))
    39653965    (slot-definition-dispatch slot-definition
    3966       (set-slot-definition-allocation slot-definition value)
     3966      (setf (std-slot-value slot-definition 'sys::allocation) value)
    39673967      (setf (slot-value slot-definition 'sys::allocation) value))))
    39683968
     
    39703970  (:method ((slot-definition slot-definition))
    39713971    (slot-definition-dispatch slot-definition
    3972       (%slot-definition-initargs slot-definition)
     3972      (std-slot-value slot-definition 'sys::initargs)
    39733973      (slot-value slot-definition 'sys::initargs))))
     3974
     3975(atomic-defgeneric (setf slot-definition-initargs) (value slot-definition)
     3976  (:method (value (slot-definition slot-definition))
     3977    (slot-definition-dispatch slot-definition
     3978      (setf (std-slot-value slot-definition 'sys::initargs) value)
     3979      (setf (slot-value slot-definition 'sys::initargs) value))))
    39743980
    39753981(atomic-defgeneric slot-definition-initform (slot-definition)
    39763982  (:method ((slot-definition slot-definition))
    39773983    (slot-definition-dispatch slot-definition
    3978       (%slot-definition-initform slot-definition)
     3984      (std-slot-value slot-definition 'sys::initform)
    39793985      (slot-value slot-definition 'sys::initform))))
    39803986
     
    39823988  (:method (value (slot-definition slot-definition))
    39833989    (slot-definition-dispatch slot-definition
    3984       (set-slot-definition-initform slot-definition value)
     3990      (setf (std-slot-value slot-definition 'sys::initform) value)
    39853991      (setf (slot-value slot-definition 'sys::initform) value))))
    39863992
     
    39883994  (:method ((slot-definition slot-definition))
    39893995    (slot-definition-dispatch slot-definition
    3990       (%slot-definition-initfunction slot-definition)
     3996      (std-slot-value slot-definition 'sys::initfunction)
    39913997      (slot-value slot-definition 'sys::initfunction))))
    39923998
     
    39944000  (:method (value (slot-definition slot-definition))
    39954001    (slot-definition-dispatch slot-definition
    3996       (set-slot-definition-initfunction slot-definition value)
     4002      (setf (std-slot-value slot-definition 'sys::initfunction) value)
    39974003      (setf (slot-value slot-definition 'sys::initfunction) value))))
    39984004
     
    40004006  (:method ((slot-definition slot-definition))
    40014007    (slot-definition-dispatch slot-definition
    4002       (%slot-definition-name slot-definition)
    4003       (slot-value slot-definition 'sys::name))))
     4008      (std-slot-value slot-definition 'sys:name)
     4009      (slot-value slot-definition 'sys:name))))
    40044010
    40054011(atomic-defgeneric (setf slot-definition-name) (value slot-definition)
    40064012  (:method (value (slot-definition slot-definition))
    40074013    (slot-definition-dispatch slot-definition
    4008       (set-slot-definition-name slot-definition value)
    4009       (setf (slot-value slot-definition 'sys::name) value))))
     4014      (setf (std-slot-value slot-definition 'sys:name) value)
     4015      (setf (slot-value slot-definition 'sys:name) value))))
    40104016
    40114017(atomic-defgeneric slot-definition-readers (slot-definition)
    40124018  (:method ((slot-definition slot-definition))
    40134019    (slot-definition-dispatch slot-definition
    4014       (%slot-definition-readers slot-definition)
     4020      (std-slot-value slot-definition 'sys::readers)
    40154021      (slot-value slot-definition 'sys::readers))))
    40164022
     
    40184024  (:method (value (slot-definition slot-definition))
    40194025    (slot-definition-dispatch slot-definition
    4020       (set-slot-definition-readers slot-definition value)
     4026      (setf (std-slot-value slot-definition 'sys::readers) value)
    40214027      (setf (slot-value slot-definition 'sys::readers) value))))
    40224028
     
    40244030  (:method ((slot-definition slot-definition))
    40254031    (slot-definition-dispatch slot-definition
    4026       (%slot-definition-writers slot-definition)
     4032      (std-slot-value slot-definition 'sys::writers)
    40274033      (slot-value slot-definition 'sys::writers))))
    40284034
     
    40304036  (:method (value (slot-definition slot-definition))
    40314037    (slot-definition-dispatch slot-definition
    4032       (set-slot-definition-writers slot-definition value)
     4038      (setf (std-slot-value slot-definition 'sys::writers) value)
    40334039      (setf (slot-value slot-definition 'sys::writers) value))))
    40344040
     
    40364042  (:method ((slot-definition slot-definition))
    40374043    (slot-definition-dispatch slot-definition
    4038       (%slot-definition-allocation-class slot-definition)
     4044      (std-slot-value slot-definition 'sys::allocation-class)
    40394045      (slot-value slot-definition 'sys::allocation-class))))
    40404046
     
    40434049  (:method (value (slot-definition slot-definition))
    40444050    (slot-definition-dispatch slot-definition
    4045       (set-slot-definition-allocation-class slot-definition value)
     4051      (setf (std-slot-value slot-definition 'sys::allocation-class) value)
    40464052      (setf (slot-value slot-definition 'sys::allocation-class) value))))
    40474053
     
    40494055  (:method ((slot-definition slot-definition))
    40504056    (slot-definition-dispatch slot-definition
    4051       (%slot-definition-location slot-definition)
     4057      (std-slot-value slot-definition 'sys::location)
    40524058      (slot-value slot-definition 'sys::location))))
    40534059
     
    40554061  (:method (value (slot-definition slot-definition))
    40564062    (slot-definition-dispatch slot-definition
    4057       (set-slot-definition-location slot-definition value)
     4063      (setf (std-slot-value slot-definition 'sys::location) value)
    40584064      (setf (slot-value slot-definition 'sys::location) value))))
    40594065
     
    40614067  (:method ((slot-definition slot-definition))
    40624068    (slot-definition-dispatch slot-definition
    4063       (%slot-definition-type slot-definition)
     4069      (std-slot-value slot-definition 'sys::%type)
    40644070      (slot-value slot-definition 'sys::%type))))
    40654071
     
    40674073  (:method (value (slot-definition slot-definition))
    40684074    (slot-definition-dispatch slot-definition
    4069       (set-slot-definition-type slot-definition value)
     4075      (setf (std-slot-value slot-definition 'sys::%type) value)
    40704076      (setf (slot-value slot-definition 'sys::%type) value))))
    40714077
     
    40734079  (:method ((slot-definition slot-definition))
    40744080    (slot-definition-dispatch slot-definition
    4075       (%slot-definition-documentation slot-definition)
     4081      (std-slot-value slot-definition 'sys:%documentation)
    40764082      (slot-value slot-definition 'sys:%documentation))))
    40774083
     
    40794085  (:method (value (slot-definition slot-definition))
    40804086    (slot-definition-dispatch slot-definition
    4081       (set-slot-definition-documentation slot-definition value)
     4087      (setf (std-slot-value slot-definition 'sys:%documentation) value)
    40824088      (setf (slot-value slot-definition 'sys:%documentation) value))))
    40834089
  • trunk/abcl/src/org/armedbear/lisp/describe.lisp

    r14455 r14478  
    119119    (format stream "~S is an instance of ~S.~%" object class)
    120120    (dolist (slotd slotds)
    121       (let* ((name (%slot-definition-name slotd))
     121      (let* ((name (mop:slot-definition-name slotd))
    122122             (length (length (symbol-name name))))
    123123        (when (> length max-slot-name-length)
    124124          (setf max-slot-name-length length)))
    125       (case (%slot-definition-allocation slotd)
     125      (case (mop:slot-definition-allocation slotd)
    126126        (:instance (push slotd instance-slotds))
    127127        (:class  (push slotd class-slotds))))
     
    139139        (dolist (slotd (nreverse instance-slotds))
    140140          (describe-slot
    141            (%slot-definition-name slotd))))
     141           (mop:slot-definition-name slotd))))
    142142        (format stream "~%")
    143143      (when class-slotds
     
    145145        (dolist (slotd (nreverse class-slotds))
    146146          (describe-slot
    147            (%slot-definition-name slotd)))
     147           (mop:slot-definition-name slotd)))
    148148        (format stream "~%")))))
    149149
  • trunk/abcl/src/org/armedbear/lisp/known-functions.lisp

    r14454 r14478  
    291291(defknown %class-slots (class) t)
    292292(defknown set-class-slots (class list) t)
    293 (defknown %slot-definition-name * t)
    294 (defknown %slot-definition-initargs * t)
    295293(defknown %slot-definition-initfunction * t)
    296294(defknown std-slot-boundp * t)
  • trunk/abcl/src/org/armedbear/lisp/make-load-form-saving-slots.lisp

    r13555 r14478  
    5050          ((typep object 'standard-object)
    5151           (dolist (slot (mop:class-slots class))
    52              (let ((slot-name (%slot-definition-name slot)))
     52             (let ((slot-name (mop:slot-definition-name slot)))
    5353               (when (or (memq slot-name slot-names)
    5454                         (null slot-names))
Note: See TracChangeset for help on using the changeset viewer.