libs/EDoc/Type.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/Type.h"
#include "EDoc/PersistenceIFace.h"
#include "EDoc/Dictionary.h"
#include "EDoc/Function.h"
#include "EDoc/exceptions.h"
#include "EDoc/Logger.h"
#include "EDoc/utils.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.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 type.", Message);


namespace EDoc
{
   //===========================================================================
   uint8_t Type::GetRecordType() const
   {
      return VALUE_RECORD_TYPE_TYPE;
   }
   //===========================================================================
   Type::Type(Dictionary& dict_in, std::string key_name_in) :
      StringIdentifiedObject(dict_in, key_name_in),
      external_linkage(true),
      translation_unit(NULL),
      throw_type(NULL),
      root_type(NULL),
      loc(&dict_in),
      visible(true)
   {
   }
   //===========================================================================
   Type::Type(Dictionary& dict_in, int32_t index_in) :
      StringIdentifiedObject(dict_in, index_in),
      external_linkage(true),
      translation_unit(NULL),
      throw_type(NULL),
      root_type(NULL),
      loc(&dict_in),
      visible(true)
   {
   }
   //===========================================================================
   Type& Type::operator=(const Type& 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;
      }

      name = right.name;
      loc = right.loc;
      external_linkage = right.external_linkage;
      throw_type = dict.types.AlwaysGet(*right.throw_type);
      root_type = dict.types.AlwaysGet(*right.root_type);

      if (!external_linkage)
      {
         // This allows for direct assignment because translation units do not belong to dictionaries but live past them.
         translation_unit = right.translation_unit;
      }
      
      // Assing identical to fields.
      Erase(identical);
      for (size_t i = 0; i < right.identical.size(); i++)
      {
         identical.push_back(dict.types.AlwaysGet(
            *right.identical[i]));
      }

      // Merge catchable by fields.
      Erase(catchable);
      for (size_t i = 0; i < right.catchable.size(); i++)
      {
         catchable.push_back(dict.types.AlwaysGet(
            *right.catchable[i]));
      }

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

