@mpeggroup/mpeg-sdl-parser 4.0.0

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

@@ -0,0 +1,76 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { AbstractStatement } from "../../node/abstract-statement.ts";
+import { DefaultClause } from "../../node/default-clause.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 buildDefaultClause(
+  buildContext: BuildContext,
+): DefaultClause {
+  const children: Array<AbstractNode> = [];
+
+  const defaultKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.DEFAULT,
+  );
+  children.push(defaultKeyword);
+
+  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);
+
+  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 '}' to match open brace",
+        (openBracePunctuator as Token).getLocation(),
+      );
+    }
+  }
+
+  return new DefaultClause(
+    defaultKeyword,
+    colonPunctuator,
+    openBracePunctuator,
+    statements,
+    closeBracePunctuator,
+    children,
+  );
+}

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

@@ -0,0 +1,71 @@
+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 { DoStatement } from "../../node/do-statement.ts";
+import { CompoundStatement } from "../../node/compound-statement.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";
+import { StatementKind } from "../../node/enum/statement-kind.ts";
+
+export function buildDoStatement(
+  buildContext: BuildContext,
+): DoStatement {
+  const doKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.DO,
+  );
+  const compoundStatement = fetchRequiredNode<CompoundStatement>(
+    buildContext,
+    NodeKind.STATEMENT,
+    StatementKind.COMPOUND,
+  );
+  const whileKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.WHILE,
+  );
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  const condition = fetchRequiredNode<
+    AbstractExpression | NumberLiteral | Identifier
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+
+  return new DoStatement(
+    doKeyword,
+    compoundStatement,
+    whileKeyword,
+    openParenthesisPunctuator,
+    condition,
+    closeParenthesisPunctuator,
+    semicolonPunctuator,
+    [
+      doKeyword,
+      compoundStatement,
+      whileKeyword,
+      openParenthesisPunctuator,
+      condition,
+      closeParenthesisPunctuator,
+      semicolonPunctuator,
+    ],
+  );
+}

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

