@mpeggroup/mpeg-sdl-parser 4.0.0

package/tests/sample-specifications/invalid.sdl

@@ -0,0 +1,24 @@
+// repeated packets in bitstream
+class transport_packet {
+  unsigned int(8)  sync_byte = 0x47;
+  bit(1)           transport_error_indicator;
+  bit(1)           payload_unit_start_indicator;
+  bit           transport_priority;
+  unsigned int(13) PID;
+  bit(2)           transport_scrambling_control;
+  bit(2)           adaptation_field_control;
+
+  unsigned int N = 184;
+
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - 1 - data.adaptation_field_length;
+  }
+
+  if (adaptation_ field_control == 0b01 || adaptation_field_control == 0b11) {
+    bit(8) data_byte[N];
+  }
+}
+// until EOF

package/tests/sample-specifications/prettified-invalid.sdl

@@ -0,0 +1,28 @@
+// repeated packets in bitstream
+class transport_packet {
+  unsigned int(8) sync_byte = 0x47;
+  bit(1) transport_error_indicator;
+  bit(1) payload_unit_start_indicator;
+  bit
+  transport_priority;
+  unsigned int(13) PID;
+  bit(2) transport_scrambling_control;
+  bit(2) adaptation_field_control;
+
+  unsigned int
+  N = 184;
+
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - 1 - data.adaptation_field_length;
+  }
+
+  if (adaptation_
+
+  field_control == 0b01 || adaptation_field_control == 0b11)
+  {
+    bit(8) data_byte[N];
+  }
+} // until EOF

package/tests/sample-specifications/prettified-various-elements-narrow.sdl

@@ -0,0 +1,97 @@
+// repeated packets in bitstream
+//
+// should be declared in a wrapping Bitstream class
+class transport_packet {
+  unsigned int(8) sync_byte = 0x47;
+  bit(1) transport_error_indicator;
+  bit(1) payload_unit_start_indicator;
+  bit(1) transport_priority;
+  unsigned int(13
+    // odd but valid comment position
+  ) PID;
+  bit(2)* transport_scrambling_control;
+  aligned(16) bit(2) adaptation_field_control =
+    0x0000.0000;
+
+  computed unsigned int N = 184;
+  computed float test = 1e1;
+  utf8string foo = u"bar" u"foo";
+  base64string foo2 = "BAR";
+  computed int dummy1 = 'ABCD' '01AB';
+  computed int dummy2 =
+    lengthof(transport_scrambling_control) +
+    N++;
+  if (adaptation_field_control == 0b10 ||
+    adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - // and another
+      1 // and another odd comment
+      - data.adaptation_field_length;
+  }
+  if (adaptation_field_control == 0b01 ||
+    adaptation_field_control == 0b11) {
+    bit(8) data_byte[N];
+  }
+}
+
+map Offsets (int) {
+  0b00, { 1024 },
+  0b01, { 2048 }
+}
+
+expandable(20) class odd(int a, B b)
+  extends odder(a) : bit(2) id = 2 {
+  reserved unsigned int(Offsets) offset;
+  computed int myArray[2];
+  computed int i = 1;
+  Strange s(1, 2);
+  while (i < 2) {
+    i++;
+  }
+  i = 2;
+  do {
+    i--;
+  } while (i > 0);
+  if (1) {
+    i++;
+  }
+  else if (1) {
+    i--;
+  }
+  else {
+    i++;
+  }
+  if (1)
+    if (2)
+      i--;
+    else
+      i++;
+  switch (i) {
+    case 0:
+    case 1:
+      // nothing
+      break;
+    case 2: { // nothing
+      break;
+    }
+    default:
+      i++;
+    // foo
+  }
+}
+
+class odd2(int a) {
+  computed int x = 0;
+  for (computed int j = 0; j < 2; j++) {
+    x++;
+  }
+  for (; j > 0; j--) {
+  }
+}
+
+class A {
+  MyClass a[1..3];
+  reserved MyClass b[3][[2]];
+} // end of file

package/tests/sample-specifications/prettified-various-elements.sdl

@@ -0,0 +1,90 @@
+// repeated packets in bitstream
+//
+// should be declared in a wrapping Bitstream class
+class transport_packet {
+  unsigned int(8) sync_byte = 0x47;
+  bit(1) transport_error_indicator;
+  bit(1) payload_unit_start_indicator;
+  bit(1) transport_priority;
+  unsigned int(13 // odd but valid comment position
+  ) PID;
+  bit(2)* transport_scrambling_control;
+  aligned(16) bit(2) adaptation_field_control = 0x0000.0000;
+
+  computed unsigned int N = 184;
+  computed float test = 1e1;
+  utf8string foo = u"bar" u"foo";
+  base64string foo2 = "BAR";
+  computed int dummy1 = 'ABCD' '01AB';
+  computed int dummy2 = lengthof(transport_scrambling_control) + N++;
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - // and another
+      1 // and another odd comment
+      - data.adaptation_field_length;
+  }
+  if (adaptation_field_control == 0b01 || adaptation_field_control == 0b11) {
+    bit(8) data_byte[N];
+  }
+}
+
+map Offsets (int) {
+  0b00, { 1024 },
+  0b01, { 2048 }
+}
+
+expandable(20) class odd(int a, B b) extends odder(a) : bit(2) id = 2 {
+  reserved unsigned int(Offsets) offset;
+  computed int myArray[2];
+  computed int i = 1;
+  Strange s(1, 2);
+  while (i < 2) {
+    i++;
+  }
+  i = 2;
+  do {
+    i--;
+  } while (i > 0);
+  if (1) {
+    i++;
+  }
+  else if (1) {
+    i--;
+  }
+  else {
+    i++;
+  }
+  if (1)
+    if (2)
+      i--;
+    else
+      i++;
+  switch (i) {
+    case 0:
+    case 1:
+      // nothing
+      break;
+    case 2: { // nothing
+      break;
+    }
+    default:
+      i++;
+    // foo
+  }
+}
+
+class odd2(int a) {
+  computed int x = 0;
+  for (computed int j = 0; j < 2; j++) {
+    x++;
+  }
+  for (; j > 0; j--) {
+  }
+}
+
+class A {
+  MyClass a[1..3];
+  reserved MyClass b[3][[2]];
+} // end of file

