From 53b8b6ffab5a968db75e9babddf4e2dbb2c688a3 Mon Sep 17 00:00:00 2001
From: JSDurand <mmemmew@gmail.com>
Date: Tue, 9 Nov 2021 20:03:23 +0800
Subject: save point: representation of grammar might be too rough.

The current representation of the grammar is the most primitive BNF.
This is the simplest to implement, but is difficult to cope with user
requirements.  Moreover, I find another paper describing the GLR
algorithm, so I need to think about the representation of the grammar
more.  In particular, I would like the generation of the grammar to be
incremental, so per chance its data type should be adapted
accordingly.
---
 src/grammar.c | 118 +++++++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 101 insertions(+), 17 deletions(-)

(limited to 'src/grammar.c')

diff --git a/src/grammar.c b/src/grammar.c
index 9265ef5..fd38ac8 100644
--- a/src/grammar.c
+++ b/src/grammar.c
@@ -10,7 +10,14 @@ struct Rule_s {
   List *right;
 };
 
-TNT *new_tnt(int type, ...)
+struct Grammar_s {
+  List *rules;
+  /* a list of names of non-terminals */
+  List *names;
+};
+
+TNT *
+new_tnt(int type, ...)
 {
   va_list args;
   va_start(args, type);
@@ -26,10 +33,11 @@ TNT *new_tnt(int type, ...)
   return result;
 }
 
-Rule *new_rule(NT left, List *right)
+Rule *
+new_rule(NT left, List *right)
 {
   if (!right) return NULL;
-  
+
   Rule *rule = MYALLOC(Rule, 1);
 
   rule->left = left;
@@ -38,7 +46,22 @@ Rule *new_rule(NT left, List *right)
   return rule;
 }
 
-void print_tnt(void *element)
+Grammar *
+new_grammar()
+{
+  Grammar *g = MYALLOC(Grammar, 1);
+  return g;
+}
+
+void
+build_grammar(Grammar *g, List *rules, List *names)
+{
+  g->rules = rules;
+  g->names = names;
+}
+
+void
+print_tnt(void *element)
 {
   TNT *tnt = (TNT*) element;
 
@@ -48,35 +71,55 @@ void print_tnt(void *element)
     printf("T %lu, ", tnt->data.t);
 }
 
-void print_rule(void *r)
+void
+print_rule(void *r)
 {
-  Rule *rule = (Rule *)r;
-  printf("Rule: NT %u => ", rule->left);
-  
+  Rule *rule = (Rule *) r;
+  printf("Rule: %u => ", rule->left);
+
   map_list(rule->right, print_tnt);
 
   printf("\n");
 }
 
-void print_grammar(Grammar g)
+/* a local function pointer */
+void
+print_name(void *element)
+{
+  char *str = (char *) element;
+  printf("%s", str);
+}
+
+/* a local function pointer */
+void
+print_sep()
+{
+  printf(", ");
+}
+
+void
+print_grammar(Grammar *g)
 {
   printf("Printing a grammar:\n");
-  map_list(g, print_rule);
+  map_list_between(g->names, print_name, print_sep);
+  printf("\n");
+  map_list(g->rules, print_rule);
   printf("\n");
 }
 
-List *new_tnt_string(char *format, int format_len, ...)
+List *
+new_tnt_string(char *format, int format_len, ...)
 {
   /* FORMAT_LEN does not include the terminating null byte, so it
      should be > 0. */
-  
+
   if (format_len <= 0) return NULL;
-  
+
   List *result = new_list();
-  
+
   va_list args;
   va_start(args, format_len);
-  
+
   for (int point = 0; point < format_len; point++) {
     switch (*(format+point)) {
     case 'n':
@@ -99,8 +142,49 @@ List *new_tnt_string(char *format, int format_len, ...)
   return result;
 }
 
-void destroy_rule(Rule *rule)
+void
+destroy_rule(void *rule, int flag)
 {
-  destroy_list(rule->right, 1);
+  Rule * r = (Rule *) rule;
+  destroy_list(r->right, flag);
   free(rule);
 }
+
+void
+destroy_rule_and_free_all(void *rule)
+{
+  destroy_rule(rule, 1);
+}
+
+void
+destroy_rule_and_free_first(void *rule)
+{
+  destroy_rule(rule, 2);
+}
+
+void
+destroy_rule_no_free(void *rule)
+{
+  destroy_rule(rule, 0);
+}
+
+void
+destroy_grammar(void *grammar, int flag)
+{
+  Grammar *g = (Grammar *) grammar;
+
+  switch (flag) {
+  case 0:
+    map_list(g->rules, destroy_rule_no_free);
+    break;
+  case 1:
+    map_list(g->rules, destroy_rule_and_free_all);
+    break;
+  default:
+    map_list(g->rules, destroy_rule_and_free_first);
+    break;    
+  }
+
+  destroy_list(g->rules, 0);
+  destroy_list(g->names, flag);
+}
-- 
cgit v1.2.3-18-g5258