directive.h

Go to the documentation of this file.

#ifndef DIRECTIVE_H
#define DIRECTIVE_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2007-2013 Mike Kinghan, imk@burroingroingjoing.com      *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@burroingroingjoing.com    *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Mike Kinghan nor the names of its contributors    *
 *   may be used to endorse or promote products derived from this software *
 *   without specific prior written permission.                            *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/

#include "line_despatch.h"
#include "chew.h"
#include <map>
#include <vector>

struct directive_base : private no_copy
{
        static line_type eval(std::string keyword, chewer<parse_buffer> & chew) {
                return eval(get_type(keyword),chew);
        }

        static void erase_all();

protected:

        static void report(std::string const & keyword, std::string const & arg);

        static void report(bool seen,
                           std::string const & keyword, std::string const & arg);

        static line_type eval(directive_type type, chewer<parse_buffer> & chew);

        static line_type
        eval_ifdef_or_ifndef(directive_type type, chewer<parse_buffer> & chew);

private:

        using evaluator = line_type (*)(chewer<parse_buffer> &);
        static directive_type get_type(std::string const & keyword);
        static std::map<std::string, directive_type> _keyword_to_type_map_;
        static std::vector<evaluator> _evaluator_tab_;
};

template<directive_type Type>
struct directive : directive_base
{

        friend struct directive_base;
        static directive_type const _type_ = Type;

        virtual ~directive() = default;

        explicit directive(std::string const & arg)
                :  _loc(insert(arg)) {}

        std::string const & argument() const {
                return _loc->first;
        }

        virtual void report() {
                directive_base::report(_loc->second,_keyword_,_loc->first);
                _loc->second = true;

        }

        bool reported() const {
                return _loc->second;
        }

        void set_reported(bool reported = true) {
                _loc->second = reported;
        }

protected:

        static line_type eval(chewer<parse_buffer> & chew);

        using directives_table = std::map<std::string,bool> ;
        using table_entry = directives_table::value_type;

        static directives_table::iterator insert(std::string const & arg) {
                return _directives_tab_.insert(table_entry(arg,false)).first;
        }

        directives_table::iterator _loc;

        static std::string const _keyword_;
        static directives_table _directives_tab_;
};


template<>
line_type directive<HASH_UNKNOWN>::eval(chewer<parse_buffer> &);

template<>
line_type directive<HASH_IF>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_IFDEF>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_IFNDEF>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_ELSE>::eval(chewer<parse_buffer> &);

template<>
line_type directive<HASH_ELIF>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_ENDIF>::eval(chewer<parse_buffer> &);

template<>
line_type directive<HASH_DEFINE>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_UNDEF>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_INCLUDE>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_PRAGMA>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_ERROR>::eval(chewer<parse_buffer> & chew);

template<>
line_type directive<HASH_LINE>::eval(chewer<parse_buffer> & chew);



#endif /* EOF*/