@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/build/node/build-multiple-character-literal.ts

@@ -0,0 +1,65 @@
+import { NumberLiteral } from "../../node/number-literal.ts";
+import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchOneToManyList } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { isToken } from "../../util/types.ts";
+
+const ESCAPED_BACKSLASH_REGEX = /\\\\/g;
+const ESCAPED_SINGLE_QUOTE_REGEX = /\\'/g;
+const MAXIMUM_MULTIPLE_CHARACTER_LITERAL_LENGTH = 10;
+
+function parseUnsignedIntFromMultipleCharacterLiteral(literal: string): number {
+  if (literal.length > MAXIMUM_MULTIPLE_CHARACTER_LITERAL_LENGTH) {
+    throw new InternalScannerError(
+      `Multiple character number literal exceeds maximum length of ${MAXIMUM_MULTIPLE_CHARACTER_LITERAL_LENGTH}: ${literal}`,
+    );
+  }
+
+  let value = 0;
+  for (let i = 0; i < literal.length; i++) {
+    const charCode = literal.charCodeAt(i);
+    if (charCode < 0x20 || charCode > 0x7E) {
+      throw new InternalScannerError(
+        `Invalid character ${
+          literal.charCodeAt(i)
+        } in multiple character number literal: ${literal}`,
+      );
+    }
+
+    value = (value << 8) + charCode;
+  }
+
+  return value;
+}
+
+export function buildMultipleCharacterLiteral(
+  buildContext: BuildContext,
+): NumberLiteral {
+  const literals = fetchOneToManyList<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    [TokenKind.SINGLE_QUOTE, TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS],
+  );
+
+  const literalText = literals
+    .filter((token) =>
+      isToken(token) &&
+      (token.tokenKind === TokenKind.MULTIPLE_CHARACTER_LITERAL_CHARACTERS)
+    )
+    .map((token) =>
+      (token as Token).text.replaceAll(ESCAPED_SINGLE_QUOTE_REGEX, "'")
+        .replaceAll(ESCAPED_BACKSLASH_REGEX, "\\")
+    ).join("");
+
+  const value = parseUnsignedIntFromMultipleCharacterLiteral(literalText);
+
+  return new NumberLiteral(
+    NumberLiteralKind.MULTIPLE_CHARACTER,
+    value,
+    literals,
+  );
+}

package/src/ast/build/node/build-parameter-list.ts

