symbol.h

Go to the documentation of this file.

#ifndef symbol_H
#define symbol_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 "identifier.h"
#include "formal_parameter_list.h"
#include "line_type.h"
#include "parameter_substitution.h"
#include <string>
#include <set>
#include <map>


// Forward decl
struct reference;

struct symbol
{
        friend reference;

        enum class provenance {
                unconfigured,
                global,
                transient
        };

        using symbol_table = std::map<std::string,symbol>;
        using table_entry = symbol_table::value_type;

        struct locator
        {
                locator();

                explicit locator(symbol_table::iterator iter)
                : _loc(iter) {}

                explicit locator(std::string const & id);

                locator(std::string const & id,
                           provenance source)
                :       _loc(insert(id,source)) {}

                template<class CharSeq>
                explicit locator(chewer<CharSeq> & chew);

                bool operator==(locator other) const {
                        return _loc == other._loc;
                }

                bool operator!=(locator & other) const {
                        return !operator==(other);
                }

                bool null() const;

                explicit operator bool() const {
                        return !null();
                }

                symbol & operator*() {
                        return _loc->second;
                }
                symbol const & operator*() const {
                        return _loc->second;
                }

                symbol * operator->() {
                        return &_loc->second;
                }
                symbol const * operator->() const {
                        return &_loc->second;
                }

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

        private:

                symbol_table::iterator _loc;
        };

        bool operator==(symbol const & other) const {
                return id() == other.id();
        }

        bool operator!=(symbol const & other) const {
                return !operator==(other);
        }

        std::string const & id() const {
                return _loc.id();
        }

        provenance origin() const {
                return _provenance;
        }

        void originate(provenance origin) {
                _provenance = origin;
        }

        unsigned line() const {
                return _line;
        }

        std::shared_ptr<std::string const> defn() const {
                return _defn;
        }

        std::shared_ptr<parameter_substitution::format const> format() const {
                return _format;
        }

        bool defined() const {
                return _defn.get();
        }

        void set_definition(std::string const & defn);

        void set_parameters(formal_parameter_list const & params) {
                _params = params;
                if (_defn && !_defn->empty()) {
                        _format.reset(new parameter_substitution::format(*this));
                } else {
                        _format.reset();
                }
        }

        void set_parameters(size_t n) {
                _params = formal_parameter_list(n);
        }

        void define(std::string const & defn, formal_parameter_list const & params);

        void clear_parameters() {
                _params = formal_parameter_list();
        }

        void undef();

        void report() const;

        bool configured() const {
                return _provenance == provenance::global ||
                           _provenance == provenance::transient;
        }

        bool deselected() const {
                return _deselected;
        }

        bool invoked() const {
                return _invoked;
        }

        bool self_referential() const {
                return _snapshot == int(pseudo_snapshot::infinite);
        }

        bool dirty() const {
                return !self_referential() && (!clean() || _snapshot < snapshot_max());
        }

        bool clean() const {
                return _snapshot > int(pseudo_snapshot::pristine);
        }

        bool in_progress() const {
                return _snapshot == int(pseudo_snapshot::define_in_progress) ||
                        _snapshot == int(pseudo_snapshot::undef_in_progress);
        }

        std::string signature() const {
                return id() + _params.str();
        }

        formal_parameter_list const & parameters() const {
                return _params;
        }

        size_t which_parameter(std::string const & str) const {
                return _params.which(str);
        }

        bool variadic() const {
                return _params.variadic();
        }

        void digest_global_define(chewer<std::string> & chew);

        line_type
        digest_transient_define(formal_parameter_list const & params,
                                std::string const & definition);

        void digest_global_undef(chewer<std::string> & chew);

        line_type digest_transient_undef();

        static size_t count(provenance source);

        static size_t count() {
                return _sym_tab_.size() - 1;
        }

        static locator lookup(std::string const & id) {
                symbol_table::iterator result = table().find(id);
                return result == table().end() ?
                       locator() : locator(result);
        }

        template<class CharSeq>
        static locator find_any_in(chewer<CharSeq> & chew, size_t & off);

        static void set_selection(char const *optarg);

        static void per_file_init();

        static void report_global_config();

private:

        enum class pseudo_snapshot {
                pristine = -1,
                define_in_progress = -2,
                undef_in_progress = -3,
                infinite = -4

        };

        void set_pseudo_snapshot(pseudo_snapshot n = pseudo_snapshot::pristine) {
                _snapshot = int(n);
        }

        void report_premiere();

        void set_invoked(bool value = true) {
                _invoked = value;
        }

        void subscribe_to(locator other);

        bool subscribes_to(locator other) const;

        void subscribe();

        void unsubscribe();

        void make_clean() {
                _snapshot = _current_snapshot_++;
                if (_provenance == provenance::global) {
                        _last_global_snapshot_ = _snapshot;
                }
        }

        void make_dirty(pseudo_snapshot n = pseudo_snapshot::pristine);

        void make_self_referential() {
                make_dirty(pseudo_snapshot::infinite);
        }

        void diagnose_retrospective_redefinition() const;

        int snapshot_max() const;

        static bool selected(std::string const & id);

        static bool deselected(std::string const & id);

        static bool add_pattern(std::string const & pattern)  {
                return _selected_symbols_set_.insert(pattern).second;
        }

        static bool
        wildcard_match(std::string const & wildcard, std::string const & name);

        static symbol_table & table() {
                return symbol::_sym_tab_;
        }

        static symbol_table::iterator
        insert(
                std::string const & id,
                provenance source,
                symbol_table::iterator hint = table().end()) {
                auto where =
                        table().insert(hint,table_entry(id,symbol(source)));
                where->second._provenance = source;
                where->second._loc = locator(where);
                where->second._deselected = deselected(id);
                return where;
        }

        explicit symbol(provenance source)
        :       _provenance(source),
                _line(0),
                _deselected(false),
                _invoked(false),
                _snapshot(int(pseudo_snapshot::pristine)){}

        locator _loc;
        std::shared_ptr<std::string> _defn;
        formal_parameter_list _params;
        provenance _provenance;
        unsigned _line;
        bool _deselected;
        bool _invoked;
        std::shared_ptr<parameter_substitution::format> _format;
        mutable int _snapshot;
        std::vector<symbol::locator> _contributors;
        std::vector<symbol::locator> _subscribers;
        std::vector<bool> _no_expand_pararms;
        static int _current_snapshot_;
        static int _last_global_snapshot_;
        static std::set<std::string> _selected_symbols_set_;
        static symbol_table _sym_tab_;
        static table_entry _null_;
};

inline symbol::locator::locator()
: _loc(symbol::table().begin()) {}

inline symbol::locator::locator(std::string const & id)
:       _loc(symbol::table().lower_bound(id)) {
        if (_loc == symbol::table().end() || _loc->first != id) {
                _loc = symbol::insert(id,symbol::provenance::unconfigured,_loc);
        }
}

template<class CharSeq>
symbol::locator::locator(chewer<CharSeq> & chew) {
        std::string id = identifier::read(chew);
        _loc = symbol::table().lower_bound(id);
        if (_loc == symbol::table().end() || _loc->first != id) {
                _loc = symbol::insert(id,symbol::provenance::unconfigured,_loc);
        }
}

inline bool symbol::locator::null() const {
        return _loc == symbol::table().begin();
}

#endif //EOF