"

 COPYRIGHT (c) 1997 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libjava' }"

Object subclass:#JavaClassReader

	instanceVariableNames:'inStream msb constants majorVsn minorVsn constNeeds2Slots

		constSlot classBeingLoaded'

	classVariableNames:'Verbose AnnotationsVerbose Silent AbsolutelySilent

		LazyClassLoading InvalidClassFormatSignal ClassLoaderQuerySignal

		JavaArchiveCache UsedJavaClassReaderClass'

	poolDictionaries:''

	category:'Languages-Java-Support'

!

!JavaClassReader class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1997 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

! !

!JavaClassReader class methodsFor:'initialization'!

initialize

    InvalidClassFormatSignal := Signal new mayProceed: true.

    InvalidClassFormatSignal notifierString: 'class load failure'.

    InvalidClassFormatSignal nameClass: self message: #invalidClassFormatSignal.

    UsedJavaClassReaderClass := JavaClassReader2.

    Verbose := false.

    Silent := true.

    AbsolutelySilent := false.

    "/LazyClassLoading := false.

    LazyClassLoading := true.

    ClassLoaderQuerySignal := QuerySignal new.

    JavaArchiveCache := CacheDictionary new: 32.

    AnnotationsVerbose := false.

    "

     JavaClassReader initialize"

    "Modified: / 27-01-1998 / 17:54:23 / cg"

    "Modified: / 17-12-2010 / 17:37:45 / Marcel Hlopko <hlopik@gmail.com>"

    "Modified: / 10-02-2011 / 23:16:45 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 10-05-2011 / 23:59:53 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaClassReader class methodsFor:'Signal constants'!

classLoaderQuerySignal

    ^ ClassLoaderQuerySignal

    "Created: 14.8.1997 / 19:56:03 / cg"

!

invalidClassFormatSignal

    ^ InvalidClassFormatSignal

    "Created: 3.8.1997 / 18:17:21 / cg"

! !

!JavaClassReader class methodsFor:'constants'!

fileMajorVersions

    "Created: / 19-10-2010 / 21:40:36 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 01-06-2011 / 21:44:14 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

fileMinorVersions

    ^ #(

        3 "Java 1.2"

        0 "Java 6"

    )

    "Created: / 19-10-2010 / 21:41:04 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

magic_LSB

    ^ 16rBEBAFECA

    "Modified: / 7.5.1998 / 13:14:27 / cg"

    "Created: / 7.5.1998 / 13:15:05 / cg"

!

magic_MSB

    ^ 16rCAFEBABE

    "Modified: / 7.5.1998 / 13:14:27 / cg"

! !

!JavaClassReader class methodsFor:'debugging'!

annotationsVerbose:aBoolean 

    AnnotationsVerbose := aBoolean

    "

     Java flushClasses.

     JavaClassReader verbose:true

     JavaClassReader verbose:false"

    "Created: / 25-02-2011 / 12:25:23 / Marcel Hlopko <hlopik@gmail.com>"

!

verbose:aBoolean

    Verbose := aBoolean

    "

     Java flushClasses.

     JavaClassReader verbose:true

     JavaClassReader verbose:false

    "

! !

!JavaClassReader class methodsFor:'file reading'!

loadClass:aClassName

    "reads a class, installs and returns it.

     The classes string constants are resolved & <clinit> is called,

     if it implements it."

    |rslt loader|

    loader := ClassLoaderQuerySignal query.

    loader isNil ifTrue:[

        ^ self loadSystemClass:aClassName

    ].

    ^ loader loadClass:aClassName

    "

     JavaClassReader loadClass:'awt/Component'

     JavaClassReader loadClass:'awt/Button'

     JavaClassReader loadClass:'browser/AddButton'

     JavaClassReader loadClass:'java/lang/Object'

     JavaClassReader loadClass:'java/lang/AbstractMethodError'

     JavaClassReader loadClass:'java/lang/Thread'

    "

    "Created: / 15.4.1996 / 14:58:53 / cg"

    "Modified: / 20.10.1998 / 17:24:54 / cg"

!

loadClassLazy: internalJavaClassName 

    ^ self loadClassLazy: internalJavaClassName ignoring: Set new.

    "Created: / 08-04-2011 / 18:00:28 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 11-04-2011 / 19:31:04 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

