X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/59734eb59735bc6d3ed6e1cfd110347b2aacfac1..ab85e6cd0021eba5d95c1e1e52187a6f256b06de:/utils/HelpGen/src/srcparser.cpp?ds=inline

diff --git a/utils/HelpGen/src/srcparser.cpp b/utils/HelpGen/src/srcparser.cpp
index 10a219f9e7..81d84ed431 100644
--- 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
-// Licence:   	wxWindows licence
+// Licence:       wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
@@ -33,387 +33,387 @@
 /***** 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()
 {
-	if ( mpCurCxt->GetParent() )
+    if ( mpCurCxt->GetParent() )
 
-		mpCurCxt->GetParent()->RemoveChild( mpCurCxt );
+        mpCurCxt->GetParent()->RemoveChild( mpCurCxt );
 }
 
 void spVisitor::SkipSiblings()
 {
-	mSiblingSkipped = TRUE;
+    mSiblingSkipped = TRUE;
 }
 
 void spVisitor::SkipChildren()
 {
-	mChildSkipped = TRUE;
+    mChildSkipped = TRUE;
 }
 
 void spVisitor::SetFilter( int contextMask )
 {
-	mContextMask = contextMask;
+    mContextMask = contextMask;
 }
 
 /***** Implementation for class spComment *****/
 
 bool spComment::IsMultiline()  const
 {
-	return mIsMultiline;
+    return mIsMultiline;
 }
 
 bool spComment::StartsParagraph() const
 {
-	return mStartsPar;
+    return mStartsPar;
 }
 
 string& spComment::GetText()
 {
-	return mText;
+    return mText;
 }
 
 string spComment::GetText() const
 {
-	return mText;
+    return mText;
 }
 
 /***** 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()
 {
-	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()
 {
-	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()
 {
-	return mAlreadySorted;
+    return mAlreadySorted;
 }
 
 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()
 {
-	return ( mComments.size() != 0 );
+    return ( mComments.size() != 0 );
 }
 
 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* 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()
 {
-	return ( mSrcOffset != (-1) && mContextLength != (-1) );
+    return ( mSrcOffset != (-1) && mContextLength != (-1) );
 }
 
 bool spContext::IsVirtualContext()
 {
-	return mIsVirtualContext;
+    return mIsVirtualContext;
 }
 
 bool spContext::VitualContextHasChildren()
 {
-	return mVirtualContextHasChildren;
+    return mVirtualContextHasChildren;
 }
 
 string spContext::GetVirtualContextBody()
 {
-	wxASSERT( mIsVirtualContext );
+    wxASSERT( mIsVirtualContext );
 
-	return mVirtualContextBody;
+    return mVirtualContextBody;
 }
 
 string spContext::GetFooterOfVirtualContextBody()
 {
-	wxASSERT( mIsVirtualContext );
+    wxASSERT( mIsVirtualContext );
 
-	return mVittualContextFooter;
+    return mVittualContextFooter;
 }
 
 
 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 )
 {
-	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 )
 {
-	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()
 {
-	return ( mpFirstOccurence != 0 );
+    return ( mpFirstOccurence != 0 );
 }
 
 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 )
 {
-	mMembers.push_back( pMember );
+    mMembers.push_back( pMember );
 
-	pMember->mpParent = this;
+    pMember->mpParent = this;
 }
 
 void spContext::AddComment( spComment* pComment )
 {
-	mComments.push_back( pComment );
+    mComments.push_back( pComment );
 }
 
 MMemberListT& spContext::GetMembers()
 {
-	return mMembers;
+    return mMembers;
 }
 
 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()
 {
-	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()
 {
-	return mpParent;
+    return mpParent;
 }
 
 bool spContext::HasOutterContext()
 {
-	return ( mpParent != 0 );
+    return ( mpParent != 0 );
 }
 
 bool spContext::IsInFile()
 {
-	return ( GetOutterContext()->GetContextType() == SP_CTX_FILE );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_FILE );
 }
 
 bool spContext::IsInNameSpace()
 {
-	return ( GetOutterContext()->GetContextType() == SP_CTX_NAMESPACE );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_NAMESPACE );
 }
 
 bool spContext::IsInClass()
 {
-	return ( GetOutterContext()->GetContextType() == SP_CTX_CLASS );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_CLASS );
 }
 
 bool spContext::IsInOperation()
 {
-	return ( GetOutterContext()->GetContextType() == SP_CTX_OPERATION );
+    return ( GetOutterContext()->GetContextType() == SP_CTX_OPERATION );
 }
 
 spClass& spContext::GetClass()
 {
-	wxASSERT( GetOutterContext()->GetType() == SP_CTX_CLASS );
-	return *((spClass*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_CLASS );
+    return *((spClass*)mpParent );
 }
 
 spFile& spContext::GetFile()
 {
-	wxASSERT( GetOutterContext()->GetType() == SP_CTX_FILE );
-	return *((spFile*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_FILE );
+    return *((spFile*)mpParent );
 }
 
 spNameSpace& spContext::GetNameSpace()
 {
-	wxASSERT( GetOutterContext()->GetType() == SP_CTX_NAMESPACE );
-	return *((spNameSpace*)mpParent );
+    wxASSERT( GetOutterContext()->GetType() == SP_CTX_NAMESPACE );
+    return *((spNameSpace*)mpParent );
 }
 
 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()
 {
-	// TBD::
+    // TBD::
 }
 
 /***** Implementation for class spOperation *****/
 
 spOperation::spOperation()
 
-	: mHasDefinition( FALSE )
+    : mHasDefinition( FALSE )
 {
     mIsConstant =
     mIsVirtual =
@@ -422,83 +422,83 @@ spOperation::spOperation()
 
 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 *****/
 
-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
 }
 
 
@@ -507,41 +507,202 @@ string spPreprocessorLine::CPP_GetIncludedFileNeme()
 
 SourceParserBase::SourceParserBase()
 
-	: mpFileBuf( NULL ),
-	  mFileBufSz( 0 ),
+    : mpFileBuf( NULL ),
+      mFileBufSz( 0 ),
 
-	  mpPlugin( NULL )
+      mpPlugin( NULL )
 {}
 
 SourceParserBase::~SourceParserBase()
 {
-	if ( mpFileBuf ) free( mpFileBuf );
+    if ( mpFileBuf ) free( mpFileBuf );
 
-	if ( mpPlugin ) delete mpPlugin;
+    if ( mpPlugin ) delete mpPlugin;
 }
 
 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 )
 {
-	if ( mpPlugin ) delete mpPlugin;
+    if ( mpPlugin ) delete mpPlugin;
 
-	mpPlugin = pPlugin;
+    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());
+}
+
+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__