@mpeggroup/mpeg-sdl-parser 4.0.0

package/tests/analyser/test-cases/map_declaration.txt

@@ -0,0 +1,89 @@
+# Elementary type output
+
+map offsets (int) {0b00,{1024},0b00,{1024}}
+
+==>
+
+[GLOBAL]:
+  offsets MAP INTEGER
+  [MAP] offsets:
+
+errors:
+
+SEMANTIC ERROR: Input values in a map declaration must be unique.
+
+# Class output
+
+map barMap (Bar) {0b00,{1024}}
+
+==>
+
+[GLOBAL]:
+  barMap MAP (class: Bar)
+  [MAP] barMap:
+
+errors:
+
+SEMANTIC ERROR: Class: Bar is not declared
+
+
+# Escape codes
+
+map offsets (int) {0b00,{int(6)}}
+
+==>
+
+[GLOBAL]:
+  offsets MAP INTEGER
+  [MAP] offsets:
+
+
+# Duplicate input values
+
+map offsets (int) {0b00,{1024},0b01,{2048},0b00,{4096}}
+
+==>
+
+[GLOBAL]:
+  offsets MAP INTEGER
+  [MAP] offsets:
+
+errors:
+
+SEMANTIC ERROR: Input values in a map declaration must be unique.
+
+
+# Output value count mismatch for elementary type
+
+map offsets (int) {0b00,{1024,2048}}
+
+==>
+
+[GLOBAL]:
+  offsets MAP INTEGER
+  [MAP] offsets:
+
+errors:
+
+SEMANTIC ERROR: The type and number of constituent values within the aggregate output values of the map declaration must match the corresponding constituent types within the map's output_type.
+
+
+# Map with parsable class output
+
+class Bar {int(8) x;}
+map barMap (Bar) {0b00,{1024}}
+
+==>
+
+[GLOBAL]:
+  Bar CLASS
+  barMap MAP (class: Bar)
+  [CLASS] Bar:
+    members:
+      x VARIABLE INTEGER
+    x VARIABLE INTEGER
+  [MAP] barMap:
+
+warnings:
+
+SEMANTIC WARNING: Declaring a map with an output_value consisting of a class with parsable members will result in undefined behaviour.

package/tests/analyser/test-cases/map_definition.txt

@@ -0,0 +1,35 @@
+# Reserved with elementary type output
+
+map Offsets (int) {0b00,{1024}}
+class A {reserved unsigned int<Offsets> offset;}
+
+==>
+
+[GLOBAL]:
+  Offsets MAP INTEGER
+  A CLASS
+  [MAP] Offsets:
+  [CLASS] A:
+    members:
+      offset VARIABLE INTEGER (map: Offsets)
+    offset VARIABLE INTEGER (map: Offsets)
+
+
+# Legacy with class output
+
+class B {}
+map MapB (B) {0b00,{1024}}
+class A {legacy B<MapB> b;}
+
+==>
+
+[GLOBAL]:
+  B CLASS
+  MapB MAP (class: B)
+  A CLASS
+  [CLASS] B:
+  [MAP] MapB:
+  [CLASS] A:
+    members:
+      b VARIABLE (class: B) (map: MapB)
+    b VARIABLE (class: B) (map: MapB)

package/tests/analyser/test-cases/number_literal.txt

@@ -0,0 +1,31 @@
+# Integer literal
+
+computed int a=1;
+
+==>
+
+[GLOBAL]:
+  a VARIABLE INTEGER COMPUTED
+
+errors:
+
+SEMANTIC ERROR: The only items that may be present in global scope are: constant computed elementary variable definitions, map declarations, class declarations.
+
+
+# Signed zero floating point placeholder
+
+class A {float(32) a = 3.14;}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE FLOATING_POINT
+    a VARIABLE FLOATING_POINT
+
+warnings:
+
+SEMANTIC WARNING: Type coercion required for 'a' value: expected FLOATING_POINT, got DECIMAL
+

package/tests/analyser/test-cases/parameter_list.txt

@@ -0,0 +1,16 @@
+# Valid parameter syntax - no string parameters possible in current SDL grammar
+
+class A(int a) {}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER
+    a VARIABLE INTEGER
+
+errors:
+
+SEMANTIC ERROR: A parameter in a parameter list must be referenced within the class declaration.

package/tests/analyser/test-cases/scopes.txt