@@ -0,0 +1,164 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import { ElementaryTypeDefinition } from "../../node/elementary-type-definition.ts";
+import type { ElementaryType } from "../../node/elementary-type.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { AlignedModifier } from "../../node/aligned-modifier.ts";
+import type { LengthAttribute } from "../../node/length-attribute.ts";
+import type { NumberLiteral } from "../../node/number-literal.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";
+import type { OptionalNode } from "../../util/types.ts";
+
+export function buildElementaryTypeDefinition(
+  buildContext: BuildContext,
+): ElementaryTypeDefinition {
+  const children: Array<AbstractNode> = [];
+
+  const reservedKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.RESERVED,
+  );
+
+  if (reservedKeyword !== undefined) {
+    children.push(reservedKeyword);
+  }
+
+  const legacyKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.LEGACY,
+  );
+  if (legacyKeyword !== undefined) {
+    children.push(legacyKeyword);
+  }
+
+  const constKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CONST,
+  );
+  if (constKeyword !== undefined) {
+    children.push(constKeyword);
+  }
+
+  const alignedModifier = fetchOptionalNode<AlignedModifier>(
+    buildContext,
+    NodeKind.ALIGNED_MODIFIER,
+  );
+  if (alignedModifier !== undefined) {
+    children.push(alignedModifier);
+  }
+
+  const elementaryType = fetchRequiredNode<ElementaryType>(
+    buildContext,
+    NodeKind.ELEMENTARY_TYPE,
+  );
+  children.push(elementaryType);
+
+  const lengthAttribute = fetchRequiredNode<LengthAttribute>(
+    buildContext,
+    NodeKind.LENGTH_ATTRIBUTE,
+  );
+  children.push(lengthAttribute);
+
+  const lookAheadOperator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.LOOK_AHEAD,
+  );
+
+  if (lookAheadOperator !== undefined) {
+    children.push(lookAheadOperator);
+  }
+
+  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;
+  let rangeOperator: OptionalNode<Token> = undefined;
+  let endValue: 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 elementary type definition after assignment operator",
+        (assignmentOperator as Token).getLocation(),
+      );
+    }
+    rangeOperator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.RANGE_OPERATOR,
+    );
+    if (rangeOperator !== undefined) {
+      children.push(rangeOperator);
+
+      endValue = fetchOptionalNode<
+        AbstractExpression | Identifier | NumberLiteral
+      >(
+        buildContext,
+        [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+      );
+
+      if (endValue !== undefined) {
+        children.push(endValue);
+      } else {
+        throw new InternalScannerError(
+          "Expected end value for elementary type definition after range operator",
+          (rangeOperator as Token).getLocation(),
+        );
+      }
+    }
+  }
+
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+
+  children.push(semicolonPunctuator);
+
+  return new ElementaryTypeDefinition(
+    reservedKeyword,
+    legacyKeyword,
+    constKeyword,
+    alignedModifier,
+    elementaryType,
+    lengthAttribute,
+    lookAheadOperator,
+    identifier,
+    assignmentOperator,
+    value,
+    rangeOperator,
+    endValue,
+    semicolonPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-elementary-type-output-value.ts

@@ -0,0 +1,25 @@
+import { ElementaryType } from "../../node/elementary-type.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ElementaryTypeOutputValue } from "../../node/elementary-type-output-value.ts";
+import { LengthAttribute } from "../../node/length-attribute.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+
+export function buildElementaryTypeOutputValue(
+  buildContext: BuildContext,
+): ElementaryTypeOutputValue {
+  const elementaryType = fetchRequiredNode<ElementaryType>(
+    buildContext,
+    NodeKind.ELEMENTARY_TYPE,
+  );
+  const lengthAttribute = fetchRequiredNode<LengthAttribute>(
+    buildContext,
+    NodeKind.LENGTH_ATTRIBUTE,
+  );
+
+  return new ElementaryTypeOutputValue(
+    elementaryType,
+    lengthAttribute,
+    [elementaryType, lengthAttribute],
+  );
+}

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

@@ -0,0 +1,36 @@
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { ElementaryType } from "../../node/elementary-type.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { Token } from "../../node/token.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { BuildContext } from "../util/build-context.ts";
+
+export function buildElementaryType(
+  buildContext: BuildContext,
+): ElementaryType {
+  const children: Array<AbstractNode> = [];
+  const unsignedQualifierKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.UNSIGNED,
+  );
+
+  if (unsignedQualifierKeyword) {
+    children.push(unsignedQualifierKeyword);
+  }
+
+  const typeKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    [TokenKind.INT, TokenKind.BIT, TokenKind.FLOAT],
+  );
+
+  children.push(typeKeyword);
+
+  return new ElementaryType(
+    unsignedQualifierKeyword,
+    typeKeyword,
+    children,
+  );
+}

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

@@ -0,0 +1,68 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import { ExpandableModifier } from "../../node/expandable-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 buildExpandableModifier(
+  buildContext: BuildContext,
+): ExpandableModifier {
+  const children: Array<AbstractNode> = [];
+
+  const expandableKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.EXPANDABLE,
+  );
+  children.push(expandableKeyword);
+
+  const openParenthesisPunctuator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  let maxClassSize: OptionalNode<NumberLiteral> = undefined;
+  let closedParenthesisPunctuator: OptionalNode<Token> = undefined;
+
+  if (openParenthesisPunctuator) {
+    children.push(openParenthesisPunctuator);
+    maxClassSize = fetchOptionalNode<NumberLiteral>(
+      buildContext,
+      NodeKind.NUMBER_LITERAL,
+    );
+    if (maxClassSize) {
+      children.push(maxClassSize);
+    } else {
+      throw new InternalScannerError(
+        "ExpandableModifier missing required maxClassSize NumberLiteral",
+        (openParenthesisPunctuator as Token).getLocation(),
+      );
+    }
+    closedParenthesisPunctuator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.CLOSE_PARENTHESIS,
+    );
+    if (closedParenthesisPunctuator) {
+      children.push(closedParenthesisPunctuator);
+    } else {
+      throw new InternalScannerError(
+        "ExpandableModifier missing required closedParenthesisPunctuator Token",
+        (openParenthesisPunctuator as Token).getLocation(),
+      );
+    }
+  }
+
+  return new ExpandableModifier(
+    expandableKeyword,
+    openParenthesisPunctuator,
+    maxClassSize,
+    closedParenthesisPunctuator,
+    children,
+  );
+}

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

