---

parser.cc

/* Parser.cc
 *
 * Copyright (C) 2002 Christian Neumann
 *
 * This file is part of Libxmlight
 * 
 * Libxmlight 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.
 *
 * Libxmlight 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 Libxmlight; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <Parser.h>
#include <cctype>
#include <Exception.h>

using namespace xmlight;
using namespace std;

bool iselementchar(const char& c)
{
        return isalpha(c) || isdigit(c) || c == ':' || c == '-' || c == '_' || c == '.';
}

bool notelementchar(const char& c)
{
        return ! iselementchar(c);
}

inline void Parser::parse_tag() {

        string::const_iterator begin, mark, data_end;
        begin = data.begin();
        data_end = data.end();
        
        if(*begin == '/') {
                // end element
                mark = find_if(begin + 1, data_end, notelementchar);
                if(mark != data_end) { 
                        _on_error(string("Invalid char ") + *mark + string("in end-element <") + data + string(">"));
                }else {
                        string name(begin + 1, data_end);
                        on_end_element(name);
                        element_count--;
                }
        }else if(*begin == '!') {
                // External DTD Declaration
                return;
        }else if(*begin == '?') {
                // xml declaration / processor statement
                if(string(begin, begin + 14) == "?xml version=\"") {
                        if(has_xmldecl) {
                                _on_error("Document allready declared!");
                        }else {
                                //cout << "XML Declaration found" << endl;
                                has_xmldecl = true;
                        }
                }else {
                        //cout << "Prozessor Anweisung" << endl;
                }
        }else {
                // element 
                if(! has_root_element) has_root_element = true;
                bool without_end_element = false;
                if(data_end[-1] == '/') without_end_element = true;
                mark = find_if(begin, data_end, notelementchar);
                if(mark != data_end) {
                        // element with attributes
                        string name = string(begin, mark);
                        TAttributes attributes;
                        begin = mark;
                        
                        for(;;) {
                                string attr_name, attr_value;
                                mark = find_if(begin, data_end, iselementchar);
                                if(mark == data_end) {
                                        break;
                                }else if(*mark == '/' && (mark + 1) == data_end) {
                                        break;
                                }else {
                                        begin = mark;
                                        
                                        mark = find_if(begin, data_end, notelementchar);
                                        if(mark == data_end) {
                                                _on_error(string("Unexpected end in tag <") + data + string(">"));
                                                return;
                                        }else if(*mark == '=' && (mark[1] == '"' || mark[1] == '\'')) {
                                                ++mark;
                                                attr_name = string(begin, mark - 1);
                                                
                                                // get value of attribute
                                                
                                                begin = mark + 1;       

                                                mark = find(begin, data_end, *mark);
                                                if(mark == data_end) {
                                                        _on_error(string("Unexpected end in tag <") + data + string(">"));
                                                        return;
                                                }else {
                                                        attr_value = string(begin, mark);
                                                        begin = mark;
                                                }

                                        }else {
                                                _on_error(string("Invalid char ") + *mark + string(" in tag <") + data + string(">"));
                                                return;
                                        }
                                                
                                }
                                attributes.insert(make_pair(attr_name, attr_value));
                        }
                        
                        on_start_element(name, attributes);
                        if(without_end_element) {
                                on_end_element(name);
                        }else {
                                ++element_count;
                        }
                        
                }else {
                        // element without attributes
                        on_start_element(data, TAttributes());
                        ++element_count;
                }
        }
}

void Parser::parse_string(const string& xmldata) 
{
        string::const_iterator position;

        for(position = xmldata.begin(); position != xmldata.end(); ++position) {
                if(parsing_tag) {
                        if(*position == '>') {
                                // tag ends
                                parsing_tag = false;
                                parse_tag();
                                data.clear();
                        }else if(*position == '[' && data == "![CDATA") {
                                //cout << "CDATA" << endl;
                                // CDATA tag, ignore
                                parsing_tag = false;
                                parsing_cdata = true;
                        }else if(*position == '-' && data == "!-") {
                                // comment
                                parsing_tag = false;
                                parsing_comment = true;
                                data.clear();
                        }else if(*position == '[' && string(data.begin(), data.begin() + 9) == "!DOCTYPE ") {
                                // DTD
                                //cout << "DTD" << endl;
                                parsing_tag = false;
                                parsing_dtd = true;
                                data.clear();
                        }else {
                                data.push_back(*position);
                        }
                }else if(parsing_comment) {
                        if(*position == '>' && data.size() >= 3 && string(data.end() - 2, data.end()) == "--") {
                                // end of comment
                                parsing_comment = false;
                                string comment = string(data.begin(), data.end() - 2);
                                on_comment(comment);
                                data.clear();
                        }else{
                                data.push_back(*position);
                        }
                }else if(parsing_cdata) {
                        if(*position == '>' && data.size() >= 2 && string(data.end() - 2, data.end()) == "]]") {
                                // end of cdata
                                parsing_cdata = false;
                                data.clear();
                        }else{
                                data.push_back(*position);
                        }
                }else if(parsing_dtd) {
                        if(*position == '<') {
                                ++dtd_count; 
                        }else if(*position == '>') {
                                if(dtd_count > 0) {
                                        dtd_count--;
                                }else {
                                        parsing_dtd = false;
                                }
                        }
                }else if(*position == '<') {
                        // new tag begins
                        if(has_root_element) {
                                on_data(data);
                                data.clear();
                        }
                        parsing_tag = true;
                }else if(has_root_element) {
                        // data
                        data.push_back(*position);

                }
                        
        } // for()

}

---