Recursive Descent Parser GObjectified

Recursive Descent Parser code adapted to the new Grammar code and
GObjectified.

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

diff --git a/rdp.c b/rdp.c
index 52245af..4dbdc63 100644 (file)
--- a/rdp.c
+++ b/rdp.c
@@ -1,53 +1,106 @@
-#include "rdp.h"
+#include <rdp.h>

 #include <stdlib.h>
 
 #include <stdlib.h>
 

-rdp_t* rdp_new (nextcb cb, gpointer data, gint value)
+struct _buffer

 {
 {

+  symbol_t* symbol;
+  gpointer attrib;
+};

 
 

-  rdp_t* parser;
-
-  parser = g_malloc (sizeof (rdp_t));
-  parser->cb = cb;
-  parser->data = data;
-  parser->start = symbol_new (FALSE, value);
-
-  parser->rules = NULL;
-
-  parser->buffer = g_list_append (NULL, NULL);
+gpointer leaf_new (gpointer data)
+{
+  return g_node_new (data);
+}

 
 

-  return parser;
+gpointer tree_new (rule_t* rule)
+{
+  return g_node_new (rule);
+}

 
 

+gpointer tree_add (gpointer tree, gpointer data)
+{
+  return g_node_append (tree, data);

 }
 
 }
 

-void rdp_delete (rdp_t* parser)
+void tree_delete (gpointer tree)

 {
 {

+  g_node_destroy (tree);
+}

 
 

-  g_free (parser->start);
-  g_free (parser);
+static void rdp_init (GTypeInstance* instance, gpointer g_class)
+{
+  Rdp* self = RDP(instance);
+  self->cb = NULL;
+  self->data = NULL;
+  self->buffer = NULL;
+  self->start = NULL;
+}

 
 

+static void rdp_finalize (GObject* obj)
+{
+  RdpClass* klass;
+  GObject* parent_class;
+  Rdp* self;
+  self = RDP(obj);
+  g_free (self->start);
+  klass = RDP_GET_CLASS(obj);
+  parent_class = g_type_class_peek_parent (klass);
+  G_OBJECT_CLASS(parent_class)->finalize (obj);

 }
 
 }
 

-gpointer leaf_new (gpointer data)
+static void rdp_class_init (RdpClass* klass)

 {
 {

-  return g_node_new (data);
+  GObjectClass* gobj_class = G_OBJECT_CLASS(klass);
+  gobj_class->finalize = rdp_finalize;

 }
 
 }
 

-gpointer tree_new (rule_t* rule)
+GType rdp_get_type ()

 {
 {

-  return g_node_new (rule);
+  static GType type = 0;
+  if (type == 0)
+    {
+      static const GTypeInfo info =
+       {
+         sizeof (RdpClass),
+         NULL,
+         NULL,
+         (GClassInitFunc)rdp_class_init,
+         NULL,
+         NULL,
+         sizeof (Rdp),
+         0,
+         rdp_init
+       };
+      type = g_type_register_static (GRAMMAR_TYPE, "RdpType", &info, 0);
+    }
+  return type;

 }
 
 }
 

-gpointer tree_add (gpointer tree, gpointer data)
+Rdp* rdp_new (nextcb cb, gpointer data, gint value)

 {
 {

-  return g_node_append (tree, data);
+
+  Rdp* parser;
+
+  parser = g_object_new (RDP_TYPE, NULL);
+
+  parser->cb = cb;
+  parser->data = data;
+  parser->start = symbol_new (FALSE, value);
+
+  parser->buffer = g_list_append (NULL, NULL);
+
+  return parser;
+

 }
 
 }
 

-void tree_delete (gpointer tree)
+void rdp_delete (Rdp* parser)

 {
 {

-  g_node_destroy (tree);
+
+  g_object_unref (parser);
+

 }
 
 }
 

-symbol_t* buffer_next (rdp_t* parser, gpointer* attrib)
+symbol_t* buffer_next (Rdp* parser, gpointer* attrib)

 {
 
   buffer_t* buffer;
 {
 
   buffer_t* buffer;


@@ -71,7 +124,7 @@ symbol_t* buffer_next (rdp_t* parser, gpointer* attrib)
       
 }
 
       
 }
 