@@ -0,0 +1,37 @@
+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 { ExplicitArrayDimension } from "../../node/explicit-array-dimension.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildExplicitArrayDimension(
+  buildContext: BuildContext,
+): ExplicitArrayDimension {
+  const openBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACKET,
+  );
+  const size = fetchRequiredNode<
+    AbstractExpression | Identifier | NumberLiteral
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  const closeBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACKET,
+  );
+
+  return new ExplicitArrayDimension(
+    openBracketPunctuator,
+    size,
+    closeBracketPunctuator,
+    [openBracketPunctuator, size, closeBracketPunctuator!],
+  );
+}

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

@@ -0,0 +1,31 @@
+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 { ExpressionStatement } from "../../node/expression-statement.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildExpressionStatement(
+  buildContext: BuildContext,
+): ExpressionStatement {
+  const expression = fetchRequiredNode<
+    AbstractExpression | Identifier | NumberLiteral
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+
+  return new ExpressionStatement(
+    expression,
+    semicolonPunctuator,
+    [expression, semicolonPunctuator],
+  );
+}

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

@@ -0,0 +1,27 @@
+import { ClassId } from "../../node/class-id.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ExtendedClassIdRange } from "../../node/extended-class-id-range.ts";
+import type { ClassIdRange } from "../../node/class-id-range.ts";
+import { ClassIdKind } from "../../node/enum/class-id-kind.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { fetchOneToManyCommaSeparatedList } from "../util/fetch-node.ts";
+
+export function buildExtendedClassIdRange(
+  buildContext: BuildContext,
+): ExtendedClassIdRange {
+  const children: Array<AbstractNode> = [];
+
+  const { nodes: classIds, commaPunctuators } =
+    fetchOneToManyCommaSeparatedList<ClassId | ClassIdRange>(
+      buildContext,
+      NodeKind.CLASS_ID,
+      [ClassIdKind.SINGLE, ClassIdKind.RANGE],
+    );
+
+  return new ExtendedClassIdRange(
+    classIds,
+    commaPunctuators,
+    children,
+  );
+}

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

@@ -0,0 +1,41 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { ExtendsModifier } from "../../node/extends-modifier.ts";
+import type { Identifier } from "../../node/identifier.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 type { Token } from "../../node/token.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildExtendsModifier(
+  buildContext: BuildContext,
+): ExtendsModifier {
+  const children: Array<AbstractNode> = [];
+
+  const extendsKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.EXTENDS,
+  );
+  children.push(extendsKeyword);
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+  const parameterValueList = fetchOptionalNode<ParameterValueList>(
+    buildContext,
+    NodeKind.PARAMETER_VALUE_LIST,
+  );
+  if (parameterValueList) {
+    children.push(parameterValueList);
+  }
+
+  return new ExtendsModifier(
+    extendsKeyword,
+    identifier,
+    parameterValueList,
+    children,
+  );
+}

package/src/ast/build/node/build-floating-point-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 buildFloatingPointLiteral(
+  token: Token,
+): NumberLiteral {
+  const value = parseFloat(token.text);
+
+  return new NumberLiteral(
+    NumberLiteralKind.FLOATING_POINT,
+    value,
+    [token],
+  );
+}