1 files changed, 773 insertions, 0 deletions

diff --git a/src/tree.c b/src/tree.c
new file mode 100644
index 0000000..52d38c0
--- /dev/null
+++ b/src/tree.c
@@ -0,0 +1,773 @@
+/* grecs - Gray's Extensible Configuration System
+   Copyright (C) 2007-2011 Sergey Poznyakoff
+
+   Grecs is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 3 of the License, or (at your
+   option) any later version.
+
+   Grecs is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Grecs. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdlib.h>
+#include "grecs.h"
+
+struct grecs_node *
+grecs_node_create(enum grecs_node_type type, grecs_locus_t *loc)
+{
+        struct grecs_node *np = grecs_zalloc(sizeof(*np));
+        np->type = type;
+        if (loc)
+                np->locus = *loc;
+        return np;
+}
+
+void
+grecs_node_bind(struct grecs_node *master, struct grecs_node *node, int dn)
+{
+        struct grecs_node *np;
+        
+        if (dn) {
+                if (!master->down)
+                        master->down = node;
+                else {
+                        for (np = master->down; np->next; np = np->next)
+                                ;
+                        np->next = node;
+                }
+                for (; node; node = node->next)
+                        node->up = master;
+        } else {
+                if (!master->next)
+                        master->next = node;
+                else {
+                        for (np = master->next; np->next; np = np->next)
+                                ;
+                        np->next = node;
+                }
+                node->up = master->up;
+        }
+}
+
+
+static enum grecs_tree_recurse_res
+_tree_recurse(struct grecs_node *node, grecs_tree_recursor_t recfun,
+              void *data)
+{
+        enum grecs_tree_recurse_res res;
+#define CKRES()                                         \
+        switch (res) {                                  \
+        case grecs_tree_recurse_fail:                   \
+        case grecs_tree_recurse_stop:                   \
+                return res;                             \
+        default:                                        \
+                break;                                  \
+        }
+
+        for (; node; node = node->next) {
+                if (node->type == grecs_node_stmt) {
+                        res = recfun(grecs_tree_recurse_set, node, data);
+                        CKRES();
+                } else {
+                        switch (recfun(grecs_tree_recurse_pre, node, data)) {
+                        case grecs_tree_recurse_ok:
+                                res = _tree_recurse(node->down, recfun, data);
+                                CKRES();
+                                res = recfun(grecs_tree_recurse_post, node,
+                                             data);
+                                CKRES();
+                                break;
+                        case grecs_tree_recurse_fail:
+                                return grecs_tree_recurse_fail;
+                        case grecs_tree_recurse_stop:
+                                return grecs_tree_recurse_stop;
+                        case grecs_tree_recurse_skip:
+                                break;
+                        }
+                }
+        }
+        return grecs_tree_recurse_ok;
+#undef CKRES
+}
+
+int
+grecs_tree_recurse(struct grecs_node *node, grecs_tree_recursor_t recfun,
+                   void *data)
+{
+        switch (_tree_recurse(node, recfun, data)) {
+        case grecs_tree_recurse_ok:
+        case grecs_tree_recurse_stop:
+                return 0;
+        default:
+                break;
+        }
+        return 1;
+}
+
+void
+grecs_node_free(struct grecs_node *node)
+{
+        /*FIXME: value*/
+        free(node);
+}
+
+void
+grecs_tree_free(struct grecs_node *node)
+{
+        while (node) {
+                struct grecs_node *next = node->next;
+                if (node->down)
+                        grecs_tree_free(node->down);
+                grecs_node_free(node);
+                node = next;
+        }
+}
+
+
+
+static int
+fake_callback(enum grecs_callback_command cmd,
+               grecs_locus_t *locus,
+               void *varptr,
+               grecs_value_t *value,
+               void *cb_data)
+{
+        return 0;
+}
+
+static struct grecs_keyword fake = {
+        "*",
+        NULL,
+        NULL,
+        grecs_type_void,
+        NULL,
+        0,
+        fake_callback,
+        NULL,
+        &fake
+};
+
+static struct grecs_keyword *
+find_keyword(struct grecs_keyword *cursect, const char *ident)
+{
+        struct grecs_keyword *kwp;
+  
+        if (cursect && cursect != &fake) {
+                for (kwp = cursect->kwd; kwp->ident; kwp++)
+                        if (strcmp(kwp->ident, ident) == 0)
+                                return kwp;
+        } else {
+                return &fake;
+        }
+        return NULL;
+}
+
+static void *
+target_ptr(struct grecs_keyword *kwp, char *base)
+{
+        if (kwp->varptr)
+                base = (char*) kwp->varptr + kwp->offset;
+        else if (base)
+                base += kwp->offset;
+        
+        return base;
+}
+
+static int
+string_to_bool(const char *string, int *pval, grecs_locus_t *locus)
+{
+        if (strcmp(string, "yes") == 0
+            || strcmp(string, "true") == 0
+            || strcmp(string, "t") == 0
+            || strcmp(string, "1") == 0)
+                *pval = 1;
+        else if (strcmp(string, "no") == 0
+                 || strcmp(string, "false") == 0
+                 || strcmp(string, "nil") == 0
+                 || strcmp(string, "0") == 0)
+                *pval = 0;
+        else {
+                grecs_error(locus, 0,
+                             _("%s: not a valid boolean value"),
+                             string);
+                return 1;
+        }
+        return 0;
+}
+
+static int
+string_to_host(struct in_addr *in, const char *string, grecs_locus_t *locus)
+{
+        if (inet_aton(string, in) == 0) {
+                struct hostent *hp;
+
+                hp = gethostbyname(string);
+                if (hp == NULL)
+                        return 1;
+                memcpy(in, hp->h_addr, sizeof(struct in_addr));
+        }
+        return 0;
+}
+
+static int
+string_to_sockaddr(struct grecs_sockaddr *sp, const char *string,
+                    grecs_locus_t *locus)
+{
+        if (string[0] == '/') {
+                struct sockaddr_un s_un;
+                if (strlen(string) >= sizeof(s_un.sun_path)) {
+                        grecs_error(locus, 0,
+                                     _("%s: UNIX socket name too long"),
+                                     string);
+                        return 1;
+                }
+                s_un.sun_family = AF_UNIX;
+                strcpy(s_un.sun_path, string);
+                sp->len = sizeof(s_un);
+                sp->sa = grecs_malloc(sp->len);
+                memcpy(sp->sa, &s_un, sp->len);
+        } else {
+                char *p = strchr(string, ':');
+                size_t len;
+                struct sockaddr_in sa;
+                
+                sa.sin_family = AF_INET;
+                if (p) 
+                        len = p - string;
+                else