xlnt/third-party/libstudxml/xml/parser.cxx

// file      : xml/parser.cxx
// copyright : Copyright (c) 2013-2017 Code Synthesis Tools CC
// license   : MIT; see accompanying LICENSE file

#include <new>     // std::bad_alloc
#include <cassert>
#include <cstring> // std::strchr
#include <istream>
#include <ostream>
#include <sstream>

#include <xml/parser>

using namespace std;

namespace xml
{
  // parsing
  //
  void parsing::
  init ()
  {
    ostringstream os;
    if (!name_.empty ())
      os << name_ << ':';
    os << line_ << ':' << column_ << ": error: " << description_;
    what_ = os.str ();
  }

  // parser::event_type
  //
  static const char* parser_event_str[] =
  {
    "start element",
    "end element",
    "start attribute",
    "end attribute",
    "characters",
    "start namespace declaration",
    "end namespace declaration",
    "end of file"
  };

  ostream&
  operator<< (ostream& os, parser::event_type e)
  {
    return os << parser_event_str[e];
  }

  // parser
  //
  parser::
  ~parser ()
  {
    if (p_ != 0)
      XML_ParserFree (p_);
  }

  void parser::
  init ()
  {
    depth_ = 0;
    state_ = state_next;
    event_ = eof;
    queue_ = eof;

    pqname_ = &qname_;
    pvalue_ = &value_;

    line_ = 0;
    column_ = 0;

    attr_i_ = 0;
    start_ns_i_ = 0;
    end_ns_i_ = 0;

    if ((feature_ & receive_attributes_map) != 0 &&
        (feature_ & receive_attributes_event) != 0)
      feature_ &= ~receive_attributes_map;

    // Allocate the parser. Make sure nothing else can throw after
    // this call since otherwise we will leak it.
    //
    p_ = XML_ParserCreateNS (0, XML_Char (' '));

    if (p_ == 0)
      throw bad_alloc ();

    // Get prefixes in addition to namespaces and local names.
    //
    XML_SetReturnNSTriplet (p_, true);

    // Set handlers.
    //
    XML_SetUserData(p_, this);

    if ((feature_ & receive_elements) != 0)
    {
      XML_SetStartElementHandler (p_, &start_element_);
      XML_SetEndElementHandler (p_, &end_element_);
    }

    if ((feature_ & receive_characters) != 0)
      XML_SetCharacterDataHandler (p_, &characters_);

    if ((feature_ & receive_namespace_decls) != 0)
      XML_SetNamespaceDeclHandler (p_,
                                   &start_namespace_decl_,
                                   &end_namespace_decl_);
  }

  void parser::
  handle_error ()
  {
    XML_Error e (XML_GetErrorCode (p_));

    if (e == XML_ERROR_ABORTED)
    {
      // For now we only abort the parser in the characters_() and
      // start_element_() handlers.
      //
      switch (content ())
      {
      case content_type::empty:
        throw parsing (*this, "characters in empty content");
      case content_type::simple:
        throw parsing (*this, "element in simple content");
      case content_type::complex:
        throw parsing (*this, "characters in complex content");
      default:
        assert (false);
      }
    }
    else
      throw parsing (iname_,
                     XML_GetCurrentLineNumber (p_),
                     XML_GetCurrentColumnNumber (p_),
                     XML_ErrorString (e));
  }

  struct stream_exception_controller
  {
    ~stream_exception_controller ()
    {
      istream::iostate s = is_.rdstate ();
      s &= ~istream::failbit;

      // If our error state (sans failbit) intersects with the
      // exception state then that means we have an active
      // exception and changing error/exception state will
      // cause another to be thrown.
      //
      if (!(old_state_ & s))
      {
        // Clear failbit if it was caused by eof.
        //
        if (is_.fail () && is_.eof ())
          is_.clear (s);

        is_.exceptions (old_state_);
      }
    }

    stream_exception_controller (istream& is)
      : is_ (is), old_state_ (is_.exceptions ())
    {
      is_.exceptions (old_state_ & ~istream::failbit);
    }

  private:
    stream_exception_controller (const stream_exception_controller&);

    stream_exception_controller&
    operator= (const stream_exception_controller&);

  private:
    istream& is_;
    istream::iostate old_state_;
  };

