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 

    30 void

    31 Py_Exit(int sts)

    32 {

    33 	exit(sts);

    34 }

    35 

    36 int

    37 main(int argc, char **argv)

    38 {

    39 	grammar *g;

    40 	FILE *fp;

    41 	char *filename, *graminit_h, *graminit_c;

    42 	

    43 	if (argc != 4) {

    44 		fprintf(stderr,

    45 			"usage: %s grammar graminit.h graminit.c\n", argv[0]);

    46 		Py_Exit(2);

    47 	}

    48 	filename = argv[1];

    49 	graminit_h = argv[2];

    50 	graminit_c = argv[3];

    51 	g = getgrammar(filename);

    52 	fp = fopen(graminit_c, "w");

    53 	if (fp == NULL) {

    54 		perror(graminit_c);

    55 		Py_Exit(1);

    56 	}

    57 	if (Py_DebugFlag)

    58 		printf("Writing %s ...\n", graminit_c);

    59 	printgrammar(g, fp);

    60 	fclose(fp);

    61 	fp = fopen(graminit_h, "w");

    62 	if (fp == NULL) {

    63 		perror(graminit_h);

    64 		Py_Exit(1);

    65 	}

    66 	if (Py_DebugFlag)

    67 		printf("Writing %s ...\n", graminit_h);

    68 	printnonterminals(g, fp);

    69 	fclose(fp);

    70 	Py_Exit(0);

    71 	return 0; /* Make gcc -Wall happy */

    72 }

    73 

    74 grammar *

    75 getgrammar(char *filename)

    76 {

    77 	FILE *fp;

    78 	node *n;

    79 	grammar *g0, *g;

    80 	perrdetail err;

    81 	

    82 	fp = fopen(filename, "r");

    83 	if (fp == NULL) {

    84 		perror(filename);

    85 		Py_Exit(1);

    86 	}

    87 	g0 = meta_grammar();

    88 	n = PyParser_ParseFile(fp, filename, g0, g0->g_start,

    89 		      (char *)NULL, (char *)NULL, &err);

    90 	fclose(fp);

    91 	if (n == NULL) {

    92 		fprintf(stderr, "Parsing error %d, line %d.\n",

    93 			err.error, err.lineno);

    94 		if (err.text != NULL) {

    95 			size_t i;

    96 			fprintf(stderr, "%s", err.text);

    97 			i = strlen(err.text);

    98 			if (i == 0 || err.text[i-1] != '\n')

    99 				fprintf(stderr, "\n");

   100 			for (i = 0; i < err.offset; i++) {

   101 				if (err.text[i] == '\t')

   102 					putc('\t', stderr);

   103 				else

   104 					putc(' ', stderr);

   105 			}

   106 			fprintf(stderr, "^\n");

   107 			PyObject_FREE(err.text);

   108 		}

   109 		Py_Exit(1);

   110 	}

   111 	g = pgen(n);

   112 	if (g == NULL) {

   113 		printf("Bad grammar.\n");

   114 		Py_Exit(1);

   115 	}

   116 	return g;

   117 }

   118 

   119 /* Can't happen in pgen */

   120 PyObject*

   121 PyErr_Occurred()

   122 {

   123 	return 0;

   124 }

   125 

   126 void

   127 Py_FatalError(const char *msg)

   128 {

   129 	fprintf(stderr, "pgen: FATAL ERROR: %s\n", msg);

   130 	Py_Exit(1);

   131 }

   132 

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

   134 

   135 char *

   136 PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)

   137 {

   138 	size_t n = 1000;

   139 	char *p = (char *)PyMem_MALLOC(n);

   140 	char *q;

   141 	if (p == NULL)

   142 		return NULL;

   143 	fprintf(stderr, "%s", prompt);

   144 	q = fgets(p, n, sys_stdin);

   145 	if (q == NULL) {

   146 		*p = '\0';

   147 		return p;

   148 	}

   149 	n = strlen(p);

   150 	if (n > 0 && p[n-1] != '\n')

   151 		p[n-1] = '\n';

   152 	return (char *)PyMem_REALLOC(p, n+1);

   153 }

   154 

   155 /* No-nonsense fgets */

   156 char *

   157 Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)

   158 {

   159 	return fgets(buf, n, stream);

   160 }

   161 

   162 

   163 #include <stdarg.h>

   164 

   165 void

   166 PySys_WriteStderr(const char *format, ...)

   167 {

   168 	va_list va;

   169 

   170 	va_start(va, format);

   171 	vfprintf(stderr, format, va);

   172 	va_end(va);

   173 }