@razdolbai/merls 0.1.0

package/src/asm/expression.ts

@@ -0,0 +1,242 @@
+import { type Token } from "./lexer";
+
+export type NumericLiteralExpression = {
+  kind: "numericLiteral";
+  value: string;
+};
+
+export type IdentifierExpression = {
+  kind: "identifier";
+  value: string;
+};
+
+export type StringExpression = {
+  kind: "string";
+  value: string;
+};
+
+export type ModifierExpression = {
+  kind: "modifier";
+  operator: "<" | ">" | "^";
+  expression: Expression;
+};
+
+export type BinaryExpression = {
+  kind: "binary";
+  operator: "+" | "-" | "*" | "/";
+  left: Expression;
+  right: Expression;
+};
+
+export type Expression =
+  | NumericLiteralExpression
+  | IdentifierExpression
+  | StringExpression
+  | ModifierExpression
+  | BinaryExpression;
+
+export type ParsedExpression = {
+  expression: Expression;
+  nextTokenIndex: number;
+};
+
+export type ParsedOperand = {
+  operand: Operand;
+  nextTokenIndex: number;
+};
+
+export type Operand = {
+  immediate: boolean;
+  indirect: boolean;
+  indexRegister: "x" | "y" | null;
+  expression: Expression;
+};
+
+const binaryPrecedence = new Map<string, number>([
+  ["+", 10],
+  ["-", 10],
+  ["*", 20],
+  ["/", 20]
+]);
+
+export function parseExpression(
+  tokens: readonly Token[],
+  startIndex = 0,
+  minimumPrecedence = 0
+): ParsedExpression {
+  let { expression: left, nextTokenIndex } = parsePrefix(tokens, startIndex);
+
+  while (nextTokenIndex < tokens.length) {
+    const operatorToken = tokens[nextTokenIndex];
+    if (operatorToken?.kind !== "expressionOperator") {
+      break;
+    }
+
+    const precedence = binaryPrecedence.get(operatorToken.lexeme);
+    if (precedence === undefined || precedence < minimumPrecedence) {
+      break;
+    }
+
+    const parsedRight = parseExpression(tokens, nextTokenIndex + 1, precedence + 1);
+    left = {
+      kind: "binary",
+      operator: operatorToken.lexeme as BinaryExpression["operator"],
+      left,
+      right: parsedRight.expression
+    };
+    nextTokenIndex = parsedRight.nextTokenIndex;
+  }
+
+  return {
+    expression: left,
+    nextTokenIndex
+  };
+}
+
+export function parseOperand(tokens: readonly Token[], startIndex = 0): ParsedOperand {
+  let index = startIndex;
+  let immediate = false;
+  let indirect = false;
+  let indexRegister: Operand["indexRegister"] = null;
+
+  if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === "#") {
+    immediate = true;
+    index += 1;
+  }
+
+  if (tokens[index]?.kind === "numericLiteral" && tokens[index]?.lexeme.startsWith("#")) {
+    immediate = true;
+    const token = tokens[index];
+    const expression: NumericLiteralExpression = {
+      kind: "numericLiteral",
+      value: token.lexeme.slice(1)
+    };
+    return {
+      operand: {
+        immediate,
+        indirect,
+        indexRegister,
+        expression
+      },
+      nextTokenIndex: index + 1
+    };
+  }
+
+  let parsedExpression: ParsedExpression;
+
+  if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === "(") {
+    indirect = true;
+    parsedExpression = parseExpression(tokens, index + 1);
+    index = parsedExpression.nextTokenIndex;
+
+    if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === ",") {
+      indexRegister = parseIndexRegister(tokens[index + 1]);
+      index += 2;
+    }
+
+    expectOperator(tokens[index], ")");
+    index += 1;
+
+    if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === ",") {
+      indexRegister = parseIndexRegister(tokens[index + 1]);
+      index += 2;
+    }
+  } else {
+    parsedExpression = parseExpression(tokens, index);
+    index = parsedExpression.nextTokenIndex;
+
+    if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === ",") {
+      indexRegister = parseIndexRegister(tokens[index + 1]);
+      index += 2;
+    }
+  }
+
+  return {
+    operand: {
+      immediate,
+      indirect,
+      indexRegister,
+      expression: parsedExpression.expression
+    },
+    nextTokenIndex: index
+  };
+}
+
+function parsePrefix(tokens: readonly Token[], startIndex: number): ParsedExpression {
+  const token = tokens[startIndex];
+  if (token === undefined) {
+    throw new Error("expected expression token");
+  }
+
+  if (token.kind === "numericLiteral") {
+    return {
+      expression: {
+        kind: "numericLiteral",
+        value: token.lexeme
+      },
+      nextTokenIndex: startIndex + 1
+    };
+  }
+
+  if (token.kind === "identifier" || token.kind === "label" || token.kind === "localLabel") {
+    return {
+      expression: {
+        kind: "identifier",
+        value: token.lexeme
+      },
+      nextTokenIndex: startIndex + 1
+    };
+  }
+
+  if (token.kind === "string") {
+    return {
+      expression: {
+        kind: "string",
+        value: token.lexeme.slice(1, -1)
+      },
+      nextTokenIndex: startIndex + 1
+    };
+  }
+
+  if (token.kind === "modifier") {
+    const parsedInner = parsePrefix(tokens, startIndex + 1);
+    return {
+      expression: {
+        kind: "modifier",
+        operator: token.lexeme as ModifierExpression["operator"],
+        expression: parsedInner.expression
+      },
+      nextTokenIndex: parsedInner.nextTokenIndex
+    };
+  }
+
+  if (token.kind === "expressionOperator" && token.lexeme === "(") {
+    const parsedInner = parseExpression(tokens, startIndex + 1);
+    expectOperator(tokens[parsedInner.nextTokenIndex], ")");
+    return {
+      expression: parsedInner.expression,
+      nextTokenIndex: parsedInner.nextTokenIndex + 1
+    };
+  }
+
+  if (token.kind === "expressionOperator" && token.lexeme === "#") {
+    return parsePrefix(tokens, startIndex + 1);
+  }
+
+  throw new Error(`unexpected expression token: ${token.lexeme}`);
+}
+
+function expectOperator(token: Token | undefined, lexeme: string): void {
+  if (token?.kind !== "expressionOperator" || token.lexeme !== lexeme) {
+    throw new Error(`expected operator ${lexeme}`);
+  }
+}
+
+function parseIndexRegister(token: Token | undefined): Operand["indexRegister"] {
+  const normalized = token?.lexeme.toLowerCase();
+  if (token?.kind === "identifier" && (normalized === "x" || normalized === "y")) {
+    return normalized;
+  }
+
+  throw new Error("expected index register");
+}

