@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/build/node/build-bit-modifier.ts

@@ -0,0 +1,86 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import { BitModifier } from "../../node/bit-modifier.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { AbstractClassId } from "../../node/abstract-class-id.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 buildBitModifier(
+  buildContext: BuildContext,
+): BitModifier {
+  const children: Array<AbstractNode> = [];
+
+  const colonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.COLON,
+  );
+  children.push(colonPunctuator);
+  const bitKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.BIT,
+  );
+  children.push(bitKeyword);
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+  const length = fetchRequiredNode<NumberLiteral>(
+    buildContext,
+    NodeKind.NUMBER_LITERAL,
+  );
+  children.push(length);
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+  const identifier = fetchOptionalNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+
+  let assignmentOperator: OptionalNode<Token> = undefined;
+  if (identifier) {
+    children.push(identifier);
+    assignmentOperator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.ASSIGNMENT,
+    );
+    if (assignmentOperator) {
+      children.push(assignmentOperator);
+    } else {
+      throw new InternalScannerError(
+        "Expected assignment operator '=' after bit modifier identifier.",
+      );
+    }
+  }
+  const classId = fetchRequiredNode<AbstractClassId>(
+    buildContext,
+    NodeKind.CLASS_ID,
+  );
+  children.push(classId);
+
+  return new BitModifier(
+    colonPunctuator,
+    bitKeyword,
+    openParenthesisPunctuator,
+    length,
+    closeParenthesisPunctuator,
+    identifier,
+    assignmentOperator,
+    classId,
+    children,
+  );
+}

package/src/ast/build/node/build-case-clause.ts

@@ -0,0 +1,101 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import { CaseClause } from "../../node/case-clause.ts";
+import type { AbstractStatement } from "../../node/abstract-statement.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,
+  fetchZeroToManyList,
+} from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildCaseClause(
+  buildContext: BuildContext,
+): CaseClause {
+  const children: Array<AbstractNode> = [];
+
+  const caseKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CASE,
+  );
+  children.push(caseKeyword);
+  const value = fetchRequiredNode<NumberLiteral>(
+    buildContext,
+    NodeKind.NUMBER_LITERAL,
+  );
+  children.push(value);
+  const colonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.COLON,
+  );
+  children.push(colonPunctuator);
+  const openBracePunctuator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACE,
+  );
+  if (openBracePunctuator) {
+    children.push(openBracePunctuator);
+  }
+  const statements = fetchZeroToManyList<AbstractStatement>(
+    buildContext,
+    NodeKind.STATEMENT,
+  );
+  children.push(...statements);
+  const breakKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.BREAK,
+  );
+  let semicolonPunctuator: OptionalNode<Token> = undefined;
+  if (breakKeyword) {
+    children.push(breakKeyword);
+    semicolonPunctuator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.SEMICOLON,
+    );
+    if (semicolonPunctuator) {
+      children.push(semicolonPunctuator);
+    } else {
+      throw new InternalScannerError(
+        "Expected semicolon punctuator ';' after break keyword.",
+      );
+    }
+  }
+
+  let closeBracePunctuator: OptionalNode<Token> = undefined;
+  if (openBracePunctuator) {
+    closeBracePunctuator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.CLOSE_BRACE,
+    );
+    if (closeBracePunctuator) {
+      children.push(closeBracePunctuator);
+    } else {
+      throw new InternalScannerError(
+        "Expected close brace punctuator '}' to match open brace punctuator.",
+      );
+    }
+  }
+
+  return new CaseClause(
+    caseKeyword,
+    value,
+    colonPunctuator,
+    openBracePunctuator,
+    statements,
+    breakKeyword,
+    semicolonPunctuator,
+    closeBracePunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-class-declaration.ts

@@ -0,0 +1,124 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { ClassDeclaration } from "../../node/class-declaration.ts";
+import { AbstractStatement } from "../../node/abstract-statement.ts";
+import { BitModifier } from "../../node/bit-modifier.ts";
+import { ExtendsModifier } from "../../node/extends-modifier.ts";
+import { ParameterList } from "../../node/parameter-list.ts";
+import type { ExpandableModifier } from "../../node/expandable-modifier.ts";
+import type { AlignedModifier } from "../../node/aligned-modifier.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 buildClassDeclaration(
+  buildContext: BuildContext,
+): ClassDeclaration {
+  const children: Array<AbstractNode> = [];
+  const alignedModifier = fetchOptionalNode<AlignedModifier>(
+    buildContext,
+    NodeKind.ALIGNED_MODIFIER,
+  );
+  if (alignedModifier) {
+    children.push(alignedModifier);
+  }
+
+  const expandableModifier = fetchOptionalNode<ExpandableModifier>(
+    buildContext,
+    NodeKind.EXPANDABLE_MODIFIER,
+  );
+  if (expandableModifier) {
+    children.push(expandableModifier);
+  }
+
+  const abstractKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.ABSTRACT,
+  );
+
+  if (abstractKeyword) {
+    children.push(abstractKeyword);
+  }
+  const classKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLASS,
+  );
+
+  children.push(classKeyword);
+
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+
+  children.push(identifier);
+
+  const parameterList = fetchOptionalNode<ParameterList>(
+    buildContext,
+    NodeKind.PARAMETER_LIST,
+  );
+
+  if (parameterList) {
+    children.push(parameterList);
+  }
+  const extendsModifier = fetchOptionalNode<ExtendsModifier>(
+    buildContext,
+    NodeKind.EXTENDS_MODIFIER,
+  );
+
+  if (extendsModifier) {
+    children.push(extendsModifier);
+  }
+  const bitModifier = fetchOptionalNode<BitModifier>(
+    buildContext,
+    NodeKind.BIT_MODIFIER,
+  );
+
+  if (bitModifier) {
+    children.push(bitModifier);
+  }
+  const openBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACE,
+  );
+
+  children.push(openBracePunctuator);
+
+  const statements = fetchZeroToManyList<AbstractStatement>(
+    buildContext,
+    NodeKind.STATEMENT,
+  );
+
+  children.push(...statements);
+
+  const closeBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACE,
+  );
+  children.push(closeBracePunctuator);
+
+  return new ClassDeclaration(
+    alignedModifier,
+    expandableModifier,
+    abstractKeyword,
+    classKeyword,
+    identifier,
+    parameterList,
+    extendsModifier,
+    bitModifier,
+    openBracePunctuator,
+    statements,
+    closeBracePunctuator,
+    children,
+  );
+}

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

