libs/EDoc/Function.cpp

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 by Brendon Costa

   This library is free software; you can redistribute it and/or modify 
   it under the terms of the "LGPL Like" License defined in the file COPYING 
   that should have been distributed along with this source.

   This library 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.  

   You should have received a copy of the "LGPL Like" License 
   along with this library; see the file COPYING. if not, it can be 
   obtained from the EDoc++ website: 
   http://edoc.sourceforge.net/license.html

*******************************************************************************/
#include "config.h"

#include "EDoc/Function.h"
#include "EDoc/Type.h"
#include "EDoc/FunctionType.h"
#include "EDoc/Dictionary.h"
#include "EDoc/PersistenceIFace.h"
#include "EDoc/exceptions.h"
#include "EDoc/Logger.h"
#include "EDoc/utils.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.h"
#include "EDoc/NotificationIFace.h"

#include "EDoc/persistence_data.h"
#include "IndexedDictionary.h"

#include <sstream>

#ifdef HAVE_STRING_H
   #include <string.h>
#endif

namespace EDoc
{
   //===========================================================================
   uint8_t Function::GetRecordType() const
   {
      return VALUE_RECORD_TYPE_FUNCTION;
   }
   //===========================================================================
   Function::Function(Dictionary& dict_in, std::string key_name_in) :
      StringIdentifiedObject(dict_in, key_name_in),
      is_public(false),
      is_inline(false),
      is_implicit(false),
      has_exception_spec(false),
      function_pointer_type(NULL),
      loc(&dict_in),
      exceptions_enabled(true),
      processed_implementations(0),
      translation_unit(NULL),
      implementation(&dict),
      calculated_propogating_exceptions(false),
      visible(true),
      subst_exception(NULL),
      total_calls(-1),
      circular(NULL),
      on_processed(NULL),
      on_processed_data(NULL)
   {
   }
   //===========================================================================
   Function::Function(Dictionary& dict_in, int32_t index_in) :
      StringIdentifiedObject(dict_in, index_in),
      is_public(false),
      is_inline(false),
      is_implicit(false),
      has_exception_spec(false),
      function_pointer_type(NULL),
      loc(&dict_in),
      exceptions_enabled(true),
      processed_implementations(0),
      translation_unit(NULL),
      implementation(&dict),
      calculated_propogating_exceptions(false),
      visible(true),
      subst_exception(NULL),
      total_calls(-1),
      circular(NULL),
      on_processed(NULL),
      on_processed_data(NULL)
   {
   }
   //===========================================================================
   Function::~Function()
   {
      RemoveFromCircular();
      delete subst_exception;
      subst_exception = NULL;
   }
   //===========================================================================
   void Function::RemoveFromCircular()
   {
      if (circular)
      {
         // Remove this function from the circular set.
         std::set<Function*>::iterator it = circular->find(this);
         EDOC_ASSERT(it != circular->end(), "");
         circular->erase(it);
         
         // If we are the last in the set, then delete the set.
         if (circular->size() == 0)
         {
            delete circular;
         }
         circular = NULL;
      }
   }
   //===========================================================================
   Function& Function::operator=(const Function& right)
   {
      // @@@Brendon Do i need to assign the StringIdentifiedObject parts too?
      if (this == &right)
      {
         return *this;
      }

      EDOC_Finer("Assign-Merging primitives.");
      link_name = right.link_name;
      full_name = right.full_name;
      is_public = right.is_public;
      is_inline = right.is_inline;
      is_implicit = right.is_implicit;
      translation_unit = right.translation_unit;

      has_exception_spec = right.has_exception_spec;
      calculated_propogating_exceptions = 
         right.calculated_propogating_exceptions;

      Erase(propogating_exceptions);

      loc = right.loc;

      Erase(exception_spec);
      for (size_t i = 0; i < right.exception_spec.size(); i++)
      {
         exception_spec.push_back(
            dict.types.AlwaysGet(*right.exception_spec[i]));
      }

      Erase(address_taken);
      for (size_t i = 0; i < right.address_taken.size(); i++)
      {
         address_taken.push_back(Location(&dict));
         address_taken.back() = right.address_taken[i];
      }

      Erase(derived_virtuals);
      for (size_t i = 0; i < right.derived_virtuals.size(); i++)
      {
         derived_virtuals.push_back(
            dict.functions.AlwaysGet(
               *right.derived_virtuals[i]));
      }

      function_pointer_type = NULL;
      if (right.function_pointer_type)
      {
         function_pointer_type = dict.function_types.AlwaysGet(
            *right.function_pointer_type);
      }

      exceptions_enabled = right.exceptions_enabled;

      processed_implementations = right.processed_implementations;

      EDOC_Finer("Assign-Merging : Merging implementations.");
      EDOC_Finer("Right implementation is: " << right.implementation);
      implementation = right.implementation;
      EDOC_Finer("Our implementation is: " << implementation);
      
      populated = right.populated;
      

      Erase(referenced_in_files);
      EDOC_FOREACH_CONST(FilePList, it, right.referenced_in_files)
      {
         referenced_in_files.push_back(
            dict.files.AlwaysGet(*(*it)));
      }

      visible = right.visible;
      return *this;
   }
   //===========================================================================
   void Function::Read(PersistenceIFace& file, IndexedDictionary& idict)
   {
      size_t size = 0;

      link_name = file.ReadString(KEY_LINK_NAME);
      full_name = file.ReadString(KEY_FULL_NAME);
      is_public = file.ReadBoolean(KEY_IS_PUBLIC);
      is_inline = file.ReadBoolean(KEY_IS_INLINE);
      is_implicit = file.ReadBoolean(KEY_IS_IMPLICIT);
      translation_unit = dict.GetIndexedTranslationUnit(
         file.ReadUInt32(KEY_TRANSLATION_UNIT));
      loc.Read(file, idict);

      has_exception_spec = file.ReadBoolean(KEY_HAS_EXCEPTION_SPEC);
      if (has_exception_spec)
      {
         size = file.ReadUInt32(KEY_EXCEPTION_SPEC_LS);
         for (size_t i = 0; i < size; i++)
         {
            exception_spec.push_back(
               idict.types.AlwaysGet(file.ReadUInt32(KEY_EXCEPTION_SPEC_LI)));
         }
      }

      size = file.ReadUInt32(KEY_DERIVED_VIRT_LS);
      for (size_t i = 0; i < size; i++)
      {
         derived_virtuals.push_back(
            idict.functions.AlwaysGet(
               file.ReadUInt32(KEY_DERIVED_VIRT_LI)));
      }

      size = file.ReadUInt32(KEY_ADDRESS_TAKEN_LS);
      for (size_t i = 0; i < size; i++)
      {
         Location l(&dict);
         l.Read(file, idict);
         address_taken.push_back(loc);
      }
      if (address_taken.size())
      {
         function_pointer_type = idict.function_types.AlwaysGet(
            file.ReadUInt32(KEY_FUNCTION_TYPE));
      }


      size = file.ReadUInt32(KEY_REFERENCE_FILES_LS);
      for (size_t i = 0; i < size; i++)
      {
         referenced_in_files.push_back(
            idict.files.AlwaysGet(file.ReadUInt32(KEY_REFERENCE_FILE)));
      }

      exceptions_enabled = file.ReadBoolean(KEY_EXCEPTIONS_ENABLED);


      processed_implementations = file.ReadUInt32(KEY_PROCESSED_IMPLEMENTATION);
      if (processed_implementations)
      {
         EDOC_Finer("Reading implementation.");
         implementation.Read(file, idict);
         EDOC_Finer("Done reading implementation.");
      }

      // Private functions have a key name that includes the name of the file
      // this implementation is in. I.e. they are static or part of an anon
      // namespace. 
      // This uses the compile unit name and not the name of the file it came
      // from because we need to ensure uniqueness within different translation
      // units even if the function was implemented as a static ina header file.
      populated = true;
      if (is_public && !is_inline)
      {
         SetKeyName(link_name);
      }
      else
      {
         // If this is a private file then it should only EVER be referenced in
         // a single file which is the single translation unit that it belongs
         // to. We ensure the uniqueness of the key name by appending the name
         // of the translation unit to which it belongs to the link name.
         if (referenced_in_files.size() != 1)
         {
            EDOC_THROW_EXCEPTION(FileIOException, 
               "All private functions should be referenced in exactly "
               "1 translation unit.", "");
         }
         
         std::ostringstream stream;
         stream << link_name << ":" << translation_unit->GetID() << ":" 
            << translation_unit->GetName();
         SetKeyName(stream.str());
      }
   }
   //===========================================================================
   void Function::Write(PersistenceIFace& file) const
   {
      file.WriteString(KEY_LINK_NAME, link_name);
      file.WriteString(KEY_FULL_NAME, full_name);
      file.WriteBoolean(KEY_IS_PUBLIC, is_public);
      file.WriteBoolean(KEY_IS_INLINE, is_inline);
      file.WriteBoolean(KEY_IS_IMPLICIT, is_implicit);
      file.WriteUInt32Debug(KEY_TRANSLATION_UNIT, 
         dict.GetTranslationUnitIndex(translation_unit),
         translation_unit->GetName());
      loc.Write(file);

      file.WriteBoolean(KEY_HAS_EXCEPTION_SPEC, has_exception_spec);
      if (has_exception_spec)
      {
         file.WriteUInt32(KEY_EXCEPTION_SPEC_LS, exception_spec.size());
         for (size_t i = 0; i < exception_spec.size(); i++)
         {
            file.WriteUInt32Debug(KEY_EXCEPTION_SPEC_LI, 
               exception_spec[i]->GetIndex(), 
               exception_spec[i]->GetDeclaredName());
         }
      }

      file.WriteUInt32(KEY_DERIVED_VIRT_LS,
         derived_virtuals.size());
      for (size_t i = 0; i < derived_virtuals.size(); i++)
      {
         file.WriteUInt32Debug(KEY_DERIVED_VIRT_LI, 
            derived_virtuals[i]->GetIndex(),
            derived_virtuals[i]->GetDeclaredName());
      }


      file.WriteUInt32(KEY_ADDRESS_TAKEN_LS, address_taken.size());
      for (size_t i = 0; i < address_taken.size(); i++)
      {
         address_taken[i].Write(file);
      }
      
      if (address_taken.size())
      {
         file.WriteUInt32Debug(KEY_FUNCTION_TYPE, 
            function_pointer_type->GetIndex(), 
            function_pointer_type->GetKeyName());
      }

      file.WriteUInt32(KEY_REFERENCE_FILES_LS, referenced_in_files.size());
      EDOC_FOREACH_CONST(FilePList, it, referenced_in_files)
      {
         file.WriteUInt32Debug(KEY_REFERENCE_FILE,
            (*it)->GetIndex(),
            (*it)->GetKeyName());
      }

      file.WriteBoolean(KEY_EXCEPTIONS_ENABLED, exceptions_enabled);

      file.WriteUInt32(KEY_PROCESSED_IMPLEMENTATION, processed_implementations);
      if (processed_implementations)
      {
         implementation.Write(file);
      }   
   }
   //===========================================================================
   std::ostream& Function::Print(std::ostream& out, std::string prefix) const
   {
      out << prefix << "Link Name: " << link_name << std::endl;
      out << prefix << "Declared Name: " << full_name << std::endl;
      if (is_public)
      {
         out << prefix << "Is Public: True" << std::endl;
      }
      else
      {
         out << prefix << "Is Public: False" << std::endl;
      }

      if (is_inline)
      {
         out << prefix << "Is Inline: True" << std::endl;
      }
      else
      {
         out << prefix << "Is Inline: False" << std::endl;
      }

      if (is_implicit)
      {
         out << prefix << "Is Implicit: True" << std::endl;
      }
      else
      {
         out << prefix << "Is Implicit: False" << std::endl;
      }

      if (has_exception_spec)
      {
         out << prefix << "Has Throw Spec: True" << std::endl;
         out << prefix << "Throw spec: " << GetSpecString() << std::endl;
      }
      else
      {
         out << prefix << "Has Throw Spec: False" << std::endl;
      }

      for (size_t i = 0; i < derived_virtuals.size(); i++)
      {
         out << prefix << "Virtual Call through: " 
            << derived_virtuals[i]->GetDeclaredName() << " "
            << derived_virtuals[i]->GetSpecString() << std::endl;
      }

      for (size_t i = 0; i < address_taken.size(); i++)
      {
         out << prefix << "Address taken at: ";
         address_taken[i].SingleLinePrint(out);
         out << std::endl;
      }
      if (address_taken.size())
      {
         out << prefix << "Function Pointer Type: " 
            << function_pointer_type->GetKeyName() << std::endl;
      }

      loc.Print(out, prefix) << std::endl;

      if (exceptions_enabled)
      {
         out << prefix << "Exceptions enabled: True" << std::endl;
      }
      else
      {
         out << prefix << "Exceptions enabled: False" << std::endl;
      }

      out << prefix << "Implementation processed: " 
         << processed_implementations << std::endl;
         
      out << prefix << GetDeclaredName() << GetSpecString() << std::endl;
      if (processed_implementations)
      {
         implementation.Print(out, prefix);
      }

      if (calculated_propogating_exceptions)
      {
         out << prefix << "Calculated Propogating Exceptions: True" << std::endl;
      }
      else
      {
         out << prefix << "Calculated Propogating Exceptions: False" << std::endl;
      }
      
      EDOC_FOREACH_CONST(PropExcepList, it, propogating_exceptions)
      {
         out << prefix << INDENT_STR << "P: " << it->exception->type.value->GetDeclaredName() << std::endl;
      }
      
      out << prefix << "total_calls: " << total_calls << std::endl;
      if (circular)
      {
         out << prefix << "Part of circular callgraph along with:" << std::endl;
         EDOC_FOREACH_CONST(std::set<Function*>, it, *circular)
         {
            out << prefix << INDENT_STR
               << (*it)->GetDeclaredName() << " "
               << (*it)->GetSpecString() << std::endl;
         }
      }
      else
      {
         out << prefix << "NOT part of circular callgraph (or not yet calculated)." << std::endl;
      }
      return out;
   }

