iverilog/vhdlpp/scope.cc

/*
 * Copyright (c) 2011-2016 Stephen Williams (steve@icarus.com)
 * Copyright CERN 2013 / Stephen Williams (steve@icarus.com)
 *
 *    This source code is free software; you can redistribute it
 *    and/or modify it in source code form under the terms of the GNU
 *    General Public License as published by the Free Software
 *    Foundation; either version 2 of the License, or (at your option)
 *    any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

# include  "scope.h"
# include  "package.h"
# include  "subprogram.h"
# include  "entity.h"
# include  "std_funcs.h"
# include  "std_types.h"
# include  "compiler.h"
# include  <algorithm>
# include  <iostream>
# include  <iterator>
# include  <cstdio>
# include  <cstring>
# include  <cassert>
# include  <StringHeap.h>

using namespace std;

static int scope_counter = 0;

ScopeBase::ScopeBase(const ActiveScope&ref)
: old_signals_(ref.old_signals_), new_signals_(ref.new_signals_),
    old_variables_(ref.old_variables_), new_variables_(ref.new_variables_),
    old_components_(ref.old_components_), new_components_(ref.new_components_),
    use_types_(ref.use_types_), cur_types_(ref.cur_types_),
    use_constants_(ref.use_constants_), cur_constants_(ref.cur_constants_),
    use_subprograms_(ref.use_subprograms_), cur_subprograms_(ref.cur_subprograms_),
    scopes_(ref.scopes_), use_enums_(ref.use_enums_),
    initializers_(ref.initializers_), finalizers_(ref.finalizers_),
    package_header_(ref.package_header_), name_(ref.name_)
{
}

ScopeBase::~ScopeBase()
{
    //freeing of member objects is performed by child classes
}

void ScopeBase::cleanup()
{
    /*
     * A parent scope is destroyed only if all child scopes
     * were previously destroyed. There for we can delete all
     * objects that were defined in this scope, leaving
     * objects from the other scopes untouched.
     */
    delete_all(new_signals_);
    delete_all(new_variables_);
    delete_all(new_components_);
    delete_all(cur_types_);
    delete_all(cur_constants_);
    for (map<perm_string,SubHeaderList>::iterator cur = cur_subprograms_.begin()
                ; cur != cur_subprograms_.end() ; ++cur) {
        delete_all(cur->second);
    }
}

ScopeBase*ScopeBase::find_scope(perm_string name) const
{
    map<perm_string, ScopeBase*>::const_iterator it = scopes_.find(name);

    if(it != scopes_.end())
        return it->second;

    return NULL;
}

const VType*ScopeBase::find_type(perm_string by_name)
{
      map<perm_string,const VType*>::const_iterator cur = cur_types_.find(by_name);
      if (cur == cur_types_.end()) {
        cur = use_types_.find(by_name);
        if (cur == use_types_.end())
          return NULL;     // nothing found
      }

      return cur->second;
}

bool ScopeBase::find_constant(perm_string by_name, const VType*&typ, Expression*&exp) const
{
      typ = NULL;
      exp = NULL;

      map<perm_string,struct const_t*>::const_iterator cur = cur_constants_.find(by_name);
      if (cur == cur_constants_.end()) {
        cur = use_constants_.find(by_name);
        if (cur == use_constants_.end())
          return false;     // nothing found
      }

      typ = cur->second->typ;
      exp = cur->second->val;
      return true;
}

Signal* ScopeBase::find_signal(perm_string by_name) const
{
      map<perm_string,Signal*>::const_iterator cur = new_signals_.find(by_name);
      if (cur == new_signals_.end()) {
        cur = old_signals_.find(by_name);
        if (cur == old_signals_.end())
            return NULL;        // nothing found
      }

      return cur->second;
}

Variable* ScopeBase::find_variable(perm_string by_name) const
{
      map<perm_string,Variable*>::const_iterator cur = new_variables_.find(by_name);
      if (cur == new_variables_.end()) {
	    cur = old_variables_.find(by_name);
	    if (cur == old_variables_.end())
		return 0;     // nothing found
      }

      return cur->second;
}

const InterfacePort* ScopeBase::find_param(perm_string) const
{
      return NULL;
}

