Add transpiler to language processing system

Author: satsuki942

.DS_Store

@@ -6,7 +6,7 @@
     packages=find_packages(),
     entry_points={
         'console_scripts': [
-            'vython=src.run:main'
+            'vython=src.main:main'
         ]
     }
 )

setup.py

@@ -1,4 +1,4 @@
-from src.syntax.semantics import VersionTable
+from src.interpreter.syntax.semantics import VersionTable
 
 # バージョンの整合性検査
 # アルゴリズムと仕様もコメントで書くこと

src/primitive_lib/__init__.py renamed to src/interpreter/__init__.py

@@ -1,7 +1,7 @@
-from src.parser import Parser
-from src.larkToIR import LarkToCustomAST
-from src.interpreter import Interpreter
-from src.syntax.semantics import resolve_heap_object
+from src.interpreter.parser import Parser
+from src.interpreter.larkToIR import LarkToCustomAST
+from src.interpreter.interpreter import Interpreter
+from src.interpreter.syntax.semantics import resolve_heap_object
 
 class Compiler:
     def __init__(self, code, debug_mode=False):

src/compatibilitychecker.py renamed to src/interpreter/compatibilitychecker.py

@@ -1,7 +1,7 @@
-from src.syntax.semantics import *
-from src.syntax.language import *
-from src.compatibilitychecker import *
-from src.primitive_lib.Primitive_lib import *
+from src.interpreter.syntax.semantics import *
+from src.interpreter.syntax.language import *
+from src.interpreter.compatibilitychecker import *
+from src.interpreter.primitive_lib.Primitive_lib import *
 import re
 import copy
 

src/compiler.py renamed to src/interpreter/compiler.py

@@ -1,5 +1,5 @@
 from lark import Token, Transformer, Tree
-from src.syntax.language import *
+from src.interpreter.syntax.language import *
 
 
 class LarkToCustomAST(Transformer):

src/interpreter.py renamed to src/interpreter/interpreter.py

@@ -17,7 +17,7 @@ def __init__(self, debug_mode=False):
 
     def parse(self, code):
         # 文法定義を読み込む
