summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/debug.cc253
-rw-r--r--src/debug.h133
-rw-r--r--src/log.cc43
-rw-r--r--src/log.h38
-rw-r--r--src/saxparser.cc412
-rw-r--r--src/saxparser.h152
-rw-r--r--src/xml_encode_decode.cc103
-rw-r--r--src/xml_encode_decode.h35
8 files changed, 1169 insertions, 0 deletions
diff --git a/src/debug.cc b/src/debug.cc
new file mode 100644
index 0000000..c68ce2d
--- /dev/null
+++ b/src/debug.cc
@@ -0,0 +1,253 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set et sw=2 ts=2: */
+/***************************************************************************
+ * debug.cc
+ *
+ * Wed Feb 11 11:22:12 CET 2009
+ * Copyright 2009 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Pracro.
+ *
+ * Pracro 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.
+ *
+ * Pracro 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 Pracro; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#include "debug.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <string>
+
+#include "log.h"
+
+static FILE *logfp = stderr;
+
+#define NELEM(x) (sizeof(x)/sizeof((x)[0]))
+struct __debug_channel
+{
+ char name[32];
+ unsigned flags;
+};
+
+static const char * const debug_class_str[] =
+ { "fixme", "err", "warn", "info", "debug" };
+
+#define __DEBUG_CHANNEL_MAX 256
+
+static struct __debug_channel debug_channel[__DEBUG_CHANNEL_MAX];
+static unsigned n_debug_channel = 0;
+static unsigned debug_flags = (1 << __class_err) | (1 << __class_fixme);
+
+static int __debug_enabled(const enum __debug_class cl, const char *ch)
+{
+ unsigned i;
+ for(i = 0; i < n_debug_channel; i++) {
+ if(!strcmp(ch, debug_channel[i].name)) {
+ return (debug_channel[i].flags & (1 << cl)) != 0;
+ }
+ }
+ return debug_flags & (1 << cl);
+}
+
+
+#ifdef WITH_DEBUG
+int __debug(const char *func, const int line,
+ const enum __debug_class cl,
+ const char *ch, const char *fmt, ...)
+{
+ int ret = 0;
+ if(__debug_enabled(cl, ch)) {
+ if((unsigned)cl < NELEM(debug_class_str))
+ ret += fprintf(logfp, "%s:%s:%s:%d ",
+ debug_class_str[(unsigned)cl], ch, func, line);
+ if(fmt) {
+ va_list va;
+ va_start(va, fmt);
+ ret += vfprintf(logfp, fmt, va);
+ va_end(va);
+ }
+ }
+ if(ret){
+ fflush(logfp);
+ }
+ return ret;
+}
+
+int __debug_va(const char *func, const int line,
+ const enum __debug_class cl,
+ const char *ch, const char *fmt, va_list va)
+{
+ int ret = 0;
+ if(__debug_enabled(cl, ch)) {
+ if((unsigned)cl < NELEM(debug_class_str))
+ ret += fprintf(logfp, "%s:%s:%s:%d ",
+ debug_class_str[(unsigned)cl], ch, func, line);
+ if(fmt)
+ ret += vfprintf(logfp, fmt, va);
+ }
+ if(ret) {
+ fflush(logfp);
+ }
+ return ret;
+}
+
+#endif
+
+int __log(const char *func, const int line, const enum __debug_class cl,
+ const char *ch, const char *fmt, ...)
+{
+ std::string logmsg;
+ char str[8];
+
+#ifdef WITH_DEBUG
+ int ret = 0;
+#endif
+ if(__debug_enabled(cl, ch)) {
+ if((unsigned)cl < NELEM(debug_class_str))
+ if((unsigned)cl < NELEM(debug_class_str))
+#ifdef WITH_DEBUG
+ ret = fprintf(logfp, "%s:%s:%s:%d ", debug_class_str[(unsigned)cl], ch, func, line);
+#endif
+ sprintf(str, "%d", line);
+ logmsg = std::string(debug_class_str[(unsigned)cl]) + ":" + ch + ":" + func + ":" + str;
+ if(fmt) {
+ va_list va;
+ va_start(va, fmt);
+#ifdef WITH_DEBUG
+ ret += vfprintf(logfp, fmt, va);
+#endif
+ char* ptr;
+ if(vasprintf(&ptr, fmt, va) == -1) {}
+ logmsg += ptr;
+ va_end(va);
+ }
+ }
+#ifdef WITH_DEBUG
+ if(ret) {
+ fprintf(logfp, "\n");
+ fflush(logfp);
+ }
+#endif
+ log(logmsg);
+ return logmsg.size();
+}
+
+int __log_va(const char *func, const int line, const enum __debug_class cl,
+ const char *ch, const char *fmt, va_list va)
+{
+ std::string logmsg;
+ char str[8];
+#ifdef WITH_DEBUG
+ int ret = 0;
+#endif
+ if(__debug_enabled(cl, ch)) {
+ if((unsigned)cl < NELEM(debug_class_str))
+#ifdef WITH_DEBUG
+ ret = fprintf(logfp, "%s:%s:%s:%d ", debug_class_str[(unsigned)cl], ch, func, line);
+#endif
+ sprintf(str, "%d", line);
+ logmsg = std::string(debug_class_str[(unsigned)cl]) + ":" + ch + ":" + func + ":" + str;
+ if(fmt) {
+#ifdef WITH_DEBUG
+ ret += vfprintf(logfp, fmt, va);
+#endif
+ char* ptr;
+ if(vasprintf(&ptr, fmt, va) == -1) {}
+ logmsg += ptr;
+ }
+ }
+#ifdef WITH_DEBUG
+ if(ret) {
+ fprintf(logfp, "\n");
+ fflush(logfp);
+ }
+#endif
+ return logmsg.size();
+}
+
+void debug_init(FILE *fp)
+{
+ logfp = fp;
+}
+
+
+/*
+ * fmt := [set[,set]*]*
+ * set := [+-]channel
+ * | class[+-]channel
+ * | [+-]all
+ */
+void debug_parse(const char *fmt)
+{
+ char *s;
+ char *next;
+ char *opt;
+
+ if(!(s = strdup(fmt))) return;
+
+ for(opt = s; opt; opt = next) {
+ int set = 0;
+ int clr = 0;
+ unsigned i;
+ if((next = strchr(opt, ','))) *next++ = '\0';
+ char *p = opt + strcspn(opt, "+-");
+ if(!*p) p = opt; // All chars -> a channel name
+ if(p > opt) {
+ // we have a class
+ for(i = 0; i < NELEM(debug_class_str); i++) {
+ int n = strlen(debug_class_str[i]);
+ if(n != (p - opt)) continue;
+ if(!memcmp(opt, debug_class_str[i], n)) {
+ // Found the class
+ if(*p == '+')
+ set = 1 << i;
+ else
+ clr = 1 << i;
+ break;
+ }
+ }
+ if(i == NELEM(debug_class_str)) continue;
+ } else {
+ if(*p == '-')
+ clr = ~0;
+ else
+ set = ~0;
+ }
+ if(*p == '+' || *p == '-') p++;
+ if(!*p) continue;
+ if(!strcmp("all", p)) {
+ debug_flags = (debug_flags & ~clr) | set;
+ } else {
+ if(strlen(p) >= sizeof(debug_channel[0].name)) continue;
+ for(i = 0; i < n_debug_channel; i++) {
+ if(!strcmp(p, debug_channel[i].name)) {
+ debug_channel[i].flags = (debug_channel[i].flags & ~clr) | set;
+ break;
+ }
+ }
+ if(i == n_debug_channel && n_debug_channel < __DEBUG_CHANNEL_MAX) {
+ strcpy(debug_channel[i].name, p);
+ debug_channel[i].flags = (debug_flags & ~clr) | set;
+ n_debug_channel++;
+ }
+ }
+ }
+ free(s);
+}
+
diff --git a/src/debug.h b/src/debug.h
new file mode 100644
index 0000000..a5f199d
--- /dev/null
+++ b/src/debug.h
@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set et sw=2 ts=2: */
+/***************************************************************************
+ * debug.h
+ *
+ * Wed Feb 11 11:22:12 CET 2009
+ * Copyright 2009 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Pracro.
+ *
+ * Pracro 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.
+ *
+ * Pentominos 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 Pentominos; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#ifndef __PENTOMINOS_DEBUG_H__
+#define __PENTOMINOS_DEBUG_H__
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#ifdef HAVE_CONFIG_H
+// For USE_EFENCE
+#include <config.h>
+#ifdef USE_EFENCE
+#include <new>
+#include <stdlib.h>
+#include <efencepp.h>
+#include <efence.h>
+
+// Lazy static alocations makes efence freak out.
+// Use this to use hardcoded values instead.
+// Currently it disables:
+// - gethostbyname
+// - getsockname
+// - getpeername
+// - iconv
+//#define BYPASS_STATICALLOCATIONS
+
+#endif/*USE_EFENCE*/
+#endif/*HAVE_CONFIG*/
+
+void debug_init(FILE *fp);
+void debug_parse(const char *fmt);
+
+enum __debug_class
+{
+ __class_fixme = 0,
+ __class_err = 1,
+ __class_warn = 2,
+ __class_info = 3,
+ __class_debug = 4
+};
+
+#ifdef WITH_DEBUG
+int __debug(const char *func, const int line, enum __debug_class cl,
+ const char *ch, const char *fmt, ...)
+ __attribute__((format (printf,5,6)));
+
+int __debug_va(const char *func, const int line, enum __debug_class cl,
+ const char *ch, const char *fmt, va_list va);
+
+#define __DEBUG_PRINT(cl, ch, fmt...) \
+ do { __debug(__func__, __LINE__, cl, ch, fmt); } while(0)
+#define __DEBUG_PRINT_VA(cl, ch, fmt, a) \
+ do { __debug_va(__func__, __LINE__, cl, ch, fmt, a); } while(0)
+#define __DEBUG(cl, ch, fmt...) \
+ __DEBUG_PRINT(__class##cl, #ch, fmt)
+#define __DEBUG_VA(cl, ch, fmt, a) \
+ __DEBUG_PRINT_VA(__class##cl, #ch, fmt, a)
+
+#define FIXME(ch, fmt...) __DEBUG(_fixme, ch, fmt)
+#define ERR(ch, fmt...) __DEBUG(_err, ch, fmt)
+#define WARN(ch, fmt...) __DEBUG(_warn, ch, fmt)
+#define INFO(ch, fmt...) __DEBUG(_info, ch, fmt)
+#define DEBUG(ch, fmt...) __DEBUG(_debug, ch, fmt)
+
+#define FIXME_VA(ch, fmt, a) __DEBUG_VA(_fixme, ch, fmt, a)
+#define ERR_VA(ch, fmt, a) __DEBUG_VA(_err, ch, fmt, a)
+#define WARN_VA(ch, fmt, a) __DEBUG_VA(_warn, ch, fmt, a)
+#define INFO_VA(ch, fmt, a) __DEBUG_VA(_info, ch, fmt, a)
+#define DEBUG_VA(ch, fmt, a) __DEBUG_VA(_debug, ch, fmt, a)
+
+#else
+
+// If we compile without debug support, we want them all to go away
+#define FIXME(ch, fmt...)
+#define INFO(ch, fmt...)
+#define WARN(ch, fmt...)
+#define ERR(ch, fmt...)
+#define DEBUG(ch, fmt...)
+#define FIXME_VA(ch, fmt...)
+#define INFO_VA(ch, fmt...)
+#define WARN_VA(ch, fmt...)
+#define ERR_VA(ch, fmt...)
+#define DEBUG_VA(ch, fmt...)
+
+#endif/*WITH_DEBUG*/
+
+int __log(const char *func, const int line,
+ enum __debug_class cl, const char *ch, const char *fmt, ...)
+ __attribute__((format (printf,5,6)));
+
+int __log_va(const char *func, const int line, enum __debug_class cl,
+ const char *ch, const char *fmt, va_list va);
+
+#define __LOG_PRINT(cl, ch, fmt...) \
+ do { __log(__func__, __LINE__, cl, ch, fmt); } while(0)
+#define __LOG_PRINT_VA(cl, ch, fmt, a) \
+ do { __log_va(__func__, __LINE__, cl, ch, fmt, a); } while(0)
+#define __LOG(cl, ch, fmt...) __LOG_PRINT(__class##cl, #ch, fmt)
+#define __LOG_VA(cl, ch, fmt, a) __LOG_PRINT_VA(__class##cl, #ch, fmt, a)
+
+#define INFO_LOG(ch, fmt...) __LOG(_info, ch, fmt)
+#define WARN_LOG(ch, fmt...) __LOG(_warn, ch, fmt)
+#define ERR_LOG(ch, fmt...) __LOG(_err, ch, fmt)
+#define INFO_LOG_VA(ch, fmt, a) __LOG_VA(_info, ch, fmt, a)
+#define WARN_LOG_VA(ch, fmt, a) __LOG_VA(_warn, ch, fmt, a)
+#define ERR_LOG_VA(ch, fmt, a) __LOG_VA(_err, ch, fmt, a)
+
+#endif/*__PENTOMINOS_DEBUG_H__*/
diff --git a/src/log.cc b/src/log.cc
new file mode 100644
index 0000000..fe72422
--- /dev/null
+++ b/src/log.cc
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ * log.cc
+ *
+ * Tue Oct 24 17:44:47 CEST 2006
+ * Copyright 2006 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Artefact.
+ *
+ * Artefact 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.
+ *
+ * Artefact 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 Artefact; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#include "log.h"
+
+#include "debug.h"
+
+#include <syslog.h>
+
+/*
+ void openlog(const char *ident, int option, int facility); // Optional
+ void syslog(int priority, const char *format, ...);
+ void closelog(void); // Optional
+*/
+
+void log(std::string message)
+{
+ syslog(LOG_CONS, // Write to console if error sending to system logger.
+ "%s", message.c_str());
+}
diff --git a/src/log.h b/src/log.h
new file mode 100644
index 0000000..14a5585
--- /dev/null
+++ b/src/log.h
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ * log.h
+ *
+ * Tue Oct 24 17:44:46 CEST 2006
+ * Copyright 2006 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Artefact.
+ *
+ * Artefact 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.
+ *
+ * Artefact 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 Artefact; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#ifndef __ARTEFACT_LOG_H__
+#define __ARTEFACT_LOG_H__
+
+#include <string>
+
+/**
+ * log appends a message to the syslog queue.\n
+ * @param message An STL string containing the string to be appended.
+ */
+void log(std::string message);
+
+#endif/*__ARTEFACT_LOG_H__*/
diff --git a/src/saxparser.cc b/src/saxparser.cc
new file mode 100644
index 0000000..14f204c
--- /dev/null
+++ b/src/saxparser.cc
@@ -0,0 +1,412 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ * saxparser.cc
+ *
+ * Mon Mar 24 14:40:15 CET 2008
+ * Copyright 2008 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Pracro.
+ *
+ * Pracro 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.
+ *
+ * Pracro 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 Pracro; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#include "saxparser.h"
+#include "debug.h"
+
+#include <string.h>
+#include <stdio.h>
+
+static void character_hndl(void *p, const XML_Char *s, int len)
+{
+ SAXParser *parser = (SAXParser*)XML_GetUserData(p);
+ std::string chars;
+ chars.append(s, len);
+ parser->characterData(chars);
+}
+
+static void start_hndl(void *p, const char *el, const char **attr)
+{
+ SAXParser *parser = (SAXParser*)XML_GetUserData(p);
+
+ // Convert to comfy C++ values...
+ std::string name = el;
+ std::map< std::string, std::string > attributes;
+
+ while(*attr) {
+ std::string at_name = *attr;
+ attr++;
+ std::string at_value = *attr;
+ attr++;
+
+ attributes.insert(make_pair(at_name, at_value));
+ }
+
+ if(parser->outertag == "") parser->outertag = name;
+
+ parser->startTag(name, attributes);
+}
+
+static void end_hndl(void *p, const char *el)
+{
+ SAXParser *parser = (SAXParser*)XML_GetUserData(p);
+ std::string name = el;
+
+ if(name == parser->outertag) parser->done = true;
+
+ parser->endTag(name);
+}
+
+
+SAXParser::SAXParser()
+{
+ p = XML_ParserCreate(NULL);
+ if(!p) {
+ ERR(sax, "Couldn't allocate memory for parser\n");
+ // throw Exception(...);
+ return;
+ }
+
+ // XML_SetEncoding(p, "UTF-8");
+ XML_SetUserData(p, this);
+ XML_UseParserAsHandlerArg(p);
+ XML_SetElementHandler(p, start_hndl, end_hndl);
+ XML_SetCharacterDataHandler(p, character_hndl);
+
+ bufferbytes = 0;
+ totalbytes = 0;
+ done = false;
+
+}
+
+SAXParser::~SAXParser()
+{
+ if(p) XML_ParserFree(p);
+}
+
+int SAXParser::parse()
+{
+ char buf[32];
+ int len;
+
+ do {
+ len = readData(buf, sizeof(buf) - 1);
+ if (! XML_Parse(p, buf, len, len == 0)) {
+ parseError(buf, len, XML_ErrorString(XML_GetErrorCode(p)),
+ (int)XML_GetCurrentLineNumber(p));
+ return 1;
+ }
+
+ memset(buf, 0, sizeof(buf));
+ } while(len);
+
+ return 0;
+}
+
+static bool iswhitespace(const char *buf, size_t size)
+{
+ for(size_t i = 0; i < size; i++)
+ if(buf[i] != ' ' && buf[i] != '\n' && buf[i] != '\t' && buf[i] != '\r')
+ return false;
+ return true;
+}
+
+bool SAXParser::parse(const char *data, size_t size)
+{
+ std::string xml;
+ xml.append(data, size);
+ DEBUG(sax, "parse %d bytes [%s]\n", size, xml.c_str());
+
+ if(data == NULL || size == 0) return done;
+
+ bufferbytes = size;
+ totalbytes += bufferbytes;
+
+ if(! XML_Parse(p, data, size, false) ) {
+ if(XML_GetErrorCode(p) == XML_ERROR_JUNK_AFTER_DOC_ELEMENT) return true;
+ if(XML_GetErrorCode(p) == XML_ERROR_FINISHED &&
+ iswhitespace(data, size)) return true;
+ if(done && XML_GetErrorCode(p) == XML_ERROR_UNCLOSED_TOKEN) return true;
+ parseError(data, size, XML_ErrorString(XML_GetErrorCode(p)),
+ (int)XML_GetCurrentLineNumber(p));
+ return false;
+ }
+
+ if(done) {
+ if(! XML_Parse(p, data, 0, true) ) {
+ if(XML_GetErrorCode(p) == XML_ERROR_JUNK_AFTER_DOC_ELEMENT) return true;
+ if(XML_GetErrorCode(p) == XML_ERROR_FINISHED &&
+ iswhitespace(data, size)) return true;
+ if(XML_GetErrorCode(p) == XML_ERROR_UNCLOSED_TOKEN) return true;
+ parseError(data, 0, XML_ErrorString(XML_GetErrorCode(p)),
+ (int)XML_GetCurrentLineNumber(p));
+ return false;
+ }
+ }
+
+ if(done) {
+ DEBUG(sax, "Got END_OF_DOCUMENT [%s] at %ld\n",
+ outertag.c_str(), XML_GetCurrentByteIndex(p));
+ }
+
+ return done;
+}
+
+void SAXParser::parseError(const char *buf, size_t len,
+ std::string error, int lineno)
+{
+ fprintf(stderr, "SAXParser error at line %d: %s\n", lineno, error.c_str());
+ fprintf(stderr, "\tBuffer %u bytes: [", len);
+ if(fwrite(buf, len, 1, stderr) != len) {}
+ fprintf(stderr, "]\n");
+ fflush(stderr);
+}
+
+unsigned int SAXParser::usedBytes()
+{
+ return bufferbytes + (XML_GetCurrentByteIndex(p) - totalbytes);
+}
+
+int SAXParser::readData(char *, size_t)
+{
+ return 0;
+}
+
+void SAXParser::endTag(std::string)
+{
+}
+
+void SAXParser::startTag(std::string, attributes_t &)
+{
+}
+
+void SAXParser::characterData(std::string &)
+{
+}
+
+#ifdef TEST_SAXPARSER
+//deps: log.cc debug.cc exception.cc
+//cflags: -I..
+//libs: -lexpat
+#include <test.h>
+
+#define XMLFILE "/tmp/saxparsertest.xml"
+
+#include "exception.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+#include <memory.h>
+
+static char xml[] =
+"<?xml version='1.0' encoding='UTF-8'?>\n"
+"<pracro version=\"1.0\" user=\"testuser\" cpr=\"1505050505\">\n"
+" <commit version=\"\" macro=\"referral\" template=\"amd_forunders\">\n"
+" <field value=\"Some docs\" name=\"referral.doctor\"/>\n"
+" <field value=\"DIMS\" name=\"referral.diagnosecode\"/>\n"
+" <field value=\"Avs\" name=\"referral.diagnose\"/>\n"
+" </commit>\n"
+"</pracro>\n \t\n\r"
+ ;
+
+static char xml_notrailingwhitespace[] =
+"<?xml version='1.0' encoding='UTF-8'?>\n"
+"<pracro version=\"1.0\" user=\"testuser\" cpr=\"1505050505\">\n"
+" <commit version=\"\" macro=\"referral\" template=\"amd_forunders\">\n"
+" <field value=\"Some docs\" name=\"referral.doctor\"/>\n"
+" <field value=\"DIMS\" name=\"referral.diagnosecode\"/>\n"
+" <field value=\"Avs\" name=\"referral.diagnose\"/>\n"
+" </commit>\n"
+"</pracro>"
+ ;
+
+static char xml_fail[] =
+"<?xml version='1.0' encoding='UTF-8'?>\n"
+"<pracro version=\"1.0\" user\"testuser\" cpr=\"1505050505\">\n"
+" <request macro=\"test\" template=\"test\"/>\n"
+"</pracro>\n"
+ ;
+
+static char xml_fail2[] =
+"<?xml version='1.0' encoding='UTF-8'?>\n"
+"<pracro version=\"1.0\" user\"testuser\" cpr=\"1505050505\">\n"
+" <request macro=\"test\" template=\"test\"/>\n"
+"</pracro>\n"
+"this is junk\n"
+ ;
+
+class MyFileParser :public SAXParser {
+public:
+ MyFileParser(const char *file) {
+ fd = open(file, O_RDONLY);
+ }
+
+ int readData(char *data, size_t size) {
+ return read(fd, data, size);
+ }
+
+ void startTag(std::string name, attributes_t &attributes)
+ {
+ //printf("<%s>\n", name.c_str());
+ }
+
+ void parseError(const char *buf, size_t len, std::string error, int lineno)
+ {
+ throw Exception(error);
+ }
+
+private:
+ int fd;
+};
+
+class MyBufferParser :public SAXParser {
+public:
+ void startTag(std::string name, attributes_t &attributes)
+ {
+ //printf("<%s>\n", name.c_str());
+ }
+
+ void parseError(char *buf, size_t len, std::string error, int lineno)
+ {
+ throw Exception(error);
+ }
+};
+
+TEST_BEGIN;
+
+FILE *fp = fopen(XMLFILE, "w");
+TEST_NOTEQUAL(fp, NULL, "Test if file \""XMLFILE"\" could be written.");
+if(!fp) TEST_FATAL("Could not write "XMLFILE);
+fprintf(fp, "%s", xml);
+fclose(fp);
+
+TEST_MSG("Test callback parser.");
+{
+ MyFileParser parser(XMLFILE);
+ parser.parse();
+}
+
+TEST_MSG("Test buffer parser.");
+for(size_t sz = 1; sz < 1000; sz++) {
+ bool test = false;
+ MyBufferParser parser;
+ std::string buf = xml;
+ size_t pos = 0;
+ while(pos < buf.length()) {
+ std::string substr = buf.substr(pos, sz);
+
+ try {
+ test |= parser.parse((char*)substr.c_str(), substr.length());
+ } catch(Exception &e) {
+ TEST_TRUE(true, "Buffer parser failed on size %d: %s [%s]",
+ sz, e.what(), substr.c_str());
+ }
+ pos += sz;
+ }
+
+ TEST_TRUE(test, "Test buffer parser on %d bytes", sz);
+ }
+
+fp = fopen(XMLFILE, "w");
+TEST_NOTEQUAL(fp, NULL, "Test if file \""XMLFILE"\" could be written.");
+if(!fp) TEST_FATAL("Could not write "XMLFILE);
+fprintf(fp, "%s", xml_notrailingwhitespace);
+fprintf(fp, "%s", xml_notrailingwhitespace);
+fclose(fp);
+
+TEST_MSG("Test buffer parser with multiple documents in the same buffer.");
+{
+ fp = fopen(XMLFILE, "r");
+ TEST_NOTEQUAL(fp, NULL, "Test if file \""XMLFILE"\" could be read.");
+ if(!fp) TEST_FATAL("Could not read from "XMLFILE);
+
+ for(size_t sz = 1; sz < 1000; sz++) {
+ MyBufferParser *parser = NULL;
+ rewind(fp);
+ size_t numdocs = 0;
+ char *buf = new char[sz + 1];
+ memset(buf, 0, sz + 1);
+ size_t size;
+ while( (size = fread(buf, 1, sz, fp)) > 0) {
+ while(size) {
+ if(parser == NULL) {
+ parser = new MyBufferParser();
+ }
+ if(parser->parse(buf, size)) {
+
+ // Got one
+ numdocs++;
+
+ size = size - parser->usedBytes();
+ strcpy(buf, buf + parser->usedBytes());
+ delete parser; parser = NULL;
+ } else {
+ size = 0;
+ memset(buf, 0, sz + 1);
+ }
+ }
+ }
+ TEST_EQUAL(numdocs, 2, "Test if 2 documents were parsed on docsize %d.", sz);
+ if(parser) delete parser; parser = NULL;
+ delete[] buf;
+ }
+ fclose(fp);
+}
+
+fp = fopen(XMLFILE, "w");
+TEST_NOTEQUAL(fp, NULL, "Test if file \""XMLFILE"\" could be written.");
+if(!fp) TEST_FATAL("Could not write "XMLFILE);
+fprintf(fp, "%s", xml_fail);
+fclose(fp);
+
+TEST_MSG("Test failure");
+{
+ MyFileParser parser(XMLFILE);
+ try {
+ parser.parse();
+ } catch(Exception &e) {
+ goto goon;
+ }
+ TEST_TRUE(false, "This test should fail...\n");
+}
+goon:
+
+fp = fopen(XMLFILE, "w");
+TEST_NOTEQUAL(fp, NULL, "Test if file \""XMLFILE"\" could be written.");
+if(!fp) TEST_FATAL("Could not write "XMLFILE);
+fprintf(fp, "%s", xml_fail2);
+fclose(fp);
+
+// Test failure
+{
+ MyFileParser parser(XMLFILE);
+ try {
+ parser.parse();
+ } catch(Exception &e) {
+ goto goonagain;
+ }
+ TEST_TRUE(false, "This test should fail...\n");
+}
+goonagain:
+
+unlink(XMLFILE);
+
+TEST_END;
+
+#endif/*TEST_SAXPARSER*/
diff --git a/src/saxparser.h b/src/saxparser.h
new file mode 100644
index 0000000..c303d41
--- /dev/null
+++ b/src/saxparser.h
@@ -0,0 +1,152 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ * saxparser.h
+ *
+ * Mon Mar 24 14:40:15 CET 2008
+ * Copyright 2008 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Pracro.
+ *
+ * Pracro 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.
+ *
+ * Pracro 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 Pracro; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#ifndef __PRACRO_SAXPARSER_H__
+#define __PRACRO_SAXPARSER_H__
+
+#include <string>
+#include <map>
+#include <expat.h>
+
+typedef std::map< std::string, std::string> attributes_t;
+
+/**
+ * This class implements a SAX Parser, utilising the eXpat XML parser library.
+ * It uses virtual methods for the callbacks, and transforms tagnames and
+ * attributes into C++ values (std::string and std::vector).
+ */
+class SAXParser {
+public:
+ /**
+ * Constructor.
+ * It initialises the eXpat library.
+ */
+ SAXParser();
+
+ /**
+ * Destructor.
+ * It frees the eXpat library resources.
+ */
+ virtual ~SAXParser();
+
+ /**
+ * Call this method to use the reimplemented readData method for input.
+ * The entire document is parsed through this single call.
+ * @return An integer wityh value 0 on success, or 1 on failure.
+ * @see int readData(char *data, size_t size)
+ */
+ int parse();
+
+ /**
+ * Character data callback method.
+ * Reimplement this to get character callbacks.
+ * This callback might be called several times, if a character block is big.
+ * In that cae it might be nessecary to buffer to received bytes.
+ * @param data A std::string containing the character data.
+ */
+ virtual void characterData(std::string &data);
+
+ /**
+ * Start tag callback mehtod.
+ * Reimplement this to get start tag callbacks.
+ * It is called each time a new start tag is seen.
+ * @param name A std::string containing the tag name.
+ * @param attributes A std::map of std::string to std::string containing all
+ * attributes for the tag.
+ */
+ virtual void startTag(std::string name, attributes_t &attr);
+
+ /**
+ * End tag callback mehtod.
+ * Reimplement this to get end tag callbacks.
+ * It is called each time an end tag is seen.
+ * @param name A std::string containing the tag name.
+ */
+ virtual void endTag(std::string name);
+
+ /**
+ * Error callback method.
+ * Reimplement this to handle error messages.
+ * A default implementation prints out the current buffer, linenumber and
+ * error message to the screen.
+ * @param buf A char* containing the current buffer being parsed.
+ * @param len A size_t containing the length of the current buffer being
+ * parsed.
+ * @param error A std::string containing the error message.
+ * @param lineno An integer containing the line number on which the error
+ * occurred.
+ */
+ virtual void parseError(const char *buf, size_t len, std::string error,
+ int lineno);
+
+ /**
+ * Buffer parse method.
+ * Use this method to parse an external buffer with xml data.
+ * This method can be called several times (ie. in a read loop).
+ * @param buf A char* containing the buffer to parse.
+ * @param size A size_t comntaining the size of the buffer to parse.
+ * @return A boolean with the value true if a complete document has been seen.
+ * false otherwise.
+ * @see bool parse(char *buf, size_t size)
+ */
+ bool parse(const char *buf, size_t size);
+
+ /**
+ * Get the number of bytes used from the last buffer.
+ * If the buffer parse method is used, and the buffer comes from a stream of
+ * xml doxuments, this method can be used to figure out how many bytes from
+ * the stream should be replayed, to another parser.
+ * @return an integer containing the number of bytes used from the last
+ * buffer.
+ * @see bool parse(char *buf, size_t size)
+ */
+ unsigned int usedBytes();
+
+ // private stuff that needs to be public!
+ std::string outertag;
+ bool done;
+
+protected:
+ /**
+ * Read data callback method.
+ * This method is used when the parse() method is used.
+ * It can be used to connect the parser with eg. a file.
+ * @param data A char* containing the buffer to be filled.
+ * @param size A size_t containing the maximum number of bytes to be filled
+ * (ie. the size of data)
+ * @return An integer contaning the actual number of bytes filled. 0 if no
+ * more bytes are available.
+ * @see int parse()
+ */
+ virtual int readData(char *data, size_t size);
+
+ XML_Parser p;
+
+ unsigned int bufferbytes;
+ unsigned int totalbytes;
+};
+
+#endif/*__PRACRO_SAXPARSER_H__*/
diff --git a/src/xml_encode_decode.cc b/src/xml_encode_decode.cc
new file mode 100644
index 0000000..1c0e377
--- /dev/null
+++ b/src/xml_encode_decode.cc
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ * xml_encode_decode.cc
+ *
+ * Mon Jun 9 10:19:33 CEST 2008
+ * Copyright 2008 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Pracro.
+ *
+ * Pracro 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.
+ *
+ * Pracro 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 Pracro; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#include "xml_encode_decode.h"
+#include <string.h>
+/*
+char xml_map[][2][16] =
+ {
+ { "&", "&amp;" }, // & must be first
+ { "\'", "&apos;" },
+ { "\"", "&qout;" },
+ { ">", "&gt;" },
+ { "<", "&lt;" },
+ { "", "" } // End marker
+ };
+*/
+
+char xml_map[][2][16] =
+ {
+ { "&", "&#38;" }, // & must be first
+ { "\'", "&#39;" },
+ { "\"", "&#34;" },
+ { ">", "&#62;" },
+ { "<", "&#60;" },
+ { "", "" } // End marker
+ };
+
+#define MAX_MAPS 5
+
+std::string xml_encode(std::string str)
+{
+ size_t pos;
+
+ for( int map = 0; map < MAX_MAPS; map++ ) {
+ pos = 0;
+ while( ( pos = str.find(xml_map[map][0], pos) ) != std::string::npos) {
+ str.replace(pos, strlen(xml_map[map][0]), xml_map[map][1]);
+ pos += strlen(xml_map[map][1]);
+ }
+ }
+
+ return str;
+}
+
+std::string xml_decode(std::string str)
+{
+ size_t pos;
+
+ // Traverse backwards, to handle '&' last.
+ for( int map = MAX_MAPS - 1; map > -1; map-- ) {
+ pos = 0;
+ while( ( pos = str.find(xml_map[map][1], pos) ) != std::string::npos) {
+ str.replace(pos, strlen(xml_map[map][1]), xml_map[map][0]);
+ pos += strlen(xml_map[map][0]);
+ }
+ }
+
+ return str;
+}
+
+#ifdef TEST_XML_ENCODE_DECODE
+//deps:
+//cflags:
+//libs:
+#include <test.h>
+
+TEST_BEGIN;
+
+std::string in = "&A<B>C\"D\'<>\"&amp;E<>";
+std::string enc = xml_encode(in);
+std::string denc = xml_encode(enc);
+std::string dec = xml_decode(denc);
+std::string ddec = xml_decode(dec);
+
+TEST_EQUAL_STR(in, ddec, "compare");
+TEST_EQUAL_STR(enc, dec, "compare");
+
+TEST_END;
+
+#endif/*TEST_XML_ENCODE_DECODE*/
diff --git a/src/xml_encode_decode.h b/src/xml_encode_decode.h
new file mode 100644
index 0000000..39b1407
--- /dev/null
+++ b/src/xml_encode_decode.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ * xml_encode_decode.h
+ *
+ * Mon Jun 9 10:19:33 CEST 2008
+ * Copyright 2008 Bent Bisballe Nyeng
+ * deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ * This file is part of Pracro.
+ *
+ * Pracro 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.
+ *
+ * Pracro 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 Pracro; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+#ifndef __PRACRO_XML_ENCODE_DECODE_H__
+#define __PRACRO_XML_ENCODE_DECODE_H__
+
+#include <string>
+
+std::string xml_encode(std::string str);
+std::string xml_decode(std::string str);
+
+#endif/*__PRACRO_XML_ENCODE_DECODE_H__*/