Changeset 12791


Ignore:
Timestamp:
07/08/10 21:57:18 (12 years ago)
Author:
ehuelsmann
Message:

CLASS-NAME integration for +lisp-object+.

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

Legend:

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

    r12761 r12791  
    685685            (jvm::with-inline-code ()
    686686        (jvm::emit 'jvm::aload 1)
    687         (jvm::emit-invokevirtual jvm::+lisp-object-class+ "javaInstance"
     687        (jvm::emit-invokevirtual jvm::+lisp-object+ "javaInstance"
    688688               nil jvm::+java-object+)
    689689        (jvm::emit 'jvm::checkcast "org/armedbear/lisp/FaslClassLoader")
  • branches/generic-class-file/abcl/src/org/armedbear/lisp/compiler-pass2.lisp

    r12790 r12791  
    200200
    201201
    202 (defconstant +lisp-object-class+ "org/armedbear/lisp/LispObject")
    203 (defconstant +lisp-object+ "Lorg/armedbear/lisp/LispObject;")
    204202(defconstant +lisp-object-array+ "[Lorg/armedbear/lisp/LispObject;")
    205203(defconstant +closure-binding-array+ "[Lorg/armedbear/lisp/ClosureBinding;")
     
    583581
    584582(defvar rep-classes
    585   '((:boolean  #.+lisp-object-class+        #.+lisp-object+)
    586     (:char     #.+lisp-character-class+     #.+lisp-character+)
    587     (:int      #.+lisp-integer-class+       #.+lisp-integer+)
    588     (:long     #.+lisp-integer-class+       #.+lisp-integer+)
    589     (:float    #.+lisp-single-float-class+  #.+lisp-single-float+)
    590     (:double   #.+lisp-double-float-class+  #.+lisp-double-float+))
     583  `((:boolean . ,+lisp-object+)
     584    (:char    . ,+!lisp-character+)
     585    (:int     . ,+!lisp-integer+)
     586    (:long    . ,+!lisp-integer+)
     587    (:float   . ,+!lisp-single-float+)
     588    (:double  . ,+!lisp-double-float+))
    591589  "Lists the class on which to call the `getInstance' method on,
    592590when converting the internal representation to a LispObject.")
     
    613611      (let ((class (cdr (assoc in rep-classes)))
    614612            (arg-spec (cdr (assoc in rep-arg-chars))))
    615         (emit-invokestatic (first class) "getInstance" (list arg-spec)
    616                            (second class))))
     613        (emit-invokestatic class "getInstance" (list arg-spec)
     614                           class)))
    617615    (return-from convert-representation))
    618616  (let* ((in-map (cdr (assoc in rep-conversion)))
     
    628626             (funcall op))
    629627            ((stringp op)
    630              (emit-invokevirtual +lisp-object-class+ op nil
     628             (emit-invokevirtual +lisp-object+ op nil
    631629                                 (cdr (assoc out rep-arg-chars))))
    632630            (t
     
    658656(declaim (ftype (function t string) pretty-java-class))
    659657(defun pretty-java-class (class)
    660   (cond ((equal class +lisp-object-class+)
     658  (cond ((equal (!class-name class) (!class-name +lisp-object+))
    661659         "LispObject")
    662660        ((equal class +lisp-symbol+)
     
    944942                (emit 'getfield +lisp-fixnum-class+ "value" "I"))
    945943               (t
    946                 (emit-invokevirtual +lisp-object-class+ "intValue" nil "I"))))
     944                (emit-invokevirtual +lisp-object+ "intValue" nil "I"))))
    947945        ((eq required-representation :char)
    948946         (emit-unbox-character))
     
    950948         (emit-unbox-boolean))
    951949        ((eq required-representation :long)
    952          (emit-invokevirtual +lisp-object-class+ "longValue" nil "J"))
     950         (emit-invokevirtual +lisp-object+ "longValue" nil "J"))
    953951        ((eq required-representation :float)
    954          (emit-invokevirtual +lisp-object-class+ "floatValue" nil "F"))
     952         (emit-invokevirtual +lisp-object+ "floatValue" nil "F"))
    955953        ((eq required-representation :double)
    956          (emit-invokevirtual +lisp-object-class+ "doubleValue" nil "D"))
     954         (emit-invokevirtual +lisp-object+ "doubleValue" nil "D"))
    957955        (t (assert nil))))
    958956
     
    984982(defknown emit-invoke-method (t t t) t)
    985983(defun emit-invoke-method (method-name target representation)
    986   (emit-invokevirtual +lisp-object-class+ method-name nil +lisp-object+)
     984  (emit-invokevirtual +lisp-object+ method-name nil +lisp-object+)
    987985  (fix-boxing representation nil)
    988986  (emit-move-from-stack target representation))
     
    21222120    (string "STR" ,#'equal ,#'serialize-string
    21232121            ,+lisp-abstract-string+) ;; because of (not compile-file)
    2124     (package "PKG" ,#'eq ,#'serialize-package ,+!lisp-object+)
     2122    (package "PKG" ,#'eq ,#'serialize-package ,+lisp-object+)
    21252123    (symbol "SYM" ,#'eq ,#'serialize-symbol ,+!lisp-symbol+)
    2126     (T "OBJ" ,#'eq ,#'serialize-object ,+!lisp-object+))
     2124    (T "OBJ" ,#'eq ,#'serialize-object ,+lisp-object+))
    21272125  "A list of 5-element lists. The elements of the sublists mean:
    21282126
     
    21772175           (emit-invokestatic +lisp+ "recall"
    21782176                              (list +java-string+) +lisp-object+)
    2179            (when (not (eq field-type +!lisp-object+))
     2177           (when (not (eq field-type +lisp-object+))
    21802178             (emit 'checkcast field-type))
    21812179           (emit 'putstatic *this-class* field-name field-type)
     
    22322230         ;; make sure we're not cacheing a proxied function
    22332231         ;; (AutoloadedFunctionProxy) by allowing it to resolve itself
    2234          (emit-invokevirtual +lisp-object-class+
     2232         (emit-invokevirtual +lisp-object+
    22352233                             "resolve" nil +lisp-object+)
    22362234         (emit 'putstatic *this-class* f +lisp-object+)
     
    23252323    g))
    23262324
    2327 (declaim (ftype (function (t &optional t) string) declare-object))
    2328 (defun declare-object (obj &optional (obj-ref +lisp-object+)
    2329                            obj-class)
     2325(declaim (ftype (function (t) string) declare-object))
     2326(defun declare-object (obj)
    23302327  "Stores the object OBJ in the object-lookup-table,
    23312328loading the object value into a field upon class-creation time.
     
    23362333    (remember g obj)
    23372334    (let* ((*code* *static-code*))
    2338       (declare-field g obj-ref +field-access-private+)
     2335      (declare-field g +lisp-object+ +field-access-private+)
    23392336      (emit 'ldc (pool-string g))
    23402337      (emit-invokestatic +lisp+ "recall"
    23412338                         (list +java-string+) +lisp-object+)
    2342       (when (and obj-class (string/= obj-class +lisp-object-class+))
    2343         (emit 'checkcast obj-class))
    2344       (emit 'putstatic *this-class* g obj-ref)
     2339      (emit 'putstatic *this-class* g +lisp-object+)
    23452340      (setf *static-code* *code*)
    23462341      g)))
     
    23562351           ((integerp form)
    23572352            (emit-load-externalized-object form)
    2358             (emit-invokevirtual +lisp-object-class+ "intValue" nil "I"))
     2353            (emit-invokevirtual +lisp-object+ "intValue" nil "I"))
    23592354           (t
    23602355            (sys::%format t "compile-constant int representation~%")
     
    23672362           ((integerp form)
    23682363            (emit-load-externalized-object form)
    2369             (emit-invokevirtual +lisp-object-class+ "longValue" nil "J"))
     2364            (emit-invokevirtual +lisp-object+ "longValue" nil "J"))
    23702365           (t
    23712366            (sys::%format t "compile-constant long representation~%")
     
    24932488             (ecase representation
    24942489               (:boolean
    2495                 (emit-invokevirtual +lisp-object-class+
     2490                (emit-invokevirtual +lisp-object+
    24962491                                    unboxed-method-name
    24972492                                    nil "Z"))
    24982493               ((NIL)
    2499                 (emit-invokevirtual +lisp-object-class+
     2494                (emit-invokevirtual +lisp-object+
    25002495                                    boxed-method-name
    25012496                                    nil +lisp-object+)))
     
    25652560    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    25662561                 arg2 'stack nil)
    2567     (emit-invokevirtual +lisp-object-class+ op
     2562    (emit-invokevirtual +lisp-object+ op
    25682563      (lisp-object-arg-types 1) +lisp-object+)
    25692564    (fix-boxing representation nil)
     
    26302625
    26312626(defun emit-ifne-for-eql (representation instruction-type)
    2632   (emit-invokevirtual +lisp-object-class+ "eql" instruction-type "Z")
     2627  (emit-invokevirtual +lisp-object+ "eql" instruction-type "Z")
    26332628  (convert-representation :boolean representation))
    26342629
     
    26762671           (ecase representation
    26772672             (:boolean
    2678               (emit-invokevirtual +lisp-object-class+ "eql"
     2673              (emit-invokevirtual +lisp-object+ "eql"
    26792674                                  (lisp-object-arg-types 1) "Z"))
    26802675             ((NIL)
    2681               (emit-invokevirtual +lisp-object-class+ "EQL"
     2676              (emit-invokevirtual +lisp-object+ "EQL"
    26822677                                  (lisp-object-arg-types 1) +lisp-object+)))))
    26832678    (emit-move-from-stack target representation)))
     
    28442839              (t
    28452840               (emit-push-constant-int numargs)
    2846                (emit 'anewarray +lisp-object-class+)
     2841               (emit 'anewarray +lisp-object+)
    28472842               (let ((i 0))
    28482843                 (dolist (arg args)
     
    28772872                       (list +lisp-object-array+)))
    28782873        (return-type +lisp-object+))
    2879     (emit-invokevirtual +lisp-object-class+ "execute" arg-types return-type)))
     2874    (emit-invokevirtual +lisp-object+ "execute" arg-types return-type)))
    28802875
    28812876(declaim (ftype (function (t) t) emit-call-thread-execute))
     
    31423137    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil)
    31433138                (emit-push-constant-int arg2)
    3144                 (emit-invokevirtual +lisp-object-class+
     3139                (emit-invokevirtual +lisp-object+
    31453140                                    (case op
    31463141                                      (<  "isLessThan")
     
    32753270    (let ((arg (%cadr form)))
    32763271      (compile-forms-and-maybe-emit-clear-values arg 'stack nil)
    3277       (emit-invokevirtual +lisp-object-class+ java-predicate nil "Z")
     3272      (emit-invokevirtual +lisp-object+ java-predicate nil "Z")
    32783273      'ifeq)))
    32793274
     
    32973292    (let ((arg (%cadr form)))
    32983293      (compile-forms-and-maybe-emit-clear-values arg 'stack nil)
    3299       (emit-invokevirtual +lisp-object-class+ "constantp" nil "Z")
     3294      (emit-invokevirtual +lisp-object+ "constantp" nil "Z")
    33003295      'ifeq)))
    33013296
     
    34883483       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    34893484              arg2 'stack :char)
    3490              (emit-invokevirtual +lisp-object-class+ "eql" '("C") "Z")
     3485             (emit-invokevirtual +lisp-object+ "eql" '("C") "Z")
    34913486             'ifeq)
    34923487            ((eq type1 'CHARACTER)
     
    34943489              arg2 'stack nil)
    34953490             (emit 'swap)
    3496              (emit-invokevirtual +lisp-object-class+ "eql" '("C") "Z")
     3491             (emit-invokevirtual +lisp-object+ "eql" '("C") "Z")
    34973492             'ifeq)
    34983493            ((fixnum-type-p type2)
    34993494       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35003495              arg2 'stack :int)
    3501              (emit-invokevirtual +lisp-object-class+ "eql" '("I") "Z")
     3496             (emit-invokevirtual +lisp-object+ "eql" '("I") "Z")
    35023497             'ifeq)
    35033498            ((fixnum-type-p type1)
     
    35053500              arg2 'stack nil)
    35063501             (emit 'swap)
    3507              (emit-invokevirtual +lisp-object-class+ "eql" '("I") "Z")
     3502             (emit-invokevirtual +lisp-object+ "eql" '("I") "Z")
    35083503             'ifeq)
    35093504            (t
    35103505       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35113506              arg2 'stack nil)
    3512              (emit-invokevirtual +lisp-object-class+ "eql"
     3507             (emit-invokevirtual +lisp-object+ "eql"
    35133508                                 (lisp-object-arg-types 1) "Z")
    35143509             'ifeq)))))
     
    35253520       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35263521              arg2 'stack :int)
    3527              (emit-invokevirtual +lisp-object-class+
     3522             (emit-invokevirtual +lisp-object+
    35283523                                 translated-op
    35293524                                 '("I") "Z"))
     
    35313526       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35323527              arg2 'stack nil)
    3533              (emit-invokevirtual +lisp-object-class+
     3528             (emit-invokevirtual +lisp-object+
    35343529                                 translated-op
    35353530                                 (lisp-object-arg-types 1) "Z")))
     
    35423537      (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35433538             arg2 'stack nil)
    3544       (emit-invokevirtual +lisp-object-class+ "typep"
     3539      (emit-invokevirtual +lisp-object+ "typep"
    35453540                          (lisp-object-arg-types 1) +lisp-object+)
    35463541      (emit-push-nil)
     
    35833578       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35843579              arg2 'stack :int)
    3585              (emit-invokevirtual +lisp-object-class+ "isNotEqualTo" '("I") "Z")
     3580             (emit-invokevirtual +lisp-object+ "isNotEqualTo" '("I") "Z")
    35863581             'ifeq)
    35873582            ((fixnum-type-p type1)
     
    35913586              arg2 'stack nil)
    35923587             (emit 'swap)
    3593              (emit-invokevirtual +lisp-object-class+ "isNotEqualTo" '("I") "Z")
     3588             (emit-invokevirtual +lisp-object+ "isNotEqualTo" '("I") "Z")
    35943589             'ifeq)
    35953590            (t
    35963591       (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    35973592              arg2 'stack nil)
    3598              (emit-invokevirtual +lisp-object-class+ "isNotEqualTo"
     3593             (emit-invokevirtual +lisp-object+ "isNotEqualTo"
    35993594                                 (lisp-object-arg-types 1) "Z")
    36003595             'ifeq)))))
     
    36333628         (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    36343629                arg2 'stack :int)
    3635                (emit-invokevirtual +lisp-object-class+
     3630               (emit-invokevirtual +lisp-object+
    36363631                                   (ecase op
    36373632                                     (<  "isLessThan")
     
    36483643                arg2 'stack nil)
    36493644               (emit 'swap)
    3650                (emit-invokevirtual +lisp-object-class+
     3645               (emit-invokevirtual +lisp-object+
    36513646                                   (ecase op
    36523647                                     (<  "isGreaterThan")
     
    36603655         (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    36613656                arg2 'stack nil)
    3662                (emit-invokevirtual +lisp-object-class+
     3657               (emit-invokevirtual +lisp-object+
    36633658                                   (ecase op
    36643659                                     (<  "isLessThan")
     
    38413836     (emit-invokestatic +lisp+ "coerceToFunction"
    38423837                        (lisp-object-arg-types 1) +lisp-object+)
    3843      (emit-invokevirtual +lisp-object-class+ "execute" nil +lisp-object+))
     3838     (emit-invokevirtual +lisp-object+ "execute" nil +lisp-object+))
    38443839    (3
    38453840     (let* ((*register* *register*)
     
    38753870       (aload function-register)
    38763871       (aload values-register)
    3877        (emit-invokevirtual +lisp-object-class+ "dispatch"
     3872       (emit-invokevirtual +lisp-object+ "dispatch"
    38783873                           (list +lisp-object-array+) +lisp-object+))))
    38793874  (fix-boxing representation nil)
     
    44594454      ;; we have a block variable; that should be a closure variable
    44604455      (assert (not (null (variable-closure-index (tagbody-id-variable block)))))
    4461       (emit 'new +lisp-object-class+)
     4456      (emit 'new +lisp-object+)
    44624457      (emit 'dup)
    4463       (emit-invokespecial-init +lisp-object-class+ '())
     4458      (emit-invokespecial-init +lisp-object+ '())
    44644459      (emit-new-closure-binding (tagbody-id-variable block)))
    44654460    (label BEGIN-BLOCK)
     
    46574652      ;; we have a block variable; that should be a closure variable
    46584653      (assert (not (null (variable-closure-index (block-id-variable block)))))
    4659       (emit 'new +lisp-object-class+)
     4654      (emit 'new +lisp-object+)
    46604655      (emit 'dup)
    4661       (emit-invokespecial-init +lisp-object-class+ '())
     4656      (emit-invokespecial-init +lisp-object+ '())
    46624657      (emit-new-closure-binding (block-id-variable block)))
    46634658    (dformat t "*all-variables* = ~S~%"
     
    48454840      (emit 'dup))
    48464841    (compile-form (second args) 'stack nil)
    4847     (emit-invokevirtual +lisp-object-class+
     4842    (emit-invokevirtual +lisp-object+
    48484843                        "setCdr"
    48494844                        (lisp-object-arg-types 1)
     
    48614856    (when target
    48624857      (emit-dup nil :past nil))
    4863     (emit-invokevirtual +lisp-object-class+
     4858    (emit-invokevirtual +lisp-object+
    48644859                        (if (eq op 'sys:set-car) "setCar" "setCdr")
    48654860                        (lisp-object-arg-types 1)
     
    50645059         (t
    50655060          (emit-load-externalized-object name)
    5066           (emit-invokevirtual +lisp-object-class+ "getSymbolFunctionOrDie"
     5061          (emit-invokevirtual +lisp-object+ "getSymbolFunctionOrDie"
    50675062                              nil +lisp-object+)
    50685063          (emit-move-from-stack target))))
     
    51985193      (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    51995194                   arg2 'stack :int)
    5200                   (emit-invokevirtual +lisp-object-class+ "ash" '("I") +lisp-object+)
     5195                  (emit-invokevirtual +lisp-object+ "ash" '("I") +lisp-object+)
    52015196                  (fix-boxing representation result-type)))
    52025197           (emit-move-from-stack target representation))
     
    52625257    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    52635258                 arg2 'stack :int)
    5264                 (emit-invokevirtual +lisp-object-class+ "LOGAND" '("I") +lisp-object+)
     5259                (emit-invokevirtual +lisp-object+ "LOGAND" '("I") +lisp-object+)
    52655260                (fix-boxing representation result-type)
    52665261                (emit-move-from-stack target representation))
     
    52715266                ;; swap args
    52725267                (emit 'swap)
    5273                 (emit-invokevirtual +lisp-object-class+ "LOGAND" '("I") +lisp-object+)
     5268                (emit-invokevirtual +lisp-object+ "LOGAND" '("I") +lisp-object+)
    52745269                (fix-boxing representation result-type)
    52755270                (emit-move-from-stack target representation))
     
    52775272    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    52785273                 arg2 'stack nil)
    5279                 (emit-invokevirtual +lisp-object-class+ "LOGAND"
     5274                (emit-invokevirtual +lisp-object+ "LOGAND"
    52805275                                    (lisp-object-arg-types 1) +lisp-object+)
    52815276                (fix-boxing representation result-type)
     
    53345329    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    53355330                 arg2 'stack :int)
    5336                 (emit-invokevirtual +lisp-object-class+ "LOGIOR" '("I") +lisp-object+)
     5331                (emit-invokevirtual +lisp-object+ "LOGIOR" '("I") +lisp-object+)
    53375332                (fix-boxing representation result-type)
    53385333                (emit-move-from-stack target representation))
     
    53435338                ;; swap args
    53445339                (emit 'swap)
    5345                 (emit-invokevirtual +lisp-object-class+ "LOGIOR" '("I") +lisp-object+)
     5340                (emit-invokevirtual +lisp-object+ "LOGIOR" '("I") +lisp-object+)
    53465341                (fix-boxing representation result-type)
    53475342                (emit-move-from-stack target representation))
     
    53495344    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    53505345                 arg2 'stack nil)
    5351                 (emit-invokevirtual +lisp-object-class+ "LOGIOR"
     5346                (emit-invokevirtual +lisp-object+ "LOGIOR"
    53525347                                    (lisp-object-arg-types 1) +lisp-object+)
    53535348                (fix-boxing representation result-type)
     
    53985393    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    53995394                 arg2 'stack :int)
    5400                 (emit-invokevirtual +lisp-object-class+ "LOGXOR" '("I") +lisp-object+)
     5395                (emit-invokevirtual +lisp-object+ "LOGXOR" '("I") +lisp-object+)
    54015396                (fix-boxing representation result-type))
    54025397               (t
    54035398    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    54045399                 arg2 'stack nil)
    5405                 (emit-invokevirtual +lisp-object-class+ "LOGXOR"
     5400                (emit-invokevirtual +lisp-object+ "LOGXOR"
    54065401                                    (lisp-object-arg-types 1) +lisp-object+)
    54075402                (fix-boxing representation result-type)))
     
    54255420         (let ((arg (%cadr form)))
    54265421     (compile-forms-and-maybe-emit-clear-values arg 'stack nil))
    5427          (emit-invokevirtual +lisp-object-class+ "LOGNOT" nil +lisp-object+)
     5422         (emit-invokevirtual +lisp-object+ "LOGNOT" nil +lisp-object+)
    54285423         (fix-boxing representation nil)
    54295424         (emit-move-from-stack target representation))))
     
    54825477                  (emit-push-constant-int size)
    54835478                  (emit-push-constant-int position)
    5484                   (emit-invokevirtual +lisp-object-class+ "LDB" '("I" "I") +lisp-object+)
     5479                  (emit-invokevirtual +lisp-object+ "LDB" '("I" "I") +lisp-object+)
    54855480                  (fix-boxing representation nil)
    54865481                  (emit-move-from-stack target representation))))
     
    54925487           (emit 'dup_x2) ;; use not supported by emit-dup: 3 values involved
    54935488           (emit 'pop)
    5494            (emit-invokevirtual +lisp-object-class+ "LDB" '("I" "I") +lisp-object+)
     5489           (emit-invokevirtual +lisp-object+ "LDB" '("I" "I") +lisp-object+)
    54955490           (fix-boxing representation nil)
    54965491           (emit-move-from-stack target representation))
     
    55165511     (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    55175512                  arg2 'stack :int)
    5518            (emit-invokevirtual +lisp-object-class+ "MOD" '("I") +lisp-object+)
     5513           (emit-invokevirtual +lisp-object+ "MOD" '("I") +lisp-object+)
    55195514           (fix-boxing representation nil) ; FIXME use derived result type
    55205515           (emit-move-from-stack target representation))
     
    55225517     (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    55235518                  arg2 'stack nil)
    5524            (emit-invokevirtual +lisp-object-class+ "MOD"
     5519           (emit-invokevirtual +lisp-object+ "MOD"
    55255520                               (lisp-object-arg-types 1) +lisp-object+)
    55265521           (fix-boxing representation nil) ; FIXME use derived result type
     
    56175612       (emit 'swap)
    56185613       (cond (target
    5619               (emit-invokevirtual +lisp-object-class+ "VECTOR_PUSH_EXTEND"
     5614              (emit-invokevirtual +lisp-object+ "VECTOR_PUSH_EXTEND"
    56205615                                  (lisp-object-arg-types 1) +lisp-object+)
    56215616              (fix-boxing representation nil)
    56225617              (emit-move-from-stack target representation))
    56235618             (t
    5624               (emit-invokevirtual +lisp-object-class+ "vectorPushExtend"
     5619              (emit-invokevirtual +lisp-object+ "vectorPushExtend"
    56255620                                  (lisp-object-arg-types 1) nil))))
    56265621      (t
     
    56355630    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    56365631                 arg2 'stack nil)
    5637     (emit-invokevirtual +lisp-object-class+ "SLOT_VALUE"
     5632    (emit-invokevirtual +lisp-object+ "SLOT_VALUE"
    56385633                        (lisp-object-arg-types 1) +lisp-object+)
    56395634    (fix-boxing representation nil)
     
    56565651      (emit 'dup)
    56575652      (astore value-register))
    5658     (emit-invokevirtual +lisp-object-class+ "setSlotValue"
     5653    (emit-invokevirtual +lisp-object+ "setSlotValue"
    56595654                        (lisp-object-arg-types 2) nil)
    56605655    (when value-register
     
    57325727         (compile-form (%caddr form) 'stack nil)
    57335728         (maybe-emit-clear-values (%cadr form) (%caddr form))
    5734          (emit-invokevirtual +lisp-object-class+ "copyToArray"
     5729         (emit-invokevirtual +lisp-object+ "copyToArray"
    57355730                             nil +lisp-object-array+)
    57365731         (emit-invokespecial-init +lisp-structure-object+
     
    64046399    (ecase representation
    64056400      (:int
    6406        (emit-invokevirtual +lisp-object-class+ "length" nil "I"))
     6401       (emit-invokevirtual +lisp-object+ "length" nil "I"))
    64076402      ((:long :float :double)
    6408        (emit-invokevirtual +lisp-object-class+ "length" nil "I")
     6403       (emit-invokevirtual +lisp-object+ "length" nil "I")
    64096404       (convert-representation :int representation))
    64106405      (:boolean
    64116406       ;; FIXME We could optimize this all away in unsafe calls.
    6412        (emit-invokevirtual +lisp-object-class+ "length" nil "I")
     6407       (emit-invokevirtual +lisp-object+ "length" nil "I")
    64136408       (emit 'pop)
    64146409       (emit 'iconst_1))
     
    64176412       (aver nil))
    64186413      ((nil)
    6419        (emit-invokevirtual +lisp-object-class+ "LENGTH" nil +lisp-object+)))
     6414       (emit-invokevirtual +lisp-object+ "LENGTH" nil +lisp-object+)))
    64206415    (emit-move-from-stack target representation)))
    64216416
     
    64676462                 list-form 'stack nil)
    64686463    (emit 'swap)
    6469     (emit-invokevirtual +lisp-object-class+ "NTH" '("I") +lisp-object+)
     6464    (emit-invokevirtual +lisp-object+ "NTH" '("I") +lisp-object+)
    64706465    (fix-boxing representation nil) ; FIXME use derived result type
    64716466    (emit-move-from-stack target representation)))
     
    65066501        (compile-forms-and-maybe-emit-clear-values arg1 'stack nil)
    65076502              (emit-push-int arg2)
    6508               (emit-invokevirtual +lisp-object-class+ "multiplyBy" '("I") +lisp-object+)
     6503              (emit-invokevirtual +lisp-object+ "multiplyBy" '("I") +lisp-object+)
    65096504              (fix-boxing representation result-type)
    65106505              (emit-move-from-stack target representation))
     
    65566551                  (compile-form arg2 'stack nil)
    65576552                  (emit-dup nil :past nil)
    6558                   (emit-invokevirtual +lisp-object-class+
     6553                  (emit-invokevirtual +lisp-object+
    65596554                                      (if (eq op 'max)
    65606555                                          "isLessThanOrEqualTo"
     
    66246619              (when (fixnum-type-p type1)
    66256620                (emit 'swap))
    6626               (emit-invokevirtual +lisp-object-class+ "add"
     6621              (emit-invokevirtual +lisp-object+ "add"
    66276622                                  '("I") +lisp-object+)
    66286623              (fix-boxing representation result-type)
     
    66636658             (t
    66646659        (compile-forms-and-maybe-emit-clear-values arg 'stack nil)
    6665               (emit-invokevirtual +lisp-object-class+ "negate"
     6660              (emit-invokevirtual +lisp-object+ "negate"
    66666661                                  nil +lisp-object+)
    66676662              (fix-boxing representation nil)
     
    66956690                    arg1 'stack nil
    66966691                    arg2 'stack :int)
    6697               (emit-invokevirtual +lisp-object-class+
     6692              (emit-invokevirtual +lisp-object+
    66986693                                  "subtract"
    66996694                                  '("I") +lisp-object+)
     
    67396734     (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    67406735                  arg2 'stack :int)
    6741            (emit-invokevirtual +lisp-object-class+
     6736           (emit-invokevirtual +lisp-object+
    67426737                               (symbol-name op) ;; "CHAR" or "SCHAR"
    67436738                               '("I") +lisp-object+)
     
    67946789     (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    67956790                  arg2 'stack :int)
    6796            (emit-invokevirtual +lisp-object-class+ "SVREF" '("I") +lisp-object+)
     6791           (emit-invokevirtual +lisp-object+ "SVREF" '("I") +lisp-object+)
    67976792           (fix-boxing representation nil)
    67986793           (emit-move-from-stack target representation)))
     
    68146809             (emit-move-from-stack value-register nil))
    68156810           (maybe-emit-clear-values arg1 arg2 arg3)
    6816            (emit-invokevirtual +lisp-object-class+ "svset" (list "I" +lisp-object+) nil)
     6811           (emit-invokevirtual +lisp-object+ "svset" (list "I" +lisp-object+) nil)
    68176812           (when value-register
    68186813             (aload value-register)
     
    68396834    (compile-form arg1 'stack nil)
    68406835    (compile-form arg2 'stack nil)
    6841     (emit-invokevirtual +lisp-object-class+ "truncate" (lisp-object-arg-types 1) +lisp-object+)
     6836    (emit-invokevirtual +lisp-object+ "truncate" (lisp-object-arg-types 1) +lisp-object+)
    68426837    (fix-boxing representation nil) ; FIXME use derived result type
    68436838    (emit-move-from-stack target representation)))
     
    68496844         (compile-form (second form) 'stack nil)
    68506845         (compile-form (third form) 'stack :int)
    6851          (emit-invokevirtual +lisp-object-class+ "elt" '("I") +lisp-object+)
     6846         (emit-invokevirtual +lisp-object+ "elt" '("I") +lisp-object+)
    68526847         (fix-boxing representation nil) ; FIXME use derived result type
    68536848         (emit-move-from-stack target representation))
     
    68666861    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    68676862                 arg2 'stack :int)
    6868           (emit-invokevirtual +lisp-object-class+ "aref" '("I") "I"))
     6863          (emit-invokevirtual +lisp-object+ "aref" '("I") "I"))
    68696864         (:long
    68706865    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    68716866                 arg2 'stack :int)
    6872           (emit-invokevirtual +lisp-object-class+ "aref_long" '("I") "J"))
     6867          (emit-invokevirtual +lisp-object+ "aref_long" '("I") "J"))
    68736868         (:char
    68746869          (cond ((compiler-subtypep type1 'string)
     
    68826877     (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    68836878                  arg2 'stack :int)
    6884                  (emit-invokevirtual +lisp-object-class+ "AREF" '("I") +lisp-object+)
     6879                 (emit-invokevirtual +lisp-object+ "AREF" '("I") +lisp-object+)
    68856880                 (emit-unbox-character))))
    68866881         ((nil :float :double :boolean)
     
    68896884    (compile-forms-and-maybe-emit-clear-values arg1 'stack nil
    68906885                 arg2 'stack :int)
    6891           (emit-invokevirtual +lisp-object-class+ "AREF" '("I") +lisp-object+)
     6886          (emit-invokevirtual +lisp-object+ "AREF" '("I") +lisp-object+)
    68926887          (convert-representation nil representation)))
    68936888       (emit-move-from-stack target representation)))
     
    69226917           (maybe-emit-clear-values arg1 arg2 arg3)
    69236918           (cond ((fixnum-type-p type3)
    6924                   (emit-invokevirtual +lisp-object-class+ "aset" '("I" "I") nil))
     6919                  (emit-invokevirtual +lisp-object+ "aset" '("I" "I") nil))
    69256920                 (t
    6926                   (emit-invokevirtual +lisp-object-class+ "aset" (list "I" +lisp-object+) nil)))
     6921                  (emit-invokevirtual +lisp-object+ "aset" (list "I" +lisp-object+) nil)))
    69276922           (when value-register
    69286923             (cond ((fixnum-type-p type3)
     
    69476942           (case arg2
    69486943             (0
    6949               (emit-invokevirtual +lisp-object-class+ "getSlotValue_0"
     6944              (emit-invokevirtual +lisp-object+ "getSlotValue_0"
    69506945                                  nil +lisp-object+))
    69516946             (1
    6952               (emit-invokevirtual +lisp-object-class+ "getSlotValue_1"
     6947              (emit-invokevirtual +lisp-object+ "getSlotValue_1"
    69536948                                  nil +lisp-object+))
    69546949             (2
    6955               (emit-invokevirtual +lisp-object-class+ "getSlotValue_2"
     6950              (emit-invokevirtual +lisp-object+ "getSlotValue_2"
    69566951                                  nil +lisp-object+))
    69576952             (3
    6958               (emit-invokevirtual +lisp-object-class+ "getSlotValue_3"
     6953              (emit-invokevirtual +lisp-object+ "getSlotValue_3"
    69596954                                  nil +lisp-object+))
    69606955             (t
    69616956              (emit-push-constant-int arg2)
    6962               (emit-invokevirtual +lisp-object-class+ "getSlotValue"
     6957              (emit-invokevirtual +lisp-object+ "getSlotValue"
    69636958                                  '("I") +lisp-object+)))
    69646959           (emit-move-from-stack target representation))
     
    69686963           (ecase representation
    69696964             (:int
    6970               (emit-invokevirtual +lisp-object-class+ "getFixnumSlotValue"
     6965              (emit-invokevirtual +lisp-object+ "getFixnumSlotValue"
    69716966                                  '("I") "I"))
    69726967             ((nil :char :long :float :double)
    6973               (emit-invokevirtual +lisp-object-class+ "getSlotValue"
     6968              (emit-invokevirtual +lisp-object+ "getSlotValue"
    69746969                                  '("I") +lisp-object+)
    69756970              ;; (convert-representation NIL NIL) is a no-op
    69766971              (convert-representation nil representation))
    69776972             (:boolean
    6978               (emit-invokevirtual +lisp-object-class+ "getSlotValueAsBoolean"
     6973              (emit-invokevirtual +lisp-object+ "getSlotValueAsBoolean"
    69796974                                  '("I") "Z")))
    69806975           (emit-move-from-stack target representation))
     
    69986993              (emit 'dup)
    69996994              (astore value-register))
    7000             (emit-invokevirtual +lisp-object-class+
     6995            (emit-invokevirtual +lisp-object+
    70016996                                (format nil "setSlotValue_~D" arg2)
    70026997                                (lisp-object-arg-types 1) nil)
     
    70157010              (emit 'dup)
    70167011              (astore value-register))
    7017             (emit-invokevirtual +lisp-object-class+ "setSlotValue"
     7012            (emit-invokevirtual +lisp-object+ "setSlotValue"
    70187013                                (list "I" +lisp-object+) nil)
    70197014            (when value-register
     
    70817076                  arg2 'stack nil)
    70827077           (emit 'swap)
    7083            (emit-invokevirtual +lisp-object-class+ "nthcdr" '("I") +lisp-object+)
     7078           (emit-invokevirtual +lisp-object+ "nthcdr" '("I") +lisp-object+)
    70847079           (fix-boxing representation nil)
    70857080           (emit-move-from-stack target representation))
     
    73967391         (let ((arg (%cadr form)))
    73977392     (compile-forms-and-maybe-emit-clear-values arg 'stack nil)
    7398            (emit-invokevirtual +lisp-object-class+ "sxhash" nil "I")
     7393           (emit-invokevirtual +lisp-object+ "sxhash" nil "I")
    73997394           (convert-representation :int representation)
    74007395           (emit-move-from-stack target representation)))
     
    76177612         (EXIT (gensym)))
    76187613    (compile-form (cadr form) 'stack nil)
    7619     (emit-invokevirtual +lisp-object-class+ "lockableInstance" nil
     7614    (emit-invokevirtual +lisp-object+ "lockableInstance" nil
    76207615                        +java-object+) ; value to synchronize
    76217616    (emit 'dup)
  • branches/generic-class-file/abcl/src/org/armedbear/lisp/jvm-class-file.lisp

    r12790 r12791  
    105105(define-class-name +java-object+ "java.lang.Object")
    106106(define-class-name +java-string+ "java.lang.String")
    107 (define-class-name +!lisp-object+ "org.armedbear.lisp.LispObject")
     107(define-class-name +lisp-object+ "org.armedbear.lisp.LispObject")
    108108(define-class-name +lisp-simple-string+ "org.armedbear.lisp.SimpleString")
    109109(define-class-name +lisp+ "org.armedbear.lisp.Lisp")
Note: See TracChangeset for help on using the changeset viewer.