Return to print.c CVS log

Up to [Apple XNU] / GNUtools / bison

Annotation of GNUtools/bison/print.c, revision 1.1

1.1     ! root        1: /* Print information on generated parser, for bison,
        !             2:    Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of Bison, the GNU Compiler Compiler.
        !             5: 
        !             6: Bison is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 2, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: Bison is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with Bison; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: 
        !            21: #include <stdio.h>
        !            22: #include "system.h"
        !            23: #include "machine.h"
        !            24: #include "new.h"
        !            25: #include "files.h"
        !            26: #include "gram.h"
        !            27: #include "state.h"
        !            28: 
        !            29: 
        !            30: extern char **tags;
        !            31: extern int nstates;
        !            32: extern short *accessing_symbol;
        !            33: extern core **state_table;
        !            34: extern shifts **shift_table;
        !            35: extern errs **err_table;
        !            36: extern reductions **reduction_table;
        !            37: extern char *consistent;
        !            38: extern char any_conflicts;
        !            39: extern char *conflicts;
        !            40: extern int final_state;
        !            41: 
        !            42: extern void conflict_log();
        !            43: extern void verbose_conflict_log();
        !            44: extern void print_reductions();
        !            45: 
        !            46: void print_token();
        !            47: void print_state();
        !            48: void print_core();
        !            49: void print_actions();
        !            50: void print_grammar();
        !            51: 
        !            52: void
        !            53: terse()
        !            54: {
        !            55:   if (any_conflicts)
        !            56:     {
        !            57:       conflict_log();
        !            58:     }
        !            59: }
        !            60: 
        !            61: 
        !            62: void
        !            63: verbose()
        !            64: {
        !            65:   register int i;
        !            66: 
        !            67:   if (any_conflicts)
        !            68:     verbose_conflict_log();
        !            69: 
        !            70:   print_grammar();
        !            71: 
        !            72:   for (i = 0; i < nstates; i++)
        !            73:     {
        !            74:       print_state(i);
        !            75:     }
        !            76: }
        !            77: 
        !            78: 
        !            79: void
        !            80: print_token(extnum, token)
        !            81: int extnum, token;
        !            82: {
        !            83:   fprintf(foutput, " type %d is %s\n", extnum, tags[token]);
        !            84: }
        !            85: 
        !            86: 
        !            87: void
        !            88: print_state(state)
        !            89: int state;
        !            90: {
        !            91:   fprintf(foutput, "\n\nstate %d\n\n", state);
        !            92:   print_core(state);
        !            93:   print_actions(state);
        !            94: }
        !            95: 
        !            96: 
        !            97: void
        !            98: print_core(state)
        !            99: int state;
        !           100: {
        !           101:   register int i;
        !           102:   register int k;
        !           103:   register int rule;
        !           104:   register core *statep;
        !           105:   register short *sp;
        !           106:   register short *sp1;
        !           107: 
        !           108:   statep = state_table[state];
        !           109:   k = statep->nitems;
        !           110: 
        !           111:   if (k == 0) return;
        !           112: 
        !           113:   for (i = 0; i < k; i++)
        !           114:     {
        !           115:       sp1 = sp = ritem + statep->items[i];
        !           116: 
        !           117:       while (*sp > 0)
        !           118:        sp++;
        !           119: 
        !           120:       rule = -(*sp);
        !           121:       fprintf(foutput, "    %s  ->  ", tags[rlhs[rule]]);
        !           122: 
        !           123:       for (sp = ritem + rrhs[rule]; sp < sp1; sp++)
        !           124:        {
        !           125:          fprintf(foutput, "%s ", tags[*sp]);
        !           126:        }
        !           127: 
        !           128:       putc('.', foutput);
        !           129: 
        !           130:       while (*sp > 0)
        !           131:        {
        !           132:          fprintf(foutput, " %s", tags[*sp]);
        !           133:          sp++;
        !           134:        }
        !           135: 
        !           136:       fprintf (foutput, "   (rule %d)", rule);
        !           137:       putc('\n', foutput);
        !           138:     }
        !           139: 
        !           140:   putc('\n', foutput);
        !           141: }
        !           142: 
        !           143: 
        !           144: void
        !           145: print_actions(state)
        !           146: int state;
        !           147: {
        !           148:   register int i;
        !           149:   register int k;
        !           150:   register int state1;
        !           151:   register int symbol;
        !           152:   register shifts *shiftp;
        !           153:   register errs *errp;
        !           154:   register reductions *redp;
        !           155:   register int rule;
        !           156: 
        !           157:   shiftp = shift_table[state];
        !           158:   redp = reduction_table[state];
        !           159:   errp = err_table[state];
        !           160: 
        !           161:   if (!shiftp && !redp)
        !           162:     {
        !           163:       if (final_state == state)
        !           164:        fprintf(foutput, "    $default\taccept\n");
        !           165:       else
        !           166:        fprintf(foutput, "    NO ACTIONS\n");
        !           167:       return;
        !           168:     }
        !           169: 
        !           170:   if (shiftp)
        !           171:     {
        !           172:       k = shiftp->nshifts;
        !           173: 
        !           174:       for (i = 0; i < k; i++)
        !           175:        {
        !           176:          if (! shiftp->shifts[i]) continue;
        !           177:          state1 = shiftp->shifts[i];
        !           178:          symbol = accessing_symbol[state1];
        !           179:          /* The following line used to be turned off.  */
        !           180:          if (ISVAR(symbol)) break;
        !           181:           if (symbol==0)      /* I.e. strcmp(tags[symbol],"$")==0 */
        !           182:             fprintf(foutput, "    $   \tgo to state %d\n", state1);
        !           183:           else
        !           184:             fprintf(foutput, "    %-4s\tshift, and go to state %d\n",
        !           185:                     tags[symbol], state1);
        !           186:        }
        !           187: 
        !           188:       if (i > 0)
        !           189:        putc('\n', foutput);
        !           190:     }
        !           191:   else
        !           192:     {
        !           193:       i = 0;
        !           194:       k = 0;
        !           195:     }
        !           196: 
        !           197:   if (errp)
        !           198:     {
        !           199:       int j, nerrs;
        !           200: 
        !           201:       nerrs = errp->nerrs;
        !           202: 
        !           203:       for (j = 0; j < nerrs; j++)
        !           204:        {
        !           205:          if (! errp->errs[j]) continue;
        !           206:          symbol = errp->errs[j];
        !           207:          fprintf(foutput, "    %-4s\terror (nonassociative)\n", tags[symbol]);
        !           208:        }
        !           209: 
        !           210:       if (j > 0)
        !           211:        putc('\n', foutput);
        !           212:     }
        !           213: 
        !           214:   if (consistent[state] && redp)
        !           215:     {
        !           216:       rule = redp->rules[0];
        !           217:       symbol = rlhs[rule];
        !           218:       fprintf(foutput, "    $default\treduce using rule %d (%s)\n\n",
        !           219:                rule, tags[symbol]);
        !           220:     }
        !           221:   else if (redp)
        !           222:     {
        !           223:       print_reductions(state);
        !           224:     }
        !           225: 
        !           226:   if (i < k)
        !           227:     {
        !           228:       for (; i < k; i++)
        !           229:        {
        !           230:          if (! shiftp->shifts[i]) continue;
        !           231:          state1 = shiftp->shifts[i];
        !           232:          symbol = accessing_symbol[state1];
        !           233:          fprintf(foutput, "    %-4s\tgo to state %d\n", tags[symbol], state1);
        !           234:        }
        !           235: 
        !           236:       putc('\n', foutput);
        !           237:     }
        !           238: }
        !           239: 
        !           240: #define END_TEST(end) \
        !           241:   if (column + strlen(buffer) > (end))                                  \
        !           242:     { fprintf (foutput, "%s\n   ", buffer); column = 3; buffer[0] = 0; } \
        !           243:   else
        !           244: 
        !           245: void
        !           246: print_grammar()
        !           247: {
        !           248:   int i, j;
        !           249:   short* rule;
        !           250:   char buffer[90];
        !           251:   int column = 0;
        !           252: 
        !           253:   /* rule # : LHS -> RHS */
        !           254:   fputs("\nGrammar\n", foutput);
        !           255:   for (i = 1; i <= nrules; i++)
        !           256:     /* Don't print rules disabled in reduce_grammar_tables.  */
        !           257:     if (rlhs[i] >= 0)
        !           258:       {
        !           259:        fprintf(foutput, "rule %-4d %s ->", i, tags[rlhs[i]]);
        !           260:        rule = &ritem[rrhs[i]];
        !           261:        if (*rule > 0)
        !           262:          while (*rule > 0)
        !           263:            fprintf(foutput, " %s", tags[*rule++]);
        !           264:        else
        !           265:          fputs ("              /* empty */", foutput);
        !           266:        putc('\n', foutput);
        !           267:       }
        !           268: 
        !           269:   /* TERMINAL (type #) : rule #s terminal is on RHS */
        !           270:   fputs("\nTerminals, with rules where they appear\n\n", foutput);
        !           271:   fprintf(foutput, "%s (-1)\n", tags[0]);
        !           272:   if (translations)
        !           273:     {
        !           274:       for (i = 0; i <= max_user_token_number; i++)
        !           275:        if (token_translations[i] != 2)
        !           276:          {
        !           277:            buffer[0] = 0;
        !           278:            column = strlen (tags[token_translations[i]]);
        !           279:            fprintf(foutput, "%s", tags[token_translations[i]]);
        !           280:            END_TEST (50);
        !           281:            sprintf (buffer, " (%d)", i);
        !           282: 
        !           283:            for (j = 1; j <= nrules; j++)
        !           284:              {
        !           285:                for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
        !           286:                  if (*rule == token_translations[i])
        !           287:                    {
        !           288:                      END_TEST (65);
        !           289:                      sprintf (buffer + strlen(buffer), " %d", j);
        !           290:                      break;
        !           291:                    }
        !           292:              }
        !           293:            fprintf (foutput, "%s\n", buffer);
        !           294:          }
        !           295:     }
        !           296:   else
        !           297:     for (i = 1; i < ntokens; i++)
        !           298:       {
        !           299:        buffer[0] = 0;
        !           300:        column = strlen (tags[i]);
        !           301:        fprintf(foutput, "%s", tags[i]);
        !           302:        END_TEST (50);
        !           303:        sprintf (buffer, " (%d)", i);
        !           304: 
        !           305:        for (j = 1; j <= nrules; j++)
        !           306:          {
        !           307:            for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
        !           308:              if (*rule == i)
        !           309:                {
        !           310:                  END_TEST (65);
        !           311:                  sprintf (buffer + strlen(buffer), " %d", j);
        !           312:                  break;
        !           313:                }
        !           314:          }
        !           315:        fprintf (foutput, "%s\n", buffer);
        !           316:       }
        !           317: 
        !           318:   fputs("\nNonterminals, with rules where they appear\n\n", foutput);
        !           319:   for (i = ntokens; i <= nsyms - 1; i++)
        !           320:     {
        !           321:       int left_count = 0, right_count = 0;
        !           322: 
        !           323:       for (j = 1; j <= nrules; j++)
        !           324:        {
        !           325:          if (rlhs[j] == i)
        !           326:            left_count++;
        !           327:          for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
        !           328:            if (*rule == i)
        !           329:              {
        !           330:                right_count++;
        !           331:                break;
        !           332:              }
        !           333:        }
        !           334: 
        !           335:       buffer[0] = 0;
        !           336:       fprintf(foutput, "%s", tags[i]);
        !           337:       column = strlen (tags[i]);
        !           338:       sprintf (buffer, " (%d)", i);
        !           339:       END_TEST (0);
        !           340: 
        !           341:       if (left_count > 0)
        !           342:        {
        !           343:          END_TEST (50);
        !           344:          sprintf (buffer + strlen(buffer), " on left:");
        !           345: 
        !           346:          for (j = 1; j <= nrules; j++)
        !           347:            {
        !           348:              END_TEST (65);
        !           349:              if (rlhs[j] == i)
        !           350:                sprintf (buffer + strlen(buffer), " %d", j);
        !           351:            }
        !           352:        }
        !           353: 
        !           354:       if (right_count > 0)
        !           355:        {
        !           356:          if (left_count > 0)
        !           357:            sprintf (buffer + strlen(buffer), ",");
        !           358:          END_TEST (50);
        !           359:          sprintf (buffer + strlen(buffer), " on right:");
        !           360:          for (j = 1; j <= nrules; j++)
        !           361:            {
        !           362:              for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
        !           363:                if (*rule == i)
        !           364:                  {
        !           365:                    END_TEST (65);
        !           366:                    sprintf (buffer + strlen(buffer), " %d", j);
        !           367:                    break;
        !           368:                  }
        !           369:            }
        !           370:        }
        !           371:       fprintf (foutput, "%s\n", buffer);
        !           372:     }
        !           373: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.