]> git.saurik.com Git - wxWidgets.git/blobdiff - utils/HelpGen/src/srcparser.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Added "set new icon" menu item to taskbar sample; updated some makefiles
[wxWidgets.git] / utils / HelpGen / src / srcparser.cpp
diff --git a/utils/HelpGen/src/srcparser.cpp b/utils/HelpGen/src/srcparser.cpp
index abe2cd9a9e4b4dafac52b806ef4364ae4a857a88..81d84ed431568a3b8632028e8b6d5acf548728fc 100644 (file)
--- a/utils/HelpGen/src/srcparser.cpp
+++ b/utils/HelpGen/src/srcparser.cpp
@@ -6,7 +6,7 @@
 // Created:     22/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Aleskandars Gluchovas
 // Created:     22/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Aleskandars Gluchovas
-// Licence:    wxWindows licence
+// Licence:       wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
@@ -33,468 +33,472 @@
 /***** Implementation for class spVisitor *****/
 
 void spVisitor::VisitAll( spContext& atContext,
 /***** Implementation for class spVisitor *****/
 
 void spVisitor::VisitAll( spContext& atContext,
-                                                 bool sortContent
-                                               )
+                          bool sortContent
+                        )
 {
 {
-       mSiblingSkipped = FALSE;
-       mChildSkipped   = FALSE;
-       mContextMask    = SP_CTX_ANY; // FIXME:: should be an arg.
+    mSiblingSkipped = FALSE;
+    mChildSkipped   = FALSE;
+    mContextMask    = SP_CTX_ANY; // FIXME:: should be an arg.
 
 
-       if ( sortContent && !atContext.IsSorted() )
+    if ( sortContent && !atContext.IsSorted() )
 
 
-               atContext.SortMembers();
+        atContext.SortMembers();
 
 
-       mpCurCxt = &atContext; // FIXME:: this is dirty, restoring it each time
+    mpCurCxt = &atContext; // FIXME:: this is dirty, restoring it each time
 
 
-       if ( atContext.GetContextType() & mContextMask )
+    if ( atContext.GetContextType() & mContextMask )
 
 
-               atContext.AcceptVisitor( *this );
+        atContext.AcceptVisitor( *this );
 
 
-       MMemberListT& members = atContext.GetMembers();
+    MMemberListT& members = atContext.GetMembers();
 
 
-       for( size_t i = 0; i != members.size(); ++i )
-       {
-               if ( mSiblingSkipped )
-               
-                       return;
+    for( size_t i = 0; i != members.size(); ++i )
+    {
+        if ( mSiblingSkipped )
+        
+            return;
 
 
-               if ( !mChildSkipped )
-               {
-                       size_t prevSz = members.size();
+        if ( !mChildSkipped )
+        {
+            size_t prevSz = members.size();
 
 
-                       // visit members of the context recursivelly
-                       VisitAll( *members[i], sortContent );
+            // visit members of the context recursivelly
+            VisitAll( *members[i], sortContent );
 
 
-                       if ( members.size() != prevSz )
+            if ( members.size() != prevSz )
 
 
-                               --i; // current member was removed!
+                --i; // current member was removed!
 
 
-                       mChildSkipped = 0;
-               }
-       }
+            mChildSkipped = 0;
+        }
+    }
 }
 
 void spVisitor::RemoveCurrentContext()
 {
 }
 
 void spVisitor::RemoveCurrentContext()
 {
-       if ( mpCurCxt->GetParent() )
+    if ( mpCurCxt->GetParent() )
 
 
-               mpCurCxt->GetParent()->RemoveChild( mpCurCxt );
+        mpCurCxt->GetParent()->RemoveChild( mpCurCxt );
 }
 
 void spVisitor::SkipSiblings()
 {
 }
 
 void spVisitor::SkipSiblings()
 {
-       mSiblingSkipped = TRUE;
+    mSiblingSkipped = TRUE;
 }
 
 void spVisitor::SkipChildren()
 {
 }
 
 void spVisitor::SkipChildren()
 {
-       mChildSkipped = TRUE;
+    mChildSkipped = TRUE;
 }
 
 void spVisitor::SetFilter( int contextMask )
 {
 }
 
 void spVisitor::SetFilter( int contextMask )
 {
-       mContextMask = contextMask;
+    mContextMask = contextMask;
 }
 
 /***** Implementation for class spComment *****/
 
 bool spComment::IsMultiline()  const
 {
 }
 
 /***** Implementation for class spComment *****/
 
 bool spComment::IsMultiline()  const
 {
-       return mIsMultiline;
+    return mIsMultiline;
 }
 
 bool spComment::StartsParagraph() const
 {
 }
 
 bool spComment::StartsParagraph() const
 {
-       return mStartsPar;
+    return mStartsPar;
 }
 
 string& spComment::GetText()
 {
 }
 
 string& spComment::GetText()
 {
-       return mText;
+    return mText;
 }
 
 string spComment::GetText() const
 {
 }
 
 string spComment::GetText() const
 {
-       return mText;
+    return mText;
 }
 
 /***** Implementation for class spContext *****/
 
 spContext::spContext()
 
 }
 
 /***** Implementation for class spContext *****/
 
 spContext::spContext()
 
