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 "pgenheaders.h"
  17 #include "grammar.h"
  18 #include "node.h"
  19 #include "parsetok.h"
  20 #include "pgen.h"
  21
  22 int Py_DebugFlag;
  23 int Py_VerboseFlag;
  24
  25 /* Forward */
  26 grammar *getgrammar(char *filename);
  27 #ifdef THINK_C
  28 int main(int, char **);
  29 char *askfile(void);
  30 #endif
  31
  32 void
  33 Py_Exit(int sts)
  34 {
  35         exit(sts);
  36 }
  37
  38 int
  39 main(int argc, char **argv)
  40 {
  41         grammar *g;
  42         FILE *fp;
  43         char *filename, *graminit_h, *graminit_c;
  44
  45 #ifdef THINK_C
  46         filename = askfile();
  47         graminit_h = askfile();
  48         graminit_c = askfile();
  49 #else
  50         if (argc != 4) {
  51                 fprintf(stderr,
  52                         "usage: %s grammar graminit.h graminit.c\n", argv[0]);
  53                 Py_Exit(2);
  54         }
  55         filename = argv[1];
  56         graminit_h = argv[2];
  57         graminit_c = argv[3];
  58 #endif
  59         g = getgrammar(filename);
  60         fp = fopen(graminit_c, "w");
  61         if (fp == NULL) {
  62                 perror(graminit_c);
  63                 Py_Exit(1);
  64         }
  65         printf("Writing %s ...\n", graminit_c);
  66         printgrammar(g, fp);
  67         fclose(fp);
  68         fp = fopen(graminit_h, "w");
  69         if (fp == NULL) {
  70                 perror(graminit_h);
  71                 Py_Exit(1);
  72         }
  73         printf("Writing %s ...\n", graminit_h);
  74         printnonterminals(g, fp);
  75         fclose(fp);
  76         Py_Exit(0);
  77         return 0; /* Make gcc -Wall happy */
  78 }
  79
  80 grammar *
  81 getgrammar(char *filename)
  82 {
  83         FILE *fp;
  84         node *n;
  85         grammar *g0, *g;
  86         perrdetail err;
  87
  88         fp = fopen(filename, "r");
  89         if (fp == NULL) {
  90                 perror(filename);
  91                 Py_Exit(1);
  92         }
  93         g0 = meta_grammar();
  94         n = PyParser_ParseFile(fp, filename, g0, g0->g_start,
  95                       (char *)NULL, (char *)NULL, &err);
  96         fclose(fp);
  97         if (n == NULL) {
  98                 fprintf(stderr, "Parsing error %d, line %d.\n",
  99                         err.error, err.lineno);
 100                 if (err.text != NULL) {
 101                         size_t i;
 102                         fprintf(stderr, "%s", err.text);
 103                         i = strlen(err.text);
 104                         if (i == 0 || err.text[i-1] != '\n')
 105                                 fprintf(stderr, "\n");
 106                         for (i = 0; i < err.offset; i++) {
 107                                 if (err.text[i] == '\t')
 108                                         putc('\t', stderr);
 109                                 else
 110                                         putc(' ', stderr);
 111                         }
 112                         fprintf(stderr, "^\n");
 113                         PyMem_DEL(err.text);
 114                 }
 115                 Py_Exit(1);
 116         }
 117         g = pgen(n);
 118         if (g == NULL) {
 119                 printf("Bad grammar.\n");
 120                 Py_Exit(1);
 121         }
 122         return g;
 123 }
 124
 125 #ifdef THINK_C
 126 char *
 127 askfile(void)
 128 {
 129         char buf[256];
 130         static char name[256];
 131         printf("Input file name: ");
 132         if (fgets(buf, sizeof buf, stdin) == NULL) {
 133                 printf("EOF\n");
 134                 Py_Exit(1);
 135         }
 136         /* XXX The (unsigned char *) case is needed by THINK C 3.0 */
 137         if (sscanf(/*(unsigned char *)*/buf, " %s ", name) != 1) {
 138                 printf("No file\n");
 139                 Py_Exit(1);
 140         }
 141         return name;
 142 }
 143 #endif
 144
 145 void
 146 Py_FatalError(char *msg)
 147 {
 148         fprintf(stderr, "pgen: FATAL ERROR: %s\n", msg);
 149         Py_Exit(1);
 150 }
 151
 152 #ifdef macintosh
 153 /* ARGSUSED */
 154 int
 155 guesstabsize(char *path)
 156 {
 157         return 4;
 158 }
 159 #endif
 160
 161 /* No-nonsense my_readline() for tokenizer.c */
 162
 163 char *
 164 PyOS_Readline(char *prompt)
 165 {
 166         size_t n = 1000;
 167         char *p = PyMem_MALLOC(n);
 168         char *q;
 169         if (p == NULL)
 170                 return NULL;
 171         fprintf(stderr, "%s", prompt);
 172         q = fgets(p, n, stdin);
 173         if (q == NULL) {
 174                 *p = '\0';
 175                 return p;
 176         }
 177         n = strlen(p);
 178         if (n > 0 && p[n-1] != '\n')
 179                 p[n-1] = '\n';
 180         return PyMem_REALLOC(p, n+1);
 181 }
 182
 183 #include <stdarg.h>
 184
 185 void
 186 PySys_WriteStderr(const char *format, ...)
 187 {
 188         va_list va;
 189
 190         va_start(va, format);
 191         vfprintf(stderr, format, va);
 192         va_end(va);
 193 }