include/EDoc/CatchBlock.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_CATCHBLOCK_H
#define EDOC_CATCHBLOCK_H

#include "EDoc/DictionarySpecific.h"
#include "EDoc/TypeLoc.h"
#include "EDoc/stdint.h"

#include <string>
#include <ostream>
#include <sstream>
#include <vector>

namespace EDoc
{
   class PersistenceIFace;
   class IndexedDictionary;
   class Dictionary;
   class Type;
   class CodeBlock;
   class PStack;
   class Function;
   typedef CodeBlock* CodeBlockPtr;
   
   //===========================================================================
   /** \brief Represents a catch statement in a block of code.
    *
    * Every catch block should be asssociated with a try block. It contains
    * information about the catch type, and stores a CodeBlock instance that
    * contains the code executed if an exception is encountered which matches
    * the catch_type.
    *
    * The following code will produce 2 CatchBlock instances one for the
    * catch(int) and the other for the catch(...)
    *
    * \code
    * try
    * {
    *    ...code...
    * }
    * catch(int i)
    * {
    *    ...code...
    * }
    * catch(...)
    * {
    *    ...code...
    * }
    *
    * \endcode
    *
    */
   class CatchBlock : public DictionarySpecific
   {
   public:

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

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

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

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

      //------------------------------------------------------------------------
      /** \brief Destructor.
       */
      ~CatchBlock();

      //------------------------------------------------------------------------
      /** \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 CatchBlock& 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);



      //------------------------------------------------------------------------
      // Public Primary Data values.
      //------------------------------------------------------------------------

      //------------------------------------------------------------------------
      /** \brief The type of exception this object will catch. 
       *
       * This is the type "..." for a catch all.
       */
      TypeLoc catch_type;

      //------------------------------------------------------------------------
      /** \brief The code that is executed upon this catch block handling 
       * an exception.
       *
       * 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.
       */
      CodeBlockPtr catch_code;

      //------------------------------------------------------------------------
   };
   //===========================================================================
   typedef std::vector<CatchBlock> CatchBlockVec;
}

#endif // EDOC_CATCHBLOCK_H

---