/[cmucl]/src/pcl/pkg.lisp
ViewVC logotype

Diff of /src/pcl/pkg.lisp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.9.1.3 by ram, Fri Oct 28 20:39:04 1994 UTC revision 1.30 by rtoy, Fri Mar 19 15:19:03 2010 UTC
# Line 25  Line 25 
25  ;;; *************************************************************************  ;;; *************************************************************************
26  ;;;  ;;;
27    
28  (in-package ':walker :use '(:lisp))  (ext:file-comment
29      "$Header$")
30    
31  (export '(define-walker-template  (intl:textdomain "cmucl")
           walk-form  
           walk-form-expand-macros-p  
           nested-walk-form  
           variable-lexical-p  
           variable-special-p  
           variable-globally-special-p  
           *variable-declarations*  
           variable-declaration  
           macroexpand-all  
           ))  
32    
 (in-package :iterate :use '(:lisp :walker))  
   
 (export '(iterate iterate* gathering gather with-gathering interval elements  
           list-elements list-tails plist-elements eachtime while until  
           collecting joining maximizing minimizing summing  
           *iterate-warnings*))  
   
 (in-package :pcl :use '(:lisp :walker :iterate))  
   
 ;;;  
 ;;; Some CommonLisps have more symbols in the Lisp package than the ones that  
 ;;; are explicitly specified in CLtL.  This causes trouble. Any Lisp that has  
 ;;; extra symbols in the Lisp package should shadow those symbols in the PCL  
 ;;; package.  
33  ;;;  ;;;
34  #+TI  ;;; CMUCL 18a: Jan-1998 -- Changing to DEFPACKAGE.
 (shadow '(string-append once-only destructuring-bind  
           memq assq delq neq true false  
           without-interrupts  
           defmethod)  
         *the-pcl-package*)  
   
 #+CMU  
 (shadow '(destructuring-bind)  
         *the-pcl-package*)  
 #+cmu17  
 (shadow '(find-class class-name class-of  
                      class built-in-class structure-class  
                      standard-class)  
         *the-pcl-package*)  
   
 #+GCLisp  
 (shadow '(string-append memq assq delq neq make-instance)  
         *the-pcl-package*)  
   
 #+Genera  
 (shadowing-import '(zl:arglist zwei:indentation) *the-pcl-package*)  
35    
36  #+Lucid  (defpackage "WALKER" (:use :common-lisp :ext)
37  (import '(#-LCL3.0 system:arglist #+LCL3.0 lcl:arglist    (:export "DEFINE-WALKER-TEMPLATE"
38            system:structurep system:structure-type system:structure-length)             "WALK-FORM"
39          *the-pcl-package*)             "WALK-FORM-EXPAND-MACROS-P"
40               "NESTED-WALK-FORM"
41  #+lucid             "VARIABLE-LEXICAL-P"
42  (#-LCL3.0 progn #+LCL3.0 lcl:handler-bind             "VARIABLE-SPECIAL-P"
43      #+LCL3.0 ((lcl:warning #'(lambda (condition)             "VARIABLE-GLOBALLY-SPECIAL-P"
44                                 (declare (ignore condition))             "*VARIABLE-DECLARATIONS*"
45                                 (lcl:muffle-warning))))             "VARIABLE-DECLARATION"
46  (let ((importer             "MACROEXPAND-ALL"))
47          #+LCL3.0 #'sys:import-from-lucid-pkg  
48          #-LCL3.0 (let ((x (find-symbol "IMPORT-FROM-LUCID-PKG" "LUCID")))  (defpackage "PCL"
49                     (if (and x (fboundp x))    (:use :common-lisp :walker :ext)
50                         (symbol-function x)    (:import-from :kernel "FUNCALLABLE-INSTANCE-P" "SIMPLE-PROGRAM-ERROR")
51                         ;; Only the #'(lambda (x) ...) below is really needed,    (:shadow "DOCUMENTATION")
52                         ;;  but when available, the "internal" function    (:export "ADD-METHOD"
53                         ;;  'import-from-lucid-pkg' provides better checking.             "BUILT-IN-CLASS"
54                         #'(lambda (name)             "CALL-METHOD"
55                             (import (intern name "LUCID")))))))             "CALL-NEXT-METHOD"
56    ;;             "CHANGE-CLASS"
57    ;; We need the following "internal", undocumented Lucid goodies:             "CLASS-NAME"
58    (mapc importer '("%POINTER" "DEFSTRUCT-SIMPLE-PREDICATE"             "CLASS-OF"
59                     #-LCL3.0 "LOGAND&" "%LOGAND&" #+VAX "LOGAND&-VARIABLE"))             "COMPUTE-APPLICABLE-METHODS"
60               "DEFCLASS"
61    ;;             "DEFGENERIC"
62    ;; For without-interrupts.             "DEFINE-METHOD-COMBINATION"
63    ;;             "DEFMETHOD"
64    #+LCL3.0             "DESCRIBE-OBJECT"
65    (mapc importer '("*SCHEDULER-WAKEUP*" "MAYBE-CALL-SCHEDULER"))             "ENSURE-GENERIC-FUNCTION"
66               "FIND-CLASS"
67               "FIND-METHOD"
68               "FUNCTION-KEYWORDS"
69               "INITIALIZE-INSTANCE"
70               "INVALID-METHOD-ERROR"
71               "MAKE-INSTANCE"
72               "MAKE-INSTANCES-OBSOLETE"
73               "METHOD-COMBINATION-ERROR"
74               "METHOD-QUALIFIERS"
75               "NEXT-METHOD-P"
76               "NO-APPLICABLE-METHOD"
77               "NO-NEXT-METHOD"
78               "PRINT-OBJECT"
79               "REINITIALIZE-INSTANCE"
80               "REMOVE-METHOD"
81               "SHARED-INITIALIZE"
82               "SLOT-BOUNDP"
83               "SLOT-EXISTS-P"
84               "SLOT-MAKUNBOUND"
85               "SLOT-MISSING"
86               "SLOT-UNBOUND"
87               "SLOT-VALUE"
88               "STANDARD"
89               "STANDARD-GENERIC-FUNCTION"
90               "STANDARD-METHOD"
91               "STANDARD-OBJECT"
92               "UPDATE-INSTANCE-FOR-DIFFERENT-CLASS"
93               "UPDATE-INSTANCE-FOR-REDEFINED-CLASS"
94               "WITH-ACCESSORS"
95               "WITH-SLOTS"
96               )
97    
98      (:export "SEAL" "UNSEAL" "SEALED-ERROR"
99               "*MAX-EMF-PRECOMPUTATION-METHODS*")
100    
101      ;; Function names.
102      (:export "EFFECTIVE-METHOD" "FAST-METHOD" "SLOT-ACCESSOR"
103               "CLASS-PREDICATE")
104    
105    ;;    (:export "FLUSH-EMF-CACHE" "NO-PRIMARY-METHOD"
106    ;; We import the following symbols, because in 2.1 Lisps they have to be             "NO-PRIMARY-METHOD-ERROR")
   ;;  accessed as SYS:<foo>, whereas in 3.0 lisps, they are homed in the  
   ;;  LUCID-COMMON-LISP package.  
   (mapc importer '("ARGLIST" "NAMED-LAMBDA" "*PRINT-STRUCTURE*"))  
   ;;  
   ;; We import the following symbols, because in 2.1 Lisps they have to be  
   ;;  accessed as LUCID::<foo>, whereas in 3.0 lisps, they have to be  
   ;;  accessed as SYS:<foo>  
   (mapc importer '(  
                    "NEW-STRUCTURE"      "STRUCTURE-REF"  
                    "STRUCTUREP"         "STRUCTURE-TYPE"  "STRUCTURE-LENGTH"  
                    "PROCEDUREP"         "PROCEDURE-SYMBOL"  
                    "PROCEDURE-REF"      "SET-PROCEDURE-REF"  
                    ))  
 ; ;;  
 ; ;;  The following is for the "patch" to the general defstruct printer.  
 ; (mapc importer '(  
 ;                  "OUTPUT-STRUCTURE"     "DEFSTRUCT-INFO"  
 ;                  "OUTPUT-TERSE-OBJECT"  "DEFAULT-STRUCTURE-PRINT"  
 ;                  "STRUCTURE-TYPE"       "*PRINT-OUTPUT*"  
 ;                  ))  
   ;;  
   ;; The following is for a "patch" affecting compilation of %logand&.  
   ;; On APOLLO, Domain/CommonLISP 2.10 does not include %logand& whereas  
   ;; Domain/CommonLISP 2.20 does; Domain/CommonLISP 2.20 includes :DOMAIN/OS  
   ;; on *FEATURES*, so this conditionalizes correctly for APOLLO.  
   #-(or (and APOLLO DOMAIN/OS) LCL3.0 VAX)  
   (mapc importer '("COPY-STRUCTURE"  "GET-FDESC"  "SET-FDESC"))  
107    
108    nil))    (:export "STANDARD-INSTANCE"
109               "FUNCALLABLE-STANDARD-INSTANCE"
110  #+kcl             "GENERIC-FUNCTION"
111  (progn             "STANDARD-GENERIC-FUNCTION"
112  (import '(si:structurep si:structure-def si:structure-ref))             "METHOD"
113  (shadow 'lisp:dotimes)             "STANDARD-METHOD"
114  )             "STANDARD-ACCESSOR-METHOD"
115  #+kcl             "STANDARD-READER-METHOD"
116  (in-package "SI")             "STANDARD-WRITER-METHOD"
117  #+kcl             "METHOD-COMBINATION"
118  (export '(%structure-name             "SLOT-DEFINITION"
119            %compiled-function-name             "DIRECT-SLOT-DEFINITION"
120            %set-compiled-function-name             "EFFECTIVE-SLOT-DEFINITION"
121            %instance-ref             "STANDARD-SLOT-DEFINITION"
122            %set-instance-ref))             "STANDARD-DIRECT-SLOT-DEFINITION"
123  #+kcl             "STANDARD-EFFECTIVE-SLOT-DEFINITION"
124  (in-package 'pcl)             "SPECIALIZER"
125               "EQL-SPECIALIZER"
126  #+cmu (shadow 'lisp:dotimes)             "FORWARD-REFERENCED-CLASS"
127               "FUNCALLABLE-STANDARD-CLASS"
128               "FUNCALLABLE-STANDARD-OBJECT"
129               "METAOBJECT")
130    
131      ;;*chapter-6-exports*
132      (:export "ADD-DEPENDENT"
133               "ADD-DIRECT-METHOD"
134               "ADD-DIRECT-SUBCLASS"
135               "ADD-METHOD"
136               "ALLOCATE-INSTANCE"
137               "CLASS-DEFAULT-INITARGS"
138               "CLASS-DIRECT-DEFAULT-INITARGS"
139               "CLASS-DIRECT-SLOTS"
140               "CLASS-DIRECT-SUBCLASSES"
141               "CLASS-DIRECT-SUPERCLASSES"
142               "CLASS-FINALIZED-P"
143               "CLASS-PRECEDENCE-LIST"
144               "CLASS-PROTOTYPE"
145               "CLASS-SLOTS"
146               "COMPUTE-APPLICABLE-METHODS"
147               "COMPUTE-APPLICABLE-METHODS-USING-CLASSES"
148               "COMPUTE-CLASS-PRECEDENCE-LIST"
149               "COMPUTE-DISCRIMINATING-FUNCTION"
150               "COMPUTE-DEFAULT-INITARGS"
151               "COMPUTE-EFFECTIVE-METHOD"
152               "COMPUTE-EFFECTIVE-SLOT-DEFINITION"
153               "COMPUTE-SLOTS"
154               "DIRECT-SLOT-DEFINITION-CLASS"
155               "EFFECTIVE-SLOT-DEFINITION-CLASS"
156               "ENSURE-CLASS"
157               "ENSURE-CLASS-USING-CLASS"
158               "ENSURE-GENERIC-FUNCTION"
159               "ENSURE-GENERIC-FUNCTION-USING-CLASS"
160               "EQL-SPECIALIZER-OBJECT"
161               "EXTRACT-LAMBDA-LIST"
162               "EXTRACT-SPECIALIZER-NAMES"
163               "FINALIZE-INHERITANCE"
164               "FIND-METHOD-COMBINATION"
165               "FUNCALLABLE-STANDARD-INSTANCE-ACCESS"
166               "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER"
167               "GENERIC-FUNCTION-DECLARATIONS"
168               "GENERIC-FUNCTION-LAMBDA-LIST"
169               "GENERIC-FUNCTION-METHOD-CLASS"
170               "GENERIC-FUNCTION-METHOD-COMBINATION"
171               "GENERIC-FUNCTION-METHODS"
172               "GENERIC-FUNCTION-NAME"
173               "INTERN-EQL-SPECIALIZER"
174               "MAKE-INSTANCE"
175               "MAKE-METHOD-LAMBDA"
176               "MAP-DEPENDENTS"
177               "METHOD-FUNCTION"
178               "METHOD-GENERIC-FUNCTION"
179               "METHOD-LAMBDA-LIST"
180               "METHOD-SPECIALIZERS"
181               "METHOD-QUALIFIERS"
182               "ACCESSOR-METHOD-SLOT-DEFINITION"
183               "READER-METHOD-CLASS"
184               "REMOVE-DEPENDENT"
185               "REMOVE-DIRECT-METHOD"
186               "REMOVE-DIRECT-SUBCLASS"
187               "REMOVE-METHOD"
188               "SET-FUNCALLABLE-INSTANCE-FUNCTION"
189               "SLOT-BOUNDP-USING-CLASS"
190               "SLOT-DEFINITION-ALLOCATION"
191               "SLOT-DEFINITION-INITARGS"
192               "SLOT-DEFINITION-INITFORM"
193               "SLOT-DEFINITION-INITFUNCTION"
194               "SLOT-DEFINITION-LOCATION"
195               "SLOT-DEFINITION-NAME"
196               "SLOT-DEFINITION-READERS"
197               "SLOT-DEFINITION-WRITERS"
198               "SLOT-DEFINITION-TYPE"
199               "SLOT-MAKUNBOUND-USING-CLASS"
200               "SLOT-VALUE-USING-CLASS"
201               "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS"
202               "SPECIALIZER-DIRECT-METHODS"
203               "STANDARD-INSTANCE-ACCESS"
204               "UPDATE-DEPENDENT"
205               "VALIDATE-SUPERCLASS"
206               "WRITER-METHOD-CLASS"))
207    
 #+cmu  
 (import '(kernel:funcallable-instance-p)  
         *the-pcl-package*)  
   
   
 (shadow 'documentation)  
   
   
 ;;;  
 ;;; These come from the index pages of 88-002R.  
208  ;;;  ;;;
209    ;;; These symbol names came from "The Art of the Metaobject Protocol".
210  ;;;  ;;;
211  (eval-when (compile load eval)  (defpackage "CLOS-MOP"
212      (:use :pcl :common-lisp)
213  (defvar *exports* '(add-method    (:nicknames "MOP")
214                      built-in-class    (:export "ACCESSOR-METHOD-SLOT-DEFINITION"
215                      call-method             "ADD-DEPENDENT"
216                      call-next-method             "ADD-DIRECT-METHOD"
217                      change-class             "ADD-DIRECT-SUBCLASS"
218                      class-name             "ADD-METHOD"
219                      class-of             "ALLOCATE-INSTANCE"
220                      compute-applicable-methods             "CLASS-DEFAULT-INITARGS"
221                      defclass             "CLASS-DIRECT-DEFAULT-INITARGS"
222                      defgeneric             "CLASS-DIRECT-SLOTS"
223                      define-method-combination             "CLASS-DIRECT-SUBCLASSES"
224                      defmethod             "CLASS-DIRECT-SUPERCLASSES"
225                      ensure-generic-function             "CLASS-FINALIZED-P"
226                      find-class             "CLASS-NAME"
227                      find-method             "CLASS-PRECEDENCE-LIST"
228                      function-keywords             "CLASS-PROTOTYPE"
229                      generic-flet             "CLASS-SLOTS"
230                      generic-labels             "COMPUTE-APPLICABLE-METHODS"
231                      initialize-instance             "COMPUTE-APPLICABLE-METHODS-USING-CLASSES"
232                      invalid-method-error             "COMPUTE-CLASS-PRECEDENCE-LIST"
233                      make-instance             "COMPUTE-DEFAULT-INITARGS"
234                      make-instances-obsolete             "COMPUTE-DISCRIMINATING-FUNCTION"
235                      method-combination-error             "COMPUTE-EFFECTIVE-METHOD"
236                      method-qualifiers             "COMPUTE-EFFECTIVE-SLOT-DEFINITION"
237                      next-method-p             "COMPUTE-SLOTS"
238                      no-applicable-method             "DIRECT-SLOT-DEFINITION"
239                      no-next-method             "DIRECT-SLOT-DEFINITION-CLASS"
240                      print-object             "EFFECTIVE-SLOT-DEFINITION"
241                      reinitialize-instance             "EFFECTIVE-SLOT-DEFINITION-CLASS"
242                      remove-method             "ENSURE-CLASS"
243                      shared-initialize             "ENSURE-CLASS-USING-CLASS"
244                      slot-boundp             "ENSURE-GENERIC-FUNCTION"
245                      slot-exists-p             "ENSURE-GENERIC-FUNCTION-USING-CLASS"
246                      slot-makunbound             "EQL-SPECIALIZER"
247                      slot-missing             "EQL-SPECIALIZER-OBJECT"
248                      slot-unbound             "EXTRACT-LAMBDA-LIST"
249                      slot-value             "EXTRACT-SPECIALIZER-NAMES"
250                      standard             "FINALIZE-INHERITANCE"
251                      #-cmu17 standard-class             "FIND-METHOD-COMBINATION"
252                      standard-generic-function             "FORWARD-REFERENCED-CLASS"
253                      standard-method             "FUNCALLABLE-STANDARD-CLASS"
254                      standard-object             "FUNCALLABLE-STANDARD-INSTANCE-ACCESS"
255                      #-cmu17 structure-class             "FUNCALLABLE-STANDARD-OBJECT"
256                      #-cmu17 symbol-macrolet             "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER"
257                      update-instance-for-different-class             "GENERIC-FUNCTION-DECLARATIONS"
258                      update-instance-for-redefined-class             "GENERIC-FUNCTION-LAMBDA-LIST"
259                      with-accessors             "GENERIC-FUNCTION-METHOD-CLASS"
260                      with-added-methods             "GENERIC-FUNCTION-METHOD-COMBINATION"
261                      with-slots             "GENERIC-FUNCTION-METHODS"
262                      ))             "GENERIC-FUNCTION-NAME"
263               "INTERN-EQL-SPECIALIZER"
264  );eval-when             "MAKE-INSTANCE"
265               "MAKE-METHOD-LAMBDA"
266  #-(or KCL IBCL CMU)             "MAP-DEPENDENTS"
267  (export *exports* *the-pcl-package*)             "METAOBJECT"
268               "METHOD-FUNCTION"
269  #+CMU             "METHOD-GENERIC-FUNCTION"
270  (export '#.*exports* *the-pcl-package*)             "METHOD-LAMBDA-LIST"
271               "METHOD-QUALIFIERS"
272  #+(or KCL IBCL)             "METHOD-SPECIALIZERS"
273  (mapc 'export (list *exports*) (list *the-pcl-package*))             "READER-METHOD-CLASS"
274               "REMOVE-DEPENDENT"
275               "REMOVE-DIRECT-METHOD"
276  (eval-when (compile load eval)             "REMOVE-DIRECT-SUBCLASS"
277               "REMOVE-METHOD"
278  (defvar *class-exports*             "SET-FUNCALLABLE-INSTANCE-FUNCTION"
279          '(standard-instance             "SLOT-BOUNDP-USING-CLASS"
280            funcallable-standard-instance             "SLOT-DEFINITION"
281            generic-function             "SLOT-DEFINITION-ALLOCATION"
282            standard-generic-function             "SLOT-DEFINITION-INITARGS"
283            method             "SLOT-DEFINITION-INITFORM"
284            standard-method             "SLOT-DEFINITION-INITFUNCTION"
285            standard-accessor-method             "SLOT-DEFINITION-LOCATION"
286            standard-reader-method             "SLOT-DEFINITION-NAME"
287            standard-writer-method             "SLOT-DEFINITION-READERS"
288            method-combination             "SLOT-DEFINITION-TYPE"
289            slot-definition             "SLOT-DEFINITION-WRITERS"
290            direct-slot-definition             "SLOT-MAKUNBOUND-USING-CLASS"
291            effective-slot-definition             "SLOT-VALUE-USING-CLASS"
292            standard-slot-definition             "SPECIALIZER"
293            standard-direct-slot-definition             "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS"
294            standard-effective-slot-definition             "SPECIALIZER-DIRECT-METHODS"
295            specializer             "STANDARD-ACCESSOR-METHOD"
296            eql-specializer             "STANDARD-DIRECT-SLOT-DEFINITION"
297            #-cmu17 built-in-class             "STANDARD-EFFECTIVE-SLOT-DEFINITION"
298            forward-referenced-class             "STANDARD-GENERIC-FUNCTION"
299            #-cmu17 standard-class             "STANDARD-INSTANCE-ACCESS"
300            funcallable-standard-class))             "STANDARD-METHOD"
301               "STANDARD-READER-METHOD"
302  (defvar *chapter-6-exports*             "STANDARD-SLOT-DEFINITION"
303          '(add-dependent             "STANDARD-WRITER-METHOD"
304            add-direct-method             "UPDATE-DEPENDENT"
305            add-direct-subclass             "VALIDATE-SUPERCLASS"
306            add-method             "WRITER-METHOD-CLASS"))
           allocate-instance  
           class-default-initargs  
           class-direct-default-initargs  
           class-direct-slots  
           class-direct-subclasses  
           class-direct-superclasses  
           class-finalized-p  
           class-precedence-list  
           class-prototype  
           class-slots  
           compute-applicable-methods  
           compute-applicable-methods-using-classes  
           compute-class-precedence-list  
           compute-discriminating-function  
           compute-effective-method  
           compute-effective-slot-definition  
           compute-slots  
           direct-slot-definition-class  
           effective-slot-definition-class  
           ensure-class  
           ensure-class-using-class  
           ensure-generic-function  
           ensure-generic-function-using-class  
           eql-specializer-instance  
           extract-lambda-list  
           extract-specializer-names  
           finalize-inheritance  
           find-method-combination  
           funcallable-standard-instance-access  
           generic-function-argument-precedence-order  
           generic-function-declarations  
           generic-function-lambda-list  
           generic-function-method-class  
           generic-function-method-combination  
           generic-function-methods  
           generic-function-name  
           intern-eql-specializer  
           make-instance  
           make-method-lambda  
           map-dependents  
           method-function  
           method-generic-function  
           method-lambda-list  
           method-specializers  
           method-qualifiers  
           accessor-method-slot-definition  
           reader-method-class  
           remove-dependent  
           remove-direct-method  
           remove-direct-subclass  
           remove-method  
           set-funcallable-instance-function  
           slot-boundp-using-class  
           slot-definition-allocation  
           slot-definition-initargs  
           slot-definition-initform  
           slot-definition-initfunction  
           slot-definition-location  
           slot-definition-name  
           slot-definition-readers  
           slot-definition-writers  
           slot-definition-type  
           slot-makunbound-using-class  
           slot-value-using-class  
           specializer-direct-generic-function  
           specializer-direct-methods  
           standard-instance-access  
           update-dependent  
           validate-superclass  
           writer-method-class  
           ))  
   
 );eval-when  
   
 #-(or KCL IBCL)  
 (export *class-exports* *the-pcl-package*)  
   
 #+(or KCL IBCL)  
 (mapc 'export (list *class-exports*) (list *the-pcl-package*))  
   
 #-(or KCL IBCL)  
 (export *chapter-6-exports* *the-pcl-package*)  
   
 #+(or KCL IBCL)  
 (mapc 'export (list *chapter-6-exports*) (list *the-pcl-package*))  
   
 (defvar *slot-accessor-name-package*  
   (or (find-package :slot-accessor-name)  
       (make-package :slot-accessor-name  
                     :use '()  
                     :nicknames '(:s-a-n))))  
   
 #+kcl  
 (when (get 'si::basic-wrapper 'si::s-data)  
   (import (mapcar #'(lambda (s) (intern (symbol-name s) "SI"))  
                   '(:copy-structure-header :swap-structure-contents :set-structure-def  
                     :%instance-ref :%set-instance-ref  
   
                     :cache-number-vector :cache-number-vector-length  
                     :wrapper-cache-number-adds-ok :wrapper-cache-number-length  
                     :wrapper-cache-number-mask :wrapper-cache-number-vector-length  
                     :wrapper-layout :wrapper-cache-number-vector  
                     :wrapper-state :wrapper-class :wrapper-length))))  

Legend:
Removed from v.1.9.1.3  
changed lines
  Added in v.1.30

  ViewVC Help
Powered by ViewVC 1.1.5