From e7eca3b46d1d0a9c0c2c0e1cc93c831310fed029 Mon Sep 17 00:00:00 2001
From: tonitch <tonitch@herisson.ovh>
Date: Thu, 20 Mar 2025 00:17:50 +0100
Subject: [PATCH] Implementing Variables class + dump and trace

---
 examples/simple.spf                           |   4 +-
 modules/Variables.py                          |  68 ++++++++++++++++++
 modules/__pycache__/Variables.cpython-313.pyc | Bin 0 -> 4379 bytes
 spf.py                                        |  55 ++++----------
 4 files changed, 85 insertions(+), 42 deletions(-)
 create mode 100644 modules/Variables.py
 create mode 100644 modules/__pycache__/Variables.cpython-313.pyc

diff --git a/examples/simple.spf b/examples/simple.spf
index 06138d2..61f4245 100644
--- a/examples/simple.spf
+++ b/examples/simple.spf
@@ -8,6 +8,6 @@ afficher nom, age, majeur;
 
 
 #TODO: Ces lignes devraient donner une erreur
-majeur = 42;
+# majeur = 42;
 
-afficher majeur;
+# afficher majeur;
diff --git a/modules/Variables.py b/modules/Variables.py
new file mode 100644
index 0000000..08a073c
--- /dev/null
+++ b/modules/Variables.py
@@ -0,0 +1,68 @@
+import sys
+
+trace_format = '\033[1m -> '
+reset_format = '\033[0m'
+
+class Variables:
+
+    class Variable:
+        types = { "entier": int,
+                  "texte": str,
+                  "booléen": bool,
+                  "liste": list }
+
+        def __init__(self, typ, value = None):
+            assert typ in self.types.keys(), "Ce type de variable est inconnu"
+            self.type = typ
+            assert self.checkType(value, typ), "Le type n'est pas équivalent"
+            self.value = value if (value is not None) else self.default(typ)
+
+        def set(self, value):
+            assert self.checkType(value, self.type), "Le type n'est pas équivalent"
+            self.value = value
+
+        def __str__(self):
+            if self.type == "booléen":
+                return "Vrai" if self.value else "Faux"
+            return f"{self.value}"
+
+        def __repr__(self):
+            if self.type == "texte":
+                return f"\"{self.value}\""
+            return f"{self.value}"
+
+
+        def checkType(self, value, typ) -> bool:
+            return type(value) == self.types[typ]
+
+        def default(self, typ):
+            if typ == "entier":
+                return 0
+            if typ == "texte":
+                return ""
+            if typ == "booléen":
+                return False
+            if typ == "liste":
+                return []
+
+    def __init__(self, trace=False):
+        self.variables = {}
+        self.trace = trace
+
+    def get(self, name):
+        assert name in self.variables, "la variable {name} n'éxiste pas"
+        if self.trace:
+            print(f"{trace_format}accède {name}{reset_format}", file=sys.stdout)
+        return self.variables[name]
+
+    def declare(self, typ, name, value=None):
+        assert name not in self.variables, "la variable {name} existe déjà"
+        self.variables[name] = self.Variable(typ, value)
+        if self.trace:
+            print(f"{trace_format}déclare {name} = {value}{reset_format}", file=sys.stdout)
+
+    def assign(self, name, value):
+        assert name in self.variables, "la variable n'éxiste pas"
+        self.variables[name].set(value)
+        if self.trace:
+            print(f"{trace_format}modifie {name} = {value}{reset_format}", file=sys.stdout)
diff --git a/modules/__pycache__/Variables.cpython-313.pyc b/modules/__pycache__/Variables.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7acd230a9dba80cb82deb0ab7fc64efd3597cf9
GIT binary patch
literal 4379
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

literal 0
HcmV?d00001

diff --git a/spf.py b/spf.py
index 0b1da1b..d076365 100755
--- a/spf.py
+++ b/spf.py
@@ -7,32 +7,13 @@ import argparse
 import lark
 import sys
 from enum import Enum
-
-variables = {}
-
-class VariableType(Enum):
-    boolean     = 1
-    integer     = 2
-    string      = 3
-    list        = 4
-
-
-class Variable():
-    def __init__(self, type, value):
-        self.type = type
-        self.value = value
-
-    def __str__(self):
-        if self.type == "booléen":
-            return "Vrai" if self.value else "Faux"
-        return f"{self.value}"
-
-    def __repr__(self):
-        if self.type == "texte":
-            return f"\"{self.value}\""
-        return f"{self.value}"
+from modules.Variables import Variables
 
 class SPFInterpreter(lark.visitors.Interpreter):
+    def __init__(self, trace=False):
+        super().__init__()
+        self.variables = Variables(trace)
+
     def afficher(self, el):
         for toprint in el.children[1:]:
             print(self.visit_children(toprint)[0])
@@ -41,26 +22,20 @@ class SPFInterpreter(lark.visitors.Interpreter):
     def declaration(self, el):
         type = el.children[0].value
         name = el.children[1].value
-        assert el.children[2].value == "=", "Unexpected"
-        assert el.children[3].data == "expression", "Unexpected"
-        value = self.visit_children(el.children[3])[0]
-        variables[name] = Variable(type, value)
+        value = self.visit_children(el.children[3])[0] if el.children[2].value == "=" else None
+        self.variables.declare(type, name, value)
 
     def assignation(self, el):
         name = el.children[0].value
-        assert name in variables, f"Unknown variable : {el.children[0].value} not in {variables}"
-        assert el.children[1].value == "=", "Unexpected"
-        assert el.children[2].data == "expression", "Unexpected"
+        assert el.children[1].value == "=" and el.children[2].data == "expression", "Unexpected"
         value = self.visit_children(el.children[2])[0]
-        variables[name] = value #TODO: vérifier type
+        self.variables.assign(name, value)
 
     def expressionleft(self, el):
         return self.visit_children(el)[0]
 
-
     def variable(self, el):
-        assert el.children[0].value in variables, f"Unknown variable : {el.children[0].value} not in {variables}"
-        return variables[el.children[0].value]
+        return self.variables.get(el.children[0].value)
 
     # Literals
     string = lambda self, el: el.children[0][1:-1]
@@ -68,6 +43,9 @@ class SPFInterpreter(lark.visitors.Interpreter):
     true = lambda self, _: True
     false = lambda self, _: False
 
+    def dump(self):
+        self.variables.dump()
+
 
 
 def main():
@@ -81,9 +59,6 @@ def main():
                         action="store_true")
     args = arg_parser.parse_args()
 
-    if args.trace:
-        print("Trace activated (TODO)", file=sys.stderr)
-
     with open("spf.lark") as grammar:
         spf_parser = lark.Lark(grammar, parser="lalr", strict=True, debug=True)
 
@@ -91,11 +66,11 @@ def main():
         program = spf_input.read()
         parsed = spf_parser.parse(program)
 
-    interpreter = SPFInterpreter()
+    interpreter = SPFInterpreter(args.trace)
     interpreted = interpreter.visit(parsed)
 
     if args.dump:
-        print(variables, file=sys.stderr)
+        interpreted.dump()
 
 
 if __name__ == "__main__":