From 60246d05f71c951fdbd69a7d9e59c8dcfca77c77 Mon Sep 17 00:00:00 2001
From: Nick Gasson <nick@nickg.me.uk>
Date: Thu, 9 Mar 2023 17:46:23 +0000
Subject: [PATCH] Add some tests for PSL dumper

---
 src/parse.c        | 22 ++++++++----------
 src/psl/psl-dump.c | 56 +++++++++++++++++++++++++++++++++++++++++++++-
 src/psl/psl-node.c |  2 +-
 test/test_psl.c    | 28 +++++++++++++++++++++++
 4 files changed, 93 insertions(+), 15 deletions(-)

diff --git a/src/parse.c b/src/parse.c
index 5668f6c2..358b7528 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -10028,17 +10028,12 @@ static psl_node_t p_psl_sere(void)
    // Boolean | Boolean Proc_Block | Sequence | SERE ; SERE | SERE : SERE
    //  | Compound_SERE
 
-   (void)p_psl_or_hdl_expression();
-
    psl_node_t p = psl_new(P_SERE);
 
-   switch (peek()) {
-   case tSEMI:
-      consume(tSEMI);
-      (void)p_psl_or_hdl_expression();
-   default:
-      break;
-   }
+   psl_add_operand(p, p_psl_or_hdl_expression());
+
+   while (optional(tSEMI))
+      psl_add_operand(p, p_psl_or_hdl_expression());
 
    psl_set_loc(p, CURRENT_LOC);
    return p;
@@ -10144,7 +10139,7 @@ static psl_node_t p_psl_fl_property(void)
 
          consume(tRSQUARE);
 
-         (void)p_psl_fl_property();
+         psl_set_value(p, p_psl_fl_property());
       }
       break;
 
@@ -10189,7 +10184,7 @@ static psl_node_t p_psl_fl_property(void)
          }
 
          consume(tLPAREN);
-         (void)p_psl_fl_property();
+         psl_set_value(p, p_psl_fl_property());
          consume(tRPAREN);
       }
       break;
@@ -10329,8 +10324,6 @@ static tree_t p_psl_clock_declaration(void)
    consume(tDEFAULT);
    consume(tCLOCK);
 
-   tree_t t = tree_new(T_PSL);
-
    consume(tIS);
 
    scan_as_hdl();
@@ -10343,6 +10336,9 @@ static tree_t p_psl_clock_declaration(void)
    psl_set_loc(p, CURRENT_LOC);
    psl_check(p);
 
+   tree_t t = tree_new(T_PSL);
+   tree_set_psl(t, p);
+
    tree_set_ident(t, ident_new("default clock"));
    tree_set_loc(t, CURRENT_LOC);
    return t;
diff --git a/src/psl/psl-dump.c b/src/psl/psl-dump.c
index 4d26ceb6..edd36266 100644
--- a/src/psl/psl-dump.c
+++ b/src/psl/psl-dump.c
@@ -36,11 +36,18 @@ static void psl_dump_always(psl_node_t p)
    psl_dump(psl_value(p));
 }
 
+static void psl_dump_never(psl_node_t p)
+{
+   print_syntax("#never ");
+   psl_dump(psl_value(p));
+}
+
 static void psl_dump_implication(psl_node_t p)
 {
    psl_dump(psl_operand(p, 0));
-   print_syntax(" -> ");
+   print_syntax(" -> (");
    psl_dump(psl_operand(p, 1));
+   print_syntax(")");
 }
 
 static void psl_dump_next(psl_node_t p)
@@ -49,6 +56,38 @@ static void psl_dump_next(psl_node_t p)
    psl_dump(psl_value(p));
 }
 