-        with open("src/syntax/lark-vython.lark", "r") as file:
+        with open("src/interpreter/syntax/lark-vython.lark", "r") as file:
             grammar = file.read()
 
         parser = Lark(

src/larkToIR.py renamed to src/interpreter/larkToIR.py

@@ -1,4 +1,4 @@
-from src.syntax.semantics import *
+from src.interpreter.syntax.semantics import *
 
 # 評価開始時にヒープに入る情報
 vtb = VersionTable("bool", 0, False)

src/parser.py renamed to src/interpreter/parser.py

@@ -1,4 +1,4 @@
-from src.syntax.semantics import *
+from src.interpreter.syntax.semantics import *
 
 # 評価開始時にヒープに入る情報
 vtn = VersionTable("number", 0, False)

src/preprocess.py renamed to src/interpreter/preprocess.py

@@ -0,0 +1,5 @@
+from src.interpreter.primitive_lib.Number_lib import *
+from src.interpreter.primitive_lib.String_lib import *
+from src.interpreter.primitive_lib.Boolean_lib import *
+
+primitive_classes = {"number", "string", "bool"}

src/primitive_lib/Boolean_lib.py renamed to src/interpreter/primitive_lib/Boolean_lib.py

@@ -1,4 +1,4 @@
-from src.syntax.semantics import *
+from src.interpreter.syntax.semantics import *
 
 # 評価開始時にヒープに入る情報
 vts = VersionTable("string", 0, False)

src/primitive_lib/Number_lib.py renamed to src/interpreter/primitive_lib/Number_lib.py

@@ -1,6 +1,6 @@
 import sys
 import time
-from src.compiler import Compiler
+from src.interpreter.compiler import Compiler
 
 def execute_phase(message, function):
     start_time = time.time()
@@ -9,12 +9,12 @@ def execute_phase(message, function):
     print(message)
     print(f"  --> Completed in {end_time - start_time:.2f} seconds")
 
-def main():
+def run(args):
     debug_mode = False
     file_path = None
 
     # コマンドライン引数の処理
-    for arg in sys.argv[1:]:
+    for arg in args:
         if arg in ["--debug", "-d"]:
             debug_mode = True
         else:
@@ -43,6 +43,3 @@ def main():
     execute_phase("[Phase 4] Interpretation", lambda: compiler.evaluate())
 
     print(f"[Result]\n  {compiler.get_result()}")
-
-if __name__ == "__main__":
-  main()

src/interpreter/primitive_lib/Primitive_lib.py

@@ -1,4 +1,4 @@
-from src.syntax.language import Name, Version
+from src.interpreter.syntax.language import Name, Version
 
 # 計算結果全体を示すクラス
 class Result:

src/primitive_lib/String_lib.py renamed to src/interpreter/primitive_lib/String_lib.py

@@ -0,0 +1,23 @@
+import sys
+import src.interpreter.run as i
+import src.transpiler.run as t
+
+class CommandError(Exception):
+    pass
+
+def main():
+    execute_mode = sys.argv[1]
+    # コマンドライン引数の処理
+    try:
+        if execute_mode == "-i":
+            i.run(sys.argv[2:])
+        elif execute_mode == "-t":
+            t.run(sys.argv[2:])
+        else:
+            raise CommandError(f"Unknown command: {execute_mode}")
+    except CommandError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+  main()

src/syntax/__init__.py renamed to src/interpreter/primitive_lib/__init__.py

@@ -0,0 +1,53 @@
+import ast
+import io
+import contextlib
+from src.transpiler.vython_parser import Parser
+from src.transpiler.transpiler import Transpiler
+
+class Compiler:
+    def __init__(self, vythonCode, transpile_mode, show_ast, debug_mode=False, ):
+        self.debug_mode = debug_mode
+        self.show_ast = show_ast
+        self.transpile_mode = transpile_mode
+        self.vythonCode = vythonCode
+        self.vythonaAST = None
+        self.pythonAST = None
+        self.pythonCode = None
+        self.result = None
+    
+    def parse(self):
+        if self.debug_mode:
+            print(f"File Content:\n{self.vythonCode}")
+        self.vythonaAST = Parser(debug_mode = False).parse(self.vythonCode)
+        if self.debug_mode:
+            print(self.vythonaAST)
+    
+    def transpile(self):
+        self.pythonAST = Transpiler(self.debug_mode, self.transpile_mode).transform(self.vythonaAST)
+        if self.show_ast:
+            print(ast.dump(self.pythonAST,False,indent=4))
+
+    def unparse(self):
+        self.pythonCode = ast.unparse(self.pythonAST)
+        if self.debug_mode:
+            with open('output.py', 'w') as log:
+                print("# [Unparse Python AST]",file=log)
+                print(self.pythonCode, file=log)
+
+    def execute(self):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output): 
+            exec(self.pythonCode,globals())
+        captured_output = output.getvalue()
+        self.result = captured_output
+        return self.result
+    
+    def get_result(self):
+        return self.result
+
+    def get_result_fullpath(self):
+        self.parse()
+        self.transpile()
+        self.unparse()
+        self.execute()
+        return self.result

src/run.py renamed to src/interpreter/run.py

@@ -0,0 +1,3 @@
+def incompat(self,value):
+    return
+    

test/__init__.py renamed to src/interpreter/syntax/__init__.py

@@ -0,0 +1,5 @@
+# wrapされるメソッド名に変わる
+def tmp_method():
+    result = self.tmpInvoke()# wrapされるメソッドの呼び出し: wrapされるメソッド名は少し変える
+    append(result,self)
+    return result

src/syntax/language.py renamed to src/interpreter/syntax/language.py

@@ -0,0 +1 @@
+__vt_init__(self)

src/syntax/lark-vython.lark renamed to src/interpreter/syntax/lark-vython.lark

@@ -0,0 +1,5 @@
+from src.lib.primitive_lib.Primitive_Bool import Primitive_Bool_v_0
+from src.lib.primitive_lib.Primitive_Number import Primitive_Number_v_0
+from src.lib.primitive_lib.Primitive_String import Primitive_String_v_0
+
+PrimitiveClasses = {Primitive_String_v_0, Primitive_Number_v_0, Primitive_String_v_0}

src/syntax/semantics.py renamed to src/interpreter/syntax/semantics.py

@@ -0,0 +1,32 @@
+class Primitive_Bool_v_0():
+    def __init__(self, value):
+        self.value = value
+        __vt_init__(self)
+    
+    def __repr__(self):
+        return f"{self.value}"
+    
+    def __bool__(self):
+        return self.value
+    
+    def equal(left,right):
+        return left.value == right.value
+    def nequal(left,right):
+        return left.value != right.value
+    
+    # 検査 & VT書き換えを加える
+    def __eq__(left,right):
+        return left.binary(right,"eq")
+    def __ne__(left,right):
+        return left.binary(right,"ne")
+    
+    def binary(left,right,op):
+        checkCompatibility(left,right)
+        match op:
+            # 比較
+            case "eq": result = Primitive_Bool_v_0(left.value == right.value)
+            case "ne": result = Primitive_Bool_v_0(left.value != right.value)
+        append(result,left)
+        append(result,right)
+        return result
+    

