src/tools/xml.h

Go to the documentation of this file.

/* BurrTools
 *
 * BurrTools is the legal property of its developers, whose
 * names are listed in the COPYRIGHT file, which is included
 * within the source distribution.
 *
 * This program 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.

 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef __XML_H__
#define __XML_H__

#include <vector>
#include <string>
#include <iostream>

#include <map>
#include <exception>

class xmlWriterException_c : public std::exception
{
  private:

    std::string text;

  public:

    xmlWriterException_c(const std::string & txt) : text(txt) {}
    ~xmlWriterException_c() throw() {}

    const char * what(void) const throw() { return text.c_str(); }

};

class xmlWriter_c
{
  private:

    std::ostream & stream;

    std::vector<std::string> tagStack;

    enum {
      StBase,        
      StInTag,       
      StInContent,   
    } state;

  public:

    xmlWriter_c(std::ostream & str);

    ~xmlWriter_c(void);

    void newTag(const std::string & name);

    void newAttrib(const std::string & attrib, const std::string & value);
    void newAttrib(const std::string & attrib, unsigned long value);
    void newAttrib(const std::string & attrib, signed long value);
    void newAttrib(const std::string & attrib, unsigned int value) { newAttrib(attrib, (unsigned long)value); }
    void newAttrib(const std::string & attrib, signed int value)  { newAttrib(attrib, (signed long)value); }

    void endTag(const std::string & name);

    void addContent(const std::string & text);
    void addContent(unsigned long val);
    void addContent(signed long val);
    void addContent(unsigned int val) { addContent((unsigned long)val); }
    void addContent(signed int val) { addContent((signed long)val); }
    std::ostream & addContent(void);
};

// this parser is taken from wsdlpull.sf.net, but heavily modified

class xmlParserException_c : public std::exception
{
  public:

    xmlParserException_c(std::string desc, std::string state, int line, int col);

    xmlParserException_c(std::string desc);

    ~xmlParserException_c() throw() {};

    const char * what(void) const throw() { return description.c_str(); }

  private:

    std::string description;
};

class xmlParser_c
{
  public:

    xmlParser_c(std::istream & is);
    xmlParser_c(void);

    ~xmlParser_c(void);

    std::string getInputEncoding(void);

    void defineEntityReplacementText(std::string entity, std::string value);

    int getDepth(void);

    std::string getPositionDescription(void);

    bool isWhitespace(void);

    std::string getText(void);

    const char *getTextCharacters(int *poslen);

    std::string getName(void)
    {
      return name;
    }

    std::string getPrefix(void)
    {
      return prefix;
    }

    bool isEmptyElementTag(void);

    int getAttributeCount(void)
    {
      return attributeCount;
    }

    std::string getAttributeName(int index);
    std::string getAttributePrefix(int index);
    std::string getAttributeValue(int index);

    std::string getAttributeValue(std::string name);

    int getEventType(void)
    {
      return type;
    }

    int next(void);
    int nextToken(void);
    int nextTag(void);
    void prevTag(void);

    void require(int type, std::string name);

    std::string nextText(void);

    void skipSubTree(void);

    enum
    {
      START_DOCUMENT,
      END_DOCUMENT,
      START_TAG,               
      END_TAG,                 
      TEXT,                    
      CDSECT,
      ENTITY_REF,
      IGNORABLE_WHITESPACE,
      PROCESSING_INSTRUCTION,
      COMMENT,
      DOCDECL,
      UNKNOWN
    };

    void exception(std::string desc);

  private:

    void commonInit (void);
    void initBuf (void);

    //returns the state name as  a std::string
    std::string state (int eventType);
    std::string *ensureCapacity (std::string * arr, int required);

    void nextImpl ();                             //throws IOException, XmlPullParserException
    int parseLegacy (bool push);

    //throws IOException, XmlPullParserException

    void parseDoctype (bool push);

    /* precondition: &lt;/ consumed */
    void parseEndTag ();
    int peekType ();
    std::string get (int pos);
    void push (int c);

    void parseStartTag (bool xmldecl);

    //vivek
    void pushEntity ();

    void pushText (int delimiter, bool resolveEntities);
    void read (char c);
    int read ();

    int peekbuf (int pos);
    std::string readName ();
    void skip ();
    std::string unexpected_eof;
    std::string illegal_type;
    int LEGACY;
    int XML_DECL;

    // general
    std::string version;
    bool standalone;

    //   private bool reportNspAttr;
    bool processNsp;
    bool relaxed;
    std::map < std::string, std::string > entityMap;
    int depth;
    std::vector < std::string > nspStack;
    std::vector < std::string > elementStack;
    int *nspCounts;
    int nspSize;


    std::string encoding;
    char *srcBuf;
    int srcPos;
    int srcCount;
    int srcBuflength;

    //    private bool eof;
    int line;
    int column;

    // txtbuffer
    char *txtBuf;
    int txtPos;
    int txtBufSize;

    // Event-related
    int type;
    std::string text;
    bool isWspace,skipNextTag;
    std::string Ns;
    std::string prefix;
    std::string name;
    bool degenerated;
    int attributeCount;
    std::vector < std::string > attributes;
    // source
    std::istream & reader;

    int peek[2];
    int peekCount;
    bool wasCR;
    bool unresolved;
    bool token;
};


#endif

---