javaclass

Change of bytecode.py

5:d18e689a422d
bytecode.py
     1.1 --- a/bytecode.py	Thu Oct 28 20:47:25 2004 +0200
     1.2 +++ b/bytecode.py	Fri Oct 29 18:48:35 2004 +0200
     1.3 @@ -3,238 +3,783 @@
     1.4  """
     1.5  Java bytecode conversion. Specification found at the following URL:
     1.6  http://java.sun.com/docs/books/vmspec/2nd-edition/html/Instructions2.doc.html
     1.7 +
     1.8 +NOTE: Synchronized constructs are not actually supported.
     1.9  """
    1.10  
    1.11  import dis # for access to Python bytecode values
    1.12  
    1.13 +# Bytecode production classes.
    1.14 +
    1.15 +class BytecodeWriter:
    1.16 +    def __init__(self):
    1.17 +        self.loops = []
    1.18 +        self.jumps = []
    1.19 +        self.output = []
    1.20 +        self.position = 0
    1.21 +
    1.22 +    # Special methods.
    1.23 +
    1.24 +    def end_loop(self):
    1.25 +        current_loop_start = self.loops.pop()
    1.26 +        self.jump_absolute(current_loop_start)
    1.27 +        self.output[current_loop_start + 1] = self.position
    1.28 +        self.pop_block()
    1.29 +
    1.30 +    def jump_to_next(self, status):
    1.31 +        self.jumps.push(self.position)
    1.32 +        if status:
    1.33 +            self.jump_if_true()
    1.34 +        else:
    1.35 +            self.jump_if_false()
    1.36 +
    1.37 +    def start_next(self):
    1.38 +        current_jump_start = self.jumps.pop()
    1.39 +        self.output[current_jump_start + 1] = self.position
    1.40 +
    1.41 +    # Normal bytecode generators.
    1.42 +
    1.43 +    def for_iter(self):
    1.44 +        self.loops.push(self.position)
    1.45 +        self.output.append(opmap["FOR_ITER"])
    1.46 +        self.output.append(None) # To be filled in later
    1.47 +        self.position += 2
    1.48 +
    1.49 +    def jump_if_false(self, offset=None):
    1.50 +        self.output.append(opmap["JUMP_IF_FALSE"])
    1.51 +        self.output.append(offset) # May be filled in later
    1.52 +        self.position += 2
    1.53 +
    1.54 +    def jump_if_true(self, offset=None):
    1.55 +        self.output.append(opmap["JUMP_IF_TRUE"])
    1.56 +        self.output.append(offset) # May be filled in later
    1.57 +        self.position += 2
    1.58 +
    1.59  # Bytecode conversion.
    1.60  
    1.61 -def get_instructions(code):
    1.62 -    global java_bytecodes
    1.63 +class BytecodeReader:
    1.64 +    def __init__(self, class_file):
    1.65 +        self.class_file = class_file
    1.66 +        self.position_mapping = {}
    1.67 +
    1.68 +    def process(self, code, program):
    1.69 +        self.java_position = 0
    1.70 +        while self.java_position < len(code):
    1.71 +            self.position_mapping[self.java_position] = program.position
    1.72 +            bytecode = ord(code[self.java_position])
    1.73 +            mnemonic, number_of_arguments = self.java_bytecodes[bytecode]
    1.74 +            self.process_bytecode(mnemonic, number_of_arguments)
    1.75 +
    1.76 +    def process_bytecode(self, mnemonic, number_of_arguments):
    1.77 +        if number_of_arguments is not None:
    1.78 +            arguments = []
    1.79 +            for j in range(0, number_of_arguments):
    1.80 +                arguments.append(ord(code[self.java_position + 1 + j]))
    1.81 +
    1.82 +            # Call the handler.
    1.83 +            getattr(self, mnemonic)(arguments, program)
    1.84 +        else:
    1.85 +            # Call the handler.
    1.86 +            number_of_arguments = getattr(self, mnemonic)(code[self.java_position+1:], program)
    1.87 +
    1.88 +        self.java_position = self.java_position + 1 + number_of_arguments
    1.89 +
    1.90 +    def nop(self, arguments, program):
    1.91 +        pass
    1.92 +
    1.93 +    def aaload(self, arguments, program):
    1.94 +        # NOTE: No type checking performed.
    1.95 +        program.binary_subscr()
    1.96 +
    1.97 +    def aastore(self, arguments, program):
    1.98 +        # NOTE: No type checking performed.
    1.99 +        # Stack: arrayref, index, value
   1.100 +        program.rot_three() # Stack: value, arrayref, index
   1.101 +        program.store_subscr()
   1.102 +
   1.103 +    def aconst_null(self, arguments, program):
   1.104 +        program.load_global(None)
   1.105 +
   1.106 +    def aload(self, arguments, program):
   1.107 +        program.load_fast(arguments[0])
   1.108 +
   1.109 +    def aload_0(self, arguments, program):
   1.110 +        program.load_fast(0)
   1.111 +
   1.112 +    def aload_1(self, arguments, program):
   1.113 +        program.load_fast(1)
   1.114 +
   1.115 +    def aload_2(self, arguments, program):
   1.116 +        program.load_fast(2)
   1.117 +
   1.118 +    def aload_3(self, arguments, program):
   1.119 +        program.load_fast(3)
   1.120 +
   1.121 +    def anewarray(self, arguments, program):
   1.122 +        # NOTE: Does not raise NegativeArraySizeException.
   1.123 +        # NOTE: Not using the index to type the list/array.
   1.124 +        index = arguments[0] << 8 + arguments[1]
   1.125 +
   1.126 +        program.build_list()
   1.127 +        program.setup_loop()
   1.128 +        program.load_global("range")
   1.129 +        program.load_const(0)       # Stack: list, count, range, 0
   1.130 +        program.rot_three()         # Stack: list, 0, count, range
   1.131 +        program.rot_three()         # Stack: list, range, 0, count
   1.132 +        program.call_function(2)    # Stack: list, range_list
   1.133 +        program.get_iter()          # Stack: list, iter
   1.134 +        program.for_iter()          # Stack: list, iter, value
   1.135 +        program.pop_top()           # Stack: list, iter
   1.136 +        program.rot_two()           # Stack: iter, list
   1.137 +        program.dup_top()           # Stack: iter, list, list
   1.138 +        program.load_attr("append") # Stack: iter, list, append
   1.139 +        program.load_global(None)   # Stack: iter, list, append, None
   1.140 +        program.call_function(1)    # Stack: iter, list, None
   1.141 +        program.pop_top()           # Stack: iter, list
   1.142 +        program.rot_two()           # Stack: list, iter
   1.143 +        program.end_loop()          # Back to for_iter above
   1.144 +
   1.145 +    def areturn(self, arguments, program):
   1.146 +        program.return_value()
   1.147 +
   1.148 +    def arraylength(self, arguments, program):
   1.149 +        program.load_global("len")  # Stack: arrayref, len
   1.150 +        program.rot_two()           # Stack: len, arrayref
   1.151 +        program.call_function(1)
   1.152  
   1.153 -    i = 0
   1.154 -    instructions = []
   1.155 -    while i < len(code):
   1.156 -        bytecode = ord(code[i])
   1.157 -        mnemonic, number_of_arguments, stack_change = java_bytecodes[bytecode]
   1.158 +    def astore(self, arguments, program):
   1.159 +        program.store_fast(arguments[0])
   1.160 +
   1.161 +    def astore_0(self, arguments, program):
   1.162 +        program.store_fast(0)
   1.163 +
   1.164 +    def astore_1(self, arguments, program):
   1.165 +        program.store_fast(1)
   1.166 +
   1.167 +    def astore_2(self, arguments, program):
   1.168 +        program.store_fast(2)
   1.169 +
   1.170 +    def astore_3(self, arguments, program):
   1.171 +        program.store_fast(3)
   1.172 +
   1.173 +    def athrow(self, arguments, program):
   1.174 +        # NOTE: NullPointerException not raised where null/None is found on the stack.
   1.175 +        program.raise_varargs(1)
   1.176 +
   1.177 +    baload = aaload
   1.178 +    bastore = aastore
   1.179 +
   1.180 +    def bipush(self, arguments, program):
   1.181 +        program.load_const(arguments[0])
   1.182 +
   1.183 +    caload = aaload
   1.184 +    castore = aastore
   1.185 +
   1.186 +    def checkcast(self, arguments, program):
   1.187 +        index = arguments[0] << 8 + arguments[1]
   1.188 +        target_name = self.class_file.constants[index - 1].get_name()
   1.189 +        target_components = target_name.split("/")
   1.190 +
   1.191 +        program.dup_top()                   # Stack: objectref, objectref
   1.192 +        program.load_global("isinstance")   # Stack: objectref, objectref, isinstance
   1.193 +        program.rot_two()                   # Stack: objectref, isinstance, objectref
   1.194 +        program.load_global(target_components[0])
   1.195 +        for target_component in target_components[1:]:
   1.196 +            program.load_attr(target_component)
   1.197 +        program.call_function(2)            # Stack: objectref
   1.198 +
   1.199 +    def d2f(self, arguments, program):
   1.200 +        pass
   1.201 +
   1.202 +    def d2i(self, arguments, program):
   1.203 +        program.load_global("int")  # Stack: value, int
   1.204 +        program.rot_two()           # Stack: int, value
   1.205 +        program.call_function(1)    # Stack: result
   1.206 +
   1.207 +    d2l = d2i # Preserving Java semantics
   1.208 +
   1.209 +    def dadd(self, arguments, program):
   1.210 +        # NOTE: No type checking performed.
   1.211 +        program.binary_add()
   1.212 +
   1.213 +    daload = aaload
   1.214 +    dastore = aastore
   1.215 +
   1.216 +    def dcmpg(self, arguments, program):
   1.217 +        # NOTE: No type checking performed.
   1.218 +        program.compare_op(">")
   1.219 +
   1.220 +    def dcmpl(self, arguments, program):
   1.221 +        # NOTE: No type checking performed.
   1.222 +        program.compare_op("<")
   1.223 +
   1.224 +    def dconst_0(self, arguments, program):
   1.225 +        program.load_const(0.0)
   1.226 +
   1.227 +    def dconst_1(self, arguments, program):
   1.228 +        program.load_const(1.0)
   1.229 +
   1.230 +    def ddiv(self, arguments, program):
   1.231 +        # NOTE: No type checking performed.
   1.232 +        program.binary_divide()
   1.233 +
   1.234 +    dload = aload
   1.235 +    dload_0 = aload_0
   1.236 +    dload_1 = aload_1
   1.237 +    dload_2 = aload_2
   1.238 +    dload_3 = aload_3
   1.239 +
   1.240 +    def dmul(self, arguments, program):
   1.241 +        # NOTE: No type checking performed.
   1.242 +        program.binary_multiply()
   1.243 +
   1.244 +    def dneg(self, arguments, program):
   1.245 +        # NOTE: No type checking performed.
   1.246 +        program.unary_negative()
   1.247  
   1.248 -        # NOTE: To be fixed.
   1.249 -        if number_of_arguments is None:
   1.250 -            print "Stop at", mnemonic
   1.251 -            return instructions
   1.252 +    def drem(self, arguments, program):
   1.253 +        # NOTE: No type checking performed.
   1.254 +        program.binary_modulo()
   1.255 +
   1.256 +    dreturn = areturn
   1.257 +    dstore = astore
   1.258 +    dstore_0 = astore_0
   1.259 +    dstore_1 = astore_1
   1.260 +    dstore_2 = astore_2
   1.261 +    dstore_3 = astore_3
   1.262 +
   1.263 +    def dsub(self, arguments, program):
   1.264 +        # NOTE: No type checking performed.
   1.265 +        program.binary_subtract()
   1.266 +
   1.267 +    def dup(self, arguments, program):
   1.268 +        program.dup_top()
   1.269 +
   1.270 +    def dup_x1(self, arguments, program):
   1.271 +        # Ignoring computational type categories.
   1.272 +        program.dup_top()
   1.273 +        program.rot_three()
   1.274 +
   1.275 +    def dup_x2(self, arguments, program):
   1.276 +        # Ignoring computational type categories.
   1.277 +        program.dup_top()
   1.278 +        program.rot_four()
   1.279 +
   1.280 +    dup2 = dup # Ignoring computational type categories
   1.281 +    dup2_x1 = dup_x1 # Ignoring computational type categories
   1.282 +    dup2_x2 = dup_x2 # Ignoring computational type categories
   1.283 +
   1.284 +    def f2d(self, arguments, program):
   1.285 +        pass # Preserving Java semantics
   1.286 +
   1.287 +    def f2i(self, arguments, program):
   1.288 +        program.load_global("int")  # Stack: value, int
   1.289 +        program.rot_two()           # Stack: int, value
   1.290 +        program.call_function(1)    # Stack: result
   1.291 +
   1.292 +    f2l = f2i # Preserving Java semantics
   1.293 +    fadd = dadd
   1.294 +    faload = daload
   1.295 +    fastore = dastore
   1.296 +    fcmpg = dcmpg
   1.297 +    fcmpl = dcmpl
   1.298 +    fconst_0 = dconst_0
   1.299 +    fconst_1 = dconst_1
   1.300 +
   1.301 +    def fconst_2(self, arguments, program):
   1.302 +        program.load_const(2.0)
   1.303 +
   1.304 +    fdiv = ddiv
   1.305 +    fload = dload
   1.306 +    fload_0 = dload_0
   1.307 +    fload_1 = dload_1
   1.308 +    fload_2 = dload_2
   1.309 +    fload_3 = dload_3
   1.310 +    fmul = dmul
   1.311 +    fneg = dneg
   1.312 +    frem = drem
   1.313 +    freturn = dreturn
   1.314 +    fstore = dstore
   1.315 +    fstore_0 = dstore_0
   1.316 +    fstore_1 = dstore_1
   1.317 +    fstore_2 = dstore_2
   1.318 +    fstore_3 = dstore_3
   1.319 +    fsub = dsub
   1.320 +
   1.321 +    def getfield(self, arguments, program):
   1.322 +        index = arguments[0] << 8 + arguments[1]
   1.323 +        target_name = self.class_file.constants[index - 1].get_name()
   1.324 +        # NOTE: Using the string version of the name which may contain incompatible characters.
   1.325 +        program.load_attr(str(target_name))
   1.326 +
   1.327 +    getstatic = getfield # Ignoring Java restrictions
   1.328 +
   1.329 +    def goto(self, arguments, program):
   1.330 +        offset = arguments[0] << 8 + arguments[1]
   1.331 +        java_absolute = self.java_position + offset
   1.332 +        program.jump_absolute(self.position_mapping[java_absolute])
   1.333 +
   1.334 +    def goto_w(self, arguments, program):
   1.335 +        offset = arguments[0] << 24 + arguments[1] << 16 + arguments[2] << 8 + arguments[3]
   1.336 +        java_absolute = self.java_position + offset
   1.337 +        program.jump_absolute(self.position_mapping[java_absolute])
   1.338 +
   1.339 +    def i2b(self, arguments, program):
   1.340 +        pass
   1.341  
   1.342 -        arguments = []
   1.343 -        for j in range(0, number_of_arguments):
   1.344 -            arguments.append(ord(code[i + 1 + j]))
   1.345 +    def i2c(self, arguments, program):
   1.346 +        program.load_global("chr")  # Stack: value, chr
   1.347 +        program.rot_two()           # Stack: chr, value
   1.348 +        program.call_function(1)    # Stack: result
   1.349 +
   1.350 +    def i2d(self, arguments, program):
   1.351 +        program.load_global("float")    # Stack: value, float
   1.352 +        program.rot_two()               # Stack: float, value
   1.353 +        program.call_function(1)        # Stack: result
   1.354 +
   1.355 +    i2f = i2d # Not distinguishing between float and double
   1.356 +
   1.357 +    def i2l(self, arguments, program):
   1.358 +        pass # Preserving Java semantics
   1.359 +
   1.360 +    def i2s(self, arguments, program):
   1.361 +        pass # Not distinguishing between int and short
   1.362 +
   1.363 +    iadd = fadd
   1.364 +    iaload = faload
   1.365 +
   1.366 +    def iand(self, arguments, program):
   1.367 +        # NOTE: No type checking performed.
   1.368 +        program.binary_and()
   1.369 +
   1.370 +    iastore = fastore
   1.371 +
   1.372 +    def iconst_m1(self, arguments, program):
   1.373 +        program.load_const(-1)
   1.374 +
   1.375 +    def iconst_0(self, arguments, program):
   1.376 +        program.load_const(0)
   1.377 +
   1.378 +    def iconst_1(self, arguments, program):
   1.379 +        program.load_const(1)
   1.380 +
   1.381 +    def iconst_2(self, arguments, program):
   1.382 +        program.load_const(2)
   1.383 +
   1.384 +    def iconst_3(self, arguments, program):
   1.385 +        program.load_const(3)
   1.386 +
   1.387 +    def iconst_4(self, arguments, program):
   1.388 +        program.load_const(4)
   1.389  
   1.390 -        i = i + 1 + number_of_arguments
   1.391 -        instructions.append((mnemonic, arguments))
   1.392 +    def iconst_5(self, arguments, program):
   1.393 +        program.load_const(5)
   1.394 +
   1.395 +    idiv = fdiv
   1.396 +
   1.397 +    def _if_xcmpx(self, arguments, program, op):
   1.398 +        offset = arguments[0] << 8 + arguments[1]
   1.399 +        java_absolute = self.java_position + offset
   1.400 +        program.compare_op(op)
   1.401 +        program.jump_to_next(0) # skip if false
   1.402 +        program.goto(offset)
   1.403 +        program.start_next()
   1.404 +
   1.405 +    def if_acmpeq(self, arguments, program):
   1.406 +        # NOTE: No type checking performed.
   1.407 +        self._if_xcmpx(arguments, program, "is")
   1.408 +
   1.409 +    def if_acmpne(self, arguments, program):
   1.410 +        # NOTE: No type checking performed.
   1.411 +        self._if_xcmpx(arguments, program, "is not")
   1.412  
   1.413 -    return instructions
   1.414 +    def if_icmpeq(self, arguments, program):
   1.415 +        # NOTE: No type checking performed.
   1.416 +        self._if_xcmpx(arguments, program, "==")
   1.417 +
   1.418 +    def if_icmpne(self, arguments, program):
   1.419 +        # NOTE: No type checking performed.
   1.420 +        self._if_xcmpx(arguments, program, "!=")
   1.421 +
   1.422 +    def if_icmplt(self, arguments, program):
   1.423 +        # NOTE: No type checking performed.
   1.424 +        self._if_xcmpx(arguments, program, "<")
   1.425 +
   1.426 +    def if_icmpge(self, arguments, program):
   1.427 +        # NOTE: No type checking performed.
   1.428 +        self._if_xcmpx(arguments, program, ">=")
   1.429 +
   1.430 +    def if_icmpgt(self, arguments, program):
   1.431 +        # NOTE: No type checking performed.
   1.432 +        self._if_xcmpx(arguments, program, ">")
   1.433 +
   1.434 +    def if_icmple(self, arguments, program):
   1.435 +        # NOTE: No type checking performed.
   1.436 +        self._if_xcmpx(arguments, program, "<=")
   1.437  
   1.438 -java_bytecodes = {
   1.439 -    # code : (mnemonic, number of following bytes, change in stack)
   1.440 -    0 : ("nop", 0, 0),
   1.441 -    1 : ("aconst_null", 0, 1),
   1.442 -    2 : ("iconst_m1", 0, 1),
   1.443 -    3 : ("iconst_0", 0, 1),
   1.444 -    4 : ("iconst_1", 0, 1),
   1.445 -    5 : ("iconst_2", 0, 1),
   1.446 -    6 : ("iconst_3", 0, 1),
   1.447 -    7 : ("iconst_4", 0, 1),
   1.448 -    8 : ("iconst_5", 0, 1),
   1.449 -    9 : ("lconst_0", 0, 1),
   1.450 -    10 : ("lconst_1", 0, 1),
   1.451 -    11 : ("fconst_0", 0, 1),
   1.452 -    12 : ("fconst_1", 0, 1),
   1.453 -    13 : ("fconst_2", 0, 1),
   1.454 -    14 : ("dconst_0", 0, 1),
   1.455 -    15 : ("dconst_1", 0, 1),
   1.456 -    16 : ("bipush", 1, 1),
   1.457 -    17 : ("sipush", 2, 1),
   1.458 -    18 : ("ldc", 1, 1),
   1.459 -    19 : ("ldc_w", 2, 1),
   1.460 -    20 : ("ldc2_w", 2, 1),
   1.461 -    21 : ("iload", 1, 1),
   1.462 -    22 : ("lload", 1, 1),
   1.463 -    23 : ("fload", 1, 1),
   1.464 -    24 : ("dload", 1, 1),
   1.465 -    25 : ("aload", 1, 1),
   1.466 -    26 : ("iload_0", 0, 1),
   1.467 -    27 : ("iload_1", 0, 1),
   1.468 -    28 : ("iload_2", 0, 1),
   1.469 -    29 : ("iload_3", 0, 1),
   1.470 -    30 : ("lload_0", 0, 1),
   1.471 -    31 : ("lload_1", 0, 1),
   1.472 -    32 : ("lload_2", 0, 1),
   1.473 -    33 : ("lload_3", 0, 1),
   1.474 -    34 : ("fload_0", 0, 1),
   1.475 -    35 : ("fload_1", 0, 1),
   1.476 -    36 : ("fload_2", 0, 1),
   1.477 -    37 : ("fload_3", 0, 1),
   1.478 -    38 : ("dload_0", 0, 1),
   1.479 -    39 : ("dload_1", 0, 1),
   1.480 -    40 : ("dload_2", 0, 1),
   1.481 -    41 : ("dload_3", 0, 1),
   1.482 -    42 : ("aload_0", 0, 1),
   1.483 -    43 : ("aload_1", 0, 1),
   1.484 -    44 : ("aload_2", 0, 1),
   1.485 -    45 : ("aload_3", 0, 1),
   1.486 -    46 : ("iaload", 0, -1),
   1.487 -    47 : ("laload", 0, -1),
   1.488 -    48 : ("faload", 0, -1),
   1.489 -    49 : ("daload", 0, -1),
   1.490 -    50 : ("aaload", 0, -1),
   1.491 -    51 : ("baload", 0, -1),
   1.492 -    52 : ("caload", 0, -1),
   1.493 -    53 : ("saload", 0, -1),
   1.494 -    54 : ("istore", 1, -1),
   1.495 -    55 : ("lstore", 1, -1),
   1.496 -    56 : ("fstore", 1, -1),
   1.497 -    57 : ("dstore", 1, -1),
   1.498 -    58 : ("astore", 1, -1),
   1.499 -    59 : ("istore_0", 0, -1),
   1.500 -    60 : ("istore_1", 0, -1),
   1.501 -    61 : ("istore_2", 0, -1),
   1.502 -    62 : ("istore_3", 0, -1),
   1.503 -    63 : ("lstore_0", 0, -1),
   1.504 -    64 : ("lstore_1", 0, -1),
   1.505 -    65 : ("lstore_2", 0, -1),
   1.506 -    66 : ("lstore_3", 0, -1),
   1.507 -    67 : ("fstore_0", 0, -1),
   1.508 -    68 : ("fstore_1", 0, -1),
   1.509 -    69 : ("fstore_2", 0, -1),
   1.510 -    70 : ("fstore_3", 0, -1),
   1.511 -    71 : ("dstore_0", 0, -1),
   1.512 -    72 : ("dstore_1", 0, -1),
   1.513 -    73 : ("dstore_2", 0, -1),
   1.514 -    74 : ("dstore_3", 0, -1),
   1.515 -    75 : ("astore_0", 0, -1),
   1.516 -    76 : ("astore_1", 0, -1),
   1.517 -    77 : ("astore_2", 0, -1),
   1.518 -    78 : ("astore_3", 0, -1),
   1.519 -    79 : ("iastore", 0, -3),
   1.520 -    80 : ("lastore", 0, -3),
   1.521 -    81 : ("fastore", 0, -3),
   1.522 -    82 : ("dastore", 0, -3),
   1.523 -    83 : ("aastore", 0, -3),
   1.524 -    84 : ("bastore", 0, -3),
   1.525 -    85 : ("castore", 0, -3),
   1.526 -    86 : ("sastore", 0, -3),
   1.527 -    87 : ("pop", 0, -1),
   1.528 -    88 : ("pop2", 0, None), # variable number of elements removed
   1.529 -    89 : ("dup", 0, 1),
   1.530 -    90 : ("dup_x1", 0, 1),
   1.531 -    91 : ("dup_x2", 0, 1),
   1.532 -    92 : ("dup2", 0, 2), # or 1 extra stack value
   1.533 -    93 : ("dup2_x1", 0, 2), # or 1 extra stack value
   1.534 -    94 : ("dup2_x2", 0, 2), # or 1 extra stack value
   1.535 -    95 : ("swap", 0, 0),
   1.536 -    96 : ("iadd", 0, -1),
   1.537 -    97 : ("ladd", 0, -1),
   1.538 -    98 : ("fadd", 0, -1),
   1.539 -    99 : ("dadd", 0, -1),
   1.540 -    100 : ("isub", 0, -1),
   1.541 -    101 : ("lsub", 0, -1),
   1.542 -    102 : ("fsub", 0, -1),
   1.543 -    103 : ("dsub", 0, -1),
   1.544 -    104 : ("imul", 0, -1),
   1.545 -    105 : ("lmul", 0, -1),
   1.546 -    106 : ("fmul", 0, -1),
   1.547 -    107 : ("dmul", 0, -1),
   1.548 -    108 : ("idiv", 0, -1),
   1.549 -    109 : ("ldiv", 0, -1),
   1.550 -    110 : ("fdiv", 0, -1),
   1.551 -    111 : ("ddiv", 0, -1),
   1.552 -    112 : ("irem", 0, -1),
   1.553 -    113 : ("lrem", 0, -1),
   1.554 -    114 : ("frem", 0, -1),
   1.555 -    115 : ("drem", 0, -1),
   1.556 -    116 : ("ineg", 0, 0),
   1.557 -    117 : ("lneg", 0, 0),
   1.558 -    118 : ("fneg", 0, 0),
   1.559 -    119 : ("dneg", 0, 0),
   1.560 -    120 : ("ishl", 0, -1),
   1.561 -    121 : ("lshl", 0, -1),
   1.562 -    122 : ("ishr", 0, -1),
   1.563 -    123 : ("lshr", 0, -1),
   1.564 -    124 : ("iushr", 0, -1),
   1.565 -    125 : ("lushr", 0, -1),
   1.566 -    126 : ("iand", 0, -1),
   1.567 -    127 : ("land", 0, -1),
   1.568 -    128 : ("ior", 0, -1),
   1.569 -    129 : ("lor", 0, -1),
   1.570 -    130 : ("ixor", 0, -1),
   1.571 -    131 : ("lxor", 0, -1),
   1.572 -    132 : ("iinc", 2, 0),
   1.573 -    133 : ("i2l", 0, 0),
   1.574 -    134 : ("i2f", 0, 0),
   1.575 -    135 : ("i2d", 0, 0),
   1.576 -    136 : ("l2i", 0, 0),
   1.577 -    137 : ("l2f", 0, 0),
   1.578 -    138 : ("l2d", 0, 0),
   1.579 -    139 : ("f2i", 0, 0),
   1.580 -    140 : ("f2l", 0, 0),
   1.581 -    141 : ("f2d", 0, 0),
   1.582 -    142 : ("d2i", 0, 0),
   1.583 -    143 : ("d2l", 0, 0),
   1.584 -    144 : ("d2f", 0, 0),
   1.585 -    145 : ("i2b", 0, 0),
   1.586 -    146 : ("i2c", 0, 0),
   1.587 -    147 : ("i2s", 0, 0),
   1.588 -    148 : ("lcmp", 0, -1),
   1.589 -    149 : ("fcmpl", 0, -1),
   1.590 -    150 : ("fcmpg", 0, -1),
   1.591 -    151 : ("dcmpl", 0, -1),
   1.592 -    152 : ("dcmpg", 0, -1),
   1.593 -    153 : ("ifeq", 2, -1),
   1.594 -    154 : ("ifne", 2, -1),
   1.595 -    155 : ("iflt", 2, -1),
   1.596 -    156 : ("ifge", 2, -1),
   1.597 -    157 : ("ifgt", 2, -1),
   1.598 -    158 : ("ifle", 2, -1),
   1.599 -    159 : ("if_icmpeq", 2, -2),
   1.600 -    160 : ("if_icmpne", 2, -2),
   1.601 -    161 : ("if_icmplt", 2, -2),
   1.602 -    162 : ("if_icmpge", 2, -2),
   1.603 -    163 : ("if_icmpgt", 2, -2),
   1.604 -    164 : ("if_icmple", 2, -2),
   1.605 -    165 : ("if_acmpeq", 2, -2),
   1.606 -    166 : ("if_acmpne", 2, -2),
   1.607 -    167 : ("goto", 2, 0),
   1.608 -    168 : ("jsr", 2, 1),
   1.609 -    169 : ("ret", 1, 0),
   1.610 -    170 : ("tableswitch", None, -1), # variable number of arguments
   1.611 -    171 : ("lookupswitch", None, -1), # variable number of arguments
   1.612 -    172 : ("ireturn", 0, -1),
   1.613 -    173 : ("lreturn", 0, -1),
   1.614 -    174 : ("freturn", 0, -1),
   1.615 -    175 : ("dreturn", 0, -1),
   1.616 -    176 : ("areturn", 0, -1),
   1.617 -    177 : ("return", 0, 0),
   1.618 -    178 : ("getstatic", 2, 1),
   1.619 -    179 : ("putstatic", 2, -1),
   1.620 -    180 : ("getfield", 2, 0),
   1.621 -    181 : ("putfield", 2, -2),
   1.622 -    182 : ("invokevirtual", 2, None), # variable number of elements removed
   1.623 -    183 : ("invokespecial", 2, None), # variable number of elements removed
   1.624 -    184 : ("invokestatic", 2, None), # variable number of elements removed
   1.625 -    185 : ("invokeinterface", 4, None), # variable number of elements removed
   1.626 -    187 : ("new", 2, 1),
   1.627 -    188 : ("newarray", 1, 0),
   1.628 -    189 : ("anewarray", 2, 0),
   1.629 -    190 : ("arraylength", 0, 0),
   1.630 -    191 : ("athrow", 0, 0),
   1.631 -    192 : ("checkcast", 2, 0),
   1.632 -    193 : ("instanceof", 2, 0),
   1.633 -    194 : ("monitorenter", 0, -1),
   1.634 -    195 : ("monitorexit", 0, -1),
   1.635 -    196 : ("wide", None, None), # 3 or 5 arguments, stack changes according to modified element
   1.636 -    197 : ("multianewarray", 3, None), # variable number of elements removed
   1.637 -    198 : ("ifnull", 2, -1),
   1.638 -    199 : ("ifnonnull", 2, -1),
   1.639 -    200 : ("goto_w", 4, 0),
   1.640 -    201 : ("jsr_w", 4, 1),
   1.641 -    }
   1.642 +    def ifeq(self, arguments, program):
   1.643 +        # NOTE: No type checking performed.
   1.644 +        program.load_const(0)
   1.645 +        self._if_xcmpx(arguments, program, "==")
   1.646 +
   1.647 +    def ifne(self, arguments, program):
   1.648 +        # NOTE: No type checking performed.
   1.649 +        program.load_const(0)
   1.650 +        self._if_xcmpx(arguments, program, "!=")
   1.651 +
   1.652 +    def iflt(self, arguments, program):
   1.653 +        # NOTE: No type checking performed.
   1.654 +        program.load_const(0)
   1.655 +        self._if_xcmpx(arguments, program, "<")
   1.656 +
   1.657 +    def ifge(self, arguments, program):
   1.658 +        # NOTE: No type checking performed.
   1.659 +        program.load_const(0)
   1.660 +        self._if_xcmpx(arguments, program, ">=")
   1.661 +
   1.662 +    def ifgt(self, arguments, program):
   1.663 +        # NOTE: No type checking performed.
   1.664 +        program.load_const(0)
   1.665 +        self._if_xcmpx(arguments, program, ">")
   1.666 +
   1.667 +    def ifle(self, arguments, program):
   1.668 +        # NOTE: No type checking performed.
   1.669 +        program.load_const(0)
   1.670 +        self._if_xcmpx(arguments, program, "<=")
   1.671 +
   1.672 +    def ifnonnull(self, arguments, program):
   1.673 +        # NOTE: No type checking performed.
   1.674 +        program.load_const(None)
   1.675 +        self._if_xcmpx(arguments, program, "is not")
   1.676 +
   1.677 +    def ifnull(self, arguments, program):
   1.678 +        # NOTE: No type checking performed.
   1.679 +        program.load_const(None)
   1.680 +        self._if_xcmpx(arguments, program, "is")
   1.681 +
   1.682 +    def iinc(self, arguments, program):
   1.683 +        # NOTE: No type checking performed.
   1.684 +        program.load_fast(arguments[0])
   1.685 +        program.load_const(arguments[1])
   1.686 +        program.binary_add()
   1.687 +
   1.688 +    iload = fload
   1.689 +    iload_0 = fload_0
   1.690 +    iload_1 = fload_1
   1.691 +    iload_2 = fload_2
   1.692 +    iload_3 = fload_3
   1.693 +    imul = fmul
   1.694 +    ineg = fneg
   1.695 +
   1.696 +    def instanceof(self, arguments, program):
   1.697 +        index = arguments[0] << 8 + arguments[1]
   1.698 +        target_name = self.class_file.constants[index - 1].get_name()
   1.699 +        target_components = target_name.split("/")
   1.700 +
   1.701 +        program.load_global("isinstance")   # Stack: objectref, isinstance
   1.702 +        program.rot_two()                   # Stack: isinstance, objectref
   1.703 +        program.load_global(target_components[0])
   1.704 +        for target_component in target_components[1:]:
   1.705 +            program.load_attr(target_component)
   1.706 +        program.call_function(2)            # Stack: result
   1.707 +
   1.708 +    def _invoke(self, target_name, program):
   1.709 +        program.rot_two()                   # Stack: tuple, objectref
   1.710 +        # NOTE: Using the string version of the name which may contain incompatible characters.
   1.711 +        program.load_attr(str(target_name)) # Stack: tuple, method
   1.712 +        program.rot_two()                   # Stack: method, tuple
   1.713 +        program.load_global("apply")        # Stack: method, tuple, apply
   1.714 +        program.rot_three()                 # Stack: apply, method, tuple
   1.715 +        program.call_function(2)
   1.716 +
   1.717 +    def invokeinterface(self, arguments, program):
   1.718 +        # NOTE: This implementation does not perform the necessary checks for
   1.719 +        # NOTE: signature-based polymorphism.
   1.720 +        # NOTE: Java rules not specifically obeyed.
   1.721 +        index = arguments[0] << 8 + arguments[1]
   1.722 +        count = arguments[2]
   1.723 +        target_name = self.class_file.constants[index - 1].get_name()
   1.724 +        # Stack: objectref, arg1, arg2, ...
   1.725 +        program.build_tuple(count)          # Stack: objectref, tuple
   1.726 +        self._invoke(target_name, program)
   1.727 +
   1.728 +    def invokespecial(self, arguments, program):
   1.729 +        # NOTE: This implementation does not perform the necessary checks for
   1.730 +        # NOTE: signature-based polymorphism.
   1.731 +        # NOTE: Java rules not specifically obeyed.
   1.732 +        index = arguments[0] << 8 + arguments[1]
   1.733 +        target = self.class_file.constants[index - 1]
   1.734 +        target_name = target.get_name()
   1.735 +        # Get the number of parameters from the descriptor.
   1.736 +        count = len(target.get_descriptor()[0])
   1.737 +        # Stack: objectref, arg1, arg2, ...
   1.738 +        program.build_tuple(count)          # Stack: objectref, tuple
   1.739 +        self._invoke(target_name, program)
   1.740 +
   1.741 +    def invokestatic(self, arguments, program):
   1.742 +        # NOTE: This implementation does not perform the necessary checks for
   1.743 +        # NOTE: signature-based polymorphism.
   1.744 +        # NOTE: Java rules not specifically obeyed.
   1.745 +        index = arguments[0] << 8 + arguments[1]
   1.746 +        target = self.class_file.constants[index - 1]
   1.747 +        target_name = target.get_name()
   1.748 +        # Get the number of parameters from the descriptor.
   1.749 +        count = len(target.get_descriptor()[0])
   1.750 +        # Stack: arg1, arg2, ...
   1.751 +        program.build_tuple(count)  # Stack: tuple
   1.752 +        # NOTE: Should probably use Python static methods.
   1.753 +        program.load_name("self")   # Stack: tuple, self
   1.754 +        self._invoke(target_name, program)
   1.755 +
   1.756 +    invokevirtual = invokeinterface # Ignoring Java rules
   1.757 +
   1.758 +    def ior(self, arguments, program):
   1.759 +        # NOTE: No type checking performed.
   1.760 +        program.binary_or()
   1.761 +
   1.762 +    irem = frem
   1.763 +    ireturn = freturn
   1.764 +
   1.765 +    def ishl(self, arguments, program):
   1.766 +        # NOTE: No type checking performed.
   1.767 +        # NOTE: Not verified.
   1.768 +        program.binary_lshift()
   1.769 +
   1.770 +    def ishr(self, arguments, program):
   1.771 +        # NOTE: No type checking performed.
   1.772 +        # NOTE: Not verified.
   1.773 +        program.binary_rshift()
   1.774 +
   1.775 +    istore = fstore
   1.776 +    istore_0 = fstore_0
   1.777 +    istore_1 = fstore_1
   1.778 +    istore_2 = fstore_2
   1.779 +    istore_3 = fstore_3
   1.780 +    isub = fsub
   1.781 +    iushr = ishr # Ignoring distinctions between arithmetic and logical shifts
   1.782 +
   1.783 +    def ishr(self, arguments, program):
   1.784 +        # NOTE: No type checking performed.
   1.785 +        program.binary_xor()
   1.786 +
   1.787 +    def jsr(self, arguments, program):
   1.788 +        offset = arguments[0] << 8 + arguments[1]
   1.789 +        java_absolute = self.java_position + offset
   1.790 +        # NOTE: To be implemented.
   1.791 +
   1.792 +    def wide(self, code, program):
   1.793 +        # NOTE: To be implemented.
   1.794 +        return number_of_arguments
   1.795 +
   1.796 +    java_bytecodes = {
   1.797 +        # code : (mnemonic, number of following bytes, change in stack)
   1.798 +        0 : ("nop", 0),
   1.799 +        1 : ("aconst_null", 0),
   1.800 +        2 : ("iconst_m1", 0),
   1.801 +        3 : ("iconst_0", 0),
   1.802 +        4 : ("iconst_1", 0),
   1.803 +        5 : ("iconst_2", 0),
   1.804 +        6 : ("iconst_3", 0),
   1.805 +        7 : ("iconst_4", 0),
   1.806 +        8 : ("iconst_5", 0),
   1.807 +        9 : ("lconst_0", 0),
   1.808 +        10 : ("lconst_1", 0),
   1.809 +        11 : ("fconst_0", 0),
   1.810 +        12 : ("fconst_1", 0),
   1.811 +        13 : ("fconst_2", 0),
   1.812 +        14 : ("dconst_0", 0),
   1.813 +        15 : ("dconst_1", 0),
   1.814 +        16 : ("bipush", 1),
   1.815 +        17 : ("sipush", 2),
   1.816 +        18 : ("ldc", 1),
   1.817 +        19 : ("ldc_w", 2),
   1.818 +        20 : ("ldc2_w", 2),
   1.819 +        21 : ("iload", 1),
   1.820 +        22 : ("lload", 1),
   1.821 +        23 : ("fload", 1),
   1.822 +        24 : ("dload", 1),
   1.823 +        25 : ("aload", 1),
   1.824 +        26 : ("iload_0", 0),
   1.825 +        27 : ("iload_1", 0),
   1.826 +        28 : ("iload_2", 0),
   1.827 +        29 : ("iload_3", 0),
   1.828 +        30 : ("lload_0", 0),
   1.829 +        31 : ("lload_1", 0),
   1.830 +        32 : ("lload_2", 0),
   1.831 +        33 : ("lload_3", 0),
   1.832 +        34 : ("fload_0", 0),
   1.833 +        35 : ("fload_1", 0),
   1.834 +        36 : ("fload_2", 0),
   1.835 +        37 : ("fload_3", 0),
   1.836 +        38 : ("dload_0", 0),
   1.837 +        39 : ("dload_1", 0),
   1.838 +        40 : ("dload_2", 0),
   1.839 +        41 : ("dload_3", 0),
   1.840 +        42 : ("aload_0", 0),
   1.841 +        43 : ("aload_1", 0),
   1.842 +        44 : ("aload_2", 0),
   1.843 +        45 : ("aload_3", 0),
   1.844 +        46 : ("iaload", 0),
   1.845 +        47 : ("laload", 0),
   1.846 +        48 : ("faload", 0),
   1.847 +        49 : ("daload", 0),
   1.848 +        50 : ("aaload", 0),
   1.849 +        51 : ("baload", 0),
   1.850 +        52 : ("caload", 0),
   1.851 +        53 : ("saload", 0),
   1.852 +        54 : ("istore", 1),
   1.853 +        55 : ("lstore", 1),
   1.854 +        56 : ("fstore", 1),
   1.855 +        57 : ("dstore", 1),
   1.856 +        58 : ("astore", 1),
   1.857 +        59 : ("istore_0", 0),
   1.858 +        60 : ("istore_1", 0),
   1.859 +        61 : ("istore_2", 0),
   1.860 +        62 : ("istore_3", 0),
   1.861 +        63 : ("lstore_0", 0),
   1.862 +        64 : ("lstore_1", 0),
   1.863 +        65 : ("lstore_2", 0),
   1.864 +        66 : ("lstore_3", 0),
   1.865 +        67 : ("fstore_0", 0),
   1.866 +        68 : ("fstore_1", 0),
   1.867 +        69 : ("fstore_2", 0),
   1.868 +        70 : ("fstore_3", 0),
   1.869 +        71 : ("dstore_0", 0),
   1.870 +        72 : ("dstore_1", 0),
   1.871 +        73 : ("dstore_2", 0),
   1.872 +        74 : ("dstore_3", 0),
   1.873 +        75 : ("astore_0", 0),
   1.874 +        76 : ("astore_1", 0),
   1.875 +        77 : ("astore_2", 0),
   1.876 +        78 : ("astore_3", 0),
   1.877 +        79 : ("iastore", 0),
   1.878 +        80 : ("lastore", 0),
   1.879 +        81 : ("fastore", 0),
   1.880 +        82 : ("dastore", 0),
   1.881 +        83 : ("aastore", 0),
   1.882 +        84 : ("bastore", 0),
   1.883 +        85 : ("castore", 0),
   1.884 +        86 : ("sastore", 0),
   1.885 +        87 : ("pop", 0),
   1.886 +        88 : ("pop2", 0),
   1.887 +        89 : ("dup", 0),
   1.888 +        90 : ("dup_x1", 0),
   1.889 +        91 : ("dup_x2", 0),
   1.890 +        92 : ("dup2", 0),
   1.891 +        93 : ("dup2_x1", 0),
   1.892 +        94 : ("dup2_x2", 0),
   1.893 +        95 : ("swap", 0),
   1.894 +        96 : ("iadd", 0),
   1.895 +        97 : ("ladd", 0),
   1.896 +        98 : ("fadd", 0),
   1.897 +        99 : ("dadd", 0),
   1.898 +        100 : ("isub", 0),
   1.899 +        101 : ("lsub", 0),
   1.900 +        102 : ("fsub", 0),
   1.901 +        103 : ("dsub", 0),
   1.902 +        104 : ("imul", 0),
   1.903 +        105 : ("lmul", 0),
   1.904 +        106 : ("fmul", 0),
   1.905 +        107 : ("dmul", 0),
   1.906 +        108 : ("idiv", 0),
   1.907 +        109 : ("ldiv", 0),
   1.908 +        110 : ("fdiv", 0),
   1.909 +        111 : ("ddiv", 0),
   1.910 +        112 : ("irem", 0),
   1.911 +        113 : ("lrem", 0),
   1.912 +        114 : ("frem", 0),
   1.913 +        115 : ("drem", 0),
   1.914 +        116 : ("ineg", 0),
   1.915 +        117 : ("lneg", 0),
   1.916 +        118 : ("fneg", 0),
   1.917 +        119 : ("dneg", 0),
   1.918 +        120 : ("ishl", 0),
   1.919 +        121 : ("lshl", 0),
   1.920 +        122 : ("ishr", 0),
   1.921 +        123 : ("lshr", 0),
   1.922 +        124 : ("iushr", 0),
   1.923 +        125 : ("lushr", 0),
   1.924 +        126 : ("iand", 0),
   1.925 +        127 : ("land", 0),
   1.926 +        128 : ("ior", 0),
   1.927 +        129 : ("lor", 0),
   1.928 +        130 : ("ixor", 0),
   1.929 +        131 : ("lxor", 0),
   1.930 +        132 : ("iinc", 2),
   1.931 +        133 : ("i2l", 0),
   1.932 +        134 : ("i2f", 0),
   1.933 +        135 : ("i2d", 0),
   1.934 +        136 : ("l2i", 0),
   1.935 +        137 : ("l2f", 0),
   1.936 +        138 : ("l2d", 0),
   1.937 +        139 : ("f2i", 0),
   1.938 +        140 : ("f2l", 0),
   1.939 +        141 : ("f2d", 0),
   1.940 +        142 : ("d2i", 0),
   1.941 +        143 : ("d2l", 0),
   1.942 +        144 : ("d2f", 0),
   1.943 +        145 : ("i2b", 0),
   1.944 +        146 : ("i2c", 0),
   1.945 +        147 : ("i2s", 0),
   1.946 +        148 : ("lcmp", 0),
   1.947 +        149 : ("fcmpl", 0),
   1.948 +        150 : ("fcmpg", 0),
   1.949 +        151 : ("dcmpl", 0),
   1.950 +        152 : ("dcmpg", 0),
   1.951 +        153 : ("ifeq", 2),
   1.952 +        154 : ("ifne", 2),
   1.953 +        155 : ("iflt", 2),
   1.954 +        156 : ("ifge", 2),
   1.955 +        157 : ("ifgt", 2),
   1.956 +        158 : ("ifle", 2),
   1.957 +        159 : ("if_icmpeq", 2),
   1.958 +        160 : ("if_icmpne", 2),
   1.959 +        161 : ("if_icmplt", 2),
   1.960 +        162 : ("if_icmpge", 2),
   1.961 +        163 : ("if_icmpgt", 2),
   1.962 +        164 : ("if_icmple", 2),
   1.963 +        165 : ("if_acmpeq", 2),
   1.964 +        166 : ("if_acmpne", 2),
   1.965 +        167 : ("goto", 2),
   1.966 +        168 : ("jsr", 2),
   1.967 +        169 : ("ret", 1),
   1.968 +        170 : ("tableswitch", None), # variable number of arguments
   1.969 +        171 : ("lookupswitch", None), # variable number of arguments
   1.970 +        172 : ("ireturn", 0),
   1.971 +        173 : ("lreturn", 0),
   1.972 +        174 : ("freturn", 0),
   1.973 +        175 : ("dreturn", 0),
   1.974 +        176 : ("areturn", 0),
   1.975 +        177 : ("return", 0),
   1.976 +        178 : ("getstatic", 2),
   1.977 +        179 : ("putstatic", 2),
   1.978 +        180 : ("getfield", 2),
   1.979 +        181 : ("putfield", 2),
   1.980 +        182 : ("invokevirtual", 2),
   1.981 +        183 : ("invokespecial", 2),
   1.982 +        184 : ("invokestatic", 2),
   1.983 +        185 : ("invokeinterface", 4),
   1.984 +        187 : ("new", 2),
   1.985 +        188 : ("newarray", 1),
   1.986 +        189 : ("anewarray", 2),
   1.987 +        190 : ("arraylength", 0),
   1.988 +        191 : ("athrow", 0),
   1.989 +        192 : ("checkcast", 2),
   1.990 +        193 : ("instanceof", 2),
   1.991 +        194 : ("monitorenter", 0),
   1.992 +        195 : ("monitorexit", 0),
   1.993 +        196 : ("wide", None), # 3 or 5 arguments, stack changes according to modified element
   1.994 +        197 : ("multianewarray", 3),
   1.995 +        198 : ("ifnull", 2),
   1.996 +        199 : ("ifnonnull", 2),
   1.997 +        200 : ("goto_w", 4),
   1.998 +        201 : ("jsr_w", 4),
   1.999 +        }
  1.1000 +
  1.1001 +if __name__ == "__main__":
  1.1002 +    import sys
  1.1003 +    from classfile import ClassFile
  1.1004 +    f = open(sys.argv[1])
  1.1005 +    c = ClassFile(f.read())
  1.1006  
  1.1007  # vim: tabstop=4 expandtab shiftwidth=4