Merge pull request #1 from dluman/stack-and-pointer

Stack

Author: dluman

.gitignore

@@ -160,3 +160,6 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+# SWP files, BEGONE!
+*.swp

README.md

@@ -25,7 +25,21 @@ This project is available via `PyPI`: `python -m pip install paperpc`.
 |`8xx`          |`BRP`               |`BRANCH IF POSITIVE`| Verifies `Accumulator` value is greater than `0`; if so, set `Program Counter` to value `xx`, prepare to execute value in `xx` |`No` |
 |`901`          |`INP`               |`INPUT`     |Read a single value fromw waiting input, replace `Accumulator` value|`Yes` |
 |`902`          |`OUT`               |`OUTPUT`    |Output the current value of the `Accumulator`|`No` |
-|`000`          |`HLT`               |`HALT`      |Terminates program |
+|`903`          |`PSH`               |`PUSH`      |Push a value to the machine's dedicated stack (080) |`No` |
+|`904`          |`POP`               |`POP`       |Pop a value from the machine's dedicated stack |`Yes` |
+|`905`          |`PTR`               |`STACK POINTER`|Retrieves and loads the current stack pointer to the `Accumulator`|`Yes` |
+|`906`          |`SHI`               |`STACK HEIGHT` |Calculates and places the current stack height in the `Accumulator`|`Yes` |
+|`000`          |`HLT`               |`HALT`      |Terminates program |`No` |
+
+### The stack
+
+The PaperPC stack starts at storage `080`. It occupies 18 spaces (limit `098`). This memory range may be used by
+general heap operations (i.e. values can be assigned to this range). However, any stack operation will overwrite
+values in the range starting at the stack pointer base, `080`. The stack overflows if the value of the stack pointer
+increments above `098`.
+
+In future releases, this will be configurable (e.g. a configuration file can remap, increase, or decrease the stack
+size). This is planned, but not yet implemented as a `.pcconfig` file, existing on a per-project basis.
 
 ## Using the program
 

examples/.pcconfig

@@ -0,0 +1,3 @@
+storage:
+    stack_size: 18
+    stack_base: 80

examples/example.ppc

@@ -0,0 +1,7 @@
+1    901    @ Read one value from input to Accumulator
+2    360    @ Store in memory location 060
+3    901    @ Read one value from input to Accumulator
+4    648    @ Unconditional branch to data in 048
+48   160    @ Add data in 060 to Accumulator
+49   902    @ Output the sum stored in the Accumulator
+50   000    @ Halt

examples/stack.ppc

@@ -0,0 +1,13 @@
+1   901     @ Take an input
+2   903     @ Push it to the stack
+3   901     @ Take another input
+4   903     @ Push another to stack
+5   901     @ Take an input
+6   903     @ Push new value to stack
+7   901     @ Take in another value to overflow
+8   903     @ Push new value to stack
+9   905     @ Get the stack pointer value
+10  902     @ Output the value
+11  906     @ Calculate the stack height
+12  902     @ Output the value
+13  000     @ Halt

pyproject.toml

@@ -6,7 +6,8 @@ build-backend = "setuptools.build_meta:__legacy__"
 name = "PaperPC"
 version = "0.3.0"
 dependencies = [
-    "arglite"
+    "arglite",
+    "pyyaml"
 ]
 authors = [
     {name = "Douglas Luman", email = "[email protected]"}

src/paperpc/cmd.py

@@ -70,7 +70,12 @@ def __init__(self, show_speed: bool = False):
             "8": {"cmd": self.__brp, "cycles": 2},
             "901": {"cmd": self.__inp, "cycles": 1},
             "902": {"cmd": self.__out, "cycles": 1},
-            "0": {"cmd": self.__hlt, "cycles": 0}
+            "903": {"cmd": self.__push, "cycles": 1},
+            "904": {"cmd": self.__pop, "cycles": 2},
+            "905": {"cmd": self.__ptr, "cycles": 2},
+            "906": {"cmd": self.__shi, "cycles": 3},
+            "000": {"cmd": self.__hlt, "cycles": 0},
+            "0": {"cmd": self.__ptr, "cycles": 2}
         }
         self._show_speed = show_speed
         self._total_clock = 0
@@ -87,6 +92,11 @@ def parse(self, **kwargs):
         if self._arg == "9":
             self._arg = kwargs['arg']
         try:
+            # Carve out specific escape for HALT instruction; the following
+            # is always true
+            if self._arg == "0" and self._val == 0:
+                # The command must be a HALT instruction
+                self._arg = "000"
             self._total_clock += self._syntax[self._arg]["cycles"]
             return self._syntax[self._arg]["cmd"]
         except:
@@ -131,6 +141,32 @@ def __brp(self, acc, storage):
         else:
             storage._counter += 1
 
