programLexer.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_BASE_PROGRAM_LEXER_HPP_INCLUDED
#define _STRUS_BASE_PROGRAM_LEXER_HPP_INCLUDED
#include "strus/base/regex.hpp"
#include <utility>
#include <string>
#include <vector>

namespace strus {

class ErrorBufferInterface;

class ProgramLexem
{
public:
        enum Type {Eof,Token,SQString,DQString,Error};
        Type type() const                       {return m_type;}        // lexem type
        int id() const                          {return m_id;}          // enumeration index in case of a token
        const std::string& value() const        {return m_value;}       // lexem value

        ProgramLexem( Type type_=Error)
                :m_type(type_),m_id(-1),m_value(){}
        ProgramLexem( const ProgramLexem& o)
                :m_type(o.m_type),m_id(o.m_id),m_value(o.m_value){}
        ProgramLexem( Type type_, int id_, const std::string& value_)
                :m_type(type_),m_id(id_),m_value(value_){}
        operator bool() const           {return !end();}

        bool end() const                                {return m_type == Eof || m_type == Error;}
        bool isToken( int id_) const                    {return m_type == Token && m_id == id_;}
        bool isToken() const                            {return m_type == Token;}
        bool isString() const                           {return m_type == SQString || m_type == DQString;}
        bool isError() const                            {return m_type == Error;}
        bool isEof() const                              {return m_type == Eof;}
        int checkKeyword( int nn, ...) const;

private:
        Type m_type;                    // lexem type
        int m_id;                       // enumeration index in case of a token
        std::string m_value;            // lexem value
};

class ProgramLexer
{
public:
        ProgramLexer( const char* src, const char* eolncomment_, const char** tokens, const char** errtokens, ErrorBufferInterface* errhnd_);
        ~ProgramLexer();

        const ProgramLexem& next();
        const ProgramLexem& current()           {return m_lexem;}
        const ProgramLexem& rescanCurrent();

        bool consumeToken( int tokid)
        {
                if (current().isToken( tokid))
                {
                        next();
                        return true;
                }
                return false;
        }

        enum Option {KeepStringEscaping=1};
        bool setOption( Option opt_, bool value);

        int lineno() const;

        const char* pos() const                 {return m_src;}

        std::size_t len() const                 {return m_end - m_src;}

        bool skipto( char const* pos);

        const char* nextpos();

        const char* currentpos();

        std::string currentLocationString( int posincr, int size, const char* marker) const;

private:
#if __cplusplus >= 201103L
        ProgramLexer( const ProgramLexer&) = delete;
        void operator=( const ProgramLexer&) = delete;
#else
        ProgramLexer( const ProgramLexer&){}                    
        void operator=( const ProgramLexer&){}                  
#endif
        
private:
        ErrorBufferInterface* m_errhnd;
        const char* m_eolncomment;
        std::vector<strus::RegexSearch*> m_lexems;
        std::vector<strus::RegexSearch*> m_errlexems;
        const char* m_start;
        const char* m_end;
        char const* m_src;
        char const* m_prevsrc;
        ProgramLexem m_lexem;
        int m_opt;
};

} //namespace
#endif