master_lexer.h

Go to the documentation of this file.

// Copyright (C) 2012-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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 MASTER_LEXER_H
#define MASTER_LEXER_H
 
#include <dns/exceptions.h>
 
#include <istream>
#include <string>
 
#include <stdint.h>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace dns {
namespace master_lexer_internal {
class State;
}
 
class MasterToken {
public:
    enum Type {
        END_OF_LINE, 
        END_OF_FILE, 
        INITIAL_WS,  
                     //   for detecting it)
        NOVALUE_TYPE_MAX = INITIAL_WS, 
        STRING, 
        QSTRING, 
        NUMBER,  
        ERROR    
    };
 
    enum ErrorCode {
        NOT_STARTED, 
        UNBALANCED_PAREN,       
        UNEXPECTED_END, 
        UNBALANCED_QUOTES,      
        NO_TOKEN_PRODUCED, 
        NUMBER_OUT_OF_RANGE, 
        BAD_NUMBER,    
        UNEXPECTED_QUOTES, 
        MAX_ERROR_CODE 
    };
 
    struct StringRegion {
        const char* beg;        
        size_t len;             
    };
 
    explicit MasterToken(Type type) : type_(type) {
        if (type > NOVALUE_TYPE_MAX) {
            isc_throw(InvalidParameter, "Token per-type constructor "
                      "called with invalid type: " << type);
        }
    }
 
    MasterToken(const char* str_beg, size_t str_len, bool quoted = false) :
        type_(quoted ? QSTRING : STRING) {
        val_.str_region_.beg = str_beg;
        val_.str_region_.len = str_len;
    }
 
    explicit MasterToken(uint32_t number) : type_(NUMBER) {
        val_.number_ = number;
    }
 
    explicit MasterToken(ErrorCode error_code) : type_(ERROR) {
        if (!(error_code < MAX_ERROR_CODE)) {
            isc_throw(InvalidParameter, "Invalid master lexer error code: "
                      << error_code);
        }
        val_.error_code_ = error_code;
    }
 
    Type getType() const {
        return (type_);
    }
 
    const StringRegion& getStringRegion() const {
        if (type_ != STRING && type_ != QSTRING) {
            isc_throw(InvalidOperation,
                      "Token::getStringRegion() for non string-variant type");
        }
        return (val_.str_region_);
    }
 
    std::string getString() const {
        std::string ret;
        getString(ret);
        return (ret);
    }
 
    void getString(std::string& ret) const {
        if (type_ != STRING && type_ != QSTRING) {
            isc_throw(InvalidOperation,
                      "Token::getString() for non string-variant type");
        }
        ret.assign(val_.str_region_.beg,
                   val_.str_region_.beg + val_.str_region_.len);
    }
 
    uint32_t getNumber() const {
        if (type_ != NUMBER) {
            isc_throw(InvalidOperation,
                      "Token::getNumber() for non number type");
        }
        return (val_.number_);
    }
 
    ErrorCode getErrorCode() const {
        if (type_ != ERROR) {
            isc_throw(InvalidOperation,
                      "Token::getErrorCode() for non error type");
        }
        return (val_.error_code_);
    };
 
    std::string getErrorText() const;
 
private:
    Type type_;    // this is not const so the class can be assignable
 
    // We use a union to represent different types of token values via the
    // unified Token class.  The class integrity should ensure valid operation
    // on the union; getter methods should only refer to the member set at
    // the construction.
    union {
        StringRegion str_region_;
        uint32_t number_;
        ErrorCode error_code_;
    } val_;
};
 
class MasterLexer : public boost::noncopyable {
    friend class master_lexer_internal::State;
public:
    class ReadError : public Unexpected {
    public:
        ReadError(const char* file, size_t line, const char* what) :
            Unexpected(file, line, what)
        {}
    };
 
    class LexerError : public isc::dns::Exception {
    public:
        LexerError(const char* file, size_t line, MasterToken error_token) :
            isc::dns::Exception(file, line, error_token.getErrorText().c_str()),
            token_(error_token)
        {}
        const MasterToken token_;
    };
 
    static const size_t SOURCE_SIZE_UNKNOWN;
 
    enum Options {
        NONE = 0,               
        INITIAL_WS = 1, 
        QSTRING = 2,    
        NUMBER = 4   
    };
 
    MasterLexer();
 
    ~MasterLexer();
 
    bool pushSource(const char* filename, std::string* error = 0);
 
    void pushSource(std::istream& input);
 
    void popSource();
 
    size_t getSourceCount() const;
 
    std::string getSourceName() const;
 
    size_t getSourceLine() const;
 
    size_t getTotalSourceSize() const;
 
    size_t getPosition() const;
 
    const MasterToken& getNextToken(Options options = NONE);
 
    const MasterToken& getNextToken(MasterToken::Type expect,
                                    bool eol_ok = false);
 
    void ungetToken();
 
private:
    struct MasterLexerImpl;
    boost::shared_ptr<MasterLexerImpl> impl_;
};
 
inline MasterLexer::Options
operator|(MasterLexer::Options o1, MasterLexer::Options o2) {
    return (static_cast<MasterLexer::Options>(
                static_cast<unsigned>(o1) | static_cast<unsigned>(o2)));
}
 
} // namespace dns
} // namespace isc
#endif  // MASTER_LEXER_H