package/tests/sample-specifications/sample.sdl

@@ -0,0 +1,24 @@
+// repeated packets in bitstream
+class transport_packet {
+  unsigned int(8)  sync_byte = 0x47;
+  bit(1)           transport_error_indicator;
+  bit(1)           payload_unit_start_indicator;
+  bit(1)           transport_priority;
+  unsigned int(13) PID;
+  bit(2)           transport_scrambling_control;
+  bit(2)           adaptation_field_control;
+
+  computed unsigned int N = 184;
+
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - 1 - data.adaptation_field_length;
+  }
+
+  if (adaptation_field_control == 0b01 || adaptation_field_control == 0b11) {
+    bit(8) data_byte[N];
+  }
+}
+// until EOF

package/tests/sample-specifications/various-elements.sdl

@@ -0,0 +1,88 @@
+// repeated packets in bitstream
+// 
+// should be declared in a wrapping Bitstream class
+class transport_packet {
+  unsigned int(8)  sync_byte = 0x47;
+  bit(1)           transport_error_indicator;
+  bit(1)           payload_unit_start_indicator;
+  bit(1)           transport_priority;
+  unsigned int(13 // odd but valid comment position
+  ) PID;
+  bit(2)*           transport_scrambling_control;
+  aligned(16) bit(2)           adaptation_field_control = 0x0000.0000;
+  
+  computed unsigned int N = 184;
+  computed float test = 1e1;
+  utf8string foo = u"bar" u"foo" u"";
+  base64string foo2 = "BAR";
+  computed int dummy1 = 'ABCD' '' '01AB';
+  computed int dummy2 = lengthof(transport_scrambling_control) + N++;
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) 
+  
+  {
+adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - // and another
+    1 // and another odd comment
+- data.adaptation_field_length;
+  } if (adaptation_field_control == 0b01 || adaptation_field_control == 0b11) { bit(8) data_byte[N]; }
+}
+
+map Offsets (int) {0b00,{1024},0b01,{2048}}
+
+expandable(20) class odd(int a, B b) extends odder(a): bit(2) id = 2 
+
+{
+  reserved unsigned int(Offsets) offset;
+  computed int myArray[2];
+  computed int i = 1;
+  Strange s(1, 2);
+  while (i < 2) {
+    i++;
+  }
+  i = 2;
+  do {
+    i--;
+  } while( i > 0);
+  if (1) {
+    i++;
+  }
+  else if (1) {
+    i--;  }
+  else { i++; }
+  if (1) 
+    if (2)
+    i--;
+    else 
+    i++;
+  switch (i) {
+    case 0:
+   case 1:
+      
+      // nothing
+      break;
+   case 2: 
+      
+      { // nothing
+      break;
+      }
+    default:
+      i++;
+      //     foo
+  }
+ }
+ class odd2(int a) {
+  computed int x = 0;
+  for (computed int j=0;j<2;j++) {
+   x++;
+  }
+  for (;j>0;j--) {
+  }
+ }
+
+class A {
+MyClass a[1..3];
+reserved MyClass b[3][[2]];
+}
+// end of file

package/tests/util/logger.test.ts

@@ -0,0 +1,36 @@
+import { describe, test } from "bun:test";
+import getLogger from "../../src/util/logger.ts";
+
+describe("Logger Tests", () => {
+  test("Can acquire a logger", () => {
+    const logger = getLogger("logger test 1");
+
+    logger.debug("foobar");
+  });
+
+  test("Logging with args ", () => {
+    const logger = getLogger("logger test 2");
+
+    logger.debug("foobar with args: %s", "yes");
+  });
+
+  test("Logging with different length logging names ", () => {
+    const logger1 = getLogger("logger test 3 x");
+    const logger2 = getLogger("logger test 3 xxx");
+
+    logger1.debug("foobar");
+    logger2.debug("foobar");
+    logger1.debug("foobar with args: %s", "yes");
+    logger2.debug("foobar with args: %s", "yes");
+  });
+
+  test("Logging at all levels ", () => {
+    const logger = getLogger("logger test 4");
+
+    logger.trace("foobar");
+    logger.debug("foobar");
+    logger.info("foobar");
+    logger.warn("foobar");
+    logger.error("foobar");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    "types": ["bun", "node"],
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}