src/pedro/pedrodom.h

   1 #ifndef __PEDRODOM_H__
   2 #define __PEDRODOM_H__
   3 /*
   4  * API for the Pedro mini-DOM parser and tree
   5  *
   6  * Authors:
   7  *   Bob Jamison
   8  *
   9  * Copyright (C) 2005-2007 Bob Jamison
  10  *
  11  *  This library is free software; you can redistribute it and/or
  12  *  modify it under the terms of the GNU Lesser General Public
  13  *  License as published by the Free Software Foundation; either
  14  *  version 2.1 of the License, or (at your option) any later version.
  15  *
  16  *  This library is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  Lesser General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU Lesser General Public
  22  *  License along with this library; if not, write to the Free Software
  23  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  24  */
  25
  26 #include <glib.h>
  27
  28 #include <string>
  29 #include <vector>
  30
  31
  32 namespace Pedro
  33 {
  34
  35 typedef std::string DOMString;
  36 typedef unsigned int XMLCh;
  37
  38
  39 class Namespace
  40 {
  41 public:
  42     Namespace()
  43         {}
  44
  45     Namespace(const DOMString &prefixArg, const DOMString &namespaceURIArg)
  46         {
  47         prefix       = prefixArg;
  48         namespaceURI = namespaceURIArg;
  49         }
  50
  51     Namespace(const Namespace &other)
  52         {
  53         assign(other);
  54         }
  55
  56     Namespace &operator=(const Namespace &other)
  57         {
  58         assign(other);
  59         return *this;
  60         }
  61
  62     virtual ~Namespace()
  63         {}
  64
  65     virtual DOMString getPrefix()
  66         { return prefix; }
  67
  68     virtual DOMString getNamespaceURI()
  69         { return namespaceURI; }
  70
  71 protected:
  72
  73     void assign(const Namespace &other)
  74         {
  75         prefix       = other.prefix;
  76         namespaceURI = other.namespaceURI;
  77         }
  78
  79     DOMString prefix;
  80     DOMString namespaceURI;
  81
  82 };
  83
  84 class Attribute
  85 {
  86 public:
  87     Attribute()
  88         {}
  89
  90     Attribute(const DOMString &nameArg, const DOMString &valueArg)
  91         {
  92         name  = nameArg;
  93         value = valueArg;
  94         }
  95
  96     Attribute(const Attribute &other)
  97         {
  98         assign(other);
  99         }
 100
 101     Attribute &operator=(const Attribute &other)
 102         {
 103         assign(other);
 104         return *this;
 105         }
 106
 107     virtual ~Attribute()
 108         {}
 109
 110     virtual DOMString getName()
 111         { return name; }
 112
 113     virtual DOMString getValue()
 114         { return value; }
 115
 116 protected:
 117
 118     void assign(const Attribute &other)
 119         {
 120         name  = other.name;
 121         value = other.value;
 122         }
 123
 124     DOMString name;
 125     DOMString value;
 126
 127 };
 128
 129
 130 class Element
 131 {
 132 friend class Parser;
 133
 134 public:
 135     Element()
 136         {
 137         parent = NULL;
 138         }
 139
 140     Element(const DOMString &nameArg)
 141         {
 142         parent = NULL;
 143         name   = nameArg;
 144         }
 145
 146     Element(const DOMString &nameArg, const DOMString &valueArg)
 147         {
 148         parent = NULL;
 149         name   = nameArg;
 150         value  = valueArg;
 151         }
 152
 153     Element(const Element &other)
 154         {
 155         assign(other);
 156         }
 157
 158     Element &operator=(const Element &other)
 159         {
 160         assign(other);
 161         return *this;
 162         }
 163
 164     virtual Element *clone();
 165
 166     virtual ~Element()
 167         {
 168         for (unsigned int i=0 ; i<children.size() ; i++)
 169             delete children[i];
 170         }
 171
 172     virtual DOMString getName()
 173         { return name; }
 174
 175     virtual DOMString getValue()
 176         { return value; }
 177
 178     Element *getParent()
 179         { return parent; }
 180
 181     Element *getFirstChild()
 182         { return (children.size() == 0) ? NULL : children[0]; }
 183
 184     std::vector<Element *> getChildren()
 185         { return children; }
 186
 187     std::vector<Element *> findElements(const DOMString &name);
 188
 189     DOMString getAttribute(const DOMString &name);
 190
 191     std::vector<Attribute> &getAttributes()
 192         { return attributes; }
 193
 194     DOMString getTagAttribute(const DOMString &tagName, const DOMString &attrName);
 195
 196     DOMString getTagValue(const DOMString &tagName);
 197
 198     void addChild(Element *child);
 199
 200     void addAttribute(const DOMString &name, const DOMString &value);
 201
 202     void addNamespace(const DOMString &prefix, const DOMString &namespaceURI);
 203
 204     bool exists(const DOMString &name)
 205         { return (findElements(name).size() > 0); }
 206
 207     /**
 208      * Prettyprint an XML tree to an output stream.  Elements are indented
 209      * according to element hierarchy.
 210      * @param f a stream to receive the output
 211      * @param elem the element to output
 212      */
 213     void writeIndented(FILE *f);
 214
 215     /**
 216      * Prettyprint an XML tree to standard output.  This is the equivalent of
 217      * writeIndented(stdout).
 218      * @param elem the element to output
 219      */
 220     void print();
 221
 222 protected:
 223
 224     void assign(const Element &other)
 225         {
 226         parent     = other.parent;
 227         children   = other.children;
 228         attributes = other.attributes;
 229         namespaces = other.namespaces;
 230         name       = other.name;
 231         value      = other.value;
 232         }
 233
 234     void findElementsRecursive(std::vector<Element *>&res, const DOMString &name);
 235
 236     void writeIndentedRecursive(FILE *f, int indent);
 237
 238     Element *parent;
 239
 240     std::vector<Element *>children;
 241
 242     std::vector<Attribute> attributes;
 243     std::vector<Namespace> namespaces;
 244
 245     DOMString name;
 246     DOMString value;
 247
 248 };
 249
 250
 251
 252
 253
 254 class Parser
 255 {
 256 public:
 257     /**
 258      * Constructor
 259      */
 260     Parser()
 261         { init(); }
 262
 263     virtual ~Parser()
 264         {}
 265
 266     /**
 267      * Parse XML in a char buffer.
 268      * @param buf a character buffer to parse
 269      * @param pos position to start parsing
 270      * @param len number of chars, from pos, to parse.
 271      * @return a pointer to the root of the XML document;
 272      */
 273     Element *parse(const char *buf,int pos,int len);
 274
 275     /**
 276      * Parse XML in a char buffer.
 277      * @param buf a character buffer to parse
 278      * @param pos position to start parsing
 279      * @param len number of chars, from pos, to parse.
 280      * @return a pointer to the root of the XML document;
 281      */
 282     Element *parse(const DOMString &buf);
 283
 284     /**
 285      * Parse a named XML file.  The file is loaded like a data file;
 286      * the original format is not preserved.
 287      * @param fileName the name of the file to read
 288      * @return a pointer to the root of the XML document;
 289      */
 290     Element *parseFile(const DOMString &fileName);
 291
 292     /**
 293      * Utility method to preprocess a string for XML
 294      * output, escaping its entities.
 295      * @param str the string to encode
 296      */
 297     static DOMString encode(const DOMString &str);
 298
 299     /**
 300      *  Removes whitespace from beginning and end of a string
 301      */
 302     DOMString trim(const DOMString &s);
 303
 304 private:
 305
 306     void init()
 307         {
 308         keepGoing       = true;
 309         currentNode     = NULL;
 310         parselen        = 0;
 311         parsebuf        = NULL;
 312         currentPosition = 0;
 313         }
 314
 315     void getLineAndColumn(long pos, long *lineNr, long *colNr);
 316
 317     void error(char *fmt, ...) G_GNUC_PRINTF(2,3);
 318
 319     int peek(long pos);
 320
 321     int match(long pos, const char *text);
 322
 323     int skipwhite(long p);
 324
 325     int getWord(int p0, DOMString &buf);
 326
 327     int getQuoted(int p0, DOMString &buf, int do_i_parse);
 328
 329     int parseVersion(int p0);
 330
 331     int parseDoctype(int p0);
 332
 333     int parseElement(int p0, Element *par,int depth);
 334
 335     Element *parse(XMLCh *buf,int pos,int len);
 336
 337     bool       keepGoing;
 338     Element    *currentNode;
 339     long       parselen;
 340     XMLCh      *parsebuf;
 341     DOMString  cdatabuf;
 342     long       currentPosition;
 343     int        colNr;
 344
 345 };
 346
 347
 348
 349 }//namespace Pedro
 350
 351
 352 #endif /* __PEDRODOM_H__ */
 353
 354 //########################################################################
 355 //#  E N D    O F    F I L E
 356 //########################################################################
 357