loadClassLazy: aClassName ignoring: classesBeingLoaded 

    "private helper:

      reads a class, installs and returns it.

      The class is searched along the ClassPath.

     This is a partial load (to load other classes):

     - The classes stringConstants are not fixed to be JavaStrings

       (i.e they are still ST-Strings).

     - The class is NOT initialized."

    | rslt  clsName  cls  loadedClass |

    clsName := aClassName.

    (clsName endsWith: ';') 

        ifTrue: 

            [ (clsName startsWith: '[L') 

                ifTrue: [ clsName := clsName copyFrom: 3 to: clsName size - 1. ]

                ifFalse: 

                    [ ('oops - loading of ' , clsName , ' attempted') printNL.

                    self halt: 'should not happen'.

                    ^ nil. ] ].

    (clsName endsWith: '[]') 

        ifTrue: 

            [ ('oops - loading of ' , clsName , ' attempted') printNL.

            self halt: 'should not happen'.

            ^ nil ].

    (clsName includes: $.) 

        ifTrue: [ clsName := clsName asString copyReplaceAll: $. with: $/ ].

    (classesBeingLoaded notNil and: [ classesBeingLoaded includes: clsName ]) 

        ifTrue: 

            [ ('oops - recursive load of ' , clsName , ' attempted') printNL.

            self halt: 'should not happen'.

            ^ JavaUnresolvedClassConstant fullName: clsName ].

    (cls := Java at: clsName) notNil 

        ifTrue: 

            [ ('oops - ' , clsName , ' is already loaded') printNL.

            "/self halt:clsName , ' is already loaded - should not happen'.

            ^ cls ].

    classesBeingLoaded isNil 

        ifTrue: [ loadedClass := Set with: clsName ]

        ifFalse: 

            [ loadedClass := Set withAll: classesBeingLoaded.

            loadedClass add: clsName. ].

    Java effectiveClassPath do: 

            [:path | 

            | nm  p  zar  entry  zipFile  read |

            Verbose == true 

                ifTrue: [ Transcript showCR: 'trying ' , path asFilename pathName , ' ...'. ].

            p := path.

            p asFilename isDirectory 

                ifTrue: 

                    [ (p endsWith: Filename separator) 

                        ifFalse: [ p := p , (Filename separator asString) ].

                    (Array 

                        with: clsName

                        with: clsName asLowercase

                        with: clsName asUppercase) do: 

                                [:tryName | 

                                nm := p , tryName , '.class'.

                                Verbose == true ifTrue: [ Transcript showCR: 'trying ' , nm , ' ...'. ].

                                nm asFilename exists 

                                    ifTrue: 

                                        [ (Java isExcludedFromClassPath: nm) 

                                            ifFalse: 

                                                [ rslt := self loadFileLazy: nm ignoring: loadedClass.

                                                rslt notNil ifTrue: [ ^ rslt ]. ] ]. ] ]

                ifFalse: 

                    [ Verbose == true 

                        ifTrue: 

                            [ Transcript 

                                showCR: 'trying ' , (p asFilename withSuffix: 'jar') pathName , ' ...'.

                            Transcript 

                                showCR: 'and ' , (p asFilename withSuffix: 'zip') pathName , ' ...'. ].

                    ((zipFile := p asFilename withSuffix: 'jar') exists 

                        or: [ (zipFile := p asFilename withSuffix: 'zip') exists ]) 

                            ifTrue: 

                                [

                                zar := JavaArchiveCache at: zipFile

                                            ifAbsentPut: [ ZipArchive oldFileNamed: zipFile ].

                                read := 

                                        [ nm := clsName , '.class'.

                                        entry := zar extract: nm.

                                        entry notNil 

                                            ifTrue: 

                                                [ (Java isExcludedFromClassPath: nm) 

                                                    ifFalse: 

                                                        [ rslt := self loadStreamLazy: (entry readStream) ignoring: loadedClass.

                                                        rslt notNil ifTrue: [ ^ rslt ]. ] ] ].

                                JavaClassReader invalidClassFormatSignal handle: 

                                        [ "Kludge, sometimes zar gets corrupted"

                                        zar := JavaArchiveCache at: zipFile put: (ZipArchive oldFileNamed: zipFile).

                                        read value ]

                                    do: [ read value ]. ] ] ].

    ('JAVA [info]: no file found for: ' , clsName) infoPrintCR.

    ^ nil

    "Modified: / 14-08-1997 / 11:38:42 / stefan"

    "Modified: / 17-09-1998 / 20:51:25 / cg"

    "Modified: / 18-03-2011 / 16:06:47 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 21-03-2011 / 12:42:12 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