   //===========================================================================
   /** \brief define a small macro that is called upon a merge error.
    */
   #define EDOC_MERGE_ERROR(Message) \
      EDOC_Error("Function Name: " << GetKeyName() \
         << "\nMessage: " << Message); \
      EDOC_THROW_EXCEPTION(MergeException, "Failed merging function.", Message);
      
   //===========================================================================
   void Function::Merge(const StringIdentifiedObject& right_in)
   {
      const Function& right(dynamic_cast<const Function&>(right_in));
      
      // If this object has not been populated yet, then we just assign data
      // instead of merging, but we need to make sure we do not assign from its
      // pointer but use dict to get references to appropiate objects.
      if (!populated)
      {
         EDOC_Finer("This function has not been populated so doing an "
            "assign merge from the right function.");
         *this = right;
         return;
      }

      EDOC_Finer("Doing complex merge of function.");
      if (GetKeyName() != right.GetKeyName())
      {
         EDOC_MERGE_ERROR("Unable to merge two types with different names. "
            "Left: " << GetKeyName() << ", right: " 
            << right.GetKeyName());
      
      }

      // Otherwise we have two completed functions and need to perform a complex
      // merge operation.
      
      
      if (link_name != right.link_name)
      {
         EDOC_MERGE_ERROR("Unable to merge two functions with different names. "
            "Left: " << link_name << ", right: " 
            << right.link_name);
      
      }
      
      if (is_public != right.is_public)
      {
         EDOC_MERGE_ERROR("Unable to merge two functions when one is public "
            "and the other is private to a translation unit.");
      }

      if (is_inline != right.is_inline)
      {
         EDOC_MERGE_ERROR("Unable to merge two functions when one is inlined "
            "and the other is not.");
      }

      if (processed_implementations && right.processed_implementations &&
         (exceptions_enabled != right.exceptions_enabled))
      {
         EDOC_MERGE_ERROR("Unable to merge two functions which have two "
            "implementations where one implementation has been processed "
            "with exceptions enabled and the other without. "
            << "Left Function: " << GetKeyName()
            << ", Right Function: " << right.GetKeyName()
            << ", Left Declared Name: " << GetDeclaredName()
            << ", Right Declared Name: " << right.GetDeclaredName()
            << ", Left Location: " << loc
            << ", Right Location: " << right.loc
            << ", Left Ref in Files: " << GetRefInFilesString()
            << ", Right Ref in Files: " << right.GetRefInFilesString());
      }

      if (function_pointer_type && right.function_pointer_type && 
            (function_pointer_type->GetKeyName() != 
             right.function_pointer_type->GetKeyName()))
      {
         EDOC_MERGE_ERROR("Cant merge two functions with different types."
            " left: " << function_pointer_type->GetKeyName() 
            << ", right: " << right.function_pointer_type->GetKeyName());
      }

      // We dont care too much about the declared name. It may differ for each
      // translation unit. So only merge it if we dont currently have one.
      if (!full_name.size())
      {
         full_name = right.full_name;
      }

      // Merge the exceptions_enabled flag.
      // Object with an implementation takes precedence. Otherwise we dont care
      // really what value it has.
      if (!processed_implementations && right.processed_implementations)
      {
         exceptions_enabled = right.exceptions_enabled;
      }
      
      // Warn if the exception specs differ, but the merge should inherit the
      // most restrictive exception spec of both.
      bool exception_specs_differ = false;
      if (has_exception_spec != right.has_exception_spec)
      {
         exception_specs_differ = true;
      }


      if (!exception_specs_differ && 
         (exception_spec.size() != right.exception_spec.size()))
      {
         exception_specs_differ = true;
      }
      for (size_t i = 0; !exception_specs_differ && (i < exception_spec.size());
         i++)
      {
         bool found = false;
         for (size_t j = 0; j < right.exception_spec.size(); j++)
         {
            if (right.exception_spec[j]->GetNormalisedName() == 
               exception_spec[i]->GetNormalisedName())
            {
               found = true;
               break;
            }
         }

         if (!found)
         {
            exception_specs_differ = true;
         }
      }

      // If the specs differ then set the merged to the most restrictive spec.
      if (exception_specs_differ)
      {
         EDOC_NOTIFICATION(WDIFF_THROW, 
               "Function: " << GetKeyName()
            << ", Declared Name: " << GetDeclaredName()
            << ", Left Spec:  " << GetSpecString()
            << ", Right Spec: " << right.GetSpecString(),
            this, loc.file, loc.line, right.loc.file, right.loc.line, 
            NULL, NULL, NULL, NULL);
         //EDOC_WARNING(WDIFF_THROW, 
         //      "Function: " << GetKeyName()
         //   << ", Declared Name: " << GetDeclaredName()
         //   << ", Left Spec:  " << GetSpecString()
         //   << ", Right Spec: " << right.GetSpecString());
         
         EDOC_Warning("Merging two functions with different exception specs."
            << "\nLeft Spec: " << GetSpecString()
            << "\nRight Spec: " << right.GetSpecString()
            << "\nFunction Name: " << GetKeyName());

         has_exception_spec = true;
         std::vector<Type*> merged_spec;

         // only add an exception if it is found in both specs.
         for (size_t i = 0; i < exception_spec.size(); i++)
         {
            bool found = false;
            for (size_t j = 0; j < right.exception_spec.size(); j++)
            {
               if (right.exception_spec[j]->GetNormalisedName() == 
                  exception_spec[i]->GetNormalisedName())
               {
                  found = true;
                  break;
               }
            }

            if (found)
            {
               merged_spec.push_back(exception_spec[i]);
            }
         }
         exception_spec = merged_spec;

         EDOC_Warning("Resulting merged spec is: " << GetSpecString());
      }

      // Merge implicit function param.
      // If one is implicit and the other is not then just make the result 
      // NON-Implicit
      if (!right.is_implicit)
      {
         // @@@Brendon Warning if they differ?
         is_implicit = false;
      }
      
      // Merge the virt fall through.
      for (size_t i = 0; i < right.derived_virtuals.size(); i++)
      {
         bool found = false;
         for (size_t j = 0; j < derived_virtuals.size(); j++)
         {
            if (right.derived_virtuals[i]->GetKeyName() == 
               derived_virtuals[j]->GetKeyName())
            {
               found = true;
               break;
            }
         }

         if (!found)
         {
            derived_virtuals.push_back(
               dict.functions.AlwaysGet(*right.derived_virtuals[i]));
         }
      }

      // Merge the address taken list.
      for (size_t i = 0; i < right.address_taken.size(); i++)
      {
         bool found = false;
         for (size_t j = 0; j < address_taken.size(); j++)
         {
            if (right.address_taken[i] == address_taken[j])
            {
               found = true;
               break;
            }
         }

         // If the address does not exist then add it.
         if (!found)
         {
            // Need to use assign merge so that the location object references
            // files in our dictionary not its one.
            address_taken.push_back(Location(&dict));
            address_taken.back() = right.address_taken[i];
         }
      }

      // If the address has been taken after the merge and we do not have a
      // function pointer type then get it from the right instance.
      if (address_taken.size() && !function_pointer_type)
      {
         function_pointer_type = dict.function_types.AlwaysGet(
            *right.function_pointer_type);
      }

      // Locations are not merged, as it is possible for the function to be
      // defined in two different places. However if we have no source
      // information, then use the loc for the other file.
      if (!loc)
      {
         loc = right.loc;
      }

      // In situations wheremore than one implementation exists the last
      // implementation is used by the linker. We will set the translation unit
      // to equal the last one encountered.
      if (right.processed_implementations)
      {
         translation_unit = right.translation_unit;
      }
      
      
      // merge impls. This will return true if the impls needed to be merged
      // or false if no merge was necessary as the impls are the same or
      // have previously been merged.
      if (implementation.Merge(right.implementation))
      {
         // If the impls needed to be merged and BOTH had an impl, then it
         // means that we had differing impls. In this situation we need to 
         // warn the user that there is more than 1 impl.
         if (processed_implementations && right.processed_implementations)
         {
            EDOC_Finer("Merging Left implementation: " << implementation);
            EDOC_Finer("Merging Right implementation: " 
               << right.implementation);

            // We will warn the user, but will generate the union of the 
            // two impls. This will give a more pessimistic callgraph
            // and exception impl.
            // @@@Brendon Add to the description the left and right locations
            // for file/line.
            EDOC_NOTIFICATION(WDIFF_IMPL, 
               "Function: " << GetKeyName()
               << ", Declared Name: " << GetDeclaredName(),
               this, loc.file, loc.line, right.loc.file, right.loc.line, 
               NULL, NULL, NULL, NULL);
            implementation.Merge(right.implementation);
            
            EDOC_Warning("Failed merging function: " << right.GetKeyName()
               << ", with function: " << GetKeyName() 
               << " as their implementations differ.");
            EDOC_Warning("Left implementation: " << implementation);
            EDOC_Warning("Right implementation: " << right.implementation);
            EDOC_Warning("Left referenced in files: " << GetRefInFilesString());
            EDOC_Warning("Right referenced in files: " 
               << right.GetRefInFilesString());
            EDOC_Warning("Left declared at location: " << loc);
            EDOC_Warning("Right declared at location: " << right.loc);
         }
         
         processed_implementations++;
      }
      else if (!processed_implementations && right.processed_implementations)
      {
         // This is for the situation where right has an implementation but it
         // has an empty impl.
         processed_implementations++;
      }
      
      // Merge the file references after the rest so that it is eaasier to
      // seperate out where a problem may ocur if the implementation 
      // merge fails.
      EDOC_FOREACH_CONST(FilePList, it, right.referenced_in_files)
      {
         PushBackUnique(referenced_in_files,
            dict.files.AlwaysGet(*(*it)));
      }


      populated = true;
   }
   //===========================================================================
   std::string Function::GetSpecString() const
   {
      std::ostringstream stream;

      if (has_exception_spec)
      {
         stream << "throws(";
         for (size_t i = 0; i < exception_spec.size(); i++)
         {
            if (i != 0)
            {
               stream << ", ";
            }
            if (exception_spec[i]->IsPopulated())
            {
               stream << exception_spec[i]->GetDeclaredName();
            }
            else
            {
               stream << "(UNPOPULATED: " << exception_spec[i]->GetKeyName()
                  <<")";
            }
         }
         stream << ")";
      }

      return stream.str();
   }
   //===========================================================================
   void Function::ExpandCallGraph()
   {
      if (processed_implementations)
      {
         implementation.ExpandCallGraph(*this);
      }

      for (size_t j = 0; j < derived_virtuals.size(); j++)
      {
         EDOC_Finer("Adding POSSIBLE call for function: " 
            << GetKeyName() 
            << " to child virtual function: " 
            << derived_virtuals[j]->GetKeyName());
         implementation.AddPossCall(FunctionLoc(dict, derived_virtuals[j],
            *dict.UNKNOWN_LOCATION));
      }
   }
   //===========================================================================
   std::list<const PropogatingException*> Function::GetVisiblePropExceptions() const
   {
      std::list<const PropogatingException*> ret;
      EDOC_FOREACH_CONST(PropExcepList, it, propogating_exceptions)
      {
         if (it->IsVisible())
         {
            ret.push_back(&(*it));
         }
         else
         {
            EDOC_Info("Exception is not visible: " 
               << it->exception->type.value->GetDeclaredName());
            if (!it->visible)
            {
               EDOC_Info("At prop level.");
            }

            if (!it->exception->visible)
            {
               EDOC_Info("At orig level.");
            }

            if (!it->exception->type.value->visible)
            {
               EDOC_Info("At type level.");
            }
         }
      }
      
      return ret;
   }
   //===========================================================================
   bool Function::IsMain() const
   {
      return link_name == "main";
   }
   //===========================================================================
   bool Function::IsStaticInitialiser() const
   {
      // @@@Brendon This can be made a LOT faster.
      const char* STATIC_BASE_NAME = 
         "_Z41__static_initialization_and_destruction_0ii";
      size_t static_base_name_len = strlen(STATIC_BASE_NAME);
   
      return !strncmp(link_name.c_str(), 
         STATIC_BASE_NAME, static_base_name_len);
   }
   //===========================================================================
   bool Function::IsDestructor() const
   {
      // If the name has a ~ in it then it is a destructor.
      return full_name.find('~') != std::string::npos;
   }
   //===========================================================================
   //@@@Brendon Possibly use special C++ type conversion functions.
   #define EDOC_REPLACE(DataType, Data, From, To, Count) \
      if ((void*)Data == From) {Data = (DataType*)To; Count++;}
   //===========================================================================
   size_t Function::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      if (!stack.Push(this))
      {
         return count;
      }

