Parser/pgenmain.c

   1
   2 /* Parser generator main program */
   3
   4 /* This expects a filename containing the grammar as argv[1] (UNIX)
   5    or asks the console for such a file name (THINK C).
   6    It writes its output on two files in the current directory:
   7    - "graminit.c" gets the grammar as a bunch of initialized data
   8    - "graminit.h" gets the grammar's non-terminals as #defines.
   9    Error messages and status info during the generation process are
  10    written to stdout, or sometimes to stderr. */
  11
  12 /* XXX TO DO:
  13    - check for duplicate definitions of names (instead of fatal err)
  14 */
  15
  16 #include "Python.h"
  17 #include "pgenheaders.h"
  18 #include "grammar.h"
  19 #include "node.h"
  20 #include "parsetok.h"
  21 #include "pgen.h"
  22
  23 int Py_DebugFlag;
  24 int Py_VerboseFlag;
  25 int Py_IgnoreEnvironmentFlag;
  26
  27 /* Forward */
  28 grammar *getgrammar(char *filename);
  29 #ifdef THINK_C
  30 int main(int, char **);
  31 char *askfile(void);
  32 #endif
  33
  34 void
  35 Py_Exit(int sts)
  36 {
  37         exit(sts);
  38 }
  39
  40 int
  41 main(int argc, char **argv)
  42 {
  43         grammar *g;
  44         FILE *fp;
  45         char *filename, *graminit_h, *graminit_c;
  46
  47 #ifdef THINK_C
  48         filename = askfile();
  49         graminit_h = askfile();
  50         graminit_c = askfile();
  51 #else
  52         if (argc != 4) {
  53                 fprintf(stderr,
  54                         "usage: %s grammar graminit.h graminit.c\n", argv[0]);
  55                 Py_Exit(2);
  56         }
  57         filename = argv[1];
  58         graminit_h = argv[2];
  59         graminit_c = argv[3];
  60 #endif
  61         g = getgrammar(filename);
  62         fp = fopen(graminit_c, "w");
  63         if (fp == NULL) {
  64                 perror(graminit_c);
  65                 Py_Exit(1);
  66         }
  67         if (Py_DebugFlag)
  68                 printf("Writing %s ...\n", graminit_c);
  69         printgrammar(g, fp);
  70         fclose(fp);
  71         fp = fopen(graminit_h, "w");
  72         if (fp == NULL) {
  73                 perror(graminit_h);
  74                 Py_Exit(1);
  75         }
  76         if (Py_DebugFlag)
  77                 printf("Writing %s ...\n", graminit_h);
  78         printnonterminals(g, fp);
  79         fclose(fp);
  80         Py_Exit(0);
  81         return 0; /* Make gcc -Wall happy */
  82 }
  83
  84 grammar *
  85 getgrammar(char *filename)
  86 {
  87         FILE *fp;
  88         node *n;
  89         grammar *g0, *g;
  90         perrdetail err;
  91
  92         fp = fopen(filename, "r");
  93         if (fp == NULL) {
  94                 perror(filename);
  95                 Py_Exit(1);
  96         }
  97         g0 = meta_grammar();
  98         n = PyParser_ParseFile(fp, filename, g0, g0->g_start,
  99                       (char *)NULL, (char *)NULL, &err);
 100         fclose(fp);
 101         if (n == NULL) {
 102                 fprintf(stderr, "Parsing error %d, line %d.\n",
 103                         err.error, err.lineno);
 104                 if (err.text != NULL) {
 105                         size_t i;
 106                         fprintf(stderr, "%s", err.text);
 107                         i = strlen(err.text);
 108                         if (i == 0 || err.text[i-1] != '\n')
 109                                 fprintf(stderr, "\n");
 110                         for (i = 0; i < err.offset; i++) {
 111                                 if (err.text[i] == '\t')
 112                                         putc('\t', stderr);
 113                                 else
 114                                         putc(' ', stderr);
 115                         }
 116                         fprintf(stderr, "^\n");
 117                         PyMem_DEL(err.text);
 118                 }
 119                 Py_Exit(1);
 120         }
 121         g = pgen(n);
 122         if (g == NULL) {
 123                 printf("Bad grammar.\n");
 124                 Py_Exit(1);
 125         }
 126         return g;
 127 }
 128
 129 #ifdef THINK_C
 130 char *
 131 askfile(void)
 132 {
 133         char buf[256];
 134         static char name[256];
 135         printf("Input file name: ");
 136         if (fgets(buf, sizeof buf, stdin) == NULL) {
 137                 printf("EOF\n");
 138                 Py_Exit(1);
 139         }
 140         /* XXX The (unsigned char *) case is needed by THINK C 3.0 */
 141         if (sscanf(/*(unsigned char *)*/buf, " %s ", name) != 1) {
 142                 printf("No file\n");
 143                 Py_Exit(1);
 144         }
 145         return name;
 146 }
 147 #endif
 148
 149 void
 150 Py_FatalError(const char *msg)
 151 {
 152         fprintf(stderr, "pgen: FATAL ERROR: %s\n", msg);
 153         Py_Exit(1);
 154 }
 155
 156 #ifdef macintosh
 157 /* ARGSUSED */
 158 int
 159 guesstabsize(char *path)
 160 {
 161         return 4;
 162 }
 163 #endif
 164
 165 /* No-nonsense my_readline() for tokenizer.c */
 166
 167 char *
 168 PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 169 {
 170         size_t n = 1000;
 171         char *p = PyMem_MALLOC(n);
 172         char *q;
 173         if (p == NULL)
 174                 return NULL;
 175         fprintf(stderr, "%s", prompt);
 176         q = fgets(p, n, sys_stdin);
 177         if (q == NULL) {
 178                 *p = '\0';
 179                 return p;
 180         }
 181         n = strlen(p);
 182         if (n > 0 && p[n-1] != '\n')
 183                 p[n-1] = '\n';
 184         return PyMem_REALLOC(p, n+1);
 185 }
 186
 187 #ifdef WITH_UNIVERSAL_NEWLINES
 188 /* No-nonsense fgets */
 189 char *
 190 Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
 191 {
 192         return fgets(buf, n, stream);
 193 }
 194 #endif
 195
 196
 197 #include <stdarg.h>
 198
 199 void
 200 PySys_WriteStderr(const char *format, ...)
 201 {
 202         va_list va;
 203
 204         va_start(va, format);
 205         vfprintf(stderr, format, va);
 206         va_end(va);
 207 }