BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c

   1 /*
   2  * egman.c
   3  *
   4  * SOFTWARE RIGHTS
   5  *
   6  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
   7  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
   8  * company may do whatever they wish with source code distributed with
   9  * PCCTS or the code generated by PCCTS, including the incorporation of
  10  * PCCTS, or its output, into commerical software.
  11  *
  12  * We encourage users to develop software with PCCTS.  However, we do ask
  13  * that credit is given to us for developing PCCTS.  By "credit",
  14  * we mean that if you incorporate our source code into one of your
  15  * programs (commercial product, research project, or otherwise) that you
  16  * acknowledge this fact somewhere in the documentation, research report,
  17  * etc...  If you like PCCTS and have developed a nice tool with the
  18  * output, please mention that you developed it using PCCTS.  In
  19  * addition, we ask that this header remain intact in our source code.
  20  * As long as these guidelines are kept, we expect to continue enhancing
  21  * this system and expect to make other tools available as they are
  22  * completed.
  23  *
  24  * ANTLR 1.33MR10
  25  * 2001
  26  *
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31
  32 #include "set.h"
  33 #include "syn.h"
  34 #include "hash.h"
  35 #include "generic.h"
  36 #include "proto.h"
  37
  38 static ExceptionGroup **egArray=NULL;   /* ExceptionGroup by BlkLevel */
  39 static LabelEntry     **leArray=NULL;   /* LabelEntry by BlkLevel     */
  40 static Junction       **altArray=NULL;  /* start of alternates        */
  41 static int              arraySize=0;
  42 static int              highWater=0;
  43 static ExceptionGroup *lastEG=NULL;     /* used in altFixup()         */
  44 static int             lastBlkLevel=0;  /* used in altFixup()         */
  45
  46 #ifdef __USE_PROTOS
  47 static void arrayCheck(void);
  48 #else
  49 static void arrayCheck();
  50 #endif
  51
  52 /* Called to add an exception group for an alternative EG */
  53
  54 #ifdef __USE_PROTOS
  55 void egAdd(ExceptionGroup * eg)
  56 #else
  57 void egAdd(eg)
  58 ExceptionGroup *eg;
  59 #endif
  60 {
  61   int               i;
  62
  63   ExceptionGroup    *nextEG;
  64   ExceptionGroup    *innerEG;
  65
  66   LabelEntry        *nextLE;
  67   LabelEntry        *innerLE;
  68
  69   Junction          *nextAlt;
  70   Junction          *innerAlt;
  71
  72   lastEG=eg;
  73   lastBlkLevel=BlkLevel;
  74
  75   arrayCheck();
  76   eg->pendingLink=egArray[BlkLevel];
  77   egArray[BlkLevel]=eg;
  78
  79   /* EG for alternates already have their altID filled in      */
  80
  81   for (i=BlkLevel+1; i<=highWater ; i++) {
  82     for (innerEG=egArray[i]; innerEG != NULL ; innerEG=nextEG) {
  83       nextEG=innerEG->pendingLink;
  84       innerEG->pendingLink=NULL;
  85       innerEG->outerEG=eg;
  86     };
  87     egArray[i]=NULL;
  88   };
  89
  90   /*
  91    *  for patching up the LabelEntry you might use an EG for the
  92    *  current alternative - unlike patching up an alternative EG
  93    *    i.e. start the loop at BlkLevel rather than (BlkLevel+1)
  94    *  fill it in only if the EG and the LE are for the very
  95    *    same alternative if they're at the same BlkLevel
  96    *  it's easier to leave the LE on this list (filled in) rather than
  97    *    trying to selectively remove it.  It will eventually be
  98    *    removed anyway when the BlkLevel gets small enough.
  99    */
 100
 101   for (i=BlkLevel; i<=highWater ; i++) {
 102     for (innerLE=leArray[i]; innerLE != NULL ; innerLE=nextLE) {
 103       nextLE=innerLE->pendingLink;
 104       if (BlkLevel != i ||
 105         innerLE->curAltNum == CurAltNum_array[BlkLevel]) {
 106         if (innerLE->outerEG == NULL) {
 107           innerLE->outerEG=eg;
 108         };
 109       };
 110     };
 111     if (BlkLevel != i) leArray[i]=NULL;
 112   };
 113
 114 /*
 115  * For the start of alternatives it is necessary to make a
 116  * distinction between the exception group for the current
 117  * alternative and the "fallback" EG for the block which
 118  * contains the alternative
 119  *
 120  * The fallback outerEG is used to handle the case where
 121  * no alternative of a block matches.  In that case the
 122  * signal is "NoViableAlt" (or "NoSemViableAlt" and the
 123  * generator needs the EG of the block CONTAINING the
 124  * current one.
 125  *
 126  *      rule: ( ( ( a
 127  *                | b
 128  *                )
 129  *              | c
 130  *              )
 131  *            | d
 132  *            );
 133  */
 134
 135   for (i=BlkLevel; i <= highWater ; i++) {
 136     for (innerAlt=altArray[i]; innerAlt != NULL ; innerAlt=nextAlt) {
 137       nextAlt=innerAlt->pendingLink;
 138
 139       /*  first fill in the EG for the current alternative         */
 140       /*  but leave it on the list in order to get the fallback EG */
 141       /*  if the EG is at the same LEVEL as the alternative then   */
 142       /*    fill it in only if in the very same alternative        */
 143       /*                                                           */
 144       /*        rule: ( a                                          */
 145       /*              | b                                          */
 146       /*              | c  exception ...                           */
 147       /*              )                                            */
 148       /*                                                           */
 149       /*  if the EG is outside the alternative (e.g. BlkLevel < i) */
 150       /*    then it doesn't matter about the alternative           */
 151       /*                                                           */
 152       /*        rule: ( a                                          */
 153       /*              | b                                          */
 154       /*              | c                                          */
 155       /*              )   exception ...                            */
 156       /*                                                           */
 157
 158 #if 0
 159       printf("BlkLevel=%d i=%d altnum=%d CurAltNum=%d altID=%s\n",
 160         BlkLevel,i,innerAlt->curAltNum,CurAltNum_array[BlkLevel],eg->altID);
 161 #endif
 162       if (BlkLevel != i ||
 163           innerAlt->curAltNum == CurAltNum_array[BlkLevel]) {
 164         if (innerAlt->exception_label == NULL) {
 165           innerAlt->exception_label=eg->altID;
 166         };
 167       };
 168
 169       /*  ocurs at a later pass then for the exception_label       */
 170       /*  if an outerEG has been found then fill in the outer EG   */
 171       /*  remove if from the list when the BlkLevel gets smaller   */
 172
 173       if (BlkLevel != i) {
 174         if (innerAlt->outerEG == NULL) {
 175           innerAlt->outerEG=eg;
 176         };
 177       };
 178     };
 179     if (BlkLevel != i) altArray[i]=NULL;
 180   };
 181 }
 182
 183 #ifdef __USE_PROTOS
 184 void leAdd(LabelEntry * le)
 185 #else
 186 void leAdd(le)
 187 LabelEntry *le;
 188 #endif
 189
 190 {
 191   arrayCheck();
 192   le->pendingLink=leArray[BlkLevel];
 193   le->curAltNum=CurAltNum_array[BlkLevel];
 194   leArray[BlkLevel]=le;
 195 }
 196
 197 #ifdef __USE_PROTOS
 198 void altAdd(Junction *alt)
 199 #else
 200 void altAdd(alt)
 201 Junction *alt;
 202 #endif
 203
 204 {
 205   arrayCheck();
 206 #if 0
 207   printf("BlkLevel=%d CurAltNum=%d\n",
 208             BlkLevel,CurAltNum_array[BlkLevel]);
 209 #endif
 210   alt->curAltNum=CurAltNum_array[BlkLevel];
 211   alt->pendingLink=altArray[BlkLevel];
 212   altArray[BlkLevel]=alt;
 213 }
 214
 215 static void
 216 #ifdef __USE_PROTOS
 217 arrayCheck(void)
 218 #else
 219 arrayCheck()
 220 #endif
 221 {
 222   ExceptionGroup    **egArrayNew;
 223   LabelEntry        **leArrayNew;
 224   Junction          **altArrayNew;
 225   int               arraySizeNew;
 226   int               i;
 227
 228   if (BlkLevel > highWater) highWater=BlkLevel;
 229
 230   if (BlkLevel >= arraySize) {
 231     arraySizeNew=BlkLevel+5;    /* MR20 */
 232     egArrayNew=(ExceptionGroup **)
 233         calloc(arraySizeNew,sizeof(ExceptionGroup *));
 234     leArrayNew=(LabelEntry **)
 235         calloc(arraySizeNew,sizeof(LabelEntry *));
 236     altArrayNew=(Junction **)
 237         calloc(arraySizeNew,sizeof(Junction *));
 238     for (i=0; i<arraySize ; i++) {
 239       egArrayNew[i]=egArray[i];
 240       leArrayNew[i]=leArray[i];
 241       altArrayNew[i]=altArray[i];
 242     };
 243     arraySize=arraySizeNew;
 244     if (egArray != NULL) free( (char *) egArray);
 245     if (leArray != NULL) free( (char *) leArray);
 246     if (altArray != NULL) free( (char *) altArray);
 247     egArray=egArrayNew;
 248     leArray=leArrayNew;
 249     altArray=altArrayNew;
 250   };
 251 }
 252
 253 /* always call leFixup() BEFORE egFixup() */
 254
 255 void
 256 #ifdef __USE_PROTOS
 257 egFixup(void)
 258 #else
 259 egFixup()
 260 #endif
 261 {
 262   int               i;
 263   ExceptionGroup    *nextEG;
 264   ExceptionGroup    *innerEG;
 265
 266   for (i=1; i<=highWater ; i++) {
 267     for (innerEG=egArray[i]; innerEG != NULL ; innerEG=nextEG) {
 268       nextEG=innerEG->pendingLink;
 269       innerEG->pendingLink=NULL;
 270     };
 271     egArray[i]=NULL;
 272   };
 273   lastEG=NULL;
 274   lastBlkLevel=0;
 275 }
 276
 277 /* always call leFixup() BEFORE egFixup() */
 278
 279 #ifdef __USE_PROTOS
 280 void leFixup(void)
 281 #else
 282 void leFixup()
 283 #endif
 284 {
 285
 286   int               i;
 287   LabelEntry        *nextLE;
 288   LabelEntry        *innerLE;
 289
 290   for (i=BlkLevel; i<=highWater ; i++) {
 291     for (innerLE=leArray[i]; innerLE != NULL ; innerLE=nextLE) {
 292       nextLE=innerLE->pendingLink;
 293       innerLE->pendingLink=NULL;
 294     };
 295     leArray[i]=NULL;
 296   };
 297 }
 298
 299 /* always call altFixup() BEFORE egFixup() */
 300
 301 #ifdef __USE_PROTOS
 302 void altFixup(void)
 303 #else
 304 void altFixup()
 305 #endif
 306 {
 307
 308   int               i;
 309   Junction          *nextAlt;
 310   Junction          *innerAlt;
 311
 312   for (i=BlkLevel; i<=highWater ; i++) {
 313     for (innerAlt=altArray[i]; innerAlt != NULL ; innerAlt=nextAlt) {
 314
 315       /*  if an outerEG has been found then fill in the outer EG   */
 316
 317       if (lastBlkLevel <= i) {
 318         if (innerAlt->outerEG == NULL) {
 319           innerAlt->outerEG=lastEG;
 320         };
 321       };
 322       nextAlt=innerAlt->pendingLink;
 323       innerAlt->pendingLink=NULL;
 324     };
 325     altArray[i]=NULL;
 326   };
 327 }
 328