distrib/sources/beh/bef/bef_drive_utils.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : AVERTEC global tools                                        */
   6 /*    Fichier : bef_drive_utils.c                                           */
   7 /*                                                                          */
   8 /*    © copyright 2000 AVERTEC                                              */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : Antony PINTO                                              */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 #include AVT_H
  16 #include "bef_drive_utils.h"
  17 #include "bef_lib.h"
  18
  19 #define     BEF_INDENT      "  "
  20
  21 static int         CKTYPE;
  22 static int         MAXNAME;
  23
  24 static chain_list  *strip_ckedge_int(chain_list *ptabl, char *clock);
  25 static void drive_signals_bereg(bef_driver *driver);
  26 static void drive_signals_bevectreg(bef_driver *driver, bevectreg_list *vreg);
  27 static void drive_signals_bebux(bef_driver *driver);
  28 static void drive_signals_bevectbux(bef_driver *driver, bevectbux_list *vbux);
  29 static void drive_signals_beaux(bef_driver *driver);
  30 static void drive_signals_bevectaux(bef_driver *driver, bevectaux_list *vaux);
  31
  32 static inline char *getName(void *be, long type);
  33 static inline void *getNext(void *be, long type);
  34 static inline void *vectnam(void *be, int *left, int *right, char **name, char type);
  35 static inline void getBeobjField(void *be, long type, chain_list **abl, long *time, biabl_list **biabl, vectbiabl_list **vbiabl, char **name, char *head, int *left, int *right,int *timer, int *timef, char *flags, long *moreflags);
  36 static void drive_one_vpor(bef_driver *driver, bevectpor_list *vpor);
  37 static bepor_list *drive_one_por(bef_driver *driver, bepor_list *por);
  38 static void drive_vpor(bef_driver *driver, bevectpor_list *vpor,int cpt);
  39 static void drive_por(bef_driver *driver, bepor_list *por);
  40 static void print_biabl(bef_driver *driver, biabl_list *biabl, char *name, char *vname, int vsize, int *np, char *head, int type, char flags);
  41
  42 static void drive_process(bef_driver *driver, biabl_list *biabl, char *name, char *vname, int vsize, int *np, char *head, int type, char flags);
  43 static char *getStrAblReduce(bef_driver *driver, chain_list *abl, char *buf, int *bufsize);
  44
  45 static chain_list *porreg_l = NULL;
  46 ht *BEH_TIMEVARS=NULL;
  47
  48 /****************************************************************************/
  49 /*{{{                                                                       */
  50 /****************************************************************************/
  51 /*{{{                    Declaration des signaux (compatible)               */
  52 /****************************************************************************/
  53 ///*{{{                    reverse_takeBiggerNameReg()                        */
  54 ///*                                                                          */
  55 ///*                                                                          */
  56 ///****************************************************************************/
  57 //static bereg_list *reverse_takeBiggerNameReg(bereg_list *reg)
  58 //{
  59 //  bereg_list    *p, *q = NULL;
  60 //  int            len;
  61 //
  62 //  if (!reg)
  63 //    return NULL;
  64 //  while ((p = reg->NEXT))
  65 //  {
  66 //    len         = strlen(reg->NAME);
  67 //    if (MAXNAME < len)
  68 //      MAXNAME   = len;
  69 //    reg->NEXT   = q;
  70 //    q           = reg;
  71 //    reg         = p;
  72 //  }
  73 //  reg->NEXT     = q;
  74 //
  75 //  return reg;
  76 //}
  77 //
  78 //
  79 ///*}}}************************************************************************/
  80 ///*{{{                    reverse_takeBiggerNameBux()                        */
  81 ///*                                                                          */
  82 ///*                                                                          */
  83 ///****************************************************************************/
  84 //static bebux_list *reverse_takeBiggerNameBux(bebux_list *bux)
  85 //{
  86 //  bebux_list    *p, *q = NULL;
  87 //  int            len;
  88 //
  89 //  if (!bux)
  90 //    return NULL;
  91 //  while ((p = bux->NEXT))
  92 //  {
  93 //    len         = strlen(bux->NAME);
  94 //    if (MAXNAME < len)
  95 //      MAXNAME   = len;
  96 //    bux->NEXT   = q;
  97 //    q           = bux;
  98 //    bux         = p;
  99 //  }
 100 //  bux->NEXT     = q;
 101 //
 102 //  return bux;
 103 //}
 104 //
 105 //
 106 ///*}}}************************************************************************/
 107 ///*{{{                    reverse_takeBiggerNameAux()                        */
 108 ///*                                                                          */
 109 ///*                                                                          */
 110 ///****************************************************************************/
 111 //static beaux_list *reverse_takeBiggerNameAux(beaux_list *aux)
 112 //{
 113 //  beaux_list    *p, *q = NULL;
 114 //  int            len;
 115 //
 116 //  if (!aux)
 117 //    return NULL;
 118 //  while ((p = aux->NEXT))
 119 //  {
 120 //    len         = strlen(aux->NAME);
 121 //    if (MAXNAME < len)
 122 //      MAXNAME   = len;
 123 //    aux->NEXT   = q;
 124 //    q           = aux;
 125 //    aux         = p;
 126 //  }
 127 //  aux->NEXT     = q;
 128 //
 129 //  return aux;
 130 //}
 131 //
 132 //
 133 //
 134 static int hasevents(biabl_list *biabl)
 135 {
 136   biabl_list    *biablx;
 137   char *clk;
 138
 139   for (biablx = biabl; biablx; biablx = biablx->NEXT)
 140      if ((bef_search_stable(biablx->CNDABL,&clk)) > 0) return 1;
 141   return 0;
 142 }
 143
 144 static char *insert_name(char *name, char *postfix, char *buf)
 145 {
 146   char *c;
 147
 148   if ((c=strchr(name, ' '))!=NULL)
 149   {
 150     *c='\0';
 151     sprintf(buf, "%s%s %s",name,postfix,c+1);
 152     *c=' ';
 153   }
 154   else
 155     sprintf(buf, "%s%s", name, postfix);
 156   return buf;
 157 }
 158 ///*}}}************************************************************************/
 159 /*{{{                    drive_signals_bereg()                              */
 160 /*                                                                          */
 161 /*                                                                          */
 162 /****************************************************************************/
 163 static void drive_signals_bereg(bef_driver *driver)
 164 {
 165   int            left, right;
 166   bereg_list    *reg;
 167   char          *name = NULL;
 168   ht            *porht = driver->POR.PORHT;
 169   int verilog, inertial;
 170   char buf[2048];
 171
 172   driver->FIG->BEREG = (bereg_list*)reverse((chain_list*)driver->FIG->BEREG);
 173
 174   for (reg = driver->FIG->BEREG; reg; reg = reg->NEXT)
 175   {
 176     reg              = vectnam(reg,&left,&right,&name,BEG_TYPE_SINGREG);
 177     inertial=V_BOOL_TAB[__MGL_INERTIAL_MEMORY].VALUE && (reg->FLAGS & BEH_FLAG_NORMAL)==0;
 178     verilog=(inertial && driver->VLG && !hasevents(reg->BIABL) && !beh_isloop(reg->BIABL));
 179     if (verilog)
 180     {
 181       insert_name(name, "_prereg", buf);
 182       driver->SIGNAL(driver->FP,buf,'W',left,right);
 183     }
 184     if (porht && gethtitem(porht,namealloc(name)) != EMPTYHT)
 185     {
 186       porreg_l = addchain(porreg_l,reg);
 187       driver->SIGNAL(driver->FP,name,'P',left,right);
 188       mbkfree(name);
 189       continue;
 190     }
 191     driver->SIGNAL(driver->FP,name,'R',left,right);
 192     mbkfree(name);
 193   }
 194
 195   driver->FIG->BEREG = (bereg_list*)reverse((chain_list*)driver->FIG->BEREG);
 196 }
 197
 198 /*}}}************************************************************************/
 199 /*{{{                    drive_signals_bevectreg()                          */
 200 /*                                                                          */
 201 /*                                                                          */
 202 /****************************************************************************/
 203 static void drive_signals_bevectreg(bef_driver *driver, bevectreg_list *vreg)
 204 {
 205
 206   int verilog, inv, inertial;
 207   char buf[2048];
 208   bevectreg_list *vregx;
 209
 210   vreg=(bevectreg_list *)reverse((chain_list *)vreg);
 211   for(vregx=vreg; vregx; vregx=vregx->NEXT)
 212   {
 213     ht          *porht = driver->POR.PORHT;
 214 //    drive_signals_bevectreg(driver,vreg->NEXT);
 215
 216     inertial=V_BOOL_TAB[__MGL_INERTIAL_MEMORY].VALUE && (vregx->FLAGS & BEH_FLAG_NORMAL)==0;
 217     verilog=(inertial && driver->VLG && !hasevents(vregx->VECTBIABL->BIABL) && !beh_isloop(vregx->VECTBIABL->BIABL));
 218
 219     if (verilog)
 220     {
 221       insert_name(vregx->NAME, "_prereg", buf);
 222       driver->SIGNAL(driver->FP,buf,'W',vregx->LEFT,vregx->RIGHT);
 223     }
 224
 225     if (!(porht && (gethtitem(porht,vregx->NAME) != EMPTYHT)))
 226       driver->SIGNAL(driver->FP,vregx->NAME,'R',vregx->LEFT,vregx->RIGHT);
 227     else
 228     {
 229       driver->SIGNAL(driver->FP,vregx->NAME,'P',vregx->LEFT,vregx->RIGHT);
 230       porreg_l = addchain(porreg_l,vregx);
 231     }
 232   }
 233   vreg=(bevectreg_list *)reverse((chain_list *)vreg);
 234 }
 235
 236 /*}}}************************************************************************/
 237 /*{{{                    drive_signals_bebux()                              */
 238 /*                                                                          */
 239 /*                                                                          */
 240 /****************************************************************************/
 241 static void drive_signals_bebux(bef_driver *driver)
 242 {
 243   int             left, right;
 244   struct bebux   *bux;
 245   char           *name = NULL;
 246   int verilog, oldstyle;
 247   char buf[2048];
 248
 249   driver->FIG->BEBUX = (bebux_list*)reverse((chain_list*)driver->FIG->BEBUX);
 250
 251   for (bux = driver->FIG->BEBUX; bux; bux = bux->NEXT)
 252   {
 253     bux              = vectnam(bux,&left,&right,&name,BEG_TYPE_SINGBUX);
 254     oldstyle=V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (bux->FLAGS & BEH_FLAG_NORMAL)!=0;
 255     verilog=(!oldstyle && V_BOOL_TAB[__MGL_TRISTATE_IS_MEMORY].VALUE && (bux->FLAGS & BEH_FLAG_FORCEBUS)==0 && driver->VLG && !hasevents(bux->BIABL) && !beh_isloop(bux->BIABL));
 256     if (verilog)
 257     {
 258       insert_name(name, "_prereg", buf);
 259       driver->SIGNAL(driver->FP,buf,'r',left,right);
 260       driver->SIGNAL(driver->FP,name,'R',left,right);
 261     }
 262     else
 263       driver->SIGNAL(driver->FP,name,oldstyle?'R':'r',left,right);
 264     mbkfree(name);
 265   }
 266   driver->FIG->BEBUX = (bebux_list*)reverse((chain_list*)driver->FIG->BEBUX);
 267 }
 268
 269 /*}}}************************************************************************/
 270 /*{{{                    drive_signals_bevectbux()                          */
 271 /*                                                                          */
 272 /*                                                                          */
 273 /****************************************************************************/
 274 static void drive_signals_bevectbux(bef_driver *driver, bevectbux_list *vbux)
 275 {
 276   int verilog, oldstyle;
 277   char buf[2048];
 278   bevectbux_list *vbuxx;
 279
 280   vbux=(bevectbux_list *)reverse((chain_list *)vbux);
 281   for (vbuxx=vbux; vbuxx; vbuxx=vbuxx->NEXT)
 282   {
 283 //    drive_signals_bevectbux(driver,vbux->NEXT);
 284
 285     oldstyle=V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (vbuxx->FLAGS & BEH_FLAG_NORMAL)!=0;
 286     verilog=(!oldstyle && V_BOOL_TAB[__MGL_TRISTATE_IS_MEMORY].VALUE && (vbuxx->FLAGS & BEH_FLAG_FORCEBUS)==0 && driver->VLG && !beh_isloop(vbuxx->VECTBIABL->BIABL) && !hasevents(vbuxx->VECTBIABL->BIABL));
 287     if (verilog)
 288     {
 289       insert_name(vbuxx->NAME, "_prereg", buf);
 290       driver->SIGNAL(driver->FP,buf,'r',vbuxx->LEFT,vbuxx->RIGHT);
 291       driver->SIGNAL(driver->FP,vbuxx->NAME,'R',vbuxx->LEFT,vbuxx->RIGHT);
 292     }
 293     else
 294       driver->SIGNAL(driver->FP,vbuxx->NAME,oldstyle?'R':'r',vbuxx->LEFT,vbuxx->RIGHT);
 295   }
 296   vbux=(bevectbux_list *)reverse((chain_list *)vbux);
 297 }
 298
 299 /*}}}************************************************************************/
 300 /*{{{                    drive_signals_bebus()                              */
 301 /*                                                                          */
 302 /*                                                                          */
 303 /****************************************************************************/
 304
 305 static void drive_signals_bebus(bef_driver *driver)
 306 {
 307   int             left, right;
 308   struct bebus   *bus;
 309   char           *name = NULL;
 310   int verilog, oldstyle;
 311   char buf[2048];
 312
 313   driver->FIG->BEBUS = (bebus_list*)reverse((chain_list*)driver->FIG->BEBUS);
 314
 315   for (bus = driver->FIG->BEBUS; bus; bus = bus->NEXT)
 316   {
 317     bus              = vectnam(bus,&left,&right,&name,BEG_TYPE_SINGBUX);
 318     oldstyle=V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (bus->FLAGS & BEH_FLAG_NORMAL)!=0;
 319     verilog=(!oldstyle && V_BOOL_TAB[__MGL_TRISTATE_IS_MEMORY].VALUE && (bus->FLAGS & BEH_FLAG_FORCEBUS)==0 && driver->VLG && !hasevents(bus->BIABL));
 320     if (verilog)
 321     {
 322       insert_name(name, "_prereg", buf);
 323       driver->SIGNAL(driver->FP,buf,'r',left,right);
 324       driver->SIGNAL(driver->FP,name,'b',left,right);
 325     }
 326     else if (oldstyle)
 327       driver->SIGNAL(driver->FP,name,'b',left,right);
 328     mbkfree(name);
 329   }
 330   driver->FIG->BEBUS = (bebus_list*)reverse((chain_list*)driver->FIG->BEBUS);
 331 }
 332
 333 /*}}}************************************************************************/
 334 /*{{{                    drive_signals_bevectbus()                          */
 335 /*                                                                          */
 336 /*                                                                          */
 337 /****************************************************************************/
 338 static void drive_signals_bevectbus(bef_driver *driver, bevectbus_list *vbus)
 339 {
 340   int verilog, oldstyle;
 341   char buf[2048];
 342   bevectbus_list *vbusx;
 343
 344   vbus=(bevectbus_list *)reverse((chain_list *)vbus);
 345   for (vbusx=vbus; vbusx; vbusx=vbusx->NEXT)
 346   {
 347 //    drive_signals_bevectbus(driver,vbus->NEXT);
 348     oldstyle=V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (vbus->FLAGS & BEH_FLAG_NORMAL)!=0;
 349     verilog=(!oldstyle && V_BOOL_TAB[__MGL_TRISTATE_IS_MEMORY].VALUE && (vbus->FLAGS & BEH_FLAG_FORCEBUS)==0 && driver->VLG && !beh_isloop(vbusx->VECTBIABL->BIABL) && !hasevents(vbusx->VECTBIABL->BIABL));
 350     if (verilog)
 351     {
 352       insert_name(vbusx->NAME, "_prereg", buf);
 353       driver->SIGNAL(driver->FP,buf,'r',vbusx->LEFT,vbusx->RIGHT);
 354       driver->SIGNAL(driver->FP,vbusx->NAME,'b',vbusx->LEFT,vbusx->RIGHT);
 355     }
 356     else if (oldstyle)
 357       driver->SIGNAL(driver->FP,vbusx->NAME,'b',vbusx->LEFT,vbusx->RIGHT);
 358   }
 359   vbus=(bevectbus_list *)reverse((chain_list *)vbus);
 360 }
 361
 362 /*}}}************************************************************************/
 363 /*{{{                    drive_signals_beaux()                              */
 364 /*                                                                          */
 365 /*                                                                          */
 366 /****************************************************************************/
 367 static void drive_signals_beaux(bef_driver *driver)
 368 {
 369   int             left, right;
 370   beaux_list     *aux;
 371   char           *name = NULL;
 372
 373   driver->FIG->BEAUX = (beaux_list*)reverse((chain_list*)driver->FIG->BEAUX);
 374
 375   for (aux = driver->FIG->BEAUX; aux; aux = aux->NEXT)
 376   {
 377     aux              = vectnam(aux,&left,&right,&name,BEG_TYPE_SINGAUX);
 378     driver->SIGNAL(driver->FP,name,'W',left,right);
 379     mbkfree(name);
 380   }
 381   driver->FIG->BEAUX = (beaux_list*)reverse((chain_list*)driver->FIG->BEAUX);
 382 }
 383
 384 /*}}}************************************************************************/
 385 /*{{{                    drive_signals_bevectaux()                          */
 386 /*                                                                          */
 387 /*                                                                          */
 388 /****************************************************************************/
 389 static void drive_signals_bevectaux(bef_driver *driver, bevectaux_list *vaux)
 390 {
 391   bevectaux_list *vauxx;
 392
 393   vaux=(bevectaux_list *)reverse((chain_list *)vaux);
 394   for (vauxx=vaux; vauxx; vauxx=vauxx->NEXT)
 395   {
 396 //    drive_signals_bevectaux(driver,vaux->NEXT);
 397     driver->SIGNAL(driver->FP,vauxx->NAME,'W',vauxx->LEFT,vauxx->RIGHT);
 398   }
 399   vaux=(bevectaux_list *)reverse((chain_list *)vaux);
 400 }
 401
 402 /*}}}************************************************************************/
 403 /*{{{                    print_biabl()                                      */
 404 /*                                                                          */
 405 /*                                                                          */
 406 /****************************************************************************/
 407 static void print_biabl(bef_driver *driver, biabl_list *biabl, char *name,
 408                         char *vname, int vsize, int *np, char *head, int type, char flags)
 409 {
 410   if (!biabl)
 411     beh_error(40, name);
 412   else if (!biabl->CNDABL)
 413     beh_toolbug(19,"print_biabl",name,0);
 414   else if (!biabl->VALABL)
 415     beh_toolbug(20,"print_biabl",name,0);
 416   else
 417   {
 418     // case of  with ... select
 419     if ((type != BEG_MASK_REG) && (beh_simplifybiabl(biabl)))
 420       driver->PROC.WITHSELECT(driver->FP,biabl,vname,vsize,driver->ABUFF,
 421                               driver->ABUFS);
 422     // case of process
 423     else
 424       drive_process(driver,biabl,name,vname,vsize,np,head,type,flags);
 425   }
 426 }
 427
 428 /*}}}************************************************************************/
 429 /*}}}************************************************************************/
 430 /*{{{                    Utilities (compatible)                             */
 431 /****************************************************************************/
 432 /*{{{                    getName()                                          */
 433 /*                                                                          */
 434 /*                                                                          */
 435 /****************************************************************************/
 436 static inline char *getName(void *be, long type)
 437 {
 438   char      *res = NULL;
 439
 440   switch (type)
 441   {
 442     case BEG_TYPE_SINGPOR :
 443          res        = ((bepor_list *)be)->NAME;
 444          break;
 445     case BEG_TYPE_SINGBUX :
 446          res        = ((bebux_list *)be)->NAME;
 447          break;
 448     case BEG_TYPE_SINGREG :
 449          res        = ((bereg_list *)be)->NAME;
 450          break;
 451     case BEG_TYPE_SINGAUX :
 452          res        = ((beaux_list *)be)->NAME;
 453          break;
 454     case BEG_TYPE_SINGBUS :
 455          res        = ((bebus_list *)be)->NAME;
 456          break;
 457   }
 458
 459   return res;
 460 }
 461
 462 /*}}}************************************************************************/
 463 /*{{{                    getNext()                                          */
 464 /*                                                                          */
 465 /*                                                                          */
 466 /****************************************************************************/
 467 static inline void *getNext(void *be, long type)
 468 {
 469   void      *res = NULL;
 470
 471   switch (type)
 472   {
 473     case BEG_TYPE_SINGPOR :
 474          res        = ((bepor_list *)be)->NEXT;
 475          break;
 476     case BEG_TYPE_SINGBUX :
 477          res        = ((bebux_list *)be)->NEXT;
 478          break;
 479     case BEG_TYPE_SINGREG :
 480          res        = ((bereg_list *)be)->NEXT;
 481          break;
 482     case BEG_TYPE_SINGAUX :
 483          res        = ((beaux_list *)be)->NEXT;
 484          break;
 485     case BEG_TYPE_SINGBUS :
 486          res        = ((bebus_list *)be)->NEXT;
 487          break;
 488   }
 489
 490   return res;
 491 }
 492
 493 /*}}}************************************************************************/
 494 /*{{{                    vectnam()                                          */
 495 /*                                                                          */
 496 /*  analyze a list of signal and return the bounds of the vectorised        */
 497 /*    signals, if they occure.                                              */
 498 /*                                                                          */
 499 /****************************************************************************/
 500 static inline void *vectnam(void *be, int *left, int *right, char **name,
 501                             char type)
 502 {
 503   char          *blank_space, *sig_name, name_tmp[200], number[200];
 504   char           END = 0;
 505
 506   *left                 = -1;
 507   *right                = -1;
 508
 509   sig_name              = getName(be,type);
 510   if (sig_name)
 511   {
 512     *name               = (char*)mbkalloc(strlen(sig_name) + 1);
 513     strcpy(*name, sig_name);
 514     blank_space         = strchr(*name,' ');
 515     if (blank_space)
 516     {
 517       strcpy(number, blank_space);
 518       *left             = atoi(number);
 519       *right            = *left;
 520       *blank_space      = '\0';
 521     }
 522
 523     while (!END)
 524     {
 525       if (getNext(be,type))
 526       {
 527         strcpy(name_tmp,getName(getNext(be,type),type));
 528         blank_space     = strchr(name_tmp,' ');
 529         if (blank_space)
 530         {
 531           strcpy(number,blank_space);
 532           *blank_space  = '\0';
 533           if (!strcmp(*name,name_tmp))
 534           {
 535             *right      = atoi(number);
 536             be          = getNext(be,type);
 537           }
 538           else
 539             END         = 1;
 540         }
 541         else
 542           END           = 1;
 543       }
 544       else
 545         END             = 1;
 546     }
 547     return (be);
 548   }
 549   else
 550     return NULL;
 551 }
 552
 553 /*}}}************************************************************************/
 554 /*{{{                    preprocess_abl()                                   */
 555 /*                                                                          */
 556 /*                                                                          */
 557 /****************************************************************************/
 558 chain_list *bef_preprocess_abl(chain_list *abl)
 559 {
 560   chain_list     *resabl;
 561   chain_list     *devabl;
 562   chain_list     *simpabl;
 563
 564   devabl    = devXorExpr(abl);
 565   simpabl   = simplif10Expr(devabl);
 566   resabl    = flatPolarityExpr(simpabl, 1);
 567
 568   freeExpr(devabl);
 569   freeExpr(simpabl);
 570
 571   return (resabl);
 572 }
 573
 574 /*}}}************************************************************************/
 575 /*{{{                    iprint()                                           */
 576 /*                                                                          */
 577 /* print with indentation, keep coherance                                   */
 578 /****************************************************************************/
 579 void iprint(FILE *fp,char mode,char *str, ... )
 580 {
 581   va_list        arg;
 582   static int     indent = 0;
 583   static int     init = 0;
 584   int            i, usebuf, par, old, hd, j, l;
 585   char           buf[2048];
 586
 587   va_start(arg,str);
 588
 589   usebuf        = 0;
 590   switch (mode)
 591   {
 592     case '+' :
 593          init   = 1;
 594     case '>' :
 595          indent ++;
 596          break;
 597     case '-' :
 598          init   = -1;
 599     case '<' :
 600          indent --;
 601          break;
 602     case 'i' :
 603          indent = 1;
 604          init   = 1;
 605          break;
 606     case 'd' :
 607          usebuf = 1;
 608   }
 609
 610   if (str)
 611   {
 612     if (usebuf)
 613     {
 614       l = strlen(BEF_INDENT);
 615       vsprintf(buf,str,arg);
 616       for (i = 0, hd = 0, par = 0, old = 0; buf[i] != '\0'; i++)
 617         switch (buf[i])
 618         {
 619           case ':'  :
 620                  if (MAXNAME)
 621                    for (j = i; j < indent*l - init + MAXNAME + 2; j ++)
 622                      fprintf(fp," ");
 623                  break;
 624         }
 625
 626       for (i = init; i < indent + par; i ++)
 627         fprintf(fp,"%s",BEF_INDENT);
 628       fprintf(fp,"%s",buf+hd);
 629     }
 630     else
 631     {
 632       for (i = init; i < indent; i ++)
 633         fprintf(fp,"%s",BEF_INDENT);
 634       vfprintf(fp,str,arg);
 635     }
 636   }
 637
 638   init          = 0;
 639   va_end(arg);
 640 }
 641
 642 /*}}}************************************************************************/
 643 /*{{{                    strip_ckedge_int()                                 */
 644 /*                                                                          */
 645 /*                                                                          */
 646 /****************************************************************************/
 647 static chain_list *strip_ckedge_int(chain_list *ptabl, char *clock)
 648 {
 649   if (ATOM(ptabl))
 650     if (VALUE_ATOM(ptabl) == clock)
 651       if (!CKTYPE)
 652         return createAtom("'1'");
 653       else
 654         return createAtom("'0'");
 655     else
 656       return addchain(NULL,ptabl->DATA);
 657   else if (OPER(ptabl) == STABLE)
 658     return createAtom("'0'");
 659   else
 660   {
 661     chain_list  *auxExpr, *oldExpr, *expr1;
 662
 663     oldExpr     = ptabl;
 664     auxExpr     = createExpr (OPER (ptabl));
 665     expr1       = auxExpr;
 666
 667     while ((ptabl = CDR (ptabl)))
 668       addQExpr(auxExpr,bef_strip_ckedge(CAR(ptabl),clock));
 669
 670     /* on sauvegarde la poubelle */
 671     ((chain_list *)auxExpr->DATA)->NEXT = CDR(CAR(oldExpr));
 672
 673     return (auxExpr);
 674   }
 675 }
 676
 677 /*}}}************************************************************************/
 678 /*{{{                    getBeobjField()                                    */
 679 /*                                                                          */
 680 /*                                                                          */
 681 /****************************************************************************/
 682 static inline void getBeobjField(void *be, long type, chain_list **abl,
 683                                  long *time, biabl_list **biabl,
 684                                  vectbiabl_list **vbiabl, char **name,
 685                                  char *head, int *left, int *right, int *timer, int *timef, char *flags, long *moreflags)
 686 {
 687   long l;
 688   *timer=*timef=0;
 689   *flags=0;
 690   *moreflags=0;
 691   switch (type)
 692   {
 693     case BEG_TYPE_SINGAUX :
 694          if (BEH_TIMEVARS!=NULL && (l=gethtitem(BEH_TIMEVARS, ((beaux_list *)be)->TIMEVAR))!=EMPTYHT)
 695            *time   = (int)l;
 696          else
 697            *time   = ((beaux_list *)be)->TIME;
 698          *abl    = ((beaux_list *)be)->ABL;
 699          *name   = ((beaux_list *)be)->NAME;
 700          *timer=((beaux_list *)be)->TIMER;
 701          *timef=((beaux_list *)be)->TIMEF;
 702          *moreflags=((beaux_list *)be)->FLAGS;
 703          break;
 704     case BEG_TYPE_VECTAUX :
 705          if (BEH_TIMEVARS!=NULL && (l=gethtitem(BEH_TIMEVARS, ((bevectaux_list *)be)->TIMEVAR))!=EMPTYHT)
 706            *time   = (int)l;
 707          else
 708            *time   = ((bevectaux_list *)be)->TIME;
 709          *abl    = ((bevectaux_list *)be)->ABL;
 710          *name   = ((bevectaux_list *)be)->NAME;
 711          *left   = ((bevectaux_list *)be)->LEFT;
 712          *right  = ((bevectaux_list *)be)->RIGHT;
 713          *moreflags=((bevectaux_list *)be)->FLAGS;
 714          break;
 715     case BEG_TYPE_SINGOUT :
 716          if (BEH_TIMEVARS!=NULL && (l=gethtitem(BEH_TIMEVARS, ((beout_list *)be)->TIMEVAR))!=EMPTYHT)
 717            *time   = (int)l;
 718          else
 719            *time   = ((beout_list *)be)->TIME;
 720          *timer=((beout_list *)be)->TIMER;
 721          *timef=((beout_list *)be)->TIMEF;
 722          *abl    = ((beout_list *)be)->ABL;
 723          *name   = ((beout_list *)be)->NAME;
 724          *moreflags=((beout_list *)be)->FLAGS;
 725          break;
 726     case BEG_TYPE_VECTOUT :
 727          if (BEH_TIMEVARS!=NULL && (l=gethtitem(BEH_TIMEVARS, ((bevectout_list *)be)->TIMEVAR))!=EMPTYHT)
 728            *time   = (int)l;
 729          else
 730            *time   = ((bevectout_list *)be)->TIME;
 731          *abl    = ((bevectout_list *)be)->ABL;
 732          *name   = ((bevectout_list *)be)->NAME;
 733          *left   = ((bevectout_list *)be)->LEFT;
 734          *right  = ((bevectout_list *)be)->RIGHT;
 735          *moreflags=((bevectout_list *)be)->FLAGS;
 736          break;
 737     case BEG_TYPE_VECTBUX :
 738          *vbiabl = ((bevectbux_list *)be)->VECTBIABL;
 739          *name   = ((bevectbux_list *)be)->NAME;
 740          *flags=((bevectbux_list *)be)->FLAGS;
 741          sprintf(head,"VBUX");
 742          break;
 743     case BEG_TYPE_SINGBUX :
 744          *biabl  = ((bebux_list *)be)->BIABL;
 745          *name   = ((bebux_list *)be)->NAME;
 746          *flags=((bebux_list *)be)->FLAGS;
 747          sprintf(head,"BUX");
 748          break;
 749     case BEG_TYPE_VECTBUS :
 750          *vbiabl = ((bevectbus_list *)be)->VECTBIABL;
 751          *name   = ((bevectbus_list *)be)->NAME;
 752          *flags=((bevectbus_list *)be)->FLAGS;
 753          sprintf(head,"VBUS");
 754          break;
 755     case BEG_TYPE_SINGBUS :
 756          *biabl  = ((bebus_list *)be)->BIABL;
 757          *name   = ((bebus_list *)be)->NAME;
 758          *flags=((bebus_list *)be)->FLAGS;
 759          sprintf(head,"BUS");
 760          break;
 761     case BEG_TYPE_VECTREG :
 762          *vbiabl = ((bevectreg_list *)be)->VECTBIABL;
 763          *name   = ((bevectreg_list *)be)->NAME;
 764          *flags=((bevectreg_list *)be)->FLAGS;
 765          sprintf(head,"VREG");
 766          break;
 767     case BEG_TYPE_SINGREG :
 768          *biabl  = ((bereg_list *)be)->BIABL;
 769          *name   = ((bereg_list *)be)->NAME;
 770          *flags=((bereg_list *)be)->FLAGS;
 771          sprintf(head,"REG");
 772          break;
 773     default :
 774          beh_toolbug(19,"print_one_beobj type",NULL,0);
 775   }
 776 }
 777
 778 /*}}}************************************************************************/
 779 /*}}}************************************************************************/
 780 /*{{{                    Driver initialisation (compatible)                 */
 781 /****************************************************************************/
 782 /*{{{                    bef_driverSet()                                    */
 783 /*                                                                          */
 784 /*                                                                          */
 785 /****************************************************************************/
 786 void bef_driverSet(bef_driver   *driver,
 787                    FILE         *fp,
 788                    befig_list   *fig,
 789                    char        **buffer,
 790                    int          *bufsize,
 791                    void          (*time)        (FILE*,int,int,int),
 792                    void          (*end_loop)    (FILE*,char,char*,int,int,int,loop_list*),
 793                    void          (*looplist)    (FILE*,char,char*,int,int*,int,loop_list*),
 794                    void          (*loop)        (FILE*,char,char*,int,int*,loop_list*),
 795                    void          (*value)       (FILE*,chain_list*,char,int,int,int,char**,int*),
 796                    void          (*affected)    (FILE*,char,char,int,int,int,char*,char*,loop_list*,long),
 797                    void          (*signal)      (FILE*,char*,char,int,int),
 798                    void          (*bebus_ass)   (FILE*,char*,char*,int),
 799                    int           (*isone)       (char*))
 800 {
 801   driver->FP                = fp;
 802   driver->FIG               = fig;
 803   driver->ABUFF             = buffer;
 804   driver->ABUFS             = bufsize;
 805   driver->TIME              = time;
 806   driver->END_LOOP          = end_loop;
 807   driver->LOOP_LIST         = looplist;
 808   driver->LOOP              = loop;
 809   driver->VALUE             = value;
 810   driver->AFFECTED          = affected;
 811   driver->SIGNAL            = signal;
 812   driver->INTER_ASS         = bebus_ass;
 813   driver->ISONE             = isone;
 814 }
 815
 816 /*}}}************************************************************************/
 817 /*{{{                    bef_driverSetAbl()                                 */
 818 /*                                                                          */
 819 /*                                                                          */
 820 /****************************************************************************/
 821 void bef_driverSetAbl(bef_driver *driver,
 822                       char *(*abl2strBool)(chain_list*,char*,int*))
 823 {
 824   driver->ABL.TOBOOLSTR     = abl2strBool;
 825 }
 826
 827 /*}}}************************************************************************/
 828 /*{{{                    bef_driverSetProcess()                             */
 829 /*                                                                          */
 830 /*                                                                          */
 831 /****************************************************************************/
 832 void bef_driverSetProcess(bef_driver    *driver,
 833                           void           (*withselect)  (FILE*,biabl_list*,char*,int,char**,int*),
 834                           chain_list    *(*declar)      (FILE*,biabl_list*,char*,int,char*,char**,ptype_list*clock),
 835                           void           (*begin)       (FILE*,chain_list*),
 836                           void           (*end)         (FILE*),
 837                           void           (*if_)         (FILE*,char*),
 838                           void           (*elsif)       (FILE*,char*),
 839                           int            (*else_)       (FILE*),
 840                           int            (*endif)       (FILE*,char),
 841                           int            (*edge)        (char*,char*,char,char*))
 842 {
 843   driver->PROC.WITHSELECT   = withselect;
 844   driver->PROC.DECLAR       = declar;
 845   driver->PROC.BEGIN        = begin;
 846   driver->PROC.END          = end;
 847   driver->PROC.IF           = if_;
 848   driver->PROC.ELSIF        = elsif;
 849   driver->PROC.ELSE         = else_;
 850   driver->PROC.ENDIF        = endif;
 851   driver->PROC.EDGE         = edge;
 852 }
 853
 854 /*}}}************************************************************************/
 855 /*{{{                    bef_driverSetStr()                                 */
 856 /*                                                                          */
 857 /*                                                                          */
 858 /****************************************************************************/
 859 void bef_driverSetStr(bef_driver    *driver,
 860                       char          *(*name)        (char*),
 861                       char          *(*vname)       (char*,int,int),
 862                       char          *(*vector)      (char*, char *),
 863                       char          *(*bitstr)      (char*,char*),
 864                       char          *(*bebus)       (char*),
 865                       char          *(*bereg)       (char*))
 866 {
 867   driver->STR.NAME          = name;
 868   driver->STR.VNAME         = vname;
 869   driver->STR.VECTOR        = vector;
 870   driver->STR.BITSTR        = bitstr;
 871   driver->STR.BEBUS         = bebus;
 872   driver->STR.BEREG         = bereg;
 873 }
 874
 875 /*}}}************************************************************************/
 876 /*{{{                    bef_driverSetPor()                                 */
 877 /*                                                                          */
 878 /*                                                                          */
 879 /****************************************************************************/
 880 void bef_driverSetPor(bef_driver    *driver,
 881                       void           (*por)     (FILE*,char*,char,int,int),
 882                       void           (*end)     (FILE*),
 883                       void           (*start)   (FILE*),
 884                       ht            *porht
 885                       )
 886 {
 887   driver->POR.POR           = por;
 888   driver->POR.END           = end;
 889   driver->POR.START         = start;
 890   driver->POR.PORHT         = porht;
 891 }
 892
 893 /*}}}************************************************************************/
 894 /*}}}************************************************************************/
 895 /*{{{                    Enable from outside (compatible)                   */
 896 /****************************************************************************/
 897 /*{{{                    bef_gettimeunit()                                  */
 898 /*                                                                          */
 899 /*                                                                          */
 900 /****************************************************************************/
 901 char *bef_gettimeunit (unsigned char time_unit_char)
 902 {
 903   switch (time_unit_char)
 904   {
 905     case BEH_TU__FS:
 906          return(namealloc("fs"));
 907     case BEH_TU__PS:
 908          return(namealloc("ps"));
 909     case BEH_TU__NS:
 910          return(namealloc("ns"));
 911     case BEH_TU__US:
 912          return(namealloc("us"));
 913     case BEH_TU__MS:
 914          return(namealloc("ms"));
 915     default:
 916          beh_error (200, NULL);
 917          EXIT (1);
 918          return NULL;
 919   }
 920 }
 921
 922 /*}}}************************************************************************/
 923 /*{{{                    bef_strip_ckedge()                                 */
 924 /*                                                                          */
 925 /* strip the clock edge condition                                           */
 926 /****************************************************************************/
 927 chain_list *bef_strip_ckedge(chain_list *ptabl, char *clock)
 928 {
 929   chain_list    *temp_expr, *res_expr;
 930
 931   temp_expr     = strip_ckedge_int(ptabl,clock);
 932   res_expr      = simplif10Expr(temp_expr);
 933   freeExpr(temp_expr);
 934
 935   return (res_expr);
 936 }
 937
 938 /*}}}************************************************************************/
 939 /*{{{                    bef_search_stable()                                */
 940 /*                                                                          */
 941 /* detecte la presence de STABLE                                            */
 942 /****************************************************************************/
 943 int bef_search_stable(chain_list *ptabl, char **clock)
 944 {
 945   int             num = 0;
 946
 947   if (ATOM(ptabl))
 948     return 0;
 949   if (OPER(ptabl) == STABLE)
 950   {
 951     *clock      = VALUE_ATOM(CADR(ptabl));
 952
 953     return 1;
 954   }
 955   else
 956     while ((ptabl = CDR(ptabl)) != NULL)
 957       num      += bef_search_stable(CAR(ptabl),clock);
 958
 959   return num;
 960 }
 961
 962 /*}}}************************************************************************/
 963 /*{{{                    bef_get_stable_attribute()                         */
 964 /*                                                                          */
 965 /* recupere l'attribut de STABLE                                            */
 966 /****************************************************************************/
 967 int bef_get_stable_attribute(chain_list *ptabl, char **clock)
 968 {
 969   int            num    = 0;
 970
 971   if (ATOM(ptabl))
 972     return 0;
 973
 974   if (OPER(ptabl) == STABLE)
 975   {
 976     *clock  = VALUE_ATOM(CADR(ptabl));
 977     if (ATTRIB(ptabl))
 978       num   = VALUE_ATTRIB(ptabl);
 979   }
 980   else
 981     while ((ptabl = CDR(ptabl)))
 982       if ((num = bef_get_stable_attribute(CAR(ptabl),clock)))
 983         return num;
 984
 985   return num;
 986 }
 987
 988 /*}}}************************************************************************/
 989 /*{{{                    search_notck_int()                                 */
 990 /*                                                                          */
 991 /* detecte la presence not ck ou ck                                         */
 992 /****************************************************************************/
 993 static int search_notck_int(chain_list * ptabl, char *clock)
 994 {
 995   int        num = 0;
 996
 997   if (ATOM(ptabl))
 998     return 0;
 999
1000   /* on verifie si le prochain signal est la clock */
1001   if (OPER(ptabl) == NOT)
1002     if (VALUE_ATOM(CADR(ptabl)) == clock)
1003  /*   if (CDR(CADR(ptabl)) &&
1004         VALUE_ATOM(CADR(CADR(ptabl))) == clock)*/
1005     {
1006       CKTYPE    = 1;
1007       return 1;
1008     }
1009     else
1010       return 0;
1011   else
1012     while ((ptabl = CDR(ptabl)) != NULL)
1013       num      += search_notck_int(CAR(ptabl),clock);
1014
1015   return num;
1016 }
1017
1018 /*}}}************************************************************************/
1019 /*{{{                    bef_search_notck()                                 */
1020 /*                                                                          */
1021 /* detecte la presence not ck ou ck                                         */
1022 /****************************************************************************/
1023 int bef_search_notck(chain_list * ptabl, char *clock)
1024 {
1025   CKTYPE        = 0;
1026
1027   return search_notck_int(ptabl,clock);
1028 }
1029
1030 /*}}}************************************************************************/
1031 /*{{{                    bef_drive_sigDeclaration()                         */
1032 /*                                                                          */
1033 /*                                                                          */
1034 /****************************************************************************/
1035 void bef_drive_sigDeclaration(bef_driver *driver)
1036 {
1037   drive_signals_bevectbus (driver,driver->FIG->BEVECTBUS);
1038   drive_signals_bebus     (driver);
1039   drive_signals_bevectreg (driver,driver->FIG->BEVECTREG);
1040   drive_signals_bereg     (driver);
1041   drive_signals_bevectbux (driver,driver->FIG->BEVECTBUX);
1042   drive_signals_bebux     (driver);
1043   drive_signals_bevectaux (driver,driver->FIG->BEVECTAUX);
1044   drive_signals_beaux     (driver);
1045 }
1046
1047 /*}}}************************************************************************/
1048 /*{{{                    bef_print_one_beobj()                              */
1049 /*                                                                          */
1050 /* print a process for a single signal                                      */
1051 /*                                                                          */
1052 /****************************************************************************/
1053
1054 static void bef_print_reg_case(bef_driver *driver, char *input, char *output, char *outputv)
1055 {
1056   char *name0, *stg="1'b0, 1'b1: ";
1057   chain_list *temp;
1058   if (V_INT_TAB[__MGL_DRIVE_CONFLICT].VALUE)
1059       stg="1'b0, 1'b1, 1'bx: ";
1060   name0=driver->STR.VECTOR(input, NULL);
1061   iprint(driver->FP,'i',"always @( %s )\n",name0);
1062   driver->PROC.BEGIN(driver->FP,NULL);
1063   iprint(driver->FP,0,"case ( %s )\n", name0);
1064   iprint(driver->FP,'>',stg);
1065 //  iprint(driver->FP,'>',"1'b0, 1'b1: ");
1066   driver->AFFECTED(driver->FP,0,'R',0,0,0,output,outputv,NULL,0);
1067   temp=createAtom(input);
1068   driver->VALUE   (driver->FP,temp,'R',0,0,0,driver->ABUFF, driver->ABUFS);
1069   freeExpr(temp);
1070   iprint(driver->FP, '<' ,"endcase\n");
1071   iprint(driver->FP,'-',NULL);
1072   driver->PROC.END(driver->FP);
1073 }
1074
1075
1076 void bef_print_one_beobj(bef_driver *driver, void *be, int *np,long type)
1077 {
1078   chain_list        *abl;
1079   long               time;
1080   biabl_list        *biabl;
1081   vectbiabl_list    *vbiabl, *vbiablx;
1082   char              *vname;
1083   char              *name;
1084   int                vectsize;
1085   char               head[16];
1086   long               singorvect, moreflags;
1087   int                left, right;
1088   char              *save_name, flags;
1089   int timer, timef, verilogbus, verilogreg;
1090   char buf[1024];
1091
1092   getBeobjField(be,type,&abl,&time,&biabl,&vbiabl,&name,head,&left,&right,&timer,&timef,&flags,&moreflags);
1093
1094   singorvect = type &  BEG_MASK_TYPE;
1095   type       = type & ~BEG_MASK_TYPE;
1096
1097   verilogbus=(!(V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (flags & BEH_FLAG_NORMAL)!=0) && V_BOOL_TAB[__MGL_TRISTATE_IS_MEMORY].VALUE && (flags & BEH_FLAG_FORCEBUS)==0 && driver->VLG);
1098   verilogreg=(V_BOOL_TAB[__MGL_INERTIAL_MEMORY].VALUE && (flags & BEH_FLAG_NORMAL)==0 && driver->VLG);
1099
1100   switch (singorvect)
1101   {
1102     case BEG_MASK_VECT :
1103          switch (type)
1104          {
1105            case BEG_MASK_BUS :
1106            case BEG_MASK_BUX :
1107                 for (vbiablx=vbiabl; vbiablx; vbiablx = vbiablx->NEXT)
1108                   if (hasevents(vbiablx->BIABL) || beh_isloop(vbiablx->BIABL)) break;
1109                 if (verilogbus && vbiablx==NULL && vbiabl!=NULL && vbiabl->LEFT==vbiabl->RIGHT && type!=BEG_MASK_BUS)
1110                 {
1111                   chain_list *temp;
1112                   char buf0[1024];
1113                   char *name0, *oname=name;
1114                   insert_name(name, "_prereg", buf);
1115                   name        = driver->STR.NAME(buf);
1116                   save_name   = oname;
1117                   iprint(driver->FP,'i',"\n");
1118
1119                   if (type==BEG_MASK_BUS)
1120                     save_name = driver->STR.BEBUS(oname);
1121
1122                   for (; vbiabl; vbiabl = vbiabl->NEXT)
1123                   {
1124                     iprint(driver->FP,'i',"\n");
1125                     left      = vbiabl->LEFT;
1126                     right     = vbiabl->RIGHT;
1127                     vname     = driver->STR.VNAME(name,left,right);
1128                     vectsize  = abs(left - right) + 1;
1129                     biabl     = vbiabl->BIABL;
1130
1131                     name0     = driver->STR.VNAME(name,left,right);
1132                     print_biabl(driver,biabl, name, name0,vectsize,np,head,type,flags);
1133
1134                     mbkfree(name0);
1135
1136                     name0        = driver->STR.NAME(save_name);
1137                     vname     = driver->STR.VNAME(name0,left,right);
1138                     sprintf(buf0,"%s %d", buf, vbiabl->LEFT);
1139                     bef_print_reg_case(driver,buf0,name0,vname);
1140
1141                     mbkfree(vname);
1142                   }
1143                   if (type==BEG_MASK_BUS)
1144                   {
1145                     driver->INTER_ASS(driver->FP,oname,save_name,0);
1146                   }
1147                 }
1148                 else
1149                 {
1150                   name        = driver->STR.NAME(name);
1151                   if ((V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (flags & BEH_FLAG_NORMAL)!=0) && type==BEG_MASK_BUS)
1152                   {
1153                     save_name   = name;
1154                     name        = driver->STR.BEBUS(name);
1155                   }
1156                   for (; vbiabl; vbiabl = vbiabl->NEXT)
1157                   {
1158                     iprint(driver->FP,'i',"\n");
1159                     left      = vbiabl->LEFT;
1160                     right     = vbiabl->RIGHT;
1161                     vname     = driver->STR.VNAME(name,left,right);
1162                     vectsize  = abs(left - right) + 1;
1163                     biabl     = vbiabl->BIABL;
1164
1165                     print_biabl(driver,biabl,name,vname,vectsize,np,head,type,flags);
1166                     mbkfree(vname);
1167                   }
1168                   if ((V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (flags & BEH_FLAG_NORMAL)!=0) && type==BEG_MASK_BUS)
1169                     driver->INTER_ASS(driver->FP,save_name,name,0);
1170                 }
1171                 break;
1172            case BEG_MASK_REG :// case BEG_MASK_BUX :
1173                 for (vbiablx=vbiabl; vbiablx; vbiablx = vbiablx->NEXT)
1174                   if (hasevents(vbiablx->BIABL) || beh_isloop(vbiablx->BIABL)) break;
1175                 if (verilogreg && vbiablx==NULL && vbiabl!=NULL && vbiabl->LEFT==vbiabl->RIGHT)
1176                 {
1177                   chain_list *temp;
1178                   char buf0[1024];
1179                   char *name0, *oname=name;
1180                   insert_name(name, "_prereg", buf);
1181                   name        = driver->STR.NAME(buf);
1182                   save_name   = oname;
1183                   iprint(driver->FP,'i',"\n");
1184                   if (porreg_l && porreg_l->DATA == be)
1185                   {
1186                     save_name     = driver->STR.BEREG(name);
1187                   }
1188                   for (; vbiabl; vbiabl = vbiabl->NEXT)
1189                   {
1190                     iprint(driver->FP,'i',"\n");
1191                     left      = vbiabl->LEFT;
1192                     right     = vbiabl->RIGHT;
1193 //                    vname     = driver->STR.VNAME(name,left,right);
1194                     vectsize  = abs(left - right) + 1;
1195                     biabl     = vbiabl->BIABL;
1196
1197                     name0     = driver->STR.VNAME(name,left,right);
1198
1199                     print_biabl(driver,biabl,name,name0,vectsize,np,head,type,flags);
1200                     mbkfree(name0);
1201
1202                     name0        = driver->STR.NAME(save_name);
1203                     vname     = driver->STR.VNAME(name0,left,right);
1204                     sprintf(buf0,"%s %d", buf, vbiabl->LEFT);
1205
1206                     bef_print_reg_case(driver,buf0,name0,vname);
1207
1208                     mbkfree(vname);
1209                   }
1210
1211                 }
1212                 else
1213                 {
1214                   name        = driver->STR.NAME(name);
1215                   if (porreg_l && porreg_l->DATA == be)
1216                   {
1217                     save_name = name;
1218                     name      = driver->STR.BEREG(name);
1219                   }
1220                   for (; vbiabl; vbiabl = vbiabl->NEXT)
1221                   {
1222                     iprint(driver->FP,'i',"\n");
1223                     left      = vbiabl->LEFT;
1224                     right     = vbiabl->RIGHT;
1225                     vname     = driver->STR.VNAME(name,left,right);
1226                     vectsize  = abs(left - right) + 1;
1227                     biabl     = vbiabl->BIABL;
1228                     print_biabl(driver,biabl,name,vname,vectsize,np,head,type,flags);
1229                     mbkfree(vname);
1230                   }
1231                   if (porreg_l && porreg_l->DATA == be)
1232                   {
1233                     porreg_l  = delchain(porreg_l,porreg_l);
1234                     driver->INTER_ASS(driver->FP,save_name,name,0);
1235                   }
1236                 }
1237                 break;
1238            case BEG_MASK_OUT : case BEG_MASK_AUX :
1239                 if (!abl)
1240                   beh_error(40, vname);
1241
1242                 /* added by zinaps */
1243                 if (abs(right-left)<128)
1244                 {
1245                   name      = driver->STR.NAME(name);
1246                   vname     = driver->STR.VNAME(name,left,right);
1247                   driver->AFFECTED(driver->FP,'0','W',time,timer,timef,NULL,vname,NULL,moreflags);
1248                   driver->VALUE   (driver->FP,abl,'W',time,timer,timef,driver->ABUFF,
1249                                    driver->ABUFS);
1250                   mbkfree(vname);
1251                 }
1252                 else
1253                 {
1254                   int    i, w = -1;
1255                   chain_list *cl;
1256                   if (left>right)
1257                   {
1258                     w       = right;
1259                     right   = left;
1260                     left    = w;
1261                   }
1262                   name        = driver->STR.NAME(name);
1263                   for (i = left; i <= right; i ++)
1264                   {
1265                     vname   = driver->STR.VNAME(name,i,i);
1266                     driver->AFFECTED(driver->FP,'0','W',time,timer,timef,NULL,vname,NULL,moreflags);
1267                     if (w == -1)
1268                       cl    = getAblAtPos(abl, i-left);
1269                     else
1270                       cl    = getAblAtPos(abl, right-i);
1271                     driver->VALUE(driver->FP,cl,'W',time,timer,timef,driver->ABUFF,driver->ABUFS);
1272                     freeExpr(cl);
1273                     mbkfree(vname);
1274                   }
1275                 }
1276                 /* ^^^^^^^^^^^^^^ */
1277                 break;
1278            default : ;
1279          }
1280          break;
1281     case BEG_MASK_SING :
1282          switch (type)
1283          {
1284            case BEG_MASK_BUS :
1285            case BEG_MASK_BUX :
1286                 if (verilogbus && type!=BEG_MASK_BUS && !beh_isloop(biabl) && !hasevents(biabl))
1287                 {
1288                   chain_list *temp;
1289                   char buf0[1024];
1290                   char *name0;
1291
1292                   iprint(driver->FP,'i',"\n");
1293                   insert_name(name, "_prereg", buf);
1294
1295                   if (type==BEG_MASK_BUS)
1296                   {
1297                     save_name   = name;
1298                     name        = driver->STR.BEBUS(name);
1299                   }
1300
1301                   print_biabl(driver,biabl,buf,buf,1,np,head,type,flags);
1302
1303                   bef_print_reg_case(driver,buf,name,name);
1304
1305                   if (type==BEG_MASK_BUS)
1306                     driver->INTER_ASS(driver->FP,save_name,name,1);
1307                 }
1308                 else
1309                 {
1310                    if ((V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (flags & BEH_FLAG_NORMAL)!=0) && type==BEG_MASK_BUS)
1311                    {
1312                      save_name   = name;
1313                      name        = driver->STR.BEBUS(name);
1314                    }
1315                    iprint(driver->FP,'i',"\n");
1316                    print_biabl(driver,biabl,name,name,1,np,head,type,flags);
1317                    if ((V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (flags & BEH_FLAG_NORMAL)!=0) && type==BEG_MASK_BUS)
1318                      driver->INTER_ASS(driver->FP,save_name,name,1);
1319                 }
1320                 break;
1321            case BEG_MASK_REG :
1322                 save_name   = name;
1323                 if (porreg_l && porreg_l->DATA == be)
1324                 {
1325                   name        = driver->STR.BEREG(name);
1326                 }
1327                 if (verilogreg && !beh_isloop(biabl) && !hasevents(biabl))
1328                 {
1329                   insert_name(save_name, "_prereg", buf);
1330                   iprint(driver->FP,'i',"\n");
1331                   print_biabl(driver,biabl,buf,buf,1,np,head,type,flags);
1332                   bef_print_reg_case(driver,buf,name,name);
1333                 }
1334                 else
1335                 {
1336                  iprint(driver->FP,'i',"\n");
1337                  print_biabl(driver,biabl,name,name,1,np,head,type,flags);
1338                 }
1339                 if (porreg_l && porreg_l->DATA == be)
1340                 {
1341                   porreg_l    = delchain(porreg_l,porreg_l);
1342                   driver->INTER_ASS(driver->FP,save_name,name,1);
1343                 }
1344                 break;
1345            case BEG_MASK_OUT : case BEG_MASK_AUX :
1346                 if (!abl)
1347                   beh_error(40, name);
1348                 driver->AFFECTED(driver->FP,'0','W',time,timer,timef,name,name,NULL,moreflags);
1349                 driver->VALUE   (driver->FP,abl,'W',time,timer,timef,driver->ABUFF,
1350                                  driver->ABUFS);
1351                 break;
1352            default : ;
1353          }
1354          break;
1355     default : ;
1356   }
1357 }
1358
1359 /*}}}************************************************************************/
1360 /*}}}************************************************************************/
1361 /*{{{                    Traitements des signaux simples (compatible)       */
1362 /****************************************************************************/
1363 /*{{{                    bef_driver_aux()                                   */
1364 /*                                                                          */
1365 /*                                                                          */
1366 /****************************************************************************/
1367 void bef_drive_aux(bef_driver *driver)
1368 {
1369   beaux_list        *aux  = driver->FIG->BEAUX;
1370   bevectaux_list    *vaux = driver->FIG->BEVECTAUX;
1371
1372   if (aux || vaux)
1373     iprint(driver->FP,'i',"\n");
1374
1375   for (; aux; aux = aux->NEXT)
1376     bef_print_one_beobj(driver,  aux, NULL, BEG_TYPE_SINGAUX);
1377   for (; vaux; vaux = vaux->NEXT)
1378     bef_print_one_beobj(driver, vaux, NULL, BEG_TYPE_VECTAUX);
1379 }
1380
1381 /*}}}************************************************************************/
1382 /*{{{                    bef_drive_out()                                    */
1383 /*                                                                          */
1384 /*                                                                          */
1385 /****************************************************************************/
1386 void bef_drive_out(bef_driver *driver)
1387 {
1388   bevectout_list    *vout = driver->FIG->BEVECTOUT;
1389   beout_list        *out  = driver->FIG->BEOUT;
1390
1391   if (out || vout)
1392     iprint(driver->FP,'i',"\n");
1393
1394   for (; out; out  = out->NEXT)
1395     bef_print_one_beobj(driver,  out, NULL, BEG_TYPE_SINGOUT);
1396   for (; vout; vout = vout->NEXT)
1397     bef_print_one_beobj(driver, vout, NULL, BEG_TYPE_VECTOUT);
1398 }
1399
1400 /*}}}************************************************************************/
1401 /*}}}************************************************************************/
1402 /*{{{                    Traitement des bus (compatible)                    */
1403 /****************************************************************************/
1404 /*{{{                    bef_drive_bux()                                    */
1405 /*                                                                          */
1406 /*                                                                          */
1407 /****************************************************************************/
1408 void bef_drive_bux(bef_driver *driver)
1409 {
1410   bebux_list     *bux;
1411   bevectbux_list *vbux;
1412   int             numprocess = 0;
1413
1414   for (bux = driver->FIG->BEBUX; bux; bux = bux->NEXT)
1415     bef_print_one_beobj(driver,bux,&numprocess,BEG_TYPE_SINGBUX);
1416
1417   numprocess = 0;
1418   for(vbux=driver->FIG->BEVECTBUX;vbux;vbux=vbux->NEXT)
1419     bef_print_one_beobj(driver,vbux,&numprocess,BEG_TYPE_VECTBUX);
1420 }
1421
1422 /*}}}************************************************************************/
1423 /*{{{                    bef_drive_bus()                                    */
1424 /*                                                                          */
1425 /*                                                                          */
1426 /****************************************************************************/
1427 void bef_drive_bus(bef_driver *driver)
1428 {
1429   bebus_list     *bus;
1430   bevectbus_list *vbus;
1431   int             numprocess = 0;
1432
1433   for (bus = driver->FIG->BEBUS; bus; bus = bus->NEXT)
1434     bef_print_one_beobj(driver,bus,&numprocess,BEG_TYPE_SINGBUS);
1435
1436   numprocess = 0;
1437   for(vbus = driver->FIG->BEVECTBUS;vbus;vbus=vbus->NEXT)
1438     bef_print_one_beobj(driver,vbus,&numprocess,BEG_TYPE_VECTBUS);
1439 }
1440
1441 /*}}}************************************************************************/
1442 /*}}}************************************************************************/
1443 /*{{{                    Traitement des registres  (compatible)             */
1444 /****************************************************************************/
1445 /*{{{                    bef_drive_reg()                                    */
1446 /*                                                                          */
1447 /*                                                                          */
1448 /****************************************************************************/
1449 void bef_drive_reg(bef_driver *driver)
1450 {
1451   bereg_list     *reg;
1452   bevectreg_list *vreg;
1453   int             numprocess    = 0;
1454
1455   for (reg = driver->FIG->BEREG; reg; reg = reg->NEXT)
1456     bef_print_one_beobj(driver,reg,&numprocess,BEG_TYPE_SINGREG);
1457
1458   numprocess = 0;
1459   for(vreg=driver->FIG->BEVECTREG;vreg;vreg=vreg->NEXT)
1460     bef_print_one_beobj(driver,vreg,&numprocess,BEG_TYPE_VECTREG);
1461 }
1462
1463 /*}}}************************************************************************/
1464 /*}}}************************************************************************/
1465 /*{{{                    Declaration des connecteurs                        */
1466 /****************************************************************************/
1467 /*{{{                    reverse_takeBiggerNamePor()                        */
1468 /*                                                                          */
1469 /*                                                                          */
1470 /****************************************************************************/
1471 static bepor_list *reverse_takeBiggerNamePor(bepor_list *por)
1472 {
1473   bepor_list    *p, *q = NULL;
1474   int            len;
1475
1476   if (!por)
1477     return NULL;
1478   while ((p = por->NEXT))
1479   {
1480     len         = strlen(por->NAME);
1481     if (MAXNAME < len)
1482       MAXNAME   = len;
1483     por->NEXT   = q;
1484     q           = por;
1485     por         = p;
1486   }
1487   por->NEXT     = q;
1488
1489   return por;
1490 }
1491
1492 /*}}}************************************************************************/
1493 /*{{{                    porGetDir()                                        */
1494 /*                                                                          */
1495 /*                                                                          */
1496 /****************************************************************************/
1497 static inline
1498 char porGetDir(bepor_list *st, bepor_list *ed)
1499 {
1500   char       res;
1501
1502   res       = 'X';
1503
1504   for (; st != ed->NEXT; st = st->NEXT)
1505     if (st->DIRECTION != 'X')
1506       /*
1507       if (res != 'X' && res != st->DIRECTION)
1508         res     = 'Z';
1509       */
1510       res   = st->DIRECTION;
1511
1512   return res;
1513 }
1514
1515 /*}}}************************************************************************/
1516 /*{{{                    drive_one_por()                                    */
1517 /*                                                                          */
1518 /*                                                                          */
1519 /****************************************************************************/
1520 static bepor_list *drive_one_por(bef_driver *driver, bepor_list *por)
1521 {
1522   bepor_list    *porx;
1523   int            left, right;
1524   char          *name, dir;
1525
1526   porx      = vectnam(por,&left,&right,&name,BEG_TYPE_SINGPOR);
1527   dir       = porGetDir(por,porx);
1528   if (driver->POR.PORHT)
1529     addhtitem(driver->POR.PORHT,namealloc(name),BEG_TYPE_SINGPOR);
1530   driver->POR.POR(driver->FP,name,dir,left,right);
1531
1532   mbkfree(name);
1533
1534   return porx;
1535 }
1536
1537 /*}}}************************************************************************/
1538 /*{{{                    drive_one_vpor()                                   */
1539 /*                                                                          */
1540 /*                                                                          */
1541 /****************************************************************************/
1542 static void drive_one_vpor(bef_driver *driver, bevectpor_list *vpor)
1543 {
1544   driver->POR.POR(driver->FP,vpor->NAME,vpor->DIRECTION,
1545                   vpor->LEFT,vpor->RIGHT);
1546   if (driver->POR.PORHT)
1547     addhtitem(driver->POR.PORHT,vpor->NAME,0);
1548 }
1549
1550 /*}}}************************************************************************/
1551 /*{{{                    bef_initMaxname()                                  */
1552 /*                                                                          */
1553 /*                                                                          */
1554 /****************************************************************************/
1555 void bef_initMaxname(void)
1556 {
1557   MAXNAME       = 0;
1558 }
1559
1560 /*}}}************************************************************************/
1561 /*{{{                    bef_drive_vpor()                                   */
1562 /*                                                                          */
1563 /*                                                                          */
1564 /****************************************************************************/
1565 static void drive_vpor(bef_driver *driver, bevectpor_list *vpor,int cpt)
1566 {
1567   if (vpor)
1568   {
1569     int      len;
1570
1571     len         = strlen(vpor->NAME);
1572     if (MAXNAME < len)
1573       MAXNAME   = len;
1574     drive_vpor(driver,vpor->NEXT,cpt+1);
1575     drive_one_vpor(driver,vpor);
1576     if (cpt)
1577       fprintf(driver->FP,";\n");
1578   }
1579 }
1580
1581
1582 /*}}}************************************************************************/
1583 /*{{{                    bef_drive_por()                                    */
1584 /*                                                                          */
1585 /*                                                                          */
1586 /****************************************************************************/
1587 static void drive_por(bef_driver *driver, bepor_list *por)
1588 {
1589   if (por)
1590   {
1591     bepor_list  *porx;
1592
1593     por     = reverse_takeBiggerNamePor(por);
1594
1595     for (porx = por; porx; )
1596       if ((porx = drive_one_por(driver, porx)->NEXT ))
1597         fprintf(driver->FP,";\n");
1598
1599     por     = (bepor_list *)reverse((chain_list *)por);
1600   }
1601 }
1602
1603 /*}}}************************************************************************/
1604 /*{{{                    port_declaration()                                 */
1605 /*                                                                          */
1606 /*                                                                          */
1607 /****************************************************************************/
1608 void bef_drive_porDeclaration(bef_driver *driver)
1609 {
1610   MAXNAME       = 0;
1611   driver->POR.START(driver->FP);
1612   drive_vpor (driver,driver->FIG->BEVECTPOR,driver->FIG->BEPOR ? 1 : 0);
1613   drive_por  (driver,driver->FIG->BEPOR);
1614   driver->POR.END(driver->FP);
1615   MAXNAME       = 0;
1616 }
1617
1618 /*}}}************************************************************************/
1619 /*}}}************************************************************************/
1620 /*{{{                    Drive structures of behavior                       */
1621 /****************************************************************************/
1622 /*{{{                    drive_cnd_abl()                                    */
1623 /*                                                                          */
1624 /*                                                                          */
1625 /****************************************************************************/
1626 static void drive_cnd_abl(bef_driver *driver, char *buffer, int *done_endif,
1627                           int *done_else, int first, int sameckcnd,
1628                           long flag, void *next, int drive_edge)
1629 {
1630   // condition drive
1631   // the first
1632   if (first)
1633   {
1634     if (drive_edge)
1635       driver->PROC.IF(driver->FP,buffer);
1636   }
1637   // the last for else
1638   else if (!next && driver->ISONE(buffer))
1639   {
1640     *done_else      = driver->PROC.ELSE(driver->FP);
1641     *done_endif     = 1;
1642   }
1643   // precedence
1644   else if (!(flag&BEH_CND_PRECEDE))
1645   {
1646     if (!sameckcnd)
1647     {
1648       if (!done_endif)
1649         *done_endif = driver->PROC.ENDIF(driver->FP,'0');
1650       if (drive_edge)
1651         driver->PROC.IF(driver->FP,buffer);
1652     }
1653     else
1654       iprint(driver->FP,'+',NULL);
1655     *done_else      = 0;
1656   }
1657   else if (flag&BEH_CND_LAST)
1658     *done_else      = driver->PROC.ELSE(driver->FP);
1659   else if (!sameckcnd)
1660     driver->PROC.ELSIF(driver->FP,buffer);
1661 }
1662
1663 /*}}}************************************************************************/
1664 /*{{{                    drive_end_of_process()                             */
1665 /*                                                                          */
1666 /*                                                                          */
1667 /****************************************************************************/
1668 static void drive_end_of_process(bef_driver *driver, loop_list *lastloop,
1669                                  int done_endif, int done_else, int cpt,
1670                                  char *name, char *vname, int vsize,
1671                                  int np, char *head, int type)
1672 {
1673   char           buf[4096];
1674
1675   if ( (type != BEG_MASK_REG) && !done_else)
1676   {
1677     driver->PROC.ELSE(driver->FP);
1678     driver->AFFECTED(driver->FP,'-','R',0,0,0,name,vname,lastloop,0);
1679     if (lastloop && lastloop->INDEX)
1680       fprintf(driver->FP,"%s;\n",driver->STR.BITSTR(genHZBitStr(1),buf));
1681     else
1682       fprintf(driver->FP,"%s;\n",driver->STR.BITSTR(genHZBitStr(vsize),buf));
1683   }
1684   if (!done_endif)
1685     driver->PROC.ENDIF(driver->FP,'-');
1686   driver->END_LOOP(driver->FP,'-',head,np,cpt,0,lastloop);
1687 }
1688
1689 /*}}}************************************************************************/
1690 /*{{{                    drive_one_biabl()                                  */
1691 /*                                                                          */
1692 /*                                                                          */
1693 /****************************************************************************/
1694 static void drive_one_biabl(bef_driver *driver, biabl_list *biabl,
1695                             loop_list **lastloop, char **oldckcnd,
1696                             int *done_endif, int *done_else, int *cpt,
1697                             int first, char *name,
1698                             char *vname, int vsize, int *np, char *head,
1699                             int type, char **buffer, int *bsize)
1700 {
1701   long           flag = biabl->FLAG;
1702   FILE          *fp = driver->FP;
1703   bef_process    proc = driver->PROC;
1704   int            isEdgeCondition;
1705   int            sameloop;
1706   int            drive_edge;
1707   loop_list     *loop;
1708   int            sndckcnd;
1709   char          *clock, buf[4096];
1710   int            sameckcnd;
1711   biabl_list    *next;
1712
1713   next                  = biabl->NEXT;
1714
1715   // detect edge condition
1716   if (type == BEG_MASK_REG)
1717     isEdgeCondition     = bef_search_stable(biabl->CNDABL,&clock);
1718   else
1719   {
1720     isEdgeCondition     = 0;
1721     flag|=BEH_CND_PRECEDE;
1722   }
1723   // case of edge condition
1724   if (isEdgeCondition)
1725   {
1726     char       ckstate, *ckname, *signame;
1727
1728     if (bef_search_notck(biabl->CNDABL,clock) > 0)
1729       ckstate           = '0';
1730     else
1731       ckstate           = '1';
1732     beg_get_vectname(clock,&signame,NULL,NULL,BEG_SEARCH_ABL);
1733     signame             = driver->STR.NAME(signame);
1734     ckname              = driver->STR.VECTOR(clock,buf);
1735
1736     drive_edge          = proc.EDGE(*buffer,ckname,ckstate,signame);
1737
1738     sameckcnd           = *oldckcnd && !strcmp(*oldckcnd,*buffer);
1739     if (*oldckcnd)
1740       mbkfree(*oldckcnd);
1741     *oldckcnd           = mbkstrdup(*buffer);
1742   }
1743   else
1744   // default
1745   {
1746     *buffer             = getStrAblReduce(driver,biabl->CNDABL,*buffer,bsize);
1747     if (*oldckcnd)
1748       mbkfree(*oldckcnd);
1749     *oldckcnd           = NULL;
1750     sameckcnd           = 0;
1751     drive_edge          = 1;
1752   }
1753
1754   if (!*done_endif && !(flag&BEH_CND_PRECEDE) && !(flag&BEH_CND_LAST))
1755   {
1756     if (type != BEG_MASK_REG && !*done_else)
1757     {
1758 /*      proc.ELSE(fp);
1759       *done_else        = 1;
1760       driver->AFFECTED(fp,'-','R',0,0,0,name,vname,*lastloop);
1761       if (*lastloop && (*lastloop)->INDEX)
1762         fprintf(fp,"%s;\n",driver->STR.BITSTR(genHZBitStr(1),buf));
1763       else
1764         fprintf(fp,"%s;\n",driver->STR.BITSTR(genHZBitStr(vsize),buf));
1765         */
1766     }
1767     if (!sameckcnd)
1768       *done_endif       = proc.ENDIF(fp,'0');
1769   }
1770
1771   loop                  = beh_getloop(biabl);
1772   sameloop              = beh_isSameLoop(loop,*lastloop);
1773   driver->END_LOOP (fp,'<',head,*np,*cpt,sameloop,*lastloop);
1774   driver->LOOP_LIST(fp,'+',head,*np,cpt,sameloop,loop);
1775
1776   drive_cnd_abl(driver,*buffer,done_endif,done_else,first,sameckcnd,
1777                 flag,next,drive_edge);
1778
1779   // supplementary condition in case of register
1780   if (isEdgeCondition)
1781   {
1782     chain_list    *cndabl;
1783
1784     cndabl              = bef_strip_ckedge(biabl->CNDABL,clock);
1785     sndckcnd            = (!(ATOM(cndabl) &&
1786                              !(strcmp(VALUE_ATOM(cndabl),"'1'") &&
1787                                strcmp(VALUE_ATOM(cndabl),"'0'"))));
1788     if (sndckcnd)
1789     {
1790       *buffer           = getStrAblReduce(driver,cndabl,*buffer,bsize);
1791       drive_cnd_abl(driver,*buffer,done_endif,done_else,first,0,flag,next,1);
1792     }
1793     freeExpr(cndabl);
1794   }
1795   else
1796     sndckcnd            = 0;
1797
1798   // value
1799   if (biabl->VALABL)
1800   {
1801     int time;
1802     long l;
1803     if (BEH_TIMEVARS!=NULL && (l=gethtitem(BEH_TIMEVARS, biabl->TIMEVAR))!=EMPTYHT)
1804       time=(int)l;
1805     else
1806       time=biabl->TIME;
1807     if (biabl->TIMER!=0 || biabl->TIMEF!=0)
1808       time=(int)((biabl->TIMER+biabl->TIMEF)/2.0+0.5);
1809     driver->AFFECTED(fp,'-','R',time,0,0,name,vname,loop,biabl->FLAG);
1810     driver->VALUE   (fp,biabl->VALABL,'R',time,0,0,driver->ABUFF,
1811                      driver->ABUFS);
1812   }
1813   else
1814     beh_toolbug(20, "drive_process",name, 0);
1815
1816
1817   if (!drive_edge && !sndckcnd)
1818     *done_endif           = 1;
1819   else
1820     *done_endif           = 0;
1821
1822
1823   if (sndckcnd && !(next && next->FLAG & BEH_CND_PRECEDE))
1824     if (drive_edge)
1825       proc.ENDIF(fp,'-');
1826   *lastloop             = loop;
1827 }
1828
1829 /*}}}************************************************************************/
1830 /*{{{                    getStrAblReduce()                                  */
1831 /*                                                                          */
1832 /*                                                                          */
1833 /****************************************************************************/
1834 static char *getStrAblReduce(bef_driver *driver, chain_list *abl,
1835                              char *buffer, int *bsize)
1836 {
1837   chain_list    *red;
1838
1839   red               = bef_preprocess_abl(abl);
1840   buffer[0]         = '\0';
1841   buffer            = driver->ABL.TOBOOLSTR(red,buffer,bsize);
1842   freeExpr(red);
1843
1844   return buffer;
1845 }
1846
1847 /*}}}************************************************************************/
1848 /*{{{                    drive_process()                                    */
1849 /*                                                                          */
1850 /*                                                                          */
1851 /****************************************************************************/
1852 static ptype_list *getevents(biabl_list *biabl, int *others)
1853 {
1854   biabl_list    *biablx;
1855   char *clk;
1856   ptype_list *all=NULL, *pt;
1857   long dir;
1858
1859   *others=0;
1860   for (biablx = biabl; biablx; biablx = biablx->NEXT)
1861      if ((bef_search_stable(biablx->CNDABL,&clk)) > 0)
1862      {
1863         if (bef_search_notck(biablx->CNDABL,clk) > 0) dir=0;
1864         else dir=1;
1865
1866         for (pt=all; pt!=NULL && !(pt->DATA==clk && pt->TYPE==dir); pt=pt->NEXT) ;
1867         if (pt==NULL)
1868           all=addptype(all, dir,clk);
1869      }
1870      else (*others)++;
1871   return (ptype_list *)reverse((chain_list *)all);
1872 }
1873
1874 static void drive_process(bef_driver *driver, biabl_list *biabl, char *name,
1875                           char *vname, int vsize, int *np, char *head,
1876                           int type, char flags)
1877 {
1878   chain_list    *loopchain;
1879   char          *oldckcnd;
1880   int            done_endif, done_else, cpt, first, go, others;
1881   biabl_list    *biablx;
1882   loop_list     *lastloop;
1883   ptype_list *events, *pt;
1884   char buf[4096];
1885   char *pbuf;
1886   int bsize, time;
1887   long l;
1888
1889   driver->PROC.EDGE(buf,"",0,"");
1890
1891   if (driver->VLG) // verilog
1892     events=getevents(biabl, &others);
1893   else
1894     events=NULL;
1895
1896   if ((!(V_BOOL_TAB[__MGL_OLD_STYLE_BUS].VALUE || (flags & BEH_FLAG_NORMAL)!=0) &&
1897       ((type & ~BEG_MASK_TYPE)== BEG_MASK_BUS || (type & ~BEG_MASK_TYPE)==BEG_MASK_BUX) && driver->VLG && vsize==1 && !beh_isloop(biabl))
1898       ||
1899       (V_BOOL_TAB[__MGL_INERTIAL_MEMORY].VALUE && (flags & BEH_FLAG_NORMAL)==0 &&
1900       ((type & ~BEG_MASK_TYPE)== BEG_MASK_REG) && driver->VLG && vsize==1 && !beh_isloop(biabl) && events==NULL)
1901      )
1902   {
1903     iprint(driver->FP,'i',"/* %s '%s' */\n",(type & ~BEG_MASK_TYPE)== BEG_MASK_REG?"REGISTER":"BUS",vname);
1904     for (biablx = biabl; biablx; biablx = biablx->NEXT)
1905       {
1906         if (BEH_TIMEVARS!=NULL && (l=gethtitem(BEH_TIMEVARS, biablx->TIMEVAR))!=EMPTYHT)
1907           time=(int)l;
1908         else
1909           time=biablx->TIME;
1910         *driver->ABUFF = getStrAblReduce(driver,biablx->CNDABL,*driver->ABUFF, driver->ABUFS);
1911         if (driver->ISONE(*driver->ABUFF)) l=BEH_CND_WEAK;
1912         else l=0;
1913         driver->AFFECTED(driver->FP,'0','w',time, biablx->TIMER, biablx->TIMEF, name, vname, NULL,biablx->FLAG | l);
1914         if (l==0)
1915         {
1916           fprintf(driver->FP, "(%s) ? ", *driver->ABUFF);
1917         }
1918         driver->VALUE   (driver->FP,biablx->VALABL,'w',biablx->TIME, biablx->TIMER, biablx->TIMEF,driver->ABUFF, driver->ABUFS);
1919         if (l==0)
1920           fprintf(driver->FP, " : 1'bz;\n");
1921         else
1922           fprintf(driver->FP, " ;\n");
1923       }
1924     iprint(driver->FP,'i',"/* ---------------------------- */\n",name);
1925   }
1926   else
1927   {
1928     if (events==NULL) events=addptype(events, 0, NULL);
1929     else if (others>0) events=addptype(events, 1, NULL);
1930
1931     if (driver->VLG && events!=NULL && events->NEXT!=NULL)
1932       iprint(driver->FP,'i',"/* Event split for '%s' */\n",vname);
1933
1934     for (pt=events; pt!=NULL; pt=pt->NEXT)
1935     {
1936       // sensibility list
1937       if (pt->TYPE==0 && pt->DATA==NULL)
1938         loopchain     = driver->PROC.DECLAR(driver->FP,biabl,name,*np,head,
1939                                             driver->ABUFF,NULL);
1940       else
1941         loopchain     = driver->PROC.DECLAR(driver->FP,biabl,name,*np,head,
1942                                             driver->ABUFF,pt);
1943
1944       // process
1945       lastloop      = NULL;
1946       oldckcnd      = NULL;
1947       done_else     = 0;
1948       cpt           = 0;
1949       done_endif    = 1;
1950       first         = 1;
1951
1952       driver->PROC.BEGIN(driver->FP,loopchain);
1953       for (biablx = biabl; biablx; biablx = biablx->NEXT, first = 0)
1954       {
1955         go=0;
1956         if (pt->TYPE==0 && pt->DATA==NULL) go=1;
1957         else
1958            {
1959              int hasclk;
1960              char *clk;
1961              long dir;
1962              hasclk=bef_search_stable(biablx->CNDABL,&clk);
1963              if (pt->TYPE==1 && pt->DATA==NULL && hasclk<=0) go=1;
1964              else if (hasclk>0 && clk==pt->DATA)
1965                {
1966                   if (bef_search_notck(biablx->CNDABL,clk) > 0) dir=0;
1967                   else dir=1;
1968                   if (dir==pt->TYPE) go=1;
1969                }
1970            }
1971        if (go)
1972          drive_one_biabl(driver,biablx,&lastloop,&oldckcnd,&done_endif,&done_else,
1973                         &cpt,first,name,vname,vsize,np,head,type,
1974                         driver->ABUFF,driver->ABUFS);
1975       }
1976
1977       // end of process
1978       drive_end_of_process(driver,lastloop,done_endif,done_else,cpt,name,vname,
1979                            vsize,*np,head,type);
1980       driver->PROC.END(driver->FP);
1981       (*np) ++;
1982
1983       if (oldckcnd)
1984         mbkfree(oldckcnd);
1985       if (pt->NEXT!=NULL) iprint(driver->FP,'i',"\n");
1986     }
1987     if (driver->VLG && events!=NULL && events->NEXT!=NULL)
1988       iprint(driver->FP,'i',"/* ---------------------------- */\n");
1989   }
1990   freeptype(events);
1991 }
1992
1993 /*}}}************************************************************************/
1994 /*}}}************************************************************************/
1995 /*}}}************************************************************************/