starlight-cli 1.0.2 → 1.0.4

package/src/evaluator.js

@@ -0,0 +1,400 @@
+const readlineSync = require('readline-sync');
+const fs = require('fs');
+const Lexer = require('./lexer');
+const Parser = require('./parser');
+
+class ReturnValue {
+  constructor(value) { this.value = value; }
+}
+class BreakSignal {}
+class ContinueSignal {}
+
+class Environment {
+  constructor(parent = null) {
+    this.store = Object.create(null);
+    this.parent = parent;
+  }
+
+  has(name) {
+    if (name in this.store) return true;
+    if (this.parent) return this.parent.has(name);
+    return false;
+  }
+
+  get(name) {
+    if (name in this.store) return this.store[name];
+    if (this.parent) return this.parent.get(name);
+    throw new Error(`Undefined variable: ${name}`);
+  }
+
+  set(name, value) {
+    if (name in this.store) { this.store[name] = value; return value; }
+    if (this.parent && this.parent.has(name)) { return this.parent.set(name, value); }
+    this.store[name] = value;
+    return value;
+  }
+
+  define(name, value) {
+    this.store[name] = value;
+    return value;
+  }
+}
+
+class Evaluator {
+  constructor() {
+    this.global = new Environment();
+    this.setupBuiltins();
+  }
+
+  setupBuiltins() {
+    this.global.define('len', arg => {
+        if (Array.isArray(arg) || typeof arg === 'string') return arg.length;
+        if (arg && typeof arg === 'object') return Object.keys(arg).length;
+        return 0;
+    });
+
+    this.global.define('print', arg => { console.log(arg); return null; });
+    this.global.define('type', arg => {
+        if (Array.isArray(arg)) return 'array';
+        return typeof arg;
+    });
+    this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
+    this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
+
+    this.global.define('ask', prompt => {
+        const readlineSync = require('readline-sync');
+        return readlineSync.question(prompt + ' ');
+    });
+    this.global.define('num', arg => {
+    const n = Number(arg);
+    if (Number.isNaN(n)) {
+        throw new Error('Cannot convert value to number');
+    }
+    return n;
+});
+
+this.global.define('str', arg => {
+    return String(arg);
+});
+
+}
+
+
+  evaluate(node, env = this.global) {
+    switch (node.type) {
+      case 'Program': return this.evalProgram(node, env);
+      case 'BlockStatement': return this.evalBlock(node, new Environment(env));
+      case 'VarDeclaration': return this.evalVarDeclaration(node, env);
+      case 'AssignmentExpression': return this.evalAssignment(node, env);
+      case 'CompoundAssignment': return this.evalCompoundAssignment(node, env);
+      case 'SldeployStatement': return this.evalSldeploy(node, env);
+      case 'AskStatement': return this.evalAsk(node, env);
+      case 'DefineStatement': return this.evalDefine(node, env);
+      case 'ExpressionStatement': return this.evaluate(node.expression, env);
+      case 'BinaryExpression': return this.evalBinary(node, env);
+      case 'LogicalExpression': return this.evalLogical(node, env);
+      case 'UnaryExpression': return this.evalUnary(node, env);
+      case 'Literal': return node.value;
+      case 'Identifier': return env.get(node.name);
+      case 'IfStatement': return this.evalIf(node, env);
+      case 'WhileStatement': return this.evalWhile(node, env);
+      case 'ForStatement': return this.evalFor(node, env);
+      case 'BreakStatement': throw new BreakSignal();
+      case 'ContinueStatement': throw new ContinueSignal();
+      case 'ImportStatement': return this.evalImport(node, env);
+      case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
+      case 'CallExpression': return this.evalCall(node, env);
+      case 'ReturnStatement': {
+        const val = node.argument ? this.evaluate(node.argument, env) : null;
+        throw new ReturnValue(val);
+      }
+      case 'ArrayExpression': return node.elements.map(el => this.evaluate(el, env));
+      case 'IndexExpression': return this.evalIndex(node, env);
+      case 'ObjectExpression': return this.evalObject(node, env);
+      case 'MemberExpression': return this.evalMember(node, env);
+      case 'UpdateExpression': return this.evalUpdate(node, env);
+      default:
+        throw new Error(`Unknown node type in evaluator: ${node.type}`);
+    }
+  }
+
+  evalProgram(node, env) {
+    let result = null;
+    for (const stmt of node.body) {
+      result = this.evaluate(stmt, env);
+    }
+    return result;
+  }
+ evalImport(node, env) {
+  const path = node.path;
+  let lib;
+
+  try {
+    lib = require(path);
+  } catch (e) {
+    const fullPath = path.endsWith('.sl') ? path : path + '.sl';
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Import not found: ${path}`);
+    }
+
+    const code = fs.readFileSync(fullPath, 'utf-8');
+    const tokens = new Lexer(code).getTokens();
+    const ast = new Parser(tokens).parse();
+
+    const moduleEnv = new Environment(env);
+    this.evaluate(ast, moduleEnv);
+
+    lib = {};
+    for (const key of Object.keys(moduleEnv.store)) {
+      lib[key] = moduleEnv.store[key];
+    }
+
+    // JS-style default export fallback
+    lib.default = lib;
+  }
+
+  for (const spec of node.specifiers) {
+    if (spec.type === 'DefaultImport') {
+      env.define(spec.local, lib.default ?? lib);
+    }
+
+    if (spec.type === 'NamespaceImport') {
+      env.define(spec.local, lib);
+    }
+
+    if (spec.type === 'NamedImport') {
+      if (!(spec.imported in lib)) {
+        throw new Error(`Module '${path}' has no export '${spec.imported}'`);
+      }
+      env.define(spec.local, lib[spec.imported]);
+    }
+  }
+
+  return null;
+}
+
+  evalBlock(node, env) {
+    let result = null;
+    for (const stmt of node.body) {
+      try {
+        result = this.evaluate(stmt, env);
+      } catch (e) {
+        if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
+        throw e;
+      }
+    }
+    return result;
+  }
+
+  evalVarDeclaration(node, env) {
+    const val = this.evaluate(node.expr, env);
+    return env.define(node.id, val);
+  }
+
+  evalAssignment(node, env) {
+    const rightVal = this.evaluate(node.right, env);
+    const left = node.left;
+
+    if (left.type === 'Identifier') return env.set(left.name, rightVal);
+    if (left.type === 'MemberExpression') {
+      const obj = this.evaluate(left.object, env);
+      obj[left.property] = rightVal;
+      return rightVal;
+    }
+    if (left.type === 'IndexExpression') {
+      const obj = this.evaluate(left.object, env);
+      const idx = this.evaluate(left.indexer, env);
+      obj[idx] = rightVal;
+      return rightVal;
+    }
+
+    throw new Error('Invalid assignment target');
+  }
+
+  evalCompoundAssignment(node, env) {
+    const left = node.left;
+    let current;
+
+    if (left.type === 'Identifier') current = env.get(left.name);
+    else if (left.type === 'MemberExpression') current = this.evalMember(left, env);
+    else if (left.type === 'IndexExpression') current = this.evalIndex(left, env);
+    else throw new Error('Invalid compound assignment target');
+
+    const rhs = this.evaluate(node.right, env);
+    let computed;
+    switch (node.operator) {
+      case 'PLUSEQ': computed = current + rhs; break;
+      case 'MINUSEQ': computed = current - rhs; break;
+      case 'STAREQ': computed = current * rhs; break;
+      case 'SLASHEQ': computed = current / rhs; break;
+      case 'MODEQ': computed = current % rhs; break;
+      default: throw new Error('Unknown compound operator');
+    }
+
+    if (left.type === 'Identifier') env.set(left.name, computed);
+    else if (left.type === 'MemberExpression') this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+    else this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+
+    return computed;
+  }
+
+  evalSldeploy(node, env) {
+    const val = this.evaluate(node.expr, env);
+    console.log(val);
+    return val;
+  }
+
+  evalAsk(node, env) {
+    const prompt = this.evaluate(node.prompt, env);
+    const input = readlineSync.question(prompt + ' ');
+    return input;
+  }
+
+  evalDefine(node, env) {
+    const val = node.expr ? this.evaluate(node.expr, env) : null;
+    return this.global.define(node.id, val);
+  }
+
+  evalBinary(node, env) {
+    const l = this.evaluate(node.left, env);
+    const r = this.evaluate(node.right, env);
+    switch (node.operator) {
+      case 'PLUS': return l + r;
+      case 'MINUS': return l - r;
+      case 'STAR': return l * r;
+      case 'SLASH': return l / r;
+      case 'MOD': return l % r;
+      case 'EQEQ': return l === r;
+      case 'NOTEQ': return l !== r;
+      case 'LT': return l < r;
+      case 'LTE': return l <= r;
+      case 'GT': return l > r;
+      case 'GTE': return l >= r;
+      default: throw new Error(`Unknown binary operator ${node.operator}`);
+    }
+  }
+
+  evalLogical(node, env) {
+    const l = this.evaluate(node.left, env);
+    if (node.operator === 'AND') return l && this.evaluate(node.right, env);
+    if (node.operator === 'OR') return l || this.evaluate(node.right, env);
+    throw new Error(`Unknown logical operator ${node.operator}`);
+  }
+
+  evalUnary(node, env) {
+    const val = this.evaluate(node.argument, env);
+    switch (node.operator) {
+      case 'NOT': return !val;
+      case 'MINUS': return -val;
+      case 'PLUS': return +val;
+      default: throw new Error(`Unknown unary operator ${node.operator}`);
+    }
+  }
+
+  evalIf(node, env) {
+    const test = this.evaluate(node.test, env);
+    if (test) return this.evaluate(node.consequent, env);
+    if (node.alternate) return this.evaluate(node.alternate, env);
+    return null;
+  }
+
+  evalWhile(node, env) {
+    while (this.evaluate(node.test, env)) {
+      try { this.evaluate(node.body, env); }
+      catch (e) {
+        if (e instanceof BreakSignal) break;
+        if (e instanceof ContinueSignal) continue;
+        throw e;
+      }
+    }
+    return null;
+  }
+
+  evalFor(node, env) {
+    const local = new Environment(env);
+    if (node.init) this.evaluate(node.init, local);
+    while (!node.test || this.evaluate(node.test, local)) {
+      try { this.evaluate(node.body, local); }
+      catch (e) {
+        if (e instanceof BreakSignal) break;
+        if (e instanceof ContinueSignal) { if (node.update) this.evaluate(node.update, local); continue; }
+        throw e;
+      }
+      if (node.update) this.evaluate(node.update, local);
+    }
+    return null;
+  }
+
+  evalFunctionDeclaration(node, env) {
+    const fn = { params: node.params, body: node.body, env };
+    env.define(node.name, fn);
+    return null;
+  }
+
+  evalCall(node, env) {
+    const calleeEvaluated = this.evaluate(node.callee, env);
+    if (typeof calleeEvaluated === 'function') {
+      const args = node.arguments.map(a => this.evaluate(a, env));
+      return calleeEvaluated(...args);
+    }
+    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+      throw new Error('Call to non-function');
+    }
+    const fn = calleeEvaluated;
+    const callEnv = new Environment(fn.env);
+    fn.params.forEach((p, i) => {
+      const argVal = node.arguments[i] ? this.evaluate(node.arguments[i], env) : null;
+      callEnv.define(p, argVal);
+    });
+    try { return this.evaluate(fn.body, callEnv); }
+    catch (e) { if (e instanceof ReturnValue) return e.value; throw e; }
+  }
+
+  evalIndex(node, env) {
+    const obj = this.evaluate(node.object, env);
+    const idx = this.evaluate(node.indexer, env);
+    if (obj == null) throw new Error('Indexing null/undefined');
+    return obj[idx];
+  }
+
+  evalObject(node, env) {
+    const out = {};
+    for (const p of node.props) out[p.key] = this.evaluate(p.value, env);
+    return out;
+  }
+
+  evalMember(node, env) {
+    const obj = this.evaluate(node.object, env);
+    if (obj == null) throw new Error('Member access of null/undefined');
+    return obj[node.property];
+  }
+
+  evalUpdate(node, env) {
+    const arg = node.argument;
+    const getCurrent = () => {
+      if (arg.type === 'Identifier') return env.get(arg.name);
+      if (arg.type === 'MemberExpression') return this.evalMember(arg, env);
+      if (arg.type === 'IndexExpression') return this.evalIndex(arg, env);
+      throw new Error('Invalid update target');
+    };
+    const setValue = (v) => {
+      if (arg.type === 'Identifier') env.set(arg.name, v);
+      else if (arg.type === 'MemberExpression') {
+        const obj = this.evaluate(arg.object, env);
+        obj[arg.property] = v;
+      }
+      else if (arg.type === 'IndexExpression') {
+        const obj = this.evaluate(arg.object, env);
+        const idx = this.evaluate(arg.indexer, env);
+        obj[idx] = v;
+      }
+    };
+    const current = getCurrent();
+    const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
+    if (node.prefix) { setValue(newVal); return newVal; }
+    else { setValue(newVal); return current; }
+  }
+}
+
+module.exports = Evaluator;  

package/src/lexer.js

@@ -0,0 +1,157 @@
+class Lexer {
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+    this.currentChar = input[0] || null;
+  }
+
+  advance() {
+    this.pos++;
+    this.currentChar = this.pos < this.input.length ? this.input[this.pos] : null;
+  }
+
+  peek() {
+    return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
+  }
+
+  error(msg) {
+    throw new Error(`LEXER ERROR: ${msg} at position ${this.pos}`);
+  }
+
+  skipWhitespace() {
+    while (this.currentChar && /\s/.test(this.currentChar)) this.advance();
+  }
+
+  skipComment() {
+    if (this.currentChar === '#') {
+      if (this.peek() === '*') {
+        this.advance(); this.advance(); // skip #*
+        while (this.currentChar !== null) {
+          if (this.currentChar === '*' && this.peek() === '#') {
+            this.advance(); this.advance();
+            return;
+          }
+          this.advance();
+        }
+        this.error("Unterminated multi-line comment (#* ... *#)");
+      } else {
+        while (this.currentChar && this.currentChar !== '\n') this.advance();
+      }
+    }
+  }
+
+  number() {
+    let result = '';
+    while (this.currentChar && /[0-9]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+
+    if (this.currentChar === '.' && /[0-9]/.test(this.peek())) {
+      result += '.'; this.advance();
+      while (this.currentChar && /[0-9]/.test(this.currentChar)) {
+        result += this.currentChar;
+        this.advance();
+      }
+      return { type: 'NUMBER', value: parseFloat(result) };
+    }
+
+    return { type: 'NUMBER', value: parseInt(result) };
+  }
+
+  identifier() {
+    let result = '';
+    while (this.currentChar && /[A-Za-z0-9_]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+
+    const keywords = [
+      'let', 'sldeploy', 'if', 'else', 'while', 'for',
+      'break', 'continue', 'func', 'return', 'true', 'false', 'null',
+      'ask', 'define', 'import', 'from', 'as'
+    ];
+
+    if (keywords.includes(result)) {
+      return { type: result.toUpperCase(), value: result };
+    }
+
+    return { type: 'IDENTIFIER', value: result };
+}
+
+
+  string() {
+    const quote = this.currentChar;
+    this.advance();
+    let result = '';
+
+    while (this.currentChar && this.currentChar !== quote) {
+      if (this.currentChar === '\\') {
+        this.advance();
+        switch (this.currentChar) {
+          case 'n': result += '\n'; break;
+          case 't': result += '\t'; break;
+          case '"': result += '"'; break;
+          case "'": result += "'"; break;
+          case '\\': result += '\\'; break;
+          default: result += this.currentChar;
+        }
+      } else {
+        result += this.currentChar;
+      }
+      this.advance();
+    }
+
+    if (this.currentChar !== quote) {
+      this.error('Unterminated string literal');
+    }
+
+    this.advance();
+    return { type: 'STRING', value: result };
+  }
+
+  getTokens() {
+    const tokens = [];
+
+    while (this.currentChar !== null) {
+      if (/\s/.test(this.currentChar)) { this.skipWhitespace(); continue; }
+      if (this.currentChar === '#') { this.skipComment(); continue; }
+      if (/[0-9]/.test(this.currentChar)) { tokens.push(this.number()); continue; }
+      if (/[A-Za-z_]/.test(this.currentChar)) { tokens.push(this.identifier()); continue; }
+      if (this.currentChar === '"' || this.currentChar === "'") { tokens.push(this.string()); continue; }
+
+      const char = this.currentChar;
+      const next = this.peek();
+
+      if (char === '=' && next === '=') { tokens.push({ type: 'EQEQ' }); this.advance(); this.advance(); continue; }
+      if (char === '=' && next === '>') { tokens.push({ type: 'ARROW' }); this.advance(); this.advance(); continue; }
+      if (char === '!' && next === '=') { tokens.push({ type: 'NOTEQ' }); this.advance(); this.advance(); continue; }
+      if (char === '<' && next === '=') { tokens.push({ type: 'LTE' }); this.advance(); this.advance(); continue; }
+      if (char === '>' && next === '=') { tokens.push({ type: 'GTE' }); this.advance(); this.advance(); continue; }
+      if (char === '&' && next === '&') { tokens.push({ type: 'AND' }); this.advance(); this.advance(); continue; }
+      if (char === '|' && next === '|') { tokens.push({ type: 'OR' }); this.advance(); this.advance(); continue; }
+      if (char === '+' && next === '+') { tokens.push({ type: 'PLUSPLUS' }); this.advance(); this.advance(); continue; }
+      if (char === '-' && next === '-') { tokens.push({ type: 'MINUSMINUS' }); this.advance(); this.advance(); continue; }
+
+      const map = { '+': 'PLUSEQ', '-': 'MINUSEQ', '*': 'STAREQ', '/': 'SLASHEQ', '%': 'MODEQ' };
+      if (next === '=' && map[char]) { tokens.push({ type: map[char] }); this.advance(); this.advance(); continue; }
+
+      const singles = {
+        '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'MOD',
+        '=': 'EQUAL', '<': 'LT', '>': 'GT', '!': 'NOT',
+        '(': 'LPAREN', ')': 'RPAREN', '{': 'LBRACE', '}': 'RBRACE',
+        ';': 'SEMICOLON', ',': 'COMMA', '[': 'LBRACKET', ']': 'RBRACKET',
+        ':': 'COLON', '.': 'DOT'
+      };
+
+      if (singles[char]) { tokens.push({ type: singles[char] }); this.advance(); continue; }
+
+      this.error("Unexpected character: " + char);
+    }
+
+    tokens.push({ type: 'EOF' });
+    return tokens;
+  }
+}
+
+module.exports = Lexer;