-gboolean rdp_step (rdp_t* parser, symbol_t* symbol, gpointer* attrib)
+gboolean rdp_step (Rdp* parser, symbol_t* symbol, gpointer* attrib)

 {
 
   GList* l;
 {
 
   GList* l;


@@ -93,51 +146,58 @@ gboolean rdp_step (rdp_t* parser, symbol_t* symbol, gpointer* attrib)
       return TRUE;
     }
 
       return TRUE;
     }
 

-  for (l = g_list_first (parser->rules); l != NULL; l = g_list_next (l))
+  for (l = grammar_get_rules (parser, symbol); l != NULL; l = g_list_next (l))

     {
 
       rule_t* rule;
     {
 
       rule_t* rule;

+      GList* m;

 
       rule = (rule_t*) l->data;
 
 
       rule = (rule_t*) l->data;
 

-      if (symbol == NULL || symbol_equal (symbol, rule->left))
-       {
-
-         GList* m;

 
 

-         *attrib = tree_new (rule);
+      *attrib = tree_new (symbol_copy (symbol));

 
 

-         for (m = g_list_first (rule->right); m != NULL; m = g_list_next (m))
-           {
+      m = grammar_get_rule (rule);

 
 

-             symbol_t* s;
+      /*
+      if (m == NULL)
+       {
+         tree_add (*attrib, leaf_new (g_string_new ("")));
+         return TRUE;
+       }
+      */

 
 

-             s = (symbol_t*) m->data;
+      while (m != NULL)
+       {

 
 

-             if (!rdp_step (parser, s, &attr))
-               {
-                 parser->buffer = buffer;
-                 break;
-               }
+         symbol_t* s;

 
 

-             tree_add (*attrib, attr);
+         s = (symbol_t*) m->data;

 
 

+         if (!rdp_step (parser, s, &attr))
+           {
+             parser->buffer = buffer;
+             break;

            }
 
            }
 

-         if (m == NULL)
-           return TRUE;
-         else
-           tree_delete (*attrib);
+         tree_add (*attrib, attr);
+
+         m = g_list_next (m);

 
        }
 
 
        }
 

+      if (m == NULL)
+       return TRUE;
+      else
+       tree_delete (*attrib);
+

     }
 
   return FALSE;
 
 }
 
     }
 
   return FALSE;
 
 }
 

-gpointer rdp_build (rdp_t* parser)
+gpointer rdp_build (Rdp* parser)

 {
 
   gpointer attrib;
 {
 
   gpointer attrib;

diff --git a/rdp.h b/rdp.h
index 2e892fb..1455c52 100644 (file)
--- a/rdp.h
+++ b/rdp.h
@@ -1,25 +1,41 @@
 #ifndef RDP_H
 #define RDP_H
 
 #ifndef RDP_H
 #define RDP_H
 

-#include "parser.h"
+#include <grammar.h>

 
 

-typedef struct
-{
-  symbol_t* symbol;
-  gpointer attrib;
-} buffer_t;
+#define RDP_TYPE            (rdp_get_type ())
+#define RDP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+                                    RDP_TYPE, Rdp))
+#define RDP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), \
+                                    RDP_TYPE, RdpClass))
+#define IS_RDP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+                                    RDP_TYPE))
+#define IS_RDP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+                                    RDP_TYPE))
+#define RDP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+                                    RDP_TYPE, RdpClass))
+
+
+typedef struct _buffer buffer_t;

 
 typedef struct
 {
 
 typedef struct
 {

+  Grammar parent;

   nextcb cb;
   gpointer data;
   nextcb cb;
   gpointer data;

-  GList* rules;

   GList* buffer;
   symbol_t* start;
   GList* buffer;
   symbol_t* start;

-} rdp_t;
+} Rdp;
+
+typedef struct
+{
+  GrammarClass parent;
+} RdpClass;
+
+GType rdp_get_type ();

 
 

-rdp_t* rdp_new (nextcb, gpointer, gint);
-void rdp_delete (rdp_t*);
-gpointer rdp_build (rdp_t*);
+Rdp* rdp_new (nextcb, gpointer, gint);
+void rdp_delete (Rdp*);
+gpointer rdp_build (Rdp*);

 
 #endif
 
 #endif