distrib/sources/inf/inf_drive.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : YAGLE/TAS                                                   */
   6 /*    Fichier : inf_drive.c                                                 */
   7 /*                                                                          */
   8 /*    © copyright 2000 AVERTEC                                              */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : Caroline BLED                                             */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <math.h>
  18 #include <float.h>
  19 #include AVT_H
  20 #include MUT_H
  21 #include INF_H
  22
  23 static int print_mode=0;
  24
  25 void inf_set_print_mode(int val)
  26 {
  27   print_mode=val;
  28 }
  29
  30 static void inf_fprintf(FILE *f, char *fmt, ...)
  31 {
  32   va_list pa;
  33   char buf[32000];
  34   va_start (pa, fmt);
  35   vsprintf(buf, fmt, pa);
  36   va_end(pa);
  37
  38   if (!print_mode)
  39    fprintf(f, "%s", buf);
  40   else
  41    avt_log(LOGCONFIG, print_mode, "%s", buf);
  42 }
  43
  44 /* Functions to format the inf file */
  45 /****************************************************************************/
  46 /*      FUNCTION NAME :  inf_leaveLine                                      */
  47 /*             ARG(1) :  Current file descriptor.                           */
  48 /*             ARG(2) :  Number of lines you want to leave.                 */
  49 /*             RETURN :  NONE.                                              */
  50 /*      FUNCTIONALITY :  Leave lines in the current file.                   */
  51 /****************************************************************************/
  52 void inf_leaveLines (FILE * f, int nb)
  53 {
  54   int i;
  55
  56   for (i = 0; i < nb; i++) {
  57     inf_fprintf (f, "\n");
  58   }
  59 }
  60
  61 /****************************************************************************/
  62 /*      FUNCTION NAME :  inf_tabs                                           */
  63 /*             ARG(1) :  Current file descriptor.                           */
  64 /*             ARG(2) :  Number of tabs you want to have.                   */
  65 /*             RETURN :  NONE.                                              */
  66 /*      FUNCTIONALITY :  prints tabs in the current file.                   */
  67 /****************************************************************************/
  68 void inf_tabs (FILE * f, int nb)
  69 {
  70   int i;
  71
  72   for (i = 0; i < nb; i++) {
  73     inf_fprintf (f, "    ");
  74   }
  75 }
  76
  77 /****************************************************************************/
  78 /*      FUNCTION NAME :  inf_spaces                                         */
  79 /*             ARG(1) :  Current file descriptor.                           */
  80 /*             ARG(2) :  Number of spaces you want to have.                 */
  81 /*             RETURN :  NONE.                                              */
  82 /*      FUNCTIONALITY :  prints spaces in the current file.                 */
  83 /****************************************************************************/
  84 void inf_spaces (FILE * f, int nb)
  85 {
  86   int i;
  87
  88   for (i = 0; i < nb; i++) {
  89     inf_fprintf (f, " ");
  90   }
  91 }
  92
  93 /******************************************************************************/
  94 /*   FUNCTION NAME : inf_reVectName                                           */
  95 /*          ARG(1) : name to revectorize.                                     */
  96 /*          RETURN : name revectorized.                                       */
  97 /*  FUNCTIONNALITY : Searches the space caracter and replace it by braces in  */
  98 /*                   the string given in argument.                            */
  99 /******************************************************************************/
 100 char *inf_reVectName (char *name)
 101 {
 102   return infTasVectName(name);
 103   /*
 104   static char namex[512];
 105   short i = strlen (name);
 106   short j = i - 1;
 107   char vect = 'N';
 108
 109   strcpy (namex, name);
 110
 111   do {
 112     while ((--i != -1) && (namex[i] != ' '))
 113       if (namex[i] == '.')
 114         j = i - 1;
 115
 116     if (i != -1) {
 117       short k;
 118
 119       vect = 'Y';
 120       namex[i] = '[';
 121
 122       for (k = strlen (namex); k != j; k--)
 123         namex[k + 1] = namex[k];
 124
 125       namex[j + 1] = ']';
 126       j = i - 1;
 127     }
 128   }
 129   while (i != -1);
 130
 131   if (vect == 'N')
 132     return (name);
 133   else
 134     return (namex);
 135 */
 136 }
 137
 138
 139 void inf_driveSigChain (FILE * f, char *section, chain_list * lst)
 140 {
 141   inf_fprintf (f, "%s\nBegin\n", section);
 142   while (lst) {
 143     inf_tabs (f, 1);
 144     inf_fprintf (f, "\"%s\" ;\n", inf_reVectName ((char *)lst->DATA));
 145     lst = lst->NEXT;
 146   }
 147   inf_fprintf (f, "End;\n");
 148   inf_leaveLines (f, 1);
 149 }
 150
 151
 152 /******************************************************************************/
 153 /*   FUNCTION NAME : inf_driveRename                                          */
 154 /*          ARG(1) : file descriptor.                                         */
 155 /*          RETURN : NONE.                                                    */
 156 /*  FUNCTIONNALITY : Drives the RENAME section of the INF file from the       */
 157 /*                   INF_RENAME list.                                         */
 158 /******************************************************************************/
 159 void inf_driveRename (FILE * f, inffig_list * ifl)
 160 {
 161   chain_list *list0, *rename;
 162   inf_assoc *assoc;
 163   if (inf_GetPointer (ifl, INF_RENAME, "", (void **)&list0)) {
 164     inf_fprintf (f, "Rename\nBegin\n");
 165     for (rename = list0; rename; rename = rename->NEXT) {
 166       inf_tabs (f, 1);
 167       assoc = (inf_assoc *) rename->DATA;
 168       inf_fprintf (f, "\"%s\" : \"%s\" ;\n", inf_reVectName (assoc->orig), inf_reVectName (assoc->dest));
 169     }
 170     inf_fprintf (f, "End;\n");
 171     inf_leaveLines (f, 1);
 172   }
 173 }
 174 void inf_driveMemsym (FILE * f, inffig_list * ifl)
 175 {
 176   chain_list *list0, *rename;
 177   inf_assoc *assoc;
 178   if (inf_GetPointer (ifl, INF_MEMSYM, "", (void **)&list0)) {
 179     inf_fprintf (f, "Memsym\nBegin\n");
 180     for (rename = list0; rename; rename = rename->NEXT) {
 181       inf_tabs (f, 1);
 182       assoc = (inf_assoc *) rename->DATA;
 183       inf_fprintf (f, "\"%s\" : \"%s\" ;\n", inf_reVectName (assoc->orig), inf_reVectName (assoc->dest));
 184     }
 185     inf_fprintf (f, "End;\n");
 186     inf_leaveLines (f, 1);
 187   }
 188 }
 189
 190 /******************************************************************************/
 191 /*   FUNCTION NAME : inf_driveCklatch                                         */
 192 /*          ARG(1) : file descriptor.                                         */
 193 /*          RETURN : NONE.                                                    */
 194 /*  FUNCTIONNALITY : Drives the CKLATCH section of the INF file from the      */
 195 /*                   INF_CKLATCH list.                                        */
 196 /******************************************************************************/
 197 void inf_driveBinary (FILE * f, inffig_list * ifl, char *section, char *infotype)
 198 {
 199   chain_list *ch;
 200   chain_list *lst0, *lst1;
 201
 202   lst0 = inf_GetEntriesByType (ifl, infotype, INF_YES);
 203   lst1 = inf_GetEntriesByType (ifl, infotype, INF_NO);
 204   if (lst0 || lst1) {
 205     inf_fprintf (f, "%s\nBegin\n", section);
 206     for (ch = lst0; ch; ch = ch->NEXT) {
 207       inf_tabs (f, 1);
 208       inf_fprintf (f, "  \"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 209     }
 210     for (ch = lst1; ch; ch = ch->NEXT) {
 211       inf_tabs (f, 1);
 212       inf_fprintf (f, "~ \"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 213     }
 214     inf_fprintf (f, "End;\n");
 215     inf_leaveLines (f, 1);
 216     freechain (lst0);
 217     freechain (lst1);
 218   }
 219 }
 220
 221 void inf_driveSigListSection (FILE * f, inffig_list * ifl, char *section_name, char *infotype, char *val)
 222 {
 223   chain_list *lst0;
 224
 225   lst0 = inf_GetEntriesByType (ifl, infotype, val);
 226   if (lst0) {
 227     inf_driveSigChain (f, section_name, lst0);
 228     freechain (lst0);
 229   }
 230 }
 231
 232 /******************************************************************************/
 233 /*   FUNCTION NAME : inf_driveCkprech                                         */
 234 /*          ARG(1) : file descriptor.                                         */
 235 /*          RETURN : NONE.                                                    */
 236 /*  FUNCTIONNALITY : Drives the CKPRECH section of the INF file from the      */
 237 /*                   INF_CKPRECH list.                                        */
 238 /******************************************************************************/
 239
 240 chain_list *inf_mergeclist (chain_list * l1, chain_list * l2)
 241 {
 242   chain_list *cl, *ch;
 243   for (cl = l1; cl; cl = cl->NEXT) {
 244     for (ch = l2; ch; ch = ch->NEXT)
 245       if (cl->DATA == ch->DATA)
 246         break;
 247     if (ch == NULL)
 248       l2 = addchain (l2, cl->DATA);
 249   }
 250   freechain (l1);
 251   return l2;
 252 }
 253
 254
 255
 256 void inf_driveCkprech (FILE * f, inffig_list * ifl)
 257 {
 258   chain_list *ch;
 259   chain_list *lst0;
 260
 261   lst0 = inf_GetEntriesByType (ifl, INF_CKPRECH, INF_ANY_VALUES);
 262   if (lst0) {
 263     inf_fprintf (f, "CkPrech\nBegin\n");
 264     for (ch = lst0; ch; ch = ch->NEXT) {
 265       inf_tabs (f, 1);
 266       inf_fprintf (f, "\"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 267     }
 268     inf_fprintf (f, "End;\n");
 269     inf_leaveLines (f, 1);
 270     freechain (lst0);
 271   }
 272 }
 273
 274 void inf_drivePinSlew (FILE * f, inffig_list * ifl)
 275 {
 276   chain_list *ch;
 277   chain_list *lst0, *lst1;
 278   double rise, fall, hv, lv;
 279   char subbuf[64];
 280   lst0 = inf_GetEntriesByType (ifl, INF_PIN_RISING_SLEW, INF_ANY_VALUES);
 281   lst1 = inf_GetEntriesByType (ifl, INF_PIN_HIGH_VOLTAGE, INF_ANY_VALUES);
 282
 283   lst0 = inf_mergeclist (lst0, lst1);
 284   lst1 = inf_GetEntriesByType (ifl, INF_PIN_FALLING_SLEW, INF_ANY_VALUES);
 285   lst0 = inf_SortEntries(inf_mergeclist (lst0, lst1));
 286
 287   if (lst0) {
 288     inf_fprintf (f, "PinSlew\nBegin\n");
 289     for (ch = lst0; ch; ch = ch->NEXT) {
 290       inf_tabs (f, 1);
 291       rise=fall=-1;
 292       inf_GetDouble (ifl, (char *)ch->DATA, INF_PIN_RISING_SLEW, &rise);
 293       inf_GetDouble (ifl, (char *)ch->DATA, INF_PIN_FALLING_SLEW, &fall);
 294       if (!inf_GetDouble (ifl, (char *)ch->DATA, INF_PIN_LOW_VOLTAGE, &lv))
 295         lv = -DBL_MAX;
 296       if (!inf_GetDouble (ifl, (char *)ch->DATA, INF_PIN_HIGH_VOLTAGE, &hv))
 297         hv = -DBL_MAX;
 298
 299       if (hv == -DBL_MAX)
 300         strcpy (subbuf, "");
 301       else if (lv == -DBL_MAX)
 302         sprintf (subbuf, "Supply=%g ", hv);
 303       else
 304         sprintf (subbuf, "Supply=(%g,%g) ", lv, hv);
 305
 306       inf_fprintf (f, "\"%s\" : %sRise=%.1f Fall=%.1f;\n", inf_reVectName ((char *)ch->DATA), subbuf,
 307                rise<0?-1:rise*1e12, fall<0?-1:fall*1e12);
 308     }
 309     inf_fprintf (f, "End;\n");
 310     inf_leaveLines (f, 1);
 311     freechain (lst0);
 312   }
 313 }
 314
 315 /******************************************************************************/
 316 /*   FUNCTION NAME : inf_driveDirout                                          */
 317 /*          ARG(1) : file descriptor.                                         */
 318 /*          RETURN : NONE.                                                    */
 319 /*  FUNCTIONNALITY : Drives the DIROUT section of the INF file from the       */
 320 /*                   INF_DIROUT and INF_NOTDIROUT lists.                      */
 321 /******************************************************************************/
 322 void inf_driveDirout (FILE * f, inffig_list * ifl)
 323 {
 324   chain_list *ch, *list0;
 325   int val;
 326
 327   list0 = inf_GetEntriesByType (ifl, INF_DIROUT, INF_ANY_VALUES);
 328   if (list0) {
 329     inf_fprintf (f, "DirOut\nBegin\n");
 330
 331     for (ch = list0; ch; ch = ch->NEXT) {
 332       inf_tabs (f, 1);
 333       inf_GetInt (ifl, (char *)ch->DATA, INF_DIROUT, &val);
 334       switch (val) {
 335       case -1:
 336         inf_fprintf (f, "~ \"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 337         break;
 338       case 0:
 339         inf_fprintf (f, "  \"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 340         break;
 341       default:
 342         inf_fprintf (f, "  \"%s\" : %d ;\n", inf_reVectName ((char *)ch->DATA), val);
 343         break;
 344       }
 345     }
 346     inf_fprintf (f, "End;\n");
 347     inf_leaveLines (f, 1);
 348     freechain(list0);
 349   }
 350 }
 351
 352 void inf_driveNoCheck (FILE * f, inffig_list * ifl)
 353 {
 354   chain_list *ch, *list0;
 355   int val;
 356   char *st;
 357
 358   list0 = inf_GetEntriesByType (ifl, INF_NOCHECK, INF_ANY_VALUES);
 359   if (list0) {
 360     inf_fprintf (f, "NoCheck\nBegin\n");
 361
 362     for (ch = list0; ch; ch = ch->NEXT) {
 363       inf_tabs (f, 1);
 364       inf_GetInt (ifl, (char *)ch->DATA, INF_NOCHECK, &val);
 365       if ((val & (INF_NOCHECK_SETUP | INF_NOCHECK_HOLD)) == (INF_NOCHECK_SETUP | INF_NOCHECK_HOLD))
 366         st = "All";
 367       else if (val & INF_NOCHECK_SETUP)
 368         st = "Setup";
 369       else if (val & INF_NOCHECK_HOLD)
 370         st = "Hold";
 371       else
 372         st = "";
 373
 374       if (st != "")
 375         inf_fprintf (f, "  \"%s\" %s;\n", inf_reVectName ((char *)ch->DATA), st);
 376     }
 377     inf_fprintf (f, "End;\n");
 378     inf_leaveLines (f, 1);
 379     freechain(list0);
 380   }
 381 }
 382
 383 /******************************************************************************/
 384 /*   FUNCTION NAME : inf_driveMutex                                           */
 385 /*          ARG(1) : file descriptor.                                         */
 386 /*          RETURN : NONE.                                                    */
 387 /*  FUNCTIONNALITY : Drives the MUTEX section of the INF file from the        */
 388 /*                   INF_MUTU, INF_MUTD, INF_CMPU and INF_CMPD lists.         */
 389 /******************************************************************************/
 390 void inf_driveOneMutex (FILE * f, char *header, chain_list * cl)
 391 {
 392   inf_tabs (f, 1);
 393   inf_fprintf (f, "%s  {", header);
 394   while (cl) {
 395     inf_fprintf (f, " \"%s\"", inf_reVectName ((char *)cl->DATA));
 396     if (cl->NEXT)
 397       inf_fprintf (f, ",");
 398     cl = cl->NEXT;
 399   }
 400   inf_fprintf (f, " };\n");
 401 }
 402
 403
 404 void inf_driveMutex (FILE * f, inffig_list * myfig)
 405 {
 406   chain_list *mutex;
 407   chain_list *head0 = NULL, *head1 = NULL, *head2 = NULL, *head3 = NULL;
 408
 409   inf_GetPointer (myfig, INF_MUXU, "", (void **)&head0);
 410   inf_GetPointer (myfig, INF_MUXD, "", (void **)&head1);
 411   inf_GetPointer (myfig, INF_CMPU, "", (void **)&head2);
 412   inf_GetPointer (myfig, INF_CMPD, "", (void **)&head3);
 413
 414   if (head0 || head1 || head2 || head3) {
 415     inf_fprintf (f, "Mutex\nBegin\n");
 416
 417     for (mutex = head0; mutex; mutex = mutex->NEXT) {
 418       inf_driveOneMutex (f, "MuxUP", (chain_list *) mutex->DATA);
 419     }
 420     for (mutex = head1; mutex; mutex = mutex->NEXT) {
 421       inf_driveOneMutex (f, "MuxDN", (chain_list *) mutex->DATA);
 422     }
 423     for (mutex = head2; mutex; mutex = mutex->NEXT) {
 424       inf_driveOneMutex (f, "CmpUP", (chain_list *) mutex->DATA);
 425     }
 426     for (mutex = head3; mutex; mutex = mutex->NEXT) {
 427       inf_driveOneMutex (f, "CmpDN", (chain_list *) mutex->DATA);
 428     }
 429
 430     inf_fprintf (f, "End;\n");
 431     inf_leaveLines (f, 1);
 432   }
 433 }
 434
 435 void inf_driveCrosstalkMutex (FILE * f, inffig_list * myfig)
 436 {
 437   chain_list *mutex;
 438   chain_list *head0 = NULL, *head1 = NULL;
 439
 440   inf_GetPointer (myfig, INF_CROSSTALKMUXU, "", (void **)&head0);
 441   inf_GetPointer (myfig, INF_CROSSTALKMUXD, "", (void **)&head1);
 442
 443   if (head0 || head1) {
 444     inf_fprintf (f, "Crosstalk Mutex\nBegin\n");
 445
 446     for (mutex = head0; mutex; mutex = mutex->NEXT) {
 447       inf_driveOneMutex (f, "MuxUP", (chain_list *) mutex->DATA);
 448     }
 449     for (mutex = head1; mutex; mutex = mutex->NEXT) {
 450       inf_driveOneMutex (f, "MuxDN", (chain_list *) mutex->DATA);
 451     }
 452     inf_fprintf (f, "End;\n");
 453     inf_leaveLines (f, 1);
 454   }
 455 }
 456
 457 /******************************************************************************/
 458 /*   FUNCTION NAME : inf_delSig                                               */
 459 /*          ARG(1) : structure of the signal to delete from the INF_SIGLIST.  */
 460 /*          ARG(2) : head of the INF_SIGLIST.                                 */
 461 /*          ARG(3) : structure before signal to delete.                       */
 462 /*          RETURN : new head of the INF_SIGLIST.                             */
 463 /*  FUNCTIONNALITY : delete a element form the INF_SIGLIST.                   */
 464 /******************************************************************************/
 465 list_list *inf_delSig (list_list * sig, list_list * head, list_list * previous)
 466 {
 467   if (sig == head)
 468     head = sig->NEXT;
 469   else
 470     previous->NEXT = sig->NEXT;
 471
 472   mbkfree (sig);
 473
 474   return head;
 475 }
 476
 477 /******************************************************************************/
 478 /*   FUNCTION NAME : inf_driveConstraint                                      */
 479 /*          ARG(1) : file descriptor.                                         */
 480 /*          RETURN : NONE.                                                    */
 481 /*  FUNCTIONNALITY : Drives the CONSTRAINT section of the INF file from the   */
 482 /*                   INF_SIGLIST list.                                        */
 483 /******************************************************************************/
 484 void inf_driveConstraint (FILE * f, inffig_list * ifl)
 485 {
 486   chain_list *list0, *cl;
 487   int val;
 488   char *name;
 489
 490   list0 = inf_GetEntriesByType (ifl, INF_STUCK, INF_ANY_VALUES);
 491   if (list0) {
 492     inf_fprintf (f, "Constraint\nBegin\n");
 493     for (cl = list0; cl; cl = cl->NEXT) {
 494       name = (char *)cl->DATA;
 495       inf_GetInt (ifl, name, INF_STUCK, &val);
 496       inf_tabs (f, 1);
 497       inf_fprintf (f, "\"%s\" : %d ;\n", inf_reVectName (name), val);
 498     }
 499     inf_fprintf (f, "End;\n");
 500     inf_leaveLines (f, 1);
 501     freechain (list0);
 502   }
 503 }
 504
 505 /******************************************************************************/
 506 /*   FUNCTION NAME : inf_drivePrecharge                                       */
 507 /*          ARG(1) : file descriptor.                                         */
 508 /*          RETURN : NONE.                                                    */
 509 /*  FUNCTIONNALITY : Drives the PRECHARGE section of the INF file from the    */
 510 /*                   INF_SIGLIST list.                                        */
 511 /******************************************************************************/
 512 void inf_drivePrecharge (FILE * f, INF_INFOSET * is)
 513 {
 514   list_list *l;
 515
 516   inf_fprintf (f, "Precharge\nBegin\n");
 517   for (l = is->INF_SIGLIST; l; l = l->NEXT) {
 518     if (l->TYPE == INF_LL_PRECHARGE) {
 519       inf_tabs (f, 1);
 520       inf_fprintf (f, "  \"%s\" ;\n", inf_reVectName ((char *)l->DATA));
 521     }
 522     else if (l->TYPE == INF_LL_NOTPRECHARGE) {
 523       inf_tabs (f, 1);
 524       inf_fprintf (f, "~ \"%s\" ;\n", inf_reVectName ((char *)l->DATA));
 525     }
 526   }
 527   inf_fprintf (f, "End;\n");
 528   inf_leaveLines (f, 1);
 529 }
 530
 531 /******************************************************************************/
 532 /*   FUNCTION NAME : inf_driveBypass                                          */
 533 /*          ARG(1) : file descriptor.                                         */
 534 /*          RETURN : NONE.                                                    */
 535 /*  FUNCTIONNALITY : Drives the BYPASS section of the INF file from the       */
 536 /*                   INF_SIGLIST list.                                        */
 537 /******************************************************************************/
 538 void inf_driveBypass (FILE * f, inffig_list * ifl)
 539 {
 540   chain_list *cl, *list0;
 541   char *name, *val, *code;
 542
 543   list0 = inf_GetEntriesByType (ifl, INF_BYPASS, INF_ANY_VALUES);
 544   if (list0) {
 545     inf_fprintf (f, "Bypass\nBegin\n");
 546     for (cl = list0; cl; cl = cl->NEXT) {
 547       name = (char *)cl->DATA;
 548       inf_GetString (ifl, name, INF_BYPASS, &val);
 549       if (strcmp (val, INF_ALL) == 0)
 550         code = "";
 551       else if (strcmp (val, INF_IN) == 0)
 552         code = " < ";
 553       else if (strcmp (val, INF_OUT) == 0)
 554         code = " > ";
 555       else if (strcmp (val, INF_ONLYEND) == 0)
 556         code = " ! ";
 557       else
 558         code = " ? ";
 559
 560       inf_tabs (f, 1);
 561       inf_fprintf (f, "\"%s\"%s;\n", inf_reVectName (name), code);
 562     }
 563     inf_fprintf (f, "End;\n");
 564     inf_leaveLines (f, 1);
 565     freechain (list0);
 566   }
 567 }
 568
 569 /******************************************************************************/
 570 /*   FUNCTION NAME : inf_driveSigSimple                                       */
 571 /*          ARG(1) : file descriptor.                                         */
 572 /*          ARG(2) : INF TYPE.                                                */
 573 /*          ARG(3) : name of the section to drive.                            */
 574 /*          RETURN : NONE.                                                    */
 575 /*  FUNCTIONNALITY : Drives the corresponding section of the INF file from the*/
 576 /*                   INF_SIGLIST list.                                        */
 577 /******************************************************************************/
 578 void inf_driveSigSimple (FILE * f, long type, char *section, INF_INFOSET * is)
 579 {
 580   list_list *l;
 581
 582   inf_fprintf (f, "%s\nBegin\n", section);
 583   for (l = is->INF_SIGLIST; l; l = l->NEXT) {
 584     if (l->TYPE == type) {
 585       inf_tabs (f, 1);
 586       inf_fprintf (f, "\"%s\" ;\n", inf_reVectName ((char *)l->DATA));
 587     }
 588   }
 589   inf_fprintf (f, "End;\n");
 590   inf_leaveLines (f, 1);
 591 }
 592
 593 /******************************************************************************/
 594 /*   FUNCTION NAME : inf_drivePathsigs                                        */
 595 /*          ARG(1) : file descriptor.                                         */
 596 /*          RETURN : NONE.                                                    */
 597 /*  FUNCTIONNALITY : Drives the PATHSIGS section of the INF file from the     */
 598 /*                   INF_SIGLIST list.                                        */
 599 /******************************************************************************/
 600 void inf_drivePathsigs (FILE * f, INF_INFOSET * is)
 601 {
 602   list_list *l;
 603   ptype_list *p;
 604
 605   inf_fprintf (f, "PathSigs\nBegin\n");
 606   for (l = is->INF_SIGLIST; l; l = l->NEXT) {
 607     if (l->TYPE == INF_LL_PATHSIGS) {
 608       inf_tabs (f, 1);
 609       if (l->USER == NULL)
 610         inf_fprintf (f, "\"%s\" ;\n", inf_reVectName ((char *)l->DATA));
 611       else {
 612         p = (ptype_list *) l->USER;
 613         if (p->TYPE == INF_UP)
 614           inf_fprintf (f, "\"%s\" < UP >;\n", inf_reVectName ((char *)l->DATA));
 615         else if (p->TYPE == INF_DOWN)
 616           inf_fprintf (f, "\"%s\" < DOWN >;\n", inf_reVectName ((char *)l->DATA));
 617       }
 618     }
 619   }
 620   inf_fprintf (f, "End;\n");
 621   inf_leaveLines (f, 1);
 622 }
 623
 624 /******************************************************************************/
 625 /*   FUNCTION NAME : inf_getRange                                             */
 626 /*          ARG(1) : inf_carac structure with values.                         */
 627 /*          RETURN : string with range values.                                */
 628 /*  FUNCTIONNALITY : Check if initially, values was enumerated or specified   */
 629 /*                   with bound in the INF file.                              */
 630 /******************************************************************************/
 631 char *inf_getRange (chain_list * cl, char *s, float factor)
 632 {
 633   double step;
 634   int i;
 635   char bound = 'Y';
 636   char val[50];
 637   double *VALUES;
 638   int NVALUES;
 639
 640   NVALUES = countchain (cl);
 641   VALUES = mbkalloc (sizeof (double) * NVALUES);
 642   for (i = 0; i < NVALUES; i++, cl = cl->NEXT)
 643     VALUES[i] = ((inf_assoc *) cl->DATA)->dval;
 644
 645   step = VALUES[1] - VALUES[0];
 646   for (i = 2; bound == 'Y' && i < NVALUES; i++) {
 647     if (fabs (step - (VALUES[i] - VALUES[i - 1])) > 1e-18)
 648       bound = 'N';
 649   }
 650
 651   if (bound == 'Y') {            /*str = "(low : upper : stp)" */
 652     sprintf (s, "(%g : %g : %g)", VALUES[0] * factor, VALUES[NVALUES - 1] * factor, step * factor);
 653   }
 654   else {                        /* str = "(val1, val2,..., valn)" */
 655     sprintf (s, "(%g", VALUES[0] * factor);
 656     for (i = 1; i < NVALUES; i++) {
 657       strcat (s, ", ");
 658       sprintf (val, "%g", VALUES[i] * factor);
 659       strcat (s, val);
 660     }
 661     strcat (s, ")");
 662   }
 663   mbkfree (VALUES);
 664   return s;
 665 }
 666
 667 /******************************************************************************/
 668 /*   FUNCTION NAME : inf_driveSlopein                                         */
 669 /*          ARG(1) : file descriptor.                                         */
 670 /*          RETURN : NONE.                                                    */
 671 /*  FUNCTIONNALITY : Drives the SLOPEIN section of the INF file from the      */
 672 /*                   INF_SIGLIST list.                                        */
 673 /******************************************************************************/
 674 void inf_driveSlopein (FILE * f, inffig_list * ifl)
 675 {
 676   char buf[2048];
 677   chain_list *list0, *cl, *ch;
 678   char *name;
 679
 680   list0 = inf_GetEntriesByType (ifl, INF_SLOPEIN, INF_ANY_VALUES);
 681   if (list0) {
 682     inf_fprintf (f, "SlopeIN\nBegin\n");
 683     for (cl = list0; cl; cl = cl->NEXT) {
 684       name = (char *)cl->DATA;
 685       inf_tabs (f, 1);
 686       inf_GetPointer (ifl, name, INF_SLOPEIN, (void **)&ch);
 687       inf_getRange (ch, buf, 1e12);
 688       inf_fprintf (f, "\"%s\" : %s ;\n", inf_reVectName (name), buf);
 689     }
 690     inf_fprintf (f, "End;\n");
 691     inf_leaveLines (f, 1);
 692     freechain (list0);
 693   }
 694 }
 695
 696 /******************************************************************************/
 697 /*   FUNCTION NAME : inf_driveCapaout                                         */
 698 /*          ARG(1) : file descriptor.                                         */
 699 /*          RETURN : NONE.                                                    */
 700 /*  FUNCTIONNALITY : Drives the CAPAOUT section of the INF file from the      */
 701 /*                   INF_SIGLIST list.                                        */
 702 /******************************************************************************/
 703 void inf_driveCapaout (FILE * f, inffig_list * ifl)
 704 {
 705   char buf[2048], *name, wl[128];
 706   double lw, l;
 707   chain_list *list0, *cl, *ch;
 708
 709   list0 = inf_GetEntriesByType (ifl, INF_CAPAOUT, INF_ANY_VALUES);
 710   if (list0) {
 711     inf_fprintf (f, "CapaOut\nBegin\n");
 712     for (cl = list0; cl; cl = cl->NEXT) {
 713       name = (char *)cl->DATA;
 714       inf_tabs (f, 1);
 715       inf_GetPointer (ifl, name, INF_CAPAOUT, (void **)&ch);
 716       if (inf_GetDouble (ifl, name, INF_CAPAOUT_LW, &lw)) {
 717         inf_GetDouble (ifl, name, INF_CAPAOUT_L, &l);
 718         sprintf (wl, "L=%g W=%g", l, (l / lw));
 719       }
 720       else
 721         strcpy (wl, "");
 722
 723       inf_getRange (ch, buf, 1e15);
 724       inf_fprintf (f, "\"%s\" : %s %s;\n", inf_reVectName (name), buf, wl);
 725     }
 726     inf_fprintf (f, "End;\n");
 727     inf_leaveLines (f, 1);
 728     freechain (list0);
 729   }
 730 }
 731
 732 void inf_driveOutputCapacitance (FILE * f, inffig_list * ifl)
 733 {
 734   char *name;
 735   double c;
 736   chain_list *list0, *cl;
 737
 738   list0 = inf_GetEntriesByType (ifl, INF_OUTPUT_CAPACITANCE, INF_ANY_VALUES);
 739   if (list0) {
 740     inf_fprintf (f, "Output Capacitance\nBegin\n");
 741     for (cl = list0; cl; cl = cl->NEXT) {
 742       name = (char *)cl->DATA;
 743       inf_tabs (f, 1);
 744       inf_GetDouble (ifl, name, INF_OUTPUT_CAPACITANCE, &c);
 745       inf_fprintf (f, "\"%s\" : %g;\n", inf_reVectName (name), c*1e15);
 746     }
 747     inf_fprintf (f, "End;\n");
 748     inf_leaveLines (f, 1);
 749     freechain (list0);
 750   }
 751 }
 752
 753 /******************************************************************************/
 754 /*   FUNCTION NAME : inf_driveFalsepath                                       */
 755 /*          ARG(1) : file descriptor.                                         */
 756 /*          RETURN : NONE.                                                    */
 757 /*  FUNCTIONNALITY : Drives the FALSEPATH section of the INF file from the    */
 758 /*                   INF_FALSEPATH list.                                      */
 759 /******************************************************************************/
 760 void inf_driveFalsepath (FILE * f, INF_INFOSET * is)
 761 {
 762   chain_list *ch;
 763   ptype_list *p;
 764   char *name;
 765
 766   inf_fprintf (f, "FalsePath\nBegin\n");
 767   for (ch = is->INF_FALSEPATH; ch; ch = ch->NEXT) {
 768     inf_tabs (f, 1);
 769     for (p = (ptype_list *) ch->DATA; p; p = p->NEXT) {
 770       name=(char *)p->DATA;
 771       switch (p->TYPE) {
 772       case INF_UPDOWN:
 773         inf_fprintf (f, "\"%s\"", inf_reVectName (name));
 774         break;
 775       case INF_UP:
 776         inf_fprintf (f, "\"%s\" < UP >", inf_reVectName (name));
 777         break;
 778       case INF_DOWN:
 779         inf_fprintf (f, "\"%s\" < DOWN >", inf_reVectName (name));
 780         break;
 781       case INF_NOTHING:
 782         inf_fprintf (f, "< VOID >");
 783         break;
 784       case INF_CK:
 785         if (name[0]=='^')
 786           inf_fprintf (f, ": < HZ >");
 787         else if (name[0]=='°')
 788           inf_fprintf (f, ": < NOTHZ >");
 789         else
 790           inf_fprintf (f, ": \"%s\"", inf_reVectName (name));
 791         break;
 792       }
 793       inf_spaces (f, 1);
 794     }
 795     inf_fprintf (f, ";\n");
 796   }
 797   inf_fprintf (f, "End;\n");
 798   inf_leaveLines (f, 1);
 799 }
 800
 801 void inf_driveFalseslack (FILE * f, INF_INFOSET * is)
 802 {
 803   chain_list *ch;
 804   ptype_list *p;
 805   int type;
 806   char *prev="";
 807
 808   inf_fprintf (f, "FalseSlack\nBegin\n");
 809   for (ch = is->INF_FALSESLACK; ch; ch = ch->NEXT) {
 810     inf_tabs (f, 1);
 811     type=((ptype_list *) ch->DATA)->TYPE & (INF_FALSESLACK_SETUP|INF_FALSESLACK_HOLD|INF_FALSESLACK_LATCH);
 812     if (type & INF_FALSESLACK_LATCH) { inf_fprintf (f, "LATCH"); prev="-"; }
 813     if (type & INF_FALSESLACK_PRECH) { inf_fprintf (f, "%sPRECH", prev); prev="-"; }
 814     if ((type & (INF_FALSESLACK_SETUP|INF_FALSESLACK_HOLD))!=(INF_FALSESLACK_SETUP|INF_FALSESLACK_HOLD))
 815     {
 816       if (type & INF_FALSESLACK_SETUP) inf_fprintf (f, "%sSETUP", prev);
 817       else inf_fprintf (f, "%sHOLD", prev);
 818       prev="-";
 819     }
 820     if (strlen(prev)!=0) inf_fprintf (f, " :");
 821
 822     for (p = (ptype_list *) ch->DATA; p; p = p->NEXT) {
 823       inf_fprintf (f, " \"%s\"", inf_reVectName ((char *)p->DATA));
 824       if ((p->TYPE & (INF_FALSESLACK_UP|INF_FALSESLACK_DOWN))!=(INF_FALSESLACK_UP|INF_FALSESLACK_DOWN))
 825       {
 826         if (p->TYPE & INF_FALSESLACK_UP) inf_fprintf (f, " < UP >");
 827         else inf_fprintf (f, " < DOWN >");
 828       }
 829       if ((p->TYPE & (INF_FALSESLACK_HZ|INF_FALSESLACK_NOTHZ))!=(INF_FALSESLACK_HZ|INF_FALSESLACK_NOTHZ))
 830       {
 831         if (p->TYPE & INF_FALSESLACK_HZ) inf_fprintf (f, " < HZ >");
 832         else if (p->TYPE & INF_FALSESLACK_NOTHZ) inf_fprintf (f, " < NOTHZ >");
 833       }
 834     }
 835     inf_fprintf (f, ";\n");
 836   }
 837   inf_fprintf (f, "End;\n");
 838   inf_leaveLines (f, 1);
 839 }
 840
 841 void inf_driveProba (FILE * f, inffig_list * ifl)
 842 {
 843   char *name;
 844   double val;
 845   chain_list *list0, *cl;
 846
 847   list0 = inf_GetEntriesByType (ifl, INF_SWITCHING_PROBABILITY, INF_ANY_VALUES);
 848   if (list0) {
 849     inf_fprintf (f, "SwitchingProbability\nBegin\n");
 850     for (cl = list0; cl; cl = cl->NEXT) {
 851       name = (char *)cl->DATA;
 852       inf_GetDouble (ifl, name, INF_SWITCHING_PROBABILITY, &val);
 853       inf_tabs (f, 1);
 854       inf_fprintf (f, "\"%s\" : %g;\n", inf_reVectName (name), val);
 855     }
 856     inf_fprintf (f, "End;\n");
 857     inf_leaveLines (f, 1);
 858     freechain (list0);
 859   }
 860 }
 861
 862 /******************************************************************************/
 863 /*   FUNCTION NAME : inf_driveDelay                                           */
 864 /*          ARG(1) : file descriptor.                                         */
 865 /*          RETURN : NONE.                                                    */
 866 /*  FUNCTIONNALITY : Drives the DELAY section of the INF file from the        */
 867 /*                   INF_DELAY list.                                          */
 868 /******************************************************************************/
 869 void inf_driveDelay (FILE * f, inffig_list * ifl)
 870 {
 871   chain_list *delay, *ch;
 872   inf_assoc *assoc;
 873
 874   if (inf_GetPointer (ifl, INF_DELAY, "", (void **)&delay)) {
 875     inf_fprintf (f, "Delay\nBegin\n");
 876     for (ch = delay; delay; delay = delay->NEXT) {
 877       inf_tabs (f, 1);
 878       assoc = (inf_assoc *) delay->DATA;
 879       inf_fprintf (f, "\"%s\" : \"%s\" : %.1fps ;\n", inf_reVectName (assoc->orig), inf_reVectName (assoc->dest),
 880                assoc->dval * 1e12);
 881     }
 882     inf_fprintf (f, "End;\n");
 883     inf_leaveLines (f, 1);
 884   }
 885 }
 886
 887 /******************************************************************************/
 888 /*   FUNCTION NAME : inf_driveDlatch                                          */
 889 /*          ARG(1) : file descriptor.                                         */
 890 /*          RETURN : NONE.                                                    */
 891 /*  FUNCTIONNALITY : Drives the DLATCH section of the INF file from the       */
 892 /*                   INF_DLATCH and INF_NOTDLATCH lists.                      */
 893 /******************************************************************************/
 894 void inf_driveDlatch (FILE * f, inffig_list * ifl)
 895 {
 896   chain_list *ch;
 897   chain_list *list0, *list1;
 898
 899   list0 = inf_GetEntriesByType (ifl, INF_DLATCH, INF_YES);
 900   list1 = inf_GetEntriesByType (ifl, INF_DLATCH, INF_NO);
 901
 902   if (list0 || list1) {
 903     inf_fprintf (f, "Dlatch\nBegin\n");
 904     for (ch = list1; ch; ch = ch->NEXT) {
 905       inf_tabs (f, 1);
 906       inf_fprintf (f, "~ \"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 907     }
 908
 909     for (ch = list0; ch; ch = ch->NEXT) {
 910       inf_tabs (f, 1);
 911       inf_fprintf (f, "  \"%s\" ;\n", inf_reVectName ((char *)ch->DATA));
 912     }
 913     inf_fprintf (f, "End;\n");
 914     inf_leaveLines (f, 1);
 915     freechain(list0);
 916     freechain(list1);
 917   }
 918 }
 919
 920 /******************************************************************************/
 921 /*   FUNCTION NAME : inf_driveSiglist                                         */
 922 /*          ARG(1) : file descriptor.                                         */
 923 /*          RETURN : NONE.                                                    */
 924 /*  FUNCTIONNALITY :                                        */
 925 /******************************************************************************/
 926 void inf_driveSiglist (FILE * f, INF_INFOSET * is)
 927 {
 928   list_list *l;
 929   int inf_driven[INF_NB_SIGTYPE];
 930   int i;
 931
 932
 933   for (i = 0; i < INF_NB_SIGTYPE; i++)
 934     inf_driven[i] = 0;
 935
 936   for (l = is->INF_SIGLIST; l; l = l->NEXT) {
 937     switch (l->TYPE) {
 938     case INF_LL_PATHSIGS:
 939       if (inf_driven[INF_LL_PATHSIGS] == 0) {
 940         inf_drivePathsigs (f, is);
 941         inf_driven[INF_LL_PATHSIGS] = 1;
 942       }
 943       break;
 944     default:
 945       is->INF_SIGLIST = is->INF_SIGLIST->NEXT;
 946       break;
 947     }
 948   }
 949 }
 950
 951 void infDriveStbDefault (FILE * f, inffig_list * myfig)
 952 {
 953   double val = -1;
 954   if (inf_GetDouble (myfig, INF_STB_HEADER, INF_DEFAULT_PERIOD, &val))
 955     inf_fprintf (f, "Period %.1f;\n", val * 1e12);
 956   if (inf_GetDouble (myfig, INF_STB_HEADER, INF_SETUPMARGIN, &val))
 957     inf_fprintf (f, "SetupTime %.1f;\n", val * 1e12);
 958   if (inf_GetDouble (myfig, INF_STB_HEADER, INF_HOLDMARGIN, &val))
 959     inf_fprintf (f, "HoldTime %.1f;\n", val * 1e12);
 960   if (val != -1)
 961     inf_fprintf (f, "\n");
 962 }
 963
 964
 965 void infDriveLatencies (FILE * f, inffig_list * ifl)
 966 {
 967   chain_list *list, *chainx;
 968   double val1=0, val2=0, val3=0, val4=0;
 969   char *name;
 970   // clock
 971   list          = inf_GetEntriesByType(ifl,INF_LATENCY_FALL_MIN,INF_ANY_VALUES);
 972   list=inf_mergeclist(list, inf_GetEntriesByType(ifl,INF_LATENCY_FALL_MAX,INF_ANY_VALUES));
 973   list=inf_mergeclist(list, inf_GetEntriesByType(ifl,INF_LATENCY_RISE_MIN,INF_ANY_VALUES));
 974   list=inf_mergeclist(list, inf_GetEntriesByType(ifl,INF_LATENCY_RISE_MAX,INF_ANY_VALUES));
 975   if (list!=NULL)
 976   {
 977      inf_fprintf (f, "ClockLatencies\nBegin\n");
 978      for (chainx = list; chainx; chainx = delchain(chainx,chainx))
 979      {
 980        val1=0, val2=0, val3=0, val4=0;
 981        name=(char *)chainx->DATA;
 982        inf_GetDouble(ifl, name, INF_LATENCY_FALL_MIN, &val3);
 983        inf_GetDouble(ifl, name, INF_LATENCY_FALL_MAX, &val4);
 984        inf_GetDouble(ifl, name, INF_LATENCY_RISE_MIN, &val1);
 985        inf_GetDouble(ifl, name, INF_LATENCY_RISE_MAX, &val2);
 986        inf_tabs (f, 1);
 987        inf_fprintf (f, "\"%s\" : %.1f  %.1f  %.1f  %.1f;\n", inf_reVectName (name), val1*1e12, val2*1e12, val3*1e12, val4*1e12);
 988
 989      }
 990     inf_fprintf (f, "End;\n");
 991     inf_leaveLines (f, 1);
 992   }
 993 }
 994
 995 void infDriveStbClocks (FILE * f, inffig_list * myfig)
 996 {
 997   chain_list *lst0, *cl;
 998   char *name, *inverted, *virt, *ideal, *master;
 999   int edges;
1000   double minr, maxr, minf, maxf, per;
1001   int strip, val;
1002   lst0 = inf_GetEntriesByType (myfig, INF_CLOCK_TYPE, INF_ANY_VALUES);
1003   if (lst0) {
1004     inf_fprintf (f, "Clock Connectors\nBegin\n");
1005     for (cl = lst0; cl; cl = cl->NEXT) {
1006       name = (char *)cl->DATA;
1007       inverted = virt = ideal = "";
1008       if (inf_GetInt (myfig, name, INF_CLOCK_TYPE, &val)) {
1009         if ((val & INF_CLOCK_INVERTED) != 0)
1010           inverted = "! ";
1011         if ((val & INF_CLOCK_VIRTUAL) != 0)
1012           virt = "Virtual ";
1013         if ((val & INF_CLOCK_IDEAL) != 0)
1014           ideal = "Ideal ";
1015       }
1016
1017       if (!inf_GetDouble (myfig, name, INF_MIN_RISE_TIME, &minr)
1018           || !inf_GetDouble (myfig, name, INF_MAX_RISE_TIME, &maxr)
1019           || !inf_GetDouble (myfig, name, INF_MIN_FALL_TIME, &minf)
1020           || !inf_GetDouble (myfig, name, INF_MAX_FALL_TIME, &maxf))
1021         strip = 1;
1022       else
1023         strip = 0;
1024       if (!inf_GetDouble (myfig, name, INF_CLOCK_PERIOD, &per))
1025         per = -1;
1026       inf_tabs (f, 1);
1027       if (!strip) {
1028         inf_fprintf (f, "%s%s%s\"%s\" : Up", virt, ideal, inverted, inf_reVectName (name));
1029         if (fabs (minr - maxr) > 1e-17)
1030           inf_fprintf (f, " (%.1f:%.1f); Down", minr * 1e12, maxr * 1e12);
1031         else
1032           inf_fprintf (f, " %.1f; Down", minr * 1e12);
1033         if (fabs (minf - maxf) > 1e-17)
1034           inf_fprintf (f, " (%.1f:%.1f);", minf * 1e12, maxf * 1e12);
1035         else
1036           inf_fprintf (f, " %.1f;", minf * 1e12);
1037         if (per != -1)
1038           inf_fprintf (f, " Period %.1f;", per * 1e12);
1039
1040         if (inf_GetString (myfig, name, INF_MASTER_CLOCK, &master) && master!=NULL)
1041         {
1042            if (!inf_GetInt (myfig, name, INF_MASTER_CLOCK_EDGES, &edges)) edges=0;
1043            inf_fprintf (f, " Clock \"%s\" %s %s ;", inf_reVectName (master), (edges & 2)?"UP":"DOWN", (edges & 1)?"UP":"DOWN");
1044         }
1045       }
1046       else
1047         inf_fprintf (f, "%s%s%s\"%s\";", virt, ideal, inverted, inf_reVectName (name));
1048       inf_fprintf (f, "\n");
1049     }
1050     inf_fprintf (f, "End;\n\n");
1051   }
1052   freechain (lst0);
1053 }
1054
1055 static char *__getedge (char val)
1056 {
1057   if (val == INF_STB_RISING)
1058     return " Rising";
1059   if (val == INF_STB_FALLING)
1060     return " Falling";
1061   if (val == INF_STB_SLOPEALL)
1062     return "";
1063   return "?";
1064 }
1065
1066 static char *__getstab (char val)
1067 {
1068   if (val == INF_STB_STABLE)
1069     return "Stable";
1070   if (val == INF_STB_UNSTABLE)
1071     return "Unstable";
1072   return "?";
1073 }
1074
1075 static char *__getrel (char val)
1076 {
1077   if (val == INF_STB_BEFORE)
1078     return "Before";
1079   if (val == INF_STB_AFTER)
1080     return "After";
1081   return "?";
1082 }
1083
1084 static char *__gethz (char val)
1085 {
1086   if (val == INF_STB_NOTHING)
1087     return "";
1088   if (val == INF_STB_HZ_NO_PRECH)
1089     return " Without Precharge";
1090   if (val == INF_STB_HZ_NO_PRECH)
1091     return " Without Evaluate";
1092   return "?";
1093 }
1094
1095 void infDriveStbSpec (FILE * f, inf_stb_p_s * isps, char *signame)
1096 {
1097   inf_stb_p_s_stab *stab;
1098   char *rel;
1099
1100   while (isps) {
1101     inf_tabs (f, 1);
1102     inf_fprintf (f, "\"%s\"%s", inf_reVectName (signame), __getedge (isps->DATAEDGE));
1103     if (isps->SPECTYPE == INF_STB_SPECOUT)
1104       rel = "For";
1105     else
1106       rel = "From";
1107
1108     if (isps->CKNAME)
1109       inf_fprintf (f, " %s \"%s\" %s", rel, inf_reVectName (isps->CKNAME), __getedge (isps->CKEDGE));
1110     inf_fprintf (f, "%s:\n", __gethz (isps->HZOPTION));
1111
1112     for (stab = isps->STABILITY; stab; stab = stab->NEXT) {
1113       inf_tabs (f, 2);
1114       if (stab->CKNAME == NULL) {
1115         chain_list *cl;
1116         inf_fprintf (f, "%s", __getstab (stab->STABILITY));
1117         for (cl = stab->TIME_LIST; cl; cl = cl->NEXT)
1118           inf_fprintf (f, " %.1f", *(double *)cl->DATA * 1e12);
1119         inf_fprintf (f, ";\n");
1120       }
1121       else
1122         inf_fprintf (f, "%s %.1f %s \"%s\" %s;\n",
1123                  __getstab (stab->STABILITY),
1124                  stab->DELAY * 1e12,
1125                  __getrel (stab->RELATIVITY),
1126                  stab->CKNAME ? inf_reVectName (stab->CKNAME) : "?", __getedge (stab->CKEDGE));
1127     }
1128     isps = isps->NEXT;
1129   }
1130 }
1131
1132 void infDriveStbSpecSection (FILE * f, inffig_list * myfig, char *section, char *header)
1133 {
1134   chain_list *lst0, *cl;
1135   char *name;
1136   inf_stb_p_s *head;
1137
1138   lst0 = inf_GetEntriesByType (myfig, section, INF_ANY_VALUES);
1139   if (lst0) {
1140     inf_fprintf (f, "%s\nBegin\n", header);
1141     for (cl = lst0; cl; cl = cl->NEXT) {
1142       name = (char *)cl->DATA;
1143       if (inf_GetPointer (myfig, name, section, (void **)&head)) {
1144         infDriveStbSpec (f, head, name);
1145       }
1146     }
1147
1148     inf_fprintf (f, "End;\n\n");
1149     freechain(lst0);
1150   }
1151 }
1152
1153 void infDriveStbGroups (FILE * f, inffig_list * myfig, char *header, char *section, char *periodsection)
1154 {
1155   chain_list *list, *chainx, *namelist;
1156   char *domainname;
1157   double val;
1158   list = inf_GetValuesByType (myfig, section);
1159   if (list) {
1160     inf_fprintf (f, "%s\nBegin\n", header);
1161     for (chainx = list; chainx; chainx = delchain (chainx, chainx)) {
1162       domainname = (char *)chainx->DATA;
1163       inf_tabs (f, 1);
1164       inf_fprintf (f, "\"%s\":", domainname);
1165       for (namelist = inf_GetEntriesByType (myfig, section, domainname);
1166            namelist; namelist = delchain (namelist, namelist)) {
1167         inf_fprintf (f, " \"%s\"", inf_reVectName ((char *)namelist->DATA));
1168         if (namelist->NEXT)
1169           inf_fprintf (f, ",");
1170       }
1171       inf_fprintf (f, ";");
1172       if (periodsection && inf_GetDouble (myfig, periodsection, domainname, &val))
1173         inf_fprintf (f, " Period %.1f;", val * 1e12);
1174       inf_fprintf (f, "\n");
1175     }
1176     inf_fprintf (f, "End;\n\n");
1177   }
1178 }
1179
1180 void infDriveStbPriorityClock (FILE * f, inffig_list * myfig)
1181 {
1182   // priority clock
1183   char *def;
1184   chain_list *chainx, *list;
1185
1186   list = inf_GetEntriesByType (myfig, INF_PREFERED_CLOCK, INF_ANY_VALUES);
1187   if (list) {
1188     inf_fprintf (f, "Multiple Clock Priority\nBegin\n");
1189     for (chainx = list, list = NULL; chainx; chainx = delchain (chainx, chainx)) {
1190       inf_GetString (myfig, (char *)chainx->DATA, INF_PREFERED_CLOCK, &def);
1191       inf_tabs (f, 1);
1192       inf_fprintf (f, " \"%s\" : \"%s\";\n", inf_reVectName ((char *)chainx->DATA), inf_reVectName (def));
1193     }
1194     inf_fprintf (f, "End;\n\n");
1195   }
1196 }
1197
1198 void infDriveStbDisable (FILE * f, inffig_list * myfig)
1199 {
1200   chain_list *chainx, *list;
1201   inf_assoc *assoc;
1202   if (inf_GetPointer (myfig, INF_DISABLE_PATH, "", (void **)&list)) {
1203     inf_fprintf (f, "Disable\nBegin\n");
1204     for (chainx = list; chainx; chainx = chainx->NEXT) {
1205       assoc = (inf_assoc *) chainx->DATA;
1206       inf_tabs (f, 1);
1207       if (assoc->orig)
1208         inf_fprintf (f, "From \"%s\"", inf_reVectName (assoc->orig));
1209       if (assoc->dest)
1210         inf_fprintf (f, "%sTo \"%s\"", assoc->orig ? " " : "", inf_reVectName (assoc->dest));
1211       inf_fprintf (f, ";\n");
1212     }
1213     inf_fprintf (f, "End;\n\n");
1214   }
1215 }
1216
1217 void infDriveStbCommandState (FILE * f, inffig_list * myfig)
1218 {
1219   chain_list *chainx, *list;
1220   char *name, *def, *state;
1221   list = inf_GetEntriesByType (myfig, INF_VERIF_STATE, INF_ANY_VALUES);
1222   if (list) {
1223     inf_fprintf (f, "Conditioned Command States\nBegin\n");
1224     for (chainx = list; chainx; chainx = delchain (chainx, chainx)) {
1225       name = (char *)chainx->DATA;
1226       inf_tabs (f, 1);
1227       inf_fprintf (f, "\"%s\" : ", inf_reVectName (name));
1228       inf_GetString (myfig, name, INF_VERIF_STATE, &def);
1229       if (strcmp (def, INF_VERIFUP) == 0)
1230         state = "Up";
1231       else if (strcmp (def, INF_VERIFDOWN) == 0)
1232         state = "Down";
1233       else if (strcmp (def, INF_VERIFRISE) == 0)
1234         state = "Rising";
1235       else if (strcmp (def, INF_VERIFFALL) == 0)
1236         state = "Falling";
1237       else if (strcmp (def, INF_NOVERIF) == 0)
1238         state = "NoVerif";
1239       else {
1240         inf_fprintf (f, "?");
1241         continue;
1242       }
1243
1244       inf_fprintf (f, "%s;\n", state);
1245     }
1246     inf_fprintf (f, "End;\n\n");
1247   }
1248 }
1249
1250 void infDriveDirectives (FILE * f, inffig_list * myfig)
1251 {
1252   chain_list *chainx, *list;
1253   inf_assoc *assoc;
1254   splitint *si;
1255   int val;
1256
1257   if (inf_GetPointer (myfig, INF_DIRECTIVES, "", (void **)&list)) {
1258     inf_fprintf (f, "Directives\nBegin\n");
1259     for (chainx = list; chainx; chainx = chainx->NEXT) {
1260       assoc = (inf_assoc *) chainx->DATA;
1261       val=assoc->lval;
1262       si=(splitint *)&val;
1263
1264       inf_tabs (f, 1);
1265       if (si->cval.a & INF_DIRECTIVE_FILTER)
1266         inf_fprintf (f, "Filter: ");
1267       else
1268         inf_fprintf (f, "Check: ");
1269
1270
1271       if (si->cval.b & INF_DIRECTIVE_CLOCK) inf_fprintf (f, "Clock ");
1272       inf_fprintf (f, "\"%s\" ", inf_reVectName (assoc->orig));
1273       if (si->cval.b & INF_DIRECTIVE_UP) inf_fprintf (f, "Up ");
1274       else if (si->cval.b & INF_DIRECTIVE_DOWN) inf_fprintf (f, "Down ");
1275       else if (si->cval.b & INF_DIRECTIVE_RISING) inf_fprintf (f, "Rising ");
1276       else if (si->cval.b & INF_DIRECTIVE_FALLING) inf_fprintf (f, "Falling ");
1277
1278       if (si->cval.c & INF_DIRECTIVE_BEFORE) inf_fprintf (f, "Before ");
1279       else if (si->cval.c & INF_DIRECTIVE_AFTER) inf_fprintf (f, "After ");
1280       else inf_fprintf (f, "With ");
1281
1282       if ((si->cval.d & INF_DIRECTIVE_DELAY)==0)
1283       {
1284         if (si->cval.d & INF_DIRECTIVE_CLOCK) inf_fprintf (f, "Clock ");
1285         inf_fprintf (f, "\"%s\" ", inf_reVectName (assoc->dest));
1286
1287         if (assoc->dval!=0) inf_fprintf (f, "Margin %.1f", assoc->dval* 1e12);
1288       }
1289       else
1290       {
1291         inf_fprintf (f, "Delay %.1f From \"%s\" ", assoc->dval* 1e12, assoc->dest);
1292       }
1293       if (si->cval.d & INF_DIRECTIVE_UP) inf_fprintf (f, "Up ");
1294       else if (si->cval.d & INF_DIRECTIVE_DOWN) inf_fprintf (f, "Down ");
1295       else if (si->cval.d & INF_DIRECTIVE_RISING) inf_fprintf (f, "Rising ");
1296       else if (si->cval.d & INF_DIRECTIVE_FALLING) inf_fprintf (f, "Falling ");
1297
1298       inf_fprintf (f, ";\n");
1299     }
1300     inf_fprintf (f, "End;\n\n");
1301   }
1302 }
1303
1304
1305 void infDriveStb (FILE * f, inffig_list * myfig)
1306 {
1307 //  inf_fprintf (f, "#-=> parameters\n\n");
1308   infDriveStbDefault (f, myfig);
1309 //  inf_fprintf (f, "#-=> clock definitions\n\n");
1310   infDriveStbClocks (f, myfig);
1311   infDriveLatencies (f, myfig);
1312 //  inf_fprintf (f, "#-=> asynchronous clock groups\n\n");
1313   infDriveStbGroups (f, myfig, "Asynchronous Clock Groups", INF_ASYNC_CLOCK_GROUP, INF_ASYNC_CLOCK_GROUP_PERIOD);
1314 //  inf_fprintf (f, "#-=> equivalent clock groups\n\n");
1315   infDriveStbGroups (f, myfig, "Equivalent Clock Groups", INF_EQUIV_CLOCK_GROUP, NULL);
1316 //  inf_fprintf (f, "#-=> prefered clock\n\n");
1317   infDriveStbPriorityClock (f, myfig);
1318 //  inf_fprintf (f, "#-=> command state\n\n");
1319   infDriveStbCommandState (f, myfig);
1320 //  inf_fprintf (f, "#-=> disabled paths\n\n");
1321   infDriveStbDisable (f, myfig);
1322 //  inf_fprintf (f, "#-=> input specifications\n\n");
1323   infDriveStbSpecSection (f, myfig, INF_SPECIN, "Specify Input Connectors");
1324 //  inf_fprintf (f, "#-=> output specifications\n\n");
1325   infDriveStbSpecSection (f, myfig, INF_SPECOUT, "Verify Output Connectors");
1326 //  inf_fprintf (f, "#-=> input connector stability\n\n");
1327   infDriveStbSpecSection (f, myfig, INF_STBOUT_SPECIN, "Input Connectors Stability");
1328 //  inf_fprintf (f, "#-=> output connector stability\n\n");
1329   infDriveStbSpecSection (f, myfig, INF_STBOUT_SPECOUT, "Output Connectors Stability");
1330 //  inf_fprintf (f, "#-=> memory stability\n\n");
1331   infDriveStbSpecSection (f, myfig, INF_STBOUT_SPECMEM, "Memory Nodes Stability");
1332 //  inf_fprintf (f, "#-=> node stability\n\n");
1333   infDriveStbSpecSection (f, myfig, INF_STBOUT_SPECINODE, "Internal Nodes Stability");
1334 }
1335
1336
1337 void infDriveHeader (FILE * f, inffig_list * ifl)
1338 {
1339   inf_fprintf (f, "Name \"%s\";\n\n", ifl->NAME);
1340 }
1341
1342 void infDriveOperatingCondition (FILE * f, inffig_list * ifl)
1343 {
1344   int hastemp;
1345   double val;
1346   chain_list *cl, *list0;
1347   char *name;
1348
1349   list0 = inf_GetEntriesByType (ifl, INF_POWER, INF_ANY_VALUES);
1350   hastemp = inf_GetDouble (ifl, INF_OPERATING_CONDITION, INF_TEMPERATURE, &val);
1351   if (hastemp || list0) {
1352     inf_fprintf (f, "Operating Conditions\nBegin\n");
1353     if (hastemp) {
1354       inf_tabs (f, 1);
1355       inf_fprintf (f, "Temp = %g;\n", val);
1356     }
1357     for (cl = list0; cl; cl = cl->NEXT) {
1358       inf_tabs (f, 1);
1359       name = (char *)cl->DATA;
1360       inf_GetDouble (ifl, name, INF_POWER, &val);
1361       inf_fprintf (f, "Supply : \"%s\" = %g;\n", inf_reVectName (name), val);
1362     }
1363     inf_fprintf (f, "End;\n");
1364     inf_leaveLines (f, 1);
1365   }
1366   freechain(list0);
1367 }
1368
1369
1370 static char *getdelaynodetype (int val)
1371 {
1372   if ((val & INF_MARGIN_ON_ALL) == INF_MARGIN_ON_ALL)
1373     return "Any";
1374   if (val & INF_MARGIN_ON_LATCH)
1375     return "Latch";
1376   if (val & INF_MARGIN_ON_FLIPFLOP)
1377     return "FlipFlop";
1378   if (val & INF_MARGIN_ON_BREAK)
1379     return "Break";
1380   if (val & INF_MARGIN_ON_CONNECTOR)
1381     return "Con";
1382   if (val & INF_MARGIN_ON_PRECHARGE)
1383     return "Prech";
1384   if (val & INF_MARGIN_ON_CMD)
1385     return "Cmd";
1386   return "?";
1387 }
1388
1389
1390 static void __infDrivePathDelayMargin (FILE * f, inffig_list * myfig, char *name)
1391 {
1392   // priority clock
1393   inf_miscdata *imd0;
1394   int i, j, k;
1395   struct {
1396     char *o;
1397     char *s;
1398   } run[] = {
1399     {
1400       "Min", INF_PATHDELAYMARGINMIN}, {
1401         "Max", INF_PATHDELAYMARGINMAX}, {
1402           "ClockPath", INF_PATHDELAYMARGINCLOCK}, {
1403             "DataPath", INF_PATHDELAYMARGINDATA}, {
1404               "Rise", INF_PATHDELAYMARGINRISE}, {
1405                 "Fall", INF_PATHDELAYMARGINFALL}
1406   };
1407   char section[128];
1408
1409   for (i = 0; i < 2; i++)
1410     for (j = 2; j < 4; j++)
1411       for (k = 4; k < 6; k++) {
1412         sprintf (section, INF_PATHDELAYMARGINPREFIX "|%s,%s,%s", run[i].s, run[j].s, run[k].s);
1413         if (inf_GetPointer (myfig, name, section, (void **)&imd0)) {
1414           inf_tabs (f, 1);
1415           inf_fprintf (f, "%s \"%s\" : Factor=%g Delta=%g %s %s %s;\n", getdelaynodetype (imd0->lval), name,
1416                    imd0->dval, imd0->dval1 * 1e12, run[i].o, run[j].o, run[k].o);
1417         }
1418       }
1419
1420
1421 #if 0
1422   char *def;
1423   chain_list *chainx, *list;
1424   r inf_miscdata *imd0, *imd1, *imd2, *imd3;
1425   int has0, has1, has2, has3;
1426
1427   has0 = inf_GetPointer (myfig, name, INF_PATHDELAYMARGINCLOCKMIN, (void **)&imd0);
1428   has1 = inf_GetPointer (myfig, name, INF_PATHDELAYMARGINDATAMIN, (void **)&imd1);
1429   has2 = inf_GetPointer (myfig, name, INF_PATHDELAYMARGINCLOCKMAX, (void **)&imd2);
1430   has3 = inf_GetPointer (myfig, name, INF_PATHDELAYMARGINDATAMAX, (void **)&imd3);
1431
1432   if (has0 && has1 && has2 && has3 &&
1433       imd0->dval == imd1->dval && imd2->dval == imd3->dval && imd0->dval == imd2->dval &&
1434       imd0->dval1 == imd1->dval1 && imd2->dval1 == imd3->dval1 && imd0->dval1 == imd2->dval1) {
1435     inf_tabs (f, 1);
1436     inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld ;\n", getdelaynodetype (imd0->lval), name, imd0->dval,
1437              mbk_long_round (imd0->dval1 * 1e12));
1438   }
1439   else {
1440     if (has0 && has1 && imd0->dval == imd1->dval && imd0->dval1 == imd1->dval1) {
1441       inf_tabs (f, 1);
1442       inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld Min;\n", getdelaynodetype (imd0->lval), name, imd0->dval,
1443                mbk_long_round (imd0->dval1 * 1e12));
1444     }
1445     else {
1446       if (has0) {
1447         inf_tabs (f, 1);
1448         inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld ClockPath Min;\n", getdelaynodetype (imd0->lval), name,
1449                  imd0->dval, mbk_long_round (imd0->dval1 * 1e12));
1450       }
1451       if (has1) {
1452         inf_tabs (f, 1);
1453         inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld DataPath Min;\n", getdelaynodetype (imd1->lval), name,
1454                  imd1->dval, mbk_long_round (imd1->dval1 * 1e12));
1455       }
1456
1457     }
1458
1459     if (has2 && has3 && imd2->dval == imd3->dval && imd2->dval1 == imd3->dval1) {
1460       inf_tabs (f, 1);
1461       inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld Max;\n", getdelaynodetype (imd2->lval), name, imd2->dval,
1462                mbk_long_round (imd2->dval1 * 1e12));
1463     }
1464     else {
1465       if (has2) {
1466         inf_tabs (f, 1);
1467         inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld ClockPath Max;\n", getdelaynodetype (imd2->lval), name,
1468                  imd2->dval, mbk_long_round (imd2->dval1 * 1e12));
1469       }
1470       if (has3) {
1471         inf_tabs (f, 1);
1472         inf_fprintf (f, "%s \"%s\" Factor=%g Delta=%ld DataPath Max;\n", getdelaynodetype (imd3->lval), name,
1473                  imd3->dval, mbk_long_round (imd3->dval1 * 1e12));
1474       }
1475     }
1476   }
1477 #endif
1478 }
1479
1480 void infDrivePathDelayMargin (FILE * f, inffig_list * myfig)
1481 {
1482   ht *tempht;
1483   chain_list *list, *cl;
1484   char *run[] = {
1485     INF_PATHDELAYMARGINMIN, INF_PATHDELAYMARGINMAX,
1486     INF_PATHDELAYMARGINCLOCK, INF_PATHDELAYMARGINDATA,
1487     INF_PATHDELAYMARGINRISE, INF_PATHDELAYMARGINFALL
1488   };
1489   int i, j, k;
1490   char section[128];
1491
1492   tempht = addht (128);
1493
1494   for (i = 0; i < 2; i++)
1495     for (j = 2; j < 4; j++)
1496       for (k = 4; k < 6; k++) {
1497         sprintf (section, INF_PATHDELAYMARGINPREFIX "|%s,%s,%s", run[i], run[j], run[k]);
1498         list = inf_GetEntriesByType (myfig, section, INF_ANY_VALUES);
1499         for (cl = list; cl; cl = cl->NEXT)
1500           addhtitem (tempht, cl->DATA, 0);
1501         freechain (list);
1502       }
1503
1504   list = GetAllHTKeys (tempht);
1505   delht (tempht);
1506
1507   if (list) {
1508     inf_fprintf (f, "Path Delay Margin\nBegin\n");
1509     for (cl = list; cl; cl = cl->NEXT) {
1510       __infDrivePathDelayMargin (f, myfig, (char *)cl->DATA);
1511     }
1512     inf_fprintf (f, "End;\n\n");
1513     freechain (list);
1514   }
1515 }
1516
1517
1518 void infDriveMulticyclePath (FILE * f, inffig_list * myfig)
1519 {
1520   chain_list *chainx, *list;
1521   inf_assoc *assoc;
1522   if (inf_GetPointer (myfig, INF_MULTICYCLE_PATH, "", (void **)&list)) {
1523     inf_fprintf (f, "MultiCycle Path\nBegin\n");
1524     for (chainx = list; chainx; chainx = chainx->NEXT) {
1525       assoc = (inf_assoc *) chainx->DATA;
1526       inf_tabs (f, 1);
1527       if ((assoc->lval & (INF_MULTICYCLE_SETUP | INF_MULTICYCLE_HOLD)) !=
1528           (INF_MULTICYCLE_SETUP | INF_MULTICYCLE_HOLD)) {
1529         if (assoc->lval & INF_MULTICYCLE_SETUP)
1530           inf_fprintf (f, "For SETUP ");
1531         else
1532           inf_fprintf (f, "For HOLD ");
1533       }
1534       if (!
1535           (strcmp (assoc->dest, "*") == 0
1536            && (assoc->lval & (INF_MULTICYCLE_RISE | INF_MULTICYCLE_FALL)) ==
1537            (INF_MULTICYCLE_RISE | INF_MULTICYCLE_FALL))) {
1538         inf_fprintf (f, "\"%s\" ", inf_reVectName (assoc->dest));
1539         if ((assoc->lval & (INF_MULTICYCLE_RISE | INF_MULTICYCLE_FALL)) !=
1540             (INF_MULTICYCLE_RISE | INF_MULTICYCLE_FALL)) {
1541           if (assoc->lval & INF_MULTICYCLE_RISE)
1542             inf_fprintf (f, "Rising ");
1543           else
1544             inf_fprintf (f, "Falling ");
1545         }
1546       }
1547
1548       inf_fprintf (f, "After %g ", assoc->dval);
1549       if (assoc->lval & INF_MULTICYCLE_END)
1550         inf_fprintf (f, "End Cycles");
1551       else
1552         inf_fprintf (f, "Start Cycles");
1553
1554       if (strcmp (assoc->orig, "*") != 0)
1555         inf_fprintf (f, " From \"%s\"", inf_reVectName (assoc->orig));
1556
1557       inf_fprintf (f, ";\n");
1558     }
1559     inf_fprintf (f, "End;\n\n");
1560   }
1561 }
1562
1563 void inf_driveIgnore (FILE * f, inffig_list * myfig)
1564 {
1565   chain_list *mutex;
1566   chain_list *head0 = NULL, *head1 = NULL, *head2 = NULL, *head3 = NULL, *head4 = NULL, *head5 = NULL, *head6=NULL;
1567
1568   inf_GetPointer (myfig, INF_IGNORE_INSTANCE, "", (void **)&head0);
1569   inf_GetPointer (myfig, INF_IGNORE_TRANSISTOR, "", (void **)&head1);
1570   inf_GetPointer (myfig, INF_IGNORE_RESISTANCE, "", (void **)&head2);
1571   inf_GetPointer (myfig, INF_IGNORE_CAPACITANCE, "", (void **)&head3);
1572   inf_GetPointer (myfig, INF_IGNORE_DIODE, "", (void **)&head6);
1573   inf_GetPointer (myfig, INF_IGNORE_PARASITICS, "", (void **)&head4);
1574   inf_GetPointer (myfig, INF_IGNORE_NAMES, "", (void **)&head5);
1575
1576   if (head0 || head1 || head2 || head3 || head5 || head6) {
1577     inf_fprintf (f, "Ignore\nBegin\n");
1578
1579     if (head0) {
1580       inf_tabs (f, 1);
1581       inf_fprintf (f, "Instances:\n");
1582     }
1583     for (mutex = head0; mutex; mutex = mutex->NEXT) {
1584       inf_tabs (f, 2);
1585       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1586     }
1587
1588     if (head1) {
1589       inf_tabs (f, 1);
1590       inf_fprintf (f, "Transistors:\n");
1591     }
1592     for (mutex = head1; mutex; mutex = mutex->NEXT) {
1593       inf_tabs (f, 2);
1594       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1595     }
1596
1597     if (head2) {
1598       inf_tabs (f, 1);
1599       inf_fprintf (f, "Resistances:\n");
1600     }
1601     for (mutex = head2; mutex; mutex = mutex->NEXT) {
1602       inf_tabs (f, 2);
1603       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1604     }
1605
1606     if (head3) {
1607       inf_tabs (f, 1);
1608       inf_fprintf (f, "Capacitances:\n");
1609     }
1610     for (mutex = head3; mutex; mutex = mutex->NEXT) {
1611       inf_tabs (f, 2);
1612       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1613     }
1614     if (head6) {
1615       inf_tabs (f, 1);
1616       inf_fprintf (f, "Diodes:\n");
1617     }
1618     for (mutex = head6; mutex; mutex = mutex->NEXT) {
1619       inf_tabs (f, 2);
1620       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1621     }
1622
1623     if (head4) {
1624       inf_tabs (f, 1);
1625       inf_fprintf (f, "Parasitics:\n");
1626     }
1627     for (mutex = head4; mutex; mutex = mutex->NEXT) {
1628       inf_tabs (f, 2);
1629       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1630     }
1631
1632     if (head5) {
1633       inf_tabs (f, 1);
1634       inf_fprintf (f, "SignalNames:\n");
1635     }
1636     for (mutex = head5; mutex; mutex = mutex->NEXT) {
1637       inf_tabs (f, 2);
1638       inf_fprintf (f, "\"%s\"%s\n", ((inf_assoc *) mutex->DATA)->orig, mutex->NEXT ? "," : ";");
1639     }
1640
1641     inf_fprintf (f, "End;\n");
1642     inf_leaveLines (f, 1);
1643   }
1644 }
1645
1646 void inf_driveConnectorDirections (FILE * f, inffig_list * myfig)
1647 {
1648   chain_list *cl;
1649   int has = 0;
1650   unsigned int i;
1651   struct {
1652     char *txt;
1653     char *value;
1654     chain_list *head;
1655   } tab[] = {
1656     {
1657       "Input", "I", NULL}, {
1658         "Output", "O", NULL}, {
1659           "InOut", "B", NULL}, {
1660             "Tristate", "T", NULL}, {
1661               "HZ", "Z", NULL}, {
1662                 "Unknown", "X", NULL}
1663   };
1664
1665   for (i = 0; i < sizeof (tab) / sizeof (*tab); i++)
1666     if ((tab[i].head = inf_GetEntriesByType (myfig, INF_CONNECTOR_DIRECTION, tab[i].value)))
1667       has++;
1668
1669   if (has) {
1670     inf_fprintf (f, "Connector Directions\nBegin\n");
1671
1672     for (i = 0; i < sizeof (tab) / sizeof (*tab); i++) {
1673       if (tab[i].head) {
1674         inf_tabs (f, 1);
1675         inf_fprintf (f, "%s:\n", tab[i].txt);
1676       }
1677       for (cl = tab[i].head; cl; cl = cl->NEXT) {
1678         inf_tabs (f, 2);
1679         inf_fprintf (f, "\"%s\"%s\n", (char *)cl->DATA, cl->NEXT ? "," : ";");
1680       }
1681       freechain (tab[i].head);
1682     }
1683
1684     inf_fprintf (f, "End;\n");
1685     inf_leaveLines (f, 1);
1686   }
1687 }
1688
1689 void infDriveDisableGateDelay (FILE * f, inffig_list * myfig)
1690 {
1691   chain_list *list, *cl;
1692   inf_assoc *assoc;
1693   int dir1, dir2;
1694
1695   list = inf_GetEntriesByType (myfig, INF_DISABLE_GATE_DELAY, INF_ANY_VALUES);
1696
1697   if (list!=NULL)
1698     {
1699       inf_fprintf (f, "Disable Gate Delay\nBegin\n");
1700       while (list!=NULL)
1701         {
1702           inf_GetPointer (myfig, list->DATA, INF_DISABLE_GATE_DELAY, (void **)&cl);
1703           while (cl!=NULL)
1704             {
1705               assoc = (inf_assoc *) cl->DATA;
1706               inf_tabs (f, 1);
1707               dir1=assoc->lval>>4;
1708               dir2=assoc->lval & 0x0f;
1709
1710               inf_fprintf (f, "\"%s\" ", inf_reVectName (assoc->orig));
1711               if (dir1!=3)
1712                 {
1713                   if (dir1 & 0x1) inf_fprintf (f, "< DOWN > ");
1714                   else if (dir1 & 0x2) inf_fprintf (f, "< UP > ");
1715                 }
1716               inf_fprintf (f, "\"%s\" ", inf_reVectName ((char *)list->DATA));
1717               if (dir2!=3)
1718                 {
1719                   if (dir2 & 0x1) inf_fprintf (f, "< DOWN > ");
1720                   else if (dir2 & 0x2) inf_fprintf (f, "< UP > ");
1721                 }
1722               inf_fprintf (f, ";\n");
1723               cl=cl->NEXT;
1724             }
1725           list=delchain(list, list);
1726         }
1727       inf_fprintf (f, "End;\n\n");
1728     }
1729 }
1730
1731 void inf_driveRSTYPE (FILE * f, inffig_list * ifl)
1732 {
1733   chain_list *list0, *cl;
1734   int val;
1735   char *name, *type;
1736
1737   list0 = inf_GetEntriesByType (ifl, INF_MARKRS, INF_ANY_VALUES);
1738   if (list0) {
1739     inf_fprintf (f, "RSType\nBegin\n");
1740     for (cl = list0; cl; cl = cl->NEXT) {
1741       name = (char *)cl->DATA;
1742       inf_GetInt (ifl, name, INF_MARKRS, &val);
1743       switch(val)
1744       {
1745         case INF_RS_LEGAL: type="Legal"; break;
1746         case INF_RS_ILLEGAL: type="Illegal"; break;
1747         case INF_RS_MARKONLY: type="Mark_Only"; break;
1748       }
1749       inf_tabs (f, 1);
1750       inf_fprintf (f, "\"%s\" : \"%s\" ;\n", inf_reVectName (name), type);
1751     }
1752     inf_fprintf (f, "End;\n");
1753     inf_leaveLines (f, 1);
1754     freechain (list0);
1755   }
1756 }
1757
1758 void infDriveClockUncertainty (FILE * f, inffig_list * myfig)
1759 {
1760   chain_list *chainx, *list;
1761   inf_assoc *assoc;
1762   if (inf_GetPointer (myfig, INF_CLOCK_UNCERTAINTY, "", (void **)&list)) {
1763     inf_fprintf (f, "ClockUncertainty\nBegin\n");
1764     for (chainx = list; chainx; chainx = chainx->NEXT) {
1765       assoc = (inf_assoc *) chainx->DATA;
1766       inf_tabs (f, 1);
1767       if ((assoc->lval & (INF_CLOCK_UNCERTAINTY_SETUP | INF_CLOCK_UNCERTAINTY_HOLD)) !=
1768           (INF_CLOCK_UNCERTAINTY_SETUP | INF_CLOCK_UNCERTAINTY_HOLD)) {
1769         if (assoc->lval & INF_CLOCK_UNCERTAINTY_SETUP)
1770           inf_fprintf (f, "For SETUP");
1771         else
1772           inf_fprintf (f, "For HOLD");
1773       }
1774
1775       inf_fprintf (f, " From \"%s\"", inf_reVectName (assoc->orig));
1776
1777       if ((assoc->lval & (INF_CLOCK_UNCERTAINTY_START_RISE | INF_CLOCK_UNCERTAINTY_START_FALL)) !=
1778           (INF_CLOCK_UNCERTAINTY_START_RISE | INF_CLOCK_UNCERTAINTY_START_FALL))
1779         {
1780           if (assoc->lval & INF_CLOCK_UNCERTAINTY_START_RISE)
1781             inf_fprintf (f, " Rising ");
1782           else
1783             inf_fprintf (f, " Falling ");
1784         }
1785
1786       inf_fprintf (f, " To \"%s\"", inf_reVectName (assoc->dest));
1787
1788       if ((assoc->lval & (INF_CLOCK_UNCERTAINTY_END_RISE | INF_CLOCK_UNCERTAINTY_END_FALL)) !=
1789           (INF_CLOCK_UNCERTAINTY_END_RISE | INF_CLOCK_UNCERTAINTY_END_FALL))
1790         {
1791           if (assoc->lval & INF_CLOCK_UNCERTAINTY_END_RISE)
1792             inf_fprintf (f, " Rising ");
1793           else
1794             inf_fprintf (f, " Falling ");
1795         }
1796
1797       inf_fprintf (f, ": %g ", assoc->dval*1e12);
1798       inf_fprintf (f, ";\n");
1799     }
1800     inf_fprintf (f, "End;\n\n");
1801   }
1802 }
1803
1804 /******************************************************************************/
1805 /*   FUNCTION NAME : inf_drive                                                */
1806 /*          ARG(1) : file name.                                               */
1807 /*          RETURN : NONE.                                                    */
1808 /*  FUNCTIONNALITY : Drives a inf file from inf lists.                        */
1809 /******************************************************************************/
1810 void infDrive_filtered (inffig_list * myfig, char *filename, int locations, FILE * outputfile, char *section)
1811 {
1812   FILE *f;
1813   int oldmode;
1814   char *c, *tok;
1815   char buf[1024];
1816   int found=0;
1817
1818   strcpy(buf, section);
1819
1820   if (outputfile == NULL) {
1821     if (filename == NULL && myfig)
1822       filename = myfig->NAME;
1823
1824     if (filename == NULL)
1825       return;
1826
1827     f = mbkfopen (filename, NULL, WRITE_TEXT);
1828   }
1829   else
1830     f = outputfile;
1831
1832   if (f) {
1833     if (myfig) {
1834       oldmode = inf_StuckSection (locations);
1835
1836       if (outputfile == NULL)
1837         avt_printExecInfo (f, "#", "", "");
1838
1839       inf_fprintf (f, "\n");
1840
1841       infDriveHeader (f, myfig);
1842
1843       tok=strtok_r(buf, " ", &c);
1844       while (tok!=NULL)
1845         {
1846           found=0;
1847
1848           if (mbk_TestREGEX("OperatingCondition",tok))
1849           {found=1; infDriveOperatingCondition (f, myfig);}
1850
1851           if (mbk_TestREGEX("PinSlew",tok))
1852             {found=1; inf_drivePinSlew (f, myfig);}
1853
1854           if (mbk_TestREGEX("Rename",tok))
1855             {found=1; inf_driveRename (f, myfig);}
1856
1857           if (mbk_TestREGEX("Memsym",tok))
1858             {found=1; inf_driveMemsym (f, myfig);}
1859
1860           if (mbk_TestREGEX("Stop",tok))
1861             {found=1; inf_driveSigListSection (f, myfig, "Stop", INF_STOP, INF_ANY_VALUES);}
1862
1863           if (mbk_TestREGEX("Sensitive",tok))
1864             {found=1; inf_driveSigListSection (f, myfig, "Sensitive", INF_SENSITIVE, INF_ANY_VALUES);}
1865
1866           if (mbk_TestREGEX("Suppress",tok))
1867             {found=1; inf_driveSigListSection (f, myfig, "Suppress", INF_SUPPRESS, INF_ANY_VALUES);}
1868
1869           if (mbk_TestREGEX("Inputs",tok))
1870             {found=1; inf_driveSigListSection (f, myfig, "Inputs", INF_INPUTS, INF_ANY_VALUES);}
1871
1872           if (mbk_TestREGEX("NotLatch",tok))
1873             {found=1; inf_driveSigListSection (f, myfig, "NotLatch", INF_NOTLATCH, INF_ANY_VALUES);}
1874
1875           if (mbk_TestREGEX("KeepTristateBehaviour",tok))
1876             {found=1; inf_driveSigListSection (f, myfig, "KeepTristateBehaviour", INF_KEEP_TRISTATE_BEHAVIOUR, INF_ANY_VALUES);}
1877
1878           if (mbk_TestREGEX("CkLatch",tok))
1879             {found=1; inf_driveBinary (f, myfig, "CkLatch", INF_CKLATCH);}
1880
1881           if (mbk_TestREGEX("Ckprech",tok))
1882             {found=1; inf_driveCkprech (f, myfig);}
1883
1884           if (mbk_TestREGEX("Precharge",tok))
1885             {found=1; inf_driveBinary (f, myfig, "Precharge", INF_PRECHARGE);}
1886
1887           if (mbk_TestREGEX("ModelLoop",tok))
1888             {found=1; inf_driveBinary (f, myfig, "ModelLoop", INF_MODELLOOP);}
1889
1890           if (mbk_TestREGEX("RSType",tok))
1891             {found=1; inf_driveRSTYPE(f, myfig);}
1892
1893           if (mbk_TestREGEX("Dirout",tok))
1894             {found=1; inf_driveDirout (f, myfig);}
1895
1896           if (mbk_TestREGEX("Mutex",tok))
1897             {found=1; inf_driveMutex (f, myfig);}
1898
1899           if (mbk_TestREGEX("CrosstalkMutex",tok))
1900             {found=1; inf_driveCrosstalkMutex (f, myfig);}
1901
1902           if (mbk_TestREGEX("Constraint",tok))
1903             {found=1; inf_driveConstraint (f, myfig);}
1904
1905           if (mbk_TestREGEX("ConnectorDirections",tok))
1906             {found=1; inf_driveConnectorDirections (f, myfig);}
1907           //          inf_driveSigListSection (f, myfig, "Clock", INF_CLOCK_TYPE);
1908
1909           if (mbk_TestREGEX("PathIN",tok))
1910             {found=1; inf_driveSigListSection (f, myfig, "PathIN", INF_PATHIN, INF_ANY_VALUES);}
1911
1912           if (mbk_TestREGEX("PathOUT",tok))
1913             {found=1; inf_driveSigListSection (f, myfig, "PathOUT", INF_PATHOUT, INF_ANY_VALUES);}
1914
1915           if (mbk_TestREGEX("PathDelayMargin",tok))
1916             {found=1; infDrivePathDelayMargin (f, myfig);}
1917
1918           if (mbk_TestREGEX("MulticyclePath",tok))
1919             {found=1; infDriveMulticyclePath (f, myfig);}
1920
1921           if (mbk_TestREGEX("ClockUncertainty",tok))
1922             {found=1; infDriveClockUncertainty (f, myfig);}
1923
1924           if (mbk_TestREGEX("Ignore",tok))
1925             {found=1; inf_driveIgnore (f, myfig);}
1926
1927           if (mbk_TestREGEX("NoCheck",tok))
1928             {found=1; inf_driveNoCheck (f, myfig);}
1929
1930           if (mbk_TestREGEX("Bypass",tok))
1931             {found=1; inf_driveBypass (f, myfig);}
1932
1933           if (mbk_TestREGEX("DisableGateDelay",tok))
1934             {found=1; infDriveDisableGateDelay (f, myfig);}
1935
1936          if (mbk_TestREGEX("NoRising",tok))
1937             {found=1; inf_driveSigListSection (f, myfig, "NoRising", INF_NORISING, INF_ANY_VALUES);}
1938
1939           if (mbk_TestREGEX("NoFalling",tok))
1940             {found=1; inf_driveSigListSection (f, myfig, "NoFalling", INF_NOFALLING, INF_ANY_VALUES);}
1941
1942           if (mbk_TestREGEX("Break",tok))
1943             {found=1; inf_driveSigListSection (f, myfig, "Break", INF_BREAK, INF_ANY_VALUES);}
1944
1945           if (mbk_TestREGEX("StrictSetup",tok))
1946             {found=1; inf_driveSigListSection (f, myfig, "StrictSetup", INF_STRICT_SETUP, INF_ANY_VALUES);}
1947
1948           if (mbk_TestREGEX("Inter",tok))
1949             {found=1; inf_driveSigListSection (f, myfig, "Inter", INF_INTER, INF_ANY_VALUES);}
1950
1951           if (mbk_TestREGEX("Asynchron",tok))
1952             {found=1; inf_driveSigListSection (f, myfig, "Asynchron", INF_ASYNCHRON, INF_ANY_VALUES);}
1953
1954           if (mbk_TestREGEX("Transparent",tok))
1955             {found=1; inf_driveSigListSection (f, myfig, "Transparent", INF_TRANSPARENT, INF_ANY_VALUES);}
1956
1957           if (mbk_TestREGEX("DoNotCross",tok))
1958             {found=1; inf_driveSigListSection (f, myfig, "DoNotCross", INF_DONTCROSS, INF_ANY_VALUES);}
1959
1960           if (mbk_TestREGEX("RC",tok))
1961             {found=1; inf_driveSigListSection (f, myfig, "RC", INF_RC, INF_YES);}
1962
1963           if (mbk_TestREGEX("NORC",tok))
1964             {found=1; inf_driveSigListSection (f, myfig, "NORC", INF_RC, INF_NO);}
1965
1966           if (mbk_TestREGEX("SIGLIST",tok))
1967             { found=1;
1968               if (myfig->LOADED.INF_SIGLIST)
1969               inf_driveSiglist (f, &myfig->LOADED);
1970             }
1971
1972           if (mbk_TestREGEX("Falsepath",tok))
1973             { found=1;
1974               if (myfig->LOADED.INF_FALSEPATH)
1975               inf_driveFalsepath (f, &myfig->LOADED);
1976             }
1977
1978           if (mbk_TestREGEX("Falseslack",tok))
1979             { found=1;
1980               if (myfig->LOADED.INF_FALSESLACK)
1981               inf_driveFalseslack (f, &myfig->LOADED);
1982             }
1983
1984           if (mbk_TestREGEX("Delay",tok))
1985             {found=1; inf_driveDelay (f, myfig);}
1986
1987           if (mbk_TestREGEX("Dlatch",tok))
1988             {found=1; inf_driveDlatch (f, myfig);}
1989
1990           if (mbk_TestREGEX("FlipFlop",tok))
1991             {found=1; inf_driveSigListSection (f, myfig, "FlipFlop", INF_FLIPFLOP, INF_ANY_VALUES);}
1992
1993           if (mbk_TestREGEX("Slopein",tok))
1994             {found=1; inf_driveSlopein (f, myfig);}
1995
1996           if (mbk_TestREGEX("Capaout",tok))
1997             {found=1; inf_driveCapaout (f, myfig);}
1998
1999           if (mbk_TestREGEX("OutputCapacitance",tok))
2000             {found=1; inf_driveOutputCapacitance(f, myfig);}
2001
2002           if (mbk_TestREGEX("Stuck",tok))
2003             {found=1; inf_StuckSection (oldmode);}
2004
2005           if (mbk_TestREGEX("Directives",tok))
2006             {found=1; infDriveDirectives(f, myfig);}
2007
2008           if (mbk_TestREGEX("SwitchingProbability",tok))
2009             {found=1; inf_driveProba (f, myfig);}
2010
2011           // stb informations
2012           if (mbk_TestREGEX("Stb",tok))
2013             {
2014               found=1;
2015               inf_fprintf (f, "\n# -=> Stability Informations <=-\n\n");
2016               infDriveStb (f, myfig);
2017             }
2018           if (!found) avt_errmsg (INF_ERRMSG, "021", AVT_ERR, tok);
2019
2020           tok=strtok_r(NULL, " ", &c);
2021         }
2022     }
2023     if (outputfile == NULL)
2024       fclose (f);
2025   }
2026   else
2027     avt_errmsg (INF_ERRMSG, "018", AVT_ERR, filename);
2028   // avt_error("inf", 3, AVT_ERR, "could not create file '%s.inf'\n", filename);
2029 }
2030
2031 void infDrive (inffig_list * myfig, char *filename, int locations, FILE * outputfile)
2032 {
2033   infDrive_filtered (myfig, filename, locations, outputfile, "*");
2034 }