@ianlangs/mathscript 1.2.0 → 1.4.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "type": "module",
   "name": "@ianlangs/mathscript",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "superset de js",
-  "main": "src/main.js",
+  "main": "src/transpile.js",
   "scripts": {
-    "test": "node ./src/main.js --init"
+    "test": "node ./src/msc.js --init"
   },
   "repository": {
     "type": "git",
@@ -24,8 +24,8 @@
     "url": "https://github.com/IanLangs/Mathscript/issues"
   },
   "bin": {
-    "msc": "./src/main.js",
-    "ms-node": "./src/node.js"
+    "msc": "./src/msc.js",
+    "ms-node": "./src/msnode.js"
   },
   "homepage": "https://github.com/IanLangs/Mathscript#readme"
 }

package/src/msc.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import fs from 'fs'
+import { transpile } from './transpile.js'
+
+function init(files) {
+    const config = { Files: files }
+    fs.writeFileSync('msconfig.json', JSON.stringify(config, null, 4))
+    console.log('msconfig.json creado')
+}
+
+function transpileFiles(files) {
+    for (const file of files) {
+        const code = fs.readFileSync(file, 'utf-8')
+        const out = transpile(code, file)
+        fs.writeFileSync(file.replace(/\.ms$/, '.js'), out)
+        console.log(`✔ ${file}`)
+    }
+}
+
+function transpileFromConfig(path = 'msconfig.json') {
+    const config = JSON.parse(fs.readFileSync(path, 'utf-8'))
+    transpileFiles(config.Files)
+}
+
+const args = process.argv.slice(2)
+
+if (args[0] === '--init' || args[0] === '-i') {
+    init(args.slice(1))
+}
+else if (args[0] === '--transpile' || args[0] === '-t') {
+    transpileFiles(args.slice(1))
+}
+else if (args.length === 0) {
+    transpileFromConfig()
+}
+else if (args.length === 1 && args[0].endsWith('.json')) {
+    transpileFromConfig(args[0])
+}
+else {
+    console.log(`Uso:
+
+msc --init <archivos.ms>
+msc -i <archivos.ms>
+
+msc --transpile <archivos.ms>
+msc -t <archivos.ms>
+
+msc <config.json>
+msc
+`)
+}

package/src/msnode.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import fs from 'fs'
+import { transpile } from './transpile.js'
+
+const file = process.argv[2]
+
+if (!file) {
+    console.log("Uso: ms-node archivo.ms")
+    process.exit(1)
+}
+
+const code = fs.readFileSync(file, 'utf-8')
+const js = transpile(code, file)
+eval(js)

package/src/transpile.js

@@ -1,83 +1,93 @@
-const Consts = [
-  [/::\s*[^\s\(\)]*/g, ""],
-  [/mut\s+([a-zA-Z_]\w*)\s*=\s*(.+)/g, "let $1 = (()=>{let v=$2; return {get:()=>v,set:n=>v=n}})()"],
-  [/immut\s+([a-zA-Z_]\w*)/g, "delete $1.set"],
-  [/using\(/g, "require("],
-  [/fn/g, "function"],
-]
-
-function analyzeMS(code) {
-  const lines = code.split("\n")
-  const scopes = [new Map()] // nombre -> { mut: boolean, kind }
-
-  function findVar(name) {
-    for (let s of scopes) {
-      if (s.has(name)) return s.get(name)
-    }
-    return null
-  }
-
-  lines.forEach((line, i) => {
-    const ln = i + 1
-    const trimmed = line.trim()
-
-    if (trimmed.includes("{")) scopes.unshift(new Map())
-    if (trimmed.includes("}")) scopes.shift()
-
-    // mut x = ...
-    const mutMatch = line.match(/^\s*mut\s+([a-zA-Z_]\w*)/)
-    if (mutMatch) {
-      const name = mutMatch[1]
-      scopes[0].set(name, { mut: true, kind: "mut" })
-      return
-    }
+export function transpile(code, filename = "<input>") {
+    code = code.replace("using(", "require(").replace(/::?[^=\n\(\)]*/g, "").replace(/\bfn\b/g, "function")
+    const lines = code.split('\n')
+    const vars = new Map()
+    const output = []
 
-    // let x = ...
-    const letMatch = line.match(/^\s*let\s+([a-zA-Z_]\w*)/)
-    if (letMatch) {
-      const name = letMatch[1]
-      scopes[0].set(name, { mut: false, kind: "let" })
-      return
+    function error(line, msg) {
+        console.error(`\n[MS ERROR] ${filename}:${line}\n  ${msg}\n`)
+        process.exit(1)
     }
 
-    // const x = ...
-    const constMatch = line.match(/^\s*const\s+([a-zA-Z_]\w*)/)
-    if (constMatch) {
-      const name = constMatch[1]
-      scopes[0].set(name, { mut: false, kind: "const" })
-      return
-    }
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i]
+        const line = raw.trim()
+        const ln = i + 1
 
-    // immut x
-    const im = line.match(/^\s*immut\s+([a-zA-Z_]\w*)/)
-    if (im) {
-      const name = im[1]
-      const v = findVar(name)
+        if (!line) {
+            output.push(raw)
+            continue
+        }
 
-      if (!v) {
-        throw new Error(`MS Compile Error (line ${ln}): '${name}' is not declared`)
-      }
+        // mut x = value
+        let m = line.match(/^mut\s+([a-zA-Z_]\w*)\s*=\s*(.+)$/)
+        if (m) {
+            const name = m[1]
+            const value = m[2]
 
-      if (!v.mut) {
-        throw new Error(
-          `MS Compile Error (line ${ln}): '${name}' is not mutable (declared as ${v.kind})`
-        )
-      }
+            if (vars.has(name)) {
+                error(ln, `'${name}' ya está declarada`)
+            }
 
-      v.mut = false
-      return
-    }
-  })
-}
+            vars.set(name, { mutable: true })
+            output.push(`let ${name} = ${value}`)
+            continue
+        }
+
+        // immut x
+        m = line.match(/^immut\s+([a-zA-Z_]\w*)$/)
+        if (m) {
+            const name = m[1]
+
+            if (!vars.has(name)) {
+                error(ln, `'${name}' no está declarada`)
+            }
 
+            const info = vars.get(name)
+            if (!info.mutable) {
+                error(ln, `'${name}' no es mutable`)
+            }
 
-function transpile(code, ...consts) {
-  analyzeMS(code)
+            info.mutable = false
+            continue
+        }
+
+        // x = y
+        m = line.match(/^([a-zA-Z_]\w*)\s*=\s*(.+)$/)
+        if (m) {
+            const name = m[1]
+
+            if (vars.has(name)) {
+                const info = vars.get(name)
+                if (!info.mutable) {
+                    error(ln, `'${name}' es inmutable`)
+                }
+            }
+
+            output.push(raw)
+            continue
+        }
+
+        // let x =
+        m = line.match(/^let\s+([a-zA-Z_]\w*)\s*=/)
+        if (m) {
+            vars.set(m[1], { mutable: true })
+            output.push(raw)
+            continue
+        }
+
+        // const x =
+        m = line.match(/^const\s+([a-zA-Z_]\w*)\s*=/)
+        if (m) {
+            vars.set(m[1], { mutable: false })
+            output.push(raw)
+            continue
+        }
+
+        output.push(raw)
+    }
 
-  for (let [i, j] of consts) {
-    code = code.replace(i, j)
-  }
-  return code
+    return output.join('\n')
 }
 
-export default { transpile, Consts }
+export default { transpile }

package/tests/funcs.js

@@ -4,7 +4,7 @@ function suma(a, b) {
 
 console.log(suma(3, 4)) // 7
 
-function saludo(nombre) {
+function saludo(nombre ) {
     return "Hola " + nombre
 }
 

package/tests/vars.js

@@ -1,13 +1,12 @@
 // Mutable
-let x = (()=>{let v=5; return {get:()=>v,set:n=>v=n}})()
-console.log(x.get()) // 5
-x.set(10)
-console.log(x.get()) // 10
+let x = 5
+console.log(x) // 5
+x = 10
+console.log(x) // 10
 
 // Inmutable
-delete x.set
 try {
-    x.set(20) // debería dar error
+    //x = 20 // debería dar error
 } catch(e) {
     console.log("error mutabilidad") // esperado
 }
@@ -15,7 +14,7 @@ try {
 // Variable
 let y = "hola"
 console.log(y) // "hola"
-// delete y.set // error no es mutable
+// immut y // error no es mutable
 
 
 // Const

package/tests/vars.ms

@@ -1,16 +1,12 @@
 // Mutable
-mut x::number = 5
-console.log(x.get()) // 5
-x.set(10)
-console.log(x.get()) // 10
+mut x = 5
+console.log(x) // 5
+x = 10
+console.log(x) // 10
 
 // Inmutable
 immut x
-try {
-    x.set(20) // debería dar error
-} catch(e) {
-    console.log("error mutabilidad") // esperado
-}
+//x = 20 //  error
 
 // Variable
 let y = "hola"

package/src/main.js

@@ -1,29 +0,0 @@
-#!/bin/env node
-import T from './transpile.js'
-import fs from 'fs'
-
-function processConfig(config) {
-    for (let file of config.Files) {
-        try {
-            let code = fs.readFileSync(file, "utf-8")
-            code = T.transpile(code, ...(T.Consts))
-            fs.writeFileSync(file.replace(/\.ms$/g, ".js"), code, 'utf-8')
-        } catch(e) {
-            console.error(`Error procesando ${file}:`, e.message)
-        }
-    }
-}
-
-if(process.argv[2] == "-i" || process.argv[2] == "--init") {
-    let config = {Files:[]}
-    config.Files = process.argv.slice(3)
-    fs.writeFileSync("msconfig.json", JSON.stringify(config, ["Files"], 4))
-    process.exit(0)
-} else if (process.argv[2] == "-t" || process.argv[2] == "--transpile") {
-    let config = {Files:process.argv.slice(3)}
-    processConfig(config)
-} else if (process.argv.length == 2) {
-    processConfig(JSON.parse(fs.readFileSync("msconfig.json", 'utf-8')))
-} else if (process.argv.length == 3) {
-    processConfig(JSON.parse(fs.readFileSync(process.argv[2], 'utf-8')))
-}

package/src/node.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-import fs from "fs"
-import T from "./transpile.js"
-
-const file = process.argv[2]
-if (!file) {
-  console.error("Usage: ms-node <file.ms>")
-  process.exit(1)
-}
-
-
-const source = fs.readFileSync(file, "utf-8")
-const js = T.transpile(source, ...(T.Consts))
-const run = new Function(js)
-run()