Parse.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Utils_Console_Parse_
#define HH_SENF_Utils_Console_Parse_ 1

// Custom includes
#include <string>
#include <vector>
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/function.hpp>
#include <senf/Utils/safe_bool.hh>
#include <senf/Utils/Exception.hh>

//#include "Parse.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace console {

    template <class Type>
    struct ArgumentTraits;
    template <class Type>
    struct ReturnValueTraits;

    namespace detail {
        struct FilePositionWithIndex;
        struct ParserAccess;
        template <class ParameterType>
        struct ArgumentInfo;
        template<class Collection, class Adder>
        struct CollectionArgumentTraits;
        template <class Collection>
        struct MapArgumentTraits;
    }

#   define SENF_CONSOLE_PARSE_FRIEND( type )                                                                    \
        friend void senf_console_parse_argument(senf::console::ParseCommandInfo::TokensRange const &, type &);  \
        friend struct senf::console::detail::ArgumentInfo<type>;                                                \
        friend struct senf::console::ArgumentTraits<type>;                                                      \
        friend struct senf::console::ReturnValueTraits<type>;                                                   \
        template<class Collection, class Adder>                                                                 \
        friend struct senf::console::detail::CollectionArgumentTraits;                                          \
        template <class Collection>                                                                             \
        friend struct senf::console::detail::MapArgumentTraits;


    class Token
    {
    public:
        enum TokenType {
            None                = 0,
            PathSeparator       = 0x0001, // '/'
            ArgumentGroupOpen   = 0x0002, // '('
            ArgumentGroupClose  = 0x0004, // ')'
            DirectoryGroupOpen  = 0x0008, // '{'
            DirectoryGroupClose = 0x0010, // '}'
            CommandTerminator   = 0x0020, // ';'
            OtherPunctuation    = 0x0040,
            BasicString         = 0x0080,
            HexString           = 0x0100,
            Word                = 0x0200
        };

        enum TokenGroup {
            ArgumentGrouper     = ArgumentGroupOpen
                                | ArgumentGroupClose,

            DirectoryGrouper    = DirectoryGroupOpen
                                | DirectoryGroupClose,

            Punctuation         = DirectoryGroupOpen
                                | DirectoryGroupClose
                                | PathSeparator
                                | CommandTerminator
                                | OtherPunctuation,

            String              = BasicString
                                | HexString,

            SimpleArgument      = Word
                                | BasicString
                                | HexString
        };

        Token();                        
        Token(TokenType type, std::string token);
        Token(TokenType type, std::string token, detail::FilePositionWithIndex const & pos);


        std::string const & value() const; 

        TokenType type() const;         

        unsigned line() const;          
        unsigned column() const;        
        unsigned index() const;         

        bool is(unsigned tokens) const; 

        bool operator==(Token const & other) const;
        bool operator!=(Token const & other) const;

    protected:

    private:
        TokenType type_;
        std::string token_;
        unsigned line_;
        unsigned column_;
        unsigned index_;
    };

    std::ostream & operator<<(std::ostream & os, Token const & token);

    Token NoneToken();

    Token PathSeparatorToken();

    Token ArgumentGroupOpenToken();

    Token ArgumentGroupCloseToken();

    Token DirectoryGroupOpenToken();

    Token DirectoryGroupCloseToken();

    Token CommandTerminatorToken();

    Token OtherPunctuationToken(std::string const & value);

    Token BasicStringToken(std::string const & value);

    Token HexStringToken(std::string const & value);

    Token WordToken(std::string const & value);

    class ParseCommandInfo
    {
        typedef std::vector<Token> Tokens;
        typedef std::vector<std::string> CommandPath;

    public:
        class ArgumentIterator;

        typedef CommandPath::const_iterator path_iterator;
        typedef Tokens::const_iterator token_iterator;
        typedef ArgumentIterator argument_iterator;
        typedef Tokens::size_type size_type;

        typedef boost::iterator_range<path_iterator> CommandPathRange;
        typedef boost::iterator_range<argument_iterator> ArgumentsRange;
        typedef boost::iterator_range<token_iterator> TokensRange;

        enum BuiltinCommand { NoBuiltin,
                              BuiltinCD,
                              BuiltinLS,
                              BuiltinLL,
                              BuiltinLR,
                              BuiltinPUSHD,
                              BuiltinPOPD,
                              BuiltinEXIT,
                              BuiltinHELP,
                              BuiltinECHO };

        ParseCommandInfo();

        BuiltinCommand builtin() const; 

        TokensRange commandPath() const; 

        ArgumentsRange arguments() const; 

        TokensRange tokens() const;     

        void clear();                   
        bool empty();                   

        void builtin(BuiltinCommand builtin); 
        void command(std::vector<Token> & commandPath); 

        void addToken(Token const & token); 

    protected:

    private:
        struct MakeRange;

        std::vector<Token> commandPath_;
        BuiltinCommand builtin_;
        Tokens tokens_;
    };

    class ParseCommandInfo::ArgumentIterator
        : public boost::iterator_facade< ParseCommandInfo::ArgumentIterator,
                                         ParseCommandInfo::TokensRange,
                                         boost::bidirectional_traversal_tag,
                                         ParseCommandInfo::TokensRange >
    {
    public:
        ArgumentIterator();
        explicit ArgumentIterator(ParseCommandInfo::TokensRange::iterator i);

    private:
        reference dereference() const;
        bool equal(ArgumentIterator const & other) const;
        void increment();
        void decrement();

        mutable ParseCommandInfo::TokensRange::iterator b_;
        mutable ParseCommandInfo::TokensRange::iterator e_;

        void setRange() const;

        friend class boost::iterator_core_access;
        friend class ParseCommandInfo;
    };

    struct SyntaxErrorException : public senf::Exception
    { explicit SyntaxErrorException(std::string const & msg = "syntax error")
          : senf::Exception(msg) {} };

    class CheckedArgumentIteratorWrapper
        : boost::noncopyable,
          public boost::iterator_facade< CheckedArgumentIteratorWrapper,
                                         ParseCommandInfo::TokensRange,
                                         boost::forward_traversal_tag,
                                         ParseCommandInfo::TokensRange >,
          public senf::safe_bool<CheckedArgumentIteratorWrapper>

    {
        typedef boost::iterator_facade< CheckedArgumentIteratorWrapper,
                                        ParseCommandInfo::TokensRange,
                                        boost::forward_traversal_tag,
                                        ParseCommandInfo::TokensRange > IteratorFacade;

    public:
        explicit CheckedArgumentIteratorWrapper(
            ParseCommandInfo::ArgumentsRange const & range,
            std::string const & msg = "invalid number of arguments");

        explicit CheckedArgumentIteratorWrapper(
            ParseCommandInfo::TokensRange const & range,
            std::string const & msg = "invalid number of arguments");

        ~CheckedArgumentIteratorWrapper() noexcept(false);

        operator ParseCommandInfo::ArgumentIterator();

        bool boolean_test() const;      
        bool done() const;              

        void clear();                   

        bool operator==(ParseCommandInfo::ArgumentIterator const & other) const;
        bool operator!=(ParseCommandInfo::ArgumentIterator const & other) const;

        using IteratorFacade::operator++;
        ParseCommandInfo::ArgumentIterator operator++(int);

    private:
        reference dereference() const;
        void increment();

        ParseCommandInfo::ArgumentIterator i_;
        ParseCommandInfo::ArgumentIterator e_;
        std::string msg_;

        friend class boost::iterator_core_access;
    };

    std::ostream & operator<<(std::ostream & stream, ParseCommandInfo const & info);

    class CommandParser
        : boost::noncopyable
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef boost::function<void (ParseCommandInfo const &)> Callback;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        CommandParser();
        ~CommandParser();

        //\}
        //-////////////////////////////////////////////////////////////////////////

        void parse(std::string const & command, Callback cb); 
        void parseFile(std::string const & filename, Callback cb); 

        void parseArguments(std::string const & arguments, ParseCommandInfo & info);

        void parsePath(std::string const & path, ParseCommandInfo & info);

        std::string::size_type parseIncremental(std::string const & commands, Callback cb);

        static bool isSpecialChar(char ch); 
        static bool isPunctuationChar(char ch); 
        static bool isSpaceChar(char ch); 
        static bool isInvalidChar(char ch); 
        static bool isWordChar(char ch); 

        struct ParserErrorException : public SyntaxErrorException
        { explicit ParserErrorException(std::string const & msg) : SyntaxErrorException(msg) {} };

    private:
        struct Impl;
        struct SetIncremental;

        template <class Iterator>
        Iterator parseLoop(Iterator b, Iterator e, std::string const & source, Callback cb);

        Impl & impl();

        boost::scoped_ptr<Impl> impl_;

        friend struct SetIncremental;
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Parse.cci"
//#include "Parse.ct"
//#include "Parse.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: