epoxylang 0.1.2 → 0.1.4

package/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Publish package
+        run: npm publish --access public

package/examples/demo.epx

@@ -3,7 +3,9 @@ make square[n] {
 }
 
 assign nums as array = {2, 4, 6};
-assign result as int = call square[nums{1}];
 
-store msg = `square of [nums{1}] is [result]`;
-show msg;
+repeat[x in 0 to 2, 1]{
+  assign result as int = call square[nums{x}]; $ yaha pe comment dal rhe hai bhaii..
+  store msg = `square of [nums{x}] is [result]`;
+  show msg;
+}

package/examples/test.epx

@@ -0,0 +1,11 @@
+all assign hello as array = {"satya0", "satya1", "satya2"};
+show hello{0};
+
+assign numbers as array = {1, 2, 3, 4, 5, 6};
+
+repeat[i in 0 to 5, 1]{
+  assign n as int = numbers{i};
+  check [(n / 2 == 1) or (n / 2 == 2) or (n / 2 == 3)] {
+    show n;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epoxylang",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "epoxy": "./bin/epoxy.js"

package/src/generator/jsgenerator.js

@@ -17,6 +17,8 @@ class JSCodeGenerator {
                 return node.statements.map(s => this.visit(s)).join("\n");
             case "AssignStatement":
                 return this.visitAssignStatement(node);
+            case "UpdateStatement":
+                return this.visitUpdateStatement(node);
             case "BinaryExpression": return this.visitBinaryExpression(node);
             case "Literal": return this.visitLiteral(node);
             case "Identifier": return this.visitIdentifier(node);
@@ -37,11 +39,30 @@ class JSCodeGenerator {
 
 
     visitAssignStatement(node) {
-        const keyword = node.isGlobal ? "var" : "let";
+        // Determine the JavaScript keyword based on mutability flags
+        let keyword;
+        if (node.isFix) {
+            keyword = "const";
+        } else if (node.isGlobal) {
+            keyword = "var";
+        } else {
+            keyword = "let";
+        }
+
+        // Handle declaration without assignment
+        if (node.value === null) {
+            return `${keyword} ${node.name};`;
+        }
+
         const value = this.visit(node.value);
         return `${keyword} ${node.name} = ${value};`;
     }
 
+    visitUpdateStatement(node) {
+        const value = this.visit(node.value);
+        return `${node.name} = ${value};`;
+    }
+
     visitBinaryExpression(node) {
         const left = this.visit(node.left);
         const right = this.visit(node.right);
@@ -111,8 +132,18 @@ class JSCodeGenerator {
 
 
     visitStoreStatement(node) {
+        // Determine the JavaScript keyword based on mutability flags
+        let keyword;
+        if (node.isFix) {
+            keyword = "const";
+        } else if (node.isGlobal) {
+            keyword = "var";
+        } else {
+            keyword = "let";
+        }
+
         const interpolated = this.convertInterpolation(node.value);
-        return `const ${node.name} = \`${interpolated}\`;`;
+        return `${keyword} ${node.name} = \`${interpolated}\`;`;
     }
 
     visitShowStatement(node) {

package/src/lexer/lexer.js

@@ -24,7 +24,12 @@ class Lexer {
 
     readNumber() {
         let num = "";
-        while (this.current && /[0-9]/.test(this.current)) {
+        let hasDecimal = false;
+
+        while (this.current && (/[0-9]/.test(this.current) || (this.current === "." && !hasDecimal))) {
+            if (this.current === ".") {
+                hasDecimal = true;
+            }
             num += this.current;
             this.advance();
         }
@@ -121,6 +126,8 @@ class Lexer {
                 "}": TokenType.RBRACE,
                 "[": TokenType.LBRACKET,
                 "]": TokenType.RBRACKET,
+                "(": TokenType.LPAREN,
+                ")": TokenType.RPAREN,
                 ";": TokenType.SEMICOLON,
                 ",": TokenType.COMMA
             };

package/src/lexer/tokens.js

@@ -2,6 +2,8 @@ const TokenType = {
     // keywords
     ASSIGN: "ASSIGN",
     ALL: "ALL",
+    FIX: "FIX",
+    UPDATE: "UPDATE",
     STORE: "STORE",
     MAKE: "MAKE",
     CALL: "CALL",
@@ -47,6 +49,8 @@ const TokenType = {
     RBRACE: "RBRACE",
     LBRACKET: "LBRACKET",
     RBRACKET: "RBRACKET",
+    LPAREN: "LPAREN",
+    RPAREN: "RPAREN",
     SEMICOLON: "SEMICOLON",
     COMMA: "COMMA",
 
@@ -64,6 +68,8 @@ class Token {
 const KEYWORDS = {
     assign: TokenType.ASSIGN,
     all: TokenType.ALL,
+    fix: TokenType.FIX,
+    update: TokenType.UPDATE,
     store: TokenType.STORE,
     make: TokenType.MAKE,
     call: TokenType.CALL,
@@ -83,6 +89,7 @@ const KEYWORDS = {
 const TYPES = [
     "string",
     "int",
+    "double",
     "bool",
     "array",
     "null",

package/src/parser/ast.js

@@ -6,9 +6,10 @@ class Program {
 }
 
 class AssignStatement {
-    constructor({ isGlobal, name, dataType, value }) {
+    constructor({ isGlobal, isFix, name, dataType, value }) {
         this.type = "AssignStatement";
-        this.isGlobal = isGlobal;
+        this.isGlobal = isGlobal; // all -> var
+        this.isFix = isFix; // fix -> const
         this.name = name;
         this.dataType = dataType; //null allowed
         this.value = value;
@@ -16,8 +17,18 @@ class AssignStatement {
 }
 
 class StoreStatement {
-    constructor({ name, value }) {
+    constructor({ isGlobal, isFix, name, value }) {
         this.type = "StoreStatement";
+        this.isGlobal = isGlobal; // all -> var
+        this.isFix = isFix; // fix -> const
+        this.name = name;
+        this.value = value;
+    }
+}
+
+class UpdateStatement {
+    constructor({ name, value }) {
+        this.type = "UpdateStatement";
         this.name = name;
         this.value = value;
     }
@@ -124,6 +135,7 @@ export {
     Program,
     AssignStatement,
     StoreStatement,
+    UpdateStatement,
     BinaryExpression,
     Identifier,
     Literal,

package/src/parser/parser.js

@@ -3,6 +3,7 @@ import {
     Program,
     AssignStatement,
     StoreStatement,
+    UpdateStatement,
     BinaryExpression,
     Identifier,
     Literal,
@@ -64,29 +65,48 @@ class Parser {
         return new Program(statements);
     }
 
+
     parseStatement() {
         const t = this.current().type;
 
-        if (t === TokenType.ALL || t === TokenType.ASSIGN) return this.parseAssign();
-        if (t === TokenType.STORE) return this.parseStore();
+        // Handle assign with optional all/fix prefix
+        if (t === TokenType.ALL || t === TokenType.FIX || t === TokenType.ASSIGN) {
+            // Check if it's assign (could be "assign", "all assign", or "fix assign")
+            if (t === TokenType.ASSIGN) return this.parseAssign();
+            if (this.peekType() === TokenType.ASSIGN) return this.parseAssign();
+        }
+
+        // Handle store with optional all/fix prefix
+        if (t === TokenType.ALL || t === TokenType.FIX || t === TokenType.STORE) {
+            // Check if it's store (could be "store", "all store", or "fix store")
+            if (t === TokenType.STORE) return this.parseStore();
+            if (this.peekType() === TokenType.STORE) return this.parseStore();
+        }
+
+        if (t === TokenType.UPDATE) return this.parseUpdate();
         if (t === TokenType.CHECK) return this.parseCheck();
         if (t === TokenType.MAKE) return this.parseMake();
         if (t === TokenType.CALL) return this.parseCall();
         if (t === TokenType.GIVE) return this.parseGive();
         if (t === TokenType.REPEAT && this.peekType() === TokenType.LBRACKET) return this.parseRepeatFor();
         if (t === TokenType.REPEAT) return this.parseRepeatUntil();
-
-        if (t === TokenType.SHOW) return this.parseShow(); // 🔥 ADD THIS
+        if (t === TokenType.SHOW) return this.parseShow();
 
         throw new Error("Unknown statement: " + t);
     }
 
+
     parseAssign() {
         let isGlobal = false;
+        let isFix = false;
 
+        // Check for 'all' or 'fix' prefix
         if (this.current().type === TokenType.ALL) {
             isGlobal = true;
             this.eat(TokenType.ALL);
+        } else if (this.current().type === TokenType.FIX) {
+            isFix = true;
+            this.eat(TokenType.FIX);
         }
 
         this.eat(TokenType.ASSIGN);
@@ -101,9 +121,25 @@ class Parser {
             this.eat(TokenType.TYPE);
         }
 
-        this.eat(TokenType.EQUAL);
+        // Check if this is a declaration without assignment
+        if (this.current().type === TokenType.SEMICOLON) {
+            // Declaration only: assign name as type;
+            if (!dataType) {
+                throw new Error(
+                    "assign: datatype required when declaring variable without value"
+                );
+            }
+            this.eat(TokenType.SEMICOLON);
+            return new AssignStatement({
+                isGlobal,
+                isFix,
+                name,
+                dataType,
+                value: null
+            });
+        }
 
-        // 🔥 FIX IS HERE
+        this.eat(TokenType.EQUAL);
         const value = this.parseExpression();
 
         // enforce rule
@@ -116,11 +152,11 @@ class Parser {
             throw new Error("assign: array literal requires 'as array'");
         }
 
-
         this.eat(TokenType.SEMICOLON);
 
         return new AssignStatement({
             isGlobal,
+            isFix,
             name,
             dataType,
             value
@@ -128,6 +164,18 @@ class Parser {
     }
 
     parseStore() {
+        let isGlobal = false;
+        let isFix = false;
+
+        // Check for 'all' or 'fix' prefix
+        if (this.current().type === TokenType.ALL) {
+            isGlobal = true;
+            this.eat(TokenType.ALL);
+        } else if (this.current().type === TokenType.FIX) {
+            isFix = true;
+            this.eat(TokenType.FIX);
+        }
+
         this.eat(TokenType.STORE);
         const name = this.current().value;
         this.eat(TokenType.IDENTIFIER);
@@ -143,7 +191,18 @@ class Parser {
         this.eat(TokenType.STRING);
         this.eat(TokenType.SEMICOLON);
 
-        return new StoreStatement({ name, value: str.value });
+        return new StoreStatement({ isGlobal, isFix, name, value: str.value });
+    }
+
+    parseUpdate() {
+        this.eat(TokenType.UPDATE);
+        const name = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+        this.eat(TokenType.EQUAL);
+        const value = this.parseExpression();
+        this.eat(TokenType.SEMICOLON);
+
+        return new UpdateStatement({ name, value });
     }
 
     parseValue() {
@@ -167,6 +226,32 @@ class Parser {
     parsePrimary() {
         const tok = this.current();
 
+        // Handle unary minus for negative numbers
+        if (tok.type === TokenType.MINUS) {
+            this.eat(TokenType.MINUS);
+            const expr = this.parsePrimary();
+            // If it's a literal number, negate it directly
+            if (expr.type === "Literal" && typeof expr.value === "number") {
+                return new Literal(-expr.value);
+            }
+            // Otherwise create a binary expression: 0 - expr
+            return new BinaryExpression(new Literal(0), TokenType.MINUS, expr);
+        }
+
+        // Handle unary plus (just ignore it)
+        if (tok.type === TokenType.PLUS) {
+            this.eat(TokenType.PLUS);
+            return this.parsePrimary();
+        }
+
+        // Parentheses for precedence
+        if (tok.type === TokenType.LPAREN) {
+            this.eat(TokenType.LPAREN);
+            const expr = this.parseExpression();
+            this.eat(TokenType.RPAREN);
+            return expr;
+        }
+
         // literals
         if (
             tok.type === TokenType.NUMBER ||

package/src/test.js

@@ -0,0 +1,11 @@
+import { compile } from './index.js';
+import { readFileSync } from 'fs';
+console.log("=== Testing test.epx ===");
+const code1 = readFileSync('./examples/test.epx', 'utf-8');
+console.log("Epoxy code:");
+console.log(code1);
+console.log("\nCompiled JavaScript:");
+const js1 = compile(code1);
+console.log(js1);
+console.log("\nRunning JavaScript:");
+eval(js1);