      for (size_t i = 0; i < exception_spec.size(); i++)
      {
         EDOC_REPLACE(Type, exception_spec[i], remove, replace, count);
      }

      for (size_t i = 0; i < derived_virtuals.size(); i++)
      {
         EDOC_REPLACE(Function, derived_virtuals[i], 
            remove, replace, count);
      }

      for (size_t i = 0; i < address_taken.size(); i++)
      {
         count += address_taken[i].ReplaceReferences(stack, remove, replace);
      }

      EDOC_REPLACE(FunctionType, function_pointer_type, remove, replace, count);

      count += loc.ReplaceReferences(stack, remove, replace);

      if (processed_implementations)
      {
         count += implementation.ReplaceReferences(stack, remove, replace);
      }

      EDOC_FOREACH(PropExcepList, it, propogating_exceptions)
      {
         count += it->ReplaceReferences(stack, remove, replace);
      }

      for (size_t i = 0; i < filtered_exceptions.size(); i++)
      {
         count += filtered_exceptions[i].ReplaceReferences(stack, 
            remove, replace);
      }

      EDOC_FOREACH(FilePList, it, referenced_in_files)
      {
         EDOC_REPLACE(File, (*it), remove, replace, count);
      }

      if (circular)
      {
         EDOC_FOREACH(std::set<Function*>, it, *circular)
         {
            EDOC_ASSERT((void*)(*it) != remove, 
               "Replacing a function pointer after it has been populated "
               "into a circular callgraph is not currently supported.");
         }
      }

