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: 14.8.1997 / 19:48:56 / 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: 14.8.1997 / 20:07:33 / 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:$. by:$/

    ].

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

                rslt := self loadFileLazy:nm ignoring:loadedClass.

                rslt notNil ifTrue:[^ rslt].

            ].

        ]

    ].

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

    ^ nil

    "Modified: 12.8.1997 / 01:40:29 / cg"

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

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

                    ]

            ].

        ].

        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

                    ]

                ]

            ]

        ].

    ]

    "Modified: 14.8.1997 / 19:54:07 / 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:[

        ('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"

!

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

    |javaClass|

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

    javaClass notNil ifTrue:[

        ClassLoaderQuerySignal answer:aClassLoader

        do:[

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

            JavaUnresolvedConstant resolveFor:javaClass.

        ].

    ].

    ^ javaClass

    "Modified: 3.8.1997 / 19:48:45 / 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|

    "/

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

        super_class := nil

    ] ifFalse:[

        super_class := constants at:super_class_index.

        existingSuperClass := Java classNamed:super_class fullName.

        existingSuperClass notNil ifTrue:[

            super_class := existingSuperClass

        ] ifFalse:[

            (super_class isMemberOf:JavaUnresolvedClassConstant) ifTrue:[

                Silent ifFalse:[

                    'load superClass: ' print. super_class fullName printCR.

                ].

                existingSuperClass := self class 

                                    loadClassLazy:(super_class fullName)

                                    ignoring:classesbeingLoaded.