epoxylang 0.1.1 → 0.1.3

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/README.md

@@ -0,0 +1,319 @@
+# Epoxy Language
+
+Epoxy is a small, expressive programming language that compiles to JavaScript.  
+It is designed to be readable, explicit and strict while remaining close to core programming concepts.
+
+Epoxy focuses on:
+- Clear English-like syntax
+- Explicit intent (assign vs store)
+- Predictable execution
+- JavaScript as a compilation target
+
+The project includes:
+- A lexer
+- A parser
+- An AST
+- A JavaScript code generator
+- A CLI runner
+
+---
+
+## Installation
+
+### Global installation (recommended)
+
+```bash
+npm install -g epoxylang
+````
+
+Verify installation:
+
+```bash
+epoxy --help
+```
+
+If you are using Git Bash on Windows and the command is not found, ensure your npm global bin directory is in `PATH`:
+
+```bash
+C:\Users\<your-username>\AppData\Roaming\npm
+```
+
+---
+
+## Running an Epoxy Program
+
+Epoxy source files use the `.epx` extension.
+
+```bash
+epoxy file.epx
+```
+
+Example:
+
+```bash
+epoxy examples/demo.epx
+```
+
+---
+
+## Your First Program
+
+Create a file called `hello.epx`:
+
+```epx
+assign mymsg = "Hello, Epoxy";
+show mymsg;
+```
+
+Run it:
+
+```bash
+epoxy hello.epx
+```
+
+Output:
+
+```
+Hello, Epoxy
+```
+
+---
+
+## Language Overview
+
+### Variables
+
+Epoxy distinguishes between **computed values** and **stored strings**.
+
+#### assign — for values and expressions
+
+```epx
+assign x = 5;
+assign y as int = 10;
+assign flag as bool = true;
+assign mymsg as string = "Hello, Epoxy"
+assign myarray as array = {1,2,3,4};
+```
+
+Global variables:
+
+```epx
+all assign version = 1;
+```
+
+Type annotation is optional, but required when assigning a function call result.
+
+Supported types:
+
+* `int`
+* `string`
+* `bool`
+* `array`
+* `null`
+* `undefined`
+* `object`
+
+---
+
+### store — for interpolated strings
+
+`store` is used only for backtick strings and supports interpolation.
+
+```epx
+store msg = `Value of ex is 69`;
+show msg;
+```
+
+Function calls or variable inside `store` **must** be wrapped in `[ ]`.
+
+```epx
+store result = `Sum is [call add[2, 3]]`;
+```
+
+---
+
+## Functions
+
+### Defining a function
+
+```epx
+make add[a, b] {
+  give a + b;
+}
+```
+
+### Calling a function
+
+```epx
+call add[2,3];
+```
+
+or
+
+```epx
+assign result as int = call add[2, 3];
+show result;
+```
+
+Function calls assigned to variables **require a datatype**.
+
+---
+
+## Control Flow
+
+### Conditional statements
+
+```epx
+assign x = 10;
+check [x > 5] {
+  store ok = `[x] is greater than 5`;
+  show ok;
+}
+or check [x == 5] {
+  store ok = `[x] is equal to 5`;
+  show ok;
+}
+alt {
+  store ok = `[x] is smaller than 5`;
+  show ok;
+}
+```
+
+Supported logical operators:
+
+* `and`
+* `or`
+
+---
+
+## Loops
+
+### Repeat (for-style loop)
+
+```epx
+repeat [i in 0 to 5, 1] {
+  show i;
+}
+```
+
+Syntax:
+
+```
+repeat [variable in start to end, step] { ... }
+```
+
+---
+
+### Repeat until (do-until loop)
+
+```epx
+assign x = 0;
+
+repeat until [x > 3] {
+  show x;
+  assign x = x + 1;
+}
+```
+
+---
+
+## Arrays
+
+### Array declaration
+
+```epx
+assign nums as array = {1, 2, 3, 4};
+```
+
+### Array access
+
+```epx
+show nums{2};
+```
+
+---
+
+## Expressions
+
+Epoxy supports standard arithmetic and comparison expressions:
+
+```epx
+assign total = 10 + 10 * 2;
+assign valid = 10 > 3 and 10 < 10;
+show total;
+show valid;
+```
+
+---
+
+## Compilation Model
+
+Epoxy programs are compiled to JavaScript and executed by Node.js.
+
+Example Epoxy code:
+
+```epx
+assign x = 5;
+show x;
+```
+
+Generated JavaScript:
+
+```js
+let x = 5;
+console.log(x);
+```
+
+---
+
+## CLI Behavior
+
+* Epoxy compiles and runs code in one step
+* Errors are reported during parsing or execution
+* The runtime uses Node.js
+
+---
+
+## Project Structure
+
+```
+src/
+├── lexer/
+│   ├── lexer.js
+│   └── tokens.js
+├── parser/
+│   ├── parser.js
+│   └── ast.js
+├── generator/
+│   └── jsgenerator.js
+├── runtime/
+│   └── runner.js
+bin/
+└── epoxy.js
+```
+
+---
+
+## Versioning
+
+Epoxy follows semantic versioning:
+
+```
+MAJOR.MINOR.PATCH
+```
+
+Until `1.0.0`, breaking changes may occur between minor versions.
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Status
+
+Epoxy is an experimental language project intended for learning, exploration, and language design experimentation.
+
+Contributions, ideas, and discussions are welcome.

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.1",
+  "version": "0.1.3",
   "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);