  parser::event_type parser::
  next ()
  {
    if (state_ == state_next)
      return next_ (false);
    else
    {
      // If we previously peeked at start/end_element, then adjust
      // state accordingly.
      //
      switch (event_)
      {
      case end_element:
        {
          if (!element_state_.empty () &&
              element_state_.back ().depth == depth_)
            pop_element ();

          depth_--;
          break;
        }
      case start_element:
        {
          depth_++;
          break;
        }
      default:
        break;
      }

      state_ = state_next;
      return event_;
    }
  }

  const string& parser::
  attribute (const qname_type& qn) const
  {
    if (const element_entry* e = get_element ())
    {
      attribute_map_type::const_iterator i (e->attr_map_.find (qn));

      if (i != e->attr_map_.end ())
      {
        if (!i->second.handled)
        {
          i->second.handled = true;
          e->attr_unhandled_--;
        }
        return i->second.value;
      }
    }

    throw parsing (*this, "attribute '" + qn.string () + "' expected");
  }

  string parser::
  attribute (const qname_type& qn, const string& dv) const
  {
    if (const element_entry* e = get_element ())
    {
      attribute_map_type::const_iterator i (e->attr_map_.find (qn));

      if (i != e->attr_map_.end ())
      {
        if (!i->second.handled)
        {
          i->second.handled = true;
          e->attr_unhandled_--;
        }
        return i->second.value;
      }
    }

    return dv;
  }

  bool parser::
  attribute_present (const qname_type& qn) const
  {
    if (const element_entry* e = get_element ())
    {
      attribute_map_type::const_iterator i (e->attr_map_.find (qn));

      if (i != e->attr_map_.end ())
      {
        if (!i->second.handled)
        {
          i->second.handled = true;
          e->attr_unhandled_--;
        }
        return true;
      }
    }

    return false;
  }

  void parser::
  next_expect (event_type e)
  {
    if (next () != e)
      throw parsing (*this, string (parser_event_str[e]) + " expected");
  }

  void parser::
  next_expect (event_type e, const string& ns, const string& n)
  {
    if (next () != e || namespace_ () != ns || name () != n)
      throw parsing (*this,
                     string (parser_event_str[e]) + " '" +
                     qname_type (ns, n).string () + "' expected");
  }

  string parser::
  element ()
  {
    content (content_type::simple);
    string r;

    // The content of the element can be empty in which case there
    // will be no characters event.
    //
    event_type e (next ());
    if (e == characters)
    {
      r.swap (value ());
      e = next ();
    }

    // We cannot really get anything other than end_element since
    // the simple content validation won't allow it.
    //
    assert (e == end_element);

    return r;
  }

  string parser::
  element (const qname_type& qn, const string& dv)
  {
    if (peek () == start_element && qname () == qn)
    {
      next ();
      return element ();
    }

    return dv;
  }

  const parser::element_entry* parser::
  get_element_ () const
  {
    // The start_element_() Expat handler may have already provisioned
    // an entry in the element stack. In this case, we need to get the
    // one before it, if any.
    //
    const element_entry* r (0);
    element_state::size_type n (element_state_.size () - 1);

    if (element_state_[n].depth == depth_)
      r = &element_state_[n];
    else if (n != 0 && element_state_[n].depth > depth_)
    {
      n--;
      if (element_state_[n].depth == depth_)
        r = &element_state_[n];
    }

    return r;
  }

  void parser::
  pop_element ()
  {
    // Make sure there are no unhandled attributes left.
    //
    const element_entry& e (element_state_.back ());
    if (e.attr_unhandled_ != 0)
    {
      // Find the first unhandled attribute and report it.
      //
      for (attribute_map_type::const_iterator i (e.attr_map_.begin ());
           i != e.attr_map_.end (); ++i)
      {
        if (!i->second.handled)
          throw parsing (
            *this, "unexpected attribute '" + i->first.string () + "'");
      }
      assert (false);
    }

    element_state_.pop_back ();
  }