@@ -0,0 +1,50 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ParameterList } from "../../node/parameter-list.ts";
+import type { Parameter } from "../../node/parameter.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { Token } from "../../node/token.ts";
+import {
+  fetchOneToManyCommaSeparatedList,
+  fetchRequiredNode,
+} from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildParameterList(
+  buildContext: BuildContext,
+): ParameterList {
+  const children: Array<AbstractNode> = [];
+
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+
+  const { nodes: parameters, commaPunctuators } =
+    fetchOneToManyCommaSeparatedList<
+      Parameter
+    >(buildContext, NodeKind.PARAMETER);
+
+  // now push each output value and comma punctuator to children
+  for (let i = 0; i < parameters.length; i++) {
+    children.push(parameters[i]);
+    if (i < commaPunctuators.length) {
+      children.push(commaPunctuators[i]);
+    }
+  }
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+  return new ParameterList(
+    openParenthesisPunctuator,
+    parameters,
+    commaPunctuators,
+    closeParenthesisPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-parameter-value-list.ts

@@ -0,0 +1,54 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ParameterValueList } from "../../node/parameter-value-list.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { Token } from "../../node/token.ts";
+import {
+  fetchOneToManyCommaSeparatedList,
+  fetchRequiredNode,
+} from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildParameterValueList(
+  buildContext: BuildContext,
+): ParameterValueList {
+  const children: Array<AbstractNode> = [];
+
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+
+  const { nodes: values, commaPunctuators } = fetchOneToManyCommaSeparatedList<
+    AbstractExpression
+  >(buildContext, [
+    NodeKind.EXPRESSION,
+    NodeKind.IDENTIFIER,
+    NodeKind.NUMBER_LITERAL,
+  ]);
+
+  // now push each output value and comma punctuator to children
+  for (let i = 0; i < values.length; i++) {
+    children.push(values[i]);
+    if (i < commaPunctuators.length) {
+      children.push(commaPunctuators[i]);
+    }
+  }
+
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+  return new ParameterValueList(
+    openParenthesisPunctuator,
+    values,
+    commaPunctuators,
+    closeParenthesisPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-parameter.ts

@@ -0,0 +1,47 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { ElementaryType } from "../../node/elementary-type.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { Parameter } from "../../node/parameter.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+
+export function buildParameter(
+  buildContext: BuildContext,
+): Parameter {
+  const children: Array<AbstractNode> = [];
+
+  const classIdentifier = fetchOptionalNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  let elementaryType: OptionalNode<ElementaryType> = undefined;
+  if (classIdentifier) {
+    children.push(classIdentifier);
+  } else {
+    elementaryType = fetchOptionalNode<ElementaryType>(
+      buildContext,
+      NodeKind.ELEMENTARY_TYPE,
+    );
+    if (elementaryType) {
+      children.push(elementaryType);
+    } else {
+      throw new InternalScannerError(
+        "Parameter must have either a class identifier or an elementary type.",
+      );
+    }
+  }
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+  return new Parameter(
+    classIdentifier,
+    elementaryType,
+    identifier,
+    children,
+  );
+}

package/src/ast/build/node/build-partial-array-dimension.ts

@@ -0,0 +1,55 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import { PartialArrayDimension } from "../../node/partial-array-dimension.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildPartialArrayDimension(
+  buildContext: BuildContext,
+): PartialArrayDimension {
+  const openBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACKET,
+  );
+  const innerOpenBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACKET,
+  );
+  const index = fetchRequiredNode<
+    AbstractExpression | Identifier | NumberLiteral
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  const innerCloseBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACKET,
+  );
+  const closeBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACKET,
+  );
+
+  return new PartialArrayDimension(
+    openBracketPunctuator,
+    innerOpenBracketPunctuator,
+    index,
+    innerCloseBracketPunctuator,
+    closeBracketPunctuator,
+    [
+      openBracketPunctuator,
+      innerOpenBracketPunctuator,
+      index,
+      innerCloseBracketPunctuator,
+      closeBracketPunctuator,
+    ],
+  );
+}

package/src/ast/build/node/build-specification.ts

@@ -0,0 +1,24 @@
+import { Specification } from "../../node/specification.ts";
+import type { ComputedElementaryTypeDefinition } from "../../node/computed-elementary-type-definition.ts";
+import type { MapDeclaration } from "../../node/map-declaration.ts";
+import type { ClassDeclaration } from "../../node/class-declaration.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { fetchZeroToManyList } from "../util/fetch-node.ts";
+import { StatementKind } from "../../node/enum/statement-kind.ts";
+import { NodeKind } from "../../../../index.ts";
+
+export function buildSpecification(
+  buildContext: BuildContext,
+): Specification {
+  const globals = fetchZeroToManyList<
+    | ComputedElementaryTypeDefinition
+    | MapDeclaration
+    | ClassDeclaration
+  >(buildContext, NodeKind.STATEMENT, [
+    StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION,
+    StatementKind.MAP_DECLARATION,
+    StatementKind.CLASS_DECLARATION,
+  ]);
+
+  return new Specification(globals);
+}

package/src/ast/build/node/build-string-definition.ts

