"

 COPYRIGHT (c) 1996-2015 by Claus Gittinger

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

 COPYRIGHT (c) 2010-2015 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/experiments' }"

JavaByteCodeProcessor subclass:#JavaByteCodeInterpreter

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Languages-Java-Bytecode'

!

!JavaByteCodeInterpreter class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1996-2015 by Claus Gittinger

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

 COPYRIGHT (c) 2010-2015 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

"

! !

!JavaByteCodeInterpreter class methodsFor:'interpretation'!

interpret:aMethod receiver:aReceiver arguments:argArray

    ^ self new interpret:aMethod receiver:aReceiver arguments:argArray

! !

!JavaByteCodeInterpreter methodsFor:'instructions'!

aaload

    "loads onto the stack a reference from an array

     stack: arrayref, index -> value

     args: nothing"

    | arrayref  index |

    index := self pop.

    arrayref := self pop.

    arrayref isNil ifTrue:[

        ^ JavaVM throwNullPointerException

    ].

    ^ self pushRef:(arrayref at:index + 1).

    "

     The arrayref must be of type reference and must refer to an array whose

     components are of type reference. The index must be of type int. Both arrayref

     and index are popped from the operand stack. The reference value in the component

     of the array at index is retrieved and pushed onto the operand stack.

     If arrayref is null, aaload throws a NullPointerException.

     Otherwise, if index is not within the bounds of the array referenced by arrayref,

     the aaload instruction throws an ArrayIndexOutOfBoundsException."

    "Modified: / 21-03-2011 / 17:20:46 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 04-08-2014 / 15:53:49 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

aastore

    "stores into a reference in an array

     stack: arrayref, index, value -> nothing

     args: nothing"

    | arrayref  index  value |

    value := self pop.

    index := self pop.

    arrayref := self pop.

    arrayref isNil ifTrue:[

        ^ JavaVM throwNullPointerException

    ].

    arrayref at:index + 1 put:value.

    "

     The arrayref must be of type reference and must refer to an array whose components are of

     type reference. The index must be of type int and value must be of type reference. The arrayref,

     index, and value are popped from the operand stack. The reference value is stored as the

     component of the array at index.

     The type of value must be assignment compatible (§2.6.7) with the type of the components

     of the array referenced by arrayref. Assignment of a value of reference type S (source)

     to a variable of reference type T (target) is allowed only when the type S supports all

     the operations defined on type T. The detailed rules follow:

     If S is a class type, then:

     If T is a class type, then S must be the same class (§2.8.1) as T, or S must be a subclass of T;

     If T is an interface type, S must implement (§2.13) interface T.

     If S is an interface type, then:

     If T is a class type, then T must be Object (§2.4.7).

     If T is an interface type, then T must be the same interface as S or a superinterface of S (§2.13.2).

     If S is an array type, namely, the type SC[], that is, an array of components of type SC, then:

     If T is a class type, then T must be Object (§2.4.7).

     If T is an array type TC[], that is, an array of components of type TC, then one of the following must be true:

     TC and SC are the same primitive type (§2.4.1).

     TC and SC are reference types (§2.4.6), and type SC is assignable to TC by these runtime rules.

     If T is an interface type, T must be one of the interfaces implemented by arrays (§2.15).

     If arrayref is null, aastore throws a NullPointerException.

     Otherwise, if index is not within the bounds of the array referenced by arrayref,

     the aastore instruction throws an ArrayIndexOutOfBoundsException.

     Otherwise, if arrayref is not null and the actual type of value is not assignment

     compatible (§2.6.7) with the actual type of the components of the array, aastore

     throws an ArrayStoreException."

    "Modified: / 22-03-2011 / 12:27:17 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

    "Modified: / 04-08-2014 / 15:53:57 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

aconst_null

    "

     Push null

     stack: nothing -> null

     args: nothing"

    self pushConstant: nil.

"

Description

Push the null object reference onto the operand stack.

Notes

The Java virtual machine does not mandate a concrete

value for null."

    "Created: / 24-02-2011 / 22:40:50 / Marcel Hlopko <hlopik@gmail.com>"

    "Modified: / 24-02-2011 / 22:07:57 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 14-03-2011 / 20:55:27 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

aload

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

aload: idx 

    "Load reference from local variable

     nothing -> objectRef

     args: index"

    self pushRef: (context at: idx + 1).

    "Description

     The index is an unsigned byte that must be an index into the local

     variable array of the current frame (§3.6). The local variable at

     index must contain a reference. The objectref in the local variable

     at index is pushed onto the operand stack.

     Notes

     The aload instruction cannot be used to load a value of type returnAddress

     from a local variable onto the operand stack. This asymmetry with the

     astore instruction is intentional.

     The aload opcode can be used in conjunction with the wide instruction

     to access a local variable using a two-byte unsigned index."

    "Modified: / 13-03-2011 / 20:59:08 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