  parser::event_type parser::
  next_ (bool peek)
  {
    event_type e (next_body ());

    // Content-specific processing. Note that we handle characters in the
    // characters_() Expat handler for two reasons. Firstly, it is faster
    // to ignore the whitespaces at the source. Secondly, this allows us
    // to distinguish between element and attribute characters. We can
    // move this processing to the handler because the characters event
    // is never queued.
    //
    switch (e)
    {
    case end_element:
      {
        // If this is a peek, then avoid popping the stack just yet.
        // This way, the attribute map will still be valid until we
        // call next().
        //
        if (!peek)
        {
          if (!element_state_.empty () &&
              element_state_.back ().depth == depth_)
            pop_element ();

          depth_--;
        }
        break;
      }
    case start_element:
      {
        if (const element_entry* e = get_element ())
        {
          switch (e->content)
          {
          case content_type::empty:
            throw parsing (*this, "element in empty content");
          case content_type::simple:
            throw parsing (*this, "element in simple content");
          default:
            break;
          }
        }

        // If this is a peek, then delay adjusting the depth.
        //
        if (!peek)
          depth_++;

        break;
      }
    default:
      break;
    }

    return e;
  }

  parser::event_type parser::
  next_body ()
  {
    // See if we have any start namespace declarations we need to return.
    //
    if (start_ns_i_ < start_ns_.size ())
    {
      // Based on the previous event determine what's the next one must be.
      //
      switch (event_)
      {
      case start_namespace_decl:
        {
          if (++start_ns_i_ == start_ns_.size ())
          {
            start_ns_i_ = 0;
            start_ns_.clear ();
            pqname_ = &qname_;
            break; // No more declarations.
          }
          // Fall through.
        }
      case start_element:
        {
          event_ = start_namespace_decl;
          pqname_ = &start_ns_[start_ns_i_];
          return event_;
        }
      default:
        {
          assert (false);
          return event_ = eof;
        }
      }
    }

    // See if we have any attributes we need to return as events.
    //
    if (attr_i_ < attr_.size ())
    {
      // Based on the previous event determine what's the next one must be.
      //
      switch (event_)
      {
      case start_attribute:
        {
          event_ = characters;
          pvalue_ = &attr_[attr_i_].value;
          return event_;
        }
      case characters:
        {
          event_ = end_attribute; // Name is already set.
          return event_;
        }
      case end_attribute:
        {
          if (++attr_i_ == attr_.size ())
          {
            attr_i_ = 0;
            attr_.clear ();
            pqname_ = &qname_;
            pvalue_ = &value_;
            break; // No more attributes.
          }
          // Fall through.
        }
      case start_element:
      case start_namespace_decl:
        {
          event_ = start_attribute;
          pqname_ = &attr_[attr_i_].qname;
          return event_;
        }
      default:
        {
          assert (false);
          return event_ = eof;
        }
      }
    }

    // See if we have any end namespace declarations we need to return.
    //
    if (end_ns_i_ < end_ns_.size ())
    {
      // Based on the previous event determine what's the next one must be.
      //
      switch (event_)
      {
      case end_namespace_decl:
        {
          if (++end_ns_i_ == end_ns_.size ())
          {
            end_ns_i_ = 0;
            end_ns_.clear ();
            pqname_ = &qname_;
            break; // No more declarations.
          }
          // Fall through.
        }
        // The end namespace declaration comes before the end element
        // which means it can follow pretty much any other event.
        //
      default:
        {
          event_ = end_namespace_decl;
          pqname_ = &end_ns_[end_ns_i_];
          return event_;
        }
      }
    }

    // Check the queue.
    //
    if (queue_ != eof)
    {
      event_ = queue_;
      queue_ = eof;

      line_ = XML_GetCurrentLineNumber (p_);
      column_ = XML_GetCurrentColumnNumber (p_);

      return event_;
    }

    // Reset the character accumulation flag.
    //
    accumulate_ = false;

    XML_ParsingStatus ps;
    XML_GetParsingStatus (p_, &ps);

    switch (ps.parsing)
    {
    case XML_INITIALIZED:
      {
        // As if we finished the previous chunk.
        break;
      }
    case XML_PARSING:
      {
        assert (false);
        return event_ = eof;
      }
    case XML_FINISHED:
      {
        return event_ = eof;
      }
    case XML_SUSPENDED:
      {
        switch (XML_ResumeParser (p_))
        {
        case XML_STATUS_SUSPENDED:
          {
            // If the parser is again in the suspended state, then
            // that means we have the next event.
            //
            return event_;
          }
        case XML_STATUS_OK:
          {
            // Otherwise, we need to get and parse the next chunk of data
            // unless this was the last chunk, in which case this is eof.
            //
            if (ps.finalBuffer)
              return event_ = eof;

            break;
          }
        case XML_STATUS_ERROR:
          handle_error ();
        }

        break;
      }
    }

    // Get and parse the next chunk of data until we get the next event
    // or reach eof.
    //
    if (!accumulate_)
      event_ = eof;

    XML_Status s;
    do
    {
      if (size_ != 0)
      {
        s = XML_Parse (p_,
                       static_cast <const char*> (data_.buf),
                       static_cast <int> (size_),
                       true);

        if (s == XML_STATUS_ERROR)
          handle_error ();

        break;
      }
      else
      {
        const size_t cap (4096);

        char* b (static_cast<char*> (XML_GetBuffer (p_, cap)));
        if (b == 0)
          throw bad_alloc ();

        // Temporarily unset the exception failbit. Also clear the fail bit
        // when we reset the old state if it was caused by eof.
        //
        istream& is (*data_.is);
        {
          stream_exception_controller sec (is);
          is.read (b, static_cast<streamsize> (cap));
        }

        // If the caller hasn't configured the stream to use exceptions,
        // then use the parsing exception to report an error.
        //
        if (is.bad () || (is.fail () && !is.eof ()))
          throw parsing (*this, "io failure");

        bool eof (is.eof ());

        s = XML_ParseBuffer (p_, static_cast<int> (is.gcount ()), eof);

        if (s == XML_STATUS_ERROR)
          handle_error ();

        if (eof)
          break;
      }
    } while (s != XML_STATUS_SUSPENDED);

    return event_;
  }

