distrib/sources/api/api/gen_tree_utils.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   Alliance                     */
   4 /*                                                                          */
   5 /*    Produit : GENIUS   v1.00                                              */
   6 /*    Fichier : gen_tree_utils.c                                            */
   7 /*                                                                          */
   8 /*    Auteur(s) : Francois DONNET                        le : 08/04/1999    */
   9 /*                                                                          */
  10 /*    (c) copyright 1999 Laboratoire MASI equipe CAO & VLSI                 */
  11 /*    Tous droits reserves                                                  */
  12 /*    Support : e-mail alliance-support@asim.lip6.fr                        */
  13 /*                                                                          */
  14 /*                                                                          */
  15 /*    Modifie par :                                     le : ../../....     */
  16 /*    Modifie par :                                     le : ../../....     */
  17 /*    Modifie par :                                     le : ../../....     */
  18 /*                                                                          */
  19 /****************************************************************************/
  20
  21 #include <stdio.h>
  22 #include <math.h>
  23 #include <string.h>
  24 #include MUT_H
  25 #include AVT_H
  26 #include "gen_tree_utils.h"
  27 #include "gen_tree_parser.h"
  28
  29 static HeapAlloc tree_heap;
  30 static HeapAlloc syminfo_heap;
  31
  32 static int initcount=0;
  33 void APIInit()
  34 {
  35   if (initcount==0)
  36     {
  37       CreateHeap(sizeof(tree_list), 0, &tree_heap);
  38       CreateHeap(sizeof(SymInfoItem), 0, &syminfo_heap);
  39     }
  40   initcount++;
  41 }
  42
  43 void APIExit()
  44 {
  45   initcount--;
  46   if (initcount==0)
  47     {
  48       DeleteHeap(&tree_heap);
  49       DeleteHeap(&syminfo_heap);
  50     }
  51 }
  52
  53 int APIBlockIsC(tree_list *tree)
  54 {
  55   return TOKEN(tree)==GEN_TOKEN_ACTION;
  56 }
  57
  58 char *APIGetCName(tree_list *tree)
  59 {
  60   return getname_of(tree->NEXT);
  61 }
  62
  63 tree_list *APIGetCTree(tree_list *tree)
  64 {
  65   return tree->NEXT;
  66 }
  67
  68 int APIBlockIsArchitecture(tree_list *tree)
  69 {
  70   return TOKEN(tree)==GEN_TOKEN_ARCHITECTURE;
  71 }
  72
  73 int APIBlockIsEntity(tree_list *tree)
  74 {
  75   return TOKEN(tree)==GEN_TOKEN_ENTITY;
  76 }
  77
  78 char *APIEntityName(tree_list *tree)
  79 {
  80   return (char *)tree->NEXT->DATA->DATA;
  81 }
  82
  83 void TreeHeap_Manage(int mode)
  84 {
  85   if (mode==0)
  86     {
  87       CreateHeap(sizeof(tree_list), 0, &tree_heap);
  88     }
  89   else
  90     {
  91       DeleteHeap(&tree_heap);
  92     }
  93 }
  94
  95 /****************************************************************************/
  96 /*                   add a tree elem at the top                             */
  97 /****************************************************************************/
  98 extern tree_list* addtree(char* file, int lineno, int token, tree_list* data, tree_list* next)
  99 {
 100    tree_list* pt;
 101 /*   register int i;
 102
 103    if (HEAD_TREE == NULL) {
 104       pt = (tree_list *)mbkalloc(BUFSIZE0*sizeof(tree_list));
 105       blocks_to_free=addchain(blocks_to_free,pt);
 106       HEAD_TREE = pt;
 107       for (i = 1; i < BUFSIZE0; i++) {
 108          pt->NEXT = pt + 1;
 109          pt++;
 110       }
 111       pt->NEXT = NULL;
 112    }
 113
 114    pt = HEAD_TREE;
 115    HEAD_TREE = HEAD_TREE->NEXT;
 116   */
 117    pt=(tree_list *)AddHeapItem(&tree_heap);
 118    /*change fields*/
 119    pt->NEXT=next;
 120    pt->DATA=data;
 121    LINE(pt)=lineno;
 122    FILE_NAME(pt)=file;
 123    TOKEN(pt)=token;
 124    return pt;
 125 }
 126
 127
 128 /****************************************************************************/
 129 /*              free recursively a tree_list from the top                   */
 130 /****************************************************************************/
 131
 132 extern void freetree(tree_list* tree)
 133 {
 134   tree_list *tr, *ntr;
 135   for (tr=tree; tr!=NULL; tr=ntr) { ntr=tr->NEXT; DelHeapItem(&tree_heap, tr); }
 136
 137 //   HEAD_TREE=(tree_list*) append((chain_list*)tree, (chain_list*)HEAD_TREE);
 138 }
 139
 140
 141 /****************************************************************************/
 142 /*               build an atomic tree with a value                          */
 143 /****************************************************************************/
 144 extern tree_list *PutAto_Tree(token,file,lineno,value)
 145   char* file;
 146   int token,lineno;
 147   void* value;
 148 {
 149 return addtree(file,lineno,token,value,NULL);
 150 }
 151
 152 extern void ChangeAto_Tree(tree_list *tree, void *value)
 153 {
 154   tree->DATA=value;
 155 }
 156
 157 /****************************************************************************/
 158 /*         build an unary operator typed token with its branch              */
 159 /****************************************************************************/
 160 extern tree_list *PutUni_Tree(token,file,lineno,branch)
 161   char* file;
 162   int token,lineno;
 163   tree_list *branch;
 164 {
 165   branch=addtree(file,lineno,GEN_TOKEN_NODE,branch,NULL);
 166 return addtree(file,lineno,token,NULL,branch);
 167 }
 168
 169
 170 /****************************************************************************/
 171 /*         build an binary operator typed token with its branches           */
 172 /****************************************************************************/
 173 extern tree_list *PutBin_Tree(token,file,lineno,branch1,branch2)
 174   char* file;
 175   int token,lineno;
 176   tree_list *branch1,*branch2;
 177 {
 178   branch2=addtree(file,lineno,GEN_TOKEN_NODE,branch2,NULL);
 179   branch1=addtree(file,lineno,GEN_TOKEN_NODE,branch1,branch2);
 180 return addtree(file,lineno,token,NULL,branch1);
 181 }
 182
 183
 184 /****************************************************************************/
 185 /*            build an operator typed token with its 3 branches             */
 186 /****************************************************************************/
 187 extern tree_list *PutTri_Tree(token,file,lineno,branch1,branch2,branch3)
 188   char* file;
 189   int token,lineno;
 190   tree_list *branch1,*branch2,*branch3;
 191 {
 192   branch3=addtree(file,lineno,GEN_TOKEN_NODE,branch3,NULL);
 193   branch2=addtree(file,lineno,GEN_TOKEN_NODE,branch2,branch3);
 194   branch1=addtree(file,lineno,GEN_TOKEN_NODE,branch1,branch2);
 195 return addtree(file,lineno,token,NULL,branch1);
 196 }
 197
 198
 199 /****************************************************************************/
 200 /*            build an operator typed token with its 4 branches             */
 201 /****************************************************************************/
 202 extern tree_list *PutQua_Tree(token,file,lineno,branch1,branch2,branch3,branch4)
 203   char* file;
 204   int token,lineno;
 205   tree_list *branch1,*branch2,*branch3,*branch4;
 206 {
 207   branch4=addtree(file,lineno,GEN_TOKEN_NODE,branch4,NULL);
 208   branch3=addtree(file,lineno,GEN_TOKEN_NODE,branch3,branch4);
 209   branch2=addtree(file,lineno,GEN_TOKEN_NODE,branch2,branch3);
 210   branch1=addtree(file,lineno,GEN_TOKEN_NODE,branch1,branch2);
 211 return addtree(file,lineno,token,NULL,branch1);
 212 }
 213
 214
 215 /***************************************************************************/
 216 /*            return the string of the first ident met                     */
 217 /***************************************************************************/
 218 extern char *getname(tree)
 219    tree_list *tree;
 220 {
 221   if (!tree) {
 222     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 1);
 223     //fprintf(stderr,"getname: NULL pointer\n");
 224     EXIT(1);
 225   }
 226   switch (TOKEN(tree)) {
 227   /* as an ABL this token is a node */
 228   case GEN_TOKEN_NODE:
 229     return getname(tree->DATA);
 230     break;
 231   case '(':/*vector*/
 232     return getname(tree->NEXT);
 233     break;
 234   case GEN_TOKEN_SIGNAL: case GEN_TOKEN_IN: case GEN_TOKEN_OUT: case GEN_TOKEN_INOUT: case GEN_TOKEN_TRANSCV: case GEN_TOKEN_TRISTATE: case GEN_TOKEN_LINKAGE:
 235   case GEN_TOKEN_VARIABLE: case GEN_TOKEN_INTEGER: case GEN_TOKEN_CHAR: case GEN_TOKEN_FILE: case GEN_TOKEN_REF:
 236   case GEN_TOKEN_REF_CHAR: case GEN_TOKEN_REF_FILE: case GEN_TOKEN_OF: case GEN_TOKEN_STATIC: case GEN_TOKEN_DOUBLE: case GEN_TOKEN_VOIDTOKEN_D: case GEN_TOKEN_LONG:
 237   case GEN_TOKEN_REF_INT: case GEN_TOKEN_REF_DOUBLE: case GEN_TOKEN_REF_VOID: case GEN_TOKEN_ARRAY:
 238     return getname(tree->NEXT);
 239     break;
 240   case GEN_TOKEN_IDENT:
 241     return (char*) tree->DATA;
 242     break;
 243   default:
 244     Error_Tree("getname",tree);
 245     EXIT(2);
 246         return NULL;
 247   }
 248 }
 249
 250
 251 /***************************************************************************/
 252 /*             return the string of the second ident met                   */
 253 /***************************************************************************/
 254 extern char *getname_of(tree)
 255    tree_list *tree;
 256 {
 257   if (!tree) {
 258     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 2);
 259     //fprintf(stderr,"getname_of: NULL pointer\n");
 260     EXIT(1);
 261   }
 262   switch (TOKEN(tree)) {
 263   /* as an ABL this token is a node */
 264   case GEN_TOKEN_NODE:
 265     return getname_of(tree->DATA);
 266     break;
 267   case GEN_TOKEN_OF:
 268     return getname(tree->NEXT->NEXT);
 269     break;
 270   default:
 271     Error_Tree("getname_of",tree);
 272     EXIT(2);
 273         return NULL;
 274   }
 275 }
 276
 277
 278 /***************************************************************************/
 279 /*                      return the first ident met                         */
 280 /***************************************************************************/
 281 extern tree_list *getident(tree)
 282    tree_list *tree;
 283 {
 284   if (!tree) {
 285     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 3);
 286     //fprintf(stderr,"getident: NULL pointer\n");
 287     EXIT(1);
 288   }
 289   switch (TOKEN(tree)) {
 290   /* as an ABL this token is a node */
 291   case GEN_TOKEN_NODE:
 292     return getident(tree->DATA);
 293     break;
 294   case GEN_TOKEN_SIGNAL: case GEN_TOKEN_IN: case GEN_TOKEN_OUT: case GEN_TOKEN_INOUT: case GEN_TOKEN_TRANSCV: case GEN_TOKEN_TRISTATE: case GEN_TOKEN_LINKAGE:
 295   case GEN_TOKEN_VARIABLE: case GEN_TOKEN_INTEGER: case GEN_TOKEN_CHAR: case GEN_TOKEN_FILE:  case GEN_TOKEN_REF:
 296   case GEN_TOKEN_REF_CHAR: case GEN_TOKEN_REF_FILE: case GEN_TOKEN_OF: case GEN_TOKEN_STATIC:
 297     return getident(tree->NEXT);
 298     break;
 299   case GEN_TOKEN_IDENT:
 300     return tree;
 301     break;
 302   default:
 303     Error_Tree("getident",tree);
 304     EXIT(2);
 305         return NULL;
 306   }
 307 }
 308
 309
 310 /***************************************************************************/
 311 /*                   return the second ident met                           */
 312 /***************************************************************************/
 313 extern tree_list *getident_of(tree)
 314    tree_list *tree;
 315 {
 316   if (!tree) {
 317     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 4);
 318     //fprintf(stderr,"getident_of: NULL pointer\n");
 319     EXIT(1);
 320   }
 321   switch (TOKEN(tree)) {
 322   /* as an ABL this token is a node */
 323   case GEN_TOKEN_NODE:
 324     return getident_of(tree->DATA);
 325     break;
 326   case GEN_TOKEN_OF:
 327     return getident(tree->NEXT->NEXT);
 328     break;
 329   default:
 330     Error_Tree("getident_of",tree);
 331     EXIT(2);
 332         return NULL;
 333   }
 334 }
 335
 336
 337 /***************************************************************************/
 338 /*                       return size of vector                             */
 339 /* tree is the vector and env the values of variables in expressions       */
 340 /***************************************************************************/
 341
 342
 343 /***************************************************************************/
 344 /*              return a list of a tree structure                          */
 345 /***************************************************************************/
 346 extern chain_list *tree2chain(tree_list *tree, chain_list *pile)
 347 {
 348   if (!tree) {
 349     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 5);
 350     //fprintf(stderr,"tree2chain: NULL pointer\n");
 351     EXIT(1);
 352   }
 353   switch (TOKEN(tree)) {
 354   /*nodes..*/
 355   case GEN_TOKEN_NODE:
 356       return tree2chain(tree->DATA,pile);
 357       break;
 358   case ',': case ';':
 359       /*to revert effect of addchain*/
 360       pile=tree2chain(tree->NEXT->NEXT,pile);
 361       return tree2chain(tree->NEXT,pile);
 362       break;
 363   default:
 364       return addchain(pile,tree);
 365   }
 366 }
 367
 368
 369 /****************************************************************************/
 370 /*  return a duplicate  of tree.  Rq: strings aren't reallocated  */
 371 /****************************************************************************/
 372 extern tree_list *Duplicate_Tree(tree)
 373    tree_list *tree;
 374 {
 375   tree_list *inter;
 376   if (!tree) {
 377     return NULL;
 378     fprintf(stderr,"Duplicate_Tree: NULL pointer\n");
 379     EXIT(1);
 380   }
 381   switch (TOKEN(tree)) {
 382   /* as an ABL this token is a node */
 383   case GEN_TOKEN_NODE:
 384     return addtree(FILE_NAME(tree),LINE(tree),tree->TOKEN,Duplicate_Tree(tree->DATA),NULL);
 385     break;
 386   /*fourth class*/
 387   case GEN_TOKEN_PRAGMA_SYM:
 388     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),(tree_list *)dupchainlst((chain_list *)tree->DATA),NULL);
 389   case GEN_TOKEN_FOR:  case GEN_TOKEN_ENTITY: case GEN_TOKEN_OF:
 390     inter=Duplicate_Tree(tree->NEXT);
 391     inter->NEXT=Duplicate_Tree(tree->NEXT->NEXT);
 392     inter->NEXT->NEXT=Duplicate_Tree(tree->NEXT->NEXT->NEXT);
 393     inter->NEXT->NEXT->NEXT=Duplicate_Tree(tree->NEXT->NEXT->NEXT->NEXT);
 394     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),NULL,inter);
 395     break;
 396   /*third class*/
 397   case GEN_TOKEN_ELSE: case '?':  case GEN_TOKEN_ARCHITECTURE:
 398   case GEN_TOKEN_COMPONENT: case GEN_TOKEN_MBKFOPEN:
 399     inter=Duplicate_Tree(tree->NEXT);
 400     inter->NEXT=Duplicate_Tree(tree->NEXT->NEXT);
 401     inter->NEXT->NEXT=Duplicate_Tree(tree->NEXT->NEXT->NEXT);
 402     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),NULL,inter);
 403     break;
 404   case GEN_TOKEN_CAST:
 405     inter=Duplicate_Tree(tree->NEXT->NEXT->NEXT); // expr
 406     inter=addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree->NEXT->NEXT),tree->NEXT->NEXT->DATA,inter);
 407     inter=addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree->NEXT),tree->NEXT->DATA,inter);
 408     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),NULL,inter);
 409   /*binary class*/
 410   case GEN_TOKEN_FPRINTF: case GEN_TOKEN_SPRINTF: case GEN_TOKEN_BSPRINTF: case GEN_TOKEN_EQUI: case GEN_TOKEN_MAP:
 411   case '+': case '-': case '*': case '/': case '%': case '>': case '<':
 412   case '&': case '|': case '^': case GEN_TOKEN_EG:
 413   case GEN_TOKEN_SUPEG: case GEN_TOKEN_INFEG: case GEN_TOKEN_NOTEG: case GEN_TOKEN_SHR: case GEN_TOKEN_SHL:
 414   case ';': case ',': case GNS_TOKEN_AND: case GEN_TOKEN_XOR: case GEN_TOKEN_MOD: case GEN_TOKEN_POW:
 415   case '=': case GEN_TOKEN_IF: case GEN_TOKEN_DO: case GEN_TOKEN_WHILE: case '(': case GEN_TOKEN_ACTION:
 416   case GEN_TOKEN_OR: case GEN_TOKEN_FOPEN: case GEN_TOKEN_TO: case GEN_TOKEN_DOWNTO:  case GEN_TOKEN_FUNCTION:
 417   case GEN_TOKEN_OTHER_TYPES: case GEN_TOKEN_ARRAY:
 418     inter=Duplicate_Tree(tree->NEXT);
 419     inter->NEXT=Duplicate_Tree(tree->NEXT->NEXT);
 420     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),NULL,inter);
 421     break;
 422   /*unary class*/
 423   case GEN_TOKEN_OPPOSITE: case '~':
 424   case GEN_TOKEN_INC_BEFORE: case GEN_TOKEN_INC_AFTER: case GEN_TOKEN_DEC_BEFORE: case GEN_TOKEN_DEC_AFTER:
 425   case GEN_TOKEN_IN: case GEN_TOKEN_OUT: case GEN_TOKEN_INOUT: case GEN_TOKEN_TRANSCV: case GEN_TOKEN_TRISTATE: case GEN_TOKEN_LINKAGE:
 426   case GEN_TOKEN_GENERIC: case GEN_TOKEN_PORT: case GEN_TOKEN_EXCLUDE:
 427   case GEN_TOKEN_NOT:
 428   case GEN_TOKEN_VARIABLE: case GEN_TOKEN_SIGNAL: case GEN_TOKEN_INTEGER: case GEN_TOKEN_FCLOSE: case GEN_TOKEN_VOIDTOKEN_D:
 429   case GEN_TOKEN_CHAR: case GEN_TOKEN_FILE: case GEN_TOKEN_REF_CHAR: case GEN_TOKEN_REF_FILE: case GEN_TOKEN_DOUBLE: case GEN_TOKEN_LONG:
 430   case GEN_TOKEN_BLOCK: case GEN_TOKEN_EXIT: case GEN_TOKEN_STATIC: case GEN_TOKEN_ADR:
 431     inter=Duplicate_Tree(tree->NEXT);
 432     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),NULL,inter);
 433     break;
 434   /*terminal*/
 435   case GEN_TOKEN_REF:
 436     inter=Duplicate_Tree(tree->NEXT);
 437     inter->NEXT=tree->NEXT->NEXT; // ref depth
 438     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),NULL,inter);
 439   case GEN_TOKEN_STDOUT: case GEN_TOKEN_STDERR: case GEN_TOKEN_RETURN: case GEN_TOKEN_BREAK:
 440   case GEN_TOKEN_IDENT: case GEN_TOKEN_DIGIT: case GEN_TOKEN_DIGIT_CHAR: case GEN_TOKEN_NOP: case GEN_TOKEN_LOINS:/*pointer on a loins*/
 441   case GEN_TOKEN_NULL:
 442     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),tree->DATA,NULL);
 443     /*namealloc or no data pointer*/
 444     break;
 445   case GEN_TOKEN_DIGIT_DOUBLE:
 446     {
 447       double *a=(double *)mbkalloc(sizeof(double));
 448       *a=*(double *)tree->DATA;
 449       return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),(tree_list *)a,NULL);
 450     }
 451   case GEN_TOKEN_VOIDTOKEN:
 452      return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),(tree_list *)dupptypelst((ptype_list *)tree->DATA),NULL);
 453   case GEN_TOKEN_VOIDTOKEN_CL:
 454      return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),(tree_list *)dupchainlst((chain_list *)tree->DATA),NULL);
 455   case GEN_TOKEN_VOIDTOKEN_CL_TA:
 456      return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),(tree_list *)APIDupARGS((chain_list *)tree->DATA),NULL);
 457   case GEN_TOKEN_STRING:
 458     {char *a=(char *)mbkalloc(strlen((char*)tree->DATA)+1);
 459     strcpy(a,(char*)tree->DATA);
 460     return addtree(FILE_NAME(tree),LINE(tree),TOKEN(tree),(tree_list*)a,NULL);
 461     break;}
 462   default:
 463     Error_Tree("Duplicate_Tree",tree);
 464     EXIT(2);
 465         return NULL;
 466   }
 467 }
 468
 469
 470
 471 /****************************************************************************/
 472 /*  Dump on FILE *stdout the syntaxical tree typed in file2tree.h     */
 473 /****************************************************************************/
 474 extern void Dump_Tree(tree_list *tree)
 475 {
 476   if (!tree) {
 477     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 6);
 478     //fprintf(stderr,"Dump_Tree: NULL pointer\n");
 479     EXIT(1);
 480   }
 481
 482   switch (TOKEN(tree)) {
 483   /* as an ABL token is a node */
 484   case GEN_TOKEN_NODE:
 485     Dump_Tree(tree->DATA);
 486     break;
 487   case GEN_TOKEN_ENTITY:
 488     fprintf(stdout,"\n******************************************************\n");
 489     fprintf(stdout," ENTITY ");
 490     Dump_Tree(tree->NEXT);
 491     fprintf(stdout," IS\n");
 492     Dump_Tree(tree->NEXT->NEXT);
 493     Dump_Tree(tree->NEXT->NEXT->NEXT);
 494     fprintf(stdout,"\n");
 495     break;
 496   case GEN_TOKEN_ARCHITECTURE:
 497     fprintf(stdout,"\n******************************************************\n");
 498     fprintf(stdout," ARCHITECTURE ");
 499     Dump_Tree(tree->NEXT);
 500     fprintf(stdout," IS\n");
 501     Dump_Tree(tree->NEXT->NEXT);
 502     fprintf(stdout," BEGIN\n");
 503     Dump_Tree(tree->NEXT->NEXT->NEXT);
 504     fprintf(stdout," END\n");
 505     break;
 506   case GEN_TOKEN_ACTION:
 507     fprintf(stdout,"\n******************************************************\n");
 508     fprintf(stdout," ACTION ");
 509     Dump_Tree(tree->NEXT);
 510     fprintf(stdout," IS\n BEGIN\n");
 511     Dump_Tree(tree->NEXT->NEXT);
 512     fprintf(stdout," END\n");
 513     break;
 514   case GEN_TOKEN_GENERIC:
 515     fprintf(stdout," GENERIC (");
 516     Dump_Tree(tree->NEXT);
 517     fprintf(stdout," )\n");
 518     break;
 519   case GEN_TOKEN_PORT:
 520     fprintf(stdout," PORT (");
 521     Dump_Tree(tree->NEXT);
 522     fprintf(stdout," )\n");
 523     break;
 524   case GEN_TOKEN_MAP:
 525     Dump_Tree(tree->NEXT);
 526     fprintf(stdout," PORT MAP (");
 527     Dump_Tree(tree->NEXT->NEXT);
 528     fprintf(stdout," )\n");
 529     break;
 530   case GEN_TOKEN_COMPONENT:
 531     fprintf(stdout," COMPONENT ");
 532     Dump_Tree(tree->NEXT);
 533     fprintf(stdout," IS\n ");
 534     Dump_Tree(tree->NEXT->NEXT);
 535     Dump_Tree(tree->NEXT->NEXT->NEXT);
 536     fprintf(stdout,"\n");
 537     break;
 538   case GEN_TOKEN_OF:
 539     Dump_Tree(tree->NEXT);
 540     fprintf(stdout," OF ");
 541     Dump_Tree(tree->NEXT->NEXT);
 542     break;
 543   case '+': case '-': case '*': case '/': case '%': case '>': case '<':
 544   case '&': case '|': case '^': case ';': case ',': case '=':
 545     Dump_Tree(tree->NEXT);
 546     fprintf(stdout," %c ",(char)TOKEN(tree));
 547     Dump_Tree(tree->NEXT->NEXT);
 548     break;
 549   case '?':
 550     Dump_Tree(tree->NEXT);
 551     fprintf(stdout," ? ");
 552     Dump_Tree(tree->NEXT->NEXT);
 553     fprintf(stdout," : ");
 554     Dump_Tree(tree->NEXT->NEXT->NEXT);
 555     break;
 556   case '~':
 557     fprintf(stdout," ~");
 558     Dump_Tree(tree->NEXT);
 559     break;
 560   case GEN_TOKEN_MOD:
 561     Dump_Tree(tree->NEXT);
 562     fprintf(stdout," mod ");
 563     Dump_Tree(tree->NEXT->NEXT);
 564     break;
 565   case GEN_TOKEN_POW:
 566     Dump_Tree(tree->NEXT);
 567     fprintf(stdout," ** ");
 568     Dump_Tree(tree->NEXT->NEXT);
 569     break;
 570   case GNS_TOKEN_AND:
 571     Dump_Tree(tree->NEXT);
 572     fprintf(stdout," && ");
 573     Dump_Tree(tree->NEXT->NEXT);
 574     break;
 575   case GEN_TOKEN_OR:
 576     Dump_Tree(tree->NEXT);
 577     fprintf(stdout," || ");
 578     Dump_Tree(tree->NEXT->NEXT);
 579     break;
 580   case GEN_TOKEN_XOR:
 581     Dump_Tree(tree->NEXT);
 582     fprintf(stdout," xor ");
 583     Dump_Tree(tree->NEXT->NEXT);
 584     break;
 585   case GEN_TOKEN_NOT:
 586     fprintf(stdout," !");
 587     Dump_Tree(tree->NEXT);
 588     break;
 589   case GEN_TOKEN_OPPOSITE:
 590     fprintf(stdout," -");
 591     Dump_Tree(tree->NEXT);
 592     break;
 593   case GEN_TOKEN_EG:
 594     Dump_Tree(tree->NEXT);
 595     fprintf(stdout," == ");
 596     Dump_Tree(tree->NEXT->NEXT);
 597     break;
 598   case GEN_TOKEN_NOTEG:
 599     Dump_Tree(tree->NEXT);
 600     fprintf(stdout," != ");
 601     Dump_Tree(tree->NEXT->NEXT);
 602     break;
 603   case GEN_TOKEN_SUPEG:
 604     Dump_Tree(tree->NEXT);
 605     fprintf(stdout," >= ");
 606     Dump_Tree(tree->NEXT->NEXT);
 607     break;
 608   case GEN_TOKEN_INFEG:
 609     Dump_Tree(tree->NEXT);
 610     fprintf(stdout," <= ");
 611     Dump_Tree(tree->NEXT->NEXT);
 612     break;
 613   case GEN_TOKEN_SHL:
 614     Dump_Tree(tree->NEXT);
 615     fprintf(stdout," << ");
 616     Dump_Tree(tree->NEXT->NEXT);
 617     break;
 618   case GEN_TOKEN_SHR:
 619     Dump_Tree(tree->NEXT);
 620     fprintf(stdout," >> ");
 621     Dump_Tree(tree->NEXT->NEXT);
 622     break;
 623   case GEN_TOKEN_FPRINTF:
 624   case GEN_TOKEN_SPRINTF:
 625   case GEN_TOKEN_BSPRINTF:
 626     fprintf(stdout,"FPRINTF ( ");
 627     Dump_Tree(tree->NEXT);
 628     fprintf(stdout,", ");
 629     Dump_Tree(tree->NEXT->NEXT);
 630     fprintf(stdout,") ");
 631     fflush(stdout);
 632     break;
 633   case GEN_TOKEN_EXCLUDE:
 634     fprintf(stdout,"EXCLUDE (");
 635     Dump_Tree(tree->NEXT);
 636     fprintf(stdout,") ");
 637     fflush(stdout);
 638     break;
 639   case GEN_TOKEN_FOPEN:
 640     fprintf(stdout,"FOPEN (");
 641     Dump_Tree(tree->NEXT);
 642     fprintf(stdout,", ");
 643     Dump_Tree(tree->NEXT->NEXT);
 644     fprintf(stdout,") ");
 645     fflush(stdout);
 646     break;
 647   case GEN_TOKEN_MBKFOPEN:
 648     fprintf(stdout,"MBKFOPEN (");
 649     Dump_Tree(tree->NEXT);
 650     fprintf(stdout,", ");
 651     Dump_Tree(tree->NEXT->NEXT);
 652     fprintf(stdout,", ");
 653     Dump_Tree(tree->NEXT->NEXT->NEXT);
 654     fprintf(stdout,") ");
 655     fflush(stdout);
 656     break;
 657   case GEN_TOKEN_FCLOSE:
 658     fprintf(stdout,"FCLOSE (");
 659     Dump_Tree(tree->NEXT);
 660     fprintf(stdout,") ");
 661     fflush(stdout);
 662     break;
 663   case GEN_TOKEN_FOR:
 664     fprintf(stdout,"FOR( ");
 665     Dump_Tree(tree->NEXT);
 666     fprintf(stdout," ; ");
 667     Dump_Tree(tree->NEXT->NEXT);
 668     fprintf(stdout," ; ");
 669     Dump_Tree(tree->NEXT->NEXT->NEXT);
 670     fprintf(stdout," ) {\n");
 671     Dump_Tree(tree->NEXT->NEXT->NEXT->NEXT);
 672     fprintf(stdout,"}\n");
 673     break;
 674   case GEN_TOKEN_IF:
 675     fprintf(stdout,"IF( ");
 676     Dump_Tree(tree->NEXT);
 677     fprintf(stdout," ) {\n");
 678     Dump_Tree(tree->NEXT->NEXT);
 679     fprintf(stdout,"}\n");
 680     break;
 681   case GEN_TOKEN_DO:
 682     fprintf(stdout,"DO{ ");
 683     Dump_Tree(tree->NEXT);
 684     fprintf(stdout," } \nWHILE(");
 685     Dump_Tree(tree->NEXT->NEXT);
 686     fprintf(stdout,")\n");
 687     break;
 688   case GEN_TOKEN_WHILE:
 689     fprintf(stdout,"WHILE( ");
 690     Dump_Tree(tree->NEXT);
 691     fprintf(stdout," ) {\n");
 692     Dump_Tree(tree->NEXT->NEXT);
 693     fprintf(stdout,"}\n");
 694     break;
 695   case GEN_TOKEN_ELSE:
 696     fprintf(stdout,"IF( ");
 697     Dump_Tree(tree->NEXT);
 698     fprintf(stdout," ) {\n");
 699     Dump_Tree(tree->NEXT->NEXT);
 700     fprintf(stdout,"}\nELSE{\n");
 701     Dump_Tree(tree->NEXT->NEXT->NEXT);
 702     fprintf(stdout,"}\n");
 703     break;
 704   case '(':
 705     Dump_Tree(tree->NEXT);
 706     fprintf(stdout,"(");
 707     Dump_Tree(tree->NEXT->NEXT);
 708     fprintf(stdout,")");
 709     fflush(stdout);
 710     break;
 711   case GEN_TOKEN_TO:
 712     Dump_Tree(tree->NEXT);
 713     fprintf(stdout," to ");
 714     Dump_Tree(tree->NEXT->NEXT);
 715     break;
 716   case GEN_TOKEN_DOWNTO:
 717     Dump_Tree(tree->NEXT);
 718     fprintf(stdout," downto ");
 719     Dump_Tree(tree->NEXT->NEXT);
 720     break;
 721   case GEN_TOKEN_IN:
 722     fprintf(stdout,"IN ");
 723     Dump_Tree(tree->NEXT);
 724     break;
 725   case GEN_TOKEN_OUT:
 726     fprintf(stdout,"OUT ");
 727     Dump_Tree(tree->NEXT);
 728     break;
 729   case GEN_TOKEN_INOUT:
 730     fprintf(stdout,"INOUT ");
 731     Dump_Tree(tree->NEXT);
 732     break;
 733   case GEN_TOKEN_TRISTATE:
 734     fprintf(stdout,"TRISTATE ");
 735     Dump_Tree(tree->NEXT);
 736     break;
 737   case GEN_TOKEN_TRANSCV:
 738     fprintf(stdout,"TRANSCV ");
 739     Dump_Tree(tree->NEXT);
 740     break;
 741   case GEN_TOKEN_LINKAGE:
 742     fprintf(stdout,"LINKAGE ");
 743     Dump_Tree(tree->NEXT);
 744     break;
 745   case GEN_TOKEN_INTEGER:
 746     fprintf(stdout,"INTEGER ");
 747     Dump_Tree(tree->NEXT);
 748     break;
 749   case GEN_TOKEN_BLOCK:
 750     Dump_Tree(tree->NEXT);
 751     break;
 752   case GEN_TOKEN_CHAR:
 753     fprintf(stdout,"CHAR ");
 754     Dump_Tree(tree->NEXT);
 755     break;
 756   case GEN_TOKEN_FILE:
 757     fprintf(stdout,"FILE ");
 758     Dump_Tree(tree->NEXT);
 759     break;
 760   case GEN_TOKEN_REF:
 761     fprintf(stdout,"*");
 762     Dump_Tree(tree->NEXT);
 763     break;
 764   case GEN_TOKEN_VARIABLE:
 765     fprintf(stdout,"VARIABLE ");
 766     Dump_Tree(tree->NEXT);
 767     break;
 768   case GEN_TOKEN_SIGNAL:
 769     fprintf(stdout,"SIGNAL ");
 770     Dump_Tree(tree->NEXT);
 771     break;
 772   case GEN_TOKEN_EQUI:
 773     Dump_Tree(tree->NEXT);
 774     fprintf(stdout," => ");
 775     Dump_Tree(tree->NEXT->NEXT);
 776     break;
 777   case GEN_TOKEN_DEC_BEFORE:
 778     fprintf(stdout," --");
 779     Dump_Tree(tree->NEXT);
 780     break;
 781   case GEN_TOKEN_DEC_AFTER:
 782     Dump_Tree(tree->NEXT);
 783     fprintf(stdout,"-- ");
 784     fflush(stdout);
 785     break;
 786   case GEN_TOKEN_INC_BEFORE:
 787     fprintf(stdout," ++");
 788     Dump_Tree(tree->NEXT);
 789     break;
 790   case GEN_TOKEN_INC_AFTER:
 791     Dump_Tree(tree->NEXT);
 792     fprintf(stdout,"++ ");
 793     fflush(stdout);
 794     break;
 795   case GEN_TOKEN_FUNCTION:
 796     fprintf(stdout," %s (",(char *)tree->NEXT->DATA);
 797     Dump_Tree(tree->NEXT->NEXT);
 798     fprintf(stdout,") ");
 799     fflush(stdout);
 800     break;
 801   case GEN_TOKEN_EXIT:
 802     fprintf(stdout,"exit(");
 803     Dump_Tree(tree->NEXT);
 804     fprintf(stdout,")");
 805     fflush(stdout);
 806     break;
 807   case GEN_TOKEN_BREAK:
 808     fprintf(stdout,"break");
 809     fflush(stdout);
 810     break;
 811   case GEN_TOKEN_RETURN:
 812     fprintf(stdout,"return");
 813     fflush(stdout);
 814     break;
 815   case GEN_TOKEN_STRING:
 816     fprintf(stdout,"\"%s\"",(char*)tree->DATA);
 817     fflush(stdout);
 818     break;
 819   case GEN_TOKEN_IDENT:
 820     fprintf(stdout,"%s",(char*)tree->DATA);
 821     fflush(stdout);
 822     break;
 823   case GEN_TOKEN_DIGIT:
 824     fprintf(stdout,"%d",(int)(long)tree->DATA);
 825     fflush(stdout);
 826     break;
 827    case GEN_TOKEN_LOINS:/*pointer on a loins in lofig*/
 828     if (tree->DATA) fprintf(stdout,"LOINS");
 829     else fprintf(stdout,"!!!no access to loins!!!");
 830     fflush(stdout);
 831     break;
 832   case GEN_TOKEN_STATIC:
 833     fprintf(stdout,"static ");
 834     fflush(stdout);
 835     break;
 836   case GEN_TOKEN_STDOUT:
 837     fprintf(stdout,"stdout");
 838     fflush(stdout);
 839     break;
 840   case GEN_TOKEN_STDERR:
 841     fprintf(stdout,"stderr");
 842     fflush(stdout);
 843     break;
 844   case GEN_TOKEN_NOP:
 845     fprintf(stdout,"N.O.P\n"); /*nothing to dump*/
 846     break;
 847   default:
 848     Error_Tree("Dump_Tree",tree);
 849   }
 850 }
 851
 852
 853
 854 /****************************************************************************/
 855 /*   Dump an error message on the uppest token of tree. Rq: the argument    */
 856 /*               message should be a function name                          */
 857 /*Rq: the number line dumped is just an information, it could be completely */
 858 /* wrong... We only guaranty that for tokens GEN_TOKEN_IDENT, GEN_TOKEN_STRING and GEN_TOKEN_DIGIT, it */
 859 /* is the good one. Anyway mostly, the number line is around the error ;-)  */
 860 /****************************************************************************/
 861 extern void Error_Tree(char *message,tree_list *tree)
 862 {
 863   if (!tree) {
 864     avt_errmsg(API_ERRMSG, "004", AVT_FATAL, 7);
 865 //    fprintf(stderr,"Error_Tree: NULL pointer\n");
 866     EXIT(1);
 867   }
 868   switch (TOKEN(tree)) {
 869   /* node of ABL */
 870   case GEN_TOKEN_NODE:
 871     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 8);
 872 //    fprintf(stderr,"(%s): unexpected node in file %s:%d\n",message,FILE_NAME(tree),LINE(tree));
 873     break;
 874   case '(': case '?':
 875   case '+': case '-': case '*': case '/': case '%': case '>': case '<':
 876   case '&': case '|': case '^': case ';': case ',': case '=': case '~':
 877     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 9);
 878 //    fprintf(stderr,"(%s) %d: unexpected token '%c' in file %s\n",message,
 879 //          LINE(tree),TOKEN(tree),FILE_NAME(tree));
 880     break;
 881   case GEN_TOKEN_ARRAY:
 882     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 10);
 883 //    fprintf(stderr,"(%s) %d: unexpected ARRAY in file %s\n",message,LINE(tree),FILE_NAME(tree));
 884     break;
 885   case GEN_TOKEN_TO:
 886     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 11);
 887 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"to",FILE_NAME(tree));
 888     break;
 889   case GEN_TOKEN_DOWNTO:
 890     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 12);
 891 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"downto",FILE_NAME(tree));
 892     break;
 893   case GEN_TOKEN_ENTITY:
 894     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 13);
 895 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"entity",FILE_NAME(tree));
 896     break;
 897   case GEN_TOKEN_ARCHITECTURE:
 898     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 14);
 899 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
 900 //          LINE(tree),"structure",FILE_NAME(tree));
 901     break;
 902   case GEN_TOKEN_ACTION:
 903     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 15);
 904 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"action",FILE_NAME(tree));
 905     break;
 906   case GEN_TOKEN_MOD:
 907     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 16);
 908 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"mod",FILE_NAME(tree));
 909     break;
 910   case GEN_TOKEN_POW:
 911     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 17);
 912 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"pow",FILE_NAME(tree));
 913     break;
 914   case GEN_TOKEN_MAP:
 915     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 18);
 916 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"port map",FILE_NAME(tree));
 917     break;
 918   case GEN_TOKEN_COMPONENT:
 919     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 19);
 920 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"component",FILE_NAME(tree));
 921     break;
 922   case GEN_TOKEN_OF:
 923     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 20);
 924 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"of",FILE_NAME(tree));
 925     break;
 926   case GEN_TOKEN_GENERIC:
 927     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 21);
 928 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"generic",FILE_NAME(tree));
 929     break;
 930   case GEN_TOKEN_PORT:
 931     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 22);
 932 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"port",FILE_NAME(tree));
 933     break;
 934   case GEN_TOKEN_VARIABLE:
 935     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 23);
 936 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"variable",FILE_NAME(tree));
 937     break;
 938   case GEN_TOKEN_INTEGER:
 939     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 24);
 940 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"integer",FILE_NAME(tree));
 941     break;
 942   case GEN_TOKEN_BLOCK:
 943     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 25);
 944 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"block",FILE_NAME(tree));
 945     break;
 946   case GEN_TOKEN_CHAR:
 947     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 26);
 948 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"char",FILE_NAME(tree));
 949     break;
 950   case GEN_TOKEN_FILE:
 951     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 27);
 952 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"FILE",FILE_NAME(tree));
 953     break;
 954   case GEN_TOKEN_REF:
 955     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 28);
 956 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"_REF",FILE_NAME(tree));
 957     break;
 958   case GEN_TOKEN_REF_FILE:
 959     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 29);
 960 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"_REF_FILE",FILE_NAME(tree));
 961     break;
 962   case GEN_TOKEN_REF_CHAR:
 963     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 30);
 964 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"_REF_CHAR",FILE_NAME(tree));
 965     break;
 966   case GEN_TOKEN_STATIC:
 967     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 31);
 968 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"static",FILE_NAME(tree));
 969     break;
 970   case GEN_TOKEN_SIGNAL:
 971     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 32);
 972 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"signal",FILE_NAME(tree));
 973     break;
 974   case GNS_TOKEN_AND:
 975     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 33);
 976 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"&&",FILE_NAME(tree));
 977     break;
 978   case GEN_TOKEN_OR:
 979     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 34);
 980 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"||",FILE_NAME(tree));
 981     break;
 982   case GEN_TOKEN_EG:
 983     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 35);
 984 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"==",FILE_NAME(tree));
 985     break;
 986   case GEN_TOKEN_OPPOSITE:
 987     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 36);
 988 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"-",FILE_NAME(tree));
 989     break;
 990   case GEN_TOKEN_NOT:
 991     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 37);
 992 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"!",FILE_NAME(tree));
 993     break;
 994   case GEN_TOKEN_NOTEG:
 995     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 38);
 996 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"!=",FILE_NAME(tree));
 997     break;
 998   case GEN_TOKEN_SUPEG:
 999     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 39);
