lumos-language 1.0.5 → 1.0.7

package/README.md

@@ -44,11 +44,24 @@ Lumos is influenced by
     <li><code>break</code></li>
     <li><code>continue</code></li>
   </ul>
+- Launch from your terminal:
+  <ol>
+    <li><code>cd path/to/lumos-language</code></li>
+    <li><code>node index.cjs</code></li>
+  </ol>
+- Compile on your terminal:
+  <ol>
+    <li><code>cd path/to/lumos-language</code></li>
+    <li><code>node index.cjs main.lumos</code></li>
+  </ol>
 
 ## Caution
 
 - Please write the code in a single line and don't execute it while writing.
 
+## Change
+- You can refer to [npm](https://www.npmjs.com/package/lumos-language) or [GitHub Releases](https://github.com/Uchida16104/Lumos-Language/releases).
+
 ## More Info
 Get from <strong><a href="https://cdn.glitch.global/a6e15949-0cae-4ce8-a653-5883a6d0adc5/Lumos.pdf?v=1748869028196">pdf</a></strong>.
 

package/index.cjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const readline = require("readline");
+
+const vars = {};
+const functions = {};
+
+function evaluateExpression(expr, scope = vars) {
+  expr = expr.trim();
+  if (/^".*"$/.test(expr)) return expr.slice(1, -1);
+  if (expr in scope) return scope[expr];
+  if (!isNaN(expr)) return Number(expr);
+
+  let m;
+
+  if ((m = expr.match(/^(.+?)\s*(==|!=|<=|>=|<|>)\s*(.+)$/))) {
+    const a = evaluateExpression(m[1], scope);
+    const b = evaluateExpression(m[3], scope);
+    switch (m[2]) {
+      case "==": return a == b;
+      case "!=": return a != b;
+      case "<=": return a <= b;
+      case ">=": return a >= b;
+      case "<":  return a < b;
+      case ">":  return a > b;
+    }
+  }
+
+  if ((m = expr.match(/^(.+?)\s*([+\-*/%])\s*(.+)$/))) {
+    const a = evaluateExpression(m[1], scope);
+    const b = evaluateExpression(m[3], scope);
+    switch (m[2]) {
+      case "+": return a + b;
+      case "-": return a - b;
+      case "*": return a * b;
+      case "/": return a / b;
+      case "%": return a % b;
+    }
+  }
+
+  throw new Error("Invalid expression: " + expr);
+}
+
+function interpret(cmd) {
+  let m;
+
+  if ((m = cmd.match(/^let\s+(\w+)\s*=\s*(.+)$/))) {
+    const name = m[1], value = evaluateExpression(m[2]);
+    vars[name] = value;
+    return `${name} = ${value}`;
+  }
+
+  if ((m = cmd.match(/^def\s+(\w+)\(([^)]*)\)\s*{([\s\S]+)}$/))) {
+    const name = m[1];
+    const params = m[2].split(",").map(s => s.trim()).filter(Boolean);
+    const body = m[3].trim();
+    functions[name] = { params, body };
+    return `Function ${name} defined.`;
+  }
+
+  if ((m = cmd.match(/^(\w+)\((.*)\)$/)) && functions[m[1]]) {
+    const func = functions[m[1]];
+    const args = m[2] ? m[2].split(",").map(s => s.trim()) : [];
+    const localScope = { ...vars };
+    func.params.forEach((p, i) => {
+      localScope[p] = evaluateExpression(args[i], vars);
+    });
+    const letm = func.body.match(/^let\s+(\w+)\s*=\s*(.+)$/);
+    if (!letm) throw new Error("Invalid function body");
+    const res = evaluateExpression(letm[2], localScope);
+    vars[letm[1]] = res;
+    return `${letm[1]} = ${res}`;
+  }
+
+  if ((m = cmd.match(/^for\s+(\w+)\s*=\s*(\d+)\s+to\s+(\d+)\s*{([\s\S]+)}$/))) {
+    const [_, v, s, e, body] = m;
+    for (let i = +s; i <= +e; i++) {
+      vars[v] = i;
+      interpret(body.trim());
+    }
+    return `Looped ${v} from ${s} to ${e}`;
+  }
+
+  if ((m = cmd.match(/^while\s*\((.+?)\)\s*{([\s\S]+)}$/))) {
+    const cond = m[1], body = m[2].trim();
+    let count = 0;
+    while (evaluateExpression(cond)) {
+      interpret(body);
+      if (++count > 10000) throw new Error("Infinite loop detected");
+    }
+    return "While loop executed.";
+  }
+
+  if ((m = cmd.match(/^if\s*\((.+?)\)\s*{([\s\S]+?)}(?:\s*elsif\s*\((.+?)\)\s*{([\s\S]+?)})?(?:\s*else\s*{([\s\S]+?)})?$/))) {
+    if (evaluateExpression(m[1])) return interpret(m[2].trim());
+    else if (m[3] && evaluateExpression(m[3])) return interpret(m[4].trim());
+    else if (m[5]) return interpret(m[5].trim());
+    return "If condition was false.";
+  }
+
+  if ((m = cmd.match(/^(\d+)\.times\s+do\s+\|(\w+)\|\s*{([\s\S]+)}\s*end$/))) {
+    const [_, n, v, body] = m;
+    let out = [];
+    for (let i = 0; i < +n; i++) {
+      vars[v] = i;
+      out.push(interpret(body.trim()));
+    }
+    return out.join("\n");
+  }
+
+  if (vars.hasOwnProperty(cmd)) {
+    return vars[cmd];
+  }
+
+  throw new Error("Unrecognized command: " + cmd);
+}
+
+function runFile(fn) {
+  const lines = fs.readFileSync(fn, "utf8").split(/\r?\n/);
+  lines.filter(line => line.trim()).forEach(line => {
+    const res = interpret(line.trim());
+    console.log("> " + res);
+  });
+}
+
+function startREPL() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "Lumos> ",
+  });
+  console.log("Welcome to Lumos CLI (type exit)");
+  rl.prompt();
+
+  rl.on("line", line => {
+    if (line.trim() === "exit") return rl.close();
+    if (line.trim()) {
+      try {
+        const res = interpret(line.trim());
+        console.log("> " + res);
+      } catch (e) {
+        console.error("! " + e.message);
+      }
+    }
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    console.log("Goodbye!");
+    process.exit(0);
+  });
+}
+
+const args = process.argv.slice(2);
+if (args.length) runFile(args[0]);
+else startREPL();

