avoid duplicates in the path lists
[mikachu/openbox.git] / parser / parse.c
index 48db4ec..69343a8 100644 (file)
@@ -1,13 +1,42 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
+
+   parse.c for the Openbox window manager
+   Copyright (c) 2003        Ben Jansens
+
+   This program 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 2 of the License, or
+   (at your option) any later version.
+
+   This program 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.
+
+   See the COPYING file for a copy of the GNU General Public License.
+*/
+
 #include "parse.h"
 #include <glib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+static gboolean xdg_start;
+static gchar   *xdg_config_home_path;
+static gchar   *xdg_data_home_path;
+static GSList  *xdg_config_dir_paths;
+static GSList  *xdg_data_dir_paths;
 
 struct Callback {
-    char *tag;
+    gchar *tag;
     ParseCallback func;
     void *data;
 };
 
-static GHashTable *callbacks;
+struct _ObParseInst {
+    GHashTable *callbacks;
+};
 
 static void destfunc(struct Callback *c)
 {
@@ -15,22 +44,28 @@ static void destfunc(struct Callback *c)
     g_free(c);
 }
 
-void parse_startup()
+ObParseInst* parse_startup()
 {
-    callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
-                                      (GDestroyNotify)destfunc);
+    ObParseInst *i = g_new(ObParseInst, 1);
+    i->callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+                                         (GDestroyNotify)destfunc);
+    return i;
 }
 
-void parse_shutdown()
+void parse_shutdown(ObParseInst *i)
 {
-    g_hash_table_destroy(callbacks);
+    if (i) {
+        g_hash_table_destroy(i->callbacks);
+        g_free(i);
+    }
 }
 