+static void psl_dump_next_a(psl_node_t p)
+{
+   print_syntax("#next_a ");
+   psl_dump(psl_value(p));
+}
+
+static void psl_dump_next_event(psl_node_t p)
+{
+   print_syntax("#next_event (");
+   psl_dump(psl_value(p));
+   print_syntax(")");
+}
+
+static void psl_dump_sere(psl_node_t p)
+{
+   print_syntax("{");
+
+   const int n = psl_operands(p);
+   for (int i = 0; i < n; i++) {
+      if (i > 0) print_syntax("; ");
+      psl_dump(psl_operand(p, i));
+   }
+
+   print_syntax("}");
+}
+
+static void psl_dump_clock_decl(psl_node_t p)
+{
+   print_syntax("#default #clock #is ");
+   vhdl_dump(psl_tree(p), 0);
+}
+
 void psl_dump(psl_node_t p)
 {
    switch (psl_kind(p)) {
@@ -58,6 +97,9 @@ void psl_dump(psl_node_t p)
    case P_ALWAYS:
       psl_dump_always(p);
       break;
+   case P_NEVER:
+      psl_dump_never(p);
+      break;
    case P_HDL_EXPR:
       vhdl_dump(psl_tree(p), 0);
       break;
@@ -67,6 +109,18 @@ void psl_dump(psl_node_t p)
    case P_NEXT:
       psl_dump_next(p);
       break;
+   case P_NEXT_A:
+      psl_dump_next_a(p);
+      break;
+   case P_NEXT_EVENT:
+      psl_dump_next_event(p);
+      break;
+   case P_CLOCK_DECL:
+      psl_dump_clock_decl(p);
+      break;
+   case P_SERE:
+      psl_dump_sere(p);
+      break;
    default:
       print_syntax("\n");
       fflush(stdout);
diff --git a/src/psl/psl-node.c b/src/psl/psl-node.c
index c10ffbed..74c96a97 100644
--- a/src/psl/psl-node.c
+++ b/src/psl/psl-node.c
@@ -51,7 +51,7 @@ static const imask_t has_map[P_LAST_PSL_KIND] = {
    (I_SUBKIND | I_VALUE),
 
    // P_SERE
-   (0),
+   (I_PARAMS),
 
    // P_IMPLICATION
    (I_SUBKIND | I_PARAMS),
diff --git a/test/test_psl.c b/test/test_psl.c
index 3e5ca65b..f6c1b30d 100644
--- a/test/test_psl.c
+++ b/test/test_psl.c
@@ -21,6 +21,7 @@
 #include "option.h"
 #include "phase.h"
 #include "psl/psl-node.h"
+#include "psl/psl-phase.h"
 #include "scan.h"
 
 START_TEST(test_parse1)
@@ -120,6 +121,32 @@ START_TEST(test_parse3)
 }
 END_TEST
 
+START_TEST(test_dump)
+{
+   opt_set_int(OPT_PSL_COMMENTS, 1);
+
+   input_from_file(TESTDIR "/psl/parse3.vhd");
+
+   tree_t a = parse_and_check(T_ENTITY, T_ARCH);
+
+   LOCAL_TEXT_BUF tb = tb_new();
+   capture_syntax(tb);
+
+   psl_dump(tree_psl(tree_stmt(a, 0)));
+   ck_assert_str_eq(tb_get(tb), "default clock is \"and\"(CLK'EVENT, \"=\"(CLK, '1'))");
+   tb_rewind(tb);
+
+   psl_dump(tree_psl(tree_stmt(a, 1)));
+   ck_assert_str_eq(tb_get(tb), "assert never B");
+   tb_rewind(tb);
+
+   psl_dump(tree_psl(tree_stmt(a, 6)));
+   ck_assert_str_eq(tb_get(tb), "assert {A; \"and\"(B, C)}");
+   tb_rewind(tb);
+
+   fail_if_errors();
+}
+
 Suite *get_psl_tests(void)
 {
    Suite *s = suite_create("psl");
@@ -129,6 +156,7 @@ Suite *get_psl_tests(void)
    tcase_add_test(tc_core, test_parse2);
    tcase_add_test(tc_core, test_sem1);
    tcase_add_test(tc_core, test_parse3);
+   tcase_add_test(tc_core, test_dump);
    suite_add_tcase(s, tc_core);
 
    return s;
-- 
2.39.2