@mpeggroup/mpeg-sdl-parser 4.0.0

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

@@ -0,0 +1,29 @@
+import type {
+  OneToManyList,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class ParameterValueList extends AbstractCompositeNode {
+  constructor(
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly values: OneToManyList<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    public readonly commaPunctuators: ZeroToManyList<Token>,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.PARAMETER_VALUE_LIST,
+      children,
+    );
+  }
+}

package/src/ast/node/parameter.ts

@@ -0,0 +1,20 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { ElementaryType } from "./elementary-type.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { Identifier } from "./identifier.ts";
+
+export class Parameter extends AbstractCompositeNode {
+  constructor(
+    public readonly classIdentifier: OptionalNode<Identifier>,
+    public readonly elementaryType: OptionalNode<ElementaryType>,
+    public readonly identifier: RequiredNode<Identifier>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.PARAMETER,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractArrayDimension } from "./abstract-array-dimension.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { ArrayDimensionKind } from "./enum/array-dimension-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class PartialArrayDimension extends AbstractArrayDimension {
+  constructor(
+    openBracketPunctuator: RequiredNode<Token>,
+    public readonly innerOpenBracketPunctuator: RequiredNode<Token>,
+    public readonly index: RequiredNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    public readonly innerCloseBracketPunctuator: RequiredNode<Token>,
+    closeBracketPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      ArrayDimensionKind.PARTIAL,
+      openBracketPunctuator,
+      closeBracketPunctuator,
+      children,
+    );
+  }
+}

package/src/ast/node/specification.ts