-void parse_register(const char *tag, ParseCallback func, void *data)
+void parse_register(ObParseInst *i, const gchar *tag,
+                    ParseCallback func, void *data)
 {
     struct Callback *c;
 
-    if ((c = g_hash_table_lookup(callbacks, tag))) {
+    if ((c = g_hash_table_lookup(i->callbacks, tag))) {
         g_warning("tag '%s' already registered", tag);
         return;
     }
@@ -39,36 +74,48 @@ void parse_register(const char *tag, ParseCallback func, void *data)
     c->tag = g_strdup(tag);
     c->func = func;
     c->data = data;
-    g_hash_table_insert(callbacks, c->tag, c);
+    g_hash_table_insert(i->callbacks, c->tag, c);
 }
 
 gboolean parse_load_rc(xmlDocPtr *doc, xmlNodePtr *root)
 {
-    char *path;
+    GSList *it;
+    gchar *path;
     gboolean r = FALSE;
 
-    path = g_build_filename(g_get_home_dir(), ".openbox", "rc3", NULL);
-    if (parse_load(path, "openbox_config", doc, root)) {
-        r = TRUE;
-    } else {
+    for (it = xdg_config_dir_paths; !r && it; it = g_slist_next(it)) {
+        path = g_build_filename(it->data, "openbox", "rc.xml", NULL);
+        r = parse_load(path, "openbox_config", doc, root);
         g_free(path);
-        path = g_build_filename(RCDIR, "rc3", NULL);
-        if (parse_load(path, "openbox_config", doc, root)) {
-            r = TRUE;
-        }
     }
-    g_free(path);
     if (!r)
         g_warning("unable to find a valid config file, using defaults");
     return r;
 }
 
-gboolean parse_load(const char *path, const char *rootname,
-                    xmlDocPtr *doc, xmlNodePtr *root)
+gboolean parse_load_menu(const gchar *file, xmlDocPtr *doc, xmlNodePtr *root)
 {
+    GSList *it;
+    gchar *path;
+    gboolean r = FALSE;
 
-    xmlLineNumbersDefault(1);
+    if (file[0] == '/') {
+        r = parse_load(file, "openbox_menu", doc, root);
+    } else {
+        for (it = xdg_config_dir_paths; !r && it; it = g_slist_next(it)) {
+            path = g_build_filename(it->data, "openbox", file, NULL);
+            r = parse_load(path, "openbox_menu", doc, root);
+            g_free(path);
+        }
+    }
+    if (!r)
+        g_warning("unable to find a valid menu file '%s'", file);
+    return r;
+}
 
+gboolean parse_load(const gchar *path, const gchar *rootname,
+                    xmlDocPtr *doc, xmlNodePtr *root)
+{
     if ((*doc = xmlParseFile(path))) {
         *root = xmlDocGetRootElement(*doc);
         if (!*root) {
@@ -79,8 +126,31 @@ gboolean parse_load(const char *path, const char *rootname,
             if (xmlStrcasecmp((*root)->name, (const xmlChar*)rootname)) {
                 xmlFreeDoc(*doc);
                 *doc = NULL;
-                g_warning("document %s is of wrong type. root *root is "
-                          "not 'openbox_config'", path);
+                g_warning("document %s is of wrong type. root node is "
+                          "not '%s'", path, rootname);
+            }
+        }
+    }
+    if (!*doc)
+        return FALSE;
+    return TRUE;
+}
+
+gboolean parse_load_mem(gpointer data, guint len, const gchar *rootname,
+                        xmlDocPtr *doc, xmlNodePtr *root)
+{
+    if ((*doc = xmlParseMemory(data, len))) {
+        *root = xmlDocGetRootElement(*doc);
+        if (!*root) {
+            xmlFreeDoc(*doc);
+            *doc = NULL;
+            g_warning("Given memory is an empty document");
+        } else {
+            if (xmlStrcasecmp((*root)->name, (const xmlChar*)rootname)) {
+                xmlFreeDoc(*doc);
+                *doc = NULL;
+                g_warning("document in given memory is of wrong type. root "
+                          "node is not '%s'", rootname);
             }
         }
     }
@@ -91,40 +161,40 @@ gboolean parse_load(const char *path, const char *rootname,
 
 void parse_close(xmlDocPtr doc)
 {
-    xmlFree(doc);
+    xmlFreeDoc(doc);
 }
 
-void parse_tree(xmlDocPtr doc, xmlNodePtr node, void *nothing)
+void parse_tree(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node)
 {
     while (node) {
-        struct Callback *c = g_hash_table_lookup(callbacks, node->name);
+        struct Callback *c = g_hash_table_lookup(i->callbacks, node->name);
 
         if (c)
-            c->func(doc, node, c->data);
+            c->func(i, doc, node, c->data);
 
         node = node->next;
     }
 }
 
-char *parse_string(xmlDocPtr doc, xmlNodePtr node)
+gchar *parse_string(xmlDocPtr doc, xmlNodePtr node)
 {
-    xmlChar *c = xmlNodeListGetString(doc, node->xmlChildrenNode, TRUE);
-    char *s = g_strdup(c ? (char*)c : "");
+    xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
+    gchar *s = g_strdup(c ? (gchar*)c : "");
     xmlFree(c);
     return s;
 }
 
-int parse_int(xmlDocPtr doc, xmlNodePtr node)
+gint parse_int(xmlDocPtr doc, xmlNodePtr node)
 {
-    xmlChar *c = xmlNodeListGetString(doc, node->xmlChildrenNode, TRUE);
-    int i = atoi((char*)c);
+    xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
+    gint i = atoi((gchar*)c);
     xmlFree(c);
     return i;
 }
 
 gboolean parse_bool(xmlDocPtr doc, xmlNodePtr node)
 {
-    xmlChar *c = xmlNodeListGetString(doc, node->xmlChildrenNode, TRUE);
+    xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
     gboolean b = FALSE;
     if (!xmlStrcasecmp(c, (const xmlChar*) "true"))
         b = TRUE;
@@ -136,16 +206,16 @@ gboolean parse_bool(xmlDocPtr doc, xmlNodePtr node)
     return b;
 }
 
-gboolean parse_contains(const char *val, xmlDocPtr doc, xmlNodePtr node)
+gboolean parse_contains(const gchar *val, xmlDocPtr doc, xmlNodePtr node)
 {
-    xmlChar *c = xmlNodeListGetString(doc, node->xmlChildrenNode, TRUE);
+    xmlChar *c = xmlNodeListGetString(doc, node->children, TRUE);
     gboolean r;
     r = !xmlStrcasecmp(c, (const xmlChar*) val);
     xmlFree(c);
     return r;
 }
 
-xmlNodePtr parse_find_node(const char *tag, xmlNodePtr node)
+xmlNodePtr parse_find_node(const gchar *tag, xmlNodePtr node)
 {
     while (node) {
         if (!xmlStrcasecmp(node->name, (const xmlChar*) tag))
@@ -155,32 +225,32 @@ xmlNodePtr parse_find_node(const char *tag, xmlNodePtr node)
     return NULL;
 }
 
-gboolean parse_attr_int(const char *name, xmlNodePtr node, int *value)
+gboolean parse_attr_int(const gchar *name, xmlNodePtr node, gint *value)
 {
     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
     gboolean r = FALSE;
     if (c) {
-        *value = atoi((char*)c);
+        *value = atoi((gchar*)c);
         r = TRUE;
     }
     xmlFree(c);
     return r;
 }
 
-gboolean parse_attr_string(const char *name, xmlNodePtr node, char **value)
+gboolean parse_attr_string(const gchar *name, xmlNodePtr node, gchar **value)
 {
     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
     gboolean r = FALSE;
     if (c) {
-        *value = g_strdup((char*)c);
+        *value = g_strdup((gchar*)c);
         r = TRUE;
     }
     xmlFree(c);
     return r;
 }
 
-gboolean parse_attr_contains(const char *val, xmlNodePtr node,
-                             const char *name)
+gboolean parse_attr_contains(const gchar *val, xmlNodePtr node,
+                             const gchar *name)
 {
     xmlChar *c = xmlGetProp(node, (const xmlChar*) name);
     gboolean r;
@@ -188,3 +258,167 @@ gboolean parse_attr_contains(const char *val, xmlNodePtr node,
     xmlFree(c);
     return r;
 }
+
+static gint slist_path_cmp(const gchar *a, const gchar *b)
+{
+    return strcmp(a, b);
+}
+
+typedef GSList* (*GSListFunc) (gpointer list, gconstpointer data);
+
+static GSList* slist_path_add(GSList *list, gpointer data, GSListFunc func)
+{
+    g_assert(func);
+
+    if (!data)
+        return list;
+
+    if (!g_slist_find_custom(list, data, (GCompareFunc) slist_path_cmp))
+        list = func(list, data);
+
+    return list;
+}
+
+static GSList* split_paths(const gchar *paths)
+{
+    GSList *list = NULL;
+    gchar **spl, **it;
+
+    if (!paths)
+        return NULL;
+    spl = g_strsplit(paths, ":", -1);
+    for (it = spl; *it; ++it)
+        list = slist_path_add(list, *it, (GSListFunc) g_slist_append);
+    g_free(spl);
+    return list;
+}
+
+void parse_paths_startup()
+{
+    gchar *path;
+
+    if (xdg_start)
+        return;
+    xdg_start = TRUE;
+
+    path = getenv("XDG_CONFIG_HOME");
+    if (path && path[0] != '\0') /* not unset or empty */
+        xdg_config_home_path = g_build_filename(path, NULL);
+    else
+        xdg_config_home_path = g_build_filename(g_get_home_dir(), ".config",
+                                                NULL);
+
+    path = getenv("XDG_DATA_HOME");
+    if (path && path[0] != '\0') /* not unset or empty */
+        xdg_data_home_path = g_build_filename(path, NULL);
+    else
+        xdg_data_home_path = g_build_filename(g_get_home_dir(), ".local",
+                                              "share", NULL);
+
+    path = getenv("XDG_CONFIG_DIRS");
+    if (path && path[0] != '\0') /* not unset or empty */
+        xdg_config_dir_paths = split_paths(path);
+    else {
+        xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
+                                              g_build_filename
+                                              (G_DIR_SEPARATOR_S,
+                                               "etc", "xdg", NULL),
+                                              (GSListFunc) g_slist_append);
+        xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
+                                              g_strdup(CONFIGDIR),
+                                              (GSListFunc) g_slist_append);
+    }
+    xdg_config_dir_paths = slist_path_add(xdg_config_dir_paths,
+                                          xdg_config_home_path,
+                                          (GSListFunc) g_slist_prepend);
+    
+    path = getenv("XDG_DATA_DIRS");
+    if (path && path[0] != '\0') /* not unset or empty */
+        xdg_data_dir_paths = split_paths(path);
+    else {
+        xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
+                                            g_build_filename
+                                            (G_DIR_SEPARATOR_S,
+                                             "usr", "local", "share", NULL),
+                                            (GSListFunc) g_slist_append);
+        xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
+                                            g_build_filename
+                                            (G_DIR_SEPARATOR_S,
+                                             "usr", "share", NULL),
+                                            (GSListFunc) g_slist_append);
+        xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
+                                            g_strdup(DATADIR),
+                                            (GSListFunc) g_slist_append);
+    }
+    xdg_data_dir_paths = slist_path_add(xdg_data_dir_paths,
+                                        xdg_data_home_path,
+                                        (GSListFunc) g_slist_prepend);
+}
+
+void parse_paths_shutdown()
+{
+    GSList *it;
+
+    if (!xdg_start)
+        return;
+    xdg_start = FALSE;
+
+    for (it = xdg_config_dir_paths; it; it = g_slist_next(it))
+        g_free(it->data);
+    g_slist_free(xdg_config_dir_paths);
+    xdg_config_dir_paths = NULL;
+    for (it = xdg_data_dir_paths; it; it = g_slist_next(it))
+        g_free(it->data);
+    g_slist_free(xdg_data_dir_paths);
+    xdg_data_dir_paths = NULL;
+}
+
+gchar *parse_expand_tilde(const gchar *f)
+{
+    gchar **spl;
+    gchar *ret;
+
+    if (!f)
+        return NULL;
+    spl = g_strsplit(f, "~", 0);
+    ret = g_strjoinv(g_get_home_dir(), spl);
+    g_strfreev(spl);
+    return ret;
+}
+
+void parse_mkdir_path(const gchar *path, gint mode)
+{
+    gchar *c, *e;
+
+    g_assert(path[0] == '/');
+
+    c = g_strdup(path);
+    e = c;
+    while ((e = strchr(e + 1, '/'))) {
+        *e = '\0';
+        mkdir(c, mode);
+        *e = '/';
+    }
+    mkdir(c, mode);
+    g_free(c);
+}
+
+const gchar* parse_xdg_config_home_path()
+{
+    return xdg_config_home_path;
+}
+
+const gchar* parse_xdg_data_home_path()
+{
+    return xdg_data_home_path;
+}
+
+GSList* parse_xdg_config_dir_paths()
+{
+    return xdg_config_dir_paths;
+}
+
+GSList* parse_xdg_data_dir_paths()
+{
+    return xdg_data_dir_paths;
+}