ga-lang 1.2.0 → 1.2.3

package/dist/src/ast.js

@@ -16,6 +16,30 @@ 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 BinaryExpr {
+    left;
+    operator;
+    right;
+    constructor(left, operator, right) {
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitBinaryExpr(this);
+    }
+}
 export class PrintStmt {
     expression;
     constructor(expression) {
@@ -36,3 +60,43 @@ 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);
+    }
+}
+export class ReturnStmt {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitReturnStmt(this);
+    }
+}

package/dist/src/interpreter.js

@@ -1,3 +1,12 @@
+import { BinaryExpr, FunctionStmt, ReturnStmt } from './ast.js';
+import { TokenKind } from './token.js';
+class ReturnValue extends Error {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+}
 export class Interpreter {
     environment = new Map();
     interpret(statements) {
@@ -13,18 +22,76 @@ export class Interpreter {
      */
     visitPrintStmt(stmt) {
         const value = this.evaluate(stmt.expression);
-        console.log(value);
+        console.log(this.toDevanagariString(value));
+    }
+    toDevanagariString(value) {
+        if (typeof value === 'number') {
+            return this.numberToDevanagari(value);
+        }
+        return String(value);
+    }
+    numberToDevanagari(num) {
+        const devanagariZero = 0x0966;
+        return num
+            .toString()
+            .split('')
+            .map((char) => {
+            if (char >= '0' && char <= '9') {
+                return String.fromCharCode(devanagariZero + parseInt(char));
+            }
+            return char;
+        })
+            .join('');
     }
     visitVarStmt(stmt) {
         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);
+    }
+    visitReturnStmt(stmt) {
+        const value = stmt.value !== null ? this.evaluate(stmt.value) : null;
+        throw new ReturnValue(value);
+    }
     visitLiteralExpr(expr) {
         if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
             return expr.value.slice(1, -1);
         }
+        // Check if it's a Devanagari number and convert it
+        if (typeof expr.value === 'string' && this.isDevanagariNumber(expr.value)) {
+            return this.devanagariToNumber(expr.value);
+        }
         return expr.value;
     }
+    isDevanagariNumber(value) {
+        if (value.length === 0)
+            return false;
+        for (const char of value) {
+            const code = char.charCodeAt(0);
+            if (code < 0x0966 || code > 0x096f) {
+                return false;
+            }
+        }
+        return true;
+    }
+    devanagariToNumber(value) {
+        const devanagariZero = 0x0966;
+        let num = 0;
+        for (const char of value) {
+            const code = char.charCodeAt(0);
+            num = num * 10 + (code - devanagariZero);
+        }
+        return num;
+    }
     visitVariableExpr(expr) {
         const value = this.environment.get(expr.name.lexeme);
         if (value === undefined) {
@@ -32,6 +99,105 @@ 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
+        try {
+            for (const stmt of func.body) {
+                this.execute(stmt);
+            }
+        }
+        catch (returnValue) {
+            if (returnValue instanceof ReturnValue) {
+                // Restore previous environment before returning
+                this.environment = prevEnvironment;
+                return returnValue.value;
+            }
+            throw returnValue;
+        }
+        // Restore previous environment
+        this.environment = prevEnvironment;
+        return null;
+    }
+    visitBinaryExpr(expr) {
+        const left = this.evaluate(expr.left);
+        const right = this.evaluate(expr.right);
+        // Convert Devanagari digits to regular numbers for arithmetic
+        const leftNum = this.toNumber(left);
+        const rightNum = this.toNumber(right);
+        switch (expr.operator.kind) {
+            case TokenKind.Plus:
+                // Handle string concatenation or numeric addition
+                if (typeof left === 'string' && typeof right === 'string') {
+                    return left + right;
+                }
+                return leftNum + rightNum;
+            case TokenKind.Minus:
+                return leftNum - rightNum;
+            case TokenKind.Star:
+                return leftNum * rightNum;
+            case TokenKind.Slash:
+                if (rightNum === 0) {
+                    throw new Error('Division by zero');
+                }
+                return leftNum / rightNum;
+            case TokenKind.Mod:
+                if (rightNum === 0) {
+                    throw new Error('Modulo by zero');
+                }
+                return leftNum % rightNum;
+            default:
+                throw new Error(`Unknown operator: ${expr.operator.kind}`);
+        }
+    }
+    toNumber(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string') {
+            // Check if it's a Devanagari number
+            const devanagariZero = '\u{0966}'.charCodeAt(0); // ०
+            let isDevanagari = true;
+            let num = 0;
+            for (const char of value) {
+                const code = char.charCodeAt(0);
+                if (code >= devanagariZero && code <= devanagariZero + 9) {
+                    num = num * 10 + (code - devanagariZero);
+                }
+                else if (char >= '0' && char <= '9') {
+                    isDevanagari = false;
+                }
+                else {
+                    throw new Error(`Cannot convert '${value}' to number`);
+                }
+            }
+            if (isDevanagari && value.length > 0)
+                return num;
+            // Otherwise try regular parsing
+            const parsed = parseFloat(value);
+            if (isNaN(parsed)) {
+                throw new Error(`Cannot convert '${value}' to number`);
+            }
+            return parsed;
+        }
+        throw new Error(`Cannot convert '${value}' to number`);
+    }
     /*
      * 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 { BinaryExpr, CallExpr, ExpressionStmt, FunctionStmt, LiteralExpr, PrintStmt, ReturnStmt, 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,25 @@ 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();
+        }
+        if (this.match(TokenKind.Return)) {
+            return this.parseReturnStmt();
+        }
+        return this.parseExpressionStmt();
+    }
+    parseReturnStmt() {
+        let value = null;
+        // Check if there's a value to return (not just "फिर्ता" alone)
+        if (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+            value = this.parseExpression();
+        }
+        return new ReturnStmt(value);
+    }
+    parseExpressionStmt() {
+        const expr = this.parseExpression();
+        return new ExpressionStmt(expr);
     }
     parsePrintStmt() {
         this.consume(TokenKind.OpenParen, "Expect '(' after 'छाप'");
@@ -37,8 +59,67 @@ 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.parseAddition();
+    }
+    parseAddition() {
+        let expr = this.parseMultiplication();
+        while (this.match(TokenKind.Plus, TokenKind.Minus)) {
+            const operator = this.previous();
+            const right = this.parseMultiplication();
+            expr = new BinaryExpr(expr, operator, right);
+        }
+        return expr;
+    }
+    parseMultiplication() {
+        let expr = this.parseCall();
+        while (this.match(TokenKind.Star, TokenKind.Slash, TokenKind.Mod)) {
+            const operator = this.previous();
+            const right = this.parseCall();
+            expr = new BinaryExpr(expr, operator, right);
+        }
+        return expr;
+    }
+    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)) {
@@ -47,6 +128,11 @@ export class Parser {
         if (this.match(TokenKind.Identifier)) {
             return new VariableExpr(this.previous());
         }
+        if (this.match(TokenKind.OpenParen)) {
+            const expr = this.parseExpression();
+            this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+            return expr;
+        }
         throw this.error(this.peek(), 'Expression expected.');
     }
     match(...kinds) {

package/examples/init.ga

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ga-lang",
-  "version": "1.2.0",
+  "version": "1.2.3",
   "description": "An interpreted toy programming language",
   "type": "module",
   "main": "dist/main.js",

package/src/ast.ts

@@ -7,6 +7,8 @@ export interface Expr {
 export interface ExprVisitor<T> {
   visitVariableExpr(expr: VariableExpr): T;
   visitLiteralExpr(expr: LiteralExpr): T;
+  visitCallExpr(expr: CallExpr): T;
+  visitBinaryExpr(expr: BinaryExpr): T;
 }
 
 export interface Stmt {
@@ -16,6 +18,10 @@ 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;
+  visitReturnStmt(stmt: ReturnStmt): T;
 }
 
 export class VariableExpr implements Expr {
@@ -42,6 +48,36 @@ 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 BinaryExpr implements Expr {
+  left: Expr;
+  operator: Token;
+  right: Expr;
+
+  constructor(left: Expr, operator: Token, right: Expr) {
+    this.left = left;
+    this.operator = operator;
+    this.right = right;
+  }
+
+  accept<T>(visitor: ExprVisitor<T>): T {
+    return visitor.visitBinaryExpr(this);
+  }
+}
+
 export class PrintStmt implements Stmt {
   expression: Expr;
 
@@ -67,3 +103,55 @@ 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);
+  }
+}
+
+export class ReturnStmt implements Stmt {
+  value: Expr | null;
+
+  constructor(value: Expr | null) {
+    this.value = value;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitReturnStmt(this);
+  }
+}

package/src/interpreter.ts

@@ -1,13 +1,28 @@
-import type {
-  Expr,
-  ExprVisitor,
-  LiteralExpr,
-  PrintStmt,
-  Stmt,
-  StmtVisitor,
-  VariableExpr,
-  VarStmt
+import {
+  BinaryExpr,
+  FunctionStmt,
+  ReturnStmt,
+  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';
+import { TokenKind } from './token.js';
+
+class ReturnValue extends Error {
+  value: any;
+  constructor(value: any) {
+    super();
+    this.value = value;
+  }
+}
 
 export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
   private environment: Map<string, any> = new Map();
@@ -27,7 +42,28 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
    */
   visitPrintStmt(stmt: PrintStmt): void {
     const value = this.evaluate(stmt.expression);
-    console.log(value);
+    console.log(this.toDevanagariString(value));
+  }
+
+  private toDevanagariString(value: any): string {
+    if (typeof value === 'number') {
+      return this.numberToDevanagari(value);
+    }
+    return String(value);
+  }
+
+  private numberToDevanagari(num: number): string {
+    const devanagariZero = 0x0966;
+    return num
+      .toString()
+      .split('')
+      .map((char) => {
+        if (char >= '0' && char <= '9') {
+          return String.fromCharCode(devanagariZero + parseInt(char));
+        }
+        return char;
+      })
+      .join('');
   }
 
   visitVarStmt(stmt: VarStmt): void {
@@ -36,14 +72,59 @@ 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);
+  }
+
+  visitReturnStmt(stmt: ReturnStmt): void {
+    const value = stmt.value !== null ? this.evaluate(stmt.value) : null;
+    throw new ReturnValue(value);
+  }
+
   visitLiteralExpr(expr: LiteralExpr): any {
     if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
       return expr.value.slice(1, -1);
     }
 