@@ -0,0 +1,106 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { StringDefinition } from "../../node/string-definition.ts";
+import { StringLiteral } from "../../node/string-literal.ts";
+import { AlignedModifier } from "../../node/aligned-modifier.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildStringDefinition(
+  buildContext: BuildContext,
+): StringDefinition {
+  const children: Array<AbstractNode> = [];
+
+  const reservedKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.RESERVED,
+  );
+  if (reservedKeyword) {
+    children.push(reservedKeyword);
+  }
+  const legacyKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.LEGACY,
+  );
+  if (legacyKeyword) {
+    children.push(legacyKeyword);
+  }
+  const constKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CONST,
+  );
+  if (constKeyword) {
+    children.push(constKeyword);
+  }
+  const alignedModifier = fetchOptionalNode<AlignedModifier>(
+    buildContext,
+    NodeKind.ALIGNED_MODIFIER,
+  );
+  if (alignedModifier) {
+    children.push(alignedModifier);
+  }
+  const stringVariableKindToken = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    [
+      TokenKind.UTF16_STRING,
+      TokenKind.UTF8_STRING,
+      TokenKind.UTF8_LIST,
+      TokenKind.BASE64_STRING,
+    ],
+  );
+  children.push(stringVariableKindToken);
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+  const assignmentPunctuator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.ASSIGNMENT,
+  );
+  let stringLiteral: OptionalNode<StringLiteral> = undefined;
+  if (assignmentPunctuator) {
+    children.push(assignmentPunctuator);
+    stringLiteral = fetchOptionalNode<StringLiteral>(
+      buildContext,
+      NodeKind.STRING_LITERAL,
+    );
+    if (stringLiteral) {
+      children.push(stringLiteral);
+    } else {
+      throw new InternalScannerError(
+        "Expected string literal after assignment operator in string definition",
+        (assignmentPunctuator as Token).getLocation(),
+      );
+    }
+  }
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+  children.push(semicolonPunctuator);
+
+  return new StringDefinition(
+    reservedKeyword,
+    legacyKeyword,
+    constKeyword,
+    alignedModifier,
+    stringVariableKindToken,
+    identifier,
+    assignmentPunctuator,
+    stringLiteral,
+    semicolonPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-switch-statement.ts

@@ -0,0 +1,84 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { SwitchStatement } from "../../node/switch-statement.ts";
+import { CaseClause } from "../../node/case-clause.ts";
+import { DefaultClause } from "../../node/default-clause.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { Token } from "../../node/token.ts";
+import {
+  fetchOptionalNode,
+  fetchRequiredNode,
+  fetchZeroToManyList,
+} from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+
+export function buildSwitchStatement(
+  buildContext: BuildContext,
+): SwitchStatement {
+  const children: Array<AbstractNode> = [];
+
+  const switchKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SWITCH,
+  );
+  children.push(switchKeyword);
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+  const expression = fetchRequiredNode<
+    AbstractExpression | NumberLiteral | Identifier
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  children.push(expression);
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+  const openBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACE,
+  );
+  children.push(openBracePunctuator);
+  const caseClauses = fetchZeroToManyList<CaseClause>(
+    buildContext,
+    NodeKind.CASE_CLAUSE,
+  );
+  children.push(...caseClauses);
+  const defaultClause = fetchOptionalNode<DefaultClause>(
+    buildContext,
+    NodeKind.DEFAULT_CLAUSE,
+  );
+  if (defaultClause) {
+    children.push(defaultClause);
+  }
+  const closeBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACE,
+  );
+  children.push(closeBracePunctuator);
+
+  return new SwitchStatement(
+    switchKeyword,
+    openParenthesisPunctuator,
+    expression,
+    closeParenthesisPunctuator,
+    openBracePunctuator,
+    caseClauses,
+    defaultClause,
+    closeBracePunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-token.ts

@@ -0,0 +1,26 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { Token } from "../../node/token.ts";
+import { syntacticTokenNodeProp } from "../../../lezer/props/syntactic-token-node-prop-source.ts";
+import { getLocationFromTextPosition } from "../../../util/location-utils.ts";
+import { tokenKindByTokenTypeId } from "../util/token-kind-by-token-type-id-map.ts";
+
+export function buildToken(
+  buildContext: BuildContext,
+): Token {
+  const { cursor, text } = buildContext;
+  const tokenKind = tokenKindByTokenTypeId.get(cursor.type.id);
+
+  if (tokenKind === undefined) {
+    throw new InternalScannerError(
+      `No TokenKind mapping found for token type id: ${cursor.type.id} (${cursor.type.name})`,
+    );
+  }
+
+  // Assuming the syntacticTokenNodeProp is easier to get than slicing the text each time
+  const tokenText = cursor.type.prop(syntacticTokenNodeProp) ||
+    text.sliceString(cursor.from, cursor.to);
+  const location = getLocationFromTextPosition(text, cursor.from);
+
+  return new Token(tokenKind, tokenText, location);
+}

package/src/ast/build/node/build-unary-expression.ts

@@ -0,0 +1,109 @@
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import { UnaryExpression } from "../../node/unary-expression.ts";
+import { ArrayElementAccess } from "../../node/array-element-access.ts";
+import type { ClassMemberAccess } from "../../node/class-member-access.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import { Token } from "../../node/token.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { OptionalNode } from "../../util/types.ts";
+
+export function buildUnaryExpression(
+  buildContext: BuildContext,
+): AbstractExpression | Identifier | NumberLiteral {
+  const children: Array<AbstractNode> = [];
+
+  const unaryOperator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    [
+      TokenKind.UNARY_PLUS,
+      TokenKind.UNARY_NEGATION,
+    ],
+  );
+
+  if (unaryOperator) {
+    children.push(unaryOperator);
+  }
+
+  const openParenthesisPunctuator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+
+  if (openParenthesisPunctuator) {
+    children.push(openParenthesisPunctuator);
+  }
+
+  const operand = fetchRequiredNode<
+    AbstractExpression | Identifier | NumberLiteral
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+
+  children.push(operand);
+
+  let closeParenthesisPunctuator: OptionalNode<Token> = undefined;
+  if (openParenthesisPunctuator) {
+    closeParenthesisPunctuator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.CLOSE_PARENTHESIS,
+    );
+
+    if (closeParenthesisPunctuator) {
+      children.push(closeParenthesisPunctuator);
+    } else {
+      throw new InternalScannerError(
+        "Expected closing parenthesis for unary expression which includes open parenthesis",
+        (openParenthesisPunctuator as Token).getLocation(),
+      );
+    }
+  }
+
+  const arrayElementAccess = fetchOptionalNode<ArrayElementAccess>(
+    buildContext,
+    NodeKind.ARRAY_ELEMENT_ACCESS,
+  );
+
+  if (arrayElementAccess) {
+    children.push(arrayElementAccess);
+  }
+
+  const classMemberAccess = fetchOptionalNode<ClassMemberAccess>(
+    buildContext,
+    NodeKind.CLASS_MEMBER_ACCESS,
+  );
+
+  if (classMemberAccess) {
+    children.push(classMemberAccess);
+  }
+
+  const postfixOperator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    [TokenKind.POSTFIX_INCREMENT, TokenKind.POSTFIX_DECREMENT],
+  );
+
+  if (postfixOperator) {
+    children.push(postfixOperator);
+  }
+
+  return new UnaryExpression(
+    unaryOperator,
+    openParenthesisPunctuator,
+    operand,
+    closeParenthesisPunctuator,
+    arrayElementAccess,
+    classMemberAccess,
+    postfixOperator,
+    children,
+  );
+}

package/src/ast/build/node/build-unexpected-error.ts

@@ -0,0 +1,14 @@
+import type { BuildContext } from "../util/build-context.ts";
+import { UnexpectedError } from "../../node/unexpected-error.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+
+export function buildUnexpectedError(
+  buildContext: BuildContext,
+): UnexpectedError {
+  const unexpectedNode = fetchRequiredNode<AbstractNode>(
+    buildContext,
+  );
+
+  return new UnexpectedError(unexpectedNode);
+}