mootExpatParser.h

Go to the documentation of this file.

/* -*- Mode: C++ -*- */

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2003-2009 by Bryan Jurish <moocow@cpan.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
   
   This library 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
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/*--------------------------------------------------------------------------
 * File: mootExpatParser.h (formerly mootXmlParser.h)
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moocow's PoS tagger : expat wrapper
 *--------------------------------------------------------------------------*/

#ifndef _MOOT_EXPAT_PARSER_H
#define _MOOT_EXPAT_PARSER_H

#include <mootConfig.h>

#ifdef MOOT_EXPAT_ENABLED

#include <expat.h>

#include <stdexcept>

#include <mootCIO.h>
#include <mootCxxIO.h>
#include <mootBufferIO.h>



#define MOOT_DEFAULT_EXPAT_BUFLEN 8192

namespace moot {

/*--------------------------------------------------------------
 * TYPES
 */

  class mootExpatParser {
  public:
    /*----------------------------------------------------
     * mootExpatParser: ContextBuffer
     */

    class ContextBuffer : public mootio::micbuffer {
    public:
      ContextBuffer(const char *buffer, size_t buflen)
        : mootio::micbuffer(buffer, buflen)
      {};

      ContextBuffer(XML_Parser parser)
        : mootio::micbuffer(NULL,0)
      {
        assert(parser != NULL);
        int cb_offset_i, cb_used_i;
        cb_rdata  = XML_GetInputContext(parser, &cb_offset_i, &cb_used_i);
        cb_rdata += cb_offset_i;
        cb_offset = 0;
        cb_used   = XML_GetCurrentByteCount(parser);
      };
      ~ContextBuffer(void) {};

    }; //-- /class mootExpatParser::ContextBuffer

  public:
    /*----------------------------------------------------
     * mootExpatParser: Data
     */
    //-- i/o streams
    mootio::mistream *xp_istream;         
    bool              xp_istream_created; 


    //-- expat stuff
    char              *xml_buf;      
    size_t             xml_buflen;   
    std::string        xml_encoding; 
    //int                xml_done;     ///< whether we're done parsing yet
    XML_Parser         parser;       

 
  public:
    /*----------------------------------------------------
     * mootExpatParser: Constructor
     */
    mootExpatParser(size_t bufsize=MOOT_DEFAULT_EXPAT_BUFLEN,
                    const std::string &encoding="");

    virtual void setEncoding(const std::string &encoding="")
    {
      xml_encoding = encoding;
      reset();
    };

    virtual void reset(void);

    /*----------------------------------------------------
     * mootExpatParser: Destructor
     */
    virtual ~mootExpatParser(void);

    /*----------------------------------------------------*/

    virtual void from_mstream(mootio::mistream *mistreamp, bool autoclose=false);

    virtual void from_mstream(mootio::mistream &mistream, bool autoclose=false) { from_mstream(&mistream,autoclose); };

    virtual void from_filename(const char *filename);

    virtual void from_file(FILE *file);

    virtual void from_fd(int fd)
    {
      close();
      throw domain_error("from_fd(): not implemented");
    };
    
    virtual void from_buffer(const void *buf, size_t len);

    virtual void from_string(const char *s) { from_buffer(s,strlen(s)); };

    virtual void from_cxxstream(std::istream &is);

    virtual void close(void);

    /*----------------------------------------------------*/
    virtual bool parse_check(void);

    bool parse_filename(const std::string &filename);

    bool parse_file(FILE *infile=stdin, const std::string &in_name="");

    bool parse_buffer(const char *buf, size_t buflen);

    bool parse_all(mootio::mistream *in=NULL);

    bool parse_chunk(int &nbytes, int &is_final, mootio::mistream *in=NULL);

    /*----------------------------------------------------*/

    /*----------------------------------------------------
     * mootExpatParser: Printing and Context
     */
    virtual void context_dump(FILE *tofile=NULL);

    virtual std::string context_string(void)
    {
      return parser ? ContextBuffer(parser).as_string() : std::string("");
    };

    /*----------------------------------------------------
     * mootExpatParser: Error Reporting
     */
    virtual void carp(const char *fmt, ...);

    virtual void xpcarp(const char *fmt, ...);

    inline long int line_number(void)
    { return XML_GetCurrentLineNumber(parser); }

    inline int column_number(void)
    { return XML_GetCurrentColumnNumber(parser); }

    inline long byte_offset(void)
    { return XML_GetCurrentByteIndex(parser); }

    inline int byte_count(void)
    { return XML_GetCurrentByteCount(parser); }

    /*----------------------------------------------------
     * mootExpatParser: Handlers
     */
    virtual void XmlDeclHandler(const XML_Char  *version,
                                const XML_Char  *encoding,
                                int             standalone)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void StartElementHandler(const char *el, const char **attr)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void EndElementHandler(const char *el)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void CharacterDataHandler(const XML_Char *s, int len)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void ProcessingInstructionHandler(const XML_Char *s,
                                              const XML_Char *target,
                                              const XML_Char *data)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void CommentHandler(const XML_Char *s)
    {
      XML_DefaultCurrent(parser);
    };


    virtual void StartCdataSectionHandler(void)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void EndCdataSectionHandler(void)
    {
      XML_DefaultCurrent(parser);
    };

    virtual void DefaultHandler(const XML_Char *s, int len)
    {};

    /*----------------------------------------------------
     * mootExpatParser: Expat wrappers (static)
     */
    /* expat callback wrapper */
    static void _xp_XmlDeclHandler(mootExpatParser    *mp,
                                   const XML_Char  *version,
                                   const XML_Char  *encoding,
                                   int             standalone)
    {
      if (mp) mp->XmlDeclHandler(version,encoding,standalone);
    };

    /* expat callback wrapper */
    static void _xp_StartElementHandler(mootExpatParser *mp,
                                        const char *el,
                                        const char **attr)
    {
      if (mp) mp->StartElementHandler(el,attr);
    };

    /* expat callback wrapper */
    static void _xp_EndElementHandler(mootExpatParser *mp, const char *el)
    {
      if (mp) mp->EndElementHandler(el);
    };

    /* expat callback wrapper */
    static void _xp_CharacterDataHandler(mootExpatParser *mp,
                                         const XML_Char *s,
                                         int len)
    {
      if (mp) mp->CharacterDataHandler(s,len);
    };

    /* expat callback wrapper */
    static void _xp_CommentHandler(mootExpatParser *mp,
                                   const XML_Char *s)
    {
      if (mp) mp->CommentHandler(s);
    };

    /* expat callback wrapper */
    static void _xp_DefaultHandler(mootExpatParser *mp,
                                   const XML_Char *s,
                                   int len)
    {
      if (mp) mp->DefaultHandler(s,len);
    };
  };

}; // moot_END_NAMESPACE

#endif // moot_EXPAT_ENABLED

#endif // MOOT_EXPAT_PARSER_H