resolve_inherited_component.cpp

Go to the documentation of this file.

/*******************************************************************\
 
Module: GOTO Program Utilities
 
Author: Diffblue Ltd.
 
\*******************************************************************/
 
#include "resolve_inherited_component.h"
 
#include <util/range.h>
#include <util/std_types.h>
#include <util/symbol_table_base.h>
 
resolve_inherited_componentt::resolve_inherited_componentt(
  const symbol_table_baset &symbol_table)
  : symbol_table(symbol_table)
{
}
resolve_inherited_componentt::resolve_inherited_componentt( {…}
 
std::optional<resolve_inherited_componentt::inherited_componentt>
resolve_inherited_componentt::operator()(
  const irep_idt &class_id,
  const irep_idt &component_name,
  bool include_interfaces,
  const std::function<bool(const symbolt &)> user_filter)
{
  PRECONDITION(!class_id.empty());
  PRECONDITION(!component_name.empty());
 
  std::vector<irep_idt> classes_to_visit;
  classes_to_visit.push_back(class_id);
  while(!classes_to_visit.empty())
  {
    irep_idt current_class = classes_to_visit.back();
    classes_to_visit.pop_back();
 
    const irep_idt &full_component_identifier=
      build_full_component_identifier(current_class, component_name);
 
    const symbolt *symbol = symbol_table.lookup(full_component_identifier);
    if(symbol && user_filter(*symbol))
    {
      return inherited_componentt(current_class, component_name);
    }
 
    const auto current_class_symbol_it =
      symbol_table.symbols.find(current_class);
 
    if(current_class_symbol_it != symbol_table.symbols.end())
    {
      const auto parents =
        make_range(to_struct_type(current_class_symbol_it->second.type).bases())
          .map([](const struct_typet::baset &base) {
            return base.type().get_identifier();
          });
 
      if(include_interfaces)
      {
        classes_to_visit.insert(
          classes_to_visit.end(), parents.begin(), parents.end());
      }
      else
      {
        if(!parents.empty())
          classes_to_visit.push_back(*parents.begin());
      }
    }
  }
 
  return {};
}
resolve_inherited_componentt::operator()( {…}
 
irep_idt resolve_inherited_componentt::build_full_component_identifier(
  const irep_idt &class_name, const irep_idt &component_name)
{
  // Verify the parameters are called in the correct order.
  PRECONDITION(id2string(class_name).find("::")!=std::string::npos);
  PRECONDITION(id2string(component_name).find("::")==std::string::npos);
  return id2string(class_name)+'.'+id2string(component_name);
}
irep_idt resolve_inherited_componentt::build_full_component_identifier( {…}
 
irep_idt resolve_inherited_componentt::inherited_componentt::
  get_full_component_identifier() const
{
  return resolve_inherited_componentt::build_full_component_identifier(
    class_identifier, component_identifier);
}
irep_idt resolve_inherited_componentt::inherited_componentt:: {…}
 
std::optional<resolve_inherited_componentt::inherited_componentt>
get_inherited_method_implementation(
  const irep_idt &call_basename,
  const irep_idt &classname,
  const symbol_table_baset &symbol_table)
{
  resolve_inherited_componentt call_resolver{symbol_table};
  auto exclude_abstract_methods = [&](const symbolt &symbol) {
    return !symbol.type.get_bool(ID_C_abstract);
  };
 
  auto resolved_call =
    call_resolver(classname, call_basename, false, exclude_abstract_methods);
  if(!resolved_call)
  {
    // Check for a default implementation:
    resolved_call =
      call_resolver(classname, call_basename, true, exclude_abstract_methods);
  }
  if(!resolved_call)
  {
    // Finally accept any abstract definition, which will likely get stubbed:
    resolved_call = call_resolver(classname, call_basename, true);
  }
  return resolved_call;
}
get_inherited_method_implementation( {…}