Changeset 12789


Ignore:
Timestamp:
07/07/10 20:53:34 (12 years ago)
Author:
ehuelsmann
Message:

More CLASS-NAME integration.

Location:
branches/generic-class-file/abcl/src/org/armedbear/lisp
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/generic-class-file/abcl/src/org/armedbear/lisp/compiler-pass2.lisp

    r12787 r12789  
    199199          n)))
    200200
    201 (defconstant +fasl-loader-class+
    202   "org/armedbear/lisp/FaslClassLoader")
     201
    203202(defconstant +lisp-object-class+ "org/armedbear/lisp/LispObject")
    204203(defconstant +lisp-object+ "Lorg/armedbear/lisp/LispObject;")
     
    207206(defconstant +lisp-symbol-class+ "org/armedbear/lisp/Symbol")
    208207(defconstant +lisp-symbol+ "Lorg/armedbear/lisp/Symbol;")
    209 (defconstant +lisp-structure-object-class+ "org/armedbear/lisp/StructureObject")
    210 (defconstant +lisp-thread-class+ "org/armedbear/lisp/LispThread")
    211 (defconstant +lisp-thread+ "Lorg/armedbear/lisp/LispThread;")
    212 (defconstant +lisp-cons-class+ "org/armedbear/lisp/Cons")
    213 (defconstant +lisp-cons+ "Lorg/armedbear/lisp/Cons;")
    214208(defconstant +lisp-integer-class+ "org/armedbear/lisp/LispInteger")
    215209(defconstant +lisp-integer+ "Lorg/armedbear/lisp/LispInteger;")
     
    235229(defconstant +lisp-simple-string-class+ "org/armedbear/lisp/SimpleString")
    236230(defconstant +lisp-simple-string+ "Lorg/armedbear/lisp/SimpleString;")
    237 (defconstant +lisp-environment+ "Lorg/armedbear/lisp/Environment;")
    238 (defconstant +lisp-environment-class+ "org/armedbear/lisp/Environment")
    239231(defconstant +lisp-special-binding+ "Lorg/armedbear/lisp/SpecialBinding;")
    240232(defconstant +lisp-special-binding-class+ "org/armedbear/lisp/SpecialBinding")
    241 (defconstant +lisp-throw-class+ "org/armedbear/lisp/Throw")
    242 (defconstant +lisp-return-class+ "org/armedbear/lisp/Return")
    243 (defconstant +lisp-go-class+ "org/armedbear/lisp/Go")
    244 (defconstant +lisp-primitive-class+ "org/armedbear/lisp/Primitive")
    245 (defconstant +lisp-hash-table-class+ "org/armedbear/lisp/HashTable")
    246 (defconstant +lisp-eql-hash-table-class+ "org/armedbear/lisp/EqlHashTable")
    247233(defconstant +lisp-closure-parameter-class+ "org/armedbear/lisp/Closure$Parameter")
    248234(defconstant +lisp-closure-parameter-array+ "[Lorg/armedbear/lisp/Closure$Parameter;")
     
    686672        ((equal class +lisp-symbol+)
    687673         "Symbol")
    688         ((equal class +lisp-thread-class+)
     674        ((equal class +lisp-thread+)
    689675         "LispThread")
    690676        (t
     
    726712(defun maybe-initialize-thread-var ()
    727713  (when *initialize-thread-var*
    728     (emit-invokestatic +lisp-thread-class+ "currentThread" nil +lisp-thread+)
     714    (emit-invokestatic +lisp-thread+ "currentThread" nil +lisp-thread+)
    729715    (astore *thread*)
    730716    (setf *initialize-thread-var* nil)))
     
    773759                            (SYMBOL     +lisp-symbol-class+)
    774760                            (CHARACTER  +lisp-character-class+)
    775                             (CONS       +lisp-cons-class+)
    776                             (HASH-TABLE +lisp-hash-table-class+)
     761                            (CONS       +lisp-cons+)
     762                            (HASH-TABLE +lisp-hash-table+)
    777763                            (FIXNUM     +lisp-fixnum-class+)
    778764                            (STREAM     +lisp-stream+)
     
    12941280                   (inst 'aload *thread*)
    12951281                   (inst 'aconst_null)
    1296                    (inst 'putfield (list +lisp-thread-class+ "_values"
     1282                   (inst 'putfield (list +lisp-thread+ "_values"
    12971283                                         +lisp-object-array+)))))
    12981284             (dolist (instruction instructions)
     
    18161802         (*handlers* nil))
    18171803    (setf (method-max-locals constructor) 1)
    1818     (unless (equal super +lisp-primitive-class+)
     1804    (unless (eq super +lisp-primitive+)
    18191805      (multiple-value-bind
    18201806            (req opt key key-p rest
     
    18841870                                            +lisp-object+ +lisp-object+))))))
    18851871    (aload 0) ;; this
    1886     (cond ((equal super +lisp-primitive-class+)
     1872    (cond ((eq super +lisp-primitive+)
    18871873           (emit-constructor-lambda-name lambda-name)
    18881874           (emit-constructor-lambda-list args)
     
    215721435. The type of the field to save the serialized result to")
    21582144
    2159 (defknown emit-load-externalized-object (t) string)
     2145(defknown emit-load-externalized-object (t &optional t) string)
    21602146(defun emit-load-externalized-object (object &optional cast)
    21612147  "Externalizes `object' for use in a FASL.
     
    28032789               (ht-form (%caddr form)))
    28042790           (compile-form ht-form 'stack nil)
    2805            (emit 'checkcast +lisp-hash-table-class+)
     2791           (emit 'checkcast +lisp-hash-table+)
    28062792           (compile-form key-form 'stack nil)
    28072793           (maybe-emit-clear-values ht-form key-form)
    2808            (emit-invokevirtual +lisp-hash-table-class+ "gethash1"
     2794           (emit-invokevirtual +lisp-hash-table+ "gethash1"
    28092795                               (lisp-object-arg-types 1) +lisp-object+)
    28102796           (fix-boxing representation nil)
     
    28212807               (value-form (fourth form)))
    28222808           (compile-form ht-form 'stack nil)
    2823            (emit 'checkcast +lisp-hash-table-class+)
     2809           (emit 'checkcast +lisp-hash-table+)
    28242810           (compile-form key-form 'stack nil)
    28252811           (compile-form value-form 'stack nil)
    28262812           (maybe-emit-clear-values ht-form key-form value-form)
    28272813           (cond (target
    2828                   (emit-invokevirtual +lisp-hash-table-class+ "puthash"
     2814                  (emit-invokevirtual +lisp-hash-table+ "puthash"
    28292815                                      (lisp-object-arg-types 2) +lisp-object+)
    28302816                  (fix-boxing representation nil)
    28312817                  (emit-move-from-stack target representation))
    28322818                 (t
    2833                   (emit-invokevirtual +lisp-hash-table-class+ "put"
     2819                  (emit-invokevirtual +lisp-hash-table+ "put"
    28342820                                      (lisp-object-arg-types 2) nil)))))
    28352821        (t
     
    29092895                       (list +lisp-object+ +lisp-object-array+)))
    29102896        (return-type +lisp-object+))
    2911     (emit-invokevirtual +lisp-thread-class+ "execute" arg-types return-type)))
     2897    (emit-invokevirtual +lisp-thread+ "execute" arg-types return-type)))
    29122898
    29132899(defknown compile-function-call (t t t) t)
     
    30783064           (emit-load-externalized-object
    30793065            (local-function-environment local-function)
    3080             +lisp-environment-class+)
     3066            +lisp-environment+)
    30813067           (emit-load-externalized-object (local-function-name local-function))
    3082            (emit-invokevirtual +lisp-environment-class+ "lookupFunction"
     3068           (emit-invokevirtual +lisp-environment+ "lookupFunction"
    30833069                               (list +lisp-object+)
    30843070                               +lisp-object+))
     
    34003386
    34013387(defun p2-test-consp (form)
    3402   (p2-test-instanceof-predicate form +lisp-cons-class+))
     3388  (p2-test-instanceof-predicate form +lisp-cons+))
    34033389
    34043390(defun p2-test-atom (form)
    3405   (p2-test-instanceof-predicate form +lisp-cons-class+)
     3391  (p2-test-instanceof-predicate form +lisp-cons+)
    34063392  'ifne)
    34073393
     
    38423828    ;; Save multiple values returned by first subform.
    38433829    (emit-push-current-thread)
    3844     (emit 'getfield +lisp-thread-class+ "_values" +lisp-object-array+)
     3830    (emit 'getfield +lisp-thread+ "_values" +lisp-object-array+)
    38453831    (astore values-register)
    38463832    (dolist (subform subforms)
     
    38493835    (emit-push-current-thread)
    38503836    (aload values-register)
    3851     (emit 'putfield +lisp-thread-class+ "_values" +lisp-object-array+)
     3837    (emit 'putfield +lisp-thread+ "_values" +lisp-object-array+)
    38523838    ;; Result.
    38533839    (aload result-register)
     
    38923878         (emit 'swap)
    38933879         (aload values-register)
    3894          (emit-invokevirtual +lisp-thread-class+ "accumulateValues"
     3880         (emit-invokevirtual +lisp-thread+ "accumulateValues"
    38953881                             (list +lisp-object+ +lisp-object-array+)
    38963882                             +lisp-object-array+)
     
    39453931         (emit-push-variable-name variable)
    39463932         (emit 'swap)
    3947          (emit-invokevirtual +lisp-thread-class+ "bindSpecial"
     3933         (emit-invokevirtual +lisp-thread+ "bindSpecial"
    39483934                             (list +lisp-symbol+ +lisp-object+)
    39493935                             +lisp-special-binding+)
     
    39863972   (emit-push-current-thread)
    39873973   (aload register)
    3988    (emit-invokevirtual +lisp-thread-class+ "resetSpecialBindings"
     3974   (emit-invokevirtual +lisp-thread+ "resetSpecialBindings"
    39893975                       (list +lisp-special-bindings-mark+) nil)
    39903976  )
     
    39923978(defun save-dynamic-environment (register)
    39933979   (emit-push-current-thread)
    3994    (emit-invokevirtual +lisp-thread-class+ "markSpecialBindings"
     3980   (emit-invokevirtual +lisp-thread+ "markSpecialBindings"
    39953981                       nil +lisp-special-bindings-mark+)
    39963982   (astore register)
     
    40514037             ;; Store values from values form in values register.
    40524038             (emit-push-current-thread)
    4053              (emit 'getfield +lisp-thread-class+ "_values" +lisp-object-array+)
     4039             (emit 'getfield +lisp-thread+ "_values" +lisp-object-array+)
    40544040             (emit-move-from-stack values-register)
    40554041             ;; Did we get just one value?
     
    40704056             (aload result-register)
    40714057             (emit-push-constant-int (length vars))
    4072              (emit-invokevirtual +lisp-thread-class+ "getValues"
     4058             (emit-invokevirtual +lisp-thread+ "getValues"
    40734059                                 (list +lisp-object+ "I") +lisp-object-array+)
    40744060             ;; Values array is now on the stack at runtime.
     
    42304216           (assert (not *file-compilation*))
    42314217           (emit-load-externalized-object (variable-environment variable)
    4232                                           +lisp-environment-class+)
     4218                                          +lisp-environment+)
    42334219           (emit 'swap)
    42344220           (emit-push-variable-name variable)
    42354221           (emit 'swap)
    4236            (emit-invokevirtual +lisp-environment-class+ "rebind"
     4222           (emit-invokevirtual +lisp-environment+ "rebind"
    42374223                               (list +lisp-symbol+ +lisp-object+)
    42384224                               nil))
     
    42624248         (assert (not *file-compilation*))
    42634249         (emit-load-externalized-object (variable-environment variable)
    4264                                         +lisp-environment-class+)
     4250                                        +lisp-environment+)
    42654251         (emit-push-variable-name variable)
    4266          (emit-invokevirtual +lisp-environment-class+ "lookup"
     4252         (emit-invokevirtual +lisp-environment+ "lookup"
    42674253                             (list +lisp-object+)
    42684254                             +lisp-object+))
     
    43574343                 (emit-push-current-thread)
    43584344                 (emit-push-variable-name variable)
    4359                  (emit-invokevirtual +lisp-thread-class+
     4345                 (emit-invokevirtual +lisp-thread+
    43604346                                     "bindSpecialToCurrentValue"
    43614347                                     (list +lisp-symbol+)
     
    45174503        (astore go-register)
    45184504        ;; Get the tag.
    4519         (emit 'getfield +lisp-go-class+ "tagbody" +lisp-object+) ; Stack depth is still 1.
     4505        (emit 'getfield +lisp-go+ "tagbody" +lisp-object+) ; Stack depth is still 1.
    45204506        (emit-push-variable (tagbody-id-variable block))
    45214507        (emit 'if_acmpne RETHROW) ;; Not this TAGBODY
    45224508        (aload go-register)
    4523         (emit 'getfield +lisp-go-class+ "tag" +lisp-object+) ; Stack depth is still 1.
     4509        (emit 'getfield +lisp-go+ "tag" +lisp-object+) ; Stack depth is still 1.
    45244510        (astore tag-register)
    45254511        ;; Don't actually generate comparisons for tags
     
    45454531                            :to END-BLOCK
    45464532                            :code HANDLER
    4547                             :catch-type (pool-class +lisp-go-class+))
     4533                            :catch-type (pool-class (!class-name +lisp-go+)))
    45484534              *handlers*)
    45494535        (push (make-handler :from BEGIN-BLOCK
     
    45984584   (check-arg-count form 1))
    45994585  (compile-forms-and-maybe-emit-clear-values (cadr form) 'stack nil)
    4600   (emit 'instanceof +lisp-cons-class+)
     4586  (emit 'instanceof +lisp-cons+)
    46014587  (let ((LABEL1 (gensym))
    46024588        (LABEL2 (gensym)))
     
    46384624
    46394625(defun p2-consp (form target representation)
    4640   (p2-instanceof-predicate form target representation +lisp-cons-class+))
     4626  (p2-instanceof-predicate form target representation +lisp-cons+))
    46414627
    46424628(defun p2-fixnump (form target representation)
     
    47004686        ;; The Return object is on the runtime stack. Stack depth is 1.
    47014687        (emit 'dup) ; Stack depth is 2.
    4702         (emit 'getfield +lisp-return-class+ "tag" +lisp-object+) ; Still 2.
     4688        (emit 'getfield +lisp-return+ "tag" +lisp-object+) ; Still 2.
    47034689        (emit-push-variable (block-id-variable block))
    47044690        ;; If it's not the block we're looking for...
     
    47104696        (emit 'athrow)
    47114697        (label THIS-BLOCK)
    4712         (emit 'getfield +lisp-return-class+ "result" +lisp-object+)
     4698        (emit 'getfield +lisp-return+ "result" +lisp-object+)
    47134699        (emit-move-from-stack target) ; Stack depth is 0.
    47144700        ;; Finally...
     
    47164702                            :to END-BLOCK
    47174703                            :code HANDLER
    4718                             :catch-type (pool-class +lisp-return-class+))
     4704                            :catch-type (pool-class (!class-name +lisp-return+)))
    47194705              *handlers*)
    47204706        (push (make-handler :from BEGIN-BLOCK
     
    47854771(define-inlined-function p2-cons (form target representation)
    47864772  ((check-arg-count form 2))
    4787   (emit 'new +lisp-cons-class+)
     4773  (emit 'new +lisp-cons+)
    47884774  (emit 'dup)
    47894775  (let* ((args (%cdr form))
     
    47924778    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    47934779                 arg2 'stack nil))
    4794   (emit-invokespecial-init +lisp-cons-class+ (lisp-object-arg-types 2))
     4780  (emit-invokespecial-init +lisp-cons+ (lisp-object-arg-types 2))
    47954781  (emit-move-from-stack target))
    47964782
     
    57505736  (cond ((and (check-arg-count form 2)
    57515737              (eq (derive-type (%cadr form)) 'SYMBOL))
    5752          (emit 'new +lisp-structure-object-class+)
     5738         (emit 'new +lisp-structure-object+)
    57535739         (emit 'dup)
    57545740         (compile-form (%cadr form) 'stack nil)
     
    57585744         (emit-invokevirtual +lisp-object-class+ "copyToArray"
    57595745                             nil +lisp-object-array+)
    5760          (emit-invokespecial-init +lisp-structure-object-class+
     5746         (emit-invokespecial-init +lisp-structure-object+
    57615747                                  (list +lisp-symbol+ +lisp-object-array+))
    57625748         (emit-move-from-stack target representation))
     
    57705756    (cond ((and (<= 1 slot-count 6)
    57715757                (eq (derive-type (%car args)) 'SYMBOL))
    5772            (emit 'new +lisp-structure-object-class+)
     5758           (emit 'new +lisp-structure-object+)
    57735759           (emit 'dup)
    57745760           (compile-form (%car args) 'stack nil)
     
    57775763             (compile-form slot-form 'stack nil))
    57785764           (apply 'maybe-emit-clear-values args)
    5779            (emit-invokespecial-init +lisp-structure-object-class+
     5765           (emit-invokespecial-init +lisp-structure-object+
    57805766                                    (append (list +lisp-symbol+)
    57815767                                            (make-list slot-count :initial-element +lisp-object+)))
     
    57865772(defun p2-make-hash-table (form target representation)
    57875773  (cond ((= (length form) 1) ; no args
    5788          (emit 'new +lisp-eql-hash-table-class+)
     5774         (emit 'new +lisp-eql-hash-table+)
    57895775         (emit 'dup)
    5790          (emit-invokespecial-init +lisp-eql-hash-table-class+ nil)
     5776         (emit-invokespecial-init +lisp-eql-hash-table+ nil)
    57915777         (fix-boxing representation nil)
    57925778         (emit-move-from-stack target representation))
     
    64526438    (cond ((>= 4 length 1)
    64536439     (dolist (cons-head cons-heads)
    6454        (emit 'new +lisp-cons-class+)
     6440       (emit 'new +lisp-cons+)
    64556441       (emit 'dup)
    64566442       (compile-form cons-head 'stack nil))
     
    64596445       (progn
    64606446         (emit-invokespecial-init
    6461     +lisp-cons-class+ (lisp-object-arg-types 1))
     6447    +lisp-cons+ (lisp-object-arg-types 1))
    64626448         (pop cons-heads))) ; we've handled one of the args, so remove it
    64636449     (dolist (cons-head cons-heads)
    64646450       (declare (ignore cons-head))
    64656451       (emit-invokespecial-init
    6466         +lisp-cons-class+ (lisp-object-arg-types 2)))
     6452        +lisp-cons+ (lisp-object-arg-types 2)))
    64676453     (if list-star-p
    64686454         (progn
     
    71817167      (0
    71827168       (emit-push-current-thread)
    7183        (emit-invokevirtual +lisp-thread-class+ "setValues" nil +lisp-object+)
     7169       (emit-invokevirtual +lisp-thread+ "setValues" nil +lisp-object+)
    71847170       (emit-move-from-stack target))
    71857171      (1
     
    72017187                (compile-form arg1 'stack nil)
    72027188                (compile-form arg2 'stack nil))))
    7203        (emit-invokevirtual +lisp-thread-class+
     7189       (emit-invokevirtual +lisp-thread+
    72047190                           "setValues"
    72057191                           (lisp-object-arg-types len)
     
    72117197       (dolist (arg args)
    72127198         (compile-form arg 'stack nil))
    7213        (emit-invokevirtual +lisp-thread-class+
     7199       (emit-invokevirtual +lisp-thread+
    72147200                           "setValues"
    72157201                           (lisp-object-arg-types len)
     
    72837269         (compile-form (%caddr form) 'stack nil)
    72847270         (maybe-emit-clear-values (%cadr form) (%caddr form))
    7285          (emit-invokevirtual +lisp-thread-class+ "setSpecialVariable"
     7271         (emit-invokevirtual +lisp-thread+ "setSpecialVariable"
    72867272                             (list +lisp-symbol+ +lisp-object+) +lisp-object+)
    72877273         (fix-boxing representation nil)
     
    73357321             (emit-load-externalized-object name)
    73367322       (compile-forms-and-maybe-emit-clear-values (second value-form) 'stack nil)
    7337              (emit-invokevirtual +lisp-thread-class+ "pushSpecial"
     7323             (emit-invokevirtual +lisp-thread+ "pushSpecial"
    73387324                                 (list +lisp-symbol+ +lisp-object+) +lisp-object+))
    73397325            (t
     
    73417327             (emit-load-externalized-object name)
    73427328       (compile-forms-and-maybe-emit-clear-values value-form 'stack nil)
    7343              (emit-invokevirtual +lisp-thread-class+ "setSpecialVariable"
     7329             (emit-invokevirtual +lisp-thread+ "setSpecialVariable"
    73447330                                 (list +lisp-symbol+ +lisp-object+) +lisp-object+)))
    73457331      (fix-boxing representation nil)
     
    74757461                            (SYMBOL     +lisp-symbol-class+)
    74767462                            (CHARACTER  +lisp-character-class+)
    7477                             (CONS       +lisp-cons-class+)
    7478                             (HASH-TABLE +lisp-hash-table-class+)
     7463                            (CONS       +lisp-cons+)
     7464                            (HASH-TABLE +lisp-hash-table+)
    74797465                            (FIXNUM     +lisp-fixnum-class+)
    74807466          (STREAM     +lisp-stream+)
     
    76827668      (emit-push-current-thread)
    76837669      (aload tag-register)
    7684       (emit-invokevirtual +lisp-thread-class+ "pushCatchTag"
     7670      (emit-invokevirtual +lisp-thread+ "pushCatchTag"
    76857671                          (lisp-object-arg-types 1) nil)
    76867672      (let ((*blocks* (cons block *blocks*)))
     
    76937679      ;; The Throw object is on the runtime stack. Stack depth is 1.
    76947680      (emit 'dup) ; Stack depth is 2.
    7695       (emit 'getfield +lisp-throw-class+ "tag" +lisp-object+) ; Still 2.
     7681      (emit 'getfield +lisp-throw+ "tag" +lisp-object+) ; Still 2.
    76967682      (aload tag-register) ; Stack depth is 3.
    76977683      ;; If it's not the tag we're looking for, we branch to the start of the
     
    76997685      (emit 'if_acmpne DEFAULT-HANDLER) ; Stack depth is 1.
    77007686      (emit-push-current-thread)
    7701       (emit-invokevirtual +lisp-throw-class+ "getResult"
     7687      (emit-invokevirtual +lisp-throw+ "getResult"
    77027688                          (list +lisp-thread+) +lisp-object+)
    77037689      (emit-move-from-stack target) ; Stack depth is 0.
     
    77067692      ;; A Throwable object is on the runtime stack here. Stack depth is 1.
    77077693      (emit-push-current-thread)
    7708       (emit-invokevirtual +lisp-thread-class+ "popCatchTag" nil nil)
     7694      (emit-invokevirtual +lisp-thread+ "popCatchTag" nil nil)
    77097695      (emit 'athrow) ; Re-throw.
    77107696      (label EXIT)
    77117697      ;; Finally...
    77127698      (emit-push-current-thread)
    7713       (emit-invokevirtual +lisp-thread-class+ "popCatchTag" nil nil)
     7699      (emit-invokevirtual +lisp-thread+ "popCatchTag" nil nil)
    77147700      (let ((handler1 (make-handler :from BEGIN-PROTECTED-RANGE
    77157701                                    :to END-PROTECTED-RANGE
    77167702                                    :code THROW-HANDLER
    7717                                     :catch-type (pool-class +lisp-throw-class+)))
     7703                                    :catch-type (pool-class (!class-name +lisp-throw+))))
    77187704            (handler2 (make-handler :from BEGIN-PROTECTED-RANGE
    77197705                                    :to END-PROTECTED-RANGE
     
    77317717  (emit-clear-values) ; Do this unconditionally! (MISC.503)
    77327718  (compile-form (third form) 'stack nil) ; Result.
    7733   (emit-invokevirtual +lisp-thread-class+ "throwToTag"
     7719  (emit-invokevirtual +lisp-thread+ "throwToTag"
    77347720                      (lisp-object-arg-types 2) nil)
    77357721  ;; Following code will not be reached.
     
    77747760        (unless (single-valued-p protected-form)
    77757761          (emit-push-current-thread)
    7776           (emit 'getfield +lisp-thread-class+ "_values" +lisp-object-array+)
     7762          (emit 'getfield +lisp-thread+ "_values" +lisp-object-array+)
    77777763          (astore values-register))
    77787764        (label END-PROTECTED-RANGE))
     
    77877773      (astore exception-register)
    77887774      (emit-push-current-thread)
    7789       (emit 'getfield +lisp-thread-class+ "_values" +lisp-object-array+)
     7775      (emit 'getfield +lisp-thread+ "_values" +lisp-object-array+)
    77907776      (astore values-register)
    77917777      (let ((*register* *register*))
     
    77957781      (emit-push-current-thread)
    77967782      (aload values-register)
    7797       (emit 'putfield +lisp-thread-class+ "_values" +lisp-object-array+)
     7783      (emit 'putfield +lisp-thread+ "_values" +lisp-object-array+)
    77987784      (aload exception-register)
    77997785      (emit 'athrow) ; Re-throw exception.
     
    78037789        (emit-push-current-thread)
    78047790        (aload values-register)
    7805         (emit 'putfield +lisp-thread-class+ "_values" +lisp-object-array+))
     7791        (emit 'putfield +lisp-thread+ "_values" +lisp-object-array+))
    78067792      ;; Result.
    78077793      (aload result-register)
     
    81918177                 (emit 'aaload)
    81928178                 (setf (variable-index variable) nil)))
    8193           (emit-invokevirtual +lisp-thread-class+ "bindSpecial"
     8179          (emit-invokevirtual +lisp-thread+ "bindSpecial"
    81948180                              (list +lisp-symbol+ +lisp-object+)
    81958181                              +lisp-special-binding+)
     
    82408226      (and *child-p* *closure-variables*))
    82418227        +lisp-compiled-closure+
    8242       +lisp-primitive-class+))
     8228      +lisp-primitive+))
    82438229
    82448230    (setf (abcl-class-file-lambda-list class-file) args)
  • branches/generic-class-file/abcl/src/org/armedbear/lisp/jvm-class-file.lisp

    r12788 r12789  
    111111(define-class-name +lisp-class+ "org.armedbear.lisp.LispClass")
    112112(define-class-name +!lisp-symbol+ "org.armedbear.lisp.Symbol")
    113 (define-class-name +!lisp-thread+ "org.armedbear.lisp.LispThread")
     113(define-class-name +lisp-thread+ "org.armedbear.lisp.LispThread")
    114114(define-class-name +lisp-closure-binding+ "org.armedbear.lisp.ClosureBinding")
    115115(define-class-name +!lisp-integer+ "org.armedbear.lisp.Integer")
     
    118118(define-class-name +!lisp-single-float+ "org.armedbear.lisp.SingleFloat")
    119119(define-class-name +!lisp-double-float+ "org.armedbear.lisp.DoubleFloat")
    120 (define-class-name +!lisp-cons+ "org.armedbear.lisp.Cons")
     120(define-class-name +lisp-cons+ "org.armedbear.lisp.Cons")
    121121(define-class-name +lisp-load+ "org.armedbear.lisp.Load")
    122122(define-class-name +!lisp-character+ "org.armedbear.lisp.Character")
     123(define-class-name +lisp-structure-object+ "org.armedbear.lisp.StructureObject")
    123124(define-class-name +!lisp-simple-vector+ "org.armedbear.lisp.SimpleVector")
    124125(define-class-name +!lisp-abstract-string+ "org.armedbear.lisp.AbstractString")
     
    126127(define-class-name +!lisp-abstract-bit-vector+
    127128    "org.armedbear.lisp.AbstractBitVector")
    128 (define-class-name +!lisp-environment+ "org.armedbear.lisp.Environment")
     129(define-class-name +lisp-environment+ "org.armedbear.lisp.Environment")
    129130(define-class-name +!lisp-special-binding+ "org.armedbear.lisp.SpecialBinding")
    130131(define-class-name +lisp-special-bindings-mark+
    131132    "org.armedbear.lisp.SpecialBindingsMark")
    132 (define-class-name +!lisp-throw+ "org.armedbear.lisp.Throw")
    133 (define-class-name +!lisp-return+ "org.armedbear.lisp.Return")
    134 (define-class-name +!lisp-go+ "org.armedbear.lisp.Go")
    135 (define-class-name +!lisp-primitive+ "org.armedbear.lisp.Primitive")
    136 (define-class-name +!lisp-eql-hash-table+ "org.armedbear.lisp.EqlHashTable")
     133(define-class-name +lisp-throw+ "org.armedbear.lisp.Throw")
     134(define-class-name +lisp-return+ "org.armedbear.lisp.Return")
     135(define-class-name +lisp-go+ "org.armedbear.lisp.Go")
     136(define-class-name +lisp-primitive+ "org.armedbear.lisp.Primitive")
     137(define-class-name +lisp-eql-hash-table+ "org.armedbear.lisp.EqlHashTable")
     138(define-class-name +lisp-hash-table+ "org.armedbear.lisp.HashTable")
    137139(define-class-name +lisp-package+ "org.armedbear.lisp.Package")
    138140(define-class-name +lisp-readtable+ "org.armedbear.lisp.Readtable")
Note: See TracChangeset for help on using the changeset viewer.