source: python/vendor/Python-2.6.5/Parser/pgenmain.c

/* Parser generator main program */

/* This expects a filename containing the grammar as argv[1] (UNIX)
   or asks the console for such a file name (THINK C).
   It writes its output on two files in the current directory:
   - "graminit.c" gets the grammar as a bunch of initialized data
   - "graminit.h" gets the grammar's non-terminals as #defines.
   Error messages and status info during the generation process are
   written to stdout, or sometimes to stderr. */

/* XXX TO DO:
   - check for duplicate definitions of names (instead of fatal err)
*/

#include "Python.h"
#include "pgenheaders.h"
#include "grammar.h"
#include "node.h"
#include "parsetok.h"
#include "pgen.h"

int Py_DebugFlag;
int Py_VerboseFlag;
int Py_IgnoreEnvironmentFlag;

/* Forward */
grammar *getgrammar(char *filename);

void
Py_Exit(int sts)
{
        exit(sts);
}

int
main(int argc, char **argv)
{
        grammar *g;
        FILE *fp;
        char *filename, *graminit_h, *graminit_c;
        
        if (argc != 4) {
                fprintf(stderr,
                        "usage: %s grammar graminit.h graminit.c\n", argv[0]);
                Py_Exit(2);
        }
        filename = argv[1];
        graminit_h = argv[2];
        graminit_c = argv[3];
        g = getgrammar(filename);
        fp = fopen(graminit_c, "w");
        if (fp == NULL) {
                perror(graminit_c);
                Py_Exit(1);
        }
        if (Py_DebugFlag)
                printf("Writing %s ...\n", graminit_c);
        printgrammar(g, fp);
        fclose(fp);
        fp = fopen(graminit_h, "w");
        if (fp == NULL) {
                perror(graminit_h);
                Py_Exit(1);
        }
        if (Py_DebugFlag)
                printf("Writing %s ...\n", graminit_h);
        printnonterminals(g, fp);
        fclose(fp);
        Py_Exit(0);
        return 0; /* Make gcc -Wall happy */
}

grammar *
getgrammar(char *filename)
{
        FILE *fp;
        node *n;
        grammar *g0, *g;
        perrdetail err;
        
        fp = fopen(filename, "r");
        if (fp == NULL) {
                perror(filename);
                Py_Exit(1);
        }
        g0 = meta_grammar();
        n = PyParser_ParseFile(fp, filename, g0, g0->g_start,
                      (char *)NULL, (char *)NULL, &err);
        fclose(fp);
        if (n == NULL) {
                fprintf(stderr, "Parsing error %d, line %d.\n",
                        err.error, err.lineno);
                if (err.text != NULL) {
                        size_t i;
                        fprintf(stderr, "%s", err.text);
                        i = strlen(err.text);
                        if (i == 0 || err.text[i-1] != '\n')
                                fprintf(stderr, "\n");
                        for (i = 0; i < err.offset; i++) {
                                if (err.text[i] == '\t')
                                        putc('\t', stderr);
                                else
                                        putc(' ', stderr);
                        }
                        fprintf(stderr, "^\n");
                        PyObject_FREE(err.text);
                }
                Py_Exit(1);
        }
        g = pgen(n);
        if (g == NULL) {
                printf("Bad grammar.\n");
                Py_Exit(1);
        }
        return g;
}

/* Can't happen in pgen */
PyObject*
PyErr_Occurred()
{
        return 0;
}

void
Py_FatalError(const char *msg)
{
        fprintf(stderr, "pgen: FATAL ERROR: %s\n", msg);
        Py_Exit(1);
}

/* No-nonsense my_readline() for tokenizer.c */

char *
PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
{
        size_t n = 1000;
        char *p = (char *)PyMem_MALLOC(n);
        char *q;
        if (p == NULL)
                return NULL;
        fprintf(stderr, "%s", prompt);
        q = fgets(p, n, sys_stdin);
        if (q == NULL) {
                *p = '\0';
                return p;
        }
        n = strlen(p);
        if (n > 0 && p[n-1] != '\n')
                p[n-1] = '\n';
        return (char *)PyMem_REALLOC(p, n+1);
}

/* No-nonsense fgets */
char *
Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
{
        return fgets(buf, n, stream);
}


#include <stdarg.h>

void
PySys_WriteStderr(const char *format, ...)
{
        va_list va;

        va_start(va, format);
        vfprintf(stderr, format, va);
        va_end(va);
}