include/EDoc/TryBlock.h

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

*******************************************************************************/
#ifndef EDOC_TRYBLOCK_H
#define EDOC_TRYBLOCK_H

#include "EDoc/DictionarySpecific.h"
#include "EDoc/CatchBlock.h"

#include <string>
#include <ostream>
#include <vector>
#include <list>

namespace EDoc
{
   class PersistenceIFace;
   class IndexedDictionary;
   class Dictionary;
   class CodeBlock;
   class PStack;
   class Function;
   
   //===========================================================================
   /** \brief Represents a try block in C++ code.
    *
    * An instance of this class is created for every try block encountered in
    * C++ code. It is also created for certain other constructs like a special
    * cases where no exceptions are allowed. This is a special usage of the try
    * block. 
    * 
    * In normal usage a TryBlock has a number of associated CatchBlock's in the
    * catch_blocks list. When an exception occurs in the try block it can be
    * handled in one of the catch blocks. A special usage of this however is
    * when the catch_blocks list is empty. This is used to represent a block of
    * code that MUST NOT THROW ANY EXCEPTIONS. This is a special construct
    * defined internally to GCC for certain situations.
    */
   class TryBlock : public DictionarySpecific
   {
   public:

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::CodeBlock(Dictionary* dict_in=NULL)
       */
      TryBlock(Dictionary* dict_in=NULL);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::CodeBlock(const CodeBlock& right)
       */
      TryBlock(const TryBlock& right);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::CodeBlock(const CodeBlock& right, 
       * Dictionary& dict_in)
       */
      TryBlock(const TryBlock& right, Dictionary& dict_in);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::operator=()
       */
      TryBlock& operator=(const TryBlock& right);

      //------------------------------------------------------------------------
      /** \brief Destructor.
       */
      ~TryBlock();
      
      //------------------------------------------------------------------------
      /** \brief See CodeBlock::Read()
       */
      void Read(PersistenceIFace& file, IndexedDictionary& idict);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::Write()
       */
      void Write(PersistenceIFace& file) const;

      //------------------------------------------------------------------------
      /** \brief See DictionarySpecific::ReplaceReferences()
       */
      virtual size_t ReplaceReferences(PStack& stack, 
         void* remove, void* replace);

      //------------------------------------------------------------------------
      /** \brief See DictionarySpecific::Print()
       */
      virtual std::ostream& Print(std::ostream& out, 
         std::string prefix="") const;

      //------------------------------------------------------------------------
      /** \brief See DictionarySpecific::Validate()
       */
      virtual void Validate(PStack& stack, const Dictionary& dict_in) const;

      //------------------------------------------------------------------------
      /** \brief Equivilance operator (Works across dictionaries).
       */
      bool operator==(const TryBlock& right) const;







      //------------------------------------------------------------------------
      /** \brief See CodeBlock::ExpandCallGraph() as this is just a wrapper that
       * calls that in order to improve code readability.
       */
      void ExpandCallGraph(Function& function);


      //------------------------------------------------------------------------
      /** \brief A reference to the block of code executed inside the try block.
       *
       * Note: This is a pointer so we can have circular dependencies. It is 
       * simplest to break the circular include chain by making CodeBlock an
       * incomplete type in both the CatchBlock and TryBlock classes.
       */
      CodeBlock* try_block;

      //------------------------------------------------------------------------
      /** \brief A list of catch blocks in the order in which they are defined
       * in the C++ code.
       */
      std::vector<CatchBlock> catch_blocks;

      //------------------------------------------------------------------------

   };
   //===========================================================================
   typedef std::list<TryBlock> TryBlockList;
   
}

#endif // EDOC_TRYBLOCK_H

---