tsslang 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsslang",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "TSSLang programming language",
   "license": "MIT",
   "bin": {

package/tss.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const file = process.argv[2];
+if (!file) {
+  console.log("Use: tss <file.tss>");
+  process.exit(1);
+}
+const code = fs.readFileSync(file, "utf8");
+
+function stripComments(line) {
+  const i = line.indexOf("#");
+  if (i >= 0) return line.slice(0, i);
+  return line;
+}
+
+function exprToJS(expr) {
+  expr = expr.trim();
+
+  expr = expr.replace(/\btrue\b/g, "true");
+  expr = expr.replace(/\bfalse\b/g, "false");
+  expr = expr.replace(/\bnull\b/g, "null");
+
+  expr = expr.replace(/\band\b/g, "&&");
+  expr = expr.replace(/\bor\b/g, "||");
+  expr = expr.replace(/\bnot\b/g, "!");
+
+  expr = expr.replace(/\bjson\.parse\b/g, "__tss.json.parse");
+  expr = expr.replace(/\bjson\.stringify\b/g, "__tss.json.stringify");
+
+  expr = expr.replace(/\bfile\.read\b/g, "__tss.file.read");
+  expr = expr.replace(/\bfile\.write\b/g, "__tss.file.write");
+
+  expr = expr.replace(/\bserver\./g, "__tss.server.");
+
+  return expr;
+}
+
+function compileTSS(source) {
+  const lines = source.split("\n");
+
+  let js = "";
+  let indent = 0;
+
+  function emit(line) {
+    js += "  ".repeat(indent) + line + "\n";
+  }
+
+  function inc() {
+    indent++;
+  }
+
+  function dec() {
+    indent = Math.max(0, indent - 1);
+  }
+
+  emit(`"use strict";`);
+  emit(`const __tss = require(path.join(__dirname, "tss_runtime.js"));`);
+  emit(`(async () => {`);
+  inc();
+
+  for (let index = 0; index < lines.length; index++) {
+    const rawLine = lines[index];
+    let line = stripComments(rawLine).trim();
+    if (!line) continue;
+
+    const closeElseInline = line.match(/^\}\s*else\s*\{$/);
+    if (closeElseInline) {
+      dec();
+      emit(`} else {`);
+      inc();
+      continue;
+    }
+
+    if (line === "else {") {
+      dec();
+      emit(`} else {`);
+      inc();
+      continue;
+    }
+
+    if (line === "}") {
+      dec();
+      emit("}");
+      continue;
+    }
+
+    if (line.startsWith("print ")) {
+      const rest = line.slice(6);
+      emit(`console.log(${exprToJS(rest)});`);
+      continue;
+    }
+
+    if (line.startsWith("let ")) {
+      emit(`let ${exprToJS(line.slice(4))};`);
+      continue;
+    }
+
+    if (/^[A-Za-z_]\w*\s*=/.test(line)) {
+      emit(`${exprToJS(line)};`);
+      continue;
+    }
+
+    if (line.startsWith("if ")) {
+      const m = line.match(/^if\s+(.+)\s*\{$/);
+      if (!m) throw new Error(`Syntax error (if) at line ${index + 1}`);
+      emit(`if (${exprToJS(m[1])}) {`);
+      inc();
+      continue;
+    }
+
+    if (line.startsWith("while ")) {
+      const m = line.match(/^while\s+(.+)\s*\{$/);
+      if (!m) throw new Error(`Syntax error (while) at line ${index + 1}`);
+      emit(`while (${exprToJS(m[1])}) {`);
+      inc();
+      continue;
+    }
+
+    if (line.startsWith("for ")) {
+      const m = line.match(/^for\s+([A-Za-z_]\w*)\s+in\s+(.+)\.\.(.+)\s*\{$/);
+      if (!m) throw new Error(`Syntax error (for) at line ${index + 1}`);
+      const varName = m[1];
+      const start = exprToJS(m[2]);
+      const end = exprToJS(m[3]);
+      emit(`for (let ${varName} = (${start}); ${varName} <= (${end}); ${varName}++) {`);
+      inc();
+      continue;
+    }
+
+    if (line.startsWith("fn ")) {
+      const m = line.match(/^fn\s+([A-Za-z_]\w*)\s*\((.*?)\)\s*\{$/);
+      if (!m) throw new Error(`Syntax error (fn) at line ${index + 1}`);
+      const name = m[1];
+      const args = m[2].trim();
+      emit(`function ${name}(${args}) {`);
+      inc();
+      continue;
+    }
+
+    if (line.startsWith("return ")) {
+      emit(`return ${exprToJS(line.slice(7))};`);
+      continue;
+    }
+
+    if (line.startsWith("run ")) {
+      const rest = line.slice(4).trim();
+      emit(`await __tss.run(${exprToJS(rest)});`);
+      continue;
+    }
+
+    if (line.startsWith("sleep ")) {
+      const rest = line.slice(6).trim();
+      emit(`await __tss.sleep(${exprToJS(rest)});`);
+      continue;
+    }
+
+    if (line.startsWith("server.get ")) {
+      const m = line.match(/^server\.get\s+(.+)\s*\{$/);
+      if (!m) throw new Error(`Syntax error (server.get) at line ${index + 1}`);
+      const route = exprToJS(m[1]);
+      emit(`__tss.server.get(${route}, async (req, res) => {`);
+      inc();
+      continue;
+    }
+
+    if (line.startsWith("server.post ")) {
+      const m = line.match(/^server\.post\s+(.+)\s*\{$/);
+      if (!m) throw new Error(`Syntax error (server.post) at line ${index + 1}`);
+      const route = exprToJS(m[1]);
+      emit(`__tss.server.post(${route}, async (req, res) => {`);
+      inc();
+      continue;
+    }
+
+    if (line.startsWith("listen ")) {
+      const port = exprToJS(line.slice(7));
+      emit(`await __tss.server.listen(${port});`);
+      continue;
+    }
+
+    if (line.startsWith("res.json ")) {
+      emit(`res.json(${exprToJS(line.slice(9))});`);
+      continue;
+    }
+
+    if (line.startsWith("res.text ")) {
+      emit(`res.text(${exprToJS(line.slice(9))});`);
+      continue;
+    }
+
+    if (line.startsWith("js:")) {
+      emit(line.slice(3).trim());
+      continue;
+    }
+
+    throw new Error(`Unknown command at line ${index + 1}: ${rawLine.trim()}`);
+  }
+
+  dec();
+  emit(`})();`);
+
+  return js;
+}
+
+try {
+  const outJS = compileTSS(code);
+  const outPath = path.join(process.cwd(), ".tss_out.js");
+  fs.writeFileSync(outPath, outJS, "utf8");
+  execSync(`node "${outPath}"`, { stdio: "inherit" });
+} catch (e) {
+  console.error("TSS Error:", e.message);
+  process.exit(1);
+}

package/tss_runtime.js

@@ -0,0 +1,132 @@
+"use strict";
+const fs = require("fs");
+const { exec } = require("child_process");
+const http = require("http");
+const url = require("url");
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, Number(ms) || 0));
+}
+
+function run(cmd) {
+  return new Promise((resolve, reject) => {
+    exec(String(cmd), { shell: true }, (err, stdout, stderr) => {
+      if (stdout) process.stdout.write(stdout);
+      if (stderr) process.stderr.write(stderr);
+      if (err) reject(err);
+      else resolve(true);
+    });
+  });
+}
+
+const file = {
+  read(p) {
+    return fs.readFileSync(String(p), "utf8");
+  },
+  write(p, content) {
+    fs.writeFileSync(String(p), String(content ?? ""), "utf8");
+    return true;
+  },
+};
+
+const json = {
+  parse(s) {
+    return JSON.parse(String(s));
+  },
+  stringify(v) {
+    return JSON.stringify(v);
+  },
+};
+
+// -------------------------
+// Minimal server
+// -------------------------
+class TSSServer {
+  constructor() {
+    this.routes = { GET: [], POST: [] };
+    this.httpServer = null;
+  }
+
+  get(route, handler) {
+    this.routes.GET.push([route, handler]);
+  }
+
+  post(route, handler) {
+    this.routes.POST.push([route, handler]);
+  }
+
+  _match(method, pathname) {
+    const list = this.routes[method] || [];
+    for (const [r, h] of list) {
+      if (String(r) === pathname) return h;
+    }
+    return null;
+  }
+
+  async listen(port) {
+    port = Number(port) || 3000;
+
+    if (this.httpServer) throw new Error("server already running");
+
+    this.httpServer = http.createServer(async (req, res) => {
+      const parsed = url.parse(req.url, true);
+      const pathname = parsed.pathname;
+
+      // Request helper
+      const reqObj = {
+        method: req.method,
+        path: pathname,
+        query: parsed.query || {},
+        headers: req.headers,
+        body: null,
+      };
+
+      // Read body for POST/PUT
+      if (req.method === "POST" || req.method === "PUT") {
+        reqObj.body = await new Promise((resolve) => {
+          let data = "";
+          req.on("data", (chunk) => (data += chunk));
+          req.on("end", () => resolve(data));
+        });
+      }
+
+      // Response helper
+      const resObj = {
+        json(obj) {
+          const s = JSON.stringify(obj);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(s);
+        },
+        text(txt) {
+          res.writeHead(200, { "Content-Type": "text/plain" });
+          res.end(String(txt));
+        },
+        status(code) {
+          res.statusCode = Number(code) || 200;
+          return resObj;
+        },
+      };
+
+      const handler = this._match(req.method, pathname);
+      if (!handler) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+        return;
+      }
+
+      try {
+        await handler(reqObj, resObj);
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("Server Error: " + e.message);
+      }
+    });
+
+    await new Promise((resolve) => this.httpServer.listen(port, resolve));
+    console.log(`✅ TSS Server running on http://127.0.0.1:${port}`);
+  }
+}
+
+const server = new TSSServer();
+
+module.exports = { sleep, run, file, json, server };