Parser.h

Go to the documentation of this file.

//
// Copyright (c) 2006-2007 Raphael David / CANTOR
//

#ifndef CMR_DUMMY_PARSER_INCLUDED
#define CMR_DUMMY_PARSER_INCLUDED

#include "commore/Commore.h"
#include "commore/Tuple.h"

namespace commore
{
    class Path;
    //
    // Parser dictionary
    // Resolve unknow type
    //
    class CMREXD ParserDoctype
    {
    public:
        ParserDoctype(const AString& name);
        virtual ~ParserDoctype();

    public:
        //
        // Check a markup meaning
        // return true if it has a special meaning
        // markup_name - the input markup name
        // type - return the attribute type
        // is_tuple - if true means that markup is
        //        not an attribute but directly a tuple (type must be T_TUPLE or T_LIST_TUPLE)
        // att_name - is the attribut name
        //
        virtual bool get_att_type(const AString& markup_name, Types& type, bool& is_tuple, AString& attName) = 0;
        static ParserDoctype* get_parser_doc_type(const AChar* name);

    private:
        AString name_;
        ParserDoctype* next_;

    };
    //
    // Dummy text parser
    // for parse C style lexical syntax
    //
    class CMREXD CmrParser : public Tuple
    {
    public:
        class Reader;
        enum WORD_TYPE
        {
            EMPTY,
            OPER,
            IDENT,
            STRING,
            QSTRING,
            NUMBER
        };

    public:
        //
        // Initialize on a stream source
        // and read first token
        //
        CmrParser(IBStream& isource);
        CmrParser(const Path& file);
        CmrParser(const AString& s);
        ~CmrParser();

    public:
        //
        // Check if sources is valid
        //
        bool is_open();


        //
        // Return the source file name
        //
        const AString& get_source_name();

        //
        // Read next token
        //
        WORD_TYPE read_next();

        //
        // Get text content of current token
        //
        AString& get_word()
        {
            return word_;
        }
        //
        // Get type of current token
        //
        WORD_TYPE get_type()
        {
            return type_;
        }

        //
        // Check end of source
        //
        bool is_eof()
        {
            return type_ == EMPTY;
        }

        //
        // Check oprator
        // _read : if true read next token
        //
        bool is_oper()
        {
            return type_ == OPER;
        }
        bool is_oper(const char* s);
        bool is_oper_read(const char* s);

        //
        // Check ident
        //
        bool is_ident()
        {
            return type_ == IDENT;
        }
        bool is_ident(const char* s);
        bool is_identu(const char* s);
        bool is_ident_read(const char* s);
        bool is_identu_read(const char* s);
        bool is_ident_read(AString& s);

        //
        // Check string
        //
        bool is_string()
        {
            return type_ == STRING;
        }
        bool is_string_read(AString& s)
        {
            bool r = type_ == STRING;
            if (r)
            {
                s = word_;
                read_next();
            }
            return r;
        }

        //
        // Check qstring
        //
        bool is_qstring()
        {
            return type_ == QSTRING;
        }
        bool is_qstring_read(AString& s)
        {
            bool r = type_ == QSTRING;
            if (r)
            {
                s = word_;
                read_next();
            }
            return r;
        }

        //
        // Check number
        //
        bool is_number();
        bool is_number(int& v);
        bool is_number_read(int& v);
        bool is_number_read(AString& v);
        int get_number();
        //
        // Conytrol how are parsed string
        // Default is C like, aternate is VB like
        // (how is escaped the " char)
        //
        bool get_string_mode() const
        {
            return string_mode_;
        }
        void set_string_mode(bool basic = true)
        {
            string_mode_ = basic;
        }

        //
        // Get comment and layout
        // !(layout contains comment)
        //
        const StringBuffer& get_layout() const
        {
            return layout_;
        }
        const ListAString& get_comment() const
        {
            return comment_;
        }
        AString get_expected() const;
        int get_line() const;

    private:
        IBStream& isource();
        int read_char_();

    private:
        int line_;
        AString word_;
        StringBuffer layout_;
        ListAString comment_;
        WORD_TYPE type_;
        int current_;
        int next_;
        Reader* reader_;
        bool string_mode_;
        ListAString expected_;
    };

    //
    // A trivial XML parser
    // It reads XML stream one markup by one markup
    // It is an XML iterator
    //
    class CMREXD XmlParser
    {
    public:
        XmlParser(IBStream& i);
        ~XmlParser();

    public:
        //
        // The markup attribute iterator
        //
        struct CMREXD AttIterator
        {
            AttIterator() : name(""), value(""), next_(0) {}
            const char* name;
            const char* value;
            void* next_;
            bool next();
            operator bool () const
            {
                return next_ != 0;
            }
        };
        //
        // Read next markup.
        // - read stream util it get a markup start char '<'
        // - skip comment and <! <? markup
        //
        // Read stream until end of markup.
        // Read the text between the markup and next markup.
        // Try to read next markup if it is the end
        // markup of current markup. In this
        // case the markup is tagged as begin_end markup and get_value
        // return the text between the two markup.
        //
        int read_next();

        //
        // Check end of stream or error reached
        //
        bool is_end_stream() const;
        //
        // Is current markup a begin markup
        //
        bool is_begin_markup() const;
        //
        // Is current markup a end markup
        // tag : the markup name
        //
        bool is_end_markup() const;
        bool is_end_markup(const char* tag) const;

        //
        // Is current markup a begin and end markup
        //
        bool is_begin_end_markup() const;
        bool is_markup(const char* tag) const;

        //
        // Return name of current markup
        //
        const  AString get_markup_name() const;
        //
        // Check if makup attribute is set
        //
        bool is_set(const AString& attName) const;

        //
        // Get list of markup attribute
        //
        int get_set(ListAString& attList) const;

        //
        // Get an iterator on makup attribute list
        //
        AttIterator get_att_list();

        //
        // Get string value of markup
        // Text between current makup and next markup
        // It does not remove spaces characters.
        //
        AString get_value() const;
        void get_value(StringBuffer& buf) const;
        void get_value(AString& buf) const;

        //
        // Get string value of a makup attribute of
        // current markup.
        //
        AString get(const  AString& attName) const;
        bool get(const  AString& attName,  AString& value) const;

        //
        // Debug purpose : dump content of current markup
        //
        AString to_string() const;

        //
        // Get current doc type detected by parser
        //
        ParserDoctype* get_doc_type();
        const AChar* dump();

    private:
        //
        // Not allowed operation
        //
        XmlParser(const XmlParser&);
        XmlParser& operator = (const XmlParser&);


    private:
        class Impl;
        Impl* impl_;
    };

    //
    // Parser for ini file
    // Not yet used
    //
    class CMREXD IniParser
    {
    public:
        IniParser(const Path& iniFileName);
        ~IniParser();

    public:
        bool match(const AChar* section, const AChar* name) const;
        bool match(const AChar* section, AString& name) const;
        bool match(AString& section, AString& name) const;
        bool match_index(const AChar* section, const AChar* name) const;
        const AChar* get_index() const;
        int get_index_num() const;
        void get_value(AString& value) const;
        int get_valueNum() const;
        const AChar* get_value() const;
        bool read_next();

    private:
        class Impl;
        Impl* impl_;

    };
};

#endif