@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/completion/rules/computed-elementary-type-rules.ts

@@ -0,0 +1,44 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const computedElementaryTypeRules = [
+  { previous: -1, expected: TokenTypeId.computed },
+  {
+    previous: TokenTypeId.computed,
+    expected: [TokenTypeId._const, TokenTypeId.ElementaryType],
+  },
+  { previous: TokenTypeId._const, expected: TokenTypeId.ElementaryType },
+  { previous: TokenTypeId.ElementaryType, expected: TokenTypeId.Identifier },
+  // const must have an assignment
+  {
+    previous: [
+      TokenTypeId.computed,
+      TokenTypeId._const,
+      TokenTypeId.ElementaryType,
+      TokenTypeId.Identifier,
+    ],
+    expected: TokenTypeId.Assignment,
+  },
+  // non-const has optional assignment
+  {
+    previous: [
+      TokenTypeId.computed,
+      TokenTypeId.ElementaryType,
+      TokenTypeId.Identifier,
+    ],
+    expected: [TokenTypeId.Assignment, TokenTypeId.Semicolon],
+  },
+  {
+    previous: TokenTypeId.Assignment,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.Semicolon,
+      ...binaryOperatorTypes,
+    ],
+  })),
+];

package/src/completion/rules/default-clause-rules.ts

@@ -0,0 +1,23 @@
+import { statementTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const defaultClauseRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId._default,
+  },
+  {
+    previous: TokenTypeId._default,
+    expected: TokenTypeId.Colon,
+  },
+  {
+    previous: TokenTypeId.Colon,
+    expected: statementTypes,
+  },
+  ...statementTypes.map((statementType) => ({
+    previous: statementType,
+    expected: statementTypes,
+  })),
+];

package/src/completion/rules/do-statement-rules.ts

@@ -0,0 +1,38 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const doStatementRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId._do,
+  },
+  {
+    previous: TokenTypeId._do,
+    expected: TokenTypeId.CompoundStatement,
+  },
+  {
+    previous: TokenTypeId.CompoundStatement,
+    expected: TokenTypeId._while,
+  },
+  {
+    previous: TokenTypeId._while,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.CloseParenthesis,
+      ...binaryOperatorTypes,
+    ],
+  })),
+  {
+    previous: TokenTypeId.CloseParenthesis,
+    expected: TokenTypeId.Semicolon,
+  },
+];

package/src/completion/rules/elementary-type-definition-rules.ts

@@ -0,0 +1,62 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const elementaryTypeDefinitionRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.reserved,
+      TokenTypeId.legacy,
+      TokenTypeId._const,
+      TokenTypeId.AlignedModifier,
+      TokenTypeId.ElementaryType,
+    ],
+  },
+  {
+    previous: TokenTypeId.reserved,
+    expected: [
+      TokenTypeId._const,
+      TokenTypeId.AlignedModifier,
+      TokenTypeId.ElementaryType,
+    ],
+  },
+  {
+    previous: TokenTypeId._const,
+    expected: [TokenTypeId.AlignedModifier, TokenTypeId.ElementaryType],
+  },
+  {
+    previous: TokenTypeId.AlignedModifier,
+    expected: TokenTypeId.ElementaryType,
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.LengthAttribute,
+  },
+  {
+    previous: TokenTypeId.LengthAttribute,
+    expected: [TokenTypeId.LookAhead, TokenTypeId.Identifier],
+  },
+  {
+    previous: TokenTypeId.LookAhead,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: [TokenTypeId.Assignment, TokenTypeId.Semicolon],
+  },
+  {
+    previous: TokenTypeId.Assignment,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: [TokenTypeId.Assignment, expressionType],
+    expected: [
+      TokenTypeId.RangeOperator,
+      TokenTypeId.Semicolon,
+      ...binaryOperatorTypes,
+    ],
+  })),
+  { previous: TokenTypeId.RangeOperator, expected: expressionTypes },
+];

package/src/completion/rules/elementary-type-output-value-rules.ts

@@ -0,0 +1,13 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const elementaryTypeOutputValueRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.ElementaryType,
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.LengthAttribute,
+  },
+];

package/src/completion/rules/elementary-type-rules.ts

@@ -0,0 +1,18 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const elementaryTypeRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.int,
+      TokenTypeId.unsigned,
+      TokenTypeId.float,
+      TokenTypeId.bit,
+    ],
+  },
+  {
+    previous: TokenTypeId.unsigned,
+    expected: TokenTypeId.int,
+  },
+];

package/src/completion/rules/expandable-modifier-rules.ts

@@ -0,0 +1,21 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const expandableModifierRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.expandable,
+  },
+  {
+    previous: TokenTypeId.expandable,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: TokenTypeId.IntegerLiteral,
+  },
+  {
+    previous: TokenTypeId.IntegerLiteral,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+];

package/src/completion/rules/explicit-array-dimension-rules.ts

@@ -0,0 +1,22 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const explicitArrayDimensionRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenBracket,
+  },
+  {
+    previous: TokenTypeId.OpenBracket,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.CloseBracket,
+      ...binaryOperatorTypes,
+    ],
+  })),
+];

package/src/completion/rules/expression-statement-rules.ts

@@ -0,0 +1,22 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const expressionStatementRules = [
+  {
+    previous: -1,
+    expected: [...expressionTypes, TokenTypeId.AssignmentExpression],
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.Semicolon,
+      ...binaryOperatorTypes,
+    ],
+  })),
+  {
+    previous: TokenTypeId.AssignmentExpression,
+    expected: TokenTypeId.Semicolon,
+  },
+];

package/src/completion/rules/extended-class-id-range-rules.ts

@@ -0,0 +1,17 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const extendedClassIdRangeRules = [
+  {
+    previous: -1,
+    expected: [TokenTypeId.ClassId, TokenTypeId.ClassIdRange],
+  },
+  {
+    previous: TokenTypeId.ClassId,
+    expected: TokenTypeId.Comma,
+  },
+  {
+    previous: TokenTypeId.ClassIdRange,
+    expected: TokenTypeId.Comma,
+  },
+];

package/src/completion/rules/extends-modifier-rules.ts

@@ -0,0 +1,17 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const extendsModifierRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId._extends,
+  },
+  {
+    previous: TokenTypeId._extends,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: TokenTypeId.ParameterValueList,
+  },
+];

package/src/completion/rules/for-statement-rules.ts

@@ -0,0 +1,51 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const forStatementRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId._for,
+  },
+  {
+    previous: TokenTypeId._for,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: [
+      TokenTypeId.AssignmentExpression,
+      TokenTypeId.ComputedElementaryTypeDefinition,
+      TokenTypeId.Semicolon,
+    ],
+  },
+  {
+    previous: TokenTypeId.ComputedElementaryTypeDefinition,
+    expected: TokenTypeId.Semicolon,
+  },
+  {
+    previous: TokenTypeId.Semicolon,
+    expected: [
+      TokenTypeId.AssignmentExpression,
+      ...expressionTypes,
+      TokenTypeId.CloseParenthesis,
+    ],
+  },
+  ...expressionTypes.map((expressionType) => (
+    {
+      previous: [
+        TokenTypeId.AssignmentExpression,
+        expressionType,
+      ],
+      expected: [
+        TokenTypeId.Semicolon,
+        ...binaryOperatorTypes,
+      ],
+    }
+  )),
+  {
+    previous: TokenTypeId.CloseParenthesis,
+    expected: TokenTypeId.CompoundStatement,
+  },
+];

package/src/completion/rules/if-statement-rules.ts

@@ -0,0 +1,42 @@
+import {
+  binaryOperatorTypes,
+  expressionTypes,
+  statementTypes,
+} from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const ifStatementRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId._if,
+  },
+  {
+    previous: TokenTypeId._if,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.CloseParenthesis,
+      ...binaryOperatorTypes,
+    ],
+  })),
+  {
+    previous: TokenTypeId.CloseParenthesis,
+    expected: statementTypes,
+  },
+  ...statementTypes.map((statementType) => ({
+    previous: statementType,
+    expected: TokenTypeId._else,
+  })),
+  {
+    previous: TokenTypeId._else,
+    expected: statementTypes,
+  },
+];

package/src/completion/rules/implicit-array-dimension-rules.ts

@@ -0,0 +1,21 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const implicitArrayDimensionRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenBracket,
+  },
+  {
+    previous: TokenTypeId.OpenBracket,
+    expected: [TokenTypeId.IntegerLiteral, TokenTypeId.CloseBracket],
+  },
+  {
+    previous: [TokenTypeId.OpenBracket, TokenTypeId.IntegerLiteral],
+    expected: TokenTypeId.RangeOperator,
+  },
+  {
+    previous: [TokenTypeId.RangeOperator, TokenTypeId.IntegerLiteral],
+    expected: TokenTypeId.CloseBracket,
+  },
+];

package/src/completion/rules/length-attribute-rules.ts

@@ -0,0 +1,19 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const lengthAttributeRules = [
+  { previous: -1, expected: TokenTypeId.OpenParenthesis },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.CloseParenthesis,
+      ...binaryOperatorTypes,
+    ],
+  })),
+];

