eval_context.h

Go to the documentation of this file.

// Copyright (C) 2015-2021 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 <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;

    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