Some new functions

Author: HaryKali

__pycache__/basic.cpython-312.pyc

@@ -1,5 +1,8 @@
+from operator import index
+
 from jinja2.runtime import new_context
 from numba.typed.listobject import new_list
+import os
 
 TT_FLOAT = 'FLOAT'
 TT_IDENTIFIER = 'IDENTIFIER'
@@ -1449,31 +1452,34 @@ def __repr__(self):
 
 
 class BuiltInFunction(BaseFunction):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, name):
+        super().__init__(name)
 
     def execute(self, args):
         res = RTResult()
         exec_ctx = self.generate_new_context()
         method_name = f"execute_{self.name}"
         method = getattr(self, method_name, self.no_visit_method)
 
-        res.register(self.check_and_populate_args(method.arg_namse, args, exec_ctx))
+        res.register(self.check_and_populate_args(method.arg_names, args, exec_ctx))
         if res.error: return res
 
         return_value = res.register(method(exec_ctx))
         if res.error: return res
         return res.success(return_value)
 
-    def no_visit_method(self, node, context):
-        raise Exception(f"No execute_{self.name} method deined")
+    def no_visit_method(self, exec_ctx):
+        raise Exception(f"No execute_{self.name} method defined")
 
     def copy(self):
         copy = BuiltInFunction(self.name)
         copy.set_context(self.context)
         copy.set_pos(self.pos_start, self.pos_end)
         return copy
 
+    def __repr__(self):
+        return f"<Built-in function {self.name}>"
+
     def execute_print(self, exec_ctx):
         print(str(exec_ctx.symbol_table.get("value")))
         return RTResult().success(Number.null)
@@ -1489,11 +1495,126 @@ def execute_input(self, exec_ctx):
         text = input()
         return RTResult().success(String(text))
 
-    execute_input().arg_names = []
+    execute_input.arg_names = []
 
+    def execute_input_int(self, exec_ctx):
+        while True:
+            value = input()
+            try:
+                value = int(value)
+                break
+            except ValueError:
+                print(f"'{value}' should be int , try again")
+        return RTResult().success(Number(value))
 
-    def __repr__(self):
-        return f"<Built-in function {self.name}>"
+    execute_input_int.arg_names = []
+
+    def execute_clear(self, exec_ctx):
+        os.system("cls" if os.name == "nt" else "clear")
+        return RTResult().success(Number.null)
+
+    execute_clear.arg_names = []
+
+    def execute_is_number(self, exec_ctx):
+        is_number = isinstance(exec_ctx.symbol_table.get("value"), Number)
+        return RTResult().success(Number.true if is_number else Number.false)
+
+    execute_is_number.arg_names = ["value"]
+
+    def execute_is_string(self, exec_ctx):
+        is_string = isinstance(exec_ctx.symbol_table.get("value"), String)
+        return RTResult().success(Number.true if is_string else Number.false)
+
+    execute_is_string.arg_names = ["value"]
+
+    def execute_is_function(self, exec_ctx):
+        is_func = isinstance(exec_ctx.symbol_table.get("value"), Function)
+        return RTResult().success(Number.true if is_func else Number.false)
+
+    execute_is_function.arg_names = ["value"]
+
+    def execute_is_list(self, exec_ctx):
+        is_list = isinstance(exec_ctx.symbol_table.get("value"), List)
+        return RTResult().success(Number.true if is_list else Number.false)
+
+    execute_is_list.arg_names = ["value"]
+
+    def execute_append(self, exec_ctx):
+        list_ = exec_ctx.symbol_table.get("list")
+        value = exec_ctx.symbol_table.get("value")
+
+        if not isinstance(list_, List):
+            return RTResult().failure(RTError(
+                self.pos_start, self.pos_end,
+                "First argument must be list",
+                exec_ctx
+            ))
+        list_.elements.append(value)
+        return RTResult().success(Number.null)
+
+    execute_append.arg_names = ["list", "value"]
+
+    def execute_pop(self, exec_ctx):
+        list_ = exec_ctx.symbol_table.get("list")
+        index = exec_ctx.symbol_table.get("index")
+
+        if not isinstance(list_, List):
+            return RTResult().failure(RTError(
+                self.pos_start, self.pos_end,
+                "First argument must be list",
+                exec_ctx
+            ))
+
+        if not isinstance(index, Number):
+            return RTResult().failure(RTError(
+                self.pos_start, self.pos_end,
+                "Second argument must be int",
+                exec_ctx
+            ))
+        try:
+            element = list_.elements.pop(index.value)
+        except:
+            return RTResult().failure(RTError(
+                self.pos_start, self.pos_end,
+                "Out of index!!!",
+                exec_ctx
+            ))
+        return RTResult().success(element)
+
+    execute_pop.arg_names = ["list", "index"]
+
+    def execute_extend(self, exec_ctx):
+        listA = exec_ctx.symbol_table.get("listA")
+        listB = exec_ctx.symbol_table.get("listB")
+        if not isinstance(listA, List):
+            return RTResult().failure(RTError(
+                self.pos_start, self.pos_end,
+                "First argument must be list",
+                exec_ctx
+            ))
+        if not isinstance(listB, List):
+            return RTResult().failure(RTError(
+                self.pos_start, self.pos_end,
+                "Second argument must be list",
+                exec_ctx
+            ))
+        listA.elements.extend(listB.elements)
+        return RTResult().success(Number.null)
+
+    execute_extend.arg_names = ["listA", "listB"]
+
+BuiltInFunction.print       = BuiltInFunction("print")
+BuiltInFunction.print_ret   = BuiltInFunction("print_ret")
+BuiltInFunction.input       = BuiltInFunction("input")
+BuiltInFunction.input_int   = BuiltInFunction("input_int")
+BuiltInFunction.clear       = BuiltInFunction("clear")
+BuiltInFunction.is_number   = BuiltInFunction("is_number")
+BuiltInFunction.is_string   = BuiltInFunction("is_string")
+BuiltInFunction.is_list     = BuiltInFunction("is_list")
+BuiltInFunction.is_function = BuiltInFunction("is_function")
+BuiltInFunction.append      = BuiltInFunction("append")
+BuiltInFunction.pop         = BuiltInFunction("pop")
+BuiltInFunction.extend      = BuiltInFunction("extend")
 
 
 class SymbolTable:
