Showed Gamakshi! <3

Author: manash

examples/binary.gama

@@ -0,0 +1,17 @@
+let pyramid = func(depth) {
+  if (depth == 4) {
+    return null;
+  }
+  if (depth == 1) {
+    puts('  *')
+  }
+  if (depth == 2) {
+    puts(' * *');
+  }
+  if (depth == 3) {
+    puts('*   *')
+  }
+  pyramid(depth + 1);
+}
+
+pyramid(1);

examples/fibo.gama

@@ -7,5 +7,5 @@ let fibo = func(n) {
         fibo(n - 1) + fibo(n - 2);
     }
 }
-
-fibo(5);
+let x = fibo(5);
+puts(x);

examples/max.gama

@@ -0,0 +1,15 @@
+let ar = [1, 5, 7, 9, 10, 25];
+
+let getMax = func(arr, already) {
+    if(isEmpty(arr)) {
+        return already
+    }
+    let x = head(arr);
+    let nex = tail(arr);
+    if (x > already) {
+        return getMax(nex, x);
+    }
+    return getMax(nex, already);
+}
+
+puts(getMax(ar, -100000));

index.ts

@@ -0,0 +1,28 @@
+import {readFile} from "fs";
+import {Parser} from "./parser/parser";
+import {startRepl} from "./repl";
+
+const args = process.argv;
+
+function sourceFile() {
+    const path = args.at(2)!;
+    readFile(path, (err, data) => {
+        if (err) {
+            console.error(`${err.message}: For file ${path}`);
+        }
+        try {
+            Parser.create(data.toString()).parse().eval();
+        } catch (err: any) {
+            console.error(err.message);
+        }
+    });
+}
+function start() {
+    if (args.length > 2) {
+        sourceFile();
+        return;
+    }
+    startRepl();
+}
+
+start();

lexer/token.ts

@@ -44,6 +44,7 @@ keywords.set("false", TOKEN.FALSE);
 keywords.set("true", TOKEN.TRUE);
 keywords.set("let", TOKEN.LET);
 keywords.set("func", TOKEN.FUNCTION);
+keywords.set("null", TOKEN.NULL);
 
 export class Token {
     private _token: TOKEN;

package-lock.json

@@ -4,7 +4,7 @@
   "description": "A Compiler For the Gamakshi Language",
   "main": "index.js",
   "scripts": {
-    "start": "ts-node index.js",
+    "start": "ts-node index.ts",
     "test": "npx jest test",
     "repl": "npx ts-node repl.ts"
   },
@@ -17,6 +17,7 @@
   "devDependencies": {
     "@types/chai": "^4.3.1",
     "@types/jest": "^27.5.1",
+    "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.29.0",
     "@typescript-eslint/parser": "^5.29.0",
     "chai": "^4.3.6",

package.json

@@ -12,6 +12,7 @@
  */
 
 import {HeadFn} from "./exprs/basicFunctions/head";
+import {IsEmptyFn} from "./exprs/basicFunctions/isEmpty";
 import {Length} from "./exprs/basicFunctions/len";
 import {PushFn} from "./exprs/basicFunctions/push";
 import {Puts} from "./exprs/basicFunctions/puts";
@@ -60,26 +61,29 @@ class ExecutionContext {
     setVariable(name: string, val: any) {
         const mp = this.getTop();
         if (mp.has(name)) {
-            throw new Error(`Variable ${name} is already declared`);
+            throw new Error(`Runtime Error: Variable ${name} is already declared`);
         }
         if (this.basic.has(name)) {
-            throw new Error(`Cannot Declare builtin function: ${name}`);
+            throw new Error(`Runtime Error: Cannot Declare builtin function: ${name}`);
         }
         mp.set(name, val);
     }
     setForce(name: string, val: any) {
         if (this.isBuiltin(name)) {
-            throw new Error(`Cannot set builtin function ${name} as arguments`);
+            throw new Error(`Runtime Error: Cannot set builtin function ${name} as arguments`);
         }
         const mp = this.getTop();
         mp.set(name, val);
     }
     getVariable(name: string) {
         const mp = this.getTop();
         if (!mp.has(name) && !this.basic.has(name)) {
-            throw new Error(`Variable ${name} is not declared`);
+            throw new Error(`Runtime Error: Variable ${name} is not declared`);
         }
-        return mp.get(name) || this.basic.get(name)!;
+        if(mp.has(name)) {
+            return mp.get(name)!;
+        }
+        return this.basic.get(name)!;
     }
     constructor() {
         this.stack = new Stack<Map<string, any>>();
@@ -90,6 +94,7 @@ class ExecutionContext {
         this.basic.set("head", HeadFn.create());
         this.basic.set("tail", TailFn.create());
         this.basic.set('puts', Puts.create());
+        this.basic.set('isEmpty', IsEmptyFn.create());
     }
     isBuiltin(str: string): boolean {
         return this.basic.has(str);

parser/context.ts

@@ -0,0 +1,25 @@
+import {FuncLiteral} from "../functionLiteral";
+
+export class IsEmptyFn extends FuncLiteral {
+    execute(evalArgs: any[]) {
+        if (evalArgs.length !== 1) {
+            throw new Error(`Runtime Error: Invalid Number of arguments in isEmpty()`);
+        }
+        const arg = evalArgs.at(0)!;
+        if (arg instanceof Map) {
+            return arg.size === 0;
+        }
+        const type = typeof arg;
+        if (type === 'string' || Array.isArray(arg)) {
+            return arg.length === 0;
+        }
+        throw new Error(`Runtime Error: Invaid type ${type} argument for isEmpty()`);
+    }
+
+    private constructor() {
+        super()
+    }
+    static create() {
+        return new IsEmptyFn();
+    }
+}

parser/exprs/basicFunctions/isEmpty.ts

@@ -12,7 +12,6 @@ import {Statement} from "../statements/statement";
 import {Expr, functionArgsParser} from "./expr";
 
 export class FuncLiteral implements Expr {
-
     args: Expr[];
     body: Statement; // BlockStatements
     env: Map<string, any> = new Map<string, any>(); 
@@ -32,7 +31,7 @@ export class FuncLiteral implements Expr {
 
     execute(evalArgs: any[]) {
         if (evalArgs.length !== this.args.length) {
-            throw new Error("Runtime Error: Incorrect number of functions arguments");
+            throw new Error("Runtime Error: Incorrect number of functions arguments: " + this.toString());
         }
         context.pushContext(this.env);
         for (let i = 0; i < evalArgs.length; ++i) {