epoxylang 0.1.13 → 0.1.15

package/epoxy-vs-code/syntaxes/epoxy.tmLanguage.json

@@ -68,7 +68,7 @@
         },
         {
           "name": "keyword.other.epoxy",
-          "match": "\\b(call|show|as)\\b"
+          "match": "\\b(call|show|as|error|snafu|skip|halt)\\b"
         },
         {
           "name": "keyword.operator.logical.epoxy",

package/examples/guess.epx

@@ -0,0 +1,25 @@
+all assign guessed as string;
+@js :~
+let randnum = Math.floor(Math.random() * 99) + 1;
+~:
+show randnum;
+all assign tries = 0;
+all assign numberoftries = 5;
+repeat until[tries > numberoftries]{
+    update guessed = :input;
+    check[guessed != randnum]{
+        update tries = tries + 1;
+        check[guessed > randnum]{
+            snafu "you guessed too high";
+            show "tries left: " + (numberoftries - tries + 1);
+        }
+        alt{
+            snafu "you guessed too low";
+            show "tries left: " + (numberoftries - tries + 1);
+        }
+    }
+    alt{
+        show `you guessed it right in [tries]`;
+        halt;
+    }
+}

package/examples/interpolation_test.epx

@@ -0,0 +1,22 @@
+$ Test string interpolation in show and error
+
+assign tries = 78;
+
+$ Test 1: store with interpolation (already working)
+store finalmsg = `you guessed it right in [tries]`;
+show finalmsg;
+
+$ Test 2: show with backtick interpolation (should now work)
+show `you guessed it right in [tries]`;
+
+$ Test 3: error with backtick interpolation
+error `error occurred at try [tries]`;
+
+$ Test 4: snafu with backtick interpolation
+snafu `snafu at try number [tries]`;
+
+$ Test 5: Complex expression in interpolation
+assign x = 10;
+assign y = 20;
+show `sum of x and y is [x + y]`;
+error `product is [x * y]`;

package/examples/loop_control_test.epx

@@ -0,0 +1,47 @@
+$ Test skip (continue) and halt (break) keywords
+
+show "Test 1: skip (continue) in loop";
+assign count = 0;
+repeat[i in 0 to 10, 1]{
+    check[i == 5]{
+        show "skipping 5";
+        skip;
+    }
+    update count = count + 1;
+    show i;
+}
+show `total iterations: [count]`;
+
+show "---";
+
+show "Test 2: halt (break) in loop";
+repeat[i in 0 to 100, 1]{
+    check[i == 7]{
+        show "halting at 7";
+        halt;
+    }
+    show i;
+}
+
+show "---";
+
+show "Test 3: skip even numbers";
+repeat[i in 0 to 10, 1]{
+    check[i % 2 == 0]{
+        skip;
+    }
+    show `odd number: [i]`;
+}
+
+show "---";
+
+show "Test 4: halt when condition met";
+assign found = false;
+repeat[i in 0 to 20, 1]{
+    check[i == 15]{
+        update found = true;
+        show "found target at 15";
+        halt;
+    }
+}
+show `found: [found]`;

package/examples/square.epx

@@ -4,8 +4,7 @@ make square[n] {
 assign nums as array = {2, 4, 6};
 assign ok as string;
 repeat[x in nums]{
-  assign result as int = call square[nums{x}]; $ yaha pe comment dal rhe hai bhaii..
-  $ assign add as int = call [x,y] -> give x +y
+  assign result as int = call square[nums{x}];
   store msg = `square of [nums{x}] is [result]`;
   show msg;
 }

package/package.json

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

package/src/generator/jsgenerator.js

@@ -28,6 +28,8 @@ class JSCodeGenerator {
             case "StoreStatement": return this.visitStoreStatement(node);
             case "ShowStatement": return this.visitShowStatement(node);
             case "ErrorStatement": return this.visitErrorStatement(node);
+            case "SkipStatement": return this.visitSkipStatement(node);
+            case "HaltStatement": return this.visitHaltStatement(node);
             case "FunctionDeclaration": return this.visitFunctionDeclaration(node);
             case "ReturnStatement": return this.visitReturnStatement(node);
             case "CallExpression": return this.visitCallExpression(node);
@@ -162,23 +164,50 @@ class JSCodeGenerator {
     }
 
     visitShowStatement(node) {
+        // Check if the value is a backtick string literal that needs interpolation
+        if (node.value.type === "Literal" && typeof node.value.value === "string") {
+            // We need to check the original token to see if it was a backtick string
+            // Since we don't have access to the token here, we'll handle it differently
+            // by creating a template literal if the string contains []
+            const str = node.value.value;
+            if (str.includes("[") && str.includes("]")) {
+                // This might be an interpolated string, convert it
+                const interpolated = this.convertInterpolation(str);
+                return `console.log(\`${interpolated}\`);`;
+            }
+        }
         return `console.log(${this.visit(node.value)});`;
     }
 
     visitErrorStatement(node) {
-        return `
-        
-        console.error("\x1b[31m" + ${this.visit(node.value)}  + "\x1b[0m");`;
+        // Check if the value is a backtick string literal that needs interpolation
+        if (node.value.type === "Literal" && typeof node.value.value === "string") {
+            const str = node.value.value;
+            if (str.includes("[") && str.includes("]")) {
+                // This might be an interpolated string, convert it
+                const interpolated = this.convertInterpolation(str);
+                return `console.error(\`${interpolated}\`);`;
+            }
+        }
+        return `console.error(${this.visit(node.value)});`;
+    }
+
+    visitSkipStatement(node) {
+        return "continue;";
+    }
+
+    visitHaltStatement(node) {
+        return "break;";
     }
 
     visitFunctionDeclaration(node) {
         const params = node.params.join(", ");
         const body = node.body.map(s => this.visit(s)).join("\n");
-        return `function ${node.name}(${params}) {\n${body}\n}`;
+        return `function ${node.name} (${params}) { \n${body} \n } `;
     }
 
     visitReturnStatement(node) {
-        return `return ${this.visit(node.value)};`;
+        return `return ${this.visit(node.value)}; `;
     }
 
     visitArrayLiteral(node) {
@@ -189,27 +218,30 @@ class JSCodeGenerator {
     visitArrayAccess(node) {
         const arr = this.visit(node.array);
         const idx = this.visit(node.index);
-        return `${arr}[${idx}]`;
+        return `${arr} [${idx}]`;
     }
 
     visitCallExpression(node) {
         const args = node.args.map(a => this.visit(a)).join(", ");
-        return `${node.name}(${args})`;
+        return `${node.name} (${args})`;
     }
 
     visitIfChain(node) {
-        let code = `if (${this.visit(node.condition)}) {\n`;
+        let code = `if (${this.visit(node.condition)}) {
+\n`;
         code += node.body.map(s => this.visit(s)).join("\n");
         code += "\n}";
 
         for (const oc of node.orChecks) {
-            code += ` else if (${this.visit(oc.condition)}) {\n`;
+            code += ` else if (${this.visit(oc.condition)}) {
+    \n`;
             code += oc.body.map(s => this.visit(s)).join("\n");
             code += "\n}";
         }
 
         if (node.altBody) {
-            code += ` else {\n`;
+            code += ` else {
+        \n`;
             code += node.altBody.map(s => this.visit(s)).join("\n");
             code += "\n}";
         }
@@ -224,9 +256,9 @@ class JSCodeGenerator {
         // Handle array iteration: repeat[x in arrayName]
         if (node.arrayName) {
             return `
-for (let ${v} = 0; ${v} < ${node.arrayName}.length; ${v}++) {
+            for (let ${v} = 0; ${v} < ${node.arrayName}.length; ${v} ++) {
 ${body}
-}`.trim();
+            } `.trim();
         }
 
         // Handle numeric range with bidirectional support
@@ -237,9 +269,9 @@ ${body}
         // Generate bidirectional loop: compare start and end at runtime
         // If start <= end: increment, else: decrement
         return `
-for (let ${v} = ${start}; ${start} <= ${end} ? ${v} <= ${end} : ${v} >= ${end}; ${start} <= ${end} ? ${v} += ${step} : ${v} -= ${step}) {
+            for (let ${v} = ${start}; ${start} <= ${end} ? ${v} <= ${end} : ${v} >= ${end}; ${start} <= ${end} ? ${v} += ${step} : ${v} -= ${step}) {
 ${body}
-}`.trim();
+            } `.trim();
     }
 
     visitRepeatUntil(node) {
@@ -247,9 +279,9 @@ ${body}
         const body = node.body.map(s => this.visit(s)).join("\n");
 
         return `
-do {
+            do {
 ${body}
-} while (!(${condition}));`.trim();
+            } while (!(${condition})); `.trim();
     }
 
     visitMethodCall(node) {
@@ -310,7 +342,7 @@ ${body}
                     return this.convertPythonSlice(target, args[0]);
 
                 default:
-                    throw new Error(`Unknown array method: ${methodName}`);
+                    throw new Error(`Unknown array method: ${methodName} `);
             }
         }
 
@@ -344,18 +376,18 @@ ${body}
                     return `${target}.replace(${this.visit(args[0])}, ${this.visit(args[1])})`;
 
                 default:
-                    throw new Error(`Unknown string method: ${methodName}`);
+                    throw new Error(`Unknown string method: ${methodName} `);
             }
         }
 
-        throw new Error(`Unknown target type: ${node.targetType}`);
+        throw new Error(`Unknown target type: ${node.targetType} `);
     }
 
     visitLambdaExpression(node) {
         // Convert lambda to arrow function: call [x] -> x % 2 == 0 => (x) => x % 2 === 0
         const params = node.params.join(", ");
         const body = this.visit(node.body);
-        return `(${params}) => ${body}`;
+        return `(${params}) => ${body} `;
     }
 
     convertPythonSlice(target, sliceExpr) {
@@ -369,17 +401,17 @@ ${body}
             // Parse slice notation
             if (slice === "::-1") {
                 // Reverse array
-                return `${target}.slice().reverse();`;
+                return `${target}.slice().reverse(); `;
             } else if (slice.startsWith("::")) {
                 // Every nth element
                 const step = parseInt(slice.substring(2));
-                return `${target}.filter((_, i) => i % ${step} === 0);`;
+                return `${target}.filter((_, i) => i % ${step} === 0); `;
             } else if (slice.includes(":")) {
                 // Range slice
                 const parts = slice.split(":");
                 const start = parts[0] || "0";
                 const end = parts[1] || `${target}.length`;
-                return `${target}.slice(${start}, ${end});`;
+                return `${target}.slice(${start}, ${end}); `;
             }
         }
 

package/src/lexer/lexer.js

@@ -173,6 +173,13 @@ class Lexer {
                 // If not :input, fall through to handle : as COLON token
             }
 
+            // three-char operators (check BEFORE two-char!)
+            const peek1 = this.peek();
+            const peek2 = this.pos + 2 < this.input.length ? this.input[this.pos + 2] : null;
+            const threeChar = this.current + peek1 + peek2;
+            if (threeChar === "===") { this.advance(); this.advance(); this.advance(); return new Token(TokenType.EQEQEQ); }
+            if (threeChar === "!==") { this.advance(); this.advance(); this.advance(); return new Token(TokenType.NOTEQEQ); }
+
             // double-char operators
             const twoChar = this.current + this.peek();
             if (twoChar === "==") { this.advance(); this.advance(); return new Token(TokenType.EQEQ); }

package/src/lexer/tokens.js

@@ -20,6 +20,8 @@ const TokenType = {
     SHOW: "SHOW",
     ERROR: "ERROR",
     SNAFU: "SNAFU",
+    SKIP: "SKIP",
+    HALT: "HALT",
     METHOD: "METHOD",
 
     // datatypes
@@ -50,7 +52,9 @@ const TokenType = {
     GTE: "GTE",
     LTE: "LTE",
     EQEQ: "EQEQ",
+    EQEQEQ: "EQEQEQ",
     NOTEQ: "NOTEQ",
+    NOTEQEQ: "NOTEQEQ",
     ARROW: "ARROW",
 
     // symbols
@@ -97,6 +101,8 @@ const KEYWORDS = {
     show: TokenType.SHOW,
     error: TokenType.ERROR,
     snafu: TokenType.SNAFU,
+    skip: TokenType.SKIP,
+    halt: TokenType.HALT,
     method: TokenType.METHOD,
 };
 
@@ -121,8 +127,10 @@ const OP_MAP = {
     LT: "<",
     GTE: ">=",
     LTE: "<=",
-    EQEQ: "===",
-    NOTEQ: "!==",
+    EQEQ: "==",
+    EQEQEQ: "===",
+    NOTEQ: "!=",
+    NOTEQEQ: "!==",
     AND: "&&",
     OR: "||"
 };

package/src/parser/ast.js

@@ -127,6 +127,18 @@ class ErrorStatement {
     }
 }
 
+class SkipStatement {
+    constructor() {
+        this.type = "SkipStatement";
+    }
+}
+
+class HaltStatement {
+    constructor() {
+        this.type = "HaltStatement";
+    }
+}
+
 class RepeatFor {
     constructor(varName, start, end, step, body, arrayName = null) {
         this.type = "RepeatFor";
@@ -187,6 +199,8 @@ export {
     RepeatUntil,
     ShowStatement,
     ErrorStatement,
+    SkipStatement,
+    HaltStatement,
     RepeatFor,
     RawJSBlock,
     InputExpression,

package/src/parser/parser.js

@@ -15,6 +15,8 @@ import {
     RepeatUntil,
     ShowStatement,
     ErrorStatement,
+    SkipStatement,
+    HaltStatement,
     RepeatFor,
     RawJSBlock,
     InputExpression,
@@ -98,6 +100,8 @@ class Parser {
         if (t === TokenType.REPEAT) return this.parseRepeatUntil();
         if (t === TokenType.SHOW) return this.parseShow();
         if (t === TokenType.ERROR || t === TokenType.SNAFU) return this.parseError();
+        if (t === TokenType.SKIP) return this.parseSkip();
+        if (t === TokenType.HALT) return this.parseHalt();
         if (t === TokenType.METHOD) return this.parseMethodCall();
 
         throw new Error("Unknown statement: " + t);
@@ -449,7 +453,8 @@ class Parser {
             [
                 TokenType.GT, TokenType.LT,
                 TokenType.GTE, TokenType.LTE,
-                TokenType.EQEQ, TokenType.NOTEQ
+                TokenType.EQEQ, TokenType.NOTEQ,
+                TokenType.EQEQEQ, TokenType.NOTEQEQ
             ].includes(this.current().type)
         ) {
             const op = this.current().type;
@@ -686,6 +691,18 @@ class Parser {
         return new ErrorStatement(value);
     }
 
+    parseSkip() {
+        this.eat(TokenType.SKIP);
+        this.eat(TokenType.SEMICOLON);
+        return new SkipStatement();
+    }
+
+    parseHalt() {
+        this.eat(TokenType.HALT);
+        this.eat(TokenType.SEMICOLON);
+        return new HaltStatement();
+    }
+
     parseMethodCall() {
         this.eat(TokenType.METHOD);
         this.eat(TokenType.COLON);