Change function prefixes according to projet namechange.

14 files changed, 219 insertions, 219 deletions

diff --git a/Makefile b/Makefile
index 9e8d4c3..7e35afa 100644
--- a/Makefile
+++ b/Makefile
@@ -6,8 +6,8 @@ CXXFLAGS=$(CFLAGS)
 all: complete obj simple syslog filter mutex minimal
 
 complete:
-	gcc ${CFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_DBG_SYSLOG -DWITH_DBG_FILTER -DWITH_DBG_MUTEX
-	g++ ${CXXFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_DBG_SYSLOG -DWITH_DBG_FILTER -DWITH_DBG_MUTEX
+	gcc ${CFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_HUG_SYSLOG -DWITH_HUG_FILTER -DWITH_HUG_MUTEX
+	g++ ${CXXFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_HUG_SYSLOG -DWITH_HUG_FILTER -DWITH_HUG_MUTEX
 
 obj:
 #	Compile hugin as c prog and link with c++ program (use hugin.hpp)
@@ -29,16 +29,16 @@ minimal:
 	g++ ${CXXFLAGS} hugin.c main_minimal.c -o hugin-minimal
 
 syslog:
-	gcc ${CFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_DBG_SYSLOG
-	g++ ${CXXFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_DBG_SYSLOG
+	gcc ${CFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_HUG_SYSLOG
+	g++ ${CXXFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_HUG_SYSLOG
 
 filter:
-	gcc ${CFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_DBG_FILTER
-	g++ ${CXXFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_DBG_FILTER
+	gcc ${CFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_HUG_FILTER
+	g++ ${CXXFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_HUG_FILTER
 
 mutex:
-	gcc ${CFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_DBG_MUTEX
-	g++ ${CXXFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_DBG_MUTEX
+	gcc ${CFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_HUG_MUTEX
+	g++ ${CXXFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_HUG_MUTEX
 
 clean:
 	rm -f hugin_{complete,complete-cpp,simple,syslog,filter,mutex,minimal}
\ No newline at end of file
diff --git a/hugin.c b/hugin.c
index aebfd08..6aff5b8 100644
--- a/hugin.c
+++ b/hugin.c
@@ -37,58 +37,58 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
-#ifdef WITH_DBG_MUTEX
+#ifdef WITH_HUG_MUTEX
 #include <pthread.h>
 #endif
 
-#ifdef WITH_DBG_FILTER
+#ifdef WITH_HUG_FILTER
 #include "hugin_filter.h"
 #endif
 
-#ifdef WITH_DBG_SYSLOG
+#ifdef WITH_HUG_SYSLOG
 #include "hugin_syslog.h"
 #endif
 
-struct dbg_config_t {
+struct hug_config_t {
   unsigned int flags;
   int fd;
   int file_fd;
   int stdout_no_date;
-#ifdef WITH_DBG_MUTEX
+#ifdef WITH_HUG_MUTEX
   pthread_mutex_t mutex;
 #endif
-#ifdef WITH_DBG_SYSLOG
+#ifdef WITH_HUG_SYSLOG
   const char* syslog_host;
   int syslog_port;
 #endif
-} dbg_config = {
-  DBG_FLAG_DEFAULT, // flags
+} hug_config = {
+  HUG_FLAG_DEFAULT, // flags
   -1, // fd
   -1, // file_fd
   0, //stdout_no_date
-#ifdef WITH_DBG_MUTEX
+#ifdef WITH_HUG_MUTEX
   {}, // mutex;
 #endif
-#ifdef WITH_DBG_SYSLOG
+#ifdef WITH_HUG_SYSLOG
   "", // syslog_host;
   -1, // syslog_port;
 #endif
   /* // This doesn't work in C++
-  .flags = DBG_FLAG_DEFAULT,
+  .flags = HUG_FLAG_DEFAULT,
   .fd = -1,
   .file_fd = -1,
   .stdout_no_date = 0
   */
 }; 
 
-#ifdef WITH_DBG_MUTEX
+#ifdef WITH_HUG_MUTEX
   pthread_mutex_t localtime_mutex;
 #endif
 
-struct tm *dbg_localtime(const time_t *timep, struct tm *result)
+struct tm *hug_localtime(const time_t *timep, struct tm *result)
 {
   struct tm *res = NULL;
-#ifdef WITH_DBG_MUTEX
+#ifdef WITH_HUG_MUTEX
   pthread_mutex_lock(&localtime_mutex);
 #endif
 
@@ -97,7 +97,7 @@ struct tm *dbg_localtime(const time_t *timep, struct tm *result)
     res = result;
   }
 
-#ifdef WITH_DBG_MUTEX
+#ifdef WITH_HUG_MUTEX
   pthread_mutex_unlock(&localtime_mutex);
 #endif
 
@@ -105,54 +105,54 @@ struct tm *dbg_localtime(const time_t *timep, struct tm *result)
 }
 
 
-static void dbg_mutex_init()
+static void hug_mutex_init()
 {
-#ifdef WITH_DBG_MUTEX
-  if(dbg_config.flags & DBG_FLAG_USE_MUTEX) {
-    pthread_mutex_init(&dbg_config.mutex, NULL);
+#ifdef WITH_HUG_MUTEX
+  if(hug_config.flags & HUG_FLAG_USE_MUTEX) {
+    pthread_mutex_init(&hug_config.mutex, NULL);
   }
 
   pthread_mutex_init(&localtime_mutex, NULL);
 #endif
 }
 
-static void dbg_mutex_lock()
+static void hug_mutex_lock()
 {
-#ifdef WITH_DBG_MUTEX
-  if(dbg_config.flags & DBG_FLAG_USE_MUTEX) {
-    pthread_mutex_lock(&dbg_config.mutex);
+#ifdef WITH_HUG_MUTEX
+  if(hug_config.flags & HUG_FLAG_USE_MUTEX) {
+    pthread_mutex_lock(&hug_config.mutex);
   }
 #endif
 }
 
-static void dbg_mutex_unlock()
+static void hug_mutex_unlock()
 {
-#ifdef WITH_DBG_MUTEX
-  if(dbg_config.flags & DBG_FLAG_USE_MUTEX) {
-    pthread_mutex_unlock(&dbg_config.mutex);
+#ifdef WITH_HUG_MUTEX
+  if(hug_config.flags & HUG_FLAG_USE_MUTEX) {
+    pthread_mutex_unlock(&hug_config.mutex);
   }
 #endif
 }
 
-static void dbg_mutex_close()
+static void hug_mutex_close()
 {
-#ifdef WITH_DBG_MUTEX
-  if(dbg_config.flags & DBG_FLAG_USE_MUTEX) {
+#ifdef WITH_HUG_MUTEX
+  if(hug_config.flags & HUG_FLAG_USE_MUTEX) {
     // Make sure we don't destroy the mutex while another thread is using it.
-    dbg_mutex_lock();
-    dbg_mutex_unlock();
-    pthread_mutex_destroy(&dbg_config.mutex);
+    hug_mutex_lock();
+    hug_mutex_unlock();
+    pthread_mutex_destroy(&hug_config.mutex);
   }
   
   pthread_mutex_destroy(&localtime_mutex);
 #endif
 }
 
-dbg_status_t dbg_init(unsigned int flags, ...)
+hug_status_t hug_init(unsigned int flags, ...)
 {
-  dbg_status_t status = DBG_STATUS_OK;
+  hug_status_t status = HUG_STATUS_OK;
 
-  dbg_config.flags = flags;
+  hug_config.flags = flags;
 
   int end = 0;
 
@@ -161,46 +161,46 @@ dbg_status_t dbg_init(unsigned int flags, ...)
   while(!end) {
     int option = va_arg(vl, int);
     switch(option) {
-    case DBG_OPTION_END:
+    case HUG_OPTION_END:
       end = 1;
       break;
-    case DBG_OPTION_FD:
-      dbg_config.fd = va_arg(vl, int);
+    case HUG_OPTION_FD:
+      hug_config.fd = va_arg(vl, int);
       break;
-    case DBG_OPTION_STDOUT_NO_DATE:
-      dbg_config.stdout_no_date = va_arg(vl, int);
+    case HUG_OPTION_STDOUT_NO_DATE:
+      hug_config.stdout_no_date = va_arg(vl, int);
       break;
-    case DBG_OPTION_FILENAME:
-      if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FILE) {
+    case HUG_OPTION_FILENAME:
+      if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FILE) {
         const char *filename = (const char*)va_arg(vl, char*);
-        dbg_config.file_fd = open(filename, O_CREAT | O_RDWR, 0777);
+        hug_config.file_fd = open(filename, O_CREAT | O_RDWR, 0777);
       }
       break;
-#ifdef WITH_DBG_SYSLOG
-    case DBG_OPTION_SYSLOG_PORT:
-      dbg_config.syslog_port = va_arg(vl, int);
+#ifdef WITH_HUG_SYSLOG
+    case HUG_OPTION_SYSLOG_PORT:
+      hug_config.syslog_port = va_arg(vl, int);
       break;
-    case DBG_OPTION_SYSLOG_HOST:
-      dbg_config.syslog_host = (const char*)va_arg(vl, char*);
+    case HUG_OPTION_SYSLOG_HOST:
+      hug_config.syslog_host = (const char*)va_arg(vl, char*);
       break;
 #endif
-#ifdef WITH_DBG_FILTER
-    case DBG_OPTION_FILTER:
-      dbg_filter_parse((const char*)va_arg(vl, char*));
+#ifdef WITH_HUG_FILTER
+    case HUG_OPTION_FILTER:
+      hug_filter_parse((const char*)va_arg(vl, char*));
       break;
 #endif
     default:
-      status = DBG_STATUS_UNKNOWN_OPTION;
+      status = HUG_STATUS_UNKNOWN_OPTION;
       printf("option: %x\n", option);
       goto err;
     }
   }
 
-  dbg_mutex_init();
+  hug_mutex_init();
 
-#ifdef WITH_DBG_SYSLOG
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_SYSLOG) {
-    dbg_syslog_init(dbg_config.syslog_host, dbg_config.syslog_port);
+#ifdef WITH_HUG_SYSLOG
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_SYSLOG) {
+    hug_syslog_init(hug_config.syslog_host, hug_config.syslog_port);
   }
 #endif
 
@@ -210,17 +210,17 @@ dbg_status_t dbg_init(unsigned int flags, ...)
   return status;
 }
 
-void dbg_close()
+void hug_close()
 {
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FILE) {
-    if(dbg_config.file_fd != -1) close(dbg_config.file_fd);
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FILE) {
+    if(hug_config.file_fd != -1) close(hug_config.file_fd);
   }
 
-#ifdef WITH_DBG_SYSLOG
-  dbg_syslog_close();
+#ifdef WITH_HUG_SYSLOG
+  hug_syslog_close();
 #endif
 
-  dbg_mutex_close();
+  hug_mutex_close();
 }
 
 /*
@@ -230,11 +230,11 @@ static unsigned int gettid()
 }
 */
 
-static int dbg_create_header(char *hdr, size_t size)
+static int hug_create_header(char *hdr, size_t size)
 {
   time_t rawtime = time(NULL);
   struct tm t;
-  dbg_localtime(&rawtime, &t);
+  hug_localtime(&rawtime, &t);
 
   return snprintf(hdr, size,
                   "%d-%02d-%02d %02d:%02d:%02d",
@@ -246,7 +246,7 @@ static int dbg_create_header(char *hdr, size_t size)
                   t.tm_sec);
 }
 
-static int dbg_output_fd(int fd, const char *msg, int withdate)
+static int hug_output_fd(int fd, const char *msg, int withdate)
 {
   int s;
 
@@ -254,7 +254,7 @@ static int dbg_output_fd(int fd, const char *msg, int withdate)
 
   if(withdate) {
     char hdr[32];
-    dbg_create_header(hdr, sizeof(hdr));
+    hug_create_header(hdr, sizeof(hdr));
     
     s = write(fd, hdr, strlen(hdr));
     s = write(fd, " ", 1);
@@ -278,10 +278,10 @@ int __debug(const char *func, const int line,
   const char * const debug_class_str[] =
     { "fixme", "err", "warn", "info", "debug" };
 
-  dbg_mutex_lock();
+  hug_mutex_lock();
 
-#ifdef WITH_DBG_FILTER
-  if(!dbg_filter_enabled(cl, ch)) goto done;
+#ifdef WITH_HUG_FILTER
+  if(!hug_filter_enabled(cl, ch)) goto done;
 #endif
 
   //
@@ -301,32 +301,32 @@ int __debug(const char *func, const int line,
   // Send message to output
   //
 
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_STDOUT) {
-    dbg_output_fd(STDOUT_FILENO, buf, dbg_config.stdout_no_date == 0);
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_STDOUT) {
+    hug_output_fd(STDOUT_FILENO, buf, hug_config.stdout_no_date == 0);
   }
 
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_STDERR) {
-    dbg_output_fd(STDERR_FILENO, buf, 1);
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_STDERR) {
+    hug_output_fd(STDERR_FILENO, buf, 1);
   }
 
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FD) {
-    dbg_output_fd(dbg_config.fd, buf, 1);
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FD) {
+    hug_output_fd(hug_config.fd, buf, 1);
   }
 
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FILE) {
-    dbg_output_fd(dbg_config.file_fd, buf, 1);
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FILE) {
+    hug_output_fd(hug_config.file_fd, buf, 1);
   }
 
-#ifdef WITH_DBG_SYSLOG
-  if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_SYSLOG) {
-    dbg_syslog_output(buf);
+#ifdef WITH_HUG_SYSLOG
+  if(hug_config.flags & HUG_FLAG_OUTPUT_TO_SYSLOG) {
+    hug_syslog_output(buf);
   }
 #endif
 
-#ifdef WITH_DBG_FILTER
+#ifdef WITH_HUG_FILTER
 done:
 #endif
-  dbg_mutex_unlock();
+  hug_mutex_unlock();
 
   return result;
 }
diff --git a/hugin.h b/hugin.h
index 6d46b19..1effcd7 100644
--- a/hugin.h
+++ b/hugin.h
@@ -28,49 +28,49 @@
 #ifndef __HUGIN_HUGIN_H__
 #define __HUGIN_HUGIN_H__
 
-enum DBG_FLAG {
+enum HUG_FLAG {
   // Features
-#ifdef WITH_DBG_THREAD
-  DBG_FLAG_USE_THREAD       = 0x00000001,
+#ifdef WITH_HUG_THREAD
+  HUG_FLAG_USE_THREAD       = 0x00000001,
 #endif
-#ifdef WITH_DBG_MUTEX
-  DBG_FLAG_USE_MUTEX        = 0x00000002,
+#ifdef WITH_HUG_MUTEX
+  HUG_FLAG_USE_MUTEX        = 0x00000002,
 #endif
-#ifdef WITH_DBG_FILTER
-  DBG_FLAG_USE_FILTER       = 0x00000004,
+#ifdef WITH_HUG_FILTER
+  HUG_FLAG_USE_FILTER       = 0x00000004,
 #endif
 
   // Outputs
-  DBG_FLAG_OUTPUT_TO_STDOUT = 0x00010000,
-  DBG_FLAG_OUTPUT_TO_STDERR = 0x00020000,
-  DBG_FLAG_OUTPUT_TO_FD     = 0x00040000,
-  DBG_FLAG_OUTPUT_TO_FILE   = 0x00080000,
-#ifdef WITH_DBG_SYSLOG
-  DBG_FLAG_OUTPUT_TO_SYSLOG = 0x00100000,
+  HUG_FLAG_OUTPUT_TO_STDOUT = 0x00010000,
+  HUG_FLAG_OUTPUT_TO_STDERR = 0x00020000,
+  HUG_FLAG_OUTPUT_TO_FD     = 0x00040000,
+  HUG_FLAG_OUTPUT_TO_FILE   = 0x00080000,
+#ifdef WITH_HUG_SYSLOG
+  HUG_FLAG_OUTPUT_TO_SYSLOG = 0x00100000,
 #endif
 
   // Default value of flags
-  DBG_FLAG_DEFAULT          = DBG_FLAG_OUTPUT_TO_STDOUT, // Output to stdout
+  HUG_FLAG_DEFAULT          = HUG_FLAG_OUTPUT_TO_STDOUT, // Output to stdout
 };
 
-enum DBG_OPTION {
+enum HUG_OPTION {
   /**
    * No more options / last option.  This is used
    * to terminate the VARARGs list.
    */
-  DBG_OPTION_END,
+  HUG_OPTION_END,
 
   /**
    * const char* argument containing a filename which will be used for log
-   * output. To be used with the DBG_FLAG_OUTPUT_TO_FILE flag.
+   * output. To be used with the HUG_FLAG_OUTPUT_TO_FILE flag.
    */
-  DBG_OPTION_FILENAME,
+  HUG_OPTION_FILENAME,
 
   /**
    * Integer argument describing a file descriptor which will be used for log
-   * output. To be used with the DBG_FLAG_OUTPUT_TO_FD flag.
+   * output. To be used with the HUG_FLAG_OUTPUT_TO_FD flag.
    */
-  DBG_OPTION_FD,
+  HUG_OPTION_FD,
 
   /**
    * Set this option to make the stdout output to be printed without any date
@@ -80,22 +80,22 @@ enum DBG_OPTION {
    *  0 := use date
    *  1 := do not use date.
    */
-  DBG_OPTION_STDOUT_NO_DATE,
+  HUG_OPTION_STDOUT_NO_DATE,
 
   /**
    * Host and port to use when logging on an external server.
    * Host is a const char* argument, port is an integer.
-   * To be used with the DBG_FLAG_USE_SYSLOG flag.
-   * Linux: If DBG_OPTION_SYSLOG_HOST is not supplied, the local syslog will be
+   * To be used with the HUG_FLAG_USE_SYSLOG flag.
+   * Linux: If HUG_OPTION_SYSLOG_HOST is not supplied, the local syslog will be
    * used.
-   * Windows: If DBG_OPTION_SYSLOG_HOST is not supplied an error will be
+   * Windows: If HUG_OPTION_SYSLOG_HOST is not supplied an error will be
    * returned by hugin_init.
-   * If DBG_OPTION_SYSLOG_PORT is not supplied, the default syslogd port will
+   * If HUG_OPTION_SYSLOG_PORT is not supplied, the default syslogd port will
    * be used (port 514).
    */
-#ifdef WITH_DBG_SYSLOG
-  DBG_OPTION_SYSLOG_HOST,
-  DBG_OPTION_SYSLOG_PORT,
+#ifdef WITH_HUG_SYSLOG
+  HUG_OPTION_SYSLOG_HOST,
+  HUG_OPTION_SYSLOG_PORT,
 #endif
 
   /**
@@ -105,36 +105,36 @@ enum DBG_OPTION {
    *     |  class[+-]channel
    *     |  [+-]all   
    */
-#ifdef WITH_DBG_FILTER
-  DBG_OPTION_FILTER,
+#ifdef WITH_HUG_FILTER
+  HUG_OPTION_FILTER,
 #endif
 };
 
 typedef enum {
-  DBG_STATUS_OK = 0,
-  DBG_STATUS_UNKNOWN_OPTION,
-  DBG_STATUS_ERROR,
-} dbg_status_t;
+  HUG_STATUS_OK = 0,
+  HUG_STATUS_UNKNOWN_OPTION,
+  HUG_STATUS_ERROR,
+} hug_status_t;
 
 /**
- * @param flags combination of DBG_FLAG values
+ * @param flags combination of HUG_FLAG values
  * @param ... list of options (type-value pairs,
- *        terminated with DBG_OPTION_END).
+ *        terminated with HUG_OPTION_END).
  * @return 0 on success, 1 on error.
  */
-dbg_status_t dbg_init(unsigned int flags, ...);
-void dbg_close();
+hug_status_t hug_init(unsigned int flags, ...);
+void hug_close();
 
 /**
  * Example of usage (use mutex protected calls, send output to file):
  *
- * dbg_status_t status;
- * status = hugin_init(DBG_FLAG_OUTPUT_TO_FILE | DBG_FLAG_USE_MUTEX,
- *                     DBG_OPTION_FILENAME, "/tmp/my.log",
-                       DBG_OPTION_END);
- * if(status != DBG_STATUS_OK) exit(1);
+ * hug_status_t status;
+ * status = hugin_init(HUG_FLAG_OUTPUT_TO_FILE | HUG_FLAG_USE_MUTEX,
+ *                     HUG_OPTION_FILENAME, "/tmp/my.log",
+                       HUG_OPTION_END);
+ * if(status != HUG_STATUS_OK) exit(1);
  * INFO(example, "We are up and running\n");
- * dbg_close();
+ * hug_close();
  */
 
 /**
diff --git a/hugin_filter.c b/hugin_filter.c
index dfd541f..f817145 100644
--- a/hugin_filter.c
+++ b/hugin_filter.c
@@ -30,8 +30,8 @@
 #include <string.h>
 #include <stdlib.h>
 
-#ifndef WITH_DBG_FILTER
-#warning hugin_filter.c compiled but WITH_DBG_FILTER not defined
+#ifndef WITH_HUG_FILTER
+#warning hugin_filter.c compiled but WITH_HUG_FILTER not defined
 #endif
 
 #define NELEM(x)	(sizeof(x)/sizeof((x)[0]))
@@ -49,7 +49,7 @@ static unsigned n_debug_channel = 0;
 // Default is to enable everything...
 static unsigned debug_flags = 0xffffffff;//(1<<__class_err)|(1<<__class_fixme);
 
-int dbg_filter_enabled(const enum __debug_class cl, const char *ch)
+int hug_filter_enabled(const enum __debug_class cl, const char *ch)
 {
 	unsigned i;
 	for(i = 0; i < n_debug_channel; i++) {
@@ -66,7 +66,7 @@ int dbg_filter_enabled(const enum __debug_class cl, const char *ch)
  *     |  class[+-]channel
  *     |  [+-]all
  */
-int dbg_filter_parse(const char *filter)
+int hug_filter_parse(const char *filter)
 {
 	char *s;
 	char *next;
diff --git a/hugin_filter.h b/hugin_filter.h
index 5ddd07b..7d2a09a 100644
--- a/hugin_filter.h
+++ b/hugin_filter.h
@@ -30,7 +30,7 @@
 
 #include "hugin.h"
 
-int dbg_filter_enabled(const enum __debug_class cl, const char *ch);
-int dbg_filter_parse(const char *filter);
+int hug_filter_enabled(const enum __debug_class cl, const char *ch);
+int hug_filter_parse(const char *filter);
 
 #endif/*__HUGIN_HUGIN_FILTER_H__*/
diff --git a/hugin_syslog.c b/hugin_syslog.c
index de93edb..75e2559 100644
--- a/hugin_syslog.c
+++ b/hugin_syslog.c
@@ -48,8 +48,8 @@ typedef int socket_t;
 
 #include "hugin_util.h"
 
-#ifndef WITH_DBG_SYSLOG
-#warning hugin_syslog.c compiled but WITH_DBG_SYSLOG not defined
+#ifndef WITH_HUG_SYSLOG
+#warning hugin_syslog.c compiled but WITH_HUG_SYSLOG not defined
 #endif
 
 #define SYSLOG_MSGLEN 1024
@@ -61,8 +61,8 @@ typedef int socket_t;
 
 #define SYSLOG_LENOFEXECNAME 256
 
-static int dbg_syslog_sock;
-static struct sockaddr_in dbg_syslog_sockaddr;
+static int hug_syslog_sock;
+static struct sockaddr_in hug_syslog_sockaddr;
 static pid_t pid;
 static char execname[SYSLOG_LENOFEXECNAME];
 
@@ -79,7 +79,7 @@ static void wsastartup()
 }
 #endif
 
-void dbg_syslog_init(const char* host, int port) 
+void hug_syslog_init(const char* host, int port) 
 {
 
 #ifdef WIN32
@@ -87,16 +87,16 @@ void dbg_syslog_init(const char* host, int port)
 #endif
 
   printf("Initializing syslog module remote %s:%d\n", host, port);
-  if ( (dbg_syslog_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+  if ( (hug_syslog_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
     fprintf(stderr, "Failed to create socket\n");
     return;  
   }
-  memset(&dbg_syslog_sockaddr, 0, sizeof(dbg_syslog_sockaddr));
-  dbg_syslog_sockaddr.sin_family = AF_INET;
-//  dbg_syslog_sockaddr.sin_addr.s_addr = inet_addr(host);
+  memset(&hug_syslog_sockaddr, 0, sizeof(hug_syslog_sockaddr));
+  hug_syslog_sockaddr.sin_family = AF_INET;
+//  hug_syslog_sockaddr.sin_addr.s_addr = inet_addr(host);
   struct hostent *hp = gethostbyname(host);
-  memcpy(&(dbg_syslog_sockaddr.sin_addr),*(hp->h_addr_list),sizeof(struct in_addr));
-  dbg_syslog_sockaddr.sin_port = htons(port);
+  memcpy(&(hug_syslog_sockaddr.sin_addr),*(hp->h_addr_list),sizeof(struct in_addr));
+  hug_syslog_sockaddr.sin_port = htons(port);
 
   // This implementation has all kind of possible errors:
   //   * It is Linux only
@@ -124,7 +124,7 @@ void dbg_syslog_init(const char* host, int port)
 }
 
 /*
-void dbg_syslog_createheader() {
+void hug_syslog_createheader() {
   const time_t rawtime = time(NULL);
   struct tm time;
   localtime_r(&rawtime, &time);
@@ -209,13 +209,13 @@ void dbg_syslog_createheader() {
  *
  * */
 
-void dbg_syslog_output(char* msg) 
+void hug_syslog_output(char* msg) 
 {
-  if(dbg_syslog_sock < 0) return;
+  if(hug_syslog_sock < 0) return;
 
   const time_t rawtime = time(NULL);
   struct tm time;
-  dbg_localtime(&rawtime, &time);
+  hug_localtime(&rawtime, &time);
   char buftime[SYSLOG_TIMELEN];
   strftime(buftime, SYSLOG_TIMELEN, "%b %e %H:%M:%S ", &time);
 
@@ -237,21 +237,21 @@ void dbg_syslog_output(char* msg)
 
 //  printf("Sending to syslog: %s\n", buf);
   int buf_len = strlen(buf);
-  if((sendto(dbg_syslog_sock, buf, buf_len, 0, (struct sockaddr *) &dbg_syslog_sockaddr, 
-             sizeof(dbg_syslog_sockaddr))) != buf_len) {
+  if((sendto(hug_syslog_sock, buf, buf_len, 0, (struct sockaddr *) &hug_syslog_sockaddr, 
+             sizeof(hug_syslog_sockaddr))) != buf_len) {
     fprintf(stderr, "Failed to send message successfully: %s\n", strerror(errno));
   }
 }
 
-void dbg_syslog_close() {
+void hug_syslog_close() {
   printf("Closing syslog module\n");
-  if(dbg_syslog_sock < 0) return;
+  if(hug_syslog_sock < 0) return;
 
 #ifdef WIN32
-  closesocket(dbg_syslog_sock);
+  closesocket(hug_syslog_sock);
   WSACleanup();
 #else
-  close(dbg_syslog_sock);
+  close(hug_syslog_sock);
 #endif
 }
 
diff --git a/hugin_syslog.h b/hugin_syslog.h
index 12d1479..c3c05fd 100644
--- a/hugin_syslog.h
+++ b/hugin_syslog.h
@@ -28,10 +28,10 @@
 #ifndef __HUGIN_HUGIN_SYSLOG_H__
 #define __HUGIN_HUGIN_SYSLOG_H__
 
-void dbg_syslog_init(const char* host, int port);
+void hug_syslog_init(const char* host, int port);
 
-void dbg_syslog_output(char* msg);
+void hug_syslog_output(char* msg);
 
-void dbg_syslog_close();
+void hug_syslog_close();
 
 #endif/*__HUGIN_HUGIN_SYSLOG_H__*/
diff --git a/hugin_util.h b/hugin_util.h
index 5a23e7e..9cf48ba 100644
--- a/hugin_util.h
+++ b/hugin_util.h
@@ -34,6 +34,6 @@
  * Threadsafe version of localtime (if compiled with mutex support).
  * See man page for the posix localtime_r function.
  */
-struct tm *dbg_localtime(const time_t *timep, struct tm *result);
+struct tm *hug_localtime(const time_t *timep, struct tm *result);
 
 #endif/*__HUGIN_HUGIN_UTIL_H__*/
diff --git a/main_complete.c b/main_complete.c
index c7796fa..a649078 100644
--- a/main_complete.c
+++ b/main_complete.c
@@ -39,23 +39,23 @@ int main(int argc, char *argv[])
   if(fd == -1) {
     return 1;
   }
-  dbg_status_t status = dbg_init(DBG_FLAG_USE_MUTEX |
-                                 DBG_FLAG_OUTPUT_TO_FILE |
-                                 DBG_FLAG_OUTPUT_TO_FD |
-                                 DBG_FLAG_OUTPUT_TO_STDOUT |
-                                 DBG_FLAG_OUTPUT_TO_SYSLOG |
-                                 DBG_FLAG_OUTPUT_TO_STDERR |
-                                 DBG_FLAG_USE_FILTER |
+  hug_status_t status = hug_init(HUG_FLAG_USE_MUTEX |
+                                 HUG_FLAG_OUTPUT_TO_FILE |
+                                 HUG_FLAG_OUTPUT_TO_FD |
+                                 HUG_FLAG_OUTPUT_TO_STDOUT |
+                                 HUG_FLAG_OUTPUT_TO_SYSLOG |
+                                 HUG_FLAG_OUTPUT_TO_STDERR |
+                                 HUG_FLAG_USE_FILTER |
                                  0,
-                                 DBG_OPTION_FD, fd,
-                                 DBG_OPTION_FILENAME, "/tmp/my2.log",
-                                 DBG_OPTION_STDOUT_NO_DATE, 1,
-                                 DBG_OPTION_SYSLOG_HOST, "127.0.0.1",
-                                 DBG_OPTION_SYSLOG_PORT, 514,
-                                 DBG_OPTION_FILTER, "+all",
-                                 DBG_OPTION_END);
+                                 HUG_OPTION_FD, fd,
+                                 HUG_OPTION_FILENAME, "/tmp/my2.log",
+                                 HUG_OPTION_STDOUT_NO_DATE, 1,
+                                 HUG_OPTION_SYSLOG_HOST, "127.0.0.1",
+                                 HUG_OPTION_SYSLOG_PORT, 514,
+                                 HUG_OPTION_FILTER, "+all",
+                                 HUG_OPTION_END);
 
-  if(status != DBG_STATUS_OK) {
+  if(status != HUG_STATUS_OK) {
     printf("Error: %d\n", status);
     return 1;
   }
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
 
   DEBUG(foo, "Or are we %d?", 42);
   
-  dbg_close();
+  hug_close();
 
   return 0;
 }
diff --git a/main_filter.c b/main_filter.c
index b2df29f..211e122 100644
--- a/main_filter.c
+++ b/main_filter.c
@@ -35,13 +35,13 @@
 
 int main(int argc, char *argv[])
 {
-  dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_STDOUT |
-                                 DBG_FLAG_USE_FILTER |
+  hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_STDOUT |
+                                 HUG_FLAG_USE_FILTER |
                                  0,
-                                 DBG_OPTION_FILTER, "-all,+example",
-                                 DBG_OPTION_END);
+                                 HUG_OPTION_FILTER, "-all,+example",
+                                 HUG_OPTION_END);
 
-  if(status != DBG_STATUS_OK) {
+  if(status != HUG_STATUS_OK) {
     printf("Error: %d\n", status);
     return 1;
   }
@@ -52,7 +52,7 @@ int main(int argc, char *argv[])
 
   DEBUG(foo, "Or are we %d?", 42);
   
-  dbg_close();
+  hug_close();
 
   return 0;
 }
diff --git a/main_mutex.c b/main_mutex.c
index 410e9ca..d3f16fb 100644
--- a/main_mutex.c
+++ b/main_mutex.c
@@ -35,12 +35,12 @@
 
 int main(int argc, char *argv[])
 {
-  dbg_status_t status = dbg_init(DBG_FLAG_USE_MUTEX |
-                                 DBG_FLAG_OUTPUT_TO_STDOUT |
+  hug_status_t status = hug_init(HUG_FLAG_USE_MUTEX |
+                                 HUG_FLAG_OUTPUT_TO_STDOUT |
                                  0,
-                                 DBG_OPTION_END);
+                                 HUG_OPTION_END);
 
-  if(status != DBG_STATUS_OK) {
+  if(status != HUG_STATUS_OK) {
     printf("Error: %d\n", status);
     return 1;
   }
@@ -51,7 +51,7 @@ int main(int argc, char *argv[])
 
   DEBUG(foo, "Or are we %d?", 42);
   
-  dbg_close();
+  hug_close();
 
   return 0;
 }
diff --git a/main_simple.c b/main_simple.c
index caad5f8..07b577d 100644
--- a/main_simple.c
+++ b/main_simple.c
@@ -40,17 +40,17 @@ int main(int argc, char *argv[])
     return 1;
   }
 
-  dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_FILE |
-                                 DBG_FLAG_OUTPUT_TO_FD |
-                                 DBG_FLAG_OUTPUT_TO_STDOUT |
-                                 DBG_FLAG_OUTPUT_TO_STDERR |
+  hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_FILE |
+                                 HUG_FLAG_OUTPUT_TO_FD |
+                                 HUG_FLAG_OUTPUT_TO_STDOUT |
+                                 HUG_FLAG_OUTPUT_TO_STDERR |
                                  0,
-                                 DBG_OPTION_FD, fd,
-                                 DBG_OPTION_FILENAME, "/tmp/my2.log",
-                                 DBG_OPTION_STDOUT_NO_DATE, 0,
-                                 DBG_OPTION_END);
+                                 HUG_OPTION_FD, fd,
+                                 HUG_OPTION_FILENAME, "/tmp/my2.log",
+                                 HUG_OPTION_STDOUT_NO_DATE, 0,
+                                 HUG_OPTION_END);
 
-  if(status != DBG_STATUS_OK) {
+  if(status != HUG_STATUS_OK) {
     printf("Error: %d\n", status);
     return 1;
   }
@@ -61,7 +61,7 @@ int main(int argc, char *argv[])
 
   DEBUG(foo, "Or are we %d?", 42);
   
-  dbg_close();
+  hug_close();
 
   return 0;
 }
diff --git a/main_simple.cc b/main_simple.cc
index c83cc05..c555fde 100644
--- a/main_simple.cc
+++ b/main_simple.cc
@@ -40,17 +40,17 @@ int main(int argc, char *argv[])
     return 1;
   }
 
-  dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_FILE |
-                                 DBG_FLAG_OUTPUT_TO_FD |
-                                 DBG_FLAG_OUTPUT_TO_STDOUT |
-                                 DBG_FLAG_OUTPUT_TO_STDERR |
+  hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_FILE |
+                                 HUG_FLAG_OUTPUT_TO_FD |
+                                 HUG_FLAG_OUTPUT_TO_STDOUT |
+                                 HUG_FLAG_OUTPUT_TO_STDERR |
                                  0,
-                                 DBG_OPTION_FD, fd,
-                                 DBG_OPTION_FILENAME, "/tmp/my2.log",
-                                 DBG_OPTION_STDOUT_NO_DATE, 0,
-                                 DBG_OPTION_END);
+                                 HUG_OPTION_FD, fd,
+                                 HUG_OPTION_FILENAME, "/tmp/my2.log",
+                                 HUG_OPTION_STDOUT_NO_DATE, 0,
+                                 HUG_OPTION_END);
 
-  if(status != DBG_STATUS_OK) {
+  if(status != HUG_STATUS_OK) {
     printf("Error: %d\n", status);
     return 1;
   }
@@ -61,7 +61,7 @@ int main(int argc, char *argv[])
 
   DEBUG(foo, "Or are we %d?", 42);
   
-  dbg_close();
+  hug_close();
 
   return 0;
 }
diff --git a/main_syslog.c b/main_syslog.c
index 29df99c..2ac99be 100644
--- a/main_syslog.c
+++ b/main_syslog.c
@@ -35,12 +35,12 @@
 
 int main(int argc, char *argv[])
 {
-  dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_SYSLOG,
-                                 DBG_OPTION_SYSLOG_HOST, "localhost",
-                                 DBG_OPTION_SYSLOG_PORT, 514,
-                                 DBG_OPTION_END);
+  hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_SYSLOG,
+                                 HUG_OPTION_SYSLOG_HOST, "localhost",
+                                 HUG_OPTION_SYSLOG_PORT, 514,
+                                 HUG_OPTION_END);
 
-  if(status != DBG_STATUS_OK) {
+  if(status != HUG_STATUS_OK) {
     printf("Error: %d\n", status);
     return 1;
   }
@@ -51,7 +51,7 @@ int main(int argc, char *argv[])
 
   DEBUG(foo, "Or are we %d?", 42);
   
-  dbg_close();
+  hug_close();
 
   return 0;
 }