-       : mpParent        ( NULL ),
-         mpFirstOccurence( NULL ),
-         mAlreadySorted  ( FALSE ),
+    : mpParent        ( NULL ),
+      mpFirstOccurence( NULL ),
+      mAlreadySorted  ( FALSE ),
 
 
-         mSrcLineNo    (-1),
-         mSrcOffset    (-1),
-         mContextLength(-1),
-         mLastScrLineNo(-1),
+      mSrcLineNo    (-1),
+      mSrcOffset    (-1),
+      mContextLength(-1),
+      mLastScrLineNo(-1),
 
 
-         mHeaderLength (-1),
-         mFooterLength (-1),
+      mHeaderLength (-1),
+      mFooterLength (-1),
 
 
-         mFirstCharPos (-1),
-         mLastCharPos  (-1),
+      mFirstCharPos (-1),
+      mLastCharPos  (-1),
 
 
-         mVisibility( SP_VIS_PRIVATE ),
+      mVisibility( SP_VIS_PRIVATE ),
 
 
-         mIsVirtualContext         ( FALSE ),
-         mVirtualContextHasChildren( FALSE ),
+      mIsVirtualContext         ( FALSE ),
+      mVirtualContextHasChildren( FALSE ),
 
 
-         mpUserData( NULL )
+      mpUserData( NULL )
 {}
 
 void spContext::RemoveChildren()
 {
 {}
 
 void spContext::RemoveChildren()
 {
-       for( size_t i = 0; i != mMembers.size(); ++i )
-       
-               delete mMembers[i];
+    for( size_t i = 0; i != mMembers.size(); ++i )
+    
+        delete mMembers[i];
 
 
-       mMembers.erase( mMembers.begin(), mMembers.end() );
+    mMembers.erase( mMembers.begin(), mMembers.end() );
 }
 
 spContext::~spContext()
 {
 }
 
 spContext::~spContext()
 {
-       RemoveChildren();
+    RemoveChildren();
 
 
-       for( size_t i = 0; i != mComments.size(); ++i )
-       
-               delete mComments[i];
+    for( size_t i = 0; i != mComments.size(); ++i )
+    
+        delete mComments[i];
 }
 
 bool spContext::IsSorted()
 {
 }
 
 bool spContext::IsSorted()
 {
-       return mAlreadySorted;
+    return mAlreadySorted;
 }
 
 void spContext::GetContextList( MMemberListT& lst, int contextMask )
 {
 }
 
 void spContext::GetContextList( MMemberListT& lst, int contextMask )
 {
-       for( size_t i = 0; i != mMembers.size(); ++i )
-       {
-               spContext& member = *mMembers[i];
+    for( size_t i = 0; i != mMembers.size(); ++i )
+    {
+        spContext& member = *mMembers[i];
 
 
-               if ( member.GetContextType() & contextMask )
+        if ( member.GetContextType() & contextMask )
 
 
-                       lst.push_back( &member );
+            lst.push_back( &member );
 
 
-               // collect required contexts recursively
-               member.GetContextList( lst, contextMask );
-       }
+        // collect required contexts recursively
+        member.GetContextList( lst, contextMask );
+    }
 }
 
 bool spContext::HasComments()
 {
 }
 
 bool spContext::HasComments()
 {
-       return ( mComments.size() != 0 );
+    return ( mComments.size() != 0 );
 }
 
 void spContext::RemoveChild( spContext* pChild )
 {
 }
 
 void spContext::RemoveChild( spContext* pChild )
 {
-       for( size_t i = 0; i != mMembers.size(); ++i )
+    for( size_t i = 0; i != mMembers.size(); ++i )
 
 
-               if ( mMembers[i] == pChild )
-               {
-                       mMembers.erase( &mMembers[i] );
+        if ( mMembers[i] == pChild )
+        {
+            mMembers.erase( &mMembers[i] );
 
 
-                       delete pChild;
-                       return;
-               }
+            delete pChild;
+            return;
+        }
 
 
-       // the given child should exist on the parent's list 
-       wxASSERT( 0 );
+    // the given child should exist on the parent's list 
+    wxASSERT( 0 );
 }
 
 spContext* spContext::GetEnclosingContext( int mask )
 {
 }
 
 spContext* spContext::GetEnclosingContext( int mask )
 {
-       spContext* cur = this->GetParent();
+    spContext* cur = this->GetParent();
 
 
-       while ( cur && !(cur->GetContextType() & mask) ) 
-               
-               cur = cur->GetParent();
+    while ( cur && !(cur->GetContextType() & mask) ) 
+        
+        cur = cur->GetParent();
 
 
-       return cur;
+    return cur;
 }
 
 bool spContext::PositionIsKnown()
 {
 }
 
 bool spContext::PositionIsKnown()
 {
-       return ( mSrcOffset != (-1) && mContextLength != (-1) );
+    return ( mSrcOffset != (-1) && mContextLength != (-1) );
 }
 
 bool spContext::IsVirtualContext()
 {
 }
 
 bool spContext::IsVirtualContext()
 {
-       return mIsVirtualContext;
+    return mIsVirtualContext;
 }
 
 bool spContext::VitualContextHasChildren()
 {
 }
 
 bool spContext::VitualContextHasChildren()
 {
-       return mVirtualContextHasChildren;
+    return mVirtualContextHasChildren;
 }
 
 string spContext::GetVirtualContextBody()
 {
 }
 
 string spContext::GetVirtualContextBody()
 {
-       wxASSERT( mIsVirtualContext );
+    wxASSERT( mIsVirtualContext );
 
 
-       return mVirtualContextBody;
+    return mVirtualContextBody;
 }
 
 string spContext::GetFooterOfVirtualContextBody()
 {
 }
 
 string spContext::GetFooterOfVirtualContextBody()
 {
-       wxASSERT( mIsVirtualContext );
+    wxASSERT( mIsVirtualContext );
 
 
-       return mVittualContextFooter;
+    return mVittualContextFooter;
 }
 
 
 void spContext::SetVirtualContextBody( const string& body, 
 }
 
 
 void spContext::SetVirtualContextBody( const string& body, 
-                                                                          bool          hasChildren,
-                                                                          const string& footer )
+                                       bool          hasChildren,
+                                       const string& footer )
 {
 {
-       mVirtualContextHasChildren = hasChildren;
+    mVirtualContextHasChildren = hasChildren;
 
 
-       mVirtualContextBody   = body;
-       mVittualContextFooter = footer;
+    mVirtualContextBody   = body;
+    mVittualContextFooter = footer;
 
 
-       // atuomaticllay becomes virtual context
+    // atuomaticllay becomes virtual context
 
 
-       mIsVirtualContext   = TRUE;
+    mIsVirtualContext   = TRUE;
 }
 
 string spContext::GetBody( spContext* pCtx )
 {
 }
 
 string spContext::GetBody( spContext* pCtx )
 {
-       if ( ( pCtx == NULL || pCtx == this ) && mIsVirtualContext ) 
-               
-               return mVirtualContextBody;
+    if ( ( pCtx == NULL || pCtx == this ) && mIsVirtualContext ) 
+        
+        return mVirtualContextBody;
 
 
-       if ( GetParent() )
+    if ( GetParent() )
 
 
-               return GetParent()->GetBody( ( pCtx != NULL ) ? pCtx : this );
-       else
-               return ""; // source-fragment cannot be found
+        return GetParent()->GetBody( ( pCtx != NULL ) ? pCtx : this );
+    else
+        return ""; // source-fragment cannot be found
 }
 
 string spContext::GetHeader( spContext* pCtx )
 {
 }
 
 string spContext::GetHeader( spContext* pCtx )
 {
-       if ( GetParent() )
+    if ( GetParent() )
 
 
-               return GetParent()->GetHeader( ( pCtx != NULL ) ? pCtx : this );
-       else
-               return ""; // source-fragment cannot be found
+        return GetParent()->GetHeader( ( pCtx != NULL ) ? pCtx : this );
+    else
+        return ""; // source-fragment cannot be found
 }
 
 bool spContext::IsFirstOccurence()
 {
 }
 
 bool spContext::IsFirstOccurence()
 {
-       return ( mpFirstOccurence != 0 );
+    return ( mpFirstOccurence != 0 );
 }
 
 spContext* spContext::GetFirstOccurence()
 {
 }
 
 spContext* spContext::GetFirstOccurence()
 {
-       // this object should not itself be 
-       // the first occurence of the context
-       wxASSERT( mpFirstOccurence != 0 );
+    // this object should not itself be 
+    // the first occurence of the context
+    wxASSERT( mpFirstOccurence != 0 );
 
 
-       return mpFirstOccurence;
+    return mpFirstOccurence;
 }
 
 void spContext::AddMember( spContext* pMember )
 {
 }
 
 void spContext::AddMember( spContext* pMember )
 {
-       mMembers.push_back( pMember );
+    mMembers.push_back( pMember );
 
 
-       pMember->mpParent = this;
+    pMember->mpParent = this;
 }
 
 void spContext::AddComment( spComment* pComment )
 {
 }
 
 void spContext::AddComment( spComment* pComment )
 {
-       mComments.push_back( pComment );
+    mComments.push_back( pComment );
 }
 
 MMemberListT& spContext::GetMembers()
 {
 }
 
 MMemberListT& spContext::GetMembers()
 {
-       return mMembers;
+    return mMembers;
 }
 
 spContext* spContext::FindContext( const string& identifier,
 }
 
 spContext* spContext::FindContext( const string& identifier,
-                                                              int   contextType,
-                                                                  bool  searchSubMembers
-                                                                )
+                                   int   contextType,
+                                   bool  searchSubMembers
+                                 )
 {
 {
-       for( size_t i = 0; i != mMembers.size(); ++i )
-       {
-               spContext& member = *mMembers[i];
+    for( size_t i = 0; i != mMembers.size(); ++i )
+    {
+        spContext& member = *mMembers[i];
 
 
-               if ( member.GetName() == identifier && 
-                        ( contextType & member.GetContextType() )
-                  )
+        if ( member.GetName() == identifier && 
+             ( contextType & member.GetContextType() )
+           )
 
 
-                  return &member;
+           return &member;
 
 
-               if ( searchSubMembers )
-               {
-                       spContext* result = 
-                               member.FindContext( identifier, contextType, 1 );
+        if ( searchSubMembers )
+        {
+            spContext* result = 
+                member.FindContext( identifier, contextType, 1 );
 
 
-                       if ( result ) return result;
-               }
-       }
+            if ( result ) return result;
+        }
+    }
 
 
-       return 0;
+    return 0;
 }
 
 void spContext::RemoveThisContext()
 {
 }
 
 void spContext::RemoveThisContext()
 {
-       if ( mpParent )
-               mpParent->RemoveChild( this );
-       else
-               // context should have a parent
-               wxASSERT(0);
+    if ( mpParent )
+        mpParent->RemoveChild( this );
+    else
+        // context should have a parent
+        wxASSERT(0);
 }
 
 spContext* spContext::GetOutterContext()
 {
 }
 
 spContext* spContext::GetOutterContext()
 {
-       return mpParent;
+    return mpParent;
 }
 
 bool spContext::HasOutterContext()
 {
 }
 
 bool spContext::HasOutterContext()
 {
-       return ( mpParent != 0 );
+    return ( mpParent != 0 );
 }
 
 bool spContext::IsInFile()
 {
 }
 
 bool spContext::IsInFile()
 {
-       return ( GetOutterContext()->GetContextType() == SP_CTX_FILE );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_FILE );
 }
 
 bool spContext::IsInNameSpace()
 {
 }
 
 bool spContext::IsInNameSpace()
 {
-       return ( GetOutterContext()->GetContextType() == SP_CTX_NAMESPACE );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_NAMESPACE );
 }
 
 bool spContext::IsInClass()
 {
 }
 
 bool spContext::IsInClass()
 {
-       return ( GetOutterContext()->GetContextType() == SP_CTX_CLASS );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_CLASS );
 }
 
 bool spContext::IsInOperation()
 {
 }
 
 bool spContext::IsInOperation()
 {
-       return ( GetOutterContext()->GetContextType() == SP_CTX_OPERATION );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_OPERATION );
 }
 
 spClass& spContext::GetClass()
 {
 }
 
 spClass& spContext::GetClass()
 {
-       wxASSERT( GetOutterContext()->GetType() == SP_CTX_CLASS );
-       return *((spClass*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_CLASS );
+    return *((spClass*)mpParent );
 }
 
 spFile& spContext::GetFile()
 {
 }
 
 spFile& spContext::GetFile()
 {
-       wxASSERT( GetOutterContext()->GetType() == SP_CTX_FILE );
-       return *((spFile*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_FILE );
+    return *((spFile*)mpParent );
 }
 
 spNameSpace& spContext::GetNameSpace()
 {
 }
 
 spNameSpace& spContext::GetNameSpace()
 {
-       wxASSERT( GetOutterContext()->GetType() == SP_CTX_NAMESPACE );
-       return *((spNameSpace*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_NAMESPACE );
+    return *((spNameSpace*)mpParent );
 }
 
 spOperation& spContext::GetOperation()
 {
 }
 
 spOperation& spContext::GetOperation()
 {
-       wxASSERT( GetOutterContext()->GetType() == SP_CTX_OPERATION );
-       return *((spOperation*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_OPERATION );
+    return *((spOperation*)mpParent );
 }
 
 /***** Implementation for class spClass *****/
 
 void spClass::SortMembers()
 {
 }
 
 /***** Implementation for class spClass *****/
 
 void spClass::SortMembers()
 {
-       // TBD::
+    // TBD::
 }
 
 /***** Implementation for class spOperation *****/
 
 spOperation::spOperation()
 
 }
 
 /***** Implementation for class spOperation *****/
 
 spOperation::spOperation()
 
-       : mHasDefinition( FALSE )
-{}
+    : mHasDefinition( FALSE )
+{
+    mIsConstant =
+    mIsVirtual =
+    mHasDefinition = false;
+}
 
 string spOperation::GetFullName(MarkupTagsT tags)
 {
 
 string spOperation::GetFullName(MarkupTagsT tags)
 {
-       string txt = tags[TAG_BOLD].start + mRetType;
-       txt += " ";
-       txt += mName;
-       txt += "( ";
-       txt += tags[TAG_BOLD].end;
-       
-       for( size_t i = 0; i != mMembers.size(); ++i )
-       {
-               // DBG::
-               wxASSERT( mMembers[i]->GetContextType() == SP_CTX_PARAMETER );
+    string txt = tags[TAG_BOLD].start + mRetType;
+    txt += " ";
+    txt += mName;
+    txt += "( ";
+    txt += tags[TAG_BOLD].end;
+    
+    for( size_t i = 0; i != mMembers.size(); ++i )
+    {
+        // DBG::
+        wxASSERT( mMembers[i]->GetContextType() == SP_CTX_PARAMETER );
 
 
-               spParameter& param = *((spParameter*)mMembers[i]);
+        spParameter& param = *((spParameter*)mMembers[i]);
 
 
-               if ( i != 0 )
-                       txt += ", ";
-               
-               txt += tags[TAG_BOLD].start;
-               
-               txt += param.mType;
+        if ( i != 0 )
+            txt += ", ";
+        
+        txt += tags[TAG_BOLD].start;
+        
+        txt += param.mType;
 
 
-               txt += tags[TAG_BOLD].end;
-               txt += tags[TAG_ITALIC].start;
+        txt += tags[TAG_BOLD].end;
+        txt += tags[TAG_ITALIC].start;
 
 
-               txt += " ";
-               txt += param.mName;
+        txt += " ";
+        txt += param.mName;
 
 
-               if ( param.mInitVal != "" )
-               {
-                       txt += " = ";
-                       txt += tags[TAG_BOLD].start;
+        if ( param.mInitVal != "" )
+        {
+            txt += " = ";
+            txt += tags[TAG_BOLD].start;
 
 
-                       txt += param.mInitVal;
+            txt += param.mInitVal;
 
 
-                       txt += tags[TAG_BOLD].end;
-               }
+            txt += tags[TAG_BOLD].end;
+        }
 
 
-               txt += tags[TAG_ITALIC].end;;
-       }
+        txt += tags[TAG_ITALIC].end;;
+    }
 
 
-       txt += tags[TAG_BOLD].start;
-       txt += " )";
-       txt += tags[TAG_BOLD].end;
+    txt += tags[TAG_BOLD].start;
+    txt += " )";
+    txt += tags[TAG_BOLD].end;
 
 
-       // TBD:: constantness of method
+    // TBD:: constantness of method
 
 
-       return txt;
+    return txt;
 }
 
 /***** Implemenentation for class spPreprocessorLine *****/
 
 }
 
 /***** Implemenentation for class spPreprocessorLine *****/
 
-string spPreprocessorLine::CPP_GetIncludedFileNeme()
+string spPreprocessorLine::CPP_GetIncludedFileNeme() const
 {
 {
-       wxASSERT( GetStatementType() == SP_PREP_DEF_INCLUDE_FILE );
+    wxASSERT( GetStatementType() == SP_PREP_DEF_INCLUDE_FILE );
 
 
-       size_t i = 0;
+    size_t i = 0;
 
 
-       while( i < mLine.length() && mLine[i] != '"' && mLine[i] != '<' ) 
-               
-               ++i;
+    while( i < mLine.length() && mLine[i] != '"' && mLine[i] != '<' ) 
+        
+        ++i;
 
 
-       ++i;
+    ++i;
 
 
-       size_t start = i;
+    size_t start = i;
 
 
-       while( i < mLine.length() && mLine[i] != '"' && mLine[i] != '>' ) 
+    while( i < mLine.length() && mLine[i] != '"' && mLine[i] != '>' ) 
 
 
-               ++i;
+        ++i;
 
 
-       if ( start < mLine.length() )
-       {
-               string fname;
-               fname.append( mLine, start, ( i - start ) );
+    if ( start < mLine.length() )
+    {
+        string fname;
+        fname.append( mLine, start, ( i - start ) );
 
 
-               return fname;
-       }
-       else
-               return ""; // syntax error probably
+        return fname;
+    }
+    else
+        return ""; // syntax error probably
 }
 
 
 }
 
 
@@ -503,41 +507,202 @@ string spPreprocessorLine::CPP_GetIncludedFileNeme()
 
 SourceParserBase::SourceParserBase()
 
 
 SourceParserBase::SourceParserBase()
 
-       : mpFileBuf( NULL ),
-         mFileBufSz( 0 ),
+    : mpFileBuf( NULL ),
+      mFileBufSz( 0 ),
 
 
-         mpPlugin( NULL )
+      mpPlugin( NULL )
 {}
 
 SourceParserBase::~SourceParserBase()
 {
 {}
 
 SourceParserBase::~SourceParserBase()
 {
-       if ( mpFileBuf ) free( mpFileBuf );
+    if ( mpFileBuf ) free( mpFileBuf );
 
 
-       if ( mpPlugin ) delete mpPlugin;
+    if ( mpPlugin ) delete mpPlugin;
 }
 
 spFile* SourceParserBase::ParseFile( const char* fname )
 {
 }
 
 spFile* SourceParserBase::ParseFile( const char* fname )
 {
-       // FIXME:: the below should not be fixed!
+    // FIXME:: the below should not be fixed!
 
 
-       const size_t MAX_BUF_SIZE = 1024*256;
+    const size_t MAX_BUF_SIZE = 1024*256;
 
 
-       if ( !mpFileBuf ) mpFileBuf = (char*)malloc( MAX_BUF_SIZE );
+    if ( !mpFileBuf ) mpFileBuf = (char*)malloc( MAX_BUF_SIZE );
 
 
-       mFileBufSz = MAX_BUF_SIZE;
+    mFileBufSz = MAX_BUF_SIZE;
 
 
-       FILE* fp = fopen( fname, "rt" );
+    FILE* fp = fopen( fname, "rt" );
 
 
-       if ( (int)fp == -1 || !fp ) return NULL;
+    if ( (int)fp == -1 || !fp ) return NULL;
 
 
-       int sz = fread( mpFileBuf, 1, mFileBufSz, fp );
+    int sz = fread( mpFileBuf, 1, mFileBufSz, fp );
 
 
-       return Parse( mpFileBuf, mpFileBuf + sz );
+    return Parse( mpFileBuf, mpFileBuf + sz );
 }
 
 void SourceParserBase::SetPlugin( SourceParserPlugin* pPlugin )
 {
 }
 
 void SourceParserBase::SetPlugin( SourceParserPlugin* pPlugin )
 {
-       if ( mpPlugin ) delete mpPlugin;
+    if ( mpPlugin ) delete mpPlugin;
+
+    mpPlugin = pPlugin;
+}
+
+// ===========================================================================
+// debug methods
+// ===========================================================================
+
+#ifdef __WXDEBUG__
+
+void spContext::Dump(const wxString& indent) const
+{
+    DumpThis(indent);
+
+    // increase it for the children
+    wxString indentChild = indent + "    ";
+
+    for ( MMemberListT::const_iterator i = mMembers.begin();
+          i != mMembers.end();
+          i++ ) {
+        (*i)->Dump(indentChild);
+    }
+}
+
+void spContext::DumpThis(const wxString& indent) const
+{
+    wxFAIL_MSG("abstract base class can't be found in parser tree!");
+}
+
+void spParameter::DumpThis(const wxString& indent) const
+{
+    wxLogDebug("%sparam named '%s' of type '%s'",
+               indent.c_str(), mName.c_str(), mType.c_str());
+}
+
+void spAttribute::DumpThis(const wxString& indent) const
+{
+    wxLogDebug("%svariable named '%s' of type '%s'",
+               indent.c_str(), mName.c_str(), mType.c_str());
+}
 
 
-       mpPlugin = pPlugin;
+void spOperation::DumpThis(const wxString& indent) const
+{
+    wxString protection;
+    if ( !!mScope ) {
+        switch ( mVisibility ) {
+            case SP_VIS_PUBLIC:
+                protection = "public";
+                break;
+
+            case SP_VIS_PROTECTED:
+                protection = "protected";
+                break;
+
+            case SP_VIS_PRIVATE:
+                protection = "private";
+                break;
+
+            default:
+                wxFAIL_MSG("unknown protection type");
+        }
+    }
+    else {
+        protection = "global";
+    }
+
+    wxLogDebug("%s%s%s%s function named '%s::%s' of type '%s'",
+               indent.c_str(),
+               mIsConstant ? "const " : "",
+               mIsVirtual ? "virtual " : "",
+               protection.c_str(),
+               mScope.c_str(), mName.c_str(), mRetType.c_str());
 }
 }
+
+void spPreprocessorLine::DumpThis(const wxString& indent) const
+{
+    wxString kind;
+    switch ( mDefType ) {
+        case SP_PREP_DEF_DEFINE_SYMBOL:
+            kind = "define";
+            break;
+
+        case SP_PREP_DEF_REDEFINE_SYMBOL:
+            kind = "redefine";
+            break;
+
+        case SP_PREP_DEF_INCLUDE_FILE:
+            kind.Printf("include (%s)", CPP_GetIncludedFileNeme().c_str());
+            break;
+
+        case SP_PREP_DEF_OTHER:
+            kind = "other";
+            break;
+
+    }
+
+    wxLogDebug("%spreprocessor statement: %s",
+               indent.c_str(), kind.c_str());
+}
+
+void spClass::DumpThis(const wxString& indent) const
+{
+    wxString base;
+    for ( StrListT::const_iterator i = mSuperClassNames.begin();
+          i != mSuperClassNames.end();
+          i++ ) {
+        if ( !!base )
+            base += ", ";
+        base += *i;
+    }
+
+    if ( !base )
+        base = "none";
+
+    wxString kind;
+    switch ( mClassSubType ) {
+        case SP_CLTYPE_CLASS:
+            kind = "class";
+            break;
+
+        case SP_CLTYPE_TEMPLATE_CLASS:
+            kind = "template class";
+            break;
+
+        case SP_CLTYPE_STRUCTURE:
+            kind = "struc";
+            break;
+
+        case SP_CLTYPE_UNION:
+            kind = "union";
+            break;
+
+        case SP_CLTYPE_INTERFACE:
+            kind = "interface";
+            break;
+
+        default:
+            wxFAIL_MSG("unknown class subtype");
+    }
+
+    wxLogDebug("%s%s named '%s' (base classes: %s)",
+               indent.c_str(), kind.c_str(),
+               mName.c_str(), base.c_str());
+}
+
+void spEnumeration::DumpThis(const wxString& indent) const
+{
+    wxLogDebug("%senum named '%s'",
+               indent.c_str(), mName.c_str());
+}
+
+void spTypeDef::DumpThis(const wxString& indent) const
+{
+    wxLogDebug("%stypedef %s = %s",
+               indent.c_str(), mName.c_str(), mOriginalType.c_str());
+}
+
+void spFile::DumpThis(const wxString& indent) const
+{
+    wxLogDebug("%sfile '%s'",
+               indent.c_str(), mFileName.c_str());
+}
+
+#endif // __WXDEBUG__
wxWidgets (Impactor)