  static void
  split_name (const XML_Char* s, qname& qn)
  {
    string& ns (qn.namespace_ ());
    string& name (qn.name ());
    string& prefix (qn.prefix ());

    const char* p (strchr (s, ' '));

    if (p == 0)
    {
      ns.clear ();
      name = s;
      prefix.clear ();
    }
    else
    {
      ns.assign (s, 0, p - s);

      s = p + 1;
      p = strchr (s, ' ');

      if (p == 0)
      {
        name = s;
        prefix.clear ();
      }
      else
      {
        name.assign (s, 0, p - s);
        prefix = p + 1;
      }
    }
  }

  void XMLCALL parser::
  start_element_ (void* v, const XML_Char* name, const XML_Char** atts)
  {
    parser& p (*static_cast<parser*> (v));

    XML_ParsingStatus ps;
    XML_GetParsingStatus (p.p_, &ps);

    // Expat has a (mis)-feature of a possibily calling handlers even
    // after the non-resumable XML_StopParser call.
    //
    if (ps.parsing == XML_FINISHED)
      return;

    // Cannot be a followup event.
    //
    assert (ps.parsing == XML_PARSING);

    // When accumulating characters in simple content, we expect to
    // see more characters or end element. Seeing start element is
    // possible but means violation of the content model.
    //
    if (p.accumulate_)
    {
      // It would have been easier to throw the exception directly,
      // however, the Expat code is most likely not exception safe.
      //
      p.line_ = XML_GetCurrentLineNumber (p.p_);
      p.column_ = XML_GetCurrentColumnNumber (p.p_);
      XML_StopParser (p.p_, false);
      return;
    }

    p.event_ = start_element;
    split_name (name, p.qname_);

    p.line_ = XML_GetCurrentLineNumber (p.p_);
    p.column_ = XML_GetCurrentColumnNumber (p.p_);

    // Handle attributes.
    //
    if (*atts != 0)
    {
      bool am ((p.feature_ & receive_attributes_map) != 0);
      bool ae ((p.feature_ & receive_attributes_event) != 0);

      // Provision an entry for this element.
      //
      element_entry* pe (0);
      if (am)
      {
        p.element_state_.push_back (element_entry (p.depth_ + 1));
        pe = &p.element_state_.back ();
      }

      if (am || ae)
      {
        for (; *atts != 0; atts += 2)
        {
          if (am)
          {
            qname_type qn;
            split_name (*atts, qn);
            attribute_map_type::value_type v (qn, attribute_value_type ());
            v.second.value = *(atts + 1);
            v.second.handled = false;
            pe->attr_map_.insert (v);
          }
          else
          {
            p.attr_.push_back (attribute_type ());
            split_name (*atts, p.attr_.back ().qname);
            p.attr_.back ().value = *(atts + 1);
          }
        }

        if (am)
          pe->attr_unhandled_ = pe->attr_map_.size ();
      }
    }

    XML_StopParser (p.p_, true);
  }

