void GBVCallOutline::load()
//----------------------------
// this code is cut-and-pasted from GTFUNC.CPP
// FIXME -- this should all be put back in one spot
{
BusyNotice busy( "Loading..." );
TreeNodeList roots;
int i;
_loadFilter->setSymType( KSTFunctions );
TreeFuncNode::loadModule( NULL, dbManager()->module(), roots, _loadFilter );
for( i = 0; i < roots.count(); i += 1 ) {
TreeFuncNode * node = (TreeFuncNode *) roots[ i ];
for( int j = 0; j < node->getCount( TreeNode::FlatList ); j += 1 ) {
TreeFuncNode *pNode;
pNode = (TreeFuncNode *) node->getNode( TreeNode::FlatList, j );
if( pNode->getCount( TreeNode::ParentList ) == 0 ) {
addLevel0( pNode );
}
}
}
for( i = 0; i < roots.count(); i += 1 ) {
TreeFuncNode * node = (TreeFuncNode *) roots[ i ];
node->deleteTree();
}
reset();
}
void TreeFuncWindow::fillRoots( void )
//------------------------------------
{
TreeNodeList roots;
int i;
_loadFilter->setSymType( KSTFunctions );
TreeFuncNode::loadModule( this, dbManager()->module(), roots, _loadFilter );
for( i = roots.count(); i > 0; i -= 1 ) {
TreeFuncNode * node = (TreeFuncNode *) roots[ i - 1 ];
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;
}
}
}
}
bool TreeFuncNode::TreeFuncHook( drmem_hdl owner, dr_ref_info * ref,
char* ownerName, void * info )
//------------------------------------------------------------------
// this function really needs to be split up
{
int parentIndex;
int parentRoot;
TreeFuncNode * parent = NULL;
int childIndex;
int childRoot;
TreeFuncNode * child = NULL;
FuncSearchData* data = (FuncSearchData *) info;
char * depName;
bool accept;
#if DEBUG
data->funcsFound += 1;
if( !(data->funcsFound % 10) ) {
WString stat;
stat.printf( "Loading - %d found", data->funcsFound );
browseTop->statusText( stat.gets() );
}
#endif
// find if the symbol matches the filter
depName = DRGetName( ref->dependent );
accept = data->key->matches( ref->dependent, depName );
WBRFree( depName ); // OPTIMIZE -- could use this later
if( !accept ) {
return true; // <---- early return -- discard symbol, keep looking
}
for( int i = data->roots->count(); i > 0; i -= 1 ) {
TreeFuncNode * rt = (TreeFuncNode*) (*data->roots)[ i - 1 ];
parentIndex = rt->findNode( owner );
if( !parent ) {
if( parentIndex >= 0 ) {
parent = (TreeFuncNode *)(*rt->_flatNodes)[ parentIndex ];
parentRoot = i - 1;
}
}
if( !child ) {
childIndex = rt->findNode( ref->dependent );
if( childIndex >= 0 ) {
child = (TreeFuncNode *)(*rt->_flatNodes)[ childIndex ];
childRoot = i - 1;
}
}
if( child != NULL && parent != NULL ) {
break;
}
}
if( child != NULL && parent != NULL ) {
WBRFree( ownerName );
if( parentRoot == childRoot ) {
int prtIdx = child->findParent( parent );
if( prtIdx < 0 ) {
if( ref->dependent == owner ) { // direct recursion -- a->a
bool inReferences = false;
for( int refIdx = 0; refIdx < child->_flatReferences->count(); refIdx += 1 ) {
if( (*child->_flatReferences)[ refIdx ]->getHandle() == owner ) {
TreeNode * node = (*child->_flatReferences)[ refIdx ];
for( int ref2idx = 0; ref2idx < node->getCount( ParentList ); ref2idx += 1 ) {
if( node->getNode( ParentList, ref2idx )->getHandle() == owner ) {
TreePtr * ptr = node->getPtr( ParentList, ref2idx );
((TreeRefPtr*)ptr)->incRefs();
inReferences = true;
break;
}
}
}
if( inReferences ) {
break;
}
}
if( !inReferences ) {
TreeRefNode * newRef;
newRef = new TreeRefNode( data->parentWin, parent, parent );
parent->_children.add( newRef );
parent->_hasRef = true;
parent->_flatReferences->add( newRef );
}
} else {
parent->_children.add( child );
child->_parents.add(
new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
}
} else {
TreePtr * ptr = child->getPtr( ParentList, prtIdx );
((TreeFuncPtr *)ptr)->incRefs();
}
} else {
int i;
for( i = child->_flatNodes->count(); i > 0; i -= 1 ) {
parent->_flatNodes->add( (*child->_flatNodes)[ i - 1 ] );
}
data->roots->removeAt( childRoot );
parent->_children.add( child );
child->_parents.add(
new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
TreeCycleList * fList = child->_flatNodes;
TreeRefList * rList = child->_flatReferences;
for( i = fList->count(); i > 0; i -= 1 ) {
TreeFuncNode * node = (TreeFuncNode *) (*fList)[ i - 1 ];
node->_flatNodes = parent->_flatNodes;
node->_flatReferences = parent->_flatReferences;
}
for( i = rList->count(); i > 0; i -= 1 ) {
parent->_flatReferences->add( (*rList)[ i - 1 ] );
}
delete fList;
delete rList;
}
} else {
if( child != NULL ) {
parent = new TreeFuncNode( data->parentWin, DRGetSymType( owner ),
owner, data->mod, ownerName,
child->_flatNodes,
child->_flatReferences );
parent->_children.add( child );
child->_parents.add(
new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
} else {
if( parent != NULL ) {
WBRFree( ownerName );
child = new TreeFuncNode( data->parentWin,
DRGetSymType( ref->dependent ),
ref->dependent, data->mod,
DRGetName( ref->dependent ),
parent->_flatNodes,
parent->_flatReferences );
parent->_children.add( child );
child->_parents.add(
new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
} else { // child == parent == NULL
parent = new TreeFuncNode( data->parentWin,
DRGetSymType( owner ),
owner, data->mod, ownerName );
if( ref->dependent == owner ) {
TreeRefNode * newRef;
newRef = new TreeRefNode( data->parentWin, parent, parent );
parent->_children.add( newRef );
parent->_hasRef = true;
parent->_flatReferences->add( newRef );
} else {
child = new TreeFuncNode( data->parentWin,
DRGetSymType( ref->dependent ),
ref->dependent, data->mod,
DRGetName( ref->dependent ),
parent->_flatNodes,
parent->_flatReferences );
child->_parents.add(
new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
parent->_children.add( child );
}
data->roots->add( parent );
}
}
}
return true;
}
