distrib/sources/tas/zen/zen_zennod.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : ZEN Version 1.00                                            */
   6 /*    Fichier : zen_zenfig.c                                                */
   7 /*                                                                          */
   8 /*    (c) copyright 2002 AVERTEC                                            */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : //Stephane Picault                                        */
  12 /*                  Antony PINTO                                            */
  13 /*                                                                          */
  14 /****************************************************************************/
  15
  16 #include "zen_main.h"
  17
  18 static  ht    *ZEN_HTNOD = NULL;
  19
  20 /****************************************************************************/
  21 /*{{{                    zen_searchzennod()                                 */
  22 /*                                                                          */
  23 /* cherche un noeud dans la liste des noeuds                                */
  24 /****************************************************************************/
  25 zennod_list *zen_searchzennod(ZenFig,name)
  26 zenfig_list *ZenFig;
  27 char        *name;
  28 {
  29   /*  zennod_list *ScanZenNod;
  30
  31       for (ScanZenNod=ZenFig->NOD;ScanZenNod;ScanZenNod=ScanZenNod->NEXT)
  32       if (ScanZenNod->NAME==name) return ScanZenNod;
  33       return NULL;
  34    */
  35   long                res;
  36   static zenfig_list *zenfig = NULL;
  37
  38   if (!ZenFig)
  39   {
  40     delht(ZEN_HTNOD);
  41     ZEN_HTNOD = NULL;
  42     return NULL;
  43   }
  44   else if (zenfig)
  45     ;
  46 //  {
  47 //    if (ZenFig!=zenfig) ZEN_WARNING(0,"attention nouvelle zenfig");
  48 //  }
  49   else zenfig = ZenFig;
  50
  51   if (!ZEN_HTNOD) ZEN_HTNOD = addht(ZEN_HTSIZE);
  52
  53   if ((res=gethtitem(ZEN_HTNOD,name))==EMPTYHT) return NULL;
  54   else return (zennod_list*)res;
  55 }
  56
  57 /*}}}************************************************************************/
  58 /*{{{                    zen_addzennod()                                    */
  59 /*                                                                          */
  60 /*                                                                          */
  61 /****************************************************************************/
  62 zennod_list *zen_addzennod(lastzennod,name,abl)
  63 zennod_list *lastzennod;   /* pointer on the last zennod_list     */
  64 char        *name;         /* node's name                         */
  65 chain_list  *abl;
  66 {
  67   zennod_list   *NewZenNod;
  68   pCircuit       cct;
  69   pNode          bdd;
  70
  71   cct = (abl)?initializeCct(name,1,1) :NULL;
  72   bdd = (abl)?zen_ablToBddCct(cct,abl):NULL;
  73 //  if (bdd) addOutputCct(cct,name,bdd);
  74
  75   if (!ZEN_HTNOD) ZEN_HTNOD = addht(ZEN_HTSIZE);
  76
  77   NewZenNod = zen_alloczennod();
  78
  79
  80   NewZenNod->NEXT   = lastzennod;
  81   NewZenNod->NAME   = namealloc(name);
  82   NewZenNod->INDEX  = 0;
  83   NewZenNod->FLAGS  = 0;
  84   NewZenNod->VALUE  = ZEN_VALUE_UNKNOWN;
  85   NewZenNod->INNOD  = NULL;
  86   NewZenNod->OUTNOD = NULL;
  87   NewZenNod->CCT    = cct;
  88   NewZenNod->BDD    = bdd;
  89   NewZenNod->NBZER  = -1;
  90   NewZenNod->NBONE  = -1;
  91
  92   addhtitem(ZEN_HTNOD,NewZenNod->NAME,(long)NewZenNod);
  93   return NewZenNod;
  94 }
  95
  96 /*}}}************************************************************************/
  97 /*{{{                    zen_alloczennod()                                  */
  98 /*                                                                          */
  99 /* allocation memoire d'un zennod                                           */
 100 /****************************************************************************/
 101 zennod_list *zen_alloczennod()
 102 {
 103   return (zennod_list*)mbkalloc(sizeof(zennod_list));
 104 }
 105
 106 /*}}}************************************************************************/
 107 /*{{{                    zen_freezennod()                                   */
 108 /*                                                                          */
 109 /*                                                                          */
 110 /****************************************************************************/
 111 void zen_freezennod(listzennod)
 112 zennod_list *listzennod;
 113 {
 114   if (!listzennod) return;
 115
 116   freechain(listzennod->OUTNOD);
 117   freechain(listzennod->INNOD);
 118   zen_freezennod(listzennod->NEXT);
 119   destroyCct(listzennod->CCT);
 120   mbkfree(listzennod);
 121 }
 122
 123
 124 /*}}}************************************************************************/
 125 /*{{{                    zen_viewzennod(                                    */
 126 /*                                                                          */
 127 /*                                                                          */
 128 /****************************************************************************/
 129 void zen_viewzennod(node)
 130 zennod_list *node;
 131 {
 132   chain_list    *ScanChain;
 133   zennod_list   *ScanNod;
 134
 135   avt_log(LOGZEN,2,"\n\t--> Node");
 136   avt_log(LOGZEN,2,"\n\t\tNAME\t: %s",node->NAME);
 137   avt_log(LOGZEN,2,"\n\t\tINDEX\t= %ld",node->INDEX);
 138   if (node->BDD)
 139   {
 140     avt_log(LOGZEN,2,"\n\t\tBDD\t:\n");
 141     displayExprLog(LOGZEN,2,bddToAblCct(node->CCT,node->BDD));
 142   }
 143   else
 144     avt_log(LOGZEN,2,"\n\t\tBDD\t: (Null)\n");
 145   avt_log(LOGZEN,2,"\t\tVALUE\t= %c",node->VALUE);
 146   for (ScanChain=node->INNOD;ScanChain;ScanChain=ScanChain->NEXT)
 147   {
 148     ScanNod = (zennod_list*)ScanChain->DATA;
 149     avt_log(LOGZEN,2,"\n\t\tINNOD\t: (%ld)\t: %s\t= %c",
 150         ScanNod->INDEX,ScanNod->NAME,ScanNod->VALUE);
 151   }
 152   for (ScanChain=node->OUTNOD;ScanChain;ScanChain=ScanChain->NEXT)
 153   {
 154     ScanNod = (zennod_list*)ScanChain->DATA;
 155     avt_log(LOGZEN,2,"\n\t\tOUTNOD\t: (%ld)\t: %s\t= %c",
 156         ScanNod->INDEX,ScanNod->NAME,ScanNod->VALUE);
 157   }
 158   avt_log(LOGZEN,2,"\n\t<-- Node");
 159
 160   if ( ((node->BDD)&&(!node->INNOD)) || ((!node->BDD)&&(node->INNOD)))
 161     ZEN_WARNING(0,"no bdd on zennode");
 162 }
 163
 164 /*}}}************************************************************************/
 165 /*{{{                                                                       */
 166 /*                                                                          */
 167 /*                                                                          */
 168 /****************************************************************************/
 169 zennod_list *zen_addOutNode(zenfig,beout,name,abl)
 170 zenfig_list *zenfig;
 171 beout_list  *beout;
 172 char        *name;
 173 chain_list **abl;
 174 {
 175   zennod_list   *newZenNode;
 176
 177   *abl = beout->ABL;
 178   newZenNode = zen_addzennod(zenfig->NOD,name,*abl);
 179   zenfig->NOD_OUT = addchain(zenfig->NOD_OUT,newZenNode);
 180   zenfig->NOD = newZenNode;
 181   return newZenNode;
 182
 183 }
 184
 185 /*}}}************************************************************************/
 186 /*{{{                                                                       */
 187 /*                                                                          */
 188 /*                                                                          */
 189 /****************************************************************************/
 190 zennod_list *zen_addRegNode(zenfig,bereg,name1,name2,abl)
 191 zenfig_list *zenfig;
 192 bereg_list  *bereg;
 193 char        *name1;
 194 char        *name2;
 195 chain_list **abl;
 196 {
 197   zennod_list   *newZenNode = NULL;
 198   chain_list    *chainx;
 199   biabl_list    *biabl;
 200
 201   for (biabl=bereg->BIABL;biabl;biabl=biabl->NEXT)
 202   {
 203     chainx = supportChain_listExpr(biabl->CNDABL);
 204     for (;chainx;chainx=chainx->NEXT)
 205       if (chainx->DATA==name2)
 206       {
 207         *abl = biabl->CNDABL;
 208         newZenNode = zen_addzennod(zenfig->NOD,name1,*abl);
 209         zenfig->NOD = newZenNode;
 210         break;
 211       }
 212     if (newZenNode) break;
 213     chainx = supportChain_listExpr(biabl->VALABL);
 214     for (;chainx;chainx=chainx->NEXT)
 215       if (chainx->DATA==name2)
 216       {
 217         *abl = biabl->VALABL;
 218         newZenNode = zen_addzennod(zenfig->NOD,name1,*abl);
 219         zenfig->NOD = newZenNode;
 220         break;
 221       }
 222     if (newZenNode) break;
 223   }
 224   if (newZenNode) zenfig->NOD_OUT = addchain(zenfig->NOD_OUT,newZenNode);
 225   return newZenNode;
 226
 227 }
 228
 229 /*}}}************************************************************************/
 230 /*{{{                                                                       */
 231 /*                                                                          */
 232 /*                                                                          */
 233 /****************************************************************************/
 234 zennod_list *zen_addAuxNode(zenfig,beaux,name,abl)
 235 zenfig_list *zenfig;
 236 beaux_list  *beaux;
 237 char        *name;
 238 chain_list **abl;
 239 {
 240   zennod_list   *newZenNode;
 241
 242   *abl = beaux->ABL;
 243   newZenNode = zen_addzennod(zenfig->NOD,name,*abl);
 244   zenfig->NOD = newZenNode;
 245   return newZenNode;
 246 }
 247
 248 /*}}}************************************************************************/
 249 /*{{{                                                                       */
 250 /*                                                                          */
 251 /*                                                                          */
 252 /****************************************************************************/
 253 zennod_list *zen_addRinNode(zenfig,name)
 254 zenfig_list *zenfig;
 255 char        *name;
 256 {
 257   zennod_list   *newZenNode;
 258
 259   newZenNode = zen_addzennod(zenfig->NOD,name,createAtom(name));
 260   zenfig->NOD_IN = addchain(zenfig->NOD_IN,newZenNode);
 261   zenfig->NOD = newZenNode;
 262   return newZenNode;
 263 }