inital basical executor

src/lang/executor.ts

@@ -0,0 +1,45 @@
+import { Program, BinaryPart } from "./abstractSyntaxTree";
+
+export const executor = (ast: Program, rootOverride: {[key: string]: any} = {}): any => {
+  const programMemory: { [key: string]: any } = {
+    root: {
+      ...rootOverride
+    },
+  };
+  const { body } = ast;
+  body.forEach((statement) => {
+    if (statement.type === "VariableDeclaration") {
+      statement.declarations.forEach((declaration) => {
+        const variableName = declaration.id.name;
+        if (declaration.init.type === "Literal") {
+          programMemory.root[variableName] = declaration.init.value;
+        } else if (declaration.init.type === "BinaryExpression") {
+          const getVal = (part: BinaryPart) => {
+            if (part.type === "Literal") {
+              return part.value;
+            } else if (part.type === "Identifier") {
+              return programMemory.root[part.name];
+            }
+          };
+          const left = getVal(declaration.init.left);
+          const right = getVal(declaration.init.right);
+          programMemory.root[variableName] = left + right;
+        }
+      });
+    } else if (statement.type === "ExpressionStatement") {
+      const expression = statement.expression;
+      if (expression.type === "CallExpression") {
+        const functionName = expression.callee.name;
+        const args = expression.arguments.map((arg) => {
+          if (arg.type === "Literal") {
+            return arg.value;
+          } else if (arg.type === "Identifier") {
+            return programMemory.root[arg.name];
+          }
+        });
+        programMemory.root[functionName](...args);
+      }
+    }
+  });
+  return programMemory;
+};