GObjectified Grammar

Grammar is now implemented as a hash table of non-terminals, giving a
list of rules for each of them. It is also a GObject now.

--This line, and those below, will be ignored--
Files to commit:
   <can't compute list>

This list might be incomplete or outdated if editing the log
message was not invoked from an up-to-date changes buffer!

git-archimport-id: cascardo@tlscascardo--private/libgrammatic--dev--0.1--patch-2

diff --git a/grammar.c b/grammar.c
new file mode 100644 (file)
index 0000000..b73cd39
--- /dev/null
+++ b/grammar.c
@@ -0,0 +1,118 @@
+#include <grammar.h>
+
+struct _rule
+{
+  GList* right;
+};
+
+symbol_t* symbol_new (gboolean terminal, gint value)
+{
+  symbol_t* symbol;
+  symbol = g_malloc (sizeof (symbol_t));
+  symbol->terminal = terminal;
+  symbol->value = value;
+  return symbol;
+}
+
+rule_t* rule_new ()
+{
+  rule_t* rule;
+  rule = g_malloc (sizeof (rule_t));
+  rule->right = NULL;
+  return rule;
+}
+
+void rule_append (rule_t* rule, symbol_t* right)
+{
+  rule->right = g_list_append (rule->right, right);
+}
+
+guint symbol_hash (gconstpointer data)
+{
+  symbol_t* symbol;
+  symbol = (symbol_t*) data;
+  return g_direct_hash ((gpointer)symbol->value);
+}
+
+gboolean symbol_equal (gconstpointer data1, gconstpointer data2)
+{
+  symbol_t* symbol1;
+  symbol_t* symbol2;
+  symbol1 = (symbol_t*) data1;
+  symbol2 = (symbol_t*) data2;
+  return symbol1->value == symbol2->value &&
+    symbol1->terminal == symbol2->terminal;
+}
+
+static void grammar_init (GTypeInstance* instance, gpointer g_class)
+{
+  Grammar* self = GRAMMAR(instance);
+  self->grammar = g_hash_table_new_full (symbol_hash, symbol_equal,
+                                        g_free, g_free);
+}
+
+static void grammar_finalize (GObject* obj)
+{
+  GrammarClass* klass;
+  GObject* parent_class;
+  Grammar* self;
+  self = GRAMMAR(obj);
+  g_hash_table_destroy (self->grammar);
+  klass = GRAMMAR_GET_CLASS(obj);
+  parent_class = g_type_class_peek_parent (klass);
+  G_OBJECT_CLASS(parent_class)->finalize (obj);
+}
+
+static void grammar_class_init (GrammarClass* klass)
+{
+  GObjectClass* gobj_class = G_OBJECT_CLASS(klass);
+  gobj_class->finalize = grammar_finalize;
+}
+
+GType grammar_get_type ()
+{
+  static GType type = 0;
+  if (type == 0)
+    {
+      static const GTypeInfo info =
+       {
+         sizeof (GrammarClass),
+         NULL,
+         NULL,
+         (GClassInitFunc)grammar_class_init,
+         NULL,
+         NULL,
+         sizeof (Grammar),
+         0,
+         grammar_init
+       };
+      type = g_type_register_static (G_TYPE_OBJECT, "GrammarType", &info, 0);
+    }
+  return type;
+}
+
+rule_t* grammar_rule_new (Grammar* grammar, symbol_t* left)
+{
+
+  GList** l;
+  rule_t* rule;
+
+  if (!g_hash_table_lookup_extended (grammar->grammar,
+                                    left, NULL, (gpointer*)&l))
+    {
+      l = g_malloc (sizeof (GList**));
+      g_hash_table_insert (grammar->grammar, left, l);
+    }
+
+  rule = rule_new ();
+
+  *l = g_list_append (*l, rule);
+
+  return rule;
+
+}
+
+void grammar_rule_append (rule_t* rule, symbol_t* right)
+{
+  rule_append (rule, right);
+}

diff --git a/grammar.h b/grammar.h
new file mode 100644 (file)
index 0000000..ee32492
--- /dev/null
+++ b/grammar.h
@@ -0,0 +1,46 @@
+#ifndef GRAMMAR_H
+#define GRAMMAR_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#define GRAMMAR_TYPE            (grammar_get_type ())
+#define GRAMMAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+                                    GRAMMAR_TYPE, Grammar))
+#define GRAMMAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), \
+                                    GRAMMAR_TYPE, GrammarClass))
+#define IS_GRAMMAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+                                    GRAMMAR_TYPE))
+#define IS_GRAMMAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+                                    GRAMMAR_TYPE))
+#define GRAMMAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+                                    GRAMMAR_TYPE, GrammarClass))
+
+
+typedef gint (*nextcb) (gpointer, gpointer*);
+
+typedef struct
+{
+  gboolean terminal;
+  gint value;
+} symbol_t;
+
+typedef struct _rule rule_t;
+typedef struct
+{
+  GObject parent;
+  GHashTable* grammar;
+} Grammar;
+typedef struct
+{
+  GObjectClass parent;
+} GrammarClass;
+
+GType grammar_get_type ();
+
+symbol_t* symbol_new (gboolean, gint);
+
+rule_t* grammar_rule_new (Grammar*, symbol_t*);
+void grammar_rule_append (rule_t*, symbol_t*);
+
+#endif

diff --git a/parser.c b/parser.c
deleted file mode 100644 (file)
index e3f098c..0000000
--- a/parser.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "parser.h"
-
-symbol_t* symbol_new (gboolean terminal, gint value)
-{
-  symbol_t* symbol;
-  symbol = g_malloc (sizeof (symbol_t));
-  symbol->terminal = terminal;
-  symbol->value = value;
-  return symbol;
-}
-
-rule_t* rule_new (symbol_t* left)
-{
-  rule_t* rule;
-  rule = g_malloc (sizeof (rule_t));
-  rule->left = left;
-  rule->right = NULL;
-  return rule;
-}
-
-void rule_append (rule_t* rule, symbol_t* right)
-{
-  rule->right = g_list_append (rule->right, right);
-}
-
-guint symbol_hash (gconstpointer data)
-{
-  symbol_t* symbol;
-  symbol = (symbol_t*) data;
-  return g_direct_hash (symbol->value);
-}
-
-gboolean symbol_equal (gconstpointer data1, gconstpointer data2)
-{
-  symbol_t* symbol1;
-  symbol_t* symbol2;
-  symbol1 = (symbol_t*) data1;
-  symbol2 = (symbol_t*) data2;
-  return symbol1->value == symbol2->value &&
-    symbol1->terminal == symbol2->terminal;
-}
-

diff --git a/parser.h b/parser.h
deleted file mode 100644 (file)
index 54ee8d0..0000000
--- a/parser.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef PARSER_H
-#define PARSER_H
-
-#include <glib.h>
-
-typedef gint (*nextcb) (gpointer, gpointer*);
-
-typedef struct
-{
-  gboolean terminal;
-  gint value;
-} symbol_t;
-
-typedef struct
-{
-  symbol_t* left;
-  GList* right;
-} rule_t;
-
-symbol_t* symbol_new (gboolean, gint);
-rule_t* rule_new (symbol_t*);
-void rule_append (rule_t*, symbol_t* right);
-
-#endif