const InterfacePort* ScopeBase::find_param_all(perm_string by_name) const
{
      for(map<perm_string,SubHeaderList>::const_iterator cur = use_subprograms_.begin();
              cur != use_subprograms_.end(); ++cur) {
            const SubHeaderList& subp_list = cur->second;

            for(SubHeaderList::const_iterator it = subp_list.begin();
                        it != subp_list.end(); ++it) {
                if(const InterfacePort*port = (*it)->find_param(by_name))
                    return port;
            }
      }

      for(map<perm_string,SubHeaderList>::const_iterator cur = cur_subprograms_.begin();
              cur != cur_subprograms_.end(); ++cur) {
            const SubHeaderList& subp_list = cur->second;

            for(SubHeaderList::const_iterator it = subp_list.begin();
                        it != subp_list.end(); ++it) {
                if(const InterfacePort*port = (*it)->find_param(by_name))
                    return port;
            }
      }

      return NULL;
}

SubHeaderList ScopeBase::find_subprogram(perm_string name) const
{
      map<perm_string,SubHeaderList>::const_iterator cur;

      cur = cur_subprograms_.find(name);
      if (cur != cur_subprograms_.end())
            return cur->second;

      cur = use_subprograms_.find(name);
      if (cur != use_subprograms_.end())
            return cur->second;

      return find_std_subprogram(name);
}

const VTypeEnum* ScopeBase::is_enum_name(perm_string name) const
{
    for(list<const VTypeEnum*>::const_iterator it = use_enums_.begin();
            it != use_enums_.end(); ++it) {
        if((*it)->has_name(name))
            return *it;
    }

    return find_std_enum_name(name);
}

/*
 * This method is only used by the ActiveScope derived class to import
 * definition from another scope.
 */
void ScopeBase::do_use_from(const ScopeBase*that)
{
      for (map<perm_string,ComponentBase*>::const_iterator cur = that->old_components_.begin()
		 ; cur != that->old_components_.end() ; ++ cur) {
	    if (cur->second == 0)
		  continue;
	    old_components_[cur->first] = cur->second;
      }
      for (map<perm_string,ComponentBase*>::const_iterator cur = that->new_components_.begin()
         ; cur != that->new_components_.end() ; ++ cur) {
        if (cur->second == 0)
          continue;
        old_components_[cur->first] = cur->second;
      }

      for (map<perm_string,SubHeaderList>::const_iterator cur = that->cur_subprograms_.begin()
		 ; cur != that->cur_subprograms_.end() ; ++ cur) {
	    if (cur->second.empty())
		  continue;
	    use_subprograms_[cur->first] = cur->second;
      }

      for (map<perm_string,const VType*>::const_iterator cur = that->cur_types_.begin()
		 ; cur != that->cur_types_.end() ; ++ cur) {
	    if (cur->second == 0)
		  continue;
	    use_types_[cur->first] = cur->second;
      }

      for (map<perm_string,const_t*>::const_iterator cur = that->cur_constants_.begin()
		 ; cur != that->cur_constants_.end() ; ++ cur) {
	    use_constants_[cur->first] = cur->second;
      }

      use_enums_ = that->use_enums_;
}

void ScopeBase::transfer_from(ScopeBase&ref, transfer_type_t what)
{
    if(what & SIGNALS) {
        std::copy(ref.new_signals_.begin(), ref.new_signals_.end(),
            insert_iterator<map<perm_string, Signal*> >(
                new_signals_, new_signals_.end())
        );
        ref.new_signals_.clear();
    }

    if(what & VARIABLES) {
        std::copy(ref.new_variables_.begin(), ref.new_variables_.end(),
            insert_iterator<map<perm_string, Variable*> >(
                new_variables_, new_variables_.end())
        );
        ref.new_variables_.clear();
    }

    if(what & COMPONENTS) {
        std::copy(ref.new_components_.begin(), ref.new_components_.end(),
            insert_iterator<map<perm_string, ComponentBase*> >(
                new_components_, new_components_.end())
        );
        ref.new_components_.clear();
    }
}