1000 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),">=",FILE_NAME(tree));
1001     break;
1002   case GEN_TOKEN_INFEG:
1003     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 40);
1004 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"<=",FILE_NAME(tree));
1005     break;
1006   case GEN_TOKEN_XOR:
1007     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 41);
1008 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"xor",FILE_NAME(tree));
1009     break;
1010   case GEN_TOKEN_FPRINTF:
1011   case GEN_TOKEN_SPRINTF:
1012   case GEN_TOKEN_BSPRINTF:
1013     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 42);
1014 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"fprintf/sprintf/bsprintf",FILE_NAME(tree));
1015     break;
1016   case GEN_TOKEN_EXCLUDE:
1017     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 43);
1018 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"exclude",FILE_NAME(tree));
1019     break;
1020   case GEN_TOKEN_MBKFOPEN:
1021     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 44);
1022 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"mbkfopen",FILE_NAME(tree));
1023     break;
1024   case GEN_TOKEN_FOPEN:
1025     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 45);
1026 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"fopen",FILE_NAME(tree));
1027     break;
1028   case GEN_TOKEN_FCLOSE:
1029     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 46);
1030 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"fclose",FILE_NAME(tree));
1031     break;
1032   case GEN_TOKEN_PRINTF:
1033     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 47);
1034 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"printf",FILE_NAME(tree));
1035     break;
1036   case GEN_TOKEN_FOR:
1037     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 48);
1038 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"for",FILE_NAME(tree));
1039     break;
1040   case GEN_TOKEN_IF:
1041     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 49);
1042 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"if",FILE_NAME(tree));
1043     break;
1044   case GEN_TOKEN_DO:
1045     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 50);
1046 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"do",FILE_NAME(tree));
1047     break;
1048   case GEN_TOKEN_WHILE:
1049     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 51);
1050 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"while",FILE_NAME(tree));
1051     break;
1052   case GEN_TOKEN_ELSE:
1053     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 52);
1054 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"else",FILE_NAME(tree));
1055     break;
1056   case GEN_TOKEN_IN:
1057     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 53);
1058 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"in",FILE_NAME(tree));
1059     break;
1060   case GEN_TOKEN_OUT:
1061     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 54);
1062 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"out",FILE_NAME(tree));
1063     break;
1064   case GEN_TOKEN_INOUT:
1065     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 55);
1066 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"inout",FILE_NAME(tree));
1067     break;
1068   case GEN_TOKEN_LINKAGE:
1069     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 56);
1070 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"linkage",FILE_NAME(tree));
1071     break;
1072   case GEN_TOKEN_TRISTATE:
1073     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 57);
1074 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
1075 //          LINE(tree),"tristate",FILE_NAME(tree));
1076     break;
1077   case GEN_TOKEN_TRANSCV:
1078     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 58);
1079 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
1080 //          LINE(tree),"transcv",FILE_NAME(tree));
1081     break;
1082   case GEN_TOKEN_EQUI:
1083     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 59);
1084 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"=>",FILE_NAME(tree));
1085     break;
1086   case GEN_TOKEN_SHL:
1087     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 60);
1088 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"<<",FILE_NAME(tree));
1089     break;
1090   case GEN_TOKEN_SHR:
1091     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 61);
1092 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),">>",FILE_NAME(tree));
1093     break;
1094   case GEN_TOKEN_DEC_BEFORE: case GEN_TOKEN_DEC_AFTER:
1095     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 62);
1096 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"--",FILE_NAME(tree));
1097     break;
1098   case GEN_TOKEN_INC_BEFORE: case GEN_TOKEN_INC_AFTER:
1099     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 63);
1100 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"++",FILE_NAME(tree));
1101     break;
1102   case GEN_TOKEN_STRING: case GEN_TOKEN_IDENT:
1103     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 64);
1104 //    fprintf(stderr, "(%s) %d: unexpected string '%s' in file %s\n",
1105 //            message, LINE(tree), (char*)tree->DATA,FILE_NAME(tree));
1106     break;
1107   case GEN_TOKEN_DIGIT:
1108     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 65);
1109 //    fprintf(stderr,"(%s) %d: unexpected digit '%d' in file %s\n",message,
1110 //          LINE(tree),(int)(long)tree->DATA,FILE_NAME(tree));
1111     break;
1112    case GEN_TOKEN_LOINS:/*pointer on a loins in lofig*/
1113       if (tree->DATA) avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 66);
1114 //    fprintf(stdout,"(%s) unexpected loins in file %s\n",
1115 //                              message,FILE_NAME(tree));
1116       else avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 67);
1117 //    fprintf(stdout,"(%s) unexpected loins with null pointer in file %s\n",
1118 //                   message,FILE_NAME(tree));
1119       break;
1120   case GEN_TOKEN_EXIT:
1121     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 68);
1122 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
1123 //          LINE(tree),"EXIT",FILE_NAME(tree));
1124     break;
1125   case GEN_TOKEN_RETURN:
1126     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 69);
1127 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
1128 //          LINE(tree),"RETURN",FILE_NAME(tree));
1129     break;
1130   case GEN_TOKEN_BREAK:
1131     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 70);
1132 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
1133 //          LINE(tree),"BREAK",FILE_NAME(tree));
1134     break;
1135   case GEN_TOKEN_NOP:
1136     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 71);
1137 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,
1138 //          LINE(tree),"NOP",FILE_NAME(tree));
1139     break;
1140   case GEN_TOKEN_STDOUT:
1141     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 72);
1142 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"stdout",FILE_NAME(tree));
1143     break;
1144   case GEN_TOKEN_STDERR:
1145     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 73);
1146 //    fprintf(stderr,"(%s) %d: unexpected token '%s' in file %s\n",message,LINE(tree),"stderr",FILE_NAME(tree));
1147     break;
1148   default:
1149     avt_errmsg(API_ERRMSG, "004", AVT_ERROR, 74);
1150 //    fprintf(stderr,"(%s): token %d unknown\n",message,TOKEN(tree));
1151   }
1152 }
1153
1154
1155 /****************************************************************************/
1156 /*       Free all the tree, just stay strings in memory(namealloc)          */
1157 /****************************************************************************/
1158 extern void Free_Tree(tree)
1159    tree_list *tree;
1160 {
1161   if (!tree) {
1162     return;
1163   //  fprintf(stderr,"Free_Tree: NULL pointer\n");
1164     EXIT(1);
1165   }
1166   switch (TOKEN(tree)) {
1167   /* node of ABL */
1168   case GEN_TOKEN_NODE:
1169     Free_Tree(tree->DATA);
1170     break;
1171   case GEN_TOKEN_PRAGMA_SYM:
1172     freechain((chain_list *)tree->DATA);
1173     freetree(tree);
1174     break;
1175   /*fourth class*/
1176   case GEN_TOKEN_FOR: case GEN_TOKEN_ENTITY: case GEN_TOKEN_OF:
1177     Free_Tree(tree->NEXT->NEXT->NEXT->NEXT);
1178     Free_Tree(tree->NEXT->NEXT->NEXT);
1179     Free_Tree(tree->NEXT->NEXT);
1180     Free_Tree(tree->NEXT);
1181     freetree(tree);
1182     break;
1183   /*third class*/
1184   case GEN_TOKEN_ELSE: case '?':   case GEN_TOKEN_ARCHITECTURE:
1185   case GEN_TOKEN_COMPONENT: case GEN_TOKEN_MBKFOPEN:
1186     Free_Tree(tree->NEXT->NEXT->NEXT);
1187     Free_Tree(tree->NEXT->NEXT);
1188     Free_Tree(tree->NEXT);
1189     freetree(tree);
1190     break;
1191   case GEN_TOKEN_CAST:
1192     Free_Tree(tree->NEXT->NEXT->NEXT);
1193     freetree(tree);
1194     break;
1195   /*binary class*/
1196   case GEN_TOKEN_FPRINTF: case GEN_TOKEN_SPRINTF: case GEN_TOKEN_BSPRINTF: case'(': case GEN_TOKEN_TO: case GEN_TOKEN_DOWNTO:
1197   case GEN_TOKEN_ACTION: case GEN_TOKEN_EQUI: case GEN_TOKEN_MAP:
1198   case '+': case '-': case '*': case '/': case '%': case '>': case '<':
1199   case '&': case '|': case '^': case GNS_TOKEN_AND: case GEN_TOKEN_OR: case GEN_TOKEN_EG:
1200   case GEN_TOKEN_SUPEG: case GEN_TOKEN_INFEG: case GEN_TOKEN_NOTEG: case GEN_TOKEN_SHR: case GEN_TOKEN_SHL:
1201   case ';': case ',': case GEN_TOKEN_XOR: case GEN_TOKEN_MOD: case GEN_TOKEN_POW:
1202   case '=': case GEN_TOKEN_IF: case GEN_TOKEN_DO: case GEN_TOKEN_WHILE: case GEN_TOKEN_FOPEN:  case GEN_TOKEN_FUNCTION:
1203   case GEN_TOKEN_OTHER_TYPES:  case GEN_TOKEN_ARRAY:
1204     Free_Tree(tree->NEXT->NEXT);
1205     Free_Tree(tree->NEXT);
1206     freetree(tree);
1207     break;
1208   /*unary class*/
1209   case GEN_TOKEN_OPPOSITE: case '~':
1210   case GEN_TOKEN_INC_BEFORE: case GEN_TOKEN_INC_AFTER: case GEN_TOKEN_DEC_BEFORE: case GEN_TOKEN_DEC_AFTER:
1211   case GEN_TOKEN_IN: case GEN_TOKEN_OUT: case GEN_TOKEN_INOUT: case GEN_TOKEN_TRANSCV: case GEN_TOKEN_TRISTATE: case GEN_TOKEN_LINKAGE:
1212   case GEN_TOKEN_NOT: case GEN_TOKEN_GENERIC: case GEN_TOKEN_PORT:
1213   case GEN_TOKEN_EXCLUDE:
1214   case GEN_TOKEN_ADR:
1215   case GEN_TOKEN_VARIABLE: case GEN_TOKEN_SIGNAL: case GEN_TOKEN_INTEGER: case GEN_TOKEN_FCLOSE: case GEN_TOKEN_VOIDTOKEN_D:
1216   case GEN_TOKEN_CHAR: case GEN_TOKEN_FILE: case GEN_TOKEN_REF: case GEN_TOKEN_REF_CHAR: case GEN_TOKEN_REF_FILE: case GEN_TOKEN_DOUBLE: case GEN_TOKEN_LONG:
1217   case GEN_TOKEN_BLOCK: case GEN_TOKEN_EXIT: case GEN_TOKEN_STATIC: case GEN_TOKEN_REF_VOID: case GEN_TOKEN_REF_INT: case GEN_TOKEN_REF_DOUBLE:
1218     Free_Tree(tree->NEXT);
1219     tree->NEXT->NEXT=NULL;
1220     freetree(tree);
1221     break;
1222   /*terminal*/
1223   case GEN_TOKEN_STRING:
1224     mbkfree(tree->DATA);  /*mbkalloc*/
1225     freetree(tree);
1226     break;
1227   case GEN_TOKEN_STDOUT: case GEN_TOKEN_STDERR: case GEN_TOKEN_IDENT: case GEN_TOKEN_DIGIT: case GEN_TOKEN_NOP: case GEN_TOKEN_LOINS:
1228   case GEN_TOKEN_BREAK: case GEN_TOKEN_RETURN: case GEN_TOKEN_DIGIT_CHAR: case GEN_TOKEN_NULL:
1229     freetree(tree);
1230     break;
1231   case GEN_TOKEN_DIGIT_DOUBLE:
1232     mbkfree(tree->DATA); // (double*)
1233     freetree(tree);
1234     break;
1235   case GEN_TOKEN_VOIDTOKEN:
1236     freeptype((ptype_list *)tree->DATA);
1237     freetree(tree);
1238     break;
1239   case GEN_TOKEN_VOIDTOKEN_CL:
1240     freechain((chain_list *)tree->DATA);
1241     freetree(tree);
1242     break;
1243   case GEN_TOKEN_VOIDTOKEN_CL_TA:
1244     {
1245       chain_list *cl;
1246       for (cl=(chain_list *)tree->DATA; cl!=NULL; cl=cl->NEXT)
1247          APIFreeTARG((t_arg *)cl->DATA);
1248       freechain((chain_list *)tree->DATA);
1249       freetree(tree);
1250       break;
1251     }
1252   default:
1253     Error_Tree("Free_Tree",tree);
1254     EXIT(2);
1255   }
1256 }
1257
1258
1259 /****************************************************************************/
1260 /*               return 1 if token is met in tree                           */
1261 /****************************************************************************/
1262 extern int SeekToken_Tree(tree,token)
1263    tree_list *tree;
1264    int token;
1265 {
1266   if (!tree) {
1267     return 0;
1268 //    fprintf(stderr,"SeekToken_Tree: NULL pointer\n");
1269     EXIT(1);
1270   }
1271   if (TOKEN(tree)==token) return 1;
1272
1273   switch (TOKEN(tree)) {
1274   /* node of ABL */
1275   case GEN_TOKEN_NODE:
1276     return SeekToken_Tree(tree->DATA,token);
1277     break;
1278   /*fourth class*/
1279   case GEN_TOKEN_FOR:
1280     return SeekToken_Tree(tree->NEXT->NEXT->NEXT->NEXT,token)
1281     || SeekToken_Tree(tree->NEXT->NEXT->NEXT,token)
1282     || SeekToken_Tree(tree->NEXT->NEXT,token)
1283     || SeekToken_Tree(tree->NEXT,token);
1284     break;
1285   /*third class*/
1286   case GEN_TOKEN_ELSE: case '?': case GEN_TOKEN_ENTITY:  case GEN_TOKEN_ARCHITECTURE:
1287   case GEN_TOKEN_COMPONENT: case GEN_TOKEN_MBKFOPEN:
1288     return SeekToken_Tree(tree->NEXT->NEXT->NEXT,token)
1289     || SeekToken_Tree(tree->NEXT->NEXT,token)
1290     || SeekToken_Tree(tree->NEXT,token);
1291     break;
1292   /*binary class*/
1293   case GEN_TOKEN_FPRINTF: case GEN_TOKEN_SPRINTF:  case GEN_TOKEN_BSPRINTF: case'(': case GEN_TOKEN_TO: case GEN_TOKEN_DOWNTO:
1294   case GEN_TOKEN_ACTION: case GEN_TOKEN_EQUI: case GEN_TOKEN_MAP:
1295   case '+': case '-': case '*': case '/': case '%': case '>': case '<':
1296   case '&': case '|': case '^': case GNS_TOKEN_AND: case GEN_TOKEN_OR: case GEN_TOKEN_EG:
1297   case GEN_TOKEN_SUPEG: case GEN_TOKEN_INFEG: case GEN_TOKEN_NOTEG: case GEN_TOKEN_SHR: case GEN_TOKEN_SHL:
1298   case ';': case ',': case GEN_TOKEN_XOR: case GEN_TOKEN_MOD: case GEN_TOKEN_POW:
1299   case '=': case GEN_TOKEN_IF: case GEN_TOKEN_DO: case GEN_TOKEN_WHILE: case GEN_TOKEN_OF: case GEN_TOKEN_FOPEN:  case GEN_TOKEN_FUNCTION:
1300   case GEN_TOKEN_OTHER_TYPES:  case GEN_TOKEN_ARRAY:
1301     return SeekToken_Tree(tree->NEXT->NEXT,token)
1302     || SeekToken_Tree(tree->NEXT,token);
1303     break;
1304   /*unary class*/
1305   case GEN_TOKEN_OPPOSITE: case '~':
1306   case GEN_TOKEN_INC_BEFORE: case GEN_TOKEN_INC_AFTER: case GEN_TOKEN_DEC_BEFORE: case GEN_TOKEN_DEC_AFTER:
1307   case GEN_TOKEN_IN: case GEN_TOKEN_OUT: case GEN_TOKEN_INOUT: case GEN_TOKEN_TRANSCV: case GEN_TOKEN_TRISTATE: case GEN_TOKEN_LINKAGE:
1308   case GEN_TOKEN_NOT: case GEN_TOKEN_GENERIC: case GEN_TOKEN_PORT:
1309   case GEN_TOKEN_EXCLUDE:
1310   case GEN_TOKEN_VARIABLE: case GEN_TOKEN_SIGNAL: case GEN_TOKEN_INTEGER: case GEN_TOKEN_FCLOSE:
1311   case GEN_TOKEN_CHAR: case GEN_TOKEN_FILE: case GEN_TOKEN_REF: case GEN_TOKEN_REF_CHAR: case GEN_TOKEN_REF_FILE:
1312   case GEN_TOKEN_BLOCK: case GEN_TOKEN_EXIT: case GEN_TOKEN_STATIC: case GEN_TOKEN_VOIDTOKEN_D: case GEN_TOKEN_DOUBLE: case GEN_TOKEN_LONG:
1313   case GEN_TOKEN_REF_VOID: case GEN_TOKEN_REF_INT: case GEN_TOKEN_REF_DOUBLE: case GEN_TOKEN_ADR:
1314     return SeekToken_Tree(tree->NEXT,token);
1315     break;
1316   /*terminal*/
1317   case GEN_TOKEN_STRING:
1318   case GEN_TOKEN_STDOUT: case GEN_TOKEN_STDERR: case GEN_TOKEN_IDENT: case GEN_TOKEN_DIGIT: case GEN_TOKEN_NOP: case GEN_TOKEN_LOINS:
1319   case GEN_TOKEN_BREAK: case GEN_TOKEN_RETURN: case GEN_TOKEN_DIGIT_DOUBLE: case GEN_TOKEN_DIGIT_CHAR: case GEN_TOKEN_NULL:
1320     return 0;
1321     break;
1322   default:
1323     Error_Tree("SeekToken_Tree",tree);
1324     EXIT(2);
1325     return 0;
1326   }
1327 }
1328
1329
1330 SymInfoItem *AddSymInfoItem(SymInfoItem *head)
1331 {
1332   SymInfoItem *tmp=(SymInfoItem *)AddHeapItem(&syminfo_heap);
1333   tmp->NEXT=head;
1334   return tmp;
1335 }