distrib/sources/tas/tlf/tlf3.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_util.h"
  17 #include "tlf_parse.h"
  18 #include "tlf_env.h"
  19
  20 /******************************************************************************/
  21 /* private                                                                    */
  22 /******************************************************************************/
  23 static cbhcomb  *ptrcbhcomb;
  24 static cbhseq   *ptrcbhseq;
  25 static short     mout;
  26
  27
  28 typedef struct minmax {
  29     float MIN;
  30     float MAX;
  31 } minmax;
  32
  33 static chain_list       *output;
  34
  35 static long              losig_index;
  36 static lofig_list       *ptrlofig;
  37 static losig_list       *ptrlosig;
  38 static locon_list       *ptrlocon;
  39
  40 static char             *cname;
  41
  42 static char              namebuf[1024];
  43 static chain_list       *ch, *chp, *xchain, *ychain, *xydatamin, *xydatamax, *ydatamin, *ydatamax;
  44 static char              xtype, ytype;
  45 static char              dimension;
  46 static int               nx, ny;
  47 static float            *ptfl;
  48 static timing_model     *modelmin;
  49 static timing_model     *modelmax;
  50 static timing_ttable    *ttemplate;
  51 static char             *cname;
  52 static char             *version;
  53 static ttvfig_list      *fig;
  54 static int               nbconsig, nbbreaksig, nblatchsig;
  55 static chain_list       *consigchain, *breaksigchain, *latchsigchain;
  56 static ttvevent_list    *root, *node;
  57 static ttvline_list     *line;
  58 static ht               *pinht;
  59 static ht               *pincapht;
  60 static ht               *doublemodels;
  61 static chain_list       *clocks;
  62 static int               i, l, m, lsb, msb;
  63 static ttvsig_list      *sigroot, *signode, *sig;
  64 static char             *pinr, *pinn, *pname, *bname, *vectname;
  65 static char             *mindlymname, *maxdlymname, *minslwmname, *maxslwmname;
  66 static long              linetype;
  67 static long              capa;
  68 static float             slwmin, slwmax, dlymin, dlymax, mincstr, maxcstr;
  69 static float            *caparray;
  70 static float             pincapa;
  71 static int               v;
  72 static timing_model     *delaymodelmin, *slewmodelmin;
  73 static timing_model     *delaymodelmax, *slewmodelmax;
  74 static long              dir;
  75 static chain_list       *flipflops;
  76 static chain_list       *latchs;
  77 static minmax           *ptmm;
  78 static segment          *ptseg;
  79 static double            thmin = 0.1, thmax = 0.9;
  80 static double            inputdth = 0.5, outputdth = 0.5;
  81 static double            voltage, temperature;
  82 static int               itype, otype;
  83 static timing_props     *properties;
  84
  85
  86 /******************************************************************************/
  87 /* function declarations                                                      */
  88 /******************************************************************************/
  89
  90 int yyerror();
  91 int yylex();
  92
  93 %}
  94
  95 %union {
  96   char                                        *text;
  97   float                                        real;
  98   struct chain                                *chainlist;
  99   struct { struct chain *CHAIN; char TYPE; } axedef;
 100   struct { struct chain *CHAIN; char DIM;  } datadef;
 101   struct { float MIN; float MAX; }           valdef;
 102   struct { char *MIN; char *MAX; }           bitext;
 103   char                                         cchar;
 104   long                                         llong;
 105   struct segment                               *ssegment;
 106 };
 107
 108 %token            TLF3_TOKEN_01
 109 %token            TLF3_TOKEN_0Z
 110 %token            TLF3_TOKEN_10
 111 %token            TLF3_TOKEN_1Z
 112 %token            TLF3_TOKEN_ARROW "=>"
 113 %token            TLF3_TOKEN_ASYNCH
 114 %token            TLF3_TOKEN_BIDIR
 115 %token            TLF3_TOKEN_CELL
 116 %token            TLF3_TOKEN_CELLTYPE
 117 %token            TLF3_TOKEN_CLEAR
 118 %token            TLF3_TOKEN_CLOCK
 119 %token            TLF3_TOKEN_CLOCK_REG
 120 %token            TLF3_TOKEN_CLOCK_SLEW_AXIS
 121 %token            TLF3_TOKEN_COMB
 122 %token            TLF3_TOKEN_CONST
 123 %token            TLF3_TOKEN_CONTROL
 124 %token            TLF3_TOKEN_DATA
 125 %token            TLF3_TOKEN_DATE
 126 %token            TLF3_TOKEN_DELAY
 127 %token <real>     TLF3_TOKEN_ENABLE
 128 %token <real>     TLF3_TOKEN_ENUMBER
 129 %token            TLF3_TOKEN_ENVIRONMENT
 130 %token <text>     TLF3_TOKEN_EXPR
 131 %token            TLF3_TOKEN_FAST
 132 %token            TLF3_TOKEN_FOR_BITS
 133 %token            TLF3_TOKEN_FUNCTION
 134 %token            TLF3_TOKEN_GROUND
 135 %token            TLF3_TOKEN_HEADER
 136 %token            TLF3_TOKEN_HIGH
 137 %token            TLF3_TOKEN_HOLD
 138 %token <text>     TLF3_TOKEN_IDENT
 139 %token            TLF3_TOKEN_IGNORE
 140 %token            TLF3_TOKEN_INCELL
 141 %token            TLF3_TOKEN_INPUT
 142 %token            TLF3_TOKEN_INPUT_REG
 143 %token            TLF3_TOKEN_INPUT_SLEW_AXIS
 144 %token            TLF3_TOKEN_INVERTED_OUTPUT
 145 %token            TLF3_TOKEN_LATCH
 146 %token            TLF3_TOKEN_LIBRARY
 147 %token            TLF3_TOKEN_LOAD_AXIS
 148 %token            TLF3_TOKEN_AXIS
 149 %token            TLF3_TOKEN_LOW
 150 %token            TLF3_TOKEN_MODEL
 151 %token            TLF3_TOKEN_NEGEDGE
 152 %token <real>     TLF3_TOKEN_NUMBER
 153 %token            TLF3_TOKEN_OPE
 154 %token            TLF3_TOKEN_OUTCELL
 155 %token            TLF3_TOKEN_OUTPUT
 156 %token            TLF3_TOKEN_PATH
 157 %token            TLF3_TOKEN_PIN
 158 %token            TLF3_TOKEN_PINDIR
 159 %token            TLF3_TOKEN_PINTYPE
 160 %token            TLF3_TOKEN_PIN_CAP
 161 %token            TLF3_TOKEN_POSEDGE
 162 %token <text>     TLF3_TOKEN_QSTRING
 163 %token            TLF3_TOKEN_REGISTER
 164 %token            TLF3_TOKEN_SEQ
 165 %token            TLF3_TOKEN_SET
 166 %token            TLF3_TOKEN_SETUP
 167 %token            TLF3_TOKEN_SLAVE_CLOCK
 168 %token            TLF3_TOKEN_SLEW
 169 %token            TLF3_TOKEN_SLOW
 170 %token            TLF3_TOKEN_SLEW_AXIS
 171 %token            TLF3_TOKEN_SPLINE
 172 %token            TLF3_TOKEN_TECHNOLOGY
 173 %token            TLF3_TOKEN_TIMING_PROPS
 174 %token            TLF3_TOKEN_TLF_VERSION
 175 %token            TLF3_TOKEN_TRISTATE
 176 %token            TLF3_TOKEN_TRANSITION_START
 177 %token            TLF3_TOKEN_TRANSITION_END
 178 %token            TLF3_TOKEN_INPUT_THRESHOLD
 179 %token            TLF3_TOKEN_OUTPUT_THRESHOLD
 180 %token <text>     TLF3_TOKEN_VECT
 181 %token <text>     TLF3_TOKEN_VECT_IDENT
 182 %token            TLF3_TOKEN_VENDOR
 183 %token            TLF3_TOKEN_VERSION
 184 %token            TLF3_TOKEN_Z0
 185 %token            TLF3_TOKEN_Z1
 186 %token            TLF3_TOKEN_LINEAR
 187 %token            TLF3_TOKEN_VALUE
 188 %token            TLF3_TOKEN_NET_CAP
 189 %token            TLF3_TOKEN_NET_RES
 190 %token            TLF3_TOKEN_TEMPERATURE
 191 %token            TLF3_TOKEN_VOLTAGE
 192
 193 %start tlf_file
 194
 195 %type <chainlist> array1D
 196 %type <chainlist> array2D
 197 %type <chainlist> array1D_list
 198 %type <axedef>    axe
 199 %type <cchar>     axetype
 200 %type <text>      cellname
 201 %type <cchar>     celltype
 202 %type <cchar>     clocktrans
 203 %type <valdef>    constant
 204 %type <valdef>    constdelay
 205 %type <valdef>    constslew
 206 %type <bitext>    constraint
 207 %type <valdef>    cval
 208 %type <chainlist> cval_list
 209 %type <chainlist> segment_list
 210 %type <datadef>   data
 211 %type <bitext>    delay
 212 %type <text>      ident
 213 %type <chainlist> ident_list
 214 %type <datadef>   modeldata
 215 %type <text>      modelname
 216 %type <chainlist> reg_list
 217 %type <chainlist> outputs
 218 %type <real>      pincap
 219 %type <llong>     pindir
 220 %type <text>      pinname
 221 %type <cchar>     pintype
 222 %type <bitext>    slew
 223 %type <text>      templatename
 224 %type <cchar>     transition
 225 %type <chainlist> val_list
 226 %type <real>      val
 227 %type <ssegment>  segment
 228
 229 %%
 230
 231 tlf_file     : header genmod_list gentprops cell_list
 232              {
 233                 if(TLF_TRACE_MODE == 'Y')
 234                     fprintf (stdout, "   <--- done\n");
 235 /*                else
 236                     fprintf(stdout,"DONE!\n");*/
 237                 cbh_delcct();
 238              }
 239              ;
 240
 241 genmod_list  : empty
 242              | genmod_list genmod
 243              ;
 244
 245 /*genmod       : TLF3_TOKEN_MODEL '(' ')'
 246              ;*/
 247
 248 genmod       : netmodel
 249              ;
 250
 251 netmodel     : TLF3_TOKEN_MODEL '(' modelname '(' modelbody ')' ')'
 252              {
 253                 modelmax = NULL;
 254                 for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
 255                 if (xydatamax && !xydatamin) {
 256                     sprintf (namebuf, "%s", $3);
 257                     modelmax = stm_addtblmodel (cname, namebuf, nx, 0, xtype, STM_NOTYPE);
 258                     stm_storemodel (cname, namebuf, modelmax, 0);
 259                 }
 260                 if ((xtype == STM_LOAD) || (xtype == STM_NOTYPE)) {
 261                     stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
 262                 }
 263                 switch (dimension) {
 264                     case TLF_1D :
 265                         if (nx > 0 && ny > 0)
 266                             avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
 267                         else {
 268                             stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
 269                             for (ch = xydatamax; ch; ch = ch->NEXT)
 270                                 mbkfree(ch->DATA);
 271                             if (xydatamax)
 272                                 freechain (xydatamax);
 273                         }
 274                     break;
 275                     case TLF_CONST :
 276                         if (nx > 0 && ny > 0)
 277                             avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
 278                         else {
 279                             stm_modtbl_setconst (modelmax->UMODEL.TABLE, *(float*)xydatamax->DATA);
 280                             for (ch = xydatamax; ch; ch = ch->NEXT)
 281                                 mbkfree(ch->DATA);
 282                             if (xydatamax)
 283                                 freechain (xydatamax);
 284                         }
 285                     break;
 286                 }
 287                 if(xchain){
 288                     for (ch = xchain; ch; ch = ch->NEXT){
 289                         if(ch->DATA)
 290                             mbkfree(ch->DATA);
 291                     }
 292                     freechain (xchain);
 293                 }
 294              }
 295              |  TLF3_TOKEN_MODEL '(' modelname '(' TLF3_TOKEN_LINEAR TLF3_TOKEN_VALUE '(' segment_list ')' ')' ')'
 296              {
 297                 modelmax = stm_addmodel(cname, $3);
 298                 modelmax->UTYPE = STM_MOD_MODTBL;
 299                 modelmax->UMODEL.TABLE = stm_prop_seg2tbl ($8, STM_LOAD);
 300                 stm_storemodel (cname, $3, modelmax, 0);
 301              }
 302              ;
 303
 304 gentprops    : TLF3_TOKEN_TIMING_PROPS '(' prop_list ')'
 305              ;
 306
 307 prop_list    : empty
 308              | prop_list prop
 309              ;
 310
 311 prop         : threshold
 312              {
 313              }
 314              | delay_th
 315              {
 316                 if(inputdth != outputdth)
 317                    fprintf (stderr, "***tlf warning: input and output thresholds are not the same***\n");
 318              }
 319              | TLF3_TOKEN_TEMPERATURE '(' val ')'
 320              {
 321                 temperature = $3;
 322              }
 323              | TLF3_TOKEN_VOLTAGE '(' val ')'
 324              {
 325                 voltage = $3;
 326              }
 327              | TLF3_TOKEN_NET_CAP '(' ident ')'
 328              {
 329                 modelmax = stm_getmodel(cname, $3);
 330                 if (TLF_CAPA_UNIT == TLF_PF)
 331                     for(i = 0; i < modelmax->UMODEL.TABLE->NX; i++)
 332                         modelmax->UMODEL.TABLE->SET1D[i] = modelmax->UMODEL.TABLE->SET1D[i] * 1000.0;
 333                 stm_addcapmodel(properties, modelmax);
 334              }
 335              | TLF3_TOKEN_NET_RES '(' ident ')'
 336              {
 337                 stm_addresmodel(properties, stm_getmodel(cname, $3));
 338              }
 339              ;
 340
 341 delay_th     : TLF3_TOKEN_INPUT_THRESHOLD '(' val ')'
 342              {
 343                inputdth = $3;
 344              }
 345              | TLF3_TOKEN_OUTPUT_THRESHOLD '(' val ')'
 346              {
 347                outputdth = $3;
 348              }
 349              ;
 350
 351 threshold    : TLF3_TOKEN_TRANSITION_START '(' val ')'
 352              {
 353                thmin = $3;
 354              }
 355              | TLF3_TOKEN_TRANSITION_END '(' val ')'
 356              {
 357                thmax = $3;
 358              }
 359              ;
 360
 361 header       : TLF3_TOKEN_HEADER '(' helem_list ')'
 362              {
 363 /*               if(TLF_TRACE_MODE != 'Y') {
 364                    fprintf(stdout,"\nLOADING LIBRARY %s TLF3... ", LIBRARY_TLF_NAME);
 365                    fflush( stdout );
 366                }*/
 367                output = NULL;
 368                losig_index = 0;
 369                ptrlofig = NULL;
 370                ptrlosig = NULL;
 371                ptrlocon = NULL;
 372                ptrcbhcomb = NULL;
 373                ptrcbhseq = NULL;
 374
 375                cbh_newclassifier();
 376                cbh_createcct();
 377              }
 378              ;
 379
 380 helem_list   : empty
 381              | helem_list helem
 382              ;
 383
 384 helem        : library
 385              | technology
 386              | date
 387              | vendor
 388              | environment
 389              | version
 390              | tlf_version
 391              ;
 392
 393 library      : TLF3_TOKEN_LIBRARY '(' TLF3_TOKEN_QSTRING ')'
 394              {
 395                 nbconsig    = 0;
 396                 nbbreaksig  = 0;
 397                 nblatchsig  = 0;
 398                 consigchain    = NULL;
 399                 breaksigchain  = NULL;
 400                 latchsigchain  = NULL;
 401                 clocks = NULL;
 402
 403                 tlf_setenv();
 404                 LIBRARY_TLF_NAME = tlf_treatname($3);
 405                 stm_addcell (LIBRARY_TLF_NAME);
 406                 cname = LIBRARY_TLF_NAME;
 407                 if(!STM_PROPERTIES)
 408                     properties = stm_prop_create (NULL, NULL);
 409                 else
 410                     properties = STM_PROPERTIES;
 411                 mbkfree($3);
 412              }
 413              ;
 414
 415 technology   : TLF3_TOKEN_TECHNOLOGY '(' TLF3_TOKEN_QSTRING ')'
 416              {
 417                 mbkfree($3);
 418              }
 419              ;
 420
 421 date         : TLF3_TOKEN_DATE '(' TLF3_TOKEN_QSTRING ')'
 422              {
 423                 mbkfree($3);
 424              }
 425              ;
 426
 427 vendor       : TLF3_TOKEN_VENDOR '(' TLF3_TOKEN_QSTRING ')'
 428              {
 429                 mbkfree($3);
 430              }
 431              ;
 432
 433 environment  : TLF3_TOKEN_ENVIRONMENT '(' TLF3_TOKEN_QSTRING ')'
 434              {
 435                 mbkfree($3);
 436              }
 437              ;
 438
 439 version      : TLF3_TOKEN_VERSION '(' TLF3_TOKEN_QSTRING ')'
 440              {
 441                 mbkfree($3);
 442              }
 443              ;
 444
 445 tlf_version  : TLF3_TOKEN_TLF_VERSION '(' TLF3_TOKEN_QSTRING ')'
 446              {
 447                 mbkfree($3);
 448              }
 449              ;
 450
 451 cell_list    : empty
 452              | cell_list cell
 453              ;
 454
 455 cell         : TLF3_TOKEN_CELL '(' celldef celltprops definitions arcs ')'
 456              {
 457                 locon_list  *p;
 458                 cbhcomb     *c;
 459                 char        *str;
 460
 461                 if((ptrcbhseq != NULL) && (!mout)) {
 462                     if(ptrcbhseq->PIN != NULL) {
 463                         p = getlocon(ptrlofig, ptrcbhseq->PIN);
 464                         c = cbh_getcombfromlocon(p);
 465                         if(!c->FUNCTION) {
 466                             str = eqt_ConvertStr(ptrcbhseq->NAME);
 467                             c->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
 468                             mbkfree (str);
 469                         }
 470                         if((ptrcbhseq->DATA != NULL) && (tlf_lookingForExpr(ptrcbhseq->DATA, ptrcbhseq->PIN) == 1))
 471                             ptrcbhseq->DATA = tlf_replaceInAbl(ptrcbhseq->DATA, ptrcbhseq->PIN, ptrcbhseq->NAME);
 472                     }
 473
 474                     if(ptrcbhseq->NEGPIN != NULL) {
 475                         p = getlocon(ptrlofig, ptrcbhseq->NEGPIN);
 476                         c = cbh_getcombfromlocon(p);
 477                         if(!c->FUNCTION) {
 478                             str = eqt_ConvertStr(ptrcbhseq->NEGNAME);
 479                             c->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
 480                             mbkfree (str);
 481                         }
 482                         if((ptrcbhseq->DATA != NULL) && (tlf_lookingForExpr(ptrcbhseq->DATA, ptrcbhseq->NEGPIN) == 1))
 483                             ptrcbhseq->DATA = tlf_replaceInAbl(ptrcbhseq->DATA, ptrcbhseq->NEGPIN, ptrcbhseq->NEGNAME);
 484                     }
 485
 486                     cbh_addseqtolofig(ptrlofig, ptrcbhseq);
 487
 488                 }
 489
 490
 491
 492
 493                 if(mout == 0)
 494                     cbh_classlofig(ptrlofig);
 495
 496
 497                 for (i = 0; i < fig->NBCONSIG; i++) {
 498                     sig = fig->CONSIG[i];
 499                     if ((sig->TYPE & TTV_SIG_B) == TTV_SIG_B) {
 500                         breaksigchain = addchain(breaksigchain,sig);
 501                         nbbreaksig++;
 502                     }
 503                     if ((sig->TYPE & TTV_SIG_L) == TTV_SIG_L) {
 504                         latchsigchain = addchain(latchsigchain,sig);
 505                         nblatchsig++;
 506                     }
 507                 }
 508
 509                 fig->NBEBREAKSIG = nbbreaksig;
 510                 fig->EBREAKSIG   = ttv_allocreflist (breaksigchain, nbbreaksig);
 511                 fig->NBELATCHSIG = nblatchsig;
 512                 fig->ELATCHSIG   = ttv_allocreflist (latchsigchain, nblatchsig);
 513
 514                 for (i = 0; i < fig->NBCONSIG; i++) {
 515                     capa = gethtitem (pincapht, namealloc (fig->CONSIG[i]->NAME));
 516                     if (capa != EMPTYHT)
 517                         mbkfree((float*)capa);
 518                 }
 519
 520                 ptrcbhseq = NULL;
 521                 delht (pinht);
 522                 delht (pincapht);
 523                 delht (doublemodels);
 524                 freechain (clocks);
 525                 freechain (flipflops);
 526                 freechain (latchs);
 527                 clocks        = NULL;
 528                 flipflops     = NULL;
 529                 latchs        = NULL;
 530                 nbbreaksig    = 0;
 531                 latchsigchain = NULL;
 532                 nblatchsig    = 0;
 533                 breaksigchain = NULL;
 534                 fig->STATUS |= TTV_STS_DTX;
 535                 fig->STATUS |= TTV_STS_TTX;
 536              }
 537              ;
 538
 539 definitions  : def_list
 540              {
 541                 fig->CONSIG = ttv_allocreflist (consigchain, nbconsig);
 542                 fig->NBCONSIG = nbconsig;
 543                 for (i = 0; i < fig->NBCONSIG; i++)
 544                     addhtitem (pinht, namealloc (fig->CONSIG[i]->NAME), (long)fig->CONSIG[i]);
 545                 consigchain = NULL;
 546                 nbconsig = 0;
 547              }
 548              ;
 549
 550 def_list     : empty
 551              | def_list def
 552              ;
 553
 554 def          : model
 555              | pin
 556              | reg
 557              ;
 558
 559 reg          : TLF3_TOKEN_REGISTER '('
 560              {
 561                 if(ptrcbhseq != NULL) {
 562                     mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
 563                 }
 564                 else {
 565                     ptrcbhseq = cbh_newseq();
 566                     ptrcbhseq->SEQTYPE = CBH_FLIPFLOP;
 567                     ptrcbhseq->RSCONF = NULL;
 568                     ptrcbhseq->RSCONFNEG = NULL;
 569                }
 570              }
 571               reg_list ')'
 572              {
 573                 if(ptrcbhseq != NULL)
 574                     flipflops = append (flipflops, output);
 575                 output = NULL;
 576              }
 577              | TLF3_TOKEN_LATCH    '('
 578              {
 579                 if(ptrcbhseq != NULL) {
 580                     mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
 581                 }
 582
 583                 else {
 584                     ptrcbhseq = cbh_newseq();
 585                     ptrcbhseq->SEQTYPE = CBH_LATCH;
 586                     ptrcbhseq->RSCONF = NULL;
 587                     ptrcbhseq->RSCONFNEG = NULL;
 588                 }
 589              }
 590               reg_list ')'
 591              {
 592                 if(ptrcbhseq != NULL)
 593                     latchs = append (latchs, output);
 594                 output = NULL;
 595              }
 596              ;
 597
 598 reg_list : empty{}
 599          | reg_list outputs
 600          | reg_list reg_elem {}
 601          ;
 602
 603 reg_elem : TLF3_TOKEN_CLEAR TLF3_TOKEN_EXPR
 604          {
 605             char    *str;
 606             str = eqt_ConvertStr($2);
 607             ptrcbhseq->RESET = eqt_StrToAbl(tlfEqtCtx,str);
 608             mbkfree (str);
 609          }
 610          | TLF3_TOKEN_CLOCK_REG TLF3_TOKEN_EXPR
 611          {
 612             char    *str;
 613             str = eqt_ConvertStr($2);
 614             ptrcbhseq->CLOCK = eqt_StrToAbl(tlfEqtCtx,str);
 615             mbkfree (str);
 616          }
 617          | TLF3_TOKEN_SLAVE_CLOCK TLF3_TOKEN_EXPR
 618          {
 619             char    *str;
 620             str = eqt_ConvertStr($2);
 621             ptrcbhseq->SLAVECLOCK = eqt_StrToAbl(tlfEqtCtx,str);
 622             mbkfree (str);
 623          }
 624          | TLF3_TOKEN_SET TLF3_TOKEN_EXPR
 625          {
 626             char    *str;
 627             str = eqt_ConvertStr($2);
 628             ptrcbhseq->SET = eqt_StrToAbl(tlfEqtCtx,str);
 629             mbkfree (str);
 630          }
 631          | TLF3_TOKEN_INPUT_REG TLF3_TOKEN_EXPR
 632          {
 633             char    *str;
 634             str = eqt_ConvertStr($2);
 635             ptrcbhseq->DATA = eqt_StrToAbl(tlfEqtCtx,str);
 636             mbkfree (str);
 637          }
 638          ;
 639
 640 outputs      : TLF3_TOKEN_OUTPUT '(' ident_list ')'
 641              {
 642                 char pin[1024], name[1024];
 643
 644                 if($3->NEXT != NULL)
 645                     mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
 646                 else {
 647                     if(ptrcbhseq != NULL){
 648                         strcpy(pin,tlf_chainlistToStr($3));
 649                         sprintf(name,"I%s",pin);
 650                         ptrcbhseq->PIN = namealloc(pin);
 651                         ptrcbhseq->NAME = namealloc(name);
 652                     }
 653                 }
 654                 if (output == NULL)
 655                     output = $3;
 656                 else
 657                     output = append(output,$3);
 658              }
 659              | TLF3_TOKEN_INVERTED_OUTPUT '(' ident_list ')'
 660              {
 661                 char negpin[1024], negname[1024];
 662
 663                 if($3->NEXT != NULL)
 664                     mout = tlf_multout(&ptrlofig,&ptrcbhcomb,&ptrcbhseq,cname);
 665                 else {
 666                     if(ptrcbhseq != NULL) {
 667                         strcpy(negpin,tlf_chainlistToStr($3));
 668                         sprintf(negname,"I%s",negpin);
 669                         ptrcbhseq->NEGPIN = namealloc(negpin);
 670                         ptrcbhseq->NEGNAME = namealloc(negname);
 671                     }
 672                 }
 673                 if (output == NULL)
 674                     output = $3;
 675                 else
 676                     output = append(output,$3);
 677              }
 678              ;
 679
 680 ident_list   : ident
 681              {
 682                 $$ = addchain (NULL, $1);
 683              }
 684              | ident ident_list
 685              {
 686                 $$ = addchain ($2, $1);
 687              }
 688              ;
 689
 690 celldef      : cellname celltype
 691              {
 692                 lofig_list *p;
 693
 694                 cname = $1;
 695                 mout = 0;
 696                 if(TLF_TRACE_MODE == 'Y')
 697                     fprintf (stdout, "   ---> processing cell %s\n", cname);
 698
 699                 /* nouvelle cellule --> lofig a creer */
 700                 losig_index = 1;
 701                 if((p=getloadedlofig(cname)) == NULL) {
 702                     ptrlofig = addlofig(cname);
 703                     ptrlofig->MODE = 'P';
 704                     addcatalog(ptrlofig->NAME);
 705                 }
 706
 707                 else
 708                     ptrlofig = p;
 709
 710                 version = (char*) mbkalloc (TLF_BUFSIZE * sizeof (char));
 711                 sprintf (version, "%.2f", elpTechnoVersion);
 712                 stm_addcell ($1);
 713                 fig = ttv_givehead ($1, $1, NULL);
 714                 ttv_lockttvfig(fig);
 715                 ttv_setttvlevel (fig);
 716                 TLF_TTVFIG_LIST = addchain (TLF_TTVFIG_LIST, fig);
 717                 fig->INFO->TOOLNAME      = TLF_TOOLNAME;
 718                 fig->INFO->TOOLVERSION   = TLF_TOOLVERSION;
 719                 fig->INFO->TECHNONAME    = elpTechnoName;
 720                 fig->INFO->TECHNOVERSION = version;
 721                 fig->INFO->SLOPE         = STM_DEF_SLEW;
 722                 fig->INFO->CAPAOUT       = STM_DEF_LOAD;
 723                 fig->INFO->STHHIGH       = thmax;
 724                 fig->INFO->STHLOW        = thmin;
 725                 fig->INFO->DTH           = outputdth;
 726                     fig->INFO->TEMP          = temperature;
 727                     fig->INFO->VDD           = voltage;
 728                 ttv_setttvdate (fig, TTV_DATE_LOCAL);
 729                 pinht = addht (100);
 730                 pincapht = addht (100);
 731                 doublemodels = addht (100);
 732              }
 733              ;
 734
 735 celltype     : TLF3_TOKEN_CELLTYPE '(' TLF3_TOKEN_IGNORE ')'
 736              {
 737                 $$ = STM_IGNORE;
 738              }
 739              | TLF3_TOKEN_CELLTYPE '(' TLF3_TOKEN_OUTCELL ')'
 740              {
 741                 $$ = STM_IGNORE;
 742              }
 743              | TLF3_TOKEN_CELLTYPE '(' TLF3_TOKEN_INCELL ')'
 744              {
 745                 $$ = STM_IGNORE;
 746              }
 747              | TLF3_TOKEN_CELLTYPE '(' TLF3_TOKEN_INCELL TLF3_TOKEN_OUTCELL ')'
 748              {
 749                 $$ = STM_IGNORE;
 750              }
 751              | TLF3_TOKEN_CELLTYPE '(' TLF3_TOKEN_SEQ ')'
 752              {
 753                 $$ = STM_SEQ;
 754              }
 755              | TLF3_TOKEN_CELLTYPE '(' TLF3_TOKEN_COMB ')'
 756              {
 757                 $$ = STM_COMB;
 758              }
 759              ;
 760
 761 celltprops   : empty
 762              | TLF3_TOKEN_TIMING_PROPS '(' ')'
 763              ;
 764
 765 arcs         : arc_list
 766              {
 767
 768                 for (i = 0; i < fig->NBCONSIG; i++) {
 769                     sig = fig->CONSIG[i];
 770
 771                     /* typer B, LL (latch), LF (flip-flop) */
 772
 773                     for (line = sig->NODE[0].INLINE; line; line = line->NEXT) {
 774                         /* access */
 775                         if ((line->TYPE & TTV_LINE_A) == TTV_LINE_A) {
 776                             switch (getoutputtype (sig->NAME, flipflops, latchs)) {
 777                                 case 'B' :
 778                                     sig->TYPE |= TTV_SIG_B;
 779                                     break;
 780                                 case 'L' :
 781                                     sig->TYPE |= TTV_SIG_LL;
 782                                     break;
 783                                 case 'F' :
 784                                     sig->TYPE |= TTV_SIG_LF;
 785                                     break;
 786                             }
 787                             break;
 788                         }
 789                         /* hold, setup */
 790                         if (((line->TYPE & TTV_LINE_O) == TTV_LINE_O) || ((line->TYPE & TTV_LINE_U) == TTV_LINE_U)) {
 791                             sig->TYPE |= TTV_SIG_B;
 792                             line->NODE->ROOT->TYPE |= TTV_SIG_B;
 793                         }
 794                     }
 795                     for (line = sig->NODE[1].INLINE; line; line = line->NEXT) {
 796                         /* access */
 797                         if ((line->TYPE & TTV_LINE_A) == TTV_LINE_A) {
 798                             switch (getoutputtype (sig->NAME, flipflops, latchs)) {
 799                                 case 'B' :
 800                                     sig->TYPE |= TTV_SIG_B;
 801                                     break;
 802                                 case 'L' :
 803                                     sig->TYPE |= TTV_SIG_LL;
 804                                     break;
 805                                 case 'F' :
 806                                     sig->TYPE |= TTV_SIG_LF;
 807                                     break;
 808                             }
 809                             break;
 810                         }
 811                         /* hold, setup */
 812                         if (((line->TYPE & TTV_LINE_O) == TTV_LINE_O) || ((line->TYPE & TTV_LINE_U) == TTV_LINE_U)) {
 813                             sig->TYPE |= TTV_SIG_B;
 814                             line->NODE->ROOT->TYPE |= TTV_SIG_B;
 815                         }
 816                     }
 817                 }
 818              }
 819              ;
 820
 821 model        : TLF3_TOKEN_MODEL '(' modelname templatename '(' modelbody ')' ')'
 822              {
 823                 if (!xydatamin && !xydatamax) {
 824                     for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
 825                     for (ny = 0, ch = ychain; ch; ch = ch->NEXT) ny++;
 826                     ttemplate = stm_modtbl_addtemplate ($3, nx, ny, xtype, ytype);
 827                     if (xtype == STM_INPUT_SLEW || xtype == STM_CLOCK_SLEW) {
 828                         if (TLF_TIME_UNIT == TLF_NS)
 829                             stm_modtbl_settemplateXrange (ttemplate, xchain, 1e3);
 830                         if (TLF_TIME_UNIT == TLF_PS)
 831                             stm_modtbl_settemplateXrange (ttemplate, xchain, 1);
 832                     }
 833                     if (xtype == STM_LOAD) {
 834                         if (TLF_CAPA_UNIT == TLF_PF)
 835                             stm_modtbl_settemplateXrange (ttemplate, xchain, 1e3);
 836                         if (TLF_CAPA_UNIT == TLF_FF)
 837                             stm_modtbl_settemplateXrange (ttemplate, xchain, 1);
 838                     }
 839                     if (ytype == STM_INPUT_SLEW || ytype == STM_CLOCK_SLEW) {
 840                         if (TLF_TIME_UNIT == TLF_NS)
 841                             stm_modtbl_settemplateYrange (ttemplate, ychain, 1e3);
 842                         if (TLF_TIME_UNIT == TLF_PS)
 843                             stm_modtbl_settemplateYrange (ttemplate, ychain, 1);
 844                     }
 845                     if (ytype == STM_LOAD) {
 846                         if (TLF_CAPA_UNIT == TLF_PF)
 847                             stm_modtbl_settemplateYrange (ttemplate, ychain, 1e3);
 848                         if (TLF_CAPA_UNIT == TLF_FF)
 849                             stm_modtbl_settemplateYrange (ttemplate, ychain, 1);
 850                     }
 851                 } else {
 852                     modelmin = NULL;
 853                     modelmax = NULL;
 854                     if ($4) {
 855                         ttemplate = stm_modtbl_gettemplate ($4);
 856                         if (xydatamin) {
 857                             sprintf (namebuf, "%s_min", $3);
 858                             modelmin = stm_addmodel (cname, namebuf);
 859                             modelmin->UMODEL.TABLE = stm_modtbl_create_ftemplate (ttemplate);
 860                             modelmin->UTYPE = STM_MOD_MODTBL;
 861                             stm_storemodel (cname, namebuf, modelmin, 0);
 862                             addhtitem (doublemodels, namealloc ($3), 1);
 863                         }
 864                         if (xydatamax && xydatamin) {
 865                             sprintf (namebuf, "%s_max", $3);
 866                             modelmax = stm_addmodel (cname, namebuf);
 867                             modelmax->UMODEL.TABLE = stm_modtbl_create_ftemplate (ttemplate);
 868                             modelmax->UTYPE = STM_MOD_MODTBL;
 869                             stm_storemodel (cname, namebuf, modelmax, 0);
 870                         }
 871                         if (xydatamax && !xydatamin) {
 872                             sprintf (namebuf, "%s", $3);
 873                             modelmax = stm_addmodel (cname, namebuf);
 874                             modelmax->UMODEL.TABLE = stm_modtbl_create_ftemplate (ttemplate);
 875                             modelmax->UTYPE = STM_MOD_MODTBL;
 876                             stm_storemodel (cname, namebuf, modelmax, 0);
 877                         }
 878                     } else {
 879                         for (nx = 0, ch = xchain; ch; ch = ch->NEXT) nx++;
 880                         for (ny = 0, ch = ychain; ch; ch = ch->NEXT) ny++;
 881                         if (xydatamin) {
 882                             addhtitem (doublemodels, namealloc ($3), 1);
 883                             sprintf (namebuf, "%s_min", $3);
 884                             modelmin = stm_addtblmodel (cname, namebuf, nx, ny, xtype, ytype);
 885                         }
 886                         if (xydatamax && xydatamin) {
 887                             sprintf (namebuf, "%s_max", $3);
 888                             modelmax = stm_addtblmodel (cname, namebuf, nx, ny, xtype, ytype);
 889                         }
 890                         if (xydatamax && !xydatamin) {
 891                             sprintf (namebuf, "%s", $3);
 892                             modelmax = stm_addtblmodel (cname, namebuf, nx, ny, xtype, ytype);
 893                         }
 894                     }
 895
 896                     if (xtype == STM_INPUT_SLEW || xtype == STM_CLOCK_SLEW) {
 897                         if (TLF_TIME_UNIT == TLF_NS) {
 898                             if (modelmin)
 899                                 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1e3);
 900                             stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1e3);
 901                         }
 902                         if (TLF_TIME_UNIT == TLF_PS) {
 903                             if (modelmin)
 904                                 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1);
 905                             stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
 906                         }
 907                     }
 908                     if (xtype == STM_LOAD) {
 909                         if (TLF_CAPA_UNIT == TLF_PF) {
 910                             if (modelmin)
 911                                 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1e3);
 912                             stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1e3);
 913                         }
 914                         if (TLF_CAPA_UNIT == TLF_FF) {
 915                             if (modelmin)
 916                                 stm_modtbl_setXrange (modelmin->UMODEL.TABLE, xchain, 1);
 917                             stm_modtbl_setXrange (modelmax->UMODEL.TABLE, xchain, 1);
 918                         }
 919                     }
 920                     if (ytype == STM_INPUT_SLEW || ytype == STM_CLOCK_SLEW) {
 921                         if (TLF_TIME_UNIT == TLF_NS) {
 922                             if (modelmin)
 923                                 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1e3);
 924                             stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1e3);
 925                         }
 926                         if (TLF_TIME_UNIT == TLF_PS) {
 927                             if (modelmin)
 928                                 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1);
 929                             stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1);
 930                         }
 931                     }
 932                     if (ytype == STM_LOAD) {
 933                         if (TLF_CAPA_UNIT == TLF_PF) {
 934                             if (modelmin)
 935                                 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1e3);
 936                             stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1e3);
 937                         }
 938                         if (TLF_CAPA_UNIT == TLF_FF) {
 939                             if (modelmin)
 940                                 stm_modtbl_setYrange (modelmin->UMODEL.TABLE, ychain, 1);
 941                             stm_modtbl_setYrange (modelmax->UMODEL.TABLE, ychain, 1);
 942                         }
 943                     }
 944                     switch (dimension) {
 945                         case TLF_CONST :
 946                             if (nx > 0 || ny > 0)
 947                                 avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
 948                             else {
 949                                 if (TLF_TIME_UNIT == TLF_NS) {
 950                                     if (modelmin)
 951                                         stm_modtbl_setconst (modelmin->UMODEL.TABLE, *(float*)xydatamin->DATA * 1e3);
 952                                     if (modelmax)
 953                                         stm_modtbl_setconst (modelmax->UMODEL.TABLE, *(float*)xydatamax->DATA * 1e3);
 954                                 }
 955                                 if (TLF_TIME_UNIT == TLF_PS) {
 956                                     if (modelmin)
 957                                         stm_modtbl_setconst (modelmin->UMODEL.TABLE, *(float*)xydatamin->DATA);
 958                                     if (modelmax)
 959                                         stm_modtbl_setconst (modelmax->UMODEL.TABLE, *(float*)xydatamax->DATA);
 960                                 }
 961                                 if (xydatamin) {
 962                                     mbkfree(xydatamin->DATA);
 963                                     freechain (xydatamin);
 964                                 }
 965                                 if (xydatamax) {
 966                                     mbkfree(xydatamax->DATA);
 967                                     freechain (xydatamax);
 968                                 }
 969                             }
 970                         break;
 971                         case TLF_1D :
 972                             if (nx > 0 && ny > 0)
 973                                 avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
 974                             else {
 975                                 if (TLF_TIME_UNIT == TLF_NS) {
 976                                     if (modelmin)
 977                                         stm_modtbl_set1Dset (modelmin->UMODEL.TABLE, xydatamin, 1e3);
 978                                     stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1e3);
 979                                 }
 980                                 if (TLF_TIME_UNIT == TLF_PS) {
 981                                     if (modelmin)
 982                                         stm_modtbl_set1Dset (modelmin->UMODEL.TABLE, xydatamin, 1);
 983                                     stm_modtbl_set1Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
 984                                 }
 985
 986                                 for (ch = xydatamin; ch; ch = ch->NEXT)
 987                                     mbkfree(ch->DATA);
 988                                 if (xydatamin)
 989                                     freechain (xydatamin);
 990
 991                                 for (ch = xydatamax; ch; ch = ch->NEXT)
 992                                     mbkfree(ch->DATA);
 993                                 if (xydatamax)
 994                                     freechain (xydatamax);
 995                             }
 996                         break;
 997                         case TLF_2D :
 998                             if (nx == 0 || ny == 0)
 999                                 avt_errmsg (STM_ERRMSG, "000", AVT_ERROR, $3);
