diff options
| -rw-r--r-- | src/debug.cc | 253 | ||||
| -rw-r--r-- | src/debug.h | 133 | ||||
| -rw-r--r-- | src/log.cc | 43 | ||||
| -rw-r--r-- | src/log.h | 38 | ||||
| -rw-r--r-- | src/saxparser.cc | 412 | ||||
| -rw-r--r-- | src/saxparser.h | 152 | ||||
| -rw-r--r-- | src/xml_encode_decode.cc | 103 | ||||
| -rw-r--r-- | src/xml_encode_decode.h | 35 |
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] = + { + { "&", "&" }, // & must be first + { "\'", "'" }, + { "\"", "&qout;" }, + { ">", ">" }, + { "<", "<" }, + { "", "" } // End marker + }; +*/ + +char xml_map[][2][16] = + { + { "&", "&" }, // & must be first + { "\'", "'" }, + { "\"", """ }, + { ">", ">" }, + { "<", "<" }, + { "", "" } // 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\'<>\"&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__*/ |