src/core/idlast/namespace.cpp

   1 #include <stack>
   2 #include "core/idlast/namespace.h"
   3
   4 using namespace awful;
   5 using namespace awful::idlast;
   6
   7 Pointer< Namespace > Namespace::addNamespace( Namespace* pNamespace_ )
   8 {
   9         Pointer< Namespace > pNS = m_Namespaces.get( pNamespace_->getName() );
  10         if( pNS )
  11                 return pNS;
  12
  13         if( !m_Namespaces.add( pNamespace_ ) )
  14                 return 0;
  15
  16         pNamespace_->m_pParent = this;
  17         return pNamespace_;
  18 }
  19
  20 Pointer< Namespace > Namespace::findNamespace( std::string Name_ ) const
  21 {
  22         Pointer< Namespace > pNS = m_Namespaces.get( Name_ );
  23         if( pNS )
  24                 return pNS;
  25
  26         if( !m_pParent )
  27                 return NULL;
  28
  29         return m_pParent->findNamespace( Name_ );
  30 }
  31
  32 Pointer< Class > Namespace::findClass( std::string Name_, bool bStruct_ ) const
  33 {
  34         Pointer< Class > pClass;
  35
  36         if( bStruct_ )
  37                 pClass = m_Structs.get( Name_ );
  38         else
  39                 pClass = m_Classes.get( Name_ );
  40
  41         if( pClass )
  42                 return pClass;
  43
  44         if( !m_pParent )
  45                 return NULL;
  46
  47         return m_pParent->findClass( Name_, bStruct_ );
  48 }
  49
  50 void Namespace::resolveRefs() const
  51 {
  52         std::stack< const Namespace* > WorkStack;
  53
  54         WorkStack.push( this );
  55         while( !WorkStack.empty() )
  56         {
  57                 const Namespace* pCurrentNamespace = WorkStack.top();
  58                 WorkStack.pop();
  59
  60                 // Push child namespaces on the stack
  61                 const Dictionary< Namespace >& Namespaces = pCurrentNamespace->getNamespaces();
  62                 Dictionary< Namespace >::const_iterator nsit;
  63                 for( nsit = Namespaces.begin(); nsit != Namespaces.end(); ++nsit )
  64                         WorkStack.push( nsit->second );
  65
  66                 // Process classes
  67                 const Dictionary< Class >& Classes = pCurrentNamespace->getClasses();
  68                 Dictionary< Class >::const_iterator clit;
  69                 for( clit = Classes.begin(); clit != Classes.end(); ++clit )
  70                         clit->second->resolveRefs( false );
  71
  72                 // Process structs
  73                 const Dictionary< Class >& Structs = pCurrentNamespace->getStructs();
  74                 Dictionary< Class >::const_iterator stit;
  75                 for( stit = Structs.begin(); stit != Structs.end(); ++stit )
  76                         stit->second->resolveRefs( true );
  77         }
  78
  79         // Iterate through classes again to resolve the polymorphism flag
  80         WorkStack.push( this );
  81         while( !WorkStack.empty() )
  82         {
  83                 const Namespace* pCurrentNamespace = WorkStack.top();
  84                 WorkStack.pop();
  85
  86                 // Push child namespaces on the stack
  87                 const Dictionary< Namespace >& Namespaces = pCurrentNamespace->getNamespaces();
  88                 Dictionary< Namespace >::const_iterator nsit;
  89                 for( nsit = Namespaces.begin(); nsit != Namespaces.end(); ++nsit )
  90                         WorkStack.push( nsit->second );
  91
  92                 // Process classes
  93                 const Dictionary< Class >& Classes = pCurrentNamespace->getClasses();
  94                 Dictionary< Class >::const_iterator clit;
  95                 for( clit = Classes.begin(); clit != Classes.end(); ++clit )
  96                         clit->second->resolvePolymorphism();
  97         }
  98 }