1000                             else {
1001                                 if (TLF_TIME_UNIT == TLF_NS) {
1002                                     if (modelmin)
1003                                         stm_modtbl_set2Dset (modelmin->UMODEL.TABLE, xydatamin, 1e3);
1004                                     stm_modtbl_set2Dset (modelmax->UMODEL.TABLE, xydatamax, 1e3);
1005                                 }
1006                                 if (TLF_TIME_UNIT == TLF_PS) {
1007                                     if (modelmin)
1008                                         stm_modtbl_set2Dset (modelmin->UMODEL.TABLE, xydatamin, 1);
1009                                     stm_modtbl_set2Dset (modelmax->UMODEL.TABLE, xydatamax, 1);
1010                                 }
1011                                 for (ch = xydatamin; ch; ch = ch->NEXT) {
1012                                     for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1013                                         mbkfree(chp->DATA);
1014                                     freechain (ch->DATA);
1015                                 }
1016                                 if (xydatamin)
1017                                     freechain (xydatamin);
1018                                 for (ch = xydatamax; ch; ch = ch->NEXT) {
1019                                     for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1020                                         mbkfree(chp->DATA);
1021                                     freechain (ch->DATA);
1022                                 }
1023                                 if (xydatamax)
1024                                     freechain (xydatamax);
1025                             }
1026                         break;
1027                     }
1028                 }
1029                 for (ch = xchain; ch; ch = ch->NEXT)
1030                     mbkfree(ch->DATA);
1031                 freechain (xchain);
1032                 for (ch = ychain; ch; ch = ch->NEXT)
1033                     mbkfree(ch->DATA);
1034                 freechain (ychain);
1035              }
1036              ;
1037
1038 modelbody    : modeltype axe axe data
1039              {
1040                 xchain    = $2.CHAIN;
1041                 xtype     = $2.TYPE;
1042                 ychain    = $3.CHAIN;
1043                 ytype     = $3.TYPE;
1044                 xydatamax = NULL;
1045                 for (ch = $4.CHAIN; ch; ch = ch->NEXT) {
1046                     ydatamax = NULL;
1047                     for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1048                         ptfl = (float*)mbkalloc (sizeof (float));
1049                         *ptfl = ((minmax*)chp->DATA)->MAX;
1050                         ydatamax = addchain (ydatamax, ptfl);
1051                     }
1052                     ydatamax = reverse (ydatamax);
1053                     xydatamax = addchain (xydatamax, ydatamax);
1054                 }
1055                 xydatamax = reverse (xydatamax);
1056
1057                 xydatamin = NULL;
1058                 if (((minmax*)(((chain_list*)($4.CHAIN->DATA))->DATA))->MIN != STM_NOVALUE) {
1059                     for (ch = $4.CHAIN; ch; ch = ch->NEXT) {
1060                         ydatamin = NULL;
1061                         for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT) {
1062                             ptfl = (float*)mbkalloc (sizeof (float));
1063                             *ptfl = ((minmax*)chp->DATA)->MIN;
1064                             ydatamin = addchain (ydatamin, ptfl);
1065                         }
1066                         ydatamin = reverse (ydatamin);
1067                         xydatamin = addchain (xydatamin, ydatamin);
1068                     }
1069                     xydatamin = reverse (xydatamin);
1070                 }
1071                 for (ch = $4.CHAIN; ch; ch = ch->NEXT) {
1072                     for (chp = (chain_list*)ch->DATA; chp; chp = chp->NEXT)
1073                         mbkfree ((minmax*)chp->DATA);
1074                     freechain ((chain_list*)ch->DATA);
1075                 }
1076                 freechain (ch);
1077                 dimension = $4.DIM;
1078              }
1079              | modeltype axe data
1080              {
1081                 xchain    = $2.CHAIN;
1082                 xtype     = $2.TYPE;
1083                 ychain    = NULL;
1084                 ytype     = STM_NOTYPE;
1085                 xydatamax = NULL;
1086                 for (ch = $3.CHAIN; ch; ch = ch->NEXT) {
1087                     ptfl = (float*)mbkalloc (sizeof (float));
1088                     *ptfl = ((minmax*)ch->DATA)->MAX;
1089                     xydatamax = addchain (xydatamax, ptfl);
1090                 }
1091                 xydatamax = reverse (xydatamax);
1092                 xydatamin = NULL;
1093                 if (((minmax*)$3.CHAIN->DATA)->MIN != STM_NOVALUE) {
1094                     for (ch = $3.CHAIN; ch; ch = ch->NEXT) {
1095                         ptfl = (float*)mbkalloc (sizeof (float));
1096                         *ptfl = ((minmax*)ch->DATA)->MIN;
1097                         xydatamin = addchain (xydatamin, ptfl);
1098                     }
1099                     xydatamin = reverse (xydatamin);
1100                 }
1101                 for (ch = $3.CHAIN; ch; ch = ch->NEXT) {
1102                     mbkfree ((minmax*)ch->DATA);
1103                 }
1104                 dimension = $3.DIM;
1105              }
1106              | modeltype data
1107              {
1108                 xchain    = NULL;
1109                 xtype     = STM_NOTYPE;
1110                 ychain    = NULL;
1111                 ytype     = STM_NOTYPE;
1112                 xydatamax = NULL;
1113                 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1114                     ptfl = (float*)mbkalloc (sizeof (float));
1115                     *ptfl = ((minmax*)ch->DATA)->MAX;
1116                     xydatamax = addchain (xydatamax, ptfl);
1117                 }
1118                 xydatamax = reverse (xydatamax);
1119                 xydatamin = NULL;
1120                 if (((minmax*)$2.CHAIN->DATA)->MIN != STM_NOVALUE) {
1121                     for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1122                         ptfl = (float*)mbkalloc (sizeof (float));
1123                         *ptfl = ((minmax*)ch->DATA)->MIN;
1124                         xydatamin = addchain (xydatamin, ptfl);
1125                     }
1126                     xydatamin = reverse (xydatamin);
1127                 }
1128                 for (ch = $2.CHAIN; ch; ch = ch->NEXT) {
1129                     mbkfree ((minmax*)ch->DATA);
1130                 }
1131                 dimension = $2.DIM;
1132              }
1133              ;
1134
1135 segment_list : empty
1136              {
1137                 $$ = NULL;
1138              }
1139              | segment segment_list
1140              {
1141                 ptseg = $1;
1142                 $$ = addchain ($2, ptseg);
1143              }
1144              ;
1145
1146 segment      : val ':' val ':' val ':' val
1147              {
1148                 ptseg = (segment*)mbkalloc (sizeof (struct segment));
1149                 ptseg->X0 = $1;
1150                 ptseg->X1 = $3;
1151                 ptseg->INTER = $5;
1152                 ptseg->SLO = $7;
1153                 $$ = ptseg;
1154              }
1155              ;
1156
1157 modeltype    : TLF3_TOKEN_SPLINE
1158              | TLF3_TOKEN_CONST
1159              ;
1160
1161 axe          : '(' axetype val val val_list ')'
1162              {
1163                 ptfl = (float*)mbkalloc (sizeof (float));
1164                 *ptfl = $4;
1165                 $$.CHAIN = addchain ($5, ptfl);
1166                 ptfl = (float*)mbkalloc (sizeof (float));
1167                 *ptfl = $3;
1168                 $$.CHAIN = addchain ($$.CHAIN, ptfl);
1169                 $$.TYPE = $2;
1170              }
1171              ;
1172
1173 axetype      : TLF3_TOKEN_INPUT_SLEW_AXIS
1174              {
1175                 $$ = STM_INPUT_SLEW;
1176              }
1177              | TLF3_TOKEN_CLOCK_SLEW_AXIS
1178              {
1179                 $$ = STM_CLOCK_SLEW;
1180              }
1181              | TLF3_TOKEN_SLEW_AXIS
1182              {
1183                 $$ = STM_INPUT_SLEW;
1184              }
1185              | TLF3_TOKEN_LOAD_AXIS
1186              {
1187                 $$ = STM_LOAD;
1188              }
1189              | TLF3_TOKEN_AXIS
1190              {
1191                 $$ = STM_NOTYPE;
1192              }
1193              ;
1194
1195 cval_list    : empty
1196              {
1197                 $$ = NULL;
1198              }
1199              | cval cval_list
1200              {
1201                 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1202                 ptmm->MIN = $1.MIN;
1203                 ptmm->MAX = $1.MAX;
1204                 $$ = addchain ($2, ptmm);
1205              }
1206              ;
1207
1208 val_list     : empty
1209              {
1210                 $$ = NULL;
1211              }
1212              | val val_list
1213              {
1214                 ptfl = (float*)mbkalloc (sizeof (float));
1215                 *ptfl = $1;
1216                 $$ = addchain ($2, ptfl);
1217              }
1218              ;
1219
1220 data         : TLF3_TOKEN_DATA '(' modeldata ')'
1221              {
1222                 $$ = $3;
1223              }
1224              | '(' modeldata ')'
1225              {
1226                 $$ = $2;
1227              }
1228              | TLF3_TOKEN_DATA modeldata
1229              {
1230                 $$ = $2;
1231              }
1232              | modeldata
1233              {
1234                 $$ = $1;
1235              }
1236              ;
1237
1238 modeldata    : cval
1239              {
1240                 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1241                 ptmm->MIN = $1.MIN;
1242                 ptmm->MAX = $1.MAX;
1243                 $$.CHAIN = addchain (NULL, ptmm);
1244                 $$.DIM = TLF_CONST;
1245              }
1246              | array1D
1247              {
1248                 $$.CHAIN = $1;
1249                 $$.DIM = TLF_1D;
1250              }
1251              | array2D
1252              {
1253                 $$.CHAIN = $1;
1254                 $$.DIM = TLF_2D;
1255              }
1256              ;
1257
1258 array2D      : array1D array1D array1D_list
1259              {
1260                 $$ = addchain ($3, $2);
1261                 $$ = addchain ($$, $1);
1262              }
1263              ;
1264
1265 array1D      : '(' cval cval cval_list ')'
1266              {
1267                 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1268                 ptmm->MIN = $3.MIN;
1269                 ptmm->MAX = $3.MAX;
1270                 $$ = addchain ($4, ptmm);
1271                 ptmm = (minmax*)mbkalloc (sizeof (struct minmax));
1272                 ptmm->MIN = $2.MIN;
1273                 ptmm->MAX = $2.MAX;
1274                 $$ = addchain ($$, ptmm);
1275              }
1276              ;
1277
1278 array1D_list : empty
1279              {
1280                 $$ = NULL;
1281              }
1282              | array1D array1D_list
1283              {
1284                 $$ = addchain ($2, $1);
1285              }
1286              ;
1287
1288 pin          : TLF3_TOKEN_PIN '(' pinname
1289              {
1290                 pname = $3;
1291              }
1292                pintype pindir pinfunc pinenable pntprop_list ')'
1293              {
1294                 int i=0;
1295                 locon_list *c;
1296                 losig_list *s;
1297                 char locondir;
1298
1299                 locondir = $6;
1300
1301
1302                 ptfl = (float*)mbkalloc (sizeof (float));
1303                 *ptfl = pincapa;
1304                 addhtitem (pincapht, pname, (long)ptfl);
1305                 if ($6 == 'I')
1306                     dir = TTV_SIG_CI;
1307
1308                 if ($6 == 'O') {
1309                     if ($5 == 'T') {
1310                         locondir = 'Z';
1311                         dir = TTV_SIG_CZ;
1312                     }
1313                     else
1314                         dir = TTV_SIG_CO;
1315                 }
1316                 if ($6 == 'B') {
1317                     if ($5 == 'T') {
1318                         locondir = 'T';
1319                         dir = TTV_SIG_CT;
1320                     }
1321                     else
1322                         dir = TTV_SIG_CB;
1323                 }
1324                 consigchain = ttv_addrefsig (fig, pname, pname, *ptfl , dir, consigchain);
1325                 nbconsig++;
1326                 if ($5 == 'C')
1327                     clocks = addchain (clocks, pname);
1328                 pincapa = TLF_NO_CAPA;
1329
1330
1331                 /* nouveau connecteur --> LOCON et LOSIG a creer */
1332                 if($5 != 'G') {
1333                     for(c=ptrlofig->LOCON; ((c != NULL) && (strcasecmp(c->NAME,pname) != 0)); c=c->NEXT);
1334                     if(c == NULL) { /* connecteur inexistant, on ajoute signal et connecteur */
1335                         for(s=ptrlofig->LOSIG; (s != NULL); s=s->NEXT) {/* recherche du 1er index de libre */
1336                             if (i < s->INDEX)
1337                                 i = s->INDEX;
1338                         }
1339                         losig_index = i + 1;
1340                         ptrlosig = addlosig(ptrlofig, losig_index, addchain(NULL, pname), 'E');
1341                         ptrlocon = addlocon(ptrlofig, ttv_devect(pname), ptrlosig, locondir);
1342                     }
1343                     else { /* connecteur et signal existants, on redirige le connecteur */
1344                         ptrlocon = c;
1345                         ptrlocon->DIRECTION = locondir;
1346                     }
1347
1348                     if(ptrcbhcomb !=NULL){
1349                         cbh_addcombtolocon(ptrlocon, ptrcbhcomb);
1350                     }
1351                 }
1352
1353                 ptrcbhcomb = NULL;
1354                 ptrlosig = NULL;
1355                 ptrlocon = NULL;
1356
1357              }
1358              | TLF3_TOKEN_PIN '(' vpinname pintype pindir pinfunc vpintprops ')'
1359              {
1360
1361                 for (i = lsb; i <= msb; i++) {
1362                     vectname = namealloc (stm_vect (bname, i));
1363                     ptfl = (float*)mbkalloc (sizeof (float));
1364                     *ptfl = caparray[i - lsb];
1365                     addhtitem (pincapht, vectname, (long)ptfl);
1366                     addhtitem (pincapht, pname, (long)ptfl);
1367                     if ($5 == 'I')
1368                         dir = TTV_SIG_CI;
1369                     if ($5 == 'O') {
1370                         if ($4 == 'T')
1371                             dir = TTV_SIG_CZ;
1372                         else
1373                             dir = TTV_SIG_CO;
1374                     }
1375                     if ($5 == 'B') {
1376                         if ($4 == 'T')
1377                             dir = TTV_SIG_CT;
1378                         else
1379                             dir = TTV_SIG_CB;
1380                     }
1381                     consigchain = ttv_addrefsig (fig, vectname, vectname , *ptfl, dir, consigchain);
1382                     nbconsig++;
1383                     if ($4 == 'C')
1384                         clocks = addchain (clocks, vectname);
1385                 }
1386                 mbkfree(caparray);
1387              }
1388              ;
1389
1390 pintype      : TLF3_TOKEN_PINTYPE '(' TLF3_TOKEN_DATA ')'
1391              {
1392                 $$ = 'D';
1393              }
1394              | TLF3_TOKEN_PINTYPE '(' TLF3_TOKEN_CLOCK ')'
1395              {
1396                 $$ = 'C';
1397              }
1398              | TLF3_TOKEN_PINTYPE '(' TLF3_TOKEN_CLOCK clocktrans ')'
1399              {
1400                 $$ = 'C';
1401              }
1402              | TLF3_TOKEN_PINTYPE '(' TLF3_TOKEN_CONTROL TLF3_TOKEN_ASYNCH clocktrans ')'
1403              {
1404                 $$ = 'H';
1405              }
1406              | TLF3_TOKEN_PINTYPE '(' TLF3_TOKEN_GROUND ')'
1407              {
1408                 $$ = 'G';
1409              }
1410              | TLF3_TOKEN_PINTYPE '(' TLF3_TOKEN_DATA TLF3_TOKEN_TRISTATE ')'
1411              {
1412                 $$ = 'T';
1413              }
1414              ;
1415
1416 pindir       : TLF3_TOKEN_PINDIR '(' TLF3_TOKEN_INPUT ')'
1417              {
1418                 $$ = 'I';
1419              }
1420              | TLF3_TOKEN_PINDIR '(' TLF3_TOKEN_OUTPUT ')'
1421              {
1422                 $$ = 'O';
1423                 ptrcbhcomb = cbh_newcomb();
1424                 ptrcbhcomb->NAME = namealloc(pname);
1425              }
1426              | TLF3_TOKEN_PINDIR '(' TLF3_TOKEN_BIDIR ')'
1427              {
1428                 $$ = 'B';
1429                 ptrcbhcomb = cbh_newcomb();
1430                 ptrcbhcomb->NAME = pname;
1431              }
1432              ;
1433
1434 pinfunc      : empty
1435              {
1436              }
1437              |TLF3_TOKEN_FUNCTION  TLF3_TOKEN_EXPR
1438              {
1439                 char    *str;
1440                 str = eqt_ConvertStr($2);
1441                 ptrcbhcomb->FUNCTION = eqt_StrToAbl(tlfEqtCtx,str);
1442                 mbkfree (str);
1443              }
1444              ;
1445
1446 pinenable    : empty
1447              {
1448              }
1449              |TLF3_TOKEN_ENABLE TLF3_TOKEN_EXPR
1450              {
1451                 char    *str;
1452                 if(ptrcbhcomb != NULL) {
1453                     str = eqt_ConvertStr($2);
1454                     ptrcbhcomb->HZFUNC = notExpr(eqt_StrToAbl(tlfEqtCtx,str));
1455                     mbkfree (str);
1456                 }
1457              }
1458              ;
1459
1460 pntprop_list : empty
1461              | pntprop_list pntprop
1462              ;
1463
1464 pntprop      : TLF3_TOKEN_TIMING_PROPS '(' pincap ')'
1465              {
1466                 pincapa = $3;
1467              }
1468              | TLF3_TOKEN_TIMING_PROPS '(' ')'
1469              ;
1470
1471 vpintprops   : TLF3_TOKEN_TIMING_PROPS '(' forbits_list ')'
1472              {
1473              }
1474              ;
1475
1476 forbits_list : forbits
1477              | forbits_list forbits
1478              ;
1479
1480 forbits      : TLF3_TOKEN_FOR_BITS '(' TLF3_TOKEN_VECT pincap ')'
1481              {
1482                 v = atoi (stm_unquote ($3));
1483                 mbkfree($3);
1484                 if (v <= msb && v >= lsb)
1485                     caparray[v - lsb] = $4;
1486              }
1487              ;
1488
1489 pincap       : TLF3_TOKEN_PIN_CAP '(' val ')'
1490              {
1491                 if (TLF_CAPA_UNIT == TLF_PF)
1492                     $$ = $3 * 1e3;
1493                 if (TLF_CAPA_UNIT == TLF_FF)
1494                     $$ = $3;
1495              }
1496              ;
1497
1498 arc_list     : empty
1499              | arc_list arc
1500              ;
1501
1502 arc          : path
1503              | setup
1504              | hold
1505              ;
1506
1507 speed        : TLF3_TOKEN_FAST
1508              | TLF3_TOKEN_SLOW
1509              | empty
1510              ;
1511
1512 path         : TLF3_TOKEN_PATH '(' pinname "=>" pinname speed transition transition delay slew ')'
1513              {
1514                 if ($7 != 'X' && $8 != 'X') {
1515                     pinn = $3;
1516                     pinr = $5;
1517                     mindlymname = $9.MIN ? $9.MIN : $9.MAX;
1518                     minslwmname = $10.MIN ? $10.MIN : $10.MAX;
1519                     maxdlymname = $9.MAX;
1520                     maxslwmname = $10.MAX;
1521                     signode = (ttvsig_list*)gethtitem (pinht, pinn);
1522                     sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
1523                     if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
1524                         if ($8 == 'U') {
1525                             root = &sigroot->NODE[1];
1526                             otype = elpRISE;
1527                         }
1528                         if ($8 == 'D') {
1529                             root = &sigroot->NODE[0];
1530                             otype = elpFALL;
1531                         }
1532                         if ($7 == 'U') {
1533                             node = &signode->NODE[1];
1534                             itype = elpRISE;
1535                         }
1536                         if ($7 == 'D') {
1537                             node = &signode->NODE[0];
1538                             itype = elpFALL;
1539                         }
1540                         if (isclockpin (clocks, pinn))
1541                             linetype = TTV_LINE_A;
1542                         else
1543                             linetype = 0;
1544                         delaymodelmax = stm_getmodel (cname, maxdlymname);
1545                         stm_mod_shrinkslewaxis (delaymodelmax, thmin, thmax, itype);
1546
1547                         slewmodelmax  = stm_getmodel (cname, maxslwmname);
1548                         stm_mod_shrinkslewaxis (slewmodelmax, thmin, thmax, itype);
1549                         stm_mod_shrinkslewdata (slewmodelmax, thmin, thmax, otype);
1550
1551                         delaymodelmin = stm_getmodel (cname, mindlymname);
1552                         stm_mod_shrinkslewaxis (delaymodelmin, thmin, thmax, itype);
1553
1554                         slewmodelmin  = stm_getmodel (cname, minslwmname);
1555                         stm_mod_shrinkslewaxis (slewmodelmin, thmin, thmax, itype);
1556                         stm_mod_shrinkslewdata (slewmodelmin, thmin, thmax, otype);
1557
1558                         if ($8 == 'D') {
1559                             stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
1560                             stm_mod_update(slewmodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
1561                             stm_mod_update(delaymodelmin, voltage/2.0, voltage, voltage/5.0, 0.0);
1562                             stm_mod_update(slewmodelmin, voltage/2.0, voltage, voltage/5.0, 0.0);
1563                         }else{
1564                             stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
1565                             stm_mod_update(slewmodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
1566                             stm_mod_update(delaymodelmin, voltage/2.0, voltage, voltage/5.0, voltage);
1567                             stm_mod_update(slewmodelmin, voltage/2.0, voltage, voltage/5.0, voltage);
1568                         }
1569
1570                         capa = gethtitem (pincapht, pinr);
1571                         if (capa != EMPTYHT) {
1572                             slwmin = stm_mod_slew (slewmodelmin, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
1573                             dlymin = stm_mod_delay (delaymodelmin, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
1574                             slwmax = stm_mod_slew (slewmodelmax, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
1575                             dlymax = stm_mod_delay (delaymodelmax, *(float*)capa + STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
1576                         } else {
1577                             slwmin = stm_mod_slew (slewmodelmin, STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
1578                             dlymin = stm_mod_delay (delaymodelmin, STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
1579                             slwmax = stm_mod_slew (slewmodelmax, STM_DEF_LOAD, STM_DEF_SLEW, NULL, NULL, "unknown");
1580                             dlymax = stm_mod_delay (delaymodelmax, STM_DEF_LOAD, STM_DEF_SLEW, NULL, "unknown");
1581                         }
1582                         line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_T | linetype);
1583                         ttv_addcaracline (line, maxdlymname,
1584                                                                                               mindlymname,
1585                                                                                               maxslwmname,
1586                                                                                               minslwmname);
1587                         line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_D | linetype);
1588                         ttv_addcaracline (line, maxdlymname,
1589                                                                                               mindlymname,
1590                                                                                               maxslwmname,
1591                                                                                               minslwmname);
1592                     }
1593                 }
1594              }
1595              | TLF3_TOKEN_PATH '(' pinname "=>" pinname speed transition transition constdelay constslew ')'
1596              {
1597                 if ($7 != 'X' && $8 != 'X') {
1598                     pinn = $3;
1599                     pinr = $5;
1600                     dlymin = $9.MIN != STM_NOVALUE ? $9.MIN * 1000 : $9.MAX * 1000;
1601                     slwmin = $10.MIN != STM_NOVALUE ? $10.MIN * 1000 : $10.MAX * 1000;
1602                     dlymax = $9.MAX * 1000;
1603                     slwmax = $10.MAX * 1000;
1604                     signode = (ttvsig_list*)gethtitem (pinht, pinn);
1605                     sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
1606                     if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
1607                         if ($8 == 'U')
1608                             root = &sigroot->NODE[1];
1609                         if ($8 == 'D')
1610                             root = &sigroot->NODE[0];
1611                         if ($7 == 'U')
1612                             node = &signode->NODE[1];
1613                         if ($7 == 'D')
1614                             node = &signode->NODE[0];
1615                         if (isclockpin (clocks, pinn))
1616                             linetype = TTV_LINE_A;
1617                         else
1618                             linetype = 0;
1619                         line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_T | linetype);
1620                         line = ttv_addline (fig, root, node, dlymax*TTV_UNIT, slwmax*TTV_UNIT, dlymin*TTV_UNIT, slwmin*TTV_UNIT, TTV_LINE_D | linetype);
1621                     }
1622                 }
1623              }
1624              ;
1625
1626 setup        : TLF3_TOKEN_SETUP '(' pinname "=>" pinname transition transition constraint ')'
1627              {
1628                 if ($6 != 'X' && $7 != 'X') {
1629                     pinn = $3;
1630                     pinr = $5;
1631                     maxdlymname = $8.MAX;
1632                     sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
1633                     signode = (ttvsig_list*)gethtitem (pinht, pinn);
1634                     if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
1635                         if ($7 == 'U')
1636                             root = &sigroot->NODE[1];
1637                         if ($7 == 'D')
1638                             root = &sigroot->NODE[0];
1639                         if ($6 == 'U') {
1640                             node = &signode->NODE[1];
1641                             itype = elpRISE;
1642                         }
1643                         if ($6 == 'D') {
1644                             node = &signode->NODE[0];
1645                             itype = elpFALL;
1646                         }
1647
1648                         delaymodelmax = stm_getmodel (cname, maxdlymname);
1649                         stm_mod_shrinkslewaxis (delaymodelmax, thmin, thmax, itype);
1650
1651                         if (!delaymodelmax)
1652                             printf ("no model %s\n", maxdlymname);
1653                         maxcstr = stm_mod_constraint (delaymodelmax, STM_DEF_SLEW, STM_DEF_SLEW);
1654                         if (itype == elpFALL) {
1655                             stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
1656                         }else{
1657                             stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
1658                         }
1659                         line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_U);
1660                         ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
1661                         line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_U);
1662                         ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
1663                     }
1664                 }
1665              }
1666              | TLF3_TOKEN_SETUP '(' pinname "=>" pinname transition transition constant ')'
1667              {
1668                 if ($6 != 'X' && $7 != 'X') {
1669                     pinn = $3;
1670                     pinr = $5;
1671                     maxcstr = $8.MAX * 1000;
1672                     sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
1673                     signode = (ttvsig_list*)gethtitem (pinht, pinn);
1674                     if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
1675                         if ($7 == 'U')
1676                             root = &sigroot->NODE[1];
1677                         if ($7 == 'D')
1678                             root = &sigroot->NODE[0];
1679                         if ($6 == 'U')
1680                             node = &signode->NODE[1];
1681                         if ($6 == 'D')
1682                             node = &signode->NODE[0];
1683                         line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_U);
1684                         line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_U);
1685                     }
1686                 }
1687              }
1688              ;
1689
1690 hold         : TLF3_TOKEN_HOLD '(' pinname "=>" pinname transition transition constraint ')'
1691              {
1692                 if ($6 != 'X' && $7 != 'X') {
1693                     pinr = $5;
1694                     pinn = $3;
1695                     maxdlymname = $8.MAX;
1696                     sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
1697                     signode = (ttvsig_list*)gethtitem (pinht, pinn);
1698                     if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
1699                         if ($7 == 'U')
1700                             root = &sigroot->NODE[1];
1701                         if ($7 == 'D')
1702                             root = &sigroot->NODE[0];
1703                         if ($6 == 'U') {
1704                             node = &signode->NODE[1];
1705                             itype = elpRISE;
1706                         }
1707                         if ($6 == 'D') {
1708                             node = &signode->NODE[0];
1709                             itype = elpFALL;
1710                         }
1711
1712                         delaymodelmax = stm_getmodel (cname, maxdlymname);
1713                         stm_mod_shrinkslewaxis (delaymodelmax, thmin, thmax, itype);
1714
1715                         if (!delaymodelmax)
1716                             printf ("no model %s\n", maxdlymname);
1717                         maxcstr = stm_mod_constraint (delaymodelmax, STM_DEF_SLEW, STM_DEF_SLEW);
1718                         if (itype == elpFALL) {
1719                             stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, 0.0);
1720                         }else{
1721                             stm_mod_update(delaymodelmax, voltage/2.0, voltage, voltage/5.0, voltage);
1722                         }
1723                         line = ttv_addline (fig, root, node, TTV_NOTIME, TTV_NOSLOPE, mincstr*TTV_UNIT, 0, TTV_LINE_T | TTV_LINE_O);
1724                         ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
1725                         line = ttv_addline (fig, root, node, TTV_NOTIME, TTV_NOSLOPE, mincstr*TTV_UNIT, 0, TTV_LINE_D | TTV_LINE_O);
1726                         ttv_addcaracline (line, maxdlymname, NULL, NULL, NULL);
1727                     }
1728                 }
1729              }
1730              | TLF3_TOKEN_HOLD '(' pinname "=>" pinname transition transition constant ')'
1731              {
1732                 if ($6 != 'X' && $7 != 'X') {
1733                     pinr = $5;
1734                     pinn = $3;
1735                     maxcstr = $8.MAX * 1000;
1736                     sigroot = (ttvsig_list*)gethtitem (pinht, pinr);
1737                     signode = (ttvsig_list*)gethtitem (pinht, pinn);
1738                     if ((long)sigroot != EMPTYHT && (long)signode != EMPTYHT) {
1739                         if ($7 == 'U')
1740                             root = &sigroot->NODE[1];
1741                         if ($7 == 'D')
1742                             root = &sigroot->NODE[0];
1743                         if ($6 == 'U')
1744                             node = &signode->NODE[1];
1745                         if ($6 == 'D')
1746                             node = &signode->NODE[0];
1747                         line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_T | TTV_LINE_O);
1748                         line = ttv_addline (fig, root, node, maxcstr*TTV_UNIT, 0, TTV_NOTIME, TTV_NOSLOPE, TTV_LINE_D | TTV_LINE_O);
1749                     }
1750                 }
1751              }
1752              ;
1753
1754 transition   : TLF3_TOKEN_10
1755              {
1756                 $$ = 'D';
1757              }
1758              | TLF3_TOKEN_01
1759              {
1760                 $$ = 'U';
1761              }
1762              | TLF3_TOKEN_0Z
1763              {
1764                 $$ = 'X';
1765              }
1766              | TLF3_TOKEN_1Z
1767              {
1768                 $$ = 'X';
1769              }
1770              | TLF3_TOKEN_Z0
1771              {
1772                 $$ = 'D';
1773              }
1774              | TLF3_TOKEN_Z1
1775              {
1776                 $$ = 'U';
1777              }
1778              | clocktrans
1779              {
1780                 $$ = $1;
1781              }
1782              ;
1783
1784 clocktrans   : TLF3_TOKEN_NEGEDGE
1785              {
1786                 $$ = 'D';
1787              }
1788              | TLF3_TOKEN_POSEDGE
1789              {
1790                 $$ = 'U';
1791              }
1792              | TLF3_TOKEN_HIGH
1793              {
1794                 $$ = 'H';
1795              }
1796              | TLF3_TOKEN_LOW
1797              {
1798                 $$ = 'L';
1799              }
1800              ;
1801
1802 constraint   : modelname
1803              {
1804                 if (gethtitem (doublemodels, namealloc ($1)) != EMPTYHT) {
1805                     sprintf (namebuf, "%s_min", $1);
1806                     $$.MIN = namealloc (namebuf);
1807                     sprintf (namebuf, "%s_max", $1);
1808                     $$.MAX = namealloc (namebuf);
1809                 } else {
1810                     $$.MIN = NULL;
1811                     $$.MAX = namealloc ($1);
1812                 }
1813              }
1814              ;
1815
1816 delay        : TLF3_TOKEN_DELAY '(' modelname ')'
1817              {
1818                 if (gethtitem (doublemodels, namealloc ($3)) != EMPTYHT) {
1819                     sprintf (namebuf, "%s_min", $3);
1820                     $$.MIN = namealloc (namebuf);
1821                     sprintf (namebuf, "%s_max", $3);
1822                     $$.MAX = namealloc (namebuf);
1823                 } else {
1824                     $$.MIN = NULL;
1825                     $$.MAX = namealloc ($3);
1826                 }
1827              }
1828              ;
1829
1830 slew         : TLF3_TOKEN_SLEW  '(' modelname ')'
1831              {
1832                 if (gethtitem (doublemodels, namealloc ($3)) != EMPTYHT) {
1833                     sprintf (namebuf, "%s_min", $3);
1834                     $$.MIN = namealloc (namebuf);
1835                     sprintf (namebuf, "%s_max", $3);
1836                     $$.MAX = namealloc (namebuf);
1837                 } else {
1838                     $$.MIN = NULL;
1839                     $$.MAX = namealloc ($3);
1840                 }
1841              }
1842              ;
1843
1844 templatename : empty
1845              {
1846                 $$ = NULL;
1847              }
1848              | ident
1849              {
1850                 $$ = $1;
1851              }
1852              ;
1853
1854 vpinname     : TLF3_TOKEN_VECT_IDENT
1855              {
1856                 bname = stm_basename ($1);
1857                 l = stm_lsb ($1);
1858                 m = stm_msb ($1);
1859                 mbkfree($1);
1860                 lsb = l < m ? l : m;
1861                 msb = m > l ? m : l;
1862                 caparray = (float*)mbkalloc ((msb - lsb + 1) * sizeof (float));
1863                 for (i = 0; i < msb - lsb; i++)
1864                     caparray[i] = TLF_NO_CAPA;
1865              }
1866              ;
1867
1868 pinname      : ident
1869              {
1870                 $$ = $1;
1871              }
1872              ;
1873
1874 modelname    : ident
1875              {
1876                 $$ = $1;
1877              }
1878              ;
1879
1880 cellname     : ident
1881              {
1882                 $$ = $1;
1883              }
1884              ;
1885
1886 constant     : TLF3_TOKEN_CONST '(' cval ')'
1887              {
1888                 $$ = $3;
1889              }
1890              | TLF3_TOKEN_CONST cval
1891              {
1892                 $$ = $2;
1893              }
1894              ;
1895
1896 constdelay   : TLF3_TOKEN_DELAY '(' TLF3_TOKEN_CONST '(' cval ')' ')'
1897              {
1898                 $$ = $5;
1899              }
1900              ;
1901
1902 constslew    : TLF3_TOKEN_SLEW '(' TLF3_TOKEN_CONST '(' cval ')' ')'
1903              {
1904                 $$ = $5;
1905              }
1906              ;
1907
1908 cval         : val ':' val ':' val
1909              {
1910                 $$.MIN = $1;
1911                 $$.MAX = $5;
1912              }
1913              | val ':' ':' val
1914              {
1915                 $$.MIN = $1;
1916                 $$.MAX = $4;
1917              }
1918              | val
1919              {
1920                 $$.MIN = STM_NOVALUE;
1921                 $$.MAX = $1;
1922              }
1923              ;
1924
1925 val          : TLF3_TOKEN_NUMBER
1926              {
1927                 $$ = $1;
1928              }
1929              | TLF3_TOKEN_ENUMBER
1930              {
1931                 $$ = $1;
1932              }
1933              | TLF3_TOKEN_10
1934              {
1935                 $$ = 10 ;
1936              }
1937              | '~'
1938              {
1939                 $$ = 1000000 ;
1940              }
1941              ;
1942
1943 ident        : TLF3_TOKEN_IDENT
1944              {
1945                 $$ = $1;
1946              }
1947              ;
1948
1949 empty        : /* empty */
1950              ;
1951
1952 %%
1953 extern char stbtext[];
1954
1955 int yyerror ()
1956 {
1957     avt_errmsg (STM_ERRMSG, "051", AVT_ERROR, TLF_LINE);
1958     return 0;
1959 }
1960