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 / tlf / tlf4.y
1 /******************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI AVERTEC */
4 /* */
5 /* Produit : TLF Version 1.00 */
6 /* Fichier : tlf.y */
7 /* */
8 /* (c) copyright 2000 AVERTEC */
9 /* Tous droits reserves */
10 /* */
11 /* Auteur(s) : Gilles Augustins */
12 /* */
13 /******************************************************************************/
14
15 %{
16 #include "tlf_parse.h"
17 #include "tlf_env.h"
18 #include "tlf_util.h"
19
20 /******************************************************************************/
21 /* private */
22 /******************************************************************************/
23 static cbhcomb *ptrcbhcomb;
24 static cbhseq *ptrcbhseq;
25 static short mout;
26
27 typedef struct minmax {
28 float MIN;
29 float MAX;
30 } minmax;
31
32 typedef struct loconbus {
33 char *NAME;
34 losig_list *LOSIG;
35 char DIREC;
36 } loconbus;
37
38 static chain_list *output;
39
40 static long losig_index;
41 static lofig_list *ptrlofig;
42 static losig_list *ptrlosig;
43 static locon_list *ptrlocon;
44
45 static char *cname;
46
47 static char namebuf[1024];
48 static chain_list *ch, *chp, *xchain, *ychain, *xydatamin, *xydatamax, *ydatamin, *ydatamax;
49 static char xtype, ytype;
50 static char dimension;
51 static int nx, ny;
52 static float *ptfl;
53 static timing_model *modelmin;
54 static timing_model *modelmax;
55 static timing_ttable *ttemplate;
56 static char *cname, *pt;
57 static char *version;
58 static ttvfig_list *fig;
59 static int nbconsig, nbbreaksig, nblatchsig;
60 static chain_list *consigchain, *breaksigchain, *latchsigchain;
61 static ttvevent_list *root, *node;
62 static ttvline_list *line;
63 static ht *modshrinkht;
64 static ht *pinht;
65 static ht *pincapht;
66 static ht *doublemodels;
67 static chain_list *clocks;
68 static int i, l, m, lsb, msb, flagbus = 0;
69 static ttvsig_list *sigroot, *signode, *sig;
70 static char *pinr, *pinn, *pname, *bname, *vectname;
71 static char *mindlymname, *maxdlymname, *minslwmname, *maxslwmname;
72 static long linetype;
73 static long capa;
74 static float slwmin, slwmax, dlymin, dlymax, maxcstr;
75 static float *caparray;
76 static float pincapa = TLF_NO_CAPA, buscapa = TLF_NO_CAPA;
77 static int v;
78 static timing_model *delaymodelmin, *slewmodelmin;
79 static timing_model *delaymodelmax, *slewmodelmax;
80 static long dir;
81 static chain_list *flipflops;
82 static chain_list *latchs;
83 static char pindir;
84 static int clockpin;
85 static float defbidircapa = 0;
86 static float defincapa = 0;
87 static float defoutcapa = 0;
88 static minmax *ptmm;
89 static segment *ptseg;
90 static double fallthmin = 0.1, fallthmax = 0.9;
91 static double risethmin = 0.1, risethmax = 0.9;
92 static double inputfalldth = 0.5, outputfalldth = 0.5;
93 static double inputrisedth = 0.5, outputrisedth = 0.5;
94 static double voltage, temperature;
95 static int itype, otype;
96 static timing_props *properties;
97
98 typedef struct statevar {
99 char *PINNAME;
100 char *VAR;
101 } statevar;
102
103 statevar *cbhname1=NULL;
104 statevar *cbhname2=NULL;
105
106
107
108 /******************************************************************************/
109 /* function declarations */
110 /******************************************************************************/
111
112 int yyerror();
113 int yylex();
114
115 %}
116
117 %union {
118 char *text;
119 float real;
120 struct chain *chainlist;
121 struct { struct chain *CHAIN; char TYPE; } axedef;
122 struct { struct chain *CHAIN; char DIM; } datadef;
123 struct { float MIN; float MAX; } valdef;
124 struct { char *MIN; char *MAX; } bitext;
125 char cchar;
126 long llong;
127 struct segment *ssegment;
128 };
129
130 %token TLF4_TOKEN_01
131 %token TLF4_TOKEN_0Z
132 %token TLF4_TOKEN_10
133 %token TLF4_TOKEN_1Z
134 %token TLF4_TOKEN_ARROW "=>"
135 %token TLF4_TOKEN_BUS_ARROW "*>"
136 %token TLF4_TOKEN_ASYNCH
137 %token <text> TLF4_TOKEN_ATTRIBUTE
138 %token TLF4_TOKEN_BIDIR
139 %token TLF4_TOKEN_BUS
140 %token TLF4_TOKEN_CAP_UNIT
141 %token TLF4_TOKEN_CAPACITANCE
142 %token TLF4_TOKEN_CELL
143 %token TLF4_TOKEN_CELLTYPE
144 %token TLF4_TOKEN_CLEAR
145 %token TLF4_TOKEN_CLEAR_PRESET_VAR1
146 %token TLF4_TOKEN_CLEAR_PRESET_VAR2
147 %token TLF4_TOKEN_CLOCK_PIN
148 %token TLF4_TOKEN_CLOCK_REG
149 %token TLF4_TOKEN_CLOCK_SLEW_AXIS
150 %token TLF4_TOKEN_COMB
151 %token TLF4_TOKEN_CONST
152 %token TLF4_TOKEN_CONTROL
153 %token TLF4_TOKEN_DATA
154 %token TLF4_TOKEN_DATE
155 %token TLF4_TOKEN_DEFINE_ATTRIBUTE
156 %token TLF4_TOKEN_DELAY
157 %token TLF4_TOKEN_ENABLE
158 %token TLF4_TOKEN_ENERGY
159 %token <real> TLF4_TOKEN_ENUMBER
160 %token TLF4_TOKEN_ENVIRONMENT
161 %token <text> TLF4_TOKEN_EXPR
162 %token TLF4_TOKEN_FALL
163 %token TLF4_TOKEN_FAST
164 %token TLF4_TOKEN_FOR_BITS
165 %token TLF4_TOKEN_FOR_PIN
166 %token TLF4_TOKEN_FUNCTION
167 %token TLF4_TOKEN_GROUND
168 %token TLF4_TOKEN_SUPPLY
169 %token TLF4_TOKEN_GENMODEL
170 %token TLF4_TOKEN_HEADER
171 %token TLF4_TOKEN_HIGH
172 %token TLF4_TOKEN_HOLD
173 %token <text> TLF4_TOKEN_IDENT
174 %token TLF4_TOKEN_IGNORE
175 %token TLF4_TOKEN_INCELL
176 %token TLF4_TOKEN_INPUT
177 %token TLF4_TOKEN_INPUT_REG
178 %token TLF4_TOKEN_INPUT_SLEW_AXIS
179 %token TLF4_TOKEN_INTERNAL
180 %token TLF4_TOKEN_INVERTED_OUTPUT
181 %token TLF4_TOKEN_LATCH
182 %token TLF4_TOKEN_LIBRARY
183 %token TLF4_TOKEN_LOAD_AXIS
184 %token TLF4_TOKEN_LOAD2_AXIS
185 %token TLF4_TOKEN_LOW
186 %token TLF4_TOKEN_LOWER_THRESHOLD
187 %token TLF4_TOKEN_INPUT_THRESHOLD
188 %token TLF4_TOKEN_OUTPUT_THRESHOLD
189 %token TLF4_TOKEN_MODEL
190 %token TLF4_TOKEN_NEGEDGE
191 %token <real> TLF4_TOKEN_NUMBER
192 %token TLF4_TOKEN_OUTCELL
193 %token TLF4_TOKEN_OUTPUT
194 %token TLF4_TOKEN_PATH
195 %token TLF4_TOKEN_PIN
196 %token TLF4_TOKEN_PINDIR
197 %token TLF4_TOKEN_PINTYPE
198 %token TLF4_TOKEN_POSEDGE
199 %token TLF4_TOKEN_PROPERTIES
200 %token <text> TLF4_TOKEN_QSTRING
201 %token TLF4_TOKEN_REGISTER
202 %token TLF4_TOKEN_RISE
203 %token TLF4_TOKEN_SEQ
204 %token TLF4_TOKEN_SET
205 %token TLF4_TOKEN_SETUP
206 %token TLF4_TOKEN_SLAVE_CLOCK
207 %token TLF4_TOKEN_SLEW
208 %token TLF4_TOKEN_SLOW
209 %token TLF4_TOKEN_SLEW_AXIS
210 %token TLF4_TOKEN_SPLINE
211 %token TLF4_TOKEN_TECHNOLOGY
212 %token TLF4_TOKEN_TIME_UNIT
213 %token TLF4_TOKEN_RES_UNIT
214 %token TLF4_TOKEN_TIMING_PROPS
215 %token TLF4_TOKEN_TLF_VERSION
216 %token TLF4_TOKEN_TRISTATE
217 %token TLF4_TOKEN_UNIT
218 %token TLF4_TOKEN_UPPER_THRESHOLD
219 %token <text> TLF4_TOKEN_VECT
220 %token <text> TLF4_TOKEN_VECT_IDENT
221 %token TLF4_TOKEN_VENDOR
222 %token TLF4_TOKEN_VERSION
223 %token TLF4_TOKEN_Z0
224 %token TLF4_TOKEN_Z1
225 %token TLF4_TOKEN_VDROP_LIMIT
226 %token TLF4_TOKEN_TRANSITION_START
227 %token TLF4_TOKEN_TRANSITION_END
228 %token TLF4_TOKEN_LINEAR
229 %token TLF4_TOKEN_VALUE
230 %token TLF4_TOKEN_NET_CAP_MODEL
231 %token TLF4_TOKEN_NET_RES_MODEL
232 %token TLF4_TOKEN_NET_CAP
233 %token TLF4_TOKEN_NET_RES
234 %token TLF4_TOKEN_TEMPERATURE
235 %token TLF4_TOKEN_VOLTAGE
236
237 %start tlf_file
238
239 %type <text> arg
240 %type <chainlist> array1D
241 %type <chainlist> array2D
242 %type <chainlist> array1D_list
243 %type <axedef> axe
244 %type <cchar> axetype
245 %type <cchar> bustype
246 %type <text> cellname
247 %type <cchar> celltype
248 %type <cchar> clocktrans
249 %type <valdef> constant
250 %type <valdef> constdelay
251 %type <valdef> constslew
252 %type <bitext> constraint
253 %type <valdef> cval
254 %type <chainlist> cval_list
255 %type <chainlist> segment_list
256 %type <datadef> data
257 %type <bitext> delay
258 %type <text> ident
259 %type <chainlist> ident_list
260 %type <datadef> modeldata
261 %type <text> modelname
262 %type <chainlist> outputs
263 %type <real> pincap
264 %type <text> pinname
265 %type <cchar> pintype
266 %type <bitext> slew
267 %type <cchar> target
268 %type <text> templatename
269 %type <cchar> transition
270 %type <chainlist> val_list
271 %type <real> val
272 %type <real> capacitance
273 %type <ssegment> segment
274
275 %%
276
277 tlf_file : header def_list cell_list
278 {
279 if(TLF_TRACE_MODE == 'Y')
280 fprintf (stdout, " <--- done\n");
281 /* else
282 fprintf(stdout,"DONE!\n");*/
283 cbh_delcct();
284 }
285 ;
286
287 def_list : empty
288 | def def_list
289 ;
290
291 def : defattr
292 | genmod
293 | netcapmodel
294 | netresmodel
295 | gentprop
296 | properties
297 | attribute
298 ;
299
300
301 defattr : TLF4_TOKEN_DEFINE_ATTRIBUTE '(' ident target type ')'
302 {
303 set_attribute ($3, $4);
304 }
305 ;
306
307 target : '(' TLF4_TOKEN_CELL ')'
308 {
309 $$ = 'C';
310 }
311 | '(' TLF4_TOKEN_LIBRARY ')'
312 {
313 $$ = 'L';
314 }
315 | '(' TLF4_TOKEN_PIN ')'
316 {
317 $$ = 'P';
318 }
319 ;
320
321 type : '(' ident ')'
322 ;
323
324 genmod : TLF4_TOKEN_GENMODEL '(' templatename '(' modelbody ')' ')'
325 {
326 for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
327 for (ny = 0, ch = ychain; ch; ch = ch->NEXT) ny++;
328 ttemplate = stm_modtbl_addtemplate ($3, nx, ny, xtype, ytype);
329 if (xtype == STM_INPUT_SLEW || xtype == STM_CLOCK_SLEW) {
330 if (TLF_TIME_UNIT == TLF_NS)
331 stm_modtbl_settemplateXrange (ttemplate, xchain, 1e3);
332 if (TLF_TIME_UNIT == TLF_PS)
333 stm_modtbl_settemplateXrange (ttemplate, xchain, 1);
334 }
335 if (xtype == STM_LOAD) {
336 if (TLF_CAPA_UNIT == TLF_PF)
337 stm_modtbl_settemplateXrange (ttemplate, xchain, 1e3);
338 if (TLF_CAPA_UNIT == TLF_FF)
339 stm_modtbl_settemplateXrange (ttemplate, xchain, 1);
340 }
341 if (ytype == STM_INPUT_SLEW || ytype == STM_CLOCK_SLEW) {
342 if (TLF_TIME_UNIT == TLF_NS)
343 stm_modtbl_settemplateYrange (ttemplate, ychain, 1e3);
344 if (TLF_TIME_UNIT == TLF_PS)
345 stm_modtbl_settemplateYrange (ttemplate, ychain, 1);
346 }
347 if (ytype == STM_LOAD) {
348 if (TLF_CAPA_UNIT == TLF_PF)
349 stm_modtbl_settemplateYrange (ttemplate, ychain, 1e3);
350 if (TLF_CAPA_UNIT == TLF_FF)
351 stm_modtbl_settemplateYrange (ttemplate, ychain, 1);
352 }
353 for (ch = xchain; ch; ch = ch->NEXT)
354 mbkfree(ch->DATA);
355 freechain (xchain);
356 for (ch = ychain; ch; ch = ch->NEXT)
357 mbkfree(ch->DATA);
358 freechain (ychain);
359 }
360 ;
361
362 gentprop : TLF4_TOKEN_TIMING_PROPS '(' ')'
363 ;
364
365 properties : TLF4_TOKEN_PROPERTIES '(' prop_list ')'
366 {
367 float scale;
368 if(properties){
369 if(properties->RESMODEL){
370 if(TLF_RES_UNIT == TLF_KOHM)
371 scale = 1000.0;
372 else if(TLF_RES_UNIT == TLF_OHM)
373 scale = 1.0;
374 stm_scale_loadmodel(properties->RESMODEL,scale);
375 }
376 if(properties->CAPMODEL){
377 if(TLF_CAPA_UNIT == TLF_PF)
378 scale = 1000.0;
379 else if(TLF_CAPA_UNIT == TLF_FF)
380 scale = 1.0;
381 stm_scale_loadmodel(properties->CAPMODEL,scale);
382 }
383 }
384 }
385 ;
386
387 prop_list : empty
388 | prop_list prop
389 ;
390
391 prop : TLF4_TOKEN_UNIT '(' unit_list ')'
392 | TLF4_TOKEN_FOR_PIN '(' TLF4_TOKEN_INPUT capacitance ')'
393 {
394 defincapa = $4;
395 }
396 | TLF4_TOKEN_FOR_PIN '(' TLF4_TOKEN_OUTPUT capacitance ')'
397 {
398 defoutcapa = $4;
399 }
400 | TLF4_TOKEN_FOR_PIN '(' TLF4_TOKEN_BIDIR capacitance ')'
401 {
402 defbidircapa = $4;
403 }
404 | TLF4_TOKEN_TEMPERATURE '(' val ')'
405 {
406 temperature = $3;
407 }
408 | TLF4_TOKEN_VOLTAGE '(' val ')'
409 {
410 voltage = $3;
411 }
412 | delay_th
413 {
414 if((inputrisedth != inputfalldth) || (inputrisedth != inputfalldth) || (inputrisedth != inputfalldth))
415 fprintf (stderr, "***tlf warning: input and output thresholds are not the same***\n");
416 }
417 | threshold
418 {
419 if((risethmin != fallthmin) || (risethmax != fallthmax))
420 fprintf (stderr, "***tlf warning: slew thresholds are not the same for rising and falling***\n");
421 }
422 | TLF4_TOKEN_NET_CAP '(' ident ')'
423 {
424 if(!STM_PROPERTIES)
425 properties = stm_prop_create (NULL, NULL);
426 else
427 properties = STM_PROPERTIES;
428 if(!properties->CAPMODEL)
429 stm_addcapmodel(properties, stm_getmodel(cname, $3));
430 }
431 | TLF4_TOKEN_NET_RES '(' ident ')'
432 {
433 if(!STM_PROPERTIES)
434 properties = stm_prop_create (NULL, NULL);
435 else
436 properties = STM_PROPERTIES;
437 if(!properties->RESMODEL)
438 stm_addresmodel(properties, stm_getmodel(cname, $3));
439 }
440 ;
441
442 delay_th : TLF4_TOKEN_INPUT_THRESHOLD '(' TLF4_TOKEN_RISE '(' val ')' TLF4_TOKEN_FALL '(' val ')' ')'
443 {
444 inputrisedth = $5 / 100;
445 inputfalldth = $9 / 100;
446 }
447 | TLF4_TOKEN_OUTPUT_THRESHOLD '(' TLF4_TOKEN_RISE '(' val ')' TLF4_TOKEN_FALL '(' val ')' ')'
448 {
449 outputrisedth = $5 / 100;
450 outputfalldth = $9 / 100;
451 }
452 ;
453
454 threshold : TLF4_TOKEN_LOWER_THRESHOLD '(' TLF4_TOKEN_RISE '(' val ')' TLF4_TOKEN_FALL '(' val ')' ')'
455 {
456 risethmin = $5 / 100;
457 fallthmin = $9 / 100;
458 }
459 | TLF4_TOKEN_UPPER_THRESHOLD '(' TLF4_TOKEN_RISE '(' val ')' TLF4_TOKEN_FALL '(' val ')' ')'
460 {
461 risethmax = $5 / 100;
462 fallthmax = $9 / 100;
463 }
464 | TLF4_TOKEN_TRANSITION_START '(' val ')'
465 {
466 risethmin = $3;
467 fallthmin = $3;
468 }
469 | TLF4_TOKEN_TRANSITION_END '(' val ')'
470 {
471 risethmax = $3;
472 fallthmax = $3;
473 }
474 ;
475
476
477 capacitance : TLF4_TOKEN_CAPACITANCE '(' val ')'
478 {
479 $$ = $3;
480 }
481 ;
482
483 unit_list : empty
484 | unit_list unit
485 ;
486
487 unit : TLF4_TOKEN_CAP_UNIT '(' val TLF4_TOKEN_IDENT ')'
488 {
489 if (!strcasecmp ($4, "pf"))
490 TLF_CAPA_UNIT = TLF_PF;
491 if (!strcasecmp ($4, "ff"))
492 TLF_CAPA_UNIT = TLF_FF;
493 }
494 | TLF4_TOKEN_TIME_UNIT '(' val TLF4_TOKEN_IDENT ')'
495 {
496 if (!strcasecmp ($4, "ps"))
497 TLF_TIME_UNIT = TLF_PS;
498 if (!strcasecmp ($4, "ns"))
499 TLF_TIME_UNIT = TLF_NS;
500 }
501 | TLF4_TOKEN_RES_UNIT '(' val TLF4_TOKEN_IDENT ')'
502 {
503 if (!strcasecmp ($4, "kohm"))
504 TLF_RES_UNIT = TLF_KOHM;
505 if (!strcasecmp ($4, "ohm"))
506 TLF_RES_UNIT = TLF_OHM;
507 }
508 ;
509
510 attribute : TLF4_TOKEN_ATTRIBUTE '(' arg ')'
511 {
512 char *str;
513
514 if((!strcasecmp($1,"state_variable_map")) && (ptrcbhcomb != NULL)){
515 if(cbhname1 == NULL){
516 cbhname1 = (statevar*)mbkalloc(sizeof(struct statevar));
517 cbhname1->PINNAME = mbkstrdup(pname);
518 cbhname1->VAR = mbkstrdup($3);
519 if(ptrcbhcomb->FUNCTION == NULL) {
520 str = eqt_ConvertStr($3);
521 ptrcbhcomb->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
522 mbkfree (str);
523 }
524 }
525 else {
526 if(strcasecmp(cbhname1->VAR,$3)) {
527 cbhname2 = (statevar*)mbkalloc(sizeof(struct statevar));
528 cbhname2->PINNAME = mbkstrdup(pname);
529 cbhname2->VAR = mbkstrdup($3);
530 if(ptrcbhcomb->FUNCTION == NULL) {
531 str = eqt_ConvertStr($3);
532 ptrcbhcomb->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
533 mbkfree (str);
534 }
535 }
536 else {
537 mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
538 cbhname1 = NULL;
539 }
540 }
541 }
542
543 callback_attribute ($1, $3);
544 }
545 ;
546
547 arg : TLF4_TOKEN_QSTRING
548 {
549 $$ = stm_unquote ($1);
550 mbkfree($1);
551 }
552 | ident
553 {
554 $$ = $1;
555 }
556 | val
557 {
558 char buf[TLF_BUFSIZE];
559 sprintf(buf,"%g",$1);
560 $$ = namealloc(buf);
561 }
562
563 ;
564
565 header : TLF4_TOKEN_HEADER '(' helem_list ')'
566 {
567 /* if(TLF_TRACE_MODE != 'Y') {
568 fprintf(stdout,"\nLOADING LIBRARY %s TLF4... ", LIBRARY_TLF_NAME);
569 fflush( stdout );
570 }*/
571 output = NULL;
572 losig_index = 0;
573 ptrlofig = NULL;
574 ptrlosig = NULL;
575 ptrlocon = NULL;
576 ptrcbhcomb = NULL;
577 ptrcbhseq = NULL;
578
579 pincapa = TLF_NO_CAPA;
580 buscapa = TLF_NO_CAPA;
581 defbidircapa = 0;
582 defincapa = 0;
583 defoutcapa = 0;
584 fallthmin = 0.1;
585 fallthmax = 0.9;
586 risethmin = 0.1;
587 risethmax = 0.9;
588 //flagbus = 0;
589
590 tlf4reset();
591
592 cbh_newclassifier();
593 cbh_createcct();
594 }
595 ;
596
597 helem_list : empty
598 | helem_list helem
599 ;
600
601 helem : library
602 | technology
603 | date
604 | vendor
605 | environment
606 | version
607 | tlf_version
608 ;
609
610 library : TLF4_TOKEN_LIBRARY '(' TLF4_TOKEN_QSTRING ')'
611 {
612 nbconsig = 0;
613 nbbreaksig = 0;
614 nblatchsig = 0;
615 consigchain = NULL;
616 breaksigchain = NULL;
617 latchsigchain = NULL;
618 clocks = NULL;
619
620 tlf_setenv();
621 LIBRARY_TLF_NAME = tlf_treatname($3);
622 stm_addcell (LIBRARY_TLF_NAME);
623 cname = LIBRARY_TLF_NAME;
624 mbkfree($3);
625 }
626 ;
627
628 technology : TLF4_TOKEN_TECHNOLOGY '(' TLF4_TOKEN_QSTRING ')'
629 {
630 mbkfree($3);
631 }
632 ;
633
634 date : TLF4_TOKEN_DATE '(' TLF4_TOKEN_QSTRING ')'
635 {
636 mbkfree($3);
637 }
638 ;
639
640 vendor : TLF4_TOKEN_VENDOR '(' TLF4_TOKEN_QSTRING ')'
641 {
642 mbkfree($3);
643 }
644 ;
645
646 environment : TLF4_TOKEN_ENVIRONMENT '(' TLF4_TOKEN_QSTRING ')'
647 {
648 mbkfree($3);
649 }
650 ;
651
652 version : TLF4_TOKEN_VERSION '(' TLF4_TOKEN_QSTRING ')'
653 {
654 mbkfree($3);
655 }
656 ;
657
658 tlf_version : TLF4_TOKEN_TLF_VERSION '(' TLF4_TOKEN_QSTRING ')'
659 {
660 mbkfree($3);
661 }
662 ;
663
664 cell_list : empty
665 | cell_list cell
666 ;
667
668 cell : TLF4_TOKEN_CELL '(' celldef cellelms arcs ')'
669 {
670 char buf[1024];
671 locon_list *p;
672 cbhcomb *c;
673 char *str;
674
675
676 if((ptrcbhseq != NULL) && (!mout)){
677 if(cbhname1 != NULL){
678 if(!strcasecmp(cbhname1->PINNAME,ptrcbhseq->PIN))
679 ptrcbhseq->NAME = namealloc(cbhname1->VAR);
680 else if(!strcasecmp(cbhname1->PINNAME,ptrcbhseq->NEGPIN))
681 ptrcbhseq->NEGNAME = namealloc(cbhname1->VAR);
682 }
683 if(cbhname2 != NULL){
684 if(!strcasecmp(cbhname2->PINNAME,ptrcbhseq->PIN))
685 ptrcbhseq->NAME = namealloc(cbhname2->VAR);
686 else if(!strcasecmp(cbhname2->PINNAME,ptrcbhseq->NEGPIN))
687 ptrcbhseq->NEGNAME = namealloc(cbhname2->VAR);
688 }
689
690 if((ptrcbhseq->NAME == NULL) && (ptrcbhseq->PIN !=NULL)) {
691 sprintf(buf,"I%s",ptrcbhseq->PIN);
692 ptrcbhseq->NAME = namealloc(buf);
693 }
694
695 if((ptrcbhseq->NEGNAME == NULL) && (ptrcbhseq->NEGPIN != NULL)){
696 sprintf(buf,"I%s",ptrcbhseq->NEGPIN);
697 ptrcbhseq->NEGNAME = namealloc(buf);
698 }
699
700 if(ptrcbhseq->PIN != NULL) {
701 p = getlocon(ptrlofig, ptrcbhseq->PIN);
702 c = cbh_getcombfromlocon(p);
703 if(!c->FUNCTION) {
704 str = eqt_ConvertStr(ptrcbhseq->NAME);
705 c->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
706 mbkfree (str);
707 }
708 if((ptrcbhseq->DATA != NULL) && (tlf_lookingForExpr(ptrcbhseq->DATA, ptrcbhseq->PIN) == 1))
709 ptrcbhseq->DATA = tlf_replaceInAbl(ptrcbhseq->DATA, ptrcbhseq->PIN, ptrcbhseq->NAME);
710 }
711
712 if(ptrcbhseq->NEGPIN != NULL) {
713 p = getlocon(ptrlofig, ptrcbhseq->NEGPIN);
714 c = cbh_getcombfromlocon(p);
715 if(!c->FUNCTION) {
716 str = eqt_ConvertStr(ptrcbhseq->NEGNAME);
717 c->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
718 mbkfree (str);
719 }
720 if((ptrcbhseq->DATA != NULL) && (tlf_lookingForExpr(ptrcbhseq->DATA, ptrcbhseq->NEGPIN) == 1))
721 ptrcbhseq->DATA = tlf_replaceInAbl(ptrcbhseq->DATA, ptrcbhseq->NEGPIN, ptrcbhseq->NEGNAME);
722 }
723
724 cbh_addseqtolofig(ptrlofig, ptrcbhseq);
725 }
726
727 if(mout == 0)
728 cbh_classlofig(ptrlofig);
729
730
731 for (i = 0; i < fig->NBCONSIG; i++) {
732 sig = fig->CONSIG[i];
733 if ((sig->TYPE & TTV_SIG_B) == TTV_SIG_B) {
734 breaksigchain = addchain(breaksigchain,sig);
735 nbbreaksig++;
736 }
737 if ((sig->TYPE & TTV_SIG_L) == TTV_SIG_L) {
738 latchsigchain = addchain(latchsigchain,sig);
739 nblatchsig++;
740 }
741 }
742
743 fig->NBEBREAKSIG = nbbreaksig;
744 fig->EBREAKSIG = ttv_allocreflist (breaksigchain, nbbreaksig);
745 fig->NBELATCHSIG = nblatchsig;
746 fig->ELATCHSIG = ttv_allocreflist (latchsigchain, nblatchsig);
747
748 for (i = 0; i < fig->NBCONSIG; i++) {
749 capa = gethtitem (pincapht, namealloc (fig->CONSIG[i]->NAME));
750 if (capa != EMPTYHT)
751 mbkfree((float*)capa);
752 }
753
754 ptrcbhseq = NULL;
755 cbhname1 = NULL;
756 cbhname2 = NULL;
757 delht (modshrinkht);
758 delht (pinht);
759 delht (pincapht);
760 delht (doublemodels);
761 freechain (clocks);
762 freechain (flipflops);
763 freechain (latchs);
764 clocks = NULL;
765 flipflops = NULL;
766 latchs = NULL;
767 nbbreaksig = 0;
768 latchsigchain = NULL;
769 nblatchsig = 0;
770 breaksigchain = NULL;
771 fig->STATUS |= TTV_STS_DTX;
772 fig->STATUS |= TTV_STS_TTX;
773 }
774 ;
775
776 cellelms : cellelm_list
777 {
778 fig->CONSIG = ttv_allocreflist (consigchain, nbconsig);
779 fig->NBCONSIG = nbconsig;
780 for (i = 0; i < fig->NBCONSIG; i++)
781 addhtitem (pinht, namealloc (fig->CONSIG[i]->NAME), (long)fig->CONSIG[i]);
782 consigchain = NULL;
783 nbconsig = 0;
784 }
785 ;
786
787 cellelm_list : empty
788 | cellelm_list cellelm
789 ;
790
791 cellelm : model
792 | directive
793 | pin
794 | registers
795 | celltprops
796 | attribute
797 ;
798
799 registers : TLF4_TOKEN_REGISTER '('
800 {
801 if(ptrcbhseq != NULL) {
802 mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
803 }
804 else {
805 ptrcbhseq = cbh_newseq();
806 ptrcbhseq->SEQTYPE = CBH_FLIPFLOP;
807 }
808 }
809 reg_list ')'
810 {
811 if(ptrcbhseq != NULL)
812 flipflops = append (flipflops, output);
813 output = NULL;
814 }
815 | TLF4_TOKEN_LATCH '('
816 {
817 if(ptrcbhseq != NULL) {
818 mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
819 }
820
821 else {
822 ptrcbhseq = cbh_newseq();
823 ptrcbhseq->SEQTYPE = CBH_LATCH;
824 }
825 }
826 reg_list ')'
827 {
828 if(ptrcbhseq != NULL)
829 latchs = append (latchs, output);
830 output = NULL;
831 }
832 ;
833
834 reg_list : empty{}
835 | reg_list outputs
836 | reg_list reg_elem {}
837 ;
838
839 reg_elem : TLF4_TOKEN_CLEAR TLF4_TOKEN_EXPR
840 {
841 char *str;
842 if(ptrcbhseq != NULL) {
843 str = eqt_ConvertStr($2);
844 ptrcbhseq->RESET = eqt_StrToAbl(tlfEqtCtx,str);
845 mbkfree (str);
846 }
847 }
848 | TLF4_TOKEN_CLOCK_REG TLF4_TOKEN_EXPR
849 {
850 char *str;
851 if(ptrcbhseq != NULL) {
852 str = eqt_ConvertStr($2);
853 ptrcbhseq->CLOCK = eqt_StrToAbl(tlfEqtCtx,str);
854 mbkfree (str);
855 }
856 }
857 | TLF4_TOKEN_SLAVE_CLOCK TLF4_TOKEN_EXPR
858 {
859 char *str;
860 if(ptrcbhseq != NULL) {
861 str = eqt_ConvertStr($2);
862 ptrcbhseq->SLAVECLOCK = eqt_StrToAbl(tlfEqtCtx,str);
863 mbkfree (str);
864 }
865 }
866 | TLF4_TOKEN_SET TLF4_TOKEN_EXPR
867 {
868 char *str;
869 if(ptrcbhseq != NULL) {
870 str = eqt_ConvertStr($2);
871 ptrcbhseq->SET = eqt_StrToAbl(tlfEqtCtx,str);
872 mbkfree (str);
873 }
874 }
875 | TLF4_TOKEN_INPUT_REG TLF4_TOKEN_EXPR
876 {
877 char *str;
878 if(ptrcbhseq != NULL) {
879 str = eqt_ConvertStr($2);
880 ptrcbhseq->DATA = eqt_StrToAbl(tlfEqtCtx,str);
881 mbkfree (str);
882 }
883 }
884 | TLF4_TOKEN_CLEAR_PRESET_VAR1 TLF4_TOKEN_EXPR
885 {
886 char *str;
887 if(ptrcbhseq != NULL) {
888 str = eqt_ConvertStr($2);
889 ptrcbhseq->RSCONF = eqt_StrToAbl(tlfEqtCtx,str);
890 mbkfree (str);
891 }
892 }
893 | TLF4_TOKEN_CLEAR_PRESET_VAR2 TLF4_TOKEN_EXPR
894 {
895 char *str;
896 if(ptrcbhseq != NULL) {
897 str = eqt_ConvertStr($2);
898 ptrcbhseq->RSCONFNEG = eqt_StrToAbl(tlfEqtCtx,str);
899 mbkfree (str);
900 }
901 }
902 ;
903
904 outputs : TLF4_TOKEN_OUTPUT '(' ident_list ')'
905 {
906 if($3->NEXT != NULL)
907 mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
908 else {
909 if(ptrcbhseq != NULL)
910 ptrcbhseq->PIN = namealloc(tlf_chainlistToStr($3));
911 }
912 if (output == NULL)
913 output = $3;
914 else
915 output = append(output,$3);
916 }
917 | TLF4_TOKEN_INVERTED_OUTPUT '(' ident_list ')'
918 {
919 if($3->NEXT != NULL)
920 mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
921 else {
922 if(ptrcbhseq != NULL)
923 ptrcbhseq->NEGPIN = namealloc(tlf_chainlistToStr($3));
924 }
925 if (output == NULL)
926 output = $3;
927 else
928 output = append(output,$3);
929 }
930 ;
931
932 ident_list : ident
933 {
934 $$ = addchain (NULL, $1);
935 }
936 | ident ident_list
937 {
938 $$ = addchain ($2, $1);
939 }
940 ;
941
942 celldef : cellname celltype
943 {
944 lofig_list *p;
945
946 cname = $1;
947 mout = 0;
948 if(TLF_TRACE_MODE == 'Y')
949 fprintf (stdout, " ---> processing cell %s\n", cname);
950
951 /* nouvelle cellule --> lofig a creer */
952 losig_index = 1;
953 if((p=getloadedlofig(cname)) == NULL) {
954 ptrlofig = addlofig(cname);
955 ptrlofig->MODE = 'P';
956 addcatalog(ptrlofig->NAME);
957 }
958
959 else
960 ptrlofig = p;
961
962 version = (char*) mbkalloc (TLF_BUFSIZE * sizeof (char));
963 sprintf (version, "%.2f", elpTechnoVersion);
964 stm_addcell ($1);
965 fig = ttv_givehead ($1, $1, NULL);
966 ttv_lockttvfig(fig);
967 ttv_setttvlevel (fig);
968 TLF_TTVFIG_LIST = addchain (TLF_TTVFIG_LIST, fig);
969 fig->INFO->TOOLNAME = TLF_TOOLNAME;
970 fig->INFO->TOOLVERSION = TLF_TOOLVERSION;
971 fig->INFO->TECHNONAME = elpTechnoName;
972 fig->INFO->TECHNOVERSION = version;
973 fig->INFO->SLOPE = STM_DEF_SLEW;
974 fig->INFO->CAPAOUT = STM_DEF_LOAD;
975 fig->INFO->STHHIGH = risethmax;
976 fig->INFO->STHLOW = risethmin;
977 fig->INFO->DTH = outputrisedth;
978 fig->INFO->TEMP = temperature;
979 fig->INFO->VDD = voltage;
980 ttv_setttvdate (fig, TTV_DATE_LOCAL);
981 modshrinkht = addht (100);
982 pinht = addht (100);
983 pincapht = addht (100);
984 doublemodels = addht (100);
985 }
986 ;
987
988 directive : ident
989 {
990 }
991 ;
992
993 celltype : TLF4_TOKEN_CELLTYPE '(' TLF4_TOKEN_IGNORE ')'
994 {
995 $$ = STM_IGNORE;
996 }
997 | TLF4_TOKEN_CELLTYPE '(' TLF4_TOKEN_OUTCELL ')'
998 {
999 $$ = STM_IGNORE;
1000 }
1001 | TLF4_TOKEN_CELLTYPE '(' TLF4_TOKEN_INCELL ')'
1002 {
1003 $$ = STM_IGNORE;
1004 }
1005 | TLF4_TOKEN_CELLTYPE '(' TLF4_TOKEN_INCELL TLF4_TOKEN_OUTCELL ')'
1006 {
1007 $$ = STM_IGNORE;
1008 }
1009 | TLF4_TOKEN_CELLTYPE '(' TLF4_TOKEN_SEQ ')'
1010 {
1011 $$ = STM_SEQ;
1012 }
1013 | TLF4_TOKEN_CELLTYPE '(' TLF4_TOKEN_COMB ')'
1014 {
1015 $$ = STM_COMB;
1016 }
1017 | empty
1018 {
1019 $$ = STM_IGNORE;
1020 }
1021 ;
1022
1023 celltprops : TLF4_TOKEN_TIMING_PROPS '(' ')'
1024 ;
1025
1026 arcs : arc_list
1027 {
1028
1029 for (i = 0; i < fig->NBCONSIG; i++) {
1030 sig = fig->CONSIG[i];
1031
1032 /* typer B, LL (latch), LF (flip-flop) */
1033
1034 for (line = sig->NODE[0].INLINE; line; line = line->NEXT) {
1035 /* access */
1036 if ((line->TYPE & TTV_LINE_A) == TTV_LINE_A) {
1037 switch (getoutputtype (sig->NAME, flipflops, latchs)) {
1038 case 'B' :
1039 sig->TYPE |= TTV_SIG_B;
1040 break;
1041 case 'L' :
1042 sig->TYPE |= TTV_SIG_LL;
1043 break;
1044 case 'F' :
1045 sig->TYPE |= TTV_SIG_LF;
1046 break;
1047 }
1048 line->NODE->ROOT->TYPE |= TTV_SIG_B;
1049 break;
1050 }
1051 /* hold, setup */
1052 if (((line->TYPE & TTV_LINE_O) == TTV_LINE_O) || ((line->TYPE & TTV_LINE_U) == TTV_LINE_U)) {
1053 sig->TYPE |= TTV_SIG_B;
1054 line->NODE->ROOT->TYPE |= TTV_SIG_B;
1055 }
1056 }
1057
1058 for (line = sig->NODE[1].INLINE; line; line = line->NEXT) {
1059 /* access */
1060 if ((line->TYPE & TTV_LINE_A) == TTV_LINE_A) {
1061 switch (getoutputtype (sig->NAME, flipflops, latchs)) {
1062 case 'B' :
1063 sig->TYPE |= TTV_SIG_B;
1064 break;
1065 case 'L' :
1066 sig->TYPE |= TTV_SIG_LL;
1067 break;
1068 case 'F' :
1069 sig->TYPE |= TTV_SIG_LF;
1070 break;
1071 }
1072 line->NODE->ROOT->TYPE |= TTV_SIG_B;
1073 break;
1074 }
1075 /* hold, setup */
1076 if (((line->TYPE & TTV_LINE_O) == TTV_LINE_O) || ((line->TYPE & TTV_LINE_U) == TTV_LINE_U)) {
1077 sig->TYPE |= TTV_SIG_B;
1078 line->NODE->ROOT->TYPE |= TTV_SIG_B;
1079 }
1080 }
1081 }
1082 }
1083 ;
1084
1085
1086 netcapmodel : TLF4_TOKEN_NET_CAP_MODEL '(' modelname '(' modelbody ')' ')'
1087 {
1088 modelmax = NULL;
1089 for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
1090 if (xydatamax && !xydatamin) {
1091 sprintf (namebuf, "%s", $3);
1092 modelmax = stm_addtblmodel (cname, namebuf, nx, 0, xtype, STM_NOTYPE);
1093 stm_storemodel (cname, namebuf, modelmax, 0);
1094 }
1095 if (xtype == STM_LOAD) {
1096 stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
1097 }
1098 switch (dimension) {
1099 case TLF_1D :
1100 stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
1101 for (ch = xydatamax; ch; ch = ch->NEXT)
1102 mbkfree(ch->DATA);
1103 if (xydatamax)
1104 freechain (xydatamax);
1105 break;
1106 }
1107 if(xchain){
1108 for (ch = xchain; ch; ch = ch->NEXT){
1109 if(ch->DATA)
1110 mbkfree(ch->DATA);
1111 }
1112 freechain (xchain);
1113 }
1114 }
1115 | TLF4_TOKEN_NET_CAP_MODEL '(' modelname '(' TLF4_TOKEN_LINEAR TLF4_TOKEN_VALUE '(' segment_list ')' ')' ')'
1116 {
1117 modelmax = stm_addmodel(cname, $3);
1118 modelmax->UTYPE = STM_MOD_MODTBL;
1119 modelmax->UMODEL.TABLE = stm_prop_seg2tbl ($8, STM_LOAD);
1120 stm_storemodel (cname, $3, modelmax, 0);
1121 }
1122 ;
1123
1124 netresmodel : TLF4_TOKEN_NET_RES_MODEL '(' modelname '(' modelbody ')' ')'
1125 {
1126 modelmax = NULL;
1127 for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
1128 if (xydatamax && !xydatamin) {
1129 sprintf (namebuf, "%s", $3);
1130 modelmax = stm_addtblmodel (cname, namebuf, nx, 0, xtype, STM_NOTYPE);
1131 stm_storemodel (cname, namebuf, modelmax, 0);
1132 }
1133 if (xtype == STM_LOAD) {
1134 stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
1135 }
1136 switch (dimension) {
1137 case TLF_1D :
1138 stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
1139 for (ch = xydatamax; ch; ch = ch->NEXT)
1140 mbkfree(ch->DATA);
1141 if (xydatamax)
1142 freechain (xydatamax);
1143 break;
1144 }
1145 if(xchain){
1146 for (ch = xchain; ch; ch = ch->NEXT){
1147 if(ch->DATA)
1148 mbkfree(ch->DATA);
1149 }
1150 freechain (xchain);
1151 }
1152 }
1153 | TLF4_TOKEN_NET_RES_MODEL '(' modelname '(' TLF4_TOKEN_LINEAR TLF4_TOKEN_VALUE '(' segment_list ')' ')' ')'
1154 {
1155 modelmax = stm_addmodel(cname, $3);
1156 modelmax->UTYPE = STM_MOD_MODTBL;
1157 modelmax->UMODEL.TABLE = stm_prop_seg2tbl ($8, STM_LOAD);
1158 stm_storemodel (cname, $3, modelmax, 0);
1159
1160 }
1161 ;
1162
1163 model : TLF4_TOKEN_MODEL '(' modelname templatename '(' modelbody ')' ')'
1164 {
1165 if (!xydatamin && !xydatamax) {
1166 for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
1167 for (ny = 0, ch = ychain; ch; ch = ch->NEXT) ny++;
1168 ttemplate = stm_modtbl_addtemplate ($3, nx, ny, xtype, ytype);
1169 if (xtype == STM_INPUT_SLEW || xtype == STM_CLOCK_SLEW) {
1170 if (TLF_TIME_UNIT == TLF_NS)
1171 stm_modtbl_settemplateXrange (ttemplate, xchain, 1e3);
1172 if (TLF_TIME_UNIT == TLF_PS)
1173 stm_modtbl_settemplateXrange (ttemplate, xchain, 1);
1174 }
1175 if (xtype == STM_LOAD) {
1176 if (TLF_CAPA_UNIT == TLF_PF)
1177 stm_modtbl_settemplateXrange (ttemplate, xchain, 1e3);
1178 if (TLF_CAPA_UNIT == TLF_FF)
1179 stm_modtbl_settemplateXrange (ttemplate, xchain, 1);
1180 }
1181 if (ytype == STM_INPUT_SLEW || ytype == STM_CLOCK_SLEW) {
1182 if (TLF_TIME_UNIT == TLF_NS)
1183 stm_modtbl_settemplateYrange (ttemplate, ychain, 1e3);
1184 if (TLF_TIME_UNIT == TLF_PS)
1185 stm_modtbl_settemplateYrange (ttemplate, ychain, 1);
1186 }
1187 if (ytype == STM_LOAD) {
1188 if (TLF_CAPA_UNIT == TLF_PF)
1189 stm_modtbl_settemplateYrange (ttemplate, ychain, 1e3);
1190 if (TLF_CAPA_UNIT == TLF_FF)
1191 stm_modtbl_settemplateYrange (ttemplate, ychain, 1);
1192 }
1193 } else {
1194 modelmin = NULL;
1195 modelmax = NULL;
1196 if ($4) {
1197 ttemplate = stm_modtbl_gettemplate ($4);
1198 if (xydatamin) {
1199 sprintf (namebuf, "%s_min", $3);
1200 modelmin = stm_addmodel (cname, namebuf);
1201 modelmin->UMODEL.TABLE = stm_modtbl_create_ftemplate (ttemplate);
1202 modelmin->UTYPE = STM_MOD_MODTBL;
1203 stm_storemodel (cname, namebuf, modelmin, 0);
1204 addhtitem (doublemodels, namealloc ($3), 1);
1205 }
1206 if (xydatamax && xydatamin) {
1207 sprintf (namebuf, "%s_max", $3);
1208 modelmax = stm_addmodel (cname, namebuf);
1209 modelmax->UMODEL.TABLE = stm_modtbl_create_ftemplate (ttemplate);
1210 modelmax->UTYPE = STM_MOD_MODTBL;
1211 stm_storemodel (cname, namebuf, modelmax, 0);
1212 }
1213 if (xydatamax && !xydatamin) {
1214 sprintf (namebuf, "%s", $3);
1215 modelmax = stm_addmodel (cname, namebuf);
1216 modelmax->UMODEL.TABLE = stm_modtbl_create_ftemplate (ttemplate);
1217 modelmax->UTYPE = STM_MOD_MODTBL;
1218 stm_storemodel (cname, namebuf, modelmax, 0);
1219 }
1220 } else {
1221 for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
1222 for (ny = 0, ch = ychain; ch; ch = ch->NEXT) ny++;
1223 if (xydatamin) {
1224 addhtitem (doublemodels, namealloc ($3), 1);
1225 sprintf (namebuf, "%s_min", $3);
1226 modelmin = stm_addtblmodel (cname, namebuf, nx, ny, xtype, ytype);
1227 }
1228 if (xydatamax && xydatamin) {
1229 sprintf (namebuf, "%s_max", $3);
1230 modelmax = stm_addtblmodel (cname, namebuf, nx, ny, xtype, ytype);
1231 }
1232 if (xydatamax && !xydatamin) {
1233 sprintf (namebuf, "%s", $3);
1234 modelmax = stm_addtblmodel (cname, namebuf, nx, ny, xtype, ytype);
1235 }
1236 }
1237 if (xtype == STM_INPUT_SLEW || xtype == STM_CLOCK_SLEW) {
1238 if (TLF_TIME_UNIT == TLF_NS) {
1239 if (modelmin)
1240 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1e3);
1241 stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1e3);
1242 }
1243 if (TLF_TIME_UNIT == TLF_PS) {
1244 if (modelmin)
1245 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1);
1246 stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
1247 }
1248 }
1249 if (xtype == STM_LOAD) {
1250 if (TLF_CAPA_UNIT == TLF_PF) {
1251 if (modelmin)
1252 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1e3);
1253 stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1e3);
1254 }
1255 if (TLF_CAPA_UNIT == TLF_FF) {
1256 if (modelmin)
1257 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1);
1258 stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
1259 }
1260 }
1261 if (ytype == STM_INPUT_SLEW || ytype == STM_CLOCK_SLEW) {
1262 if (TLF_TIME_UNIT == TLF_NS) {
1263 if (modelmin)
1264 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1e3);
1265 stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1e3);
1266 }
1267 if (TLF_TIME_UNIT == TLF_PS) {
1268 if (modelmin)
1269 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1);
1270 stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1);
1271 }
1272 }
1273 if (ytype == STM_LOAD) {
1274 if (TLF_CAPA_UNIT == TLF_PF) {
1275 if (modelmin)
1276 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1e3);
1277 stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1e3);
1278 }
1279 if (TLF_CAPA_UNIT == TLF_FF) {
1280 if (modelmin)
1281 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1);
1282 stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1);
1283 }
1284 }
1285 switch (dimension) {
1286 case TLF_CONST :
1287 if (nx > 0 || ny > 0)
1288 avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
1289 else {
1290 if (TLF_TIME_UNIT == TLF_NS) {
1291 if (xydatamin)
1292 stm_modtbl_setconst (modelmin->UMODEL.TABLE, *(float*)xydatamin->DATA * 1e3);
1293 if (xydatamax)
1294 stm_modtbl_setconst (modelmax->UMODEL.TABLE, *(float*)xydatamax->DATA * 1e3);
1295 }
1296 if (TLF_TIME_UNIT == TLF_PS) {
1297 if (xydatamin)
1298 stm_modtbl_setconst (modelmin->UMODEL.TABLE, *(float*)xydatamin->DATA);
1299 if (xydatamax)
1300 stm_modtbl_setconst (modelmax->UMODEL.TABLE, *(float*)xydatamax->DATA);
1301 }
1302 if(xydatamin){
1303 if (xydatamin->DATA) {
1304 mbkfree(xydatamin->DATA);
1305 }
1306 freechain (xydatamin);
1307 }
1308 if(xydatamax){
1309 if (xydatamax->DATA) {
1310 mbkfree(xydatamax->DATA);
1311 }
1312 freechain (xydatamax);
1313 }
1314 }
1315 break;
1316 case TLF_1D :
1317 if (nx > 0 && ny > 0)
1318 avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
1319 else {
1320 if (TLF_TIME_UNIT == TLF_NS) {
1321 if (modelmin)
1322 stm_modtbl_set1Dset (modelmin->UMODEL.TABLE, xydatamin, 1e3);
1323 stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1e3);
1324 }
1325 if (TLF_TIME_UNIT == TLF_PS) {
1326 if (modelmin)
1327 stm_modtbl_set1Dset (modelmin->UMODEL.TABLE, xydatamin, 1);
1328 stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
1329 }
1330
1331 for (ch = xydatamin; ch; ch = ch->NEXT)
1332 mbkfree(ch->DATA);
1333 if (xydatamin)
1334 freechain (xydatamin);
1335
1336 for (ch = xydatamax; ch; ch = ch->NEXT)
1337 mbkfree(ch->DATA);
1338 if (xydatamax)
1339 freechain (xydatamax);
1340 }
1341 break;
1342 case TLF_2D :
1343 if (nx == 0 || ny == 0)
1344 avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
1345 else {
1346 if (TLF_TIME_UNIT == TLF_NS) {
1347 if (modelmin)
1348 stm_modtbl_set2Dset (modelmin->UMODEL.TABLE, xydatamin, 1e3);
1349 stm_modtbl_set2Dset (modelmax->UMODEL.TABLE, xydatamax, 1e3);
1350 }
1351 if (TLF_TIME_UNIT == TLF_PS) {
1352 if (modelmin)
1353 stm_modtbl_set2Dset (modelmin->UMODEL.TABLE, xydatamin, 1);
1354 stm_modtbl_set2Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
1355 }
1356 for (ch = xydatamin; ch; ch = ch->NEXT) {
1357 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1358 mbkfree(chp->DATA);
1359 freechain (ch->DATA);
1360 }
1361 if (xydatamin)
1362 freechain (xydatamin);
1363 for (ch = xydatamax; ch; ch = ch->NEXT) {
1364 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1365 mbkfree(chp->DATA);
1366 freechain (ch->DATA);
1367 }
1368 if (xydatamax)
1369 freechain (xydatamax);
1370 }
1371 break;
1372 }
1373 }
1374 if(xchain){
1375 for (ch = xchain; ch; ch = ch->NEXT){
1376 if(ch->DATA)
1377 mbkfree(ch->DATA);
1378 }
1379 freechain (xchain);
1380 }
1381 if(ychain){
1382 for (ch = ychain; ch; ch = ch->NEXT){
1383 if(ch->DATA)
1384 mbkfree(ch->DATA);
1385 }
1386 freechain (ychain);
1387 }
1388 }
1389 ;
1390
1391 modelbody : modeltype axe axe axe data
1392 {
1393 xchain = $2.CHAIN;
1394 xtype = $2.TYPE;
1395 ychain = $3.CHAIN;
1396 ytype = $3.TYPE;
1397 xydatamax = NULL;
1398 for (ch = $5.CHAIN; ch; ch = ch->NEXT) {
1399 ydatamax = NULL;
1400 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1401 ptfl = (float*)mbkalloc (sizeof (float));
1402 *ptfl = ((minmax*)chp->DATA)->MAX;
1403 ydatamax = addchain (ydatamax, ptfl);
1404 }
1405 ydatamax = reverse (ydatamax);
1406 xydatamax = addchain (xydatamax, ydatamax);
1407 }
1408 if (xydatamax)
1409 xydatamax = reverse (xydatamax);
1410
1411 xydatamin = NULL;
1412 if ($5.CHAIN) {
1413 if (((minmax*)(((chain_list*)($5.CHAIN->DATA))->DATA))->MIN != STM_NOVALUE) {
1414 for (ch = $5.CHAIN; ch; ch = ch->NEXT) {
1415 ydatamin = NULL;
1416 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1417 ptfl = (float*)mbkalloc (sizeof (float));
1418 *ptfl = ((minmax*)chp->DATA)->MIN;
1419 ydatamin = addchain (ydatamin, ptfl);
1420 }
1421 ydatamin = reverse (ydatamin);
1422 xydatamin = addchain (xydatamin, ydatamin);
1423 }
1424 xydatamin = reverse (xydatamin);
1425 }
1426 for (ch = $5.CHAIN; ch; ch = ch->NEXT) {
1427 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1428 mbkfree ((minmax*)chp->DATA);
1429 freechain ((chain_list*)ch->DATA);
1430 }
1431 //freechain ($5.CHAIN);
1432 }
1433 dimension = $5.DIM;
1434 }
1435 | modeltype axe axe data
1436 {
1437 xchain = $2.CHAIN;
1438 xtype = $2.TYPE;
1439 ychain = $3.CHAIN;
1440 ytype = $3.TYPE;
1441 xydatamax = NULL;
1442 for (ch = $4.CHAIN; ch; ch = ch->NEXT) {
1443 ydatamax = NULL;
1444 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1445 ptfl = (float*)mbkalloc (sizeof (float));
1446 *ptfl = ((minmax*)chp->DATA)->MAX;
1447 ydatamax = addchain (ydatamax, ptfl);
1448 }
1449 ydatamax = reverse (ydatamax);
1450 xydatamax = addchain (xydatamax, ydatamax);
1451 }
1452 if (xydatamax)
1453 xydatamax = reverse (xydatamax);
1454
1455 xydatamin = NULL;
1456 if ($4.CHAIN) {
1457 if (((minmax*)(((chain_list*)($4.CHAIN->DATA))->DATA))->MIN != STM_NOVALUE) {
1458 for (ch = $4.CHAIN; ch; ch = ch->NEXT) {
1459 ydatamin = NULL;
1460 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1461 ptfl = (float*)mbkalloc (sizeof (float));
1462 *ptfl = ((minmax*)chp->DATA)->MIN;
1463 ydatamin = addchain (ydatamin, ptfl);
1464 }
1465 ydatamin = reverse (ydatamin);
1466 xydatamin = addchain (xydatamin, ydatamin);
1467 }
1468 xydatamin = reverse (xydatamin);
1469 }
1470 for (ch = $4.CHAIN; ch; ch = ch->NEXT) {
1471 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1472 mbkfree ((minmax*)chp->DATA);
1473 freechain ((chain_list*)ch->DATA);
1474 }
1475 //freechain ($4.CHAIN);
1476 }
1477 dimension = $4.DIM;
1478 }
1479 | modeltype axe data
1480 {
1481 xchain = $2.CHAIN;
1482 xtype = $2.TYPE;
1483 ychain = NULL;
1484 ytype = STM_NOTYPE;
1485 xydatamax = NULL;
1486 for (ch = $3.CHAIN; ch; ch = ch->NEXT) {
1487 ptfl = (float*)mbkalloc (sizeof (float));
1488 *ptfl = ((minmax*)ch->DATA)->MAX;
1489 xydatamax = addchain (xydatamax, ptfl);
1490 }
1491 if (xydatamax)
1492 xydatamax = reverse (xydatamax);
1493 xydatamin = NULL;
1494 if ($3.CHAIN) {
1495 if (((minmax*)$3.CHAIN->DATA)->MIN != STM_NOVALUE) {
1496 for (ch = $3.CHAIN; ch; ch = ch->NEXT) {
1497 ptfl = (float*)mbkalloc (sizeof (float));
1498 *ptfl = ((minmax*)ch->DATA)->MIN;
1499 xydatamin = addchain (xydatamin, ptfl);
1500 }
1501 xydatamin = reverse (xydatamin);
1502 }
1503 for (ch = $3.CHAIN; ch; ch = ch->NEXT)
1504 mbkfree ((minmax*)ch->DATA);
1505 }
1506 dimension = $3.DIM;
1507 }
1508 | modeltype data
1509 {
1510 xchain = NULL;
1511 xtype = STM_NOTYPE;
1512 ychain = NULL;
1513 ytype = STM_NOTYPE;
1514 xydatamax = NULL;
1515 xydatamin = NULL;
1516 dimension = $2.DIM;
1517 switch(dimension){
1518 case TLF_1D:
1519 case TLF_CONST:
1520 xydatamax = NULL;
1521 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1522 ptfl = (float*)mbkalloc (sizeof (float));
1523 *ptfl = ((minmax*)ch->DATA)->MAX;
1524 xydatamax = addchain (xydatamax, ptfl);
1525 }
1526 if (xydatamax)
1527 xydatamax = reverse (xydatamax);
1528 xydatamin = NULL;
1529 if ($2.CHAIN) {
1530 if (((minmax*)$2.CHAIN->DATA)->MIN != STM_NOVALUE) {
1531 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1532 ptfl = (float*)mbkalloc (sizeof (float));
1533 *ptfl = ((minmax*)ch->DATA)->MIN;
1534 xydatamin = addchain (xydatamin, ptfl);
1535 }
1536 xydatamin = reverse (xydatamin);
1537 }
1538 for (ch = $2.CHAIN; ch; ch = ch->NEXT)
1539 mbkfree ((minmax*)ch->DATA);
1540 }
1541 break;
1542 case TLF_2D:
1543 xydatamax = NULL;
1544 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1545 ydatamax = NULL;
1546 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1547 ptfl = (float*)mbkalloc (sizeof (float));
1548 *ptfl = ((minmax*)chp->DATA)->MAX;
1549 ydatamax = addchain (ydatamax, ptfl);
1550 }
1551 ydatamax = reverse (ydatamax);
1552 xydatamax = addchain (xydatamax, ydatamax);
1553 }
1554 if (xydatamax)
1555 xydatamax = reverse (xydatamax);
1556
1557 xydatamin = NULL;
1558 if ($2.CHAIN) {
1559 if (((minmax*)(((chain_list*)($2.CHAIN->DATA))->DATA))->MIN != STM_NOVALUE) {
1560 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1561 ydatamin = NULL;
1562 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1563 ptfl = (float*)mbkalloc (sizeof (float));
1564 *ptfl = ((minmax*)chp->DATA)->MIN;
1565 ydatamin = addchain (ydatamin, ptfl);
1566 }
1567 ydatamin = reverse (ydatamin);
1568 xydatamin = addchain (xydatamin, ydatamin);
1569 }
1570 xydatamin = reverse (xydatamin);
1571 }
1572 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1573 for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1574 mbkfree ((minmax*)chp->DATA);
1575 freechain ((chain_list*)ch->DATA);
1576 }
1577 //freechain ($2.CHAIN);
1578 }
1579 break;
1580 }
1581 }
1582 ;
1583
1584 segment_list : empty
1585 {
1586 $$ = NULL;
1587 }
1588 | segment segment_list
1589 {
1590 ptseg = $1;
1591 $$ = addchain ($2, ptseg);
1592 }
1593 ;
1594
1595 segment : val ':' val ':' val ':' val
1596 {
1597 ptseg = (segment*)mbkalloc (sizeof (struct segment));
1598 ptseg->X0 = $1;
1599 ptseg->X1 = $3;
1600 ptseg->INTER = $5;
1601 ptseg->SLO = $7;
1602 $$ = ptseg;
1603 }
1604 ;
1605
1606 modeltype : TLF4_TOKEN_SPLINE
1607 | TLF4_TOKEN_CONST
1608 ;
1609
1610 axe : '(' axetype val val_list ')'
1611 {
1612 ptfl = (float*)mbkalloc (sizeof (float));
1613 *ptfl = $3;
1614 $$.CHAIN = addchain ($4, ptfl);
1615 $$.TYPE = $2;
1616 }
1617 ;
1618
1619
1620 axetype : TLF4_TOKEN_INPUT_SLEW_AXIS
1621 {
1622 $$ = STM_INPUT_SLEW;
1623 }
1624 | TLF4_TOKEN_CLOCK_SLEW_AXIS
1625 {
1626 $$ = STM_CLOCK_SLEW;
1627 }
1628 | TLF4_TOKEN_SLEW_AXIS
1629 {
1630 $$ = STM_INPUT_SLEW;
1631 }
1632 | TLF4_TOKEN_LOAD_AXIS
1633 {
1634 $$ = STM_LOAD;
1635 }
1636 | TLF4_TOKEN_LOAD2_AXIS
1637 {
1638 $$ = STM_LOAD;
1639 }
1640 ;
1641
1642 cval_list : empty
1643 {
1644 $$ = NULL;
1645 }
1646 | cval cval_list
1647 {
1648 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1649 ptmm->MIN = $1.MIN;
1650 ptmm->MAX = $1.MAX;
1651 $$ = addchain ($2, ptmm);
1652 }
1653 ;
1654
1655 val_list : empty
1656 {
1657 $$ = NULL;
1658 }
1659 | val val_list
1660 {
1661 ptfl = (float*)mbkalloc (sizeof (float));
1662 *ptfl = $1;
1663 $$ = addchain ($2, ptfl);
1664 }
1665 ;
1666
1667 data : TLF4_TOKEN_DATA '(' modeldata ')'
1668 {
1669 $$ = $3;
1670 }
1671 | '(' modeldata ')'
1672 {
1673 $$ = $2;
1674 }
1675 | TLF4_TOKEN_DATA modeldata
1676 {
1677 $$ = $2;
1678 }
1679 | modeldata
1680 {
1681 $$ = $1;
1682 }
1683 ;
1684
1685 modeldata : cval
1686 {
1687 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1688 ptmm->MIN = $1.MIN;
1689 ptmm->MAX = $1.MAX;
1690 $$.CHAIN = addchain (NULL, ptmm);
1691 $$.DIM = TLF_CONST;
1692 }
1693 | array1D
1694 {
1695 $$.CHAIN = $1;
1696 $$.DIM = TLF_1D;
1697 }
1698 | array2D
1699 {
1700 $$.CHAIN = $1;
1701 $$.DIM = TLF_2D;
1702 }
1703 | empty
1704 {
1705 $$.CHAIN = NULL;
1706 $$.DIM = TLF_NODIM;
1707 }
1708
1709 ;
1710
1711 array2D : array1D array1D array1D_list
1712 {
1713 $$ = addchain ($3, $2);
1714 $$ = addchain ($$, $1);
1715 }
1716 ;
1717
1718 array1D : '(' cval cval cval_list ')'
1719 {
1720 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1721 ptmm->MIN = $3.MIN;
1722 ptmm->MAX = $3.MAX;
1723 $$ = addchain ($4, ptmm);
1724 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1725 ptmm->MIN = $2.MIN;
1726 ptmm->MAX = $2.MAX;
1727 $$ = addchain ($$, ptmm);
1728 }
1729 ;
1730
1731 array1D_list : empty
1732 {
1733 $$ = NULL;
1734 }
1735 | array1D array1D_list
1736 {
1737 $$ = addchain ($2, $1);
1738 }
1739 ;
1740
1741 pin : TLF4_TOKEN_PIN '(' pinname
1742 {
1743 pname = $3;
1744 }
1745 pinprop_list ')'
1746 {
1747 int i=0;
1748 locon_list *c;
1749 losig_list *s;
1750
1751 ptfl = (float*)mbkalloc (sizeof (float));
1752 if (pincapa == TLF_NO_CAPA) {
1753 if (buscapa != TLF_NO_CAPA)
1754 *ptfl = buscapa;
1755 else{
1756 switch (pindir) {
1757 case 'I' :
1758 *ptfl = defincapa;
1759 break;
1760 case 'O' :
1761 *ptfl = defoutcapa;
1762 break;
1763 case 'B' :
1764 *ptfl = defbidircapa;
1765 break;
1766 default :
1767 *ptfl = 0.0;
1768 }
1769 }
1770 addhtitem (pincapht, pname, (long)ptfl);
1771 } else {
1772 *ptfl = pincapa;
1773 addhtitem (pincapht, pname, (long)ptfl);
1774 }
1775 switch (pindir) {
1776 case 'I' :
1777 dir = TTV_SIG_CI;
1778 break;
1779 case 'O' :
1780 if(ptrcbhcomb){
1781 if((ptrcbhcomb->HZFUNC) != NULL) {
1782 pindir = 'Z';
1783 dir = TTV_SIG_CZ ;
1784 }
1785 else
1786 dir = TTV_SIG_CO;
1787 }else
1788 dir = TTV_SIG_CO;
1789 break;
1790 case 'B' :
1791 if(ptrcbhcomb){
1792 if((ptrcbhcomb->HZFUNC) != NULL) {
1793 pindir = 'T';
1794 dir = TTV_SIG_CT ;
1795 }
1796 else
1797 dir = TTV_SIG_CB;
1798 }else
1799 dir = TTV_SIG_CB;
1800 break;
1801 default :
1802 dir = TTV_SIG_CX;
1803 }
1804 if((pindir != 'A') && !isglobalvdd(pname) && !isglobalvss(pname)){
1805 consigchain = ttv_addrefsig (fig, pname, pname, *ptfl, dir, consigchain);
1806 nbconsig++;
1807 if (clockpin)
1808 clocks = addchain (clocks, pname);
1809 }
1810 if((pindir != 'X') && (!flagbus)){
1811 /* nouveau connecteur --> LOCON et LOSIG a creer */
1812 for(c=ptrlofig->LOCON; ((c != NULL) && (c->NAME != ttv_devect(pname))); c=c->NEXT);
1813 if(c == NULL) { /* connecteur inexistant, on ajoute signal et connecteur */
1814 for(s=ptrlofig->LOSIG; (s != NULL); s=s->NEXT) {/* recherche du 1er index de libre */
1815 if (i < s->INDEX)
1816 i = s->INDEX;
1817 }
1818 losig_index = i + 1;
1819 ptrlosig = addlosig(ptrlofig, losig_index, addchain(NULL, ttv_devect(pname)), 'E');
1820 // if(!flagbus)
1821 ptrlocon = addlocon(ptrlofig, ttv_devect(pname), ptrlosig, pindir);
1822 // else{
1823 // ptloconbus = (loconbus*)mbkalloc (sizeof (struct loconbus));
1824 // ptloconbus->NAME = ttv_devect(pname);
1825 // ptloconbus->LOSIG = ptrlosig;
1826 // ptloconbus->DIREC = pindir;
1827 // buschain = addchain(buschain, ptloconbus);
1828 // }
1829 }
1830 else { /* connecteur et signal existants, on redirige le connecteur */
1831 ptrlocon = c;
1832 ptrlocon->DIRECTION = pindir;
1833 }
1834
1835 if(/*!flagbus && */ptrcbhcomb)
1836 cbh_addcombtolocon(ptrlocon, ptrcbhcomb);
1837 }
1838 // if(!flagbus){
1839 ptrcbhcomb = NULL;
1840 ptrlosig = NULL;
1841 ptrlocon = NULL;
1842 // }
1843 pincapa = TLF_NO_CAPA;
1844 pindir = 'X';
1845 clockpin = 0;
1846 }
1847 | TLF4_TOKEN_BUS '(' busname bustype busprops {/* buschain = NULL;*/ flagbus = 1;} pin_list ')'
1848 {
1849 locon_list *c;
1850 losig_list *s;
1851 int n = 0;
1852 char buf[1024];
1853
1854 if(l > m)
1855 for(i = l; i >= m; i--){
1856 sprintf(buf, "%s %d", bname, i);
1857 for(c=ptrlofig->LOCON; ((c != NULL) && (c->NAME != namealloc(buf))); c=c->NEXT);
1858 if(c == NULL) { /* connecteur inexistant, on ajoute signal et connecteur */
1859 for(s=ptrlofig->LOSIG; (s != NULL); s=s->NEXT) {/* recherche du 1er index de libre */
1860 if (n < s->INDEX)
1861 n = s->INDEX;
1862 }
1863 losig_index = n + 1;
1864 ptrlosig = addlosig(ptrlofig, losig_index, addchain(NULL, namealloc(buf)), 'E');
1865 ptrlocon = addlocon(ptrlofig, namealloc(buf), ptrlosig, pindir);
1866 }
1867 }
1868 else if(l < m)
1869 for(i = l; i <= m; i++){
1870 sprintf(buf, "%s %d", bname, i);
1871 for(c=ptrlofig->LOCON; ((c != NULL) && (c->NAME != namealloc(buf))); c=c->NEXT);
1872 if(c == NULL) { /* connecteur inexistant, on ajoute signal et connecteur */
1873 for(s=ptrlofig->LOSIG; (s != NULL); s=s->NEXT) {/* recherche du 1er index de libre */
1874 if (n < s->INDEX)
1875 n = s->INDEX;
1876 }
1877 losig_index = n + 1;
1878 ptrlosig = addlosig(ptrlofig, losig_index, addchain(NULL, namealloc(buf)), 'E');
1879 ptrlocon = addlocon(ptrlofig, namealloc(buf), ptrlosig, pindir);
1880 }
1881 }
1882 flagbus = 0;
1883 // if(buschain)
1884 // if(l != vectorindex(((loconbus*)buschain->DATA)->NAME))
1885 // reverse(buschain);
1886 // for(chain=buschain; chain; chain=chain->NEXT){
1887 // ptloconbus = (loconbus*)chain->DATA;
1888 // ptrlocon = addlocon(ptrlofig, ptloconbus->NAME, ptloconbus->LOSIG, ptloconbus->DIREC);
1889 // cbh_addcombtolocon(ptrlocon, ptrcbhcomb);
1890 // mbkfree(chain->DATA) ;
1891 // }
1892 // if(buschain)
1893 // freechain(buschain);
1894 for (i = lsb; i <= msb; i++) {
1895 pt = stm_vect (bname, i);
1896 vectname = namealloc (pt);
1897 mbkfree(pt);
1898 if(i == msb)
1899 mbkfree(bname);
1900 for(ch = consigchain; ch; ch = ch->NEXT)
1901 if(!strcmp(vectname, ((ttvsig_list*)ch->DATA)->NAME)){
1902 break;
1903 }
1904 if(ch)
1905 continue;
1906 ptfl = (float*)mbkalloc (sizeof (float));
1907 if (buscapa != TLF_NO_CAPA)
1908 *ptfl = buscapa;
1909 else
1910 if (caparray[i - lsb] != TLF_NO_CAPA)
1911 *ptfl = caparray[i - lsb];
1912 else
1913 switch ($4) {
1914 case 'I' :
1915 *ptfl = defincapa;
1916 break;
1917 case 'O' :
1918 *ptfl = defoutcapa;
1919 break;
1920 case 'B' :
1921 *ptfl = defbidircapa;
1922 break;
1923 default :
1924 *ptfl = 0.0;
1925 }
1926 addhtitem (pincapht, vectname, (long)ptfl);
1927 switch ($4) {
1928 case 'I' :
1929 dir = TTV_SIG_CI;
1930 break;
1931 case 'O' :
1932 dir = TTV_SIG_CO;
1933 break;
1934 case 'B' :
1935 dir = TTV_SIG_CB;
1936 break;
1937 default :
1938 dir = TTV_SIG_CX;
1939 }
1940 consigchain = ttv_addrefsig (fig, vectname, vectname, *ptfl, dir, consigchain);
1941 nbconsig++;
1942 if (clockpin)
1943 clocks = addchain (clocks, vectname);
1944 }
1945 mbkfree(caparray);
1946 buscapa = TLF_NO_CAPA;
1947 pindir = 'X';
1948 clockpin = 0;
1949 }
1950 | TLF4_TOKEN_PIN '(' busname pintype busprops ')'
1951 {
1952 for (i = lsb; i <= msb; i++) {
1953 pt = stm_vect (bname, i);
1954 vectname = namealloc (pt);
1955 mbkfree(pt);
1956 if(i == msb)
1957 mbkfree(bname);
1958 ptfl = (float*)mbkalloc (sizeof (float));
1959
1960 if (pincapa == TLF_NO_CAPA) {
1961 if (buscapa != TLF_NO_CAPA)
1962 *ptfl = buscapa;
1963 else{
1964 switch (pindir) {
1965 case 'I' :
1966 *ptfl = defincapa;
1967 break;
1968 case 'O' :
1969 *ptfl = defoutcapa;
1970 break;
1971 case 'B' :
1972 *ptfl = defbidircapa;
1973 break;
1974 default :
1975 *ptfl = 0.0;
1976 }
1977 }
1978 addhtitem (pincapht, vectname, (long)ptfl);
1979 } else {
1980 *ptfl = caparray[i - lsb];
1981 addhtitem (pincapht, vectname, (long)ptfl);
1982 }
1983 switch (pindir) {
1984 case 'I' :
1985 dir = TTV_SIG_CI;
1986 break;
1987 case 'O' :
1988 dir = TTV_SIG_CO;
1989 break;
1990 case 'B' :
1991 dir = TTV_SIG_CB;
1992 break;
1993 default :
1994 dir = TTV_SIG_CX;
1995 }
1996 consigchain = ttv_addrefsig (fig, vectname, vectname, *ptfl, dir, consigchain);
1997 nbconsig++;
1998 if (clockpin)
1999 clocks = addchain (clocks, vectname);
2000 }
2001 mbkfree(caparray);
2002 pindir = 'X';
2003 clockpin = 0;
2004 }
2005 ;
2006
2007 bustype : pintype
2008 {
2009 $$ = $1;
2010 }
2011 ;
2012
2013 pintype : TLF4_TOKEN_PINTYPE '(' TLF4_TOKEN_BIDIR ')'
2014 {
2015 $$ = 'B';
2016 }
2017 | TLF4_TOKEN_PINTYPE '(' TLF4_TOKEN_INPUT ')'
2018 {
2019 $$ = 'I';
2020 }
2021 | TLF4_TOKEN_PINTYPE '(' TLF4_TOKEN_SUPPLY ')'
2022 {
2023 $$ = 'A';
2024 }
2025 | TLF4_TOKEN_PINTYPE '(' TLF4_TOKEN_GROUND ')'
2026 {
2027 $$ = 'A';
2028 }
2029 | TLF4_TOKEN_PINTYPE '(' TLF4_TOKEN_INTERNAL ')'
2030 {
2031 $$ = 'X';
2032 }
2033 | TLF4_TOKEN_PINTYPE '(' TLF4_TOKEN_OUTPUT ')'
2034 {
2035 $$ = 'O';
2036 }
2037 ;
2038
2039 pinprop_list : empty
2040 | pinprop_list pinprop
2041 ;
2042
2043 pinprop : pincap
2044 {
2045 pincapa = $1;
2046 }
2047 | energy
2048 {
2049 }
2050 | vdrop_limit
2051 {
2052 }
2053 | pintype
2054 {
2055 pindir = $1;
2056 if((pindir == 'O') || (pindir == 'B')){
2057 ptrcbhcomb = cbh_newcomb();
2058 ptrcbhcomb->NAME = namealloc(pname);
2059 }
2060 }
2061 | TLF4_TOKEN_CLOCK_PIN
2062 {
2063 clockpin = 1;
2064 }
2065 | pinfunc
2066 {
2067 }
2068 | pinenable
2069 {
2070 }
2071 | attribute
2072 {
2073 }
2074 | directive
2075 {
2076 }
2077 ;
2078
2079 pinenable : TLF4_TOKEN_ENABLE TLF4_TOKEN_EXPR
2080 {
2081 char *str;
2082 if(ptrcbhcomb != NULL) {
2083 str = eqt_ConvertStr($2);
2084 ptrcbhcomb->HZFUNC = notExpr(eqt_StrToAbl(tlfEqtCtx,str));
2085 mbkfree (str);
2086 }
2087 }
2088 ;
2089
2090 pinfunc : TLF4_TOKEN_FUNCTION TLF4_TOKEN_EXPR
2091 {
2092 char *str;
2093 if(ptrcbhcomb != NULL) {
2094 str = eqt_ConvertStr($2);
2095 ptrcbhcomb->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
2096 mbkfree (str);
2097 }
2098 }
2099 ;
2100
2101
2102 rise : TLF4_TOKEN_RISE '(' modelname ')'
2103 | TLF4_TOKEN_RISE '(' modelbody ')'
2104 |
2105 ;
2106
2107 fall : TLF4_TOKEN_FALL '(' modelname ')'
2108 | TLF4_TOKEN_FALL '(' modelbody ')'
2109 | empty
2110 ;
2111
2112 busprops : empty
2113 | forbits_list
2114 {
2115 }
2116 | pincap
2117 {
2118 buscapa = $1;
2119 }
2120 | TLF4_TOKEN_CLOCK_PIN
2121 {
2122 clockpin = 1;
2123 }
2124 ;
2125
2126 pin_list : empty
2127 | pin_list pin
2128 ;
2129
2130 forbits_list : forbits
2131 | forbits_list forbits
2132 ;
2133
2134 forbits : TLF4_TOKEN_FOR_BITS '(' TLF4_TOKEN_VECT pincap ')'
2135 {
2136 v = atoi (stm_unquote ($3));
2137 mbkfree($3);
2138 if (v <= msb && v >= lsb)
2139 caparray[v - lsb] = $4;
2140 }
2141 ;
2142
2143 pincap : TLF4_TOKEN_CAPACITANCE '(' val ')'
2144 {
2145 if (TLF_CAPA_UNIT == TLF_PF)
2146 $$ = $3 * 1e3;
2147 if (TLF_CAPA_UNIT == TLF_FF)
2148 $$ = $3;
2149 }
2150 ;
2151
2152 arc_list : empty
2153 | arc_list arc
2154 ;
2155
2156 arc : path
2157 | setup
2158 | hold
2159 ;
2160
2161 speed : TLF4_TOKEN_FAST
2162 | TLF4_TOKEN_SLOW
2163 | empty
2164 ;
2165
2166 path : TLF4_TOKEN_PATH '(' pinname "=>" pinname speed transition transition delay slew energy_list ')'
2167 {
2168 if ($7 != 'X' && $8 != 'X') {
2169 pinn = $3;
2170 pinr = $5;
2171 mindlymname = $9.MIN ? $9.MIN : $9.MAX;
2172 minslwmname = $10.MIN ? $10.MIN : $10.MAX;
2173 maxdlymname = $9.MAX;
2174 maxslwmname = $10.MAX;
2175 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2176 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2177 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
2178 if (isclockpin (clocks, pinn))
2179 linetype = TTV_LINE_A;
2180 else
2181 linetype = 0;
2182 if ($7 == 'U') {
2183 node = &signode->NODE[1];
2184 itype = elpRISE;
2185 }
2186 else if ($7 == 'D') {
2187 node = &signode->NODE[0];
2188 itype = elpFALL;
2189 }
2190 if ($8 == 'U') {
2191 root = &sigroot->NODE[1];
2192 otype = elpRISE;
2193 }
2194 else if ($8 == 'D') {
2195 root = &sigroot->NODE[0];
2196 otype = elpFALL;
2197 }
2198 else if ($8 == 'u') {
2199 root = &sigroot->NODE[1];
2200 otype = elpRISE;
2201 linetype |= TTV_LINE_HZ;
2202 }
2203 else if ($8 == 'd') {
2204 root = &sigroot->NODE[0];
2205 otype = elpFALL;
2206 linetype |= TTV_LINE_HZ;
2207 }
2208
2209 delaymodelmax = stm_getmodel (cname, maxdlymname);
2210 if(gethtitem(modshrinkht, maxdlymname) == EMPTYHT){
2211 if (itype == elpRISE)
2212 stm_mod_shrinkslewaxis (delaymodelmax, risethmin, risethmax, itype);
2213 else
2214 stm_mod_shrinkslewaxis (delaymodelmax, fallthmin, fallthmax, itype);
2215 addhtitem (modshrinkht, maxdlymname, (long)delaymodelmax);
2216 }
2217
2218
2219 slewmodelmax = stm_getmodel (cname, maxslwmname);
2220 if(gethtitem(modshrinkht, maxslwmname) == EMPTYHT){
2221 if (itype == elpRISE)
2222 stm_mod_shrinkslewaxis (slewmodelmax, risethmin, risethmax, itype);
2223 else
2224 stm_mod_shrinkslewaxis (slewmodelmax, fallthmin, fallthmax, itype);
2225 if (otype == elpRISE)
2226 stm_mod_shrinkslewdata (slewmodelmax, risethmin, risethmax, otype);
2227 else
2228 stm_mod_shrinkslewdata (slewmodelmax, fallthmin, fallthmax, otype);
2229 addhtitem (modshrinkht, maxslwmname, (long)slewmodelmax);
2230 }
2231
2232 delaymodelmin = stm_getmodel (cname, mindlymname);
2233 if(gethtitem(modshrinkht, mindlymname) == EMPTYHT){
2234 if (itype == elpRISE)
2235 stm_mod_shrinkslewaxis (delaymodelmin, risethmin, risethmax, itype);
2236 else
2237 stm_mod_shrinkslewaxis (delaymodelmin, fallthmin, fallthmax, itype);
2238 addhtitem (modshrinkht, mindlymname, (long)delaymodelmin);
2239 }
2240
2241 slewmodelmin = stm_getmodel (cname, minslwmname);
2242 if(gethtitem(modshrinkht, minslwmname) == EMPTYHT){
2243 if (itype == elpRISE)
2244 stm_mod_shrinkslewaxis (slewmodelmin, risethmin, risethmax, itype);
2245 else
2246 stm_mod_shrinkslewaxis (slewmodelmin, fallthmin, fallthmax, itype);
2247 if (otype == elpRISE)
2248 stm_mod_shrinkslewdata (slewmodelmin, risethmin, risethmax, otype);
2249 else
2250 stm_mod_shrinkslewdata (slewmodelmin, fallthmin, fallthmax, otype);
2251 addhtitem (modshrinkht, minslwmname, (long)slewmodelmin);
2252 }
2253
2254 if ($8 == 'D') {
2255 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2256 stm_mod_update(slewmodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2257 stm_mod_update(delaymodelmin, voltage/2.0, voltage, voltage/5.0, 0.0);
2258 stm_mod_update(slewmodelmin, voltage/2.0, voltage, voltage/5.0, 0.0);
2259 }else{
2260 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2261 stm_mod_update(slewmodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2262 stm_mod_update(delaymodelmin, voltage/2.0, voltage, voltage/5.0, voltage);
2263 stm_mod_update(slewmodelmin, voltage/2.0, voltage, voltage/5.0, voltage);
2264 }
2265
2266 capa = gethtitem (pincapht, pinr);
2267 if (capa != EMPTYHT) {
2268 slwmin = stm_mod_slew (slewmodelmin, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2269 dlymin = stm_mod_delay (delaymodelmin, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2270 slwmax = stm_mod_slew (slewmodelmax, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2271 dlymax = stm_mod_delay (delaymodelmax, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2272 } else {
2273 slwmin = stm_mod_slew (slewmodelmin, STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2274 dlymin = stm_mod_delay (delaymodelmin, STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2275 slwmax = stm_mod_slew (slewmodelmax, STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2276 dlymax = stm_mod_delay (delaymodelmax, STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2277 }
2278 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_T | linetype);
2279 ttv_addcaracline (line, maxdlymname,
2280 mindlymname,
2281 maxslwmname,
2282 minslwmname);
2283 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_D | linetype);
2284 ttv_addcaracline (line, maxdlymname,
2285 mindlymname,
2286 maxslwmname,
2287 minslwmname);
2288 }
2289 }
2290 }
2291 | TLF4_TOKEN_PATH '(' pinname "*>" busname speed transition transition delay slew energy_list ')'
2292 {
2293 if ($7 != 'X' && $8 != 'X') {
2294 for(i = lsb; i <= msb; i++){
2295 pinn = $3;
2296 pt = stm_vect (bname, i);
2297 pinr = namealloc (pt);
2298 mbkfree(pt);
2299 if(i == msb)
2300 mbkfree(bname);
2301 mindlymname = $9.MIN ? $9.MIN : $9.MAX;
2302 minslwmname = $10.MIN ? $10.MIN : $10.MAX;
2303 maxdlymname = $9.MAX;
2304 maxslwmname = $10.MAX;
2305 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2306 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2307 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
2308 if (isclockpin (clocks, pinn))
2309 linetype = TTV_LINE_A;
2310 else
2311 linetype = 0;
2312 if ($7 == 'U') {
2313 node = &signode->NODE[1];
2314 itype = elpRISE;
2315 }
2316 else if ($7 == 'D') {
2317 node = &signode->NODE[0];
2318 itype = elpFALL;
2319 }
2320 if ($8 == 'U') {
2321 root = &sigroot->NODE[1];
2322 otype = elpRISE;
2323 }
2324 else if ($8 == 'D') {
2325 root = &sigroot->NODE[0];
2326 otype = elpFALL;
2327 }
2328 else if ($8 == 'u') {
2329 root = &sigroot->NODE[1];
2330 otype = elpRISE;
2331 linetype |= TTV_LINE_HZ;
2332 }
2333 else if ($8 == 'd') {
2334 root = &sigroot->NODE[0];
2335 otype = elpFALL;
2336 linetype |= TTV_LINE_HZ;
2337 }
2338
2339 delaymodelmax = stm_getmodel (cname, maxdlymname);
2340 if(gethtitem(modshrinkht, maxdlymname) == EMPTYHT){
2341 if (itype == elpRISE)
2342 stm_mod_shrinkslewaxis (delaymodelmax, risethmin, risethmax, itype);
2343 else
2344 stm_mod_shrinkslewaxis (delaymodelmax, fallthmin, fallthmax, itype);
2345 addhtitem (modshrinkht, maxdlymname, (long)delaymodelmax);
2346 }
2347
2348
2349 slewmodelmax = stm_getmodel (cname, maxslwmname);
2350 if(gethtitem(modshrinkht, maxslwmname) == EMPTYHT){
2351 if (itype == elpRISE)
2352 stm_mod_shrinkslewaxis (slewmodelmax, risethmin, risethmax, itype);
2353 else
2354 stm_mod_shrinkslewaxis (slewmodelmax, fallthmin, fallthmax, itype);
2355 if (otype == elpRISE)
2356 stm_mod_shrinkslewdata (slewmodelmax, risethmin, risethmax, otype);
2357 else
2358 stm_mod_shrinkslewdata (slewmodelmax, fallthmin, fallthmax, otype);
2359 addhtitem (modshrinkht, maxslwmname, (long)slewmodelmax);
2360 }
2361
2362 delaymodelmin = stm_getmodel (cname, mindlymname);
2363 if(gethtitem(modshrinkht, mindlymname) == EMPTYHT){
2364 if (itype == elpRISE)
2365 stm_mod_shrinkslewaxis (delaymodelmin, risethmin, risethmax, itype);
2366 else
2367 stm_mod_shrinkslewaxis (delaymodelmin, fallthmin, fallthmax, itype);
2368 addhtitem (modshrinkht, mindlymname, (long)delaymodelmin);
2369 }
2370
2371 slewmodelmin = stm_getmodel (cname, minslwmname);
2372 if(gethtitem(modshrinkht, minslwmname) == EMPTYHT){
2373 if (itype == elpRISE)
2374 stm_mod_shrinkslewaxis (slewmodelmin, risethmin, risethmax, itype);
2375 else
2376 stm_mod_shrinkslewaxis (slewmodelmin, fallthmin, fallthmax, itype);
2377 if (otype == elpRISE)
2378 stm_mod_shrinkslewdata (slewmodelmin, risethmin, risethmax, otype);
2379 else
2380 stm_mod_shrinkslewdata (slewmodelmin, fallthmin, fallthmax, otype);
2381 addhtitem (modshrinkht, minslwmname, (long)slewmodelmin);
2382 }
2383
2384 if ($8 == 'D') {
2385 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2386 stm_mod_update(slewmodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2387 stm_mod_update(delaymodelmin, voltage/2.0, voltage, voltage/5.0, 0.0);
2388 stm_mod_update(slewmodelmin, voltage/2.0, voltage, voltage/5.0, 0.0);
2389 }else{
2390 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2391 stm_mod_update(slewmodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2392 stm_mod_update(delaymodelmin, voltage/2.0, voltage, voltage/5.0, voltage);
2393 stm_mod_update(slewmodelmin, voltage/2.0, voltage, voltage/5.0, voltage);
2394 }
2395
2396 capa = gethtitem (pincapht, pinr);
2397 if (capa != EMPTYHT) {
2398 slwmin = stm_mod_slew (slewmodelmin, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2399 dlymin = stm_mod_delay (delaymodelmin, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2400 slwmax = stm_mod_slew (slewmodelmax, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2401 dlymax = stm_mod_delay (delaymodelmax, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2402 } else {
2403 slwmin = stm_mod_slew (slewmodelmin, STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2404 dlymin = stm_mod_delay (delaymodelmin, STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2405 slwmax = stm_mod_slew (slewmodelmax, STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
2406 dlymax = stm_mod_delay (delaymodelmax, STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
2407 }
2408 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_T | linetype);
2409 ttv_addcaracline (line, maxdlymname,
2410 mindlymname,
2411 maxslwmname,
2412 minslwmname);
2413 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_D | linetype);
2414 ttv_addcaracline (line, maxdlymname,
2415 mindlymname,
2416 maxslwmname,
2417 minslwmname);
2418 }
2419 }
2420 }
2421 mbkfree(caparray);
2422 }
2423 | TLF4_TOKEN_PATH '(' pinname "=>" pinname speed transition transition constdelay constslew energy_list ')'
2424 {
2425 if ($7 != 'X' && $8 != 'X') {
2426 pinn = $3;
2427 pinr = $5;
2428 dlymin = $9.MIN != STM_NOVALUE ? $9.MIN : $9.MAX;
2429 slwmin = $10.MIN != STM_NOVALUE ? $10.MIN : $10.MAX;
2430 dlymax = $9.MAX;
2431 slwmax = $10.MAX;
2432 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2433 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2434 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2435 if (isclockpin (clocks, pinn))
2436 linetype = TTV_LINE_A;
2437 else
2438 linetype = 0;
2439 if ($8 == 'U'){
2440 root = &sigroot->NODE[1];
2441 }else if ($8 == 'D'){
2442 root = &sigroot->NODE[0];
2443 }else if ($8 == 'u'){
2444 root = &sigroot->NODE[1];
2445 linetype |= TTV_LINE_HZ;
2446 }else if ($8 == 'd'){
2447 root = &sigroot->NODE[0];
2448 linetype |= TTV_LINE_HZ;
2449 }
2450 if ($7 == 'U')
2451 node = &signode->NODE[1];
2452 else if ($7 == 'D')
2453 node = &signode->NODE[0];
2454 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_T | linetype);
2455 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_D | linetype);
2456 }
2457 }
2458 }
2459 | TLF4_TOKEN_PATH '(' pinname "*>" busname speed transition transition constdelay constslew energy_list ')'
2460 {
2461 if ($7 != 'X' && $8 != 'X') {
2462 for(i = lsb; i <= msb; i++){
2463 pinn = $3;
2464 pt = stm_vect (bname, i);
2465 pinr = namealloc (pt);
2466 mbkfree(pt);
2467 if(i == msb)
2468 mbkfree(bname);
2469 dlymin = $9.MIN != STM_NOVALUE ? $9.MIN : $9.MAX;
2470 slwmin = $10.MIN != STM_NOVALUE ? $10.MIN : $10.MAX;
2471 dlymax = $9.MAX;
2472 slwmax = $10.MAX;
2473 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2474 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2475 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2476 if (isclockpin (clocks, pinn))
2477 linetype = TTV_LINE_A;
2478 else
2479 linetype = 0;
2480 if ($8 == 'U'){
2481 root = &sigroot->NODE[1];
2482 }else if ($8 == 'D'){
2483 root = &sigroot->NODE[0];
2484 }else if ($8 == 'u'){
2485 root = &sigroot->NODE[1];
2486 linetype |= TTV_LINE_HZ;
2487 }else if ($8 == 'd'){
2488 root = &sigroot->NODE[0];
2489 linetype |= TTV_LINE_HZ;
2490 }
2491 if ($7 == 'U')
2492 node = &signode->NODE[1];
2493 else if ($7 == 'D')
2494 node = &signode->NODE[0];
2495 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_T | linetype);
2496 line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_D | linetype);
2497 }
2498 }
2499 }
2500 mbkfree(caparray);
2501 }
2502 | TLF4_TOKEN_PATH '(' pinname "=>" pinname speed transition transition energy ')'
2503 {
2504 }
2505 | TLF4_TOKEN_PATH '(' pinname "*>" busname speed transition transition energy ')'
2506 {
2507 mbkfree(caparray);
2508 }
2509 ;
2510
2511 setup : TLF4_TOKEN_SETUP '(' pinname "=>" pinname transition transition constraint ')'
2512 {
2513 if ($6 != 'X' && $7 != 'X') {
2514 pinn = $3;
2515 pinr = $5;
2516 maxdlymname = $8.MAX;
2517 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2518 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2519 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2520 if ($7 == 'U')
2521 root = &sigroot->NODE[1];
2522 if ($7 == 'D')
2523 root = &sigroot->NODE[0];
2524 if ($6 == 'U') {
2525 node = &signode->NODE[1];
2526 itype = elpRISE;
2527 }
2528 if ($6 == 'D') {
2529 node = &signode->NODE[0];
2530 itype = elpFALL;
2531 }
2532 delaymodelmax = stm_getmodel (cname, maxdlymname);
2533 if(gethtitem(modshrinkht, maxdlymname) == EMPTYHT){
2534 if (itype == elpRISE)
2535 stm_mod_shrinkslewaxis (delaymodelmax, risethmin, risethmax, itype);
2536 else
2537 stm_mod_shrinkslewaxis (delaymodelmax, fallthmin, fallthmax, itype);
2538 addhtitem (modshrinkht, maxdlymname, (long)delaymodelmax);
2539 }
2540 if (!delaymodelmax)
2541 printf ("no model %s\n", maxdlymname);
2542 maxcstr = stm_mod_constraint (delaymodelmax, STM_DEF_SLEW, STM_DEF_SLEW);
2543 if (itype == elpFALL) {
2544 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2545 }else{
2546 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2547 }
2548 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_U);
2549 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2550 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_U);
2551 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2552 }
2553 }
2554 }
2555 | TLF4_TOKEN_SETUP '(' busname "*>" pinname transition transition constraint ')'
2556 {
2557 if ($6 != 'X' && $7 != 'X') {
2558 for(i = lsb; i <= msb; i++){
2559 pt = stm_vect (bname, i);
2560 pinn = namealloc (pt);
2561 mbkfree(pt);
2562 if(i == msb)
2563 mbkfree(bname);
2564 pinr = $5;
2565 maxdlymname = $8.MAX;
2566 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2567 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2568 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2569 if ($7 == 'U')
2570 root = &sigroot->NODE[1];
2571 if ($7 == 'D')
2572 root = &sigroot->NODE[0];
2573 if ($6 == 'U') {
2574 node = &signode->NODE[1];
2575 itype = elpRISE;
2576 }
2577 if ($6 == 'D') {
2578 node = &signode->NODE[0];
2579 itype = elpFALL;
2580 }
2581 delaymodelmax = stm_getmodel (cname, maxdlymname);
2582 if(gethtitem(modshrinkht, maxdlymname) == EMPTYHT){
2583 if (itype == elpRISE)
2584 stm_mod_shrinkslewaxis (delaymodelmax, risethmin, risethmax, itype);
2585 else
2586 stm_mod_shrinkslewaxis (delaymodelmax, fallthmin, fallthmax, itype);
2587 addhtitem (modshrinkht, maxdlymname, (long)delaymodelmax);
2588 }
2589 if (!delaymodelmax)
2590 printf ("no model %s\n", maxdlymname);
2591 maxcstr = stm_mod_constraint (delaymodelmax, STM_DEF_SLEW, STM_DEF_SLEW);
2592 if (itype == elpFALL) {
2593 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2594 }else{
2595 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2596 }
2597 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_U);
2598 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2599 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_U);
2600 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2601 }
2602 }
2603 }
2604 mbkfree(caparray);
2605 }
2606 | TLF4_TOKEN_SETUP '(' pinname "=>" pinname transition transition constant ')'
2607 {
2608 if ($6 != 'X' && $7 != 'X') {
2609 pinn = $3;
2610 pinr = $5;
2611 maxcstr = $8.MAX;
2612 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2613 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2614 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2615 if ($7 == 'U')
2616 root = &sigroot->NODE[1];
2617 if ($7 == 'D')
2618 root = &sigroot->NODE[0];
2619 if ($6 == 'U')
2620 node = &signode->NODE[1];
2621 if ($6 == 'D')
2622 node = &signode->NODE[0];
2623 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_U);
2624 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_U);
2625 }
2626 }
2627 }
2628 | TLF4_TOKEN_SETUP '(' busname "*>" pinname transition transition constant ')'
2629 {
2630 if ($6 != 'X' && $7 != 'X') {
2631 for(i = lsb; i <= msb; i++){
2632 pt = stm_vect (bname, i);
2633 pinn = namealloc (pt);
2634 mbkfree(pt);
2635 if(i == msb)
2636 mbkfree(bname);
2637 pinr = $5;
2638 maxcstr = $8.MAX;
2639 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2640 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2641 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2642 if ($7 == 'U')
2643 root = &sigroot->NODE[1];
2644 if ($7 == 'D')
2645 root = &sigroot->NODE[0];
2646 if ($6 == 'U')
2647 node = &signode->NODE[1];
2648 if ($6 == 'D')
2649 node = &signode->NODE[0];
2650 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_U);
2651 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_U);
2652 }
2653 }
2654 }
2655 mbkfree(caparray);
2656 }
2657 ;
2658
2659 hold : TLF4_TOKEN_HOLD '(' pinname "=>" pinname transition transition constraint ')'
2660 {
2661 if ($6 != 'X' && $7 != 'X') {
2662 pinr = $5;
2663 pinn = $3;
2664 maxdlymname = $8.MAX;
2665 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2666 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2667 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2668 if ($7 == 'U')
2669 root = &sigroot->NODE[1];
2670 if ($7 == 'D')
2671 root = &sigroot->NODE[0];
2672 if ($6 == 'U') {
2673 node = &signode->NODE[1];
2674 itype = elpRISE;
2675 }
2676 if ($6 == 'D') {
2677 node = &signode->NODE[0];
2678 itype = elpFALL;
2679 }
2680 delaymodelmax = stm_getmodel (cname, maxdlymname);
2681 if(gethtitem(modshrinkht, maxdlymname) == EMPTYHT){
2682 if (itype == elpRISE)
2683 stm_mod_shrinkslewaxis (delaymodelmax, risethmin, risethmax, itype);
2684 else
2685 stm_mod_shrinkslewaxis (delaymodelmax, fallthmin, fallthmax, itype);
2686 addhtitem (modshrinkht, maxdlymname, (long)delaymodelmax);
2687 }
2688 if (!delaymodelmax)
2689 printf ("no model %s\n", maxdlymname);
2690 maxcstr = stm_mod_constraint (delaymodelmax, STM_DEF_SLEW, STM_DEF_SLEW);
2691 if (itype == elpFALL) {
2692 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2693 }else{
2694 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2695 }
2696 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_O);
2697 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2698 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_O);
2699 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2700 }
2701 }
2702 }
2703 | TLF4_TOKEN_HOLD '(' busname "*>" pinname transition transition constraint ')'
2704 {
2705 if ($6 != 'X' && $7 != 'X') {
2706 for(i = lsb; i <= msb; i++){
2707 pinr = $5;
2708 pt = stm_vect (bname, i);
2709 pinn = namealloc(pt);
2710 mbkfree(pt);
2711 if(i == msb)
2712 mbkfree(bname);
2713 maxdlymname = $8.MAX;
2714 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2715 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2716 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2717 if ($7 == 'U')
2718 root = &sigroot->NODE[1];
2719 if ($7 == 'D')
2720 root = &sigroot->NODE[0];
2721 if ($6 == 'U') {
2722 node = &signode->NODE[1];
2723 itype = elpRISE;
2724 }
2725 if ($6 == 'D') {
2726 node = &signode->NODE[0];
2727 itype = elpFALL;
2728 }
2729 delaymodelmax = stm_getmodel (cname, maxdlymname);
2730 if(gethtitem(modshrinkht, maxdlymname) == EMPTYHT){
2731 if (itype == elpRISE)
2732 stm_mod_shrinkslewaxis (delaymodelmax, risethmin, risethmax, itype);
2733 else
2734 stm_mod_shrinkslewaxis (delaymodelmax, fallthmin, fallthmax, itype);
2735 addhtitem (modshrinkht, maxdlymname, (long)delaymodelmax);
2736 }
2737 if (!delaymodelmax)
2738 printf ("no model %s\n", maxdlymname);
2739 maxcstr = stm_mod_constraint (delaymodelmax, STM_DEF_SLEW, STM_DEF_SLEW);
2740 if (itype == elpFALL) {
2741 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
2742 }else{
2743 stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
2744 }
2745 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_O);
2746 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2747 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_O);
2748 ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
2749 }
2750 }
2751 }
2752 mbkfree(caparray);
2753 }
2754 | TLF4_TOKEN_HOLD '(' pinname "=>" pinname transition transition constant ')'
2755 {
2756 if ($6 != 'X' && $7 != 'X') {
2757 pinr = $5;
2758 pinn = $3;
2759 maxcstr = $8.MAX;
2760 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2761 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2762 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2763 if ($7 == 'U')
2764 root = &sigroot->NODE[1];
2765 if ($7 == 'D')
2766 root = &sigroot->NODE[0];
2767 if ($6 == 'U')
2768 node = &signode->NODE[1];
2769 if ($6 == 'D')
2770 node = &signode->NODE[0];
2771 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_O);
2772 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_O);
2773 }
2774 }
2775 }
2776 | TLF4_TOKEN_HOLD '(' busname "*>" pinname transition transition constant ')'
2777 {
2778 if ($6 != 'X' && $7 != 'X') {
2779 for(i = lsb; i <= msb; i++){
2780 pinr = $5;
2781 pt = stm_vect (bname, i);
2782 pinn = namealloc (pt);
2783 mbkfree(pt);
2784 if(i == msb)
2785 mbkfree(bname);
2786 maxcstr = $8.MAX;
2787 sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
2788 signode = (ttvsig_list*)gethtitem (pinht, pinn);
2789 if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT && (long)sigroot != DELETEHT && (long)signode != DELETEHT) {
2790 if ($7 == 'U')
2791 root = &sigroot->NODE[1];
2792 if ($7 == 'D')
2793 root = &sigroot->NODE[0];
2794 if ($6 == 'U')
2795 node = &signode->NODE[1];
2796 if ($6 == 'D')
2797 node = &signode->NODE[0];
2798 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_O);
2799 line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_O);
2800 }
2801 }
2802 }
2803 mbkfree(caparray);
2804 }
2805 ;
2806
2807 transition : TLF4_TOKEN_10
2808 {
2809 $$ = 'D';
2810 }
2811 | TLF4_TOKEN_01
2812 {
2813 $$ = 'U';
2814 }
2815 | TLF4_TOKEN_0Z
2816 {
2817 $$ = 'u';
2818 }
2819 | TLF4_TOKEN_1Z
2820 {
2821 $$ = 'd';
2822 }
2823 | TLF4_TOKEN_Z0
2824 {
2825 $$ = 'D';
2826 }
2827 | TLF4_TOKEN_Z1
2828 {
2829 $$ = 'U';
2830 }
2831 | clocktrans
2832 {
2833 $$ = $1;
2834 }
2835 ;
2836
2837 clocktrans : TLF4_TOKEN_NEGEDGE
2838 {
2839 $$ = 'D';
2840 }
2841 | TLF4_TOKEN_POSEDGE
2842 {
2843 $$ = 'U';
2844 }
2845 | TLF4_TOKEN_HIGH
2846 {
2847 $$ = 'H';
2848 }
2849 | TLF4_TOKEN_LOW
2850 {
2851 $$ = 'L';
2852 }
2853 ;
2854
2855 energy_list : energy
2856 {
2857 }
2858 | empty
2859 ;
2860
2861 energy : TLF4_TOKEN_ENERGY '(' modelname ')'
2862 | TLF4_TOKEN_ENERGY '(' rise fall ')'
2863 | TLF4_TOKEN_ENERGY constant
2864 ;
2865
2866 vdrop_limit : TLF4_TOKEN_VDROP_LIMIT '(' val ')'
2867 ;
2868
2869 constant : '(' TLF4_TOKEN_CONST '(' cval ')' ')'
2870 {
2871 if (TLF_TIME_UNIT == TLF_NS) {
2872 if($4.MIN != STM_NOVALUE)
2873 $$.MIN = $4.MIN * 1e3;
2874 else
2875 $$.MIN = $4.MIN;
2876 if($4.MAX != STM_NOVALUE)
2877 $$.MAX = $4.MAX * 1e3;
2878 else
2879 $$.MAX = $4.MAX;
2880 }
2881 if (TLF_TIME_UNIT == TLF_PS)
2882 $$ = $4;
2883 }
2884 ;
2885 constdelay : TLF4_TOKEN_DELAY '(' TLF4_TOKEN_CONST '(' cval ')' ')'
2886 {
2887 $$ = $5;
2888 }
2889 ;
2890
2891 constslew : TLF4_TOKEN_SLEW '(' TLF4_TOKEN_CONST '(' cval ')' ')'
2892 {
2893 $$ = $5;
2894 }
2895 ;
2896
2897 constraint : modelname
2898 {
2899 if (gethtitem (doublemodels, namealloc ($1)) != EMPTYHT) {
2900 sprintf (namebuf, "%s_min", $1);
2901 $$.MIN = namealloc (namebuf);
2902 sprintf (namebuf, "%s_max", $1);
2903 $$.MAX = namealloc (namebuf);
2904 } else {
2905 $$.MIN = NULL;
2906 $$.MAX = namealloc ($1);
2907 }
2908 }
2909 ;
2910
2911 delay : TLF4_TOKEN_DELAY '(' modelname ')'
2912 {
2913 if (gethtitem (doublemodels, namealloc ($3)) != EMPTYHT) {
2914 sprintf (namebuf, "%s_min", $3);
2915 $$.MIN = namealloc (namebuf);
2916 sprintf (namebuf, "%s_max", $3);
2917 $$.MAX = namealloc (namebuf);
2918 } else {
2919 $$.MIN = NULL;
2920 $$.MAX = namealloc ($3);
2921 }
2922 }
2923 ;
2924
2925
2926 slew : TLF4_TOKEN_SLEW '(' modelname ')'
2927 {
2928 if (gethtitem (doublemodels, namealloc ($3)) != EMPTYHT) {
2929 sprintf (namebuf, "%s_min", $3);
2930 $$.MIN = namealloc (namebuf);
2931 sprintf (namebuf, "%s_max", $3);
2932 $$.MAX = namealloc (namebuf);
2933 } else {
2934 $$.MIN = NULL;
2935 $$.MAX = namealloc ($3);
2936 }
2937 }
2938 ;
2939
2940 templatename : empty
2941 {
2942 $$ = NULL;
2943 }
2944 | ident
2945 {
2946 $$ = $1;
2947 }
2948 ;
2949
2950 busname : TLF4_TOKEN_VECT_IDENT
2951 {
2952 bname = stm_basename ($1);
2953 l = stm_lsb ($1);
2954 m = stm_msb ($1);
2955 mbkfree($1);
2956 lsb = l < m ? l : m;
2957 msb = m > l ? m : l;
2958 caparray = (float*)mbkalloc ((msb - lsb + 1) * sizeof (float));
2959 for (i = 0; i < msb - lsb; i++)
2960 caparray[i] = TLF_NO_CAPA;
2961 }
2962 ;
2963
2964 pinname : ident
2965 {
2966 $$ = $1;
2967 }
2968 ;
2969
2970 modelname : ident
2971 {
2972 $$ = $1;
2973 }
2974 ;
2975
2976 cellname : ident
2977 {
2978 $$ = $1;
2979 }
2980 ;
2981
2982 cval : val ':' val ':' val
2983 {
2984 $$.MIN = $1;
2985 $$.MAX = $5;
2986 }
2987 | val ':' ':' val
2988 {
2989 $$.MIN = $1;
2990 $$.MAX = $4;
2991 }
2992 | val
2993 {
2994 $$.MIN = STM_NOVALUE;
2995 $$.MAX = $1;
2996 }
2997 ;
2998
2999 val : TLF4_TOKEN_NUMBER
3000 {
3001 $$ = $1;
3002 }
3003 | TLF4_TOKEN_ENUMBER
3004 {
3005 $$ = $1;
3006 }
3007 | TLF4_TOKEN_10
3008 {
3009 $$ = 10 ;
3010 }
3011 | '~'
3012 {
3013 $$ = 1000000 ;
3014 }
3015 ;
3016
3017 ident : TLF4_TOKEN_IDENT
3018 {
3019 $$ = $1;
3020 }
3021 ;
3022
3023 empty : /* empty */
3024 ;
3025
3026 %%
3027
3028 extern char stbtext[];
3029
3030 int yyerror ()
3031 {
3032 avt_errmsg (STM_ERRMSG, "051", AVT_ERROR, TLF_LINE);
3033 return 0;
3034 }
3035