+    @storage
+    def __push(self, acc, storage):
+        stack_len = len(storage.stack)
+        storage.stack_ptr = storage.stack_base + stack_len
+        storage.stack.append(acc.value)
+        if storage.stack_ptr - storage.stack_base > storage.stack_size:
+            print("[ERROR] Stack overflow!")
+            sys.exit(1)
+        storage._spaces[storage.stack_ptr] = acc.value
+
+    @storage
+    def __pop(self, acc, storage):
+        stack_len = len(storage.stack)
+        stack_pos = storage.stack_base + stack_len
+        storage._spaces[storage.stack_ptr] = "---"
+        acc.value = int(storage.stack.pop())
+        storage.stack_ptr -= 1
+
+    @storage
+    def __ptr(self, acc, storage):
+        acc.value = int(storage.stack_ptr)
+
+    @storage
+    def __shi(self, acc, storage):
+        acc.value = len(storage.stack)
+
     @manipulate
     def __sft(self, acc, storage):
         self._val = str(self._val).zfill(2)
@@ -154,7 +190,6 @@ def __sft(self, acc, storage):
 
     @inputs
     def __inp(self, acc, storage, input: int = 0):
-        storage._expected_inputs += 1
         try:
             int(input)
             if input > 999:

src/paperpc/config.py

@@ -0,0 +1,23 @@
+import os
+import yaml
+import fnmatch
+
+class Config:
+
+    def __init__(self):
+        config_file = None
+        for root, dirname, filenames in os.walk(os.getcwd()):
+            for filename in fnmatch.filter(filenames, ".pcconfig"):
+                config_file = f"{root}/{filename}"
+                break
+        try:
+            with open(config_file, "r") as fh:
+                config = yaml.safe_load(fh)
+                self.__set_settings(config)
+        except TypeError:
+            # No config, so just move on
+            pass
+
+    def __set_settings(self, config):
+        for setting in config:
+            setattr(self, setting, config[setting])

src/paperpc/main.py

@@ -2,6 +2,7 @@
 
 from .parts import *
 from .cmd import *
+from .config import *
 from arglite import parser as cliarg
 from itertools import islice
 from rich.console import Console
@@ -20,7 +21,6 @@ def debug_log(acc, storage) -> None:
     console.print(f"ACC VALUE: {acc.value}")
 
 def main() -> None:
-
     # Load instruction set, crash out
     # if set does not exist as file
     try:
@@ -29,13 +29,17 @@ def main() -> None:
         print("Invalid source file.")
         sys.exit(1)
     with open(src, "r") as fh:
+        # Allow for inconsistent lineation in program input
         data = [val.strip() for val in fh.readlines() if val.strip()]
 
+    # Load settings
+    config = Config()
+
     # Initialize accumulator
     acc = Accumulator()
 
     # Set up storage for individual instructions
-    storage = Storage(data)
+    storage = Storage(data, config)
 
     # Trigger debug output if debug flag set
     if cliarg.optional.debug:
@@ -49,8 +53,10 @@ def main() -> None:
     # comma-separated list
     inputs = Inputs(cliarg.optional.inputs)
     len_inputs = len(inputs._values)
+
     # Step through instruction list, translate to
     # functions
+
     while True:
 
         cmd = commands.parse(
@@ -63,7 +69,7 @@ def main() -> None:
         if 'inputs' in arg_types:
             try:
                 cmd(acc, storage, inputs._values.pop(0))
-            except IndexError:
+            except IndexError as e:
                 # This is the last case to consider
                 print(f"[ERROR] Reached end of inputs.")
                 print(f"        Expected:\t{storage._expected_inputs}")

src/paperpc/parts.py

@@ -4,29 +4,36 @@
 
 class Storage:
 
-    def __init__(self, instructions):
+    def __init__(self, instructions, config):
         # Split into line numbers and instructions using the 2+ spaces
         # rule to define separation between lines, instructions, comments
         self._counter = 1
-        self._program = (
+        self.stack = []
+        self.stack_base = config.storage["stack_base"] or 80
+        self.stack_size = config.storage["stack_size"] or 18
+        self.stack_ptr = self.stack_base
+        self._program = list(
             re.split(
                 r"\s{2,}|\t{1,}",
                 instruction
             ) for instruction in instructions)
-        self._expected_inputs = 0
+        # Apparently, must initialize storage here; if we wait until the
+        # end of the constructor, the program is...blank?
+        self._expected_inputs = len([
+            instruction for instruction
+            in self._program if instruction[1] == "901"
+        ])
         self.__initialize_storage()
 
     def __initialize_storage(self):
-        # This implementation follows the accepted solution from SO:
-        # https://stackoverflow.com/questions/5944708/how-can-i-automatically-limit-the-length-of-a-list-as-new-elements-are-added
+        # This implementation follows the accepted solution from
+        # SO question no. 5944708
         line = 1
-        self._spaces = deque(maxlen=100)
+        self._spaces = deque(maxlen = 100)
         for _ in range(100):
             self._spaces.append(None)
         for instruction in self._program:
             self._spaces[int(instruction[0])] = instruction[1]
-            #if instruction[1] == "901":
-            #    self._expected_inputs += 1
             try:
                 comment = str(instruction[2])
                 if not comment.startswith("@"):
@@ -76,6 +83,10 @@ def value(self):
 class Inputs:
 
     def __init__(self, inputs):
-        if type(inputs) == int:
-            inputs = [inputs]
-        self._values = list(inputs)
+        try:
+            if type(inputs) == int:
+                inputs = [inputs]
+            self._values = list(inputs)
+        except TypeError:
+            print("[ERROR] Program expects inputs, but none given.")
+            sys.exit(1)