      populated = right.populated;
      visible = right.visible;
      return *this;
   }
   //===========================================================================
   void Type::Read(PersistenceIFace& file, IndexedDictionary& idict)
   {
      name = file.ReadString(KEY_CANONICAL_NAME);
      external_linkage = file.ReadBoolean(KEY_EXTERNAL_LINKAGE);
      if (!external_linkage)
      {
         translation_unit = idict.dict->GetIndexedTranslationUnit(
            file.ReadUInt32(KEY_TRANSLATION_UNIT));
      }
      
      throw_type = idict.types.AlwaysGet(file.ReadUInt32(KEY_THROW_TYPE));
      root_type = idict.types.AlwaysGet(file.ReadUInt32(KEY_ROOT_TYPE));

      loc.Read(file, idict);

      size_t size = file.ReadUInt32(KEY_IDENTICAL_TYPE_LS);
      for (size_t i = 0; i < size; i++)
      {
         identical.push_back(
            idict.types.AlwaysGet(file.ReadUInt32(KEY_IDENTICAL_TYPE_LI)));
      }

      size = file.ReadUInt32(KEY_CATCHABLE_TYPE_LS);
      for (size_t i = 0; i < size; i++)
      {
         catchable.push_back(
            idict.types.AlwaysGet(file.ReadUInt32(KEY_CATCHABLE_TYPE_LI)));
      }

      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)));
      }

      populated = true;
      SetKeyName(GetNameInternal());
   }
   //===========================================================================
   std::ostream& Type::Print(std::ostream& out, std::string prefix) const
   {
      out << prefix << "Name: " << name << std::endl;

      out << prefix << "Throw Type: " 
         << (throw_type ? throw_type->GetNormalisedName() : "(NULL)") 
         << std::endl;

      out << prefix << "Root Type: " 
         << (root_type ? root_type->GetNormalisedName() : "(NULL)") 
         << std::endl;

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

      for (size_t i = 0; i < identical.size(); i++)
      {
         out << prefix << "Identical to: " << identical[i]->GetNormalisedName() << std::endl;
      }

      for (size_t i = 0; i < catchable.size(); i++)
      {
         out << prefix << "Catchable by: " << catchable[i]->GetNormalisedName() << std::endl;
      }

      return out;
   }

   //===========================================================================
   bool Type::operator==(const Type& right) const
   {
      if ((name != right.name) || 
          (external_linkage != right.external_linkage) ||
          (identical.size() != right.identical.size()) ||
          (catchable.size() != right.catchable.size()) ||
          (throw_type != right.throw_type) || 
          (root_type != right.root_type) ||
          (loc != right.loc))
      {
         return false;
      }

      if (!external_linkage)
      {
         if (translation_unit->GetID() != 
            right.translation_unit->GetID())
         {
            return false;
         }
      }
      
      for (size_t i = 0; i < identical.size(); i++)
      {
         if (identical[i] != right.identical[i])
         {
            return false;
         }
      }

      for (size_t i = 0; i < catchable.size(); i++)
      {
         if (catchable[i] != right.catchable[i])
         {
            return false;
         }
      }

      return true;
   }
   //===========================================================================
   void Type::Merge(const StringIdentifiedObject& right_in)
   {
      const Type& right(dynamic_cast<const Type&>(right_in));
      
      if (!populated)
      {
         *this = right;
         return;
      }
      
      if (external_linkage != right.external_linkage)
      {
         EDOC_MERGE_ERROR("");
      }
      
      if (!external_linkage)
      {
         if (translation_unit->GetID() != 
            right.translation_unit->GetID())
         {
            EDOC_Error("Our translation unit name: " 
               << translation_unit->GetName() 
               << "\nRight translation unit name: " 
               << right.translation_unit->GetName());
            EDOC_MERGE_ERROR("Unable to merge two types with internal "
               "linkage but of different translation units.");
         }
      }
      
      
      if (!name.size())
      {
         EDOC_Finer("Assigning name: " << right.name);
         name = right.name;
      }
      else if (right.name.size() && (name != right.name))
      {
         EDOC_MERGE_ERROR("Unable to merge two types with different names. "
            "Left: " << name << ", right: " << right.name);
      
      }
      else
      {
         EDOC_Finer("Otherwise we have a name and it is equal to the right "
            "name or right has no name.");
      }

      // @@@Brendon This is probably not what we want.
      if (loc && right.loc && (loc != right.loc))
      {
         EDOC_MERGE_ERROR("Unable to merge two types declared in "
            "different files.");
      }
      else if (!loc)
      {
         EDOC_Finer("Merging locations.");
         loc.Merge(right.loc);
      }


      // Expect one or the other to have a throw type.
      if (!throw_type && !right.throw_type)
      {
         EDOC_MERGE_ERROR("Unable to merge two incomplete types.");
      }
      else if (!throw_type)
      {
         throw_type = dict.types.AlwaysGet(*right.throw_type);
      }
      else if (!right.throw_type)
      {
         // Do nothing.
         EDOC_ASSERT(throw_type, "");
      }
      else if (throw_type->GetNormalisedName() != right.throw_type->GetNormalisedName())
      {
         std::ostringstream ls;
         ls << "Referenced in files: ";
         EDOC_FOREACH(FilePList, it, referenced_in_files)
         {
            if (it != referenced_in_files.begin())
            {
               ls << ", ";
            }
            ls << (*it)->GetName();
         }
         ls << std::endl;
         Print(ls);
         
         std::ostringstream rs;
         rs << "Referenced in files: ";
         EDOC_FOREACH_CONST(FilePList, it, right.referenced_in_files)
         {
            if (it != right.referenced_in_files.begin())
            {
               rs << ", ";
            }
            rs << (*it)->GetName();
         }
         rs << std::endl;
         right.Print(rs);
         
         EDOC_Error("Type: " << GetKeyName() << " is found in two files but has differing throw types. They are"
            << "\nLeft: " << throw_type->GetNormalisedName()
            << "\nRight: " << right.throw_type->GetNormalisedName()
            << "\n\nLeft: " << ls.str()
            << "\n\nRight: " << rs.str());
         EDOC_MERGE_ERROR("Cant merge types with differing throw types.");
      }
      else
      {
         EDOC_Finer("Eithre throw types are the same of both NULL. right: " 
            << (right.throw_type ? right.throw_type->GetNormalisedName():"(NULL)"));
      }

      // Expect one or the other to have a root_type.
      if (!root_type && !right.root_type)
      {
         EDOC_MERGE_ERROR("Unable to merge two incomplete types.");
      }
      else if (!root_type)
      {
         root_type = dict.types.AlwaysGet(*right.root_type);
      }
      else if (!root_type)
      {
         // Do nothing.
         EDOC_ASSERT(root_type, "");
      }
      else if (root_type->GetNormalisedName() != right.root_type->GetNormalisedName())
      {
         EDOC_MERGE_ERROR("Cant merge types with differing root_type types.");
      }


      // Merge identical to fields.
      for (size_t i = 0; i < right.identical.size(); i++)
      {
         // Dont add duplicates.
         Type* t = dict.types.AlwaysGet(*right.identical[i]);
         for (size_t j = 0; j < identical.size() && t; j++)
         {
            if (t == identical[j])
            {
               t = NULL;
            }
         }

         if (t)
         {
            identical.push_back(t);
         }
      }

      // Merge catchable by fields.
      for (size_t i = 0; i < right.catchable.size(); i++)
      {
         // Dont add duplicates.
         Type* t = dict.types.AlwaysGet(*right.catchable[i]);
         for (size_t j = 0; j < catchable.size() && t; j++)
         {
            if (t == catchable[j])
            {
               t = NULL;
            }
         }

         if (t)
         {
            catchable.push_back(t);
         }
      }

      // Merge the file references
      EDOC_FOREACH_CONST(FilePList, it, right.referenced_in_files)
      {
         PushBackUnique(referenced_in_files,
            dict.files.AlwaysGet(*(*it)));
      }

      // After doing this we are assumed to be populated.
      populated = true;
   }

   //===========================================================================
   bool Type::IsCaughtBy(const Type& right) const
   {
      //returns true if this type is catchable by the type passed in as "right".

      if (&right == this)
      {
         return true;
      }

      if (right.name == "...")
      {
         return true;
      }

      if (!throw_type || !right.throw_type)
      {
         EDOC_THROW_EXCEPTION(BugException, "@@@Brendon", "");
      }

      if (right.throw_type == throw_type)
      {
         return true;
      }

      // @@@Brendon Do i want to take into account identical types?
      
      // Check to see if the type on the right is in our catchable list. I.e.
      // Can this be caught by right
      for (size_t i = 0; i < throw_type->catchable.size(); i++)
      {
         if (throw_type->catchable[i] == right.throw_type)
         {
            return true;
         }
      }

      // No matching catch.
      return false;
   }

   //===========================================================================
   void Type::Write(PersistenceIFace& file) const
   {
      file.WriteString(KEY_CANONICAL_NAME, name);
      file.WriteBoolean(KEY_EXTERNAL_LINKAGE, external_linkage);
      if (!external_linkage)
      {
         file.WriteUInt32Debug(KEY_TRANSLATION_UNIT, 
            dict.GetTranslationUnitIndex(translation_unit),
            translation_unit->GetName());
      }
      
      
      file.WriteUInt32Debug(KEY_THROW_TYPE, throw_type->GetIndex(),
         throw_type->name);
      file.WriteUInt32Debug(KEY_ROOT_TYPE, root_type->GetIndex(), root_type->name);

      loc.Write(file);

      file.WriteUInt32(KEY_IDENTICAL_TYPE_LS, identical.size());
      for (size_t i = 0; i < identical.size(); i++)
      {
         file.WriteUInt32Debug(KEY_IDENTICAL_TYPE_LI, identical[i]->GetIndex(), 
            identical[i]->name);
      }

      file.WriteUInt32(KEY_CATCHABLE_TYPE_LS, catchable.size());
      for (size_t i = 0; i < catchable.size(); i++)
      {
         file.WriteUInt32Debug(KEY_CATCHABLE_TYPE_LI, catchable[i]->GetIndex(), 
            catchable[i]->name);
      }

      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());
      }
   }
   //===========================================================================
   bool Type::IsEquivilant(const Type& right) const
   {
      if (this == &right)
      {
         return true;
      }

      // If the types have the same key names then they are the same and no
      // additional checks need to be performed.
      if (GetKeyName() == right.GetKeyName())
      {
         return true;
      }
      
      // If eithre of the root types do not have external linkage then we must
      // assume they are equal.
      if (root_type->external_linkage &&
         right.root_type->external_linkage)
      {
         // If both have external linkage and the key names as above differ then
         // they are definatly different types.
         return false;
      }
      else
      {
         return true;
      }
   }
   //===========================================================================
   //@@@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 Type::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      if (!stack.Push(this))
      {
         return count;
      }

      //if (!external_linkage)
      //{
      //   //count += translation_unit->ReplaceReferences(stack, remove,
      //         replace);
      //   //EDOC_REPLACE(File, translation_unit, remove, replace, count);
      //}
      
      EDOC_REPLACE(Type, throw_type, remove, replace, count);
      EDOC_REPLACE(Type, root_type, remove, replace, count);

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

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

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

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

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

      if (!external_linkage)
      {
         EDOC_ASSERT(translation_unit, *this);
         //translation_unit->Validate(stack, dict_in);
      }
      else
      {
         EDOC_ASSERT(!translation_unit, *this);
      }
      
      EDOC_ASSERT(throw_type, *this);
      throw_type->Validate(stack, dict_in);

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

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

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

      loc.Validate(stack, dict_in);
      
      // Also test the "caches".
      EDOC_FOREACH_CONST(FilePList, it, referenced_in_files)
      {
         (*it)->Validate(stack, dict_in);
      }
   }
   //===========================================================================
   std::string Type::GetNameInternal() const
   {
      // The name of the type includes the file if it does not have external
      // linkage. I.e. When does not have external linkage the type is private
      // to the translation unit.
      std::ostringstream stream;
      if (!external_linkage)
      {
         stream << translation_unit->GetID() << ":" 
            << translation_unit->GetName() << ":" 
            << loc.line << ":"
            << name;
         return stream.str();
      }
      else
      {
         return name;
      }
   }
   //===========================================================================

}

---