anchor.diff:  	    '(:writable nil))
   	,@(when (not (member :readable flags))
   	    '(:readable nil))
  -	,@(when (or (member :construct flags) 
  -		    (member :construct-only flags))
  -	    '(:construct t))
  +	,@(when (member :construct-only flags)
  +	    '(:construct-only t))
   	
   	;; initargs
   	,@(if (find :initarg args)
  
positive.code: 
  (defclass direct-property-slot-definition (direct-virtual-slot-definition)
    ((pname :reader slot-definition-pname :initarg :pname)
     (readable :initform t :reader slot-readable-p :initarg :readable)
     (writable :initform t :reader slot-writable-p :initarg :writable)
     (construct :initform nil :initarg :construct)))
  
  (defclass effective-property-slot-definition (effective-virtual-slot-definition)
    ((pname :reader slot-definition-pname :initarg :pname)
     (readable :reader slot-readable-p :initarg :readable)
     (writable :reader slot-writable-p :initarg :writable)
     (construct :initarg :construct)))
  
  (defclass direct-user-data-slot-definition (direct-virtual-slot-definition)
    ())
  
negative.code:       (error "An object of class ~A has instance slots and should only be created with MAKE-INSTANCE" class)
      (call-next-method)))
  
  
  (defmethod allocate-foreign ((object gobject) &rest initargs)
    (let ((init-slots ())) 
      (flet ((value-from-initargs (slotd)
  	     (loop
  	      with slot-initargs = (slot-definition-initargs slotd)
  	      for (initarg value) on initargs by #'cddr
  	      when (find initarg slot-initargs)
  	      do (return (values value t)))))
  
      (loop 
       for slotd in (class-slots (class-of object))
       when (and 
  	   (eq (slot-definition-allocation slotd) :property)
  	   (construct-only-property-p slotd))
       do (multiple-value-bind (value initarg-p) (value-from-initargs slotd)
  	  (cond
  	   (initarg-p (push (cons slotd value) init-slots))
  	   ((slot-definition-initfunction slotd)
  	    (push 
  	     (cons slotd (funcall (slot-definition-initfunction slotd)))
  	     init-slots))))))
  
      (cond
       (init-slots
        (let ((element-size (+ +gvalue-size+ +size-of-pointer+))
  	    (num-slots (length init-slots)))
  	(with-allocated-memory (params (* num-slots element-size))
            (loop
  	   with string-writer = (writer-function 'string)
  	   for (slotd . value) in init-slots
  	   as offset = params then (sap+ offset element-size)
  	   as type = (slot-definition-type slotd)
  	   as pname = (slot-definition-pname slotd)
  	   do (funcall string-writer pname offset)
                (gvalue-init (sap+ offset +size-of-pointer+) type value))
  
  	  (unwind-protect
  	      (%gobject-newv (type-number-of object) num-slots params)
  	
  	    (loop
  	     with string-destroy = (destroy-function 'string)
  	     repeat num-slots
  	     as offset = params then (sap+ offset element-size)
  	     do (funcall string-destroy offset)
  	        (gvalue-unset (sap+ offset +size-of-pointer+)))))))
  
       (t (%gobject-new (type-number-of object))))))
  
  
  (defmethod shared-initialize ((object gobject) names &rest initargs)
    (declare (ignore names initargs))
    (let ((*ignore-setting-construct-only-property* t))
      (call-next-method)))
  
  (defmethod initialize-instance :around ((object gobject) &rest initargs)
    (declare (ignore initargs))
    (prog1
        (call-next-method)
      #+debug-ref-counting(%object-weak-ref (foreign-location object))
      #+glib2.8
      (when (slot-value (class-of object) 'instance-slots-p)
        (with-slots (location) object
          (%object-add-toggle-ref location)
  	(%object-unref location)))))
  
  
  (defmethod instance-finalizer ((instance gobject))
  