@@ -1603,7 +1724,7 @@ def visit_VarAccessNode(self, node, context):
                 context
             ))
 
-        value = value.copy().set_pos(node.pos_start, node.pos_end)
+        value.set_pos(node.pos_start, node.pos_end).set_context(context)
         return res.success(value)
 
     def visit_VarAssignNode(self, node, context):
@@ -1708,23 +1829,45 @@ def visit_FunDefNode(self, node, context):
     def visit_CallNode(self, node, context):
         res = RTResult()
         args = []
+
+        # 不再 copy()，保留原函数引用
         value_to_call = res.register(self.visit(node.node_to_call, context))
         if res.error: return res
-        value_to_call = value_to_call.copy().set_pos(node.pos_start, node.pos_end)
+        value_to_call.set_pos(node.pos_start, node.pos_end).set_context(context)
 
         for arg_node in node.arg_nodes:
             args.append(res.register(self.visit(arg_node, context)))
             if res.error: return res
 
         return_value = res.register(value_to_call.execute(args))
         if res.error: return res
-        return res.success(return_value)
+
+        # 返回值可以 copy，因为它是新创建的，不会影响上下文
+        return res.success(return_value.copy().set_pos(node.pos_start, node.pos_end).set_context(context))
 
 
 global_symbol_table = SymbolTable()
 global_symbol_table.set("NULL", Number.null)
 global_symbol_table.set("False", Number.false)
 global_symbol_table.set("True", Number.true)
+global_symbol_table.set("NULL", Number.null)
+global_symbol_table.set("FALSE", Number.false)
+global_symbol_table.set("TRUE", Number.true)
+# global_symbol_table.set("MATH_PI", Number.math_PI)
+global_symbol_table.set("print", BuiltInFunction.print)
+global_symbol_table.set("print_ret", BuiltInFunction.print_ret)
+global_symbol_table.set("input", BuiltInFunction.input)
+global_symbol_table.set("input_int", BuiltInFunction.input_int)
+global_symbol_table.set("clear", BuiltInFunction.clear)
+global_symbol_table.set("cls", BuiltInFunction.clear)
+global_symbol_table.set("is_sum", BuiltInFunction.is_number)
+global_symbol_table.set("is_str", BuiltInFunction.is_string)
+global_symbol_table.set("is_list", BuiltInFunction.is_list)
+global_symbol_table.set("is_fun", BuiltInFunction.is_function)
+global_symbol_table.set("append", BuiltInFunction.append)
+global_symbol_table.set("pop", BuiltInFunction.pop)
+global_symbol_table.set("exetend", BuiltInFunction.extend)
+
 
 
 def run(fn, text):