Rename offset to pc refactor to match trailofbits/manticore#938

Author: computerality

pyevmasm/evmasm2.py

@@ -62,7 +62,7 @@ class EVMAsm(object):
             'PUSH1 0x60\\nBLOCKHASH\\nMSTORE\\nPUSH1 0x2\\nPUSH2 0x100'
     '''
     class Instruction(object):
-        def __init__(self, opcode, name, operand_size, pops, pushes, fee, description, operand=None, offset=0):
+        def __init__(self, opcode, name, operand_size, pops, pushes, fee, description, operand=None, pc=0):
             '''
             This represents an EVM instruction.
             EVMAsm will create this for you.
@@ -75,15 +75,15 @@ def __init__(self, opcode, name, operand_size, pops, pushes, fee, description, o
             :param fee: gas fee for the instruction
             :param description: textual description of the instruction
             :param operand: optional immediate operand
-            :param offset: optional offset of this instruction in the program
+            :param pc: optional program counter of this instruction in the program
 
             Example use::
 
                 instruction = EVMAsm.assemble_one('PUSH1 0x10')
                 print 'Instruction: %s'% instruction
                 print '\tdescription:', instruction.description
                 print '\tgroup:', instruction.group
-                print '\taddress:', instruction.offset
+                print '\tpc:', instruction.pc
                 print '\tsize:', instruction.size
                 print '\thas_operand:', instruction.has_operand
                 print '\toperand_size:', instruction.operand_size
@@ -114,7 +114,7 @@ def __init__(self, opcode, name, operand_size, pops, pushes, fee, description, o
                 mask = (1 << operand_size * 8) - 1
                 if ~mask & operand:
                     raise ValueError("operand should be %d bits long" % (operand_size * 8))
-            self._offset = offset
+            self._pc = pc
 
         def __eq__(self, other):
             ''' Instructions are equal if all features match '''
@@ -125,12 +125,12 @@ def __eq__(self, other):
                 self._pops == other._pops and\
                 self._pushes == other._pushes and\
                 self._fee == other._fee and\
-                self._offset == other._offset and\
+                self._pc == other._pc and\
                 self._description == other._description
 
         def __repr__(self):
             output = 'Instruction(0x%x, %r, %d, %d, %d, %d, %r, %r, %r)' % (self._opcode, self._name, self._operand_size,
-                                                                            self._pops, self._pushes, self._fee, self._description, self._operand, self._offset)
+                                                                            self._pops, self._pushes, self._fee, self._description, self._operand, self._pc)
             return output
 
         def __str__(self):
@@ -227,9 +227,9 @@ def bytes(self):
             return ''.join(bytes)
 
         @property
-        def offset(self):
+        def pc(self):
             '''Location in the program (optional)'''
-            return self._offset
+            return self._pc
 
         @property
         def group(self):
@@ -481,11 +481,11 @@ def _get_reverse_table():
         return reverse_table
 
     @staticmethod
-    def assemble_one(assembler, offset=0):
+    def assemble_one(assembler, pc=0):
         ''' Assemble one EVM instruction from its textual representation.
 
             :param assembler: assembler code for one instruction
-            :param offset: offset of the instruction in the bytecode (optional)
+            :param pc: program counter of the instruction (optional)
             :return: An Instruction object
 
             Example use::
@@ -505,18 +505,18 @@ def assemble_one(assembler, offset=0):
                 assert len(assembler) == 1
                 operand = None
 
-            return EVMAsm.Instruction(opcode, name, operand_size, pops, pushes, gas, description, operand=operand, offset=offset)
+            return EVMAsm.Instruction(opcode, name, operand_size, pops, pushes, gas, description, operand=operand, pc=pc)
         except Exception as e:
             print "Exception", repr(e)
 
-            raise Exception("Something wrong at offset %d" % offset)
+            raise Exception("Something wrong at pc %d" % pc)
 
     @staticmethod
-    def assemble_all(assembler, offset=0):
+    def assemble_all(assembler, pc=0):
         ''' Assemble a sequence of textual representation of EVM instructions
 
             :param assembler: assembler code for any number of instructions
-            :param offset: offset of the first instruction in the bytecode(optional)
+            :param pc: program counter of the first instruction (optional)
             :return: An generator of Instruction objects
 
             Example use::
@@ -540,17 +540,17 @@ def assemble_all(assembler, offset=0):
         for line in assembler:
             if not line.strip():
                 continue
-            instr = EVMAsm.assemble_one(line, offset=offset)
+            instr = EVMAsm.assemble_one(line, pc=pc)
             yield instr
-            offset += instr.size
+            pc += instr.size
 
     @staticmethod
-    def disassemble_one(bytecode, offset=0):
+    def disassemble_one(bytecode, pc=0):
         ''' Decode a single instruction from a bytecode
 
             :param bytecode: the bytecode stream
             :type bytecode: bytearray or str
-            :param offset: offset of the instruction in the bytecode(optional)
+            :param pc: program counter of the instruction (optional)
             :type bytecode: iterator/sequence/str
             :return: an Instruction object
 
@@ -567,18 +567,18 @@ def disassemble_one(bytecode, offset=0):
 
         invalid = ('INVALID', 0, 0, 0, 0, 'Unknown opcode')
         name, operand_size, pops, pushes, gas, description = EVMAsm._table.get(opcode, invalid)
-        instruction = EVMAsm.Instruction(opcode, name, operand_size, pops, pushes, gas, description, offset=offset)
+        instruction = EVMAsm.Instruction(opcode, name, operand_size, pops, pushes, gas, description, pc=pc)
         if instruction.has_operand:
             instruction.parse_operand(bytecode)
 
         return instruction
 
     @staticmethod
-    def disassemble_all(bytecode, offset=0):
+    def disassemble_all(bytecode, pc=0):
         ''' Decode all instructions in bytecode
 
             :param bytecode: an evm bytecode (binary)
-            :param offset: offset of the first instruction in the bytecode(optional)
+            :param pc: program counter of the first instruction (optional)
             :type bytecode: iterator/sequence/str
             :return: An generator of Instruction objects
 
@@ -606,16 +606,16 @@ def disassemble_all(bytecode, offset=0):
             bytecode = bytearray(bytecode)
         bytecode = iter(bytecode)
         while True:
-            instr = EVMAsm.disassemble_one(bytecode, offset=offset)
-            offset += instr.size
+            instr = EVMAsm.disassemble_one(bytecode, pc=pc)
+            pc += instr.size
             yield instr
 
     @staticmethod
-    def disassemble(bytecode, offset=0):
+    def disassemble(bytecode, pc=0):
         ''' Disassemble an EVM bytecode
 
             :param bytecode: binary representation of an evm bytecode (hexadecimal)
-            :param offset: offset of the first instruction in the bytecode(optional)
+            :param pc: program counter of the first instruction (optional)
             :type bytecode: str
             :return: the text representation of the aseembler code
 
@@ -630,14 +630,14 @@ def disassemble(bytecode, offset=0):
                 PUSH2 0x100
 
         '''
-        return '\n'.join(map(str, EVMAsm.disassemble_all(bytecode, offset=offset)))
+        return '\n'.join(map(str, EVMAsm.disassemble_all(bytecode, pc=pc)))
 
     @staticmethod
-    def assemble(asmcode, offset=0):
+    def assemble(asmcode, pc=0):
         ''' Assemble an EVM program
 
             :param asmcode: an evm assembler program
-            :param offset: offset of the first instruction in the bytecode(optional)
+            :param pc: program counter of the first instruction (optional)
             :type asmcode: str
             :return: the hex representation of the bytecode
 
@@ -653,14 +653,14 @@ def assemble(asmcode, offset=0):
                 ...
                 "\x60\x60\x60\x40\x52\x60\x02\x61\x01\x00"
         '''
-        return ''.join(map(lambda x: x.bytes, EVMAsm.assemble_all(asmcode, offset=offset)))
+        return ''.join(map(lambda x: x.bytes, EVMAsm.assemble_all(asmcode, pc=pc)))
 
     @staticmethod
-    def disassemble_hex(bytecode, offset=0):
+    def disassemble_hex(bytecode, pc=0):
         ''' Disassemble an EVM bytecode
 
             :param bytecode: canonical representation of an evm bytecode (hexadecimal)
-            :param int offset: offset of the first instruction in the bytecode(optional)
+            :param pc: program counter of the first instruction (optional)
             :type bytecode: str
             :return: the text representation of the aseembler code
 
@@ -678,14 +678,14 @@ def disassemble_hex(bytecode, offset=0):
         if bytecode.startswith('0x'):
             bytecode = bytecode[2:]
         bytecode = bytecode.decode('hex')
-        return EVMAsm.disassemble(bytecode, offset=offset)
+        return EVMAsm.disassemble(bytecode, pc=pc)
 
     @staticmethod
-    def assemble_hex(asmcode, offset=0):
+    def assemble_hex(asmcode, pc=0):
         ''' Assemble an EVM program
 
             :param asmcode: an evm assembler program
-            :param offset: offset of the first instruction in the bytecode(optional)
+            :param pc: program counter of the first instruction (optional)
             :type asmcode: str
             :return: the hex representation of the bytecode
 
@@ -701,4 +701,4 @@ def assemble_hex(asmcode, offset=0):
                 ...
                 "0x6060604052600261010"
         '''
-        return '0x' + EVMAsm.assemble(asmcode, offset=offset).encode('hex')
+        return '0x' + EVMAsm.assemble(asmcode, pc=pc).encode('hex')