anewarray

    "

       Create new array of reference

       stack: count -> arrayRef

       args: arrayType"

    | type  size |

    type := constantPool at: self fetchIndex2.

    size := self pop.

    self pushNewArrayOf: type sized: size.

    "

     Description

     The count must be of type int. It is popped off the operand stack. The count

     represents the number of components of the array to be created. The unsigned

     indexbyte1 and indexbyte2 are used to construct an index into the runtime

     constant pool of the current class (3.6), where the value of the index is

     (indexbyte1 << 8) | indexbyte2. The runtime constant pool item at that index

     must be a symbolic reference to a class, array, or interface type. The named

     class, array, or interface type is resolved (5.4.3.1). A new array with components

     of that type, of length count, is allocated from the garbage-collected heap,

     and a reference arrayref to this new array object is pushed onto the operand

     stack. All components of the new array are initialized to null, the default

     value for reference types (2.5.1).

     Linking Exceptions

     During resolution of the symbolic reference to the class, array, or interface

     type, any of the exceptions documented in 5.4.3.1 can be thrown.

     Runtime Exception

     Otherwise, if count is less than zero, the anewarray instruction throws a

     NegativeArraySizeException.

     Notes

     The anewarray instruction is used to create a single dimension of an array of

     object references or part of a multidimensional array."

    "Created: / 14-03-2011 / 18:24:57 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

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

!

areturn

    "

     Return reference from method

     stack: objectRef -> empty

     args: nothing"

    self leaveProcessorWith: (self pop).

    "

     Description

     The objectref must be of type reference and must refer to an object of a type

     that is assignment compatible (§2.6.7) with the type represented by the return

     descriptor (§4.3.3) of the current method. If the current method is a synchronized

     method, the monitor acquired or reentered on invocation of the method is released

     or exited (respectively) as if by execution of a monitorexit instruction. If no

     exception is thrown, objectref is popped from the operand stack of the current

     frame (§3.6) and pushed onto the operand stack of the frame of the invoker. Any

     other values on the operand stack of the current method are discarded.

     The interpreter then reinstates the frame of the invoker and returns control to

     the invoker.

     Runtime Exceptions

     If the current method is a synchronized method and the current thread is not the

     owner of the monitor acquired or reentered on invocation of the method, areturn

     throws an IllegalMonitorStateException. This can happen, for example, if a synchronized

     method contains a monitorexit instruction, but no monitorenter instruction, on the object

     on which the method is synchronized.

     Otherwise, if the virtual machine implementation enforces the rules on structured use

     of locks described in §8.13 and if the first of those rules is violated during invocation

     of the current method, then areturn throws an IllegalMonitorStateException."

    "Created: / 14-03-2011 / 13:45:29 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

arraylength

    "

     Get length of array

     stack: arrayRef -> length

     args: nothing"

    self pushInt: self pop size.

    "

     Description

     The arrayref must be of type reference and must refer to an array. It is

     popped from the operand stack. The length of the array it references is

     determined. That length is pushed onto the operand stack as an int.

     Runtime Exception

     If the arrayref is null, the arraylength instruction throws a NullPointerException."

    "Created: / 14-03-2011 / 18:41:01 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

astore

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

astore: idx 

    "

     stores a reference into a local variable #index

     stack: objectref -> nothing

     args: index"

    context at: idx + 1 put: (self pop).

    "Description

     The index is an unsigned byte that must be an index into the local

     variable array of the current frame (3.6). The objectref on the

     top of the operand stack must be of type returnAddress or of type

     reference. It is popped from the operand stack, and the value of

     the local variable at index is set to objectref.

     Notes

     The astore instruction is used with an objectref of type returnAddress

     when implementing the finally clauses of the Java programming language

     (see Section 7.13, Compiling finally). The aload instruction cannot be

     used to load a value of type returnAddress from a local variable onto

     he operand stack. This asymmetry with the astore instruction is intentional.

     The astore opcode can be used in conjunction with the wide instruction

     to access a local variable using a two-byte unsigned index."

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

!

athrow

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

baload

    self halt

!

bastore

    self halt

!

bipush

    "

     pushes a byte onto the stack as an integer value

     stack: nothing -> value

     args: byte"

    self pushInt: (self fetchByte).

    "

     The immediate byte is sign-extended to an int value. That value is pushed onto the operand stack.

"

    "Modified: / 13-03-2011 / 16:58:07 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

breakpoint

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

caload

    self halt

!

castore

    self halt

!

