1 
2 /* Grammar implementation */
3 
4 #include "Python.h"
5 #include "pgenheaders.h"
6 
7 #include <ctype.h>
8 
9 #include "token.h"
10 #include "grammar.h"
11 
12 #ifdef RISCOS
13 #include <unixlib.h>
14 #endif
15 
16 extern int Py_DebugFlag;
17 
18 grammar *
newgrammar(int start)19 newgrammar(int start)
20 {
21     grammar *g;
22 
23     g = (grammar *)PyObject_MALLOC(sizeof(grammar));
24     if (g == NULL)
25         Py_FatalError("no mem for new grammar");
26     g->g_ndfas = 0;
27     g->g_dfa = NULL;
28     g->g_start = start;
29     g->g_ll.ll_nlabels = 0;
30     g->g_ll.ll_label = NULL;
31     g->g_accel = 0;
32     return g;
33 }
34 
35 dfa *
adddfa(grammar * g,int type,char * name)36 adddfa(grammar *g, int type, char *name)
37 {
38     dfa *d;
39 
40     g->g_dfa = (dfa *)PyObject_REALLOC(g->g_dfa,
41                                         sizeof(dfa) * (g->g_ndfas + 1));
42     if (g->g_dfa == NULL)
43         Py_FatalError("no mem to resize dfa in adddfa");
44     d = &g->g_dfa[g->g_ndfas++];
45     d->d_type = type;
46     d->d_name = strdup(name);
47     d->d_nstates = 0;
48     d->d_state = NULL;
49     d->d_initial = -1;
50     d->d_first = NULL;
51     return d; /* Only use while fresh! */
52 }
53 
54 int
addstate(dfa * d)55 addstate(dfa *d)
56 {
57     state *s;
58 
59     d->d_state = (state *)PyObject_REALLOC(d->d_state,
60                                   sizeof(state) * (d->d_nstates + 1));
61     if (d->d_state == NULL)
62         Py_FatalError("no mem to resize state in addstate");
63     s = &d->d_state[d->d_nstates++];
64     s->s_narcs = 0;
65     s->s_arc = NULL;
66     s->s_lower = 0;
67     s->s_upper = 0;
68     s->s_accel = NULL;
69     s->s_accept = 0;
70     return s - d->d_state;
71 }
72 
73 void
addarc(dfa * d,int from,int to,int lbl)74 addarc(dfa *d, int from, int to, int lbl)
75 {
76     state *s;
77     arc *a;
78 
79     assert(0 <= from && from < d->d_nstates);
80     assert(0 <= to && to < d->d_nstates);
81 
82     s = &d->d_state[from];
83     s->s_arc = (arc *)PyObject_REALLOC(s->s_arc, sizeof(arc) * (s->s_narcs + 1));
84     if (s->s_arc == NULL)
85         Py_FatalError("no mem to resize arc list in addarc");
86     a = &s->s_arc[s->s_narcs++];
87     a->a_lbl = lbl;
88     a->a_arrow = to;
89 }
90 
91 int
addlabel(labellist * ll,int type,char * str)92 addlabel(labellist *ll, int type, char *str)
93 {
94     int i;
95     label *lb;
96 
97     for (i = 0; i < ll->ll_nlabels; i++) {
98         if (ll->ll_label[i].lb_type == type &&
99             strcmp(ll->ll_label[i].lb_str, str) == 0)
100             return i;
101     }
102     ll->ll_label = (label *)PyObject_REALLOC(ll->ll_label,
103                                     sizeof(label) * (ll->ll_nlabels + 1));
104     if (ll->ll_label == NULL)
105         Py_FatalError("no mem to resize labellist in addlabel");
106     lb = &ll->ll_label[ll->ll_nlabels++];
107     lb->lb_type = type;
108     lb->lb_str = strdup(str);
109     if (Py_DebugFlag)
110         printf("Label @ %8p, %d: %s\n", ll, ll->ll_nlabels,
111                PyGrammar_LabelRepr(lb));
112     return lb - ll->ll_label;
113 }
114 
115 /* Same, but rather dies than adds */
116 
117 int
findlabel(labellist * ll,int type,char * str)118 findlabel(labellist *ll, int type, char *str)
119 {
120     int i;
121 
122     for (i = 0; i < ll->ll_nlabels; i++) {
123         if (ll->ll_label[i].lb_type == type /*&&
124             strcmp(ll->ll_label[i].lb_str, str) == 0*/)
125             return i;
126     }
127     fprintf(stderr, "Label %d/'%s' not found\n", type, str);
128     Py_FatalError("grammar.c:findlabel()");
129     return 0; /* Make gcc -Wall happy */
130 }
131 
132 /* Forward */
133 static void translabel(grammar *, label *);
134 
135 void
translatelabels(grammar * g)136 translatelabels(grammar *g)
137 {
138     int i;
139 
140 #ifdef Py_DEBUG
141     printf("Translating labels ...\n");
142 #endif
143     /* Don't translate EMPTY */
144     for (i = EMPTY+1; i < g->g_ll.ll_nlabels; i++)
145         translabel(g, &g->g_ll.ll_label[i]);
146 }
147 
148 static void
translabel(grammar * g,label * lb)149 translabel(grammar *g, label *lb)
150 {
151     int i;
152 
153     if (Py_DebugFlag)
154         printf("Translating label %s ...\n", PyGrammar_LabelRepr(lb));
155 
156     if (lb->lb_type == NAME) {
157         for (i = 0; i < g->g_ndfas; i++) {
158             if (strcmp(lb->lb_str, g->g_dfa[i].d_name) == 0) {
159                 if (Py_DebugFlag)
160                     printf(
161                         "Label %s is non-terminal %d.\n",
162                         lb->lb_str,
163                         g->g_dfa[i].d_type);
164                 lb->lb_type = g->g_dfa[i].d_type;
165                 free(lb->lb_str);
166                 lb->lb_str = NULL;
167                 return;
168             }
169         }
170         for (i = 0; i < (int)N_TOKENS; i++) {
171             if (strcmp(lb->lb_str, _PyParser_TokenNames[i]) == 0) {
172                 if (Py_DebugFlag)
173                     printf("Label %s is terminal %d.\n",
174                         lb->lb_str, i);
175                 lb->lb_type = i;
176                 free(lb->lb_str);
177                 lb->lb_str = NULL;
178                 return;
179             }
180         }
181         printf("Can't translate NAME label '%s'\n", lb->lb_str);
182         return;
183     }
184 
185     if (lb->lb_type == STRING) {
186         if (isalpha(Py_CHARMASK(lb->lb_str[1])) ||
187             lb->lb_str[1] == '_') {
188             char *p;
189             char *src;
190             char *dest;
191             size_t name_len;
192             if (Py_DebugFlag)
193                 printf("Label %s is a keyword\n", lb->lb_str);
194             lb->lb_type = NAME;
195             src = lb->lb_str + 1;
196             p = strchr(src, '\'');
197             if (p)
198                 name_len = p - src;
199             else
200                 name_len = strlen(src);
201             dest = (char *)malloc(name_len + 1);
202             if (!dest) {
203                 printf("Can't alloc dest '%s'\n", src);
204                 return;
205             }
206             strncpy(dest, src, name_len);
207             dest[name_len] = '\0';
208             free(lb->lb_str);
209             lb->lb_str = dest;
210         }
211         else if (lb->lb_str[2] == lb->lb_str[0]) {
212             int type = (int) PyToken_OneChar(lb->lb_str[1]);
213             if (type != OP) {
214                 lb->lb_type = type;
215                 free(lb->lb_str);
216                 lb->lb_str = NULL;
217             }
218             else
219                 printf("Unknown OP label %s\n",
220                     lb->lb_str);
221         }
222         else if (lb->lb_str[2] && lb->lb_str[3] == lb->lb_str[0]) {
223             int type = (int) PyToken_TwoChars(lb->lb_str[1],
224                                        lb->lb_str[2]);
225             if (type != OP) {
226                 lb->lb_type = type;
227                 free(lb->lb_str);
228                 lb->lb_str = NULL;
229             }
230             else
231                 printf("Unknown OP label %s\n",
232                     lb->lb_str);
233         }
234         else if (lb->lb_str[2] && lb->lb_str[3] && lb->lb_str[4] == lb->lb_str[0]) {
235             int type = (int) PyToken_ThreeChars(lb->lb_str[1],
236                                                 lb->lb_str[2],
237                                                 lb->lb_str[3]);
238             if (type != OP) {
239                 lb->lb_type = type;
240                 free(lb->lb_str);
241                 lb->lb_str = NULL;
242             }
243             else
244                 printf("Unknown OP label %s\n",
245                     lb->lb_str);
246         }
247         else
248             printf("Can't translate STRING label %s\n",
249                 lb->lb_str);
250     }
251     else
252         printf("Can't translate label '%s'\n",
253                PyGrammar_LabelRepr(lb));
254 }
255