calc-mcp-server 0.1.0

package/src/parser/lexer.ts

@@ -0,0 +1,216 @@
+import { Token, TokenType } from './ast.js';
+
+export class Lexer {
+  private pos = 0;
+  private input = '';
+  private length = 0;
+
+  tokenize(input: string): Token[] {
+    this.input = input;
+    this.pos = 0;
+    this.length = input.length;
+    const tokens: Token[] = [];
+
+    while (this.pos < this.length) {
+      const char = this.input[this.pos];
+
+      if (this.isWhitespace(char)) {
+        this.skipWhitespace();
+        continue;
+      }
+
+      const token = this.readToken();
+      if (token && token.type !== 'WHITESPACE') {
+        tokens.push(token);
+      }
+    }
+
+    tokens.push({
+      type: 'EOF',
+      value: '',
+      position: { start: this.pos, end: this.pos },
+    });
+
+    return tokens;
+  }
+
+  private readToken(): Token | null {
+    const char = this.input[this.pos];
+    const start = this.pos;
+
+    // Hex literal: 0x or 0X
+    if (char === '0' && this.peek() === 'x') {
+      return this.readHexLiteral(start);
+    }
+
+    // Binary literal: 0b or 0B
+    if (char === '0' && this.peek() === 'b') {
+      return this.readBinaryLiteral(start);
+    }
+
+    // Octal literal: 0o or 0O
+    if (char === '0' && this.peek() === 'o') {
+      return this.readOctalLiteral(start);
+    }
+
+    // Number (decimal or float)
+    if (this.isDigit(char) || (char === '.' && this.isDigit(this.peek()))) {
+      return this.readNumber(start);
+    }
+
+    // Operators
+    if (this.isOperatorChar(char)) {
+      return this.readOperator(start);
+    }
+
+    // Parentheses
+    if (char === '(') {
+      this.advance();
+      return { type: 'LPAREN', value: '(', position: { start, end: this.pos } };
+    }
+
+    if (char === ')') {
+      this.advance();
+      return { type: 'RPAREN', value: ')', position: { start, end: this.pos } };
+    }
+
+    // Char literal
+    if (char === "'") {
+      return this.readCharLiteral(start);
+    }
+
+    // Unknown character
+    this.advance();
+    return null;
+  }
+
+  private readNumber(start: number): Token {
+    let value = '';
+
+    while (this.pos < this.length && (this.isDigit(this.input[this.pos]) || this.input[this.pos] === '.')) {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    return { type: 'NUMBER', value, position: { start, end: this.pos } };
+  }
+
+  private readHexLiteral(start: number): Token {
+    this.advance(); // '0'
+    this.advance(); // 'x'
+
+    let value = '0x';
+    while (this.pos < this.length && this.isHexDigit(this.input[this.pos])) {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    return { type: 'HEX', value, position: { start, end: this.pos } };
+  }
+
+  private readBinaryLiteral(start: number): Token {
+    this.advance(); // '0'
+    this.advance(); // 'b'
+
+    let value = '0b';
+    while (this.pos < this.length && (this.input[this.pos] === '0' || this.input[this.pos] === '1')) {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    return { type: 'BINARY', value, position: { start, end: this.pos } };
+  }
+
+  private readOctalLiteral(start: number): Token {
+    this.advance(); // '0'
+    this.advance(); // 'o'
+
+    let value = '0o';
+    while (this.pos < this.length && this.isOctalDigit(this.input[this.pos])) {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    return { type: 'OCTAL', value, position: { start, end: this.pos } };
+  }
+
+  private readOperator(start: number): Token {
+    // Check for multi-char operators: <<, >>, >>>
+    const twoChar = this.input.substring(this.pos, this.pos + 2);
+
+    if (twoChar === '<<' || twoChar === '>>') {
+      // Check for >>>
+      if (twoChar === '>>' && this.peek(2) === '>') {
+        this.pos += 3;
+        return { type: 'OPERATOR', value: '>>>', position: { start, end: this.pos } };
+      }
+      this.pos += 2;
+      return { type: 'OPERATOR', value: twoChar, position: { start, end: this.pos } };
+    }
+
+    // Single char operators
+    const op = this.input[this.pos];
+    this.advance();
+    return { type: 'OPERATOR', value: op, position: { start, end: this.pos } };
+  }
+
+  private readCharLiteral(start: number): Token {
+    this.advance(); // opening '
+
+    let value = "'";
+
+    // Handle escape sequences
+    if (this.input[this.pos] === '\\') {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    if (this.pos < this.length) {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    if (this.pos < this.length && this.input[this.pos] === "'") {
+      value += this.input[this.pos];
+      this.advance();
+    }
+
+    return { type: 'CHAR_LITERAL', value, position: { start, end: this.pos } };
+  }
+
+  private skipWhitespace(): void {
+    while (this.pos < this.length && this.isWhitespace(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+
+  private advance(): void {
+    this.pos++;
+  }
+
+  private peek(offset = 1): string {
+    return this.pos + offset < this.length ? this.input[this.pos + offset] : '';
+  }
+
+  private isWhitespace(char: string): boolean {
+    return /\s/.test(char);
+  }
+
+  private isDigit(char: string): boolean {
+    return /[0-9]/.test(char);
+  }
+
+  private isHexDigit(char: string): boolean {
+    return /[0-9a-fA-F]/.test(char);
+  }
+
+  private isOctalDigit(char: string): boolean {
+    return /[0-7]/.test(char);
+  }
+
+  private isOperatorChar(char: string): boolean {
+    return ['+', '-', '*', '/', '%', '&', '|', '^', '~', '!', '<', '>'].includes(char);
+  }
+}
+
+export type { Token, TokenType };

package/src/parser/parser.ts

@@ -0,0 +1,154 @@
+import { Token, ASTNode, BinaryOpNode, UnaryOpNode, LiteralNode, GroupNode, TokenType } from './ast.js';
+import { ErrorHandler } from '../errors/handler.js';
+
+// Operator precedence (higher number = higher precedence)
+const PRECEDENCE: Record<string, number> = {
+  '(': 10,
+  ')': 10,
+  '~': 9,
+  '*': 8,
+  '/': 8,
+  '%': 8,
+  '+': 7,
+  '-': 7,
+  '<<': 6,
+  '>>': 6,
+  '>>>': 6,
+  '&': 5,
+  '^': 4,
+  '|': 3,
+};
+
+export class Parser {
+  private pos = 0;
+  private tokens: Token[] = [];
+  private errorHandler = new ErrorHandler();
+
+  parse(tokens: Token[]): ASTNode {
+    this.tokens = tokens;
+    this.pos = 0;
+
+    if (this.tokens.length === 0 || (this.tokens.length === 1 && this.tokens[0].type === 'EOF')) {
+      throw new Error('Expression cannot be empty');
+    }
+
+    const ast = this.parseExpression();
+
+    if (this.current()?.type !== 'EOF') {
+      const token = this.current()!;
+      throw this.errorHandler.syntaxError(
+        `Unexpected token: ${token.value}`,
+        token.position.start,
+        token.position.end
+      );
+    }
+
+    return ast;
+  }
+
+  private parseExpression(minPrecedence = 0): ASTNode {
+    let left = this.parseUnary();
+
+    while (true) {
+      const op = this.current();
+      if (!op || op.type !== 'OPERATOR') {
+        break;
+      }
+
+      const precedence = PRECEDENCE[op.value] ?? 0;
+      if (precedence < minPrecedence) {
+        break;
+      }
+
+      this.advance();
+      const right = this.parseExpression(precedence + 1);
+
+      left = {
+        type: 'BinaryOp',
+        operator: op.value,
+        left,
+        right,
+        position: { start: left.position?.start ?? 0, end: right.position?.end ?? 0 },
+      } as BinaryOpNode;
+    }
+
+    return left;
+  }
+
+  private parseUnary(): ASTNode {
+    const token = this.current();
+
+    if (token && token.type === 'OPERATOR' && (token.value === '~' || token.value === '-')) {
+      this.advance();
+      const operand = this.parseUnary();
+
+      return {
+        type: 'UnaryOp',
+        operator: token.value,
+        operand,
+        position: { start: token.position.start, end: operand.position?.end ?? token.position.end },
+      } as UnaryOpNode;
+    }
+
+    return this.parsePrimary();
+  }
+
+  private parsePrimary(): ASTNode {
+    const token = this.current();
+
+    if (!token || token.type === 'EOF') {
+      throw new Error('Unexpected end of input');
+    }
+
+    // Parenthesized expression
+    if (token.type === 'LPAREN') {
+      this.advance();
+      const expr = this.parseExpression();
+
+      const closing = this.current();
+      if (!closing || closing.type !== 'RPAREN') {
+        throw this.errorHandler.syntaxError(
+          'Unmatched parenthesis: expected )',
+          token.position.start,
+          token.position.end
+        );
+      }
+      this.advance();
+
+      return {
+        type: 'Group',
+        expression: expr,
+        position: { start: token.position.start, end: closing.position.end },
+      } as GroupNode;
+    }
+
+    // Literal
+    if (this.isLiteral(token)) {
+      this.advance();
+      return {
+        type: 'Literal',
+        value: token.value,
+        tokenType: token.type,
+        position: token.position,
+      } as LiteralNode;
+    }
+
+    throw this.errorHandler.syntaxError(
+      `Unexpected token: ${token.value}`,
+      token.position.start,
+      token.position.end
+    );
+  }
+
+  private isLiteral(token: Token): boolean {
+    return ['NUMBER', 'HEX', 'BINARY', 'OCTAL', 'CHAR_LITERAL'].includes(token.type);
+  }
+
+  private current(): Token | undefined {
+    return this.tokens[this.pos];
+  }
+
+  private advance(): void {
+    this.pos++;
+  }
+}