dhcp4/parser_context.h

Go to the documentation of this file.

// Copyright (C) 2015-2018 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 PARSER_CONTEXT_H
#define PARSER_CONTEXT_H
#include <string>
#include <map>
#include <vector>
#include <dhcp4/dhcp4_parser.h>
#include <dhcp4/parser_context_decl.h>
#include <exceptions/exceptions.h>
 
// Tell Flex the lexer's prototype ...
#define YY_DECL isc::dhcp::Dhcp4Parser::symbol_type parser4_lex (Parser4Context& driver)
 
// ... and declare it for the parser's sake.
YY_DECL;
 
namespace isc {
namespace dhcp {
 
class Dhcp4ParseError : public isc::Exception {
public:
    Dhcp4ParseError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
 
class Parser4Context
{
public:
 
    typedef enum {
        PARSER_JSON,
 
        PARSER_DHCP4,
 
        SUBPARSER_DHCP4,
 
        PARSER_INTERFACES,
 
        PARSER_SUBNET4,
 
        PARSER_POOL4,
 
        PARSER_HOST_RESERVATION,
 
        PARSER_OPTION_DEFS,
 
        PARSER_OPTION_DEF,
 
        PARSER_OPTION_DATA,
 
        PARSER_HOOKS_LIBRARY,
 
        PARSER_DHCP_DDNS,
 
        PARSER_CONFIG_CONTROL,
 
        PARSER_LOGGING
    } ParserType;
 
    Parser4Context();
 
    virtual ~Parser4Context();
 
    std::vector<isc::data::ElementPtr> stack_;
 
    void scanStringBegin(const std::string& str, ParserType type);
 
    void scanFileBegin(FILE* f, const std::string& filename, ParserType type);
 
    void scanEnd();
 
    void includeFile(const std::string& filename);
 
    isc::data::ElementPtr parseString(const std::string& str,
                                      ParserType parser_type);
 
    isc::data::ElementPtr parseFile(const std::string& filename,
                                    ParserType parser_type);
 
    void error(const isc::dhcp::location& loc, const std::string& what);
 
    void error(const std::string& what);
 
    static void fatal(const std::string& what);
 
    isc::data::Element::Position loc2pos(isc::dhcp::location& loc);
 
    void require(const std::string& name,
                 isc::data::Element::Position open_loc,
                 isc::data::Element::Position close_loc);
 
    typedef enum {
        NO_KEYWORD,
 
        CONFIG,
 
        DHCP4,
 
        // not yet Dhcp6, DhcpDdns,
 
        LOGGING,
 
        INTERFACES_CONFIG,
 
        SANITY_CHECKS,
 
        DHCP_SOCKET_TYPE,
 
        OUTBOUND_INTERFACE,
 
        LEASE_DATABASE,
 
        HOSTS_DATABASE,
 
        DATABASE_TYPE,
 
        HOST_RESERVATION_IDENTIFIERS,
 
        HOOKS_LIBRARIES,
 
        SUBNET4,
 
        SHARED_NETWORK,
 
        RESERVATION_MODE,
 
        OPTION_DEF,
 
        OPTION_DATA,
 
        CLIENT_CLASSES,
 
        EXPIRED_LEASES_PROCESSING,
 
        SERVER_ID,
 
        CONTROL_SOCKET,
 
        DHCP_QUEUE_CONTROL,
 
        POOLS,
 
        RESERVATIONS,
 
        RELAY,
 
        LOGGERS,
 
        OUTPUT_OPTIONS,
 
        DHCP_DDNS,
 
        NCR_PROTOCOL,
 
        NCR_FORMAT,
 
        REPLACE_CLIENT_NAME,
 
        CONFIG_CONTROL,
 
        CONFIG_DATABASE
 
    } ParserContext;
 
    std::string file_;
 
    std::vector<std::string> files_;
 
    isc::dhcp::location loc_;
 
    std::vector<isc::dhcp::location> locs_;
 
    std::vector<struct yy_buffer_state*> states_;
 
    FILE* sfile_;
 
    std::vector<FILE*> sfiles_;
 
    ParserContext ctx_;
 
    void enter(const ParserContext& ctx);
 
    void leave();
 
    const std::string contextName();
 
 private:
    bool trace_scanning_;
 
    bool trace_parsing_;
 
    std::vector<ParserContext> cstack_;
 
    isc::data::ElementPtr parseCommon();
};
 
}; // end of isc::eval namespace
}; // end of isc namespace
 
#endif