distrib/sources/yagle/genius/gen_verif_PortMap.c

   1
   2 /****************************************************************************/
   3 /*                                                                          */
   4 /*                      Chaine de CAO & VLSI   Alliance                     */
   5 /*                                                                          */
   6 /*    Produit : GENIUS   v1.00                                              */
   7 /*    Fichier : gen_verif_PortMap.c                                         */
   8 /*                                                                          */
   9 /*    Auteur(s) : Francois DONNET                        le : 10/06/1999    */
  10 /*                                                                          */
  11 /*    (c) copyright 1999 Laboratoire MASI equipe CAO & VLSI                 */
  12 /*    Tous droits reserves                                                  */
  13 /*    Support : e-mail alliance-support@asim.lip6.fr                        */
  14 /*                                                                          */
  15 /*                                                                          */
  16 /****************************************************************************/
  17
  18
  19 #include <stdlib.h>
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include MUT_H
  23 #include MLO_H
  24 #include API_H
  25 #include AVT_H
  26 #include "gen_verif_utils.h"
  27 #include "gen_verif_exp_VHDL.h"
  28 #include "gen_verif_vector.h"
  29 #include "gen_verif_exclude.h"
  30 #include "gen_verif_PortMap.h"
  31
  32
  33
  34
  35 /***************************************************************************/
  36 /*  change a tree of generic variables in a list of ptypeput on top of var */
  37 /***************************************************************************/
  38 extern ptype_list *GenTree2chain(tree_list *tree, ptype_list *var)
  39 {
  40   if (!tree) {
  41               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 192);
  42 //    fprintf(stderr,"GenTree2chain: NULL pointer\n");
  43     EXIT(1);
  44   }
  45   switch (TOKEN(tree)) {
  46   /* as an ABL this token is a node */
  47   case GEN_TOKEN_NODE:
  48     return GenTree2chain(tree->DATA,var);
  49     break;
  50   case GEN_TOKEN_GENERIC:
  51     return GenTree2chain(tree->NEXT,var);
  52     break;
  53   case GEN_TOKEN_NOP:
  54     return NULL;
  55     break;
  56   case ',':
  57     var=GenTree2chain(tree->NEXT->NEXT,var);       /*not to reverse order*/
  58     return GenTree2chain(tree->NEXT,var);
  59     break;
  60   case GEN_TOKEN_VARIABLE: case GEN_TOKEN_INTEGER:
  61     return GenTree2chain(tree->NEXT,var);
  62     break;
  63   case GEN_TOKEN_IDENT:
  64     return addptype(var,RAND_BYTE,tree);
  65     break;
  66   default:
  67     Error_Tree("GenTree2chain",tree);
  68     EXIT(2); return NULL;
  69   }
  70 }
  71
  72
  73 /***************************************************************************/
  74 /*    Verify if port map of instance matches with component model and      */
  75 /* entity signals Sig and generic variables env                            */
  76 /***************************************************************************/
  77 static inline tree_list *Compare_PortMap(tree_list *instance,
  78                                    tree_list *model, ptype_list *env_inst,
  79                                    ptype_list *env_model, chain_list *Sig)
  80 {
  81   int /*array_sig,array_mod,*/type;
  82   tree_list *sig;
  83
  84   if (!instance || !model) {
  85               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 193);
  86 //    fprintf(stderr,"Compare_PortMap: NULL pointer\n");
  87     EXIT(1);
  88   }
  89   switch (TOKEN(instance)) {
  90   /* as an ABL this token is a node */
  91   case GEN_TOKEN_NODE:
  92     if (TOKEN(model)!=GEN_TOKEN_NODE) {
  93        Error_Tree("Compare_PortMap",model);
  94        EXIT(2);
  95     }
  96     Compare_PortMap(instance->DATA,model->DATA,env_inst,env_model,Sig);
  97     return instance;
  98     break;
  99   case ',':
 100     if (TOKEN(model)!=',') {
 101        Error_Tree("Compare_PortMap",model);
 102        EXIT(2);
 103     }
 104     /* no use to catch result because here it doesn't change*/
 105     Compare_PortMap(instance->NEXT,model->NEXT,env_inst,env_model,Sig);
 106     Compare_PortMap(instance->NEXT->NEXT,model->NEXT->NEXT,env_inst,env_model,Sig);
 107     return instance;
 108     break;
 109
 110   /* PORT MAP(sig1,sig2,...,sigN) */
 111   case GEN_TOKEN_SIGNAL:
 112     if (TOKEN(model)!=GEN_TOKEN_SIGNAL) {
 113        Error_Tree("Compare_PortMap",model);
 114        EXIT(2);
 115     }
 116     /*result could change only here*/
 117     instance->NEXT=Compare_PortMap(instance->NEXT,model->NEXT,env_inst,env_model,Sig);
 118     return instance;
 119     break;
 120
 121   case GEN_TOKEN_IDENT:  case '(':
 122     sig=fetch_inlist(instance,Sig);/*TOKEN(sig)=IN,OUT,INOUT...*/
 123     if (!sig) return instance;
 124     type=TOKEN(sig);
 125     if (!sig->NEXT) {
 126               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 194);
 127 //       fprintf(stderr,"Compare_PortMap: NULL pointer\n");
 128        EXIT(1);
 129     }
 130     sig=sig->NEXT->DATA;/*TOKEN(sig)=IDENT or '('-->vector */
 131
 132     /*compare size of vectors*/
 133     if (TOKEN(instance)=='(' && Bound_Vector(instance,sig,env_inst)) {
 134               avt_errmsg(GNS_ERRMSG, "124", AVT_ERROR, FILE_NAME(instance),LINE(instance),getname(instance),LINE(sig));
 135 /*       fprintf(stderr,"%s:%d: array of signal '%s' out of bounds with model line %d\n",
 136          FILE_NAME(instance),LINE(instance),getname(instance),LINE(sig));*/
 137        Inc_Error();
 138     }
 139     else if (TOKEN(instance)==GEN_TOKEN_IDENT && TOKEN(sig)=='(') {  /*signal unsized*/
 140       int lineno=LINE(instance);
 141       char *file=FILE_NAME(instance);
 142       tree_list *size=Duplicate_Tree(sig->NEXT->NEXT);/*take sizeof model*/
 143       instance=PUT_BIN('(',instance,size);
 144     }
 145     /*
 146     array_mod=Verif_Vector(model->NEXT,env_model);
 147     array_sig=Size_Vector(instance,env_inst);
 148 // zinaps : bug here
 149     if (array_sig!=array_mod) {
 150       if (Nb_Vector_Vars()>1)
 151         {
 152           fprintf(stderr,"%s:%d: size of signal '%s' doesn't match with size of '%s' (%d!=%d)\n",
 153                   FILE_NAME(instance),LINE(instance),getname(instance),getname(model->NEXT),array_mod,array_sig);
 154           Inc_Error();
 155         }
 156     }
 157     */
 158     Compare_Type(model,instance,type);
 159     return instance;
 160   default:
 161     Error_Tree("Compare_PortMap",instance);
 162     EXIT(2); return NULL;
 163   }
 164 }
 165
 166
 167 /***************************************************************************/
 168 /* return the signal located at the right side of equipotential matching   */
 169 /* the connector model,  env is list of variables                          */
 170 /* return NULL if not found or error in size of model                      */
 171 /***************************************************************************/
 172 static inline tree_list *Seek_Equi(tree_list *tree, tree_list *model,
 173                                     ptype_list *env, chain_list *Sig)
 174 {
 175   tree_list *con;
 176
 177   if (!tree || !model) {
 178               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 195);
 179 //    fprintf(stderr,"Seek_Equi: NULL pointer\n");
 180     EXIT(1);
 181   }
 182   switch (TOKEN(tree)) {
 183   /* as an ABL this token is a node */
 184   case GEN_TOKEN_NODE:
 185     return Seek_Equi(tree->DATA,model,env,Sig);
 186     break;
 187   case ',':
 188     con=Seek_Equi(tree->NEXT,model,env,Sig);
 189     if (!con) con=Seek_Equi(tree->NEXT->NEXT,model,env,Sig);
 190     return con;
 191     break;
 192   case GEN_TOKEN_EQUI:
 193     con=Seek_Equi(tree->NEXT,model,env,Sig);        /*TOKEN(con)=IDENT or '('*/
 194     if (con) {
 195        if (Compare_Vector(model/*TOKEN=IDENT or '('*/,con,env,env)) {
 196               avt_errmsg(GNS_ERRMSG, "125", AVT_ERROR, FILE_NAME(tree),LINE(tree),getname(model),LINE(model));
 197 /*         fprintf(stderr,"%s:%d: array doesn't match for '%s' (line model %d)\n",
 198                   FILE_NAME(tree),LINE(tree),getname(model),LINE(model));*/
 199          Inc_Error();
 200        }
 201
 202        /*if direction are inverted in port map and component-->invert signal*/
 203        else if (TOKEN(model)=='(' && TOKEN(con)=='('
 204        && ((TOKEN(model->NEXT->NEXT->DATA)==GEN_TOKEN_TO
 205        && TOKEN(con->NEXT->NEXT->DATA)==GEN_TOKEN_DOWNTO)
 206        || (TOKEN(model->NEXT->NEXT->DATA)==GEN_TOKEN_DOWNTO
 207        && TOKEN(con->NEXT->NEXT->DATA)==GEN_TOKEN_TO)))  {
 208          /*catch signal*/
 209          con=tree->NEXT->NEXT->DATA;            /*TOKEN(con)=IDENT or '('*/
 210          if (TOKEN(con/*catch signal*/)==GEN_TOKEN_IDENT) {
 211             tree_list *sig;
 212             char *file=FILE_NAME(con);               /*for PUT_BIN macro*/
 213             int lineno=LINE(con);               /*for PUT_BIN macro*/
 214             sig=fetch_inlist(con/*IDENT or '('*/,Sig);
 215             /*TOKEN(sig)=IN,OUT,INOUT...*/
 216             if (!sig || !sig->NEXT) {
 217               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 196);
 218 //                fprintf(stderr,"Seek_Equi: NULL pointer\n");
 219                 EXIT(1);
 220             }
 221             sig=sig->NEXT->DATA; /*TOKEN(sig)=IDENT or '('-->vector */
 222             if (TOKEN(sig)=='(') /*put an array*/
 223               tree->NEXT->NEXT->DATA=PUT_BIN('(',tree->NEXT->NEXT->DATA,
 224                                      Duplicate_Tree(sig->NEXT->NEXT));
 225          }
 226          /*catch signal*/
 227          con=tree->NEXT->NEXT->DATA;            /*TOKEN(con)=IDENT or '('*/
 228          /*there is already an array*/
 229          if (TOKEN(con)=='(') {
 230             tree_list *save;
 231             con=con->NEXT->NEXT->DATA;   /*TOKEN(con)=GEN_TOKEN_TO or GEN_TOKEN_DOWNTO*/
 232             /*inversion*/
 233             if (TOKEN(con)==GEN_TOKEN_TO) TOKEN(con)=GEN_TOKEN_DOWNTO;
 234             else if (TOKEN(con)==GEN_TOKEN_DOWNTO) TOKEN(con)=GEN_TOKEN_TO;
 235             else {
 236                Error_Tree("Seek_Equi",con);
 237                EXIT(2);
 238             }
 239             save=con->NEXT->DATA;                             /*expression*/
 240             con->NEXT->DATA=con->NEXT->NEXT->DATA;            /*expression*/
 241             con->NEXT->NEXT->DATA=save;                       /*expression*/
 242          }
 243          /*there is no array still*/
 244          else if (TOKEN(con)!=GEN_TOKEN_IDENT) {
 245             Error_Tree("Seek_Equi",con);
 246             EXIT(2);
 247          }
 248        }
 249        return tree->NEXT->NEXT->DATA;  /*we are interested in signals*/
 250     }
 251     return NULL;
 252     break;
 253   case '(':
 254     con=Seek_Equi(tree->NEXT,model,env,Sig);     /*TOKEN(con)=IDENT*/
 255     if (con) return tree;
 256     else return NULL;
 257   case GEN_TOKEN_IDENT:
 258     if (getname(tree)==getname(model)) return tree;
 259     else return NULL;
 260     break;
 261   default:
 262     Error_Tree("Seek_Equi",tree);
 263     EXIT(2); return NULL;
 264   }
 265 }
 266
 267
 268
 269 /***************************************************************************/
 270 /*        Sort the equipotentials of instance in order of model            */
 271 /* env contains the list of generic variables                              */
 272 /***************************************************************************/
 273 static inline tree_list *Sort_Equi(tree_list *instance, tree_list *model,
 274                               ptype_list *env, chain_list *Sig)
 275 {
 276   int lineno;
 277   char* file;
 278   tree_list *res1,*res2,*found;
 279
 280   if (!instance || !model) {
 281               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 197);
 282 //    fprintf(stderr,"Sort_Equi: NULL pointer\n");
 283     EXIT(1);
 284   }
 285   switch (TOKEN(model)) {
 286   /* as an ABL this token is a node */
 287   case GEN_TOKEN_NODE:
 288     return Sort_Equi(instance,model->DATA,env,Sig);
 289     break;
 290   case ',':
 291     res1=Sort_Equi(instance,model->NEXT,env,Sig);
 292     res2=Sort_Equi(instance,model->NEXT->NEXT,env,Sig);
 293     lineno=LINE(res1);/* used in PUT_BIN()*/
 294     file=FILE_NAME(res1);
 295     return PUT_BIN(',',res1,res2);
 296     break;
 297   case GEN_TOKEN_SIGNAL:
 298     found=Seek_Equi(instance,model->NEXT->DATA->NEXT->DATA/*TOKEN=IDENT or '('*/,env,Sig);
 299     if (!found) {
 300               avt_errmsg(GNS_ERRMSG, "126", AVT_ERROR, FILE_NAME(instance),LINE(instance),getname(model->NEXT));
 301 /*      fprintf(stderr,"%s:%d: connector '%s' is missing in left side of instance\n",
 302          FILE_NAME(instance),LINE(instance),getname(model->NEXT));*/
 303       Inc_Error();
 304       return Duplicate_Tree(model);
 305     }
 306     lineno=LINE(found);/* used in PUT_UNI()*/
 307     file=FILE_NAME(found);
 308     return PUT_UNI(GEN_TOKEN_SIGNAL,Duplicate_Tree(found));
 309     break;
 310   default:
 311     Error_Tree("Sort_Equi",model);
 312     EXIT(2); return NULL;
 313   }
 314 }
 315
 316
 317 /***************************************************************************/
 318 /*        Compare the number of argument between instance and model        */
 319 /* return 1 if different else return 0                                     */
 320 /***************************************************************************/
 321 static inline int Compare_NumArgs(tree_list *instance, tree_list *model)
 322 {
 323   if (!instance || !model) {
 324               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 198);
 325 //    fprintf(stderr,"Compare_NumArgs: NULL pointer\n");
 326     EXIT(1);
 327   }
 328   switch (TOKEN(instance)) {
 329   /* as an ABL this token is a node */
 330   case GEN_TOKEN_NODE:
 331     if (TOKEN(model)!=GEN_TOKEN_NODE) {
 332        Error_Tree("Compare_NumArgs",model);
 333        EXIT(2);
 334     }
 335     return Compare_NumArgs(instance->DATA,model->DATA);
 336     break;
 337   case ',':
 338     if (TOKEN(model)!=',') {
 339               avt_errmsg(GNS_ERRMSG, "127", AVT_ERROR, FILE_NAME(instance),LINE(instance),LINE(model));
 340 /*    fprintf(stderr,"%s:%d: too many connections in Port Map. Component line %d\n",
 341               FILE_NAME(instance),LINE(instance),LINE(model));*/
 342       Inc_Error();
 343       return 1;
 344     }
 345     if (Compare_NumArgs(instance->NEXT,model->NEXT)) return 1;
 346     else return Compare_NumArgs(instance->NEXT->NEXT,model->NEXT->NEXT);
 347     break;
 348
 349   /* PORT MAP(sig1,sig2,...,sigN)  or PORT MAP(con1=>sig1,...,conN=>sigN) */
 350   case GEN_TOKEN_SIGNAL: case GEN_TOKEN_EQUI:
 351     if (TOKEN(model)==',') {
 352               avt_errmsg(GNS_ERRMSG, "128", AVT_ERROR, FILE_NAME(instance),LINE(instance),LINE(model));
 353 /*      fprintf(stderr,"%s:%d: not enough connections in Port Map. Component line %d\n",
 354               FILE_NAME(instance),LINE(instance),LINE(model));*/
 355       Inc_Error();
 356       return 1;
 357     }
 358     return 0;
 359     break;
 360   default:
 361     Error_Tree("Compare_NumArgs",instance);
 362     EXIT(2); return 0;
 363   }
 364 }
 365
 366 /***************************************************************************/
 367 /*           return 1 if tree contains an equi else return 0               */
 368 /***************************************************************************/
 369 static inline int Detect_Equi(tree_list *tree)
 370 {
 371   if (!tree) {
 372               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 199);
 373 //    fprintf(stderr,"Detect_Equi: NULL pointer\n");
 374     EXIT(1);
 375   }
 376   switch (TOKEN(tree)) {
 377   /* as an ABL this token is a node */
 378   case GEN_TOKEN_NODE:
 379     return Detect_Equi(tree->DATA);
 380     break;
 381   case ',':
 382     return Detect_Equi(tree->NEXT);
 383     break;
 384  case GEN_TOKEN_SIGNAL:
 385     return 0;
 386     break;
 387   case GEN_TOKEN_EQUI:
 388     return 1;
 389     break;
 390   default:
 391     Error_Tree("Detect_Equi",tree);
 392     EXIT(2); return 0;
 393   }
 394 }
 395
 396
 397 /***************************************************************************/
 398 /*              Give real dimension to signal unsized                      */
 399 /***************************************************************************/
 400 static inline tree_list* Give_Dimension(tree_list *tree,chain_list *Sig)
 401 {
 402   tree_list* ret;
 403
 404   if (!tree) {
 405               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 200);
 406 //    fprintf(stderr,"Give_Dimension: NULL pointer\n");
 407     EXIT(1);
 408   }
 409   switch (TOKEN(tree)) {
 410   /* as an ABL this token is a node */
 411   case GEN_TOKEN_NODE:
 412     tree->DATA=Give_Dimension(tree->DATA,Sig);
 413     return tree;
 414     break;
 415   case ',':
 416     Give_Dimension(tree->NEXT,Sig);
 417     Give_Dimension(tree->NEXT->NEXT,Sig);
 418     return tree;
 419     break;
 420   case GEN_TOKEN_SIGNAL:
 421     Give_Dimension(tree->NEXT,Sig);
 422     return tree;
 423     break;
 424   case GEN_TOKEN_EQUI:
 425     Give_Dimension(tree->NEXT->NEXT,Sig);
 426     return tree;
 427     break;
 428   case '(':
 429     /*nothing to do*/
 430     return tree;
 431     break;
 432   case GEN_TOKEN_IDENT:
 433     ret=fetch_inlist(tree, Sig);    /* TOKEN(ret)=SIGNAL */
 434     if (ret) {
 435       ret=ret->NEXT->DATA;            /* TOKEN(ret)='(' or TOKEN(ret)=IDENT */
 436       if (TOKEN(ret)=='(') {
 437          ret=Duplicate_Tree(ret);
 438          Free_Tree(tree);
 439          return ret;
 440       }
 441     }
 442     return tree;
 443     break;
 444   default:
 445     Error_Tree("Give_Dimension",tree);
 446     EXIT(2); return NULL;
 447   }
 448 }
 449
 450
 451 /***************************************************************************/
 452 /* Verify that all instances of tree match with components Comp and generic*/
 453 /* variables and signals Sig                                               */
 454 /* result put on top of Ins                                                */
 455 /***************************************************************************/
 456 extern chain_list *Verif_Instance(tree,Sig,env,Comp,Ins)
 457    tree_list *tree;
 458    ptype_list* env;
 459    chain_list *Sig,*Comp,*Ins;
 460 {
 461   int ope1,ope2,error;
 462   chain_list *Ins2;     /*garbage just to free mem*/
 463   tree_list *component,*port;
 464   ptype_list *env_component,*p,*q;
 465
 466   if (!tree) {
 467     return Ins;
 468 /*    fprintf(stderr,"Verif_Instance: NULL pointer\n");
 469     EXIT(1);*/
 470   }
 471
 472   switch (TOKEN(tree)) {
 473   /* as an ABL this token is a node */
 474   case GEN_TOKEN_NODE:
 475     return Verif_Instance(tree->DATA,Sig,env,Comp,Ins);
 476     break;
 477   case GEN_TOKEN_EXCLUDE:
 478     Ins= Verif_Instance(tree->NEXT,Sig,env,Comp,Ins);
 479     return Ins;
 480     break;
 481   case ';':
 482     Ins=Verif_Instance(tree->NEXT,Sig,env,Comp,Ins);
 483     return Verif_Instance(tree->NEXT->NEXT,Sig,env,Comp,Ins);
 484     break;
 485   case GEN_TOKEN_OF:
 486     return Verif_Instance(tree->NEXT,Sig,env,Comp,Ins);
 487     break;
 488   case GEN_TOKEN_IDENT:
 489     return put_inlist(tree,Ins);
 490     break;
 491   case GEN_TOKEN_MAP:
 492     Ins=Verif_Instance(tree->NEXT,Sig,env,Comp,Ins);
 493 #if 0
 494     /*to alert if 2 times the same name is used*/
 495     if ((ope1=Is_Exclude(getname(tree->NEXT)))) {
 496       /*copy MAP and a NODE*/
 497       tree_list *map=addtree(FILE_NAME(tree),LINE(tree),GEN_TOKEN_MAP,NULL,tree->NEXT);
 498       tree_list *node=addtree(FILE_NAME(tree),LINE(tree),GEN_TOKEN_NODE,map,NULL);
 499       /*scratch and insertion of exclude in tree*/
 500       tree->LINE=ope1;
 501       tree->TOKEN=GEN_TOKEN_EXCLUDE;
 502       tree->DATA=NULL;
 503       tree->NEXT=node;
 504       /*we were at MAP level*/
 505       tree=map;
 506     }
 507 #endif
 508     error=Get_Error();
 509     component=fetch_inlist(getident_of(tree->NEXT),Comp);/*TOKEN(component)=NODE*/
 510     /* error from user*/
 511     if (!component) return Ins;
 512     /* test for BUG!!! */
 513     if (!component->NEXT || !component->NEXT->NEXT ||
 514         !component->NEXT->NEXT->DATA) {
 515               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 201);
 516 //         fprintf(stderr,"Verif_Instance: NULL pointer in component list\n");
 517          EXIT(1);
 518     }
 519     port=component->NEXT->NEXT->DATA;
 520     if (TOKEN(port)!=GEN_TOKEN_PORT) {
 521          Error_Tree("Verif_Instance",port);
 522          EXIT(2);
 523     }
 524
 525     if (Compare_NumArgs(tree->NEXT->NEXT,port->NEXT)) return Ins;
 526     /*no use to continue because number of arguments are different*/
 527     env_component=GenTree2chain(component->NEXT,NULL);
 528     /* to accord values with global environment */
 529     for (q=env_component;q;q=q->NEXT) {
 530       char *name=getname(q->DATA);
 531       for (p=env;p;p=p->NEXT) if (getname(p->DATA)==name) break;
 532       if (p) q->TYPE=p->TYPE;
 533     }
 534     /* give a size to signal vector without */
 535     Give_Dimension(tree->NEXT->NEXT,Sig);
 536     if (Detect_Equi(tree->NEXT->NEXT)) {
 537   /*  PORT MAP(con3=>sig3,...,con1=>sig1) ---> PORT MAP(sig1,sig2,...,sigN)  */
 538        tree_list *res;
 539        res=Sort_Equi(tree->NEXT->NEXT,port->NEXT,env_component,Sig);
 540        Free_Tree(tree->NEXT->NEXT->DATA);
 541        tree->NEXT->NEXT->DATA=res;
 542     }
 543     if (error==Get_Error()) {
 544          Compare_PortMap(tree->NEXT->NEXT,port->NEXT,env,env_component,Sig);
 545     }
 546     freeptype(env_component);
 547     return Ins;
 548     break;
 549   case GEN_TOKEN_IF:
 550     Verif_Bool_VHDL(tree->NEXT,env);
 551     return Verif_Instance(tree->NEXT->NEXT,Sig,env,Comp,Ins);
 552     break;
 553   case GEN_TOKEN_FOR:
 554     ope1=Verif_Exp_VHDL(tree->NEXT->NEXT,env);
 555     ope2=Verif_Exp_VHDL(tree->NEXT->NEXT->NEXT,env);
 556     /*if (ope1>ope2) {
 557       fprintf(stderr,"%s:%d: bounds of FOR are inverted\n",FILE_NAME(tree),LINE(tree));
 558       Inc_Error();
 559     }
 560     */
 561     if (!tree->NEXT) {
 562               avt_errmsg(GNS_ERRMSG, "004", AVT_FATAL, 202);
 563 //      fprintf(stderr,"Verif_Instance: NULL pointer in FOR\n");
 564       EXIT(1);
 565     }
 566    // zinaps: removed Verif_HighBound_FOR(tree->NEXT->NEXT->NEXT,env);
 567     /*to check if variable isn't already used and for is in bounds*/
 568     /*lower bound of for*/
 569     env=put_value(tree->NEXT->DATA,ope1,env);
 570     Ins=Verif_Instance(tree->NEXT->NEXT->NEXT->NEXT,Sig,env,Comp,Ins);
 571     /*upper bound of for*/
 572     env->TYPE=ope2;
 573     Ins2=Verif_Instance(tree->NEXT->NEXT->NEXT->NEXT,Sig,env,Comp,NULL);
 574     /*no use to control 2 times name of instances*/
 575     freechain(Ins2);
 576     /*remove variable of for*/
 577     env->NEXT=NULL;
 578     freeptype(env);
 579     return Ins;
 580     break;
 581   default:
 582     Error_Tree("Verif_Instance",tree);
 583     EXIT(2); return NULL;
 584   }
 585 }
 586
 587
 588