"

 COPYRIGHT (c) 1996-2011 by Claus Gittinger

 New code and modifications done at SWING Research Group [1]:

 COPYRIGHT (c) 2010-2011 by Jan Vrany, Jan Kurs and Marcel Hlopko

                            SWING Research Group, Czech Technical University in Prague

 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.

 [1] Code written at SWING Research Group contains a signature

     of one of the above copright owners. For exact set of such code,

     see the differences between this version and version stx:libjava

     as of 1.9.2010

"

"{ Package: 'stx:libjava' }"

Object subclass:#JavaResolver

	instanceVariableNames:'exceptionThrower'

	classVariableNames:'uniqueInstance'

	poolDictionaries:''

	category:'Languages-Java-Reader-Support-new'

!

!JavaResolver class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1996-2011 by Claus Gittinger

 New code and modifications done at SWING Research Group [1]:

 COPYRIGHT (c) 2010-2011 by Jan Vrany, Jan Kurs and Marcel Hlopko

                            SWING Research Group, Czech Technical University in Prague

 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.

 [1] Code written at SWING Research Group contains a signature

     of one of the above copright owners. For exact set of such code,

     see the differences between this version and version stx:libjava

     as of 1.9.2010

"

! !

!JavaResolver class methodsFor:'initialization'!

initialize

    uniqueInstance := JavaResolver new.

    uniqueInstance exceptionThrower: JavaVM.

    "/has methods at: and at: put: 

    "/uniqueInstance resolvedClasses: Java.

    "Modified: / 10-04-2011 / 10:23:43 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 13-04-2011 / 14:07:35 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaResolver class methodsFor:'instance creation'!

uniqueInstance

    ^uniqueInstance.

    "Created: / 08-04-2011 / 17:36:37 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

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

! !

!JavaResolver methodsFor:'accessing'!

exceptionThrower

    ^ exceptionThrower

!

exceptionThrower:something

    exceptionThrower := something.

! !

!JavaResolver methodsFor:'class resolving'!

checkIfPrimitiveArrayRef: aJavaClassRef andWrap: result 

    ^ (JavaDescriptor readFromString: aJavaClassRef name) javaClass.

    "Created: / 23-05-2011 / 21:12:04 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

