DeSR Dependency Parser

text/XmlReader.cpp

/*
**  Tanl C++ Library
**  text/XmlReader.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2008  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR 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, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

// standard
#include <string.h>

#include "XmlReader.h"

// define required default virtual method
int yyFlexLexer::yylex() { return 0; }

namespace Tanl {
namespace XML {

using namespace std;

XmlReader::XmlReader(istream& stream) :
  NodeType(None),
  state(Initial),
  depth(0),
  isEmptyElement(false),
  scanner(&stream)
{
}

bool XmlReader::Read() throw(XmlException)
{
  if (Eof())
    return false;
  state = Interactive;
  while (true) {
    Name.clear();
    Value.clear();
    int tokType = scanner.scan();
    switch (tokType) {
    case XML_DECL:
      NodeType = XmlDeclaration;
      Name = "xml";
      Value = string(scanner.YYText()+5, scanner.YYLeng()-7);
      return true;
    case PROC_INST:
      NodeType = ProcessingInstruction;
      // FIXME: should split into Name and Value
      Value = string(scanner.YYText()+2, scanner.YYLeng()-4);
      return true;
    case DOCTYPE:
      NodeType = DocumentType;
      // FIXME: should split into Name and Value
      Value = string(scanner.YYText()+10, scanner.YYLeng()-11);
      return true;
    case COMMENT:
      NodeType = Comment;
      Value = string(scanner.YYText()+4, scanner.YYLeng()-7);
      return true;
    case TAG_OPEN: {
      attrs.clear();
      attrIndex = 0;
      tokType = scanner.scan();
      if (tokType == ID) {
        NodeType = Element;
        Name = tagName = scanner.YYText();
      } else if (tokType == EndOfFile) {
        state = Error;
        throw XmlException("Premature EOF");
      } else {
        state = Error;
        throw XmlException("Syntax error: no element name");
      }
      // read attributes
      attrIndex = -1;
      bool moreAttr = true;
      while (moreAttr) {
        tokType = scanner.scan();
        switch (tokType) {
        case ID: {
          string name = scanner.YYText();
          switch (scanner.scan()) {
          case EQ:
            switch (scanner.scan()) {
            case VAL: {
              string value = scanner.YYText();
              attrs.push_back(NodeAttr(name, value));
              continue;
            }
            case EOF:
              state = Error;
              throw XmlException("Premature EOF");
            }
            break;
          case EOF:
            state = Error;
            throw XmlException("Premature EOF");
          default:
            state = Error;
            throw XmlException("Syntax error: no equal sign");
          }
        }
        case TAG_EMPTY:
          isEmptyElement = true;
          tagName.clear();
          return true;
        case TAG_END:
          moreAttr = false;
          break;
        }
      }
      ++depth;
      return true;
    }
    case TAG_CLOSE:
      tagName.clear();
      if (depth) {
        NodeType = EndElement;
        char const* text = scanner.YYText()+2;
        // trim whitespace
        char const* end = strpbrk(text, " \n\r\t>");
        Name = string(text, end - text);
        --depth;
        return true;
      } else {
        state = Error;
        throw XmlException("Syntax error: extra close tag");
      }
    case CHARACTERS:
      NodeType = Text;
      Value = scanner.YYText();
      return true;
    case RAW_CHARS:
      NodeType = CDATA;
      Value = scanner.YYText();
      return true;
    case WHITESPACE:
      NodeType = Whitespace;
      Value = scanner.YYText();
      return true;
    case EoF:
      state = EndOfFile;
      return false;
    default:
      state = Error;
      throw XmlException("Syntax error: ");
    }
  }
}

bool XmlReader::MoveToFirstAttribute()
{
  if (!attrs.size())
    return false;
  attrIndex = 0;
  NodeType = Attribute;
  Name = attrs[attrIndex].name;
  Value = attrs[attrIndex].value;
  return true;
}

bool XmlReader::MoveToNextAttribute()
{
  if (++attrIndex < attrs.size()) {
    NodeType = Attribute;
    Name = attrs[attrIndex].name;
    Value = attrs[attrIndex].value;
    return true;
  } else
    return false;
}

} // namespace XML
} // namespace Tanl

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.