libs/EDoc/CodeBlock.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/CodeBlock.h"
#include "EDoc/TryBlock.h"
#include "EDoc/utils.h"
#include "EDoc/Function.h"
#include "EDoc/Type.h"
#include "EDoc/FunctionType.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.h"
#include "EDoc/Dictionary.h"

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

namespace EDoc
{
   //===========================================================================
   CodeBlock::CodeBlock(Dictionary* dict_in) :
      DictionarySpecific(dict_in)
   {
   }
   //===========================================================================
   CodeBlock::CodeBlock(const CodeBlock& right) :
      DictionarySpecific(&right.dict)
   {
      *this = right;
   }
   //===========================================================================
   CodeBlock::CodeBlock(const CodeBlock& right, Dictionary& dict_in) :
      DictionarySpecific(&dict_in)
   {
      *this = right;
   }
   //===========================================================================
   CodeBlock& CodeBlock::operator=(const CodeBlock& right)
   {
      if (this == &right)
      {
         return *this;
      }

      Erase(function_calls);
      EDOC_FOREACH_CONST(FuncLocList, it, right.function_calls)
      {
         function_calls.push_back(FunctionLoc(*it, dict));
      }

      Erase(originating_exceptions);
      EDOC_FOREACH_CONST(ExcepList, it, right.originating_exceptions)
      {
         originating_exceptions.push_back(Exception(*it, dict));
      }

      Erase(function_pointer_calls);
      EDOC_FOREACH_CONST(FTypeLocList, it, right.function_pointer_calls)
      {
         function_pointer_calls.push_back(FunctionTypeLoc(*it, dict));
      }

      Erase(try_blocks);
      EDOC_FOREACH_CONST(TryBlockList, it, right.try_blocks)
      {
         try_blocks.push_back(TryBlock(*it, dict));
      }

      Erase(possible_function_calls);
      
      return *this;
   }
   //===========================================================================
   void CodeBlock::Read(PersistenceIFace& file, IndexedDictionary& idict)
   {
      size_t size = 0;

      size = file.ReadUInt32(KEY_FUNCTION_CALL_LS);
      Erase(function_calls);
      for (size_t i = 0; i < size; i++)
      {
         function_calls.push_back(FunctionLoc(&dict));
         function_calls.back().Read(file, idict);
      }

      size = file.ReadUInt32(KEY_ORIGINATING_EXCEPTIONS_LS);
      Erase(originating_exceptions);
      for (size_t i = 0; i < size; i++)
      {
         originating_exceptions.push_back(Exception(&dict));
         originating_exceptions.back().Read(file, idict);
      }

      size = file.ReadUInt32(KEY_FUNCP_CALLS_LS);
      Erase(function_pointer_calls);
      for (size_t i = 0; i < size; i++)
      {
         function_pointer_calls.push_back(FunctionTypeLoc(&dict));
         function_pointer_calls.back().Read(file, idict);
      }

      size = file.ReadUInt32(KEY_TRY_BLOCKS_LS);
      Erase(try_blocks);
      for (size_t i = 0; i < size; i++)
      {
         try_blocks.push_back(TryBlock(&dict));
         try_blocks.back().Read(file, idict);
      }
   }
   //===========================================================================
   void CodeBlock::Write(PersistenceIFace& file) const
   {
      file.WriteUInt32(KEY_FUNCTION_CALL_LS, function_calls.size());
      EDOC_FOREACH_CONST(FuncLocList, it, function_calls)
      {
         it->Write(file);
      }

      // Dont save originating exceptions that were generated automatically
      size_t size = 0;
      EDOC_FOREACH_CONST(ExcepList, it, originating_exceptions)
      {
         if (!it->auto_throw_spec)
         {
            size++;
         }
      }
      file.WriteUInt32(KEY_ORIGINATING_EXCEPTIONS_LS, size);
      EDOC_FOREACH_CONST(ExcepList, it, originating_exceptions)
      {
         if (!it->auto_throw_spec)
         {
            it->Write(file);
         }
      }

      file.WriteUInt32(KEY_FUNCP_CALLS_LS, function_pointer_calls.size());
      EDOC_FOREACH_CONST(FTypeLocList, it, function_pointer_calls)
      {
         it->Write(file);
      }

      file.WriteUInt32(KEY_TRY_BLOCKS_LS, try_blocks.size());
      EDOC_FOREACH_CONST(TryBlockList, it, try_blocks)
      {
         it->Write(file);
      }
   }
   //===========================================================================
   bool CodeBlock::Merge(const CodeBlock& right)
   {
      bool differed = false;
      
      #define EDOC_LIST_MERGE(VectorName, VectorType) \
      { \
         size_t i = 0; \
         for (std::list<VectorType>::const_iterator it = \
            right.VectorName.begin(); \
            it != right.VectorName.end(); \
            it++, i++) \
         { \
            EDOC_Finer("Searching in vector: right." << #VectorName \
               << ", size: " << right.VectorName.size() \
               << ", i: " << i); \
            bool found = false; \
            size_t j = 0; \
            for (std::list<VectorType>::const_iterator jt = \
               VectorName.begin(); \
               jt != VectorName.end(); \
               jt++, j++) \
            { \
               EDOC_Finer("Searching in vector: " << #VectorName \
                  << ", size: " << VectorName.size() \
                  << ", j: " << j); \
               if (*jt == *it) \
               { \
                  EDOC_Finer("Found in vector: " << #VectorName); \
                  found = true; \
                  break; \
               } \
            } \
             \
            if (!found) \
            { \
               differed = 1; \
               EDOC_Finer("Pushing empty onto back vector: " << #VectorName); \
               VectorName.push_back(VectorType(&dict)); \
               VectorName.back() = *it; \
            } \
         } \
      }

      EDOC_LIST_MERGE(function_calls, FunctionLoc)
      EDOC_LIST_MERGE(originating_exceptions, Exception)
      EDOC_LIST_MERGE(function_pointer_calls, FunctionTypeLoc)
      EDOC_LIST_MERGE(try_blocks, TryBlock)
      
      // Note: There is no need for merging at any deeper depths. This should
      // suffice for merging two different function implementations. It could be
      // made to generate less blocks by looking for try blocks with same catch
      // types and merging the impls etc, but it is not worth the effort and
      // will not change the functionality.
      return differed;
   }
   //===========================================================================
   bool CodeBlock::operator==(const CodeBlock& right) const
   {
      // Compare two code blocks (Possibly from different dictionaries)
      // for equality where the order of the data is unimportant but the
      // contents must be the same.
      #define EDOC_LIST_COMPARE(VectorName, VectorType) \
      if (VectorName.size() != right.VectorName.size()) \
      { \
         return false; \
      } \
      for (std::list<VectorType>::const_iterator it = VectorName.begin(); \
         it != VectorName.end(); it++) \
      { \
         bool found = false; \
         for (std::list<VectorType>::const_iterator jt = \
            right.VectorName.begin(); \
            jt != right.VectorName.end(); \
            jt++) \
         { \
            if (*it == *jt) \
            { \
               found = true; \
               break; \
            } \
         } \
         if (!found) \
         { \
            return false; \
         } \
      }

      EDOC_LIST_COMPARE(function_calls, FunctionLoc)
      EDOC_LIST_COMPARE(originating_exceptions, Exception)
      EDOC_LIST_COMPARE(function_pointer_calls, FunctionTypeLoc)
      EDOC_LIST_COMPARE(try_blocks, TryBlock)
      
      return true;
   }
   //===========================================================================
   std::list<FunctionLoc> CodeBlock::AllFunctionCalls()
   {
      std::list<FunctionLoc> ret(function_calls);
      Append(ret, possible_function_calls);
      return ret;
   }
   //===========================================================================
   void CodeBlock::AddPossCall(FunctionLoc func)
   {
      possible_function_calls.push_back(func);
      possible_function_calls.back().possible = true;
   }
   //===========================================================================
   std::list<CodeBlock*> CodeBlock::GetAllCodeBlocks()
   {
      std::list<CodeBlock*> ret;
      ret.push_back(this);
      
      EDOC_FOREACH(TryBlockList, it, try_blocks)
      {
         // Append the try blocks code segment.
         Append(ret, it->try_block->GetAllCodeBlocks());
         
         // Append the try blocks catchg segments code.
         EDOC_FOREACH(CatchBlockVec, jt, it->catch_blocks)
         {
            Append(ret, jt->catch_code->GetAllCodeBlocks());
         }
      }
      
      return ret;
   }
   //===========================================================================
   size_t CodeBlock::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      if (!stack.Push(this))
      {
         return count;
      }

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

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

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

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

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

      return count;
   }
   //===========================================================================
   std::ostream& CodeBlock::Print(std::ostream& out, std::string prefix) const
   {
      out << prefix << "{" << std::endl;
      
      EDOC_FOREACH_CONST(FuncLocList, it, function_calls)
      {
         out << prefix << INDENT_STR << "Call : " 
             << it->value->GetKeyName() << std::endl;
      }

      EDOC_FOREACH_CONST(FuncLocList, it, possible_function_calls)
      {
         out << prefix << INDENT_STR << "Poss Call : " 
             << it->value->GetKeyName() << std::endl;
      }

      EDOC_FOREACH_CONST(ExcepList, it, originating_exceptions)
      {
         out << prefix << INDENT_STR << "Throw : " 
             << it->type.value->GetKeyName() << std::endl;
      }

      EDOC_FOREACH_CONST(FTypeLocList, it, function_pointer_calls)
      {
         out << prefix << INDENT_STR << "FP Call : " 
             << it->value->GetKeyName() << std::endl;
      }

      EDOC_FOREACH_CONST(TryBlockList, it, try_blocks)
      {
         it->Print(out, prefix + INDENT_STR);
      }

      out << prefix << "}" << std::endl;
      return out;
   }
   //===========================================================================
   void CodeBlock::ExpandCallGraph(Function& function)
   {
      // Look at the function  pointer calls list and add any matches with
      // addresses taken to the possible_function_calls list
      EDOC_FOREACH(FTypeLocList, it, function_pointer_calls)
      {
         for (size_t j = 0; j < it->value->addressed_functions.size(); j++)
         {
            AddPossCall(FunctionLoc(dict, 
               it->value->addressed_functions[j], 
               it->loc));
         }
      }

      EDOC_FOREACH(TryBlockList, it, try_blocks)
      {
         it->ExpandCallGraph(function);
      }
   }
   //===========================================================================
   void CodeBlock::Validate(PStack& stack, const Dictionary& dict_in) const
   {
      StackRef ref(stack, this);
      if (!ref)
      {
         return;
      }
      
      EDOC_ASSERT(&dict == &dict_in, "");
      
      EDOC_FOREACH_CONST(FuncLocList, it, function_calls)
      {
         it->Validate(stack, dict_in);
      }

      EDOC_FOREACH_CONST(ExcepList, it, originating_exceptions)
      {
         it->Validate(stack, dict_in);
         EDOC_ASSERT(
            it->type.value->throw_type->external_linkage, 
            "Throw type of an originating exception should ALWAYS have "
            "external linkage."
            << "\nException type is: " 
            << it->type.value->GetKeyName()
            << "\nThrow type is: " 
            << it->type.value->throw_type->GetKeyName());
      }

      EDOC_FOREACH_CONST(FTypeLocList, it, function_pointer_calls)
      {
         it->Validate(stack, dict_in);
      }

      EDOC_FOREACH_CONST(TryBlockList, it, try_blocks)
      {
         it->Validate(stack, dict_in);
      }

      EDOC_FOREACH_CONST(FuncLocList, it, possible_function_calls)
      {
         it->Validate(stack, dict_in);
         EDOC_ASSERT(it->possible, "Possible function calls must always "
            "have the \"possible\" flag set to true in the "
            "FunctionLoc object.");
      }
   }
   //===========================================================================
   std::list<EDoc::Exception*> CodeBlock::GetOriginatingExceptions()
   {
      std::list<EDoc::Exception*> ret;
      for (std::list<Exception>::iterator it = 
         originating_exceptions.begin();
         it != originating_exceptions.end(); it++)
      {
         ret.push_back(&(*it));
      }

      return ret;
   }
   //===========================================================================
}

---