resolveClassIndentifiedByRef: aJavaClassRef init: doInit 

    "marcel is back working harder then ever :)"

    | result |

    self validateClassRef: aJavaClassRef.

    JavaClassReader classLoaderQuerySignal answer: (aJavaClassRef classLoader)

        do: [

            result := self lookupClassIfAlreadyResolved: aJavaClassRef javaClassName.

"/        result notNil ifTrue:[ 

"/            "/wrap result with array(s) if needed and return it

"/            "/FIXME: Marcel, can you have a look? Is that correct?

"/            ^self checkIfArrayRef: aJavaClassRef andWrap: result.

"/        ].

        ].

     "

     To resolve an unresolved symbolic reference from D to a class or interface C denoted by N,

     the following steps are performed:

     The defining class loader of D is used to create a class or interface denoted by N.

     This class or interface is C. Any exception that can be thrown as a result of failure

     of class or interface creation can thus be thrown as a result of failure of class and

     interface resolution. The details of the process are given in Section 5.3.

    "

    result isNil ifTrue: [

        JavaClassReader classLoaderQuerySignal answer: (aJavaClassRef classLoader)

            do: [

                "#loadUnresolvedClass: wraps the class!!!!!!"

                result := self loadUnresolvedClass: aJavaClassRef.

                ((aJavaClassRef name first == $[) and: [ result isJavaArrayClass not ]) ifTrue: [

                    self breakPoint: #jv.

                ]

            ].

    ] ifFalse: [ 

        result := self checkIfArrayRef: aJavaClassRef andWrap: result. 

    ].

    result isNil ifTrue: [ self breakPoint: #mh ].

    result isJavaPrimitiveType ifTrue: [

        ^ self checkIfPrimitiveArrayRef: aJavaClassRef andWrap: result

    ].

    (doInit and: [ result isJavaArrayClass not ]) ifTrue: [ result classInit ].

     "

     If C is an array class and its element type is a reference type, then the symbolic reference

     to the class or interface representing the element type is resolved by invoking the algorithm

     in Section 5.4.3.1 recursively.""Finally, access permissions to C are checked:

     If C is not accessible (5.4.4) to D, class or interface resolution throws an IllegalAccessError.

     This condition can occur, for example, if C is a class that was originally declared to be

     public but was changed to be non-public after D was compiled.

     If steps 1 and 2 succeed but step 3 fails, C is still valid and usable. Nevertheless, resolution

     fails, and D is prohibited from accessing C." 

    "JV@2011-08-10: HACK FOR SAXON DEMO!!!!!!" 

    "(self checkPermissionsFrom: aJavaClassRef owner to: result)"

    "JV@2011-12-07: HACK FOR TOMCAT DEMO :-))"

    OperatingSystem getLoginName = 'm' ifTrue:[

        (self checkPermissionsFrom: aJavaClassRef owner to: result) ifTrue: [ ^ result ] ifFalse: [ self throwIllegalAccessError ].

    ] ifFalse:[

        ^result

    ].

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

    "Created: / 12-08-2011 / 22:19:51 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified (comment): / 03-10-2011 / 23:03:01 / m"

    "Modified: / 06-12-2011 / 16:26:54 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 07-12-2011 / 21:30:55 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified (format): / 18-02-2012 / 19:22:42 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!JavaResolver methodsFor:'class resolving helpers'!

checkIfArrayRef: aJavaClassRef andWrap: nonArrayClass 

    "/wrap result with array(s) if needed and return it

    | class|    

    class := nonArrayClass.

    aJavaClassRef name do:[:c|

        c ~~ $[ ifTrue:[ ^ class ].

        class := class javaArrayClass.

    ].

    ^class

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

    "Modified: / 23-10-2011 / 23:46:41 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

checkPermissionsFrom: refOwner to: resolvedClass 

    "

     A class or interface C is accessible to a class or interface D if and only if either of the following conditions are true:

            C is public.

            C and D are members of the same runtime package (§5.3).

     Finally, access permissions to C are checked:

     If C is not accessible (§5.4.4) to D, class or interface resolution throws an IllegalAccessError.

     This condition can occur, for example, if C is a class that was originally declared to be

     public but was changed to be non-public after D was compiled.

     At run time, a class or interface is determined not by its name alone,

     but by a pair: its fully qualified name and its defining class loader.

     Each such class or interface belongs to a single runtime package. The runtime

     package of a class or interface is determined by the package name and

     defining class loader of the class or interface."

    ^true.

    (JavaDescriptor isJavaPrimitiveArrayName: resolvedClass javaName) ifTrue: [

        ^ true

    ].

    resolvedClass isPublic ifTrue: [ ^ true ].

    resolvedClass classLoader = refOwner classLoader ifFalse: [ ^ false. ].

    refOwner javaPackage = resolvedClass javaPackage ifTrue: [ ^ true ].

    "/a little bit too verbose here just so it's clear what's in query

    JavaVM privilegedAccessQuery query ifTrue: [ ^ true ] ifFalse: [ ^ false ].

    "Created: / 11-04-2011 / 19:35:21 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified (format): / 09-10-2011 / 17:27:30 / m"

    "Modified (comment): / 09-10-2011 / 23:11:54 / Marcel Hlopko <hlopik@gmail.com>"

    "Modified: / 13-12-2011 / 14:34:48 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

loadUnresolvedClass: aJavaClassRef 

    | nm |

    nm := aJavaClassRef name.

    nm size == 1 

        and: [ JavaDescriptor baseTypes at: nm first ifPresent: [:cls | ^ cls ] ].

     "Note, that loadClass itself deals with class loaders.

     The caller of me should set one using code like:

     JavaClassReader classLoaderQuerySignal answer: loader do:[call me]

    "

    ^ JavaVM classForName: nm.       

    "Created: / 11-04-2011 / 19:27:10 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 23-05-2011 / 21:06:25 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 08-09-2011 / 08:33:14 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

lookupClassIfAlreadyResolved: javaClassName 

    ^ JavaVM classNamed: javaClassName

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

    "Modified: / 21-10-2011 / 13:40:52 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

validateClassRef: aJavaClassRef 

    self assert: aJavaClassRef isJavaRef.

    self assert: aJavaClassRef isJavaClassRef .

    "Modified: / 23-05-2011 / 21:04:00 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaResolver methodsFor:'common helpers'!

checkPermissionsForMethodOrField: aJavaMethodOrField from: accessingJavaClass to: resolvedJavaClass 

    "A class or interface C is accessible to a class or interface D if 

     and only if either of the following conditions are true:

     C is public.

     C and D are members of the same runtime package (§5.3).

     A field or method R is accessible to a class or interface D if and only

     if any of the following conditions is true:

     R is public.

     R is protected and is declared in a class C, and D is either a subclass

     of C or C itself.

     R is either protected or package private (that is, neither public nor

     protected nor private), and is declared by a class in the same runtime

     package as D.

     R is private and is declared in D.

     This discussion of access control omits a related restriction on the target

     of a protected field access or method invocation (the target must be of class

     D or a subtype of D). That requirement is checked as part of the verification

     process (§5.4.1); it is not part of link-time access control."

    (self checkPermissionsFrom: accessingJavaClass to: resolvedJavaClass) ifFalse: [

        JavaVM privilegedAccessQuery query ifTrue: [ ^ true ].

        ^ false

    ].

    aJavaMethodOrField isPublic ifTrue: [ ^ true ].

    ((aJavaMethodOrField isProtected 

        and: [

            resolvedJavaClass javaComponentClass 

                equalsOrIsSubclassOf: aJavaMethodOrField javaClass

        ]) 

            and: [

                accessingJavaClass javaComponentClass 

                    equalsOrIsSubclassOf: aJavaMethodOrField javaClass

            ]) 

            ifTrue: [ ^ true ].

    ((aJavaMethodOrField isPrivate not 

        and: [ resolvedJavaClass javaPackage = accessingJavaClass javaPackage ]) 

            and: [

                resolvedJavaClass classLoader = accessingJavaClass classLoader                                                

            ]) 

            ifTrue: [ ^ true ].

    (aJavaMethodOrField isPrivate 

        and: [ aJavaMethodOrField javaClass name = accessingJavaClass name ]) 

            ifTrue: [ ^ true ].

    "/a little bit too verbose here just so it's clear what's in query

    JavaVM privilegedAccessQuery query ifTrue: [ ^ true ] ifFalse: [ ^ false ].

    "Created: / 14-04-2011 / 14:19:33 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified (comment): / 09-10-2011 / 23:12:48 / Marcel Hlopko <hlopik@gmail.com>"

    "Modified: / 06-12-2011 / 16:19:35 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaResolver methodsFor:'exceptions'!

throwAbstractMethodError

    exceptionThrower throwAbstractMethodError.

    "Created: / 11-04-2011 / 20:19:42 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 13-04-2011 / 14:07:46 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

throwIllegalAccessError

    exceptionThrower throwIllegalAccessError.

    "Created: / 11-04-2011 / 19:39:16 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 13-04-2011 / 23:06:58 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

throwIncompatibleClassChangeError

    exceptionThrower throwIncompatibleClassChangeError.

    "Created: / 11-04-2011 / 20:02:01 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 13-04-2011 / 14:07:54 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

throwNoSuchFieldException

    exceptionThrower throwNoSuchFieldException.

    "Created: / 11-04-2011 / 21:35:02 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 13-04-2011 / 14:07:57 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

throwNoSuchMethodError

    exceptionThrower throwNoSuchMethodError.

    "Created: / 11-04-2011 / 20:19:41 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 13-04-2011 / 14:08:01 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaResolver methodsFor:'field resolving'!

resolveFieldIndentifiedByRef: aJavaFieldRef 

    | result  class |

    self validateFieldRef: aJavaFieldRef.

    result := self lookupFieldIfAlreadyResolved: aJavaFieldRef.

    result ifNotNil: [ ^ result ].

    class ifNil: [ self halt: 'should not happen - tell mh' ].

    result := class lookupFieldByNameAndType: aJavaFieldRef nameAndType.

    result ifNil: [ self throwNoSuchFieldException ].

    (self 

        checkPermissionsForField: result

        from: aJavaFieldRef classRef owner

        to: class) ifFalse: [ self throwIllegalAccessError ].

    ^ result.

    "

     To resolve an unresolved symbolic reference from D to a field in a class

     or interface C, the symbolic reference to C given by the field reference

     must first be resolved (§5.4.3.1). Therefore, any exception that can be

     thrown as a result of failure of resolution of a class or interface reference

     can be thrown as a result of failure of field resolution. If the reference

     to C can be successfully resolved, an exception relating to the failure of

     resolution of the field reference itself can be thrown.

     When resolving a field reference, field resolution first attempts to look

     up the referenced field in C and its superclasses:

     If C declares a field with the name and descriptor specified by the field

     reference, field lookup succeeds. The declared field is the result of the

     field lookup.

     Otherwise, field lookup is applied recursively to the direct superinterfaces

     of the specified class or interface C.

     Otherwise, if C has a superclass S, field lookup is applied recursively to S.

     Otherwise, field lookup fails.

     If field lookup fails, field resolution throws a NoSuchFieldError. Otherwise,

     if field lookup succeeds but the referenced field is not accessible (§5.4.4)

     to D, field resolution throws an IllegalAccessError.

     Otherwise, let <E, L1> be the class or interface in which the referenced

     field is actually declared and let L2 be the defining loader of D. Let T be

     the name of the type of the referenced field. The Java virtual machine must

     impose the loading constraint that TL1=TL2(§5.3.4)."

    "Created: / 11-04-2011 / 21:15:20 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 13-04-2011 / 11:57:24 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

resolveStaticFieldIndentifiedByRef: aJavaFieldRef 

    | result  class |

    self validateFieldRef: aJavaFieldRef.

    result := self lookupFieldIfAlreadyResolved: aJavaFieldRef.

    result ifNotNil: [ ^ result ].

    class ifNil: [ self halt: 'should not happen - tell mh' ].

    result := class lookupStaticFieldByNameAndType: aJavaFieldRef nameAndType.

    result ifNil: [ self throwNoSuchFieldException ].

    (self 

        checkPermissionsForField: result

        from: aJavaFieldRef classRef owner

        to: class) ifFalse: [ self throwIllegalAccessError ].

    ^ result.

    "

     To resolve an unresolved symbolic reference from D to a field in a class

     or interface C, the symbolic reference to C given by the field reference

     must first be resolved (§5.4.3.1). Therefore, any exception that can be

     thrown as a result of failure of resolution of a class or interface reference

     can be thrown as a result of failure of field resolution. If the reference

     to C can be successfully resolved, an exception relating to the failure of

     resolution of the field reference itself can be thrown.

     When resolving a field reference, field resolution first attempts to look

     up the referenced field in C and its superclasses:

     If C declares a field with the name and descriptor specified by the field

     reference, field lookup succeeds. The declared field is the result of the

     field lookup.

     Otherwise, field lookup is applied recursively to the direct superinterfaces

     of the specified class or interface C.

     Otherwise, if C has a superclass S, field lookup is applied recursively to S.

     Otherwise, field lookup fails.

     If field lookup fails, field resolution throws a NoSuchFieldError. Otherwise,

     if field lookup succeeds but the referenced field is not accessible (§5.4.4)

     to D, field resolution throws an IllegalAccessError.

     Otherwise, let <E, L1> be the class or interface in which the referenced

     field is actually declared and let L2 be the defining loader of D. Let T be

     the name of the type of the referenced field. The Java virtual machine must

     impose the loading constraint that TL1=TL2(§5.3.4)."

    "Created: / 28-04-2011 / 22:31:34 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaResolver methodsFor:'field resolving helpers'!

checkPermissionsForField: aJavaField from: accessingJavaClass to: resolvedJavaClass 

    "A class or interface C is accessible to a class or interface D if and only 

     if either of the following conditions are true:

     C is public.

     C and D are members of the same runtime package (5.3).

     A field or method R is accessible to a class or interface D if and only

     if any of the following conditions is true:

     R is public.

     R is protected and is declared in a class C, and D is either a subclass of

     C or C itself.

     R is either protected or package private (that is, neither public nor protected

     nor private), and is declared by a class in the same runtime package as D.

     R is private and is declared in D.

     This discussion of access control omits a related restriction on the target of

     a protected field access or method invocation (the target must be of class D or

     a subtype of D). That requirement is checked as part of the verification process

     (5.4.1); it is not part of link-time access control."

    ^ self 

        checkPermissionsForMethodOrField: aJavaField from: accessingJavaClass

        to: resolvedJavaClass.

    "Created: / 11-04-2011 / 21:46:29 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 14-04-2011 / 14:21:05 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

lookupFieldIfAlreadyResolved: aJavaFieldRef 

    ^ nil.

    "Created: / 11-04-2011 / 21:16:45 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

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

!

validateFieldRef: aJavaFieldRef 

    aJavaFieldRef isJavaRef ifFalse:[self halt:'I expected Java Ref'].

    aJavaFieldRef isJavaFieldRef ifFalse:[self halt:'I expected Java Field Ref'].

    "Created: / 11-04-2011 / 21:16:44 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

! !

!JavaResolver methodsFor:'interface method resolving'!

resolveInterfaceMethodIdentifiedByRef: aJavaInterfaceMethodRef 

    | result  class |

    self validateInterfaceMethodRef: aJavaInterfaceMethodRef.

    result := self 

                lookupInterfaceMethodIfAlreadyResolved: aJavaInterfaceMethodRef.

    result ifNotNil: [ ^ result ].

    class ifNil: [ self halt: 'should not happen - tell mh' ].