libs/EDoc/FunctionType.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/FunctionType.h"
#include "EDoc/PersistenceIFace.h"
#include "EDoc/Dictionary.h"
#include "EDoc/exceptions.h"
#include "EDoc/Logger.h"
#include "EDoc/utils.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.h"

#include "EDoc/Type.h"
#include "EDoc/Function.h"
#include "EDoc/NotificationIFace.h"

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

#include <iostream>

//==============================================================================
/** \brief define a small macro that is called upon a merge error.
 */
#define EDOC_MERGE_ERROR(Message) \
   EDOC_Error(Message); \
   EDOC_THROW_EXCEPTION(MergeException, \
      "Failed merging function type.", Message);


namespace EDoc
{
   //===========================================================================
   uint8_t FunctionType::GetRecordType() const
   {
      return VALUE_RECORD_TYPE_FUNCTION_TYPE;
   }
   //===========================================================================
   FunctionType::FunctionType(Dictionary& dict_in, std::string key_name_in) :
      StringIdentifiedObject(dict_in, key_name_in),
      return_type(NULL),
      method_context(NULL),
      is_const(false),
      has_exception_spec(false)
   {
   }
   //===========================================================================
   FunctionType::FunctionType(Dictionary& dict_in, int32_t index_in) :
      StringIdentifiedObject(dict_in, index_in),
      return_type(NULL),
      method_context(NULL),
      is_const(false),
      has_exception_spec(false)
   {
   }
   //===========================================================================
   FunctionType& FunctionType::operator=(const FunctionType& right)
   {
      // @@@Brendon Do i need to assign the StringIdentifiedObject parts too?
      if (this == &right)
      {
         EDOC_Finer("Not assigning as the instances are the same.");
         return *this;
      }

      full_name = right.full_name;
      return_type = dict.types.AlwaysGet(*right.return_type);
      method_context = NULL;
      if (right.method_context)
      {
         method_context = dict.types.AlwaysGet(*right.method_context);
      }

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

      has_exception_spec = right.has_exception_spec;
      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]));
      }

      populated = right.populated;
      return *this;
   }
   //===========================================================================
   void FunctionType::Read(PersistenceIFace& file, IndexedDictionary& idict)
   {
      size_t size = 0;
      
      full_name = file.ReadString(KEY_FULL_NAME);
      return_type = idict.types.AlwaysGet(file.ReadUInt32(KEY_RETURN_TYPE));
      is_const = file.ReadBoolean(KEY_IS_CONST);
      
      method_context = NULL;
      if (file.ReadBoolean(KEY_IS_METHOD))
      {
         method_context = idict.types.AlwaysGet(
            file.ReadUInt32(KEY_METHOD_CONTEXT));
      }

      size = file.ReadUInt32(KEY_PARAMETERS_LS);
      for (size_t i = 0; i < size; i++)
      {
         exception_spec.push_back(
            idict.types.AlwaysGet(file.ReadUInt32(KEY_PARAMETERS_LI)));
      }


      Erase(exception_spec);
      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)));
         }
      }

      populated = true;
      SetKeyName(full_name);
   }
   //===========================================================================
   void FunctionType::Write(PersistenceIFace& file) const
   {
      file.WriteString(KEY_FULL_NAME, full_name);
      file.WriteUInt32(KEY_RETURN_TYPE, return_type->GetIndex());
      file.WriteBoolean(KEY_IS_CONST, is_const);
      
      file.WriteBoolean(KEY_IS_METHOD, method_context);
      if (method_context)
      {
         file.WriteUInt32(KEY_METHOD_CONTEXT, method_context->GetIndex());
      }

      file.WriteUInt32(KEY_PARAMETERS_LS, exception_spec.size());
      for (size_t i = 0; i < exception_spec.size(); i++)
      {
         file.WriteUInt32(KEY_PARAMETERS_LI, exception_spec[i]->GetIndex());
      }


      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.WriteUInt32(KEY_EXCEPTION_SPEC_LI, 
               exception_spec[i]->GetIndex());
         }
      }
   }
   //===========================================================================
   std::ostream& FunctionType::Print(std::ostream& out, std::string prefix) const
   {
      out << prefix << "Name: " << full_name << std::endl;
      out << prefix << "Return Type: " << return_type->GetDeclaredName() 
         << std::endl;
      if (method_context)
      {
         out << prefix << "Method Context: " 
            << method_context->GetDeclaredName() << std::endl;
      }
      
      for (size_t i = 0; i < parameters.size(); i++)
      {
         out << prefix << "Parameter: " << parameters[i]->GetDeclaredName() 
            << std::endl;
      }
      
      if (is_const)
      {
         out << prefix << "Is Const: True" << std::endl;
      }
      else
      {
         out << prefix << "Is Const: False" << std::endl;
      }

      if (has_exception_spec)
      {
         out << prefix << "Has Throw Spec: True" << std::endl;
         out << "Throw spec: " << GetSpecString() << std::endl;
      }
      else
      {
         out << prefix << "Has Throw Spec: False" << std::endl;
      }
      
      return out;
   }
   //===========================================================================
   void FunctionType::Merge(const StringIdentifiedObject& right_in)
   {
      const FunctionType& right(dynamic_cast<const FunctionType&>(right_in));
      
      if (!populated)
      {
         *this = right;
         return;
      }
      
      if (full_name != right.full_name)
      {
         EDOC_MERGE_ERROR("Unable to merge two function types with "
            "different names. "
            "Left: " << full_name << ", right: " << right.full_name);
      }
      
      if (return_type->GetNormalisedName() != 
         right.return_type->GetNormalisedName())
      {
         EDOC_MERGE_ERROR("Unable to merge two function types @@@");
      }
      
      if ((method_context && !right.method_context) ||
          (!method_context && right.method_context))
      {
         EDOC_MERGE_ERROR("Unable to merge two function types @@@");
      }
      else if (method_context && right.method_context)
      {
         if (method_context->GetNormalisedName() != 
            right.method_context->GetNormalisedName())
         {
            EDOC_MERGE_ERROR("Unable to merge two function types @@@");
         }
      }
      
      if (parameters.size() != right.parameters.size())
      {
         EDOC_MERGE_ERROR("Unable to merge two function types @@@");
      }
      
      for (size_t i = 0; i < parameters.size(); i++)
      {
         if (parameters[i]->GetNormalisedName() != 
            right.parameters[i]->GetNormalisedName())
         {
            EDOC_MERGE_ERROR("Unable to merge two function types @@@");
         }
      }
      
      if (is_const != right.is_const)
      {
         EDOC_MERGE_ERROR("Unable to merge two function types @@@");
      }
      
      // Merge exception specs with warnings, but do not emit any errors...
      // 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(), 
            NULL, NULL, 0, NULL, 0, NULL, NULL, this, 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());
      }
      
   }
   //===========================================================================
   std::string FunctionType::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();
   }
   //===========================================================================
   bool FunctionType::IsEquivilant(const FunctionType& right) const
   {
      if (this == &right)
      {
         return true;
      }
      
      // Check the return types.
      if (!return_type->IsEquivilant(*right.return_type))
      {
         return false;
      }
      
      // Check the parameter list sizes.
      if (parameters.size() != right.parameters.size())
      {
         return false;
      }
      
      // Check the indicitual parameters.
      for (size_t i = 0; i < parameters.size(); i++)
      {
         if (!parameters[i]->IsEquivilant(*right.parameters[i]))
         {
            return false;
         }
      }
      
      // If we get this far then the function pointer types are the same.
      // @@@Brendon Do i warn about incompatible throw specs here?
      return true;
   }
   //===========================================================================
   //@@@Brendon Possibly use special C++ type conversion functions.
   #define EDOC_REPLACE(DataFunctionType, Data, From, To, Count) \
      if ((void*)Data == From) {Data = (DataFunctionType*)To; Count++;}
   //===========================================================================
   size_t FunctionType::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      if (!stack.Push(this))
      {
         return count;
      }

      EDOC_REPLACE(Type, return_type, remove, replace, count);
      EDOC_REPLACE(Type, method_context, remove, replace, count);

      for (size_t i = 0; i < parameters.size(); i++)
      {
         EDOC_REPLACE(Type, parameters[i], remove, replace, 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 < addressed_functions.size(); i++)
      {
         EDOC_REPLACE(Function, addressed_functions[i], remove, replace, count);
      }

      return count;
   }
   //===========================================================================
   void FunctionType::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, "");
      EDOC_ASSERT(dict_in.function_types.Get(GetKeyName()) == this, 
         "Our address: " << (const void*)this 
         << ", dicts address: " 
         << (const void*)dict_in.function_types.Get(GetKeyName())
         << " type: " << *this
         << " types scoped name: " << GetKeyName());

      EDOC_ASSERT(return_type, *this);
      return_type->Validate(stack, dict_in);

      if (method_context)
      {
         method_context->Validate(stack, dict_in);
      }

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

      // If there is no exception spec, then the list should not have anything
      // in it.
      if (!has_exception_spec)
      {
         EDOC_ASSERT(exception_spec.size() == 0, "");
      }

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


      for (size_t i = 0; i < addressed_functions.size(); i++)
      {
         EDOC_ASSERT(addressed_functions[i], *this);
         addressed_functions[i]->Validate(stack, dict_in);
      }
   }
   //===========================================================================
   std::string FunctionType::GetNameInternal(bool canonical) const
   {
      if (!canonical)
      {
         return full_name;
      }
      else
      {
         // Then we must construct a name based on the root types.
         std::ostringstream stream;
         
         stream << return_type->GetNormalisedName() << " (";
         if (method_context)
         {
            stream << method_context->GetNormalisedName() << "::";
         }
         stream << "*)(";
         for (size_t i = 0; i < parameters.size(); i++)
         {
            if (i == 0)
            {
               stream << parameters[i]->GetNormalisedName();
            }
            stream << ", " << parameters[i]->GetNormalisedName();
         }
         stream << ")";
         
         // @@@Brendon Do i include the throw spec?
         return stream.str();
      }
   }
   //===========================================================================

}

---