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