projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / tas / ttv / ttv_fact.c
1 /****************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI Alliance */
4 /* */
5 /* Produit : TTV Verison 1 */
6 /* Fichier : ttv_fact.c */
7 /* */
8 /* (c) copyright 1995-1998 Laboratoire LIP6 equipe ASIM */
9 /* Tous droits reserves */
10 /* Support : e-mail alliance-support@asim.lip6.fr */
11 /* */
12 /* Auteur(s) : Karim DIOURY */
13 /* */
14 /****************************************************************************/
15 /* factorisation de chemin */
16 /****************************************************************************/
17
18 #include "ttv.h"
19
20 chain_list *TTV_ALLOC_FLINE = NULL ;
21 chain_list *TTV_CMPT_NODE = NULL ;
22 chain_list *TTV_CMPT_SIGLIST = NULL ;
23 ttvfline_list *TTV_FREE_FLINE = NULL ;
24 long TTV_MAX_FCYCLE = (long)10 ;
25 long TTV_MAX_FLINE = (long)0 ;
26 long TTV_MAX_CMPT = (long)0 ;
27
28 /*****************************************************************************/
29 /* function ttv_addcouple() */
30 /* parametres : */
31 /* node1 : noeud d'entree */
32 /* node : noeud de recherche */
33 /* node2 : noeud de sortie */
34 /* */
35 /* rajoute un couple de noeud a un cmpt */
36 /*****************************************************************************/
37 void ttv_addcouple(node1,node,node2)
38 ttvevent_list *node1 ;
39 ttvevent_list *node ;
40 ttvevent_list *node2 ;
41 {
42 ttvcmpt_list *cmpt ;
43 ht *htab ;
44
45 if((node == NULL) || (node1 == NULL) || (node2 == NULL))
46 return ;
47
48 cmpt = ttv_getcmpt(node) ;
49
50 if(((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT) ||
51 (cmpt->NBCOUPLE > (cmpt->NBNODEIN + cmpt->NBNODEOUT + (long)1)))
52 return ;
53
54 if(cmpt->TABNODE == NULL)
55 {
56 cmpt->TABNODE = addht(cmpt->NBNODEIN) ;
57 htab = addht(cmpt->NBNODEOUT) ;
58 cmpt->TABLIST = addchain(cmpt->TABLIST,htab) ;
59 addhtitem(cmpt->TABNODE,(void *)node1,(long)htab) ;
60 addhtitem(htab,(void *)node2,(long)node2) ;
61 cmpt->NBCOUPLE++ ;
62 return ;
63 }
64
65 htab = (ht *)gethtitem(cmpt->TABNODE,(void *)node1) ;
66
67 if((htab == (ht *)EMPTYHT) || (htab == (ht *)DELETEHT))
68 {
69 htab = addht(cmpt->NBNODEOUT) ;
70 cmpt->TABLIST = addchain(cmpt->TABLIST,htab) ;
71 addhtitem(cmpt->TABNODE,(void *)node1,(long)htab) ;
72 addhtitem(htab,(void *)node2,(long)node2) ;
73 cmpt->NBCOUPLE++ ;
74 return ;
75 }
76
77 if(sethtitem(htab,(void *)node2,(long)node2) == 0)
78 cmpt->NBCOUPLE++ ;
79 }
80
81 /*****************************************************************************/
82 /* function ttv_checkcouple() */
83 /* parametres : */
84 /* node1 : noeud d'entree */
85 /* node : noeud de recherche */
86 /* node2 : noeud de sortie */
87 /* */
88 /* verifie si un couple existe dans un noeud */
89 /*****************************************************************************/
90 int ttv_checkcouple(node1,node,node2)
91 ttvevent_list *node1 ;
92 ttvevent_list *node ;
93 ttvevent_list *node2 ;
94 {
95 ttvcmpt_list *cmpt ;
96 ht *htab ;
97 long value ;
98
99 if((node == NULL) || (node1 == NULL) || (node2 == NULL))
100 return(0) ;
101
102 cmpt = ttv_getcmpt(node) ;
103
104 if(cmpt == NULL)
105 return(0) ;
106
107 if(cmpt->TABNODE == NULL)
108 return(1) ;
109
110 htab = (ht *)gethtitem(cmpt->TABNODE,(void *)node1) ;
111
112 if((htab == (ht *)EMPTYHT) || (htab == (ht *)DELETEHT))
113 return(0) ;
114
115 value = gethtitem(htab,(void *)node2) ;
116
117 if((value == EMPTYHT) || (value == DELETEHT))
118 return(0) ;
119 else
120 return(1) ;
121 }
122
123 /*****************************************************************************/
124 /* function ttv_delcouple() */
125 /* parametres : */
126 /* node : noeud */
127 /* */
128 /* supprime les couples d'un noeud */
129 /*****************************************************************************/
130 int ttv_delcouple(node)
131 ttvevent_list *node ;
132 {
133 ttvcmpt_list *cmpt ;
134 chain_list *chain ;
135
136 cmpt = ttv_getcmpt(node) ;
137
138 if(cmpt == NULL)
139 return(0) ;
140
141 if(cmpt->TABNODE == NULL)
142 {
143 cmpt->NBCOUPLE = (long)0 ;
144 return(0) ;
145 }
146
147 for(chain = cmpt->TABLIST ; chain != NULL ; chain = chain->NEXT)
148 {
149 delht((ht *)chain->DATA) ;
150 }
151
152 if(cmpt->TABLIST != NULL)
153 {
154 freechain(cmpt->TABLIST) ;
155 cmpt->TABLIST = NULL ;
156 }
157
158 if(cmpt->TABNODE != NULL)
159 {
160 delht(cmpt->TABNODE) ;
161 cmpt->TABNODE = NULL ;
162 }
163
164 cmpt->NBCOUPLE = (long)0 ;
165
166 return(1) ;
167 }
168
169 /*****************************************************************************/
170 /* function ttv_cmptcompar() */
171 /* parametres : */
172 /* chain1 : premier cmpt */
173 /* chain2 : deuxieme cmpt */
174 /* */
175 /* compare deux cmpt en fonction des gains qu'ils engendrent */
176 /*****************************************************************************/
177 int ttv_cmptcompar(chain1,chain2)
178 chain_list **chain1 ;
179 chain_list **chain2 ;
180 {
181 ttvcmpt_list *cmpt1 ;
182 ttvcmpt_list *cmpt2 ;
183
184 cmpt1 = ttv_getcmpt((ttvevent_list *)((*chain1)->DATA)) ;
185 cmpt2 = ttv_getcmpt((ttvevent_list *)((*chain2)->DATA)) ;
186
187 return((int)((cmpt1->NBPATH - (cmpt1->NBIN+cmpt1->NBOUT)) -
188 (cmpt2->NBPATH - (cmpt2->NBIN+cmpt2->NBOUT)))) ;
189 }
190
191 /*****************************************************************************/
192 /* function ttv_classcmpt() */
193 /* parametres : */
194 /* chain : liste des node a classer */
195 /* */
196 /* classe la liste de node en fonction des gains qu'ils engendrent */
197 /*****************************************************************************/
198 chain_list *ttv_classcmpt(chain)
199 chain_list *chain ;
200 {
201 chain_list *chainx ;
202 chain_list **chaintab ;
203 long nbchain = 0 ;
204 long nbchainx ;
205
206 if(chain == NULL)
207 return(chain) ;
208
209 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
210 nbchain++ ;
211
212 chaintab = (chain_list**)mbkalloc(nbchain * sizeof(chain_list *)) ;
213
214 chainx = chain ;
215
216 for(nbchainx = (long)0 ; nbchainx < nbchain ; nbchainx++)
217 {
218 *(chaintab + nbchainx) = chainx ;
219 chainx = chainx->NEXT ;
220 }
221
222 qsort(chaintab,nbchain,sizeof(chain_list *),(int (*)(const void*,const void*))ttv_cmptcompar) ;
223
224 chain = *chaintab ;
225 chainx = chain ;
226
227 for(nbchainx = (long)1 ; nbchainx < nbchain ; nbchainx++)
228 {
229 chainx->NEXT = *(chaintab + nbchainx) ;
230 chainx = chainx->NEXT ;
231 }
232
233 chainx->NEXT = NULL ;
234
235 mbkfree(chaintab) ;
236
237 return(chain) ;
238 }
239
240 /*****************************************************************************/
241 /* function ttv_freeallcmpt() */
242 /* parametres : */
243 /* */
244 /* supprime tous les compteurs */
245 /*****************************************************************************/
246 void ttv_freeallcmpt()
247 {
248 ptype_list *ptype ;
249 chain_list *chain ;
250
251 for(chain = TTV_CMPT_NODE ; chain != NULL ; chain = chain->NEXT)
252 {
253 if((ptype = getptype(((ttvevent_list *)chain->DATA)->USER,TTV_NODE_CMPT))
254 != NULL)
255 {
256 ttv_freecmpt((ttvevent_list *)chain->DATA) ;
257 }
258 }
259
260 for(chain = TTV_ALLOC_FLINE ; chain != NULL ; chain = chain->NEXT)
261 mbkfree(chain->DATA) ;
262
263 freechain(TTV_ALLOC_FLINE) ;
264 freechain(TTV_CMPT_NODE) ;
265
266 TTV_ALLOC_FLINE = NULL ;
267 TTV_FREE_FLINE = NULL ;
268 TTV_CMPT_NODE = NULL ;
269 }
270
271 /*****************************************************************************/
272 /* function ttv_delallcmpt() */
273 /* parametres : */
274 /* */
275 /* supprime tous les compteurs */
276 /*****************************************************************************/
277 void ttv_delallcmpt()
278 {
279 chain_list *chain ;
280 int i ;
281
282 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
283 {
284 for(i = 0 ; i < 2 ; i++)
285 {
286 ttv_freecmpt((ttvevent_list *)(((ttvsig_list *)chain->DATA)->NODE + i)) ;
287 }
288 }
289 }
290
291 /*****************************************************************************/
292 /* function ttv_freeflinelist() */
293 /* parametres : */
294 /* fline : lien */
295 /* */
296 /* supprime une liste de lien */
297 /*****************************************************************************/
298 int ttv_freeflinelist(fline)
299 ttvfline_list *fline ;
300 {
301 if(fline == NULL) return 0 ;
302
303 TTV_FREE_FLINE = (ttvfline_list *)append((chain_list *)fline,
304 (chain_list *)TTV_FREE_FLINE);
305 return 1 ;
306 }
307
308 /*****************************************************************************/
309 /* function ttv_freefline() */
310 /* parametres : */
311 /* cmpt : compteur */
312 /* type : type de lien */
313 /* */
314 /* supprime les liens d'un compteur */
315 /*****************************************************************************/
316 int ttv_freefline(cmpt,type)
317 ttvcmpt_list *cmpt ;
318 long type ;
319 {
320 if(cmpt == NULL) return 0 ;
321
322 if((type & TTV_FLIN_IN) == TTV_FLIN_IN)
323 {
324 if(cmpt->PATHIN == NULL)
325 return(0) ;
326 TTV_FREE_FLINE = (ttvfline_list *)append((chain_list *)cmpt->PATHIN,
327 (chain_list *)TTV_FREE_FLINE);
328 cmpt->PATHIN = NULL ;
329 cmpt->NBNODEIN = (long)0 ;
330 }
331 if((type & TTV_FLIN_OUT) == TTV_FLIN_OUT)
332 {
333 if(cmpt->PATHOUT == NULL)
334 return(0) ;
335 TTV_FREE_FLINE = (ttvfline_list *)append((chain_list *)cmpt->PATHOUT,
336 (chain_list *)TTV_FREE_FLINE);
337 cmpt->PATHOUT = NULL ;
338 cmpt->NBNODEOUT = (long)0 ;
339 }
340
341 return 1 ;
342 }
343
344 /*****************************************************************************/
345 /* function ttv_freecmpt() */
346 /* parametres : */
347 /* node : noeud */
348 /* */
349 /* supprime le cmpt d'un noeud */
350 /*****************************************************************************/
351 int ttv_freecmpt(node)
352 ttvevent_list *node ;
353 {
354 ttvcmpt_list *cmpt ;
355 ptype_list *ptype ;
356
357 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
358 return(0) ;
359 else
360 cmpt = (ttvcmpt_list *)ptype->DATA ;
361
362 ttv_freefline(cmpt,TTV_FLIN_IN|TTV_FLIN_OUT) ;
363
364 if(cmpt->TABIN != NULL)
365 delht(cmpt->TABIN) ;
366
367 if(cmpt->TABOUT != NULL)
368 delht(cmpt->TABOUT) ;
369
370 ttv_delcouple(node) ;
371
372 node->USER = delptype(node->USER,TTV_NODE_CMPT) ;
373
374 mbkfree(cmpt) ;
375
376 return(1) ;
377 }
378
379 /*****************************************************************************/
380 /* function ttv_allocfline() */
381 /* parametres : */
382 /* cmpt : ajoue d'un lien a un compteur */
383 /* node : noeud a ajouter */
384 /* type : type de lien in ou out */
385 /* */
386 /* fonction d'allocation de lien pour un compteur */
387 /*****************************************************************************/
388 ttvfline_list *ttv_allocfline(cmpt,node,type)
389 ttvcmpt_list *cmpt ;
390 ttvevent_list *node ;
391 long type ;
392 {
393 ttvfline_list *pt ;
394 int i ;
395
396 if(cmpt != NULL)
397 {
398 if((type & TTV_FLIN_IN) == TTV_FLIN_IN)
399 {
400 if(cmpt->TABIN != NULL)
401 {
402 pt = (ttvfline_list *)gethtitem(cmpt->TABIN,node) ;
403 if((pt != (ttvfline_list *)EMPTYHT) && (pt != (ttvfline_list *)DELETEHT))
404 return(pt) ;
405 }
406 }
407 else
408 {
409 if(cmpt->TABOUT != NULL)
410 {
411 pt = (ttvfline_list *)gethtitem(cmpt->TABOUT,node) ;
412 if((pt != (ttvfline_list *)EMPTYHT) && (pt != (ttvfline_list *)DELETEHT))
413 return(pt) ;
414 }
415 }
416 }
417
418 if (TTV_FREE_FLINE == NULL)
419 {
420 pt = (ttvfline_list *)mbkalloc(TTV_MAX_BLOC * sizeof(ttvfline_list));
421 TTV_MAX_FLINE += TTV_MAX_BLOC ;
422 TTV_FREE_FLINE = pt;
423 TTV_ALLOC_FLINE = addchain(TTV_ALLOC_FLINE,(void *)pt) ;
424 for (i = 1 ; i < TTV_MAX_BLOC ; i++)
425 {
426 pt->NEXT = pt + 1;
427 pt++;
428 }
429 pt->NEXT = NULL;
430 }
431
432 pt = TTV_FREE_FLINE;
433 TTV_FREE_FLINE = TTV_FREE_FLINE->NEXT;
434
435 pt->NBIN = (long)0 ;
436 pt->NBOUT = (long)0 ;
437 pt->NBPATH = (long)0 ;
438 pt->NODE = node ;
439 pt->NEXT = NULL ;
440
441 if(cmpt != NULL)
442 {
443 if((type & TTV_FLIN_IN) == TTV_FLIN_IN)
444 {
445 if(cmpt->TABIN == NULL)
446 cmpt->TABIN = addht(10) ;
447 pt->NEXT = cmpt->PATHIN ;
448 cmpt->PATHIN = pt ;
449 cmpt->NBNODEIN++ ;
450 addhtitem(cmpt->TABIN,(void *)node,(long)pt) ;
451 }
452 else
453 {
454 if(cmpt->TABOUT == NULL)
455 cmpt->TABOUT = addht(10) ;
456 pt->NEXT = cmpt->PATHOUT ;
457 cmpt->PATHOUT = pt ;
458 cmpt->NBNODEOUT++ ;
459 addhtitem(cmpt->TABOUT,(void *)node,(long)pt) ;
460 }
461 }
462
463 return(pt) ;
464 }
465
466 /*****************************************************************************/
467 /* function ttv_alloccmpt() */
468 /* parametres : */
469 /* node : node ou il faut ajouter les compteur */
470 /* */
471 /* fonction d'allocation de compteur pour un noeud */
472 /*****************************************************************************/
473 ttvcmpt_list *ttv_alloccmpt(node)
474 ttvevent_list *node ;
475 {
476 ttvcmpt_list *pt ;
477 ptype_list *ptype ;
478
479 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) != NULL)
480 return((ttvcmpt_list *)ptype->DATA) ;
481
482 pt = (ttvcmpt_list *)mbkalloc(sizeof(ttvcmpt_list));
483 TTV_MAX_CMPT ++ ;
484 pt->NBIN = (long)0 ;
485 pt->NBOUT = (long)0 ;
486 pt->NBPATH = (long)0 ;
487 pt->PATHIN = NULL ;
488 pt->PATHOUT = NULL ;
489 pt->TABNODE = NULL ;
490 pt->TABLIST = NULL ;
491 pt->NBCOUPLE = (long)0 ;
492 pt->NBNODEIN = (long)0 ;
493 pt->NBNODEOUT = (long)0 ;
494 pt->TABIN = NULL ;
495 pt->TABOUT = NULL ;
496
497 node->USER = addptype(node->USER,TTV_NODE_CMPT,(void *)pt) ;
498
499 TTV_CMPT_NODE = addchain(TTV_CMPT_NODE,(void *)node) ;
500
501 return(pt) ;
502 }
503
504 /*****************************************************************************/
505 /* function ttv_getcmpt() */
506 /* parametres : */
507 /* node : node ou il faut ajouter les compteur */
508 /* */
509 /* fonction d'allocation de compteur pour un noeud */
510 /*****************************************************************************/
511 ttvcmpt_list *ttv_getcmpt(node)
512 ttvevent_list *node ;
513 {
514 ptype_list *ptype ;
515
516 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) != NULL)
517 return((ttvcmpt_list *)ptype->DATA) ;
518 else
519 return(NULL) ;
520 }
521
522 /*****************************************************************************/
523 /* function ttv_clearcmpt() */
524 /* parametres : */
525 /* node : node ou il faut netoyer les compteur */
526 /* */
527 /* fonction de nettoyage des compteur d'un noeud */
528 /*****************************************************************************/
529 int ttv_clearcmpt(cmpt,type)
530 ttvcmpt_list *cmpt ;
531 long type ;
532 {
533 ttvevent_list *ptnode ;
534 ttvfline_list *fline ;
535 ttvfline_list *flinex ;
536 ptype_list *ptype ;
537 chain_list *chainnode ;
538 chain_list *chain ;
539 long nb ;
540 int flag = (long)0 ;
541
542 if(cmpt == NULL) return(0) ;
543
544 if((type & TTV_FLIN_IN) == TTV_FLIN_IN)
545 {
546 flag = (long)1 ;
547 chainnode = NULL ;
548 delht(cmpt->TABIN) ;
549 nb = (long)0 ;
550 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
551 {
552 if((ptype = getptype(fline->NODE->USER,TTV_NODE_FIN)) == NULL)
553 {
554 fline->NODE->USER = addptype(fline->NODE->USER,TTV_NODE_FIN,
555 ttv_allocfline(NULL,fline->NODE,TTV_FLIN_IN)) ;
556 ptype = fline->NODE->USER ;
557 chainnode = addchain(chainnode,(void *)fline->NODE) ;
558 }
559 flinex = (ttvfline_list *)ptype->DATA ;
560 flinex->NBIN += fline->NBIN ;
561 flinex->NBOUT += fline->NBOUT ;
562 flinex->NBPATH += fline->NBPATH ;
563 }
564 ttv_freefline(cmpt,TTV_FLIN_IN) ;
565 cmpt->TABIN = addht(10) ;
566 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
567 {
568 ptnode = (ttvevent_list *)chain->DATA ;
569 ptype = getptype(ptnode->USER,TTV_NODE_FIN) ;
570 flinex = (ttvfline_list *)ptype->DATA ;
571 flinex->NEXT = cmpt->PATHIN ;
572 cmpt->PATHIN = flinex ;
573 addhtitem(cmpt->TABIN,(void *)flinex->NODE,(long)flinex) ;
574 ptnode->USER = delptype(ptnode->USER,TTV_NODE_FIN) ;
575 nb++ ;
576 }
577 cmpt->NBNODEIN = nb ;
578 freechain(chainnode) ;
579 }
580
581 if((type & TTV_FLIN_OUT) == TTV_FLIN_OUT)
582 {
583 flag = (long)1 ;
584 chainnode = NULL ;
585 delht(cmpt->TABOUT) ;
586 nb = (long)0 ;
587 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
588 {
589 if((ptype = getptype(fline->NODE->USER,TTV_NODE_FOUT)) == NULL)
590 {
591 fline->NODE->USER = addptype(fline->NODE->USER,TTV_NODE_FOUT,
592 ttv_allocfline(NULL,fline->NODE,TTV_FLIN_OUT)) ;
593 ptype = fline->NODE->USER ;
594 chainnode = addchain(chainnode,(void *)fline->NODE) ;
595 }
596 flinex = (ttvfline_list *)ptype->DATA ;
597 flinex->NBIN += fline->NBIN ;
598 flinex->NBOUT += fline->NBOUT ;
599 flinex->NBPATH += fline->NBPATH ;
600 }
601 ttv_freefline(cmpt,TTV_FLIN_OUT) ;
602 cmpt->TABOUT = addht(10) ;
603 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
604 {
605 ptnode = (ttvevent_list *)chain->DATA ;
606 ptype = getptype(ptnode->USER,TTV_NODE_FOUT) ;
607 flinex = (ttvfline_list *)ptype->DATA ;
608 flinex->NEXT = cmpt->PATHOUT ;
609 cmpt->PATHOUT = flinex ;
610 addhtitem(cmpt->TABOUT,(void *)flinex->NODE,(long)flinex) ;
611 ptnode->USER = delptype(ptnode->USER,TTV_NODE_FOUT) ;
612 nb++ ;
613 }
614 cmpt->NBNODEOUT = nb ;
615 freechain(chainnode) ;
616 }
617
618 return(flag) ;
619 }
620
621 /*****************************************************************************/
622 /* function ttv_verifactsig() */
623 /* parametres : */
624 /* ptsig : signal a verifier */
625 /* type : type de recherche */
626 /* */
627 /* verifie si les noeud d'un signal sont des points de factorisation */
628 /*****************************************************************************/
629 int ttv_verifactsig(ptsig,type)
630 ttvsig_list *ptsig ;
631 long type ;
632 {
633 ttvevent_list *node ;
634 int i ;
635 int flag = 0 ;
636
637 for(i = 0 ; i < 2 ; i++)
638 {
639 node = ptsig->NODE + i ;
640 if((node->TYPE & (TTV_NODE_MIN|TTV_NODE_MOUT)) != 0)
641 {
642 node->TYPE &= ~(TTV_NODE_MIN|TTV_NODE_MOUT) ;
643 if((type & TTV_FIND_FACTGLO) == TTV_FIND_FACTGLO)
644 {
645 node->TYPE &= ~(TTV_NODE_PFACT) ;
646 flag = 1 ;
647 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
648 {
649 node->TYPE |= TTV_NODE_IMAX ;
650 }
651 else
652 {
653 node->TYPE |= TTV_NODE_IMIN ;
654 }
655 }
656 }
657 if(((type & TTV_FIND_FACTGLO) != TTV_FIND_FACTGLO) &&
658 ((node->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT))
659 {
660 flag = 1 ;
661 node->TYPE &= ~(TTV_NODE_PFACT) ;
662 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
663 {
664 node->TYPE |= TTV_NODE_IMAX ;
665 }
666 else
667 {
668 node->TYPE |= TTV_NODE_IMIN ;
669 }
670 }
671 }
672 return(flag) ;
673 }
674
675 /*****************************************************************************/
676 /* function ttv_checkfactsig() */
677 /* parametres : */
678 /* ptsig : signal a verifier */
679 /* */
680 /* test si un signal est un point de factorisation */
681 /*****************************************************************************/
682 int ttv_checkfactsig(ptsig)
683 ttvsig_list *ptsig ;
684 {
685 if(((ptsig->NODE[0].TYPE & (TTV_NODE_IMAX|TTV_NODE_IMIN)) != 0) ||
686 ((ptsig->NODE[1].TYPE & (TTV_NODE_IMAX|TTV_NODE_IMIN)) != 0))
687 return(1) ;
688 else
689 return(0) ;
690 }
691
692 /*****************************************************************************/
693 /* function ttv_classnodetype() */
694 /* parametres : */
695 /* chainnode : liste de noeud */
696 /* type : type de recherche */
697 /* */
698 /* classe les noeuds deja points de factorisation en noeud prioritaire */
699 /*****************************************************************************/
700 chain_list *ttv_classnodetype(chainnode)
701 chain_list *chainnode ;
702 {
703 ttvevent_list *node ;
704 chain_list *chain ;
705 chain_list *chainx ;
706 chain_list *chainnodex ;
707
708 chainnode = ttv_classcmpt(chainnode) ;
709
710 chainnodex = NULL ;
711 chain = chainnode ;
712
713 while(chain != NULL)
714 {
715 node = (ttvevent_list *)chain->DATA ;
716 if(((node->TYPE & (TTV_NODE_IMAX|TTV_NODE_IMIN)) != 0) ||
717 ((node->ROOT->TYPE & TTV_SIG_I) == TTV_SIG_I))
718 {
719 if(chain == chainnode)
720 {
721 chainnode = chainnode->NEXT ;
722 chain->NEXT = chainnodex ;
723 chainnodex = chain ;
724 chain = chainnode ;
725 }
726 else
727 {
728 chainx->NEXT = chain->NEXT ;
729 chain->NEXT = chainnodex ;
730 chainnodex = chain ;
731 chain = chainx->NEXT ;
732 }
733 }
734 else
735 {
736 chainx = chain ;
737 chain = chain->NEXT ;
738 }
739 }
740
741 chainnodex = reverse(chainnodex) ;
742 chainnode = append(chainnode,chainnodex) ;
743
744 return(chainnode) ;
745 }
746
747 /*****************************************************************************/
748 /* function ttv_delcmpt() */
749 /* parametres : */
750 /* node : node ou il faut supprimer les compteur */
751 /* */
752 /* fonction de suppression de compteur pour un noeud */
753 /*****************************************************************************/
754 int ttv_delcmpt(node,gain)
755 ttvevent_list *node ;
756 long gain ;
757 {
758 ttvcmpt_list *pt ;
759 ttvcmpt_list *cmpt ;
760 ttvcmpt_list *cmptx ;
761 ttvfline_list *fline ;
762 ttvfline_list *flinex ;
763 ttvfline_list *flineaux ;
764 chain_list *chainin = NULL ;
765 chain_list *chainout = NULL ;
766 chain_list *chain ;
767 ptype_list *ptype ;
768 long nbin ;
769 long nbout ;
770 char flagin = 'N' ;
771 char flagout = 'N' ;
772
773 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
774 return(0) ;
775 else
776 pt = (ttvcmpt_list *)ptype->DATA ;
777
778 if(gain < (long) 2)
779 {
780 for(fline = pt->PATHIN ; fline != NULL ; fline = fline->NEXT)
781 {
782 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) != TTV_NODE_OLDFACT)
783 {
784 if(flagin == 'N')
785 flagin = 'Y' ;
786 else
787 {
788 flagin = 'N' ;
789 break ;
790 }
791 }
792 }
793
794 for(fline = pt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
795 {
796 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) != TTV_NODE_OLDFACT)
797 {
798 if(flagout == 'N')
799 flagout = 'Y' ;
800 else
801 {
802 flagout = 'N' ;
803 break ;
804 }
805 }
806 }
807 }
808
809 for(fline = pt->PATHIN ; fline != NULL ; fline = fline->NEXT)
810 {
811 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
812 continue ;
813 cmpt = ttv_getcmpt(fline->NODE) ;
814 if(((fline->NODE->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT) &&
815 (gain < (long)2))
816 {
817 chainin = addchain(chainin,(void *)fline->NODE) ;
818 }
819 for(flinex = pt->PATHOUT ; flinex != NULL ; flinex = flinex->NEXT)
820 {
821 if(((flinex->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT) ||
822 (ttv_checkcouple(fline->NODE,node,flinex->NODE) == 0))
823 continue ;
824 cmptx = ttv_getcmpt(flinex->NODE) ;
825 if(((flinex->NODE->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT) &&
826 (gain < (long)2))
827 {
828 chainout = addchain(chainout,(void *)flinex->NODE) ;
829 }
830 if(cmpt != NULL)
831 {
832 flineaux = ttv_allocfline(cmpt,flinex->NODE,TTV_FLIN_OUT) ;
833 flineaux->NBIN = fline->NBIN ;
834 flineaux->NBOUT = flinex->NBOUT ;
835 flineaux->NBPATH = fline->NBPATH ;
836 fline->NODE->TYPE |= TTV_NODE_NEWFOUT ;
837 }
838 if(cmptx != NULL)
839 {
840 flineaux = ttv_allocfline(cmptx,fline->NODE,TTV_FLIN_IN) ;
841 flineaux->NBIN = fline->NBIN ;
842 flineaux->NBOUT = flinex->NBOUT ;
843 flineaux->NBPATH = fline->NBPATH ;
844 flinex->NODE->TYPE |= TTV_NODE_NEWFIN ;
845 if((flagin == 'N') &&
846 ((flinex->NODE->TYPE & TTV_NODE_MAROUT) != TTV_NODE_MAROUT))
847 {
848 flinex->NODE->TYPE &= ~(TTV_NODE_MARFACT|TTV_NODE_MARIN) ;
849 }
850 }
851 }
852 if((flagout == 'N') && (cmpt != NULL) &&
853 ((fline->NODE->TYPE & TTV_NODE_MARIN) != TTV_NODE_MARIN))
854 {
855 fline->NODE->TYPE &= ~(TTV_NODE_MARFACT|TTV_NODE_MAROUT) ;
856 }
857 }
858
859 if(gain < (long) 2)
860 {
861 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
862 {
863 cmpt = ttv_getcmpt((ttvevent_list *)chain->DATA) ;
864 /*ttv_clearcmpt(cmpt,TTV_FLIN_OUT) ;*/
865 nbin = (long)0 ;
866 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
867 {
868 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
869 continue ;
870 nbin++ ;
871 if(nbin == (long)4)
872 break ;
873 }
874 nbout = (long)0 ;
875 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
876 {
877 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
878 continue ;
879 nbout++ ;
880 if(nbout == (long)4)
881 break ;
882 }
883 if(((nbin*nbout) - (nbin+nbout)) == gain)
884 {
885 ((ttvevent_list *)chain->DATA)->TYPE |= TTV_NODE_MARFACT ;
886 }
887 }
888
889 for(chain = chainout ; chain != NULL ; chain = chain->NEXT)
890 {
891 cmpt = ttv_getcmpt((ttvevent_list *)chain->DATA) ;
892 /*ttv_clearcmpt(cmpt,TTV_FLIN_IN) ;*/
893 nbin = (long)0 ;
894 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
895 {
896 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
897 continue ;
898 nbin++ ;
899 if(nbin == (long)4)
900 break ;
901 }
902 nbout = (long)0 ;
903 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
904 {
905 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
906 continue ;
907 nbout++ ;
908 if(nbout == (long)4)
909 break ;
910 }
911 if(((nbin*nbout) - (nbin+nbout)) == gain)
912 {
913 ((ttvevent_list *)chain->DATA)->TYPE |= TTV_NODE_MARFACT ;
914 }
915 }
916 freechain(chainin) ;
917 freechain(chainout) ;
918 }
919
920
921 ttv_freecmpt(node) ;
922
923 return(1) ;
924 }
925
926 /*****************************************************************************/
927 /* function ttv_deletebadfact() */
928 /* parametres : */
929 /* type : type de recherche */
930 /* */
931 /* supprmie les noeuds qui ne sont pas des points de factorisations */
932 /* en fonction ddu nombre de couple et des entrees sorties */
933 /*****************************************************************************/
934 int ttv_deletebadfact(type)
935 long type ;
936 {
937 ttvsig_list *ptsig ;
938 ttvevent_list *node ;
939 ttvcmpt_list *cmpt ;
940 ptype_list *ptype ;
941 chain_list *chainnode ;
942 chain_list *chain ;
943 long i ;
944 int flag = 1 ;
945
946 chainnode = NULL ;
947 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
948 {
949 ptsig = (ttvsig_list *)chain->DATA ;
950 for(i = 0 ; i < 2 ; i++)
951 {
952 node = (ttvevent_list *)ptsig->NODE + i ;
953 if((((node->TYPE & TTV_NODE_IMAX) == TTV_NODE_IMAX) &&
954 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
955 (((node->TYPE & TTV_NODE_IMIN) == TTV_NODE_IMIN) &&
956 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)) ||
957 ((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT))
958 continue ;
959 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
960 {
961 node->TYPE &= ~(TTV_NODE_PFACT) ;
962 continue ;
963 }
964 else
965 cmpt = (ttvcmpt_list *)ptype->DATA ;
966 /*ttv_clearcmpt(cmpt,TTV_FLIN_IN|TTV_FLIN_OUT) ;*/
967 if(cmpt->NBCOUPLE <= (cmpt->NBNODEIN+cmpt->NBNODEOUT+(long)1))
968 {
969 chainnode = addchain(chainnode,(void *)node) ;
970 node->TYPE |= TTV_NODE_MARFACT ;
971 }
972 }
973 }
974 chainnode = ttv_classnodetype(chainnode) ;
975 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
976 {
977 node = (ttvevent_list *)chain->DATA ;
978
979 if((node->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT)
980 {
981 ttv_delcmpt(node,(long)3) ;
982 node->TYPE &= ~(TTV_NODE_MARFACT|TTV_NODE_PFACT) ;
983 node->TYPE |= TTV_NODE_OLDFACT ;
984 }
985 else
986 {
987 flag = 0 ;
988 }
989 }
990
991 freechain(chainnode) ;
992 ttv_cleanfactline() ;
993 ttv_cleansiglist() ;
994 return(flag) ;
995 }
996
997 /*****************************************************************************/
998 /* function ttv_deleteglobal() */
999 /* parametres : */
1000 /* type : type de recherche */
1001 /* */
1002 /* supprmie les noeuds qui ne sont pas des points de factorisations */
1003 /* en fonction de leur gain global */
1004 /*****************************************************************************/
1005 void ttv_deleteglobal(type)
1006 long type ;
1007 {
1008 ttvsig_list *ptsig ;
1009 ttvevent_list *node ;
1010 ttvcmpt_list *cmpt ;
1011 ptype_list *ptype ;
1012 chain_list *chainnode ;
1013 chain_list *chain ;
1014 long i ;
1015
1016 chainnode = NULL ;
1017 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
1018 {
1019 ptsig = (ttvsig_list *)chain->DATA ;
1020 for(i = 0 ; i < 2 ; i++)
1021 {
1022 node = (ttvevent_list *)ptsig->NODE + i ;
1023 if((((node->TYPE & TTV_NODE_IMAX) == TTV_NODE_IMAX) &&
1024 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
1025 (((node->TYPE & TTV_NODE_IMIN) == TTV_NODE_IMIN) &&
1026 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)) ||
1027 ((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT))
1028 continue ;
1029 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
1030 {
1031 node->TYPE &= ~(TTV_NODE_PFACT) ;
1032 continue ;
1033 }
1034 else
1035 cmpt = (ttvcmpt_list *)ptype->DATA ;
1036 if((cmpt->NBPATH - (cmpt->NBIN + cmpt->NBOUT)) < (long)2)
1037 {
1038 ttv_delcmpt(node,(long)2) ;
1039 node->TYPE &= ~(TTV_NODE_PFACT) ;
1040 node->TYPE |= TTV_NODE_OLDFACT ;
1041 }
1042 }
1043 }
1044
1045 ttv_cleanfactline() ;
1046 ttv_cleansiglist() ;
1047 }
1048
1049 /*****************************************************************************/
1050 /* function ttv_deletenofact() */
1051 /* parametres : */
1052 /* type : type de recherche */
1053 /* */
1054 /* supprmie les noeuds qui ne sont pas des points de factorisations */
1055 /* en fonction de leur gain local */
1056 /*****************************************************************************/
1057 void ttv_deletenofact(type)
1058 long type ;
1059 {
1060 ttvsig_list *ptsig ;
1061 ttvevent_list *node ;
1062 ttvcmpt_list *cmpt ;
1063 ttvfline_list *fline ;
1064 ptype_list *ptype ;
1065 chain_list *chainnode ;
1066 chain_list *chain ;
1067 chain_list *chainaux[6] ;
1068 long gain ;
1069 long i ;
1070 long nbin ;
1071 long nbout ;
1072
1073 for(gain = -1 ; gain < 3 ; gain++ )
1074 {
1075 chainnode = NULL ;
1076 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
1077 {
1078 ptsig = (ttvsig_list *)chain->DATA ;
1079 for(i = 0 ; i < 2 ; i++)
1080 {
1081 node = (ttvevent_list *)ptsig->NODE + i ;
1082 if((((node->TYPE & TTV_NODE_IMAX) == TTV_NODE_IMAX) &&
1083 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
1084 (((node->TYPE & TTV_NODE_IMIN) == TTV_NODE_IMIN) &&
1085 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)) ||
1086 ((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT))
1087 continue ;
1088 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
1089 {
1090 node->TYPE &= ~(TTV_NODE_PFACT) ;
1091 continue ;
1092 }
1093 else
1094 cmpt = (ttvcmpt_list *)ptype->DATA ;
1095 /*ttv_clearcmpt(cmpt,TTV_FLIN_IN|TTV_FLIN_OUT) ;*/
1096 nbin = (long)0 ;
1097 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
1098 {
1099 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
1100 continue ;
1101 nbin++ ;
1102 if(nbin == (long)4)
1103 break ;
1104 }
1105 nbout = (long)0 ;
1106 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
1107 {
1108 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
1109 continue ;
1110 nbout++ ;
1111 if(nbout == (long)4)
1112 break ;
1113 }
1114 if(((nbin*nbout) - (nbin+nbout)) == gain)
1115 {
1116 chainnode = addchain(chainnode,(void *)node) ;
1117 node->TYPE |= TTV_NODE_MARFACT ;
1118 if(nbin == (long)1)
1119 node->TYPE |= TTV_NODE_MARIN ;
1120 if(nbout == (long)1)
1121 node->TYPE |= TTV_NODE_MAROUT ;
1122 }
1123 else if(((nbin*nbout) - (nbin+nbout)) < gain)
1124 {
1125 gain = ((nbin*nbout) - (nbin+nbout)) ;
1126 for(chainaux[0] = chainnode ; chainaux[0] != NULL ;
1127 chainaux[0] = chainaux[0]->NEXT)
1128 {
1129 ((ttvevent_list *)chainaux[0]->DATA)->TYPE &= ~(TTV_NODE_MARFACT|
1130 TTV_NODE_MARIN|TTV_NODE_MAROUT) ;
1131 }
1132 freechain(chainnode) ;
1133 chainnode = addchain(NULL,(void *)node) ;
1134 node->TYPE |= TTV_NODE_MARFACT ;
1135 if(nbin == (long)1)
1136 node->TYPE |= TTV_NODE_MARIN ;
1137 if(nbout == (long)1)
1138 node->TYPE |= TTV_NODE_MAROUT ;
1139 }
1140 }
1141 }
1142 if(gain == (long)-1)
1143 {
1144 chainnode = ttv_classnodetype(chainnode) ;
1145 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
1146 {
1147 node = (ttvevent_list *)chain->DATA ;
1148
1149 if((node->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT)
1150 {
1151 ttv_delcmpt(node,gain) ;
1152 node->TYPE &= ~(TTV_NODE_MARFACT|TTV_NODE_PFACT) ;
1153 node->TYPE |= TTV_NODE_OLDFACT ;
1154 }
1155 }
1156 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
1157 {
1158 node = (ttvevent_list *)chain->DATA ;
1159 node->TYPE &= ~(TTV_NODE_MARIN|TTV_NODE_MAROUT) ;
1160 }
1161 freechain(chainnode) ;
1162 continue ;
1163 }
1164 if(gain == (long)2)
1165 {
1166 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
1167 {
1168 node = (ttvevent_list *)chain->DATA ;
1169 node->TYPE &= ~(TTV_NODE_MARIN|TTV_NODE_MAROUT|TTV_NODE_MARFACT) ;
1170 }
1171 freechain(chainnode) ;
1172 continue ;
1173 }
1174 chainaux[0] = NULL ;
1175 chainaux[1] = NULL ;
1176 chainaux[2] = NULL ;
1177 chainaux[3] = NULL ;
1178 chainaux[4] = NULL ;
1179 chainaux[5] = NULL ;
1180 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
1181 {
1182 node = (ttvevent_list *)chain->DATA ;
1183 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
1184 continue ;
1185 else
1186 cmpt = (ttvcmpt_list *)ptype->DATA ;
1187 nbin = (long)0 ;
1188 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
1189 {
1190 if((fline->NODE->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT)
1191 {
1192 nbin++ ;
1193 }
1194 }
1195 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
1196 {
1197 if((fline->NODE->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT)
1198 {
1199 nbin++ ;
1200 }
1201 }
1202 chainaux[nbin] = addchain(chainaux[nbin],node) ;
1203 }
1204 freechain(chainnode) ;
1205 for(i = 0 ; i < 6 ; i++)
1206 {
1207 chainaux[i] = ttv_classnodetype(chainaux[i]) ;
1208 for(chain = chainaux[i] ; chain != NULL ; chain = chain->NEXT)
1209 {
1210 node = (ttvevent_list *)chain->DATA ;
1211
1212 if((node->TYPE & TTV_NODE_MARFACT) == TTV_NODE_MARFACT)
1213 {
1214 ttv_delcmpt(node,gain) ;
1215 node->TYPE &= ~(TTV_NODE_MARFACT|TTV_NODE_PFACT) ;
1216 node->TYPE |= TTV_NODE_OLDFACT ;
1217 }
1218 }
1219 freechain(chainaux[i]) ;
1220 }
1221 }
1222
1223 ttv_cleanfactline() ;
1224 ttv_cleansiglist() ;
1225 }
1226
1227 /*****************************************************************************/
1228 /* function ttv_cleansiglist() */
1229 /* parametres : */
1230 /* */
1231 /* supprmie les signaux qui ne sont plus des points de factorisation */
1232 /*****************************************************************************/
1233 void ttv_cleansiglist()
1234 {
1235 ttvsig_list *ptsig ;
1236 ttvevent_list *node ;
1237 chain_list *chainsig ;
1238 chain_list *chain ;
1239 chain_list *chainx ;
1240 int i ;
1241 char flag ;
1242
1243 chainsig = NULL ;
1244 chain = TTV_CMPT_SIGLIST ;
1245
1246 while(chain != NULL)
1247 {
1248 flag = 'N' ;
1249 ptsig = (ttvsig_list *)chain->DATA ;
1250 for(i = 0 ; i < 2 ; i++)
1251 {
1252 node = (ttvevent_list *)ptsig->NODE + i ;
1253 if(((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT) ||
1254 (ttv_getcmpt(node) == NULL))
1255 {
1256 node->TYPE &= ~(TTV_NODE_FACTMASK) ;
1257 ttv_freecmpt(node) ;
1258 }
1259 else
1260 {
1261 flag = 'Y' ;
1262 }
1263 }
1264 if(flag == 'N')
1265 {
1266 if(chain == TTV_CMPT_SIGLIST)
1267 {
1268 TTV_CMPT_SIGLIST = TTV_CMPT_SIGLIST->NEXT ;
1269 chain->NEXT = chainsig ;
1270 chainsig = chain ;
1271 chain = TTV_CMPT_SIGLIST ;
1272 }
1273 else
1274 {
1275 chainx->NEXT = chain->NEXT ;
1276 chain->NEXT = chainsig ;
1277 chainsig = chain ;
1278 chain = chainx->NEXT ;
1279 }
1280 }
1281 else
1282 {
1283 chainx = chain ;
1284 chain = chain->NEXT ;
1285 }
1286 }
1287 freechain(chainsig) ;
1288 }
1289
1290 /*****************************************************************************/
1291 /* function ttv_cleanfactline() */
1292 /* parametres : */
1293 /* */
1294 /* supprmie les liens allant au noeud de factorisation non retenus */
1295 /*****************************************************************************/
1296 void ttv_cleanfactline()
1297 {
1298 ttvsig_list *ptsig ;
1299 ttvevent_list *node ;
1300 ttvcmpt_list *cmpt ;
1301 ttvfline_list *fline ;
1302 ttvfline_list *flinex ;
1303 chain_list *chainnode ;
1304 chain_list *chain ;
1305 int i ;
1306
1307 chainnode = NULL ;
1308 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
1309 {
1310 ptsig = (ttvsig_list *)chain->DATA ;
1311 for(i = 0 ; i < 2 ; i++)
1312 {
1313 node = (ttvevent_list *)ptsig->NODE + i ;
1314 if((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT)
1315 {
1316 node->TYPE &= ~(TTV_NODE_NEWFIN|TTV_NODE_NEWFOUT) ;
1317 if((node->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
1318 chainnode = addchain(chainnode,(void *)node) ;
1319 continue ;
1320 }
1321 if((node->TYPE & TTV_NODE_NEWFIN) == TTV_NODE_NEWFIN)
1322 {
1323 node->TYPE &= ~(TTV_NODE_NEWFIN) ;
1324 cmpt = ttv_getcmpt(node) ;
1325 fline = cmpt->PATHIN ;
1326 while(fline != NULL)
1327 {
1328 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
1329 {
1330 delhtitem(cmpt->TABIN,(void *)fline->NODE) ;
1331 if(cmpt->PATHIN == fline)
1332 {
1333 cmpt->PATHIN = cmpt->PATHIN->NEXT ;
1334 fline->NEXT = NULL ;
1335 ttv_freeflinelist(fline) ;
1336 fline = cmpt->PATHIN ;
1337 }
1338 else
1339 {
1340 flinex->NEXT = fline->NEXT ;
1341 fline->NEXT = NULL ;
1342 ttv_freeflinelist(fline) ;
1343 fline = flinex->NEXT ;
1344 }
1345 cmpt->NBNODEIN-- ;
1346 continue ;
1347 }
1348 flinex = fline ;
1349 fline = fline->NEXT ;
1350 }
1351 }
1352 if((node->TYPE & TTV_NODE_NEWFOUT) == TTV_NODE_NEWFOUT)
1353 {
1354 node->TYPE &= ~(TTV_NODE_NEWFOUT) ;
1355 cmpt = ttv_getcmpt(node) ;
1356 fline = cmpt->PATHOUT ;
1357 while(fline != NULL)
1358 {
1359 if((fline->NODE->TYPE & TTV_NODE_OLDFACT) == TTV_NODE_OLDFACT)
1360 {
1361 delhtitem(cmpt->TABOUT,(void *)fline->NODE) ;
1362 if(cmpt->PATHOUT == fline)
1363 {
1364 cmpt->PATHOUT = cmpt->PATHOUT->NEXT ;
1365 fline->NEXT = NULL ;
1366 ttv_freeflinelist(fline) ;
1367 fline = cmpt->PATHOUT ;
1368 }
1369 else
1370 {
1371 flinex->NEXT = fline->NEXT ;
1372 fline->NEXT = NULL ;
1373 ttv_freeflinelist(fline) ;
1374 fline = flinex->NEXT ;
1375 }
1376 cmpt->NBNODEOUT-- ;
1377 continue ;
1378 }
1379 flinex = fline ;
1380 fline = fline->NEXT ;
1381 }
1382 }
1383 }
1384 }
1385 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
1386 {
1387 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_OLDFACT) ;
1388 }
1389
1390 freechain(chainnode) ;
1391 }
1392
1393 /*****************************************************************************/
1394 /* function ttv_count() */
1395 /* parametres : */
1396 /* ttvfig : ttvfig que l'on veut factorise */
1397 /* chainin : chaine des entre ou des sortie */
1398 /* type : type de factorisation dual ou pas */
1399 /* */
1400 /* compte le nombre de chemin et de sortie ou des entree et le memorise */
1401 /* dans des ptype */
1402 /* renvoie la liste des points de factorisations trouve si la parcours est */
1403 /* dual et le nombre de chemin si le parcours n'est pas dual */
1404 /*****************************************************************************/
1405 long ttv_count(ttvfig,root,chainin,type)
1406 ttvfig_list *ttvfig ;
1407 ttvevent_list *root ;
1408 chain_list *chainin ;
1409 long type ;
1410 {
1411 ttvevent_list *node ;
1412 ttvcmpt_list *cmpt ;
1413 ttvcmpt_list *cmptx ;
1414 ttvfline_list *fline ;
1415 ttvfline_list *flinex ;
1416 chain_list *chain ;
1417 chain_list *chainmarque = NULL ;
1418 ttvevent_list *nodes ;
1419 ttvevent_list *nodee ;
1420 ttvevent_list *nodem ;
1421 ttvevent_list *pnode ;
1422 ttvevent_list *snode ;
1423 long nbse ;
1424 long nbss ;
1425 long nbsm ;
1426 long nbee ;
1427 long nbes ;
1428 long nbem ;
1429 long nbme ;
1430 long nbms ;
1431 long nbmm ;
1432 long nbe ;
1433 long nbs ;
1434 long nbm = 0 ;
1435 char flag ;
1436 char flagext ;
1437 char flagfig ;
1438
1439 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
1440 {
1441 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
1442 {
1443 nodes = NULL ;
1444 nodee = NULL ;
1445 nodem = NULL ;
1446 nbse = (long)0 ;
1447 nbss = (long)0 ;
1448 nbsm = (long)0 ;
1449 nbee = (long)0 ;
1450 nbes = (long)0 ;
1451 nbem = (long)0 ;
1452 nbme = (long)0 ;
1453 nbms = (long)0 ;
1454 nbmm = (long)0 ;
1455 flag = 'E' ;
1456 }
1457 else nbm ++ ;
1458
1459 node = (ttvevent_list *)chain->DATA ;
1460 if(((node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_N)) != 0) ||
1461 ((root->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_N)) != 0))
1462 flagext = 'Y' ;
1463 else
1464 flagext = 'N' ;
1465 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
1466 pnode = node ;
1467 snode = NULL ;
1468 flagfig = 'N' ;
1469 while(node->FIND->OUTLINE != NULL)
1470 {
1471 if(node->FIND->OUTLINE->FIG == ttvfig)
1472 {
1473 flagfig = 'Y' ;
1474 break ;
1475 }
1476 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
1477 node = node->FIND->OUTLINE->NODE ;
1478 else
1479 node = node->FIND->OUTLINE->ROOT ;
1480 if(node == root)
1481 break ;
1482 }
1483 if(flagfig == 'N')
1484 continue ;
1485 node = pnode ;
1486 while(node->FIND->OUTLINE != NULL)
1487 {
1488 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1489 {
1490 node->FIND->OUTLINE->TYPE |= TTV_LINE_DEPTMAX ;
1491 }
1492 else
1493 {
1494 node->FIND->OUTLINE->TYPE |= TTV_LINE_DEPTMIN ;
1495 }
1496
1497 if((node->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1498 {
1499 if(flagext == 'Y')
1500 node->ROOT->TYPE |= TTV_SIG_EXT ;
1501 cmpt = ttv_alloccmpt(node) ;
1502 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
1503 {
1504 if((pnode->TYPE & TTV_NODE_PUSED) != TTV_NODE_PUSED)
1505 fline = ttv_allocfline(cmpt,pnode,TTV_FLIN_OUT) ;
1506 if((pnode->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1507 {
1508 cmptx = ttv_alloccmpt(pnode) ;
1509 if((pnode->TYPE & TTV_NODE_PUSED) != TTV_NODE_PUSED)
1510 flinex = ttv_allocfline(cmptx,node,TTV_FLIN_IN) ;
1511 }
1512 if((node->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)
1513 {
1514 node->TYPE |= TTV_NODE_MARQUE ;
1515 chainmarque = addchain(chainmarque,(void *)node) ;
1516 cmpt->NBIN++ ;
1517 }
1518 if((pnode->TYPE & TTV_NODE_PUSED) != TTV_NODE_PUSED)
1519 {
1520 fline->NBIN++ ;
1521 if((pnode->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1522 flinex->NBIN++ ;
1523 pnode->TYPE |= TTV_NODE_PUSED ;
1524 }
1525 nbe = cmpt->NBIN ;
1526 nbm = cmpt->NBPATH ;
1527 nbs = cmpt->NBOUT ;
1528 if((nbmm - (nbme + nbms)) < (nbm - (nbe + nbs)))
1529 {
1530 nbme = nbe ;
1531 nbms = nbs ;
1532 nbmm = nbm ;
1533 nodem = node ;
1534 }
1535 if(nbee < nbe)
1536 {
1537 if((nbem - (nbee + nbes)) < (nbm - (nbe + nbs)))
1538 {
1539 nbee = nbe ;
1540 nbes = nbs ;
1541 nbem = nbm ;
1542 nodee = node ;
1543 flag = 'E' ;
1544 }
1545 }
1546 if(nbss < nbs)
1547 {
1548 if((nbsm - (nbse + nbss)) < (nbm - (nbe + nbs)))
1549 {
1550 nbse = nbe ;
1551 nbss = nbs ;
1552 nbsm = nbm ;
1553 nodes = node ;
1554 flag = 'S' ;
1555 }
1556 }
1557 if((node->TYPE & (TTV_NODE_MIN|TTV_NODE_MOUT)) != 0)
1558 if((node != nodee) && (node != nodes) && (node != nodem))
1559 node->TYPE &= ~(TTV_NODE_MIN | TTV_NODE_MOUT) ;
1560 pnode = node ;
1561 }
1562 else
1563 {
1564 if(flagext == 'Y')
1565 node->ROOT->TYPE |= TTV_SIG_EXT ;
1566 fline = ttv_allocfline(cmpt,pnode,TTV_FLIN_IN) ;
1567 if((pnode->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1568 {
1569 cmptx = ttv_alloccmpt(pnode) ;
1570 flinex = ttv_allocfline(cmptx,node,TTV_FLIN_OUT) ;
1571 }
1572 if((node->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)
1573 {
1574 node->TYPE |= TTV_NODE_MARQUE ;
1575 chainmarque = addchain(chainmarque,(void *)node) ;
1576 cmpt->NBOUT++ ;
1577 }
1578 if((pnode->TYPE & TTV_NODE_PUSED) != TTV_NODE_PUSED)
1579 {
1580 fline->NBOUT++ ;
1581 if((pnode->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1582 flinex->NBOUT++ ;
1583 pnode->TYPE |= TTV_NODE_PUSED ;
1584 }
1585 cmpt->NBPATH++ ;
1586 fline->NBPATH++ ;
1587 if((pnode->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1588 flinex->NBPATH++ ;
1589 if((type & TTV_FIND_COUPLE) == TTV_FIND_COUPLE)
1590 ttv_addcouple(snode,pnode,node) ;
1591 snode = pnode ;
1592 pnode = node ;
1593 }
1594 }
1595 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
1596 node = node->FIND->OUTLINE->NODE ;
1597 else
1598 node = node->FIND->OUTLINE->ROOT ;
1599 if(node == root)
1600 {
1601 if(node->FIND->OUTLINE != NULL)
1602 {
1603 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1604 {
1605 node->FIND->OUTLINE->TYPE |= TTV_LINE_DEPTMAX ;
1606 }
1607 else
1608 {
1609 node->FIND->OUTLINE->TYPE |= TTV_LINE_DEPTMIN ;
1610 }
1611 }
1612 break ;
1613 }
1614 }
1615 if((pnode->TYPE & TTV_NODE_PFACT) == TTV_NODE_PFACT)
1616 {
1617 cmptx = ttv_alloccmpt(pnode) ;
1618 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
1619 {
1620 if((pnode->TYPE & TTV_NODE_PUSED) != TTV_NODE_PUSED)
1621 {
1622 flinex = ttv_allocfline(cmptx,node,TTV_FLIN_IN) ;
1623 flinex->NBIN++ ;
1624 pnode->TYPE |= TTV_NODE_PUSED ;
1625 }
1626 }
1627 else
1628 {
1629 flinex = ttv_allocfline(cmptx,node,TTV_FLIN_OUT) ;
1630 if((pnode->TYPE & TTV_NODE_PUSED) != TTV_NODE_PUSED)
1631 {
1632 flinex->NBOUT++ ;
1633 pnode->TYPE |= TTV_NODE_PUSED ;
1634 }
1635 flinex->NBPATH++ ;
1636 }
1637 if((type & TTV_FIND_COUPLE) == TTV_FIND_COUPLE)
1638 ttv_addcouple(snode,pnode,node) ;
1639 }
1640 if(((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) && (nodem != NULL))
1641 {
1642 if(((nbmm - (nbme + nbms)) >= (((nbem + nbsm) - (nbse * nbes))
1643 - (nbee + nbss + 1))) ||
1644 (flag == 'E') || ((nodem == nodes) && (nodem == nodee)))
1645 {
1646 nodee->TYPE &= ~(TTV_NODE_MIN | TTV_NODE_MOUT) ;
1647 nodes->TYPE &= ~(TTV_NODE_MIN | TTV_NODE_MOUT) ;
1648 nodem->TYPE |= (TTV_NODE_MIN|TTV_NODE_MOUT) ;
1649 }
1650 else if((nbes < nbee) && (nbss > nbse))
1651 {
1652 nodee->TYPE |= TTV_NODE_MIN ;
1653 nodee->TYPE &= ~(TTV_NODE_MOUT) ;
1654 nodes->TYPE |= TTV_NODE_MOUT ;
1655 nodes->TYPE &= ~(TTV_NODE_MIN) ;
1656 }
1657 else
1658 {
1659 nodee->TYPE &= ~(TTV_NODE_MIN | TTV_NODE_MOUT) ;
1660 nodes->TYPE &= ~(TTV_NODE_MIN | TTV_NODE_MOUT) ;
1661 nodem->TYPE |= (TTV_NODE_MIN|TTV_NODE_MOUT) ;
1662 }
1663 }
1664 }
1665
1666 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
1667 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE|TTV_NODE_PUSED) ;
1668 for(chain = chainmarque ; chain != NULL ; chain = chain->NEXT)
1669 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE|TTV_NODE_PUSED) ;
1670
1671 freechain(chainmarque) ;
1672 return(nbm) ;
1673 }
1674
1675 /*****************************************************************************/
1676 /* function ttv_filterrs() */
1677 /* parametres : */
1678 /* chain : list de noeuds */
1679 /* */
1680 /* filtre les destinations rs */
1681 /*****************************************************************************/
1682 chain_list *ttv_filterrs(chain,type)
1683 chain_list *chain ;
1684 char type ;
1685 {
1686 chain_list *ch ;
1687 chain_list *chx ;
1688 chain_list *chrs = NULL ;
1689 chain_list *chnotrs = NULL ;
1690
1691 ch = chain ;
1692 while(ch != NULL)
1693 {
1694 chx = ch ;
1695 ch = ch->NEXT ;
1696 if(((((ttvevent_list *)chx->DATA)->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
1697 ((((ttvevent_list *)chx->DATA)->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
1698 {
1699 chx->NEXT = chrs ;
1700 chrs = chx ;
1701 }
1702 else
1703 {
1704 chx->NEXT = chnotrs ;
1705 chnotrs = chx ;
1706 }
1707 }
1708 if(type == 'Y')
1709 {
1710 for(ch = chnotrs ; ch != NULL ; ch = ch->NEXT)
1711 ((ttvevent_list *)ch->DATA)->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
1712 freechain(chnotrs) ;
1713 return(chrs) ;
1714 }
1715 else
1716 {
1717 for(ch = chrs ; ch != NULL ; ch = ch->NEXT)
1718 ((ttvevent_list *)ch->DATA)->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
1719 freechain(chrs) ;
1720 return(chnotrs) ;
1721 }
1722 }
1723
1724 /*****************************************************************************/
1725 /* function ttv_countsep() */
1726 /* parametres : */
1727 /* ttvfig : ttvfig a factoriser */
1728 /* type : type de factorisation lien ou chemin */
1729 /* */
1730 /* compte le nombre de chemin et d'entree de sortie que voie un signal */
1731 /* renvoie le nombre de chemin total dans le graphe */
1732 /*****************************************************************************/
1733 long ttv_countsep(ttvfig,type,marque)
1734 ttvfig_list *ttvfig ;
1735 long type ;
1736 char marque ;
1737 {
1738 ttvsig_list *sig ;
1739 ttvevent_list *event ;
1740 ttvlbloc_list *ptlbloc[3] ;
1741 ttvline_list *ptline ;
1742 chain_list *chain ;
1743 chain_list *chaindualhz = NULL ;
1744 chain_list *chainduals = NULL ;
1745 chain_list *chaindualr = NULL ;
1746 chain_list *ch ;
1747 long nbpath = 0 ;
1748 long i ;
1749
1750 if(ttvfig == NULL)
1751 return(0) ;
1752
1753 type &= ~(TTV_FIND_DUAL | TTV_FIND_HZ) ;
1754
1755 if((((ttvfig->STATUS & TTV_STS_DTX) != TTV_STS_DTX) &&
1756 ((type & TTV_FIND_LINE) == TTV_FIND_LINE)) ||
1757 (((ttvfig->STATUS & TTV_STS_TTX) != TTV_STS_TTX) &&
1758 ((type & TTV_FIND_PATH) == TTV_FIND_PATH)))
1759 {
1760 ttv_error(31,ttvfig->INFO->FIGNAME,TTV_WARNING) ;
1761 return(0) ;
1762 }
1763
1764 for(i = 0 ; i < ttvfig->NBCONSIG ; i++)
1765 {
1766 sig = *(ttvfig->CONSIG + i) ;
1767 if(((sig->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
1768 ((sig->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
1769 continue ;
1770 if((sig->TYPE & TTV_SIG_CO) == TTV_SIG_CO)
1771 {
1772 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type,ttvfig->INFO->LEVEL) ;
1773 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1774 ttv_fifoclean() ;
1775 freechain(chain) ;
1776 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type,ttvfig->INFO->LEVEL) ;
1777 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1778 ttv_fifoclean() ;
1779 freechain(chain) ;
1780 }
1781 }
1782
1783 for(i = 0 ; i < ttvfig->NBNCSIG ; i++)
1784 {
1785 sig = *(ttvfig->NCSIG + i) ;
1786 if(((sig->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
1787 ((sig->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
1788 continue ;
1789 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type,ttvfig->INFO->LEVEL) ;
1790 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1791 ttv_fifoclean() ;
1792 freechain(chain) ;
1793 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type,ttvfig->INFO->LEVEL) ;
1794 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1795 ttv_fifoclean() ;
1796 freechain(chain) ;
1797 }
1798
1799 for(i = 0 ; i < ttvfig->NBELCMDSIG + ttvfig->NBILCMDSIG ; i++)
1800 {
1801 sig = (i < ttvfig->NBELCMDSIG) ? *(ttvfig->ELCMDSIG + i)
1802 : *(ttvfig->ILCMDSIG + i - ttvfig->NBELCMDSIG) ;
1803 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
1804 {
1805 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type,ttvfig->INFO->LEVEL) ;
1806 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1807 ttv_fifoclean() ;
1808 freechain(chain) ;
1809 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type,ttvfig->INFO->LEVEL) ;
1810 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1811 ttv_fifoclean() ;
1812 freechain(chain) ;
1813 }
1814 }
1815
1816 for(i = 0 ; i < ttvfig->NBELATCHSIG + ttvfig->NBILATCHSIG ; i++)
1817 {
1818 sig = (i < ttvfig->NBELATCHSIG) ? *(ttvfig->ELATCHSIG + i)
1819 : *(ttvfig->ILATCHSIG + i - ttvfig->NBELATCHSIG) ;
1820 if(((sig->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
1821 ((sig->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
1822 {
1823 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_R,ttvfig->INFO->LEVEL) ;
1824 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1825 ttv_fifoclean() ;
1826 for(ch = chain ; ch != NULL ; ch = ch->NEXT)
1827 if((((ttvevent_list *)ch->DATA)->TYPE & TTV_NODE_INR) != TTV_NODE_INR)
1828 {
1829 chaindualr = addchain(chaindualr,ch->DATA) ;
1830 ((ttvevent_list *)ch->DATA)->TYPE |= TTV_NODE_INR ;
1831 }
1832 freechain(chain) ;
1833 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_R,ttvfig->INFO->LEVEL) ;
1834 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1835 ttv_fifoclean() ;
1836 for(ch = chain ; ch != NULL ; ch = ch->NEXT)
1837 if((((ttvevent_list *)ch->DATA)->TYPE & TTV_NODE_INR) != TTV_NODE_INR)
1838 {
1839 chaindualr = addchain(chaindualr,ch->DATA) ;
1840 ((ttvevent_list *)ch->DATA)->TYPE |= TTV_NODE_INR ;
1841 }
1842 freechain(chain) ;
1843 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_S,ttvfig->INFO->LEVEL) ;
1844 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1845 ttv_fifoclean() ;
1846 for(ch = chain ; ch != NULL ; ch = ch->NEXT)
1847 if((((ttvevent_list *)ch->DATA)->TYPE & TTV_NODE_INS) != TTV_NODE_INS)
1848 {
1849 chainduals = addchain(chainduals,ch->DATA) ;
1850 ((ttvevent_list *)ch->DATA)->TYPE |= TTV_NODE_INS ;
1851 }
1852 freechain(chain) ;
1853 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_S,ttvfig->INFO->LEVEL) ;
1854 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1855 ttv_fifoclean() ;
1856 for(ch = chain ; ch != NULL ; ch = ch->NEXT)
1857 if((((ttvevent_list *)ch->DATA)->TYPE & TTV_NODE_INS) != TTV_NODE_INS)
1858 {
1859 chainduals = addchain(chainduals,ch->DATA) ;
1860 ((ttvevent_list *)ch->DATA)->TYPE |= TTV_NODE_INS ;
1861 }
1862 freechain(chain) ;
1863 }
1864 else if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
1865 {
1866 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type,ttvfig->INFO->LEVEL) ;
1867 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1868 ttv_fifoclean() ;
1869 freechain(chain) ;
1870 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type,ttvfig->INFO->LEVEL) ;
1871 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1872 ttv_fifoclean() ;
1873 freechain(chain) ;
1874 }
1875 }
1876
1877 for(i = 0 ; i < ttvfig->NBEPRESIG + ttvfig->NBIPRESIG ; i++)
1878 {
1879 sig = (i < ttvfig->NBEPRESIG) ? *(ttvfig->EPRESIG + i)
1880 : *(ttvfig->IPRESIG + i - ttvfig->NBEPRESIG) ;
1881 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
1882 {
1883 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type,ttvfig->INFO->LEVEL) ;
1884 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1885 ttv_fifoclean() ;
1886 freechain(chain) ;
1887 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type,ttvfig->INFO->LEVEL) ;
1888 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1889 ttv_fifoclean() ;
1890 freechain(chain) ;
1891 }
1892 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_HZ,ttvfig->INFO->LEVEL) ;
1893 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_HZ) ;
1894 ttv_fifoclean() ;
1895 for(ch = chain ; ch != NULL ; ch = ch->NEXT)
1896 if((((ttvevent_list *)ch->DATA)->TYPE & TTV_NODE_INHZ) != TTV_NODE_INHZ)
1897 {
1898 chaindualhz = addchain(chaindualhz,ch->DATA) ;
1899 ((ttvevent_list *)ch->DATA)->TYPE |= TTV_NODE_INHZ ;
1900 }
1901 freechain(chain) ;
1902 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_HZ,ttvfig->INFO->LEVEL) ;
1903 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_HZ) ;
1904 ttv_fifoclean() ;
1905 for(ch = chain ; ch != NULL ; ch = ch->NEXT)
1906 if((((ttvevent_list *)ch->DATA)->TYPE & TTV_NODE_INHZ) != TTV_NODE_INHZ)
1907 {
1908 chaindualhz = addchain(chaindualhz,ch->DATA) ;
1909 ((ttvevent_list *)ch->DATA)->TYPE |= TTV_NODE_INHZ ;
1910 }
1911 freechain(chain) ;
1912 }
1913
1914 for(i = 0 ; i < ttvfig->NBEBREAKSIG + ttvfig->NBIBREAKSIG ; i++)
1915 {
1916 sig = (i < ttvfig->NBEBREAKSIG) ? *(ttvfig->EBREAKSIG + i)
1917 : *(ttvfig->IBREAKSIG + i - ttvfig->NBEBREAKSIG) ;
1918 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
1919 {
1920 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type,ttvfig->INFO->LEVEL) ;
1921 nbpath += (long)ttv_count(ttvfig,sig->NODE,chain,type) ;
1922 ttv_fifoclean() ;
1923 freechain(chain) ;
1924 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type,ttvfig->INFO->LEVEL) ;
1925 nbpath += (long)ttv_count(ttvfig,sig->NODE+1,chain,type) ;
1926 ttv_fifoclean() ;
1927 freechain(chain) ;
1928 }
1929 }
1930
1931 if(((type & TTV_FIND_LINE) == TTV_FIND_LINE) && (marque == 'Y'))
1932 {
1933 long j ;
1934
1935 ptlbloc[0] = ttvfig->DBLOC ;
1936 ptlbloc[1] = ttvfig->EBLOC ;
1937 ptlbloc[2] = ttvfig->FBLOC ;
1938 for(i = 0 ; i < 2 ; i++)
1939 for( ; ptlbloc[i] != NULL ; ptlbloc[i] = ptlbloc[i]->NEXT)
1940 {
1941 for(j = 0 ; j < TTV_MAX_LBLOC ; j++)
1942 {
1943 ptline = ptlbloc[i]->LINE + j ;
1944 if((ptline->TYPE & TTV_LINE_FR) == TTV_LINE_FR)
1945 continue ;
1946 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1947 {
1948 if((ptline->TYPE & TTV_LINE_DEPTMAX) == TTV_LINE_DEPTMAX)
1949 ptline->TYPE &= ~(TTV_LINE_DEPTMAX) ;
1950 else
1951 ptline->TYPE |= TTV_LINE_DENPTMAX ;
1952 }
1953 else
1954 {
1955 if((ptline->TYPE & TTV_LINE_DEPTMIN) == TTV_LINE_DEPTMIN)
1956 ptline->TYPE &= ~(TTV_LINE_DEPTMIN) ;
1957 else
1958 ptline->TYPE |= TTV_LINE_DENPTMIN ;
1959 }
1960 }
1961 }
1962 }
1963
1964 for(i = 0 ; i < ttvfig->NBCONSIG ; i++)
1965 {
1966 sig = *(ttvfig->CONSIG + i) ;
1967 if((sig->TYPE & TTV_SIG_CI) == TTV_SIG_CI)
1968 {
1969 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
1970 if((chaindualr != NULL) || (chainduals != NULL))
1971 chain = ttv_filterrs(chain,'N') ;
1972 ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_DUAL) ;
1973 ttv_fifoclean() ;
1974 freechain(chain) ;
1975 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
1976 if((chaindualr != NULL) || (chainduals != NULL))
1977 chain = ttv_filterrs(chain,'N') ;
1978 ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_DUAL) ;
1979 ttv_fifoclean() ;
1980 freechain(chain) ;
1981 }
1982 }
1983
1984 for(i = 0 ; i < ttvfig->NBNCSIG ; i++)
1985 {
1986 sig = *(ttvfig->NCSIG + i) ;
1987 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
1988 if((chaindualr != NULL) || (chainduals != NULL))
1989 chain = ttv_filterrs(chain,'N') ;
1990 ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_DUAL) ;
1991 ttv_fifoclean() ;
1992 freechain(chain) ;
1993 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
1994 if((chaindualr != NULL) || (chainduals != NULL))
1995 chain = ttv_filterrs(chain,'N') ;
1996 ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_DUAL) ;
1997 ttv_fifoclean() ;
1998 freechain(chain) ;
1999 }
2000
2001 for(i = 0 ; i < ttvfig->NBELCMDSIG + ttvfig->NBILCMDSIG ; i++)
2002 {
2003 sig = (i < ttvfig->NBELCMDSIG) ? *(ttvfig->ELCMDSIG + i)
2004 : *(ttvfig->ILCMDSIG + i - ttvfig->NBELCMDSIG) ;
2005 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
2006 {
2007 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2008 if((chaindualr != NULL) || (chainduals != NULL))
2009 chain = ttv_filterrs(chain,'N') ;
2010 ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_DUAL) ;
2011 ttv_fifoclean() ;
2012 freechain(chain) ;
2013 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2014 if((chaindualr != NULL) || (chainduals != NULL))
2015 chain = ttv_filterrs(chain,'N') ;
2016 ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_DUAL) ;
2017 ttv_fifoclean() ;
2018 freechain(chain) ;
2019 }
2020 }
2021
2022 for(i = 0 ; i < ttvfig->NBEBREAKSIG + ttvfig->NBIBREAKSIG ; i++)
2023 {
2024 sig = (i < ttvfig->NBEBREAKSIG) ? *(ttvfig->EBREAKSIG + i)
2025 : *(ttvfig->IBREAKSIG + i - ttvfig->NBEBREAKSIG) ;
2026 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
2027 {
2028 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2029 if((chaindualr != NULL) || (chainduals != NULL))
2030 chain = ttv_filterrs(chain,'N') ;
2031 ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_DUAL) ;
2032 ttv_fifoclean() ;
2033 freechain(chain) ;
2034 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2035 if((chaindualr != NULL) || (chainduals != NULL))
2036 chain = ttv_filterrs(chain,'N') ;
2037 ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_DUAL) ;
2038 ttv_fifoclean() ;
2039 freechain(chain) ;
2040 }
2041 }
2042
2043 for(i = 0 ; i < ttvfig->NBELATCHSIG + ttvfig->NBILATCHSIG ; i++)
2044 {
2045 sig = (i < ttvfig->NBELATCHSIG) ? *(ttvfig->ELATCHSIG + i)
2046 : *(ttvfig->ILATCHSIG + i - ttvfig->NBELATCHSIG) ;
2047 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
2048 {
2049 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2050 if((chaindualr != NULL) || (chainduals != NULL))
2051 chain = ttv_filterrs(chain,'N') ;
2052 ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_DUAL) ;
2053 ttv_fifoclean() ;
2054 freechain(chain) ;
2055 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2056 if((chaindualr != NULL) || (chainduals != NULL))
2057 chain = ttv_filterrs(chain,'N') ;
2058 ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_DUAL) ;
2059 ttv_fifoclean() ;
2060 freechain(chain) ;
2061 }
2062 }
2063
2064 for(ch = chaindualr ; ch ; ch = ch->NEXT)
2065 {
2066 event = (ttvevent_list *)ch->DATA ;
2067 event->TYPE &= ~(TTV_NODE_INR) ;
2068 chain = ttv_findpath(ttvfig,ttvfig,event,NULL,type|TTV_FIND_DUAL|TTV_FIND_R,
2069 ttvfig->INFO->LEVEL) ;
2070 chain = ttv_filterrs(chain,'Y') ;
2071 ttv_count(ttvfig,event,chain,type|TTV_FIND_DUAL|TTV_FIND_R) ;
2072 ttv_fifoclean() ;
2073 freechain(chain) ;
2074 }
2075
2076 freechain(chaindualr) ;
2077
2078 for(ch = chainduals ; ch ; ch = ch->NEXT)
2079 {
2080 event = (ttvevent_list *)ch->DATA ;
2081 event->TYPE &= ~(TTV_NODE_INS) ;
2082 chain = ttv_findpath(ttvfig,ttvfig,event,NULL,type|TTV_FIND_DUAL|TTV_FIND_S,
2083 ttvfig->INFO->LEVEL) ;
2084 chain = ttv_filterrs(chain,'Y') ;
2085 ttv_count(ttvfig,event,chain,type|TTV_FIND_DUAL|TTV_FIND_S) ;
2086 ttv_fifoclean() ;
2087 freechain(chain) ;
2088 }
2089
2090 freechain(chainduals) ;
2091
2092 for(i = 0 ; i < ttvfig->NBEPRESIG + ttvfig->NBIPRESIG ; i++)
2093 {
2094 sig = (i < ttvfig->NBEPRESIG) ? *(ttvfig->EPRESIG + i)
2095 : *(ttvfig->IPRESIG + i - ttvfig->NBEPRESIG) ;
2096 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
2097 {
2098 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2099 if((chaindualr != NULL) || (chainduals != NULL))
2100 chain = ttv_filterrs(chain,'N') ;
2101 ttv_count(ttvfig,sig->NODE,chain,type|TTV_FIND_DUAL) ;
2102 ttv_fifoclean() ;
2103 freechain(chain) ;
2104 chain = ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_DUAL,ttvfig->INFO->LEVEL) ;
2105 if((chaindualr != NULL) || (chainduals != NULL))
2106 chain = ttv_filterrs(chain,'N') ;
2107 ttv_count(ttvfig,sig->NODE+1,chain,type|TTV_FIND_DUAL) ;
2108 ttv_fifoclean() ;
2109 freechain(chain) ;
2110 }
2111 }
2112
2113 for(ch = chaindualhz ; ch ; ch = ch->NEXT)
2114 {
2115 event = (ttvevent_list *)ch->DATA ;
2116 event->TYPE &= ~(TTV_NODE_INHZ) ;
2117 chain = ttv_findpath(ttvfig,ttvfig,event,NULL,type|TTV_FIND_DUAL|TTV_FIND_HZ,
2118 ttvfig->INFO->LEVEL) ;
2119 ttv_count(ttvfig,event,chain,type|TTV_FIND_DUAL|TTV_FIND_HZ) ;
2120 ttv_fifoclean() ;
2121 freechain(chain) ;
2122 }
2123
2124 freechain(chaindualhz) ;
2125
2126 ttv_fifodelete() ;
2127
2128 return(nbpath) ;
2129 }
2130
2131 /*****************************************************************************/
2132 /* function ttv_detectinter() */
2133 /* parametres : */
2134 /* ttvfig : ttvfig que l'on veut factorise */
2135 /* type : type de detection sur lien ou sur chemin */
2136 /* */
2137 /* detecte les points intermediaires pour la factorisation */
2138 /*****************************************************************************/
2139 void ttv_detectinter(ttvfig,type)
2140 ttvfig_list *ttvfig;
2141 int type;
2142 {
2143 /*FILE *file ;*/
2144 ttvsig_list *ptsig ;
2145 ttvevent_list *node ;
2146 ttvcmpt_list *cmpt ;
2147 ttvsbloc_list *ptsbloc ;
2148 ttvsbloc_list *ptsblocsav ;
2149 ttvlbloc_list *ptlbloc[3] ;
2150 ttvline_list *ptline ;
2151 chain_list *chaini ;
2152 chain_list *chainx ;
2153 chain_list *chain ;
2154 ptype_list *ptype ;
2155 long i,j,nbfree,nbend ;
2156 long nbpath ;
2157 long nbx ;
2158 long typenode ;
2159 long typenodex = (long)0 ;
2160 int test ;
2161 char flag ;
2162 char nbloop ;
2163 char nbloopx ;
2164 char marque ;
2165
2166 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2167 {
2168 nbloop = 0 ;
2169 typenodex |= TTV_NODE_IMAX ;
2170 }
2171 else
2172 {
2173 typenodex &= ~(TTV_NODE_IMAX) ;
2174 nbloop = 1 ;
2175 }
2176
2177 if((type & TTV_FIND_MIN) == TTV_FIND_MIN)
2178 {
2179 typenodex |= TTV_NODE_IMIN ;
2180 nbloopx = 2 ;
2181 }
2182 else
2183 {
2184 typenodex &= ~(TTV_NODE_IMIN) ;
2185 nbloopx = 1 ;
2186 }
2187
2188 if(((type & TTV_FIND_MIN) != TTV_FIND_MIN) &&
2189 ((type & TTV_FIND_MAX) != TTV_FIND_MAX))
2190 {
2191 typenodex |= TTV_NODE_IMAX ;
2192 typenodex |= TTV_NODE_IMIN ;
2193 nbloop = 0 ;
2194 nbloopx = 2 ;
2195 }
2196
2197 type &= ~(TTV_FIND_DUAL|TTV_FIND_MAX|TTV_FIND_MIN|TTV_FIND_HZ) ;
2198 type |= TTV_FIND_HIER ;
2199
2200 /*file = mbkfopen(ttvfig->INFO->FIGNAME,"cnt",WRITE_TEXT) ;
2201 fprintf(file,"figure %s\n\n",ttvfig->INFO->FIGNAME) ;*/
2202
2203 for(nbloop = 0 ; nbloop < nbloopx ; nbloop++ )
2204 {
2205 marque = 'Y' ;
2206 if(nbloop == 0)
2207 {
2208 type |= TTV_FIND_MAX ;
2209 type &= ~(TTV_FIND_MIN) ;
2210 /*fprintf(file,"MAX PATH FACTORISATION\n\n") ;*/
2211 typenode = TTV_NODE_IMAX ;
2212 }
2213 else
2214 {
2215 /*fprintf(file,"MIN PATH FACTORISATION\n\n") ;*/
2216 type |= TTV_FIND_MIN ;
2217 type &= ~(TTV_FIND_MAX) ;
2218 typenode = TTV_NODE_IMIN ;
2219 }
2220
2221 for(i = 0 ; i < ttvfig->NBINTSIG + ttvfig->NBEXTSIG ; i++)
2222 {
2223 ptsig = (i < ttvfig->NBEXTSIG) ? *(ttvfig->EXTSIG + i)
2224 : *(ttvfig->INTSIG + i - ttvfig->NBEXTSIG) ;
2225 if(ptsig->ROOT == ttvfig)
2226 {
2227 ptsig->NODE[0].TYPE |= typenodex ;
2228 ptsig->NODE[1].TYPE |= typenodex ;
2229 }
2230 else
2231 {
2232 ptsig->NODE[0].TYPE &= ~(typenode) ;
2233 ptsig->NODE[1].TYPE &= ~(typenode) ;
2234 }
2235 ptsig->NODE[0].TYPE &= ~(TTV_NODE_FACTMASK) ;
2236 ptsig->NODE[1].TYPE &= ~(TTV_NODE_FACTMASK) ;
2237 ptsig->NODE[0].TYPE |= TTV_NODE_PFACT ;
2238 ptsig->NODE[1].TYPE |= TTV_NODE_PFACT ;
2239 TTV_CMPT_SIGLIST = addchain(TTV_CMPT_SIGLIST,(void *)ptsig) ;
2240 }
2241
2242 for(i = 0 ; i < ttvfig->NBESIG ; i++)
2243 {
2244 ptsig = *(ttvfig->ESIG + i) ;
2245 if(ptsig->ROOT == ttvfig)
2246 {
2247 ptsig->NODE[0].TYPE &= ~(TTV_NODE_FACTMASK) ;
2248 ptsig->NODE[1].TYPE &= ~(TTV_NODE_FACTMASK) ;
2249 ptsig->NODE[0].TYPE |= TTV_NODE_PFACT ;
2250 ptsig->NODE[1].TYPE |= TTV_NODE_PFACT ;
2251 ptsig->NODE[0].TYPE &= ~(typenode) ;
2252 ptsig->NODE[1].TYPE &= ~(typenode) ;
2253 TTV_CMPT_SIGLIST = addchain(TTV_CMPT_SIGLIST,(void *)ptsig) ;
2254 }
2255 }
2256
2257 ptsbloc = ttvfig->ISIG ;
2258 nbfree = (TTV_MAX_SBLOC - (ttvfig->NBISIG % TTV_MAX_SBLOC)) % TTV_MAX_SBLOC ;
2259 nbend = ttvfig->NBISIG + nbfree ;
2260
2261 for(i = nbfree ; i < nbend ; i++)
2262 {
2263 j = i % TTV_MAX_SBLOC ;
2264 if((j == 0) && (i != 0)) ptsbloc = ptsbloc->NEXT ;
2265 ptsig = ptsbloc->SIG + j ;
2266 ptsig->NODE[0].TYPE &= ~(TTV_NODE_FACTMASK) ;
2267 ptsig->NODE[1].TYPE &= ~(TTV_NODE_FACTMASK) ;
2268 ptsig->NODE[0].TYPE |= TTV_NODE_PFACT ;
2269 ptsig->NODE[1].TYPE |= TTV_NODE_PFACT ;
2270 ptsig->NODE[0].TYPE &= ~(typenode) ;
2271 ptsig->NODE[1].TYPE &= ~(typenode) ;
2272 TTV_CMPT_SIGLIST = addchain(TTV_CMPT_SIGLIST,(void *)ptsig) ;
2273 }
2274
2275 test = 1 ;
2276 flag = 'Y' ;
2277 if((type & TTV_FIND_FACTGLO) != TTV_FIND_FACTGLO)
2278 {
2279 while((test != 0) && (test <= TTV_MAX_FCYCLE))
2280 {
2281 if(flag == 'Y')
2282 {
2283 nbpath = ttv_countsep(ttvfig,type,marque) ;
2284 marque = 'N' ;
2285
2286 ttv_deleteglobal(type) ;
2287 ttv_deletenofact(type) ;
2288
2289 ttv_delallcmpt() ;
2290 }
2291
2292 ttv_countsep(ttvfig,type|TTV_FIND_COUPLE,marque) ;
2293
2294 flag = 'N' ;
2295
2296 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
2297 {
2298 ptsig = (ttvsig_list *)chain->DATA ;
2299 for(i = 0 ; i < 2 ; i++)
2300 {
2301 node = (ttvevent_list *)ptsig->NODE + i ;
2302 if((node->TYPE & TTV_NODE_PFACT) != TTV_NODE_PFACT)
2303 continue ;
2304 if((cmpt = ttv_getcmpt(node)) == NULL)
2305 continue ;
2306 /*ttv_clearcmpt(cmpt,TTV_FLIN_IN|TTV_FLIN_OUT) ;*/
2307 if(((cmpt->NBNODEIN * cmpt->NBNODEOUT) -
2308 (cmpt->NBNODEIN + cmpt->NBNODEOUT)) < (long)2)
2309 flag = 'Y' ;
2310 }
2311 if(flag == 'Y')
2312 break ;
2313 }
2314
2315 if(flag == 'Y')
2316 {
2317 if(test < TTV_MAX_FCYCLE)
2318 ttv_delallcmpt() ;
2319 else
2320 {
2321 /* ne sert a rien */
2322 /*ttv_delallcmpt() ;
2323 ttv_countsep(ttvfig,type|TTV_FIND_COUPLE,marque) ;*/
2324 /* fin sert a rien */
2325 break ;
2326 }
2327 }
2328 else
2329 {
2330 if((ttv_deletebadfact(type) == 0) && (test < TTV_MAX_FCYCLE))
2331 {
2332 ttv_delallcmpt() ;
2333 }
2334 else
2335 {
2336 /* ne sert a rien */
2337 /*ttv_delallcmpt() ;
2338 ttv_countsep(ttvfig,type|TTV_FIND_COUPLE,marque) ;*/
2339 /* fin sert a rien */
2340 break ;
2341 }
2342 }
2343 test++ ;
2344 }
2345 }
2346 else
2347 {
2348 ttv_countsep(ttvfig,type,marque) ;
2349 marque = 'N' ;
2350 }
2351
2352 /*fprintf(file,"nb cycle = %ld nb fline = %ld nb cmpt = %ld\n\n",test,TTV_MAX_FLINE,TTV_MAX_CMPT) ;*/
2353 nbx = (long)0 ;
2354 for(chain = TTV_CMPT_SIGLIST ; chain != NULL ; chain = chain->NEXT)
2355 {
2356 ptsig = (ttvsig_list *)chain->DATA ;
2357 if(ttv_verifactsig(ptsig,type) != 0)
2358 {
2359 nbx++ ;
2360 /*fprintf(file,"%s : factorisation point \n\n",ttv_getsigname(ttvfig,buf,ptsig)) ;*/
2361 }
2362 /*else
2363 fprintf(file,"%s : not factorisation point \n\n",ttv_getsigname(ttvfig,buf,ptsig)) ;*/
2364
2365 if((type & TTV_FIND_FACTGLO) == TTV_FIND_FACTGLO)
2366 continue ;
2367 for(i = 0 ; i < 2 ; i++)
2368 {
2369 /* fprintf(file,"node %ld : ",i) ;
2370 node = (ttvevent_list *)ptsig->NODE + i ;
2371 if(((node->TYPE & TTV_NODE_IMAX) == TTV_NODE_IMAX) &&
2372 ((type & TTV_FIND_MAX) == TTV_FIND_MAX))
2373 fprintf(file,"FP : MAX ") ;
2374 if(((node->TYPE & TTV_NODE_IMIN) == TTV_NODE_IMIN) &&
2375 ((type & TTV_FIND_MIN) == TTV_FIND_MIN))
2376 fprintf(file,"FP : MIN ") ;
2377 if(((node->TYPE & TTV_NODE_IMAX) == TTV_NODE_IMAX) &&
2378 ((type & TTV_FIND_MIN) == TTV_FIND_MIN))
2379 fprintf(file,"MAX ") ;
2380 if(((node->TYPE & TTV_NODE_IMIN) == TTV_NODE_IMIN) &&
2381 ((type & TTV_FIND_MAX) == TTV_FIND_MAX))
2382 fprintf(file,"MIN ") ;
2383 if((ptype = getptype(node->USER,TTV_NODE_CMPT)) == NULL)
2384 cmpt = NULL ;
2385 else
2386 cmpt = (ttvcmpt_list *)ptype->DATA ;*/
2387 /*ttv_clearcmpt(cmpt,TTV_FLIN_IN|TTV_FLIN_OUT) ;*/
2388 /*if(cmpt != NULL)
2389 {
2390 long nbinx ;
2391 long nboutx ;
2392 long nbinmax ;
2393 long nboutmax ;
2394 long nbpathin ;
2395 long nbpathout ;
2396
2397 fprintf(file,"nbin = %ld nbout = %ld nbpath = %ld gain = %ld\n",
2398 cmpt->NBIN,cmpt->NBOUT,cmpt->NBPATH,
2399 cmpt->NBPATH - (cmpt->NBIN + cmpt->NBOUT)) ;
2400 if(cmpt->NBCOUPLE <= (cmpt->NBNODEIN+cmpt->NBNODEOUT+(long)1))
2401 fprintf(file,"BF nbnodein = %ld nbnodeout = %ld nbfantotal = %ld nbcouple = %ld\n",cmpt->NBNODEIN,cmpt->NBNODEOUT,cmpt->NBNODEIN+cmpt->NBNODEOUT,cmpt->NBCOUPLE) ;
2402 else
2403 fprintf(file,"GF nbnodein = %ld nbnodeout = %ld nbfantotal = %ld nbcouple = %ld\n",cmpt->NBNODEIN,cmpt->NBNODEOUT,cmpt->NBNODEIN+cmpt->NBNODEOUT,cmpt->NBCOUPLE) ;
2404
2405 nbin = 0 ;
2406 nbinx = 0 ;
2407 nboutmax = 0 ;
2408 nbpathin = 0 ;
2409
2410 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
2411 {
2412 fprintf(file,"IN : %s %c nbin = %ld nbout = %ld nbpath = %ld gain = %ld\n",
2413 ttv_getsigname(ttvfig,buf,fline->NODE->ROOT),
2414 ((fline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? 'U':'D',
2415 fline->NBIN,fline->NBOUT,fline->NBPATH,
2416 fline->NBPATH - (fline->NBIN + fline->NBOUT)) ;
2417 nbin += fline->NBIN ;
2418 nbinx++ ;
2419 nbpathin += fline->NBPATH ;
2420 if(fline->NBOUT > nboutmax)
2421 nboutmax = fline->NBOUT ;
2422 if(fline->NBOUT > cmpt->NBOUT)
2423 fprintf(file,"ERROR OUT : nbout = %d nbcmptout = %ld\n",
2424 fline->NBOUT,cmpt->NBOUT) ;
2425 if((fline->NODE->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
2426 fprintf(file,"ERROR MUL : %s %c\n",ttv_getsigname(ttvfig,buf,fline->NODE->ROOT),((fline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? 'U':'D') ;
2427 fline->NODE->TYPE |= TTV_NODE_MARQUE ;
2428 }
2429
2430 for(fline = cmpt->PATHIN ; fline != NULL ; fline = fline->NEXT)
2431 fline->NODE->TYPE &= ~(TTV_NODE_MARQUE) ;
2432
2433 nbout = 0 ;
2434 nboutx = 0 ;
2435 nbinmax = 0 ;
2436 nbpathout = 0 ;
2437
2438 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
2439 {
2440 fprintf(file,"OUT : %s %c nbin = %ld nbout = %ld nbpath = %ld gain = %ld\n",
2441 ttv_getsigname(ttvfig,buf,fline->NODE->ROOT),
2442 ((fline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? 'U':'D',
2443 fline->NBIN,fline->NBOUT,fline->NBPATH,
2444 fline->NBPATH - (fline->NBIN + fline->NBOUT)) ;
2445 nbout += fline->NBOUT ;
2446 nboutx++ ;
2447 nbpathout += fline->NBPATH ;
2448 if(fline->NBIN > nbinmax)
2449 nbinmax = fline->NBIN ;
2450 if(fline->NBIN > cmpt->NBIN)
2451 fprintf(file,"ERROR IN : nbin = %d nbcmptin = %ld\n",
2452 fline->NBIN,cmpt->NBIN) ;
2453 if((fline->NODE->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
2454 fprintf(file,"ERROR MUL : %s %c\n",ttv_getsigname(ttvfig,buf,fline->NODE->ROOT),((fline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? 'U':'D') ;
2455 fline->NODE->TYPE |= TTV_NODE_MARQUE ;
2456 }
2457 for(fline = cmpt->PATHOUT ; fline != NULL ; fline = fline->NEXT)
2458 fline->NODE->TYPE &= ~(TTV_NODE_MARQUE) ;
2459
2460 if((((nbinx*nboutx) - (nbinx+nboutx)) < (long)2) ||
2461 (nbinx == (long)0) || (nboutx == (long)0))
2462 fprintf(file,"ERROR FAN : ") ;
2463 fprintf(file,"node fan : fanin = %d fanout = %ld\n",
2464 nbinx,nboutx) ;
2465 if((nbpathin != cmpt->NBPATH) || (nbpathout != cmpt->NBPATH))
2466 fprintf(file,"ERROR PATH : nbpathin = %d nbpathout = %ld nbpath = %ld\n",
2467 nbpathin,nbpathout,cmpt->NBPATH) ;
2468 if((nbin != cmpt->NBIN) || (nboutmax > cmpt->NBOUT))
2469 fprintf(file,"ERROR IN : nbin = %d nbcmptin = %ld nboutmax = %ld\n" ,
2470 nbin,cmpt->NBIN,nbpathout) ;
2471 if((nbout != cmpt->NBOUT) || (nbinmax > cmpt->NBIN))
2472 fprintf(file,"ERROR OUT : nbout = %d nbcmptout = %ld nbinmax = %ld \n",
2473 nbout,cmpt->NBOUT,nbinmax) ;
2474 }
2475 else fprintf(file,"nothing\n") ;
2476 fprintf(file,"\n") ;
2477 fflush(file) ;*/
2478 }
2479 }
2480 ttv_freeallcmpt() ;
2481 freechain(TTV_CMPT_SIGLIST) ;
2482 TTV_CMPT_SIGLIST = NULL ;
2483 }
2484 /* fprintf(file,"\nnb fact = %ld nb path = %ld\n",nbx,nbpath) ;*/
2485
2486 chainx = NULL ;
2487 chaini = NULL ;
2488 flag = 'N' ;
2489 ptsblocsav = NULL ;
2490
2491 if((nbx=ttvfig->NBESIG) != 0)
2492 {
2493 for(i = 0 ; i < ttvfig->NBESIG ; i++)
2494 {
2495 ptsig = *(ttvfig->ESIG + i) ;
2496 ptsig->NODE[0].TYPE &= ~(TTV_NODE_PFACT) ;
2497 ptsig->NODE[1].TYPE &= ~(TTV_NODE_PFACT) ;
2498 if(ttv_checkfactsig(ptsig) != 0)
2499 {
2500 flag = 'Y' ;
2501 chaini = addchain(chaini,ptsig) ;
2502 ptsig->TYPE |= TTV_SIG_I ;
2503 ptsig->TYPE &= ~(TTV_SIG_S) ;
2504 nbx-- ;
2505 }
2506 else
2507 {
2508 ptsig->TYPE &= ~(TTV_SIG_EXT) ;
2509 chainx = addchain(chainx,(void*)ptsig) ;
2510 }
2511 }
2512 if(flag == 'Y')
2513 {
2514 ttv_freereflist(ttvfig,ttvfig->ESIG,(long)0) ;
2515 ttvfig->ESIG = ttv_allocreflist(chainx,nbx) ;
2516 ttvfig->NBESIG = nbx ;
2517 }
2518 else
2519 freechain(chainx) ;
2520 chainx = NULL ;
2521 flag = 'N' ;
2522 }
2523
2524
2525 if((nbx = ttvfig->NBISIG) != 0)
2526 {
2527 ptsbloc = ttvfig->ISIG ;
2528 nbfree = (TTV_MAX_SBLOC - (ttvfig->NBISIG % TTV_MAX_SBLOC))
2529 % TTV_MAX_SBLOC ;
2530 nbend = ttvfig->NBISIG + nbfree ;
2531
2532 for(i = nbfree ; i < nbend ; i++)
2533 {
2534 j = i % TTV_MAX_SBLOC ;
2535 if((j == 0) && (i != 0)) ptsbloc = ptsbloc->NEXT ;
2536 ptsig = ptsbloc->SIG + j ;
2537 ptsig->NODE[0].TYPE &= ~(TTV_NODE_PFACT) ;
2538 ptsig->NODE[1].TYPE &= ~(TTV_NODE_PFACT) ;
2539 if(ttv_checkfactsig(ptsig) != 0)
2540 {
2541 ttvsig_list *ptsigx ;
2542
2543 flag = 'Y' ;
2544 ptsig->TYPE |= TTV_SIG_F ;
2545 chaini = ttv_addrefsig(ttvfig,ptsig->NAME,ptsig->NETNAME,ptsig->CAPA,TTV_SIG_I,chaini) ;
2546 ptsigx = (ttvsig_list *)chaini->DATA ;
2547 if((ptsig->TYPE & TTV_SIG_EXT) == TTV_SIG_EXT)
2548 {
2549 ptsigx->TYPE |= TTV_SIG_EXT ;
2550 ptsig->TYPE &= ~(TTV_SIG_EXT) ;
2551 }
2552 ptsigx->NODE[0].TYPE |= (ptsig->NODE[0].TYPE & TTV_NODE_IMAX) ;
2553 ptsigx->NODE[1].TYPE |= (ptsig->NODE[1].TYPE & TTV_NODE_IMAX) ;
2554 ptsigx->NODE[0].TYPE |= (ptsig->NODE[0].TYPE & TTV_NODE_IMIN) ;
2555 ptsigx->NODE[1].TYPE |= (ptsig->NODE[1].TYPE & TTV_NODE_IMIN) ;
2556 ptsigx->USER = ptsig->USER ;
2557 ptsigx->NODE[0].USER = ptsig->NODE[0].USER ;
2558 ptsigx->NODE[1].USER = ptsig->NODE[1].USER ;
2559 ptsigx->NODE[0].INLINE = ptsig->NODE[0].INLINE ;
2560 ptsigx->NODE[1].INLINE = ptsig->NODE[1].INLINE ;
2561 ptsigx->NODE[0].INPATH = ptsig->NODE[0].INPATH ;
2562 ptsigx->NODE[1].INPATH = ptsig->NODE[1].INPATH ;
2563 ptsig->USER = NULL ;
2564 ptsig->NODE[0].USER = NULL ;
2565 ptsig->NODE[1].USER = NULL ;
2566 ptsig->USER = addptype(ptsig->USER,TTV_SIG_NEW,(void*)ptsigx) ;
2567 chainx = addchain(chainx,ptsig) ;
2568 nbx-- ;
2569 }
2570 else
2571 {
2572 ptsig->TYPE &= ~(TTV_SIG_EXT) ;
2573 }
2574 }
2575
2576 if(flag == 'Y')
2577 {
2578 nbx = ttvfig->NBISIG - nbx ;
2579 ptsbloc = ttvfig->ISIG ;
2580 nbfree = (TTV_MAX_SBLOC - (ttvfig->NBISIG % TTV_MAX_SBLOC))
2581 % TTV_MAX_SBLOC ;
2582 nbend = ttvfig->NBISIG + nbfree ;
2583
2584 for(i = nbfree ; i < nbend ; i++)
2585 {
2586 j = i % TTV_MAX_SBLOC ;
2587 if((j == 0) && (i != 0)) ptsbloc = ptsbloc->NEXT ;
2588 ptsig = ptsbloc->SIG + j ;
2589 if((ptsig->TYPE & TTV_SIG_F) == TTV_SIG_F)
2590 ptsig->TYPE |= TTV_SIG_MARQUE ;
2591 nbx-- ;
2592 if(nbx == (long)0) break ;
2593 }
2594
2595 for(chain = chainx ; chain != NULL ; chain = chain->NEXT)
2596 {
2597 ttvsig_list *ptsigx ;
2598
2599 ttvfig->NBISIG -- ;
2600 ptsig = (ttvsig_list *)chain->DATA ;
2601 ptsigx = ttvfig->ISIG->SIG + nbfree ;
2602 if((ptsig->TYPE & TTV_SIG_MARQUE) == TTV_SIG_MARQUE)
2603 {
2604 ptsig->TYPE &= ~(TTV_SIG_MARQUE) ;
2605 continue ;
2606 }
2607 while((ptsigx->TYPE & TTV_SIG_F) == TTV_SIG_F)
2608 {
2609 nbfree++ ;
2610 if(nbfree == TTV_MAX_SBLOC)
2611 {
2612 ptsbloc = ttvfig->ISIG ;
2613 ttvfig->ISIG = ptsbloc->NEXT ;
2614 ptsbloc->NEXT = ptsblocsav ;
2615 ptsblocsav = ptsbloc ;
2616 nbfree = 0 ;
2617 }
2618 ptsigx = ttvfig->ISIG->SIG + nbfree ;
2619 }
2620 ptype = ptsig->USER ;
2621 ptsig->NAME = ptsigx->NAME ;
2622 ptsig->NETNAME = ptsigx->NETNAME ;
2623 ptsig->CAPA = ptsigx->CAPA ;
2624 ptsig->ROOT = ptsigx->ROOT ;
2625 ptsig->TYPE = ptsigx->TYPE ;
2626 ptsig->USER = ptsigx->USER ;
2627 ptsig->NODE[0].ROOT = ptsig ;
2628 ptsig->NODE[0].TYPE = ptsigx->NODE[0].TYPE ;
2629 ptsig->NODE[0].INLINE = ptsigx->NODE[0].INLINE ;
2630 ptsig->NODE[0].INPATH = ptsigx->NODE[0].INPATH ;
2631 ptsig->NODE[0].FIND = ptsigx->NODE[0].FIND ;
2632 ptsig->NODE[0].USER = ptsigx->NODE[0].USER ;
2633 ptsig->NODE[1].ROOT = ptsig ;
2634 ptsig->NODE[1].TYPE = ptsigx->NODE[1].TYPE ;
2635 ptsig->NODE[1].INLINE = ptsigx->NODE[1].INLINE ;
2636 ptsig->NODE[1].INPATH = ptsigx->NODE[1].INPATH ;
2637 ptsig->NODE[1].FIND = ptsigx->NODE[1].FIND ;
2638 ptsig->NODE[1].USER = ptsigx->NODE[1].USER ;
2639 ptype->NEXT = ptsig->USER ;
2640 ptsig->USER = ptype ;
2641 ptsigx->USER = NULL ;
2642 ptsigx->NODE[0].USER = NULL ;
2643 ptsigx->NODE[1].USER = NULL ;
2644 ptsigx->USER = addptype(ptsigx->USER,TTV_SIG_NEW,(void*)ptsig) ;
2645 chainx = addchain(chainx,(void*)ptsigx) ;
2646 nbfree++ ;
2647 if(nbfree == TTV_MAX_SBLOC)
2648 {
2649 ptsbloc = ttvfig->ISIG ;
2650 ttvfig->ISIG = ptsbloc->NEXT ;
2651 ptsbloc->NEXT = ptsblocsav ;
2652 ptsblocsav = ptsbloc ;
2653 nbfree = 0 ;
2654 }
2655 }
2656 flag = 'N' ;
2657 }
2658 if(ttvfig->ISIG != NULL)
2659 {
2660 ptsig = ttvfig->ISIG->SIG + nbfree ;
2661 while((ptsig->TYPE & TTV_SIG_F) == TTV_SIG_F)
2662 {
2663 nbfree++ ;
2664 if(nbfree == TTV_MAX_SBLOC)
2665 {
2666 ptsbloc = ttvfig->ISIG ;
2667 ttvfig->ISIG = ptsbloc->NEXT ;
2668 ptsbloc->NEXT = ptsblocsav ;
2669 ptsblocsav = ptsbloc ;
2670 nbfree = 0 ;
2671 }
2672 ptsig = ttvfig->ISIG->SIG + nbfree ;
2673 }
2674 }
2675 }
2676
2677 ptlbloc[2] = ttvfig->FBLOC ;
2678 ptlbloc[1] = ttvfig->EBLOC ;
2679 ptlbloc[0] = ttvfig->DBLOC ;
2680 for(i = 0 ; i < 3 ; i++)
2681 for( ; ptlbloc[i] != NULL ; ptlbloc[i] = ptlbloc[i]->NEXT)
2682 {
2683 for(j = 0 ; j < TTV_MAX_LBLOC ; j++)
2684 {
2685 ptline = ptlbloc[i]->LINE + j ;
2686 if((ptline->TYPE & TTV_LINE_FR) == TTV_LINE_FR)
2687 continue ;
2688 if((ptype = getptype(ptline->ROOT->ROOT->USER,TTV_SIG_NEW)) != NULL)
2689 {
2690 if((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
2691 ptline->ROOT = ((ttvsig_list*)ptype->DATA)->NODE+1 ;
2692 else
2693 ptline->ROOT = ((ttvsig_list*)ptype->DATA)->NODE ;
2694 }
2695 if((ptype = getptype(ptline->NODE->ROOT->USER,TTV_SIG_NEW)) != NULL)
2696 {
2697 if((ptline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
2698 ptline->NODE = ((ttvsig_list*)ptype->DATA)->NODE+1 ;
2699 else
2700 ptline->NODE = ((ttvsig_list*)ptype->DATA)->NODE ;
2701 }
2702 if((ptline->NODE->ROOT->TYPE & TTV_SIG_I) == TTV_SIG_I)
2703 {
2704 ptline->NODE->ROOT->TYPE |= TTV_SIG_MARQUE ;
2705 if((ptline->TYPE & TTV_LINE_D) == TTV_LINE_D)
2706 ptline->NODE->ROOT->TYPE |= TTV_SIG_EXT ;
2707 }
2708 if((ptline->ROOT->ROOT->TYPE & TTV_SIG_I) == TTV_SIG_I)
2709 {
2710 ptline->ROOT->ROOT->TYPE |= TTV_SIG_MARQUE ;
2711 if((ptline->TYPE & TTV_LINE_D) == TTV_LINE_D)
2712 ptline->ROOT->ROOT->TYPE |= TTV_SIG_EXT ;
2713 }
2714 }
2715 }
2716
2717 ptlbloc[2] = ttvfig->PBLOC ;
2718 ptlbloc[1] = ttvfig->JBLOC ;
2719 ptlbloc[0] = ttvfig->TBLOC ;
2720 for(i = 0 ; i < 3 ; i++)
2721 for( ; ptlbloc[i] != NULL ; ptlbloc[i] = ptlbloc[i]->NEXT)
2722 {
2723 for(j = 0 ; j < TTV_MAX_LBLOC ; j++)
2724 {
2725 ptline = ptlbloc[i]->LINE + j ;
2726 if((ptline->TYPE & TTV_LINE_FR) == TTV_LINE_FR)
2727 continue ;
2728 if((ptype = getptype(ptline->ROOT->ROOT->USER,TTV_SIG_NEW)) != NULL)
2729 {
2730 if((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
2731 ptline->ROOT = ((ttvsig_list*)ptype->DATA)->NODE+1 ;
2732 else
2733 ptline->ROOT = ((ttvsig_list*)ptype->DATA)->NODE ;
2734 }
2735 if((ptype = getptype(ptline->NODE->ROOT->USER,TTV_SIG_NEW)) != NULL)
2736 {
2737 if((ptline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
2738 ptline->NODE = ((ttvsig_list*)ptype->DATA)->NODE+1 ;
2739 else
2740 ptline->NODE = ((ttvsig_list*)ptype->DATA)->NODE ;
2741 }
2742 }
2743 }
2744
2745 for(chain = chainx ; chain != NULL ; chain = chain->NEXT)
2746 ((ttvsig_list *)chain->DATA)->USER =
2747 delptype(((ttvsig_list *)chain->DATA)->USER,TTV_SIG_NEW) ;
2748
2749 freechain(chainx) ;
2750 ttv_freesbloclist(ptsblocsav) ;
2751
2752 if(chaini != NULL) flag = 'Y' ;
2753 else flag = 'N' ;
2754 for(i = 0 ; i < ttvfig->NBEXTSIG + ttvfig->NBINTSIG ; i++)
2755 {
2756 ptsig = (i < ttvfig->NBEXTSIG) ? *(ttvfig->EXTSIG + i)
2757 : *(ttvfig->INTSIG + i - ttvfig->NBEXTSIG) ;
2758 if((i >= ttvfig->NBEXTSIG) && ((ptsig->TYPE & TTV_SIG_EXT) == TTV_SIG_EXT))
2759 {
2760 flag = 'Y' ;
2761 }
2762 ptsig->NODE[0].TYPE &= ~(TTV_NODE_PFACT) ;
2763 ptsig->NODE[1].TYPE &= ~(TTV_NODE_PFACT) ;
2764 if((ttv_checkfactsig(ptsig) != 0) || (ptsig->ROOT == ttvfig) ||
2765 ((ptsig->TYPE & TTV_SIG_MARQUE) == TTV_SIG_MARQUE))
2766 {
2767 ptsig->TYPE &= ~(TTV_SIG_MARQUE) ;
2768 chaini = addchain(chaini,ptsig) ;
2769 }
2770 else
2771 {
2772 ptsig->TYPE &= ~(TTV_SIG_EXT) ;
2773 flag = 'Y' ;
2774 }
2775 }
2776
2777 if(flag == 'Y')
2778 {
2779 ttv_freereflist(ttvfig,ttvfig->EXTSIG,(long)0) ;
2780 ttv_freereflist(ttvfig,ttvfig->INTSIG,(long)0) ;
2781 ttvfig->EXTSIG = NULL ;
2782 ttvfig->INTSIG = NULL ;
2783 ttvfig->NBEXTSIG = (long)0 ;
2784 ttvfig->NBINTSIG = (long)0 ;
2785 chain = chaini ;
2786 while(chain != NULL)
2787 {
2788 ptsig = (ttvsig_list *)chain->DATA ;
2789 chaini = chain->NEXT ;
2790 if((ptsig->TYPE & TTV_SIG_EXT) == TTV_SIG_EXT)
2791 {
2792 ptsig->TYPE &= ~(TTV_SIG_EXT) ;
2793 chain->NEXT = (chain_list *)ttvfig->EXTSIG ;
2794 ttvfig->EXTSIG = (ttvsig_list **)chain ;
2795 ttvfig->NBEXTSIG++ ;
2796 }
2797 else
2798 {
2799 chain->NEXT = (chain_list *)ttvfig->INTSIG ;
2800 ttvfig->INTSIG = (ttvsig_list **)chain ;
2801 ttvfig->NBINTSIG++ ;
2802 }
2803 chain = chaini ;
2804 }
2805 ttvfig->EXTSIG = ttv_allocreflist((chain_list *)ttvfig->EXTSIG,
2806 ttvfig->NBEXTSIG) ;
2807 ttvfig->INTSIG = ttv_allocreflist((chain_list *)ttvfig->INTSIG,
2808 ttvfig->NBINTSIG) ;
2809 }
2810 else
2811 freechain(chaini) ;
2812
2813 ttv_delsigtab(ttvfig) ;
2814 }