Rename pc to program_counter

Author: cburgdorf

eth/abc.py

@@ -827,7 +827,10 @@ def dup(self, position: int) -> None:
 
 
 class CodeStreamAPI(ABC):
-    pc: int
+    """
+    A class representing a stream of EVM code.
+    """
+    program_counter: int
 
     @abstractmethod
     def read(self, size: int) -> bytes:
@@ -850,7 +853,11 @@ def peek(self) -> int:
         ...
 
     @abstractmethod
-    def seek(self, pc: int) -> ContextManager['CodeStreamAPI']:
+    def seek(self, program_counter: int) -> ContextManager['CodeStreamAPI']:
+        """
+        Return a :class:`~typing.ContextManager` with the program counter
+        set to ``program_counter``.
+        """
         ...
 
     @abstractmethod

eth/tools/_utils/slow_code_stream.py

@@ -65,27 +65,27 @@ def __next__(self) -> int:
             return STOP
 
     def peek(self) -> int:
-        current_pc = self.pc
+        current_pc = self.program_counter
         next_opcode = next(self)
-        self.pc = current_pc
+        self.program_counter = current_pc
         return next_opcode
 
     @property
-    def pc(self) -> int:
+    def program_counter(self) -> int:
         return self.stream.tell()
 
-    @pc.setter
-    def pc(self, value: int) -> None:
+    @program_counter.setter
+    def program_counter(self, value: int) -> None:
         self.stream.seek(min(value, len(self)))
 
     @contextlib.contextmanager
     def seek(self, pc: int) -> Iterator['SlowCodeStream']:
-        anchor_pc = self.pc
-        self.pc = pc
+        anchor_pc = self.program_counter
+        self.program_counter = pc
         try:
             yield self
         finally:
-            self.pc = anchor_pc
+            self.program_counter = anchor_pc
 
     def _potentially_disqualifying_opcode_positions(self, position: int) -> Iterator[int]:
         # Look at the last 32 positions (from 1 byte back to 32 bytes back).

eth/vm/code_stream.py

@@ -26,17 +26,17 @@ def __init__(self, code_bytes: bytes) -> None:
         # in order to avoid method overhead when setting/accessing pc, we no longer fence
         # the pc (Program Counter) into 0 <= pc <= len(code_bytes). We now let it float free.
         # NOTE: Setting pc to a negative value has undefined behavior.
-        self.pc = 0
+        self.program_counter = 0
         self._raw_code_bytes = code_bytes
         self._length_cache = len(code_bytes)
         self.invalid_positions: Set[int] = set()
         self.valid_positions: Set[int] = set()
 
     def read(self, size: int) -> bytes:
-        old_pc = self.pc
-        target_pc = old_pc + size
-        self.pc = target_pc
-        return self._raw_code_bytes[old_pc:target_pc]
+        old_program_counter = self.program_counter
+        target_program_counter = old_program_counter + size
+        self.program_counter = target_program_counter
+        return self._raw_code_bytes[old_program_counter:target_program_counter]
 
     def __len__(self) -> int:
         return self._length_cache
@@ -46,31 +46,31 @@ def __getitem__(self, i: int) -> int:
 
     def __iter__(self) -> Iterator[int]:
         # a very performance-sensitive method
-        pc = self.pc
+        pc = self.program_counter
         while pc < self._length_cache:
             opcode = self._raw_code_bytes[pc]
-            self.pc = pc + 1
+            self.program_counter = pc + 1
             yield opcode
             # a read might have adjusted the pc during the last yield
-            pc = self.pc
+            pc = self.program_counter
 
         yield STOP
 
     def peek(self) -> int:
-        pc = self.pc
+        pc = self.program_counter
         if pc < self._length_cache:
             return self._raw_code_bytes[pc]
         else:
             return STOP
 
     @contextlib.contextmanager
-    def seek(self, pc: int) -> Iterator['CodeStream']:
-        anchor_pc = self.pc
-        self.pc = pc
+    def seek(self, program_counter: int) -> Iterator['CodeStream']:
+        anchor_pc = self.program_counter
+        self.program_counter = program_counter
         try:
             yield self
         finally:
-            self.pc = anchor_pc
+            self.program_counter = anchor_pc
 
     def _potentially_disqualifying_opcode_positions(self, position: int) -> Iterator[int]:
         # Look at the last 32 positions (from 1 byte back to 32 bytes back).

eth/vm/computation.py

@@ -547,7 +547,7 @@ def apply_computation(cls,
                         "OPCODE: 0x%x (%s) | pc: %s",
                         opcode,
                         opcode_fn.mnemonic,
-                        max(0, computation.code.pc - 1),
+                        max(0, computation.code.program_counter - 1),
                     )
 
                 try:

eth/vm/forks/frontier/opcodes.py

