xmlhdrparser.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef __TEXTWOLF_XML_HEADER_PARSER_HPP__
#define __TEXTWOLF_XML_HEADER_PARSER_HPP__
#include "textwolf/exception.hpp"
#include "textwolf/sourceiterator.hpp"
#include <cstdlib>

namespace textwolf {

class XmlHdrParser
        :public throws_exception
{
public:
        XmlHdrParser()
                :m_state(Init)
                ,m_attributetype(Encoding)
                ,m_idx(0)
                ,m_charsConsumed(0)
                ,m_zeroCount(0){}

        XmlHdrParser( const XmlHdrParser& o)
                :m_state(o.m_state)
                ,m_attributetype(o.m_attributetype)
                ,m_idx(o.m_idx)
                ,m_charsConsumed(o.m_charsConsumed)
                ,m_zeroCount(o.m_zeroCount)
                ,m_item(o.m_item)
                ,m_src(o.m_src){}


        void putInput( const char* src_, std::size_t srcsize_)
        {
                m_src.append( src_, srcsize_);
        }

        const std::string& consumedData() const
        {
                return m_src;
        }

        bool parse()
        {
                unsigned char ch = nextChar();
                for (;ch != 0; ch = nextChar())
                {
                        switch (m_state)
                        {
                                case Init:
                                        if (ch == '<')
                                        {
                                                m_state = ParseXmlOpen;
                                        }
                                        else if (ch <= 32)
                                        {
                                                continue;
                                        }
                                        else
                                        {
                                                setError( "expected open tag angle bracket '>'");
                                                return false;
                                        }
                                        break;

                                case ParseXmlOpen:
                                        if (ch == '?')
                                        {
                                                m_state = ParseXmlHdr;
                                        }
                                        else if (ch <= 32)
                                        {
                                                break;
                                        }
                                        else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_')
                                        {
                                                return true;
                                        }
                                        else
                                        {
                                                setError( "expected xml header question mark '?' after open tag angle bracket '<'");
                                                return false;
                                        }
                                        break;

                                case ParseXmlHdr:
                                        if (ch <= 32 || ch == '?')
                                        {
                                                if (m_item != "xml")
                                                {
                                                        setError( "expected '<?xml' as xml header start");
                                                        return false;
                                                }
                                                m_item.clear();
                                                if (ch == '?') return true; /*...."<?xml?>"*/

                                                m_state = FindAttributeName;
                                        }
                                        else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_')
                                        {
                                                m_item.push_back(ch);
                                                continue;
                                        }
                                        else if (ch == '>')
                                        {
                                                setError( "unexpected close angle bracket '>' in xml header after '<?xml'");
                                                return false;
                                        }
                                        else
                                        {
                                                setError( "expected '<?xml' as xml header start (invalid character)");
                                                return false;
                                        }
                                        break;

                                case FindAttributeName:
                                        if (ch <= 32)
                                        {
                                                continue;
                                        }
                                        else if (ch == '>' || ch == '?')
                                        {
                                                if (ch == '>')
                                                {
                                                        setError( "unexpected close angle bracket '>' in xml header (missing '?')");
                                                        return false;
                                                }
                                                return true;
                                        }
                                        else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_')
                                        {
                                                m_item.push_back(ch);
                                                m_state = ParseAttributeName;
                                        }
                                        else
                                        {
                                                setError( "invalid character in xml header attribute name");
                                                return false;
                                        }
                                        break;
                                case ParseAttributeName:
                                        if (ch <= 32 || ch == '=')
                                        {
                                                if (m_item == "encoding")
                                                {
                                                        m_attributetype = Encoding;
                                                }
                                                else if (m_item == "version")
                                                {
                                                        m_attributetype = Version;
                                                }
                                                else if (m_item == "standalone")
                                                {
                                                        m_attributetype = Standalone;
                                                }
                                                else
                                                {
                                                        setError( "unknown xml header attribute name");
                                                        return false;
                                                }
                                                m_item.clear();
                                                if (ch == '=')
                                                {
                                                        m_state = FindAttributeValue;
                                                        continue;
                                                }
                                                m_state = FindAttributeAssign;
                                        }
                                        else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_')
                                        {
                                                m_item.push_back(ch);
                                                continue;
                                        }
                                        else
                                        {
                                                setError( "invalid character in xml header attribute name");
                                                return false;
                                        }
                                        break;
                                case FindAttributeAssign:
                                        if (ch == '=')
                                        {
                                                m_state = FindAttributeValue;
                                        }
                                        else if (ch <= 32)
                                        {
                                                continue;
                                        }
                                        else
                                        {
                                                setError( "expected '=' after xml header attribute name");
                                                return false;
                                        }
                                        break;
                                case FindAttributeValue:
                                        if (ch == '"')
                                        {
                                                m_state = ParseAttributeValueDq;
                                                continue;
                                        }
                                        else if (ch == '\'')
                                        {
                                                m_state = ParseAttributeValueSq;
                                                continue;
                                        }
                                        else if (ch <= 32)
                                        {
                                                continue;
                                        }
                                        else
                                        {
                                                setError( "expected single or double quote string as xml header attribute value");
                                                return false;
                                        }
                                        break;
                                case ParseAttributeValueSq:
                                        if (ch == '\'')
                                        {
                                                switch (m_attributetype)
                                                {
                                                        case Encoding:
                                                                m_encoding = m_item;
                                                                break;
                                                        case Version:
                                                        case Standalone:
                                                                break;
                                                }
                                                m_item.clear();
                                                m_state = FindAttributeName;
                                                continue;
                                        }
                                        else
                                        {
                                                m_item.push_back( ch);
                                        }
                                        break;
                                case ParseAttributeValueDq:
                                        if (ch == '\"')
                                        {
                                                switch (m_attributetype)
                                                {
                                                        case Encoding:
                                                                m_encoding = m_item;
                                                                break;
                                                        case Version:
                                                        case Standalone:
                                                                break;
                                                }
                                                m_item.clear();
                                                m_state = FindAttributeName;
                                                continue;
                                        }
                                        else
                                        {
                                                m_item.push_back( ch);
                                        }
                                        break;
                        }/*switch(..)*/
                }/*for(;..;..)*/
                return false;
        }

        const char* lasterror() const
        {
                return m_lasterror.empty()?0:m_lasterror.c_str();
        }

        const char* encoding() const
        {
                return m_encoding.empty()?0:m_encoding.c_str();
        }

        std::size_t charsConsumed() const
        {
                return m_charsConsumed;
        }

        void clear()
        {
                m_state = Init;
                m_attributetype = Encoding;
                m_idx = 0;
                m_charsConsumed = 0;
                m_zeroCount = 0;
                m_item.clear();
                m_src.clear();
                m_encoding.clear();
                m_lasterror.clear();
        }

private:
        void setError( const std::string& m)
        {
                m_lasterror = m;
        }

        unsigned char nextChar()
        {
                for (; m_zeroCount<4; m_zeroCount++)
                {
                        if (m_idx >= m_src.size()) return 0;
                        unsigned char ch = m_src[m_idx];
                        ++m_idx;
                        if (ch != 0)
                        {
                                m_zeroCount = 0;
                                if (ch > 32)
                                {
                                        ++m_charsConsumed;
                                }
                                return ch;
                        }
                }
                throw exception( IllegalXmlHeader);
        }

        enum State
        {
                Init,
                ParseXmlOpen,
                ParseXmlHdr,
                FindAttributeName,
                ParseAttributeName,
                FindAttributeAssign,
                FindAttributeValue,
                ParseAttributeValueSq,
                ParseAttributeValueDq
        };

        enum AttributeType
        {
                Encoding,
                Version,
                Standalone
        };

        static const char* stateName( State i)
        {
                static const char* ar[] = {"Init","ParseXmlOpen","ParseXmlHdr","FindAttributeName","ParseAttributeName","FindAttributeAssign","FindAttributeValue","ParseAttributeValueSq","ParseAttributeValueDq"};
                return ar[ (int)i];
        }

private:
        State m_state;                  
        AttributeType m_attributetype;  
        std::size_t m_idx;              
        std::size_t m_charsConsumed;    
        std::size_t m_zeroCount;        
        std::string m_item;             
        std::string m_src;              
        std::string m_encoding;         
        std::string m_lasterror;        
};

}//namespace
#endif