Return to main.c CVS log

Up to [Apple XNU] / GNUtools / bison

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

1.1     ! root        1: /* Top level entry point of 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"   /* JF for MAXSHORT */
        !            24: 
        !            25: extern int lineno;
        !            26: extern int verboseflag;
        !            27: 
        !            28: /* Nonzero means failure has been detected; don't write a parser file.  */
        !            29: int failure;
        !            30: 
        !            31: /* The name this program was run with, for messages. */
        !            32: char *program_name;
        !            33: 
        !            34: extern void getargs(), openfiles(), reader(), reduce_grammar();
        !            35: extern void set_derives(), set_nullable(), generate_states();
        !            36: extern void lalr(), initialize_conflicts(), verbose(), terse();
        !            37: extern void output(), done();
        !            38: 
        !            39: 
        !            40: /* VMS complained about using `int'.  */
        !            41: int
        !            42: main(argc, argv)
        !            43: int argc;
        !            44: char *argv[];
        !            45: {
        !            46:   program_name = argv[0];
        !            47:   failure = 0;
        !            48:   lineno = 0;
        !            49:   getargs(argc, argv);
        !            50:   openfiles();
        !            51: 
        !            52:   /* read the input.  Copy some parts of it to fguard, faction, ftable and fattrs.
        !            53:      In file reader.c.
        !            54:      The other parts are recorded in the grammar; see gram.h.  */
        !            55:   reader();
        !            56: 
        !            57:   /* find useless nonterminals and productions and reduce the grammar.  In
        !            58:      file reduce.c */
        !            59:   reduce_grammar();
        !            60: 
        !            61:   /* record other info about the grammar.  In files derives and nullable.  */
        !            62:   set_derives();
        !            63:   set_nullable();
        !            64: 
        !            65:   /* convert to nondeterministic finite state machine.  In file LR0.
        !            66:      See state.h for more info.  */
        !            67:   generate_states();
        !            68: 
        !            69:   /* make it deterministic.  In file lalr.  */
        !            70:   lalr();
        !            71: 
        !            72:   /* Find and record any conflicts: places where one token of lookahead is not
        !            73:      enough to disambiguate the parsing.  In file conflicts.
        !            74:      Currently this does not do anything to resolve them;
        !            75:      the trivial form of conflict resolution that exists is done in output.  */
        !            76:   initialize_conflicts();
        !            77: 
        !            78:   /* print information about results, if requested.  In file print. */
        !            79:   if (verboseflag)
        !            80:     verbose();
        !            81:   else
        !            82:     terse();
        !            83: 
        !            84:   /* output the tables and the parser to ftable.  In file output. */
        !            85:   output();
        !            86:   done(failure);
        !            87: }
        !            88: 
        !            89: /* functions to report errors which prevent a parser from being generated */
        !            90: 
        !            91: void
        !            92: fatal(s)
        !            93: char *s;
        !            94: {
        !            95:   extern char *infile;
        !            96: 
        !            97:   if (infile == 0)
        !            98:     fprintf(stderr, "fatal error: %s\n", s);
        !            99:   else
        !           100:     fprintf(stderr, "\"%s\", line %d: %s\n", infile, lineno, s);
        !           101:   done(1);
        !           102: }
        !           103: 
        !           104: 
        !           105: /* JF changed to accept/deal with variable args.
        !           106:    DO NOT change this to use varargs.  It will appear to work
        !           107:    but will break on systems that don't have the necessary library
        !           108:    functions.  This is the ONLY safe way to write such a function.  */
        !           109: /*VARARGS1*/
        !           110: 
        !           111: void
        !           112: fatals(fmt,x1,x2,x3,x4,x5,x6,x7,x8)
        !           113: char *fmt;
        !           114: {
        !           115:   char buffer[200];
        !           116: 
        !           117:   sprintf(buffer, fmt, x1,x2,x3,x4,x5,x6,x7,x8);
        !           118:   fatal(buffer);
        !           119: }
        !           120: 
        !           121: 
        !           122: void
        !           123: toomany(s)
        !           124: char *s;
        !           125: {
        !           126:   char buffer[200];
        !           127: 
        !           128:        /* JF new msg */
        !           129:   sprintf(buffer, "limit of %d exceeded, too many %s", MAXSHORT, s);
        !           130:   fatal(buffer);
        !           131: }
        !           132: 
        !           133: 
        !           134: void
        !           135: berror(s)
        !           136: char *s;
        !           137: {
        !           138:   fprintf(stderr, "internal error, %s\n", s);
        !           139:   abort();
        !           140: }

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