@@ -301,7 +301,7 @@
         gas_cost=constants.GAS_HIGH,
     ),
     opcode_values.PC: as_opcode(
-        logic_fn=flow.pc,
+        logic_fn=flow.program_counter,
         mnemonic=mnemonics.PC,
         gas_cost=constants.GAS_BASE,
     ),

eth/vm/logic/flow.py

@@ -17,7 +17,7 @@ def stop(computation: BaseComputation) -> None:
 def jump(computation: BaseComputation) -> None:
     jump_dest = computation.stack_pop1_int()
 
-    computation.code.pc = jump_dest
+    computation.code.program_counter = jump_dest
 
     next_opcode = computation.code.peek()
 
@@ -32,7 +32,7 @@ def jumpi(computation: BaseComputation) -> None:
     jump_dest, check_value = computation.stack_pop_ints(2)
 
     if check_value:
-        computation.code.pc = jump_dest
+        computation.code.program_counter = jump_dest
 
         next_opcode = computation.code.peek()
 
@@ -47,8 +47,8 @@ def jumpdest(computation: BaseComputation) -> None:
     pass
 
 
-def pc(computation: BaseComputation) -> None:
-    pc = max(computation.code.pc - 1, 0)
+def program_counter(computation: BaseComputation) -> None:
+    pc = max(computation.code.program_counter - 1, 0)
 
     computation.stack_push_int(pc)
 

eth/vm/logic/invalid.py

@@ -13,5 +13,5 @@ def __init__(self, value: int) -> None:
 
     def __call__(self, computation: ComputationAPI) -> None:
         raise InvalidInstruction(
-            f"Invalid opcode 0x{self.value:x} @ {computation.code.pc - 1}"
+            f"Invalid opcode 0x{self.value:x} @ {computation.code.program_counter - 1}"
         )

tests/core/code-stream/test_code_stream.py

@@ -39,13 +39,13 @@ def test_next_returns_the_correct_next_opcode():
 def test_peek_returns_next_opcode_without_changing_code_stream_location():
     code_stream = CodeStream(b'\x01\x02\x30')
     code_iter = iter(code_stream)
-    assert code_stream.pc == 0
+    assert code_stream.program_counter == 0
     assert code_stream.peek() == opcode_values.ADD
-    assert code_stream.pc == 0
+    assert code_stream.program_counter == 0
     assert next(code_iter) == opcode_values.ADD
-    assert code_stream.pc == 1
+    assert code_stream.program_counter == 1
     assert code_stream.peek() == opcode_values.MUL
-    assert code_stream.pc == 1
+    assert code_stream.program_counter == 1
 
 
 def test_STOP_opcode_is_returned_when_bytecode_end_is_reached():
@@ -59,11 +59,11 @@ def test_STOP_opcode_is_returned_when_bytecode_end_is_reached():
 def test_seek_reverts_to_original_stream_position_when_context_exits():
     code_stream = CodeStream(b'\x01\x02\x30')
     code_iter = iter(code_stream)
-    assert code_stream.pc == 0
+    assert code_stream.program_counter == 0
     with code_stream.seek(1):
-        assert code_stream.pc == 1
+        assert code_stream.program_counter == 1
         assert next(code_iter) == opcode_values.MUL
-    assert code_stream.pc == 0
+    assert code_stream.program_counter == 0
     assert code_stream.peek() == opcode_values.ADD
 
 
@@ -198,9 +198,9 @@ def test_new_vs_reference_code_stream_iter(bytecode):
     latest = CodeStream(bytecode)
     for expected_op, actual_op in zip(reference, latest):
         assert expected_op == actual_op
-        assert reference.pc == latest.pc
+        assert reference.program_counter == latest.program_counter
 
-    assert latest.pc == reference.pc
+    assert latest.program_counter == reference.program_counter
 
 
 @given(read_len=st.integers(min_value=0), bytecode=st.binary(max_size=128))
@@ -211,7 +211,7 @@ def test_new_vs_reference_code_stream_read(read_len, bytecode):
     readout_actual = latest.read(read_len)
     assert readout_expected == readout_actual
     if read_len <= len(bytecode):
-        assert latest.pc == reference.pc
+        assert latest.program_counter == reference.program_counter
     assert latest.read(1) == reference.read(1)
 
 
@@ -229,7 +229,7 @@ def test_new_vs_reference_code_stream_read_during_iter(read_idx, read_len, bytec
             readout_actual = latest.read(read_len)
             readout_expected = reference.read(read_len)
             assert readout_expected == readout_actual
-        if reference.pc >= len(reference):
-            assert latest.pc >= len(reference)
+        if reference.program_counter >= len(reference):
+            assert latest.program_counter >= len(reference)
         else:
-            assert latest.pc == reference.pc
+            assert latest.program_counter == reference.program_counter