loadClassesIn: directory 

    "load all classes (.class files, strictly speaking) found in given directory 

     or .jar file. The argument is string containing the name of the directory.

     Returns a set of loaded classes."

    | dir  dirString  className  loadedClasses |

    dir := directory asFilename.

    loadedClasses := Set new.

    Java addToClassPath: dir pathName.

    dir recursiveDirectoryContentsAsFilenamesDo: 

            [:filename | 

            (filename isRegularFile and: [ filename suffix = #class ]) 

                ifTrue: 

                    [ dirString := dir asAbsoluteFilename pathName.

                    className := filename withoutSuffix pathName.

                    className := className subString: dirString size + 2 to: className size.

                    loadedClasses add: (self loadClass: className). ]. ].

    ^ loadedClasses.

    "Created: / 15-03-2011 / 15:39:49 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 01-04-2011 / 15:44:46 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 29-04-2011 / 17:43:32 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

loadFile:aFilename

    "reads a class from aFilename, installs and returns it.

     The classes strings are fixed and its class-init function is called."

    self loadFileLazy:aFilename ignoring:(Set new).

    self postLoadActions

!

loadFileLazy:aFilename ignoring:classesBeingLoaded

    "reads a class from aFilename, installs and returns it.

     Strings are fixed and classrefs are fixed, 

     but NO no class-init functions are called."

    |aClass pool|

    aClass := self readFile:aFilename ignoring:classesBeingLoaded.

    aClass notNil ifTrue:[

        aClass isJavaClass ifTrue:[

            "/ a java class

            Java at:(aClass fullName asSymbol) put:aClass.

            classesBeingLoaded remove:aClass fullName ifAbsent:nil.

            JavaUnresolvedConstant resolveFor:aClass.

        ] ifFalse:[    

            "/ a smalltalk class

            "/ self halt.

aClass inspect.

        ]

    ].

    ^ aClass

    "

     JavaClassReader loadFile:'/phys/ibm3/hotjava/classes/browser/AddButton.class'

     '/phys/ibm3/java/lib/java/lang' asFilename

        directoryContents do:[:nm |

            (nm endsWith:'.class') ifTrue:[

                ('/phys/ibm3/java/lib/java/lang/' , nm) printNL.

                JavaClassReader loadFile:'/phys/ibm3/java/lib/java/lang/' , nm

            ]

        ].

     '/phys/ibm3/java/lib/java/io' asFilename

        directoryContents do:[:nm |

            (nm endsWith:'.class') ifTrue:[

                ('/phys/ibm3/java/lib/java/io/' , nm) printNL.

                JavaClassReader loadFile:'/phys/ibm3/java/lib/java/io/' , nm

            ]

        ].

     '/phys/ibm3/java/lib/java/net' asFilename

        directoryContents do:[:nm |

            (nm endsWith:'.class') ifTrue:[

                ('/phys/ibm3/java/lib/java/net/' , nm) printNL.

                JavaClassReader loadFile:'/phys/ibm3/java/lib/java/net/' , nm

            ]

        ].

     '/phys/ibm3/java/lib/java/util' asFilename

        directoryContents do:[:nm |

            (nm endsWith:'.class') ifTrue:[

                ('/phys/ibm3/java/lib/java/util/' , nm) printNL.

                JavaClassReader loadFile:'/phys/ibm3/java/lib/java/util/' , nm

            ]

        ].

     '/phys/ibm3/java/lib/java/awt' asFilename

        directoryContents do:[:nm |

            (nm endsWith:'.class') ifTrue:[

                ('/phys/ibm3/java/lib/java/awt/' , nm) printNL.

                JavaClassReader loadFile:'/phys/ibm3/java/lib/java/awt/' , nm

            ]

        ].

     '/phys/ibm3/java/lib/java/applet' asFilename

        directoryContents do:[:nm |

            (nm endsWith:'.class') ifTrue:[

                ('/phys/ibm3/java/lib/java/applet/' , nm) printNL.

                JavaClassReader loadFile:'/phys/ibm3/java/lib/java/applet/' , nm

            ]

        ].

     JavaClassReader loadFile:'/phys/ibm3/java/lib/java/lang/AbstractMethodError.class'

     JavaClassReader loadFile:'/phys/ibm3/java/lib/java/lang/Thread.class'

    "

    "Created: / 15.4.1996 / 14:58:53 / cg"

    "Modified: / 12.5.1998 / 22:06:52 / cg"

!

loadStreamLazy:aStream ignoring:classesBeingLoaded

    "reads a class from aStream, installs and returns it.

     Strings are fixed and classrefs are fixed, 

     but NO no class-init functions are called."

    |javaClass pool|

    javaClass := self readStream:aStream ignoring:classesBeingLoaded.

    javaClass notNil ifTrue:[

        Java at:(javaClass fullName asSymbol) put:javaClass.

        classesBeingLoaded remove:javaClass fullName ifAbsent:nil.

        JavaUnresolvedConstant resolveFor:javaClass.

    ].

    ^ javaClass

    "Created: / 30.3.1998 / 17:59:02 / cg"

!

loadSystemClass: aClassName 

    "reads a class, installs and returns it.

     The classes string constants are resolved & <clinit> is called,

     if it implements it.

     This only loads local classes (i.e. any Java classReader is not used)"

    | rslt |

    rslt := UsedJavaClassReaderClass loadClassLazy: aClassName

                ignoring: (Set new).

    rslt notNil ifTrue: [ UsedJavaClassReaderClass postLoadActions ].

    self assert: rslt constantPool owner == rslt.

    rslt ifNil: [self breakPoint:#mh].

    ^ rslt

    "

     JavaClassReader loadSystemClass:'awt/Component'

     JavaClassReader loadSystemClass:'awt/Button'

     JavaClassReader loadSystemClass:'browser/AddButton'

     JavaClassReader loadSystemClass:'java/lang/Object'

     JavaClassReader loadSystemClass:'java/lang/AbstractMethodError'

     JavaClassReader loadSystemClass:'java/lang/Thread'"

    "Created: / 20-10-1998 / 17:24:40 / cg"

    "Modified: / 13-05-2011 / 17:50:55 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 22-05-2011 / 13:44:49 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

postLoadActions

    "Resolve all classes' string constants.

     Perform all class initialization functions (of those which are not

     yet initialized)."

    ^ self postLoadActions:true

    "Modified: 15.8.1997 / 01:02:17 / cg"

!

postLoadActions:loadUnresolved

    "Resolve all classes' string constants.

     Perform all class initialization functions 

     (of those which are not yet initialized)."

    |classes prevUnresolved newUnresolved loader|

    "/ need at least java.lang.String, for valid constants

    Java java_lang_String isNil ifTrue:[

        self loadClassLazy:'java.lang.String' ignoring:(Set new).

    ].

    LazyClassLoading ifFalse:[

        loader := ClassLoaderQuerySignal query.

        prevUnresolved := nil.

        newUnresolved := JavaUnresolvedConstant unresolvedClassNames asArray.

        loadUnresolved ifTrue:[

            [prevUnresolved ~= newUnresolved] whileTrue:[

                newUnresolved do:[:nextUnresolved |

                    |classURL|

                    (Java at:nextUnresolved) isNil ifTrue:[ "/ could have been loaded in the meantime

                        Silent ifFalse:[

                            'loading unresolved: ' print. nextUnresolved printCR.

                        ].

                        loader isNil ifTrue:[

                            self

                                loadClassLazy:nextUnresolved

                                ignoring:(Set new).

                        ] ifFalse:[

                            "/

                            "/ the aquired loader is a javaClassLoader

                            "/ which expects an URL as arg.

                            "/

                            "/ classURL := Java as_URL:('file:' , nextUnresolved asString , '.class').

                            "/ loader loadClass:classURL

                            loader

                                perform:#'loadClass(Ljava/lang/String;)Ljava/lang/Class;'

                                with:(Java as_String:(nextUnresolved asString)).

                        ]

                    ]

                ].

                prevUnresolved := newUnresolved.

                newUnresolved := JavaUnresolvedConstant unresolvedClassNames asArray.

            ].

        ].

false ifTrue:[

        newUnresolved size == 0 ifTrue:[

            "/ nothing unresolved

            (classes := Java allClasses) notNil ifTrue:[

                "/ init all new classes