package/package.json

@@ -1,29 +1,32 @@
 {
   "name": "lumos-language",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Lumos - Interactive CLI",
-  "main": "index.js",
+  "main": "index.cjs",
   "bin": {
-    "lumos": "index.js"
+    "lumos": "./index.cjs"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Uchida16104/Lumos.git"
+    "url": "git+https://github.com/Uchida16104/Lumos-Language.git"
   },
   "publishConfig": {
-  "@Uchida16104:registry": "https://npm.pkg.github.com"
+    "@Uchida16104:registry": "https://npm.pkg.github.com"
   },
   "bugs": {
-    "url": "https://github.com/Uchida16104/Lumos/issues"
+    "url": "https://github.com/Uchida16104/Lumos-Language/issues"
   },
   "homepage": "https://lumos-language.glitch.me",
   "author": "Hirotoshi Uchida",
   "license": "MIT",
-  "type": "module",
+  "type": "commonjs",
   "scripts": {
     "test": "lumos"
   },
   "keywords": [
     "programming-language"
-  ]
+  ],
+  "dependencies": {
+    "lumos-language": "^1.0.7"
+  }
 }

package/index.js

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-
-const readline = require("readline");
-
-class BreakException {}
-class ContinueException {}
-
-const vars = {};
-const functions = {};
-
-function evaluateExpression(expr) {
-  try {
-    return Function(...Object.keys(vars), `return (${expr})`)(...Object.values(vars));
-  } catch (e) {
-    throw new Error("Invalid expression: " + expr);
-  }
-}
-
-function preprocessCommand(command) {
-  command = command.replace(/\r\n/g, "\n");
-
-  const timesRegex = /^(\d+)\.times\s+do\s+\|([a-zA-Z_][a-zA-Z0-9_]*)\|([\s\S]+?)end$/;
-  const timesMatch = command.match(timesRegex);
-  if (timesMatch) {
-    const count = parseInt(timesMatch[1]);
-    const varName = timesMatch[2];
-    const body = timesMatch[3].trim();
-    let result = "";
-    for (let i = 0; i < count; i++) {
-      vars[varName] = i;
-      result += interpret(body) + "\n";
-    }
-    return result.trim();
-  }
-
-  const ifElseRegex = /^if\s*\((.+?)\)\s*\{([\s\S]+?)\}(?:\s*elsif\s*\((.+?)\)\s*\{([\s\S]+?)\})?(?:\s*else\s*\{([\s\S]+?)\})?$/;
-  const ifElseMatch = command.match(ifElseRegex);
-  if (ifElseMatch) {
-    const [, cond1, body1, cond2, body2, body3] = ifElseMatch;
-    if (evaluateExpression(cond1)) return interpret(body1.trim());
-    if (cond2 && evaluateExpression(cond2)) return interpret(body2.trim());
-    if (body3) return interpret(body3.trim());
-    return "If condition was false.";
-  }
-
-  return null;
-}
-
-function interpret(command) {
-  const preprocessed = preprocessCommand(command);
-  if (preprocessed !== null) return preprocessed;
-
-  command = command.trim();
-
-  if (/^let\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/.test(command)) {
-    const [, name, value] = command.match(/^let\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)$/);
-    vars[name] = evaluateExpression(value);
-    return `${name} = ${vars[name]}`;
-  }
-
-  if (/^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\(([^)]*)\)\s*\{([\s\S]*)\}$/.test(command)) {
-    const [, name, args, body] = command.match(/^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\(([^)]*)\)\s*\{([\s\S]*)\}$/);
-    functions[name] = {
-      args: args.split(",").map((s) => s.trim()).filter((s) => s),
-      body: body.trim(),
-    };
-    return `Function ${name} defined.`;
-  }
-
-  if (/^([a-zA-Z_][a-zA-Z0-9_]*)\((.*)\)$/.test(command)) {
-    const [, name, argstr] = command.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\((.*)\)$/);
-    if (!functions[name]) throw new Error("Undefined function: " + name);
-    const func = functions[name];
-    const argValues = argstr.split(",").map((s) => evaluateExpression(s.trim()));
-    const localVars = {};
-    func.args.forEach((arg, i) => (localVars[arg] = argValues[i]));
-
-    const prevVars = Object.assign({}, vars);
-    Object.assign(vars, localVars);
-
-    let result;
-    try {
-      result = interpret(func.body);
-    } finally {
-      Object.assign(vars, prevVars);
-    }
-    return result;
-  }
-
-  let loopMatch = command.match(/^for\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+?)\s+to\s+(.+?)\s*\{([\s\S]+)\}$/);
-  if (loopMatch) {
-    const vname = loopMatch[1];
-    const start = evaluateExpression(loopMatch[2]);
-    const end = evaluateExpression(loopMatch[3]);
-    const body = loopMatch[4];
-
-    for (let i = start; i <= end; i++) {
-      vars[vname] = i;
-      try {
-        interpret(body.trim());
-      } catch (e) {
-        if (e instanceof BreakException) break;
-        if (e instanceof ContinueException) continue;
-        throw e;
-      }
-    }
-    return `Looped ${vname} from ${start} to ${end}`;
-  }
-
-  let whileMatch = command.match(/^while\s*\((.+?)\)\s*\{([\s\S]+)\}$/);
-  if (whileMatch) {
-    const condition = whileMatch[1];
-    const body = whileMatch[2];
-
-    while (evaluateExpression(condition)) {
-      try {
-        interpret(body.trim());
-      } catch (e) {
-        if (e instanceof BreakException) break;
-        if (e instanceof ContinueException) continue;
-        throw e;
-      }
-    }
-    return "While loop executed.";
-  }
-
-  if (command === "break") throw new BreakException();
-  if (command === "continue") throw new ContinueException();
-
-  return evaluateExpression(command);
-}
-
-// CLI 入力受付
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  prompt: "Lumos> ",
-});
-
-console.log("Welcome to Lumos CLI!");
-rl.prompt();
-
-rl.on("line", (line) => {
-  const command = line.trim();
-  try {
-    const result = interpret(command);
-    console.log("> " + result);
-  } catch (err) {
-    console.error("! " + err.message);
-  }
-  rl.prompt();
-});
-