include/EDoc/FunctionLoc.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_FUNCTIONLOC_H
#define EDOC_FUNCTIONLOC_H

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

#include <list>

namespace EDoc
{
   class Function;
   class Type;
   class PStack;
   
   //===========================================================================
   /** \brief Is a conglomerate of a reference to a Function object and a
    * Location in a source file.
    *
    * This can be used for a few purposes one of which is to store data for a
    * function call. This way the function that is being called is stored along
    * with the location in the source code from which the call is made for
    * debugging purposes.
    */
   class FunctionLoc : public DictionarySpecific
   {
   public:

      //------------------------------------------------------------------------
      /** \brief Create a new FunctionLoc given the dictionary, a function to 
       * reference and the location.
       */
      FunctionLoc(Dictionary& dict_in, Function* value_in, 
         const Location& loc_in);

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

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

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

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

      //------------------------------------------------------------------------
      /** \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 FunctionLoc& right) const;

      //------------------------------------------------------------------------
      /** \brief Less than comparison so this can be used for std::map keys.
       *
       * Compares Location first then Function instances.
       */
      bool operator<(const FunctionLoc& right) const;






      //------------------------------------------------------------------------
      /** \brief A location in a source file.
       */
      Location loc;

      //------------------------------------------------------------------------
      /** \brief A reference to a Function.
       *
       * Note: As part of a propagating exception instance this value may be
       * NULL indicating that the propagating exception is an originating 
       * exception. So remember that this may have at some points a NULL value.
       */
      Function* value;

      //------------------------------------------------------------------------
      /** \brief When this object respresents a function call, then this flag
       * is true if the call is a "possible" call and not an explicit call.
       *
       * A possible call is one that results from a function pointer call or a
       * virtual function call.
       */
      bool possible;



      //------------------------------------------------------------------------
      // Public Temporary Data values.
      //------------------------------------------------------------------------

      //------------------------------------------------------------------------
      /** \brief USED ONLY FROM Dictionary::CalculatePropogatingExceptions()
       *
       * Data used by the CalculatePropogatingExceptions in order to
       * determine if a function loc object represents the current function
       * whose exception list is being calculated. This is really just temporary
       * data and does not belong here, but it is the simplest place to put it.
       */
      bool is_top_level;
      
      //------------------------------------------------------------------------
   };
   //===========================================================================
   typedef std::list<FunctionLoc> FuncLocList;
}

#endif // EDOC_FUNCTIONLOC_H

---