#include "geo.h"

extern void tdelete( TNODEPTR *root , int value , int property );
extern void tpop( TNODEPTR *root , TNODEPTR *node , int *value ,
		 int *property);

void ygraph(void)
{

int i , hedge , location , eindex , er , el , r , l , cell , count ;
int beginEdge , iedge , inode , oedge , onode , lastE ;
WCPTR saveptr ;
DLINK1PTR hptr ;
PLISTPTR plptr ;
FLAREPTR fptr , ifptr , ofptr ;
TNODEPTR tnode ;


yNodules = (NODPTR) malloc( (2 + numberCells) * sizeof(NODBOX));
for( i = 0 ; i <= numberCells + 1 ; i++ ) {
    yNodules[i].inList = (FLAREPTR) NULL ;
    yNodules[i].outList = (FLAREPTR) NULL ;
    yNodules[i].done = 0 ;
}
hptr = Hlist ;
hedge = hptr->edge ;
location = edgeList[hedge].loc ;
er = edgeList[hedge].end ;
el = edgeList[hedge].start ;
plptr = tplist( hChanBeginRoot , location ) ;
for( ; plptr != (PLISTPTR) NULL ; plptr = plptr->pnext ) {
    eindex = plptr->property ;
    r = eArray[eindex].hiend ;
    l = eArray[eindex].loend ;
    if( ! (l >= el && r <= er) ) {
	continue ;
    }
    fptr = yNodules[0].outList ;
    yNodules[0].outList = (FLAREPTR) malloc( sizeof(FLARE) ) ;
    yNodules[0].outList->next = fptr ;
    yNodules[0].outList->fixEdge = hedge ;
    yNodules[0].outList->eindex = (int *) malloc( 2 * sizeof(int) ) ; 
    yNodules[0].outList->eindex[0] = 1 ; 
    yNodules[0].outList->eindex[1] = eindex ; 
    yNodules[0].done = 1 ; 
}
hptr = Hend ;
hedge = hptr->edge ;
location = edgeList[hedge].loc ;
er = edgeList[hedge].end ;
el = edgeList[hedge].start ;
plptr = tplist( hChanEndRoot , location ) ;
for( ; plptr != (PLISTPTR) NULL ; plptr = plptr->pnext ) {
    eindex = plptr->property ;
    r = eArray[eindex].hiend ;
    l = eArray[eindex].loend ;
    if( ! (l >= el && r <= er) ) {
	continue ;
    }
    fptr = yNodules[numberCells + 1].inList ;
    yNodules[numberCells + 1].inList = (FLAREPTR) malloc(sizeof(FLARE));
    yNodules[numberCells + 1].inList->next = fptr ;
    yNodules[numberCells + 1].inList->fixEdge = hedge ;
    yNodules[numberCells + 1].inList->eindex = (int *) 
						malloc(2 * sizeof(int)); 
    yNodules[numberCells + 1].inList->eindex[0] = 1 ; 
    yNodules[numberCells + 1].inList->eindex[1] = eindex ; 
    yNodules[numberCells + 1].done = 1 ; 
}

hptr = hFixedList->next ;
for( ; hptr->next != (DLINK1PTR) NULL ; hptr = hptr->next ) {
    hedge = hptr->edge ;
    cell = edgeList[hedge].cell ;
    if( yNodules[cell].done == 1 ) {
	continue ;
    }
    yNodules[cell].done = 1 ;
    beginEdge = hedge ;
    do {
	if( edgeList[hedge].UorR < 0 ) {
	    location = edgeList[hedge].loc ;
	    plptr = tplist( hChanEndRoot , location ) ;
	    for( ; plptr != (PLISTPTR) NULL ; plptr = plptr->pnext ) {
		eindex = plptr->property ;
		if( eArray[eindex].edge2 != hedge ) {
		    continue ;
		}
		fptr = yNodules[cell].inList ;
		yNodules[cell].inList = (FLAREPTR) malloc(sizeof(FLARE));
		yNodules[cell].inList->next = fptr ;
		yNodules[cell].inList->fixEdge = hedge ;
		yNodules[cell].inList->eindex = (int *) 
						malloc(2 * sizeof(int)); 
		yNodules[cell].inList->eindex[0] = 1 ; 
		yNodules[cell].inList->eindex[1] = eindex ; 
	    }
	} else {
	    location = edgeList[hedge].loc ;
	    plptr = tplist( hChanBeginRoot , location ) ;
	    for( ; plptr != (PLISTPTR) NULL ; plptr = plptr->pnext ) {
		eindex = plptr->property ;
		if( eArray[eindex].edge1 != hedge ) {
		    continue ;
		}
		fptr = yNodules[cell].outList ;
		yNodules[cell].outList = (FLAREPTR) malloc(sizeof(FLARE));
		yNodules[cell].outList->next = fptr ;
		yNodules[cell].outList->fixEdge = hedge ;
		yNodules[cell].outList->eindex = (int *) 
						malloc(2 * sizeof(int)); 
		yNodules[cell].outList->eindex[0] = 1 ; 
		yNodules[cell].outList->eindex[1] = eindex ; 
	    }
	}
	hedge = edgeList[hedge].nextEdge ;
	hedge = edgeList[hedge].nextEdge ;
    } while( hedge != beginEdge ) ;
}

for( cell = 0 ; cell <= numberCells + 1 ; cell++ ) {
    fptr = yNodules[cell].inList ;
    for( ; fptr != (FLAREPTR) NULL ; fptr = fptr->next ) {
	for( count = fptr->eindex[0]; count <= fptr->eindex[0]; count++){
	    eindex = fptr->eindex[count] ;
	    location = eArray[eindex].lbside ;
	    er = eArray[eindex].hiend ;
	    el = eArray[eindex].loend ;
	    plptr = tplist( hChanEndRoot , location ) ;
	    for( ; plptr != (PLISTPTR) NULL ; plptr = plptr->pnext ) {
		eindex = plptr->property ;
		r = eArray[eindex].hiend ;
		l = eArray[eindex].loend ;
		if( ! (l >= el && r <= er) ) {
		    continue ;
		}
		tdelete( &hChanEndRoot , location , eindex ) ;
		if( ++(fptr->eindex[0]) % 2 == 0 ) {
		    fptr->eindex = (int *) realloc( fptr->eindex ,
				(2 + fptr->eindex[0]) * sizeof(int) ) ;
		}
		fptr->eindex[ fptr->eindex[0] ] = eindex ;
		break ;
	    }
	}
    }
    fptr = yNodules[cell].outList ;
    for( ; fptr != (FLAREPTR) NULL ; fptr = fptr->next ) {
	for( count = fptr->eindex[0]; count <= fptr->eindex[0]; count++){
	    eindex = fptr->eindex[count] ;
	    location = eArray[eindex].rtside ;
	    er = eArray[eindex].hiend ;
	    el = eArray[eindex].loend ;
	    plptr = tplist( hChanBeginRoot , location ) ;
	    for( ; plptr != (PLISTPTR) NULL ; plptr = plptr->pnext ) {
		eindex = plptr->property ;
		r = eArray[eindex].hiend ;
		l = eArray[eindex].loend ;
		if( ! (l >= el && r <= er) ) {
		    continue ;
		}
		tdelete( &hChanBeginRoot , location , eindex ) ;
		if( ++(fptr->eindex[0]) % 2 == 0 ) {
		    fptr->eindex = (int *) realloc( fptr->eindex ,
				(2 + fptr->eindex[0]) * sizeof(int) ) ;
		}
		fptr->eindex[ fptr->eindex[0] ] = eindex ;
		break ;
	    }
	}
    }
}

numYnodes = 0 ;
for( hptr = hFixedList; hptr != (DLINK1PTR) NULL; hptr = hptr->next ){
    edgeList[ hptr->edge ].node = ++numYnodes ;
}
yNodeArray = (WCPTR *) malloc( (1 + numYnodes) * sizeof(WCPTR) );
for( i = 1 ; i <= numYnodes ; i++ ) {
    yNodeArray[i] = (WCPTR) NULL ;
}
for( cell = 1 ; cell <= numberCells ; cell++ ) {
    ifptr = yNodules[cell].inList ;
    for( ; ifptr != (FLAREPTR) NULL ; ifptr = ifptr->next ) {
	iedge = ifptr->fixEdge ;
	inode = edgeList[iedge].node ;
	ofptr = yNodules[cell].outList ;
	for( ; ofptr != (FLAREPTR) NULL ; ofptr = ofptr->next ) {
	    oedge = ofptr->fixEdge ;
	    onode = edgeList[oedge].node ;
	    saveptr = yNodeArray[inode] ;
	    yNodeArray[inode] = (WCPTR) malloc( sizeof(WCBOX));
	    yNodeArray[inode]->next = saveptr ;
	    yNodeArray[inode]->fixedWidth = 1 ;
	    yNodeArray[inode]->node = onode ;
	    yNodeArray[inode]->channels = (int *) NULL ;
	    yNodeArray[inode]->length = edgeList[oedge].loc -
					edgeList[iedge].loc ;
	}
    }
}
for( cell = 0 ; cell <= numberCells + 1 ; cell++ ) {
    ofptr = yNodules[cell].outList ;
    for( ; ofptr != (FLAREPTR) NULL ; ofptr = ofptr->next ) {
	iedge = ofptr->fixEdge ;
	inode = edgeList[iedge].node ;

	lastE = ofptr->eindex[ ofptr->eindex[0] ] ;
	onode = edgeList[ eArray[lastE].edge2 ].node ;

	saveptr = yNodeArray[inode] ;
	yNodeArray[inode] = (WCPTR) malloc( sizeof(WCBOX));
	yNodeArray[inode]->next = saveptr ;
	yNodeArray[inode]->fixedWidth = 0 ;
	yNodeArray[inode]->length = 0 ;
	yNodeArray[inode]->node = onode ;
	yNodeArray[inode]->channels = (int *) malloc( (1 + 
				ofptr->eindex[0]) * sizeof(int) );
	for( count = 0 ; count <= ofptr->eindex[0] ; count++ ) {
	    yNodeArray[inode]->channels[count] = ofptr->eindex[count] ;
	}
    }
}

if( hChanBeginRoot != (TNODEPTR) NULL ) {
    for( ; ; ) {
	tpop( &hChanBeginRoot , &tnode , &location , &eindex ) ;
	if( tnode == (TNODEPTR) NULL ) {
	    break ;
	}
    }
}
if( hChanEndRoot != (TNODEPTR) NULL ) {
    for( ; ; ) {
	tpop( &hChanEndRoot , &tnode , &location , &eindex ) ;
	if( tnode == (TNODEPTR) NULL ) {
	    break ;
	}
    }
}

return ;
}