@@ -0,0 +1,56 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ClassDefinition } from "../../node/class-definition.ts";
+import type { ParameterValueList } from "../../node/parameter-value-list.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 { TokenKind } from "../../node/enum/token-kind.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildClassDefinition(
+  buildContext: BuildContext,
+): ClassDefinition {
+  const children: Array<AbstractNode> = [];
+
+  const legacyKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.LEGACY,
+  );
+  if (legacyKeyword) {
+    children.push(legacyKeyword);
+  }
+
+  const classIdentifier = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(classIdentifier);
+  const identifier = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+  const parameterValueList = fetchOptionalNode<ParameterValueList>(
+    buildContext,
+    NodeKind.PARAMETER_VALUE_LIST,
+  );
+  if (parameterValueList) {
+    children.push(parameterValueList);
+  }
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+  children.push(semicolonPunctuator);
+
+  return new ClassDefinition(
+    legacyKeyword,
+    classIdentifier,
+    identifier,
+    parameterValueList,
+    semicolonPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-class-id-range.ts

@@ -0,0 +1,32 @@
+import { ClassId } from "../../node/class-id.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ClassIdRange } from "../../node/class-id-range.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 buildClassIdRange(
+  buildContext: BuildContext,
+): ClassIdRange {
+  const startClassId = fetchRequiredNode<ClassId>(
+    buildContext,
+    NodeKind.CLASS_ID,
+  );
+  const rangeOperator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.RANGE_OPERATOR,
+  );
+  const endClassId = fetchRequiredNode<ClassId>(
+    buildContext,
+    NodeKind.CLASS_ID,
+  );
+
+  return new ClassIdRange(
+    startClassId,
+    rangeOperator,
+    endClassId,
+    [startClassId, rangeOperator, endClassId],
+  );
+}

package/src/ast/build/node/build-class-id.ts

@@ -0,0 +1,19 @@
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ClassId } from "../../node/class-id.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+
+export function buildClassId(
+  buildContext: BuildContext,
+): ClassId {
+  const value = fetchRequiredNode<NumberLiteral>(
+    buildContext,
+    NodeKind.NUMBER_LITERAL,
+  );
+
+  return new ClassId(
+    value,
+    [value],
+  );
+}

package/src/ast/build/node/build-class-member-access.ts

@@ -0,0 +1,27 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { ClassMemberAccess } from "../../node/class-member-access.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 buildClassMemberAccess(
+  buildContext: BuildContext,
+): ClassMemberAccess {
+  const classMemberAccessOperator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.PERIOD,
+  );
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+
+  return new ClassMemberAccess(
+    classMemberAccessOperator,
+    identifier,
+    [classMemberAccessOperator, identifier],
+  );
+}

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