@@ -0,0 +1,21 @@
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { ClassDeclaration } from "./class-declaration.ts";
+import type { ComputedElementaryTypeDefinition } from "./computed-elementary-type-definition.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { MapDeclaration } from "./map-declaration.ts";
+import type { ZeroToManyList } from "../util/types.ts";
+
+export class Specification extends AbstractCompositeNode {
+  constructor(
+    globals: ZeroToManyList<
+      | ComputedElementaryTypeDefinition
+      | MapDeclaration
+      | ClassDeclaration
+    >,
+  ) {
+    super(
+      NodeKind.SPECIFICATION,
+      globals,
+    );
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import type { AlignedModifier } from "./aligned-modifier.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { StringLiteral } from "./string-literal.ts";
+import type { Token } from "./token.ts";
+
+export class StringDefinition extends AbstractStatement {
+  constructor(
+    public readonly reservedKeyword: OptionalNode<Token>,
+    public readonly legacyKeyword: OptionalNode<Token>,
+    public readonly constKeyword: OptionalNode<Token>,
+    public readonly alignedModifier: OptionalNode<AlignedModifier>,
+    public readonly stringVariableKindToken: RequiredNode<Token>,
+    public readonly identifier: RequiredNode<Identifier>,
+    public readonly assignmentPunctuator: OptionalNode<Token>,
+    public readonly stringLiteral: OptionalNode<StringLiteral>,
+    public readonly semicolonPunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.STRING_DEFINITION,
+      children,
+    );
+  }
+}

package/src/ast/node/string-literal.ts

@@ -0,0 +1,21 @@
+import type { OneToManyList } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import { StringLiteralKind } from "./enum/string-literal-kind.ts";
+import type { Token } from "./token.ts";
+
+export class StringLiteral extends AbstractCompositeNode {
+  constructor(
+    public readonly stringLiteralKind: StringLiteralKind,
+    public readonly value: string,
+    // an array to support multiple concatenated string literal tokens
+    public readonly literals: OneToManyList<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      NodeKind.STRING_LITERAL,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,32 @@
+import type { AbstractExpression } from "./abstract-expression.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { CaseClause } from "./case-clause.ts";
+import type { DefaultClause } from "./default-clause.ts";
+import type {
+  OptionalNode,
+  RequiredNode,
+  ZeroToManyList,
+} from "../util/types.ts";
+import type { Token } from "./token.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+
+export class SwitchStatement extends AbstractStatement {
+  constructor(
+    public readonly switchKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly expression: RequiredNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly openBracePunctuator: RequiredNode<Token>,
+    public readonly caseClauses: ZeroToManyList<CaseClause>,
+    public readonly defaultClause: OptionalNode<DefaultClause>,
+    public readonly closeBracePunctuator: RequiredNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(StatementKind.SWITCH, children);
+  }
+}

package/src/ast/node/token.ts

@@ -0,0 +1,20 @@
+import type { Location } from "../../location.ts";
+import { AbstractLeafNode } from "./abstract-leaf-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+import type { TokenKind } from "./enum/token-kind.ts";
+
+export class Token extends AbstractLeafNode {
+  constructor(
+    public readonly tokenKind: TokenKind,
+    public readonly text: string,
+    private readonly location: Location,
+  ) {
+    super(
+      NodeKind.TOKEN,
+    );
+  }
+
+  getLocation(): Location {
+    return this.location;
+  }
+}

package/src/ast/node/trivia.ts

@@ -0,0 +1,13 @@
+import type { Location } from "../../location.ts";
+
+/**
+ * Represents a parsed trivia item.
+ *
+ * @interface Trivia
+ * @property {string} text - The text content of the trivia.
+ * @property {Location} location - The location of the trivia.
+ */
+export interface Trivia {
+  readonly text: string;
+  readonly location: Location;
+}

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

@@ -0,0 +1,31 @@
+import type { OptionalNode, RequiredNode } from "../util/types.ts";
+import { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import type { ArrayElementAccess } from "./array-element-access.ts";
+import type { ClassMemberAccess } from "./class-member-access.ts";
+import { ExpressionKind } from "./enum/expression-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class UnaryExpression extends AbstractExpression {
+  constructor(
+    public readonly unaryOperator: OptionalNode<Token>,
+    public readonly openParenthesisPunctuator: OptionalNode<Token>,
+    public readonly operand: RequiredNode<
+      | AbstractExpression
+      | Identifier
+      | NumberLiteral
+    >,
+    public readonly closeParenthesisPunctuator: OptionalNode<Token>,
+    public readonly arrayElementAccess: OptionalNode<ArrayElementAccess>,
+    public readonly classMemberAccess: OptionalNode<ClassMemberAccess>,
+    public readonly postfixOperator: OptionalNode<Token>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      ExpressionKind.UNARY,
+      children,
+    );
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { RequiredNode } from "../util/types.ts";
+import { AbstractCompositeNode } from "./abstract-composite-node.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { NodeKind } from "./enum/node-kind.ts";
+
+export class UnexpectedError extends AbstractCompositeNode {
+  constructor(
+    public readonly unexpectedToken: RequiredNode<AbstractNode>,
+  ) {
+    super(NodeKind.UNEXPECTED_ERROR, [unexpectedToken]);
+  }
+}

package/src/ast/node/while-statement.ts

@@ -0,0 +1,26 @@
+import type { RequiredNode } from "../util/types.ts";
+import type { AbstractExpression } from "./abstract-expression.ts";
+import type { AbstractNode } from "./abstract-node.ts";
+import { AbstractStatement } from "./abstract-statement.ts";
+import { StatementKind } from "./enum/statement-kind.ts";
+import type { Identifier } from "./identifier.ts";
+import type { NumberLiteral } from "./number-literal.ts";
+import type { Token } from "./token.ts";
+
+export class WhileStatement extends AbstractStatement {
+  constructor(
+    public readonly whileKeyword: RequiredNode<Token>,
+    public readonly openParenthesisPunctuator: RequiredNode<Token>,
+    public readonly condition: RequiredNode<
+      AbstractExpression | Identifier | NumberLiteral
+    >,
+    public readonly closeParenthesisPunctuator: RequiredNode<Token>,
+    public readonly statement: RequiredNode<AbstractStatement>,
+    children: Array<AbstractNode>,
+  ) {
+    super(
+      StatementKind.WHILE,
+      children,
+    );
+  }
+}

package/src/ast/util/types.ts

@@ -0,0 +1,138 @@
+import type { AbstractCompositeNode } from "../node/abstract-composite-node.ts";
+import type { AbstractNode } from "../node/abstract-node.ts";
+import type { AbstractStatement } from "../node/abstract-statement.ts";
+import type { ComputedElementaryTypeDefinition } from "../node/computed-elementary-type-definition.ts";
+import type { Identifier } from "../node/identifier.ts";
+import { NodeKind } from "../node/enum/node-kind.ts";
+import { TokenKind } from "../node/enum/token-kind.ts";
+import type { MissingError } from "../node/missing-error.ts";
+import type { Token } from "../node/token.ts";
+import type { UnexpectedError } from "../node/unexpected-error.ts";
+import { StatementKind } from "../node/enum/statement-kind.ts";
+import type { ElementaryType } from "../node/elementary-type.ts";
+import type { AbstractExpression } from "../node/abstract-expression.ts";
+import type { ExpandableModifier } from "../node/expandable-modifier.ts";
+import type { DefaultClause } from "../node/default-clause.ts";
+import type { NumberLiteral } from "../node/number-literal.ts";
+import type { CaseClause } from "../node/case-clause.ts";
+import type { ExtendsModifier } from "../node/extends-modifier.ts";
+import type { AlignedModifier } from "../node/aligned-modifier.ts";
+import type { BitModifier } from "../node/bit-modifier.ts";
+import { ExpressionKind } from "../node/enum/expression-kind.ts";
+
+export type OptionalNode<T> = T | UnexpectedError | undefined;
+
+export type RequiredNode<T> = T | MissingError | UnexpectedError;
+
+export type ZeroToManyList<T> = Array<T | UnexpectedError>;
+
+export type OneToManyList<T> = Array<T | MissingError | UnexpectedError>;
+
+export function isCompositeNode(
+  node: AbstractNode | undefined,
+): node is AbstractCompositeNode {
+  return node?.isComposite === true;
+}
+
+export function isToken(
+  node: AbstractNode | undefined,
+): node is Token {
+  return node?.nodeKind === NodeKind.TOKEN;
+}
+
+export function isUnexpectedError(
+  node: AbstractNode | undefined,
+): node is UnexpectedError {
+  return node?.nodeKind === NodeKind.UNEXPECTED_ERROR;
+}
+
+export function isMissingError(
+  node: AbstractNode | undefined,
+): node is MissingError {
+  return node?.nodeKind === NodeKind.TOKEN &&
+    ((node as Token).tokenKind === TokenKind.ERROR_MISSING_TOKEN);
+}
+
+export function isStatement(
+  node: AbstractNode | undefined,
+): node is AbstractStatement {
+  return node?.nodeKind === NodeKind.STATEMENT &&
+    (Object.values(StatementKind) as number[]).includes(
+      (node as AbstractStatement).statementKind,
+    );
+}
+
+export function isIdentifier(
+  node: AbstractNode | undefined,
+): node is Identifier {
+  return node?.nodeKind === NodeKind.IDENTIFIER;
+}
+
+export function isElementaryType(
+  node: AbstractNode | undefined,
+): node is ElementaryType {
+  return node?.nodeKind === NodeKind.ELEMENTARY_TYPE;
+}
+
+export function isAbstractExpression(
+  node: AbstractNode | undefined,
+): node is AbstractExpression {
+  return node?.nodeKind === NodeKind.EXPRESSION;
+}
+
+export function isUnaryExpression(
+  node: AbstractNode | undefined,
+): node is AbstractExpression {
+  return (node?.nodeKind === NodeKind.EXPRESSION) &&
+    (node as AbstractExpression).expressionKind === ExpressionKind.UNARY;
+}
+
+export function isNumberLiteral(
+  node: AbstractNode | undefined,
+): node is NumberLiteral {
+  return node?.nodeKind === NodeKind.NUMBER_LITERAL;
+}
+
+export function isComputedElementaryTypeDefinition(
+  node: AbstractNode | undefined,
+): node is ComputedElementaryTypeDefinition {
+  return node?.nodeKind === NodeKind.STATEMENT &&
+    (node as AbstractStatement).statementKind ===
+      StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION;
+}
+
+export function isExpandableModifier(
+  node: AbstractNode | undefined,
+): node is ExpandableModifier {
+  return node?.nodeKind === NodeKind.EXPANDABLE_MODIFIER;
+}
+
+export function isAlignedModifier(
+  node: AbstractNode | undefined,
+): node is AlignedModifier {
+  return node?.nodeKind === NodeKind.ALIGNED_MODIFIER;
+}
+
+export function isExtendsModifier(
+  node: AbstractNode | undefined,
+): node is ExtendsModifier {
+  return node?.nodeKind === NodeKind.EXTENDS_MODIFIER;
+}
+
+export function isCaseClause(
+  node: AbstractNode | undefined,
+): node is CaseClause {
+  return node?.nodeKind === NodeKind.CASE_CLAUSE;
+}
+
+export function isDefaultClause(
+  node: AbstractNode | undefined,
+): node is DefaultClause {
+  return node?.nodeKind === NodeKind.DEFAULT_CLAUSE;
+}
+
+export function isBitModifier(
+  node: AbstractNode | undefined,
+): node is BitModifier {
+  return node?.nodeKind === NodeKind.BIT_MODIFIER;
+}

package/src/ast/visitor/node-handler.ts

@@ -0,0 +1,15 @@
+import type { AbstractCompositeNode } from "../node/abstract-composite-node.ts";
+import type { AbstractLeafNode } from "../node/abstract-leaf-node.ts";
+
+/**
+ * Interface representing a handler for nodes in an abstract syntax tree.
+ *
+ * @interface NodeHandler
+ */
+export interface NodeHandler {
+  beforeVisit(node: AbstractCompositeNode): void;
+
+  visit(node: AbstractLeafNode): void;
+
+  afterVisit(node: AbstractCompositeNode): void;
+}

package/src/ast/visitor/node-visitor.ts

@@ -0,0 +1,13 @@
+import type { AbstractNode } from "../node/abstract-node.ts";
+
+/**
+ * Interface representing a visitor for nodes.
+ */
+export interface NodeVisitor {
+  /**
+   * Called when visiting a node.
+   * @param node The node to visit.
+   * @returns The result of the visit operation.
+   */
+  visit(node: AbstractNode): void;
+}

package/src/ast/visitor/traversing-visitor.ts

@@ -0,0 +1,69 @@
+import getLogger from "../../util/logger.ts";
+import type { AbstractLeafNode } from "../node/abstract-leaf-node.ts";
+import type { AbstractNode } from "../node/abstract-node.ts";
+import { NodeKind } from "../node/enum/node-kind.ts";
+import type { NodeHandler } from "./node-handler.ts";
+import type { NodeVisitor } from "./node-visitor.ts";
+import { debugEnabled } from "../../util/logger.ts";
+import { isCompositeNode, isToken } from "../util/types.ts";
+
+const logger = getLogger("TraversingVisitor");
+
+/**
+ * A visitor that traverses nodes and delegates operations to a node handler.
+ */
+export class TraversingVisitor implements NodeVisitor {
+  constructor(public readonly nodeHandler: NodeHandler) {}
+
+  depth = 0;
+
+  /**
+   * Called when visiting a node.
+   * @param node The node to visit.
+   */
+  visit(node: AbstractNode): void {
+    const indent = "  ".repeat(this.depth);
+
+    if (debugEnabled) {
+      let tokenText = "";
+      if (isToken(node)) {
+        tokenText = ` => ${node.text}`;
+      }
+
+      if (node.leadingTrivia) {
+        tokenText += ` => leadingTrivia: ${
+          node.leadingTrivia.map((t) => `"${t.text.replace(/\n/g, "\\n")}"`)
+            .join(", ")
+        }`;
+      }
+
+      if (node.trailingTrivia) {
+        tokenText += ` => trailingTrivia: ${
+          node.trailingTrivia.map((t) => `"${t.text.replace(/\n/g, "\\n")}"`)
+            .join(", ")
+        }`;
+      }
+
+      logger.debug(
+        "visit: %s %s%s",
+        indent,
+        NodeKind[node.nodeKind],
+        tokenText,
+      );
+    }
+
+    if (isCompositeNode(node)) {
+      this.nodeHandler.beforeVisit(node);
+
+      for (const childNode of node.children) {
+        this.depth++;
+        this.visit(childNode);
+        this.depth--;
+      }
+
+      this.nodeHandler.afterVisit(node);
+    } else {
+      this.nodeHandler.visit(node as AbstractLeafNode);
+    }
+  }
+}