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_critic.c
1
2 /****************************************************************************/
3 /* */
4 /* Chaine de CAO & VLSI Alliance */
5 /* */
6 /* Produit : TTV Version 1 */
7 /* Fichier : ttv_critic.c */
8 /* */
9 /* (c) copyright 1995-1998 Laboratoire LIP6 equipe ASIM */
10 /* Tous droits reserves */
11 /* Support : e-mail alliance-support@asim.lip6.fr */
12 /* */
13 /* Auteur(s) : Karim DIOURY */
14 /* */
15 /****************************************************************************/
16 /* recherche des chemins critique dans une ttvfig */
17 /****************************************************************************/
18
19 #define SPEED_UP_ACCESS_ALL
20 //#define SPEED_UP_ACCESS_CRITIC //not done yet
21
22 #include "ttv.h"
23 #include "ttv_ssta.h"
24
25 // defines internes
26 #define SAVE_ALL_LATCH_TAG 1
27 #define SAVE_ALL_INPUT_TAG 2
28 #define SAVE_ALL_TAG (SAVE_ALL_LATCH_TAG|SAVE_ALL_INPUT_TAG)
29 // --------
30 #define TTV_LOW_RATIO 0.8
31 #define TTV_HIGH_RATIO 1.2
32 // --------
33 chain_list *TTV_FIFO_HEAD = NULL ;
34 chain_list *TTV_FIFO_UP = NULL ;
35 chain_list *TTV_FIFO_B = NULL ;
36 chain_list *TTV_FIFO_SAV = NULL ;
37 char TTV_FIFO_NUM = (char)0 ;
38 chain_list *TTV_CHAIN_CLOCK = NULL ;
39 static chain_list *TTV_CHAIN_FREE = NULL ;
40 static char TTV_FIND_ALLPATH = 'N' ;
41 static char TTV_FIND_BUILD = 'Y' ;
42 static long TTV_EXCLUDE_TYPE_START=0, TTV_EXCLUDE_TYPE_END=0;
43 static chain_list *MARKED_SIG_LIST=NULL;
44 chain_list *TTV_EXPLICIT_CLOCK_NODES=NULL, *TTV_EXPLICIT_START_NODES=NULL, *TTV_EXPLICIT_END_NODES=NULL;
45 int TTV_MARK_MODE=0, TTV_QUIET_MODE=1;
46 static int TTV_SEARCH_INFORMATIONS;
47 static chain_list *TTV_CHARAC_CRITIC_SLOPES_LIST=NULL, *TTV_CHARAC_CRITIC_CAPAS_LIST=NULL;
48 static chain_list *TTV_CHARAC_CRITIC_RESULT_DELAYS=NULL, *TTV_CHARAC_CRITIC_RESULT_SLOPES=NULL, *TTV_CHARAC_CRITIC_RESULT_ENERGY=NULL;
49 static ttvevent_list *TTV_SEARCH_FIRST_NODE;
50 static chain_list *TTV_CRITIC_PARA_SEARCH=NULL;
51
52 long TTV_MORE_SEARCH_OPTIONS=0;
53
54 #define TTV_SEARCH_STEP_IN_CLOCK_PATH 1
55 static long TTV_SEARCH_STEP=0;
56
57 void ttv_allocpathmodel_propagate (ttvfig_list *ttvfig, ttvfig_list *insfig, ttvevent_list *node, ttvevent_list *root, ttvpath_list *path, long type);
58
59 typedef struct
60 {
61 ttvpath_list *paths ;
62 ttvpath_list *before_paths ;
63 } LOCAL_SORT_INFO;
64
65 static LOCAL_SORT_INFO inner_sort_info, upper_sort_info;
66
67 void ttv_set_ttv_getpath_clock_list(chain_list *lst)
68 {
69 TTV_CHAIN_CLOCK=lst;
70 }
71
72 void ttv_reset_search_informations()
73 {
74 TTV_SEARCH_INFORMATIONS=0;
75 }
76
77 long ttv_get_search_informations()
78 {
79 return TTV_SEARCH_INFORMATIONS;
80 }
81
82 void ttv_search_mode(int set, long mask)
83 {
84 if (set)
85 TTV_MORE_SEARCH_OPTIONS|=mask;
86 else
87 TTV_MORE_SEARCH_OPTIONS&=~mask;
88 }
89
90 void ttv_activate_multi_cmd_critic_mode(int val)
91 {
92 if (val)
93 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_MULTIPLE_COMMAND_CRITIC_ACCESS;
94 else
95 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_MULTIPLE_COMMAND_CRITIC_ACCESS;
96 }
97
98 void ttv_activate_multi_end_cmd_critic_mode(int val)
99 {
100 if (val)
101 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_DIFF_ENDING_CRITIC_COMMAND;
102 else
103 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_DIFF_ENDING_CRITIC_COMMAND;
104 }
105
106 void ttv_activate_real_access_mode(int val)
107 {
108 if (val)
109 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_REAL_ACCESS;
110 else
111 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_REAL_ACCESS;
112 }
113
114 void ttv_activate_path_and_access_mode(int val)
115 {
116 if (val)
117 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_PATH_AND_ACCESS;
118 else
119 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_PATH_AND_ACCESS;
120 }
121
122 void ttv_activate_simple_critic(int val)
123 {
124 if (val)
125 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_SIMPLE_CRITIC;
126 else
127 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_SIMPLE_CRITIC;
128 }
129
130 void ttv_activate_search_charac_mode(chain_list *slopes_in, chain_list *capas_in)
131 {
132 TTV_CHARAC_CRITIC_SLOPES_LIST=slopes_in;
133 TTV_CHARAC_CRITIC_CAPAS_LIST=capas_in;
134 TTV_CHARAC_CRITIC_RESULT_DELAYS=NULL;
135 }
136
137 void ttv_retreive_search_charac_results(chain_list **delays, chain_list **slopes, chain_list **energy)
138 {
139 *delays=TTV_CHARAC_CRITIC_RESULT_DELAYS;
140 *slopes=TTV_CHARAC_CRITIC_RESULT_SLOPES;
141 *energy=TTV_CHARAC_CRITIC_RESULT_ENERGY;
142 TTV_CHARAC_CRITIC_SLOPES_LIST=NULL;
143 TTV_CHARAC_CRITIC_CAPAS_LIST=NULL;
144 TTV_CHARAC_CRITIC_RESULT_DELAYS=NULL;
145 }
146
147 /* fonction qui test L<O<=R en modulo */
148 static inline int greater_lowerequal(char L, char O, char R)
149 {
150 if (R>L) return L<O && O<=R;
151 return O>L || O<=R;
152 }
153
154 /* fonction qui test L>O>=R en modulo */
155 static inline int lower_greaterequal(char L, char O, char R)
156 {
157 if (R<L) return R<=O && O<L;
158 return O<L || O>=R;
159 }
160
161 void ttv_set_search_exclude_type(long typestart, long typeend, long *oldstart, long *oldend)
162 {
163 *oldstart=TTV_EXCLUDE_TYPE_START;
164 *oldend=TTV_EXCLUDE_TYPE_END;
165 if (typestart!=-1) TTV_EXCLUDE_TYPE_START=typestart;
166 if (typeend!=-1) TTV_EXCLUDE_TYPE_END=typeend;
167 }
168
169 static chain_list *namefromsig(ttvfig_list *tvf, chain_list *sigs)
170 {
171 chain_list *cl=NULL;
172 char buf[1024];
173 while (sigs!=NULL)
174 {
175 ttv_getsigname(tvf,buf,(ttvsig_list *)sigs->DATA);
176 cl=addchain(cl, namealloc(buf));
177 sigs=sigs->NEXT;
178 }
179 return cl;
180 }
181
182 int ttv_must_be_excluded(ttvsig_list *tvs, long excludeflag, int exclude_not_clockcommand)
183 {
184 if (exclude_not_clockcommand && (tvs->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q))==TTV_SIG_Q && getptype(tvs->USER, TTV_SIG_CLOCK)==NULL)
185 return 1;
186 if (excludeflag==0) return 0;
187 if ((tvs->TYPE & excludeflag)!=0)
188 {
189 if ((tvs->TYPE & TTV_SIG_L)==0) return 1;
190 excludeflag&=TTV_SIG_LL|TTV_SIG_LF|TTV_SIG_LR|TTV_SIG_LS|TTV_SIG_LSL;
191 excludeflag&=~TTV_SIG_LL;
192 if ((tvs->TYPE & excludeflag)!=0) return 1;
193 // cas de ttv_sig_l tout seul
194 if ((tvs->TYPE & TTV_SIG_LF)!=TTV_SIG_LF
195 && (tvs->TYPE & TTV_SIG_LR)!=TTV_SIG_LR
196 && (tvs->TYPE & TTV_SIG_LS)!=TTV_SIG_LS
197 && excludeflag==0) return 1;
198 }
199 return 0;
200 }
201
202 chain_list *ttv_apply_exclude_flag(chain_list *cl, long excludeflag, int exclude_not_clockcommand)
203 {
204 chain_list *newchain;
205 if (excludeflag==0 && exclude_not_clockcommand==0) return cl;
206 newchain=NULL;
207 while (cl!=NULL)
208 {
209 if (!ttv_must_be_excluded((ttvsig_list *)cl->DATA, excludeflag, exclude_not_clockcommand))
210 newchain=addchain(newchain, cl->DATA);
211 cl=delchain(cl, cl);
212 }
213 return newchain;
214 }
215
216 static chain_list *ttv_remove_connector_B(chain_list *cl)
217 {
218 chain_list *newchain;
219 ttvsig_list *tvs;
220 newchain=NULL;
221 while (cl!=NULL)
222 {
223 tvs=(ttvsig_list *)cl->DATA;
224 if ((tvs->TYPE & TTV_SIG_CB)!=TTV_SIG_CB ||
225 (tvs->TYPE & TTV_SIG_L)==TTV_SIG_L ||
226 (tvs->TYPE & TTV_SIG_R)==TTV_SIG_R)
227 newchain=addchain(newchain, cl->DATA);
228 cl=delchain(cl, cl);
229 }
230 return newchain;
231 }
232
233 static void ttv_clean_critic_para_nodes()
234 {
235 ttvevent_list *tve;
236 while (TTV_CRITIC_PARA_SEARCH!=NULL)
237 {
238 tve=(ttvevent_list *)TTV_CRITIC_PARA_SEARCH->DATA;
239 tve->USER=testanddelptype(tve->USER, TTV_NODE_CRITIC_PARA_INFO);
240 TTV_CRITIC_PARA_SEARCH=delchain(TTV_CRITIC_PARA_SEARCH, TTV_CRITIC_PARA_SEARCH);
241 }
242 }
243
244 /*****************************************************************************/
245 /* function ttv_getinittime() */
246 /* parametres : */
247 /* */
248 /* dit ce que doit faire la recherche pour un connecteur */
249 /*****************************************************************************/
250 long ttv_getinittime(ttvfig_list *ttvfig,ttvevent_list *event, char phaseevent, long type, char phasefilter, char *foundphase)
251 {
252 long time ;
253 int mode=0;
254
255 if (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_USE_DATA_START) mode|=1;
256 if (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_USE_CLOCK_START) mode|=2;
257
258 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
259 stb_getdelayedge(stb_getstbfig(ttvfig),event,phaseevent,&time,NULL, phasefilter, mode, foundphase, NULL) ;
260 else
261 stb_getdelayedge(stb_getstbfig(ttvfig),event,phaseevent,NULL,&time, phasefilter, mode, NULL, foundphase) ;
262
263 if(time == TTV_NOTIME)
264 return((long)0) ;
265
266 return(time) ;
267 }
268
269 //----- fonction pour les marquages en vue de detection des boucles ----------
270 inline int ttv_isbypassednode(ttvevent_list *ev)
271 {
272 if (ev->FIND==NULL || (ev->FIND->TYPE & TTV_FIND_BYPASS)==0) return 0;
273 return 1;
274 }
275
276 inline void ttv_bypassnode(ttvevent_list *ev)
277 {
278 ev->FIND->TYPE|=TTV_FIND_BYPASS;
279 }
280
281 inline void ttv_donotbypassnode(ttvevent_list *ev)
282 {
283 ev->FIND->TYPE&=~TTV_FIND_BYPASS;
284 }
285
286 static int ttv_check_node_on_path(ttvfig_list *ttvfig, ttvevent_list *root, ttvevent_list *node, long type, ttvevent_list *nodetofind)
287 {
288 ttvevent_list *nodex ;
289 ptype_list *ptype ;
290
291 nodex = node ;
292
293 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
294 {
295 if (nodex==nodetofind) return 1;
296 if((nodex->FIND->OUTLINE == NULL) &&
297 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
298 {
299 nodex = (ttvevent_list *)ptype->DATA ;
300 if (nodex==nodetofind) return 1;
301 }
302
303 while(nodex->FIND->OUTLINE != NULL)
304 {
305 nodex = nodex->FIND->OUTLINE->ROOT ;
306 if((nodex->FIND->OUTLINE == NULL) &&
307 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
308 {
309 if (nodex==nodetofind) return 1;
310 nodex = (ttvevent_list *)ptype->DATA ;
311 }
312 if(nodex == root) break ;
313 if (nodex==nodetofind) return 1;
314 }
315 }
316 else
317 {
318 if (nodex==nodetofind) return 1;
319 while(nodex->FIND->OUTLINE != NULL)
320 {
321 nodex = nodex->FIND->OUTLINE->NODE ;
322 if(nodex == root) break ;
323 if (nodex==nodetofind) return 1;
324 }
325 }
326
327 return 0 ;
328 }
329
330 /*****************************************************************************/
331 /* function ttv_transfertnodefindinfo() */
332 /* parametres : */
333 /* */
334 /* propagation de la recherche */
335 /*****************************************************************************/
336 #define ADDACCESS 1
337
338 #define THRU_FILTER_ACTIVE 1
339 //#define THRU_FILTER_NOCROSS 2
340
341 static int ttv_avoidmaxfilter(ttvevent_list *tve, int filter, char *newval)
342 {
343 int ret=0;
344 if ((TTV_IgnoreMaxFilter & 1)!=0 && (tve->ROOT->TYPE & TTV_SIG_L)!=0) ret=1;
345 if ((TTV_IgnoreMaxFilter & 2)!=0 && (tve->ROOT->TYPE & TTV_SIG_R)!=0) ret=1;
346 if ((TTV_IgnoreMaxFilter & 4)!=0 && filter) ret=1;
347 if (tve->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_NOFILTERMAX) ret=1;
348 if (ret==1) *newval|=TTV_FINDSTRUCT_FLAGS_NOFILTERMAX;
349 return ret;
350 }
351
352 static int ttv_ckgenerated(long min, long max, stbck *ck, long dir, char state)
353 {
354 long ckmin, ckmax;
355 if ((dir & TTV_NODE_UP)!=0)
356 {
357 ckmin=ck->SUPMIN, ckmax=ck->SUPMAX;
358 if (state=='d' && ck->SUPMAX<ck->SDNMAX) ckmin+=ck->PERIOD, ckmax+=ck->PERIOD;
359 }
360 else
361 {
362 ckmin=ck->SDNMIN, ckmax=ck->SDNMAX;
363 if (state=='u' && ck->SDNMAX<ck->SUPMAX) ckmin+=ck->PERIOD, ckmax+=ck->PERIOD;
364 }
365 if (max<ckmin || min>ckmax) return 0;
366 return 1;
367 }
368
369 static ttvfind_stb_stuff *ttv_getstb_stuff(ttvfind_stb_stuff *tss, int phase)
370 {
371 while (tss!=NULL && tss->PHASE!=phase) tss=tss->NEXT;
372 return tss;
373 }
374 inline int ttv_transfertnodefindinfo(ttvfig,node,root,line,delay,type)
375 ttvfig_list *ttvfig ;
376 ttvevent_list *root ;
377 ttvevent_list *node ;
378 ttvline_list *line ;
379 long delay ;
380 long type ;
381 {
382 ttvevent_list *cmd, *start, *end, *filterclock ;
383 stbfig_list *stbfig ;
384 stbck origedge;
385 long crossdelay=TTV_NOTIME, crossdelayend=TTV_NOTIME, mindelay, latchminslope, startmin, startmax, endmax, endmin;
386 long time, latchmaxclose, tmpl, move=0, cdelay=delay ;
387 char phase, filterstate, orgphase=TTV_NO_PHASE,cmdphase ;
388 int period_inc, onfilternode=0, filternocross=0;
389 char nofiltermax=0, forcedtransp=0, flag=0, aptss_flag;
390 long ideal_crossdelay=TTV_NOTIME, ideal_crossdelayend=TTV_NOTIME;
391 stbnode *n, *snode;
392 int ideal=0;
393 ttvfind_stb_stuff dummy[128], *activephase_tss, *newtss, *newtsslist;
394
395 stbfig = stb_getstbfig(ttvfig) ;
396 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
397 start=node, end=root;
398 else
399 {
400 start=root, end=node;
401 // if ((root->FIND->THRU_FILTER & THRU_FILTER_NOCROSS)!=0) return 0;
402 }
403
404 if ((root->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_LAST_CROSSED_IS_PRECH)!=0)
405 {
406 if (getptype(node->ROOT->USER, TTV_SIG_CLOCK)!=NULL) return 0;
407 flag|=TTV_FINDSTRUCT_FLAGS_LAST_CROSSED_IS_PRECH;
408 }
409
410 if ((stbfig!=NULL && (stbfig->FLAGS & STB_CLOCK_INFO_READY)!=0 && stb_has_filter_directive(end))
411 && ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DONT_FILTER_ENDING_NODE)==0 || TTV_SEARCH_FIRST_NODE!=end))
412 {
413 onfilternode=1;
414 }
415
416 if((root->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_FORCEDTRANSPARENCY)!= 0)
417 {
418 forcedtransp=TTV_FINDSTRUCT_FLAGS_FORCEDTRANSPARENCY;
419 if (node->FIND != NULL && ttv_check_node_on_path(ttvfig,TTV_SEARCH_FIRST_NODE,root,type,node)) return(0) ;
420 }
421
422 if(forcedtransp==0 && ((root->FIND->FLAGS & TTV_FINDSTRUCT_CROSS_ENABLED)!=0 || (root->FIND->THRU_FILTER & THRU_FILTER_ACTIVE)!=0 || onfilternode))
423 {
424 flag|=TTV_FINDSTRUCT_CROSS_ENABLED;
425 if(root->FIND!=NULL && node->FIND != NULL)
426 {
427 if((node->FIND->PERIODE < root->FIND->PERIODE) &&
428 ttv_check_node_on_path(ttvfig,TTV_SEARCH_FIRST_NODE,root,type,node)
429 )
430 return(0) ;
431 }
432
433 if ((root->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_MUSTBECLOCK)!=0)
434 {
435 if (stb_getstbnode(node)->CK==NULL) return 0;
436 else flag|=TTV_FINDSTRUCT_FLAGS_MUSTBECLOCK;
437 if ((root->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_ISIDEAL)!=0) cdelay=0, flag|=TTV_FINDSTRUCT_FLAGS_ISIDEAL;
438 }
439
440 period_inc=0;
441 newtsslist=NULL;
442 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
443 {
444 if ((line->TYPE & TTV_LINE_HZ)!=0) return 0;
445 snode=stb_getstbnode(node);
446 ttv_initfindstb(&dummy[0]);
447
448 for (phase=0; phase<stbfig->PHASENUMBER; phase++)
449 {
450 aptss_flag=0;
451 move=0;
452 stb_getdelayedge(stbfig,node,phase,&time,&mindelay, phase,0,NULL,NULL) ;
453 if (time!=TTV_NOTIME)
454 {
455 aptss_flag=0;
456 if((root->ROOT->TYPE & TTV_SIG_LL) == TTV_SIG_LL
457 || (root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
458 {
459 if ((root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
460 {
461 stb_geteventphase(stbfig, root,&cmdphase,NULL,NULL,1,1) ;
462 cmd=NULL;
463 }
464 else
465 {
466 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
467 cmd = ttv_getlinecmd(ttvfig,line,TTV_LINE_CMDMAX) ;
468 else
469 cmd = ttv_getlinecmd(ttvfig,line,TTV_LINE_CMDMIN) ;
470 if (cmd!=NULL)
471 cmdphase=stb_getstbnode(cmd)->CK->CKINDEX;
472 else
473 stb_geteventphase(stbfig, root,&cmdphase,NULL,NULL,1,1) ;
474 }
475 // stb_geteventphase(stbfig,node,&phase,NULL,NULL,0,1) ;
476 stb_getlatchslope(stbfig,root,cmd,NULL,&latchminslope,&latchmaxclose,NULL,NULL,ADDACCESS,phase, &move) ;
477
478 crossdelay = latchminslope - cdelay ;
479 crossdelayend = latchmaxclose - cdelay ;
480 ideal_crossdelay = latchminslope;
481 ideal_crossdelayend = latchmaxclose;
482 if ((activephase_tss=ttv_getstb_stuff(root->FIND->STB, cmdphase))==NULL)
483 activephase_tss=&dummy[0];
484 }
485 else if (onfilternode)
486 {
487 long tmptime;
488 stb_get_filter_directive_info(stbfig, end, phase, &startmin, &startmax, &endmax, &endmin, &filterstate, &move, &filterclock, &origedge);
489 if (root->FIND->ORGPHASE==TTV_NO_PHASE)
490 stb_get_directive_setup_slope(stbfig, stb_getstbnode(end), &orgphase, &tmptime, 1);
491 ideal_crossdelay=startmin;
492 ideal_crossdelayend=endmax;
493 if ((activephase_tss=ttv_getstb_stuff(root->FIND->STB, origedge.CTKCKINDEX))==NULL)
494 activephase_tss=&dummy[0];
495 if (activephase_tss->IDEAL_CROSSDELAY!=TTV_NOTIME)
496 {
497 if (ideal_crossdelay<activephase_tss->IDEAL_CROSSDELAY+move) ideal_crossdelay=activephase_tss->IDEAL_CROSSDELAY+move;
498 if (ideal_crossdelayend>activephase_tss->IDEAL_NOMORECROSSDELAY+move) ideal_crossdelayend=activephase_tss->IDEAL_NOMORECROSSDELAY+move;
499 }
500 if (activephase_tss->CROSSDELAY!=TTV_NOTIME)
501 {
502 if (startmin<activephase_tss->CROSSDELAY+move) startmin=activephase_tss->CROSSDELAY+move;
503 if (endmax>activephase_tss->NOMORECROSSDELAY+move) endmax=activephase_tss->NOMORECROSSDELAY+move;
504 }
505 crossdelay = startmin - cdelay ;
506 crossdelayend = endmax - cdelay ;
507 latchminslope=startmin;
508 latchmaxclose=endmax;
509 }
510 else
511 {
512 activephase_tss=ttv_getstb_stuff(root->FIND->STB, phase);
513 if (activephase_tss==NULL) continue;
514 crossdelay = activephase_tss->CROSSDELAY - cdelay ;
515 crossdelayend = activephase_tss->NOMORECROSSDELAY - cdelay ;
516 latchminslope=activephase_tss->CROSSDELAY;
517 latchmaxclose=activephase_tss->NOMORECROSSDELAY;
518 ideal_crossdelay=activephase_tss->IDEAL_CROSSDELAY;
519 ideal_crossdelayend=activephase_tss->IDEAL_NOMORECROSSDELAY;
520 }
521
522 if(time != TTV_NOTIME && (time < crossdelay || (!ttv_avoidmaxfilter(root, onfilternode,&nofiltermax) && mindelay>crossdelayend)))
523 {
524 if (onfilternode && (n=stb_getstbnode(node))->CK!=NULL)
525 {
526 if (n->CK->ORIGINAL_CLOCK!=NULL && getptype(n->CK->ORIGINAL_CLOCK->ROOT->USER, STB_IDEAL_CLOCK)!=NULL)
527 ideal=1, cdelay=0;
528 if (ttv_ckgenerated(mindelay+cdelay, time+cdelay, &origedge, root->TYPE, ' ')
529 && ((root->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_MUSTBECLOCK)!=0
530 || (!ideal && ttv_ckgenerated(crossdelay+cdelay-move, crossdelayend+cdelay-move, &origedge, root->TYPE, filterstate))
531 || (ideal && ttv_ckgenerated(ideal_crossdelay-move, ideal_crossdelayend-move, &origedge, root->TYPE, filterstate)))
532 )
533 {
534 if ((node->TYPE & TTV_NODE_UP)!=0) mindelay=n->CK->SUPMIN, time=n->CK->SUPMAX;
535 else mindelay=n->CK->SDNMIN, time=n->CK->SDNMAX;
536 crossdelay=mindelay;
537 crossdelayend=time;
538 ideal_crossdelay=mindelay;
539 ideal_crossdelayend=time;
540 latchminslope=crossdelay+cdelay;
541 latchmaxclose=crossdelayend+cdelay;
542 flag|=TTV_FINDSTRUCT_FLAGS_MUSTBECLOCK;
543 if (ideal) flag|=TTV_FINDSTRUCT_FLAGS_ISIDEAL;
544 move=0;
545 }
546 else
547 continue;
548 }
549 else continue;
550 }
551
552 // cas min : on cross un latch mais le delai min ne crosse pas
553 // on calcul un nouveau delai min qui cross
554 if((type & TTV_FIND_MIN) == TTV_FIND_MIN)
555 {
556 if((root->ROOT->TYPE & TTV_SIG_LL) == TTV_SIG_LL
557 || (root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R || onfilternode)
558 {
559 if (mindelay+cdelay<latchminslope) mindelay=latchminslope-cdelay;
560 }
561 else mindelay=activephase_tss->CROSSDELAY_MIN-cdelay;
562 }
563 else
564 {
565 if((root->ROOT->TYPE & TTV_SIG_LL) == TTV_SIG_LL
566 || (root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R || onfilternode)
567 {
568 if (time+cdelay>latchmaxclose && !ttv_avoidmaxfilter(root, onfilternode,&nofiltermax)) mindelay=latchmaxclose-cdelay;
569 else mindelay=time;
570 }
571 else mindelay=activephase_tss->CROSSDELAY_MIN-cdelay;
572 }
573
574 if((node->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L
575 || (node->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
576 {
577 // stb_geteventphase(stbfig,node,&phase,NULL,NULL,1,1) ;
578
579 if (!(activephase_tss->PHASE==phase && (stbfig!=NULL && stbfig->STABILITYMODE & STB_STABILITY_LT) !=0))
580 {
581 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
582 {
583 if(greater_lowerequal(activephase_tss->PHASE, root->FIND->ORGPHASE, phase))
584 period_inc=1 ;
585 }
586 else
587 {
588 if(lower_greaterequal(activephase_tss->PHASE, root->FIND->ORGPHASE, phase))
589 period_inc=1 ;
590 }
591 }
592 }
593
594 newtss=ttv_allocfindstb();
595 newtss->PERIOD_CHANGE=activephase_tss->PERIOD_CHANGE+move;
596 newtss->PHASE = phase ;
597 newtss->STARTPHASE = activephase_tss->STARTPHASE ; // don't care
598 newtss->FLAGS = aptss_flag ;
599 newtss->CROSSDELAY = crossdelay ;
600 newtss->NOMORECROSSDELAY = crossdelayend ;
601 newtss->IDEAL_CROSSDELAY = ideal_crossdelay ;
602 newtss->IDEAL_NOMORECROSSDELAY = ideal_crossdelayend ;
603 newtss->CROSSDELAY_MIN = mindelay ;
604 newtss->NEXT=newtsslist;
605 newtsslist=newtss;
606 }
607 }
608 }
609 else // ----------------DUAL ---------------
610 {
611 ttvfind_stb_stuff *activephase_tsslist;
612 if (root->FIND->OUTLINE!=NULL && (root->FIND->OUTLINE->TYPE & TTV_LINE_HZ)!=0) return 0;
613 if ((root->FIND->FLAGS & TTV_FINDSTRUCT_FLAGS_ISIDEAL)!=0) cdelay=0, flag|=TTV_FINDSTRUCT_FLAGS_ISIDEAL;
614
615 if (root->FIND->STB==NULL)
616 {
617 int i, j;
618 n=stb_getstbnode(TTV_SEARCH_FIRST_NODE);
619 for (i=0, j=0; i<stbfig->PHASENUMBER; i++)
620 {
621 stb_getdelayedge(stbfig,TTV_SEARCH_FIRST_NODE,i,&time,&mindelay, i,0,NULL,NULL) ;
622 if (time!=TTV_NOTIME)
623 {
624 ttv_initfindstb(&dummy[j]);
625 dummy[j].PHASE=dummy[j].STARTPHASE=i;
626 if (j>0) dummy[j-1].NEXT=&dummy[j];
627 j++;
628 }
629 }
630 if (j==0) activephase_tsslist=NULL;
631 else activephase_tsslist=&dummy[0];
632 }
633 else
634 activephase_tsslist=root->FIND->STB;
635
636 for (activephase_tss=activephase_tsslist; activephase_tss!=NULL; activephase_tss=activephase_tss->NEXT)
637 {
638 if (activephase_tss->FLAGS & TTV_TPS_FINDSTRUCT_THRU_FILTER_NOCROSS) continue;
639 aptss_flag=0;
640 phase=activephase_tss->PHASE;
641 if((node->ROOT->TYPE & TTV_SIG_LL) == TTV_SIG_LL
642 || (node->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
643 {
644 if (activephase_tss->CROSSDELAY!=TTV_NOTIME)
645 crossdelay=activephase_tss->CROSSDELAY, crossdelayend=activephase_tss->NOMORECROSSDELAY;
646 else
647 {
648 stb_getdelayedge(stbfig,TTV_SEARCH_FIRST_NODE,activephase_tss->STARTPHASE,&time,&mindelay, activephase_tss->STARTPHASE,0,NULL,NULL) ;
649 // if (phase==TTV_NO_PHASE) stb_geteventphase(stbfig,TTV_SEARCH_FIRST_NODE,&phase,NULL,NULL,1,1) ;
650 if (getptype(TTV_SEARCH_FIRST_NODE->ROOT->USER, STB_IDEAL_CLOCK)!=NULL) ideal=1, cdelay=0, flag|=TTV_FINDSTRUCT_FLAGS_ISIDEAL;
651 if (!ideal)
652 {
653 crossdelay=mindelay+root->FIND->DELAY;
654 crossdelayend=time+root->FIND->DELAY;
655 }
656 else
657 {
658 crossdelay=mindelay;
659 crossdelayend=time;
660 }
661 }
662
663 if ((node->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
664 {
665 stb_geteventphase(stbfig, node,&cmdphase,NULL,NULL,1,1) ;
666 cmd=NULL;
667 }
668 else
669 {
670 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
671 cmd = ttv_getlinecmd(ttvfig,line,TTV_LINE_CMDMAX) ;
672 else
673 cmd = ttv_getlinecmd(ttvfig,line,TTV_LINE_CMDMIN) ;
674 if (cmd!=NULL)
675 cmdphase=stb_getstbnode(cmd)->CK->CKINDEX;
676 else
677 stb_geteventphase(stbfig, node,&cmdphase,NULL,NULL,1,1) ;
678 }
679
680 stb_getlatchslope(stbfig,node,cmd,NULL,&time,&latchmaxclose,NULL,NULL,ADDACCESS,phase,&move) ;
681 // if (cmd!=NULL && (n=stb_getstbnode(cmd))!=NULL && n->CK!=NULL)
682 orgphase= cmdphase;
683 /* else
684 orgphase=phase;*/
685 crossdelay += cdelay ;
686 crossdelayend += cdelay;
687 if(crossdelayend<=time || (!ttv_avoidmaxfilter(root, onfilternode,&nofiltermax) && crossdelay>=latchmaxclose))
688 {
689 aptss_flag|=TTV_TPS_FINDSTRUCT_THRU_FILTER_NOCROSS;
690 //return(0) ;
691 }
692 tmpl=activephase_tss->CROSSDELAY_MIN;
693 if ((type & TTV_FIND_MIN) == TTV_FIND_MIN)
694 {
695 if (crossdelay<time)
696 {
697 if (tmpl==TTV_NOTIME)
698 tmpl=0;
699 tmpl+=time-crossdelay;
700 crossdelay=time;
701 }
702 }
703 else
704 {
705 if (crossdelayend>latchmaxclose && !ttv_avoidmaxfilter(root, onfilternode,&nofiltermax))
706 {
707 if (tmpl==TTV_NOTIME)
708 tmpl=0;
709 tmpl+=latchmaxclose-crossdelayend;
710 crossdelay=latchmaxclose;
711 }
712 }
713 mindelay=tmpl;
714 }
715 else if (onfilternode)
716 {
717 stb_get_filter_directive_info(stbfig, end, phase, &startmin, &startmax, &endmax, &endmin, &filterstate, &move, &filterclock, &origedge);
718 stb_get_directive_setup_slope(stbfig, stb_getstbnode(end), &orgphase, &time, 1);
719 if (activephase_tss->CROSSDELAY!=TTV_NOTIME)
720 crossdelay=activephase_tss->CROSSDELAY, crossdelayend=activephase_tss->NOMORECROSSDELAY;
721 else
722 {
723 stb_getdelayedge(stbfig,TTV_SEARCH_FIRST_NODE,activephase_tss->STARTPHASE,&time,&mindelay, activephase_tss->STARTPHASE,0,NULL,NULL) ;
724 if (getptype(TTV_SEARCH_FIRST_NODE->ROOT->USER, STB_IDEAL_CLOCK)!=NULL) ideal=1, cdelay=0, flag|=TTV_FINDSTRUCT_FLAGS_ISIDEAL;
725 if (!ideal)
726 {
727 crossdelay=mindelay+root->FIND->DELAY;
728 crossdelayend=time+root->FIND->DELAY;
729 }
730 else
731 {
732 crossdelay=mindelay;
733 crossdelayend=time;
734 }
735 }
736 crossdelay+=cdelay;
737 crossdelayend+=cdelay;
738 if(crossdelayend<startmin || (!ttv_avoidmaxfilter(root, onfilternode,&nofiltermax) && crossdelay>endmax))
739 {
740 if ((n=stb_getstbnode(root))->CK!=NULL && ttv_ckgenerated(crossdelay, crossdelayend, &origedge, node->TYPE, ' '))
741 {
742 flag|=TTV_FINDSTRUCT_FLAGS_MUSTBECLOCK;
743 startmin=crossdelay;
744 endmax=crossdelayend;
745 move=0;
746 }
747 else
748 {
749 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DONT_FILTER_ENDING_NODE)==0)
750 continue;
751 else
752 aptss_flag|=TTV_TPS_FINDSTRUCT_THRU_FILTER_NOCROSS;
753 }
754 }
755 tmpl=activephase_tss->CROSSDELAY_MIN;
756 if ((type & TTV_FIND_MIN) == TTV_FIND_MIN)
757 {
758 if (crossdelay<startmin)
759 {
760 if (tmpl==TTV_NOTIME)
761 tmpl=0;
762 tmpl+=startmin-crossdelay;
763 crossdelay=startmin;
764 }
765 }
766 else
767 {
768 if (crossdelayend>endmax && !ttv_avoidmaxfilter(root, onfilternode,&nofiltermax))
769 {
770 if (tmpl==TTV_NOTIME)
771 tmpl=0;
772 tmpl+=endmax-crossdelayend;
773 crossdelayend=endmax;
774 }
775 }
776 mindelay=tmpl;
777 }
778 else
779 {
780 orgphase=phase;
781 move=0;
782 mindelay=activephase_tss->CROSSDELAY_MIN;
783 if (activephase_tss->CROSSDELAY!=TTV_NOTIME)
784 crossdelay=activephase_tss->CROSSDELAY+cdelay, crossdelayend=activephase_tss->NOMORECROSSDELAY+cdelay;
785 }
786
787 if((node->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L
788 || (node->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
789 {
790 // stb_geteventphase(stbfig,node,&phase,NULL,NULL,1,1) ;
791
792 if (!(activephase_tss->PHASE==phase && (stbfig!=NULL && stbfig->STABILITYMODE & STB_STABILITY_LT) !=0))
793 {
794 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
795 {
796 if(greater_lowerequal(activephase_tss->PHASE, root->FIND->ORGPHASE, phase))
797 period_inc=1 ;
798 }
799 else
800 {
801 if(lower_greaterequal(activephase_tss->PHASE, root->FIND->ORGPHASE, phase))
802 period_inc=1 ;
803 }
804 }
805 }
806
807 newtss=ttv_allocfindstb();
808 newtss->PERIOD_CHANGE=activephase_tss->PERIOD_CHANGE+move;
809 newtss->PHASE = orgphase ;
810 newtss->STARTPHASE = activephase_tss->STARTPHASE ;
811 newtss->FLAGS = aptss_flag ;
812 newtss->CROSSDELAY = crossdelay - move ;
813 newtss->NOMORECROSSDELAY = crossdelayend - move;
814 newtss->IDEAL_CROSSDELAY = ideal_crossdelay ;
815 newtss->IDEAL_NOMORECROSSDELAY = ideal_crossdelayend ;
816 newtss->CROSSDELAY_MIN = mindelay ;
817 newtss->NEXT=newtsslist;
818 newtsslist=newtss;
819 }
820 }
821
822 if (newtsslist!=NULL)
823 {
824 ttv_fifopush(node) ;
825 node->FIND->DELAY = root->FIND->DELAY + delay ;
826 node->FIND->OUTLINE = line ;
827 node->FIND->PERIODE = root->FIND->PERIODE + period_inc;
828 node->FIND->THRU_FILTER=filternocross | (root->FIND->THRU_FILTER || onfilternode?THRU_FILTER_ACTIVE:0);
829 node->FIND->FLAGS|=flag|nofiltermax|forcedtransp;
830 node->FIND->ORGPHASE=orgphase!=TTV_NO_PHASE?orgphase:root->FIND->ORGPHASE;
831 ttv_freefindstblist(node->FIND->STB);
832 node->FIND->STB=newtsslist;
833 }
834 else
835 return 0;
836 }
837 else
838 {
839 ttv_fifopush(node) ;
840 node->FIND->DELAY = root->FIND->DELAY + delay ;
841 node->FIND->OUTLINE = line ;
842 node->FIND->FLAGS|=flag|forcedtransp;
843 ttv_freefindstblist(node->FIND->STB);
844 node->FIND->STB=NULL;
845 }
846
847
848 return(1) ;
849 }
850
851 static ttvevent_list *ttv_findlatchcommand_notdual(ttvevent_list *root, ttvevent_list *node)
852 {
853 ttvevent_list *nodex ;
854 ptype_list *ptype ;
855
856 nodex = node ;
857
858 if((nodex->FIND->OUTLINE == NULL) &&
859 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL)) return nodex;
860
861 while(nodex->FIND->OUTLINE != NULL)
862 {
863 node=nodex;
864 nodex = nodex->FIND->OUTLINE->ROOT ;
865 if((nodex->FIND->OUTLINE == NULL) &&
866 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL)) return nodex;
867
868 if((nodex->ROOT->TYPE & TTV_SIG_L)!=0) return node;
869 if (nodex == root || (nodex->ROOT->TYPE & TTV_SIG_R)!=0) return nodex;
870 }
871
872 return NULL;
873 }
874
875 /*****************************************************************************/
876 /* function ttv_connectorsearchtype() */
877 /* parametres : */
878 /* ttvfig : figure principale */
879 /* ptsig : latch d'erreur */
880 /* type : type de recheche */
881 /* */
882 /* dit ce que doit faire la recherche pour un connecteur */
883 /*****************************************************************************/
884 inline long ttv_connectorsearchtype(ttvfig,node,type)
885 ttvfig_list *ttvfig ;
886 ttvevent_list *node ;
887 long type ;
888 {
889 long res = (long)0 ;
890
891 switch(node->ROOT->TYPE & TTV_SIG_TYPECON)
892 {
893 case TTV_SIG_CI :
894 res = ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) ?
895 TTV_SIG_BEGINSEARCH : TTV_SIG_ENDSEARCH ;
896 res |= TTV_SIG_BEGINPATH ;
897 break ;
898 case TTV_SIG_CO :
899 case TTV_SIG_CZ :
900 res = ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) ?
901 TTV_SIG_ENDSEARCH : TTV_SIG_BEGINSEARCH ;
902 res |= TTV_SIG_ENDPATH ;
903 break ;
904 case TTV_SIG_CB :
905 res = ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) ?
906 TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
907 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH :
908 TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
909 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH;
910 if(ttv_islocononlyend(ttvfig,node,type) == 0)
911 res |= TTV_SIG_CROSS ;
912 break ;
913 case TTV_SIG_CT :
914 res = TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
915 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH ;
916 if(ttv_islocononlyend(ttvfig,node,type) == 0)
917 res |= TTV_SIG_CROSS ;
918 break ;
919 case TTV_SIG_CX : ;
920 break ;
921 }
922
923 return(res) ;
924 }
925
926 /*****************************************************************************/
927 /* function ttv_signalsearchtype() */
928 /* parametres : */
929 /* ttvfig : figure principale */
930 /* ptsig : latch d'erreur */
931 /* type : type de recheche */
932 /* */
933 /* dit ce que doit faire la recherche pour un signal donnee */
934 /*****************************************************************************/
935 inline long ttv_signalsearchtype(ttvfig,node,type)
936 ttvfig_list *ttvfig ;
937 ttvevent_list *node ;
938 long type ;
939 {
940 long res = (long)0 ;
941
942 switch(node->ROOT->TYPE & TTV_SIG_TYPEALL)
943 {
944 case TTV_SIG_C :
945 res = ttv_connectorsearchtype(ttvfig,node,type) ;
946 break ;
947 case TTV_SIG_CQ :
948 res = ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) ?
949 (TTV_SIG_ENDSEARCH|TTV_SIG_CROSS|TTV_SIG_ENDPATH) :
950 (TTV_SIG_CROSS|TTV_SIG_BEGINSEARCH|TTV_SIG_ENDPATH) ;
951 res |= ttv_connectorsearchtype(ttvfig,node,type) ;
952 break ;
953 case TTV_SIG_N :
954 res = TTV_SIG_CROSS ;
955 break ;
956 case TTV_SIG_NQ :
957 res = ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) ?
958 (TTV_SIG_ENDSEARCH|TTV_SIG_CROSS|TTV_SIG_ENDPATH) :
959 (TTV_SIG_CROSS|TTV_SIG_BEGINSEARCH|TTV_SIG_ENDPATH) ;
960 break ;
961 case (TTV_SIG_C|TTV_SIG_B) :
962 case (TTV_SIG_N|TTV_SIG_B) :
963 res = TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
964 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH ;
965 if((type & TTV_FIND_HIER) != TTV_FIND_HIER)
966 res |= TTV_SIG_CROSS ;
967 break ;
968 case TTV_SIG_Q :
969 res = ((type & (TTV_FIND_DUAL|TTV_FIND_CMD))!=0) ?
970 (TTV_SIG_ENDSEARCH|TTV_SIG_CROSS|TTV_SIG_ENDPATH) :
971 (TTV_SIG_CROSS|TTV_SIG_BEGINSEARCH|TTV_SIG_ENDPATH) ;
972 break ;
973 case TTV_SIG_L :
974 case TTV_SIG_R :
975 case TTV_SIG_CL :
976 case TTV_SIG_CR :
977 case TTV_SIG_NL :
978 case TTV_SIG_NR :
979 res = TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
980 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH ;
981 if(ttv_iscrosslatch(ttvfig,node,type) == 1)
982 res |= TTV_SIG_CROSS ;
983 break ;
984 case TTV_SIG_B :
985 res = TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
986 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH|TTV_SIG_CROSS ;
987 break ;
988 case TTV_SIG_I :
989 res = TTV_SIG_CROSS ;
990 case TTV_SIG_S :
991 res = TTV_SIG_CROSS ;
992 break ;
993 }
994 if((node->TYPE & TTV_NODE_STOP) == TTV_NODE_STOP
995 && (node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_L | TTV_SIG_R | TTV_SIG_B))==0)
996 res|=TTV_SIG_BEGINSEARCH|TTV_SIG_ENDSEARCH|
997 TTV_SIG_BEGINPATH|TTV_SIG_ENDPATH;
998
999
1000 return(res) ;
1001 }
1002
1003 /*****************************************************************************/
1004 /* function ttv_getnodeslope() */
1005 /* parametres : */
1006 /* ttvfig : figure principale */
1007 /* ptsig : latch d'erreur */
1008 /* type : type de recheche */
1009 /* */
1010 /* recherche le front d'entree d'yun chemin */
1011 /*****************************************************************************/
1012 long ttv_getnodeslope(ttvfig,ttvins,node,sloperef,type)
1013 ttvfig_list *ttvfig ;
1014 ttvfig_list *ttvins ;
1015 ttvevent_list *node ;
1016 long *sloperef ;
1017 long type ;
1018 {
1019 ttvline_list *line ;
1020 long slope = TTV_NOSLOPE ;
1021 long slopex ;
1022
1023 *sloperef = TTV_NOSLOPE ;
1024
1025 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1 && TTV_PROPAGATE_FORCED_SLOPE!=TTV_NOTIME)
1026 {
1027 *sloperef=TTV_PROPAGATE_FORCED_SLOPE;
1028 return *sloperef;
1029 }
1030
1031 if(((node->ROOT->TYPE & TTV_SIG_CI) == TTV_SIG_CI) &&
1032 ((node->ROOT->TYPE & TTV_SIG_CB) != TTV_SIG_CB))
1033 {
1034 *sloperef = (long)ttv_getnodeslew(node,type);
1035 return *sloperef ;
1036 }
1037 else
1038 {
1039 if(ttvins == NULL)
1040 ttvins = node->ROOT->ROOT ;
1041 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
1042 {
1043 ttv_expfigsig(ttvfig,node->ROOT,ttvins->INFO->LEVEL,ttvfig->INFO->LEVEL,
1044 TTV_STS_CL_PJT, TTV_FILE_TTX);
1045 line = node->INPATH;
1046 }
1047 else
1048 {
1049 ttv_expfigsig(ttvfig,node->ROOT,ttvins->INFO->LEVEL,ttvfig->INFO->LEVEL,
1050 TTV_STS_CLS_FED, TTV_FILE_DTX);
1051 line = node->INLINE;
1052 }
1053 for(; line; line = line->NEXT)
1054 {
1055 if((((line->TYPE & TTV_LINE_CONT) == TTV_LINE_CONT) &&
1056 ((line->TYPE & TTV_LINE_A) != TTV_LINE_A)) ||
1057 (((line->TYPE & (TTV_LINE_D | TTV_LINE_T)) != 0) &&
1058 (line->FIG != ttvfig)) ||
1059 (((line->TYPE & (TTV_LINE_P | TTV_LINE_F)) != 0) &&
1060 (line->FIG->INFO->LEVEL < ttvins->INFO->LEVEL)))
1061 continue ;
1062 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1063 {
1064 slopex = ttv_getslopemax(line) ;
1065 if((slopex > slope) || (slope == TTV_NOSLOPE))
1066 slope = slopex ;
1067 slopex = line->FMAX ;
1068 if((slopex > *sloperef) || (*sloperef == TTV_NOSLOPE))
1069 *sloperef = slopex ;
1070 }
1071 else
1072 {
1073 slopex = ttv_getslopemin(line) ;
1074 if((slopex < slope) || (slope == TTV_NOSLOPE))
1075 slope = slopex ;
1076 slopex = line->FMIN ;
1077 if((slopex < *sloperef) || (*sloperef == TTV_NOSLOPE))
1078 *sloperef = slopex ;
1079 }
1080 }
1081 }
1082
1083 if (*sloperef == TTV_NOSLOPE && slope==TTV_NOSLOPE
1084 && ((node->ROOT->TYPE & TTV_SIG_B)!=0
1085 || (node->ROOT->TYPE & TTV_SIG_L)!=0
1086 || (node->ROOT->TYPE & TTV_SIG_R)!=0
1087 )
1088 )
1089 slope=*sloperef=ttvfig->INFO->SLOPE;
1090
1091 if(*sloperef == TTV_NOSLOPE)
1092 *sloperef = (long)0 ;
1093 return((slope == TTV_NOSLOPE) ? (long)0 : slope) ;
1094 }
1095
1096 static void ttv_uncachenodelines(ttvfig_list *ttvfig,ttvfig_list *ttvins,ttvevent_list *node,long type)
1097 {
1098 if(ttvins == NULL)
1099 ttvins = node->ROOT->ROOT ;
1100 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
1101 {
1102 ttv_expfigsig(ttvfig,node->ROOT,ttvins->INFO->LEVEL,ttvfig->INFO->LEVEL,
1103 TTV_STS_CL_PJT, TTV_FILE_TTX);
1104 }
1105 else
1106 {
1107 ttv_expfigsig(ttvfig,node->ROOT,ttvins->INFO->LEVEL,ttvfig->INFO->LEVEL,
1108 TTV_STS_CLS_FED, TTV_FILE_DTX);
1109 }
1110 }
1111
1112 /*****************************************************************************/
1113
1114 /* function ttv_islocononlyend() */
1115 /* parametres : */
1116 /* ttvfig : figure principale */
1117 /* ptsig : latch d'erreur */
1118 /* type : type de recheche */
1119 /* */
1120 /* dit si un connecteur ne doit pas être traversé */
1121 /*****************************************************************************/
1122 int ttv_islocononlyend(ttvfig,node,type)
1123 ttvfig_list *ttvfig ;
1124 ttvevent_list *node ;
1125 long type ;
1126 {
1127 if(((node->ROOT->TYPE & TTV_SIG_CT) != TTV_SIG_CT) ||
1128 ((node->TYPE & TTV_NODE_ONLYEND) != TTV_NODE_ONLYEND))
1129 return 0 ;
1130
1131 if(((node->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT) &&
1132 ((node->TYPE & TTV_NODE_ONLYEND) == TTV_NODE_ONLYEND))
1133 return 1 ;
1134
1135 return 0 ;
1136 #ifndef __ALL__WARNING_
1137 ttvfig = NULL;
1138 type = 0;
1139 #endif
1140 }
1141
1142 /*****************************************************************************/
1143 /* function ttv_islineonlyend() */
1144 /* parametres : */
1145 /* ttvfig : figure principale */
1146 /* ptsig : latch d'erreur */
1147 /* type : type de recheche */
1148 /* */
1149 /* dit si un connecteur ne doit pas être traversé */
1150 /*****************************************************************************/
1151 int ttv_islineonlyend(ttvfig,line,type)
1152 ttvfig_list *ttvfig ;
1153 ttvline_list *line ;
1154 long type ;
1155 {
1156 if(((line->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N) &&
1157 ((line->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N) &&
1158 ((line->NODE->TYPE & TTV_NODE_ONLYEND) == TTV_NODE_ONLYEND) &&
1159 ((line->ROOT->TYPE & TTV_NODE_ONLYEND) == TTV_NODE_ONLYEND))
1160 return 1 ;
1161 else
1162 return 0 ;
1163
1164 #ifndef __ALL__WARNING_
1165 ttvfig = NULL;
1166 type = 0;
1167 #endif
1168 }
1169
1170 /*****************************************************************************/
1171 /* function ttv_monolatcherror() */
1172 /* parametres : */
1173 /* ttvfig : figure principale */
1174 /* ptsig : latch d'erreur */
1175 /* */
1176 /* erreur d'une chaine entre un meme latch */
1177 /*****************************************************************************/
1178 void ttv_monolatcherror(ttvfig,ptsig)
1179 ttvfig_list *ttvfig ;
1180 ttvsig_list *ptsig ;
1181 {
1182 char message[1024] ;
1183 char name[1024] ;
1184
1185 sprintf(message,"%s for latch %s",ttvfig->INFO->FIGNAME,
1186 ttv_getsigname(ttvfig,name,ptsig)) ;
1187 ttv_error(30,message,TTV_WARNING) ;
1188 }
1189
1190 /*****************************************************************************/
1191 /* function ttv_addhtpath() */
1192 /* parametres : */
1193 /* */
1194 /* ajoute et recherche un chemin dans une table */
1195 /*****************************************************************************/
1196 void ttv_addhtpath(htab,node,root)
1197 ht **htab ;
1198 ttvevent_list *node ;
1199 ttvevent_list *root ;
1200 {
1201 unsigned long key ;
1202 unsigned long keyx ;
1203 ptype_list *ptype ;
1204 int size = (sizeof(void *)/2)*8 ;
1205
1206 key = (((unsigned long)root) << size) ;
1207 keyx = (((unsigned long)node) << size) ;
1208 keyx = (keyx >> size) ;
1209 key |= keyx ;
1210
1211 if(*htab == NULL)
1212 {
1213 *htab = addht(100) ;
1214 ptype = NULL ;
1215 }
1216 else if((ptype = ttv_gethtpath(*htab,node,root)) == NULL)
1217 {
1218 ptype = (ptype_list *)gethtitem(*htab,(void *)key) ;
1219 if(ptype == (ptype_list *)EMPTYHT)
1220 ptype = NULL ;
1221 }
1222
1223 ptype = addptype(ptype,(long)node,root) ;
1224 addhtitem(*htab,(void *)key,(long)ptype) ;
1225 }
1226
1227 /*****************************************************************************/
1228 /* function ttv_gethtpath() */
1229 /* parametres : */
1230 /* */
1231 /* recherche un chemin dans une table */
1232 /*****************************************************************************/
1233 ptype_list *ttv_gethtpath(htab,node,root)
1234 ht *htab ;
1235 ttvevent_list *node ;
1236 ttvevent_list *root ;
1237 {
1238 ptype_list *ptype ;
1239 unsigned long key ;
1240 unsigned long keyx ;
1241 int size = (sizeof(void *)/2)*8 ;
1242
1243 key = (((unsigned long)root) << size) ;
1244 keyx = (((unsigned long)node) << size) ;
1245 keyx = (keyx >> size) ;
1246 key |= keyx ;
1247
1248 if(htab == NULL)
1249 return(NULL) ;
1250
1251 ptype = (ptype_list *)gethtitem(htab,(void *)key) ;
1252
1253 if(ptype == (ptype_list *)EMPTYHT)
1254 return(NULL) ;
1255
1256 for(; ptype != NULL ; ptype = ptype->NEXT)
1257 {
1258 if((ptype->TYPE == (long)node) && (ptype->DATA == (void *)root))
1259 return(ptype) ;
1260 }
1261
1262 return(NULL) ;
1263 }
1264
1265 /*****************************************************************************/
1266 /* function ttv_delhtpath() */
1267 /* parametres : */
1268 /* */
1269 /* supprime une table de chemin */
1270 /*****************************************************************************/
1271 void ttv_delhtpath(htab)
1272 ht *htab ;
1273 {
1274 long nextitem ;
1275 void *nextkey ;
1276
1277 if(htab == NULL)
1278 return ;
1279
1280 scanhtkey( htab, 1, &nextkey, &nextitem ) ;
1281 while( nextitem != EMPTYHT ) {
1282 freeptype( (ptype_list *)nextitem ) ;
1283 scanhtkey( htab, 0, &nextkey, &nextitem ) ;
1284 }
1285
1286 delht(htab) ;
1287 }
1288
1289 /*****************************************************************************/
1290 /* function ttv_filterpathhz() */
1291 /* parametres : */
1292 /* path : liste de chemin */
1293 /* */
1294 /* enleve les chemin qui ne sont pas des hz */
1295 /*****************************************************************************/
1296 ttvpath_list *ttv_filterpathhz(path,nbpath,nb,lsi,type)
1297 ttvpath_list *path ;
1298 int *nbpath;
1299 int nb;
1300 LOCAL_SORT_INFO *lsi;
1301 long type;
1302 {
1303 ttvpath_list *ptpath, *limit=NULL;
1304 ttvpath_list *ptpathx ;
1305 ttvpath_list *ptpaths ;
1306 ttvevent_list *node ;
1307 ttvevent_list *root ;
1308 ttvsig_list *tvs;
1309 ht *htab = NULL ;
1310 int beforepath=1, sortall=0;
1311
1312 if (lsi!=NULL && *nbpath>nb)
1313 {
1314 if (lsi->before_paths!=NULL && lsi->before_paths!=(void *)1)
1315 limit=lsi->before_paths;
1316 else
1317 limit=lsi->paths;
1318 }
1319
1320 for(ptpath = path ; ptpath != NULL ; ptpath = ptpath->NEXT)
1321 {
1322 tvs=ptpath->ROOT->ROOT;
1323 if((ptpath->TYPE & TTV_FIND_HZ) == TTV_FIND_HZ)
1324 {
1325 if (getptype(tvs->USER, TTV_SIG_DONE_PTYPE)==NULL)
1326 tvs->USER=addptype(tvs->USER, TTV_SIG_DONE_PTYPE, NULL);
1327 }
1328 }
1329
1330 for(ptpath = path ; ptpath != NULL ; ptpath = ptpath->NEXT)
1331 {
1332 tvs=ptpath->ROOT->ROOT;
1333 if((ptpath->TYPE & TTV_FIND_HZ) != TTV_FIND_HZ
1334 && getptype(tvs->USER, TTV_SIG_DONE_PTYPE)!=NULL)
1335 ttv_addhtpath(&htab,ptpath->NODE,ptpath->ROOT) ;
1336 }
1337
1338 for(ptpath = path ; ptpath != NULL ; ptpath = ptpathx)
1339 {
1340 tvs=ptpath->ROOT->ROOT;
1341 tvs->USER=testanddelptype(tvs->USER, TTV_SIG_DONE_PTYPE);
1342
1343 ptpathx = ptpath->NEXT ;
1344 node = ptpath->NODE ;
1345 root = ((ptpath->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
1346 ? ptpath->ROOT->ROOT->NODE
1347 : ptpath->ROOT->ROOT->NODE +1 ;
1348
1349 if(((ptpath->TYPE & TTV_FIND_HZ) == TTV_FIND_HZ) &&
1350 ((path->ROOT->ROOT->TYPE & TTV_SIG_R) != TTV_SIG_R) &&
1351 (ttv_gethtpath(htab,node,root) != NULL))
1352 {
1353 if(ptpath == path)
1354 {
1355 path = path->NEXT ;
1356 }
1357 else
1358 {
1359 ptpaths->NEXT = ptpath->NEXT ;
1360 }
1361 ptpath->NEXT = NULL ;
1362 ttv_freepathlist(ptpath) ;
1363 if (nbpath!=NULL) (*nbpath)--;
1364 if (lsi!=NULL && beforepath==1) sortall=1;
1365 }
1366 else
1367 ptpaths = ptpath ;
1368 if (lsi!=NULL && lsi->paths==limit) beforepath=0;
1369 }
1370
1371 ttv_delhtpath(htab) ;
1372
1373 path = ttv_filterpath(path,type,nbpath) ;
1374
1375 if (sortall || (lsi!=NULL && *nbpath>nb))
1376 {
1377 int i;
1378 path = ttv_classpath(path,type) ;
1379
1380 for(ptpath=path, i=1; i<nb && ptpath != NULL ; ptpath = ptpath->NEXT , i++) ;
1381
1382 if(ptpath != NULL)
1383 {
1384 ttv_freepathlist(ptpath->NEXT) ;
1385 ptpath->NEXT = NULL ;
1386 path=(ttvpath_list *)reverse((chain_list *)path);
1387 *nbpath=nb;
1388 }
1389 else
1390 *nbpath=i-1;
1391 }
1392
1393 return(path) ;
1394 }
1395
1396 /*****************************************************************************/
1397 /* function ttv_filterpath() */
1398 /* parametres : */
1399 /* path : liste de chemin */
1400 /* type : type de chemin a filtrer */
1401 /* */
1402 /* enleve les chemin qui ne sont pas dans le masque des fronts */
1403 /*****************************************************************************/
1404 ttvpath_list *ttv_filterpath(path,type,nbpath)
1405 ttvpath_list *path ;
1406 long type ;
1407 int *nbpath;
1408 {
1409 ttvpath_list *patht ;
1410 ttvpath_list *pathtx ;
1411 ttvpath_list *pathts ;
1412 ttvpath_list *pathtss ;
1413
1414 patht = path ;
1415 pathts = NULL ;
1416 pathtss = NULL ;
1417 while(patht != NULL)
1418 {
1419 if((((patht->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
1420 ((patht->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
1421 ((type & TTV_FIND_NOT_UPUP) == TTV_FIND_NOT_UPUP)) ||
1422 (((patht->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
1423 ((patht->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
1424 ((type & TTV_FIND_NOT_UPDW) == TTV_FIND_NOT_UPDW)) ||
1425 (((patht->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
1426 ((patht->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
1427 ((type & TTV_FIND_NOT_DWUP) == TTV_FIND_NOT_DWUP)) ||
1428 (((patht->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
1429 ((patht->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
1430 ((type & TTV_FIND_NOT_DWDW) == TTV_FIND_NOT_DWDW)))
1431 {
1432 if(patht == path)
1433 {
1434 pathtx = path ;
1435 path = path->NEXT ;
1436 patht = path ;
1437 pathtx->NEXT = pathts ;
1438 pathts = pathtx ;
1439 }
1440 else
1441 {
1442 pathtx = patht ;
1443 pathtss->NEXT = patht->NEXT ;
1444 patht = patht->NEXT ;
1445 pathtx->NEXT = pathts ;
1446 pathts = pathtx ;
1447 }
1448 if (nbpath!=NULL) (*nbpath)--;
1449 }
1450 else
1451 {
1452 pathtss = patht ;
1453 patht = patht->NEXT ;
1454 }
1455 }
1456
1457 ttv_freepathlist(pathts) ;
1458 return(path) ;
1459 }
1460
1461 /*****************************************************************************/
1462 /* function ttv_pathcompar() */
1463 /* parametres : */
1464 /* path1 : premier chemin */
1465 /* path2 : deuxieme chemin */
1466 /* */
1467 /* compare deux chemin et retourne selon qsort */
1468 /*****************************************************************************/
1469 int ttv_pathcompar(path1,path2)
1470 ttvpath_list **path1 ;
1471 ttvpath_list **path2 ;
1472 {
1473 if((*path1)->DELAY < (*path2)->DELAY)
1474 return 1;
1475 else if((*path1)->DELAY > (*path2)->DELAY)
1476 return -1;
1477 else
1478 return 0;
1479 }
1480
1481 /*****************************************************************************/
1482 /* function ttv_classpath() */
1483 /* parametres : */
1484 /* path : liste des chemins a classer */
1485 /* type : type de classement croissant ou decroissant */
1486 /* */
1487 /* classe la liste des chemins dans l'ordre croissant suivant le type */
1488 /*****************************************************************************/
1489 ttvpath_list *ttv_classpath(path,type)
1490 ttvpath_list *path ;
1491 long type ;
1492 {
1493 ttvpath_list *pathx ;
1494 ttvpath_list **pattab ;
1495 long nbpath = 0 ;
1496 long nbpathx ;
1497
1498 if((path == NULL) || ((type & TTV_FIND_NOTCLASS) == TTV_FIND_NOTCLASS))
1499 return(path) ;
1500
1501 for(pathx = path ; pathx != NULL ; pathx = pathx->NEXT)
1502 nbpath++ ;
1503
1504 pattab = (ttvpath_list**)mbkalloc(nbpath * sizeof(ttvpath_list *)) ;
1505
1506 pathx = path ;
1507
1508 for(nbpathx = (long)0 ; nbpathx < nbpath ; nbpathx++)
1509 {
1510 *(pattab + nbpathx) = pathx ;
1511 pathx = pathx->NEXT ;
1512 }
1513
1514 qsort(pattab,nbpath,sizeof(ttvpath_list *),(int (*)(const void*,const void*))ttv_pathcompar) ;
1515
1516 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1517 path = *pattab ;
1518 else
1519 path = *(pattab + nbpath -1) ;
1520 pathx = path ;
1521
1522 for(nbpathx = (long)1 ; nbpathx < nbpath ; nbpathx++)
1523 {
1524 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1525 pathx->NEXT = *(pattab + nbpathx) ;
1526 else
1527 pathx->NEXT = *(pattab + (nbpath - nbpathx - 1)) ;
1528 pathx = pathx->NEXT ;
1529 }
1530
1531 pathx->NEXT = NULL ;
1532
1533 mbkfree(pattab) ;
1534
1535 return(path) ;
1536 }
1537
1538 /*****************************************************************************/
1539 /* function ttv_fifopush() */
1540 /* parametres : */
1541 /* node : noeud */
1542 /* */
1543 /* ajoute un noeud dans une fifo et le type TTV_FIND_INFIFO ne fait rien */
1544 /* si il est deja dans la fifo */
1545 /*****************************************************************************/
1546 void ttv_fifopush(node)
1547 ttvevent_list *node ;
1548 {
1549 if(node->FIND == NULL)
1550 {
1551 ttv_allocfind(node) ;
1552 node->FIND->FIFO = TTV_FIFO_NUM ;
1553 }
1554 else if(node->FIND->FIFO != TTV_FIFO_NUM)
1555 {
1556 ttv_allocfind(node) ;
1557 node->FIND->FIFO = TTV_FIFO_NUM ;
1558 }
1559
1560 if((node->FIND->TYPE & TTV_FIND_INFIFO) == TTV_FIND_INFIFO) return ;
1561
1562 node->FIND->TYPE |= TTV_FIND_INFIFO ;
1563
1564 if(TTV_FIFO_HEAD == NULL)
1565 {
1566 TTV_FIFO_HEAD = TTV_FIFO_UP = TTV_FIFO_B = addchain(TTV_FIFO_HEAD,node) ;
1567 }
1568 else if((TTV_FIFO_HEAD == TTV_FIFO_B) && (TTV_FIFO_HEAD->DATA == NULL))
1569 {
1570 TTV_FIFO_B->DATA = (void *)node ;
1571 }
1572 else
1573 {
1574 if(TTV_FIFO_B->NEXT != NULL)
1575 {
1576 TTV_FIFO_B = TTV_FIFO_B->NEXT ;
1577 TTV_FIFO_B->DATA = (void *)node ;
1578 }
1579 else
1580 {
1581 TTV_FIFO_B->NEXT = addchain(NULL,node) ;
1582 TTV_FIFO_B = TTV_FIFO_B->NEXT ;
1583 }
1584 }
1585 if(TTV_FIFO_UP == NULL) TTV_FIFO_UP = TTV_FIFO_B ;
1586 }
1587
1588 /*****************************************************************************/
1589 /* function ttv_fifopop() */
1590 /* renvoie le noeud dans la fifo */
1591 /*****************************************************************************/
1592 ttvevent_list *ttv_fifopop()
1593 {
1594 ttvevent_list *node ;
1595
1596 if(TTV_FIFO_UP == NULL) return((ttvevent_list *)NULL);
1597 node = (ttvevent_list *)TTV_FIFO_UP->DATA ;
1598 if(TTV_FIFO_UP == TTV_FIFO_B) TTV_FIFO_UP = NULL ;
1599 else TTV_FIFO_UP = TTV_FIFO_UP->NEXT ;
1600
1601 node->FIND->TYPE &= TTV_FIND_OUTFIFO ;
1602 return(node) ;
1603 }
1604
1605 /*****************************************************************************/
1606 /* function ttv_fifoclean() */
1607 /* initialise la fifo */
1608 /*****************************************************************************/
1609 void ttv_fifoclean()
1610 {
1611 chain_list *chain ;
1612 ttvevent_list *node ;
1613 ttvfind_list *find ;
1614
1615
1616 for(chain = TTV_FIFO_HEAD ; chain != TTV_FIFO_B ; chain = chain->NEXT)
1617 {
1618 node = (ttvevent_list *)chain->DATA ;
1619 if(node->FIND != NULL)
1620 if(node->FIND->FIFO == TTV_FIFO_NUM)
1621 {
1622 find = node->FIND ;
1623 node->FIND = node->FIND->NEXT ;
1624 find->NEXT = NULL ;
1625 ttv_freefindlist(find) ;
1626 }
1627 if((node->ROOT->TYPE & (TTV_SIG_Q|TTV_SIG_B|TTV_SIG_R)) != 0)
1628 {
1629 if(getptype(node->USER,TTV_NODE_LATCH) != NULL)
1630 node->USER = delptype(node->USER,TTV_NODE_LATCH) ;
1631 }
1632 chain->DATA = NULL ;
1633 }
1634
1635 if(chain == NULL)
1636 return ;
1637 else if(chain->DATA == NULL)
1638 return ;
1639
1640 node = (ttvevent_list *)chain->DATA ;
1641 if(node->FIND != NULL)
1642 if(node->FIND->FIFO == TTV_FIFO_NUM)
1643 {
1644 find = node->FIND ;
1645 node->FIND = node->FIND->NEXT ;
1646 find->NEXT = NULL ;
1647 ttv_freefindlist(find) ;
1648 }
1649 if((node->ROOT->TYPE & (TTV_SIG_Q|TTV_SIG_B|TTV_SIG_R)) != 0)
1650 {
1651 if(getptype(node->USER,TTV_NODE_LATCH) != NULL)
1652 node->USER = delptype(node->USER,TTV_NODE_LATCH) ;
1653 }
1654 chain->DATA = NULL ;
1655
1656 TTV_FIFO_B = TTV_FIFO_HEAD ;
1657 TTV_FIFO_UP = NULL ;
1658 }
1659
1660 /*****************************************************************************/
1661 /* function ttv_fifodelete() */
1662 /* detruit la fifo */
1663 /*****************************************************************************/
1664 void ttv_fifodelete()
1665 {
1666 ttv_fifoclean() ;
1667 freechain(TTV_FIFO_HEAD) ;
1668 TTV_FIFO_HEAD = NULL ;
1669 TTV_FIFO_UP = NULL ;
1670 TTV_FIFO_B = NULL ;
1671 }
1672
1673 /*****************************************************************************/
1674 /* function ttv_fifosave() */
1675 /* detruit la fifo */
1676 /*****************************************************************************/
1677 void ttv_fifosave()
1678 {
1679 TTV_FIFO_SAV = addchain(TTV_FIFO_SAV,TTV_FIFO_HEAD) ;
1680 TTV_FIFO_SAV = addchain(TTV_FIFO_SAV,TTV_FIFO_UP) ;
1681 TTV_FIFO_SAV = addchain(TTV_FIFO_SAV,TTV_FIFO_B) ;
1682 TTV_FIFO_HEAD = NULL ;
1683 TTV_FIFO_UP = NULL ;
1684 TTV_FIFO_B = NULL ;
1685 TTV_FIFO_NUM++ ;
1686 }
1687
1688 /*****************************************************************************/
1689 /* function ttv_fiforestore() */
1690 /* detruit la fifo */
1691 /*****************************************************************************/
1692 void ttv_fiforestore()
1693 {
1694 ttv_fifodelete() ;
1695 TTV_FIFO_B = (chain_list *)TTV_FIFO_SAV->DATA ;
1696 TTV_FIFO_SAV = delchain(TTV_FIFO_SAV,TTV_FIFO_SAV) ;
1697 TTV_FIFO_UP = (chain_list *)TTV_FIFO_SAV->DATA ;
1698 TTV_FIFO_SAV = delchain(TTV_FIFO_SAV,TTV_FIFO_SAV) ;
1699 TTV_FIFO_HEAD = (chain_list *)TTV_FIFO_SAV->DATA ;
1700 TTV_FIFO_SAV = delchain(TTV_FIFO_SAV,TTV_FIFO_SAV) ;
1701 TTV_FIFO_NUM-- ;
1702 }
1703
1704 /*****************************************************************************/
1705 /* function ttv_getlatchaccess() */
1706 /* parametres : */
1707 /* latch : latch de recherche */
1708 /* */
1709 /* recherche les commandes d'un latch pour les access */
1710 /*****************************************************************************/
1711 ptype_list *ttv_getlatchaccess_sub(ttvfig_list *ttvfig,ttvevent_list *latch,long type, int withdataonly)
1712 {
1713 ttvline_list *line ;
1714 ttvline_list *ptline ;
1715 ttvevent_list *event ;
1716 ptype_list *cmdlist = NULL ;
1717 ptype_list *ptype ;
1718 long delay ;
1719
1720
1721 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
1722 line = latch->INPATH ;
1723 else
1724 line = latch->INLINE ;
1725
1726 for(; line != NULL ; line = line->NEXT)
1727 {
1728 if(((line->TYPE & (TTV_LINE_D|TTV_LINE_T)) != 0) &&
1729 (line->FIG != ttvfig))
1730 continue ;
1731
1732 if((line->TYPE & TTV_LINE_A) == TTV_LINE_A)
1733 {
1734 if (withdataonly==0)
1735 {
1736 if((line->NODE->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
1737 {
1738 for(ptype = cmdlist ; ptype != NULL ; ptype = ptype->NEXT)
1739 {
1740 if(ptype->DATA == line->NODE)
1741 {
1742 if(ptype->TYPE != (long)0)
1743 {
1744 ptline = (ttvline_list *)ptype->TYPE ;
1745 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1746 {
1747 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 1))==TTV_NOTIME)
1748 delay = ttv_getdelaymax(ptline) ;
1749 }
1750 else
1751 {
1752 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 0))==TTV_NOTIME)
1753 delay = ttv_getdelaymin(ptline) ;
1754 }
1755 }
1756 else
1757 {
1758 ptline = NULL ;
1759 delay = (long)0 ;
1760 }
1761 if(((type & TTV_FIND_MAX) == TTV_FIND_MAX) &&
1762 ((delay < ttv_getdelaymax(line)) || (ptline == NULL)))
1763 {
1764 ptype->TYPE = (long)line ;
1765 }
1766 else if(((type & TTV_FIND_MIN) == TTV_FIND_MIN) &&
1767 ((delay < ttv_getdelaymin(line)) || (ptline == NULL)))
1768 {
1769 ptype->TYPE = (long)line ;
1770 }
1771 break ;
1772 }
1773 }
1774 }
1775 else
1776 {
1777 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1778 cmdlist = addptype(cmdlist,(long)line,line->NODE) ;
1779 else
1780 cmdlist = addptype(cmdlist,(long)line,line->NODE) ;
1781 line->NODE->TYPE |= TTV_NODE_MARQUE ;
1782 }
1783 }
1784 }
1785 else
1786 {
1787 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1788 event = ttv_getlinecmd(ttvfig,line,TTV_LINE_CMDMAX) ;
1789 else
1790 event = ttv_getlinecmd(ttvfig,line,TTV_LINE_CMDMIN) ;
1791 if(event != NULL)
1792 {
1793 if((event->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)
1794 {
1795 cmdlist = addptype(cmdlist,(long)0,event) ;
1796 event->TYPE |= TTV_NODE_MARQUE ;
1797 }
1798 }
1799 }
1800 }
1801
1802 for(ptype = cmdlist ; ptype != NULL ; ptype = ptype->NEXT)
1803 {
1804 ((ttvevent_list *)ptype->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
1805 }
1806
1807 return(cmdlist) ;
1808 }
1809 ptype_list *ttv_getlatchaccess(ttvfig_list *ttvfig,ttvevent_list *latch,long type)
1810 {
1811 return ttv_getlatchaccess_sub(ttvfig, latch, type, 0);
1812 }
1813 ptype_list *ttv_getlatchdatacommands(ttvfig_list *ttvfig,ttvevent_list *latch,long type)
1814 {
1815 return ttv_getlatchaccess_sub(ttvfig, latch, type, 1);
1816 }
1817
1818 ptype_list *ttv_getlatchasynccmd(ttvfig_list *ttvfig,ttvevent_list *latch,long type)
1819 {
1820 ttvline_list *line ;
1821 ttvline_list *ptline ;
1822 ttvevent_list *event ;
1823 ptype_list *cmdlist = NULL ;
1824 ptype_list *ptype ;
1825 long delay ;
1826
1827 if ((latch->ROOT->TYPE & TTV_SIG_L)==0) return NULL;
1828
1829 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
1830 line = latch->INPATH ;
1831 else
1832 line = latch->INLINE ;
1833
1834 for(; line != NULL ; line = line->NEXT)
1835 {
1836 if((line->TYPE & TTV_LINE_CONT) == 0)
1837 {
1838 if (ttv_getlinecmd(ttvfig,line,((type & TTV_FIND_MAX) == TTV_FIND_MAX)?TTV_LINE_CMDMAX:TTV_LINE_CMDMIN)==NULL)
1839 {
1840 cmdlist = addptype(cmdlist,(long)line,line->NODE) ;
1841 }
1842 }
1843 }
1844 return(cmdlist) ;
1845 }
1846
1847 /*****************************************************************************/
1848 /* function ttv_getcommandaccess() */
1849 /* parametres : */
1850 /* latch : latch de recherche */
1851 /* */
1852 /* recherche les commandes d'un latch pour les access */
1853 /*****************************************************************************/
1854 ptype_list *ttv_getcommandaccess(ttvfig,command,type)
1855 ttvfig_list *ttvfig ;
1856 ttvevent_list *command ;
1857 long type ;
1858 {
1859 ttvline_list *line ;
1860 ttvline_list *ptline ;
1861 ptype_list *latchlist = NULL ;
1862 ptype_list *ptype ;
1863 chain_list *chain ;
1864 long delay ;
1865
1866
1867 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
1868 ptype = getptype(command->USER,TTV_NODE_DUALPATH) ;
1869 else
1870 ptype = getptype(command->USER,TTV_NODE_DUALLINE) ;
1871
1872 if(ptype == NULL)
1873 return(NULL) ;
1874
1875 chain = (chain_list *)ptype->DATA ;
1876
1877 for(; chain != NULL ; chain = chain->NEXT)
1878 {
1879 line = (ttvline_list *)chain->DATA ;
1880
1881 if(((line->TYPE & (TTV_LINE_D|TTV_LINE_T)) != 0) &&
1882 (line->FIG != ttvfig))
1883 continue ;
1884
1885 if((line->TYPE & TTV_LINE_A) == TTV_LINE_A)
1886 {
1887 if((line->ROOT->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
1888 {
1889 for(ptype = latchlist ; ptype != NULL ; ptype = ptype->NEXT)
1890 {
1891 if(ptype->DATA == line->ROOT)
1892 {
1893 if(ptype->TYPE != (long)0)
1894 {
1895 ptline = (ttvline_list *)ptype->TYPE ;
1896 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1897 {
1898 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 1))==TTV_NOTIME)
1899 delay = ttv_getdelaymax(ptline) ;
1900 }
1901 else
1902 {
1903 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 0))==TTV_NOTIME)
1904 delay = ttv_getdelaymin(ptline) ;
1905 }
1906 }
1907 else
1908 {
1909 ptline = NULL ;
1910 delay = (long)0 ;
1911 }
1912 if(((type & TTV_FIND_MAX) == TTV_FIND_MAX) &&
1913 ((delay < ttv_getdelaymax(line)) || (ptline == NULL)))
1914 {
1915 ptype->TYPE = (long)line ;
1916 }
1917 else if(((type & TTV_FIND_MIN) == TTV_FIND_MIN) &&
1918 ((delay < ttv_getdelaymin(line)) || (ptline == NULL)))
1919 {
1920 ptype->TYPE = (long)line ;
1921 }
1922 break ;
1923 }
1924 }
1925 }
1926 else
1927 {
1928 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
1929 latchlist = addptype(latchlist,(long)line,line->ROOT) ;
1930 else
1931 latchlist = addptype(latchlist,(long)line,line->ROOT) ;
1932 line->ROOT->TYPE |= TTV_NODE_MARQUE ;
1933 }
1934 }
1935 }
1936
1937 for(ptype = latchlist ; ptype != NULL ; ptype = ptype->NEXT)
1938 {
1939 ((ttvevent_list *)ptype->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
1940 }
1941
1942 return(latchlist) ;
1943 }
1944
1945
1946 /*****************************************************************************/
1947 /* function ttv_findaccess() */
1948 /* parametres : */
1949 /* head : ttvfig pere */
1950 /* ttvfig : ttvfig courante */
1951 /* root : noeud sortie */
1952 /* cmd : noeud command */
1953 /* type : type de recherche */
1954 /* level : niveau de la recherche */
1955 /* */
1956 /* parcours en largeur pour retrouver les chemins finissant sur root */
1957 /* si level = 0 il faut chercher dans le niveau de ttvfig qui n'est pas la */
1958 /* figure pere */
1959 /* si level = ttvfig->LEVEL la recherche est au niveau de la figure pere */
1960 /* si level < ttvfig->LEVEL la recherche est entre level et le figure pere */
1961 /* si level > ttvfig->LEVEL la recherche est entre ttvfig et level sans la */
1962 /* figure pere */
1963 /*****************************************************************************/
1964 chain_list *ttv_findaccess(head,ttvfig,root,cmd,type,level)
1965 ttvfig_list *head ;
1966 ttvfig_list *ttvfig ;
1967 ttvevent_list *root ;
1968 ttvevent_list *cmd ;
1969 long type ;
1970 long level ;
1971 {
1972 chain_list *chainin ;
1973 chain_list *chainclock ;
1974
1975 chainclock = TTV_CHAIN_CLOCK ;
1976 TTV_CHAIN_CLOCK = NULL ;
1977 TTV_FIND_BUILD = 'N' ;
1978
1979 chainin = ttv_findpath(head,ttvfig,root,cmd,type,level) ;
1980
1981 TTV_CHAIN_CLOCK = chainclock ;
1982
1983 TTV_FIND_BUILD = 'Y' ;
1984
1985 return(chainin) ;
1986 }
1987
1988 //----- fonction de marquage des noeuds sur le chemin de donnees des access ---
1989 // action==0 => demarquer , action==1 => marquer
1990 void ttv_markdatapath(ttvevent_list *start, ttvevent_list *end, long type, int action)
1991 {
1992 ttvevent_list *nodex;
1993 if ((type & TTV_FIND_DUAL)!=TTV_FIND_DUAL)
1994 {
1995 nodex=start;
1996 if (action==0) ttv_donotbypassnode(nodex);
1997 else ttv_bypassnode(nodex);
1998 while(nodex->FIND->OUTLINE != NULL)
1999 {
2000 nodex = nodex->FIND->OUTLINE->ROOT ;
2001 if (action==0) ttv_donotbypassnode(nodex);
2002 else ttv_bypassnode(nodex);
2003 if(nodex == end) break ;
2004 }
2005 }
2006 else
2007 {
2008 nodex=end;
2009 if (action==0) ttv_donotbypassnode(nodex);
2010 else ttv_bypassnode(nodex);
2011 while(nodex->FIND->OUTLINE != NULL)
2012 {
2013 nodex = nodex->FIND->OUTLINE->NODE ;
2014 if (action==0) ttv_donotbypassnode(nodex);
2015 else ttv_bypassnode(nodex);
2016 if(nodex == end) break ;
2017 }
2018 }
2019 }
2020
2021 /*****************************************************************************/
2022 /* function ttv_findclockpath() */
2023 /* parametres : */
2024 /* head : ttvfig pere */
2025 /* ttvfig : ttvfig courante */
2026 /* root : noeud sortie */
2027 /* type : type de recherche */
2028 /* level : niveau de la recherche */
2029 /* */
2030 /* parcours en largeur pour retrouver les chemins finissant sur root */
2031 /* si level = 0 il faut chercher dans le niveau de ttvfig qui n'est pas la */
2032 /* figure pere */
2033 /* si level = ttvfig->LEVEL la recherche est au niveau de la figure pere */
2034 /* si level < ttvfig->LEVEL la recherche est entre level et le figure pere */
2035 /* si level > ttvfig->LEVEL la recherche est entre ttvfig et level sans la */
2036 /* figure pere */
2037 /*****************************************************************************/
2038 chain_list *ttv_findclockpath(ttvfig_list *head,ttvfig_list *ttvfig,ttvevent_list *root,ttvevent_list *end,long type,long level, ttvevent_list *thru_command)
2039 {
2040 chain_list *chainclock = NULL ;
2041 chain_list *chainnext ;
2042 chain_list *chainsav ;
2043 chain_list *chain ;
2044 ptype_list *cmdlist ;
2045 ptype_list *ptype ;
2046 ptype_list *ptypex ;
2047 ttvevent_list *event ;
2048 ttvevent_list *cmdevent ;
2049 ttvsig_list *ptsig ;
2050 ttvline_list *ptline ;
2051 long delay ;
2052 char find = 'N' ;
2053
2054 if(TTV_CHAIN_CLOCK == NULL)
2055 return(NULL) ;
2056
2057 if((((root->ROOT->TYPE & (TTV_SIG_L|TTV_SIG_B)) != 0) &&
2058 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)) ||
2059 (((root->ROOT->TYPE & (TTV_SIG_Q|TTV_SIG_B)) != 0) &&
2060 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)))
2061 {
2062
2063 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2064 cmdlist = ttv_getcommandaccess(ttvfig,root,type) ;
2065 else if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_ACCESS)!=0)
2066 cmdlist=ttv_getlatchasynccmd(ttvfig,root,type);
2067 else
2068 cmdlist = ttv_getlatchaccess(ttvfig,root,type) ;
2069
2070 if(cmdlist == NULL)
2071 return(NULL) ;
2072
2073 ttv_markdatapath(root, end, type, 1);
2074
2075 if(V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE!=0 || (type & TTV_FIND_DUAL) == TTV_FIND_DUAL || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_ACCESS)!=0)
2076 find = 'Y' ;
2077 else
2078 {
2079 if ((type & TTV_FIND_PATHDET)==TTV_FIND_PATHDET
2080 || (type & TTV_FIND_CRITIC)==TTV_FIND_CRITIC)
2081 find='Y';
2082 else
2083 {
2084 for(ptype = cmdlist ; ptype != NULL ; ptype = ptype->NEXT)
2085 {
2086 cmdevent = (ttvevent_list *)ptype->DATA ;
2087
2088 if (thru_command!=NULL && cmdevent!=thru_command) continue;
2089 if (ttv_isbypassednode(cmdevent)) continue;
2090
2091 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2092 stb_getstblatchaccess(stb_getstbfig(head),root,cmdevent,NULL,&delay,&event) ;
2093 else
2094 stb_getstblatchaccess(stb_getstbfig(head),root,cmdevent,&delay,NULL,&event) ;
2095
2096 if((delay <= (long)0) || (event == NULL) || ttv_canbeinfalsepath(cmdevent, 'o')|| ttv_canbeinfalsepath(end, 'o'))
2097 {
2098 find='Y';
2099 break;
2100 }
2101 }
2102 }
2103 }
2104
2105 for(ptype = cmdlist ; ptype != NULL ; ptype = ptype->NEXT)
2106 {
2107 cmdevent = (ttvevent_list *)ptype->DATA ;
2108
2109 if (thru_command!=NULL && cmdevent!=thru_command) continue;
2110 if (ttv_isbypassednode(cmdevent)) continue;
2111
2112 ttv_fifopush(cmdevent) ;
2113 if(ptype->TYPE != (long)0)
2114 {
2115 ptline = (ttvline_list *)ptype->TYPE ;
2116 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2117 {
2118 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE,1))==TTV_NOTIME)
2119 delay = ttv_getdelaymax(ptline) ;
2120 }
2121 else
2122 {
2123 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 0))==TTV_NOTIME)
2124 delay = ttv_getdelaymin(ptline) ;
2125 }
2126 }
2127 else
2128 {
2129 ptline = NULL ;
2130 delay = (long)0 ;
2131 }
2132 if((ptypex = getptype(cmdevent->USER,TTV_NODE_LATCH)) == NULL)
2133 {
2134 if(cmdevent->FIND->DELAY == TTV_NOTIME)
2135 {
2136 cmdevent->USER = addptype(cmdevent->USER,TTV_NODE_LATCH,root) ;
2137 cmdevent->FIND->DELAY = delay + root->FIND->DELAY ;
2138 cmdevent->FIND->OUTLINE = ptline ;
2139 }
2140 else
2141 {
2142 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2143 {
2144 if(cmdevent->FIND->DELAY < (delay + root->FIND->DELAY))
2145 {
2146 cmdevent->FIND->DELAY = delay + root->FIND->DELAY ;
2147 cmdevent->FIND->OUTLINE = ptline ;
2148 cmdevent->USER = addptype(cmdevent->USER,TTV_NODE_LATCH,root) ;
2149 }
2150 }
2151 else
2152 {
2153 if(cmdevent->FIND->DELAY > (delay + root->FIND->DELAY))
2154 {
2155 cmdevent->FIND->DELAY = delay + root->FIND->DELAY ;
2156 cmdevent->FIND->OUTLINE = ptline ;
2157 cmdevent->USER = addptype(cmdevent->USER,TTV_NODE_LATCH,root) ;
2158 }
2159 }
2160 }
2161 }
2162 else
2163 {
2164 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2165 {
2166 if(cmdevent->FIND->DELAY < (delay + root->FIND->DELAY))
2167 {
2168 cmdevent->FIND->DELAY = delay + root->FIND->DELAY ;
2169 cmdevent->FIND->OUTLINE = ptline ;
2170 ptypex->DATA = root ;
2171 }
2172 }
2173 else
2174 {
2175 if(cmdevent->FIND->DELAY > (delay + root->FIND->DELAY))
2176 {
2177 cmdevent->FIND->DELAY = delay + root->FIND->DELAY ;
2178 cmdevent->FIND->OUTLINE = ptline ;
2179 ptypex->DATA = root ;
2180 }
2181 }
2182 }
2183
2184 if (find=='Y') continue;
2185
2186 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2187 stb_getstblatchaccess(stb_getstbfig(head),root,cmdevent,NULL,&delay,&event) ;
2188 else
2189 stb_getstblatchaccess(stb_getstbfig(head),root,cmdevent,&delay,NULL,&event) ;
2190
2191 if((delay > (long)0) && (event != NULL))
2192 {
2193 ttv_fifopush(event) ;
2194 if((ptypex = getptype(event->USER,TTV_NODE_CLOCK)) == NULL)
2195 {
2196 chainclock = addchain(chainclock,(void *)event) ;
2197 if(event->FIND->DELAY == TTV_NOTIME)
2198 {
2199 event->USER = addptype(event->USER,TTV_NODE_CLOCK,cmdevent) ;
2200 event->FIND->DELAY = delay + cmdevent->FIND->DELAY ;
2201 event->FIND->OUTLINE = NULL ;
2202 }
2203 else
2204 {
2205 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2206 {
2207 if(event->FIND->DELAY < (delay + cmdevent->FIND->DELAY))
2208 {
2209 event->FIND->DELAY = delay + cmdevent->FIND->DELAY ;
2210 event->FIND->OUTLINE = NULL ;
2211 event->USER = addptype(event->USER,TTV_NODE_CLOCK,root) ;
2212 }
2213 }
2214 else
2215 {
2216 if(event->FIND->DELAY > (delay + cmdevent->FIND->DELAY))
2217 {
2218 event->FIND->DELAY = delay + cmdevent->FIND->DELAY ;
2219 event->FIND->OUTLINE = NULL ;
2220 event->USER = addptype(event->USER,TTV_NODE_CLOCK,root) ;
2221 }
2222 }
2223 }
2224 }
2225 else
2226 {
2227 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2228 {
2229 if(event->FIND->DELAY < (delay + cmdevent->FIND->DELAY))
2230 {
2231 event->FIND->DELAY = delay + cmdevent->FIND->DELAY ;
2232 event->FIND->OUTLINE = ptline ;
2233 ptypex->DATA = cmdevent ;
2234 }
2235 }
2236 else
2237 {
2238 if(event->FIND->DELAY > (delay + cmdevent->FIND->DELAY))
2239 {
2240 event->FIND->DELAY = delay + cmdevent->FIND->DELAY ;
2241 event->FIND->OUTLINE = ptline ;
2242 ptypex->DATA = cmdevent ;
2243 }
2244 }
2245 }
2246 }
2247 else
2248 {
2249 find = 'Y' ;
2250 }
2251 }
2252 freeptype(cmdlist) ;
2253 }
2254 else if((root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
2255 {
2256
2257 ttv_markdatapath(root, end, type, 1);
2258
2259 find='Y';
2260 ttv_fifopush(root) ;
2261 if((ptype = getptype(root->USER,TTV_NODE_LATCH)) == NULL)
2262 root->USER = addptype(root->USER,TTV_NODE_LATCH,root) ;
2263 else
2264 ptype->DATA = (void *)root ;
2265
2266 if(root->FIND->NEXT != NULL)
2267 {
2268 if(root->FIND->DELAY == TTV_NOTIME)
2269 {
2270 if(root->FIND->NEXT->DELAY != TTV_NOTIME)
2271 {
2272 root->FIND->DELAY = root->FIND->NEXT->DELAY ;
2273 root->FIND->OUTLINE = root->FIND->NEXT->OUTLINE ;
2274 }
2275 }
2276 }
2277 }
2278 else return(NULL) ;
2279
2280 if(find == 'Y')
2281 {
2282 TTV_SEARCH_STEP|=TTV_SEARCH_STEP_IN_CLOCK_PATH;
2283 chainclock = ttv_findpath(head,ttvfig,root,NULL,type & ~TTV_FIND_HZ,level) ;
2284 TTV_SEARCH_STEP&=~TTV_SEARCH_STEP_IN_CLOCK_PATH;
2285 }
2286
2287 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
2288 {
2289 for(chain = TTV_CHAIN_CLOCK ; chain != NULL ; chain = chain->NEXT)
2290 {
2291 ptsig = (ttvsig_list *)chain->DATA ;
2292 ptsig->NODE->TYPE |= TTV_NODE_MARQUE ;
2293 (ptsig->NODE+1)->TYPE |= TTV_NODE_MARQUE ;
2294 }
2295
2296 chainsav = NULL ;
2297 for(chain = chainclock ; chain != NULL ; chain = chainnext)
2298 {
2299 chainnext = chain->NEXT ;
2300 event = (ttvevent_list *)chain->DATA ;
2301 if((event->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)
2302 {
2303 event->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
2304 if(chainsav == NULL)
2305 {
2306 chainclock = chainnext ;
2307 chain->NEXT = NULL ;
2308 freechain(chain) ;
2309 event->USER=testanddelptype(event->USER,TTV_NODE_CLOCK);
2310 continue ;
2311 }
2312 else
2313 {
2314 chainsav->NEXT = chain->NEXT ;
2315 chain->NEXT = NULL ;
2316 freechain(chain) ;
2317 continue ;
2318 }
2319 }
2320 chainsav = chain ;
2321 }
2322
2323 for(chain = TTV_CHAIN_CLOCK ; chain != NULL ; chain = chain->NEXT)
2324 {
2325 ptsig = (ttvsig_list *)chain->DATA ;
2326 ptsig->NODE->TYPE &= ~(TTV_NODE_MARQUE) ;
2327 (ptsig->NODE+1)->TYPE &= ~(TTV_NODE_MARQUE) ;
2328 }
2329 }
2330
2331
2332 for(chain = TTV_CHAIN_FREE ; chain != NULL ; chain = chain->NEXT)
2333 ((ttvfig_list *)chain->DATA)->STATUS &= ~(TTV_STS_NOT_FREE) ;
2334
2335 freechain(TTV_CHAIN_FREE) ;
2336 TTV_CHAIN_FREE = NULL ;
2337
2338 ttv_markdatapath(root, end, type, 0);
2339
2340 return(chainclock) ;
2341 }
2342
2343 /*****************************************************************************/
2344 /* function ttv_iscrosslatch() */
2345 /* parametres : */
2346 /* ttvfig : figure principale */
2347 /* */
2348 /* doit-on traverser un latch */
2349 /*****************************************************************************/
2350 int ttv_iscrosslatch(ttvfig,latch,type)
2351 ttvfig_list *ttvfig ;
2352 ttvevent_list *latch ;
2353 long type ;
2354 {
2355 stbfig_list *stbfig ;
2356 long datamin ;
2357 long datamax ;
2358 char phase ;
2359 int maxpathpd=V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE;
2360 char flags=0;
2361
2362 if((((latch->ROOT->TYPE & TTV_SIG_LL) != TTV_SIG_LL) &&
2363 ((latch->ROOT->TYPE & TTV_SIG_R) != TTV_SIG_R)) ||
2364 (((type & TTV_FIND_HZ) == TTV_FIND_HZ) &&
2365 ((latch->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)))
2366 return(0) ;
2367
2368 if (TTV_MaxPathPeriodPrecharge!=0 && (latch->ROOT->TYPE & TTV_SIG_R) !=0)
2369 {
2370 maxpathpd=TTV_MaxPathPeriodPrecharge;
2371 flags=TTV_FINDSTRUCT_FLAGS_LAST_CROSSED_IS_PRECH;
2372 }
2373
2374 if (ttv_testsigflag(latch->ROOT, TTV_SIG_FLAGS_DONTCROSS))
2375 return 0;
2376
2377 if (ttv_testsigflag(latch->ROOT, TTV_SIG_FLAGS_TRANSPARENT))
2378 {
2379 latch->FIND->FLAGS|=TTV_FINDSTRUCT_FLAGS_FORCEDTRANSPARENCY;
2380 latch->FIND->FLAGS|=flags;
2381 return 1;
2382 }
2383
2384 if(latch->FIND->PERIODE >= maxpathpd)
2385 return(0) ;
2386
2387 if((stbfig = stb_getstbfig(ttvfig)) == NULL)
2388 return(0) ;
2389
2390 stb_geteventphase(stbfig,latch,&phase,NULL,NULL,1,1) ;
2391
2392 if(phase == STB_NO_INDEX)
2393 {
2394 latch->FIND->FLAGS|=flags;
2395 return(1) ;
2396 }
2397
2398 stb_getstbdelta(stbfig, latch, &datamin, &datamax, NULL);
2399
2400 if(datamax <= 0)
2401 {
2402 return(0) ;
2403 }
2404
2405 /* if(latch->FIND->ORGPHASE == TTV_NO_PHASE)
2406 {
2407 latch->FIND->ORGPHASE = phase ;
2408 }
2409 */
2410 // latch->FIND->PHASE = phase ;
2411 latch->FIND->FLAGS|=flags|TTV_FINDSTRUCT_CROSS_ENABLED;
2412
2413 return(1) ;
2414 }
2415
2416 /*****************************************************************************/
2417 /* function ttv_findpath() */
2418 /* parametres : */
2419 /* head : ttvfig pere */
2420 /* ttvfig : ttvfig courante */
2421 /* root : noeud sortie */
2422 /* cmd : noeud command */
2423 /* type : type de recherche */
2424 /* level : niveau de la recherche */
2425 /* */
2426 /* parcours en largeur pour retrouver les chemins finissant sur root */
2427 /* si level = 0 il faut chercher dans le niveau de ttvfig qui n'est pas la */
2428 /* figure pere */
2429 /* si level = ttvfig->LEVEL la recherche est au niveau de la figure pere */
2430 /* si level < ttvfig->LEVEL la recherche est entre level et le figure pere */
2431 /* si level > ttvfig->LEVEL la recherche est entre ttvfig et level sans la */
2432 /* figure pere */
2433 /*****************************************************************************/
2434 chain_list *ttv_findpath(head,ttvfig,root,cmd,type,level)
2435 ttvfig_list *head ;
2436 ttvfig_list *ttvfig ;
2437 ttvevent_list *root ;
2438 ttvevent_list *cmd ;
2439 long type ;
2440 long level ;
2441 {
2442 ttvfig_list *ttvfigx ;
2443 ttvfig_list *ttvfigp ;
2444 ttvevent_list *node ;
2445 ttvevent_list *nodex ;
2446 ttvevent_list *rootx ;
2447 ptype_list *ptype ;
2448 chain_list *in_gi = NULL ;
2449 chain_list *chain ;
2450 chain_list *chainnfree = NULL ;
2451 long status ;
2452 long filetype ;
2453 long delay ;
2454 char typesigroot = 'X' ;
2455
2456 ttv_ssta_set_checkloadedstore(head);
2457
2458 if(((root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
2459 ((root->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
2460 ((root->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
2461 typesigroot = 'R' ;
2462 if(((root->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
2463 ((root->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
2464 typesigroot = 'Z' ;
2465
2466 if((root->FIND == NULL) ||
2467 (root->FIND->DELAY == TTV_NOTIME) ||
2468 (TTV_CHAIN_CLOCK == NULL))
2469 {
2470 ttv_fifopush(root) ;
2471 root->FIND->DELAY = (long)0 ;
2472 }
2473
2474 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
2475 {
2476 status = TTV_STS_L_J ;
2477 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2478 status |= TTV_STS_DUAL_J ;
2479 filetype = TTV_FILE_TTX ;
2480 }
2481 else
2482 {
2483 status = TTV_STS_LS_E ;
2484 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2485 status |= TTV_STS_DUAL_E ;
2486 filetype = TTV_FILE_DTX ;
2487 }
2488
2489 if((ttvfig->INFO->LEVEL >= level) && (level != (long)0))
2490 {
2491 long statusx = status ;
2492
2493 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
2494 {
2495 statusx |= TTV_STS_CL_PJT ;
2496 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2497 statusx |= (TTV_STS_DUAL_T|TTV_STS_DUAL_P|TTV_STS_DUAL_J) ;
2498 }
2499 else
2500 {
2501 statusx |= TTV_STS_CLS_FED ;
2502 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2503 statusx |= (TTV_STS_DUAL_D|TTV_STS_DUAL_F|TTV_STS_DUAL_E) ;
2504 }
2505 if((ttvfig->STATUS & TTV_STS_NOT_FREE) != TTV_STS_NOT_FREE)
2506 {
2507 chainnfree = addchain(chainnfree,(void *)ttvfig) ;
2508 ttvfig->STATUS |= TTV_STS_NOT_FREE ;
2509 }
2510 ttv_parsttvfig(ttvfig,statusx,filetype) ;
2511 ttvfigp = ttvfig ;
2512 if(ttvfig->INFO->LEVEL > level)
2513 {
2514 ttvfig = root->ROOT->ROOT ;
2515 while(ttvfig != NULL)
2516 {
2517 if(ttvfig->INFO->LEVEL >= level) break ;
2518 ttvfig = ttvfig->ROOT ;
2519 }
2520 level = ttvfigp->INFO->LEVEL ;
2521 }
2522 }
2523 else
2524 {
2525 if(level == (long)0)
2526 {
2527 level = ttvfig->INFO->LEVEL ;
2528 }
2529 ttvfigp = NULL ;
2530 }
2531
2532 ttvfigx = root->ROOT->ROOT ;
2533 while(ttvfigx != NULL)
2534 {
2535 long statusx = status ;
2536 if(ttvfigx->INFO->LEVEL > level) break ;
2537 if(ttvfigx->INFO->LEVEL >= ttvfig->INFO->LEVEL)
2538 {
2539 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
2540 {
2541 statusx |= TTV_STS_P ;
2542 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2543 statusx |= TTV_STS_DUAL_P ;
2544 }
2545 else
2546 {
2547 statusx |= TTV_STS_F ;
2548 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2549 statusx |= TTV_STS_DUAL_F ;
2550 }
2551 }
2552 if((ttvfigx->STATUS & TTV_STS_NOT_FREE) != TTV_STS_NOT_FREE)
2553 {
2554 chainnfree = addchain(chainnfree,(void *)ttvfigx) ;
2555 ttvfigx->STATUS |= TTV_STS_NOT_FREE ;
2556 }
2557 ttv_parsttvfig(ttvfigx,statusx,filetype) ;
2558 ttvfigx = ttvfigx->ROOT ;
2559 }
2560
2561 while((node = ttv_fifopop()) != NULL)
2562 {
2563 ttvline_list *in ;
2564
2565 // if (TTV_MARK_MODE==TTV_MARK_MODE_USE && ??inf->CLOCK!=0?? && getptype(node->ROOT->USER, TTV_SIG_MARKED)==NULL) continue;
2566 if (((TTV_SEARCH_STEP & TTV_SEARCH_STEP_IN_CLOCK_PATH)!=0 || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MUST_BE_CLOCK)!=0) && ttv_testsigflag(node->ROOT, TTV_SIG_FLAGS_ISDATA)) continue;
2567
2568 if((node->TYPE & TTV_NODE_STOP) == TTV_NODE_STOP)
2569 {
2570 if(node != root &&
2571 (((type & (TTV_FIND_HIER|TTV_FIND_DUAL)) != 0 || (node->ROOT->TYPE & (TTV_SIG_CB|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B|TTV_SIG_Q)) != TTV_SIG_CB)
2572 && ((type & TTV_FIND_HIER) == TTV_FIND_HIER || ((node->ROOT->TYPE & (TTV_SIG_N|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B|TTV_SIG_Q)) != TTV_SIG_N || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ENABLE_STOP_ON_TTV_SIG_N)!=0))
2573 && ((node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_N | TTV_SIG_Q)) != TTV_SIG_Q || (type & (TTV_FIND_DUAL|TTV_FIND_CMD)) != 0)))
2574 {
2575 if((node->FIND->TYPE & TTV_FIND_BEGIN) != TTV_FIND_BEGIN)
2576 {
2577 in_gi = addchain(in_gi,(char *)node) ;
2578 node->FIND->TYPE |= TTV_FIND_BEGIN ;
2579 }
2580 if( ((((node->ROOT->TYPE & (TTV_SIG_CB|TTV_SIG_L|TTV_SIG_R)) != TTV_SIG_CB)
2581 && ((node->ROOT->TYPE & (TTV_SIG_CT|TTV_SIG_L|TTV_SIG_R)) != TTV_SIG_CT)
2582 && ((node->ROOT->TYPE & (TTV_SIG_N|TTV_SIG_L|TTV_SIG_R)) != TTV_SIG_N))
2583 ||
2584 ((type & TTV_FIND_HIER) == TTV_FIND_HIER)
2585 ||(ttv_islocononlyend(ttvfig,node,type) != 0))
2586 &&
2587 (((node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_N | TTV_SIG_Q)) != TTV_SIG_Q)
2588 || ((type & TTV_FIND_CMD) != TTV_FIND_CMD))
2589 //|| ((type & (TTV_FIND_DUAL|TTV_FIND_CMD)) != TTV_FIND_DUAL))
2590 && ((node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_N | TTV_SIG_B)) != TTV_SIG_B))
2591 if((TTV_CHAIN_CLOCK != NULL) || (TTV_FIND_BUILD == 'Y') ||
2592 (ttv_iscrosslatch(head,node,type) == 0))
2593 {
2594 if (!((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_CROSS_STOP_NODE_IF_NONSTOP)!=0 &&
2595 (node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_L | TTV_SIG_R | TTV_SIG_B))==0))
2596 continue ;
2597 }
2598 }
2599 }
2600
2601 if(((((node->ROOT->TYPE & TTV_SIG_BYPASSOUT) != TTV_SIG_BYPASSOUT) &&
2602 ((node->TYPE & TTV_NODE_BYPASSOUT) != TTV_NODE_BYPASSOUT)) ||
2603 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)) &&
2604 ((((node->ROOT->TYPE & TTV_SIG_BYPASSIN) != TTV_SIG_BYPASSIN) &&
2605 ((node->TYPE & TTV_NODE_BYPASSIN) != TTV_NODE_BYPASSIN)) ||
2606 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)))
2607 {
2608 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
2609 {
2610 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2611 {
2612 ptype = getptype(node->USER,TTV_NODE_DUALPATH) ;
2613 if(ptype == NULL) in = NULL ;
2614 else
2615 {
2616 chain = (chain_list *)ptype->DATA ;
2617 if(chain == NULL) in = NULL ;
2618 else in = (ttvline_list *)chain->DATA ;
2619 }
2620 }
2621 else in = node->INPATH ;
2622 }
2623 else
2624 {
2625 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2626 {
2627 ptype = getptype(node->USER,TTV_NODE_DUALLINE) ;
2628 if(ptype == NULL) in = NULL ;
2629 else
2630 {
2631 chain = (chain_list *)ptype->DATA ;
2632 if(chain == NULL) in = NULL ;
2633 else in = (ttvline_list *)chain->DATA ;
2634 }
2635 }
2636 else in = node->INLINE ;
2637 }
2638
2639 while(in != NULL)
2640 {
2641 if(((in->TYPE & TTV_LINE_CONT) == TTV_LINE_CONT) ||
2642 (((in->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
2643 ((in->TYPE & (TTV_LINE_D|TTV_LINE_T)) != 0) &&
2644 (ttv_islineonlyend(ttvfig,in,type) == 1)))
2645 {
2646 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2647 {
2648 chain = chain->NEXT ;
2649 if(chain == NULL) in = NULL ;
2650 else in = (ttvline_list *)chain->DATA ;
2651 continue ;
2652 }
2653 else
2654 {
2655 in = in->NEXT ;
2656 continue ;
2657 }
2658 }
2659 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2660 {
2661 nodex = in->ROOT ;
2662 rootx = in->NODE ;
2663 if(((in->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
2664 (node->FIND->OUTLINE != NULL))
2665 {
2666 if((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC)
2667 {
2668 chain = chain->NEXT ;
2669 if(chain == NULL) in = NULL ;
2670 else in = (ttvline_list *)chain->DATA ;
2671 continue ;
2672 }
2673 }
2674 if(((nodex->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
2675 ((nodex->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
2676 ((nodex->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
2677 {
2678 if((((in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ) &&
2679 ((type & TTV_FIND_HZ) != TTV_FIND_HZ)) ||
2680 (((in->TYPE & TTV_LINE_HZ) != TTV_LINE_HZ) &&
2681 ((type & TTV_FIND_HZ) == TTV_FIND_HZ)))
2682 {
2683 chain = chain->NEXT ;
2684 if(chain == NULL) in = NULL ;
2685 else in = (ttvline_list *)chain->DATA ;
2686 continue ;
2687 }
2688 }
2689 else if((in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ)
2690 {
2691 chain = chain->NEXT ;
2692 if(chain == NULL) in = NULL ;
2693 else in = (ttvline_list *)chain->DATA ;
2694 continue ;
2695 }
2696 if((cmd != NULL) && ((nodex->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L))
2697 {
2698 if(cmd != ttv_getlinecmd(head,in,((type & TTV_FIND_MAX) == TTV_FIND_MAX)?TTV_LINE_CMDMAX:TTV_LINE_CMDMIN))
2699 {
2700 chain = chain->NEXT ;
2701 if(chain == NULL) in = NULL ;
2702 else in = (ttvline_list *)chain->DATA ;
2703 continue ;
2704 }
2705 }
2706 if(((nodex->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
2707 ((nodex->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
2708 {
2709 if((((in->TYPE & TTV_LINE_R) == TTV_LINE_R) &&
2710 ((type & TTV_FIND_S) == TTV_FIND_S)) ||
2711 (((in->TYPE & TTV_LINE_S) == TTV_LINE_S) &&
2712 ((type & TTV_FIND_R) == TTV_FIND_R)))
2713 {
2714 chain = chain->NEXT ;
2715 if(chain == NULL) in = NULL ;
2716 else in = (ttvline_list *)chain->DATA ;
2717 continue ;
2718 }
2719 }
2720 }
2721 else
2722 {
2723 nodex = in->NODE ;
2724 rootx = in->ROOT ;
2725 if(((in->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
2726 (node->FIND->OUTLINE != NULL))
2727 {
2728 if((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC)
2729 {
2730 in = in->NEXT ;
2731 continue ;
2732 }
2733 }
2734 if((typesigroot == 'R') ||
2735 ((rootx->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
2736 ((rootx->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
2737 {
2738 if(((((in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ) &&
2739 ((type & TTV_FIND_HZ) != TTV_FIND_HZ)) ||
2740 (((in->TYPE & TTV_LINE_HZ) != TTV_LINE_HZ) &&
2741 ((type & TTV_FIND_HZ) == TTV_FIND_HZ))) &&
2742 ((rootx == root) ||
2743 ((rootx->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
2744 ((rootx->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT)))
2745 {
2746 in = in->NEXT ;
2747 continue ;
2748 }
2749 }
2750 else if((in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ)
2751 {
2752 in = in->NEXT ;
2753 continue ;
2754 }
2755 if((cmd != NULL || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_PATHS)!=0)
2756 && ((root->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L)
2757 && (rootx == root))
2758 {
2759 if(cmd != ttv_getlinecmd(head,in,((type & TTV_FIND_MAX) == TTV_FIND_MAX)?TTV_LINE_CMDMAX:TTV_LINE_CMDMIN))
2760 {
2761 in = in->NEXT ;
2762 continue ;
2763 }
2764 }
2765 if(typesigroot == 'Z')
2766 {
2767 if(((((in->TYPE & TTV_LINE_R) == TTV_LINE_R) &&
2768 ((type & TTV_FIND_S) == TTV_FIND_S)) ||
2769 (((in->TYPE & TTV_LINE_S) == TTV_LINE_S) &&
2770 ((type & TTV_FIND_R) == TTV_FIND_R))) && (rootx == root))
2771 {
2772 in = in->NEXT ;
2773 continue ;
2774 }
2775 }
2776 }
2777
2778 if((((in->TYPE & TTV_LINE_DENPTMAX) == TTV_LINE_DENPTMAX) &&
2779 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
2780 (((in->TYPE & TTV_LINE_DENPTMIN) == TTV_LINE_DENPTMIN) &&
2781 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)) ||
2782 (((in->TYPE & (TTV_LINE_T | TTV_LINE_D)) != 0) &&
2783 (ttvfigp != in->FIG)) ||
2784 (((in->TYPE & (TTV_LINE_J | TTV_LINE_E)) != 0) &&
2785 (level < in->FIG->INFO->LEVEL)) ||
2786 (((in->TYPE & (TTV_LINE_F | TTV_LINE_P)) != 0) &&
2787 ((level < in->FIG->INFO->LEVEL) || (ttvfig->INFO->LEVEL > in->FIG->INFO->LEVEL))))
2788 {
2789 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2790 {
2791 chain = chain->NEXT ;
2792 if(chain == NULL) in = NULL ;
2793 else in = (ttvline_list *)chain->DATA ;
2794 }
2795 else in = in->NEXT ;
2796 continue ;
2797 }
2798
2799 if(node->ROOT->ROOT != nodex->ROOT->ROOT)
2800 {
2801 ttvfigx = nodex->ROOT->ROOT ;
2802 while((ttvfigx != ttvfig) && ((ttvfigx->STATUS &
2803 TTV_STS_NOT_FREE) != TTV_STS_NOT_FREE))
2804 {
2805 if((ttvfigx->STATUS & TTV_STS_NOT_FREE) != TTV_STS_NOT_FREE)
2806 {
2807 chainnfree = addchain(chainnfree,(void *)ttvfigx) ;
2808 ttvfigx->STATUS |= TTV_STS_NOT_FREE ;
2809 }
2810 ttv_parsttvfig(ttvfigx,status,filetype) ;
2811 ttvfigx = ttvfigx->ROOT ;
2812 }
2813 }
2814
2815 if(nodex == root)
2816 {
2817 if (TTV_CHAIN_CLOCK==NULL)
2818 {
2819 if(((root->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L)
2820 || ((root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R))
2821 {
2822 if(((((nodex->ROOT->TYPE & TTV_SIG_BYPASSIN) != TTV_SIG_BYPASSIN) &&
2823 ((nodex->TYPE & TTV_NODE_BYPASSIN) != TTV_NODE_BYPASSIN)) ||
2824 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)) &&
2825 ((((nodex->ROOT->TYPE & TTV_SIG_BYPASSOUT) != TTV_SIG_BYPASSOUT) &&
2826 ((nodex->TYPE & TTV_NODE_BYPASSOUT) != TTV_NODE_BYPASSOUT)) ||
2827 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)))
2828 {
2829 if((ptype = getptype(root->USER,TTV_NODE_DELAYLOOP)) == NULL)
2830 {
2831 ptype = root->USER = addptype(root->USER,
2832 TTV_NODE_DELAYLOOP,(void*)TTV_NOTIME) ;
2833 }
2834 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2835 {
2836 delay = ttv_getdelaymax(in) ;
2837 if(((node->FIND->DELAY + delay) > (long)ptype->DATA) &&
2838 (delay != TTV_NOTIME))
2839 {
2840 ptype->DATA = (void *)(node->FIND->DELAY + delay) ;
2841 nodex->FIND->OUTLINE = in ;
2842 if((root->FIND->TYPE & TTV_FIND_BEGIN) != TTV_FIND_BEGIN)
2843 {
2844 in_gi = addchain(in_gi,(char *)root) ;
2845 root->FIND->TYPE |= TTV_FIND_BEGIN ;
2846 }
2847 }
2848 }
2849 else
2850 {
2851 delay = ttv_getdelaymin(in) ;
2852 if((((node->FIND->DELAY + delay) < (long)ptype->DATA) ||
2853 ((long)ptype->DATA == TTV_NOTIME))
2854 && (delay != TTV_NOTIME))
2855 {
2856 ptype->DATA = (void *)(node->FIND->DELAY + delay) ;
2857 nodex->FIND->OUTLINE = in ;
2858 if((root->FIND->TYPE & TTV_FIND_BEGIN) != TTV_FIND_BEGIN)
2859 {
2860 in_gi = addchain(in_gi,(char *)root) ;
2861 root->FIND->TYPE |= TTV_FIND_BEGIN ;
2862 }
2863 }
2864 }
2865 if((long)ptype->DATA == TTV_NOTIME)
2866 ptype = root->USER = delptype(root->USER,
2867 TTV_NODE_DELAYLOOP) ;
2868 }
2869 }
2870 else
2871 ttv_monolatcherror(ttvfig,root->ROOT) ;
2872 }
2873 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2874 {
2875 chain = chain->NEXT ;
2876 if(chain == NULL) in = NULL ;
2877 else in = (ttvline_list *)chain->DATA ;
2878 }
2879 else in = in->NEXT ;
2880 continue ;
2881 }
2882
2883 if(((((nodex->ROOT->TYPE & TTV_SIG_BYPASSIN) != TTV_SIG_BYPASSIN) &&
2884 ((nodex->TYPE & TTV_NODE_BYPASSIN) != TTV_NODE_BYPASSIN)) ||
2885 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)) &&
2886 ((((nodex->ROOT->TYPE & TTV_SIG_BYPASSOUT) != TTV_SIG_BYPASSOUT) &&
2887 ((nodex->TYPE & TTV_NODE_BYPASSOUT) != TTV_NODE_BYPASSOUT)) ||
2888 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)))
2889 {
2890 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
2891 {
2892 delay = ttv_getdelaymax(in) ;
2893 if(delay != TTV_NOTIME)
2894 {
2895 if((nodex->FIND == NULL) ||
2896 (!ttv_isbypassednode(nodex) && ((nodex->FIND->FIFO < node->FIND->FIFO) ||
2897 ((node->FIND->DELAY + delay) > nodex->FIND->DELAY)))
2898 )
2899 {
2900 ttv_transfertnodefindinfo(head,nodex,node,in,delay,type) ;
2901 }
2902 }
2903 }
2904 else
2905 {
2906 delay = ttv_getdelaymin(in) ;
2907 if(delay != TTV_NOTIME)
2908 {
2909 if((nodex->FIND == NULL) ||
2910 (!ttv_isbypassednode(nodex) && ((nodex->FIND->FIFO < node->FIND->FIFO) ||
2911 ((node->FIND->DELAY + delay) < nodex->FIND->DELAY)))
2912 )
2913 {
2914 ttv_transfertnodefindinfo(head,nodex,node,in,delay,type) ;
2915 }
2916 }
2917 }
2918 }
2919 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2920 {
2921 chain = chain->NEXT ;
2922 if(chain == NULL) in = NULL ;
2923 else in = (ttvline_list *)chain->DATA ;
2924 }
2925 else in = in->NEXT ;
2926 }
2927 }
2928 }
2929
2930 if(TTV_CHAIN_CLOCK == NULL)
2931 {
2932 for(chain = chainnfree ; chain != NULL ; chain = chain->NEXT)
2933 ((ttvfig_list *)chain->DATA)->STATUS &= ~(TTV_STS_NOT_FREE) ;
2934
2935 freechain(chainnfree) ;
2936 TTV_CHAIN_FREE = NULL ;
2937 }
2938 else
2939 {
2940 TTV_CHAIN_FREE = chainnfree ;
2941 }
2942
2943 if((type & (TTV_FIND_DUAL|TTV_FIND_HZ)) == (TTV_FIND_DUAL|TTV_FIND_HZ))
2944 {
2945 chainnfree = NULL ;
2946 for(chain = in_gi ; chain != NULL ; chain = chain->NEXT)
2947 {
2948 node = (ttvevent_list *)chain->DATA ;
2949 if(((node->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
2950 ((node->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
2951 ((node->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
2952 chainnfree = addchain(chainnfree,(void*)node) ;
2953 else
2954 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
2955 }
2956 freechain(in_gi) ;
2957 in_gi = chainnfree ;
2958 if((ptype = getptype(root->USER,TTV_NODE_DELAYLOOP)) != NULL)
2959 {
2960 root->FIND->DELAY = (long)ptype->DATA ;
2961 root->USER = delptype(root->USER,TTV_NODE_DELAYLOOP) ;
2962 }
2963 }
2964
2965 if((type & (TTV_FIND_DUAL|TTV_FIND_S)) == (TTV_FIND_DUAL|TTV_FIND_S))
2966 {
2967 chainnfree = NULL ;
2968 for(chain = in_gi ; chain != NULL ; chain = chain->NEXT)
2969 {
2970 node = (ttvevent_list *)chain->DATA ;
2971 if(((node->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
2972 ((node->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
2973 chainnfree = addchain(chainnfree,(void*)node) ;
2974 else
2975 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
2976 }
2977 freechain(in_gi) ;
2978 in_gi = chainnfree ;
2979 if((ptype = getptype(root->USER,TTV_NODE_DELAYLOOP)) != NULL)
2980 {
2981 root->FIND->DELAY = (long)ptype->DATA ;
2982 root->USER = delptype(root->USER,TTV_NODE_DELAYLOOP) ;
2983 }
2984 }
2985
2986
2987 if((root->FIND->TYPE & TTV_FIND_BEGIN) == TTV_FIND_BEGIN)
2988 {
2989 if((ptype = getptype(root->USER,TTV_NODE_DELAYLOOP)) != NULL)
2990 {
2991 root->FIND->DELAY = (long)ptype->DATA ;
2992 root->USER = delptype(root->USER,TTV_NODE_DELAYLOOP) ;
2993 }
2994 }
2995
2996 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
2997 {
2998 if(ttv_canbeinfalsepath(root, 'i'))
2999 {
3000 chainnfree = NULL ;
3001 for(chain = in_gi ; chain != NULL ; chain = chain->NEXT)
3002 {
3003 node = (ttvevent_list *)chain->DATA ;
3004 if(ttv_canbeinfalsepath(node, 'o'))
3005 {
3006 int ret;
3007 if((ret=ttv_isfalsepath(head,root,node,type,0,NULL)) == 0)
3008 chainnfree = addchain(chainnfree,(void*)node) ;
3009 else
3010 {
3011 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
3012 if (ret==1) TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
3013 }
3014 }
3015 else
3016 {
3017 chainnfree = addchain(chainnfree,(void*)node) ;
3018 }
3019 }
3020 freechain(in_gi) ;
3021 in_gi = chainnfree ;
3022 }
3023 }
3024 else
3025 {
3026 if (!(TTV_SEARCH_STEP & TTV_SEARCH_STEP_IN_CLOCK_PATH))
3027 {
3028 if(ttv_canbeinfalsepath(root, 'o'))
3029 {
3030 chainnfree = NULL ;
3031 for(chain = in_gi ; chain != NULL ; chain = chain->NEXT)
3032 {
3033 node = (ttvevent_list *)chain->DATA ;
3034 if(ttv_canbeinfalsepath(node, 'i'))
3035 {
3036 int ret;
3037 if((ret=ttv_isfalsepath(head,node,root,type,0,NULL)) == 0)
3038 chainnfree = addchain(chainnfree,(void*)node) ;
3039 else
3040 {
3041 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
3042 if (ret==1) TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
3043 }
3044 }
3045 else
3046 {
3047 chainnfree = addchain(chainnfree,(void*)node) ;
3048 }
3049 }
3050 freechain(in_gi) ;
3051 in_gi = chainnfree ;
3052 }
3053 }
3054 else
3055 {
3056 ttvevent_list *cmdev;
3057 int isfalse;
3058 chainnfree = NULL ;
3059 for(chain = in_gi ; chain != NULL ; chain = chain->NEXT)
3060 {
3061 isfalse=0;
3062 node = (ttvevent_list *)chain->DATA ;
3063 if(ttv_canbeinfalsepath(node, 'i'))
3064 {
3065 // retreive the latch command
3066 cmdev=ttv_findlatchcommand_notdual(root, node);
3067 if(cmdev!=NULL && ttv_canbeinfalsepath(cmdev, 'o'))
3068 {
3069 int ret;
3070 if((ret=ttv_isfalsepath(head,node,cmdev,type,0,NULL))!=0)
3071 {
3072 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
3073 if (ret==1) TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
3074 isfalse=1;
3075 }
3076 }
3077 }
3078 if (!isfalse)
3079 chainnfree = addchain(chainnfree,(void*)node) ;
3080 }
3081 freechain(in_gi) ;
3082 in_gi = chainnfree ;
3083 }
3084 }
3085
3086 return(in_gi) ;
3087 }
3088
3089 /*****************************************************************************/
3090 /* function ttv_getcritic() */
3091 /* parametres : */
3092 /* ttvfig : ttvfig courante */
3093 /* figpath : ttvfig ou se trouve le chemin */
3094 /* root : noeud de depart */
3095 /* node : noeud d'arrive */
3096 /* type : type de recherche */
3097 /* */
3098 /* construit le detail d'un chemin en fonction du type de temps max ou min */
3099 /*****************************************************************************/
3100 ttvcritic_list *ttv_getcritic(ttvfig,figpath,root,node,latch,cmdlatch,type)
3101 ttvfig_list *ttvfig ;
3102 ttvfig_list *figpath ;
3103 ttvevent_list *root ;
3104 ttvevent_list *node ;
3105 ttvevent_list *latch ;
3106 ttvevent_list *cmdlatch ;
3107 long type ;
3108 {
3109 ttvfig_list *ttvfigx ;
3110 ttvevent_list *nodex ;
3111 ttvfig_list *ttvfigsav ;
3112 chain_list *chain ;
3113 chain_list *chainx ;
3114 ttvcritic_list *critic = NULL ;
3115 long levelroot ;
3116 long levelnode ;
3117 long level ;
3118
3119 if(((type & TTV_FIND_PATH) != TTV_FIND_PATH) ||
3120 ((type & TTV_FIND_LINE) == TTV_FIND_LINE))
3121 {
3122 type |= TTV_FIND_LINE ;
3123 type &= ~(TTV_FIND_PATH) ;
3124 }
3125
3126 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
3127 {
3128 type &= ~(TTV_FIND_DUAL) ;
3129 TTV_CHAIN_CLOCK = addchain(TTV_CHAIN_CLOCK,node->ROOT) ;
3130 }
3131
3132 if(figpath == NULL)
3133 {
3134 levelroot = ttv_getsiglevel(root->ROOT) ;
3135 if((latch != NULL) && (node != latch))
3136 levelnode = ttv_getsiglevel(latch->ROOT) ;
3137 else
3138 levelnode = ttv_getsiglevel(node->ROOT) ;
3139
3140 if(levelroot > ttvfig->INFO->LEVEL) levelroot = ttvfig->INFO->LEVEL ;
3141 if(levelnode > ttvfig->INFO->LEVEL) levelnode = ttvfig->INFO->LEVEL ;
3142
3143 if(levelroot > levelnode) level = levelnode ;
3144 else level = levelroot ;
3145
3146 for(ttvfigx = root->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
3147 {
3148 ttvfigx->STATUS |= TTV_STS_MARQUE ;
3149 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
3150 }
3151
3152 if((latch != NULL) && (node != latch))
3153 ttvfigx = latch->ROOT->ROOT ;
3154 else
3155 ttvfigx = node->ROOT->ROOT ;
3156
3157 for(; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
3158 if((ttvfigx->STATUS & TTV_STS_MARQUE) == TTV_STS_MARQUE)
3159 break ;
3160
3161 ttvfigsav = ttvfigx ;
3162
3163 for(ttvfigx = root->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
3164 {
3165 ttvfigx->STATUS &= ~(TTV_STS_MARQUE) ;
3166 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
3167 }
3168
3169 if(ttvfigsav == NULL)
3170 {
3171 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
3172 {
3173 freechain(TTV_CHAIN_CLOCK) ;
3174 TTV_CHAIN_CLOCK = NULL ;
3175 }
3176 return(NULL) ;
3177 }
3178
3179 if((level < ttvfig->INFO->LEVEL) && (level == ttvfigsav->INFO->LEVEL))
3180 {
3181 level = (long)0 ;
3182 }
3183 else if((level == ttvfig->INFO->LEVEL) && (level > ttvfigsav->INFO->LEVEL))
3184 {
3185 level = ttvfigsav->INFO->LEVEL ;
3186 ttvfigsav = ttvfig ;
3187 }
3188 }
3189 else
3190 {
3191 ttvfigsav = figpath ;
3192 if(figpath == ttvfig)
3193 {
3194 level = figpath->INFO->LEVEL ;
3195 }
3196 else
3197 {
3198 level = (long)0 ;
3199 }
3200 }
3201
3202 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
3203 {
3204 nodex = node ;
3205 node = root ;
3206 root = nodex ;
3207 }
3208
3209 TTV_SEARCH_FIRST_NODE=root;
3210
3211 if((node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_L | TTV_SIG_Q | TTV_SIG_R |
3212 TTV_SIG_N|TTV_SIG_B)) == 0)
3213 node->TYPE |= TTV_NODE_STOP ;
3214
3215 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0 || (root->ROOT->TYPE & (TTV_SIG_L|TTV_SIG_B))==0)
3216 chain = ttv_findaccess(ttvfig,ttvfigsav,root,NULL,type,level) ;
3217 else
3218 {
3219 ttv_fifopush(root) ;
3220 ttv_uncachenodelines(ttvfig,ttvfigsav,root,type);
3221 root->FIND->DELAY = 0 ;
3222 chain=addchain(NULL, root);
3223 }
3224
3225
3226 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
3227 {
3228 ((ttvevent_list *)chainx->DATA)->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
3229 }
3230
3231 freechain(chain) ;
3232
3233 if((latch != NULL) && (node != latch))
3234 {
3235 int found=0;
3236 // BLINDAGE CORE si latch non trouve
3237 if (latch->FIND==NULL)
3238 {
3239 char buf0[128], buf1[128], buf2[128], buf[1024];
3240 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
3241 {
3242 freechain(TTV_CHAIN_CLOCK) ;
3243 TTV_CHAIN_CLOCK = NULL ;
3244 }
3245 sprintf(buf, "could not reach latch '%s' for path from '%s' to '%s'",
3246 ttv_getsigname(ttvfig,buf2,latch->ROOT),
3247 ttv_getsigname(ttvfig,buf0,node->ROOT),
3248 ttv_getsigname(ttvfig,buf1,root->ROOT));
3249
3250 ttv_error(55,buf,TTV_WARNING) ;
3251 ttv_fifoclean() ;
3252
3253 return NULL;
3254 }
3255 //
3256
3257 ttv_fifosave() ;
3258 chain = ttv_findclockpath(ttvfig,ttvfig,latch,root,type|TTV_FIND_CRITIC,1, cmdlatch) ;
3259
3260
3261 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
3262 {
3263 if (chainx->DATA==node) found=1;
3264 ((ttvevent_list *)chainx->DATA)->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
3265 }
3266 freechain(chain) ;
3267
3268 if (!found)
3269 {
3270 char buf0[128], buf1[128], buf[1024], buf3[128];
3271 ttv_fiforestore() ;
3272 ttv_fifoclean() ;
3273 sprintf(buf3," thru latch '%s'",ttv_getsigname(ttvfig,buf0,latch->ROOT));
3274 sprintf(buf, "could not reach clock '%s' for path from '%s' to '%s'%s",
3275 ttv_getsigname(ttvfig,buf0,node->ROOT),
3276 ttv_getsigname(ttvfig,buf0,node->ROOT),
3277 ttv_getsigname(ttvfig,buf1,root->ROOT),
3278 buf3);
3279
3280 ttv_error(55,buf,TTV_WARNING) ;
3281
3282 return NULL;
3283 }
3284 }
3285
3286 if((node->ROOT->TYPE & (TTV_SIG_C | TTV_SIG_L | TTV_SIG_Q | TTV_SIG_R |
3287 TTV_SIG_N|TTV_SIG_B)) == 0)
3288 node->TYPE &= ~(TTV_NODE_STOP) ;
3289
3290 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
3291 {
3292 freechain(TTV_CHAIN_CLOCK) ;
3293 TTV_CHAIN_CLOCK = NULL ;
3294 }
3295
3296 // BLINDAGE CORE si node non trouve
3297 if (node->FIND==NULL)
3298 {
3299 char buf0[128], buf1[128], buf[1024], buf3[128];
3300 if((latch != NULL) && (node != latch))
3301 {
3302 ttv_fiforestore() ;
3303 }
3304 ttv_fifoclean() ;
3305 if (latch==NULL) strcpy(buf3,"");
3306 else sprintf(buf3," thru latch '%s'",ttv_getsigname(ttvfig,buf0,latch->ROOT));
3307 sprintf(buf, "could not reach clock '%s' for path from '%s' to '%s'%s",
3308 ttv_getsigname(ttvfig,buf0,node->ROOT),
3309 ttv_getsigname(ttvfig,buf0,node->ROOT),
3310 ttv_getsigname(ttvfig,buf1,root->ROOT),
3311 buf3);
3312
3313 ttv_error(55,buf,TTV_WARNING) ;
3314
3315 return NULL;
3316 }
3317 //
3318
3319 if(node->FIND->OUTLINE == NULL && getptype(node->USER,TTV_NODE_LATCH)==NULL)
3320 {
3321 if((latch != NULL) && (node != latch))
3322 {
3323 ttv_fiforestore() ;
3324 }
3325 ttv_fifoclean() ;
3326 return(NULL) ;
3327 }
3328
3329 if (TTV_CHARAC_CRITIC_SLOPES_LIST!=NULL || TTV_CHARAC_CRITIC_CAPAS_LIST!=NULL)
3330 {
3331 if (TTV_CHARAC_CRITIC_RESULT_DELAYS==NULL)
3332 ttv_DoCharacPropagation(ttvfig,figpath,node,root,type,TTV_CHARAC_CRITIC_SLOPES_LIST,TTV_CHARAC_CRITIC_CAPAS_LIST, &TTV_CHARAC_CRITIC_RESULT_DELAYS, &TTV_CHARAC_CRITIC_RESULT_SLOPES, &TTV_CHARAC_CRITIC_RESULT_ENERGY,NULL);
3333 critic = NULL;
3334 }
3335 else
3336 critic = ttv_savcritic(ttvfig,figpath,root,node,type,0) ;
3337
3338 if((latch != NULL) && (node != latch))
3339 {
3340 ttv_fiforestore() ;
3341 }
3342
3343 ttv_fifoclean() ;
3344
3345 if(critic == NULL)
3346 return(NULL) ;
3347 return(critic) ;
3348 }
3349
3350 static ttvpath_stb_stuff *ttv_getcrossvalues_notdual(ttvfig_list *tvf, ttvevent_list *tve, long type, int checkstart)
3351 {
3352 ttvfind_stb_stuff *tss;
3353 long startg, start=TTV_NOTIME;
3354 char startphase;
3355 ttvpath_stb_stuff *tps, *tpslist=NULL;
3356
3357 for (tss=tve->FIND->STB; tss!=NULL; tss=tss->NEXT)
3358 {
3359 startg = ttv_getinittime(tvf,tve,STB_NO_INDEX,type,startphase=tss->PHASE,NULL) ;
3360 start=tss->CROSSDELAY_MIN;
3361 if (tss->CROSSDELAY_MIN!=TTV_NOTIME
3362 && ((checkstart && getptype(tve->ROOT->USER, STB_IDEAL_CLOCK)!=NULL)
3363 || ((type & TTV_FIND_MAX)==TTV_FIND_MAX && start>=startg)
3364 || ((type & TTV_FIND_MIN)==TTV_FIND_MIN && start<=startg))
3365 ) start=TTV_NOTIME;
3366
3367 if (start==TTV_NOTIME)
3368 start=startg;
3369
3370 tps=ttv_allocpath_stb_stuff();
3371 tps->NEXT=tpslist;
3372 tpslist=tps;
3373 tps->STARTPHASE=tss->PHASE;
3374 tps->STARTTIME=start;
3375 tps->PERIOD_CHANGE=tss->PERIOD_CHANGE;
3376 }
3377
3378 return tpslist;
3379 }
3380
3381 static ttvpath_stb_stuff *ttv_getcrossvalues_dual(ttvfig_list *tvf, ttvevent_list *tve, ttvevent_list *startnode, long type, int *failed)
3382 {
3383 ttvfind_stb_stuff *tss;
3384 long startg, crossmin;
3385 char startphase;
3386 ttvpath_stb_stuff *tps, *tpslist=NULL;
3387 ttvevent_list *tvecheckev;
3388
3389 *failed=0;
3390
3391 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DONT_FILTER_ENDING_NODE)==0 && stb_has_filter_directive(tve))
3392 tvecheckev=tve;
3393 else
3394 tvecheckev=tve->FIND->OUTLINE->NODE;
3395
3396 for (tss=tvecheckev->FIND->STB; tss!=NULL; tss=tss->NEXT)
3397 {
3398 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DONT_FILTER_ENDING_NODE)==0
3399 && (tss->FLAGS & TTV_TPS_FINDSTRUCT_THRU_FILTER_NOCROSS)!=0) continue;
3400 startg = ttv_getinittime(tvf,startnode,STB_NO_INDEX,type,startphase=tss->STARTPHASE,NULL) ;
3401
3402 crossmin=tss->CROSSDELAY_MIN;
3403
3404 if (crossmin!=TTV_NOTIME)
3405 {
3406 crossmin=startg+crossmin;
3407 if ((type & TTV_FIND_MAX)==TTV_FIND_MAX)
3408 {
3409 if (crossmin>=startg) crossmin=TTV_NOTIME;
3410 if (crossmin!=TTV_NOTIME && crossmin<ttv_getinittime(tvf,startnode,STB_NO_INDEX,TTV_FIND_MIN,tss->STARTPHASE,NULL)) continue;
3411 }
3412 else
3413 {
3414 if (crossmin<=startg) crossmin=TTV_NOTIME;
3415 if (crossmin!=TTV_NOTIME && crossmin>ttv_getinittime(tvf,startnode,STB_NO_INDEX,TTV_FIND_MAX,tss->STARTPHASE,NULL)) continue;
3416 }
3417 }
3418 if (crossmin==TTV_NOTIME) crossmin=startg;
3419 tps=ttv_allocpath_stb_stuff();
3420 tps->NEXT=tpslist;
3421 tpslist=tps;
3422 tps->STARTPHASE=tss->STARTPHASE;
3423 tps->STARTTIME=crossmin;
3424 tps->PERIOD_CHANGE=tss->PERIOD_CHANGE;
3425 }
3426 if (tvecheckev->FIND->STB!=NULL && tpslist==NULL) *failed=1;
3427 return tpslist;
3428 }
3429
3430
3431 static ttvpath_stb_stuff *ttv_getbestcrossvalues(ttvpath_stb_stuff *tps, long type)
3432 {
3433 ttvpath_stb_stuff *best=NULL;
3434
3435 while (tps!=NULL)
3436 {
3437 if (best==NULL
3438 || ((type & TTV_FIND_MAX)==TTV_FIND_MAX && best->STARTTIME<tps->STARTTIME)
3439 || ((type & TTV_FIND_MIN)==TTV_FIND_MIN && best->STARTTIME>tps->STARTTIME)
3440 ) best=tps;
3441 tps=tps->NEXT;
3442 }
3443 return best;
3444 }
3445
3446 static ttvpath_stb_stuff *ttv_getphasecrossvalues(ttvpath_stb_stuff *tps, ttvevent_list *cmd)
3447 {
3448 char cmdphase;
3449 stbnode *n;
3450
3451 if (cmd!=NULL && (n=stb_getstbnode(cmd))!=NULL && n->CK!=NULL)
3452 cmdphase=n->CK->CKINDEX;
3453 else
3454 cmdphase=STB_NO_INDEX;
3455
3456 while (tps!=NULL && tps->STARTPHASE!=cmdphase) tps=tps->NEXT;
3457
3458 return tps;
3459 }
3460
3461 /*****************************************************************************/
3462 /* function ttv_savpath() */
3463 /* parametres : */
3464 /* ttvfig : ttvfig courante */
3465 /* ttvins : figure instance */
3466 /* path : liste des chemins */
3467 /* root : signal source */
3468 /* node : signal destination */
3469 /* type : type de recherche */
3470 /* */
3471 /* recherche tous les chemins entre ptsig et les signaux de mask */
3472 /*****************************************************************************/
3473 char ttv_getcmdphase(ttvevent_list *cmd)
3474 {
3475 stbnode *stbnode;
3476 char phase;
3477 if (cmd!=NULL && (stbnode=stb_getstbnode(cmd))!=NULL && stbnode->CK!=NULL)
3478 return stbnode->CK->CKINDEX;
3479
3480 return STB_NO_INDEX;
3481 }
3482
3483 ttvpath_list *ttv_savpath(ttvfig,ttvins,path,root,node,type)
3484 ttvfig_list *ttvfig ;
3485 ttvfig_list *ttvins ;
3486 ttvpath_list *path ;
3487 ttvevent_list *root ;
3488 ttvevent_list *node ;
3489 long type ;
3490 {
3491 ttvevent_list *nodex ;
3492 ptype_list *ptype ;
3493 ttvfig_list *ttvfigx ;
3494 ttvevent_list *cmd ;
3495 ttvevent_list *previous_node ;
3496 long typer ;
3497 long delayref = (long)0 ;
3498 long access = (long)0 ;
3499 long refaccess = (long)0 ;
3500 long start = 0 ;
3501 long starts = 0 ;
3502 long startsref = 0 ;
3503 long data ;
3504 long datamax ;
3505 long datamin, crossmin, per_change=0, clockpathdelay=0;
3506 ttvevent_list *latch = NULL ;
3507 ttvevent_list *cmdlatch = NULL ;
3508 ptype_list *latchlist = NULL, crossvalues ;
3509 chain_list *chainnode ;
3510 chain_list *chain ;
3511 ttvsig_list *tvs;
3512 stbfig_list *sb;
3513 int checkloop=0;
3514 char phase;
3515 long lcrossmin, oslope;
3516 ttvline_list *prevline=NULL;
3517 ttvpath_stb_stuff *tps, *best, *tpslat, *ptps, *phaseinfo;
3518
3519 ttvfigx = node->ROOT->ROOT ;
3520 sb=stb_getstbfig(ttvfig);
3521
3522 phaseinfo=NULL;
3523
3524 nodex = node ;
3525 chainnode = NULL ;
3526 if ((V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE>0 || TTV_MaxPathPeriodPrecharge>0) && (type & TTV_FIND_ALL)==0) checkloop=1;
3527 if((nodex->FIND->OUTLINE == NULL) &&
3528 ((ptype = getptype(nodex->USER,TTV_NODE_CLOCK)) != NULL))
3529 {
3530 delayref += ttv_GET_FINDDELAY(nodex, 0) - ttv_GET_FINDDELAY((ttvevent_list *)ptype->DATA, 0) ;
3531 nodex = (ttvevent_list *)ptype->DATA ;
3532 ttvfigx = nodex->ROOT->ROOT ;
3533 }
3534
3535 if((nodex->FIND->OUTLINE == NULL) &&
3536 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
3537 {
3538 cmdlatch = nodex ;
3539 delayref += ttv_GET_FINDDELAY(nodex, 0) - ttv_GET_FINDDELAY((ttvevent_list *)ptype->DATA, 0) ;
3540 nodex = (ttvevent_list *)ptype->DATA ;
3541 latch = nodex ;
3542 ttvfigx = nodex->ROOT->ROOT ;
3543 }
3544
3545 while(nodex->FIND->OUTLINE != NULL)
3546 {
3547 if(nodex->FIND->OUTLINE->FIG->INFO->LEVEL > ttvfigx->INFO->LEVEL)
3548 ttvfigx = nodex->FIND->OUTLINE->FIG ;
3549
3550 delayref += ttv_GET_LINE_DELAY(nodex->FIND->OUTLINE, type, 1);
3551
3552 if (checkloop)
3553 {
3554 nodex->TYPE|=TTV_NODE_MARQUE;
3555 chainnode=addchain(chainnode, nodex);
3556 }
3557 if (TTV_MARK_MODE==TTV_MARK_MODE_DO)
3558 {
3559 tvs=nodex->ROOT;
3560 if (getptype(tvs->USER, TTV_SIG_MARKED)==NULL)
3561 {
3562 tvs->USER=addptype(tvs->USER, TTV_SIG_MARKED, NULL);
3563 MARKED_SIG_LIST=addchain(MARKED_SIG_LIST, tvs);
3564 }
3565 }
3566 if((nodex->FIND->OUTLINE->TYPE & TTV_LINE_A) == TTV_LINE_A
3567 || (latch==NULL && (nodex->FIND->OUTLINE->ROOT->ROOT->TYPE & TTV_SIG_L)!=0 && (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_ACCESS)!=0))
3568 {
3569 cmdlatch = nodex->FIND->OUTLINE->NODE ;
3570 latch = nodex->FIND->OUTLINE->ROOT ;
3571 ttvfigx = latch->ROOT->ROOT ;
3572 refaccess = ttv_GET_LINE_DELAY(nodex->FIND->OUTLINE, type, 1);
3573 access = ttv_GET_FINDDELAY(nodex->FIND->OUTLINE->NODE, 0) - ttv_GET_FINDDELAY(nodex->FIND->OUTLINE->ROOT, 0);
3574 }
3575
3576 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
3577 {
3578 if(nodex->FIND->OUTLINE->NODE == root) break ;
3579 if((nodex->FIND->OUTLINE->NODE->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
3580 {
3581 TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
3582 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
3583 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
3584 freechain(chainnode) ;
3585 return(path) ;
3586 }
3587 nodex = nodex->FIND->OUTLINE->NODE ;
3588 }
3589 else
3590 {
3591 if(nodex->FIND->OUTLINE->ROOT == root) break ;
3592 if((nodex->FIND->OUTLINE->ROOT->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
3593 {
3594 TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
3595 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
3596 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
3597 freechain(chainnode) ;
3598 return(path) ;
3599 }
3600 prevline=nodex->FIND->OUTLINE;
3601 nodex = nodex->FIND->OUTLINE->ROOT ;
3602 }
3603
3604 if(((nodex->FIND->OUTLINE == NULL) ||
3605 ((nodex->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)) &&
3606 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
3607 {
3608 cmdlatch = nodex ;
3609 delayref += ttv_GET_FINDDELAY(nodex, 0) - ttv_GET_FINDDELAY((ttvevent_list *)ptype->DATA, 0) ;
3610 nodex = (ttvevent_list *)ptype->DATA ;
3611 latch = nodex ;
3612 ttvfigx = latch->ROOT->ROOT ;
3613 }
3614 if((((nodex->ROOT->TYPE & TTV_SIG_LL) == TTV_SIG_LL) ||
3615 ((nodex->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)) && (nodex != latch))
3616 {
3617 char phase;
3618
3619 if ((nodex->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
3620 stb_geteventphase(sb, nodex,&phase,NULL,NULL,1,1) ;
3621 else
3622 {
3623 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL && node->FIND->OUTLINE!=NULL)
3624 cmd = ttv_getlinecmd(ttvfig,node->FIND->OUTLINE,TTV_LINE_CMDMAX) ;
3625 else if ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL && prevline!=NULL)
3626 cmd = ttv_getlinecmd(ttvfig,prevline,TTV_LINE_CMDMAX) ;
3627 else
3628 cmd=NULL;
3629
3630 phase=ttv_getcmdphase(cmd);
3631 }
3632
3633 latchlist = addptype(latchlist,(long)phase,nodex) ;
3634 }
3635 }
3636
3637 if (checkloop)
3638 {
3639 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
3640 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
3641 freechain(chainnode) ;
3642 }
3643
3644 if (TTV_MARK_MODE==TTV_MARK_MODE_DO) return path;
3645
3646 previous_node=NULL;
3647
3648 if((ttvfigx != ttvins) && (ttvins != NULL))
3649 return(path) ;
3650
3651 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
3652 {
3653 int failed;
3654 typer = (long)0 ;
3655 if((node->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
3656 {
3657 previous_node=node->FIND->OUTLINE->NODE;
3658 if(node->FIND->OUTLINE->TYPE & TTV_LINE_PR) typer = TTV_FIND_PR ;
3659 else if(node->FIND->OUTLINE->TYPE & TTV_LINE_EV) typer = TTV_FIND_EV ;
3660 }
3661 if(((node->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS) ||
3662 ((node->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR))
3663 {
3664 if(node->FIND->OUTLINE->TYPE & TTV_LINE_R) typer = TTV_FIND_R ;
3665 else if(node->FIND->OUTLINE->TYPE & TTV_LINE_S) typer = TTV_FIND_S ;
3666 }
3667
3668 tps=ttv_getcrossvalues_dual(ttvfig, node, root, type, &failed);
3669 if (failed) return path;
3670 best=ttv_getbestcrossvalues(tps, type);
3671 if (best==NULL)
3672 {
3673 start = ttv_getinittime(ttvfig,root,STB_NO_INDEX,type,STB_NO_INDEX,&phase) ;
3674 crossmin=TTV_NOTIME;
3675 }
3676 else
3677 {
3678 start = ttv_getinittime(ttvfig,root,STB_NO_INDEX,type,best->STARTPHASE,&phase) ;
3679 crossmin=best->STARTTIME;
3680 }
3681 starts = ttv_getnodeslope(ttvfig,ttvins,root,&startsref,type) ;
3682
3683 if(latch != NULL)
3684 {
3685 stb_getstbdelta(sb, latch, &datamin, &datamax, cmdlatch);
3686 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
3687 data = datamax ;
3688 else
3689 data = datamin;
3690 clockpathdelay=ttv_GET_FINDDELAY(latch, 0);
3691 // modif pour le crossmin non mis en dual raison: pas d'access en dual
3692 }
3693 else data = (long)0 ;
3694
3695 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_KEEP_PHASE_INFO)!=0)
3696 phaseinfo=tps;
3697 else
3698 ttv_freepathstblist(tps);
3699
3700 cmd=NULL;
3701 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
3702 {
3703 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0)
3704 cmd = ttv_getlinecmd(ttvfig,node->FIND->OUTLINE,TTV_LINE_CMDMAX) ;
3705 oslope=ttv_getslopemax(node->FIND->OUTLINE);
3706 }
3707 else
3708 {
3709 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0)
3710 cmd = ttv_getlinecmd(ttvfig,node->FIND->OUTLINE,TTV_LINE_CMDMAX) ;
3711 oslope=ttv_getslopemin(node->FIND->OUTLINE);
3712 }
3713
3714
3715 // start = ttv_getinittime(ttvfig,root,STB_NO_INDEX,type,STB_NO_INDEX,&phase) ;
3716
3717 /* if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DONT_FILTER_ENDING_NODE)==0 && stb_has_filter_directive(node))
3718 crossmin=node->FIND->CROSSDELAY_MIN;
3719 else
3720 crossmin=node->FIND->OUTLINE->NODE->FIND->CROSSDELAY_MIN;
3721 */
3722 // per_change=node->FIND->PERIOD_CHANGE;
3723 /*
3724 if (crossmin!=TTV_NOTIME)
3725 {
3726 if (crossmin>=start) crossmin=TTV_NOTIME;
3727 else crossmin=start+crossmin;
3728 if (crossmin!=TTV_NOTIME && crossmin<ttv_getinittime(ttvfig,root,STB_NO_INDEX,TTV_FIND_MIN,STB_NO_INDEX,NULL)) return path;
3729 }
3730 */
3731 path = ttv_allocpath(path,ttvfigx,node,root,cmd,
3732 latch,cmdlatch,latchlist,data,access,refaccess,
3733 type|typer,delayref,ttv_GET_LINE_SLEW(node->FIND->OUTLINE, type, 1),
3734 ttv_GET_FINDDELAY(node, 0),oslope,
3735 start,starts,NULL,NULL, crossmin,phase,clockpathdelay) ;
3736 }
3737 else
3738 {
3739 for(nodex = node ; nodex->FIND->OUTLINE != NULL ; nodex = nodex->FIND->OUTLINE->ROOT)
3740 if(nodex->FIND->OUTLINE->ROOT == root) break ;
3741
3742 if(latchlist != NULL)
3743 latchlist = (ptype_list *)reverse((chain_list *)latchlist) ;
3744 if((nodex->FIND->OUTLINE == NULL) &&
3745 ((ptype = getptype(nodex->USER,TTV_NODE_CLOCK)) != NULL))
3746 {
3747 nodex = (ttvevent_list *)ptype->DATA ;
3748 for(; nodex->FIND->OUTLINE != NULL ; nodex = nodex->FIND->OUTLINE->ROOT)
3749 if(nodex->FIND->OUTLINE->ROOT == root) break ;
3750 }
3751 if((nodex->FIND->OUTLINE == NULL) &&
3752 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
3753 {
3754 nodex = (ttvevent_list *)ptype->DATA ;
3755 for(; nodex->FIND->OUTLINE != NULL ; nodex = nodex->FIND->OUTLINE->ROOT)
3756 if(nodex->FIND->OUTLINE->ROOT == root) break ;
3757 }
3758
3759 if(nodex->FIND->OUTLINE == NULL) nodex = node ;
3760 typer = (long)0 ;
3761 if((root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
3762 {
3763 previous_node=nodex;
3764 if(nodex->FIND->OUTLINE->TYPE & TTV_LINE_PR) typer = TTV_FIND_PR ;
3765 else if(nodex->FIND->OUTLINE->TYPE & TTV_LINE_EV) typer = TTV_FIND_EV ;
3766 }
3767
3768 if(((root->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS) ||
3769 ((root->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR))
3770 {
3771 if(nodex->FIND->OUTLINE->TYPE & TTV_LINE_R) typer = TTV_FIND_R ;
3772 else if(nodex->FIND->OUTLINE->TYPE & TTV_LINE_S) typer = TTV_FIND_S ;
3773 }
3774 // per_change=node->FIND->PERIOD_CHANGE;
3775 tps=ttv_getcrossvalues_notdual(ttvfig, node, type, 1);
3776 best=ttv_getbestcrossvalues(tps, type);
3777 if(latch != NULL)
3778 {
3779 long oldmode;
3780 oldmode=TTV_MORE_SEARCH_OPTIONS;
3781 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_USE_CLOCK_START;
3782 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_USE_DATA_START;
3783
3784 stb_getstbdelta(sb, latch, &datamin, &datamax, cmdlatch);
3785
3786
3787 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
3788 data = datamax ;
3789 else
3790 data=datamin;
3791 clockpathdelay=ttv_GET_FINDDELAY(node, 0)-ttv_GET_FINDDELAY(latch, 0);
3792 tpslat=ttv_getcrossvalues_notdual(ttvfig, latch, type, 0);
3793 ptps=ttv_getphasecrossvalues(tpslat, cmdlatch);
3794 if (ptps!=NULL)
3795 lcrossmin=ptps->STARTTIME;
3796 else
3797 lcrossmin=TTV_NOTIME;
3798 if (lcrossmin!=TTV_NOTIME)
3799 {
3800 phase=ttv_getcmdphase(cmdlatch);
3801 start = ttv_getinittime(ttvfig,latch,STB_NO_INDEX,type,phase,NULL) ;
3802 if (lcrossmin>=start)
3803 lcrossmin=TTV_NOTIME;
3804 if (lcrossmin!=TTV_NOTIME)
3805 data=data-(start-lcrossmin); // lag qui cross
3806 }
3807 TTV_MORE_SEARCH_OPTIONS=oldmode;
3808 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_KEEP_PHASE_INFO)!=0)
3809 phaseinfo=tpslat;
3810 else
3811 ttv_freepathstblist(tpslat);
3812 }
3813 else
3814 data=0;
3815 starts = ttv_getnodeslope(ttvfig,ttvins,node,&startsref,type) ;
3816 if (best==NULL)
3817 {
3818 start = ttv_getinittime(ttvfig,node,STB_NO_INDEX,type,STB_NO_INDEX,&phase) ;
3819 crossmin=TTV_NOTIME;
3820 }
3821 else
3822 {
3823 start = ttv_getinittime(ttvfig,node,STB_NO_INDEX,type,best->STARTPHASE,&phase) ;
3824 crossmin=best->STARTTIME;
3825 }
3826
3827 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_KEEP_PHASE_INFO)!=0 && latch==NULL)
3828 phaseinfo=tps;
3829 else
3830 ttv_freepathstblist(tps);
3831 /*
3832 if (node->FIND->CROSSDELAY_MIN!=TTV_NOTIME
3833 && (node->FIND->CROSSDELAY_MIN>=start
3834 || getptype(node->ROOT->USER, STB_IDEAL_CLOCK)!=NULL)
3835 ) node->FIND->CROSSDELAY_MIN=TTV_NOTIME;
3836 */
3837
3838 cmd=NULL;
3839 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
3840 {
3841 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0)
3842 cmd = ttv_getlinecmd(ttvfig,nodex->FIND->OUTLINE,TTV_LINE_CMDMAX) ;
3843 oslope=ttv_getslopemax(nodex->FIND->OUTLINE);
3844 }
3845 else
3846 {
3847 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0)
3848 cmd = ttv_getlinecmd(ttvfig,nodex->FIND->OUTLINE,TTV_LINE_CMDMAX) ;
3849 oslope=ttv_getslopemin(nodex->FIND->OUTLINE);
3850 }
3851 path = ttv_allocpath(path,ttvfigx,root,node,cmd,
3852 latch,cmdlatch,latchlist,data,access,refaccess,
3853 type|typer,delayref,ttv_GET_LINE_SLEW(nodex->FIND->OUTLINE, type, 1),
3854 ttv_GET_FINDDELAY(node, 0),oslope,
3855 start,starts,NULL,NULL, crossmin,phase,clockpathdelay) ;
3856 }
3857
3858 path->TTV_MORE_SEARCH_OPTIONS=TTV_MORE_SEARCH_OPTIONS;
3859 if (node->FIND->THRU_FILTER) path->TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_FLAG_THRU_FILTER_FOUND;
3860 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE!=0) path->TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_FLAG_PROGATE_USED;
3861
3862 if (phaseinfo!=NULL)
3863 path->USER=addptype(path->USER, TTV_PATH_PHASE_INFO, phaseinfo);
3864
3865 if (previous_node!=NULL)
3866 path->USER=addptype(path->USER, TTV_PATH_PREVIOUS_NODE, previous_node);
3867 /* if (per_change!=0)
3868 path->USER=addptype(path->USER, TTV_PATH_PERIOD_CHANGE, (void *)per_change);*/
3869 if (node->FIND->ORGPHASE!=TTV_NO_PHASE)
3870 path->USER=addptype(path->USER, TTV_PATH_OUTPUT_PHASE, (void *)(long)node->FIND->ORGPHASE);
3871 if((type & TTV_FIND_CARAC) == TTV_FIND_CARAC)
3872 {
3873 if (V_BOOL_TAB[__TMA_CHARAC_PRECISION].VALUE)
3874 ttv_allocpathmodel_propagate(ttvfig, ttvins, node, root,path,type);
3875 else
3876 ttv_allocpathmodel(ttvfig,path,type) ;
3877 }
3878 if((type & TTV_FIND_PATHDET) == TTV_FIND_PATHDET || (type & TTV_FIND_ALL)!=0)
3879 path->CRITIC = ttv_savcritic(ttvfig,ttvins,root,node,type,1) ;
3880 return(path) ;
3881 }
3882
3883 /*****************************************************************************/
3884 /* function ttv_savcritic() */
3885 /* parametres : */
3886 /* ttvfig : ttvfig courante */
3887 /* path : liste des chemins */
3888 /* root : signal source */
3889 /* node : signal destination */
3890 /* type : type de recherche */
3891 /* */
3892 /* recherche tous les chemins entre ptsig et les signaux de mask */
3893 /*****************************************************************************/
3894 static inline char *getlinemodel(ttvline_list *tl, long type)
3895 {
3896 if (type & TTV_FIND_MAX)
3897 return tl->MDMAX;
3898 return tl->MDMIN;
3899 }
3900
3901 ttvcritic_list *ttv_savcritic(ttvfig,ttvins,root,node,type,ignorepropagate)
3902 ttvfig_list *ttvfig ;
3903 ttvfig_list *ttvins ;
3904 ttvevent_list *root ;
3905 ttvevent_list *node ;
3906 long type ;
3907 int ignorepropagate;
3908 {
3909 ttvfig_list *ttvfigx ;
3910 ttvevent_list *nodex, *cmdlatch, *cmd ;
3911 ttvcritic_list *critic = NULL ;
3912 ttvline_list *ptline ;
3913 ptype_list *ptype ;
3914 long slope ;
3915 long newslope ;
3916 long delay ;
3917 long olddelay ;
3918 long typeline ;
3919 long start ;
3920 long data = 0 ;
3921 long datamax ;
3922 long datamin, lcrossmin ;
3923 long start0;
3924 char nodeflags=0;
3925 chain_list *line_list;
3926 stbfig_list *sb;
3927 char *lastlinemodel=NULL;
3928 ttvline_list *lastline;
3929 long oldmode;
3930 ttvpath_stb_stuff *tpslat, *ptps;
3931 char phase;
3932
3933 sb=stb_getstbfig(ttvfig);
3934 type&=~TTV_FIND_PATHDET;
3935
3936 if (!ignorepropagate && V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
3937 line_list=ttv_DoPropagation_PRECISION_LEVEL1(ttvfig, ttvins, node, root, type);
3938
3939 nodex = node ;
3940
3941 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
3942 {
3943 newslope = (long)ttv_getnodeslope(ttvfig,ttvins,node,&slope,type) ;
3944 typeline = (long) 0 ;
3945 ttvfigx = NULL ;
3946 delay = ttv_GET_FINDDELAY(node, 0);
3947 olddelay = (long) 0 ;
3948 start = ttv_getinittime(ttvfig,node,STB_NO_INDEX,type,STB_NO_INDEX,NULL) ;
3949 lastline=NULL;
3950 if((nodex->FIND->OUTLINE == NULL) &&
3951 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
3952 {
3953 critic = ttv_alloccritic(critic,ttvfig,ttvfigx,nodex,type|typeline,
3954 data,olddelay + start,slope,
3955 delay - ttv_GET_FINDDELAY(nodex, 0) + start,newslope,nodeflags,lastlinemodel,NULL) ;
3956 start = (long)0 ;
3957 nodeflags=0;
3958 olddelay = ttv_GET_FINDDELAY(nodex, 0) - ttv_GET_FINDDELAY((ttvevent_list *)ptype->DATA, 0) ;
3959 cmdlatch=nodex;
3960 nodex = (ttvevent_list *)ptype->DATA ;
3961
3962
3963 stb_getstbdelta(sb, nodex, &datamin, &datamax, cmdlatch);
3964 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
3965 data = datamax ;
3966 else
3967 data = datamin ;
3968
3969 oldmode=TTV_MORE_SEARCH_OPTIONS;
3970 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_USE_CLOCK_START;
3971 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_USE_DATA_START;
3972
3973 tpslat=ttv_getcrossvalues_notdual(ttvfig, nodex, type, 0);
3974 ptps=ttv_getphasecrossvalues(tpslat, cmdlatch);
3975 if (ptps!=NULL)
3976 lcrossmin=ptps->STARTTIME;
3977 else
3978 lcrossmin=TTV_NOTIME;
3979
3980 ttv_freepathstblist(tpslat);
3981 //lcrossmin=nodex->FIND->CROSSDELAY_MIN;
3982 if (lcrossmin!=TTV_NOTIME)
3983 {
3984 phase=ttv_getcmdphase(cmdlatch);
3985
3986 start0 = ttv_getinittime(ttvfig,nodex,STB_NO_INDEX,type,phase,NULL) ;
3987 if (((type & TTV_FIND_MAX)!=0 && lcrossmin>=start0)
3988 || ((type & TTV_FIND_MIN)!=0 && lcrossmin<=start0))
3989 lcrossmin=TTV_NOTIME;
3990 if (lcrossmin!=TTV_NOTIME)
3991 data=data-(start0-lcrossmin); // lag qui cross
3992 }
3993 TTV_MORE_SEARCH_OPTIONS=oldmode;
3994 nodeflags=TTV_NODE_FLAG_ISLATCH_ACCESS;
3995 }
3996 ptline = nodex->FIND->OUTLINE ;
3997 while(nodex->FIND->OUTLINE != NULL)
3998 {
3999 if(((type & TTV_FIND_LINE) == TTV_FIND_LINE) || (nodex == node))
4000 {
4001 critic = ttv_alloccritic(critic,ttvfig,ttvfigx,nodex,type|typeline,
4002 data,olddelay + start,slope,
4003 delay - ttv_GET_FINDDELAY(nodex, 0) + start,newslope,nodeflags,lastlinemodel,lastline) ;
4004 nodeflags=0;
4005 data = (long)0 ;
4006 start = (long)0 ;
4007 }
4008 ttv_getmodelline(ptline,&critic->MODNAME,&critic->INSNAME) ;
4009 ptline = nodex->FIND->OUTLINE ;
4010 lastline = ptline;
4011 lastlinemodel=getlinemodel(ptline, type);
4012 typeline = TTV_LINETYPE(nodex->FIND->OUTLINE) ;
4013 slope = ttv_GET_LINE_SLEW(nodex->FIND->OUTLINE, type, 1) ;
4014 olddelay = ttv_GET_LINE_DELAY(nodex->FIND->OUTLINE, type, 1) ;
4015 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
4016 newslope = ttv_getslopemax(nodex->FIND->OUTLINE) ;
4017 else
4018 newslope = ttv_getslopemin(nodex->FIND->OUTLINE) ;
4019
4020 if((nodex->FIND->OUTLINE->TYPE & TTV_LINE_A) == TTV_LINE_A
4021 || ((nodex->FIND->OUTLINE->ROOT->ROOT->TYPE & TTV_SIG_R)!=0 && getptype(nodex->FIND->OUTLINE->ROOT->USER,TTV_NODE_LATCH)!=NULL))
4022 {
4023 stb_getstbdelta(sb, nodex->FIND->OUTLINE->ROOT, &datamin, &datamax, nodex);
4024 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
4025 data = datamax ;
4026 else
4027 data = datamin ;
4028
4029 oldmode=TTV_MORE_SEARCH_OPTIONS;
4030 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_USE_CLOCK_START;
4031 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_USE_DATA_START;
4032
4033 tpslat=ttv_getcrossvalues_notdual(ttvfig, nodex->FIND->OUTLINE->ROOT, type, 0);
4034 ptps=ttv_getphasecrossvalues(tpslat, nodex);
4035 if (ptps!=NULL)
4036 lcrossmin=ptps->STARTTIME;
4037 else
4038 lcrossmin=TTV_NOTIME;
4039
4040 ttv_freepathstblist(tpslat);
4041
4042 // lcrossmin=nodex->FIND->OUTLINE->ROOT->FIND->CROSSDELAY_MIN;
4043 if (lcrossmin!=TTV_NOTIME)
4044 {
4045
4046 phase=ttv_getcmdphase(nodex);
4047 start0 = ttv_getinittime(ttvfig,nodex->FIND->OUTLINE->ROOT,STB_NO_INDEX,type,phase,NULL) ;
4048 if (((type & TTV_FIND_MAX)!=0 && lcrossmin>=start0)
4049 || ((type & TTV_FIND_MIN)!=0 && lcrossmin<=start0))
4050 lcrossmin=TTV_NOTIME;
4051 if (lcrossmin!=TTV_NOTIME)
4052 data=data-(start0-lcrossmin); // lag qui cross
4053 }
4054 TTV_MORE_SEARCH_OPTIONS=oldmode;
4055 nodeflags=TTV_NODE_FLAG_ISLATCH_ACCESS;
4056 }
4057
4058 delay = ttv_GET_FINDDELAY(nodex, 0);
4059 ttvfigx = nodex->FIND->OUTLINE->FIG ;
4060 nodex = nodex->FIND->OUTLINE->ROOT ;
4061 if((nodex->FIND->OUTLINE == NULL) &&
4062 ((ptype = getptype(nodex->USER,TTV_NODE_LATCH)) != NULL))
4063 {
4064 critic = ttv_alloccritic(critic,ttvfig,ttvfigx,nodex,type|typeline,
4065 data,olddelay + start,slope,
4066 delay - ttv_GET_FINDDELAY(nodex, 0) + start,newslope,nodeflags,lastlinemodel,lastline) ;
4067 typeline=0;
4068 start = (long)0 ;
4069 nodeflags=0;
4070 lastlinemodel=NULL;
4071 lastline=NULL;
4072 olddelay = ttv_GET_FINDDELAY(nodex, 0) - ttv_GET_FINDDELAY((ttvevent_list *)ptype->DATA, 0) ;
4073 delay = ttv_GET_FINDDELAY(nodex, 0) ;
4074 cmdlatch=nodex;
4075 nodex = (ttvevent_list *)ptype->DATA ;
4076 stb_getstbdelta(sb, nodex, &datamin, &datamax, cmdlatch);
4077 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
4078 data = datamax ;
4079 else
4080 data = datamin ;
4081
4082 oldmode=TTV_MORE_SEARCH_OPTIONS;
4083 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_USE_CLOCK_START;
4084 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_USE_DATA_START;
4085
4086 tpslat=ttv_getcrossvalues_notdual(ttvfig, nodex, type, 0);
4087 ptps=ttv_getphasecrossvalues(tpslat, cmdlatch);
4088 if (ptps!=NULL)
4089 lcrossmin=ptps->STARTTIME;
4090 else
4091 lcrossmin=TTV_NOTIME;
4092
4093 ttv_freepathstblist(tpslat);
4094 // lcrossmin=nodex->FIND->CROSSDELAY_MIN;
4095 if (lcrossmin!=TTV_NOTIME)
4096 {
4097 phase=ttv_getcmdphase(cmdlatch);
4098 start0 = ttv_getinittime(ttvfig,nodex,STB_NO_INDEX,type,phase,NULL) ;
4099 if (((type & TTV_FIND_MAX)!=0 && lcrossmin>=start0)
4100 || ((type & TTV_FIND_MIN)!=0 && lcrossmin<=start0))
4101 lcrossmin=TTV_NOTIME;
4102 if (lcrossmin!=TTV_NOTIME)
4103 data=data-(start0-lcrossmin); // lag qui cross
4104 }
4105 TTV_MORE_SEARCH_OPTIONS=oldmode;
4106 nodeflags=TTV_NODE_FLAG_ISLATCH_ACCESS;
4107 }
4108 if(nodex == root) break ;
4109 }
4110 critic = ttv_alloccritic(critic,ttvfig,ttvfigx,nodex,type|typeline,
4111 data,olddelay + start,slope,delay + start,newslope,nodeflags,lastlinemodel, ptline) ;
4112 if((type & TTV_FIND_MAX) == TTV_FIND_MAX) cmd = ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMAX) ;
4113 else cmd = ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMIN) ;
4114
4115 nodeflags=0;
4116 start = (long)0 ;
4117 data = (long)0 ;
4118 ttv_getmodelline(ptline,&critic->MODNAME,&critic->INSNAME) ;
4119 critic = ((ttvcritic_list *)reverse((chain_list *)critic));
4120 }
4121 else
4122 {
4123 start = ttv_getinittime(ttvfig,root,STB_NO_INDEX,type,STB_NO_INDEX,NULL) ;
4124 while(nodex->FIND->OUTLINE != NULL)
4125 {
4126 slope = ttv_GET_LINE_SLEW(nodex->FIND->OUTLINE, type, 1) ;
4127 olddelay = ttv_GET_LINE_DELAY(nodex->FIND->OUTLINE, type, 1) ;
4128 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
4129 newslope = ttv_getslopemax(nodex->FIND->OUTLINE) ;
4130 else
4131 newslope = ttv_getslopemin(nodex->FIND->OUTLINE) ;
4132 delay = ttv_GET_FINDDELAY(nodex->FIND->OUTLINE->NODE, 0) ;
4133 ttvfigx = nodex->FIND->OUTLINE->FIG ;
4134 typeline = TTV_LINETYPE(nodex->FIND->OUTLINE) ;
4135 ptline = nodex->FIND->OUTLINE ;
4136 if(((type & TTV_FIND_LINE) == TTV_FIND_LINE) || (nodex == node))
4137 {
4138 if(root == nodex->FIND->OUTLINE->NODE)
4139 critic = ttv_alloccritic(critic,ttvfig,ttvfigx,nodex,type|typeline,
4140 (long)0,olddelay,slope,ttv_GET_FINDDELAY(nodex, 0),newslope,nodeflags,getlinemodel(ptline, type),ptline) ;
4141 else
4142 critic = ttv_alloccritic(critic,ttvfig,ttvfigx,nodex,type|typeline,
4143 (long)0,olddelay,slope,ttv_GET_FINDDELAY(nodex, 0)-delay,newslope,nodeflags,getlinemodel(ptline, type),ptline) ;
4144 if (node==nodex)
4145 {
4146 if((type & TTV_FIND_MAX) == TTV_FIND_MAX) cmd = ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMAX) ;
4147 else cmd = ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMIN) ;
4148 }
4149
4150 }
4151 nodeflags=0;
4152 ttv_getmodelline(ptline,&critic->MODNAME,&critic->INSNAME) ;
4153 nodex = nodex->FIND->OUTLINE->NODE ;
4154 if(nodex == root) break ;
4155 }
4156 newslope = ttv_getnodeslope(ttvfig,ttvins,nodex,&slope,type) ;
4157 critic = ttv_alloccritic(critic,ttvfig,NULL,nodex,type,
4158 (long)0,start,slope,ttv_GET_FINDDELAY(nodex, 0) - delay + start,newslope,nodeflags,getlinemodel(ptline, type),NULL) ;
4159 nodeflags=0;
4160 ttv_getmodelline(ptline,&critic->MODNAME,&critic->INSNAME) ;
4161 }
4162
4163 if (!ignorepropagate && V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4164 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4165
4166 if(nodex != root)
4167 {
4168 ttv_freecriticlist(critic) ;
4169 return(NULL) ;
4170 }
4171
4172 if (critic!=NULL) critic->NODE_FLAG|=TTV_NODE_FLAG_FIRST_OF_DETAIL;
4173 return(critic) ;
4174 }
4175
4176 /*****************************************************************************/
4177 /* function ttv_keepnbpath() */
4178 /* parametres : */
4179 /* path : liste des chemins */
4180 /* nb : nombre de chemin a garder */
4181 /* type : type de recherche */
4182 /* */
4183 /* recherche le chemin le plus court ou le plus long d'une ttvfig */
4184 /*****************************************************************************/
4185 ttvpath_list *ttv_keepnbpath(ttvpath_list *path,int nb,int *nbpath,long type,LOCAL_SORT_INFO *sort_info, int dontcarehz)
4186 {
4187 ttvpath_list *pathx ;
4188 ttvpath_list *pathh ;
4189 ttvpath_list *pathr ;
4190 ttvpath_list *pathxx ;
4191 int nx ;
4192 int nbe ;
4193
4194 if(nb < 100)
4195 nx = 0 ;
4196 else
4197 nx = nb ;
4198
4199 if((type & (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_UPDW|
4200 TTV_FIND_NOT_DWUP|TTV_FIND_NOT_DWDW)) != 0 &&
4201 (!dontcarehz || !((path->ROOT->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ || (path->ROOT->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT)))
4202 {
4203 pathxx = path->NEXT ;
4204 path->NEXT = NULL ;
4205 if((path = ttv_filterpath(path,type,nbpath)) != NULL)
4206 {
4207 path->NEXT = pathxx ;
4208 }
4209 else
4210 {
4211 path = pathxx ;
4212 return(path) ;
4213 }
4214 }
4215 if(path == NULL)
4216 return(NULL) ;
4217 if(path->NEXT != NULL)
4218 {
4219 if(*nbpath == nb)
4220 {
4221 if(nx == 0)
4222 {
4223 pathx = path->NEXT ;
4224 path->NEXT = pathx->NEXT ;
4225 pathx->NEXT = NULL ;
4226 ttv_freepathlist(pathx) ;
4227 pathxx = path ;
4228 for(pathx = path->NEXT ; pathx != NULL ; pathx = pathx->NEXT)
4229 {
4230 if(((path->DELAY <= pathx->DELAY) &&
4231 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4232 ((path->DELAY >= pathx->DELAY) &&
4233 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4234 break ;
4235 pathxx = pathx ;
4236 }
4237 if(pathxx != path)
4238 {
4239 pathx = path ;
4240 path = path->NEXT ;
4241 pathx->NEXT = pathxx->NEXT ;
4242 pathxx->NEXT = pathx ;
4243 }
4244
4245 return(path) ;
4246 }
4247 else
4248 {
4249 (*nbpath)++ ;
4250 if(((path->DELAY > path->NEXT->DELAY) &&
4251 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4252 ((path->DELAY < path->NEXT->DELAY) &&
4253 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4254 {
4255 pathx = path->NEXT ;
4256 path->NEXT = path->NEXT->NEXT ;
4257 pathx->NEXT = path ;
4258 path = pathx ;
4259 sort_info->before_paths=(void *)1;
4260 }
4261 else
4262 sort_info->before_paths=NULL;
4263 sort_info->paths = path ;
4264 return(path) ;
4265 }
4266 }
4267 else if(*nbpath < nb)
4268 {
4269 (*nbpath)++ ;
4270 if(*nbpath == nb)
4271 path = ttv_classpath(path,((type & TTV_FIND_MAX) == TTV_FIND_MAX) ?
4272 TTV_FIND_MIN : TTV_FIND_MAX) ;
4273 return(path) ;
4274 }
4275 else if(*nbpath < (nb + nx - 1))
4276 {
4277 (*nbpath)++ ;
4278 if(((path->DELAY > path->NEXT->DELAY) &&
4279 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4280 ((path->DELAY < path->NEXT->DELAY) &&
4281 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4282 {
4283 pathx = path->NEXT ;
4284 path->NEXT = path->NEXT->NEXT ;
4285 pathx->NEXT = path ;
4286 path = pathx ;
4287 if (path==sort_info->paths) sort_info->paths=path->NEXT;
4288 if (path==sort_info->before_paths) sort_info->before_paths=path->NEXT;
4289 }
4290 if (sort_info->before_paths==(void *)1) sort_info->before_paths=path;
4291 return(path) ;
4292 }
4293 else
4294 {
4295 (*nbpath)++ ;
4296 if(((path->DELAY > path->NEXT->DELAY) &&
4297 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4298 ((path->DELAY < path->NEXT->DELAY) &&
4299 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4300 {
4301 pathx = path->NEXT ;
4302 path->NEXT = path->NEXT->NEXT ;
4303 pathx->NEXT = path ;
4304 path = pathx ;
4305 if (path==sort_info->paths) sort_info->paths=path->NEXT;
4306 if (path==sort_info->before_paths) sort_info->before_paths=path->NEXT;
4307 }
4308 if (sort_info->before_paths!=NULL)
4309 {
4310 pathxx = path->NEXT;
4311 path->NEXT = sort_info->paths->NEXT->NEXT;
4312 sort_info->paths->NEXT->NEXT = pathxx;
4313 pathxx = sort_info->paths->NEXT;
4314 sort_info->paths->NEXT = path;
4315 path = pathxx;
4316 }
4317
4318 pathx = sort_info->paths->NEXT ;
4319 sort_info->paths->NEXT = NULL ;
4320 path = ttv_classpath(path,((type & TTV_FIND_MAX) == TTV_FIND_MAX) ?
4321 TTV_FIND_MIN : TTV_FIND_MAX) ;
4322 nbe = 0 ;
4323 pathr = NULL ;
4324 while(pathx != NULL || path != NULL)
4325 {
4326 if(nbe < nx)
4327 {
4328 nbe ++ ;
4329 if(((path->DELAY > pathx->DELAY) &&
4330 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4331 ((path->DELAY < pathx->DELAY) &&
4332 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4333 {
4334 pathxx = pathx ;
4335 pathx = pathx->NEXT ;
4336 pathxx->NEXT = NULL ;
4337 ttv_freepathlist(pathxx) ;
4338 }
4339 else
4340 {
4341 pathxx = path ;
4342 path = path->NEXT ;
4343 pathxx->NEXT = NULL ;
4344 ttv_freepathlist(pathxx) ;
4345 }
4346 }
4347 else
4348 {
4349 if((path!=NULL) && ((pathx == NULL) || (((path->DELAY < pathx->DELAY) &&
4350 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4351 ((path->DELAY > pathx->DELAY) &&
4352 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))))
4353 {
4354 pathxx = pathx ;
4355 pathx = path ;
4356 path = pathxx ;
4357 }
4358
4359 if(pathr == NULL)
4360 {
4361 pathr = pathx ;
4362 pathh = pathr ;
4363 pathx = pathx->NEXT ;
4364 pathr->NEXT = NULL ;
4365 }
4366 else
4367 {
4368 pathr->NEXT = pathx ;
4369 pathxx = pathx->NEXT ;
4370 pathx->NEXT = NULL ;
4371 pathr = pathx ;
4372 pathx = pathxx ;
4373 }
4374 }
4375 }
4376 *nbpath = nb ;
4377 return(pathh) ;
4378 }
4379 }
4380 else
4381 {
4382 *nbpath = 1;
4383 return(path) ;
4384 }
4385 }
4386
4387 /*****************************************************************************/
4388 /* function ttv_savpathlist() */
4389 /* parametres : */
4390 /* path : list des chemins */
4391 /* root : evenement de debut */
4392 /* type : type de recherche */
4393 /* chainnode : liste des fins */
4394 /* */
4395 /* construit la liste des chemins */
4396 /*****************************************************************************/
4397 ttvpath_list *ttv_savpathlist(ttvfig,figpath,path,root,type,level,chainnode,delaymax,delaymin,savall,nb,nbcur)
4398 ttvfig_list *ttvfig ;
4399 ttvfig_list *figpath ;
4400 ttvpath_list *path ;
4401 ttvevent_list *root ;
4402 long type ;
4403 long level ;
4404 chain_list *chainnode ;
4405 long delaymax ;
4406 long delaymin ;
4407 int savall ;
4408 int nb;
4409 int *nbcur;
4410 {
4411 chain_list *chain ;
4412 chain_list *chainx ;
4413 chain_list *chainin ;
4414 chain_list *chainx2, *line_list, *thru_command_list ;
4415 ptype_list *pt, *ptype, *ptypelatch;
4416 ttvline_list *line;
4417 long delay;
4418 ttvevent_list *firstnode, *possiblelatchnode;
4419 int ret;
4420
4421 if (((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ONLYNOTHZ)!=0 && (type & TTV_FIND_HZ)!=0)
4422 || ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ONLYHZ)!=0 && (type & TTV_FIND_HZ)==0)) return path;
4423
4424 ttv_fifosave() ;
4425
4426 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
4427 {
4428 ttvevent_list *node = (ttvevent_list *)chain->DATA ;
4429 possiblelatchnode=node;
4430 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
4431
4432 if((node->ROOT->TYPE & (TTV_SIG_MASKOUT | TTV_SIG_MASKIN)) == 0)
4433 {
4434 if ((node->ROOT->TYPE & (TTV_SIG_R|TTV_SIG_L|TTV_SIG_B))!=0 && ((savall & SAVE_ALL_LATCH_TAG)==0))
4435 continue ;
4436 if ((node->ROOT->TYPE & (TTV_SIG_R|TTV_SIG_L|TTV_SIG_B))==0 && ((savall & SAVE_ALL_INPUT_TAG)==0))
4437 continue ;
4438 }
4439
4440 if(TTV_CHAIN_CLOCK==NULL || (type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
4441 {
4442 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MULTIPLE_COMMAND_CRITIC_ACCESS)!=0 && TTV_CHAIN_CLOCK!=NULL && (node->ROOT->TYPE & TTV_SIG_R)==0)
4443 {
4444 pt=ttv_getlatchaccess(ttvfig,node,type);
4445 thru_command_list=NULL;
4446 for (ptype=pt; ptype!=NULL; ptype=ptype->NEXT)
4447 thru_command_list=addchain(thru_command_list, ptype->DATA);
4448 freeptype(pt);
4449 }
4450 else thru_command_list=addchain(NULL, NULL);
4451
4452 while (thru_command_list!=NULL)
4453 {
4454 if (TTV_CHAIN_CLOCK!=NULL)
4455 {
4456 if ((node->ROOT->TYPE & (TTV_SIG_R|TTV_SIG_L|TTV_SIG_B))!=0)
4457 chainin = ttv_findclockpath(ttvfig,ttvfig,node,root,type,1,(ttvevent_list *)thru_command_list->DATA) ;
4458 else
4459 {
4460 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS)==0/*(savall & SAVE_ALL_LATCH_TAG)==0*/ || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_PATH_AND_ACCESS)!=0) // pas de vrai access
4461 chainin = addchain(NULL,node) ;
4462 else
4463 chainin = NULL;
4464 }
4465 }
4466 else if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS)==0)
4467 chainin = addchain(NULL,node) ;
4468 else
4469 chainin = NULL;
4470
4471 if (TTV_QUIET_MODE==0 && chainin==NULL && (node->ROOT->TYPE & (TTV_SIG_B|TTV_SIG_C|TTV_SIG_Q))==0)
4472 {
4473 char buf0[128];
4474 ttv_error(56,ttv_getsigname(ttvfig,buf0,node->ROOT),TTV_WARNING);
4475 }
4476
4477 for(chainx = chainin ; chainx != NULL ; chainx = chainx->NEXT)
4478 {
4479 ttvevent_list *node = (ttvevent_list *)chainx->DATA ;
4480 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
4481
4482 if (TTV_CHAIN_CLOCK!=NULL && (ret=ttv_isfalsepath(ttvfig,node,root,type,0,possiblelatchnode!=node?possiblelatchnode:NULL))!=0)
4483 {
4484 if (ret==1) TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
4485 continue;
4486 }
4487
4488 // repropagate delay
4489
4490 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && nbcur!=NULL && nb!=-1 && path!=NULL && *nbcur>=nb)
4491 {
4492 if((path->DELAY >= node->FIND->DELAY*TTV_HIGH_RATIO &&
4493 (type & TTV_FIND_MAX) == TTV_FIND_MAX) ||
4494 (path->DELAY <= node->FIND->DELAY*TTV_LOW_RATIO &&
4495 (type & TTV_FIND_MIN) == TTV_FIND_MIN))
4496 {
4497 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4498 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4499 continue;
4500 }
4501 }
4502
4503 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4504 line_list=ttv_DoPropagation_PRECISION_LEVEL1(ttvfig, figpath, node, root, type);
4505 /*
4506 if (nb!=-1 && nbcur!=NULL && path!=NULL && *nbcur>=nb)
4507 {
4508 if((path->DELAY >= ttv_GET_FINDDELAY(node, 0) &&
4509 (type & TTV_FIND_MAX) == TTV_FIND_MAX) ||
4510 (path->DELAY <= ttv_GET_FINDDELAY(node, 0) &&
4511 (type & TTV_FIND_MIN) == TTV_FIND_MIN))
4512 {
4513 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4514 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4515 continue;
4516 }
4517 }
4518 */
4519
4520 if((ttv_GET_FINDDELAY(node, 0) < delaymin) || (ttv_GET_FINDDELAY(node, 0) > delaymax))
4521 {
4522 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4523 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4524 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4525 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4526 continue ;
4527 }
4528
4529 path = ttv_savpath(ttvfig,figpath,path,root,node,type) ;
4530 if (nbcur!=NULL) (*nbcur)++;
4531
4532 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4533 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4534 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4535 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4536 }
4537 freechain(chainin);
4538 thru_command_list=delchain(thru_command_list, thru_command_list);
4539 if (thru_command_list!=NULL) ttv_fifoclean() ;
4540 }
4541 }
4542 else
4543 {
4544 firstnode=node;
4545 if ((firstnode->ROOT->TYPE & (TTV_SIG_Q|TTV_SIG_B)) != 0)
4546 ptypelatch=ttv_getcommandaccess(ttvfig,firstnode,type) ;
4547 else if((firstnode->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
4548 ptypelatch=addptype(NULL, (long)NULL, firstnode);
4549 else
4550 ptypelatch=NULL;
4551
4552 ttv_markdatapath(root, node, type, 1);
4553
4554 for(pt = ptypelatch ; pt != NULL ; pt = pt->NEXT)
4555 {
4556 ttvevent_list *node = (ttvevent_list *)pt->DATA ;
4557
4558 ttv_fifopush(node);
4559
4560 if ((firstnode->ROOT->TYPE & TTV_SIG_R) != 0)
4561 {
4562 // precharge
4563 if((ptype = getptype(node->USER,TTV_NODE_LATCH)) == NULL)
4564 node->USER = addptype(node->USER,TTV_NODE_LATCH,firstnode) ;
4565 else
4566 ptype->DATA = (void *)node ;
4567
4568 if(node->FIND->NEXT != NULL)
4569 {
4570 if(node->FIND->DELAY == TTV_NOTIME)
4571 {
4572 if(node->FIND->NEXT->DELAY != TTV_NOTIME)
4573 {
4574 node->FIND->DELAY = node->FIND->NEXT->DELAY ;
4575 node->FIND->OUTLINE = node->FIND->NEXT->OUTLINE ;
4576 }
4577 }
4578 }
4579 }
4580 else
4581 {
4582 if(pt->TYPE != (long)0)
4583 {
4584 line = (ttvline_list *)pt->TYPE ;
4585 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
4586 {
4587 if ((delay=stb_gettruncatedaccess(line->ROOT, line->NODE, 1))==TTV_NOTIME)
4588 delay = ttv_getdelaymax(line) ;
4589 }
4590 else
4591 {
4592 if ((delay=stb_gettruncatedaccess(line->ROOT, line->NODE, 0))==TTV_NOTIME)
4593 delay = ttv_getdelaymin(line) ;
4594 }
4595 }
4596 else
4597 {
4598 line = NULL ;
4599 delay = (long)0 ;
4600 }
4601 if((ptype = getptype(node->USER,TTV_NODE_LATCH)) == NULL)
4602 node->USER = addptype(node->USER,TTV_NODE_LATCH,firstnode) ;
4603 else
4604 ptype->DATA = (void *)firstnode ;
4605 node->FIND->DELAY = delay + firstnode->FIND->DELAY ;
4606 node->FIND->OUTLINE = line ;
4607 }
4608
4609 chainin = ttv_findpath(ttvfig,ttvfig,node,NULL,type,1) ;
4610
4611 for(chainx2 = chainin ; chainx2 != NULL ; chainx2 = chainx2->NEXT)
4612 {
4613 ttvevent_list *node = (ttvevent_list *)chainx2->DATA ;
4614 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
4615
4616 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && nbcur!=NULL && nb!=-1 && path!=NULL && *nbcur>=nb)
4617 {
4618 if((path->DELAY >= node->FIND->DELAY*TTV_HIGH_RATIO &&
4619 (type & TTV_FIND_MAX) == TTV_FIND_MAX) ||
4620 (path->DELAY <= node->FIND->DELAY*TTV_LOW_RATIO &&
4621 (type & TTV_FIND_MIN) == TTV_FIND_MIN))
4622 {
4623 continue;
4624 }
4625 }
4626
4627 // repropagate delay
4628 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4629 line_list=ttv_DoPropagation_PRECISION_LEVEL1(ttvfig, figpath, node, root, type);
4630
4631 if((ttv_GET_FINDDELAY(node, 0) < delaymin) || (ttv_GET_FINDDELAY(node, 0) > delaymax))
4632 {
4633 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4634 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4635 continue ;
4636 }
4637
4638 path = ttv_savpath(ttvfig,figpath,path,root,node,type) ;
4639 if (nbcur!=NULL) (*nbcur)++;
4640
4641 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4642 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4643 }
4644 }
4645
4646 ttv_markdatapath(root, node, type, 0);
4647 freeptype(ptypelatch);
4648 }
4649 ttv_fifoclean() ;
4650 }
4651
4652 ttv_fiforestore() ;
4653 level=0; // avoid warning
4654
4655 return(path) ;
4656 }
4657
4658 /*****************************************************************************/
4659 /* function ttv_savallpath() */
4660 /* parametres : */
4661 /* path : list des chemins */
4662 /* delaymax : temps maximum des chemin */
4663 /* delaymin : temps minimum des chemin */
4664 /* nb : nombre de chemin a garder */
4665 /* nb path : nombre de chemin Ren cours */
4666 /* type : type de recherche */
4667 /* chainnode : liste des fins */
4668 /* */
4669 /* construit la liste des chemins */
4670 /*****************************************************************************/
4671 ttvpath_list *ttv_savallpath(path,nb,nbpath,type,rpth,savall)
4672 ttvpath_list *path ;
4673 int nb ;
4674 int *nbpath ;
4675 long type ;
4676 ttvpath_list *rpth ;
4677 int savall ;
4678 {
4679 ttvpath_list *pathx, *npath ;
4680 // chain_list *chain ;
4681
4682 // if (path==NULL) { *nbpath=countchain((chain_list *)rpth); return rpth;}
4683
4684 for(pathx = rpth ; pathx != NULL ; pathx = npath)
4685 {
4686 npath=pathx->NEXT;
4687 if((path != NULL) && (nbpath != NULL))
4688 {
4689 if(*nbpath >= nb)
4690 {
4691 if(((path->DELAY >= pathx->DELAY) &&
4692 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4693 ((path->DELAY <= pathx->DELAY) &&
4694 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4695 {
4696 pathx->NEXT = NULL ;
4697 ttv_freepathlist(pathx) ;
4698 continue ;
4699 }
4700 }
4701 }
4702
4703 pathx->NEXT = path ;
4704 path = pathx ;
4705 if(nbpath != NULL)
4706 path = ttv_keepnbpath(path,nb,nbpath,type,&upper_sort_info,1) ;
4707 }
4708 savall=0; // avoid warning
4709 return(path) ;
4710 }
4711
4712 /*****************************************************************************/
4713 /* function ttv_savcriticpath() */
4714 /* parametres : */
4715 /* ttvfig : ttvfig courante */
4716 /* ttvins : ttvfig instance */
4717 /* path : list des chemins */
4718 /* root : evenement de debut */
4719 /* delaymax : temps maximum des chemin */
4720 /* delaymin : temps minimum des chemin */
4721 /* nb : nombre de chemin a garder */
4722 /* nb path : nombre de chemin Ren cours */
4723 /* type : type de recherche */
4724 /* chainnode : liste des fins */
4725 /* */
4726 /* construit la liste des chemins critic */
4727 /*****************************************************************************/
4728 ttvpath_list *ttv_savcriticpath(ttvfig,ttvins,path,root,delaymax,delaymin,nb,nbpath,type,level,chainnode,savall)
4729 ttvfig_list *ttvfig ;
4730 ttvfig_list *ttvins ;
4731 ttvpath_list *path ;
4732 ttvevent_list *root ;
4733 long delaymax ;
4734 long delaymin ;
4735 int nb ;
4736 int *nbpath ;
4737 long type ;
4738 long level ;
4739 chain_list *chainnode ;
4740 int savall;
4741 {
4742 ttvpath_list *pathx ;
4743 ttvevent_list *node, *firstnode, *node1, *possiblelatchnode;
4744 chain_list *chain ;
4745 chain_list *chainx ;
4746 chain_list *chainin ;
4747 chain_list *chainx2, *line_list, *thru_command_list;
4748 ptype_list *pt, *ptype, *ptypelatch;
4749 ttvline_list *line;
4750 long delay;
4751 int abort,ret;
4752
4753 if (((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ONLYNOTHZ)!=0 && (type & TTV_FIND_HZ)!=0)
4754 || ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ONLYHZ)!=0 && (type & TTV_FIND_HZ)==0)) return path;
4755
4756 ttv_fifosave() ;
4757
4758 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
4759 {
4760 node = (ttvevent_list *)chain->DATA ;
4761 possiblelatchnode=node;
4762 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
4763
4764 if(((((node->ROOT->TYPE & TTV_SIG_MASKIN) != TTV_SIG_MASKIN) &&
4765 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)) ||
4766 (((node->ROOT->TYPE & TTV_SIG_MASKOUT) != TTV_SIG_MASKOUT) &&
4767 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL))))
4768 {
4769 if ((node->ROOT->TYPE & (TTV_SIG_R|TTV_SIG_L|TTV_SIG_B))!=0 && ((savall & SAVE_ALL_LATCH_TAG)==0))
4770 continue ;
4771 if ((node->ROOT->TYPE & (TTV_SIG_R|TTV_SIG_L|TTV_SIG_B))==0 && ((savall & SAVE_ALL_INPUT_TAG)==0))
4772 continue ;
4773 }
4774
4775 if(TTV_CHAIN_CLOCK==NULL || (type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
4776 {
4777 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MULTIPLE_COMMAND_CRITIC_ACCESS)!=0 && TTV_CHAIN_CLOCK!=NULL && (node->ROOT->TYPE & TTV_SIG_R)==0)
4778 {
4779 pt=ttv_getlatchaccess(ttvfig,node,type);
4780 thru_command_list=NULL;
4781 for (ptype=pt; ptype!=NULL; ptype=ptype->NEXT)
4782 thru_command_list=addchain(thru_command_list, ptype->DATA);
4783 freeptype(pt);
4784 }
4785 else thru_command_list=addchain(NULL, NULL);
4786
4787 node1=node;
4788
4789 while (thru_command_list!=NULL)
4790 {
4791 if (TTV_CHAIN_CLOCK!=NULL)
4792 {
4793 if ((node1->ROOT->TYPE & (TTV_SIG_R|TTV_SIG_L|TTV_SIG_B))!=0)
4794 chainin = ttv_findclockpath(ttvfig,ttvfig,node1,root,type,1,(ttvevent_list *)thru_command_list->DATA) ;
4795 else
4796 {
4797 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS)==0/*(savall & SAVE_ALL_LATCH_TAG)==0*/ || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_PATH_AND_ACCESS)!=0) // pas de vrai access
4798 chainin = addchain(NULL,node1) ;
4799 else
4800 chainin = NULL;
4801 }
4802 }
4803 else if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS)==0)
4804 {
4805 // --------- zinaps + ------------
4806 if(((((node1->ROOT->TYPE & TTV_SIG_MASKIN) != TTV_SIG_MASKIN) &&
4807 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)) ||
4808 (((node1->ROOT->TYPE & TTV_SIG_MASKOUT) != TTV_SIG_MASKOUT) &&
4809 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL))))
4810 {
4811 thru_command_list=delchain(thru_command_list, thru_command_list);
4812 continue;
4813 }
4814 // -------------------------------
4815 chainin = addchain(NULL,node1) ;
4816 }
4817 else chainin=NULL;
4818
4819 if (TTV_QUIET_MODE==0 && chainin==NULL && (node1->ROOT->TYPE & (TTV_SIG_B|TTV_SIG_C|TTV_SIG_Q))==0)
4820 {
4821 char buf0[128];
4822 ttv_error(56,ttv_getsigname(ttvfig,buf0,node1->ROOT),TTV_WARNING);
4823 }
4824
4825 for(chainx = chainin ; chainx != NULL ; chainx = chainx->NEXT)
4826 {
4827 ttvevent_list *node = (ttvevent_list *)chainx->DATA ;
4828 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
4829
4830 // test des falsepaths pour les critic access
4831 abort=0;
4832 /* if (TTV_CHAIN_CLOCK!=NULL)
4833 {
4834 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
4835 abort=ttv_isfalsepath(ttvfig,root,node,type);
4836 else
4837 abort=ttv_isfalsepath(ttvfig,node,root,type);
4838 }
4839 */
4840 if (TTV_CHAIN_CLOCK!=NULL && (ret=ttv_isfalsepath(ttvfig,node,root,type,0,possiblelatchnode!=node?possiblelatchnode:NULL))!=0)
4841 {
4842 if (ret==1) TTV_SEARCH_INFORMATIONS|=TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
4843 continue;
4844 }
4845
4846 if(abort==0 && V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && path != NULL && *nbpath >= nb)
4847 {
4848 if((path->DELAY >= node->FIND->DELAY*TTV_HIGH_RATIO &&
4849 (type & TTV_FIND_MAX) == TTV_FIND_MAX) ||
4850 (path->DELAY <= node->FIND->DELAY*TTV_LOW_RATIO &&
4851 (type & TTV_FIND_MIN) == TTV_FIND_MIN))
4852 {
4853 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4854 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4855 continue ;
4856 }
4857 }
4858
4859 // repropagate delay
4860 if (!abort && V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4861 line_list=ttv_DoPropagation_PRECISION_LEVEL1(ttvfig, ttvins, node, root, type);
4862
4863 if(abort || (ttv_GET_FINDDELAY(node, 0) > delaymax) || (ttv_GET_FINDDELAY(node, 0) < delaymin))
4864 {
4865 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4866 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4867 if (!abort && V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4868 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4869 continue ;
4870 }
4871
4872 if(path != NULL)
4873 {
4874 if(*nbpath >= nb)
4875 {
4876 if(((path->DELAY >= ttv_GET_FINDDELAY(node, 0)) &&
4877 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
4878 ((path->DELAY <= ttv_GET_FINDDELAY(node, 0)) &&
4879 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
4880 {
4881 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4882 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4883 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4884 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4885 continue ;
4886 }
4887 }
4888 }
4889
4890 pathx = path ;
4891 path = ttv_savpath(ttvfig,ttvins,path,root,node,type) ;
4892
4893 if(getptype(node->USER,TTV_NODE_CLOCK) != NULL)
4894 node->USER = delptype(node->USER,TTV_NODE_CLOCK) ;
4895 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4896 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4897
4898 if(pathx == path)
4899 continue ;
4900
4901 path = ttv_keepnbpath(path,nb,nbpath,type,&upper_sort_info,1) ;
4902 }
4903 freechain(chainin) ;
4904 thru_command_list=delchain(thru_command_list, thru_command_list);
4905 if (thru_command_list!=NULL) ttv_fifoclean() ;
4906 }
4907 }
4908 else
4909 {
4910 firstnode=node;
4911 if ((firstnode->ROOT->TYPE & (TTV_SIG_Q|TTV_SIG_B)) != 0)
4912 ptypelatch=ttv_getcommandaccess(ttvfig,firstnode,type) ;
4913 else if((firstnode->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
4914 ptypelatch=addptype(NULL, (long)NULL, firstnode);
4915 else
4916 ptypelatch=NULL;
4917
4918 for(pt = ptypelatch ; pt != NULL ; pt = pt->NEXT)
4919 {
4920 ttvevent_list *node = (ttvevent_list *)pt->DATA ;
4921
4922 ttv_fifopush(node);
4923
4924 if ((firstnode->ROOT->TYPE & TTV_SIG_R) != 0)
4925 {
4926 // precharge
4927 if((ptype = getptype(node->USER,TTV_NODE_LATCH)) == NULL)
4928 node->USER = addptype(node->USER,TTV_NODE_LATCH,firstnode) ;
4929 else
4930 ptype->DATA = (void *)node ;
4931
4932 if(node->FIND->NEXT != NULL)
4933 {
4934 if(node->FIND->DELAY == TTV_NOTIME)
4935 {
4936 if(node->FIND->NEXT->DELAY != TTV_NOTIME)
4937 {
4938 node->FIND->DELAY = node->FIND->NEXT->DELAY ;
4939 node->FIND->OUTLINE = node->FIND->NEXT->OUTLINE ;
4940 }
4941 }
4942 }
4943 }
4944 else
4945 {
4946 if(pt->TYPE != (long)0)
4947 {
4948 line = (ttvline_list *)pt->TYPE ;
4949 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
4950 {
4951 if ((delay=stb_gettruncatedaccess(line->ROOT, line->NODE, 1))==TTV_NOTIME)
4952 delay = ttv_getdelaymax(line) ;
4953 }
4954 else
4955 {
4956 if ((delay=stb_gettruncatedaccess(line->ROOT, line->NODE, 0))==TTV_NOTIME)
4957 delay = ttv_getdelaymin(line) ;
4958 }
4959 }
4960 else
4961 {
4962 line = NULL ;
4963 delay = (long)0 ;
4964 }
4965 if((ptype = getptype(node->USER,TTV_NODE_LATCH)) == NULL)
4966 node->USER = addptype(node->USER,TTV_NODE_LATCH,firstnode) ;
4967 else
4968 ptype->DATA = (void *)firstnode ;
4969 node->FIND->DELAY = delay + firstnode->FIND->DELAY ;
4970 node->FIND->OUTLINE = line ;
4971 }
4972
4973 chainin = ttv_findpath(ttvfig,ttvfig,node,NULL,type,1) ;
4974
4975 for(chainx2 = chainin ; chainx2 != NULL ; chainx2 = chainx2->NEXT)
4976 {
4977 ttvevent_list *node = (ttvevent_list *)chainx2->DATA ;
4978 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
4979
4980 if(V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && path != NULL && *nbpath >= nb)
4981 {
4982 if((path->DELAY >= node->FIND->DELAY*TTV_HIGH_RATIO &&
4983 (type & TTV_FIND_MAX) == TTV_FIND_MAX) ||
4984 (path->DELAY <= node->FIND->DELAY*TTV_LOW_RATIO &&
4985 (type & TTV_FIND_MIN) == TTV_FIND_MIN))
4986 {
4987 continue ;
4988 }
4989 }
4990
4991 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4992 line_list=ttv_DoPropagation_PRECISION_LEVEL1(ttvfig, ttvins, node, root, type);
4993
4994 if((ttv_GET_FINDDELAY(node, 0) > delaymax) || (ttv_GET_FINDDELAY(node, 0) < delaymin))
4995 {
4996 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
4997 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
4998 continue ;
4999 }
5000
5001 if(path != NULL)
5002 {
5003 if(*nbpath >= nb)
5004 {
5005 if(((path->DELAY >= node->FIND->DELAY) &&
5006 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
5007 ((path->DELAY <= node->FIND->DELAY) &&
5008 ((type & TTV_FIND_MIN) == TTV_FIND_MIN)))
5009 {
5010 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
5011 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
5012 continue ;
5013 }
5014 }
5015 }
5016
5017 pathx = path ;
5018 path = ttv_savpath(ttvfig,ttvins,path,root,node,type) ;
5019
5020 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
5021 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
5022
5023 if(pathx == path)
5024 continue ;
5025
5026 path = ttv_keepnbpath(path,nb,nbpath,type,&upper_sort_info,1) ;
5027 }
5028 }
5029 freeptype(ptypelatch);
5030 }
5031 ttv_fifoclean() ;
5032 }
5033
5034 ttv_fiforestore() ;
5035 level=0; // avoid warning
5036 return(path) ;
5037 }
5038
5039 static int computesavealltag(chain_list *inputs,int allinterm)
5040 {
5041 chain_list *cl;
5042
5043 // if (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS) return SAVE_ALL_TAG;
5044
5045 if (allinterm && inputs==NULL) return SAVE_ALL_TAG;
5046 /*
5047 if (TTV_CHAIN_CLOCK==NULL) return 0;
5048
5049 while (inputs!=NULL)
5050 {
5051 for (cl=TTV_CHAIN_CLOCK; cl!=NULL && cl->DATA!=inputs->DATA; cl=cl->NEXT) ;
5052 if (cl!=NULL) return SAVE_ALL_LATCH_TAG;
5053 inputs=inputs->NEXT;
5054 }
5055 */
5056 return 0;
5057 }
5058
5059 /*****************************************************************************/
5060 /* function ttv_findsigpath() */
5061 /* parametres : */
5062 /*****************************************************************************/
5063 ttvpath_list *ttv_findsigpath(ttvfig,ttvins,figsearch,begin,end,cmd,delaymax,delaymin,type,level,path,searchtype,nb,nbcur,savall,pthz)
5064 ttvfig_list *ttvfig ;
5065 ttvfig_list *ttvins ;
5066 ttvfig_list *figsearch ;
5067 ttvevent_list *begin ;
5068 ttvevent_list *end ;
5069 ttvevent_list *cmd ;
5070 long delaymax ;
5071 long delaymin ;
5072 long type ;
5073 long level ;
5074 ttvpath_list *path ;
5075 char searchtype ;
5076 int nb ;
5077 int *nbcur ;
5078 int savall ;
5079 char *pthz ;
5080 {
5081 chain_list *chain ;
5082 chain_list *chainpath ;
5083 ttvpath_list *pth, *rpth;
5084 char typehz ;
5085 char typers, filter=0 ;
5086 ttvsig_list *tvs;
5087
5088 mbk_comcheck( 0, 0, ttv_signtimingfigure(ttvfig) );
5089
5090 TTV_SEARCH_FIRST_NODE=begin;
5091
5092 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
5093 {
5094 if(TTV_FIND_ALLPATH == 'N')
5095 chainpath = ttv_findaccess(ttvfig,figsearch,begin,cmd,type,level) ;
5096 else
5097 pth = (ttvpath_list *)ttv_findpara(ttvfig,ttvins,begin,end,delaymax,delaymin,type,level,NULL,TTV_MAX_PATHNB,savall) ;
5098
5099 typehz = 'N' ;
5100 typers = 'N' ;
5101
5102 if(TTV_FIND_ALLPATH == 'N')
5103 for(chain = chainpath ; chain != NULL ; chain = chain->NEXT)
5104 {
5105 tvs=((ttvevent_list *)chain->DATA)->ROOT;
5106 if(((((tvs->TYPE & TTV_SIG_MASKIN) != TTV_SIG_MASKIN) &&
5107 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)) ||
5108 (((tvs->TYPE & TTV_SIG_MASKOUT) != TTV_SIG_MASKOUT) &&
5109 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)))) continue;
5110
5111 if((tvs->TYPE & TTV_SIG_R) == TTV_SIG_R || (tvs->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ || (tvs->TYPE & TTV_SIG_CT) == TTV_SIG_CT)
5112 {
5113 if ((tvs->TYPE & TTV_SIG_R) != TTV_SIG_R) filter=1;
5114 typehz = 'Y' ;
5115 }
5116 if((tvs->TYPE & TTV_SIG_LR)== TTV_SIG_LR ||
5117 (tvs->TYPE & TTV_SIG_LS)== TTV_SIG_LS)
5118 typers = 'Y' ;
5119 }
5120 else
5121 for(rpth = pth ; rpth != NULL ; rpth = rpth->NEXT)
5122 {
5123 if(((rpth->ROOT->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) || ((rpth->ROOT->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) || ((rpth->ROOT->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
5124 {
5125 if ((rpth->ROOT->ROOT->TYPE & TTV_SIG_R) != TTV_SIG_R) filter=1;
5126 typehz = 'Y' ;
5127 }
5128 if(((rpth->ROOT->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
5129 ((rpth->ROOT->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
5130 typers = 'Y' ;
5131 }
5132
5133 if(typers == 'Y')
5134 {
5135 if(TTV_FIND_ALLPATH == 'N')
5136 {
5137 for(chain = chainpath ; chain != NULL ; chain = chain->NEXT)
5138 {
5139 ttvevent_list *node = (ttvevent_list *)chain->DATA ;
5140 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
5141 }
5142 freechain(chainpath) ;
5143 }
5144 else
5145 {
5146 ttv_freepathlist(rpth) ;
5147 }
5148 ttv_fifoclean() ;
5149 if(TTV_FIND_ALLPATH == 'N')
5150 chainpath = ttv_findaccess(ttvfig,figsearch,begin,cmd,type|TTV_FIND_R,level) ;
5151 else
5152 pth = (ttvpath_list *)ttv_findpara(ttvfig,ttvins,begin,end,delaymax,delaymin,type|TTV_FIND_R,level,NULL,(typehz=='Y')?TTV_MAX_PATHNB:nb,savall) ;
5153 }
5154 }
5155 else
5156 {
5157 if(((begin->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
5158 ((begin->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
5159 ((begin->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
5160 {
5161 if ((begin->ROOT->TYPE & TTV_SIG_R) != TTV_SIG_R) filter=1;
5162 typehz = 'Y' ;
5163 }
5164 else
5165 typehz = 'N' ;
5166
5167 if(((begin->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS) ||
5168 ((begin->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR))
5169 {
5170 typers = 'Y' ;
5171 if(TTV_FIND_ALLPATH == 'N')
5172 {
5173 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0)
5174 chainpath = ttv_findaccess(ttvfig,figsearch,begin,cmd,type|TTV_FIND_R,level) ;
5175 else
5176 {
5177 ttv_fifopush(begin) ;
5178 ttv_uncachenodelines(ttvfig,figsearch,begin, type);
5179 begin->FIND->DELAY = 0 ;
5180 chainpath=addchain(NULL, begin);
5181 }
5182 }
5183 else
5184 pth = (ttvpath_list *)ttv_findpara(ttvfig,ttvins,begin,end,delaymax,delaymin,type|TTV_FIND_R,level,NULL,(filter)?TTV_MAX_PATHNB:nb,savall) ;
5185 }
5186 else
5187 {
5188 if(TTV_FIND_ALLPATH == 'N')
5189 {
5190 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0 || (begin->ROOT->TYPE & (TTV_SIG_L|TTV_SIG_B))==0)
5191 chainpath = ttv_findaccess(ttvfig,figsearch,begin,cmd,type,level) ;
5192 else
5193 {
5194 ttv_fifopush(begin) ;
5195 ttv_uncachenodelines(ttvfig,figsearch,begin, type);
5196 begin->FIND->DELAY = 0 ;
5197 chainpath=addchain(NULL, begin);
5198 }
5199 }
5200 else
5201 pth = (ttvpath_list *)ttv_findpara(ttvfig,ttvins,begin,end,delaymax,delaymin,type,level,NULL,(filter)?TTV_MAX_PATHNB:nb,savall) ;
5202 typers = 'N' ;
5203 }
5204 }
5205
5206 if(TTV_FIND_ALLPATH == 'N')
5207 {
5208 if(searchtype == TTV_SEARCH_PATH)
5209 path = ttv_savpathlist(ttvfig,ttvins,path,begin,(typers == 'Y') ? type|TTV_FIND_R : type,level,chainpath,delaymax,delaymin,savall,((type & TTV_FIND_DUAL) == TTV_FIND_DUAL || typehz=='Y')?TTV_MAX_PATHNB:nb,nbcur) ;
5210 else
5211 path = ttv_savcriticpath(ttvfig,ttvins,path,begin,delaymax,delaymin,(filter)?TTV_MAX_PATHNB:nb,nbcur,(typers == 'Y') ? type|TTV_FIND_R : type,level,chainpath,savall) ;
5212 freechain(chainpath) ;
5213 }
5214 else
5215 {
5216 path = ttv_savallpath(path,(filter)?TTV_MAX_PATHNB:nb,nbcur,(typers == 'Y') ? type|TTV_FIND_R : type,pth,savall) ;
5217 }
5218
5219 ttv_fifoclean() ;
5220
5221 if(typers == 'Y')
5222 {
5223 if(TTV_FIND_ALLPATH == 'N')
5224 chainpath = ttv_findaccess(ttvfig,figsearch,begin,cmd,type|TTV_FIND_S,level) ;
5225 else
5226 pth = (ttvpath_list *)ttv_findpara(ttvfig,ttvins,begin,end,delaymax,delaymin,type|TTV_FIND_S,level,NULL,(filter)?TTV_MAX_PATHNB:nb,savall) ;
5227 if(TTV_FIND_ALLPATH == 'N')
5228 {
5229 if(searchtype == TTV_SEARCH_PATH)
5230 path = ttv_savpathlist(ttvfig,ttvins,path,begin,type|TTV_FIND_S,level,chainpath,delaymax,delaymin,savall,((type & TTV_FIND_DUAL) == TTV_FIND_DUAL || filter)?TTV_MAX_PATHNB:nb,nbcur) ;
5231 else
5232 path = ttv_savcriticpath(ttvfig,ttvins,path,begin,delaymax,delaymin,(filter)?TTV_MAX_PATHNB:nb,nbcur,type|TTV_FIND_S,level,chainpath,savall) ;
5233 freechain(chainpath) ;
5234 }
5235 else
5236 {
5237 path = ttv_savallpath(path,(filter)?TTV_MAX_PATHNB:nb,nbcur,type|TTV_FIND_S,pth,savall) ;
5238 }
5239 ttv_fifoclean() ;
5240 }
5241
5242 if(typehz == 'Y')
5243 {
5244 if (filter) *pthz = 'Y' ;
5245 if(TTV_FIND_ALLPATH == 'N')
5246 {
5247 chainpath = ttv_findaccess(ttvfig,figsearch,begin,cmd,type|TTV_FIND_HZ,level) ;
5248 }
5249 else
5250 pth = (ttvpath_list *)ttv_findpara(ttvfig,ttvins,begin,end,delaymax,delaymin,type|TTV_FIND_HZ,level,NULL,(filter)?TTV_MAX_PATHNB:nb,savall) ;
5251 if(TTV_FIND_ALLPATH == 'N')
5252 {
5253 if(searchtype == TTV_SEARCH_PATH)
5254 path = ttv_savpathlist(ttvfig,ttvins,path,begin,type|TTV_FIND_HZ,level,chainpath,delaymax,delaymin,savall,((type & TTV_FIND_DUAL) == TTV_FIND_DUAL || typehz=='Y')?TTV_MAX_PATHNB:nb,nbcur) ;
5255 else
5256 path = ttv_savcriticpath(ttvfig,ttvins,path,begin,delaymax,delaymin,(filter)?TTV_MAX_PATHNB:nb,nbcur,type|TTV_FIND_HZ,level,chainpath,savall) ;
5257 freechain(chainpath) ;
5258 }
5259 else
5260 {
5261 path = ttv_savallpath(path,(filter)?TTV_MAX_PATHNB:nb,nbcur,type|TTV_FIND_HZ,pth,savall) ;
5262 }
5263 ttv_fifoclean() ;
5264 }
5265
5266 return(path) ;
5267 }
5268
5269 /*****************************************************************************/
5270 /* function ttv_getcriticpath() */
5271 /* parametres : */
5272 /* ttvfig : ttvfig courante */
5273 /* maskin : list de masques pour les entrees */
5274 /* maskout : list de masques pour les sorties */
5275 /* delaymax : temps maximum des chemin */
5276 /* delaymin : temps maximum des chemin */
5277 /* nb : nombre de chemin a garder */
5278 /* type : type de recherche */
5279 /* */
5280 /* recherche le chemin le plus court ou le plus long d'une ttvfig */
5281 /*****************************************************************************/
5282 ttvpath_list *ttv_getcriticpath(ttvfig,figpath,maskin,maskout,delaymax,delaymin,nb,type)
5283 ttvfig_list *ttvfig ;
5284 ttvfig_list *figpath ;
5285 chain_list *maskin ;
5286 chain_list *maskout ;
5287 long delaymax ;
5288 long delaymin ;
5289 int nb ;
5290 long type ;
5291 {
5292 ttvfig_list *ttvins ;
5293 ttvsig_list *ptsig ;
5294 chain_list *chainx, *event_to_retry, *chc, *chainc ;
5295 chain_list *chaininx ;
5296 chain_list *chaininsav ;
5297 chain_list *chainfig ;
5298 chain_list *chainfigsav ;
5299 chain_list *chainfigdel ;
5300 ttvpath_list *path = NULL, *pathx, *npathx, *prevpathx ;
5301 chain_list *chain ;
5302 long level, searchsigtype ;
5303 // int nbx = 1 ; changed zinaps
5304 int nbx = 0 ;
5305 int i, savealltag, allfailed ;
5306 char typehz ;
5307
5308 if(((type & TTV_FIND_PATH) == TTV_FIND_PATH) ||
5309 ((type & TTV_FIND_LINE) != TTV_FIND_LINE))
5310 {
5311 type &= ~(TTV_FIND_LINE | TTV_FIND_HIER) ;
5312 type |= TTV_FIND_PATH ;
5313 }
5314 else
5315 type &= ~(TTV_FIND_HIER) ;
5316
5317 if(nb <= 0) nb = 1 ;
5318
5319 if(figpath == NULL)
5320 chainfigsav = reverse(ttv_getttvfiglist(ttvfig)) ;
5321 else
5322 chainfigsav = addchain(NULL,figpath) ;
5323
5324 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5325 {
5326 if (TTV_EXPLICIT_START_NODES==NULL)
5327 chaininsav = ttv_getsigbytype_and_netname(ttvfig,figpath,TTV_SIG_C|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B/*|TTV_SIG_Q*/,maskin) ;
5328 else
5329 chaininsav = dupchainlst(TTV_EXPLICIT_START_NODES);
5330 chaininsav = ttv_apply_exclude_flag(chaininsav, TTV_EXCLUDE_TYPE_START, 0/*1*/);
5331 chaininsav = ttv_remove_connector_B(chaininsav);
5332 }
5333 else
5334 {
5335 if (TTV_EXPLICIT_END_NODES==NULL)
5336 chaininsav = ttv_getsigbytype_and_netname(ttvfig,figpath,TTV_SIG_C|TTV_SIG_Q|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B,maskout) ;
5337 else
5338 chaininsav = dupchainlst(TTV_EXPLICIT_END_NODES);
5339 chaininsav = ttv_apply_exclude_flag(chaininsav, TTV_EXCLUDE_TYPE_END, 0);
5340
5341 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DONT_FILTER_ENDING_NODE)!=0 && stb_getstbfig(ttvfig)!=NULL)
5342 {
5343 // not possible for filter in dual mode
5344 for (chain=chaininsav; chain!=NULL; chain=chain->NEXT)
5345 {
5346 if (stb_has_filter_directive(((ttvsig_list *)chain->DATA)->NODE)
5347 || stb_has_filter_directive(((ttvsig_list *)chain->DATA)->NODE+1)) break;
5348 }
5349 if (chain!=NULL)
5350 {
5351 // revert back to not dual mode
5352 freechain(chaininsav);
5353 if (TTV_EXPLICIT_START_NODES==NULL)
5354 chaininsav = ttv_getsigbytype_and_netname(ttvfig,figpath,TTV_SIG_C|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B/*|TTV_SIG_Q*/,maskin) ;
5355 else
5356 chaininsav = dupchainlst(TTV_EXPLICIT_START_NODES);
5357 chaininsav = ttv_apply_exclude_flag(chaininsav, TTV_EXCLUDE_TYPE_START, 0/*1*/);
5358 chaininsav = ttv_remove_connector_B(chaininsav);
5359 type&=~TTV_FIND_DUAL;
5360 }
5361 }
5362 }
5363
5364 // calcul si on doit ignorer le maskin pour les latchs des access
5365 savealltag=computesavealltag(chaininsav, 0);
5366
5367 for(chaininx = chaininsav ; chaininx != NULL ; chaininx = chaininx->NEXT)
5368 {
5369 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5370 ((ttvsig_list *)chaininx->DATA)->TYPE |= TTV_SIG_MASKIN ;
5371 else
5372 ((ttvsig_list *)chaininx->DATA)->TYPE |= TTV_SIG_MASKOUT ;
5373 }
5374
5375 chainfigdel = chainfigsav ;
5376 for(chainfig = chainfigsav ; chainfig != NULL ; chainfig = chainfig->NEXT)
5377 {
5378 ttvins = (ttvfig_list *)chainfig->DATA ;
5379 if(((ttvins->STATUS & TTV_STS_MODEL) != TTV_STS_MODEL) &&
5380 (maskin == NULL) && (maskout == NULL))
5381 continue ;
5382
5383 if(ttvins == ttvfig)
5384 level = ttvfig->INFO->LEVEL ;
5385 else
5386 level = (long)0 ;
5387
5388 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5389 {
5390 if (TTV_EXPLICIT_END_NODES==NULL)
5391 chain = ttv_getsigbytype_and_netname(ttvfig,ttvins,TTV_SIG_C|TTV_SIG_Q|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B,maskout) ;
5392 else
5393 chain=dupchainlst(TTV_EXPLICIT_END_NODES);
5394 chain = ttv_apply_exclude_flag(chain, TTV_EXCLUDE_TYPE_END, 0);
5395 }
5396 else
5397 {
5398 searchsigtype=TTV_SIG_C|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B/*|TTV_SIG_Q*/;
5399 // if (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ENABLE_START_ON_TTV_SIG_Q) searchsigtype|=TTV_SIG_Q;
5400 if (TTV_EXPLICIT_START_NODES==NULL)
5401 chain = ttv_getsigbytype_and_netname(ttvfig,ttvins,searchsigtype,maskin) ;
5402 else
5403 chain=dupchainlst(TTV_EXPLICIT_START_NODES);
5404 chain = ttv_apply_exclude_flag(chain, TTV_EXCLUDE_TYPE_START, 0/*1*/);
5405 chain = ttv_remove_connector_B(chain);
5406 }
5407
5408 event_to_retry=NULL;
5409
5410 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
5411 {
5412 ptsig = (ttvsig_list *)chainx->DATA ;
5413 if((ptsig->TYPE & TTV_SIG_C) == TTV_SIG_C)
5414 if((((ptsig->TYPE & TTV_SIG_CO) != TTV_SIG_CO) &&
5415 ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)) ||
5416 (((ptsig->TYPE & TTV_SIG_CI) != TTV_SIG_CI) &&
5417 ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)))
5418 continue ;
5419
5420 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL && (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DIFF_ENDING_CRITIC_COMMAND))
5421 chainc = ttv_getlrcmd(ttvfig,ptsig) ;
5422 else
5423 chainc = NULL;
5424
5425 if(chainc == NULL)
5426 chainc = addchain(chainc,NULL) ;
5427
5428 allfailed=0;
5429 for(chc = chainc ; chc != NULL ; chc = chc->NEXT)
5430 {
5431 typehz = 'N' ;
5432
5433 for(i = 0 ; i < 2 ; i++)
5434 {
5435 if((((((type & (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_UPDW)) == (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_UPDW)) && (i == 1)) ||
5436 (((type & (TTV_FIND_NOT_DWUP|TTV_FIND_NOT_DWDW)) == (TTV_FIND_NOT_DWUP|TTV_FIND_NOT_DWDW)) && (i == 0)))
5437 && ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)) ||
5438 (((((type & (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_DWUP)) == (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_DWUP)) && (i == 1)) ||
5439 (((type & (TTV_FIND_NOT_UPDW|TTV_FIND_NOT_DWDW)) == (TTV_FIND_NOT_UPDW|TTV_FIND_NOT_DWDW)) && (i == 0)))
5440 && ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5441 && (ptsig->TYPE & (TTV_SIG_CT|TTV_SIG_CZ))==0 // pour le filtrage HZ
5442 ))
5443 continue ;
5444 TTV_SEARCH_INFORMATIONS&=~TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
5445 path = (ttvpath_list *)ttv_findsigpath(ttvfig,ttvins,ttvins,ptsig->NODE+i,NULL,(ttvevent_list *)chc->DATA,delaymax,delaymin,type,level,path,TTV_SEARCH_CRITICPATH,nb,&nbx,savealltag,&typehz) ;
5446 if (TTV_SEARCH_INFORMATIONS & TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH)
5447 {
5448 event_to_retry=addchain(event_to_retry, ptsig->NODE+i);
5449 allfailed|=1<i;
5450 if (typehz=='Y')
5451 {
5452 // pour le filtre des HZ il faut les 2 events, donc on recherhera les // pour les 2 events
5453 allfailed=3;
5454 if (i==0)
5455 {
5456 event_to_retry=addchain(event_to_retry, ptsig->NODE+1);
5457 break;
5458 }
5459 else
5460 {
5461 event_to_retry=addchain(event_to_retry, ptsig->NODE);
5462 }
5463 }
5464 }
5465 }
5466 if (allfailed==3) break;
5467 }
5468
5469 freechain(chainc);
5470
5471 if(typehz == 'Y')
5472 path = ttv_filterpathhz(path,&nbx, nb,&upper_sort_info, type) ;
5473
5474 typehz = 'N' ;
5475 }
5476 freechain(chain) ;
5477
5478 if (event_to_retry!=NULL)
5479 {
5480 int r_nbx, retried_nbx=0;
5481 ttvpath_list *retried_list=NULL;
5482 ttvevent_list *tve;
5483
5484
5485 // remove signal to retry from the list
5486 for (chain=event_to_retry; chain!=NULL; chain=chain->NEXT)
5487 ((ttvevent_list *)chain->DATA)->TYPE|=TTV_NODE_MARQUE;
5488
5489 for (pathx=path; pathx!=NULL; pathx=npathx)
5490 {
5491 npathx=pathx->NEXT;
5492 if ((type & TTV_FIND_DUAL)!=0) tve=pathx->NODE; else tve=pathx->ROOT;
5493 if (tve->TYPE & TTV_NODE_MARQUE)
5494 {
5495 if (pathx==path) path=npathx; else prevpathx->NEXT=npathx;
5496 pathx->NEXT=NULL;
5497 ttv_freepathlist(pathx);
5498 nbx--;
5499 }
5500 else prevpathx=pathx;
5501 }
5502 for (chain=event_to_retry; chain!=NULL; chain=chain->NEXT)
5503 ((ttvevent_list *)chain->DATA)->TYPE&=~TTV_NODE_MARQUE;
5504
5505 TTV_FIND_ALLPATH='Y';
5506 if ((type & TTV_FIND_ACCESS)==0) TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH;
5507
5508 while (event_to_retry!=NULL)
5509 {
5510 tve = (ttvevent_list *)event_to_retry->DATA ;
5511
5512 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL && (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_DIFF_ENDING_CRITIC_COMMAND))
5513 chainc = ttv_getlrcmd(ttvfig,tve->ROOT) ;
5514 else
5515 chainc = NULL;
5516
5517 if(chainc == NULL)
5518 chainc = addchain(chainc,NULL) ;
5519
5520 typehz = 'N' ;
5521 for(chc = chainc ; chc != NULL ; chc = chc->NEXT)
5522 {
5523 r_nbx=0;
5524 pathx=NULL;
5525 pathx = (ttvpath_list *)ttv_findsigpath(ttvfig,ttvins,ttvins,tve,NULL,(ttvevent_list *)chc->DATA,delaymax,delaymin,type|TTV_FIND_ALL,level,pathx,TTV_SEARCH_CRITICPATH,nb,&r_nbx,savealltag,&typehz) ;
5526 if(typehz == 'Y')
5527 {
5528 if (event_to_retry->NEXT!=NULL && tve->ROOT==((ttvevent_list *)event_to_retry->NEXT->DATA)->ROOT) // test normalement vrai
5529 {
5530 tve = (ttvevent_list *)event_to_retry->NEXT->DATA ;
5531 pathx = (ttvpath_list *)ttv_findsigpath(ttvfig,ttvins,ttvins,tve,(ttvevent_list *)chc->DATA,NULL,delaymax,delaymin,type|TTV_FIND_ALL,level,pathx,TTV_SEARCH_CRITICPATH,nb,&r_nbx,savealltag,&typehz) ;
5532 event_to_retry=delchain(event_to_retry, event_to_retry);
5533 }
5534
5535 pathx = ttv_filterpathhz(pathx,&r_nbx, nb, NULL, type) ;
5536 }
5537 // keep critic only
5538
5539 pathx=ttv_keep_critic_paths(pathx, &r_nbx, type, (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MULTIPLE_COMMAND_CRITIC_ACCESS)!=0?1:0);
5540
5541 // merge to list
5542
5543 retried_list=ttv_mergepathlists(retried_list, retried_nbx, pathx, r_nbx, nb, type, &retried_nbx);
5544 }
5545
5546 freechain(chainc);
5547
5548 if (typehz == 'Y' && event_to_retry->NEXT!=NULL && tve->ROOT==((ttvevent_list *)event_to_retry->NEXT->DATA)->ROOT)
5549 event_to_retry=delchain(event_to_retry, event_to_retry);
5550 event_to_retry=delchain(event_to_retry, event_to_retry);
5551 }
5552 TTV_FIND_ALLPATH='N';
5553 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH;
5554
5555 // merge to previous list
5556 path=ttv_mergepathlists(path, nbx, retried_list, retried_nbx, nb, type, &nbx);
5557 }
5558 TTV_SEARCH_INFORMATIONS&=~TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
5559
5560
5561 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
5562 ttv_addinfreelist(ttvins,TTV_STS_P) ;
5563 else
5564 ttv_addinfreelist(ttvins,TTV_STS_F) ;
5565 }
5566
5567 for(chaininx = chaininsav ; chaininx != NULL ; chaininx = chaininx->NEXT)
5568 {
5569 ((ttvsig_list *)chaininx->DATA)->TYPE &= ~(TTV_SIG_MASKIN|TTV_SIG_MASKOUT) ;
5570 }
5571 freechain(chaininsav) ;
5572 freechain(chainfigsav) ;
5573
5574 ttv_delinfreelist(NULL,NULL) ;
5575
5576 pathx=ttv_classpath(path,type);
5577 for(path=pathx, i=1; i<nb && path != NULL ; path = path->NEXT , i++) ;
5578
5579 if(path != NULL)
5580 {
5581 ttv_freepathlist(path->NEXT) ;
5582 path->NEXT = NULL ;
5583 }
5584 return(pathx) ;
5585 }
5586
5587 /*****************************************************************************/
5588 /* function ttv_getcriticaccess() */
5589 /* parametres : */
5590 /* ttvfig : ttvfig courante */
5591 /* maskin : list de masques pour les entrees */
5592 /* maskout : list de masques pour les sorties */
5593 /* delaymax : temps maximum des chemin */
5594 /* delaymin : temps maximum des chemin */
5595 /* nb : nombre de chemin a garder */
5596 /* type : type de recherche */
5597 /* */
5598 /* recherche le temps d'acces le plus court ou le plus long d'une ttvfig */
5599 /*****************************************************************************/
5600 ttvpath_list *ttv_getcriticaccess(ttvfig,figpath,maskin,maskout,maskclock,delaymax,delaymin,nb,type)
5601 ttvfig_list *ttvfig ;
5602 ttvfig_list *figpath ;
5603 chain_list *maskin ;
5604 chain_list *maskout ;
5605 chain_list *maskclock ;
5606 long delaymax ;
5607 long delaymin ;
5608 int nb ;
5609 long type ;
5610 {
5611 ttvpath_list *path ;
5612 #ifdef SPEED_UP_ACCESS_CRITIC
5613 long subtype;
5614 chain_list *clknames;
5615 #endif
5616 chain_list *chainclock;
5617
5618 if (TTV_EXPLICIT_CLOCK_NODES==NULL)
5619 {
5620 if(maskclock == NULL)
5621 chainclock = ttv_getclocksiglist(ttvfig) ;
5622 else
5623 chainclock = ttv_getsigbytype_and_netname(ttvfig,NULL,TTV_SIG_C|TTV_SIG_L|TTV_SIG_B,maskclock) ;
5624 }
5625 else
5626 chainclock=dupchainlst(TTV_EXPLICIT_CLOCK_NODES);
5627
5628 #ifdef SPEED_UP_ACCESS_CRITIC
5629 // speed up all access
5630 clknames=namefromsig(ttvfig, chainclock);
5631 if (clknames!=NULL)
5632 {
5633 long save0, save1, save2;
5634 ttv_set_search_exclude_type(0, 0, &save0, &save1);
5635 save2=TTV_MORE_SEARCH_OPTIONS;
5636 TTV_MORE_SEARCH_OPTIONS=0;
5637 subtype=type & (TTV_FIND_PATH|TTV_FIND_LINE|TTV_FIND_MIN|TTV_FIND_MAX);
5638 TTV_MARK_MODE=TTV_MARK_MODE_DO;
5639 ttv_getcriticpath(ttvfig,figpath,clknames,NULL,delaymax,delaymin,LONG_MAX,TTV_FIND_DUAL|subtype) ;
5640
5641 TTV_MARK_MODE=TTV_MARK_MODE_USE;
5642 freechain(clknames);
5643 ttv_set_search_exclude_type(save0, save1, &save0, &save1);
5644 TTV_MORE_SEARCH_OPTIONS=save2;
5645 }
5646 #endif
5647 TTV_CHAIN_CLOCK = chainclock;
5648 path = ttv_getcriticpath(ttvfig,figpath,maskin,maskout,delaymax,delaymin,nb,type|TTV_FIND_ACCESS) ;
5649
5650 #ifdef SPEED_UP_ACCESS_CRITIC
5651 ttv_FreeMarkedSigList();
5652 TTV_MARK_MODE=0;
5653 #endif
5654
5655 freechain(TTV_CHAIN_CLOCK) ;
5656 TTV_CHAIN_CLOCK = NULL ;
5657 return(path) ;
5658 }
5659
5660 /*****************************************************************************/
5661 /* function ttv_getpath() */
5662 /* parametres : */
5663 /* ttvfig : ttvfig courante */
5664 /* figpath : figure de recherche d'un chemin */
5665 /* ptsig : signal de depart de la recherche */
5666 /* mask : list de masques pour les entrees ou sorties */
5667 /* delaymax : temps maximum des chemin */
5668 /* delaymin : temps maximum des chemin */
5669 /* type : type de recherche */
5670 /* */
5671 /* recherche tous les chemins entre ptsig et les signaux de mask */
5672 /*****************************************************************************/
5673 ttvpath_list *ttv_getpath(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type)
5674 ttvfig_list *ttvfig ;
5675 ttvfig_list *figpath ;
5676 ttvsig_list *ptsig ;
5677 chain_list *mask ;
5678 long delaymax ;
5679 long delaymin ;
5680 long type ;
5681 {
5682 ttvfig_list *ttvfigx ;
5683 ttvfig_list *ttvfigsav ;
5684 ttvpath_list *path = NULL ;
5685 chain_list *chainin ;
5686 chain_list *chain ;
5687 chain_list *chainpath ;
5688 chain_list *chainc, *event_to_retry ;
5689 chain_list *chc ;
5690 long levelsig ;
5691 long levelend ;
5692 long level = (long)0 ;
5693 long typesig ;
5694 int i, savealltag ;
5695 char typehz ;
5696
5697 if(((type & TTV_FIND_PATH) == TTV_FIND_PATH) ||
5698 ((type & TTV_FIND_LINE) != TTV_FIND_LINE))
5699 {
5700 type &= ~(TTV_FIND_LINE | TTV_FIND_HIER) ;
5701 type |= TTV_FIND_PATH ;
5702 }
5703 else
5704 type &= ~(TTV_FIND_HIER) ;
5705
5706 if(mask != NULL)
5707 {
5708 levelsig = ttv_getsiglevel(ptsig) ;
5709
5710 if(levelsig == ttvfig->INFO->LEVEL)
5711 {
5712 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
5713 typesig = TTV_SIG_C|TTV_SIG_Q|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B ;
5714 else
5715 typesig = TTV_SIG_C|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B|TTV_SIG_Q ;
5716 }
5717 else
5718 {
5719 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
5720 typesig = TTV_SIG_Q|TTV_SIG_L|TTV_SIG_R|TTV_SIG_B ;
5721 else
5722 typesig = TTV_SIG_L|TTV_SIG_R|TTV_SIG_B|TTV_SIG_Q ;
5723 }
5724
5725 if((type & TTV_FIND_SIG) != TTV_FIND_SIG)
5726 {
5727 long excludemask;
5728 int exclQK=0;
5729 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) excludemask=TTV_EXCLUDE_TYPE_END; else excludemask=TTV_EXCLUDE_TYPE_START, exclQK=1;
5730 chainin = ttv_getsigbytype_and_netname(ttvfig,NULL,typesig,mask) ;
5731 chainin = ttv_apply_exclude_flag(chainin, excludemask, exclQK);
5732 }
5733 else
5734 {
5735 chainin = NULL ;
5736 for(chain = mask ; chain != NULL ; chain = chain->NEXT)
5737 {
5738 chainin = addchain(chainin,chain->DATA) ;
5739 }
5740 }
5741
5742 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5743 chainin = ttv_remove_connector_B(chainin);
5744
5745 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
5746 {
5747 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
5748 ((ttvsig_list *)chain->DATA)->TYPE |= TTV_SIG_MASKOUT ;
5749 else
5750 ((ttvsig_list *)chain->DATA)->TYPE |= TTV_SIG_MASKIN ;
5751 if((levelend = ttv_getsiglevel((ttvsig_list *)chain->DATA)) > level)
5752 level = levelend ;
5753 }
5754
5755 levelend = level ;
5756
5757 // calcul si on doit ignorer le maskin pour les latchs des access
5758 savealltag=computesavealltag(chainin, 0);
5759
5760 if((levelend < ttvfig->INFO->LEVEL) && (levelsig == ttvfig->INFO->LEVEL))
5761 {
5762 chainpath = NULL ;
5763 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
5764 {
5765 if((((ttvsig_list *)chain->DATA)->TYPE & TTV_SIG_C) != TTV_SIG_C)
5766 chainpath = addchain(chainpath,chain->DATA) ;
5767 else
5768 {
5769 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
5770 ((ttvsig_list *)chain->DATA)->TYPE &= ~(TTV_SIG_MASKOUT) ;
5771 else
5772 ((ttvsig_list *)chain->DATA)->TYPE &= ~(TTV_SIG_MASKIN) ;
5773 }
5774 }
5775 freechain(chainin) ;
5776 chainin = chainpath ;
5777 }
5778
5779 if(levelsig > ttvfig->INFO->LEVEL) levelsig = ttvfig->INFO->LEVEL ;
5780 if(levelend > ttvfig->INFO->LEVEL) levelend = ttvfig->INFO->LEVEL ;
5781
5782 if(levelsig > levelend) level = levelend ;
5783 else level = levelsig ;
5784
5785 for(ttvfigx = ptsig->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
5786 {
5787 ttvfigx->STATUS |= TTV_STS_MARQUE ;
5788 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
5789 }
5790
5791 ttvfigsav = ttvfig ;
5792
5793 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
5794 {
5795 for(ttvfigx = ((ttvsig_list *)chain->DATA)->ROOT ;
5796 ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
5797 {
5798 if((ttvfigx->STATUS & TTV_STS_MARQUE) == TTV_STS_MARQUE)
5799 break ;
5800 }
5801 if(ttvfigx != NULL)
5802 if(ttvfigx->INFO->LEVEL < ttvfigsav->INFO->LEVEL) ttvfigsav = ttvfigx ;
5803 if(ttvfigsav == ptsig->ROOT)
5804 break ;
5805 }
5806
5807 for(ttvfigx = ptsig->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
5808 {
5809 ttvfigx->STATUS &= ~(TTV_STS_MARQUE) ;
5810 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
5811 }
5812 }
5813 else
5814 {
5815 chainin = NULL ;
5816 savealltag=computesavealltag(chainin, 1);
5817 }
5818
5819 if((figpath == NULL) && (mask != NULL))
5820 {
5821 if((level < ttvfig->INFO->LEVEL) && (level == ttvfigsav->INFO->LEVEL))
5822 {
5823 level = (long)0 ;
5824 }
5825 else if((level == ttvfig->INFO->LEVEL) && (level > ttvfigsav->INFO->LEVEL))
5826 {
5827 level = ttvfigsav->INFO->LEVEL ;
5828 ttvfigsav = ttvfig ;
5829 }
5830 }
5831 else if((figpath == NULL) && (mask == NULL))
5832 {
5833 level = ptsig->ROOT->INFO->LEVEL ;
5834 ttvfigsav = ttvfig ;
5835 }
5836 else
5837 {
5838 ttvfigsav = figpath ;
5839 if(figpath == ttvfig)
5840 {
5841 level = figpath->INFO->LEVEL ;
5842 }
5843 else
5844 {
5845 level = (long)0 ;
5846 }
5847 }
5848
5849 if((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5850 chainc = ttv_getlrcmd(ttvfig,ptsig) ;
5851 else
5852 chainc = NULL;
5853
5854 if(chainc == NULL || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_PATHS)!=0)
5855 chainc = addchain(chainc,NULL) ;
5856
5857 typehz = 'N' ;
5858 for(chc = chainc ; chc != NULL ; chc = chc->NEXT)
5859 {
5860 event_to_retry=NULL;
5861 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL && (ptsig->TYPE & TTV_SIG_CB)==TTV_SIG_CB) continue;
5862 for(i = 0 ; i < 2 ; i++)
5863 {
5864 if((((((type & (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_UPDW)) == (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_UPDW)) && (i == 1)) ||
5865 (((type & (TTV_FIND_NOT_DWUP|TTV_FIND_NOT_DWDW)) == (TTV_FIND_NOT_DWUP|TTV_FIND_NOT_DWDW)) && (i == 0)))
5866 && ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)) ||
5867 (((((type & (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_DWUP)) == (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_DWUP)) && (i == 1)) ||
5868 (((type & (TTV_FIND_NOT_UPDW|TTV_FIND_NOT_DWDW)) == (TTV_FIND_NOT_UPDW|TTV_FIND_NOT_DWDW)) && (i == 0)))
5869 && ((type & TTV_FIND_DUAL) != TTV_FIND_DUAL)
5870 && (ptsig->TYPE & (TTV_SIG_CT|TTV_SIG_CZ))==0 // pour le filtrage HZ
5871 ))
5872 continue ;
5873 TTV_SEARCH_INFORMATIONS&=~TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
5874 path = (ttvpath_list *)ttv_findsigpath(ttvfig,figpath,ttvfigsav,ptsig->NODE+i,NULL,(ttvevent_list *)chc->DATA,delaymax,delaymin,type,level,path,TTV_SEARCH_PATH,TTV_MAX_PATHNB,NULL, savealltag,&typehz) ;
5875 if (TTV_SEARCH_INFORMATIONS & TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH)
5876 {
5877 event_to_retry=addchain(event_to_retry, ptsig->NODE+i);
5878 if (typehz=='Y')
5879 {
5880 // pour le filtre des HZ il faut les 2 events, donc on recherhera les // pour les 2 events
5881 if (i==0)
5882 {
5883 event_to_retry=addchain(event_to_retry, ptsig->NODE+1);
5884 break;
5885 }
5886 else
5887 {
5888 event_to_retry=addchain(event_to_retry, ptsig->NODE);
5889 }
5890 }
5891 }
5892 }
5893 if (event_to_retry!=NULL)
5894 {
5895 int r_nbx, retried_nbx=0;
5896 ttvpath_list *retried_list=NULL;
5897 ttvevent_list *tve;
5898 ttvpath_list *pathx, *npathx, *prevpathx;
5899
5900 // remove signal to retry from the list
5901 for (chain=event_to_retry; chain!=NULL; chain=chain->NEXT)
5902 ((ttvevent_list *)chain->DATA)->TYPE|=TTV_NODE_MARQUE;
5903
5904 for (pathx=path; pathx!=NULL; pathx=npathx)
5905 {
5906 npathx=pathx->NEXT;
5907 if ((type & TTV_FIND_DUAL)!=0) tve=pathx->NODE; else tve=pathx->ROOT;
5908 if (pathx->CMD==chc->DATA && tve->TYPE & TTV_NODE_MARQUE)
5909 {
5910 if (pathx==path) path=npathx; else prevpathx->NEXT=npathx;
5911 pathx->NEXT=NULL;
5912 ttv_freepathlist(pathx);
5913 }
5914 else prevpathx=pathx;
5915 }
5916 for (chain=event_to_retry; chain!=NULL; chain=chain->NEXT)
5917 ((ttvevent_list *)chain->DATA)->TYPE&=~TTV_NODE_MARQUE;
5918
5919 TTV_FIND_ALLPATH='Y';
5920 if ((type & TTV_FIND_ACCESS)==0) TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH;
5921 while (event_to_retry!=NULL)
5922 {
5923 tve = (ttvevent_list *)event_to_retry->DATA ;
5924
5925 typehz = 'N' ;
5926 r_nbx=0;
5927 pathx=NULL;
5928 pathx = (ttvpath_list *)ttv_findsigpath(ttvfig,figpath,ttvfigsav,tve,NULL,(ttvevent_list *)chc->DATA,delaymax,delaymin,type|TTV_FIND_ALL,level,pathx,TTV_SEARCH_PATH,TTV_MAX_PATHNB,NULL, savealltag,&typehz) ;
5929
5930 if(typehz == 'Y')
5931 {
5932 if (event_to_retry->NEXT!=NULL && tve->ROOT==((ttvevent_list *)event_to_retry->NEXT->DATA)->ROOT) // test normalement vrai
5933 {
5934 event_to_retry=delchain(event_to_retry, event_to_retry);
5935 tve = (ttvevent_list *)event_to_retry->DATA ;
5936 pathx = (ttvpath_list *)ttv_findsigpath(ttvfig,figpath,ttvfigsav,tve,NULL,(ttvevent_list *)chc->DATA,delaymax,delaymin,type|TTV_FIND_ALL,level,pathx,TTV_SEARCH_PATH,TTV_MAX_PATHNB,NULL, savealltag,&typehz) ;
5937 }
5938
5939 pathx = ttv_filterpathhz(pathx,NULL, TTV_MAX_PATHNB, NULL, type) ;
5940 }
5941 // keep critic only
5942
5943 pathx=ttv_keep_critic_paths(pathx, &r_nbx, type, (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MULTIPLE_COMMAND_CRITIC_ACCESS)!=0?1:0);
5944
5945 // merge to list
5946
5947 retried_list=ttv_mergepathlists(retried_list, retried_nbx, pathx, r_nbx, TTV_MAX_PATHNB, type, &retried_nbx);
5948
5949 event_to_retry=delchain(event_to_retry, event_to_retry);
5950 }
5951 TTV_FIND_ALLPATH='N';
5952 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH;
5953
5954 // merge to previous list
5955 path=ttv_mergepathlists(path, countchain((chain_list *)path), retried_list, retried_nbx, TTV_MAX_PATHNB, type, &r_nbx);
5956 }
5957 TTV_SEARCH_INFORMATIONS&=~TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH;
5958 }
5959 freechain(chainc) ;
5960
5961 for(chain = chainin ; chain != NULL ; chain = chain->NEXT)
5962 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
5963 ((ttvsig_list *)chain->DATA)->TYPE &= ~(TTV_SIG_MASKOUT) ;
5964 else
5965 ((ttvsig_list *)chain->DATA)->TYPE &= ~(TTV_SIG_MASKIN) ;
5966
5967 freechain(chainin) ;
5968
5969 if(typehz == 'Y')
5970 path = ttv_filterpathhz(path,NULL,0,NULL,0) ;
5971
5972 if((type & (TTV_FIND_NOT_UPUP|TTV_FIND_NOT_UPDW|
5973 TTV_FIND_NOT_DWUP|TTV_FIND_NOT_DWDW)) != 0)
5974 path = ttv_filterpath(path,type,NULL) ;
5975
5976 if((type & TTV_FIND_NOTCLASS) == TTV_FIND_NOTCLASS)
5977 return(path) ;
5978 else
5979 return(ttv_classpath(path,type)) ;
5980 }
5981
5982 /*****************************************************************************/
5983 /* function ttv_getpathnocross() */
5984 /* parametres : */
5985 /* ttvfig : ttvfig courante */
5986 /* figpath : figure de recherche d'un chemin */
5987 /* ptsig : signal de depart de la recherche */
5988 /* mask : list de masques pour les entrees ou sorties */
5989 /* delaymax : temps maximum des chemin */
5990 /* delaymin : temps maximum des chemin */
5991 /* type : type de recherche */
5992 /* */
5993 /* recherche tous les chemins entre ptsig et les signaux de mask */
5994 /*****************************************************************************/
5995 ttvpath_list *ttv_getpathnocross(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type)
5996 ttvfig_list *ttvfig ;
5997 ttvfig_list *figpath ;
5998 ttvsig_list *ptsig ;
5999 chain_list *mask ;
6000 long delaymax ;
6001 long delaymin ;
6002 long type ;
6003 {
6004 ttvpath_list *path ;
6005 int maxperiod, savmpd;
6006
6007 maxperiod = V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE ;
6008 savmpd=TTV_MaxPathPeriodPrecharge;
6009 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = 0 ;
6010 TTV_MaxPathPeriodPrecharge=0;
6011
6012 path = ttv_getpath(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type) ;
6013
6014 TTV_MaxPathPeriodPrecharge=savmpd;
6015 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = maxperiod ;
6016
6017 return(path) ;
6018 }
6019
6020 /*****************************************************************************/
6021 /* function ttv_getaccessnocross() */
6022 /* parametres : */
6023 /* ttvfig : ttvfig courante */
6024 /* figpath : figure de recherche d'un chemin */
6025 /* ptsig : signal de depart de la recherche */
6026 /* mask : list de masques pour les entrees ou sorties */
6027 /* delaymax : temps maximum des chemin */
6028 /* delaymin : temps maximum des chemin */
6029 /* type : type de recherche */
6030 /* */
6031 /* recherche tous les chemins entre ptsig et les signaux de mask */
6032 /*****************************************************************************/
6033 ttvpath_list *ttv_getaccessnocross(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type)
6034 ttvfig_list *ttvfig ;
6035 ttvfig_list *figpath ;
6036 ttvsig_list *ptsig ;
6037 chain_list *mask ;
6038 long delaymax ;
6039 long delaymin ;
6040 long type ;
6041 {
6042 ttvpath_list *path ;
6043 int maxperiod, savmpd;
6044
6045 maxperiod = V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE ;
6046 savmpd=TTV_MaxPathPeriodPrecharge;
6047 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = 0 ;
6048 TTV_MaxPathPeriodPrecharge=0;
6049
6050 path = ttv_getaccess(ttvfig,figpath,ptsig,mask,NULL,delaymax,delaymin,type) ;
6051
6052 TTV_MaxPathPeriodPrecharge=savmpd;
6053 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = maxperiod ;
6054
6055 return(path) ;
6056 }
6057
6058 /*****************************************************************************/
6059 /* function ttv_getpathsig() */
6060 /* parametres : */
6061 /* ttvfig : ttvfig courante */
6062 /* figpath : figure de recherche d'un chemin */
6063 /* ptsig : signal de depart de la recherche */
6064 /* mask : list de masques pour les entrees ou sorties */
6065 /* delaymax : temps maximum des chemin */
6066 /* delaymin : temps maximum des chemin */
6067 /* type : type de recherche */
6068 /* */
6069 /* recherche tous les chemins pour un signal */
6070 /*****************************************************************************/
6071 ttvpath_list *ttv_getpathsig(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type)
6072 ttvfig_list *ttvfig ;
6073 ttvfig_list *figpath ;
6074 ttvsig_list *ptsig ;
6075 chain_list *mask ;
6076 long delaymax ;
6077 long delaymin ;
6078 long type ;
6079 {
6080 ttvpath_list *path ;
6081
6082 TTV_FIND_ALLPATH = 'Y' ;
6083 path = ttv_getpath(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type|TTV_FIND_ALL) ;
6084 TTV_FIND_ALLPATH = 'N' ;
6085 return(path) ;
6086 }
6087
6088 ttvpath_list *ttv_getpathsignocross(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type)
6089 ttvfig_list *ttvfig ;
6090 ttvfig_list *figpath ;
6091 ttvsig_list *ptsig ;
6092 chain_list *mask ;
6093 long delaymax ;
6094 long delaymin ;
6095 long type ;
6096 {
6097 ttvpath_list *path ;
6098 int maxperiod, savmpd ;
6099
6100 maxperiod = V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE ;
6101 savmpd=TTV_MaxPathPeriodPrecharge;
6102
6103 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = 0 ;
6104 TTV_MaxPathPeriodPrecharge=0;
6105
6106 TTV_FIND_ALLPATH = 'Y' ;
6107 path = ttv_getpath(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type|TTV_FIND_ALL) ;
6108 TTV_FIND_ALLPATH = 'N' ;
6109
6110 TTV_MaxPathPeriodPrecharge=savmpd;
6111
6112 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = maxperiod ;
6113
6114 return(path) ;
6115 }
6116
6117 ttvpath_list *ttv_getaccesssignocross(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type)
6118 ttvfig_list *ttvfig ;
6119 ttvfig_list *figpath ;
6120 ttvsig_list *ptsig ;
6121 chain_list *mask ;
6122 long delaymax ;
6123 long delaymin ;
6124 long type ;
6125 {
6126 ttvpath_list *path ;
6127 int maxperiod, savmpd ;
6128
6129 maxperiod = V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE ;
6130 savmpd=TTV_MaxPathPeriodPrecharge;
6131
6132 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = 0 ;
6133 TTV_MaxPathPeriodPrecharge=0;
6134
6135 TTV_FIND_ALLPATH = 'Y' ;
6136 path = ttv_getaccess(ttvfig,figpath,ptsig,mask,NULL,delaymax,delaymin,type|TTV_FIND_ALL) ;
6137 TTV_FIND_ALLPATH = 'N' ;
6138
6139 TTV_MaxPathPeriodPrecharge=savmpd;
6140
6141 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = maxperiod ;
6142
6143 return(path) ;
6144 }
6145
6146
6147 /*****************************************************************************/
6148 /* function ttv_getaccess() */
6149 /* parametres : */
6150 /* ttvfig : ttvfig courante */
6151 /* figpath : figure de recherche d'un chemin */
6152 /* ptsig : signal de depart de la recherche */
6153 /* mask : list de masques pour les entrees ou sorties */
6154 /* delaymax : temps maximum des chemin */
6155 /* delaymin : temps maximum des chemin */
6156 /* type : type de recherche */
6157 /* */
6158 /* recherche tous les temps d'acces pour les extramitees */
6159 /*****************************************************************************/
6160 ttvpath_list *ttv_getaccess(ttvfig,figpath,ptsig,mask,maskclock,delaymax,delaymin,type)
6161 ttvfig_list *ttvfig ;
6162 ttvfig_list *figpath ;
6163 ttvsig_list *ptsig ;
6164 chain_list *mask ;
6165 chain_list *maskclock ;
6166 long delaymax ;
6167 long delaymin ;
6168 long type ;
6169 {
6170 ttvpath_list *path ;
6171 #ifdef SPEED_UP_ACCESS_CRITIC
6172 long subtype;
6173 chain_list *clknames;
6174 #endif
6175 chain_list *chainclock;
6176
6177 if (TTV_EXPLICIT_CLOCK_NODES==NULL)
6178 {
6179 if(maskclock == NULL)
6180 chainclock = ttv_getclocksiglist(ttvfig) ;
6181 else
6182 {
6183 if((type & TTV_FIND_SIG) != TTV_FIND_SIG)
6184 chainclock = ttv_getsigbytype_and_netname(ttvfig,NULL,TTV_SIG_C|TTV_SIG_L|TTV_SIG_B,maskclock) ;
6185 else
6186 chainclock = maskclock ;
6187 }
6188 }
6189 else
6190 chainclock=dupchainlst(TTV_EXPLICIT_CLOCK_NODES);
6191
6192 #ifdef SPEED_UP_ACCESS_CRITIC
6193 // speed up access
6194 clknames=namefromsig(ttvfig, chainclock);
6195 if (clknames!=NULL)
6196 {
6197 long save0, save1, save2;
6198 ttv_set_search_exclude_type(0, 0, &save0, &save1);
6199 save2=TTV_MORE_SEARCH_OPTIONS;
6200 TTV_MORE_SEARCH_OPTIONS=0;
6201 subtype=type & (TTV_FIND_PATH|TTV_FIND_LINE|TTV_FIND_MIN|TTV_FIND_MAX);
6202 TTV_MARK_MODE=TTV_MARK_MODE_DO;
6203 ttv_getcriticpath(ttvfig,figpath,clknames,NULL,delaymax,delaymin,LONG_MAX,TTV_FIND_DUAL|subtype) ;
6204
6205 TTV_MARK_MODE=TTV_MARK_MODE_USE;
6206 freechain(clknames);
6207 ttv_set_search_exclude_type(save0, save1, &save0, &save1);
6208 TTV_MORE_SEARCH_OPTIONS=save2;
6209 }
6210 #endif
6211 TTV_CHAIN_CLOCK = chainclock;
6212
6213 path = ttv_getpath(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type|TTV_FIND_ACCESS) ;
6214
6215 #ifdef SPEED_UP_ACCESS_CRITIC
6216 ttv_FreeMarkedSigList();
6217 TTV_MARK_MODE=0;
6218 #endif
6219
6220 if(maskclock==NULL || (type & TTV_FIND_SIG) != TTV_FIND_SIG)
6221 freechain(TTV_CHAIN_CLOCK) ;
6222 TTV_CHAIN_CLOCK = NULL ;
6223 return(path) ;
6224 }
6225
6226 /*****************************************************************************/
6227 /* function ttv_getsigaccess() */
6228 /* parametres : */
6229 /* ttvfig : ttvfig courante */
6230 /* figpath : figure de recherche d'un chemin */
6231 /* ptsig : signal de depart de la recherche */
6232 /* mask : list de masques pour les entrees ou sorties */
6233 /* delaymax : temps maximum des chemin */
6234 /* delaymin : temps maximum des chemin */
6235 /* type : type de recherche */
6236 /* */
6237 /* recherche tous les temps d'acces pour les latchs */
6238 /*****************************************************************************/
6239 ttvpath_list *ttv_getsigaccess(ttvfig,figpath,ptsig,mask,maskclock,delaymax,delaymin,type)
6240 ttvfig_list *ttvfig ;
6241 ttvfig_list *figpath ;
6242 ttvsig_list *ptsig ;
6243 chain_list *mask ;
6244 chain_list *maskclock ;
6245 long delaymax ;
6246 long delaymin ;
6247 long type ;
6248 {
6249 ttvpath_list *path ;
6250 long subtype;
6251 chain_list *clknames, *chainclock;
6252
6253 TTV_FIND_ALLPATH = 'Y' ;
6254 if (TTV_EXPLICIT_CLOCK_NODES==NULL)
6255 {
6256 if(maskclock == NULL)
6257 chainclock = ttv_getclocksiglist(ttvfig) ;
6258 else
6259 {
6260 if((type & TTV_FIND_SIG) != TTV_FIND_SIG)
6261 chainclock = ttv_getsigbytype_and_netname(ttvfig,NULL,TTV_SIG_C|TTV_SIG_L|TTV_SIG_B,maskclock) ;
6262 else
6263 chainclock = maskclock ;
6264 }
6265 }
6266 else
6267 chainclock=dupchainlst(TTV_EXPLICIT_CLOCK_NODES);
6268
6269 #ifdef SPEED_UP_ACCESS_ALL
6270 // speed up access
6271 clknames=namefromsig(ttvfig, chainclock);
6272 if (clknames!=NULL)
6273 {
6274 long saveprec=V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE;
6275 long save0, save1, save2;
6276 chain_list *savestartnode=TTV_EXPLICIT_START_NODES;
6277 ttv_set_search_exclude_type(0, 0, &save0, &save1);
6278 save2=TTV_MORE_SEARCH_OPTIONS;
6279 TTV_MORE_SEARCH_OPTIONS=0;
6280 V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE=0;
6281 subtype=type & (TTV_FIND_PATH|TTV_FIND_LINE|TTV_FIND_MIN|TTV_FIND_MAX);
6282 TTV_MARK_MODE=TTV_MARK_MODE_DO;
6283 TTV_EXPLICIT_START_NODES=chainclock;
6284 ttv_getcriticpath(ttvfig,figpath,clknames,NULL,delaymax,delaymin,INT_MAX,TTV_FIND_DUAL|TTV_FIND_ALL|subtype) ;
6285 TTV_EXPLICIT_START_NODES=savestartnode;
6286 freechain(clknames);
6287 ttv_set_search_exclude_type(save0, save1, &save0, &save1);
6288 TTV_MORE_SEARCH_OPTIONS=save2;
6289 V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE=saveprec;
6290 TTV_MARK_MODE=TTV_MARK_MODE_USE;
6291 }
6292 #endif
6293
6294 TTV_CHAIN_CLOCK = chainclock;
6295
6296 path = ttv_getpath(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type|TTV_FIND_ALL|TTV_FIND_ACCESS) ;
6297
6298 #ifdef SPEED_UP_ACCESS_ALL
6299 ttv_FreeMarkedSigList();
6300 TTV_MARK_MODE=0;
6301 #endif
6302
6303 if(maskclock==NULL || (type & TTV_FIND_SIG) != TTV_FIND_SIG)
6304 freechain(TTV_CHAIN_CLOCK) ;
6305 TTV_CHAIN_CLOCK = NULL ;
6306 TTV_FIND_ALLPATH = 'N' ;
6307 return(path) ;
6308 }
6309
6310 /*****************************************************************************/
6311 /* function ttv_getallpath () */
6312 /* parametres : */
6313 /* ttvfig : ttvfig courante */
6314 /* maskin : list de masques pour les entrees */
6315 /* maskout : list de masques pour les sorties */
6316 /* delaymax : temps maximum des chemin */
6317 /* delaymin : temps maximum des chemin */
6318 /* nb : nombre de chemin a garder */
6319 /* type : type de recherche */
6320 /* */
6321 /* recherche tout les chemins d'une ttvfig */
6322 /*****************************************************************************/
6323 ttvpath_list *ttv_getallpath(ttvfig,figpath,maskin,maskout,delaymax,delaymin,nb,type)
6324 ttvfig_list *ttvfig ;
6325 ttvfig_list *figpath ;
6326 chain_list *maskin ;
6327 chain_list *maskout ;
6328 long delaymax ;
6329 long delaymin ;
6330 int nb ;
6331 long type ;
6332 {
6333 ttvpath_list *path ;
6334
6335 TTV_FIND_ALLPATH = 'Y' ;
6336 path = ttv_getcriticpath(ttvfig,figpath,maskin,maskout,delaymax,delaymin,nb,type|TTV_FIND_ALL) ;
6337 TTV_FIND_ALLPATH = 'N' ;
6338 return(path) ;
6339 }
6340
6341 /*****************************************************************************/
6342 /* function ttv_getallaccess() */
6343 /* parametres : */
6344 /* ttvfig : ttvfig courante */
6345 /* maskin : list de masques pour les entrees */
6346 /* maskout : list de masques pour les sorties */
6347 /* delaymax : temps maximum des chemin */
6348 /* delaymin : temps maximum des chemin */
6349 /* nb : nombre de chemin a garder */
6350 /* type : type de recherche */
6351 /* */
6352 /* recherche tout les temps d'acces d'une ttvfig */
6353 /*****************************************************************************/
6354 ttvpath_list *ttv_getallaccess(ttvfig,figpath,maskin,maskout,maskclock,delaymax,delaymin,nb,type)
6355 ttvfig_list *ttvfig ;
6356 ttvfig_list *figpath ;
6357 chain_list *maskin ;
6358 chain_list *maskout ;
6359 chain_list *maskclock ;
6360 long delaymax ;
6361 long delaymin ;
6362 int nb ;
6363 long type ;
6364 {
6365 ttvpath_list *path ;
6366 long subtype;
6367 chain_list *clknames, *chainclock;
6368
6369 TTV_FIND_ALLPATH = 'Y' ;
6370
6371 if (TTV_EXPLICIT_CLOCK_NODES==NULL)
6372 {
6373 if(maskclock == NULL)
6374 chainclock = ttv_getclocksiglist(ttvfig) ;
6375 else
6376 chainclock = ttv_getsigbytype_and_netname(ttvfig,NULL,TTV_SIG_C|TTV_SIG_L|TTV_SIG_B,maskclock) ;
6377 }
6378 else
6379 chainclock=dupchainlst(TTV_EXPLICIT_CLOCK_NODES);
6380
6381 #ifdef SPEED_UP_ACCESS_ALL
6382 // speed up access
6383 clknames=namefromsig(ttvfig, chainclock);
6384 if (clknames!=NULL)
6385 {
6386 long saveprec=V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE;
6387 long save0, save1, save2;
6388 chain_list *savestartnode=TTV_EXPLICIT_START_NODES;
6389 ttv_set_search_exclude_type(0, 0, &save0, &save1);
6390 save2=TTV_MORE_SEARCH_OPTIONS;
6391 TTV_MORE_SEARCH_OPTIONS=0;
6392 V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE=0;
6393 subtype=type & (TTV_FIND_PATH|TTV_FIND_LINE|TTV_FIND_MIN|TTV_FIND_MAX);
6394 TTV_MARK_MODE=TTV_MARK_MODE_DO;
6395 TTV_EXPLICIT_START_NODES=chainclock;
6396 ttv_getcriticpath(ttvfig,figpath,clknames,NULL,delaymax,delaymin,INT_MAX,TTV_FIND_DUAL|TTV_FIND_ALL|subtype) ;
6397 TTV_EXPLICIT_START_NODES=savestartnode;
6398 freechain(clknames);
6399 ttv_set_search_exclude_type(save0, save1, &save0, &save1);
6400 TTV_MORE_SEARCH_OPTIONS=save2;
6401 V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE=saveprec;
6402 TTV_MARK_MODE=TTV_MARK_MODE_USE;
6403 }
6404 #endif
6405 TTV_CHAIN_CLOCK = chainclock;
6406 path = ttv_getcriticpath(ttvfig,figpath,maskin,maskout,delaymax,delaymin,nb,type|TTV_FIND_ALL|TTV_FIND_ACCESS) ;
6407
6408 #ifdef SPEED_UP_ACCESS_ALL
6409 ttv_FreeMarkedSigList();
6410 TTV_MARK_MODE=0;
6411 #endif
6412
6413 freechain(TTV_CHAIN_CLOCK) ;
6414 TTV_CHAIN_CLOCK = NULL ;
6415 TTV_FIND_ALLPATH = 'N' ;
6416 return(path) ;
6417 }
6418
6419 /*****************************************************************************/
6420 /* function ttv_testparamask() */
6421 /* parametres : */
6422 /* inf : argument de la recherche de chemin parallele */
6423 /* */
6424 /* test le mask pour la recherche de chemin parallele */
6425 /*****************************************************************************/
6426 int ttv_testparamask(inf)
6427 ttvinfopara *inf ;
6428 {
6429 ttvevent_list *nodex ;
6430 chain_list *chain ;
6431 chain_list *chainx ;
6432 chain_list *chainxx ;
6433
6434 if (((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ONLYNOTHZ)!=0 && (inf->TYPE & TTV_FIND_HZ)!=0)
6435 || ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ONLYHZ)!=0 && (inf->TYPE & TTV_FIND_HZ)==0)) return 0;
6436
6437 if((ttv_GET_FINDDELAY(inf->CURNODE, 0) > inf->MAX) || (ttv_GET_FINDDELAY(inf->CURNODE, 0) < inf->MIN))
6438 return(0) ;
6439
6440 if((inf->CLOCK == 1) && (TTV_CHAIN_CLOCK != NULL))
6441 {
6442 for(chain = TTV_CHAIN_CLOCK ; chain != NULL ; chain = chain->NEXT)
6443 {
6444 if((ttvsig_list *)chain->DATA == inf->CURNODE->ROOT)
6445 break ;
6446 }
6447 if(chain == NULL)
6448 return(0) ;
6449 }
6450
6451 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
6452 {
6453 if(ttv_isfalsepath(inf->FIG,inf->ROOT,inf->CURNODE,inf->TYPE,0,inf->LATCH) != 0)
6454 return(0) ;
6455 }
6456 else
6457 {
6458 if(ttv_isfalsepath(inf->FIG,inf->CURNODE,inf->ROOT,inf->TYPE,0,inf->LATCH) != 0)
6459 {
6460 return(0) ;
6461 }
6462 }
6463
6464 if (inf->CLOCK)
6465 {
6466 ttvevent_list *cmdev;
6467 // on check si le chemin de clock est valid : on est en mode non dual normalement
6468 cmdev=ttv_findlatchcommand_notdual(inf->ROOT,inf->CURNODE);
6469 if (cmdev!=NULL && ttv_isfalsepath(inf->FIG,inf->CURNODE,cmdev,inf->TYPE & ~TTV_FIND_HZ,0,NULL) != 0)
6470 return(0) ;
6471 }
6472
6473 if((inf->MASK == NULL) ||
6474 ((inf->TYPE & (TTV_FIND_MASKAND|TTV_FIND_MASKOR|TTV_FIND_MASKNOT)) == 0))
6475 return(1) ;
6476
6477 if((inf->TYPE & TTV_FIND_MASKAND) == TTV_FIND_MASKAND)
6478 {
6479 chain = NULL ;
6480 for(chainx = inf->MASK ; chainx != NULL ; chainx = chainx->NEXT)
6481 chain = addchain(chain,chainx->DATA) ;
6482 }
6483
6484 nodex = inf->CURNODE ;
6485
6486 while(nodex->FIND->OUTLINE != NULL)
6487 {
6488 if((inf->TYPE & TTV_FIND_MASKAND) == TTV_FIND_MASKAND)
6489 {
6490 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
6491 {
6492 chainxx = chainx->NEXT ;
6493 chainx->NEXT = NULL ;
6494 if(chainx->DATA != NULL)
6495 if(ttv_testmask(inf->FIG,nodex->ROOT,chainx) == 1)
6496 chainx->DATA = NULL ;
6497 chainx->NEXT = chainxx ;
6498 }
6499 }
6500 else if((inf->TYPE & TTV_FIND_MASKOR) == TTV_FIND_MASKOR)
6501 {
6502 if(ttv_testmask(inf->FIG,nodex->ROOT,inf->MASK) == 1)
6503 return(1) ;
6504 }
6505 else if((inf->TYPE & TTV_FIND_MASKNOT) == TTV_FIND_MASKNOT)
6506 {
6507 if(ttv_testmask(inf->FIG,nodex->ROOT,inf->MASK) == 1)
6508 return(0) ;
6509 }
6510 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
6511 {
6512 nodex = nodex->FIND->OUTLINE->NODE ;
6513 if(nodex == inf->ROOT) break ;
6514 }
6515 else
6516 {
6517 nodex = nodex->FIND->OUTLINE->ROOT ;
6518 if(nodex == inf->ROOT) break ;
6519 }
6520 }
6521
6522 if((inf->TYPE & TTV_FIND_MASKAND) == TTV_FIND_MASKAND)
6523 {
6524 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
6525 {
6526 chainxx = chainx->NEXT ;
6527 chainx->NEXT = NULL ;
6528 if(chainx->DATA != NULL)
6529 if(ttv_testmask(inf->FIG,nodex->ROOT,chainx) == 1)
6530 chainx->DATA = NULL ;
6531 chainx->NEXT = chainxx ;
6532 }
6533 for(chainx = chain ; chainx != NULL ; chainx = chainx->NEXT)
6534 {
6535 if(chainx->DATA != NULL)
6536 break ;
6537 }
6538 freechain(chain) ;
6539 if(chainx == NULL)
6540 return(1) ;
6541 }
6542 else if((inf->TYPE & TTV_FIND_MASKOR) == TTV_FIND_MASKOR)
6543 {
6544 if(ttv_testmask(inf->FIG,nodex->ROOT,inf->MASK) == 1)
6545 return(1) ;
6546 }
6547 else if((inf->TYPE & TTV_FIND_MASKNOT) == TTV_FIND_MASKNOT)
6548 {
6549 if(ttv_testmask(inf->FIG,nodex->ROOT,inf->MASK) == 1)
6550 return(0) ;
6551 }
6552
6553 if((inf->TYPE & TTV_FIND_MASKNOT) == TTV_FIND_MASKNOT)
6554 return(1) ;
6555 else
6556 return(0) ;
6557 }
6558
6559 /*****************************************************************************/
6560 /* function ttv_findpara() */
6561 /* parametres : */
6562 /* ttvfig : ttvfig courante */
6563 /* figpath : niveau minimum de recherche */
6564 /* root : noeud de depart de la recherche */
6565 /* node : noeud d'arrivee de la recherche */
6566 /* max : borne superieur de recherche */
6567 /* min : borne inferieur de recherche */
6568 /* type : type de recherche */
6569 /* level : niveau de la recherche */
6570 /* mask : mask de rechercher */
6571 /* */
6572 /* fonction de chemin parallele */
6573 /* renvoie le liste des details ou la liste des chemins suivant le type */
6574 /*****************************************************************************/
6575 void *ttv_findpara(ttvfig,figpath,root,node,max,min,type,level,mask,nb,saveall)
6576 ttvfig_list *ttvfig ;
6577 ttvfig_list *figpath ;
6578 ttvevent_list *root ;
6579 ttvevent_list *node ;
6580 long max ;
6581 long min ;
6582 long type ;
6583 long level ;
6584 chain_list *mask ;
6585 int nb ;
6586 int saveall;
6587 {
6588 ttvfig_list *ttvfigx ;
6589 chain_list *chain ;
6590 ttvinfopara info ;
6591
6592 ttv_ssta_set_checkloadedstore(ttvfig);
6593
6594 if(figpath == NULL)
6595 figpath = root->ROOT->ROOT ;
6596
6597 info.FIG = ttvfig ;
6598 info.INS = figpath ;
6599 info.ROOT = root ;
6600 info.NODE = node ;
6601 info.LATCH = NULL ;
6602 info.CURNODE = NULL ;
6603 info.MASK = mask ;
6604 info.MAX = max ;
6605 info.MIN = min ;
6606 info.LEVEL = level ;
6607 info.TYPE = type ;
6608 info.NBPATH = 0 ;
6609 info.NBMAX = nb ;
6610 info.LIST.CHAIN = NULL ; // initialise aussi info.LIST.PATHS
6611 info.CHAINFIG = NULL ;
6612 info.CLOCK = 0 ;
6613 info.CLOCKTAB = NULL ;
6614 info.SAVEALL = saveall;
6615
6616 if(level == ttvfig->INFO->LEVEL)
6617 {
6618 ttvfig->STATUS |= TTV_STS_NOT_FREE ;
6619 info.CHAINFIG = addchain(info.CHAINFIG,ttvfig) ;
6620 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
6621 ttv_parsttvfig(ttvfig,TTV_STS_DENOTINPT|TTV_STS_CLS_FED|TTV_STS_DUAL_D|
6622 TTV_STS_DUAL_E|TTV_STS_DUAL_F,TTV_FILE_DTX) ;
6623 else
6624 ttv_parsttvfig(ttvfig,TTV_STS_DENOTINPT|TTV_STS_CLS_FED,TTV_FILE_DTX) ;
6625 }
6626
6627 ttvfigx = root->ROOT->ROOT ;
6628 while(ttvfigx != NULL)
6629 {
6630 ttvfigx->STATUS |= TTV_STS_NOT_FREE ;
6631 info.CHAINFIG = addchain(info.CHAINFIG,ttvfigx) ;
6632 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
6633 {
6634 if(ttvfigx->INFO->LEVEL >= figpath->INFO->LEVEL)
6635 ttv_parsttvfig(ttvfigx,TTV_STS_DENOTINPT|TTV_STS_LS_FE|TTV_STS_DUAL_E|
6636 TTV_STS_DUAL_F,TTV_FILE_DTX) ;
6637 else
6638 ttv_parsttvfig(ttvfigx,TTV_STS_DENOTINPT|TTV_STS_LS_E|TTV_STS_DUAL_E,
6639 TTV_FILE_DTX) ;
6640 }
6641 else
6642 {
6643 if(ttvfigx->INFO->LEVEL >= figpath->INFO->LEVEL)
6644 ttv_parsttvfig(ttvfigx,TTV_STS_DENOTINPT|TTV_STS_LS_FE,TTV_FILE_DTX) ;
6645 else
6646 ttv_parsttvfig(ttvfigx,TTV_STS_DENOTINPT|TTV_STS_LS_E,TTV_FILE_DTX) ;
6647 }
6648 if(ttvfigx->INFO->LEVEL >= level) break ;
6649 ttvfigx = ttvfigx->ROOT ;
6650 }
6651
6652 ttv_fifopush(root) ;
6653 root->FIND->DELAY = (long)0 ;
6654
6655 ttv_bypassnode(root);
6656
6657 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MOST_DIRECT_ACCESS)==0 || (root->ROOT->TYPE & (TTV_SIG_L|TTV_SIG_B))==0)
6658 ttv_findp(root,&info) ;
6659 else
6660 ttv_findpclock(root,&info) ;
6661
6662 ttv_clean_critic_para_nodes();
6663 ttv_donotbypassnode(root);
6664
6665 if((info.NBPATH > info.NBMAX) &&
6666 ((info.TYPE & TTV_FIND_CRITIC) != TTV_FIND_CRITIC))
6667 ttv_reduceparapath(&info,1) ;
6668
6669 for(chain = info.CHAINFIG ; chain != NULL ; chain = chain->NEXT)
6670 ((ttvfig_list *)chain->DATA)->STATUS &= ~(TTV_STS_NOT_FREE) ;
6671
6672 freechain(info.CHAINFIG) ;
6673 /*
6674 if ((info.TYPE & TTV_FIND_CRITIC) != TTV_FIND_CRITIC)
6675 {
6676 for (pth=info.LIST.PATHS, info.LIST.CHAIN=NULL; pth!=NULL; pth=npth)
6677 {
6678 npth=pth->NEXT;
6679 pth->NEXT=NULL;
6680 info.LIST.CHAIN=addchain(info.LIST.CHAIN, pth);
6681 }
6682 info.LIST.CHAIN=reverse(info.LIST.CHAIN);
6683 }
6684 */
6685 return(info.LIST.CHAIN) ;
6686 }
6687
6688 /*****************************************************************************/
6689 /* function ttv_reduceparapath() */
6690 /* parametres : */
6691 /* root : noeud courant de la recherche */
6692 /* inf : information sur la recherche */
6693 /* force=1 => pas d'ajout de path, juste reduire */
6694 /* force=0 => ajout de path et reduction si necessaire */
6695 /* */
6696 /* fonction recursive de construction de chemin parallele */
6697 /* renvoie le liste des details ou la liste des chemins suivant le type */
6698 /*****************************************************************************/
6699 ttvpath_list *ttv_reduceparapath(inf,force)
6700 ttvinfopara *inf ;
6701 int force;
6702 {
6703 ttvpath_list *pathx, *npathx ;
6704
6705
6706 if (force)
6707 {
6708 ttvpath_list *path ;
6709 ttvpath_list *pathhead ;
6710 int nb ;
6711
6712 pathhead = ttv_classpath(inf->LIST.PATHS,inf->TYPE) ;
6713
6714 for(path = pathhead , nb = 1 ; nb < inf->NBMAX && path != NULL ; path = path->NEXT , nb++) ;
6715
6716 if(path != NULL)
6717 {
6718 ttv_freepathlist(path->NEXT) ;
6719 path->NEXT = NULL ;
6720
6721 if((inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX)
6722 {
6723 if(inf->MIN < path->DELAY)
6724 inf->MIN = path->DELAY ;
6725 }
6726 else
6727 {
6728 if(inf->MAX > path->DELAY)
6729 inf->MAX = path->DELAY ;
6730 }
6731 }
6732
6733 inf->LIST.PATHS = pathhead;
6734 inf->NBPATH = inf->NBMAX ;
6735 }
6736 else
6737 {
6738 pathx=inf->LIST.PATHS;
6739 npathx=pathx->NEXT;
6740
6741 if(pathx->LATCH == NULL)
6742 {
6743 if(((((pathx->NODE->ROOT->TYPE & TTV_SIG_MASKIN) != TTV_SIG_MASKIN) &&
6744 ((inf->TYPE & TTV_FIND_DUAL) != TTV_FIND_DUAL)) ||
6745 (((pathx->ROOT->ROOT->TYPE & TTV_SIG_MASKOUT) != TTV_SIG_MASKOUT) &&
6746 ((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL))) && ((inf->SAVEALL & SAVE_ALL_INPUT_TAG)==0))
6747 {
6748 pathx->NEXT = NULL ;
6749 ttv_freepathlist(pathx) ;
6750 inf->LIST.PATHS=npathx;
6751 return inf->LIST.PATHS;
6752 }
6753 }
6754 else
6755 {
6756 if(((pathx->LATCH->ROOT->TYPE & TTV_SIG_MASKIN) != TTV_SIG_MASKIN) &&
6757 ((inf->SAVEALL & SAVE_ALL_LATCH_TAG)== 0))
6758 {
6759 pathx->NEXT = NULL ;
6760 ttv_freepathlist(pathx) ;
6761 inf->LIST.PATHS=npathx;
6762 return inf->LIST.PATHS;
6763 }
6764 }
6765
6766 if(inf->NBPATH >= inf->NBMAX &&
6767 (((npathx->DELAY >= pathx->DELAY) &&
6768 ((inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
6769 ((npathx->DELAY <= pathx->DELAY) &&
6770 ((inf->TYPE & TTV_FIND_MIN) == TTV_FIND_MIN))))
6771 {
6772 pathx->NEXT = NULL ;
6773 ttv_freepathlist(pathx) ;
6774 inf->LIST.PATHS = npathx;
6775 }
6776 else
6777 inf->LIST.PATHS = ttv_keepnbpath(inf->LIST.PATHS,inf->NBMAX, &inf->NBPATH,inf->TYPE, &inner_sort_info,1) ;
6778 }
6779
6780 return(inf->LIST.PATHS) ;
6781 }
6782
6783 int ttv_check_insertability(ttvevent_list *event, ttvinfopara *inf)
6784 {
6785 ttvfig_list *ttvfigx ;
6786 ttvfigx = event->ROOT->ROOT ;
6787 if((ttvfigx->INFO->LEVEL >= inf->INS->INFO->LEVEL) && (ttvfigx->INFO->LEVEL <= inf->LEVEL))
6788 {
6789 if((inf->TYPE & TTV_FIND_CRITIC) != TTV_FIND_CRITIC)
6790 {
6791 if(inf->NBPATH >= inf->NBMAX &&
6792 ((inf->LIST.PATHS->DELAY >= inf->CURNODE->FIND->DELAY*TTV_HIGH_RATIO &&
6793 (inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX) ||
6794 (inf->LIST.PATHS->DELAY <= inf->CURNODE->FIND->DELAY*TTV_LOW_RATIO &&
6795 (inf->TYPE & TTV_FIND_MIN) == TTV_FIND_MIN)))
6796 {
6797 return 0;
6798 }
6799 }
6800 }
6801
6802 return 1;
6803 }
6804 /*****************************************************************************/
6805 /* function ttv_savparapath() */
6806 /* parametres : */
6807 /* root : noeud courant de la recherche */
6808 /* inf : information sur la recherche */
6809 /* */
6810 /* recherche les access */
6811 /*****************************************************************************/
6812 void ttv_savparapath(event,inf)
6813 ttvevent_list *event ;
6814 ttvinfopara *inf ;
6815 {
6816 ttvfig_list *ttvfigx ;
6817 ttvcritic_list *critic ;
6818 ptype_list *ptype ;
6819 chain_list *chainnode, *chain ;
6820 ttvevent_list *eventstart=event;
6821 ttvsig_list *tvs;
6822
6823 if (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH)
6824 {
6825 if ((ptype=getptype(inf->CURNODE->USER, TTV_NODE_CRITIC_PARA_INFO))!=NULL)
6826 {
6827 if (((inf->TYPE & TTV_FIND_MAX)!=0 && (long)ptype->DATA>inf->CURNODE->FIND->DELAY)
6828 || ((inf->TYPE & TTV_FIND_MIN)!=0 && (long)ptype->DATA<inf->CURNODE->FIND->DELAY))
6829 return;
6830 }
6831 }
6832
6833 ttvfigx = event->ROOT->ROOT ;
6834 if((event->FIND->OUTLINE == NULL) &&
6835 ((ptype = getptype(event->USER,TTV_NODE_LATCH)) != NULL))
6836 {
6837 event = (ttvevent_list *)ptype->DATA ;
6838 }
6839
6840 chainnode = NULL;
6841 while(event->FIND->OUTLINE != NULL)
6842 {
6843 if(event->FIND->OUTLINE->FIG->INFO->LEVEL > ttvfigx->INFO->LEVEL)
6844 ttvfigx = event->FIND->OUTLINE->FIG ;
6845
6846 if (TTV_MARK_MODE==TTV_MARK_MODE_DO)
6847 {
6848 tvs=event->ROOT;
6849 if (getptype(tvs->USER, TTV_SIG_MARKED)==NULL)
6850 {
6851 tvs->USER=addptype(tvs->USER, TTV_SIG_MARKED, NULL);
6852 MARKED_SIG_LIST=addchain(MARKED_SIG_LIST, tvs);
6853 }
6854 }
6855
6856 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
6857 {
6858 if(event->FIND->OUTLINE->NODE == inf->ROOT) break ;
6859 // zinaps : pour eviter les boucles
6860 if((event->FIND->OUTLINE->NODE->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
6861 {
6862 char buf0[128], buf1[128], buf2[128], buf[1024];
6863 sprintf(buf, "from '%s' to '%s' on node '%s'",
6864 ttv_getsigname(inf->FIG,buf0,inf->ROOT->ROOT),
6865 ttv_getsigname(inf->FIG,buf1,eventstart->ROOT),
6866 ttv_getsigname(inf->FIG,buf2,event->FIND->OUTLINE->NODE->ROOT));
6867
6868 ttv_error(54,buf,TTV_WARNING) ;
6869 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
6870 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
6871 freechain(chainnode) ;
6872 return;
6873 }
6874 event = event->FIND->OUTLINE->NODE ;
6875 }
6876 else
6877 {
6878 if(event->FIND->OUTLINE->ROOT == inf->ROOT) break ;
6879
6880 // zinaps : pour eviter les boucles
6881 if((event->FIND->OUTLINE->ROOT->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE)
6882 {
6883 char buf0[128], buf1[128], buf2[128], buf[1024];
6884 sprintf(buf, "from '%s' to '%s' on node '%s'",
6885 ttv_getsigname(inf->FIG,buf0,eventstart->ROOT),
6886 ttv_getsigname(inf->FIG,buf1,inf->ROOT->ROOT),
6887 ttv_getsigname(inf->FIG,buf2,event->FIND->OUTLINE->ROOT->ROOT));
6888 ttv_error(54,buf,TTV_WARNING) ;
6889 for(chain = chainnode ; chain != NULL ; chain = chain->NEXT)
6890 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
6891 freechain(chainnode) ;
6892 return;
6893 }
6894
6895 event = event->FIND->OUTLINE->ROOT ;
6896 }
6897 if((event->FIND->OUTLINE == NULL) &&
6898 ((ptype = getptype(event->USER,TTV_NODE_LATCH)) != NULL))
6899 {
6900 event = (ttvevent_list *)ptype->DATA ;
6901 }
6902 }
6903
6904 if (TTV_MARK_MODE==TTV_MARK_MODE_DO) return;
6905
6906 if((ttvfigx->INFO->LEVEL >= inf->INS->INFO->LEVEL) && (ttvfigx->INFO->LEVEL <= inf->LEVEL))
6907 {
6908 if((inf->TYPE & TTV_FIND_CRITIC) == TTV_FIND_CRITIC)
6909 {
6910 if (TTV_CHARAC_CRITIC_SLOPES_LIST!=NULL || TTV_CHARAC_CRITIC_CAPAS_LIST!=NULL)
6911 {
6912 if (TTV_CHARAC_CRITIC_RESULT_DELAYS==NULL)
6913 ttv_DoCharacPropagation(inf->FIG,inf->INS,inf->CURNODE,inf->ROOT,inf->TYPE,TTV_CHARAC_CRITIC_SLOPES_LIST,TTV_CHARAC_CRITIC_CAPAS_LIST, &TTV_CHARAC_CRITIC_RESULT_DELAYS, &TTV_CHARAC_CRITIC_RESULT_SLOPES, &TTV_CHARAC_CRITIC_RESULT_ENERGY, NULL);
6914 critic = NULL;
6915 }
6916 else
6917 critic = ttv_savcritic(inf->FIG,inf->INS,inf->ROOT,inf->CURNODE,inf->TYPE,1) ;
6918
6919 if(critic != NULL)
6920 {
6921 inf->LIST.CHAIN = addchain(inf->LIST.CHAIN,critic) ;
6922 }
6923 }
6924 else
6925 {
6926 // est-ce que l'on doit garder le path?
6927 if(!(inf->NBPATH >= inf->NBMAX &&
6928 (((inf->LIST.PATHS->DELAY >= ttv_GET_FINDDELAY(inf->CURNODE, 0)) &&
6929 ((inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
6930 ((inf->LIST.PATHS->DELAY <= ttv_GET_FINDDELAY(inf->CURNODE, 0)) &&
6931 ((inf->TYPE & TTV_FIND_MIN) == TTV_FIND_MIN)))))
6932 {
6933 void *old=inf->LIST.PATHS;
6934 inf->LIST.PATHS=ttv_savpath(inf->FIG,NULL,inf->LIST.PATHS,inf->ROOT,inf->CURNODE,inf->TYPE);
6935 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH)!=0 && old!=inf->LIST.PATHS)
6936 {
6937 if ((ptype=getptype(inf->CURNODE->USER, TTV_NODE_CRITIC_PARA_INFO))!=NULL)
6938 ptype->DATA=(void *)inf->CURNODE->FIND->DELAY;
6939 else
6940 {
6941 inf->CURNODE->USER=addptype(inf->CURNODE->USER, TTV_NODE_CRITIC_PARA_INFO, (void *)inf->CURNODE->FIND->DELAY);
6942 TTV_CRITIC_PARA_SEARCH=addchain(TTV_CRITIC_PARA_SEARCH, inf->CURNODE);
6943 }
6944 }
6945 ttv_reduceparapath(inf,0) ;
6946 }
6947 }
6948 }
6949 }
6950
6951 /*****************************************************************************/
6952 /* function ttv_findpclock() */
6953 /* parametres : */
6954 /* root : noeud courant de la recherche */
6955 /* inf : information sur la recherche */
6956 /* */
6957 /* recherche les access */
6958 /*****************************************************************************/
6959
6960 static int TTV_NB_FOUND=0;
6961
6962 void ttv_findpclock(event,inf)
6963 ttvevent_list *event ;
6964 ttvinfopara *inf ;
6965 {
6966 ptype_list *cmdlist ;
6967 ptype_list *ptype ;
6968 ptype_list *ptypex ;
6969 ttvevent_list *cmdevent ;
6970 ttvline_list *ptline ;
6971 chain_list *line_list;
6972 int condtrue;
6973 long delay ;
6974 long search, insert ;
6975
6976 TTV_NB_FOUND=0;
6977
6978 if ((TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_ACCESS)!=0)
6979 cmdlist=ttv_getlatchasynccmd(inf->FIG,event,inf->TYPE);
6980 else
6981 cmdlist = ttv_getlatchaccess(inf->FIG,event,inf->TYPE) ;
6982
6983 for(ptype = cmdlist ; ptype != NULL ; ptype = ptype->NEXT)
6984 {
6985 cmdevent = (ttvevent_list *)ptype->DATA ;
6986
6987 if (ttv_isbypassednode(cmdevent)) continue;
6988
6989 ttv_fifosave();
6990
6991 if(ptype->TYPE != (long)0)
6992 {
6993 ptline = (ttvline_list *)ptype->TYPE ;
6994 if((inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX)
6995 {
6996 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 1))==TTV_NOTIME)
6997 delay = ttv_getdelaymax(ptline);
6998 }
6999 else
7000 {
7001 if ((delay=stb_gettruncatedaccess(ptline->ROOT, ptline->NODE, 0))==TTV_NOTIME)
7002 delay = ttv_getdelaymin(ptline) ;
7003 }
7004 }
7005 else
7006 {
7007 ptline = NULL ;
7008 delay = (long)0 ;
7009 }
7010 ttv_fifopush(cmdevent) ;
7011 if((ptypex = getptype(cmdevent->USER,TTV_NODE_LATCH)) == NULL)
7012 {
7013 cmdevent->USER = addptype(cmdevent->USER,TTV_NODE_LATCH,event) ;
7014 cmdevent->FIND->DELAY = delay + event->FIND->DELAY ;
7015 }
7016 else
7017 {
7018 ptypex->DATA = event ;
7019 cmdevent->FIND->DELAY = delay + event->FIND->DELAY ;
7020 }
7021 cmdevent->FIND->OUTLINE = ptline ;
7022 inf->CURNODE = cmdevent ;
7023 inf->LATCH=event;
7024 inf->CLOCK = 1 ;
7025 condtrue=0;
7026 if(((cmdevent == inf->NODE) ||
7027 ((inf->NODE == NULL) &&
7028 (((search = ttv_signalsearchtype(inf->FIG,cmdevent,inf->TYPE)) & TTV_SIG_ENDSEARCH) == TTV_SIG_ENDSEARCH))))
7029 {
7030 if(!(V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && (insert=ttv_check_insertability(cmdevent, inf))==0))
7031 {
7032 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
7033 line_list=ttv_DoPropagation_PRECISION_LEVEL1(inf->FIG, NULL, inf->CURNODE, inf->ROOT, inf->TYPE);
7034
7035 if (ttv_testparamask(inf) != 0)
7036 {
7037 TTV_NB_FOUND++;
7038 ttv_savparapath(cmdevent,inf) ;
7039 condtrue=1;
7040 }
7041
7042 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
7043 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
7044 }
7045 else if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && insert==0 && ttv_testparamask(inf)!=0) TTV_NB_FOUND++;
7046 }
7047 if(condtrue==0 && (((inf->CURNODE != inf->NODE) && (inf->NODE != NULL)) ||
7048 ((inf->NODE == NULL) && ((search & TTV_SIG_CROSS) == TTV_SIG_CROSS))))
7049 {
7050 ttv_findp(cmdevent,inf) ;
7051 }
7052 inf->CLOCK = 0 ;
7053 inf->LATCH = NULL;
7054 ttv_fiforestore();
7055 }
7056
7057 if (TTV_QUIET_MODE==0 && (inf->TYPE & TTV_FIND_CRITIC)!=TTV_FIND_CRITIC && TTV_NB_FOUND==0 && (event->ROOT->TYPE & (TTV_SIG_B|TTV_SIG_C|TTV_SIG_Q))==0)
7058 {
7059 char buf0[128];
7060 ttv_error(56,ttv_getsigname(inf->FIG,buf0,event->ROOT),TTV_WARNING);
7061 }
7062
7063 freeptype(cmdlist) ;
7064 }
7065
7066 /*****************************************************************************/
7067 /* function ttv_findp() */
7068 /* parametres : */
7069 /* root : noeud courant de la recherche */
7070 /* inf : information sur la recherche */
7071 /* */
7072 /* fonction recursive de construction de chemin parallele */
7073 /* renvoie le liste des details ou la liste des chemins suivant le type */
7074 /*****************************************************************************/
7075 void ttv_findp(root,inf)
7076 ttvevent_list *root ;
7077 ttvinfopara *inf ;
7078 {
7079 static ttvfig_list *ttvfigx ;
7080 static ptype_list *ptype ;
7081 static long delay ;
7082 static int abort;
7083 static chain_list *line_list;
7084 long search ;
7085 ttvevent_list *nodex ;
7086 ttvline_list *in ;
7087 chain_list *chain ;
7088
7089 if (TTV_MARK_MODE==TTV_MARK_MODE_USE && inf->CLOCK!=0 && getptype(root->ROOT->USER, TTV_SIG_MARKED)==NULL) return;
7090 if ((inf->CLOCK!=0 || (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_MUST_BE_CLOCK)!=0) && ttv_testsigflag(root->ROOT, TTV_SIG_FLAGS_ISDATA)) return;
7091
7092 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7093 {
7094 if(((root->ROOT->TYPE & TTV_SIG_BYPASSIN) == TTV_SIG_BYPASSIN) ||
7095 ((root->TYPE & TTV_NODE_BYPASSIN) == TTV_NODE_BYPASSIN))
7096 return ;
7097 ptype = getptype(root->USER,TTV_NODE_DUALLINE) ;
7098 if(ptype == NULL) in = NULL ;
7099 else
7100 {
7101 chain = (chain_list *)ptype->DATA ;
7102 if(chain == NULL) in = NULL ;
7103 else in = (ttvline_list *)chain->DATA ;
7104 }
7105 }
7106 else
7107 {
7108 if(((root->ROOT->TYPE & TTV_SIG_BYPASSOUT) == TTV_SIG_BYPASSOUT) ||
7109 ((root->TYPE & TTV_NODE_BYPASSOUT) == TTV_NODE_BYPASSOUT))
7110 return ;
7111 in = root->INLINE ;
7112 }
7113
7114 while(in != NULL)
7115 {
7116 if(((in->TYPE & TTV_LINE_CONT) == TTV_LINE_CONT) ||
7117 (((in->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
7118 ((in->TYPE & (TTV_LINE_D|TTV_LINE_T)) != 0) &&
7119 (ttv_islineonlyend(inf->FIG,in,inf->TYPE) == 1)))
7120 {
7121 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7122 {
7123 chain = chain->NEXT ;
7124 if(chain == NULL) in = NULL ;
7125 else in = (ttvline_list *)chain->DATA ;
7126 }
7127 else
7128 in = in->NEXT ;
7129 continue ;
7130 }
7131 if((((inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX) && (in->VALMAX == TTV_NOTIME))
7132 ||(((inf->TYPE & TTV_FIND_MIN) == TTV_FIND_MIN) && (in->VALMIN == TTV_NOTIME)))
7133
7134 {
7135 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7136 {
7137 chain = chain->NEXT ;
7138 if(chain == NULL) in = NULL ;
7139 else in = (ttvline_list *)chain->DATA ;
7140 }
7141 else
7142 in = in->NEXT ;
7143 continue ;
7144 }
7145 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7146 {
7147 nodex = in->ROOT ;
7148 if(((nodex->ROOT->TYPE & TTV_SIG_BYPASSOUT) == TTV_SIG_BYPASSOUT) ||
7149 ((nodex->TYPE & TTV_NODE_BYPASSOUT) == TTV_NODE_BYPASSOUT))
7150 {
7151 chain = chain->NEXT ;
7152 if(chain == NULL) in = NULL ;
7153 else in = (ttvline_list *)chain->DATA ;
7154 continue ;
7155 }
7156 if(((in->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
7157 (root->FIND->OUTLINE != NULL))
7158 {
7159 if((root->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC)
7160 {
7161 chain = chain->NEXT ;
7162 if(chain == NULL) in = NULL ;
7163 else in = (ttvline_list *)chain->DATA ;
7164 continue ;
7165 }
7166 }
7167 if(((nodex->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
7168 ((nodex->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
7169 ((nodex->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
7170 {
7171 if(inf->CLOCK || ((((in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ) &&
7172 ((inf->TYPE & TTV_FIND_HZ) != TTV_FIND_HZ)) ||
7173 (((in->TYPE & TTV_LINE_HZ) != TTV_LINE_HZ) &&
7174 ((inf->TYPE & TTV_FIND_HZ) == TTV_FIND_HZ))))
7175 {
7176 chain = chain->NEXT ;
7177 if(chain == NULL) in = NULL ;
7178 else in = (ttvline_list *)chain->DATA ;
7179 continue ;
7180 }
7181 }
7182 if(((nodex->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
7183 ((nodex->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
7184 {
7185 if((((in->TYPE & TTV_LINE_R) == TTV_LINE_R) &&
7186 ((inf->TYPE & TTV_FIND_S) == TTV_FIND_S)) ||
7187 (((in->TYPE & TTV_LINE_S) == TTV_LINE_S) &&
7188 ((inf->TYPE & TTV_FIND_R) == TTV_FIND_R)))
7189 {
7190 chain = chain->NEXT ;
7191 if(chain == NULL) in = NULL ;
7192 else in = (ttvline_list *)chain->DATA ;
7193 continue ;
7194 }
7195 }
7196 }
7197 else
7198 {
7199 nodex = in->NODE ;
7200 if(((nodex->ROOT->TYPE & TTV_SIG_BYPASSIN) == TTV_SIG_BYPASSIN) ||
7201 ((nodex->TYPE & TTV_NODE_BYPASSIN) == TTV_NODE_BYPASSIN))
7202 {
7203 in = in->NEXT ;
7204 continue ;
7205 }
7206 if(((in->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
7207 (root->FIND->OUTLINE != NULL))
7208 {
7209 if((root->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC)
7210 {
7211 in = in->NEXT ;
7212 continue ;
7213 }
7214 }
7215 if(((root->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
7216 ((root->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
7217 ((root->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT))
7218 {
7219 if (inf->CLOCK && (in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ)
7220 {
7221 in = in->NEXT ;
7222 continue ;
7223 }
7224 if(!inf->CLOCK && ((((in->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ) &&
7225 ((inf->TYPE & TTV_FIND_HZ) != TTV_FIND_HZ)) ||
7226 (((in->TYPE & TTV_LINE_HZ) != TTV_LINE_HZ) &&
7227 ((inf->TYPE & TTV_FIND_HZ) == TTV_FIND_HZ))))
7228 {
7229 in = in->NEXT ;
7230 continue ;
7231 }
7232 }
7233 if(((root->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
7234 ((root->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
7235 {
7236 if((((in->TYPE & TTV_LINE_R) == TTV_LINE_R) &&
7237 ((inf->TYPE & TTV_FIND_S) == TTV_FIND_S)) ||
7238 (((in->TYPE & TTV_LINE_S) == TTV_LINE_S) &&
7239 ((inf->TYPE & TTV_FIND_R) == TTV_FIND_R)))
7240 {
7241 in = in->NEXT ;
7242 continue ;
7243 }
7244 }
7245 }
7246
7247 if((((in->TYPE & TTV_LINE_D) == TTV_LINE_D) &&
7248 ((inf->FIG != in->FIG) || (inf->FIG->INFO->LEVEL > inf->LEVEL))) ||
7249 (((in->TYPE & TTV_LINE_E) == TTV_LINE_E) && (inf->LEVEL < in->FIG->INFO->LEVEL)) ||
7250 (((in->TYPE & TTV_LINE_F) == TTV_LINE_F) && ((inf->LEVEL < in->FIG->INFO->LEVEL) ||
7251 (inf->INS->INFO->LEVEL > in->FIG->INFO->LEVEL))))
7252 {
7253 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7254 {
7255 chain = chain->NEXT ;
7256 if(chain == NULL) in = NULL ;
7257 else in = (ttvline_list *)chain->DATA ;
7258 }
7259 else in = in->NEXT ;
7260 continue ;
7261 }
7262
7263 /*
7264 if((((nodex->TYPE & TTV_NODE_STOP) == TTV_NODE_STOP) &&
7265 (((((((nodex->ROOT->TYPE & (TTV_SIG_CB|TTV_SIG_L|TTV_SIG_R))
7266 != TTV_SIG_CB) &&
7267 ((nodex->ROOT->TYPE & (TTV_SIG_CT|TTV_SIG_L|TTV_SIG_R))
7268 != TTV_SIG_CT)) ||
7269 (ttv_islocononlyend(inf->FIG,nodex,inf->TYPE) != 0))) &&
7270 ((nodex->ROOT->TYPE & (TTV_SIG_N|TTV_SIG_L|TTV_SIG_R)) != TTV_SIG_N)) &&
7271 ((nodex->ROOT->TYPE & TTV_SIG_Q) != TTV_SIG_Q) &&
7272 ((nodex->ROOT->TYPE & TTV_SIG_B) != TTV_SIG_B))) &&
7273 ((nodex != inf->NODE) && (inf->NODE != NULL) &&
7274 (TTV_CHAIN_CLOCK == NULL) &&
7275 (ttv_iscrosslatch(inf->FIG,nodex,inf->TYPE) == 0)))
7276 {
7277 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7278 {
7279 chain = chain->NEXT ;
7280 if(chain == NULL) in = NULL ;
7281 else in = (ttvline_list *)chain->DATA ;
7282 }
7283 else in = in->NEXT ;
7284 continue ;
7285 }
7286 */
7287
7288 if(root->ROOT->ROOT != nodex->ROOT->ROOT)
7289 {
7290 ttvfigx = nodex->ROOT->ROOT ;
7291 while((ttvfigx != inf->FIG) && ((ttvfigx->STATUS &
7292 TTV_STS_NOT_FREE) != TTV_STS_NOT_FREE))
7293 {
7294 ttvfigx->STATUS |= TTV_STS_NOT_FREE ;
7295 inf->CHAINFIG = addchain(inf->CHAINFIG,ttvfigx) ;
7296 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7297 ttv_parsttvfig(ttvfigx,TTV_STS_DENOTINPT|TTV_STS_LS_E|TTV_STS_DUAL_E,
7298 TTV_FILE_DTX) ;
7299 else
7300 ttv_parsttvfig(ttvfigx,TTV_STS_DENOTINPT|TTV_STS_LS_E,TTV_FILE_DTX) ;
7301 ttvfigx = ttvfigx->ROOT ;
7302 }
7303 }
7304
7305 if((inf->TYPE & TTV_FIND_MAX) == TTV_FIND_MAX)
7306 delay = ttv_getdelaymax(in) ;
7307 else
7308 delay = ttv_getdelaymin(in) ;
7309
7310 if (/*inf->CLOCK!=0 && */ttv_isbypassednode(nodex)) abort=1; else abort=0;
7311
7312 if(abort || ttv_transfertnodefindinfo(inf->FIG,nodex,root,in,delay,inf->TYPE) == 0)
7313 {
7314 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7315 {
7316 chain = chain->NEXT ;
7317 if(chain == NULL) in = NULL ;
7318 else in = (ttvline_list *)chain->DATA ;
7319 }
7320 else in = in->NEXT ;
7321 continue ;
7322 }
7323
7324 search = ttv_signalsearchtype(inf->FIG,nodex,inf->TYPE) ;
7325
7326 inf->CURNODE = nodex ;
7327
7328 if((TTV_CHAIN_CLOCK != NULL) &&
7329 ((nodex->ROOT->TYPE & (TTV_SIG_B|TTV_SIG_L|TTV_SIG_R)) != 0) && (inf->CLOCK == 0))
7330 {
7331 int isfalse=0;
7332 // on check si le chemin de data est un falsepath
7333 if (ttv_canbeinfalsepath(nodex, 'i') && ttv_canbeinfalsepath(inf->ROOT, 'o') && ttv_isfalsepath(inf->FIG,nodex, inf->ROOT,inf->TYPE,0,NULL))
7334 isfalse=1;
7335
7336 if (!isfalse)
7337 {
7338 ttv_bypassnode(nodex);
7339 if((nodex->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
7340 {
7341 long oldphase;
7342 char oldflags;
7343 ttvfind_stb_stuff *savetss;
7344 inf->CLOCK = 1 ;
7345 savetss=inf->CURNODE->FIND->STB;
7346 oldphase=inf->CURNODE->FIND->ORGPHASE;
7347 oldflags=inf->CURNODE->FIND->FLAGS;
7348 inf->CURNODE->FIND->FLAGS&=~TTV_FINDSTRUCT_CROSS_ENABLED;
7349 inf->CURNODE->FIND->STB=NULL;
7350 inf->CURNODE->FIND->ORGPHASE=TTV_NO_PHASE;
7351 nodex->USER = addptype(nodex->USER,TTV_NODE_LATCH,nodex) ;
7352 ttv_findp(inf->CURNODE,inf) ;
7353 nodex->USER = delptype(nodex->USER,TTV_NODE_LATCH) ;
7354 inf->CURNODE = nodex ;
7355 inf->CURNODE->FIND->ORGPHASE=oldphase;
7356 inf->CURNODE->FIND->STB=savetss;
7357 inf->CURNODE->FIND->FLAGS=oldflags;
7358 inf->CLOCK = 0 ;
7359 }
7360 else
7361 {
7362 ttv_findpclock(nodex,inf) ;
7363 inf->CURNODE = nodex ;
7364 }
7365 ttv_donotbypassnode(nodex);
7366 }
7367 }
7368 else if(((nodex == inf->NODE) ||
7369 ((inf->NODE == NULL) &&
7370 ((search & TTV_SIG_ENDSEARCH) == TTV_SIG_ENDSEARCH))))
7371 {
7372 if ((TTV_CHAIN_CLOCK == NULL && (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS)==0)
7373 || inf->CLOCK
7374 || (inf->CLOCK==0 && (TTV_MORE_SEARCH_OPTIONS & TTV_MORE_OPTIONS_REAL_ACCESS)==0))
7375 {
7376 // PS: j'utilise 'abort' dans la fonction recursive mais ca
7377 // aurait plutot du etre une nouvelle variable 'insert'
7378 if(!(V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && (abort=ttv_check_insertability(nodex, inf))==0))
7379 {
7380
7381 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
7382 line_list=ttv_DoPropagation_PRECISION_LEVEL1(inf->FIG, NULL, inf->CURNODE, inf->ROOT, inf->TYPE);
7383
7384 if (ttv_testparamask(inf) != 0)
7385 {
7386 TTV_NB_FOUND++;
7387 ttv_savparapath(nodex,inf) ;
7388 inf->ROOT->FIND->DELAY = (long)0 ;
7389 }
7390
7391 if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE>=1)
7392 ttv_CleanPropagation_PRECISION_LEVEL1(line_list);
7393 }
7394 else if (V_INT_TAB[__TTV_PRECISION_LEVEL].VALUE==1 && abort==0 && ttv_testparamask(inf)!=0) TTV_NB_FOUND++;
7395 }
7396 }
7397 if((((inf->CURNODE != inf->NODE) && (inf->NODE != NULL)) ||
7398 (inf->NODE == NULL)) && ((search & TTV_SIG_CROSS) == TTV_SIG_CROSS))
7399 {
7400 /* if (inf->CLOCK==0)*/ ttv_bypassnode(nodex);
7401 ttv_findp(inf->CURNODE,inf) ;
7402 /* if (inf->CLOCK==0)*/ ttv_donotbypassnode(nodex);
7403 }
7404 else
7405 {
7406 inf->ROOT->FIND->DELAY = (long)0 ;
7407 }
7408 if((inf->TYPE & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7409 {
7410 chain = chain->NEXT ;
7411 if(chain == NULL) in = NULL ;
7412 else in = (ttvline_list *)chain->DATA ;
7413 }
7414 else in = in->NEXT ;
7415 }
7416 }
7417
7418 /*****************************************************************************/
7419 /* function ttv_getcriticpara() */
7420 /* parametres : */
7421 /* ttvfig : ttvfig courante */
7422 /* figpath : figure de recherche d'un chemin */
7423 /* root : noeud de depart de la recherche */
7424 /* root : noeud d'arrivee de la recherche */
7425 /* delay : borne superieur de recherche */
7426 /* type : type de recherche */
7427 /* mask : mask de rechercher */
7428 /* */
7429 /* recherche les detail d'un chemin parallele entre deux noeuds */
7430 /* qui ont un delai particuliers */
7431 /*****************************************************************************/
7432 chain_list *ttv_getcriticpara(ttvfig_list *ttvfig,ttvfig_list *figpath,ttvevent_list *root,ttvevent_list *node,long delay, long type, chain_list *mask, long moreopt)
7433 {
7434 ttvfig_list *ttvfigx ;
7435 ttvevent_list *nodex ;
7436 chain_list *chain ;
7437 long level ;
7438 long levelroot ;
7439 long levelnode, comptag ;
7440
7441 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7442 {
7443 type &= ~(TTV_FIND_DUAL) ;
7444 if (node==NULL)
7445 TTV_CHAIN_CLOCK = ttv_getclocksiglist(ttvfig) ;
7446 else
7447 TTV_CHAIN_CLOCK = addchain(TTV_CHAIN_CLOCK,node->ROOT) ;
7448 }
7449
7450 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7451 {
7452 nodex = node ;
7453 node = root ;
7454 root = nodex ;
7455 }
7456
7457 if(figpath != NULL)
7458 {
7459 level = figpath->INFO->LEVEL ;
7460 }
7461 else
7462 {
7463 levelroot = ttv_getsiglevel(root->ROOT) ;
7464 levelnode = ttv_getsiglevel(node->ROOT) ;
7465 if(levelroot > ttvfig->INFO->LEVEL) levelroot = ttvfig->INFO->LEVEL ;
7466 if(levelnode > ttvfig->INFO->LEVEL) levelnode = ttvfig->INFO->LEVEL ;
7467 if(levelroot > levelnode) level = levelnode ;
7468 else level = levelroot ;
7469
7470 for(ttvfigx = root->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
7471 {
7472 ttvfigx->STATUS |= TTV_STS_MARQUE ;
7473 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
7474 }
7475
7476 for(ttvfigx = node->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
7477 if((ttvfigx->STATUS & TTV_STS_MARQUE) == TTV_STS_MARQUE)
7478 break ;
7479
7480 figpath = ttvfigx ;
7481
7482 for(ttvfigx = root->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
7483 {
7484 ttvfigx->STATUS &= ~(TTV_STS_MARQUE) ;
7485 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
7486 }
7487 }
7488
7489 if (node!=NULL) chain=addchain(NULL, node);
7490 else chain=NULL;
7491 comptag=computesavealltag(chain, 0);
7492 freechain(chain);
7493
7494 if (moreopt & TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH)
7495 TTV_MORE_SEARCH_OPTIONS|=TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH;
7496 TTV_SEARCH_FIRST_NODE=root;
7497 chain = (chain_list *)ttv_findpara(ttvfig,figpath,root,node,delay,delay,
7498 type|TTV_FIND_CRITIC,level,mask,0,comptag) ;
7499 ttv_fifoclean() ;
7500 TTV_MORE_SEARCH_OPTIONS&=~TTV_MORE_OPTIONS_CRITIC_PARA_SEARCH;
7501
7502 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7503 {
7504 freechain(TTV_CHAIN_CLOCK) ;
7505 TTV_CHAIN_CLOCK = NULL ;
7506 }
7507
7508 return(chain) ;
7509 }
7510
7511 /*****************************************************************************/
7512 /* function ttv_freecriticpara() */
7513 /* parametres : */
7514 /* pthead : liste des details de chemin parallele */
7515 /* */
7516 /* libere les details d'un chemin parallele */
7517 /*****************************************************************************/
7518 int ttv_freecriticpara(pthead)
7519 chain_list *pthead ;
7520 {
7521 chain_list *chain ;
7522
7523 if(pthead == NULL) return(0) ;
7524
7525 for(chain = pthead ; chain != NULL ; chain = chain->NEXT)
7526 {
7527 ttv_freecriticlist((ttvcritic_list *)chain->DATA) ;
7528 }
7529
7530 freechain(pthead) ;
7531
7532 return(1) ;
7533 }
7534
7535 /*****************************************************************************/
7536 /* function ttv_getpara() */
7537 /* parametres : */
7538 /* ttvfig : ttvfig courante */
7539 /* figpath : figure de recherche d'un chemin */
7540 /* root : noeud de depart de la recherche */
7541 /* root : noeud d'arrivee de la recherche */
7542 /* delaymax : borne superieur de recherche */
7543 /* delaymin : borne inferieur de recherche */
7544 /* type : type de recherche */
7545 /* mask : mask de rechercher */
7546 /* */
7547 /* recherche de chemin parrallele entre deux noeuds particuliers */
7548 /*****************************************************************************/
7549 ttvpath_list *ttv_getpara(ttvfig,figpath,root,node,max,min,type,mask,nb)
7550 ttvfig_list *ttvfig ;
7551 ttvfig_list *figpath ;
7552 ttvevent_list *root ;
7553 ttvevent_list *node ;
7554 long max ;
7555 long min ;
7556 long type ;
7557 chain_list *mask ;
7558 int nb ;
7559 {
7560 ttvfig_list *ttvfigx ;
7561 ttvevent_list *nodex ;
7562 ttvpath_list *path ;
7563 // chain_list *chain ;
7564 // chain_list *chainx ;
7565 long level ;
7566 long levelroot ;
7567 long levelnode ;
7568
7569 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7570 {
7571 type &= ~(TTV_FIND_DUAL) ;
7572 TTV_CHAIN_CLOCK = addchain(TTV_CHAIN_CLOCK,node->ROOT) ;
7573 }
7574
7575 if((type & TTV_FIND_DUAL) == TTV_FIND_DUAL)
7576 {
7577 nodex = node ;
7578 node = root ;
7579 root = nodex ;
7580 }
7581
7582 if(figpath != NULL)
7583 {
7584 level = figpath->INFO->LEVEL ;
7585 }
7586 else
7587 {
7588 levelroot = ttv_getsiglevel(root->ROOT) ;
7589 levelnode = ttv_getsiglevel(node->ROOT) ;
7590 if(levelroot > ttvfig->INFO->LEVEL) levelroot = ttvfig->INFO->LEVEL ;
7591 if(levelnode > ttvfig->INFO->LEVEL) levelnode = ttvfig->INFO->LEVEL ;
7592 if(levelroot > levelnode) level = levelnode ;
7593 else level = levelroot ;
7594
7595 for(ttvfigx = root->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
7596 {
7597 ttvfigx->STATUS |= TTV_STS_MARQUE ;
7598 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
7599 }
7600
7601 for(ttvfigx = node->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
7602 if((ttvfigx->STATUS & TTV_STS_MARQUE) == TTV_STS_MARQUE)
7603 break ;
7604
7605 figpath = ttvfigx ;
7606
7607 for(ttvfigx = root->ROOT->ROOT ; ttvfigx != NULL ; ttvfigx = ttvfigx->ROOT)
7608 {
7609 ttvfigx->STATUS &= ~(TTV_STS_MARQUE) ;
7610 if((ttvfigx->INFO->LEVEL >= level) || (ttvfigx == ttvfig)) break ;
7611 }
7612 }
7613
7614 if(figpath == NULL)
7615 {
7616 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7617 {
7618 freechain(TTV_CHAIN_CLOCK) ;
7619 TTV_CHAIN_CLOCK = NULL ;
7620 }
7621 return(NULL) ;
7622 }
7623
7624 path = (ttvpath_list *)ttv_findpara(ttvfig,figpath,root,node,
7625 max,min,type,level,mask,nb,SAVE_ALL_TAG) ;
7626 ttv_fifoclean() ;
7627
7628 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7629 {
7630 freechain(TTV_CHAIN_CLOCK) ;
7631 TTV_CHAIN_CLOCK = NULL ;
7632 }
7633
7634 if((type & TTV_FIND_NOTCLASS) == TTV_FIND_NOTCLASS)
7635 return(path) ;
7636 else
7637 return(ttv_classpath(path,type)) ;
7638 }
7639
7640 /*****************************************************************************/
7641 /* function ttv_getdelay() */
7642 /* parametres : */
7643 /* ttvfig : ttvfig courante */
7644 /* maskin : list de masques pour les entrees */
7645 /* maskout : list de masques pour les sorties */
7646 /* delaymax : temps maximum des delais */
7647 /* delaymin : temps maximum des delais */
7648 /* type : type de recherche */
7649 /* */
7650 /* recherche les delais d'une figure */
7651 /*****************************************************************************/
7652 chain_list *ttv_getdelay(ttvfig,figpath,maskin,maskout,delaymax,delaymin,type)
7653 ttvfig_list *ttvfig ;
7654 ttvfig_list *figpath ;
7655 chain_list *maskin ;
7656 chain_list *maskout ;
7657 long delaymax ;
7658 long delaymin ;
7659 long type ;
7660 {
7661 ttvlbloc_list *ptlbloc[3] ;
7662 ttvline_list *ptline ;
7663 ttvpath_list *path = NULL ;
7664 ttvpath_list *pathx ;
7665 ttvcritic_list *critic ;
7666 ttvevent_list *cmd ;
7667 chain_list *delaylist = NULL ;
7668 long typer ;
7669 long i ;
7670 long j ;
7671 long delay ;
7672 long newdelay ;
7673 long slope ;
7674 long newslope ;
7675
7676 if(figpath == NULL)
7677 figpath = ttvfig ;
7678
7679 if(figpath == ttvfig)
7680 ttv_parsttvfig(figpath,TTV_STS_CLS_FED,TTV_FILE_DTX) ;
7681 else
7682 ttv_parsttvfig(figpath,TTV_STS_LS_FE,TTV_FILE_DTX) ;
7683
7684 ptlbloc[0] = figpath->FBLOC ;
7685 ptlbloc[1] = figpath->EBLOC ;
7686
7687 if(figpath == ttvfig)
7688 ptlbloc[2] = figpath->DBLOC ;
7689 else
7690 ptlbloc[2] = NULL ;
7691
7692 for(i = 0 ; i < 3 ; i++)
7693 for( ; ptlbloc[i] != NULL ; ptlbloc[i] = ptlbloc[i]->NEXT)
7694 {
7695 for(j = 0 ; j < TTV_MAX_LBLOC ; j++)
7696 {
7697 ptline = ptlbloc[i]->LINE + j ;
7698 if((ptline->TYPE & TTV_LINE_FR) == TTV_LINE_FR)
7699 continue ;
7700
7701 if((ptline->TYPE & TTV_LINE_CONT) == TTV_LINE_CONT)
7702 continue ;
7703
7704 if((((ptline->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
7705 ((type & TTV_FIND_RC) != TTV_FIND_RC)) ||
7706 (((ptline->TYPE & TTV_LINE_RC) != TTV_LINE_RC) &&
7707 ((type & TTV_FIND_GATE) != TTV_FIND_GATE)))
7708 continue ;
7709
7710 if((((ptline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
7711 ((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
7712 ((type & TTV_FIND_NOT_UPUP) == TTV_FIND_NOT_UPUP)) ||
7713 (((ptline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
7714 ((ptline->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
7715 ((type & TTV_FIND_NOT_UPDW) == TTV_FIND_NOT_UPDW)) ||
7716 (((ptline->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
7717 ((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP) &&
7718 ((type & TTV_FIND_NOT_DWUP) == TTV_FIND_NOT_DWUP)) ||
7719 (((ptline->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
7720 ((ptline->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) &&
7721 ((type & TTV_FIND_NOT_DWDW) == TTV_FIND_NOT_DWDW)))
7722 continue ;
7723
7724 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
7725 {
7726 if((delay = ptline->VALMAX) == TTV_NOTIME)
7727 continue ; ;
7728 newdelay = ttv_getdelaymax(ptline) ;
7729 slope = ptline->FMAX ;
7730 newslope = ttv_getslopemax(ptline) ;
7731 cmd = ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMAX) ;
7732 }
7733 else
7734 {
7735 if((delay = ptline->VALMIN) == TTV_NOTIME)
7736 continue ; ;
7737 newdelay = ttv_getdelaymin(ptline) ;
7738 slope = ptline->FMIN ;
7739 newslope = ttv_getslopemin(ptline) ;
7740 cmd = ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMIN) ;
7741 }
7742
7743 if((newdelay >= delaymin) && (newdelay <= delaymax) &&
7744 ((ttv_testmask(ttvfig,ptline->NODE->ROOT,maskin) == 1) ||
7745 (maskin == NULL)) &&
7746 ((ttv_testmask(ttvfig,ptline->ROOT->ROOT,maskout) == 1) ||
7747 (maskout == NULL)))
7748 {
7749 if((ptline->TYPE & TTV_LINE_R) == TTV_LINE_R)
7750 typer = TTV_FIND_R ;
7751 else if((ptline->TYPE & TTV_LINE_S) == TTV_LINE_S)
7752 typer = TTV_FIND_S ;
7753 else if((ptline->TYPE & TTV_LINE_PR) == TTV_LINE_PR)
7754 typer = TTV_FIND_PR ;
7755 else if((ptline->TYPE & TTV_LINE_EV) == TTV_LINE_EV)
7756 typer = TTV_FIND_EV ;
7757 else typer = (long)0 ;
7758 if((ptline->TYPE & TTV_LINE_RC) == TTV_LINE_RC)
7759 typer |= TTV_FIND_RC ;
7760 if((ptline->TYPE & TTV_LINE_HZ) == TTV_LINE_HZ)
7761 typer |= TTV_FIND_HZ ;
7762 if((ptline->TYPE & TTV_LINE_R) == TTV_LINE_R)
7763 typer |= TTV_FIND_R ;
7764 if((ptline->TYPE & TTV_LINE_S) == TTV_LINE_S)
7765 typer |= TTV_FIND_S ;
7766 path = ttv_allocpath(path,figpath,ptline->ROOT,ptline->NODE,cmd,
7767 NULL,NULL,NULL,(long)0,(long)0,(long)0,type|typer,
7768 delay,slope,
7769 newdelay,newslope,(long)0,(long)0,NULL,NULL,0,STB_NO_INDEX,0) ;
7770 ttv_getmodelline(ptline,(char **)(&path->MD),(char **)(&path->MF)) ;
7771 }
7772 }
7773 }
7774
7775 if((type & TTV_FIND_NOTCLASS) != TTV_FIND_NOTCLASS)
7776 path = ttv_classpath(path,type) ;
7777
7778 for(pathx = path ; pathx != NULL ; pathx = pathx->NEXT)
7779 {
7780 critic = NULL ;
7781 critic = ttv_alloccritic(critic,ttvfig,pathx->FIG,pathx->ROOT,pathx->TYPE,
7782 (long)0,pathx->REFDELAY,pathx->REFSLOPE,pathx->DELAY,pathx->SLOPE,0,NULL,NULL) ;
7783 critic->MODNAME = (char *)pathx->MD ;
7784 critic->INSNAME = (char *)pathx->MF ;
7785 critic = ttv_alloccritic(critic,ttvfig,pathx->FIG,pathx->NODE,pathx->TYPE,
7786 (long)0,(long)0,(long)0,(long)0,(long)0,0,NULL,NULL) ;
7787 critic->MODNAME = (char *)pathx->MD ;
7788 critic->INSNAME = (char *)pathx->MF ;
7789 delaylist = addchain(delaylist,(void *)critic) ;
7790 pathx->MD = NULL;
7791 pathx->MF = NULL;
7792 }
7793
7794 ttv_freepathlist(path) ;
7795
7796 return(reverse(delaylist)) ;
7797 }
7798
7799 /*****************************************************************************/
7800 /* function ttv_getconstraint() */
7801 /* parametres : */
7802 /* ttvfig : ttvfig courante */
7803 /* figpath : figure hierarchique ou null */
7804 /* ptsig : signal ou l'on veut la contraintes L ou B */
7805 /* type : max min access or setup ou hold */
7806 /* file : fichier dtx ou ttx elais */
7807 /* */
7808 /* recherche les delais d'une figure */
7809 /*****************************************************************************/
7810 chain_list *ttv_getconstraint(ttvfig_list *ttvfig,ttvfig_list *figpath,ttvsig_list *ptsig,long type,long file,int avoiddir)
7811 {
7812 ttvline_list *ptline ;
7813 long level ;
7814 long dual ;
7815 ttvpath_list *path = NULL ;
7816 ttvpath_list *pathx ;
7817 ttvcritic_list *critic ;
7818 chain_list *delaylist = NULL ;
7819 ptype_list *ptype ;
7820 chain_list *chain ;
7821 long i ;
7822 long delay ;
7823 long newdelay ;
7824 long slope ;
7825 long newslope ;
7826
7827 if(figpath == NULL)
7828 level = 1 ;
7829 else
7830 level = figpath->INFO->LEVEL ;
7831
7832 if((type & (TTV_FIND_SETUP|TTV_FIND_HOLD)) != 0)
7833 {
7834 if((file & TTV_FILE_DTX) == TTV_FILE_DTX)
7835 dual = TTV_STS_DUAL_F|TTV_STS_DUAL_E|TTV_STS_DUAL_D ;
7836 else
7837 dual = TTV_STS_DUAL_P|TTV_STS_DUAL_J|TTV_STS_DUAL_T ;
7838 }
7839 else
7840 dual = (long)0 ;
7841
7842 if((file & TTV_FILE_DTX) == TTV_FILE_DTX)
7843 ttv_expfigsig(ttvfig,ptsig,level,ttvfig->INFO->LEVEL,
7844 TTV_STS_CLS_FED|dual, TTV_FILE_DTX);
7845 else
7846 ttv_expfigsig(ttvfig,ptsig,level,ttvfig->INFO->LEVEL,
7847 TTV_STS_CL_PJT|dual, TTV_FILE_TTX);
7848
7849
7850 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7851 for(i = 0 ; i < 2 ; i++)
7852 {
7853 if (i==avoiddir) continue;
7854 if((file & TTV_FILE_DTX) == TTV_FILE_DTX)
7855 ptline = (ptsig->NODE + i)->INLINE ;
7856 else
7857 ptline = (ptsig->NODE + i)->INPATH ;
7858
7859 for(; ptline != NULL ; ptline = ptline->NEXT)
7860 {
7861 if((ptline->TYPE & TTV_LINE_A) != TTV_LINE_A)
7862 continue ;
7863
7864 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
7865 {
7866 if((delay = ptline->VALMAX) == TTV_NOTIME)
7867 continue ; ;
7868 newdelay = ttv_getdelaymax(ptline) ;
7869 slope = ptline->FMAX ;
7870 newslope = ttv_getslopemax(ptline) ;
7871 }
7872 else
7873 {
7874 if((delay = ptline->VALMIN) == TTV_NOTIME)
7875 continue ; ;
7876 newdelay = ttv_getdelaymin(ptline) ;
7877 slope = ptline->FMIN ;
7878 newslope = ttv_getslopemin(ptline) ;
7879 }
7880
7881 path = ttv_allocpath(path,figpath,ptline->ROOT,ptline->NODE,NULL,
7882 NULL,NULL,NULL,(long)0,(long)0,(long)0,
7883 type &= ~(TTV_FIND_SETUP|TTV_FIND_HOLD),
7884 delay,slope,
7885 newdelay,newslope,(long)0,(long)0,NULL,NULL,0,STB_NO_INDEX,0) ;
7886 }
7887 }
7888
7889 if((type & (TTV_FIND_SETUP|TTV_FIND_HOLD)) != 0)
7890 for(i = 0 ; i < 2 ; i++)
7891 {
7892 if (i==avoiddir) continue;
7893 if((file & TTV_FILE_DTX) == TTV_FILE_DTX)
7894 ptype = getptype((ptsig->NODE+i)->USER,TTV_NODE_DUALLINE) ;
7895 else
7896 ptype = getptype((ptsig->NODE+i)->USER,TTV_NODE_DUALPATH) ;
7897
7898 if(ptype == NULL) chain = NULL ;
7899 else
7900 {
7901 chain = (chain_list *)ptype->DATA ;
7902 }
7903
7904 for(; chain != NULL ; chain = chain->NEXT)
7905 {
7906 ptline = (ttvline_list *)chain->DATA ;
7907
7908 if((ptline->TYPE & (TTV_LINE_U|TTV_LINE_O)) == 0)
7909 continue ;
7910
7911 if((((ptline->TYPE & TTV_LINE_U) == TTV_LINE_U) &&
7912 ((type & TTV_FIND_SETUP) != TTV_FIND_SETUP)) ||
7913 (((ptline->TYPE & TTV_LINE_O) == TTV_LINE_O) &&
7914 ((type & TTV_FIND_HOLD) != TTV_FIND_HOLD)))
7915 continue ;
7916
7917 if((delay = ptline->VALMAX) == TTV_NOTIME)
7918 continue ; ;
7919
7920 newdelay = ttv_getdelaymax(ptline) ;
7921
7922 slope = ptline->FMAX ;
7923 newslope = ttv_getslopemax(ptline) ;
7924
7925 path = ttv_allocpath(path,figpath,ptline->ROOT,ptline->NODE,NULL,
7926 NULL,NULL,NULL,(long)0,(long)0,(long)0,
7927 ((ptline->TYPE & TTV_LINE_U) == TTV_LINE_U) ?
7928 (type &= ~(TTV_FIND_ACCESS|TTV_FIND_HOLD)):
7929 (type &= ~(TTV_FIND_ACCESS|TTV_FIND_SETUP)),
7930 delay,slope,
7931 newdelay,newslope,(long)0,(long)0,NULL,NULL,0,STB_NO_INDEX,0) ;
7932 }
7933 }
7934
7935 if((type & TTV_FIND_NOTCLASS) != TTV_FIND_NOTCLASS)
7936 path = ttv_classpath(path,type) ;
7937
7938 for(pathx = path ; pathx != NULL ; pathx = pathx->NEXT)
7939 {
7940 critic = NULL ;
7941 critic = ttv_alloccritic(critic,ttvfig,pathx->FIG,pathx->ROOT,pathx->TYPE,
7942 (long)0,pathx->REFDELAY,pathx->REFSLOPE,pathx->DELAY,pathx->SLOPE,0,NULL,NULL) ;
7943 critic = ttv_alloccritic(critic,ttvfig,pathx->FIG,pathx->NODE,pathx->TYPE,
7944 (long)0,(long)0,(long)0,(long)0,(long)0,0,NULL,NULL) ;
7945 delaylist = addchain(delaylist,(void *)critic) ;
7946 }
7947
7948 ttv_freepathlist(path) ;
7949
7950 return(reverse(delaylist)) ;
7951 }
7952
7953 long ttv_getconstraintquick(ttvfig_list *ttvfig,ttvfig_list *figpath,ttvevent_list *tve,ttvevent_list *cmd,long type, ttvline_list **rline)
7954 {
7955 ttvline_list *ptline ;
7956 long level ;
7957 chain_list *chain ;
7958
7959 if(figpath == NULL)
7960 level = 1 ;
7961 else
7962 level = figpath->INFO->LEVEL ;
7963
7964 *rline=NULL;
7965
7966 if((type & TTV_FIND_ACCESS) == TTV_FIND_ACCESS)
7967 {
7968 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
7969 ttv_expfigsig(ttvfig,tve->ROOT,level,ttvfig->INFO->LEVEL,
7970 TTV_STS_CLS_FED, TTV_FILE_DTX);
7971 else
7972 ttv_expfigsig(ttvfig,tve->ROOT,level,ttvfig->INFO->LEVEL,
7973 TTV_STS_CL_PJT, TTV_FILE_TTX);
7974 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
7975 ptline = tve->INLINE ;
7976 else
7977 ptline = tve->INPATH ;
7978
7979 for(; ptline != NULL ; ptline = ptline->NEXT)
7980 {
7981 if((ptline->TYPE & TTV_LINE_A) == TTV_LINE_A && ptline->NODE==cmd)
7982 {
7983 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
7984 return ttv_getdelaymax(ptline) ;
7985 else
7986 return ttv_getdelaymin(ptline) ;
7987 }
7988 }
7989 }
7990
7991 if((type & (TTV_FIND_SETUP|TTV_FIND_HOLD)) != 0)
7992 {
7993 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
7994 ttv_expfigsig(ttvfig,cmd->ROOT,level,ttvfig->INFO->LEVEL,
7995 TTV_STS_CLS_FED, TTV_FILE_DTX);
7996 else
7997 ttv_expfigsig(ttvfig,cmd->ROOT,level,ttvfig->INFO->LEVEL,
7998 TTV_STS_CL_PJT, TTV_FILE_TTX);
7999
8000 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
8001 ptline = cmd->INLINE ;
8002 else
8003 ptline = cmd->INPATH ;
8004
8005 for(; ptline != NULL ; ptline = ptline->NEXT)
8006 {
8007 if((((ptline->TYPE & TTV_LINE_U) == TTV_LINE_U) &&
8008 ((type & TTV_FIND_SETUP) != TTV_FIND_SETUP)) ||
8009 (((ptline->TYPE & TTV_LINE_O) == TTV_LINE_O) &&
8010 ((type & TTV_FIND_HOLD) != TTV_FIND_HOLD)))
8011 continue ;
8012
8013 if(ptline->NODE==tve)
8014 {
8015 *rline=ptline;
8016 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
8017 return ttv_getdelaymax(ptline) ;
8018 else
8019 return ttv_getdelaymin(ptline) ;
8020 }
8021 }
8022 }
8023
8024 return TTV_NOTIME ;
8025 }
8026
8027 float ttv_getline_vt(ttvfig_list *ttvfig,ttvfig_list *figpath,ttvevent_list *tve,ttvevent_list *cmd,long type)
8028 {
8029 ttvline_list *ptline ;
8030 long level ;
8031 chain_list *chain ;
8032 char *stm_modelname=NULL;
8033 float vth = -1.0;
8034 timing_model *tmg_model;
8035
8036 if(figpath == NULL)
8037 level = 1 ;
8038 else
8039 level = figpath->INFO->LEVEL ;
8040
8041 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
8042 ttv_expfigsig(ttvfig,tve->ROOT,level,ttvfig->INFO->LEVEL,
8043 TTV_STS_CLS_FED, TTV_FILE_DTX);
8044 else
8045 ttv_expfigsig(ttvfig,tve->ROOT,level,ttvfig->INFO->LEVEL,
8046 TTV_STS_CL_PJT, TTV_FILE_TTX);
8047
8048 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
8049 ptline = tve->INLINE ;
8050 else
8051 ptline = tve->INPATH ;
8052
8053 for(; ptline != NULL ; ptline = ptline->NEXT)
8054 {
8055 if((ptline->TYPE & TTV_LINE_A) == TTV_LINE_A && ptline->NODE==cmd)
8056 {
8057 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
8058 stm_modelname=ptline->MDMAX;
8059 else
8060 stm_modelname=ptline->MDMIN;
8061 break;
8062 }
8063 }
8064
8065 if (stm_modelname!=NULL && (tmg_model = stm_getmodel (ptline->FIG->INSNAME,stm_modelname))) {
8066 vth = stm_mod_vt (tmg_model);
8067 }
8068
8069 return vth;
8070 }
8071
8072 /*****************************************************************************/
8073 /* function ttv_freedelaylist() */
8074 /* parametres : */
8075 /* pthead : liste des delais */
8076 /* */
8077 /* libere les delais */
8078 /*****************************************************************************/
8079 int ttv_freedelaylist(pthead)
8080 chain_list *pthead ;
8081 {
8082 return(ttv_freecriticpara(pthead)) ;
8083 }
8084
8085 /*****************************************************************************/
8086 /* function ttv_getnodeslew() */
8087 /*****************************************************************************/
8088 long ttv_getnodeslew(node, type)
8089 ttvevent_list * node;
8090 long type;
8091 {
8092 ttvdelay_list *delay;
8093 long slew = TTV_NOSLOPE;
8094 ptype_list *pt;
8095
8096 if((delay = ttv_getnodedelay(node)) != NULL){
8097 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
8098 slew = delay->FMAX;
8099 else
8100 slew = delay->FMIN;
8101 }
8102 else
8103 {
8104 if ((pt=getptype(node->USER, TTV_NODE_UTD_INPUT_SLOPE))!=NULL)
8105 slew = (long)pt->DATA;
8106 else
8107 slew = node->ROOT->ROOT->INFO->SLOPE ;
8108 }
8109 return slew;
8110 }
8111
8112 /*****************************************************************************/
8113 /* function ttv_allocpathmodel() */
8114 /* parametres : */
8115 /* ttvfig : ttvfig courante */
8116 /* inchain : liste des entrees */
8117 /* goal : noeud sortie */
8118 /* type : type de recherche */
8119 /* */
8120 /* construit les chemins a partir du parcours en largeur du graphe */
8121 /*****************************************************************************/
8122 //#define CAPASUPMODE
8123 static float ttv_getnodecapa(lofig_list *lofig, ttvevent_list *tve, long type)
8124 {
8125 float capa;
8126 char typemax ;
8127 char typemin ;
8128 double rmin, c1min, c2min, rmax, c1max, c2max ;
8129 locon_list *locon=NULL ;
8130 rcx_list *ptrcx ;
8131 rcx_slope slope;
8132 long search;
8133 if(lofig == NULL)
8134 {
8135 c1max = ttv_get_signal_capa(tve->ROOT) / 1000.0 ;
8136 c2max = 0.0 ;
8137 rmax = -1.0;
8138 c1min = ttv_get_signal_capa(tve->ROOT) / 1000.0 ;
8139 c2min = 0.0 ;
8140 rmin = -1.0;
8141 typemax = RCX_CAPALOAD ;
8142 typemin = RCX_CAPALOAD ;
8143 }
8144 else
8145 {
8146 locon = rcx_gethtrcxcon(NULL,lofig,tve->ROOT->NAME) ;
8147
8148 if((locon == NULL) || (locon->PNODE == NULL) ||
8149 ((ptrcx = getrcx(locon->SIG)) == NULL))
8150 {
8151 c1max = ttv_get_signal_capa(tve->ROOT) / 1000.0 ;
8152 c2max = 0.0 ;
8153 rmax = -1.0 ;
8154 c1min = ttv_get_signal_capa(tve->ROOT) / 1000.0 ;
8155 c2min = 0.0 ;
8156 rmin = -1.0;
8157 typemax = RCX_CAPALOAD ;
8158 typemin = RCX_CAPALOAD ;
8159 }
8160 else
8161 {
8162 if( rcx_crosstalkactive( RCX_QUERY ) != RCX_NOCROSSTALK ) {
8163 slope.F0MAX = ttv_getslopenode( tve->ROOT->ROOT,
8164 tve->ROOT->ROOT->INFO->LEVEL,
8165 tve,
8166 search |
8167 TTV_FIND_GATE |
8168 TTV_FIND_RC |
8169 TTV_FIND_MAX,
8170 TTV_MODE_LINE
8171 )/TTV_UNIT;
8172 slope.FCCMAX = ttv_getslopenode( tve->ROOT->ROOT,
8173 tve->ROOT->ROOT->INFO->LEVEL,
8174 tve,
8175 search |
8176 TTV_FIND_GATE |
8177 TTV_FIND_RC |
8178 TTV_FIND_MAX,
8179 TTV_MODE_DELAY
8180 )/TTV_UNIT;
8181 }
8182 else {
8183 slope.F0MAX = -1.0 ;
8184 slope.FCCMAX = -1.0 ;
8185 }
8186
8187 slope.SENS = ((tve->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
8188 ? TRC_SLOPE_UP : TRC_SLOPE_DOWN;
8189 slope.CCA = -1.0 ;
8190
8191 if((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8192 typemax = rcx_rcnload( lofig,
8193 locon->SIG,
8194 locon->PNODE,
8195 &rmax, &c1max, &c2max,
8196 RCX_BESTLOAD,
8197 0.0,
8198 &slope,
8199 RCX_MAX
8200 ) ;
8201 } else {
8202 typemin = rcx_rcnload( lofig,
8203 locon->SIG,
8204 locon->PNODE,
8205 &rmin, &c1min, &c2min,
8206 RCX_BESTLOAD,
8207 0.0,
8208 &slope,
8209 RCX_MIN
8210 );
8211 }
8212 }
8213 }
8214 if((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8215 capa = ((typemax==RCX_CAPALOAD) ? c1max*1000.0 : (c1max+c2max)*1000.0);
8216 }else{
8217 capa = ((typemin==RCX_CAPALOAD) ? c1min*1000.0 : (c1min+c2min)*1000.0);
8218 }
8219
8220
8221 return capa;
8222 }
8223
8224 static void ttv_getaxisvalues(ht *htslope, ht *htcapa, char *namein, char *nameout, chain_list **slope_axis, chain_list **capa_axis)
8225 {
8226 int i;
8227 stm_carac *caracslope = NULL ;
8228 stm_carac *caraccapa = NULL ;
8229
8230 *slope_axis=*capa_axis=NULL ;
8231 if(namein && htslope)
8232 {
8233 caracslope = (stm_carac*)gethtitem (htslope, namein) ;
8234 if ((long)caracslope == EMPTYHT)
8235 caracslope = (stm_carac*)gethtitem (htslope, namealloc ("default")) ;
8236 if ((long)caracslope == EMPTYHT)
8237 *slope_axis=addchain(*slope_axis, (void *)TTV_NOTIME) ;
8238 else
8239 {
8240 for (i = 0 ; i < caracslope->NVALUES ; i++)
8241 *slope_axis=addchain(*slope_axis, (void *)mbk_long_round(caracslope->VALUES[i]*TTV_UNIT));
8242 }
8243 }else
8244 *slope_axis=NULL; //addchain(*slope_axis, (void *)TTV_NOTIME) ;
8245
8246 if(nameout && htcapa)
8247 {
8248 caraccapa = (stm_carac*)gethtitem (htcapa, nameout) ;
8249 if ((long)caraccapa == EMPTYHT)
8250 caraccapa = (stm_carac*)gethtitem (htcapa, namealloc ("default")) ;
8251 if ((long)caraccapa == EMPTYHT)
8252 *capa_axis=addchain(*capa_axis, NULL), *(float *)&(*capa_axis)->DATA=-1;
8253 else
8254 {
8255 for (i = 0 ; i < caraccapa->NVALUES ; i++)
8256 *capa_axis=addchain(*capa_axis, NULL), *(float *)&(*capa_axis)->DATA=caraccapa->VALUES[i];
8257 }
8258 }else
8259 *capa_axis=NULL; //addchain(*capa_axis, NULL), *(float *)&(*capa_axis)->DATA=-1;
8260
8261 *slope_axis=reverse(*slope_axis);
8262 *capa_axis=reverse(*capa_axis);
8263 }
8264
8265 chain_list *ttv_getconnectoraxis(ttvfig_list *ttvfig, int slope, char *name)
8266 {
8267 ht *htslope_axis = NULL;
8268 ht *htcapa_axis = NULL;
8269 chain_list *res0, *res1;
8270 ptype_list *ptype;
8271
8272 if ((ptype = getptype(ttvfig->USER, TTV_FIG_SAXIS)) != NULL)
8273 htslope_axis = (ht*)ptype->DATA;
8274 if ((ptype = getptype(ttvfig->USER, TTV_FIG_CAXIS)) != NULL)
8275 htcapa_axis = (ht*)ptype->DATA;
8276
8277 ttv_getaxisvalues(htslope_axis, htcapa_axis, slope?name:NULL, slope?NULL:name, &res0, &res1);
8278 if (slope) return res0;
8279 return res1;
8280 }
8281
8282 void ttv_allocpathmodel_propagate (ttvfig_list *ttvfig, ttvfig_list *insfig, ttvevent_list *node, ttvevent_list *root, ttvpath_list *path, long type)
8283 {
8284 chain_list *input_slope, *output_capa, *real_output_capa, *res_slope, *res_delay, *res_energy, *cl, *ch;
8285 lofig_list *lofig;
8286 ht *htslope_axis = NULL;
8287 ht *htcapa_axis = NULL;
8288 int nbs, nbc, i, j, doref;
8289 timing_model *delay_model = NULL, *md;
8290 timing_model *slope_model = NULL;
8291 ptype_list *ptype;
8292 ttvline_list *line, *tl;
8293 long inslope, delta;
8294 float *ft, sigcapa=0, fl, factor;
8295
8296 if ((ptype = getptype(ttvfig->USER, TTV_FIG_SAXIS)) != NULL)
8297 htslope_axis = (ht*)ptype->DATA;
8298 if ((ptype = getptype(ttvfig->USER, TTV_FIG_CAXIS)) != NULL)
8299 htcapa_axis = (ht*)ptype->DATA;
8300
8301 ttv_getaxisvalues(htslope_axis, htcapa_axis, path->NODE->ROOT->NETNAME, path->ROOT->ROOT->NETNAME, &input_slope, &output_capa);
8302
8303 ch=ttv_BuildLineList(ttvfig, root, node, type, &doref);
8304 line=(ttvline_list *)ch->DATA;
8305 if (input_slope==NULL)
8306 {
8307 if ((line->NODE->ROOT->TYPE & TTV_SIG_C)!=0)
8308 {
8309 ttv_getnodeslope(ttvfig, insfig, line->NODE, &inslope, type);
8310 ft = stm_dyna_slews (STM_DEF_AXIS_BASE, inslope);
8311 nbs = STM_DEF_AXIS_BASE * 2 + 1;
8312 for (i=0; i<nbs; i++) input_slope=addchain(input_slope, (void *)mbk_long_round(ft[i]));
8313 mbkfree(ft);
8314 input_slope=reverse(input_slope);
8315 }
8316 else input_slope=addchain(input_slope, (void *)TTV_NOTIME) ;
8317 }
8318 else if ((line->NODE->ROOT->TYPE & TTV_SIG_C)==0)
8319 {
8320 freechain(input_slope);
8321 input_slope=addchain(NULL, (void *)TTV_NOTIME) ;
8322 }
8323
8324 line=NULL;
8325 for (cl=ch; cl!=NULL; cl=cl->NEXT)
8326 if (((tl=(ttvline_list *)cl->DATA)->TYPE & TTV_LINE_RC)==0) line=tl;
8327
8328 if ((tl->ROOT->ROOT->TYPE & TTV_SIG_C)!=0)
8329 {
8330 lofig = ttv_getrcxlofig (ttvfig);
8331 sigcapa=ttv_get_signal_capa(tl->ROOT->ROOT); //ttv_getnodecapa(lofig,tl->ROOT,type);
8332 }
8333 if (output_capa==NULL)
8334 {
8335 if ((tl->ROOT->ROOT->TYPE & TTV_SIG_C)!=0)
8336 {
8337 if (line!=NULL) md=stm_getmodel (ttvfig->INFO->FIGNAME, line->MDMAX); else md=NULL;
8338 ft = stm_dyna_loads (STM_DEF_AXIS_BASE, stm_mod_vf(md)/stm_mod_imax(md), sigcapa);
8339 nbc = STM_DEF_AXIS_BASE * 2 + 1;
8340 for (i=0; i<nbc; i++) output_capa=addchain(output_capa, NULL), *(float *)&output_capa->DATA=ft[i];
8341 mbkfree(ft);
8342 output_capa=reverse(output_capa);
8343 }
8344 else output_capa=addchain(output_capa, NULL), *(float *)&output_capa->DATA=-1;
8345 }
8346 else if ((tl->ROOT->ROOT->TYPE & TTV_SIG_C)==0)
8347 {
8348 freechain(output_capa);
8349 output_capa=addchain(NULL, NULL), *(float *)&output_capa->DATA=-1;
8350 }
8351
8352
8353 real_output_capa=dupchainlst(output_capa);
8354 if (V_BOOL_TAB[__TMA_DRIVECAPAOUT].VALUE)
8355 {
8356 for (cl=real_output_capa; cl!=NULL; cl=cl->NEXT)
8357 {
8358 fl=*(float *)&cl->DATA;
8359 if (fl!=-1)
8360 {
8361 fl=fl-sigcapa;
8362 if (fl<0)
8363 {
8364 avt_errmsg( TTV_ERRMSG, "059", AVT_WARNING, *(float *)&cl->DATA, tl->ROOT->ROOT->NAME, sigcapa);
8365 fl=0;
8366 }
8367 *(float *)&cl->DATA=fl;
8368 }
8369 }
8370 }
8371 // ttv_experim_setstopaftergate1(1);
8372 ttv_DoCharacPropagation(ttvfig, insfig, node, root, type, input_slope, real_output_capa, &res_delay, &res_slope, &res_energy, ch);
8373 // ttv_experim_setstopaftergate1(0);
8374
8375 freechain(real_output_capa);
8376
8377 nbs=countchain(input_slope);
8378 nbc=countchain(output_capa);
8379
8380 if (nbs==1)
8381 {
8382 delay_model = stm_mod_create_table (NULL, nbc, 0, STM_LOAD, STM_NOTYPE);
8383 slope_model = stm_mod_create_table (NULL, nbc, 0, STM_LOAD, STM_NOTYPE);
8384 for (cl=output_capa, i=0; i<nbc; i++, cl=cl->NEXT)
8385 {
8386 stm_modtbl_setXrangeval(delay_model->UMODEL.TABLE, i, *(float *)&cl->DATA);
8387 stm_modtbl_setXrangeval(slope_model->UMODEL.TABLE, i, *(float *)&cl->DATA);
8388 }
8389 for (cl=res_delay, i=0; cl!=NULL; cl=cl->NEXT, i++) stm_modtbl_set1Dval (delay_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8390 for (cl=res_slope, i=0; cl!=NULL; cl=cl->NEXT, i++) stm_modtbl_set1Dval (slope_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8391 }
8392 else if (nbc==1)
8393 {
8394 delay_model = stm_mod_create_table (NULL, nbs, 0, STM_INPUT_SLEW, STM_NOTYPE);
8395 slope_model = stm_mod_create_table (NULL, nbs, 0, STM_INPUT_SLEW, STM_NOTYPE);
8396 for (cl=input_slope, i=0; i<nbs; i++, cl=cl->NEXT)
8397 {
8398 stm_modtbl_setXrangeval(delay_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8399 stm_modtbl_setXrangeval(slope_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8400 }
8401 for (cl=res_delay, i=0; cl!=NULL; cl=cl->NEXT, i++) stm_modtbl_set1Dval (delay_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8402 for (cl=res_slope, i=0; cl!=NULL; cl=cl->NEXT, i++) stm_modtbl_set1Dval (slope_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8403 }
8404 else
8405 {
8406 delay_model = stm_mod_create_table (NULL, nbs, nbc, STM_INPUT_SLEW, STM_LOAD);
8407 slope_model = stm_mod_create_table (NULL, nbs, nbc, STM_INPUT_SLEW, STM_LOAD);
8408 for (cl=input_slope, i=0; i<nbs; i++, cl=cl->NEXT)
8409 {
8410 stm_modtbl_setXrangeval(delay_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8411 stm_modtbl_setXrangeval(slope_model->UMODEL.TABLE, i, ((long)cl->DATA)/TTV_UNIT);
8412 }
8413 for (cl=output_capa, i=0; i<nbc; i++, cl=cl->NEXT)
8414 {
8415 stm_modtbl_setYrangeval(delay_model->UMODEL.TABLE, i, *(float *)&cl->DATA);
8416 stm_modtbl_setYrangeval(slope_model->UMODEL.TABLE, i, *(float *)&cl->DATA);
8417 }
8418 for (cl=res_delay, ch=res_slope, i=0; i<nbs; i++)
8419 for (j=0; j<nbc; j++, cl=cl->NEXT, ch=ch->NEXT)
8420 {
8421 stm_modtbl_set2Dval(delay_model->UMODEL.TABLE, i, j, ((long)cl->DATA)/TTV_UNIT);
8422 stm_modtbl_set2Dval(slope_model->UMODEL.TABLE, i, j, ((long)ch->DATA)/TTV_UNIT);
8423 }
8424 }
8425
8426 if (ttv_get_path_margins_info(ttvfig, path, &factor, &delta))
8427 stm_modtbl_scale_and_add_val(delay_model->UMODEL.TABLE, delta/TTV_UNIT, factor);
8428 path->MF=slope_model;
8429 path->MD=delay_model;
8430
8431 freechain(input_slope);
8432 freechain(output_capa);
8433 freechain(res_delay);
8434 freechain(res_slope);
8435 freechain(res_energy);
8436
8437 }
8438
8439
8440
8441 void ttv_allocpathmodel (ttvfig, path, type)
8442 ttvfig_list *ttvfig;
8443 ttvpath_list *path;
8444 long type;
8445 {
8446 ttvevent_list *start;
8447 ttvevent_list *end;
8448 ttvline_list *start_line;
8449 ttvline_list *start_line_rc;
8450 ttvline_list *end_line;
8451 ttvline_list *end_line_rc;
8452 ttvline_list *line;
8453 ttvline_list *ptlineforslew = NULL;
8454 timing_model *mindelay = NULL;
8455 timing_model *moutdelay = NULL;
8456 timing_model *moutslope = NULL;
8457 timing_model *minslope = NULL;
8458 timing_model *modelindelay;
8459 timing_model *modelinslope;
8460 timing_model *modeloutdelay;
8461 timing_model *modeloutslope;
8462 long delay;
8463 int i, /*j,*/ ns, nl, ns_slew;
8464 float inslew_min, inslew_max, slew, load, capa, nodeslew, factor;
8465 long dmin, dmax, fmin, fmax;
8466 int singlerc = 0;
8467 lofig_list *lofig;
8468 char ttype;
8469 char typemax ;
8470 char typemin ;
8471 double rmin, c1min, c2min, rmax, c1max, c2max ;
8472 locon_list *locon=NULL ;
8473 rcx_list *ptrcx ;
8474 rcx_slope slope;
8475 long search, delta;
8476 ht *htslope_axis = NULL;
8477 ht *htcapa_axis = NULL;
8478 ptype_list *ptype;
8479
8480
8481 if ((ptype = getptype(ttvfig->USER, TTV_FIG_SAXIS)) != NULL)
8482 htslope_axis = (ht*)ptype->DATA;
8483 if ((ptype = getptype(ttvfig->USER, TTV_FIG_CAXIS)) != NULL)
8484 htcapa_axis = (ht*)ptype->DATA;
8485
8486
8487 lofig = ttv_getrcxlofig (ttvfig);
8488
8489 start = path->NODE;
8490 end = path->ROOT;
8491
8492 nodeslew = (float)ttv_getnodeslew(start, type);
8493
8494 /* start_line_rc, start_line, end_line, end_line_rc, delay */
8495
8496 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) {
8497 line = end->FIND->OUTLINE;
8498
8499 if ((line->TYPE & (TTV_LINE_D | TTV_LINE_T)) && ((line->TYPE & TTV_LINE_RC) == TTV_LINE_RC) && ((line->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C)) {
8500 if (line->NODE->FIND->OUTLINE) {
8501 end_line_rc = line;
8502 line = line->NODE->FIND->OUTLINE;
8503 }
8504 else {
8505 end_line_rc = line;
8506 line = NULL;
8507 }
8508 }
8509 else
8510 end_line_rc = NULL;
8511
8512 start_line_rc = NULL;
8513 start_line = NULL;
8514 end_line = line;
8515 if(end_line)
8516 ptlineforslew = end_line->NODE->FIND->OUTLINE;
8517 }
8518 else {
8519 line = start->FIND->OUTLINE;
8520
8521 if ((line->TYPE & (TTV_LINE_D | TTV_LINE_T)) && ((line->TYPE & TTV_LINE_RC) == TTV_LINE_RC) && ((line->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C)) {
8522 if (line->ROOT->FIND->OUTLINE) {
8523 start_line_rc = line;
8524 line = line->ROOT->FIND->OUTLINE;
8525 }
8526 else {
8527 start_line_rc = line;
8528 line = NULL;
8529 }
8530 }
8531 else
8532 start_line_rc = NULL;
8533
8534 end_line_rc = NULL;
8535 end_line = NULL;
8536 start_line = line;
8537 }
8538
8539 delay = 0;
8540
8541 while (line) {
8542 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) {
8543 if (line->NODE == start) {
8544 if (line->TYPE & (TTV_LINE_D | TTV_LINE_T)) start_line = line;
8545 break;
8546 }
8547
8548 if ((line->TYPE & (TTV_LINE_D | TTV_LINE_T)) && line->NODE->FIND->OUTLINE) {
8549 if ((line->NODE->FIND->OUTLINE->NODE == start) && ((line->NODE->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC)) {
8550 start_line_rc = line->NODE->FIND->OUTLINE;
8551 start_line = line;
8552 break;
8553 }
8554 }
8555 if ((line->ROOT != end) || ((line->ROOT == end) && ((line->ROOT->ROOT->TYPE & TTV_SIG_C) != TTV_SIG_C))) {
8556 if(!end_line_rc || (end_line_rc && (end_line_rc->NODE->FIND->OUTLINE != line))){
8557 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8558 delay += ttv_getdelaymax (line);
8559 inslew_max = ttv_getslopemax (line);
8560 }
8561 else {
8562 delay += ttv_getdelaymin (line);
8563 inslew_min = ttv_getslopemin (line);
8564 }
8565 }
8566 }
8567 }
8568 else {
8569 if (line->ROOT == end) {
8570 if (line->TYPE & (TTV_LINE_D | TTV_LINE_T)) end_line = line;
8571 if ((line->ROOT->ROOT->TYPE & TTV_SIG_C) != TTV_SIG_C){
8572 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8573 delay += ttv_getdelaymax (line);
8574 inslew_max = ttv_getslopemax (line);
8575 }
8576 else {
8577 delay += ttv_getdelaymin (line);
8578 inslew_min = ttv_getslopemin (line);
8579 }
8580 }
8581 break;
8582 }
8583
8584 if ((line->TYPE & (TTV_LINE_D | TTV_LINE_T)) && line->ROOT->FIND->OUTLINE) {
8585 if ((line->ROOT->FIND->OUTLINE->ROOT == end) && ((line->ROOT->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC)) {
8586 end_line_rc = line->ROOT->FIND->OUTLINE;
8587 end_line = line;
8588 if ((end_line_rc->ROOT->ROOT->TYPE & TTV_SIG_C) != TTV_SIG_C){
8589 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8590 delay += ttv_getdelaymax (line);
8591 inslew_max = ttv_getslopemax (line);
8592 }
8593 else {
8594 delay += ttv_getdelaymin (line);
8595 inslew_min = ttv_getslopemin (line);
8596 }
8597 }
8598 break;
8599 }
8600 }
8601 /* if (!(line->TYPE & (TTV_LINE_D | TTV_LINE_T)))*/
8602 ptlineforslew = line;
8603 if ((line->NODE != start) || ((line->NODE == start) && ((line->NODE->ROOT->TYPE & TTV_SIG_C) != TTV_SIG_C))) {
8604 if(!start_line_rc || (start_line_rc && (start_line_rc->ROOT->FIND->OUTLINE != line))){
8605 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8606 delay += ttv_getdelaymax (line);
8607 inslew_max = ttv_getslopemax (line);
8608 }
8609 else {
8610 delay += ttv_getdelaymin (line);
8611 inslew_min = ttv_getslopemin (line);
8612 }
8613 }
8614 }
8615 }
8616
8617 /* if (!(line->TYPE & (TTV_LINE_D | TTV_LINE_T))) {
8618 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8619 delay += ttv_getdelaymax (line);
8620 inslew_max = ttv_getslopemax (line);
8621 }
8622 else {
8623 delay += ttv_getdelaymin (line);
8624 inslew_min = ttv_getslopemin (line);
8625 }
8626 }
8627 */
8628 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL){
8629 line = line->NODE->FIND->OUTLINE;
8630 }else {
8631 line = line->ROOT->FIND->OUTLINE;
8632 }
8633 }
8634
8635 if (line && !(line->TYPE & (TTV_LINE_D | TTV_LINE_T))) {
8636 /* if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8637 delay += ttv_getdelaymax (line);
8638 inslew_max = ttv_getslopemax (line);
8639 }
8640 else {
8641 delay += ttv_getdelaymin (line);
8642 inslew_min = ttv_getslopemin (line);
8643 }*/
8644
8645 if ((type & TTV_FIND_DUAL) == TTV_FIND_DUAL) start_line = line;
8646 else end_line = line;
8647 }
8648
8649 //----------------------------------------------------------------------------
8650 //----------------------------------------------------------------------------
8651 // No models to create
8652
8653 singlerc = (start_line_rc || end_line_rc) && (start_line_rc == end_line_rc);
8654
8655 if (!singlerc) {
8656 if (!start_line && !end_line) {
8657 path->MD = NULL;
8658 path->MF = NULL;
8659 return;
8660 }
8661 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8662 if (!start_line && !end_line->MDMAX && !end_line->MFMAX) {
8663 path->MD = NULL;
8664 path->MF = NULL;
8665 return;
8666 }
8667 if (!end_line && !start_line->MDMAX && !start_line->MFMAX) {
8668 path->MD = NULL;
8669 path->MF = NULL;
8670 return;
8671 }
8672 if (!start_line->MDMAX && !end_line->MDMAX && !start_line->MFMAX && !end_line->MFMAX) {
8673 path->MD = NULL;
8674 path->MF = NULL;
8675 return;
8676 }
8677 }
8678 else {
8679 if (!start_line && !end_line->MDMIN && !end_line->MFMIN) {
8680 path->MD = NULL;
8681 path->MF = NULL;
8682 return;
8683 }
8684 if (!end_line && !start_line->MDMIN && !start_line->MFMIN) {
8685 path->MD = NULL;
8686 path->MF = NULL;
8687 return;
8688 }
8689 if (!start_line->MDMIN && !end_line->MDMIN && !start_line->MFMIN && !end_line->MFMIN) {
8690 path->MD = NULL;
8691 path->MF = NULL;
8692 return;
8693 }
8694 }
8695 }
8696 if (!start_line) {
8697 capa = STM_DONTCARE;
8698 }
8699 else {
8700 // capa = start_line->ROOT->ROOT->CAPA;
8701
8702 if(lofig == NULL)
8703 {
8704 c1max = ttv_get_signal_capa(start_line->ROOT->ROOT) / 1000.0 ;
8705 c2max = 0.0 ;
8706 rmax = -1.0;
8707 c1min = ttv_get_signal_capa(start_line->ROOT->ROOT) / 1000.0 ;
8708 c2min = 0.0 ;
8709 rmin = -1.0;
8710 typemax = RCX_CAPALOAD ;
8711 typemin = RCX_CAPALOAD ;
8712 }
8713 else
8714 {
8715 locon = rcx_gethtrcxcon(NULL,lofig,start_line->ROOT->ROOT->NAME) ;
8716
8717 if((locon == NULL) || (locon->PNODE == NULL) ||
8718 ((ptrcx = getrcx(locon->SIG)) == NULL))
8719 {
8720 c1max = ttv_get_signal_capa(start_line->ROOT->ROOT) / 1000.0 ;
8721 c2max = 0.0 ;
8722 rmax = -1.0 ;
8723 c1min = ttv_get_signal_capa(start_line->ROOT->ROOT) / 1000.0 ;
8724 c2min = 0.0 ;
8725 rmin = -1.0;
8726 typemax = RCX_CAPALOAD ;
8727 typemin = RCX_CAPALOAD ;
8728 }
8729 else
8730 {
8731 if( rcx_crosstalkactive( RCX_QUERY ) != RCX_NOCROSSTALK ) {
8732 slope.F0MAX = ttv_getslopenode( start_line->ROOT->ROOT->ROOT,
8733 start_line->ROOT->ROOT->ROOT->INFO->LEVEL,
8734 start_line->ROOT,
8735 search |
8736 TTV_FIND_GATE |
8737 TTV_FIND_RC |
8738 TTV_FIND_MAX,
8739 TTV_MODE_LINE
8740 )/TTV_UNIT;
8741 slope.FCCMAX = ttv_getslopenode( start_line->ROOT->ROOT->ROOT,
8742 start_line->ROOT->ROOT->ROOT->INFO->LEVEL,
8743 start_line->ROOT,
8744 search |
8745 TTV_FIND_GATE |
8746 TTV_FIND_RC |
8747 TTV_FIND_MAX,
8748 TTV_MODE_DELAY
8749 )/TTV_UNIT;
8750 }
8751 else {
8752 slope.F0MAX = -1.0 ;
8753 slope.FCCMAX = -1.0 ;
8754 }
8755
8756 slope.SENS = ((start_line->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
8757 ? TRC_SLOPE_UP : TRC_SLOPE_DOWN;
8758 slope.CCA = -1.0 ;
8759
8760 if((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8761 typemax = rcx_rcnload( lofig,
8762 locon->SIG,
8763 locon->PNODE,
8764 &rmax, &c1max, &c2max,
8765 RCX_BESTLOAD,
8766 0.0,
8767 &slope,
8768 RCX_MAX
8769 ) ;
8770 } else {
8771 typemin = rcx_rcnload( lofig,
8772 locon->SIG,
8773 locon->PNODE,
8774 &rmin, &c1min, &c2min,
8775 RCX_BESTLOAD,
8776 0.0,
8777 &slope,
8778 RCX_MIN
8779 );
8780 }
8781 }
8782 }
8783 if((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8784 capa = ((typemax==RCX_CAPALOAD) ? c1max*1000.0 : (c1max+c2max)*1000.0);
8785 }else{
8786 capa = ((typemin==RCX_CAPALOAD) ? c1min*1000.0 : (c1min+c2min)*1000.0);
8787 }
8788
8789 }
8790
8791 //----------------------------------------------------------------------------
8792 // models to create
8793 if((((path->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((path->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N))
8794 &&(((path->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((path->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N))){
8795 stm_addaxisvalues(htslope_axis, htcapa_axis, path->NODE->ROOT->NETNAME, path->ROOT->ROOT->NETNAME);
8796 if (!start_line) {
8797 modelindelay = NULL;
8798 modelinslope = NULL;
8799 }
8800 else {
8801 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8802 modelindelay = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MDMAX);
8803 if (STM_CACHE && modelindelay)
8804 mbk_cache_lock (STM_CACHE, modelindelay);
8805 modelinslope = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MFMAX);
8806 if (STM_CACHE && modelinslope)
8807 mbk_cache_lock (STM_CACHE, modelinslope);
8808 } else {
8809 modelindelay = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MDMIN);
8810 if (STM_CACHE && modelindelay)
8811 mbk_cache_lock (STM_CACHE, modelindelay);
8812 modelinslope = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MFMIN);
8813 if (STM_CACHE && modelinslope)
8814 mbk_cache_lock (STM_CACHE, modelinslope);
8815 }
8816 }
8817
8818 if (!end_line) {
8819 modeloutdelay = NULL;
8820 modeloutslope = NULL;
8821 }
8822 else {
8823 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8824 modeloutdelay = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MDMAX);
8825 if (STM_CACHE && modeloutdelay)
8826 mbk_cache_lock (STM_CACHE, modeloutdelay);
8827 modeloutslope = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MFMAX);
8828 if (STM_CACHE && modeloutslope)
8829 mbk_cache_lock (STM_CACHE, modeloutslope);
8830 } else {
8831 modeloutdelay = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MDMIN);
8832 if (STM_CACHE && modeloutdelay)
8833 mbk_cache_lock (STM_CACHE, modeloutdelay);
8834 modeloutslope = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MFMIN);
8835 if (STM_CACHE && modeloutslope)
8836 mbk_cache_lock (STM_CACHE, modeloutslope);
8837 }
8838 }
8839 }else if(((path->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((path->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N)){
8840 stm_addaxisvalues(htslope_axis, htcapa_axis, path->NODE->ROOT->NETNAME, NULL);
8841 if (!start_line) {
8842 modelindelay = NULL;
8843 modelinslope = NULL;
8844 }
8845 else {
8846 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8847 modelindelay = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MDMAX);
8848 if (STM_CACHE && modelindelay)
8849 mbk_cache_lock (STM_CACHE, modelindelay);
8850 modelinslope = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MFMAX);
8851 if (STM_CACHE && modelinslope)
8852 mbk_cache_lock (STM_CACHE, modelinslope);
8853 } else {
8854 modelindelay = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MDMIN);
8855 if (STM_CACHE && modelindelay)
8856 mbk_cache_lock (STM_CACHE, modelindelay);
8857 modelinslope = stm_getmodel (ttvfig->INFO->FIGNAME, start_line->MFMIN);
8858 if (STM_CACHE && modelinslope)
8859 mbk_cache_lock (STM_CACHE, modelinslope);
8860 }
8861 }
8862 if(start_line != end_line){
8863 modeloutdelay = NULL;
8864 modeloutslope = NULL;
8865 }else{
8866 modeloutdelay = modelindelay;
8867 modeloutslope = modelinslope;
8868 }
8869 }else if(((path->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((path->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N)){
8870 stm_addaxisvalues(htslope_axis, htcapa_axis, NULL, path->ROOT->ROOT->NETNAME);
8871 if (!end_line) {
8872 modeloutdelay = NULL;
8873 modeloutslope = NULL;
8874 }
8875 else {
8876 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8877 modeloutdelay = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MDMAX);
8878 if (STM_CACHE && modeloutdelay)
8879 mbk_cache_lock (STM_CACHE, modeloutdelay);
8880 modeloutslope = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MFMAX);
8881 if (STM_CACHE && modeloutslope)
8882 mbk_cache_lock (STM_CACHE, modeloutslope);
8883 } else {
8884 modeloutdelay = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MDMIN);
8885 if (STM_CACHE && modeloutdelay)
8886 mbk_cache_lock (STM_CACHE, modeloutdelay);
8887 modeloutslope = stm_getmodel (ttvfig->INFO->FIGNAME, end_line->MFMIN);
8888 if (STM_CACHE && modeloutslope)
8889 mbk_cache_lock (STM_CACHE, modeloutslope);
8890 }
8891 }
8892 if(start_line != end_line){
8893 modelindelay = NULL;
8894 modelinslope = NULL;
8895 }else{
8896 modelindelay = modeloutdelay;
8897 modelinslope = modeloutslope;
8898 }
8899 }else{
8900 modeloutdelay = NULL;
8901 modeloutslope = NULL;
8902 modelindelay = NULL;
8903 modelinslope = NULL;
8904 }
8905
8906 // creation du modele rc + gate start ------------------------------------------------------------------------
8907 if (start_line_rc && start_line && modelindelay && modelinslope && (start_line != end_line)) {
8908
8909 // delay model
8910 mindelay = stm_mod_reduce(NULL, modelindelay, nodeslew/TTV_UNIT, capa, STM_LOADFIX_RED, STM_DELAY);
8911 ns = stm_modtbl_getnslew (mindelay->UMODEL.TABLE);
8912 if (!ns) {
8913 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
8914 ttv_calcgatercdelayslope (start_line_rc, start_line, nodeslew, nodeslew,
8915 capa, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
8916 stm_modtbl_setconst (mindelay->UMODEL.TABLE, dmax/TTV_UNIT);
8917 }else{
8918 ttv_calcgatercdelayslope (start_line_rc, start_line, nodeslew, nodeslew,
8919 capa, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
8920 stm_modtbl_setconst (mindelay->UMODEL.TABLE, dmin/TTV_UNIT);
8921 }
8922 }
8923 else
8924 for (i = 0; i < ns; i++) {
8925 slew = stm_modtbl_getslewaxisval (mindelay->UMODEL.TABLE, i);
8926
8927 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
8928 ttv_calcgatercdelayslope (start_line_rc, start_line, slew*TTV_UNIT, slew*TTV_UNIT, capa, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
8929 stm_modtbl_set1Dval (mindelay->UMODEL.TABLE, i, dmax/TTV_UNIT);
8930 }else{
8931 ttv_calcgatercdelayslope (start_line_rc, start_line, slew*TTV_UNIT, slew*TTV_UNIT, capa, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
8932 stm_modtbl_set1Dval (mindelay->UMODEL.TABLE, i, dmin/TTV_UNIT);
8933 }
8934 }
8935
8936 // slope model
8937 minslope = stm_mod_reduce(NULL, modelinslope, nodeslew/TTV_UNIT, capa, STM_LOADFIX_RED, STM_SLEW);
8938 ns = stm_modtbl_getnslew (minslope->UMODEL.TABLE);
8939 if (!ns) {
8940 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
8941 ttv_calcgatercdelayslope (start_line_rc, start_line, nodeslew, nodeslew,
8942 capa, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
8943 stm_modtbl_setconst (minslope->UMODEL.TABLE, fmax/TTV_UNIT);
8944 }else{
8945 ttv_calcgatercdelayslope (start_line_rc, start_line, nodeslew, nodeslew,
8946 capa, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
8947 stm_modtbl_setconst (minslope->UMODEL.TABLE, fmin/TTV_UNIT);
8948 }
8949 }
8950 for (i = 0; i < ns; i++) {
8951 slew = stm_modtbl_getslewaxisval (minslope->UMODEL.TABLE, i);
8952 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
8953 ttv_calcgatercdelayslope (start_line_rc, start_line, slew*TTV_UNIT, slew*TTV_UNIT, capa, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
8954 stm_modtbl_set1Dval (minslope->UMODEL.TABLE, i, fmax/TTV_UNIT);
8955 }else{
8956 ttv_calcgatercdelayslope (start_line_rc, start_line, slew*TTV_UNIT, slew*TTV_UNIT, capa, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
8957 stm_modtbl_set1Dval (minslope->UMODEL.TABLE, i, fmin/TTV_UNIT);
8958 }
8959 }
8960 if (STM_CACHE) {
8961 mbk_cache_unlock (STM_CACHE, modelinslope);
8962 mbk_cache_unlock (STM_CACHE, modelindelay);
8963 }
8964 modelinslope = minslope;
8965 modelindelay = mindelay;
8966 }
8967
8968 // creation du modele rc + gate end ------------------------------------------------------------------------
8969 if (end_line_rc && end_line && modeloutdelay && modeloutslope && (start_line != end_line)) {
8970 if (ptlineforslew) {
8971 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
8972 slew = ttv_getslopemax (ptlineforslew);
8973 else
8974 slew = ttv_getslopemin (ptlineforslew);
8975 }
8976 else slew = STM_DEF_SLEW * TTV_UNIT ;
8977
8978 load = ttv_get_signal_capa(end_line->ROOT->ROOT);
8979 moutdelay = stm_mod_reduce(NULL, modeloutdelay, slew/TTV_UNIT, load, STM_SLEWFIX_RED, STM_DELAY);
8980 moutslope = stm_mod_reduce(NULL, modeloutslope, slew/TTV_UNIT, load, STM_SLEWFIX_RED, STM_SLEW);
8981 nl = stm_modtbl_getnload (moutdelay->UMODEL.TABLE);
8982 /* for (i = 0; i < nl; i++) {
8983 load = stm_modtbl_getloadaxisval (moutdelay->UMODEL.TABLE, i);
8984
8985 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
8986 ttv_calcgatercdelayslope (end_line, end_line_rc, slew, slew, load, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
8987 stm_modtbl_set1Dval (moutdelay->UMODEL.TABLE, i, dmax/TTV_UNIT);
8988 stm_modtbl_set1Dval (moutslope->UMODEL.TABLE, i, fmax/TTV_UNIT);
8989 }
8990 else {
8991 ttv_calcgatercdelayslope (end_line, end_line_rc, slew, slew, load, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
8992 stm_modtbl_set1Dval (moutdelay->UMODEL.TABLE, i, dmin/TTV_UNIT);
8993 stm_modtbl_set1Dval (moutslope->UMODEL.TABLE, i, fmin/TTV_UNIT);
8994 }
8995 }*/
8996 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
8997 stm_modtbl_scale_and_add_val (moutdelay->UMODEL.TABLE, (float)end_line_rc->VALMAX/TTV_UNIT, 1);
8998 }else{
8999 stm_modtbl_scale_and_add_val (moutdelay->UMODEL.TABLE, (float)end_line_rc->VALMIN/TTV_UNIT, 1);
9000 }
9001 if (STM_CACHE) {
9002 mbk_cache_unlock (STM_CACHE, modeloutslope);
9003 mbk_cache_unlock (STM_CACHE, modeloutdelay);
9004 }
9005 modeloutslope = moutslope;
9006 modeloutdelay = moutdelay;
9007 }
9008
9009 if (end_line_rc && end_line && modelindelay && modelinslope && (start_line == end_line)) {
9010 mindelay = stm_mod_reduce(NULL, modelindelay, nodeslew/TTV_UNIT, capa, STM_COPY, STM_DELAY);
9011 minslope = stm_mod_reduce(NULL, modelinslope, nodeslew/TTV_UNIT, capa, STM_COPY, STM_SLEW);
9012 ns = stm_modtbl_getnslew (mindelay->UMODEL.TABLE);
9013 nl = stm_modtbl_getnload (mindelay->UMODEL.TABLE);
9014 ns_slew = stm_modtbl_getnslew (minslope->UMODEL.TABLE);
9015 /* for (j = 0; j < nl; j++) {
9016 for (i = 0; i < ns; i++) {
9017 slew = stm_modtbl_getslewaxisval (mindelay->UMODEL.TABLE, i);
9018 load = stm_modtbl_getloadaxisval (mindelay->UMODEL.TABLE, j);
9019 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
9020 ttv_calcgatercdelayslope (end_line, end_line_rc, slew*TTV_UNIT, slew*TTV_UNIT, load, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
9021 stm_modtbl_set2Dval (mindelay->UMODEL.TABLE, i, j, dmax/TTV_UNIT);
9022 if(ns_slew)
9023 stm_modtbl_set2Dval (minslope->UMODEL.TABLE, i, j, fmax/TTV_UNIT);
9024 else
9025 stm_modtbl_set1Dval (minslope->UMODEL.TABLE, j, fmax/TTV_UNIT);
9026 }else{
9027 ttv_calcgatercdelayslope (end_line, end_line_rc, slew*TTV_UNIT, slew*TTV_UNIT, load, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
9028 stm_modtbl_set2Dval (mindelay->UMODEL.TABLE, i, j, dmin/TTV_UNIT);
9029 if(ns_slew)
9030 stm_modtbl_set2Dval (minslope->UMODEL.TABLE, i, j, fmin/TTV_UNIT);
9031 else
9032 stm_modtbl_set1Dval (minslope->UMODEL.TABLE, j, fmin/TTV_UNIT);
9033 }
9034 }
9035 }*/
9036 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
9037 stm_modtbl_scale_and_add_val (mindelay->UMODEL.TABLE, (float)end_line_rc->VALMAX/TTV_UNIT, 1);
9038 }else{
9039 stm_modtbl_scale_and_add_val (mindelay->UMODEL.TABLE, (float)end_line_rc->VALMIN/TTV_UNIT, 1);
9040 }
9041 if(start_line_rc){
9042 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX){
9043 stm_modtbl_scale_and_add_val (mindelay->UMODEL.TABLE, (float)start_line_rc->VALMAX/TTV_UNIT, 1);
9044 }else{
9045 stm_modtbl_scale_and_add_val (mindelay->UMODEL.TABLE, (float)start_line_rc->VALMIN/TTV_UNIT, 1);
9046 }
9047 }
9048 if (STM_CACHE) {
9049 mbk_cache_unlock (STM_CACHE, modelinslope);
9050 mbk_cache_unlock (STM_CACHE, modelindelay);
9051 }
9052 modelinslope = minslope;
9053 modelindelay = mindelay;
9054 }
9055 // creation du modele rc + gate singlerc ------------------------------------------------------------------------
9056 if (singlerc) {
9057 load = ttv_get_signal_capa(start_line_rc->NODE->ROOT);
9058 mindelay = stm_mod_create_table (NULL, 3, 0, STM_INPUT_SLEW, STM_NOTYPE);
9059 minslope = stm_mod_create_table (NULL, 3, 0, STM_INPUT_SLEW, STM_NOTYPE);
9060
9061 for (i = 0; i < 3; i++) {
9062 switch (i) {
9063 case 0: slew = nodeslew / 2; break;
9064 case 1: slew = nodeslew; break;
9065 case 2: slew = nodeslew * 2; break;
9066 }
9067
9068 mindelay->UMODEL.TABLE->XRANGE[i] = slew/TTV_UNIT;
9069 minslope->UMODEL.TABLE->XRANGE[i] = slew/TTV_UNIT;
9070 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX) {
9071 ttv_calcgatercdelayslope (end_line_rc, NULL, slew, slew, load, NULL, NULL, &dmax, &fmax, TTV_MODE_NOTSTORE);
9072 stm_modtbl_set1Dval (mindelay->UMODEL.TABLE, i, dmax/TTV_UNIT);
9073 stm_modtbl_set1Dval (minslope->UMODEL.TABLE, i, fmax/TTV_UNIT);
9074 }
9075 else {
9076 ttv_calcgatercdelayslope (end_line_rc, NULL, slew, slew, load, &dmin, &fmin, NULL, NULL, TTV_MODE_NOTSTORE);
9077 stm_modtbl_set1Dval (mindelay->UMODEL.TABLE, i, dmin/TTV_UNIT);
9078 stm_modtbl_set1Dval (minslope->UMODEL.TABLE, i, fmin/TTV_UNIT);
9079 }
9080 }
9081
9082 modelinslope = minslope;
9083 modelindelay = mindelay;
9084 }
9085
9086 // models assignation ---------------------------------------------------------
9087 if (start_line != end_line) {
9088 if (ptlineforslew) {
9089 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9090 slew = ttv_getslopemax (ptlineforslew);
9091 else
9092 slew = ttv_getslopemin (ptlineforslew);
9093 }
9094 else slew = STM_DEF_SLEW * TTV_UNIT ;
9095
9096 path->MD = stm_mod_merge (NULL, modelindelay, modeloutdelay, (float)delay/TTV_UNIT, (float)capa, (float)slew/TTV_UNIT);
9097 if(modeloutslope){
9098 path->MF = stm_mod_reduce (NULL, modeloutslope, (float)slew/TTV_UNIT, (float)capa, STM_SLEWFIX_RED, STM_SLEW);
9099 }else{
9100 if ((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9101 path->MF = stm_mod_create_fcst (NULL, ttv_getslopemax (end_line)/TTV_UNIT, STM_MOD_MODTBL);
9102 else
9103 path->MF = stm_mod_create_fcst (NULL, ttv_getslopemin (end_line)/TTV_UNIT, STM_MOD_MODTBL);
9104 }
9105 }
9106 else {
9107 if((((start_line->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((start_line->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N))
9108 &&(((start_line->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((start_line->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N))){
9109 path->MD = stm_mod_reduce(NULL, modelindelay, nodeslew/TTV_UNIT, capa, STM_COPY, STM_DELAY);
9110 path->MF = stm_mod_reduce(NULL, modelinslope, nodeslew/TTV_UNIT, capa, STM_COPY, STM_SLEW);
9111 }else if(((start_line->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((start_line->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N)){
9112 path->MD = stm_mod_reduce(NULL, modelindelay, nodeslew/TTV_UNIT, capa, STM_LOADFIX_RED, STM_DELAY);
9113 path->MF = stm_mod_reduce(NULL, modelinslope, nodeslew/TTV_UNIT, capa, STM_LOADFIX_RED, STM_SLEW);
9114 }else if(((start_line->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((start_line->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N)){
9115 path->MD = stm_mod_reduce(NULL, modelindelay, STM_DEF_SLEW, capa, STM_SLEWFIX_RED, STM_DELAY);
9116 path->MF = stm_mod_reduce(NULL, modelinslope, STM_DEF_SLEW, capa, STM_SLEWFIX_RED, STM_SLEW);
9117 }
9118 }
9119
9120 if(((path->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) && ((path->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP))
9121 ttype = STM_HH;
9122 else if(((path->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) && ((path->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN))
9123 ttype = STM_HL;
9124 else if(((path->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) && ((path->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP))
9125 ttype = STM_LH;
9126 else if(((path->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) && ((path->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN))
9127 ttype = STM_LL;
9128 stm_mod_update_transition(path->MD, ttype);
9129 stm_mod_update_transition(path->MF, ttype);
9130
9131 // temp models destruction ----------------------------------------------------
9132 if (STM_CACHE) {
9133 if (mbk_cache_islock (STM_CACHE, modelinslope) == YES)
9134 mbk_cache_unlock (STM_CACHE, modelinslope);
9135 if (mbk_cache_islock (STM_CACHE, modelindelay) == YES)
9136 mbk_cache_unlock (STM_CACHE, modelindelay);
9137 if (mbk_cache_islock (STM_CACHE, modeloutdelay) == YES)
9138 mbk_cache_unlock (STM_CACHE, modeloutdelay);
9139 if (mbk_cache_islock (STM_CACHE, modeloutslope) == YES)
9140 mbk_cache_unlock (STM_CACHE, modeloutslope);
9141 }
9142 if (mindelay) stm_mod_destroy (mindelay);
9143 if (minslope) stm_mod_destroy (minslope);
9144 if (moutdelay) stm_mod_destroy (moutdelay);
9145 if (moutslope) stm_mod_destroy (moutslope);
9146 stm_delaxisvalues();
9147
9148 if (path->MD!=NULL && ttv_get_path_margins_info(ttvfig, path, &factor, &delta))
9149 stm_modtbl_scale_and_add_val(path->MD->UMODEL.TABLE, delta/TTV_UNIT, factor);
9150 }
9151
9152 /*****************************************************************************/
9153 /* function ttv_allocnewmodel() */
9154 /* parametres : */
9155 /* ttvfig : ttvfig courante */
9156 /* inchain : liste des entrees */
9157 /* goal : noeud sortie */
9158 /* type : type de recherche */
9159 /* */
9160 /* construit les chemins a partir du parcours en largeur du graphe */
9161 /*****************************************************************************/
9162 void ttv_allocnewmodel(ttvfig,node,goal,ptline,ptend,caracnode,caracgoal,type)
9163 ttvfig_list *ttvfig ;
9164 ttvevent_list *node ;
9165 ttvevent_list *goal ;
9166 ttvline_list *ptline ;
9167 ttvline_list *ptend ;
9168 ttvline_list *caracnode ;
9169 ttvline_list *caracgoal ;
9170 long type ;
9171 {
9172 ttvline_list *ptlinex ;
9173 char *modelindelay ;
9174 char *modeloutdelay ;
9175 char *modeloutslope ;
9176 long delay, slew = STM_DEF_SLEW * TTV_UNIT ;
9177 float capa, vt, vth, vdd, vend ;
9178 timing_model *tmodel;
9179 char ttype;
9180 ht *htslope_axis = NULL;
9181 ht *htcapa_axis = NULL;
9182 ptype_list *ptype;
9183
9184 if ((ptype = getptype(ttvfig->USER, TTV_FIG_SAXIS)) != NULL)
9185 htslope_axis = (ht*)ptype->DATA;
9186 if ((ptype = getptype(ttvfig->USER, TTV_FIG_CAXIS)) != NULL)
9187 htcapa_axis = (ht*)ptype->DATA;
9188
9189 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9190 {
9191 if(caracnode == NULL)
9192 {
9193 if((caracgoal->MDMAX == NULL) && (caracgoal->MFMAX == NULL))
9194 return ;
9195 }
9196 else if(caracgoal == NULL)
9197 {
9198 if((caracnode->MDMAX == NULL) && (caracnode->MFMAX == NULL))
9199 return ;
9200 }
9201 else if((caracnode->MDMAX == NULL) && (caracgoal->MDMAX == NULL) &&
9202 (caracnode->MFMAX == NULL) && (caracgoal->MFMAX == NULL))
9203 return ;
9204 }
9205 else
9206 {
9207 if(caracnode == NULL)
9208 {
9209 if((caracgoal->MDMIN == NULL) && (caracgoal->MFMIN == NULL))
9210 return ;
9211 }
9212 else if(caracgoal == NULL)
9213 {
9214 if((caracnode->MDMIN == NULL) && (caracnode->MFMIN == NULL))
9215 return ;
9216 }
9217 else if((caracnode->MDMIN == NULL) && (caracgoal->MDMIN == NULL) &&
9218 (caracnode->MFMIN == NULL) && (caracgoal->MFMIN == NULL))
9219 return ;
9220 }
9221
9222 if(node->FIND->OUTLINE == ptline)
9223 {
9224 return ;
9225 }
9226
9227 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9228 {
9229 if(caracnode == NULL)
9230 {
9231 modelindelay = NULL ;
9232 }
9233 else
9234 {
9235 modelindelay = caracnode->MDMAX ;
9236 }
9237 if(caracgoal == NULL)
9238 {
9239 modeloutdelay = NULL ;
9240 modeloutslope = NULL ;
9241 }
9242 else
9243 {
9244 modeloutdelay = caracgoal->MDMAX ;
9245 modeloutslope = caracgoal->MFMAX ;
9246 }
9247 }
9248 else
9249 {
9250 if(caracnode == NULL)
9251 {
9252 modelindelay = NULL ;
9253 }
9254 else
9255 {
9256 modelindelay = caracnode->MDMIN ;
9257 }
9258 if(caracgoal == NULL)
9259 {
9260 modeloutdelay = NULL ;
9261 modeloutslope = NULL ;
9262 }
9263 else
9264 {
9265 modeloutdelay = caracgoal->MDMIN ;
9266 modeloutslope = caracgoal->MFMIN ;
9267 }
9268 }
9269
9270 delay = (long)0 ;
9271 ptlinex = node->FIND->OUTLINE ;
9272 if(ptlinex){
9273 if((type & TTV_FIND_MAX) == TTV_FIND_MAX){
9274 capa = ttv_getcapamax(ptlinex);
9275 slew = ttv_getslopemax(ptlinex);
9276 }else{
9277 capa = ttv_getcapamin(ptlinex);
9278 slew = ttv_getslopemin(ptlinex);
9279 }
9280 }else
9281 capa = STM_DONTCARE;
9282 for(ptlinex = node->FIND->OUTLINE ; ptlinex != NULL && ptlinex->ROOT != goal ;
9283 ptlinex = ptlinex->ROOT->FIND->OUTLINE)
9284 {
9285 if((ptlinex->TYPE & (TTV_LINE_D|TTV_LINE_T)) == 0)
9286 {
9287 if((type & TTV_FIND_MAX) == TTV_FIND_MAX){
9288 delay += ttv_getdelaymax(ptlinex) ;
9289 slew = ttv_getslopemax(ptlinex);
9290 }else{
9291 delay += ttv_getdelaymin(ptlinex) ;
9292 slew = ttv_getslopemin(ptlinex);
9293 }
9294 }
9295 }
9296
9297 if((ptlinex != NULL) && ((ptlinex->TYPE & (TTV_LINE_D|TTV_LINE_T)) == 0))
9298 {
9299 if((type & TTV_FIND_MAX) == TTV_FIND_MAX){
9300 delay += ttv_getdelaymax(ptlinex) ;
9301 slew = ttv_getslopemax(ptlinex);
9302 }else{
9303 delay += ttv_getdelaymin(ptlinex) ;
9304 slew = ttv_getslopemin(ptlinex);
9305 }
9306 }
9307
9308 if((((ptline->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((ptline->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N))
9309 &&(((ptline->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((ptline->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N))){
9310 stm_addaxisvalues(htslope_axis, htcapa_axis, ptline->NODE->ROOT->NETNAME, ptline->ROOT->ROOT->NETNAME);
9311 }else if(((ptline->NODE->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((ptline->NODE->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N)){
9312 stm_addaxisvalues(htslope_axis, htcapa_axis, ptline->NODE->ROOT->NETNAME, NULL);
9313 }else if(((ptline->ROOT->ROOT->TYPE & TTV_SIG_C) == TTV_SIG_C) || ((ptline->ROOT->ROOT->TYPE & TTV_SIG_N) == TTV_SIG_N)){
9314 stm_addaxisvalues(htslope_axis, htcapa_axis, NULL, ptline->ROOT->ROOT->NETNAME);
9315 }
9316
9317 if(((ptline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) && ((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP))
9318 ttype = STM_HH;
9319 else if(((ptline->NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) && ((ptline->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN))
9320 ttype = STM_HL;
9321 else if(((ptline->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) && ((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP))
9322 ttype = STM_LH;
9323 else if(((ptline->NODE->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN) && ((ptline->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN))
9324 ttype = STM_LL;
9325 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9326 {
9327 ptline->MDMAX = ttv_getstmmodelname(ttvfig,ptline,STM_DELAY,STM_MAX) ;
9328 ptline->MFMAX = ttv_getstmmodelname(ttvfig,ptline,STM_SLEW,STM_MAX) ;
9329 if(caracnode != caracgoal)
9330 stm_addmergedmodel(ttvfig->INFO->FIGNAME,ptline->MDMAX,ttvfig->INFO->FIGNAME,
9331 modelindelay,ttvfig->INFO->FIGNAME,modeloutdelay,
9332 (float)delay/TTV_UNIT,(float)capa,(float)slew/TTV_UNIT) ;
9333 else
9334 stm_addreducedmodel(ttvfig->INFO->FIGNAME,ptline->MDMAX,ttvfig->INFO->FIGNAME,
9335 modeloutdelay,(float)slew/TTV_UNIT,(float)capa,STM_COPY,STM_DELAY) ;
9336
9337 if(modeloutslope != NULL){
9338 if(caracnode != caracgoal)
9339 stm_addreducedmodel(ttvfig->INFO->FIGNAME,ptline->MFMAX,ttvfig->INFO->FIGNAME,
9340 modeloutslope,(float)slew/TTV_UNIT,(float)capa,STM_SLEWFIX_RED,STM_SLEW) ;
9341 else
9342 stm_addreducedmodel(ttvfig->INFO->FIGNAME,ptline->MFMAX,ttvfig->INFO->FIGNAME,
9343 modeloutslope,(float)slew/TTV_UNIT,(float)capa,STM_COPY,STM_SLEW) ;
9344 }else
9345 stm_addconstmodel(ttvfig->INFO->FIGNAME,ptline->MFMAX,ptend->FMAX/TTV_UNIT) ;
9346
9347 if (!stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MDMAX)) ptline->MDMAX = NULL;
9348 if (!stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MFMAX)) ptline->MFMAX = NULL;
9349
9350 if(ptline->MDMAX){
9351 tmodel = stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MDMAX);
9352 if((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
9353 stm_mod_update(tmodel, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VDD);
9354 else if((ptline->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN)
9355 stm_mod_update(tmodel, tmodel->VTH, tmodel->VDD, tmodel->VT, 0.0);
9356 vt = stm_mod_vt(tmodel);
9357 vth = stm_mod_vth(tmodel);
9358 vdd = stm_mod_vdd(tmodel);
9359 vend = stm_mod_vf(tmodel);
9360 stm_mod_update_transition(tmodel, ttype);
9361 }
9362 if(ptline->MFMAX){
9363 tmodel = stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MFMAX);
9364 stm_mod_update(tmodel, vth, vdd, vt, vend);
9365 stm_mod_update_transition(tmodel, ttype);
9366 }
9367 }
9368 else
9369 {
9370 ptline->MDMIN = ttv_getstmmodelname(ttvfig,ptline,STM_DELAY,STM_MIN) ;
9371 ptline->MFMIN = ttv_getstmmodelname(ttvfig,ptline,STM_SLEW,STM_MIN) ;
9372 if(caracnode != caracgoal)
9373 stm_addmergedmodel(ttvfig->INFO->FIGNAME,ptline->MDMIN,ttvfig->INFO->FIGNAME,
9374 modelindelay,ttvfig->INFO->FIGNAME,modeloutdelay,
9375 (float)delay/TTV_UNIT,(float)capa,(float)slew/TTV_UNIT) ;
9376 else
9377 stm_addreducedmodel(ttvfig->INFO->FIGNAME,ptline->MDMIN,ttvfig->INFO->FIGNAME,
9378 modeloutdelay,(float)slew/TTV_UNIT,(float)capa,STM_COPY,STM_DELAY) ;
9379
9380 if(modeloutslope != NULL){
9381 if(caracnode != caracgoal)
9382 stm_addreducedmodel(ttvfig->INFO->FIGNAME,ptline->MFMIN,ttvfig->INFO->FIGNAME,
9383 modeloutslope,(float)slew/TTV_UNIT,(float)capa,STM_SLEWFIX_RED,STM_SLEW) ;
9384 else
9385 stm_addreducedmodel(ttvfig->INFO->FIGNAME,ptline->MFMIN,ttvfig->INFO->FIGNAME,
9386 modeloutslope,(float)slew/TTV_UNIT,(float)capa,STM_COPY,STM_SLEW) ;
9387 }else
9388 stm_addconstmodel(ttvfig->INFO->FIGNAME,ptline->MFMIN,ptend->FMIN/TTV_UNIT) ;
9389
9390 if (!stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MDMIN)) ptline->MDMIN = NULL;
9391 if (!stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MFMIN)) ptline->MFMIN = NULL;
9392
9393 if(ptline->MDMIN){
9394 tmodel = stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MDMIN);
9395 if((ptline->ROOT->TYPE & TTV_NODE_UP) == TTV_NODE_UP)
9396 stm_mod_update(tmodel, tmodel->VTH, tmodel->VDD, tmodel->VT, tmodel->VDD);
9397 else if((ptline->ROOT->TYPE & TTV_NODE_DOWN) == TTV_NODE_DOWN)
9398 stm_mod_update(tmodel, tmodel->VTH, tmodel->VDD, tmodel->VT, 0.0);
9399 vt = stm_mod_vt(tmodel);
9400 vth = stm_mod_vth(tmodel);
9401 vdd = stm_mod_vdd(tmodel);
9402 vend = stm_mod_vf(tmodel);
9403 stm_mod_update_transition(tmodel, ttype);
9404 }
9405 if(ptline->MFMIN){
9406 tmodel = stm_getmodel(ttvfig->INFO->FIGNAME, ptline->MFMIN);
9407 stm_mod_update(tmodel, vth, vdd, vt, vend);
9408 stm_mod_update_transition(tmodel, ttype);
9409 }
9410 }
9411 stm_delaxisvalues();
9412 }
9413
9414 /*****************************************************************************/
9415 /* function ttv_addpath() */
9416 /* parametres : */
9417 /* ttvfig : ttvfig courante */
9418 /* inchain : liste des entrees */
9419 /* goal : noeud sortie */
9420 /* type : type de recherche */
9421 /* */
9422 /* construit les chemins a partir du parcours en largeur du graphe */
9423 /*****************************************************************************/
9424 void ttv_addpath(ttvfig,inchain,goal,cmd,type)
9425 ttvfig_list *ttvfig ;
9426 chain_list *inchain ;
9427 ttvevent_list *goal ;
9428 ttvevent_list *cmd ;
9429 long type ;
9430 {
9431 ttvevent_list *nodex ;
9432 ttvevent_list *avnodex ;
9433 ttvevent_list *node ;
9434 ttvevent_list *goalx ;
9435 ttvline_list *line ;
9436 chain_list *chainout ;
9437 chain_list *chainend ;
9438 chain_list *chainsav ;
9439 chain_list *chain ;
9440 ptype_list *ptype ;
9441 long delay ;
9442 long typeline ;
9443 char flag ;
9444 char first ;
9445
9446 if((inchain == NULL) ||
9447 ((goal->ROOT->TYPE & TTV_SIG_BYPASSOUT) == TTV_SIG_BYPASSOUT) ||
9448 ((goal->TYPE & TTV_NODE_BYPASSOUT) == TTV_NODE_BYPASSOUT))
9449 {
9450 for(chain = inchain ; chain != NULL ; chain = chain->NEXT)
9451 ((ttvevent_list *)chain->DATA)->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
9452 ttv_fifoclean() ;
9453 return ;
9454 }
9455
9456 chainout = inchain ;
9457 chainend = inchain ;
9458 chain = inchain->NEXT ;
9459 inchain->NEXT = NULL ;
9460
9461 while(chain != NULL)
9462 {
9463 chainsav = chain->NEXT ;
9464 if((((ttvevent_list *)chain->DATA)->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0)
9465 {
9466 chain->NEXT = chainout ;
9467 chainout = chain ;
9468 }
9469 else
9470 {
9471 chain->NEXT = NULL ;
9472 chainend->NEXT = chain ;
9473 chainend = chain ;
9474 }
9475 chain = chainsav ;
9476 }
9477
9478 inchain = chainout ;
9479 chainout = NULL ;
9480 chainend = NULL ;
9481
9482 for(chain = inchain ; chain != NULL ; chain = chain->NEXT)
9483 {
9484 node = (ttvevent_list *)chain->DATA ;
9485 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
9486 if(((node->ROOT->TYPE & TTV_SIG_BYPASSIN) == TTV_SIG_BYPASSIN) ||
9487 ((node->TYPE & TTV_NODE_BYPASSIN) == TTV_NODE_BYPASSIN))
9488 continue ;
9489 flag = 'N' ;
9490 if(node == goal)
9491 first = 'Y' ;
9492 else
9493 first = 'N' ;
9494 goalx = node ;
9495
9496 if(((goal->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) != 0)
9497 && ((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0))
9498 {
9499 node->TYPE |= TTV_NODE_MARQUE ;
9500 }
9501 else if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) != 0)
9502 && ((goal->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0))
9503 {
9504 goal->TYPE |= TTV_NODE_MARQUE ;
9505 }
9506
9507 if((goal->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) == TTV_SIG_Q)
9508 {
9509 goal->TYPE |= TTV_NODE_MARQUE ;
9510 }
9511
9512 if((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) == TTV_SIG_Q)
9513 {
9514 node->TYPE |= TTV_NODE_MARQUE ;
9515 }
9516
9517 for(nodex = node ; nodex->FIND->OUTLINE != NULL &&
9518 ((nodex != goal) || (first == 'Y')) ;
9519 nodex = nodex->FIND->OUTLINE->ROOT)
9520 {
9521 first = 'N' ;
9522 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
9523 {
9524 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9525 nodex->FIND->OUTLINE->TYPE |= TTV_LINE_DEPTMAX ;
9526 else
9527 nodex->FIND->OUTLINE->TYPE |= TTV_LINE_DEPTMIN ;
9528 }
9529
9530 if(((((nodex->ROOT->TYPE & TTV_SIG_I) == TTV_SIG_I) &&
9531 ((((nodex->TYPE & TTV_NODE_IMAX) == TTV_NODE_IMAX) &&
9532 ((type & TTV_FIND_MAX) == TTV_FIND_MAX)) ||
9533 (((nodex->TYPE & TTV_NODE_IMIN) == TTV_NODE_IMIN) &&
9534 ((type & TTV_FIND_MIN) == TTV_FIND_MIN))))) && (nodex != node))
9535 {
9536 if(flag == 'Y')
9537 {
9538 flag = 'N' ;
9539 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) != 0) ||
9540 ((goal->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) != 0))
9541 {
9542 if((nodex->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)
9543 {
9544 nodex->TYPE |= TTV_NODE_MARQUE ;
9545 chainend = addchain(chainend,nodex) ;
9546 }
9547 if((goalx->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)
9548 {
9549 goalx->TYPE |= TTV_NODE_MARQUE ;
9550 chainend = addchain(chainend,goalx) ;
9551 }
9552 }
9553 if((goalx->FIND->TYPE & TTV_FIND_BEGIN) != TTV_FIND_BEGIN)
9554 {
9555 goalx->FIND->TYPE |= TTV_FIND_BEGIN ;
9556 if((nodex->TYPE & TTV_NODE_END) != TTV_NODE_END)
9557 {
9558 chainout = addchain(chainout,(void*)nodex) ;
9559 nodex->TYPE |= TTV_NODE_END ;
9560 }
9561 goalx->USER = addptype(goalx->USER,TTV_NODE_AVNODE,(void *)avnodex) ;
9562 goalx->USER = addptype(goalx->USER,TTV_NODE_IN,(void*)nodex) ;
9563 if((ptype = getptype(nodex->USER,TTV_NODE_INCHAIN)) == NULL)
9564 nodex->USER = addptype(nodex->USER,TTV_NODE_INCHAIN,
9565 (void*)addchain(NULL,(void*)goalx)) ;
9566 else
9567 ptype->DATA = (chain_list *)addchain((chain_list *)ptype->DATA,
9568 (void*)goalx) ;
9569 }
9570 }
9571 goalx = nodex ;
9572 }
9573 if(nodex->FIND->OUTLINE->FIG == ttvfig)
9574 {
9575 flag = 'Y' ;
9576 }
9577 avnodex = nodex ;
9578 }
9579
9580 if(nodex == goal)
9581 {
9582 if(flag == 'Y')
9583 {
9584 if((goalx->FIND->TYPE & TTV_FIND_BEGIN) != TTV_FIND_BEGIN)
9585 {
9586 goalx->FIND->TYPE |= TTV_FIND_BEGIN ;
9587 if((goalx != node) &&
9588 ((((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) != 0) ||
9589 ((goal->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N|TTV_SIG_Q)) != 0)) &&
9590 ((goalx->TYPE & TTV_NODE_MARQUE) != TTV_NODE_MARQUE)))
9591 {
9592 goalx->TYPE |= TTV_NODE_MARQUE ;
9593 chainend = addchain(chainend,goalx) ;
9594 }
9595 if((nodex->TYPE & TTV_NODE_END) != TTV_NODE_END)
9596 {
9597 chainout = addchain(chainout,(void*)nodex) ;
9598 nodex->TYPE |= TTV_NODE_END ;
9599 }
9600 goalx->USER = addptype(goalx->USER,TTV_NODE_IN,(void*)nodex) ;
9601 goalx->USER = addptype(goalx->USER,TTV_NODE_AVNODE,(void *)avnodex) ;
9602 if((ptype = getptype(nodex->USER,TTV_NODE_INCHAIN)) == NULL)
9603 nodex->USER = addptype(nodex->USER,TTV_NODE_INCHAIN,
9604 (void*)addchain(NULL,(void*)goalx)) ;
9605 else
9606 ptype->DATA = (chain_list *)addchain((chain_list *)ptype->DATA,
9607 (void*)goalx) ;
9608 }
9609 }
9610 }
9611 }
9612
9613 inchain = append(chainend,inchain) ;
9614
9615 for(chainend = chainout ; chainend != NULL ; chainend = chainend->NEXT)
9616 {
9617 goalx = (ttvevent_list *)chainend->DATA ;
9618 goalx->TYPE &= ~(TTV_NODE_END) ;
9619 if(((type & TTV_FIND_HZ) == TTV_FIND_HZ) &&
9620 (((goalx->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R) ||
9621 ((goalx->ROOT->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ) ||
9622 ((goalx->ROOT->TYPE & TTV_SIG_CT) == TTV_SIG_CT)))
9623 typeline = TTV_LINE_HZ ;
9624 else if(((goalx->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
9625 ((goalx->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
9626 {
9627 if((type & TTV_FIND_R) == TTV_FIND_R)
9628 typeline = TTV_LINE_R ;
9629 else
9630 typeline = TTV_LINE_S ;
9631 }
9632 else typeline = (long)0 ;
9633 chainsav = NULL ;
9634 for(line = goalx->INPATH ; line != NULL ; line = line->NEXT)
9635 {
9636 if(((line->TYPE & TTV_LINE_CONT) == TTV_LINE_CONT) ||
9637 (line->NODE->FIND == NULL))
9638 continue ;
9639 if((((node = line->NODE)->FIND->TYPE & TTV_FIND_BEGIN) == TTV_FIND_BEGIN) &&
9640 (line->FIG == ttvfig))
9641 if((ptype = getptype(node->USER,TTV_NODE_IN)) != NULL)
9642 if((ttvevent_list *)ptype->DATA == goalx)
9643 {
9644 if((((goalx->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE) &&
9645 ((line->NODE->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE) &&
9646 (line->NODE != goalx)) &&
9647 ((line->TYPE & TTV_LINE_P) == TTV_LINE_P))
9648 {
9649 chainsav = addchain(chainsav,line) ;
9650 }
9651
9652 if((typeline & TTV_LINE_HZ) != (line->TYPE & TTV_LINE_HZ))
9653 continue ;
9654
9655 if((typeline & TTV_LINE_R) != (line->TYPE & TTV_LINE_R))
9656 continue ;
9657
9658 if((typeline & TTV_LINE_S) != (line->TYPE & TTV_LINE_S))
9659 continue ;
9660
9661 if((cmd != NULL) && ((goalx->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L))
9662 if(cmd != ttv_getlinecmd(ttvfig,line,((type & TTV_FIND_MAX) == TTV_FIND_MAX)?TTV_LINE_CMDMAX:TTV_LINE_CMDMIN))
9663 continue ;
9664
9665 avnodex = (ttvevent_list *)getptype(node->USER,TTV_NODE_AVNODE)->DATA ;
9666 node->USER = delptype(node->USER,TTV_NODE_AVNODE) ;
9667
9668 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
9669 node->USER = delptype(node->USER,TTV_NODE_IN) ;
9670
9671 if(line->ROOT == goal)
9672 delay = line->NODE->FIND->DELAY ;
9673 else
9674 delay = line->NODE->FIND->DELAY - line->ROOT->FIND->DELAY ;
9675 line->TYPE |= TTV_LINE_INFIG ;
9676
9677 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9678 {
9679 if((line->VALMAX != TTV_NOTIME) && (ttv_getdelaymax(line) >= delay))
9680 continue ;
9681 if((((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) ||
9682 ((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0)) &&
9683 ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9684 {
9685 ttvline_list *caracin ;
9686 ttvline_list *caracout ;
9687
9688 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9689 ((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9690 {
9691 caracin = node->FIND->OUTLINE ;
9692 }
9693 else
9694 {
9695 caracin = NULL ;
9696 }
9697 if(((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9698 ((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9699 {
9700 caracout = avnodex->FIND->OUTLINE ;
9701 }
9702 else
9703 {
9704 caracout = NULL ;
9705 }
9706 if((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC)
9707 ttv_allocnewmodel(ttvfig,node,goalx,line,avnodex->FIND->OUTLINE,
9708 caracin,caracout,TTV_FIND_MAX) ;
9709 }
9710
9711 line->VALMAX = delay ;
9712 line->FMAX = ttv_getslopemax(avnodex->FIND->OUTLINE) ;
9713 }
9714 else
9715 {
9716 if((line->VALMIN != TTV_NOTIME) && (ttv_getdelaymin(line) <= delay))
9717 continue ;
9718 if((((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) ||
9719 ((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0)) &&
9720 ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9721 {
9722 ttvline_list *caracin ;
9723 ttvline_list *caracout ;
9724
9725 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9726 ((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9727 {
9728 caracin = node->FIND->OUTLINE ;
9729 }
9730 else
9731 {
9732 caracin = NULL ;
9733 }
9734 if(((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9735 ((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9736 {
9737 caracout = avnodex->FIND->OUTLINE ;
9738 }
9739 else
9740 {
9741 caracout = NULL ;
9742 }
9743 if((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC)
9744 ttv_allocnewmodel(ttvfig,node,goalx,line,avnodex->FIND->OUTLINE,
9745 caracin,caracout,TTV_FIND_MIN) ;
9746 }
9747
9748 line->VALMIN = delay ;
9749 line->FMIN = ttv_getslopemin(avnodex->FIND->OUTLINE) ;
9750 }
9751
9752 if((line->ROOT->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
9753 {
9754 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_EV) == TTV_LINE_EV)
9755 line->TYPE |= TTV_LINE_EV ;
9756 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_PR) == TTV_LINE_PR)
9757 line->TYPE |= TTV_LINE_PR ;
9758 }
9759
9760 if(((line->ROOT->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
9761 ((line->ROOT->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
9762 {
9763 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_S) == TTV_LINE_S)
9764 line->TYPE |= TTV_LINE_S ;
9765 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_R) == TTV_LINE_R)
9766 line->TYPE |= TTV_LINE_R ;
9767 }
9768
9769 if((goalx->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L)
9770 {
9771 ptype_list *ptypecmd ;
9772
9773 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9774 {
9775 ptypecmd = ttv_addcmd(line,TTV_LINE_CMDMAX,
9776 ttv_getlinecmd(ttvfig,avnodex->FIND->OUTLINE,TTV_LINE_CMDMAX)) ;
9777 }
9778 else
9779 {
9780 ptypecmd = ttv_addcmd(line,TTV_LINE_CMDMIN,
9781 ttv_getlinecmd(ttvfig,avnodex->FIND->OUTLINE,TTV_LINE_CMDMIN)) ;
9782 }
9783 }
9784 }
9785 }
9786
9787 for(chain = chainsav ; chain != NULL ; chain = chain->NEXT)
9788 {
9789 line = (ttvline_list *)chain->DATA ;
9790 line = ttv_addline(ttvfig,line->ROOT,line->NODE,line->VALMAX,line->FMAX,
9791 line->VALMIN,line->FMIN,TTV_LINE_J|TTV_LINE_INFIG) ;
9792 line->TYPE |= (((ttvline_list *)chain->DATA)->TYPE
9793 & (TTV_LINE_HZ|TTV_LINE_EV|TTV_LINE_PR|TTV_LINE_RC|
9794 TTV_LINE_R|TTV_LINE_S)) ;
9795 if((ptype = getptype(((ttvline_list *)chain->DATA)->USER,
9796 TTV_LINE_CMDMAX))!= NULL)
9797 ttv_addcmd(line,TTV_LINE_CMDMAX,(ttvevent_list *)ptype->DATA) ;
9798 if((ptype = getptype(((ttvline_list *)chain->DATA)->USER,
9799 TTV_LINE_CMDMIN))!= NULL)
9800 ttv_addcmd(line,TTV_LINE_CMDMIN,(ttvevent_list *)ptype->DATA) ;
9801 ttv_delline((ttvline_list *)chain->DATA) ;
9802 }
9803
9804 freechain(chainsav) ;
9805
9806 ptype = getptype(goalx->USER,TTV_NODE_INCHAIN) ;
9807 for(chain = (chain_list *)ptype->DATA ;
9808 chain != NULL ; chain = chain->NEXT)
9809 {
9810 node = (ttvevent_list *)chain->DATA ;
9811
9812 if((node->FIND->TYPE & TTV_FIND_BEGIN) != TTV_FIND_BEGIN)
9813 {
9814 continue ;
9815 }
9816
9817 avnodex = (ttvevent_list *)getptype(node->USER,TTV_NODE_AVNODE)->DATA ;
9818 node->USER = delptype(node->USER,TTV_NODE_AVNODE) ;
9819
9820 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9821 {
9822 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) ||
9823 ((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0))
9824 {
9825 ttvline_list *caracin ;
9826 ttvline_list *caracout ;
9827
9828 if(goalx == goal)
9829 delay = node->FIND->DELAY ;
9830 else
9831 delay = node->FIND->DELAY - goalx->FIND->DELAY ;
9832 line = ttv_addline(ttvfig,goalx,node,delay,
9833 ttv_getslopemax(avnodex->FIND->OUTLINE),TTV_NOTIME,TTV_NOSLOPE,
9834 typeline|TTV_LINE_T|TTV_LINE_INFIG) ;
9835
9836 if(((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
9837 (node->FIND->OUTLINE->ROOT == goalx))
9838 line->TYPE |= TTV_LINE_RC ;
9839
9840 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9841 ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC) &&
9842 ((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9843 {
9844 caracin = node->FIND->OUTLINE ;
9845 }
9846 else
9847 caracin = NULL ;
9848 if(((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9849 ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC) &&
9850 ((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9851 {
9852 caracout = avnodex->FIND->OUTLINE ;
9853 }
9854 else
9855 caracout = NULL ;
9856 if((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC)
9857 ttv_allocnewmodel(ttvfig,node,goalx,line,avnodex->FIND->OUTLINE,caracin,
9858 caracout,TTV_FIND_MAX) ;
9859 }
9860 else
9861 {
9862 if(((goalx->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE) &&
9863 ((node->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE) &&
9864 (goalx != node))
9865 {
9866 if(goalx == goal)
9867 delay = node->FIND->DELAY ;
9868 else
9869 delay = node->FIND->DELAY - goalx->FIND->DELAY ;
9870 line = ttv_addline(ttvfig,goalx,node,delay,
9871 ttv_getslopemax(avnodex->FIND->OUTLINE),TTV_NOTIME,TTV_NOSLOPE,
9872 typeline|TTV_LINE_J|TTV_LINE_INFIG) ;
9873 }
9874 else
9875 {
9876 if(goalx == goal)
9877 delay = node->FIND->DELAY ;
9878 else
9879 delay = node->FIND->DELAY - goalx->FIND->DELAY ;
9880 line = ttv_addline(ttvfig,goalx,node,delay,
9881 ttv_getslopemax(avnodex->FIND->OUTLINE),TTV_NOTIME,TTV_NOSLOPE,
9882 typeline|TTV_LINE_P|TTV_LINE_INFIG) ;
9883 }
9884
9885 if(((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
9886 (node->FIND->OUTLINE->ROOT == goalx))
9887 line->TYPE |= TTV_LINE_RC ;
9888 }
9889 }
9890 else
9891 {
9892 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) ||
9893 ((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0))
9894 {
9895 ttvline_list *caracin ;
9896 ttvline_list *caracout ;
9897
9898 if(goalx == goal)
9899 delay = node->FIND->DELAY ;
9900 else
9901 delay = node->FIND->DELAY - goalx->FIND->DELAY ;
9902 line = ttv_addline(ttvfig,goalx,node,TTV_NOTIME,TTV_NOSLOPE,
9903 delay,ttv_getslopemin(avnodex->FIND->OUTLINE),
9904 typeline|TTV_LINE_T|TTV_LINE_INFIG) ;
9905
9906 if(((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
9907 (node->FIND->OUTLINE->ROOT == goalx))
9908 line->TYPE |= TTV_LINE_RC ;
9909
9910 if(((node->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9911 ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC) &&
9912 ((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9913 {
9914 caracin = node->FIND->OUTLINE ;
9915 }
9916 else
9917 caracin = NULL ;
9918 if(((goalx->ROOT->TYPE & (TTV_SIG_C|TTV_SIG_N)) != 0) &&
9919 ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC) &&
9920 ((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_RC) != TTV_LINE_RC))
9921 {
9922 caracout = avnodex->FIND->OUTLINE ;
9923 }
9924 else
9925 caracout = NULL ;
9926 if((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC)
9927 ttv_allocnewmodel(ttvfig,node,goalx,line,avnodex->FIND->OUTLINE,caracin,
9928 caracout,TTV_FIND_MIN) ;
9929 }
9930 else
9931 {
9932 if(((goalx->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE) &&
9933 ((node->TYPE & TTV_NODE_MARQUE) == TTV_NODE_MARQUE) &&
9934 (goalx != node))
9935 {
9936 if(goalx == goal)
9937 delay = node->FIND->DELAY ;
9938 else
9939 delay = node->FIND->DELAY - goalx->FIND->DELAY ;
9940 line = ttv_addline(ttvfig,goalx,node,TTV_NOTIME,TTV_NOSLOPE,
9941 delay,ttv_getslopemin(avnodex->FIND->OUTLINE),
9942 typeline|TTV_LINE_J|TTV_LINE_INFIG) ;
9943 }
9944 else
9945 {
9946 if(goalx == goal)
9947 delay = node->FIND->DELAY ;
9948 else
9949 delay = node->FIND->DELAY - goalx->FIND->DELAY ;
9950 line = ttv_addline(ttvfig,goalx,node,TTV_NOTIME,TTV_NOSLOPE,
9951 delay,ttv_getslopemin(avnodex->FIND->OUTLINE),
9952 typeline|TTV_LINE_P|TTV_LINE_INFIG) ;
9953 }
9954
9955 if(((node->FIND->OUTLINE->TYPE & TTV_LINE_RC) == TTV_LINE_RC) &&
9956 (node->FIND->OUTLINE->ROOT == goalx))
9957 line->TYPE |= TTV_LINE_RC ;
9958 }
9959 }
9960
9961 if((line->ROOT->ROOT->TYPE & TTV_SIG_R) == TTV_SIG_R)
9962 {
9963 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_EV) == TTV_LINE_EV)
9964 line->TYPE |= TTV_LINE_EV ;
9965 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_PR) == TTV_LINE_PR)
9966 line->TYPE |= TTV_LINE_PR ;
9967 }
9968
9969 if(((line->ROOT->ROOT->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
9970 ((line->ROOT->ROOT->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
9971 {
9972 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_S) == TTV_LINE_S)
9973 line->TYPE |= TTV_LINE_S ;
9974 if((avnodex->FIND->OUTLINE->TYPE & TTV_LINE_R) == TTV_LINE_R)
9975 line->TYPE |= TTV_LINE_R ;
9976 }
9977
9978 if((goalx->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L)
9979 {
9980 ptype_list *ptypecmd ;
9981
9982 if((type & TTV_FIND_MAX) == TTV_FIND_MAX)
9983 {
9984 ptypecmd = ttv_addcmd(line,TTV_LINE_CMDMAX,
9985 ttv_getlinecmd(ttvfig,avnodex->FIND->OUTLINE,TTV_LINE_CMDMAX)) ;
9986 }
9987 else
9988 {
9989 ptypecmd = ttv_addcmd(line,TTV_LINE_CMDMIN,
9990 ttv_getlinecmd(ttvfig,avnodex->FIND->OUTLINE,TTV_LINE_CMDMIN)) ;
9991 }
9992 }
9993
9994 node->FIND->TYPE &= ~(TTV_FIND_BEGIN) ;
9995 node->USER = delptype(node->USER,TTV_NODE_IN) ;
9996 }
9997 freechain((chain_list *)ptype->DATA) ;
9998 goalx->USER = delptype(goalx->USER,TTV_NODE_INCHAIN) ;
9999 }
10000 for(chain = inchain ; chain != NULL ; chain = chain->NEXT)
10001 {
10002 ((ttvevent_list *)chain->DATA)->TYPE &= ~(TTV_NODE_MARQUE) ;
10003 }
10004 goal->TYPE &= ~(TTV_NODE_MARQUE) ;
10005 ttv_fifoclean() ;
10006 freechain(chainout);
10007 freechain(inchain);
10008 }
10009
10010 /*****************************************************************************/
10011 /* function ttv_builtpath() */
10012 /* parametres : */
10013 /* ttvfig : ttvfig courante */
10014 /* type : type de recherche */
10015 /* */
10016 /* construit tout les chemins d'une ttvfig a partir des arcs elementaires */
10017 /*****************************************************************************/
10018 void ttv_builtpath(ttvfig,type)
10019 ttvfig_list *ttvfig ;
10020 long type ;
10021 {
10022 ttvsig_list *sig ;
10023 ttvlbloc_list *ptlbloc[3] ;
10024 ttvline_list *ptline ;
10025 ttvline_list *ptlinex ;
10026 chain_list *chainfree = NULL ;
10027 chain_list *chain ;
10028 chain_list *chainc ;
10029 long i ;
10030 long j ;
10031 long typers ;
10032
10033 if(ttvfig == NULL)
10034 return ;
10035
10036 if((ttvfig->STATUS & TTV_STS_DUAL) != (long)0)
10037 ttv_freedualline(ttvfig,TTV_STS_DUAL) ;
10038
10039 type &= ~(TTV_FIND_MAX | TTV_FIND_MIN | TTV_FIND_DUAL | TTV_FIND_HZ) ;
10040
10041 if((((ttvfig->STATUS & TTV_STS_DTX) != TTV_STS_DTX) &&
10042 ((type & TTV_FIND_LINE) == TTV_FIND_LINE)) ||
10043 (((ttvfig->STATUS & TTV_STS_TTX) != TTV_STS_TTX) &&
10044 ((type & TTV_FIND_PATH) == TTV_FIND_PATH)))
10045
10046 {
10047 ttv_error(31,ttvfig->INFO->FIGNAME,TTV_WARNING) ;
10048 return ;
10049 }
10050
10051 for(i = 0 ; i < ttvfig->NBCONSIG ; i++)
10052 {
10053 sig = *(ttvfig->CONSIG + i) ;
10054 if(((sig->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
10055 ((sig->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
10056 continue ;
10057 if((sig->TYPE & TTV_SIG_CO) == TTV_SIG_CO)
10058 {
10059 if((sig->TYPE & TTV_SIG_L) == TTV_SIG_L)
10060 chainc = ttv_getlrcmd(ttvfig,sig) ;
10061 else chainc = NULL ;
10062 if(chainc == NULL)
10063 chainc = addchain(chainc,NULL) ;
10064 for(chain = chainc ; chain != NULL ; chain = chain->NEXT)
10065 {
10066 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,(ttvevent_list *)chain->DATA,type|TTV_FIND_MAX,
10067 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MAX) ;
10068 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,(ttvevent_list *)chain->DATA,type|TTV_FIND_MAX,
10069 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MAX) ;
10070 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,(ttvevent_list *)chain->DATA,type|TTV_FIND_MIN,
10071 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MIN) ;
10072 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,(ttvevent_list *)chain->DATA,type|TTV_FIND_MIN,
10073 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MIN) ;
10074 }
10075 freechain(chainc) ;
10076 if(((sig->TYPE & TTV_SIG_CT) == TTV_SIG_CT) ||
10077 ((sig->TYPE & TTV_SIG_CZ) == TTV_SIG_CZ))
10078 {
10079 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MAX|TTV_FIND_HZ,
10080 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MAX|TTV_FIND_HZ) ;
10081 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MAX|TTV_FIND_HZ,
10082 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MAX|TTV_FIND_HZ) ;
10083 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MIN|TTV_FIND_HZ,
10084 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MIN|TTV_FIND_HZ) ;
10085 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MIN|TTV_FIND_HZ,
10086 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MIN|TTV_FIND_HZ) ;
10087 }
10088 }
10089 }
10090
10091 if((type & TTV_FIND_HIER) == TTV_FIND_HIER)
10092 for(i = 0 ; i < ttvfig->NBNCSIG ; i++)
10093 {
10094 sig = *(ttvfig->NCSIG + i) ;
10095 if(((sig->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
10096 ((sig->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
10097 continue ;
10098 if((sig->TYPE & TTV_SIG_L) == TTV_SIG_L)
10099 chainc = ttv_getlrcmd(ttvfig,sig) ;
10100 else chainc = NULL ;
10101 if(chainc == NULL)
10102 chainc = addchain(chainc,NULL) ;
10103 for(chain = chainc ; chain != NULL ; chain = chain->NEXT)
10104 {
10105 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,(ttvevent_list *)chain->DATA,type|TTV_FIND_MAX,
10106 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MAX) ;
10107 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,(ttvevent_list *)chain->DATA,type|TTV_FIND_MAX,
10108 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MAX) ;
10109 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,(ttvevent_list *)chain->DATA,type|TTV_FIND_MIN,
10110 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MIN) ;
10111 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,(ttvevent_list *)chain->DATA,type|TTV_FIND_MIN,
10112 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MIN) ;
10113 }
10114 freechain(chainc) ;
10115 }
10116
10117 for(i = 0 ; i < ttvfig->NBELCMDSIG + ttvfig->NBILCMDSIG ; i++)
10118 {
10119 sig = (i < ttvfig->NBELCMDSIG) ? *(ttvfig->ELCMDSIG + i)
10120 : *(ttvfig->ILCMDSIG + i - ttvfig->NBELCMDSIG) ;
10121 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
10122 {
10123 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MAX,
10124 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MAX) ;
10125 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MAX,
10126 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MAX) ;
10127 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MIN,
10128 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MIN) ;
10129 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MIN,
10130 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MIN) ;
10131 }
10132 }
10133
10134 for(i = 0 ; i < ttvfig->NBELATCHSIG + ttvfig->NBILATCHSIG ; i++)
10135 {
10136 sig = (i < ttvfig->NBELATCHSIG) ? *(ttvfig->ELATCHSIG + i)
10137 : *(ttvfig->ILATCHSIG + i - ttvfig->NBELATCHSIG) ;
10138 chainc = ttv_getlrcmd(ttvfig,sig) ;
10139 if(chainc == NULL)
10140 chainc = addchain(chainc,NULL) ;
10141 for(chain = chainc ; chain != NULL ; chain = chain->NEXT)
10142 {
10143 if(((sig->TYPE & TTV_SIG_LR) == TTV_SIG_LR) ||
10144 ((sig->TYPE & TTV_SIG_LS) == TTV_SIG_LS))
10145 {
10146 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,
10147 (ttvevent_list *)chain->DATA,type|TTV_FIND_MAX|TTV_FIND_R,
10148 ttvfig->INFO->LEVEL),sig->NODE,(ttvevent_list *)chain->DATA,
10149 type|TTV_FIND_MAX|TTV_FIND_R) ;
10150 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,
10151 (ttvevent_list *)chain->DATA,type|TTV_FIND_MAX|TTV_FIND_R,
10152 ttvfig->INFO->LEVEL),sig->NODE+1,(ttvevent_list *)chain->DATA,
10153 type|TTV_FIND_MAX|TTV_FIND_R) ;
10154 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,
10155 (ttvevent_list *)chain->DATA,type|TTV_FIND_MIN|TTV_FIND_R,
10156 ttvfig->INFO->LEVEL),sig->NODE,(ttvevent_list *)chain->DATA,
10157 type|TTV_FIND_MIN|TTV_FIND_R) ;
10158 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,
10159 (ttvevent_list *)chain->DATA,type|TTV_FIND_MIN|TTV_FIND_R,
10160 ttvfig->INFO->LEVEL),sig->NODE+1,(ttvevent_list *)chain->DATA,
10161 type|TTV_FIND_MIN|TTV_FIND_R) ;
10162 typers = TTV_FIND_S ;
10163 }
10164 else
10165 typers = (long)0 ; ;
10166 if(((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0) || (typers == TTV_FIND_S))
10167 {
10168 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,(ttvevent_list *)chain->DATA,type|TTV_FIND_MAX|typers,
10169 ttvfig->INFO->LEVEL),sig->NODE,
10170 (ttvevent_list *)chain->DATA,
10171 type|TTV_FIND_MAX|typers) ;
10172 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,(ttvevent_list *)chain->DATA,type|TTV_FIND_MAX|typers,
10173 ttvfig->INFO->LEVEL),sig->NODE+1,
10174 (ttvevent_list *)chain->DATA,
10175 type|TTV_FIND_MAX|typers) ;
10176 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,(ttvevent_list *)chain->DATA,type|TTV_FIND_MIN|typers,
10177 ttvfig->INFO->LEVEL),sig->NODE,
10178 (ttvevent_list *)chain->DATA,
10179 type|TTV_FIND_MIN|typers) ;
10180 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,(ttvevent_list *)chain->DATA,type|TTV_FIND_MIN|typers,
10181 ttvfig->INFO->LEVEL),sig->NODE+1,
10182 (ttvevent_list *)chain->DATA,
10183 type|TTV_FIND_MIN|typers) ;
10184 }
10185 }
10186 freechain(chainc) ;
10187 }
10188
10189 for(i = 0 ; i < ttvfig->NBEPRESIG + ttvfig->NBIPRESIG ; i++)
10190 {
10191 sig = (i < ttvfig->NBEPRESIG) ? *(ttvfig->EPRESIG + i)
10192 : *(ttvfig->IPRESIG + i - ttvfig->NBEPRESIG) ;
10193 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
10194 {
10195 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MAX,
10196 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MAX) ;
10197 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MAX,
10198 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MAX) ;
10199 }
10200 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,
10201 NULL,type|TTV_FIND_MAX|TTV_FIND_HZ,ttvfig->INFO->LEVEL),sig->NODE,
10202 NULL,type|TTV_FIND_MAX|TTV_FIND_HZ) ;
10203 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,
10204 NULL,type|TTV_FIND_MAX|TTV_FIND_HZ,ttvfig->INFO->LEVEL),sig->NODE+1,
10205 NULL,type|TTV_FIND_MAX|TTV_FIND_HZ) ;
10206 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
10207 {
10208 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MIN,
10209 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MIN) ;
10210 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MIN,
10211 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MIN) ;
10212 }
10213 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,
10214 type|TTV_FIND_MIN|TTV_FIND_HZ,ttvfig->INFO->LEVEL),sig->NODE,
10215 NULL,type|TTV_FIND_MIN|TTV_FIND_HZ) ;
10216 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,
10217 type|TTV_FIND_MIN|TTV_FIND_HZ,ttvfig->INFO->LEVEL),sig->NODE+1,
10218 NULL,type|TTV_FIND_MIN|TTV_FIND_HZ) ;
10219 }
10220
10221 for(i = 0 ; i < ttvfig->NBEBREAKSIG + ttvfig->NBIBREAKSIG ; i++)
10222 {
10223 sig = (i < ttvfig->NBEBREAKSIG) ? *(ttvfig->EBREAKSIG + i)
10224 : *(ttvfig->IBREAKSIG + i - ttvfig->NBEBREAKSIG) ;
10225 if((sig->TYPE & (TTV_SIG_C|TTV_SIG_N)) == 0)
10226 {
10227 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MAX,
10228 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MAX) ;
10229 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MAX,
10230 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MAX) ;
10231 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE,NULL,type|TTV_FIND_MIN,
10232 ttvfig->INFO->LEVEL),sig->NODE,NULL,type|TTV_FIND_MIN) ;
10233 ttv_addpath(ttvfig,ttv_findpath(ttvfig,ttvfig,sig->NODE+1,NULL,type|TTV_FIND_MIN,
10234 ttvfig->INFO->LEVEL),sig->NODE+1,NULL,type|TTV_FIND_MIN) ;
10235 }
10236 }
10237
10238
10239 ttvfig->STATUS |= TTV_STS_TTX ;
10240
10241 ttv_fifodelete() ;
10242
10243 ptlbloc[0] = ttvfig->FBLOC ;
10244 ptlbloc[1] = ttvfig->EBLOC ;
10245 ptlbloc[2] = ttvfig->DBLOC ;
10246 for(i = 0 ; i < 3 ; i++)
10247 for( ; ptlbloc[i] != NULL ; ptlbloc[i] = ptlbloc[i]->NEXT)
10248 {
10249 for(j = 0 ; j < TTV_MAX_LBLOC ; j++)
10250 {
10251 ptline = ptlbloc[i]->LINE + j ;
10252 if((ptline->TYPE & TTV_LINE_FR) == TTV_LINE_FR)
10253 continue ;
10254
10255 if((type & TTV_FIND_LINE) == TTV_FIND_LINE)
10256 {
10257 if((ptline->TYPE & TTV_LINE_DEPTMAX) == TTV_LINE_DEPTMAX)
10258 ptline->TYPE &= ~(TTV_LINE_DEPTMAX) ;
10259 else
10260 ptline->TYPE |= TTV_LINE_DENPTMAX ;
10261 if((ptline->TYPE & TTV_LINE_DEPTMIN) == TTV_LINE_DEPTMIN)
10262 ptline->TYPE &= ~(TTV_LINE_DEPTMIN) ;
10263 else
10264 ptline->TYPE |= TTV_LINE_DENPTMIN ;
10265
10266 if((ptline->TYPE & TTV_LINE_CONT) == TTV_LINE_CONT)
10267 {
10268 if((ptline->TYPE & TTV_LINE_D) == TTV_LINE_D)
10269 {
10270 ptlinex = ttv_addline(ttvfig,ptline->ROOT,ptline->NODE,
10271 ttv_getdelaymax(ptline),ttv_getslopemax(ptline),
10272 ttv_getdelaymin(ptline),ttv_getslopemin(ptline),
10273 TTV_LINE_T|TTV_LINE_CONT|
10274 (ptline->TYPE & (TTV_LINE_A|TTV_LINE_U|TTV_LINE_O))) ;
10275 ttv_addcaracline(ptlinex,ptline->MDMAX,ptline->MDMIN,
10276 ptline->MFMAX,ptline->MFMIN) ;
10277 }
10278 else
10279 {
10280 ptlinex = ttv_addline(ttvfig,ptline->ROOT,ptline->NODE,
10281 ttv_getdelaymax(ptline),ttv_getslopemax(ptline),
10282 ttv_getdelaymin(ptline),ttv_getslopemin(ptline),
10283 TTV_LINE_J|TTV_LINE_CONT|
10284 (ptline->TYPE & (TTV_LINE_A|TTV_LINE_U|TTV_LINE_O))) ;
10285 }
10286 if((ptline->ROOT->ROOT->TYPE & TTV_SIG_L) == TTV_SIG_L)
10287 {
10288 ttv_addcmd(ptlinex,TTV_LINE_CMDMAX,
10289 ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMAX)) ;
10290 ttv_addcmd(ptlinex,TTV_LINE_CMDMIN,
10291 ttv_getlinecmd(ttvfig,ptline,TTV_LINE_CMDMIN)) ;
10292 }
10293 }
10294 }
10295 }
10296 }
10297
10298 if((type & TTV_FIND_PATH) == TTV_FIND_PATH)
10299 {
10300 ptlbloc[2] = ttvfig->TBLOC ;
10301 ptlbloc[1] = ttvfig->PBLOC ;
10302 ptlbloc[0] = ttvfig->JBLOC ;
10303 for(i = 0 ; i < 3 ; i++)
10304 for(; ptlbloc[i] != NULL ; ptlbloc[i] = ptlbloc[i]->NEXT)
10305 {
10306 for(j = 0 ; j < TTV_MAX_LBLOC ; j++)
10307 {
10308 ptline = ptlbloc[i]->LINE + j ;
10309 if((ptline->TYPE & TTV_LINE_FR) == TTV_LINE_FR)
10310 continue ;
10311
10312 if(((ptline->NODE->ROOT->TYPE & TTV_SIG_S) == TTV_SIG_S) ||
10313 ((ptline->ROOT->ROOT->TYPE & TTV_SIG_S) == TTV_SIG_S) ||
10314 /* pour le pb des commandes
10315 ((ptline->NODE->ROOT->TYPE & (TTV_SIG_Q | TTV_SIG_C | TTV_SIG_N))
10316 == TTV_SIG_Q) ||
10317 */
10318 (((ptline->TYPE & TTV_LINE_INFIG) != TTV_LINE_INFIG) &&
10319 ((ptline->TYPE & TTV_LINE_CONT) != TTV_LINE_CONT)))
10320 {
10321 if((ptline->TYPE & TTV_LINE_T) == TTV_LINE_T)
10322 {
10323 if(ptline->MDMAX != NULL)
10324 chainfree = addchain(chainfree,ptline->MDMAX) ;
10325 if(ptline->MFMAX != NULL)
10326 chainfree = addchain(chainfree,ptline->MFMAX) ;
10327 if(ptline->MDMIN != NULL)
10328 chainfree = addchain(chainfree,ptline->MDMIN) ;
10329 if(ptline->MFMIN != NULL)
10330 chainfree = addchain(chainfree,ptline->MFMIN) ;
10331 }
10332
10333 ttv_delline(ptline) ;
10334 continue ;
10335 }
10336
10337 ptline->TYPE &= ~(TTV_LINE_INFIG) ;
10338 }
10339 }
10340 }
10341
10342 if(chainfree != NULL)
10343 {
10344 stm_freemodellist(ttvfig->INFO->FIGNAME,chainfree) ;
10345 freechain(chainfree) ;
10346 }
10347 }
10348
10349 void ttv_FreeMarkedSigList()
10350 {
10351 ttvsig_list *tvs;
10352 while (MARKED_SIG_LIST!=NULL)
10353 {
10354 tvs=(ttvsig_list *)MARKED_SIG_LIST->DATA;
10355 if (getptype(tvs->USER, TTV_SIG_MARKED)==NULL)
10356 {
10357 tvs->USER=delptype(tvs->USER, TTV_SIG_MARKED);
10358 }
10359 MARKED_SIG_LIST=delchain(MARKED_SIG_LIST, MARKED_SIG_LIST);
10360 }
10361 }
10362
10363 static int marked_for(ttvevent_list *evi, ttvevent_list *evo, int hz)
10364 {
10365 ptype_list *pt;
10366 long mask;
10367 if (evo->TYPE & TTV_NODE_UP) mask=1; else mask=2;
10368 if (hz) mask=mask<<8;
10369 if ((pt=getptype(evi->USER, TTV_SIG_MARKED))!=NULL && ((long)pt->DATA & mask)!=0) return 1;
10370 return 0;
10371 }
10372
10373 static void mark_for(ttvevent_list *evi, ttvevent_list *evo, int hz)
10374 {
10375 ptype_list *pt;
10376 long mask;
10377 if (evo->TYPE & TTV_NODE_UP) mask=1; else mask=2;
10378 if (hz) mask=mask<<8;
10379 if ((pt=getptype(evi->USER, TTV_SIG_MARKED))==NULL)
10380 pt=evi->USER=addptype(evi->USER, TTV_SIG_MARKED, (void *)0);
10381 mask|=(long)pt->DATA;
10382 pt->DATA=(void *)mask;
10383 }
10384
10385 ttvpath_list *filter_parallel_to_node(ttvpath_list *pth)
10386 {
10387 ttvpath_list *path, *next;
10388 chain_list *cl=NULL, *ch;
10389 int hz;
10390 for (path=pth; path!=NULL; path=next)
10391 {
10392 next=path->NEXT;
10393 if ((path->TYPE & TTV_FIND_HZ)==TTV_FIND_HZ) hz=1;
10394 else hz=0;
10395 if (!marked_for(path->NODE, path->ROOT, hz))
10396 {
10397 cl=addchain(cl, path);
10398 mark_for(path->NODE, path->ROOT, hz);
10399 }
10400 else
10401 {
10402 path->NEXT=NULL;
10403 ttv_freepathlist(path);
10404 }
10405 }
10406
10407 path=NULL;
10408 for (ch=cl; ch!=NULL; ch=ch->NEXT)
10409 {
10410 pth=(ttvpath_list *)ch->DATA;
10411 pth->NEXT=path;
10412 pth->NODE->USER=testanddelptype(pth->NODE->USER, TTV_SIG_MARKED);
10413
10414 path=pth;
10415 }
10416
10417 freechain(cl);
10418
10419 return path;
10420 }
10421
10422 ttvpath_list *ttv_getpathnocross_v2(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type,addasync)
10423 ttvfig_list *ttvfig ;
10424 ttvfig_list *figpath ;
10425 ttvsig_list *ptsig ;
10426 chain_list *mask ;
10427 long delaymax ;
10428 long delaymin ;
10429 long type ;
10430 int addasync;
10431 {
10432 ttvpath_list *path;
10433
10434 ttv_reset_search_informations();
10435 if (addasync) ttv_search_mode(1, TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_PATHS);
10436
10437 path = ttv_getpathnocross (ttvfig, figpath, ptsig, mask, delaymax, delaymin, type);
10438
10439 if (ttv_get_search_informations() & TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH)
10440 {
10441 ttv_freepathlist(path);
10442 path = ttv_getpathsignocross (ttvfig, figpath, ptsig, mask, delaymax, delaymin, type);
10443 path=filter_parallel_to_node(path);
10444 }
10445 if (addasync) ttv_search_mode(0, TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_PATHS);
10446 return path;
10447 }
10448
10449 ttvpath_list *ttv_getaccessnocross_v2(ttvfig,figpath,ptsig,mask,delaymax,delaymin,type,addasync)
10450 ttvfig_list *ttvfig ;
10451 ttvfig_list *figpath ;
10452 ttvsig_list *ptsig ;
10453 chain_list *mask ;
10454 long delaymax ;
10455 long delaymin ;
10456 long type ;
10457 int addasync;
10458 {
10459 ttvpath_list *path;
10460
10461 ttv_reset_search_informations();
10462 if (addasync) ttv_search_mode(1, TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_PATHS);
10463
10464 path = ttv_getaccessnocross (ttvfig, figpath, ptsig, mask, delaymax, delaymin, type);
10465
10466 if (ttv_get_search_informations() & TTV_SEARCH_INFORMATIONS_CRITIC_FALSEPATH)
10467 {
10468 ttv_freepathlist(path);
10469 path = ttv_getaccesssignocross (ttvfig, figpath, ptsig, mask, delaymax, delaymin, type);
10470 path=filter_parallel_to_node(path);
10471 }
10472 if (addasync) ttv_search_mode(0, TTV_MORE_OPTIONS_ADD_ASYNCHRONOUS_PATHS);
10473 return path;
10474 }
10475
10476 chain_list *ttv_getendpoints(ttvfig_list *tvf, chain_list *sigl, long type)
10477 {
10478 chain_list *sub, *cl, *lst, *ret=NULL;
10479 ttvevent_list *tve;
10480 ttvsig_list *sig;
10481 int maxperiod, savmpd;
10482
10483 if ((type & TTV_FIND_DUAL)!=0) type|=TTV_FIND_CMD;
10484
10485 maxperiod = V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE ;
10486 savmpd=TTV_MaxPathPeriodPrecharge;
10487
10488 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = 0 ;
10489 TTV_MaxPathPeriodPrecharge=0;
10490
10491 for (lst=sigl; lst!=NULL; lst=lst->NEXT)
10492 {
10493 sig=(ttvsig_list *)lst->DATA;
10494 sub = ttv_findpath(tvf,tvf,sig->NODE,NULL,type,tvf->INFO->LEVEL) ;
10495 for(cl= sub ; cl != NULL ; cl = cl->NEXT)
10496 {
10497 tve=(ttvevent_list *)cl->DATA;
10498 tve->FIND->TYPE &= ~TTV_FIND_BEGIN ;
10499 if ((tve->ROOT->TYPE & TTV_SIG_MARQUE)==0) ret=addchain(ret, tve->ROOT);
10500 tve->ROOT->TYPE|=TTV_SIG_MARQUE;
10501 }
10502 ttv_fifoclean();
10503 freechain(sub);
10504 sub = ttv_findpath(tvf,tvf,sig->NODE+1,NULL,type,tvf->INFO->LEVEL) ;
10505 for(cl= sub ; cl != NULL ; cl = cl->NEXT)
10506 {
10507 tve=(ttvevent_list *)cl->DATA;
10508 tve->FIND->TYPE &= ~TTV_FIND_BEGIN ;
10509 if ((tve->ROOT->TYPE & TTV_SIG_MARQUE)==0) ret=addchain(ret, tve->ROOT);
10510 tve->ROOT->TYPE|=TTV_SIG_MARQUE;
10511 }
10512 ttv_fifoclean();
10513 freechain(sub);
10514 }
10515 for (cl=ret; cl!=NULL; cl=cl->NEXT)
10516 ((ttvsig_list *)cl->DATA)->TYPE&=~TTV_SIG_MARQUE;
10517 V_INT_TAB[__TTV_MAX_PATH_PERIOD].VALUE = maxperiod ;
10518 TTV_MaxPathPeriodPrecharge=savmpd;
10519 return ret;
10520 }
10521
10522 static ttvcritic_list *ttv_create_one_node_critic(ttvfig_list *ttvfig,ttvfig_list *ttvins, ttvevent_list *node, long type)
10523 {
10524 ttvcritic_list *critic;
10525 long slope ;
10526 long newslope ;
10527 long start ;
10528
10529 newslope = (long)ttv_getnodeslope(ttvfig,ttvins,node,&slope,type) ;
10530 start = ttv_getinittime(ttvfig,node,STB_NO_INDEX,type,STB_NO_INDEX,NULL) ;
10531 critic = ttv_alloccritic(NULL,ttvfig,NULL,node,type,0,start,slope,start,newslope,0,NULL,NULL) ;
10532
10533 critic->NODE_FLAG|=TTV_NODE_FLAG_FIRST_OF_DETAIL;
10534 return(critic) ;
10535 }
10536
10537 ttvpath_list *ttv_create_one_node_path(ttvfig_list *ttvfig,ttvfig_list *ttvins,ttvevent_list *node,long type)
10538 {
10539 ttvfig_list *ttvfigx ;
10540 long startsref = 0, starts, start ;
10541 ttvpath_list *path;
10542 char phase;
10543
10544 ttvfigx = node->ROOT->ROOT ;
10545
10546 starts = ttv_getnodeslope(ttvfig,ttvins,node,&startsref,type) ;
10547 start = ttv_getinittime(ttvfig,node,STB_NO_INDEX,type,STB_NO_INDEX,&phase) ;
10548 path = ttv_allocpath(NULL,ttvfigx,node,node,NULL,
10549 NULL,NULL,NULL,0,0,0,
10550 type,0,startsref,
10551 0,starts,
10552 start,starts,NULL,NULL, TTV_NOTIME,phase,0) ;
10553
10554 path->CRITIC = ttv_create_one_node_critic(ttvfig,ttvins,node,type) ;
10555 return(path) ;
10556 }
10557