SubprogramHeader*ScopeBase::match_subprogram(perm_string name,
                                             const list<const VType*>*params) const
{
    int req_param_count = params ? params->size() : 0;

    // Find all subprograms with matching name
    SubHeaderList l = find_std_subprogram(name);
    map<perm_string,SubHeaderList>::const_iterator cur;

    cur = use_subprograms_.find(name);
    if (cur != use_subprograms_.end())
        copy(cur->second.begin(), cur->second.end(),
                front_insert_iterator<SubHeaderList>(l));

    cur = cur_subprograms_.find(name);
    if(cur != cur_subprograms_.end())
        copy(cur->second.begin(), cur->second.end(),
                front_insert_iterator<SubHeaderList>(l));

    // Find the matching one
    for(SubHeaderList::iterator it = l.begin(); it != l.end(); ++it) {
        SubprogramHeader*subp = *it;

        if(req_param_count != subp->param_count())
            continue;

        // Do not check the return type here, it might depend on the arguments

        if(params) {
            list<const VType*>::const_iterator p = params->begin();
            bool ok = true;

            for(int i = 0; i < req_param_count; ++i) {
                const VType*param_type = subp->peek_param_type(i);

                if(*p && param_type && !param_type->type_match(*p)) {
                    ok = false;
                    break;
                }

                ++p;
            }

            if(!ok)
                continue;   // check another function
        }

        // Yay, we have a match!
        return subp;
    }

    return NULL;
}

void ScopeBase::generate_name()
{
    char buf[64];

    // Generate a name for the scope
    snprintf(buf, sizeof(buf), "__scope_%d", scope_counter++);
    name_ = gen_strings.make(buf);
}

SubprogramHeader* ActiveScope::recall_subprogram(const SubprogramHeader*subp) const
{
      list<const VType*> arg_types;
      SubprogramHeader*tmp;

      for(int i = 0; i < subp->param_count(); ++i)
          arg_types.push_back(subp->peek_param_type(i));

      if ((tmp = match_subprogram(subp->name(), &arg_types))) {
            assert(!tmp->body());
            return tmp;
      }

      if (package_header_) {
            tmp = package_header_->match_subprogram(subp->name(), &arg_types);
            assert(!tmp || !tmp->body());
            return tmp;
      }

      return NULL;
}

bool ActiveScope::is_vector_name(perm_string name) const
{
      if (find_signal(name))
	    return true;
      if (find_variable(name))
	    return true;

      const VType*dummy_type;
      Expression*dummy_exp;
      if (find_constant(name, dummy_type, dummy_exp))
	    return true;

      if (context_entity_ && context_entity_->find_port(name))
	    return true;

      return false;
}

ComponentBase* Scope::find_component(perm_string by_name)
{
      map<perm_string,ComponentBase*>::const_iterator cur = new_components_.find(by_name);
      if (cur == new_components_.end()) {
        cur = old_components_.find(by_name);
        if (cur == old_components_.end())
            return 0;
        else
            return cur->second;
      } else
	    return cur->second;
}

ActiveScope::ActiveScope(const ActiveScope*par)
: ScopeBase(*par), context_entity_(par->context_entity_)
{
    generate_name();

    // Move all the objects available in higher level scopes to use*/old* maps.
    // This way we can store the new items in now empty cur*/new* maps.
    merge(par->old_signals_.begin(), par->old_signals_.end(),
          par->new_signals_.begin(), par->new_signals_.end(),
          insert_iterator<map<perm_string, Signal*> >(
              old_signals_, old_signals_.end())
    );
    merge(par->old_variables_.begin(), par->old_variables_.end(),
          par->new_variables_.begin(), par->new_variables_.end(),
          insert_iterator<map<perm_string, Variable*> >(
              old_variables_, old_variables_.end())
    );
    merge(par->old_components_.begin(), par->old_components_.end(),
          par->new_components_.begin(), par->new_components_.end(),
          insert_iterator<map<perm_string, ComponentBase*> >(
              old_components_, old_components_.end())
    );
    merge(par->use_types_.begin(), par->use_types_.end(),
          par->cur_types_.begin(), par->cur_types_.end(),
          insert_iterator<map<perm_string, const VType*> >(
              use_types_, use_types_.end())
    );
    merge(par->use_subprograms_.begin(), par->use_subprograms_.end(),
          par->cur_subprograms_.begin(), par->cur_subprograms_.end(),
          insert_iterator<map<perm_string, SubHeaderList> >(
              use_subprograms_, use_subprograms_.end())
    );
}