  void XMLCALL parser::
  end_element_ (void* v, const XML_Char* name)
  {
    parser& p (*static_cast<parser*> (v));

    XML_ParsingStatus ps;
    XML_GetParsingStatus (p.p_, &ps);

    // Expat has a (mis)-feature of a possibily calling handlers even
    // after the non-resumable XML_StopParser call.
    //
    if (ps.parsing == XML_FINISHED)
      return;

    // This can be a followup event for empty elements (<foo/>). In this
    // case the element name is already set.
    //
    if (ps.parsing != XML_PARSING)
      p.queue_ = end_element;
    else
    {
      split_name (name, p.qname_);

      // If we are accumulating characters, then queue this event.
      //
      if (p.accumulate_)
        p.queue_ = end_element;
      else
      {
        p.event_ = end_element;

        p.line_ = XML_GetCurrentLineNumber (p.p_);
        p.column_ = XML_GetCurrentColumnNumber (p.p_);
      }

      XML_StopParser (p.p_, true);
    }
  }

  void XMLCALL parser::
  characters_ (void* v, const XML_Char* s, int n)
  {
    parser& p (*static_cast<parser*> (v));

    XML_ParsingStatus ps;
    XML_GetParsingStatus (p.p_, &ps);

    // Expat has a (mis)-feature of a possibily calling handlers even
    // after the non-resumable XML_StopParser call.
    //
    if (ps.parsing == XML_FINISHED)
      return;

    content_type cont (p.content ());

    // If this is empty or complex content, see if these are whitespaces.
    //
    switch (cont)
    {
    case content_type::empty:
    case content_type::complex:
      {
        for (int i (0); i != n; ++i)
        {
          char c (s[i]);
          if (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09)
            continue;

          // It would have been easier to throw the exception directly,
          // however, the Expat code is most likely not exception safe.
          //
          p.line_ = XML_GetCurrentLineNumber (p.p_);
          p.column_ = XML_GetCurrentColumnNumber (p.p_);
          XML_StopParser (p.p_, false);
          break;
        }
        return;
      }
    default:
      break;
    }

    // Append the characters if we are accumulating. This can also be a
    // followup event for another character event. In this case also
    // append the data.
    //
    if (p.accumulate_ || ps.parsing != XML_PARSING)
    {
      assert (p.event_ == characters);
      p.value_.append (s, n);
    }
    else
    {
      p.event_ = characters;
      p.value_.assign (s, n);

      p.line_ = XML_GetCurrentLineNumber (p.p_);
      p.column_ = XML_GetCurrentColumnNumber (p.p_);

      // In simple content we need to accumulate all the characters
      // into a single event. To do this we will let the parser run
      // until we reach the end of the element.
      //
      if (cont == content_type::simple)
        p.accumulate_ = true;
      else
        XML_StopParser (p.p_, true);
    }
  }

  void XMLCALL parser::
  start_namespace_decl_ (void* v, const XML_Char* prefix, const XML_Char* ns)
  {
    parser& p (*static_cast<parser*> (v));

    XML_ParsingStatus ps;
    XML_GetParsingStatus (p.p_, &ps);

    // Expat has a (mis)-feature of a possibily calling handlers even
    // after the non-resumable XML_StopParser call.
    //
    if (ps.parsing == XML_FINISHED)
      return;

    p.start_ns_.push_back (qname_type ());
    p.start_ns_.back ().prefix () = (prefix != 0 ? prefix : "");
    p.start_ns_.back ().namespace_ () = (ns != 0 ? ns : "");
  }

  void XMLCALL parser::
  end_namespace_decl_ (void* v, const XML_Char* prefix)
  {
    parser& p (*static_cast<parser*> (v));

    XML_ParsingStatus ps;
    XML_GetParsingStatus (p.p_, &ps);

    // Expat has a (mis)-feature of a possibily calling handlers even
    // after the non-resumable XML_StopParser call.
    //
    if (ps.parsing == XML_FINISHED)
      return;

    p.end_ns_.push_back (qname_type ());
    p.end_ns_.back ().prefix () = (prefix != 0 ? prefix : "");
  }
}