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|

        p := path.

        (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].

                ]

            ].

        ]

    ].

    ^ nil

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

!

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"

!

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:[

    ].

    inStream := aFilename asFilename readStream.

    inStream isNil ifTrue:[

    ].

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

    javaClass notNil ifTrue:[

    ].

    inStream close.

    AbsolutelySilent ifFalse:[

    ].

    ^ javaClass

!

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"

    ^ self new readStream:aStream ignoring:classesBeingLoaded

    "

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

    "

    "Modified: 15.4.1996 / 15:01:30 / 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|

    ClassLoaderQuerySignal answer:aClassLoader

    do:[

        javaClass := self readStream:aStream ignoring:(Set new).

        javaClass notNil ifTrue:[

            self postLoadActions:loadUnresolved.

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

            JavaUnresolvedConstant resolveFor:javaClass.

        ].

    ].

    ^ javaClass

    "Created: / 15.8.1997 / 00:59:24 / cg"

    "Modified: / 23.1.1998 / 17:14:09 / cg"

! !

!JavaClassReader methodsFor:'file reading'!

readClassFileIgnoring:classesbeingLoaded

    "reads a class from inStream and returns it.

     The JavaClass is not installed as global and its constants

     (especially strings) may not be fully resolved."

    |magic 

     access_flags this_class this_class_index super_class super_class_index

     realSuperClass this_class_ref existingSuperClass

     fields interfaces staticFields nStatic

     jSuperClass loader|

    "/

    "/ read magic, determine byte order

    "/

    msb := true.

    magic := inStream nextUnsignedLongMSB:msb.

    magic = 16rCAFEBABE ifFalse:[

        magic = 16rBEBAFECA ifFalse:[

            InvalidClassFormatSignal raiseErrorString:'not a java class file'.

            ^ nil

        ].

        msb := false.

        Verbose ifTrue:[Transcript showCR:'file is lsb'].

    ] ifTrue:[

        Verbose ifTrue:[Transcript showCR:'file is msb'].

    ].

    "/

    "/ get version

    "/

    minorVsn := inStream nextUnsignedShortMSB:msb.

    majorVsn := inStream nextUnsignedShortMSB:msb.

    (majorVsn ~~ 45 or:[minorVsn ~~ 3]) ifTrue:[

        Transcript show:'warning this file has version '; show:majorVsn; show:'.'; showCR:minorVsn. 

    ].

    Verbose ifTrue:[

        Transcript show:'version = '; 

                   show:(majorVsn printString); 

                   show:'.';

                   showCR:(minorVsn printString).

    ].

    "/

    "/ get constant pool

    "/

    self readConstantPool.

    "/

    "/ access flags

    "/

    access_flags := inStream nextUnsignedShortMSB:msb.

    this_class_index := inStream nextUnsignedShortMSB:msb.

    super_class_index := inStream nextUnsignedShortMSB:msb.

    super_class_index == 0 ifTrue:[