xml_scanner.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/base_header.hpp>
#include <kernel/util/exception.hpp>
#include <kernel/util/string.hpp>
 
// includes, system
#include <memory>
#include <iostream>
#include <fstream>
#include <deque>
#include <map>
 
namespace FEAT
{
  namespace Xml
  {
    class Error :
      public FEAT::Exception
    {
    private:
      int my_iline;
      String my_sline;
      String my_msg;
      String my_what;
 
    public:
      Error(int iline, const String& sline, const String& msg, const String& err_type) :
        FEAT::Exception("XML Error"),
        my_iline(iline),
        my_sline(sline),
        my_msg(msg),
        my_what(err_type + ": " + msg + " in line " + stringify(iline) + ": '" + sline + "'")
      {
      }
 
      int get_line_number() const
      {
        return my_iline;
      }
 
      const String& get_line_string() const
      {
        return my_sline;
      }
 
      const String& get_message() const
      {
        return my_msg;
      }
 
      virtual const char * what() const noexcept override
      {
        return my_what.c_str();
      }
    }; // class Error
 
    class SyntaxError
      : public Error
    {
    public:
      SyntaxError(int iline, const String& sline, const String& msg) :
        Error(iline, sline, msg, "XML Syntax Error")
      {
      }
    }; // class SyntaxError
 
    class GrammarError
      : public Error
    {
    public:
      GrammarError(int iline, const String& sline, const String& msg) :
        Error(iline, sline, msg, "XML Grammar Error")
      {
      }
    }; // class GrammarError
 
    class ContentError
      : public Error
    {
    public:
      ContentError(int iline, const String& sline, const String& msg) :
        Error(iline, sline, msg, "XML Content Error")
      {
      }
    }; // class ContentError
 
    class MarkupParser
    {
    public:
      virtual ~MarkupParser() {}
 
      virtual bool attribs(std::map<String, bool>& attrs) const = 0;
 
      virtual void create(
        int iline,
        const String& sline,
        const String& name,
        const std::map<String, String>& attrs,
        bool closed) = 0;
 
      virtual void close(int iline, const String& sline) = 0;
 
      virtual std::shared_ptr<MarkupParser> markup(int iline, const String& sline, const String& name) = 0;
 
      virtual bool content(int iline, const String& sline) = 0;
    }; // class MarkupParser
 
    class DummyParser :
      public MarkupParser
    {
    public:
      explicit DummyParser();
      virtual bool attribs(std::map<String, bool>&) const override;
      virtual void create(int, const String&, const String&, const std::map<String, String>&, bool) override;
      virtual void close(int, const String&) override;
      virtual std::shared_ptr<MarkupParser> markup(int, const String&, const String&) override;
      virtual bool content(int, const String&) override;
    }; // class DummyParser
 
    class DumpParser :
      public MarkupParser
    {
    protected:
      String _name;
      bool _lines;
      std::size_t _indent;
 
    public:
      explicit DumpParser(const String& name, bool lines = true, std::size_t indent = 0);
      virtual bool attribs(std::map<String, bool>&) const override;
      virtual void create(int iline, const String&, const String&, const std::map<String, String>& attrs, bool closed) override;
      virtual void close(int iline, const String&) override;
      virtual std::shared_ptr<MarkupParser> markup(int, const String&, const String& name) override;
      virtual bool content(int iline, const String& sline) override;
    }; // class DumpParser
 
    class Scanner
    {
    private:
      class MarkupInfo
      {
      private:
        int my_line;
        String my_name;
        std::shared_ptr<MarkupParser> my_parser;
 
      public:
        explicit MarkupInfo(int _line, const String& _name, std::shared_ptr<MarkupParser> _parser) :
          my_line(_line), my_name(_name), my_parser(_parser)
        {
        }
 
        int line() const
        {
          return my_line;
        }
 
        const String& name() const
        {
          return my_name;
        }
 
        std::shared_ptr<MarkupParser> parser()
        {
          return my_parser;
        }
      }; // class MarkupInfo
 
    private:
      std::istream& _stream;
      std::vector<MarkupInfo> _markups;
      bool _have_read_root;
      int _cur_iline;
      String _cur_sline;
      bool _cur_is_markup;
      bool _cur_is_closed;
      bool _cur_is_termin;
      String _cur_name;
      std::map<String,String> _cur_attribs;
 
    public:
      explicit Scanner(std::istream& stream, int lines_read = 0) :
        _stream(stream),
        _markups(),
        _have_read_root(false),
        _cur_iline(lines_read),
        _cur_sline(),
        _cur_is_markup(false),
        _cur_is_closed(false),
        _cur_is_termin(false),
        _cur_name(),
        _cur_attribs()
      {
        _markups.reserve(32);
        _cur_sline.reserve(1024);
      }
 
      virtual ~Scanner()
      {
      }
 
      int get_cur_iline() const
      {
        return _cur_iline;
      }
 
      const String& get_cur_sline() const
      {
        return _cur_sline;
      }
 
      bool is_cur_markup() const
      {
        return _cur_is_markup;
      }
 
      bool is_cur_closed() const
      {
        return _cur_is_closed;
      }
 
      bool is_cur_termin() const
      {
        return _cur_is_termin;
      }
 
      const String& get_cur_name() const
      {
        return _cur_name;
      }
 
      const std::map<String, String>& get_cur_attribs() const
      {
        return _cur_attribs;
      }
 
      void read_root();
 
      void set_root_parser(std::shared_ptr<MarkupParser> parser);
 
      void scan();
 
      void scan(std::shared_ptr<MarkupParser> root_parser);
 
      void throw_syntax(const String& msg) const
      {
        throw SyntaxError(_cur_iline, _cur_sline, msg);
      }
 
      void throw_grammar(const String& msg) const
      {
        throw GrammarError(_cur_iline, _cur_sline, msg);
      }
 
      void throw_content(const String& msg) const
      {
        throw ContentError(_cur_iline, _cur_sline, msg);
      }
 
    protected:
      bool read_next_line();
 
      bool scan_markup();
 
      void process_markup();
 
      void create_top_parser();
 
      void process_content();
    }; // class Scanner
  } // namespace Xml
} // namespace FEAT