@@ -0,0 +1,239 @@
+# Global scope access
+
+computed const int a = 1;
+
+class A {
+    int(3) b[a];
+}
+
+
+==>
+
+[GLOBAL]:
+  a VARIABLE INTEGER COMPUTED CONST
+  A CLASS
+  [CLASS] A:
+    members:
+      b VARIABLE INTEGER []
+    b VARIABLE INTEGER []
+
+
+# Outer scope access
+
+class A {
+    computed int a = 1;
+    if (a == 1) {
+        a--;
+    }
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] COMPOUND:
+
+
+# Nested scope visibility override
+
+class A {
+    computed int a = 1;
+    if (a == 1) {
+        computed float a = 2;
+        if (a == 2) {
+            a++;
+            // a == 3
+        }
+        // a == 3
+    }
+    // a == 1
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] COMPOUND:
+      a VARIABLE FLOATING_POINT COMPUTED
+      [BLOCK] COMPOUND:
+
+warnings:
+
+SEMANTIC WARNING: Type coercion required for 'a' value: expected FLOATING_POINT, got INTEGER
+SEMANTIC WARNING: Different types in binary expression, coercion required: FLOATING_POINT vs INTEGER
+SEMANTIC WARNING: Non-integer increment operand, coercion required: FLOATING_POINT
+
+
+# Duplicate variable in IF conditional branches with braces
+
+class A {
+    computed int a = 1;
+    if (a == 1) {
+        int(2) b;
+    }
+    else {
+        int(3) b;
+    }
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+      b VARIABLE INTEGER (branch: COMPOUND)
+      b VARIABLE INTEGER (branch: COMPOUND#1)
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] COMPOUND:
+      b VARIABLE INTEGER
+    [BLOCK] COMPOUND#1:
+      b VARIABLE INTEGER
+
+warnings:
+
+SEMANTIC WARNING: This if-then-else clauses may result in duplicate class member variables being declared simultaneously.
+
+
+# Duplicate variable in IF conditional branches without braces
+
+class A {
+    computed int a = 1;
+    if (a == 1)
+        int(2) b;
+    else
+        int(3) b;
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+      b VARIABLE INTEGER (branch: COMPOUND)
+      b VARIABLE INTEGER (branch: COMPOUND#1)
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] COMPOUND:
+      b VARIABLE INTEGER
+    [BLOCK] COMPOUND#1:
+      b VARIABLE INTEGER
+
+warnings:
+
+SEMANTIC WARNING: This if-then-else clauses may result in duplicate class member variables being declared simultaneously.
+
+
+# Duplicate variable in SWITCH conditional branches
+
+class A {
+    computed int a = 1;
+    switch (a) {
+        case 1:
+            int(2) b;
+            break;
+        default:
+            int(3) b;
+    }
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+      b VARIABLE INTEGER (branch: SWITCH/COMPOUND)
+      b VARIABLE INTEGER (branch: SWITCH/COMPOUND#1)
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+        b VARIABLE INTEGER
+      [BLOCK] COMPOUND#1:
+        b VARIABLE INTEGER
+
+warnings:
+
+SEMANTIC WARNING: This switch statement may result in duplicate class member variables being declared simultaneously.
+
+# Illegal duplicate variable with different type in IF conditional branches
+
+
+class A {
+    computed int a = 1;
+    if (a == 1) {
+        int(2) b;
+    }
+    else {
+        float(3) b;
+    }
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+      b VARIABLE INTEGER (branch: COMPOUND)
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] COMPOUND:
+      b VARIABLE INTEGER
+    [BLOCK] COMPOUND#1:
+      b VARIABLE FLOATING_POINT
+
+errors:
+
+SEMANTIC ERROR: Duplicate member variable: b conflicts with type defined in different conditional branch within scope: A
+
+warnings:
+
+SEMANTIC WARNING: This if-then-else clauses may result in duplicate class member variables being declared simultaneously.
+
+# Illegal duplicate variable with different type in SWITCH conditional branches
+
+class A {
+    computed int a = 1;
+    switch (a) {
+        case 1:
+            int(2) b;
+            break;
+        default:
+            float(3) b;
+    }
+}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      a VARIABLE INTEGER COMPUTED
+      b VARIABLE INTEGER (branch: SWITCH/COMPOUND)
+    a VARIABLE INTEGER COMPUTED
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+        b VARIABLE INTEGER
+      [BLOCK] COMPOUND#1:
+        b VARIABLE FLOATING_POINT
+
+errors:
+
+SEMANTIC ERROR: Duplicate member variable: b conflicts with type defined in different conditional branch within scope: A
+
+warnings:
+
+SEMANTIC WARNING: This switch statement may result in duplicate class member variables being declared simultaneously.

package/tests/analyser/test-cases/specification.txt

@@ -0,0 +1,28 @@
+# Global scope with valid items
+
+computed const int a=1;
+map offsets (int) {0b00,{1024}}
+class A{}
+
+==>
+
+[GLOBAL]:
+  a VARIABLE INTEGER COMPUTED CONST
+  offsets MAP INTEGER
+  A CLASS
+  [MAP] offsets:
+  [CLASS] A:
+
+
+# Non-const computed at global scope
+
+computed int a=1;
+
+==>
+
+[GLOBAL]:
+  a VARIABLE INTEGER COMPUTED
+
+errors:
+
+SEMANTIC ERROR: The only items that may be present in global scope are: constant computed elementary variable definitions, map declarations, class declarations.

package/tests/analyser/test-cases/string_definition.txt

@@ -0,0 +1,40 @@
+# String definition
+
+class A {utf8string foo;}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      foo VARIABLE UCS
+    foo VARIABLE UCS
+
+
+# utf8list with literal
+
+class A {utf8list foo=u"hello world";}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      foo VARIABLE UCS
+    foo VARIABLE UCS
+
+
+# base64 string literal
+
+class A {base64string foo="aGVsbG8K";}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    members:
+      foo VARIABLE BASIC
+    foo VARIABLE BASIC

package/tests/analyser/test-cases/switch_statement.txt

@@ -0,0 +1,96 @@
+# Single case
+
+class A {switch(i){case 1:break;}}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+
+errors:
+
+SEMANTIC ERROR: Identifier: i is not declared
+
+
+# Single case with braces
+
+class A {switch(i){case 1:{break;}}}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+
+errors:
+
+SEMANTIC ERROR: Identifier: i is not declared
+
+
+# Multiple cases and default
+
+class A {switch(i){case 1:break;case 2:{i++;break;}default:i--;}}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+      [BLOCK] COMPOUND#1:
+      [BLOCK] COMPOUND#2:
+
+errors:
+
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared
+
+
+# Multiple cases with no break and default
+
+class A {switch(i){case 1:i++;case 2:i++;default:i--;}}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+      [BLOCK] COMPOUND#1:
+      [BLOCK] COMPOUND#2:
+
+errors:
+
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared
+
+
+# Multiple cases with no break and no expression and default
+
+class A {switch(i){case 1:case 2:i++;default:i--;}}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    [BLOCK] SWITCH:
+      [BLOCK] COMPOUND:
+      [BLOCK] COMPOUND#1:
+      [BLOCK] COMPOUND#2:
+
+errors:
+
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared

package/tests/analyser/test-cases/while_statement.txt

@@ -0,0 +1,16 @@
+# Simple
+
+class A {while (i<9) {i++;}}
+
+==>
+
+[GLOBAL]:
+  A CLASS
+  [CLASS] A:
+    [BLOCK] WHILE:
+      [BLOCK] COMPOUND:
+
+errors:
+
+SEMANTIC ERROR: Identifier: i is not declared
+SEMANTIC ERROR: Identifier: i is not declared

package/tests/analyser/util/symbol-table-utils.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { SymbolKind, SymbolTable } from "../../../src/analyser/symbol-table.ts";
+import { getSymbolTableString } from "../../../src/analyser/util/symbol-table-utils.ts";
+import { Identifier } from "../../../src/ast/node/identifier.ts";
+import { TokenKind } from "../../../src/ast/node/enum/token-kind.ts";
+import { Token } from "../../../src/ast/node/token.ts";
+
+const node = new Identifier(
+  "foo",
+  new Token(TokenKind.IDENTIFIER, "foo", { row: 1, column: 1, position: 0 }),
+);
+
+describe("Symbol Table Utils Tests", () => {
+  test("toString outputs human-readable format", () => {
+    const table = new SymbolTable();
+
+    table.addSymbol({
+      node,
+      name: "MyClass",
+      kind: SymbolKind.CLASS,
+      attributes: {},
+      location: { row: 1, column: 1, position: 0 },
+    });
+    table.addSymbol({
+      node,
+      name: "MyMap",
+      kind: SymbolKind.MAP,
+      attributes: {},
+      location: { row: 1, column: 1, position: 0 },
+    });
+
+    const output = getSymbolTableString(table);
+
+    expect(output).toContain("[GLOBAL]");
+    expect(output).toContain("MyClass CLASS");
+    expect(output).toContain("MyMap MAP");
+  });
+
+  test("toString includes nested scopes", () => {
+    const table = new SymbolTable();
+
+    table.addSymbol({
+      node,
+      name: "GlobalClass",
+      kind: SymbolKind.CLASS,
+      attributes: {},
+      location: { row: 1, column: 1, position: 0 },
+    });
+    table.enterClassScope("MyClass");
+    table.addSymbol({
+      node,
+      name: "param1",
+      kind: SymbolKind.VARIABLE,
+      attributes: {},
+      location: { row: 2, column: 1, position: 10 },
+    });
+
+    const output = getSymbolTableString(table);
+
+    expect(output).toContain("[GLOBAL]");
+    expect(output).toContain("GlobalClass CLASS");
+    expect(output).toContain("[CLASS] MyClass:");
+    expect(output).toContain("param1 VARIABLE");
+  });
+});