@@ -0,0 +1,33 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { CompoundStatement } from "../../node/compound-statement.ts";
+import { AbstractStatement } from "../../node/abstract-statement.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { fetchRequiredNode, fetchZeroToManyList } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildCompoundStatement(
+  buildContext: BuildContext,
+): CompoundStatement {
+  const openBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACE,
+  );
+  const statements = fetchZeroToManyList<AbstractStatement>(
+    buildContext,
+    NodeKind.STATEMENT,
+  );
+  const closeBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACE,
+  );
+
+  return new CompoundStatement(
+    openBracePunctuator,
+    statements,
+    closeBracePunctuator,
+    [openBracePunctuator, ...statements, closeBracePunctuator],
+  );
+}

package/src/ast/build/node/build-computed-array-definition.ts

@@ -0,0 +1,53 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { ExplicitArrayDimension } from "../../node/explicit-array-dimension.ts";
+import type { ElementaryType } from "../../node/elementary-type.ts";
+import { ComputedArrayDefinition } from "../../node/computed-array-definition.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchOneToManyList, fetchRequiredNode } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { ArrayDimensionKind } from "../../node/enum/array-dimension-kind.ts";
+
+export function buildComputedArrayDefinition(
+  buildContext: BuildContext,
+): ComputedArrayDefinition {
+  const computedKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.COMPUTED,
+  );
+  const elementaryType = fetchRequiredNode<ElementaryType>(
+    buildContext,
+    NodeKind.ELEMENTARY_TYPE,
+  );
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  const dimensions = fetchOneToManyList<ExplicitArrayDimension>(
+    buildContext,
+    NodeKind.ARRAY_DIMENSION,
+    ArrayDimensionKind.EXPLICIT,
+  );
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+
+  return new ComputedArrayDefinition(
+    computedKeyword,
+    elementaryType,
+    identifier,
+    dimensions,
+    semicolonPunctuator,
+    [
+      computedKeyword,
+      elementaryType,
+      identifier,
+      ...dimensions,
+      semicolonPunctuator,
+    ],
+  );
+}

package/src/ast/build/node/build-computed-elementary-type-definition.ts

@@ -0,0 +1,100 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { ComputedElementaryTypeDefinition } from "../../node/computed-elementary-type-definition.ts";
+import type { ElementaryType } from "../../node/elementary-type.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import type { BuildContext } from "../util/build-context.ts";
+
+export function buildComputedElementaryTypeDefinition(
+  buildContext: BuildContext,
+): ComputedElementaryTypeDefinition {
+  const children: Array<AbstractNode> = [];
+
+  const computedKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.COMPUTED,
+  );
+
+  children.push(computedKeyword);
+
+  const constKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CONST,
+  );
+
+  if (constKeyword !== undefined) {
+    children.push(constKeyword);
+  }
+
+  const elementaryType = fetchRequiredNode<ElementaryType>(
+    buildContext,
+    NodeKind.ELEMENTARY_TYPE,
+  );
+
+  children.push(elementaryType);
+
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+
+  const assignmentOperator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.ASSIGNMENT,
+  );
+
+  let value: OptionalNode<AbstractExpression | Identifier | NumberLiteral> =
+    undefined;
+
+  if (assignmentOperator !== undefined) {
+    children.push(assignmentOperator);
+
+    value = fetchOptionalNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >(
+      buildContext,
+      [
+        NodeKind.EXPRESSION,
+        NodeKind.IDENTIFIER,
+        NodeKind.NUMBER_LITERAL,
+      ],
+    );
+    if (value !== undefined) {
+      children.push(value);
+    } else {
+      throw new InternalScannerError(
+        "Expected value for computed elementary type definition after assignment operator",
+        (assignmentOperator as Token).getLocation(),
+      );
+    }
+  }
+
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+  children.push(semicolonPunctuator);
+
+  return new ComputedElementaryTypeDefinition(
+    computedKeyword,
+    constKeyword,
+    elementaryType,
+    identifier,
+    assignmentOperator,
+    value,
+    semicolonPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-decimal-literal.ts

@@ -0,0 +1,15 @@
+import { NumberLiteral } from "../../node/number-literal.ts";
+import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildDecimalLiteral(
+  token: Token,
+): NumberLiteral {
+  const value = parseFloat(token.text);
+
+  return new NumberLiteral(
+    NumberLiteralKind.DECIMAL,
+    value,
+    [token],
+  );
+}