      return count;
   }
   //===========================================================================
   void Function::Validate(PStack& stack, const Dictionary& dict_in) const
   {
      // @@@Brendon Validate that the keyname from StringIdentifiedObject is the
      // same as what we would calculate the keyname to be from our internal
      // data. Mismatches may occur from assignment operator.

      StackRef ref(stack, this);
      if (!ref)
      {
         return;
      }
      
      EDOC_ASSERT(&dict == &dict_in, 
         "Current dict: " << &dict 
         << "\nRequired dict: " << &dict_in
         << "\nKey: " << key_name
         << "\nIndex: " << index);
      EDOC_ASSERT(populated, GetKeyName() << ", address: " << (void*)this);

      EDOC_ASSERT(translation_unit, "");

      EDOC_ASSERT(GetKeyName().size(), GetKeyName() << ", address: " 
         << (void*)this);
      EDOC_ASSERT(dict_in.functions.Get(GetKeyName()) == this, GetKeyName() 
         << ", address: " << (void*)this);
      
      for (size_t i = 0; i < exception_spec.size(); i++)
      {
         exception_spec[i]->Validate(stack, dict_in);
      }

      for (size_t i = 0; i < derived_virtuals.size(); i++)
      {
         derived_virtuals[i]->Validate(stack, dict_in);
      }

      for (size_t i = 0; i < address_taken.size(); i++)
      {
         address_taken[i].Validate(stack, dict_in);
      }

      if (address_taken.size())
      {
         EDOC_ASSERT(function_pointer_type, "");
         function_pointer_type->Validate(stack, dict_in);
      }
      else
      {
         EDOC_ASSERT(!function_pointer_type, "");
      }
      
      loc.Validate(stack, dict_in);

      
      implementation.Validate(stack, dict_in);

      bool got_filename = false;
      std::string filename = "";
      EDOC_FOREACH_CONST(PropExcepList, it, propogating_exceptions)
      {
         it->Validate(stack, dict_in);

         // All propogating exceptions should propogate from the same file.
         if (!got_filename)
         {
            filename = it->func.loc.file->GetName();
            if (filename.size())
            {
               got_filename = true;
            }
         }
         else
         {
            EDOC_ASSERT(it->func.loc.file->GetName() == filename, GetKeyName() 
               << ", address: " << (void*)this);
         }
      }

      for (size_t i = 0; i < filtered_exceptions.size(); i++)
      {
         filtered_exceptions[i].Validate(stack, dict_in);
      }

      EDOC_FOREACH_CONST(FilePList, it, referenced_in_files)
      {
         (*it)->Validate(stack, dict_in);
      }
      
      // If this is a static function then we require that it have an
      // implementation. This is really just a check to ensure the
      // GCC mod is working.
      //
      // @@@Brendon This check is failing. In particular for is_inline unused 
      // template members
      // And for is_public for some implicitly generated thunk functions
      // I will remove this for the time being.
      //if (!is_public || is_inline)
      //{
      //   EDOC_ASSERT(processed_implementations, 
      //      "Static and inline functions must have implementations." 
      //      << " Function: " << GetKeyName() << ", address: " << (void*)this
      //      << ", Details: " << *this);
      //}

      if (circular)
      {
         EDOC_FOREACH_CONST(std::set<Function*>, it, *circular)
         {
            EDOC_ASSERT((*it)->circular == circular, "");
            (*it)->Validate(stack, dict_in);
         }
      }
   }
   //===========================================================================
   std::string Function::GetRefInFilesString() const
   {
      std::ostringstream stream;
      EDOC_FOREACH_CONST(FilePList, it, referenced_in_files)
      {
         stream << "File: " 
            << (*it)->GetKeyName() 
            << std::endl;
      }
      
      return stream.str();
   }
   //===========================================================================
   std::list<EDoc::PropogatingException*> Function::GetPropogatingExceptions()
   {
      std::list<EDoc::PropogatingException*> ret;
      EDOC_FOREACH(PropExcepList, it, propogating_exceptions)
      {
         ret.push_back(&(*it));
      }

      return ret;
   }
   //===========================================================================
   Exception& Function::GetSubstException()
   {
      if (!subst_exception)
      {
         subst_exception = new Exception(&dict);
         subst_exception->type.loc = *dict.UNKNOWN_LOCATION;
         subst_exception->type.value = const_cast<Type*>(dict.SUBSTITUTION_EXCEPTION_TYPE);

         // This should never be in documentation anyway.
         subst_exception->visible = true;
         
         // This should be set temporarily by the function being calculated
         // when this exception is used.
         subst_exception->function = this;
      }
      
      return *subst_exception;
   }
   //===========================================================================
}

---