interpreting functions

Author: hexxt-git

bun.lockb

@@ -0,0 +1,7 @@
+const log = func (i) => {
+    output (stringify i + ", ")
+},
+
+mut i = 0,
+
+for(i = i + 1, i < 10) { log@(i) }, 0

examples/fibonacci.math examples/fibonacci.bbeeexamples/fibonacci.math renamed to examples/fibonacci.bbee

@@ -46,6 +46,25 @@ export default function interpret(
             };
             return new_fn;
 
+        case ExpressionKind.FunctionCall: {
+            const fn: Value = interpretHere(expression.left);
+            if (typeof fn != "string" && typeof fn != "number") {
+                const values: Record<identifier, Variable> = {};
+                if(fn.inputs.length != expression.inputs.length) throw new Error("number of inputs to function call does not match number in declaration")
+                for (let [index, identifier] of Object.entries(fn.inputs)) {
+                    values[identifier] = {
+                        value: interpretHere(expression.inputs[Number(index)]),
+                        mutable: true,
+                    };
+                }
+                const childMemory: MemoryBlock = {
+                    parent: memory,
+                    values: values,
+                };
+                return interpret(fn.body, childMemory);
+            } else throw new Error("trying to call non callable");
+        }
+
         case ExpressionKind.NumericLiteral:
             return expression.value;
 
@@ -200,9 +219,6 @@ export default function interpret(
                     // comma calculates left and discards it but it may create side effects like assignment
                     return right;
                 }
-                case "@":
-                    console.log(expression)
-                    return interpretHere(expression.right);
                 default:
                     throw new Error("Unknown binary operator: " + expression.operator);
             }

examples/fizzbuzz.math examples/fizzbuzz.bbeeexamples/fizzbuzz.math renamed to examples/fizzbuzz.bbee

@@ -359,7 +359,7 @@ export class Parser {
         let left = this.parseUnaryOperation();
 
         while (this.top() && this.top().kind == TokenKind.call) {
-            const operator: string = this.pop().value;
+            this.pop(); // @
 
             if (PrimitiveTokens.includes(this.top().kind)) {
                 const right: Expression = this.parseUnaryOperation();
@@ -379,11 +379,30 @@ export class Parser {
 
             this.pop(); // (
 
-            const inputs = [];
+            const inputs: Expression[] = [];
 
             while (this.top().kind !== TokenKind.closePar) {
-                
+                // this feels illegal
+                const input = this.parseAssignmentOperation();
+                inputs.push(input);
+
+                if (this.top().kind !== TokenKind.comma && this.top().kind !== TokenKind.closePar)
+                    throw new Error(
+                        "Expected comma operator or closing parentheses in function inputs"
+                    );
+
+                if (this.top().kind === TokenKind.comma) this.pop(); // ,
             }
+
+            this.pop(); // )
+
+            const expression: FunctionCallExpression = {
+                kind: ExpressionKind.FunctionCall,
+                left: left,
+                inputs: inputs,
+            };
+
+            left = expression;
         }
 
         return left;