checkcast

    "

     Check whether object is of given type

     stack: objref -> objRef

     args: indexByte1 indexByte2"

    | ref  objRef |

    self breakPoint: #mh.

    ref := constantPool at: self fetchIndex2.

    ref isUnresolved ifTrue: [ ref := ref javaClass ].

    objRef := self pop.

    (objRef isNil or: [ (JavaVM canCast: objRef class to: ref) ]) ifTrue: [

        self pushRef: objRef.

    ] ifFalse: [ JavaVM throwClassCastException ].

    "

     Description

     The objectref must be of type reference. The unsigned indexbyte1 and indexbyte2 are used to

     construct an index into the runtime constant pool of the current class (§3.6), where the value

     of the index is (indexbyte1 << 8) | indexbyte2. The runtime constant pool item at the index

     must be a symbolic reference to a class, array, or interface type. The named class, array,

     or interface type is resolved (§5.4.3.1).

     If objectref is null or can be cast to the resolved class, array, or interface type, the

     operand stack is unchanged; otherwise, the checkcast instruction throws a ClassCastException.

     The following rules are used to determine whether an objectref that is not null can be cast

     to the resolved type: if S is the class of the object referred to by objectref and T is the

     resolved class, array, or interface type, checkcast determines whether objectref can be cast

     to type T as follows:

     If S is an ordinary (nonarray) class, then:

     If T is a class type, then S must be the same class (§2.8.1) as T, or a subclass of T.

     If T is an interface type, then S must implement (§2.13) interface T.

     If S is an interface type, then:

     If T is a class type, then T must be Object (§2.4.7).

     If T is an interface type, then T must be the same interface as S or a superinterface

     of S (§2.13.2).

     If S is a class representing the array type SC[], that is, an array of components of

     type SC, then:

     If T is a class type, then T must be Object (§2.4.7).

     If T is an array type TC[], that is, an array of components of type TC, then one of the

     following must be true:

     TC and SC are the same primitive type (§2.4.1).

     TC and SC are reference types (§2.4.6), and type SC can be cast to TC by recursive

     application of these rules.

     If T is an interface type, T must be one of the interfaces implemented by arrays (§2.15).

     Linking Exceptions

     During resolution of the symbolic reference to the class, array, or interface type, any of the

     exceptions documented in Section 5.4.3.1 can be thrown.

     Runtime Exception

     Otherwise, if objectref cannot be cast to the resolved class, array, or interface type,

     the checkcast instruction throws a ClassCastException.

     Notes

     The checkcast instruction is very similar to the instanceof instruction. It differs in

     its treatment of null, its behavior when its test fails (checkcast throws an exception,

     instanceof pushes a result code), and its effect on the operand stack."

    "Modified: / 21-03-2011 / 18:15:54 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

d2f

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

d2i

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

d2l

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

dadd

    "

     adds two doubles together

     stack: value1, value2 -> result

     args: nothing"

    self pushDouble: (self pop + self pop).

"

Description

Both value1 and value2 must be of type double. The values are popped from the operand 

stack and undergo value set conversion (3.8.3), resulting in value1' and value2'. 

The double result is value1' + value2'. The result is pushed onto the operand stack.

The result of a dadd instruction is governed by the rules of IEEE arithmetic:

If either value1' or value2' is NaN, the result is NaN.

The sum of two infinities of opposite sign is NaN.

The sum of two infinities of the same sign is the infinity of that sign.

The sum of an infinity and any finite value is equal to the infinity.

The sum of two zeroes of opposite sign is positive zero.

The sum of two zeroes of the same sign is the zero of that sign.

The sum of a zero and a nonzero finite value is equal to the nonzero value.

The sum of two nonzero finite values of the same magnitude and opposite sign is 

positive zero.

In the remaining cases, where neither operand is an infinity, a zero, or NaN and 

the values have the same sign or have different magnitudes, the sum is computed 

and rounded to the nearest representable value using IEEE 754 round to nearest mode. 

If the magnitude is too large to represent as a double, we say the operation overflows; 

the result is then an infinity of appropriate sign. If the magnitude is too small to 

represent as a double, we say the operation underflows; the result is then a zero of 

appropriate sign.

The Java virtual machine requires support of gradual underflow as defined by IEEE 754. 

Despite the fact that overflow, underflow, or loss of precision may occur, execution 

of a dadd instruction never throws a runtime exception.

"

    "Created: / 14-03-2011 / 20:53:28 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

daload

    "

     Load double from array

     stack: arrayRef index -> value

     args: nothing"

    self swap.

    self pushDouble: (self pop at: (self pop + 1)).

"

Description

The arrayref must be of type reference and must refer to an array whose components are of 

type double. The index must be of type int. Both arrayref and index are popped from the 

operand stack. The double value in the component of the array at index is retrieved and 

pushed onto the operand stack.

Runtime Exceptions

If arrayref is null, daload throws a NullPointerException.

Otherwise, if index is not within the bounds of the array referenced by arrayref, the 

daload instruction throws an ArrayIndexOutOfBoundsException.

"

    "Modified: / 14-03-2011 / 20:52:09 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"

!

dastore

    self halt

!

dcmpg

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

dcmpl

    "raise an error: must be redefined in concrete subclass(es)"

    ^ self shouldImplement

!

dconst: arg 

    self pushDouble: arg.

    "Created: / 14-03-2011 / 18:01:53 / Marcel Hlopko <hlopkmar@fel.cvut.cz>"