eval_context.h

Go to the documentation of this file.

// Copyright (C) 2015-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 EVAL_CONTEXT_H
#define EVAL_CONTEXT_H
#include <string>
#include <map>
#include <vector>
#include <eval/parser.h>
#include <eval/eval_context_decl.h>
#include <exceptions/exceptions.h>
 
// Tell Flex the lexer's prototype ...
#define YY_DECL \
    isc::eval::EvalParser::symbol_type evallex (EvalContext& driver)
 
// ... and declare it for the parser's sake.
YY_DECL;
 
namespace isc {
namespace eval {
 
class EvalParseError : public isc::Exception {
public:
    EvalParseError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
 
class EvalContext {
public:
 
    typedef enum {
        PARSER_BOOL,  
        PARSER_STRING 
    } ParserType;
 
    typedef std::function<bool(const ClientClass&)> CheckDefined;
 
    EvalContext(const Option::Universe& option_universe,
                CheckDefined check_defined = acceptAll);
 
    virtual ~EvalContext();
 
    static bool acceptAll(const ClientClass& client_class);
 
    isc::dhcp::Expression expression_;
 
    unsigned label_;
 
    std::vector<unsigned> labels_;
 
    void scanStringBegin(ParserType type);
 
    void scanStringEnd();
 
    bool parseString(const std::string& str, ParserType type = PARSER_BOOL);
 
    std::string file_;
 
    std::string string_;
 
    static void error(const isc::eval::location& loc, const std::string& what);
 
    static void error(const std::string& what);
 
    static void fatal(const std::string& what);
 
    uint16_t convertOptionCode(const std::string& option_code,
                               const isc::eval::location& loc);
 
    uint16_t convertOptionName(const std::string& option_name,
                               const isc::eval::location& loc);
 
    static uint32_t convertUint32(const std::string& number,
                                  const isc::eval::location& loc);
 
    static int32_t convertInt32(const std::string& number,
                                const isc::eval::location& loc);
 
    static uint16_t convertUint16(const std::string& number,
                                  const isc::eval::location& loc);
 
    static int16_t convertInt16(const std::string& number,
                                const isc::eval::location& loc);
 
    static uint8_t convertUint8(const std::string& number,
                                const isc::eval::location& loc);
 
    static int8_t convertInt8(const std::string& number,
                              const isc::eval::location& loc);
 
    int8_t convertNestLevelNumber(const std::string& nest_level,
                                  const isc::eval::location& loc);
 
    static std::string fromUint32(const uint32_t integer);
 
    static std::string fromUint16(const uint16_t integer);
 
    Option::Universe getUniverse() {
        return (option_universe_);
    }
 
    bool isClientClassDefined(const ClientClass& client_class);
 
private:
    bool trace_scanning_;
 
    bool trace_parsing_;
 
    Option::Universe option_universe_;
 
    CheckDefined check_defined_;
 
};
 
} // end of isc::eval namespace
} // end of isc namespace
 
#endif