ga-lang 1.2.0 → 1.2.1

package/dist/src/ast.js

@@ -16,6 +16,17 @@ export class LiteralExpr {
         return visitor.visitLiteralExpr(this);
     }
 }
+export class CallExpr {
+    callee;
+    args;
+    constructor(callee, args) {
+        this.callee = callee;
+        this.args = args;
+    }
+    accept(visitor) {
+        return visitor.visitCallExpr(this);
+    }
+}
 export class PrintStmt {
     expression;
     constructor(expression) {
@@ -36,3 +47,34 @@ export class VarStmt {
         return visitor.visitVarStmt(this);
     }
 }
+export class FunctionStmt {
+    name;
+    params;
+    body;
+    constructor(name, params, body) {
+        this.name = name;
+        this.params = params;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitFunctionStmt(this);
+    }
+}
+export class BlockStmt {
+    statements;
+    constructor(statements) {
+        this.statements = statements;
+    }
+    accept(visitor) {
+        return visitor.visitBlockStmt(this);
+    }
+}
+export class ExpressionStmt {
+    expression;
+    constructor(expression) {
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitExpressionStmt(this);
+    }
+}

package/dist/src/interpreter.js

@@ -1,3 +1,4 @@
+import { FunctionStmt } from './ast.js';
 export class Interpreter {
     environment = new Map();
     interpret(statements) {
@@ -19,6 +20,17 @@ export class Interpreter {
         const value = stmt.initializer !== null ? this.evaluate(stmt.initializer) : null;
         this.environment.set(stmt.name.lexeme, value);
     }
+    visitFunctionStmt(stmt) {
+        this.environment.set(stmt.name.lexeme, stmt);
+    }
+    visitBlockStmt(stmt) {
+        for (const statement of stmt.statements) {
+            this.execute(statement);
+        }
+    }
+    visitExpressionStmt(stmt) {
+        this.evaluate(stmt.expression);
+    }
     visitLiteralExpr(expr) {
         if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
             return expr.value.slice(1, -1);
@@ -32,6 +44,33 @@ export class Interpreter {
         }
         return value;
     }
+    visitCallExpr(expr) {
+        const func = this.environment.get(expr.callee.name.lexeme);
+        if (func === undefined) {
+            throw new Error(`Undefined function '${expr.callee.name.lexeme}'`);
+        }
+        if (!(func instanceof FunctionStmt)) {
+            throw new Error(`'${expr.callee.name.lexeme}' is not a function`);
+        }
+        // Create new environment for function scope
+        const prevEnvironment = this.environment;
+        this.environment = new Map(this.environment);
+        // Bind arguments to parameters
+        if (expr.args.length !== func.params.length) {
+            throw new Error(`Expected ${func.params.length} arguments but got ${expr.args.length}`);
+        }
+        for (let i = 0; i < func.params.length; i++) {
+            const value = this.evaluate(expr.args[i]);
+            this.environment.set(func.params[i].lexeme, value);
+        }
+        // Execute function body
+        for (const stmt of func.body) {
+            this.execute(stmt);
+        }
+        // Restore previous environment
+        this.environment = prevEnvironment;
+        return null;
+    }
     /*
      * Evaluate an expression
      */

package/dist/src/lexer.js

@@ -92,6 +92,11 @@ export class Lexer {
                     else
                         this.readDevanagariIdentifier();
                 }
+                else if (!this.isWhitespace(char)) {
+                    // Report invalid character
+                    throw new Error(`Invalid character '${char}' at line ${this.line}. ` +
+                        `Only Devanagari characters, numbers, special characters, and whitespace are allowed.`);
+                }
                 break;
         }
     }
@@ -149,6 +154,13 @@ export class Lexer {
     isDevanagariDigit(char) {
         return '\u{0966}' <= char && char <= '\u{096F}';
     }
+    /**
+     * Check if the character is whitespace
+     * @param {string} char
+     */
+    isWhitespace(char) {
+        return char === ' ' || char === '\r' || char === '\t' || char === '\n';
+    }
     /**
      * Read devanagari character sequence as number
      */

package/dist/src/parser.js

@@ -1,4 +1,4 @@
-import { LiteralExpr, PrintStmt, VarStmt, VariableExpr } from './ast.js';
+import { CallExpr, ExpressionStmt, FunctionStmt, LiteralExpr, PrintStmt, VarStmt, VariableExpr } from './ast.js';
 import { TokenKind } from './token.js';
 export class Parser {
     tokens;
@@ -10,6 +10,10 @@ export class Parser {
     parse() {
         const stmts = [];
         while (!this.isAtEnd()) {
+            if (this.check(TokenKind.Illegal)) {
+                const token = this.peek();
+                throw this.error(token, `Invalid character '${token.lexeme}'`);
+            }
             stmts.push(this.parseStmt());
         }
         return stmts;
@@ -21,7 +25,14 @@ export class Parser {
         if (this.match(TokenKind.Let)) {
             return this.parseVarStmt();
         }
-        throw this.error(this.peek(), 'Expression expected.');
+        if (this.match(TokenKind.Function)) {
+            return this.parseFunctionStmt();
+        }
+        return this.parseExpressionStmt();
+    }
+    parseExpressionStmt() {
+        const expr = this.parseExpression();
+        return new ExpressionStmt(expr);
     }
     parsePrintStmt() {
         this.consume(TokenKind.OpenParen, "Expect '(' after 'छाप'");
@@ -37,8 +48,49 @@ export class Parser {
         }
         return new VarStmt(name, initializer);
     }
+    parseFunctionStmt() {
+        const name = this.consume(TokenKind.Identifier, "Expect function name after 'कार्य'");
+        this.consume(TokenKind.OpenParen, "Expect '(' after function name");
+        const params = [];
+        if (!this.check(TokenKind.CloseParen)) {
+            do {
+                params.push(this.consume(TokenKind.Identifier, 'Expect parameter name'));
+            } while (this.match(TokenKind.Comma));
+        }
+        this.consume(TokenKind.CloseParen, "Expect ')' after parameters");
+        this.consume(TokenKind.OpenCurly, "Expect '{' before function body");
+        const body = this.parseBlock();
+        return new FunctionStmt(name, params, body);
+    }
+    parseBlock() {
+        const statements = [];
+        while (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+            statements.push(this.parseStmt());
+        }
+        this.consume(TokenKind.CloseCurly, "Expect '}' after block");
+        return statements;
+    }
     parseExpression() {
-        return this.parsePrimary();
+        return this.parseCall();
+    }
+    parseCall() {
+        let expr = this.parsePrimary();
+        while (this.match(TokenKind.OpenParen)) {
+            const args = [];
+            if (!this.check(TokenKind.CloseParen)) {
+                do {
+                    args.push(this.parseExpression());
+                } while (this.match(TokenKind.Comma));
+            }
+            this.consume(TokenKind.CloseParen, "Expect ')' after arguments");
+            if (expr instanceof VariableExpr) {
+                expr = new CallExpr(expr, args);
+            }
+            else {
+                throw this.error(this.previous(), 'Can only call functions');
+            }
+        }
+        return expr;
     }
     parsePrimary() {
         if (this.match(TokenKind.String, TokenKind.Number)) {

package/examples/init.ga

@@ -1,4 +1,14 @@
-मानौ सन्देश = "सोच्छौ के मेरो बारे?"
-मानौ एकदुइतिन = १२३
-छाप(सन्देश)
-छाप(एकदुइतिन)
+कार्य सुरु () {
+    मानौ सन्देश = "सोच्छौ के मेरो बारे?"
+    मानौ एकदुइतिन = १२३
+    छाप(सन्देश)
+    छाप(एकदुइतिन)
+}
+
+कार्य जोड( अ, आ) {
+ छाप(अ)
+ छाप(आ)
+}
+
+सुरु()
+जोड(१,२)

package/package.json

@@ -1,20 +1,12 @@
 {
   "name": "ga-lang",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "An interpreted toy programming language",
   "type": "module",
   "main": "dist/main.js",
   "bin": {
     "ga": "./bin/ga.js"
   },
-  "scripts": {
-    "prettier:check": "prettier --check \"./**/*.{js,ts,json}\"",
-    "prettier:fix": "prettier --write \"./**/*.{js,ts,json}\"",
-    "clean": "rm -rf dist",
-    "build": "pnpm run clean && tsc",
-    "test": "pnpm run build && node --test ./dist/tests/**/*.js",
-    "ga": "pnpm run build && node dist/src/main.js"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bvsvntv/ga.git"
@@ -31,7 +23,6 @@
     "url": "https://github.com/bvsvntv/ga/issues"
   },
   "homepage": "https://github.com/bvsvntv/ga#readme",
-  "packageManager": "pnpm@10.25.0",
   "engines": {
     "node": ">=22.x.x",
     "pnpm": ">=10.x.x"
@@ -46,5 +37,13 @@
     "@types/node": "^25.0.3",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "prettier:check": "prettier --check \"./**/*.{js,ts,json}\"",
+    "prettier:fix": "prettier --write \"./**/*.{js,ts,json}\"",
+    "clean": "rm -rf dist",
+    "build": "pnpm run clean && tsc",
+    "test": "pnpm run build && node --test ./dist/tests/**/*.js",
+    "ga": "pnpm run build && node dist/src/main.js"
   }
-}
+}

package/src/ast.ts

@@ -7,6 +7,7 @@ export interface Expr {
 export interface ExprVisitor<T> {
   visitVariableExpr(expr: VariableExpr): T;
   visitLiteralExpr(expr: LiteralExpr): T;
+  visitCallExpr(expr: CallExpr): T;
 }
 
 export interface Stmt {
@@ -16,6 +17,9 @@ export interface Stmt {
 export interface StmtVisitor<T> {
   visitPrintStmt(stmt: PrintStmt): T;
   visitVarStmt(stmt: VarStmt): T;
+  visitFunctionStmt(stmt: FunctionStmt): T;
+  visitBlockStmt(stmt: BlockStmt): T;
+  visitExpressionStmt(stmt: ExpressionStmt): T;
 }
 
 export class VariableExpr implements Expr {
@@ -42,6 +46,20 @@ export class LiteralExpr implements Expr {
   }
 }
 
+export class CallExpr implements Expr {
+  callee: VariableExpr;
+  args: Expr[];
+
+  constructor(callee: VariableExpr, args: Expr[]) {
+    this.callee = callee;
+    this.args = args;
+  }
+
+  accept<T>(visitor: ExprVisitor<T>): T {
+    return visitor.visitCallExpr(this);
+  }
+}
+
 export class PrintStmt implements Stmt {
   expression: Expr;
 
@@ -67,3 +85,43 @@ export class VarStmt implements Stmt {
     return visitor.visitVarStmt(this);
   }
 }
+
+export class FunctionStmt implements Stmt {
+  name: Token;
+  params: Token[];
+  body: Stmt[];
+
+  constructor(name: Token, params: Token[], body: Stmt[]) {
+    this.name = name;
+    this.params = params;
+    this.body = body;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitFunctionStmt(this);
+  }
+}
+
+export class BlockStmt implements Stmt {
+  statements: Stmt[];
+
+  constructor(statements: Stmt[]) {
+    this.statements = statements;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitBlockStmt(this);
+  }
+}
+
+export class ExpressionStmt implements Stmt {
+  expression: Expr;
+
+  constructor(expression: Expr) {
+    this.expression = expression;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitExpressionStmt(this);
+  }
+}

package/src/interpreter.ts

@@ -1,12 +1,16 @@
-import type {
-  Expr,
-  ExprVisitor,
-  LiteralExpr,
-  PrintStmt,
-  Stmt,
-  StmtVisitor,
-  VariableExpr,
-  VarStmt
+import {
+  FunctionStmt,
+  type BlockStmt,
+  type CallExpr,
+  type ExpressionStmt,
+  type Expr,
+  type ExprVisitor,
+  type LiteralExpr,
+  type PrintStmt,
+  type Stmt,
+  type StmtVisitor,
+  type VariableExpr,
+  type VarStmt
 } from './ast.js';
 
 export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
@@ -36,6 +40,20 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     this.environment.set(stmt.name.lexeme, value);
   }
 
+  visitFunctionStmt(stmt: FunctionStmt): void {
+    this.environment.set(stmt.name.lexeme, stmt);
+  }
+
+  visitBlockStmt(stmt: BlockStmt): void {
+    for (const statement of stmt.statements) {
+      this.execute(statement);
+    }
+  }
+
+  visitExpressionStmt(stmt: ExpressionStmt): void {
+    this.evaluate(stmt.expression);
+  }
+
   visitLiteralExpr(expr: LiteralExpr): any {
     if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
       return expr.value.slice(1, -1);
@@ -52,6 +70,42 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     return value;
   }
 
+  visitCallExpr(expr: CallExpr): any {
+    const func = this.environment.get(expr.callee.name.lexeme);
+    if (func === undefined) {
+      throw new Error(`Undefined function '${expr.callee.name.lexeme}'`);
+    }
+    if (!(func instanceof FunctionStmt)) {
+      throw new Error(`'${expr.callee.name.lexeme}' is not a function`);
+    }
+
+    // Create new environment for function scope
+    const prevEnvironment = this.environment;
+    this.environment = new Map(this.environment);
+
+    // Bind arguments to parameters
+    if (expr.args.length !== func.params.length) {
+      throw new Error(
+        `Expected ${func.params.length} arguments but got ${expr.args.length}`
+      );
+    }
+
+    for (let i = 0; i < func.params.length; i++) {
+      const value = this.evaluate(expr.args[i]!);
+      this.environment.set(func.params[i]!.lexeme, value);
+    }
+
+    // Execute function body
+    for (const stmt of func.body) {
+      this.execute(stmt);
+    }
+
+    // Restore previous environment
+    this.environment = prevEnvironment;
+
+    return null;
+  }
+
   /*
    * Evaluate an expression
    */

package/src/lexer.ts

@@ -96,6 +96,12 @@ export class Lexer {
         if (this.isDevnagariChar(char)) {
           if (this.isDevanagariDigit(char)) this.readDevanagariDigit();
           else this.readDevanagariIdentifier();
+        } else if (!this.isWhitespace(char)) {
+          // Report invalid character
+          throw new Error(
+            `Invalid character '${char}' at line ${this.line}. ` +
+              `Only Devanagari characters, numbers, special characters, and whitespace are allowed.`
+          );
         }
         break;
     }
@@ -161,6 +167,14 @@ export class Lexer {
     return '\u{0966}' <= char && char <= '\u{096F}';
   }
 
+  /**
+   * Check if the character is whitespace
+   * @param {string} char
+   */
+  private isWhitespace(char: string): boolean {
+    return char === ' ' || char === '\r' || char === '\t' || char === '\n';
+  }
+
   /**
    * Read devanagari character sequence as number
    */

package/src/parser.ts

@@ -1,4 +1,7 @@
 import {
+  CallExpr,
+  ExpressionStmt,
+  FunctionStmt,
   LiteralExpr,
   PrintStmt,
   VarStmt,
@@ -20,6 +23,10 @@ export class Parser {
   parse(): Stmt[] {
     const stmts: Stmt[] = [];
     while (!this.isAtEnd()) {
+      if (this.check(TokenKind.Illegal)) {
+        const token = this.peek();
+        throw this.error(token, `Invalid character '${token.lexeme}'`);
+      }
       stmts.push(this.parseStmt());
     }
 
@@ -35,7 +42,16 @@ export class Parser {
       return this.parseVarStmt();
     }
 
-    throw this.error(this.peek(), 'Expression expected.');
+    if (this.match(TokenKind.Function)) {
+      return this.parseFunctionStmt();
+    }
+
+    return this.parseExpressionStmt();
+  }
+
+  private parseExpressionStmt(): ExpressionStmt {
+    const expr = this.parseExpression();
+    return new ExpressionStmt(expr);
   }
 
   private parsePrintStmt(): Stmt {
@@ -59,8 +75,65 @@ export class Parser {
     return new VarStmt(name, initializer);
   }
 
+  private parseFunctionStmt(): FunctionStmt {
+    const name = this.consume(
+      TokenKind.Identifier,
+      "Expect function name after 'कार्य'"
+    );
+    this.consume(TokenKind.OpenParen, "Expect '(' after function name");
+
+    const params: Token[] = [];
+    if (!this.check(TokenKind.CloseParen)) {
+      do {
+        params.push(
+          this.consume(TokenKind.Identifier, 'Expect parameter name')
+        );
+      } while (this.match(TokenKind.Comma));
+    }
+
+    this.consume(TokenKind.CloseParen, "Expect ')' after parameters");
+    this.consume(TokenKind.OpenCurly, "Expect '{' before function body");
+
+    const body = this.parseBlock();
+
+    return new FunctionStmt(name, params, body);
+  }
+
+  private parseBlock(): Stmt[] {
+    const statements: Stmt[] = [];
+
+    while (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+      statements.push(this.parseStmt());
+    }
+
+    this.consume(TokenKind.CloseCurly, "Expect '}' after block");
+    return statements;
+  }
+
   private parseExpression(): Expr {
-    return this.parsePrimary();
+    return this.parseCall();
+  }
+
+  private parseCall(): Expr {
+    let expr = this.parsePrimary();
+
+    while (this.match(TokenKind.OpenParen)) {
+      const args: Expr[] = [];
+      if (!this.check(TokenKind.CloseParen)) {
+        do {
+          args.push(this.parseExpression());
+        } while (this.match(TokenKind.Comma));
+      }
+      this.consume(TokenKind.CloseParen, "Expect ')' after arguments");
+
+      if (expr instanceof VariableExpr) {
+        expr = new CallExpr(expr, args);
+      } else {
+        throw this.error(this.previous(), 'Can only call functions');
+      }
+    }
+
+    return expr;
   }
 
   private parsePrimary(): Expr {

package/tests/lexer.test.ts

@@ -85,4 +85,32 @@ describe('Lexer', () => {
     assert.equal(actual.length, expected.length);
     assert.deepEqual(actual, expected);
   });
+
+  test('reject non-devanagari characters outside string literals', () => {
+    const source = `मानौ x = ५`;
+
+    const lexer = new Lexer(source);
+
+    assert.throws(() => {
+      lexer.readTokens();
+    }, /Invalid character 'x' at line 1/);
+  });
+
+  test('allow non-devanagari characters inside string literals', () => {
+    const source = `मानौ सन्देश = "Hello World. 123!"`;
+
+    const lexer = new Lexer(source);
+    const actual = lexer.readTokens();
+
+    const expected = [
+      new Token(TokenKind.Let, 'मानौ', 1),
+      new Token(TokenKind.Identifier, 'सन्देश', 1),
+      new Token(TokenKind.Equal, '=', 1),
+      new Token(TokenKind.String, '"Hello World. 123!"', 1),
+      new Token(TokenKind.Eof, '', 1)
+    ];
+
+    assert.equal(actual.length, expected.length);
+    assert.deepEqual(actual, expected);
+  });
 });

package/tests/parser.test.ts

@@ -2,7 +2,13 @@ import test, { describe } from 'node:test';
 import assert from 'node:assert/strict';
 import { Lexer } from '../src/lexer.js';
 import { Parser } from '../src/parser.js';
-import { PrintStmt, VarStmt, LiteralExpr, VariableExpr } from '../src/ast.js';
+import {
+  PrintStmt,
+  VarStmt,
+  FunctionStmt,
+  LiteralExpr,
+  VariableExpr
+} from '../src/ast.js';
 
 describe('Parser', () => {
   test('parse print statement', () => {
@@ -85,4 +91,41 @@ describe('Parser', () => {
     assert.ok(stmts[0] instanceof VarStmt);
     assert.ok(stmts[1] instanceof PrintStmt);
   });
+
+  test('parse function declaration without parameters', () => {
+    const source: string = `कार्य नमस्कार() {
+  छाप("नमस्ते")
+}`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof FunctionStmt);
+    const funcStmt = stmts[0] as FunctionStmt;
+    assert.equal(funcStmt.name.lexeme, 'नमस्कार');
+    assert.equal(funcStmt.params.length, 0);
+    assert.equal(funcStmt.body.length, 1);
+  });
+
+  test('parse function declaration with parameters', () => {
+    const source: string = `कार्य जोड(अ, ब) {
+  छाप(अ)
+  छाप(ब)
+}`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof FunctionStmt);
+    const funcStmt = stmts[0] as FunctionStmt;
+    assert.equal(funcStmt.name.lexeme, 'जोड');
+    assert.equal(funcStmt.params.length, 2);
+    assert.equal(funcStmt.params[0]!.lexeme, 'अ');
+    assert.equal(funcStmt.params[1]!.lexeme, 'ब');
+    assert.equal(funcStmt.body.length, 2);
+  });
 });