package/src/asm/lexer.ts

@@ -0,0 +1,197 @@
+import { directiveTable, opcodeTable } from "./metadata";
+
+export type TokenKind =
+  | "comment"
+  | "label"
+  | "localLabel"
+  | "directive"
+  | "mnemonic"
+  | "string"
+  | "numericLiteral"
+  | "modifier"
+  | "expressionOperator"
+  | "identifier";
+
+export type Token = {
+  kind: TokenKind;
+  lexeme: string;
+  start: number;
+  end: number;
+};
+
+export type LexedLine = {
+  line: number;
+  text: string;
+  tokens: readonly Token[];
+};
+
+export type LexedSource = {
+  lines: readonly LexedLine[];
+};
+
+const operatorCharacters = new Set(["(", ")", ",", "#", "+", "-", "*", "/", "=", "<", ">", "^"]);
+
+export function lexSource(source: string): LexedSource {
+  const lines = source.split(/\r?\n/).map((text, index) => lexLine(text, index));
+  return { lines };
+}
+
+function lexLine(text: string, line: number): LexedLine {
+  const tokens: Token[] = [];
+  const firstNonWhitespace = text.search(/\S/);
+
+  if (firstNonWhitespace === -1) {
+    return { line, text, tokens };
+  }
+
+  const trimmed = text.slice(firstNonWhitespace);
+  if (trimmed.startsWith(";") || (firstNonWhitespace === 0 && trimmed.startsWith("*"))) {
+    tokens.push(createToken("comment", text.slice(firstNonWhitespace), firstNonWhitespace, text.length));
+    return { line, text, tokens };
+  }
+
+  let index = firstNonWhitespace;
+  let sawOperation = false;
+
+  while (index < text.length) {
+    const char = text[index];
+
+    if (char === " " || char === "\t") {
+      index += 1;
+      continue;
+    }
+
+    if (char === ";") {
+      tokens.push(createToken("comment", text.slice(index), index, text.length));
+      break;
+    }
+
+    if (char === '"' || char === "'") {
+      const end = consumeString(text, index);
+      tokens.push(createToken("string", text.slice(index, end), index, end));
+      index = end;
+      continue;
+    }
+
+    if (operatorCharacters.has(char)) {
+      const numericLiteral = consumeNumericLiteral(text, index);
+      if (numericLiteral !== null) {
+        tokens.push(createToken("numericLiteral", numericLiteral.lexeme, index, numericLiteral.end));
+        index = numericLiteral.end;
+        continue;
+      }
+
+      const operatorKind: TokenKind =
+        char === "<" || char === ">" || char === "^"
+          ? "modifier"
+          : "expressionOperator";
+      tokens.push(createToken(operatorKind, char, index, index + 1));
+      index += 1;
+      continue;
+    }
+
+    const end = consumeWord(text, index);
+    const lexeme = text.slice(index, end);
+    const kind = classifyWord(
+      text,
+      lexeme,
+      index,
+      end,
+      tokens.length === 0,
+      sawOperation,
+      firstNonWhitespace
+    );
+    tokens.push(createToken(kind, lexeme, index, end));
+    sawOperation ||= kind === "directive" || kind === "mnemonic";
+    index = end;
+  }
+
+  return { line, text, tokens };
+}
+
+function createToken(kind: TokenKind, lexeme: string, start: number, end: number): Token {
+  return {
+    kind,
+    lexeme,
+    start,
+    end
+  };
+}
+
+function consumeString(text: string, start: number): number {
+  const quote = text[start];
+  let index = start + 1;
+
+  while (index < text.length) {
+    if (text[index] === quote) {
+      return index + 1;
+    }
+    index += 1;
+  }
+
+  return text.length;
+}
+
+function consumeNumericLiteral(text: string, start: number): { lexeme: string; end: number } | null {
+  const prefixed = text.slice(start).match(/^#?(?:\$[0-9A-Fa-f]+|%[01]+|\d+)/);
+  if (prefixed !== null) {
+    return {
+      lexeme: prefixed[0],
+      end: start + prefixed[0].length
+    };
+  }
+
+  return null;
+}
+
+function consumeWord(text: string, start: number): number {
+  let index = start;
+
+  while (index < text.length) {
+    const char = text[index];
+    if (char === " " || char === "\t" || char === ";" || operatorCharacters.has(char)) {
+      break;
+    }
+    index += 1;
+  }
+
+  return index;
+}
+
+function classifyWord(
+  text: string,
+  lexeme: string,
+  start: number,
+  end: number,
+  isFirstToken: boolean,
+  sawOperation: boolean,
+  firstNonWhitespace: number
+): TokenKind {
+  const normalized = lexeme.toLowerCase();
+
+  if (opcodeTable.has(normalized)) {
+    return "mnemonic";
+  }
+
+  if (directiveTable.has(normalized)) {
+    return "directive";
+  }
+
+  if (lexeme.startsWith("]") || lexeme.startsWith(":")) {
+    return "localLabel";
+  }
+
+  if (/^(?:\$[0-9A-Fa-f]+|%[01]+|\d+)$/.test(lexeme)) {
+    return "numericLiteral";
+  }
+
+  const trailingText = text.slice(end);
+  const looksLikeLabelBoundary =
+    trailingText.length === 0 || /^[\t ]/.test(trailingText);
+
+  if (isFirstToken && !sawOperation && firstNonWhitespace === 0 && looksLikeLabelBoundary) {
+    return "label";
+  }
+
+  return "identifier";
+}

package/src/asm/local-labels.ts

@@ -0,0 +1,204 @@
+import { type ParsedDocument } from "./document";
+import { type Expression, type Operand } from "./expression";
+import { type ParsedLine } from "./parser";
+
+export type LocalLabelDefinition = {
+  name: string;
+  line: number;
+  anchor: string;
+  qualifiedName: string;
+};
+
+export type LocalLabelReference = {
+  name: string;
+  line: number;
+  anchor: string;
+  qualifiedName: string;
+  targetLine: number;
+};
+
+export type LocalLabelScope = {
+  definitions: Map<string, LocalLabelDefinition>;
+  references: Map<string, LocalLabelReference>;
+};
+
+type AnchorState = {
+  name: string;
+  line: number;
+};
+
+export function resolveLocalLabels(document: ParsedDocument): LocalLabelScope {
+  const definitions = new Map<string, LocalLabelDefinition>();
+  const references = new Map<string, LocalLabelReference>();
+  const definitionsByAnchor = new Map<string, Map<string, LocalLabelDefinition>>();
+
+  let currentAnchor: AnchorState | null = null;
+
+  for (const line of document.lines) {
+    currentAnchor = updateAnchor(currentAnchor, line.node, line.line);
+
+    const localDefinition = getLocalDefinition(line.node);
+    if (currentAnchor === null || localDefinition === null) {
+      continue;
+    }
+
+    const qualifiedName = qualifyName(localDefinition, currentAnchor.line);
+    const definition: LocalLabelDefinition = {
+      name: localDefinition,
+      line: line.line,
+      anchor: currentAnchor.name,
+      qualifiedName
+    };
+
+    definitions.set(qualifiedName, definition);
+
+    let anchorDefinitions = definitionsByAnchor.get(currentAnchor.name);
+    if (anchorDefinitions === undefined) {
+      anchorDefinitions = new Map();
+      definitionsByAnchor.set(currentAnchor.name, anchorDefinitions);
+    }
+    anchorDefinitions.set(localDefinition, definition);
+  }
+
+  currentAnchor = null;
+
+  for (const line of document.lines) {
+    currentAnchor = updateAnchor(currentAnchor, line.node, line.line);
+    if (currentAnchor === null) {
+      continue;
+    }
+
+    const anchorDefinitions = definitionsByAnchor.get(currentAnchor.name);
+    if (anchorDefinitions === undefined) {
+      continue;
+    }
+
+    for (const localName of findLocalReferences(line.node)) {
+      const target = anchorDefinitions.get(localName);
+      if (target === undefined) {
+        continue;
+      }
+
+      references.set(qualifyName(localName, line.line), {
+        name: localName,
+        line: line.line,
+        anchor: currentAnchor.name,
+        qualifiedName: target.qualifiedName,
+        targetLine: target.line
+      });
+    }
+  }
+
+  return {
+    definitions,
+    references
+  };
+}
+
+function updateAnchor(
+  currentAnchor: AnchorState | null,
+  node: ParsedLine,
+  line: number
+): AnchorState | null {
+  const label = getGlobalLabel(node);
+  if (label === null) {
+    return currentAnchor;
+  }
+
+  return {
+    name: label,
+    line
+  };
+}
+
+function getGlobalLabel(node: ParsedLine): string | null {
+  if (node.shape === "equate" && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "labelOnly" && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "instruction" && node.label !== null && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "directive" && node.label !== null && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "data" && node.label !== null && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  return null;
+}
+
+function getLocalDefinition(node: ParsedLine): string | null {
+  if (node.shape === "labelOnly" && isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "instruction" && node.label !== null && isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "directive" && node.label !== null && isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "data" && node.label !== null && isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "equate" && isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  return null;
+}
+
+function findLocalReferences(node: ParsedLine): readonly string[] {
+  if (node.shape === "instruction" && node.operand !== null) {
+    return findLocalNamesInOperand(node.operand);
+  }
+
+  if (node.shape === "directive" && node.operand !== null) {
+    return findLocalNamesInExpression(node.operand);
+  }
+
+  if (node.shape === "equate") {
+    return findLocalNamesInExpression(node.expression);
+  }
+
+  return [];
+}
+
+function findLocalNamesInOperand(operand: Operand): readonly string[] {
+  return findLocalNamesInExpression(operand.expression);
+}
+
+function findLocalNamesInExpression(expression: Expression): readonly string[] {
+  switch (expression.kind) {
+    case "identifier":
+      return isLocalLabel(expression.value) ? [expression.value] : [];
+    case "modifier":
+      return findLocalNamesInExpression(expression.expression);
+    case "binary":
+      return [
+        ...findLocalNamesInExpression(expression.left),
+        ...findLocalNamesInExpression(expression.right)
+      ];
+    default:
+      return [];
+  }
+}
+
+function isLocalLabel(name: string): boolean {
+  return name.startsWith("]") || name.startsWith(":");
+}
+
+function qualifyName(name: string, line: number): string {
+  return `${name}@${line}`;
+}