@bcts/dcbor-pattern 1.0.0-alpha.11

package/src/parse/meta/search-parser.ts

@@ -0,0 +1,56 @@
+/**
+ * Search pattern parser.
+ *
+ * @module parse/meta/search-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { search } from "../../pattern";
+import { parseOr } from "./or-parser";
+
+/**
+ * Parse a search pattern `...(pattern)`.
+ */
+export const parseSearch = (lexer: Lexer): Result<Pattern> => {
+  // Expect opening parenthesis
+  const openResult = lexer.next();
+  if (openResult === undefined) {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+  if (!openResult.ok) {
+    return openResult;
+  }
+  if (openResult.value.token.type !== "ParenOpen") {
+    return Err({
+      type: "UnexpectedToken",
+      token: openResult.value.token,
+      span: openResult.value.span,
+    });
+  }
+
+  // Parse the inner pattern
+  const innerResult = parseOr(lexer);
+  if (!innerResult.ok) {
+    return innerResult;
+  }
+
+  // Expect closing parenthesis
+  const closeResult = lexer.next();
+  if (closeResult === undefined) {
+    return Err({ type: "ExpectedCloseParen", span: lexer.span() });
+  }
+  if (!closeResult.ok) {
+    return closeResult;
+  }
+  if (closeResult.value.token.type !== "ParenClose") {
+    return Err({
+      type: "ExpectedCloseParen",
+      span: closeResult.value.span,
+    });
+  }
+
+  return Ok(search(innerResult.value));
+};

package/src/parse/parse-registry.ts

@@ -0,0 +1,31 @@
+/**
+ * Parse registry for resolving circular dependencies between parsers.
+ *
+ * @module parse/parse-registry
+ */
+
+import type { Lexer } from "./token";
+import type { Pattern } from "../pattern";
+import type { Result } from "../error";
+
+/**
+ * The registered parseOr function.
+ */
+export let parseOrFn: ((lexer: Lexer) => Result<Pattern>) | undefined;
+
+/**
+ * Registers the parseOr function.
+ */
+export const setParseOrFn = (fn: (lexer: Lexer) => Result<Pattern>): void => {
+  parseOrFn = fn;
+};
+
+/**
+ * Calls the registered parseOr function.
+ */
+export const parseOrFromRegistry = (lexer: Lexer): Result<Pattern> => {
+  if (parseOrFn === undefined) {
+    throw new Error("ParseOr function not initialized. Import parse/index to initialize.");
+  }
+  return parseOrFn(lexer);
+};

package/src/parse/structure/array-parser.ts

@@ -0,0 +1,210 @@
+/**
+ * Array pattern parser.
+ *
+ * @module parse/structure/array-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { sequence, or, and, not } from "../../pattern";
+import {
+  arrayPatternWithLengthInterval,
+  arrayPatternWithElements,
+} from "../../pattern/structure/array-pattern";
+import { Interval } from "../../interval";
+import { parseOrFromRegistry } from "../parse-registry";
+
+/**
+ * Parse a bracket array pattern: [pattern] or [{n}] etc.
+ */
+export const parseBracketArray = (lexer: Lexer): Result<Pattern> => {
+  // Opening bracket was already consumed
+  const peeked = lexer.peekToken();
+
+  if (peeked === undefined) {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+
+  if (!peeked.ok) {
+    return peeked;
+  }
+
+  const token = peeked.value;
+
+  // Check for Range token (array length constraint like [{3}] or [{1,5}])
+  if (token.type === "Range") {
+    lexer.next(); // consume the Range token
+    const pattern = arrayPatternWithLengthInterval(token.quantifier.interval());
+
+    // Expect closing bracket
+    const closeResult = lexer.next();
+    if (closeResult === undefined) {
+      return Err({ type: "ExpectedCloseBracket", span: lexer.span() });
+    }
+    if (!closeResult.ok) {
+      return closeResult;
+    }
+    if (closeResult.value.token.type !== "BracketClose") {
+      return Err({
+        type: "ExpectedCloseBracket",
+        span: closeResult.value.span,
+      });
+    }
+
+    return Ok({
+      kind: "Structure",
+      pattern: { type: "Array", pattern },
+    });
+  }
+
+  // Check for closing bracket (empty array pattern [] - matches array with 0 elements)
+  if (token.type === "BracketClose") {
+    lexer.next(); // consume the closing bracket
+    return Ok({
+      kind: "Structure",
+      pattern: { type: "Array", pattern: arrayPatternWithLengthInterval(Interval.exactly(0)) },
+    });
+  }
+
+  // Parse as array with element pattern(s)
+  const elementPattern = parseArrayOr(lexer);
+  if (!elementPattern.ok) {
+    return elementPattern;
+  }
+
+  const pattern = arrayPatternWithElements(elementPattern.value);
+
+  // Expect closing bracket
+  const closeResult = lexer.next();
+  if (closeResult === undefined) {
+    return Err({ type: "ExpectedCloseBracket", span: lexer.span() });
+  }
+  if (!closeResult.ok) {
+    return closeResult;
+  }
+  if (closeResult.value.token.type !== "BracketClose") {
+    return Err({
+      type: "ExpectedCloseBracket",
+      span: closeResult.value.span,
+    });
+  }
+
+  return Ok({
+    kind: "Structure",
+    pattern: { type: "Array", pattern },
+  });
+};
+
+/**
+ * Parse OR patterns within array context.
+ */
+const parseArrayOr = (lexer: Lexer): Result<Pattern> => {
+  const patterns: Pattern[] = [];
+  const first = parseArrayAnd(lexer);
+  if (!first.ok) {
+    return first;
+  }
+  patterns.push(first.value);
+
+  while (true) {
+    const peeked = lexer.peekToken();
+    if (peeked === undefined || !peeked.ok || peeked.value.type !== "Or") {
+      break;
+    }
+    lexer.next(); // consume the OR token
+
+    const next = parseArrayAnd(lexer);
+    if (!next.ok) {
+      return next;
+    }
+    patterns.push(next.value);
+  }
+
+  if (patterns.length === 1) {
+    return Ok(patterns[0]);
+  }
+
+  return Ok(or(...patterns));
+};
+
+/**
+ * Parse AND patterns within array context.
+ */
+const parseArrayAnd = (lexer: Lexer): Result<Pattern> => {
+  const patterns: Pattern[] = [];
+  const first = parseArrayNot(lexer);
+  if (!first.ok) {
+    return first;
+  }
+  patterns.push(first.value);
+
+  while (true) {
+    const peeked = lexer.peekToken();
+    if (peeked === undefined || !peeked.ok || peeked.value.type !== "And") {
+      break;
+    }
+    lexer.next(); // consume the AND token
+
+    const next = parseArrayNot(lexer);
+    if (!next.ok) {
+      return next;
+    }
+    patterns.push(next.value);
+  }
+
+  if (patterns.length === 1) {
+    return Ok(patterns[0]);
+  }
+
+  return Ok(and(...patterns));
+};
+
+/**
+ * Parse NOT patterns within array context.
+ */
+const parseArrayNot = (lexer: Lexer): Result<Pattern> => {
+  const peeked = lexer.peekToken();
+  if (peeked !== undefined && peeked.ok && peeked.value.type === "Not") {
+    lexer.next(); // consume the NOT token
+    const inner = parseArrayNot(lexer); // right associative
+    if (!inner.ok) {
+      return inner;
+    }
+    return Ok(not(inner.value));
+  }
+  return parseArraySequence(lexer);
+};
+
+/**
+ * Parse sequence patterns within array context (comma-separated).
+ */
+const parseArraySequence = (lexer: Lexer): Result<Pattern> => {
+  const patterns: Pattern[] = [];
+  const first = parseOrFromRegistry(lexer);
+  if (!first.ok) {
+    return first;
+  }
+  patterns.push(first.value);
+
+  while (true) {
+    const peeked = lexer.peekToken();
+    if (peeked === undefined || !peeked.ok || peeked.value.type !== "Comma") {
+      break;
+    }
+    lexer.next(); // consume the comma
+
+    const next = parseOrFromRegistry(lexer);
+    if (!next.ok) {
+      return next;
+    }
+    patterns.push(next.value);
+  }
+
+  if (patterns.length === 1) {
+    return Ok(patterns[0]);
+  }
+
+  return Ok(sequence(...patterns));
+};

package/src/parse/structure/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Structure parsers for dCBOR patterns.
+ *
+ * @module parse/structure
+ */
+
+export * from "./array-parser";
+export * from "./map-parser";
+export * from "./tagged-parser";

package/src/parse/structure/map-parser.ts

@@ -0,0 +1,128 @@
+/**
+ * Map pattern parser.
+ *
+ * @module parse/structure/map-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { anyMap } from "../../pattern";
+import {
+  mapPatternWithLengthInterval,
+  mapPatternWithConstraints,
+} from "../../pattern/structure/map-pattern";
+import { parseOrFromRegistry } from "../parse-registry";
+
+/**
+ * Parse a bracket map pattern: {pattern: pattern} or {{n}} etc.
+ */
+export const parseBracketMap = (lexer: Lexer): Result<Pattern> => {
+  // Opening brace was already consumed
+  const peeked = lexer.peekToken();
+
+  if (peeked === undefined) {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+
+  if (!peeked.ok) {
+    return peeked;
+  }
+
+  const token = peeked.value;
+
+  // Check for closing brace (empty map - which means "any map")
+  if (token.type === "BraceClose") {
+    lexer.next(); // consume the closing brace
+    return Ok(anyMap());
+  }
+
+  // Check for Range token (map length constraint)
+  if (token.type === "Range") {
+    lexer.next(); // consume the Range token
+    const pattern = mapPatternWithLengthInterval(token.quantifier.interval());
+
+    // Expect closing brace
+    const closeResult = lexer.next();
+    if (closeResult === undefined) {
+      return Err({ type: "ExpectedCloseBrace", span: lexer.span() });
+    }
+    if (!closeResult.ok) {
+      return closeResult;
+    }
+    if (closeResult.value.token.type !== "BraceClose") {
+      return Err({
+        type: "ExpectedCloseBrace",
+        span: closeResult.value.span,
+      });
+    }
+
+    return Ok({
+      kind: "Structure",
+      pattern: { type: "Map", pattern },
+    });
+  }
+
+  // Parse as map with key-value constraints
+  const constraints: [Pattern, Pattern][] = [];
+
+  while (true) {
+    // Parse key pattern
+    const keyResult = parseOrFromRegistry(lexer);
+    if (!keyResult.ok) {
+      return keyResult;
+    }
+
+    // Expect colon
+    const colonResult = lexer.next();
+    if (colonResult === undefined) {
+      return Err({ type: "ExpectedColon", span: lexer.span() });
+    }
+    if (!colonResult.ok) {
+      return colonResult;
+    }
+    if (colonResult.value.token.type !== "Colon") {
+      return Err({
+        type: "ExpectedColon",
+        span: colonResult.value.span,
+      });
+    }
+
+    // Parse value pattern
+    const valueResult = parseOrFromRegistry(lexer);
+    if (!valueResult.ok) {
+      return valueResult;
+    }
+
+    constraints.push([keyResult.value, valueResult.value]);
+
+    // Check for comma or closing brace
+    const nextToken = lexer.peekToken();
+    if (nextToken?.ok !== true) {
+      return Err({ type: "UnexpectedEndOfInput" });
+    }
+
+    if (nextToken.value.type === "BraceClose") {
+      lexer.next(); // consume the closing brace
+      break;
+    }
+
+    if (nextToken.value.type === "Comma") {
+      lexer.next(); // consume the comma
+      continue;
+    }
+
+    return Err({
+      type: "UnexpectedToken",
+      token: nextToken.value,
+      span: lexer.span(),
+    });
+  }
+
+  // Create map pattern with constraints
+  return Ok({
+    kind: "Structure",
+    pattern: { type: "Map", pattern: mapPatternWithConstraints(constraints) },
+  });
+};

package/src/parse/structure/tagged-parser.ts

@@ -0,0 +1,269 @@
+/**
+ * Tagged pattern parser.
+ *
+ * Supports the following syntax:
+ * - `tagged` - matches any tagged value
+ * - `tagged(value, pattern)` - matches tagged value with specific u64 tag and content pattern
+ * - `tagged(name, pattern)` - matches tagged value with named tag and content pattern
+ * - `tagged(/regex/, pattern)` - matches tagged value with tag name matching regex and content pattern
+ *
+ * @module parse/structure/tagged-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { anyTagged } from "../../pattern";
+import { createTag } from "@bcts/dcbor";
+import {
+  taggedPatternWithTag,
+  taggedPatternWithName,
+  taggedPatternWithRegex,
+} from "../../pattern/structure/tagged-pattern";
+import { parse } from "../index";
+
+/**
+ * Tag selector discriminated union.
+ */
+type TagSelector =
+  | { type: "Value"; value: number }
+  | { type: "Name"; name: string }
+  | { type: "Regex"; regex: RegExp };
+
+/**
+ * Parse a tagged pattern from the `tagged` keyword.
+ *
+ * Supports:
+ * - `tagged` - matches any tagged value
+ * - `tagged(value, pattern)` - matches tagged value with specific tag number
+ * - `tagged(name, pattern)` - matches tagged value with named tag
+ * - `tagged(/regex/, pattern)` - matches tagged value with tag name matching regex
+ */
+export const parseTagged = (lexer: Lexer): Result<Pattern> => {
+  // Check if followed by opening parenthesis
+  const peeked = lexer.peekToken();
+
+  if (peeked === undefined || !peeked.ok || peeked.value.type !== "ParenOpen") {
+    // No parentheses, just "tagged" - matches any tagged value
+    return Ok(anyTagged());
+  }
+
+  // Consume the opening parenthesis
+  lexer.next();
+
+  // Get the remainder of the input for manual parsing
+  const remainder = lexer.remainder();
+  const remainderStart = lexer.position();
+
+  // Parse the tag selector and content pattern
+  const innerResult = parseTaggedInner(remainder, remainderStart);
+  if (!innerResult.ok) {
+    return innerResult;
+  }
+
+  const [tagSelector, contentPattern, consumed] = innerResult.value;
+
+  // Advance the lexer by the consumed amount
+  lexer.bump(consumed);
+
+  // Expect closing parenthesis
+  const closeResult = lexer.next();
+  if (closeResult === undefined) {
+    return Err({ type: "ExpectedCloseParen", span: lexer.span() });
+  }
+  if (!closeResult.ok) {
+    return closeResult;
+  }
+  if (closeResult.value.token.type !== "ParenClose") {
+    return Err({
+      type: "ExpectedCloseParen",
+      span: closeResult.value.span,
+    });
+  }
+
+  // Create the pattern based on tag selector type
+  let taggedPattern;
+  switch (tagSelector.type) {
+    case "Value": {
+      const tag = createTag(BigInt(tagSelector.value));
+      taggedPattern = taggedPatternWithTag(tag, contentPattern);
+      break;
+    }
+    case "Name":
+      taggedPattern = taggedPatternWithName(tagSelector.name, contentPattern);
+      break;
+    case "Regex":
+      taggedPattern = taggedPatternWithRegex(tagSelector.regex, contentPattern);
+      break;
+  }
+
+  return Ok({
+    kind: "Structure",
+    pattern: { type: "Tagged", pattern: taggedPattern },
+  });
+};
+
+/**
+ * Parse the inner content of tagged(selector, pattern).
+ * Returns [TagSelector, Pattern, consumed_bytes].
+ */
+const parseTaggedInner = (
+  src: string,
+  remainderStart: number,
+): Result<[TagSelector, Pattern, number]> => {
+  let pos = 0;
+  skipWhitespace(src, (p) => (pos = p), pos);
+
+  // Parse the tag selector (first parameter)
+  let tagSelector: TagSelector;
+
+  if (src[pos] === "/") {
+    // Regex pattern
+    const regexResult = parseTextRegex(src, pos);
+    if (!regexResult.ok) {
+      return regexResult;
+    }
+    const [regex, newPos] = regexResult.value;
+    pos = newPos;
+    tagSelector = { type: "Regex", regex };
+  } else {
+    // Could be a number or a name
+    const wordResult = parseBareWord(src, pos);
+    if (!wordResult.ok) {
+      return wordResult;
+    }
+    const [word, newPos] = wordResult.value;
+    pos = newPos;
+
+    const numValue = parseInt(word, 10);
+    if (!isNaN(numValue) && numValue.toString() === word) {
+      tagSelector = { type: "Value", value: numValue };
+    } else {
+      tagSelector = { type: "Name", name: word };
+    }
+  }
+
+  // Expect comma
+  skipWhitespace(src, (p) => (pos = p), pos);
+  if (pos >= src.length || src[pos] !== ",") {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+  pos += 1;
+  skipWhitespace(src, (p) => (pos = p), pos);
+
+  // Parse the content pattern (second parameter)
+  // Handle nested parentheses to find the end of the pattern
+  const patternStart = pos;
+  let parenDepth = 0;
+  while (pos < src.length) {
+    const ch = src[pos];
+    if (ch === "(") {
+      parenDepth += 1;
+    } else if (ch === ")") {
+      if (parenDepth === 0) {
+        break; // This is the closing paren for our tagged()
+      }
+      parenDepth -= 1;
+    }
+    pos += 1;
+  }
+
+  const patternSrc = src.slice(patternStart, pos);
+  const trimmedPattern = patternSrc.trim();
+  const trimOffset = patternSrc.length - patternSrc.trimStart().length;
+
+  const contentResult = parse(trimmedPattern);
+  if (!contentResult.ok) {
+    // Adjust error spans to be relative to the original input
+    const error = contentResult.error;
+    if ("span" in error) {
+      const offset = remainderStart + patternStart + trimOffset;
+      const adjustedSpan = {
+        start: error.span.start + offset,
+        end: error.span.end + offset,
+      };
+      // Create a new error with the adjusted span
+      return Err({ ...error, span: adjustedSpan } as typeof error);
+    }
+    return contentResult;
+  }
+
+  return Ok([tagSelector, contentResult.value, pos]);
+};
+
+/**
+ * Parse a regex from the input string starting with /
+ */
+const parseTextRegex = (src: string, startPos: number): Result<[RegExp, number]> => {
+  let pos = startPos;
+  skipWhitespace(src, (p) => (pos = p), pos);
+
+  if (pos >= src.length || src[pos] !== "/") {
+    return Err({ type: "UnterminatedRegex", span: { start: pos, end: pos } });
+  }
+  pos += 1;
+  const start = pos;
+  let escape = false;
+
+  while (pos < src.length) {
+    const ch = src[pos];
+    pos += 1;
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escape = true;
+      continue;
+    }
+    if (ch === "/") {
+      const inner = src.slice(start, pos - 1);
+      try {
+        const regex = new RegExp(inner);
+        skipWhitespace(src, (p) => (pos = p), pos);
+        return Ok([regex, pos]);
+      } catch {
+        return Err({ type: "InvalidRegex", span: { start, end: pos } });
+      }
+    }
+  }
+
+  return Err({ type: "UnterminatedRegex", span: { start: pos, end: pos } });
+};
+
+/**
+ * Parse a bare word (alphanumeric with hyphens and underscores).
+ */
+const parseBareWord = (src: string, startPos: number): Result<[string, number]> => {
+  let pos = startPos;
+  skipWhitespace(src, (p) => (pos = p), pos);
+
+  const start = pos;
+  while (pos < src.length) {
+    const ch = src[pos];
+    if (" \t\n\r\f,)".includes(ch)) {
+      break;
+    }
+    pos += 1;
+  }
+
+  if (start === pos) {
+    return Err({ type: "UnexpectedEndOfInput" });
+  }
+
+  const word = src.slice(start, pos);
+  skipWhitespace(src, (p) => (pos = p), pos);
+
+  return Ok([word, pos]);
+};
+
+/**
+ * Skip whitespace characters.
+ */
+const skipWhitespace = (src: string, setPos: (p: number) => void, pos: number): void => {
+  while (pos < src.length && " \t\n\r\f".includes(src[pos])) {
+    pos += 1;
+  }
+  setPos(pos);
+};