BSR

A prototype of BSR is roughly finished.

1 files changed, 151 insertions, 0 deletions

diff --git a/src/test/check_bsr.c b/src/test/check_bsr.c
new file mode 100644
index 0000000..4a6ba4e
--- /dev/null
+++ b/src/test/check_bsr.c
@@ -0,0 +1,151 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "util.h"
+#include "str.h"
+#include "utf8.h"
+#include "grammar.h"
+#include "list.h"
+#include "../bsr.h"
+
+#define READ_INTO_CPA(N, U, I, VA, VI, CP) do {         \
+    U = new_utf8(N, 1);                                 \
+    I = get_info((str *)U, 0);                          \
+    VA = MYALLOC(NUM, 1);                               \
+    VI = 0;                                             \
+    for (NUM index = 0;                                 \
+         I.value >= 0 && index < str_length((str *) U); \
+         index += I.step, VI++) {                       \
+      I = get_info((str *)U, index);                    \
+      *(VA+VI) = I.value;                               \
+    }                                                   \
+    CP = MYALLOC(cpa, 1);                               \
+    CP->array = VA;                                     \
+    CP->size = VI;                                      \
+    add_to_list(names, CP);                             \
+    destroy_str((str *)U, 1);                           \
+  } while (0)
+
+#define READ_TNT_STRING(LEFT, FORMAT, LEN, ...) do {            \
+    tnt_string = new_tnt_string(FORMAT, LEN, __VA_ARGS__);      \
+    if (!tnt_string) {                                          \
+      fleprintf("left = %d, f = %s, l = %d, "                   \
+                "cannot create tnt string\n",                   \
+                LEFT, FORMAT, LEN);                             \
+      map_list(rules, destroy_rule_and_free_all);               \
+      destroy_list(rules, 0);                                   \
+      map_list(names, destroy_cpa_and_free_all);                \
+      destroy_list(names, 0);                                   \
+      return 1;                                                 \
+    }                                                           \
+    rule = new_rule(LEFT, tnt_string);                          \
+    add_to_list(rules, rule);                                   \
+  } while (0)
+
+
+int
+main(int UNUSED argc, char ** UNUSED argv)
+{
+  /* have a grammar for testing */
+  List *tnt_string = NULL;
+  Rule *rule = NULL;
+  List *rules = new_list();
+  List *names = new_list();
+
+  char *name = MYALLOC(char, 2);
+  *(name+1) = 0;
+  *name = 'E';
+
+  utf8* uname = NULL;
+
+  str_info info = EMPTY_STR_INFO;
+
+  NUM *varray = NULL;
+  NUM vindex = 0;
+  cpa *cpap = NULL;
+
+  READ_INTO_CPA(name, uname, info, varray, vindex, cpap);
+
+  name = MYALLOC(char, 2);
+  *(name+1) = 0;
+  *name = 'T';
+
+  READ_INTO_CPA(name, uname, info, varray, vindex, cpap);
+
+  name = MYALLOC(char, 2);
+  *(name+1) = 0;
+  *name = 'F';
+
+  READ_INTO_CPA(name, uname, info, varray, vindex, cpap);
+
+  name = MYALLOC(char, 2);
+  *(name+1) = 0;
+  *name = 'D';
+
+  READ_INTO_CPA(name, uname, info, varray, vindex, cpap);
+
+  READ_TNT_STRING(0, "n", 1, (NT) 1);
+  READ_TNT_STRING(0, "ntn", 3, (NT) 1, (T) 43, (NT) 1);
+
+  READ_TNT_STRING(1, "n", 1, (NT) 2);
+  READ_TNT_STRING(1, "ntn", 3, (NT) 2, (T) 42, (NT) 2);
+
+  READ_TNT_STRING(2, "n", 1, (NT) 3);
+  READ_TNT_STRING(2, "tnt", 3, (T) 40, (NT) 0, (T) 41);
+
+  READ_TNT_STRING(3, "tn", 2, (T) 48, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 49, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 50, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 51, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 52, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 53, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 54, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 55, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 56, (NT) 3);
+  READ_TNT_STRING(3, "tn", 2, (T) 57, (NT) 3);
+  rule = new_rule(3, new_list());
+  add_to_list(rules, rule);
+
+  Grammar *g = new_grammar();
+
+  build_grammar(g, rules, names);
+
+  print_grammar(g);
+
+
+  BOOL error = 0;
+  bsr *bsrp = new_bsr(&error, g);
+
+  if (error) goto cleanup;
+
+  bsr_add(g, bsrp, 0, 0, 1, 0, 1, 2);
+  bsr_add(g, bsrp, 0, 1, 1, 0, 1, 2);
+  bsr_add(g, bsrp, 0, 1, 2, 0, 1, 2);
+  
+  if (bsr_find(bsrp, g, &error,
+               0, 0, 1, 0, 1, 2)) {
+    printf("Successfully found 0, 0, 1, 0, 1, 2\n");
+  } else {
+    fleprintf0("Fail to find 0, 0, 1, 0, 1, 2\n");
+  }
+
+  if (bsr_find(bsrp, g, &error,
+               0, 0, 1, 0, 1, 3)) {
+    fleprintf0("Accidentally found 0, 0, 1, 0, 1, 3\n");
+  } else {
+    printf("Indeed cannot find 0, 0, 1, 0, 1, 3\n");
+  }
+
+  bsr_print(bsrp, g, 1);
+
+ cleanup:
+
+  destroy_grammar(g, 1);
+
+  destroy_list(rules, 1);
+
+  destroy_bsr(bsrp);
+
+  return 0;
+
+}