src/main.py

@@ -0,0 +1,76 @@
+class Primitive_Number_v_0():
+    def __init__(self, value):
+        self.value = value
+        __vt_init__(self)
+    
+    def __repr__(self):
+        return f"{self.value}"
+    
+    def __bool__(self):
+        return bool(self.value)
+    
+    def __str__(self):
+        return str(self.value)
+    
+    def equal(left,right):
+        return left.value == right.value
+    def nequal(left,right):
+        return left.value != right.value
+
+    def __add__(left,right):
+        return left.binary(right,"add")
+    def __sub__(left,right):
+        return left.binary(right,"sub")
+    def __mul__(left,right):
+        return left.binary(right,"mul")
+    def __truediv__(left,right):
+        return left.binary(right,"div")
+    def __floordiv__(left,right):
+        return left.binary(right,"floordiv")
+    def __mod__(left,right):
+        return left.binary(right,"mod")
+    def __eq__(left,right):
+        return left.binary(right,"eq")
+    def __ne__(left,right):
+        return left.binary(right,"ne")
+    def __lt__(left,right):
+        return left.binary(right,"lt")
+    def __gt__(left,right):
+        return left.binary(right,"gt")
+    def __le__(left,right):
+        return left.binary(right,"le")
+    def __ge__(left,right):
+        return left.binary(right,"ge")
+
+    def __neg__(self):
+        return self.unary("neg")
+    def __pos__(self):
+        return self.unary("pos")
+    
+    def binary(left,right,op):
+        checkCompatibility(left,right)
+        match op:
+            # 算術
+            case "add": result = Primitive_Number_v_0(left.value + right.value)
+            case "sub": result = Primitive_Number_v_0(left.value - right.value)
+            case "mul": result = Primitive_Number_v_0(left.value * right.value)
+            case "div": result = Primitive_Number_v_0(left.value / right.value)
+            case "mod": result = Primitive_Number_v_0(left.value % right.value)
+            case "floordiv": result = Primitive_Number_v_0(left.value // right.value)
+            # 比較
+            case "eq": result = Primitive_Bool_v_0(left.value == right.value)
+            case "ne": result = Primitive_Bool_v_0(left.value != right.value)
+            case "lt": result = Primitive_Bool_v_0(left.value < right.value)
+            case "gt": result = Primitive_Bool_v_0(left.value > right.value)
+            case "le": result = Primitive_Bool_v_0(left.value <= right.value)
+            case "ge": result = Primitive_Bool_v_0(left.value >= right.value)
+        append(result,left)
+        append(result,right)
+        return result
+    
+    def unary(self,op):
+        match op:
+            case "neg": result = Primitive_Number_v_0(-self.value)
+            case "pos": result = Primitive_Number_v_0(self.value)
+        append(result,self)
+        return result

src/primitive_lib/Primitive_lib.py

@@ -0,0 +1,49 @@
+class Primitive_String_v_0():
+    def __init__(self, value):
+        self.value = value
+        __vt_init__(self)
+
+    def __repr__(self):
+        return f"{self.value}"
+    
+    def __bool__(self):
+        return bool(self.value)
+    
+    def __len__(self):
+        return len(self.value)
+    
+    def equal(left,right):
+        return left.value == right.value
+    def nequal(left,right):
+        return left.value != right.value
+    
+    def __add__(left,right):
+        return left.binary(right,"add")
+    def __eq__(left,right):
+        return left.binary(right,"eq")
+    def __ne__(left,right):
+        return left.binary(right,"ne")
+    def __lt__(left,right):
+        return left.binary(right,"lt")
+    def __gt__(left,right):
+        return left.binary(right,"gt")
+    def __le__(left,right):
+        return left.binary(right,"le")
+    def __ge__(left,right):
+        return left.binary(right,"ge")
+    
+    def binary(left,right,op):
+        checkCompatibility(left,right)
+        match op:
+            # 連結
+            case "add": result = Primitive_String_v_0(left.value + right.value)
+            # 比較
+            case "eq": result = Primitive_Bool_v_0(left.value == right.value)
+            case "ne": result = Primitive_Bool_v_0(left.value != right.value)
+            case "lt": result = Primitive_Bool_v_0(left.value < right.value)
+            case "gt": result = Primitive_Bool_v_0(left.value > right.value)
+            case "le": result = Primitive_Bool_v_0(left.value <= right.value)
+            case "ge": result = Primitive_Bool_v_0(left.value >= right.value)
+        append(result,left)
+        append(result,right)
+        return result