+    // Check if it's a Devanagari number and convert it
+    if (typeof expr.value === 'string' && this.isDevanagariNumber(expr.value)) {
+      return this.devanagariToNumber(expr.value);
+    }
+
     return expr.value;
   }
 
+  private isDevanagariNumber(value: string): boolean {
+    if (value.length === 0) return false;
+    for (const char of value) {
+      const code = char.charCodeAt(0);
+      if (code < 0x0966 || code > 0x096f) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private devanagariToNumber(value: string): number {
+    const devanagariZero = 0x0966;
+    let num = 0;
+    for (const char of value) {
+      const code = char.charCodeAt(0);
+      num = num * 10 + (code - devanagariZero);
+    }
+    return num;
+  }
+
   visitVariableExpr(expr: VariableExpr): any {
     const value = this.environment.get(expr.name.lexeme);
     if (value === undefined) {
@@ -52,6 +133,113 @@ 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
+    try {
+      for (const stmt of func.body) {
+        this.execute(stmt);
+      }
+    } catch (returnValue) {
+      if (returnValue instanceof ReturnValue) {
+        // Restore previous environment before returning
+        this.environment = prevEnvironment;
+        return returnValue.value;
+      }
+      throw returnValue;
+    }
+
+    // Restore previous environment
+    this.environment = prevEnvironment;
+
+    return null;
+  }
+
+  visitBinaryExpr(expr: BinaryExpr): any {
+    const left = this.evaluate(expr.left);
+    const right = this.evaluate(expr.right);
+
+    // Convert Devanagari digits to regular numbers for arithmetic
+    const leftNum = this.toNumber(left);
+    const rightNum = this.toNumber(right);
+
+    switch (expr.operator.kind) {
+      case TokenKind.Plus:
+        // Handle string concatenation or numeric addition
+        if (typeof left === 'string' && typeof right === 'string') {
+          return left + right;
+        }
+        return leftNum + rightNum;
+      case TokenKind.Minus:
+        return leftNum - rightNum;
+      case TokenKind.Star:
+        return leftNum * rightNum;
+      case TokenKind.Slash:
+        if (rightNum === 0) {
+          throw new Error('Division by zero');
+        }
+        return leftNum / rightNum;
+      case TokenKind.Mod:
+        if (rightNum === 0) {
+          throw new Error('Modulo by zero');
+        }
+        return leftNum % rightNum;
+      default:
+        throw new Error(`Unknown operator: ${expr.operator.kind}`);
+    }
+  }
+
+  private toNumber(value: any): number {
+    if (typeof value === 'number') return value;
+    if (typeof value === 'string') {
+      // Check if it's a Devanagari number
+      const devanagariZero = '\u{0966}'.charCodeAt(0); // ०
+      let isDevanagari = true;
+      let num = 0;
+      for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code >= devanagariZero && code <= devanagariZero + 9) {
+          num = num * 10 + (code - devanagariZero);
+        } else if (char >= '0' && char <= '9') {
+          isDevanagari = false;
+        } else {
+          throw new Error(`Cannot convert '${value}' to number`);
+        }
+      }
+      if (isDevanagari && value.length > 0) return num;
+      // Otherwise try regular parsing
+      const parsed = parseFloat(value);
+      if (isNaN(parsed)) {
+        throw new Error(`Cannot convert '${value}' to number`);
+      }
+      return parsed;
+    }
+    throw new Error(`Cannot convert '${value}' to number`);
+  }
+
   /*
    * 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,6 +1,11 @@
 import {
+  BinaryExpr,
+  CallExpr,
+  ExpressionStmt,
+  FunctionStmt,
   LiteralExpr,
   PrintStmt,
+  ReturnStmt,
   VarStmt,
   VariableExpr,
   type Expr,
@@ -20,6 +25,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 +44,29 @@ export class Parser {
       return this.parseVarStmt();
     }
 
-    throw this.error(this.peek(), 'Expression expected.');
+    if (this.match(TokenKind.Function)) {
+      return this.parseFunctionStmt();
+    }
+
+    if (this.match(TokenKind.Return)) {
+      return this.parseReturnStmt();
+    }
+
+    return this.parseExpressionStmt();
+  }
+
+  private parseReturnStmt(): ReturnStmt {
+    let value: Expr | null = null;
+    // Check if there's a value to return (not just "फिर्ता" alone)
+    if (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+      value = this.parseExpression();
+    }
+    return new ReturnStmt(value);
+  }
+
+  private parseExpressionStmt(): ExpressionStmt {
+    const expr = this.parseExpression();
+    return new ExpressionStmt(expr);
   }
 
   private parsePrintStmt(): Stmt {
@@ -59,8 +90,89 @@ 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.parseAddition();
+  }
+
+  private parseAddition(): Expr {
+    let expr = this.parseMultiplication();
+
+    while (this.match(TokenKind.Plus, TokenKind.Minus)) {
+      const operator = this.previous();
+      const right = this.parseMultiplication();
+      expr = new BinaryExpr(expr, operator, right);
+    }
+
+    return expr;
+  }
+
+  private parseMultiplication(): Expr {
+    let expr = this.parseCall();
+
+    while (this.match(TokenKind.Star, TokenKind.Slash, TokenKind.Mod)) {
+      const operator = this.previous();
+      const right = this.parseCall();
+      expr = new BinaryExpr(expr, operator, right);
+    }
+
+    return expr;
+  }
+
+  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 {
@@ -72,6 +184,12 @@ export class Parser {
       return new VariableExpr(this.previous());
     }
 
+    if (this.match(TokenKind.OpenParen)) {
+      const expr = this.parseExpression();
+      this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+      return expr;
+    }
+
     throw this.error(this.peek(), 'Expression expected.');
   }
 

package/tests/interpreter.test.ts

@@ -0,0 +1,176 @@
+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 { Interpreter } from '../src/interpreter.js';
+
+describe('Interpreter', () => {
+  function runSource(source: string): string[] {
+    const lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser = new Parser(tokens);
+    const stmts = parser.parse();
+    const interpreter = new Interpreter();
+
+    const outputs: string[] = [];
+    const originalLog = console.log;
+    console.log = (...args: any[]) => {
+      outputs.push(args.join(' '));
+    };
+
+    try {
+      interpreter.interpret(stmts);
+    } finally {
+      console.log = originalLog;
+    }
+
+    return outputs;
+  }
+
+  test('evaluate addition with Devanagari numbers', () => {
+    const source = `मानौ क = ५ + ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate subtraction', () => {
+    const source = `मानौ क = १० - २
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate multiplication', () => {
+    const source = `मानौ क = ४ * २
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate division', () => {
+    const source = `मानौ क = १५ / ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '५');
+  });
+
+  test('evaluate modulo', () => {
+    const source = `मानौ क = १७ % ५
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२');
+  });
+
+  test('evaluate operator precedence', () => {
+    const source = `मानौ क = २ + ३ * ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '१४');
+  });
+
+  test('evaluate parentheses grouping', () => {
+    const source = `मानौ क = (२ + ३) * ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२०');
+  });
+
+  test('evaluate chained addition', () => {
+    const source = `मानौ क = १ + २ + ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '६');
+  });
+
+  test('evaluate mixed operations', () => {
+    const source = `मानौ क = १० - ३ * २ + ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate division by zero throws error', () => {
+    const source = `मानौ क = १० / ०
+छाप(क)`;
+    assert.throws(() => {
+      runSource(source);
+    }, /Division by zero/);
+  });
+
+  test('evaluate modulo by zero throws error', () => {
+    const source = `मानौ क = १० % ०
+छाप(क)`;
+    assert.throws(() => {
+      runSource(source);
+    }, /Modulo by zero/);
+  });
+
+  test('evaluate complex expression', () => {
+    const source = `मानौ क = (५ + ५) * (३ - १)
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२०');
+  });
+
+  test('evaluate multiple print statements', () => {
+    const source = `मानौ क = ५ + ५
+छाप(क)
+मानौ ख = क + ५
+छाप(ख)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 2);
+    assert.equal(outputs[0], '१०');
+    assert.equal(outputs[1], '१५');
+  });
+
+  test('print string literal', () => {
+    const source = `छाप("नमस्ते")`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], 'नमस्ते');
+  });
+
+  test('function returns value', () => {
+    const source = `कार्य जोड(क, ख) {
+  फिर्ता क + ख
+}
+मानौ परिणाम = जोड(२, ३)
+छाप(परिणाम)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '५');
+  });
+
+  test('function returns expression result', () => {
+    const source = `कार्य गुणा(क, ख) {
+  फिर्ता क * ख + १०
+}
+मानौ परिणाम = गुणा(३, ४)
+छाप(परिणाम)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२२');
+  });
+
+  test('function returns string', () => {
+    const source = `कार्य नमस्कार() {
+  फिर्ता "नमस्ते संसार"
+}
+मानौ सन्देश = नमस्कार()
+छाप(सन्देश)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], 'नमस्ते संसार');
+  });
+});

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,14 @@ 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,
+  BinaryExpr
+} from '../src/ast.js';
 
 describe('Parser', () => {
   test('parse print statement', () => {
@@ -85,4 +92,128 @@ 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);
+  });
+
+  test('parse binary expression with addition', () => {
+    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 VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof LiteralExpr);
+    assert.ok(binaryExpr.right instanceof LiteralExpr);
+  });
+
+  test('parse binary expression with operator precedence', () => {
+    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 VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof LiteralExpr);
+    assert.ok(binaryExpr.right instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with parentheses', () => {
+    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 VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof BinaryExpr);
+    assert.ok(binaryExpr.right instanceof LiteralExpr);
+  });
+
+  test('parse binary expression with subtraction', () => {
+    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 VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with division', () => {
+    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 VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with modulo', () => {
+    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 VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
 });