Object subclass:#JavaClassReader

	instanceVariableNames:'inStream msb constants majorVsn minorVsn constNeeds2Slots

		constSlot'

	classVariableNames:'Verbose Silent AbsolutelySilent LazyClassLoading

		InvalidClassFormatSignal ClassLoaderQuerySignal'

	poolDictionaries:''

	category:'Java-Support'

!

!JavaClassReader class methodsFor:'initialization'!

initialize

    InvalidClassFormatSignal := Signal new mayProceed:true.

    InvalidClassFormatSignal notifierString:'class load failure'.

    InvalidClassFormatSignal nameClass:self message:#invalidClassFormatSignal.

    Verbose := false. 

    Silent := true.

    AbsolutelySilent := false.

    LazyClassLoading := false. "/ true.

    ClassLoaderQuerySignal := QuerySignal new

    "

     JavaClassReader initialize

    "

    "Modified: / 27.1.1998 / 17:54:23 / cg"

! !

!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:'debugging'!

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 raise.

    loader isNil ifTrue:[

	rslt := self loadClassLazy:aClassName ignoring:(Set new).

	rslt notNil ifTrue:[self postLoadActions].

	^ rslt

    ].

    ^ 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: / 3.1.1998 / 22:36:13 / cg"

!

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|

    (aClassName endsWith:';') ifTrue:[

        ('oops - loading of ' , aClassName , ' attempted') printNL.

        self halt:'should not happen'.

        ^ nil

    ].

    (aClassName endsWith:'[]') ifTrue:[

        ('oops - loading of ' , aClassName , ' attempted') printNL.

        self halt:'should not happen'.

        ^ nil

    ].

    clsName := aClassName.

    (clsName includes:$.) ifTrue:[

        clsName := clsName asString copy replaceAll:$. 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 classPath do:[:path |

        |nm p zar entry|

        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') asFilename exists ifTrue:[

                    (Java isExcludedFromClassPath:nm) ifFalse:[

                        rslt := self loadFileLazy:nm ignoring:loadedClass.

                        rslt notNil ifTrue:[^ rslt].

                    ]

                ].

            ]

        ] ifFalse:[

            (p asFilename withSuffix:'zip') exists ifTrue:[

                zar := ZipArchive oldFileNamed:(p asFilename withSuffix:'zip').

                (Array 

                    with:clsName

                    with:clsName asLowercase

                    with:clsName asUppercase) 

                do:[:tryName |

                    nm := tryName , '.class'.

                    entry := zar extract:nm.

                    entry notNil ifTrue:[

                        (Java isExcludedFromClassPath:nm) ifFalse:[

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

                            rslt notNil ifTrue:[^ rslt].

                        ]

                    ]

                ]

            ]

        ]

    ].

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

    ^ nil

    "Modified: / 14.8.1997 / 11:38:42 / stefan"

    "Modified: / 30.3.1998 / 18:05:59 / cg"

!

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."

    |javaClass pool|

    javaClass := self readFile:aFilename ignoring:classesBeingLoaded.

    javaClass notNil ifTrue:[

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

	classesBeingLoaded remove:javaClass fullName ifAbsent:nil.

	JavaUnresolvedConstant resolveFor:javaClass.

    ].

    ^ javaClass

    "

     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"

!

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"

!

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 raise.

        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.

            ].

        ].

        newUnresolved size == 0 ifTrue:[

            "/ nothing unresolved

            (classes := Java allClasses) notNil ifTrue:[

                "/ init all new classes

                "/ fetch again - there could be new ones ...

                classes := Java allClasses.

                classes do:[:aJavaClass |

                    aJavaClass isInitialized ifFalse:[

                        Silent ifFalse:[

                            'performing class initialization of ' print. aJavaClass fullName printCR.

                        ].

                        aJavaClass classInit

                    ]

                ]

            ]

        ].

    ]

    "Created: / 15.8.1997 / 01:01:44 / cg"

    "Modified: / 7.1.1998 / 14:13:55 / cg"

!

readFile:aFilename ignoring:classesBeingLoaded

    "reads a class from aFilename and returns it.

     The JavaClass is NOT installed as global and unresolved

     refs are NOT patched."

    |inStream javaClass|

    Silent ifFalse:[

        'reading ' print. aFilename print. ' ...' printNL.

    ].

    inStream := aFilename asFilename readStream.

    inStream isNil ifTrue:[

        ('JAVA [info]: no file: ' , aFilename) printCR.

        self halt.

        ^ nil

    ].

    javaClass := self new readStream:inStream ignoring:classesBeingLoaded.

    javaClass notNil ifTrue:[

        javaClass setBinaryFilePath:(inStream pathName).

    ].

    inStream close.

    AbsolutelySilent ifFalse:[

        '  ... loaded ' print. javaClass displayString printNL.

    ].

    ^ javaClass

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

    "Modified: / 6.2.1998 / 02:20:58 / cg"

!

readStream:aStream

    "reads a class from aStream and returns it.

     The JavaClass is installed as global.

     If new classes are required to be loaded, a new standard loader

     is created."

    ^ self readStream:aStream loader:nil

    "Modified: 14.8.1997 / 19:51:50 / cg"

!

readStream:aStream ignoring:classesBeingLoaded

    "reads a class from aStream and returns it.

     The JavaClass is not installed as global"

    |javaClass|

    javaClass :=  self new readStream:aStream ignoring:classesBeingLoaded.

    AbsolutelySilent ifFalse:[

        '  ... loaded ' print. javaClass displayString printNL.

    ].

    ^ javaClass

    "Modified: / 30.3.1998 / 18:14:40 / cg"

!

readStream:aStream loader:aClassLoader

    "reads a class from aStream and returns it.

     The JavaClass is installed as global.

     If new classes are required to be loaded, aClassLoader is

     asked to do it. If aClassLoader is nil, a new standard loader

     is created."

    ^ self

	readStream:aStream 

	loader:aClassLoader 

	loadUnresolved:true

    "Modified: 15.8.1997 / 01:00:35 / cg"

!

readStream:aStream loader:aClassLoader loadUnresolved:loadUnresolved

    "reads a class from aStream and returns it.

     The JavaClass is installed as global.

     If new classes are required to be loaded, aClassLoader is

     asked to do it. If aClassLoader is nil, a new standard loader

     is created."

    |javaClass|