stone-lang 0.1.0

package/frontend/parsing/index.js

@@ -0,0 +1,7 @@
+/**
+ * Frontend Parsing - Barrel exports
+ */
+export { Lexer, TokenType, tokenizeSource, tokenize } from './tokenizer.js';
+export { Parser, buildASTFromSource, buildASTFromTokens, parse } from './astBuilder.js';
+export * from './stoneAstTypes.js';
+export { createTerminalConstructors } from './terminal-registry.js';

package/frontend/parsing/sonParser.js

@@ -0,0 +1,592 @@
+/**
+ * Stone Object Notation (.son) Parser
+ *
+ * Parses .son files - a subset of Stone syntax for data/config.
+ * Supports: strings, numbers, booleans, arrays, objects, comments.
+ * No functions, imports, or control flow.
+ */
+
+// Token types for SON (simplified subset)
+const SONTokenType = {
+  // Literals
+  NUMBER: 'NUMBER',
+  STRING: 'STRING',
+  TRUE: 'TRUE',
+  FALSE: 'FALSE',
+  NONE: 'NONE',
+
+  // Identifiers (for keys)
+  IDENTIFIER: 'IDENTIFIER',
+
+  // Delimiters
+  LBRACE: 'LBRACE',     // {
+  RBRACE: 'RBRACE',     // }
+  LBRACKET: 'LBRACKET', // [
+  RBRACKET: 'RBRACKET', // ]
+
+  // Punctuation
+  COMMA: 'COMMA',       // ,
+  ASSIGN: 'ASSIGN',     // =
+  COLON: 'COLON',       // :
+
+  // Special
+  EOF: 'EOF',
+};
+
+/**
+ * SON Token
+ */
+class SONToken {
+  constructor(type, value, line, column) {
+    this.type = type;
+    this.value = value;
+    this.line = line;
+    this.column = column;
+  }
+}
+
+/**
+ * SON Lexer - tokenizes .son files
+ */
+class SONLexer {
+  constructor(source, filename = '<son>') {
+    this.source = source;
+    this.filename = filename;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.tokens = [];
+  }
+
+  tokenize() {
+    while (this.pos < this.source.length) {
+      this.skipWhitespaceAndComments();
+      if (this.pos >= this.source.length) break;
+
+      const token = this.nextToken();
+      if (token) {
+        this.tokens.push(token);
+      }
+    }
+
+    this.tokens.push(new SONToken(SONTokenType.EOF, null, this.line, this.column));
+    return this.tokens;
+  }
+
+  nextToken() {
+    const char = this.peek();
+    const startLine = this.line;
+    const startColumn = this.column;
+
+    // Numbers (including negative)
+    if (this.isDigit(char) || (char === '-' && this.isDigit(this.peek(1)))) {
+      return this.readNumber(startLine, startColumn);
+    }
+
+    // Strings
+    if (char === '"' || char === "'") {
+      return this.readString(char, startLine, startColumn);
+    }
+
+    // Identifiers and keywords
+    if (this.isAlpha(char) || char === '_') {
+      return this.readIdentifier(startLine, startColumn);
+    }
+
+    // Single-character tokens
+    this.advance();
+    switch (char) {
+      case '{':
+        return new SONToken(SONTokenType.LBRACE, '{', startLine, startColumn);
+      case '}':
+        return new SONToken(SONTokenType.RBRACE, '}', startLine, startColumn);
+      case '[':
+        return new SONToken(SONTokenType.LBRACKET, '[', startLine, startColumn);
+      case ']':
+        return new SONToken(SONTokenType.RBRACKET, ']', startLine, startColumn);
+      case ',':
+        return new SONToken(SONTokenType.COMMA, ',', startLine, startColumn);
+      case '=':
+        return new SONToken(SONTokenType.ASSIGN, '=', startLine, startColumn);
+      case ':':
+        return new SONToken(SONTokenType.COLON, ':', startLine, startColumn);
+      default:
+        throw new SONParseError(
+          `Unexpected character '${char}'`,
+          this.filename,
+          startLine,
+          startColumn
+        );
+    }
+  }
+
+  readNumber(line, column) {
+    let num = '';
+    let isFloat = false;
+
+    // Handle negative sign
+    if (this.peek() === '-') {
+      num += '-';
+      this.advance();
+    }
+
+    while (this.isDigit(this.peek()) || this.peek() === '.') {
+      if (this.peek() === '.') {
+        // Check if it's really a decimal point
+        if (!this.isDigit(this.peek(1))) {
+          break;
+        }
+        if (isFloat) {
+          throw new SONParseError(
+            'Invalid number: multiple decimal points',
+            this.filename,
+            line,
+            column
+          );
+        }
+        isFloat = true;
+      }
+      num += this.peek();
+      this.advance();
+    }
+
+    // Scientific notation
+    if (this.peek() === 'e' || this.peek() === 'E') {
+      num += this.peek();
+      this.advance();
+      isFloat = true;
+
+      if (this.peek() === '+' || this.peek() === '-') {
+        num += this.peek();
+        this.advance();
+      }
+
+      if (!this.isDigit(this.peek())) {
+        throw new SONParseError(
+          'Invalid number: expected digit after exponent',
+          this.filename,
+          line,
+          column
+        );
+      }
+
+      while (this.isDigit(this.peek())) {
+        num += this.peek();
+        this.advance();
+      }
+    }
+
+    const value = isFloat ? parseFloat(num) : parseInt(num, 10);
+    return new SONToken(SONTokenType.NUMBER, value, line, column);
+  }
+
+  readString(quote, line, column) {
+    this.advance(); // Skip opening quote
+    let str = '';
+
+    while (this.peek() !== quote && this.pos < this.source.length) {
+      if (this.peek() === '\\') {
+        this.advance();
+        const escaped = this.peek();
+        switch (escaped) {
+          case 'n': str += '\n'; break;
+          case 't': str += '\t'; break;
+          case 'r': str += '\r'; break;
+          case '\\': str += '\\'; break;
+          case quote: str += quote; break;
+          default: str += escaped;
+        }
+        this.advance();
+      } else {
+        if (this.peek() === '\n') {
+          this.line++;
+          this.column = 0;
+        }
+        str += this.peek();
+        this.advance();
+      }
+    }
+
+    if (this.peek() !== quote) {
+      throw new SONParseError(
+        'Unterminated string',
+        this.filename,
+        line,
+        column
+      );
+    }
+
+    this.advance(); // Skip closing quote
+    return new SONToken(SONTokenType.STRING, str, line, column);
+  }
+
+  readIdentifier(line, column) {
+    let id = '';
+
+    while (this.isAlphaNumeric(this.peek()) || this.peek() === '_' || this.peek() === '-') {
+      id += this.peek();
+      this.advance();
+    }
+
+    // Keywords
+    if (id === 'true') {
+      return new SONToken(SONTokenType.TRUE, true, line, column);
+    }
+    if (id === 'false') {
+      return new SONToken(SONTokenType.FALSE, false, line, column);
+    }
+    if (id === 'none' || id === 'null') {
+      return new SONToken(SONTokenType.NONE, null, line, column);
+    }
+
+    return new SONToken(SONTokenType.IDENTIFIER, id, line, column);
+  }
+
+  skipWhitespaceAndComments() {
+    while (this.pos < this.source.length) {
+      const char = this.peek();
+
+      // Whitespace
+      if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {
+        if (char === '\n') {
+          this.line++;
+          this.column = 1;
+        } else {
+          this.column++;
+        }
+        this.pos++;
+        continue;
+      }
+
+      // Comments: // to end of line
+      if (char === '/' && this.peek(1) === '/') {
+        while (this.peek() !== '\n' && this.pos < this.source.length) {
+          this.advance();
+        }
+        continue;
+      }
+
+      break;
+    }
+  }
+
+  peek(offset = 0) {
+    const pos = this.pos + offset;
+    return pos < this.source.length ? this.source[pos] : null;
+  }
+
+  advance(n = 1) {
+    for (let i = 0; i < n; i++) {
+      if (this.pos < this.source.length) {
+        if (this.source[this.pos] === '\n') {
+          this.line++;
+          this.column = 1;
+        } else {
+          this.column++;
+        }
+        this.pos++;
+      }
+    }
+  }
+
+  isDigit(char) {
+    return char !== null && char >= '0' && char <= '9';
+  }
+
+  isAlpha(char) {
+    return char !== null && ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z'));
+  }
+
+  isAlphaNumeric(char) {
+    return this.isAlpha(char) || this.isDigit(char);
+  }
+}
+
+/**
+ * SON Parse Error
+ */
+export class SONParseError extends Error {
+  constructor(message, filename, line, column) {
+    super(`${message} at ${filename}:${line}:${column}`);
+    this.name = 'SONParseError';
+    this.filename = filename;
+    this.line = line;
+    this.column = column;
+  }
+}
+
+/**
+ * SON Parser - parses tokens into a JavaScript object
+ */
+class SONParser {
+  constructor(tokens, filename = '<son>') {
+    this.tokens = tokens;
+    this.filename = filename;
+    this.pos = 0;
+  }
+
+  parse() {
+    const result = {};
+
+    // Parse top-level key = value pairs
+    while (!this.isAtEnd()) {
+      if (this.check(SONTokenType.EOF)) break;
+
+      const { key, value } = this.parseAssignment();
+      result[key] = value;
+    }
+
+    return result;
+  }
+
+  parseAssignment() {
+    const keyToken = this.expect(SONTokenType.IDENTIFIER, 'Expected identifier');
+    const key = keyToken.value;
+
+    this.expect(SONTokenType.ASSIGN, "Expected '=' after key");
+
+    const value = this.parseValue();
+
+    // Optional comma (allow trailing commas and no commas between top-level pairs)
+    this.match(SONTokenType.COMMA);
+
+    return { key, value };
+  }
+
+  parseValue() {
+    // Object
+    if (this.match(SONTokenType.LBRACE)) {
+      return this.parseObject();
+    }
+
+    // Array
+    if (this.match(SONTokenType.LBRACKET)) {
+      return this.parseArray();
+    }
+
+    // String
+    if (this.check(SONTokenType.STRING)) {
+      return this.advance().value;
+    }
+
+    // Number
+    if (this.check(SONTokenType.NUMBER)) {
+      return this.advance().value;
+    }
+
+    // Boolean
+    if (this.check(SONTokenType.TRUE) || this.check(SONTokenType.FALSE)) {
+      return this.advance().value;
+    }
+
+    // None/null
+    if (this.check(SONTokenType.NONE)) {
+      this.advance();
+      return null;
+    }
+
+    // Identifier as string (for unquoted values)
+    if (this.check(SONTokenType.IDENTIFIER)) {
+      return this.advance().value;
+    }
+
+    const token = this.peek();
+    throw new SONParseError(
+      `Unexpected token: ${token.type}`,
+      this.filename,
+      token.line,
+      token.column
+    );
+  }
+
+  parseObject() {
+    const obj = {};
+
+    while (!this.check(SONTokenType.RBRACE) && !this.isAtEnd()) {
+      // Key can be identifier or string
+      let key;
+      if (this.check(SONTokenType.IDENTIFIER)) {
+        key = this.advance().value;
+      } else if (this.check(SONTokenType.STRING)) {
+        key = this.advance().value;
+      } else {
+        const token = this.peek();
+        throw new SONParseError(
+          'Expected object key (identifier or string)',
+          this.filename,
+          token.line,
+          token.column
+        );
+      }
+
+      // = or : for assignment
+      if (!this.match(SONTokenType.ASSIGN) && !this.match(SONTokenType.COLON)) {
+        const token = this.peek();
+        throw new SONParseError(
+          "Expected '=' or ':' after object key",
+          this.filename,
+          token.line,
+          token.column
+        );
+      }
+
+      obj[key] = this.parseValue();
+
+      // Optional comma
+      this.match(SONTokenType.COMMA);
+    }
+
+    this.expect(SONTokenType.RBRACE, "Expected '}' to close object");
+    return obj;
+  }
+
+  parseArray() {
+    const arr = [];
+
+    while (!this.check(SONTokenType.RBRACKET) && !this.isAtEnd()) {
+      arr.push(this.parseValue());
+
+      // Optional comma
+      this.match(SONTokenType.COMMA);
+    }
+
+    this.expect(SONTokenType.RBRACKET, "Expected ']' to close array");
+    return arr;
+  }
+
+  // Helper methods
+  peek() {
+    return this.tokens[this.pos];
+  }
+
+  advance() {
+    if (!this.isAtEnd()) {
+      this.pos++;
+    }
+    return this.tokens[this.pos - 1];
+  }
+
+  check(type) {
+    return !this.isAtEnd() && this.peek().type === type;
+  }
+
+  match(type) {
+    if (this.check(type)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+
+  expect(type, message) {
+    if (this.check(type)) {
+      return this.advance();
+    }
+    const token = this.peek();
+    throw new SONParseError(
+      message,
+      this.filename,
+      token.line,
+      token.column
+    );
+  }
+
+  isAtEnd() {
+    return this.pos >= this.tokens.length || this.peek().type === SONTokenType.EOF;
+  }
+}
+
+/**
+ * Parse a .son file content into a JavaScript object
+ * @param {string} source - The .son file content
+ * @param {string} filename - Optional filename for error messages
+ * @returns {object} Parsed JavaScript object
+ */
+export function parseSON(source, filename = '<son>') {
+  const lexer = new SONLexer(source, filename);
+  const tokens = lexer.tokenize();
+  const parser = new SONParser(tokens, filename);
+  return parser.parse();
+}
+
+/**
+ * Stringify a JavaScript object to .son format
+ * @param {object} obj - The object to stringify
+ * @param {number} indent - Indentation level (default 2)
+ * @returns {string} .son formatted string
+ */
+export function stringifySON(obj, indent = 2) {
+  // Top-level objects are written as bare key = value pairs (no wrapping braces)
+  if (typeof obj === 'object' && obj !== null && !Array.isArray(obj)) {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return '';
+
+    const pairs = keys.map(key => {
+      const keyStr = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+      return keyStr + ' = ' + stringifyValue(obj[key], 0, indent);
+    });
+
+    return pairs.join('\n') + '\n';
+  }
+
+  return stringifyValue(obj, 0, indent);
+}
+
+function stringifyValue(value, depth, indent) {
+  if (value === null || value === undefined) {
+    return 'none';
+  }
+
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+
+  if (typeof value === 'number') {
+    return String(value);
+  }
+
+  if (typeof value === 'string') {
+    // Use quotes if string contains special chars, otherwise can be unquoted for simple identifiers
+    if (/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(value) && !isKeyword(value)) {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]';
+
+    const spaces = ' '.repeat((depth + 1) * indent);
+    const closingSpaces = ' '.repeat(depth * indent);
+
+    const items = value.map(v => spaces + stringifyValue(v, depth + 1, indent));
+    return '[\n' + items.join(',\n') + '\n' + closingSpaces + ']';
+  }
+
+  if (typeof value === 'object') {
+    const keys = Object.keys(value);
+    if (keys.length === 0) return '{}';
+
+    const spaces = ' '.repeat((depth + 1) * indent);
+    const closingSpaces = ' '.repeat(depth * indent);
+
+    const pairs = keys.map(key => {
+      const keyStr = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+      return spaces + keyStr + ' = ' + stringifyValue(value[key], depth + 1, indent);
+    });
+
+    return '{\n' + pairs.join(',\n') + '\n' + closingSpaces + '}';
+  }
+
+  return String(value);
+}
+
+function isKeyword(str) {
+  return str === 'true' || str === 'false' || str === 'none' || str === 'null';
+}
+
+export default {
+  parse: parseSON,
+  stringify: stringifySON,
+  SONParseError,
+};