distrib/sources/yagle/genius/gen_main.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   Alliance                     */
   4 /*                                                                          */
   5 /*    Produit : GENIUS   v1.00                                              */
   6 /*    Fichier : gen_main.c                                                  */
   7 /*                                                                          */
   8 /*    (c) copyright 1999 Laboratoire MASI equipe CAO & VLSI                 */
   9 /*    Tous droits reserves                                                  */
  10 /*    Support : e-mail alliance-support@asim.lip6.fr                        */
  11 /*                                                                          */
  12 /*    Auteur(s) : Francois DONNET                        le : 04/05/1999    */
  13 /*                                                                          */
  14 /*    Modifie par :                                     le : ../../....     */
  15 /*    Modifie par :                                     le : ../../....     */
  16 /*    Modifie par :                                     le : ../../....     */
  17 /*                                                                          */
  18 /****************************************************************************/
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <time.h>
  22 #include <sys/stat.h>
  23 #include <sys/resource.h>
  24 #include <errno.h>
  25 #include <tcl.h>
  26
  27 #include MUT_H
  28 #include MLO_H
  29 #include MLU_H
  30 #include BEG_H
  31
  32 #include API_H
  33
  34 #ifdef AVERTEC
  35 #include AVT_H
  36 #endif
  37
  38
  39 #include GEN_H
  40 #include "gen_env.h"
  41 #include "gen_model_utils.h"
  42 #include "gen_model_global.h"
  43 #include "gen_verif_global.h"
  44 #include "gen_search_global.h"
  45 #include "gen_search_utils.h"
  46 //#include "gen_corresp.h"
  47 //#include "gen_search_utils.h"
  48 #include "gen_new_kind.h"
  49 #include "gen_main.h"
  50 #include "gen_display.h"
  51 #include "gen_globals.h"
  52 //#include "gen_corresp.h"
  53
  54 ht *gns_create_template_hierarchy(lib_entry *files_list);
  55
  56 void SaveContext(GeniusContext *GC)
  57 {
  58     // gen_corresp.c
  59   GC->GEN_HEAD_LOFIG=GEN_HEAD_LOFIG; GEN_HEAD_LOFIG=NULL;
  60   GC->GEN_HT_LOFIG=GEN_HT_LOFIG; GEN_HT_LOFIG=NULL;
  61
  62   memcpy(&GC->corresp_heap, &corresp_heap, sizeof(HeapAlloc));
  63   memcpy(&GC->subinst_heap, &subinst_heap, sizeof(HeapAlloc));
  64
  65   GC->GENIUS_TO_SPY=GENIUS_TO_SPY; GENIUS_TO_SPY=NULL;
  66   GC->GENIUS_SPY=GENIUS_SPY; GENIUS_SPY=NULL;
  67
  68   // gen_env.c
  69   GC->GENIUS_LIB_NAME=GENIUS_LIB_NAME; GENIUS_LIB_NAME=NULL;
  70   GC->GENIUS_LIB_PATH=GENIUS_LIB_PATH; GENIUS_LIB_PATH=NULL;
  71   GC->GENIUS_TREE=GENIUS_TREE; GENIUS_TREE=NULL;
  72   GC->GENIUS_PRIORITY=GENIUS_PRIORITY; GENIUS_PRIORITY=NULL;
  73   GC->GENIUS_OUTPUT=GENIUS_OUTPUT; GENIUS_OUTPUT=NULL;
  74   GC->GEN_DEBUG_LEVEL=GEN_DEBUG_LEVEL; GEN_DEBUG_LEVEL=0;
  75   GC->GEN_OPTIONS_PACK=GEN_OPTIONS_PACK; GEN_OPTIONS_PACK=0;
  76   GC->genius_ec=genius_ec; genius_ec=NULL;
  77
  78   // gen_execute_VHDL.c
  79   GC->VAR_UNKNOWN=VAR_UNKNOWN; VAR_UNKNOWN=0;
  80   GC->VAR_UNDEF=VAR_UNDEF; VAR_UNDEF=0;
  81
  82   // gen_model_utils.c
  83   GC->GEN_SEPAR=GEN_SEPAR; GEN_SEPAR='.';
  84   GC->blocks_to_free=blocks_to_free; blocks_to_free=NULL;
  85   GC->HEAD_MODEL=HEAD_MODEL; HEAD_MODEL=NULL;
  86   GC->HEAD_MARK=HEAD_MARK; HEAD_MARK=NULL;
  87
  88   GC->GENIUS_HEAD_LOFIG=GENIUS_HEAD_LOFIG; GENIUS_HEAD_LOFIG=NULL;
  89   GC->GENIUS_HT_LOFIG=GENIUS_HT_LOFIG; GENIUS_HT_LOFIG=NULL;
  90   GC->ModelTrace=ModelTrace; ModelTrace=NULL;
  91
  92   //gen_new_king.c
  93   memcpy(&GC->ea_heap, &ea_heap, sizeof(HeapAlloc));
  94
  95   //gen_optimization.c
  96   memcpy(&GC->lcu_heap, &lcu_heap, sizeof(HeapAlloc));
  97   memcpy(&GC->stat_heap, &stat_heap, sizeof(HeapAlloc));
  98
  99   //gen_search_global.c
 100   GC->GENIUS_GLOBAL_LOFIG=GENIUS_GLOBAL_LOFIG;
 101
 102   // gen_search_utils.c
 103   memcpy(GC->tabs, tabs, 200); strcpy(tabs,"");
 104   GC->current_lofig=current_lofig;
 105   GC->ALL_ENV=ALL_ENV;
 106   GC->GEN_USER=GEN_USER;
 107   GC->NEW_LOINS_NAMES_HT=NEW_LOINS_NAMES_HT; NEW_LOINS_NAMES_HT=NULL;
 108   GC->LOINS_LIST_CONTROL=LOINS_LIST_CONTROL; LOINS_LIST_CONTROL=NULL;
 109   GC->ALL_KIND_OF_MODELS=ALL_KIND_OF_MODELS; ALL_KIND_OF_MODELS=NULL;
 110   GC->ALL_LOINS_FOUND=ALL_LOINS_FOUND; ALL_LOINS_FOUND=NULL;
 111   GC->CUR_HIER_LOFIG=CUR_HIER_LOFIG;
 112   GC->CUR_CORRESP_TABLE=CUR_CORRESP_TABLE;
 113   memcpy(&GC->all_loins_heap, &all_loins_heap, sizeof(HeapAlloc));
 114   memcpy(&GC->loconmark_heap, &loconmark_heap, sizeof(HeapAlloc));
 115
 116   //gen_symmetric.c
 117   memcpy(&GC->swap_heap, &swap_heap, sizeof(HeapAlloc));
 118   GC->radindexht=radindexht;
 119   GC->radtable=radtable;
 120   GC->curradindex=curradindex;
 121   GC->scht=scht;
 122   GC->myallocs=myallocs;
 123
 124   memcpy(GC->ALL_SYM_INFO, ALL_SYM_INFO, sizeof(biinfo *)*MAX_SYMLIST);
 125   GC->CUR_SYM_INDEX=CUR_SYM_INDEX;
 126
 127   memcpy(GC->entry, entry, sizeof(struct localcash)*CASHS);
 128   GC->FOUND_MODEL=FOUND_MODEL;
 129
 130   GC->TEMPLATE_HT=GNS_TEMPLATE_HT;
 131 }
 132
 133 void RestoreContext(GeniusContext *GC)
 134 {
 135     // gen_corresp.c
 136   GEN_HEAD_LOFIG=GC->GEN_HEAD_LOFIG;
 137   GEN_HT_LOFIG=GC->GEN_HT_LOFIG;
 138 //  TRANS_TO_SUPPRESS=GC->TRANS_TO_SUPPRESS;
 139
 140   memcpy(&corresp_heap, &GC->corresp_heap, sizeof(HeapAlloc));
 141   memcpy(&subinst_heap, &GC->subinst_heap, sizeof(HeapAlloc));
 142
 143   GENIUS_TO_SPY=GC->GENIUS_TO_SPY;
 144   GENIUS_SPY=GC->GENIUS_SPY;
 145
 146   // gen_env.c
 147   GENIUS_LIB_NAME=GC->GENIUS_LIB_NAME;
 148   GENIUS_LIB_PATH=GC->GENIUS_LIB_PATH;
 149   GENIUS_TREE=GC->GENIUS_TREE;
 150   GENIUS_PRIORITY=GC->GENIUS_PRIORITY;
 151   GENIUS_OUTPUT=GC->GENIUS_OUTPUT;
 152   GEN_DEBUG_LEVEL=GC->GEN_DEBUG_LEVEL;
 153   GEN_OPTIONS_PACK=GC->GEN_OPTIONS_PACK;
 154   genius_ec=GC->genius_ec;
 155
 156   // gen_execute_VHDL.c
 157   VAR_UNKNOWN=GC->VAR_UNKNOWN;
 158   VAR_UNDEF=GC->VAR_UNDEF;
 159
 160   // gen_model_utils.c
 161   GEN_SEPAR=GC->GEN_SEPAR;
 162   blocks_to_free=GC->blocks_to_free;
 163   HEAD_MODEL=GC->HEAD_MODEL;
 164   HEAD_MARK=GC->HEAD_MARK;
 165
 166   GENIUS_HEAD_LOFIG=GC->GENIUS_HEAD_LOFIG;
 167   GENIUS_HT_LOFIG=GC->GENIUS_HT_LOFIG;
 168   ModelTrace=GC->ModelTrace;
 169
 170   //gen_new_king.c
 171   memcpy(&ea_heap, &GC->ea_heap, sizeof(HeapAlloc));
 172
 173   //gen_optimization.c
 174   memcpy(&lcu_heap, &GC->lcu_heap, sizeof(HeapAlloc));
 175   memcpy(&stat_heap, &GC->stat_heap, sizeof(HeapAlloc));
 176
 177   //gen_search_global.c
 178   GENIUS_GLOBAL_LOFIG=GC->GENIUS_GLOBAL_LOFIG;
 179
 180   // gen_search_utils.c
 181   memcpy(tabs, GC->tabs, 200);
 182   current_lofig=GC->current_lofig;
 183   ALL_ENV=GC->ALL_ENV;
 184   GEN_USER=GC->GEN_USER;
 185   NEW_LOINS_NAMES_HT=GC->NEW_LOINS_NAMES_HT;
 186   LOINS_LIST_CONTROL=GC->LOINS_LIST_CONTROL;
 187   ALL_KIND_OF_MODELS=GC->ALL_KIND_OF_MODELS;
 188   ALL_LOINS_FOUND=GC->ALL_LOINS_FOUND;
 189   CUR_HIER_LOFIG=GC->CUR_HIER_LOFIG;
 190   CUR_CORRESP_TABLE=GC->CUR_CORRESP_TABLE;
 191   memcpy(&all_loins_heap, &GC->all_loins_heap, sizeof(HeapAlloc));
 192   memcpy(&loconmark_heap, &GC->loconmark_heap, sizeof(HeapAlloc));
 193
 194   //gen_symmetric.c
 195   memcpy(&swap_heap, &GC->swap_heap, sizeof(HeapAlloc));
 196   radindexht=GC->radindexht;
 197   radtable=GC->radtable;
 198   curradindex=GC->curradindex;
 199   scht=GC->scht;
 200   myallocs=GC->myallocs;
 201
 202   memcpy(ALL_SYM_INFO, GC->ALL_SYM_INFO, sizeof(biinfo *)*MAX_SYMLIST);
 203   CUR_SYM_INDEX=GC->CUR_SYM_INDEX;
 204
 205   memcpy(entry, GC->entry, sizeof(struct localcash)*CASHS);
 206   FOUND_MODEL=GC->FOUND_MODEL;
 207
 208   GNS_TEMPLATE_HT=GC->TEMPLATE_HT;
 209 }
 210
 211
 212
 213 static ht *MAIN_HT_LOFIG=NULL;
 214 static int GNS_RECURSION=0;
 215
 216 lofig_list *genius_getmainheadloadedlofig(char *name)
 217 {
 218   long l;
 219   if ((l=gethtitem(MAIN_HT_LOFIG, name))==EMPTYHT) return NULL;
 220   return (lofig_list *)l;
 221 }
 222
 223
 224
 225 #define PRIME 211 /* undivisable number */
 226
 227 /* LEX&YACC functions parser */
 228 /* from gen_tree_parser.yac */
 229 extern tree_list *Read_All(lib_entry *);
 230
 231 extern void SearchInit();
 232 extern void StatHeap_Manage(int mode);
 233 extern void SwapHeap_Manage(int mode);
 234 extern void LoconMarkHeap_Manage(int mode);
 235 extern void EAHeap_Manage(int mode);
 236 extern void LofigChainUpgradeHeap_Manage(int mode);
 237 extern void AllLoinsHeap_Manage(int mode);
 238 extern void CorrespHeap_Manage(int mode);
 239
 240 typedef void (*heapfunc)(int);
 241
 242 static heapfunc heapfuncs[]=
 243   {
 244     StatHeap_Manage,
 245     SwapHeap_Manage,
 246     LoconMarkHeap_Manage,
 247     EAHeap_Manage,
 248     LofigChainUpgradeHeap_Manage,
 249     AllLoinsHeap_Manage,
 250     CorrespHeap_Manage
 251   };
 252
 253 static heapfunc heapfreefuncs[]=
 254   {
 255     StatHeap_Manage,
 256     SwapHeap_Manage,
 257     LoconMarkHeap_Manage,
 258     EAHeap_Manage,
 259     LofigChainUpgradeHeap_Manage,
 260     AllLoinsHeap_Manage
 261   };
 262
 263 /****************************************************************************/
 264 /* Parse from a LIBRARY files user's models and extract them from netlist   */
 265 /****************************************************************************/
 266
 267 static void gns_ordersignalnames(lofig_list *lf)
 268 {
 269   losig_list *ls;
 270   char *signame;
 271   for (ls=lf->LOSIG; ls!=NULL; ls=ls->NEXT)
 272   {
 273     if (ls->NAMECHAIN!=NULL && ls->NAMECHAIN->NEXT!=NULL)
 274     {
 275       signame=getsigname(ls);
 276       ls->NAMECHAIN=delchaindata(ls->NAMECHAIN, signame);
 277       ls->NAMECHAIN=addchain(ls->NAMECHAIN, signame);
 278     }
 279   }
 280 }
 281
 282 extern chain_list* genius_main(lofig_list *netlist, char *cellib, char *libname, char *outname)
 283 {
 284    int err;
 285    ptype_list *p,*bi_list;
 286    chain_list *fcl=NULL,*genius=NULL;
 287    chain_list *ret, *ret2;
 288    GeniusContext GC;
 289    lofig_list *(*tmpfunc)(char *name);
 290    mbkContext *oldctx;
 291    mbkContext newcontext;
 292    loins_list *bbox;
 293
 294
 295 #ifdef AVERTEC_LICENSE
 296    if(avt_givetoken("YAGLE_LICENSE_SERVER", "gns")!=AVT_VALID_TOKEN) EXIT(1) ;
 297 #endif
 298
 299    gns_ordersignalnames(netlist);
 300
 301    if (GNS_RECURSION==0)
 302      {
 303        MAIN_HT_LOFIG=HT_LOFIG;
 304        HOOK_GETLOADEDLOFIG=genius_getmainheadloadedlofig;
 305      }
 306    GNS_RECURSION++;
 307
 308    SaveContext(&GC);
 309    oldctx=genius_external_getcontext();
 310    newcontext.HT_LOFIG=HT_LOFIG;
 311    newcontext.HEAD_LOFIG=HEAD_LOFIG;
 312    genius_external_setcontext(&newcontext);
 313
 314    /* init environment */
 315    genius_env(netlist, cellib, libname);
 316
 317    beg_init();
 318    APIInit();
 319    genius_ec=APINewExecutionContext();
 320
 321    // initialisation des heaps
 322    for (err=0; err<(signed)(sizeof(heapfuncs)/sizeof(*heapfuncs)); err++)
 323      heapfuncs[err](0);
 324
 325    GENIUS_HEAD_LOFIG=GEN_HEAD_LOFIG; GENIUS_HT_LOFIG=GEN_HT_LOFIG;
 326    SwitchLOFIGContext(); // => genius
 327 //   for (lf=HEAD_LOFIG; lf!=NULL; lf=lf->NEXT) unlocklofig(lf) ;
 328    delalllofig();
 329    SwitchLOFIGContext(); // => normal
 330
 331    GENIUS_HEAD_LOFIG=NULL; GENIUS_HT_LOFIG=NULL; NEW_LOINS_NAMES_HT=addht(10);
 332    LOINS_LIST_CONTROL=addht(10);
 333    GEN_HEAD_LOFIG=NULL; GEN_HT_LOFIG=NULL;
 334
 335    SwitchLOFIGContext(); // => genius
 336
 337    SearchInit();
 338    InitModels();
 339
 340    /* ----> GENIUS_PRIORITY */
 341
 342    GENIUS_PRIORITY = APIReadLibrary(GENIUS_LIB_NAME,GENIUS_LIB_PATH, GEN_DEBUG_LEVEL>0?GENIUS_OUTPUT:NULL);
 343    err = Get_Error();
 344    if (err) {
 345         avt_errmsg(GNS_ERRMSG, "039", AVT_ERR, err);
 346        //fprintf(stderr,"*** %d error(s) detected,  I can't get farther!! ***\n",err);
 347        EXIT(err);
 348    }
 349    if (!GENIUS_PRIORITY) return NULL;
 350
 351    Build_All_Transistor_Models();
 352
 353    LoadSpiceFCLFiles(GENIUS_PRIORITY);
 354
 355    GNS_TEMPLATE_HT=gns_create_template_hierarchy(GENIUS_PRIORITY);
 356
 357    APIParseFile_SetTemplateInfo(GNS_TEMPLATE_HT);
 358
 359    GENIUS_TREE = Read_All(GENIUS_PRIORITY);  /* ----> GENIUS_TREE */
 360
 361    APIParseFile_SetTemplateInfo(NULL);
 362
 363    if (!GENIUS_TREE) return NULL;
 364    APIVerify_C_Functions(genius_ec);
 365
 366    err = Get_Error();
 367    if (err) {
 368        avt_errmsg(GNS_ERRMSG, "039", AVT_ERR, err);
 369        //fprintf(stderr,"*** %d error(s) detected,  I can't get farther!! ***\n",err);
 370        EXIT(err);
 371    }
 372
 373    // call user init function
 374    {
 375      APICallFunc cf;
 376      t_arg *ret;
 377      cf.NAME="GnsInit";
 378      cf.ARGS=NULL;
 379      if (APIExecAPICallFunc(genius_ec, &cf, &ret, 1)==0)
 380         APIFreeTARG(ret);
 381    }
 382
 383
 384    /*get a tree_list for GENIUS and FCL */
 385    bi_list=Verif_All(GENIUS_TREE);
 386    for (p=bi_list; p; p=p->NEXT) {
 387       if (p->TYPE==FCL) fcl=(chain_list*)p->DATA;
 388       if (p->TYPE==GENIUS) genius=(chain_list*)p->DATA;
 389    }
 390    freeptype(bi_list);
 391    err = Get_Error();
 392    if (err) {
 393        avt_errmsg(GNS_ERRMSG, "039", AVT_ERR, err);
 394        //fprintf(stderr,"\n%d error(s) detected,  I can't get farther!!\n",err);
 395        EXIT(err);
 396    }
 397
 398
 399
 400    if (GEN_DEBUG_LEVEL>0) LoadDynamicLibraries(GENIUS_OUTPUT);
 401    else LoadDynamicLibraries(NULL);
 402
 403    if (genius_ec->ALL_USED_FUNCTIONS!=NULL && APICheckCFunctions(genius_ec)) EXIT(1);
 404
 405    {
 406      t_arg *ret;
 407      chain_list *p;
 408      libfunc_type func;
 409      char buf[128];
 410      for (p=API_ACTION_RESTART; p!=NULL; p=p->NEXT)
 411        {
 412          func=(libfunc_type)p->DATA;
 413          func(&ret, NULL, 0 , buf);
 414          mbkfree(ret->TYPE); mbkfree(ret);
 415        }
 416    }
 417
 418
 419 #ifdef AVERTEC_LICENSE
 420    if(avt_givetoken("YAGLE_LICENSE_SERVER", "gns")!=AVT_VALID_TOKEN) EXIT(1) ;
 421 #endif
 422    Build_All_Models(GENIUS_TREE,fcl);
 423
 424    /*search*/
 425    ret=NULL;
 426
 427    SwitchLOFIGContext(); // => normal
 428
 429
 430    LATEST_GNS_RUN=(ALL_FOR_GNS *)mbkalloc(sizeof(ALL_FOR_GNS));
 431    LATEST_GNS_RUN->ALL_INSTANCES=NULL;
 432    LATEST_GNS_RUN->FIGNAME=netlist->NAME;
 433    LATEST_GNS_RUN->GLOBAL_LOFIG=netlist;
 434    LATEST_GNS_RUN->TEMPLATE_HT=GNS_TEMPLATE_HT;
 435    tmpfunc=external_getlofig;
 436    external_getlofig=genius_external_getlofig;
 437
 438    if (netlist)
 439       ret=FindInstances (netlist,genius,fcl);
 440
 441    LATEST_GNS_RUN->RETURN=ret;
 442
 443    external_getlofig=tmpfunc;
 444
 445    SwitchLOFIGContext(); // => genius
 446
 447    freechain(genius_ec->BLOCKS);
 448    genius_ec->BLOCKS=NULL;
 449    Free_Tree(GENIUS_TREE);
 450    GENIUS_TREE=NULL;
 451    freemodel();
 452    freechain(fcl);
 453    freechain(genius);
 454
 455    DelContext();
 456
 457    SwitchLOFIGContext(); // => normal
 458
 459    /*close file report .gen*/
 460    if (GENIUS_OUTPUT!=stdout && GENIUS_OUTPUT!=stderr) fclose(GENIUS_OUTPUT);
 461
 462    /*file names are used for message and idetification in GENIUS*/
 463    APIFreeLibrary(GENIUS_PRIORITY);
 464    GENIUS_PRIORITY=NULL; delht(NEW_LOINS_NAMES_HT);
 465    delht(LOINS_LIST_CONTROL);
 466    free_all_blocks_to_free();
 467
 468    APIFreeExecutionContext(genius_ec);
 469    APIExit();
 470
 471    {
 472      t_arg *rett;
 473      t_arg param, *tab[1];
 474      chain_list *p;
 475      libfunc_type func;
 476      char buf[128];
 477
 478      ret2=NULL;
 479      for (bbox=netlist->LOINS; bbox!=NULL; bbox=bbox->NEXT)
 480        ret2=addchain(ret2, bbox);
 481      for (p=ret; p!=NULL; p=p->NEXT)
 482        ret2=addchain(ret2, p->DATA);
 483
 484      for (p=API_ACTION_TOPLEVEL; p!=NULL; p=p->NEXT)
 485        {
 486          int j;
 487          param.NAME="param";
 488          param.POINTER=0;
 489          param.VALUE=mbkalloc(sizeof(long));
 490          *(long *)param.VALUE=(long)ret2;
 491          param.TYPE="long";
 492          func=(libfunc_type)p->DATA;
 493          tab[0]=&param;
 494          j=func(&rett, tab, 1 , buf);
 495          if (j!=0)
 496            {
 497              avt_errmsg(GNS_ERRMSG, "042", AVT_FATAL, buf);
 498              //fprintf(stderr,"Error: %s\n",buf);
 499              EXIT(2);
 500            }
 501
 502          mbkfree(param.VALUE);
 503          mbkfree(rett->TYPE); mbkfree(rett);
 504        }
 505      freechain(ret2);
 506    }
 507
 508    if (outname!=NULL) LATEST_GNS_RUN->FIGNAME=namealloc(outname);
 509
 510    gnsApplyConnectorOrientation(LATEST_GNS_RUN);
 511
 512    if (!(GEN_OPTIONS_PACK & GEN_NO_GNS))
 513      {
 514        char mode='y';
 515        if (GEN_OPTIONS_PACK & GEN_VERBOSE_GNS) mode='n';
 516        gnsDriveCorrespondanceTables(LATEST_GNS_RUN, mode);
 517      }
 518
 519    // destruction des heaps sauf pour les tables de correspondances
 520    for (err=0; err<(signed)(sizeof(heapfreefuncs)/sizeof(*heapfreefuncs)); err++)
 521      heapfuncs[err](1);
 522    clean_gen_env();
 523    memcpy(&LATEST_GNS_RUN->external_ctx, &newcontext, sizeof(mbkContext));
 524    genius_external_setcontext(oldctx);
 525    RestoreContext(&GC);
 526
 527    GNS_RECURSION--;
 528    if (GNS_RECURSION==0)
 529      {
 530        MAIN_HT_LOFIG=NULL;
 531        HOOK_GETLOADEDLOFIG=NULL;
 532      }
 533
 534    return ret;
 535 }
 536
 537 /* display system and user time */
 538
 539 void
 540 genius_print_time(struct rusage *start, struct rusage *end, time_t rstart, time_t rend)
 541 {
 542     unsigned long   temps;
 543     unsigned long   user, syst;
 544     unsigned long   userM, userS, userD;
 545     unsigned long   systM, systS, systD;
 546     unsigned long   bytes;
 547
 548     temps = rend - rstart;
 549     user = (100 * end->ru_utime.tv_sec + (end->ru_utime.tv_usec / 10000))
 550         - (100 * start->ru_utime.tv_sec + (start->ru_utime.tv_usec / 10000));
 551     syst = (100 * end->ru_stime.tv_sec + (end->ru_stime.tv_usec / 10000))
 552         - (100 * start->ru_stime.tv_sec + (start->ru_stime.tv_usec / 10000));
 553
 554     userM = user / 6000;
 555     userS = (user % 6000) / 100;
 556     userD = (user % 100) / 10;
 557
 558     systM = syst / 6000;
 559     systS = (syst % 6000) / 100;
 560     systD = (syst % 100) / 10;
 561
 562     avt_fprintf(GENIUS_OUTPUT, "¤+ %02ldm%02lds", (long) (temps / 60), (long) (temps % 60));
 563     avt_fprintf(GENIUS_OUTPUT, "¤+  u:%02ldm%02ld.%ld", userM, userS, userD);
 564     bytes = mbkprocessmemoryusage();
 565     avt_fprintf(GENIUS_OUTPUT, "¤+  M:%ldKb\n", bytes / 1024);
 566
 567     fflush(GENIUS_OUTPUT);
 568 }
 569 char *genius_getutime(struct rusage *start, struct rusage *end)
 570 {
 571     unsigned long   user;
 572     unsigned long   userM, userS, userD;
 573     static char temp[64];
 574
 575     user = (100 * end->ru_utime.tv_sec + (end->ru_utime.tv_usec / 10000))
 576         - (100 * start->ru_utime.tv_sec + (start->ru_utime.tv_usec / 10000));
 577
 578     userM = user / 6000;
 579     userS = (user % 6000) / 100;
 580     userD = (user % 100) / 10;
 581
 582     sprintf(temp, "%02ldm%02ld.%ld", userM, userS, userD);
 583
 584     return temp;
 585 }
 586
 587 void
 588 genius_chrono(struct rusage *t, time_t *rt)
 589 {
 590     getrusage(RUSAGE_SELF, t);
 591     time(rt);
 592 }
 593
 594 tree_list *Read_All(lib_entry *files_list)
 595 {
 596   int done;
 597   lib_entry *p, *p0;
 598   tree_list *res=NULL,*sav=NULL;
 599   FILE *f;
 600   chain_list *old, *cl;
 601   char *r;
 602
 603   if (!files_list) {
 604        avt_errmsg(GNS_ERRMSG, "043", AVT_WARNING);
 605        //gen_printf(0, "warning: No model file in library\n");
 606        return NULL;
 607    }
 608    /* read all files listed */
 609    for (p=files_list;p;p=p->NEXT)
 610      {
 611        if (p->format==0)
 612          {
 613            if (strcasecmp(p->name,"none")!=0)
 614              {
 615                // VHDL
 616                f = APIFindFile(p);
 617                if (f)
 618                  {
 619                    gen_printf(0, "Opening model file %s....\n",p->name);
 620
 621                    r=strrchr(p->name, '.');
 622                    if (r!=NULL && strcasecmp(r, ".tcl")==0)
 623                    {
 624                     int nb;
 625                     r=mbkalloc(1000000);
 626                     nb=fread(r,sizeof(char),1000000, f);
 627                     r[nb]='\0';
 628                     if (Tcl_EvalEx((Tcl_Interp *)TCL_INTERPRETER, r, -1, TCL_EVAL_GLOBAL)==TCL_ERROR)
 629                         avt_errmsg(GNS_ERRMSG, "165", AVT_ERROR, p->name, Tcl_GetErrorLine((Tcl_Interp *)TCL_INTERPRETER), Tcl_GetStringResult((Tcl_Interp *)TCL_INTERPRETER));
 630                     mbkfree(r);
 631                    }
 632                    else
 633                    {
 634                    old=genius_ec->BLOCKS;
 635                    res=APIParseFile(f, p->name, genius_ec, p->paramset);
 636
 637                    for (done=0, cl=genius_ec->BLOCKS; cl!=old; cl=cl->NEXT)
 638                      {
 639                        if (APIBlockIsEntity((tree_list *)cl->DATA))
 640                          {
 641                            if (!done)
 642                              {
 643                                p->entity=APIEntityName((tree_list *)cl->DATA);
 644                                done=1;
 645                              }
 646                            else
 647                              {
 648                                p0=(lib_entry *)mbkalloc(sizeof(lib_entry));
 649                                memcpy(p0, p, sizeof(lib_entry));
 650                                p0->entity=APIEntityName((tree_list *)cl->DATA);
 651                                p0->paramset=dup_adt_list(p0->paramset);
 652                                p0->NEXT=p->NEXT;
 653                                p->NEXT=p0;
 654                                p=p0;
 655                              }
 656                          }
 657                      }
 658
 659                    if (res)
 660                      {
 661                        if (sav) sav=PutBin_Tree(';',"",0,sav,res); /*PUT_BIN(';',sav,res);*/
 662                        else sav=res;
 663                      }
 664                    }
 665                    fclose(f);
 666                  }
 667                else
 668                  {
 669                   avt_errmsg(GNS_ERRMSG, "166", AVT_ERROR, p->name);
 670                    Inc_Error();
 671                  }
 672              }
 673          }
 674        else
 675          {
 676            // spice FCL, order is not modified
 677            if (sav) sav=PutBin_Tree(';',"",0,sav,p->tree);
 678            else sav=p->tree;
 679          }
 680
 681      } /* end of loop on files list */
 682    return sav;
 683 }
 684
 685 ht *gns_create_template_hierarchy(lib_entry *files_list)
 686 {
 687   lib_entry *p;
 688   ht *t_h;
 689   char res[1024];
 690
 691   t_h=addht(128);
 692
 693   for (p=files_list;p;p=p->NEXT)
 694     {
 695       if (p->model!=NULL)
 696         {
 697           if (gen_find_template_corresp(NULL, p->paramset, p->model, res)==0)
 698             {
 699               // c'est un template
 700               if (gen_get_template_corresp(t_h, p->model)==NULL)
 701                 {
 702                   gen_printf(1,"Adding template '%s' from model '%s'\n",res,p->model);
 703                   gen_add_template_corresp(t_h, res, p->model, p->paramset);
 704                 }
 705             }
 706         }
 707     }
 708   return t_h;
 709 }