gtclass.cpp

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C++ 代码 · 共 484 行 · 第 1/2 页

        return NULL;
    }
}

int TreeClassNode::getCount( TreeList_T list )
//--------------------------------------------
{
    switch( list ) {
    case ParentList:
        return _bases.count();
    case ChildList:
        return _deriveds.count();
    case TreeNode::FlatList:
        return (*_flatClasses).count();
    default:
        REQUIRE( 0, "TreeClassNode::getPtr - bad list." );
        return NULL;
    }
}

TreeNode * TreeClassNode::removeNode( TreeList_T list, TreeNode * node )
//----------------------------------------------------------------------
{
    int index;

    switch( list ) {
    case ParentList:
        for( index = _bases.count(); index > 0; index -= 1 ) {
            if( ((TreeClassPtr*)_bases[ index - 1 ])->getTo() == node ) {
                TreeClassPtr * ptr = (TreeClassPtr*)_bases.removeAt( index - 1 );
                TreeNode *     nd = ptr->getTo();
                delete ptr;
                return nd;
            }
        }
        return NULL;

    case ChildList:
        for( index = _deriveds.count(); index > 0; index -= 1 ) {
            if( ((TreeClassPtr*)_deriveds[ index - 1 ])->getTo() == node ) {
                TreeClassPtr * ptr = (TreeClassPtr *)_deriveds.removeAt( index - 1 );
                TreeNode *     nd = ptr->getTo();
                delete ptr;
                return nd;
            }
        }
        return NULL;

    case TreeNode::FlatList:
        for( index = _flatClasses->count(); index > 0; index -= 1 ) {
            if( ((TreeNode *)(TreeClassNode *)(*_flatClasses)[ index - 1 ]) == node ) {
                return (TreeClassNode *)_flatClasses->removeAt( index - 1 );
            }
        }
        return NULL;
    default:
        REQUIRE( 0, "TreeClassNode::removeNode - bad list." );
        return NULL;
    }
}

void TreeClassNode::addPtr( TreeList_T list, TreePtr * ptr )
//----------------------------------------------------------
{
    switch( list ) {
    case ParentList:
        _bases.add( (TreeClassPtr*)ptr);
        break;

    case ChildList:
        TreeClassPtr * p;
        TreeNode *     sv;

        p = (TreeClassPtr*)ptr->makeClone();
        sv = p->getTo();
        p->setTo( p->getFrom() );
        p->setFrom( sv );

        _deriveds.add( p );
        break;

    default:
        REQUIRE( 0, "TreeClassNode::addPtr - bad list." );
    }
}

void TreeClassNode::swapNode( TreeList_T list,
                              TreeNode * from, TreeNode * to )
//------------------------------------------------------------
{
    int index;

    switch( list ) {
    case ParentList:
        for( index = _bases.count(); index > 0; index -= 1 ) {
            if( ((TreeClassPtr*)_bases[ index - 1 ])->getTo() == from ) break;
        }

        REQUIRE( index > 0, "TreeClassNode::swapNode -- unknown from" );
        ((TreeClassPtr*)_bases[ index - 1 ])->setTo( to );
        break;
    case ChildList:
        for( index = _deriveds.count(); index > 0; index -= 1 ) {
            if( ((TreeClassPtr*)_deriveds[ index - 1 ])->getTo() == from ) break;
        }

        REQUIRE( index > 0, "TreeClassNode::swapNode -- unknown from" );
        ((TreeClassPtr*)_deriveds[ index - 1 ])->setTo( to );
        break;
    default:
        REQUIRE( 0, "TreeClassNode::swapNode - bad list." );
    }
}

static int CompDerivationPtr( const DerivationPtr ** lhs,
                              const DerivationPtr ** rhs )
//--------------------------------------------------------
{
    const TreeNode * lhN = (const TreeNode *) ((TreeClassPtr*)(*lhs))->getTo();
    const TreeNode * rhN = (const TreeNode *) ((TreeClassPtr*)(*rhs))->getTo();

    return TreeNode::compareNodes( lhN, rhN );
}

void TreeClassNode::sortPrtKids()
//-------------------------------
{
    _bases.sort( (TComp) CompDerivationPtr );
    _deriveds.sort( (TComp) CompDerivationPtr );
}

void TreeClassNode::setAllDeriveds( void )
//----------------------------------------
{
    for( int j = _flatClasses->count(); j > 0; j -= 1 ) {
        (*_flatClasses)[ j - 1 ]->setDeriveds();
    }
}

/*-------------------------- TreeClassWindow ----------------------------*/

TreeClassWindow::TreeClassWindow( char * title )
                    : TreeWindow( title )
//----------------------------------------------
{
    show();

    _loadFilter->setSymType( KSTClasses );
    _findFilter->setSymType( KSTClasses );
}


TreeClassWindow::~TreeClassWindow()
//---------------------------------
{
}

bool TreeClassWindow::contextHelp( bool is_active_window )
//--------------------------------------------------------
{
    if( is_active_window ) {
        WBRWinBase::helpInfo()->sysHelpId( BRH_INHERITANCE_VIEW );
    }
    return( TRUE );
}

const char * TreeClassWindow::emptyText()
//---------------------------------------
{
    return "No classes found with current query";
}

void TreeClassWindow::fillRoots( void )
//-------------------------------------
// OPTIMIZE -- this finds all class, creates symbols for them,
//             then creates TreeClassNodes from these and deletes the
//             symbols.  Would be better if didn't create / delete syms.
{
    WVList          world;
    Symbol *        sym;
    TreeClassNode * rootNode;
    TreeClassList   roots;
    WVList          bases;
    bool            quit = FALSE;

    _loadFilter->setSymType( KSTClasses );
    dbManager()->module()->findSymbols( &world, _loadFilter );

    while( world.count() > 0 ) {
        sym = (Symbol *) world.removeAt( world.count() - 1 );
        rootNode = new TreeClassNode( this, sym );
        delete sym;

        // if not related to a prev tree, its a new tree

        TreeClassList joinTo;

        if( rootNode->doParents( world, roots, joinTo ) ) {
            TreeClassNode * prevRoot = NULL;

            for( int i = joinTo.count(); i > 0; i -= 1 ) {

                // make sure that they really are related by checking
                // both.  If both aren't checked, then a partially
                // loaded child might think it is already related
                // to its parent

                if( rootNode->isRelated( joinTo[ i - 1 ] )
                    && joinTo[ i - 1 ]->isRelated( rootNode ) ) {

                    // no action, they are already joined

                } else {
                    rootNode->joinLattice( (ClassLattice *) joinTo[ i - 1 ] );
                    if( prevRoot != NULL ) {
                        REQUIRE( prevRoot->isRelated( joinTo[ i - 1 ] ),
                                 "TreeClassWindow::fillRoots ack nak" );
                        roots.removeSame( prevRoot );
                    }

                    prevRoot = joinTo[ i - 1 ];
                }
            }
        } else {
            roots.add( rootNode );
        }
    }

    for( int i = roots.count(); i > 0; i -= 1 ) {
        TreeClassNode* node = roots[ i - 1 ];
        node->setAllDeriveds();
        node->normalizeLevels();

        for( int j = node->getCount( TreeNode::FlatList ); j > 0; j -= 1 ) {
            if( node->getNode( TreeNode::FlatList, j - 1 )->getLevel() == 0 ) {
                _roots.add( new TreeRoot( this, node->getNode( TreeNode::FlatList, j - 1 ) ) );
                break;
            }
        }
    }
}