Home | History | Annotate | Download | only in Parser
      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 *
     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 *
     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
     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
     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
     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
    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
    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
    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