package/src/completion/rules/lengthof-expression-rules.ts

@@ -0,0 +1,23 @@
+import { expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const lengthofExpressionRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.lengthof,
+  },
+  {
+    previous: TokenTypeId.lengthof,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: TokenTypeId.CloseParenthesis,
+  })),
+];

package/src/completion/rules/map-declaration-rules.ts

@@ -0,0 +1,45 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const mapDeclarationRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.map,
+  },
+  {
+    previous: TokenTypeId.map,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.map, TokenTypeId.Identifier],
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: [TokenTypeId.ElementaryType, TokenTypeId.Identifier],
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.CloseParenthesis,
+    expected: TokenTypeId.OpenBrace,
+  },
+  {
+    previous: TokenTypeId.OpenBrace,
+    expected: TokenTypeId.MapEntry,
+  },
+  {
+    previous: TokenTypeId.MapEntry,
+    expected: [TokenTypeId.Comma, TokenTypeId.CloseBrace],
+  },
+  {
+    previous: TokenTypeId.Comma,
+    expected: TokenTypeId.MapEntry,
+  },
+];

package/src/completion/rules/map-definition-rules.ts

@@ -0,0 +1,46 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const mapDefinitionRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.reserved,
+      TokenTypeId.legacy,
+      TokenTypeId.ElementaryType,
+      TokenTypeId.Identifier,
+    ],
+  },
+  {
+    previous: TokenTypeId.reserved,
+    expected: [TokenTypeId.ElementaryType, TokenTypeId.Identifier],
+  },
+  {
+    previous: TokenTypeId.legacy,
+    expected: [TokenTypeId.ElementaryType, TokenTypeId.Identifier],
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.RelationalLessThan,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: TokenTypeId.RelationalLessThan,
+  },
+  {
+    previous: TokenTypeId.RelationalLessThan,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.RelationalLessThan, TokenTypeId.Identifier],
+    expected: TokenTypeId.RelationalGreaterThan,
+  },
+  {
+    previous: [TokenTypeId.Identifier, TokenTypeId.RelationalGreaterThan],
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.RelationalGreaterThan, TokenTypeId.Identifier],
+    expected: TokenTypeId.Semicolon,
+  },
+];

package/src/completion/rules/map-entry-rules.ts

@@ -0,0 +1,17 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const mapEntryRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.BinaryLiteral,
+  },
+  {
+    previous: TokenTypeId.BinaryLiteral,
+    expected: TokenTypeId.Comma,
+  },
+  {
+    previous: TokenTypeId.Comma,
+    expected: TokenTypeId.AggregateOutputValue,
+  },
+];

package/src/completion/rules/parameter-list-rules.ts

@@ -0,0 +1,21 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const parameterListRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: TokenTypeId.Parameter,
+  },
+  {
+    previous: TokenTypeId.Parameter,
+    expected: [TokenTypeId.Comma, TokenTypeId.CloseParenthesis],
+  },
+  {
+    previous: TokenTypeId.Comma,
+    expected: TokenTypeId.Parameter,
+  },
+];

package/src/completion/rules/parameter-rules.ts

@@ -0,0 +1,17 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const parameterRules = [
+  {
+    previous: -1,
+    expected: [TokenTypeId.Identifier, TokenTypeId.ElementaryType],
+  },
+  {
+    previous: [-1, TokenTypeId.Identifier],
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.Identifier,
+  },
+];

package/src/completion/rules/parameter-value-list-rules.ts

@@ -0,0 +1,27 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const parameterValueListRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenParenthesis,
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: expressionTypes,
+  },
+  {
+    previous: TokenTypeId.Comma,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.Comma,
+      TokenTypeId.CloseParenthesis,
+      ...binaryOperatorTypes,
+    ],
+  })),
+];

package/src/completion/rules/partial-array-dimension-rules.ts

@@ -0,0 +1,33 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const partialArrayDimensionRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenBracket,
+  },
+  {
+    previous: [-1, TokenTypeId.OpenBracket],
+    expected: TokenTypeId.OpenBracket,
+  },
+  {
+    previous: [TokenTypeId.OpenBracket, TokenTypeId.OpenBracket],
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.CloseBracket,
+      ...binaryOperatorTypes,
+    ],
+  })),
+  ...expressionTypes.map((expressionType) => ({
+    previous: [expressionType, TokenTypeId.CloseBracket],
+    expected: [
+      TokenTypeId.CloseBracket,
+      ...binaryOperatorTypes,
+    ],
+  })),
+];