mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 19:43:32 +00:00
9b29358511
Status lines for Emacs and Vim have been added to Python sources so they'll be easier to edit using Python's preferred coding style. Some DNS helper functions have been broken up into multiple files. It's nice to have one function per file whenever possible, since that way we don't need -ffunction-sections. Another reason it's good to have small source files, is because the build will be enforcing resource limits on compilation and testing soon.
275 lines
8.4 KiB
C
275 lines
8.4 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Python 3 │
|
|
│ https://docs.python.org/3/license.html │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "third_party/python/Include/grammar.h"
|
|
#include "third_party/python/Include/objimpl.h"
|
|
#include "third_party/python/Include/pgenheaders.h"
|
|
#include "third_party/python/Include/pyerrors.h"
|
|
#include "third_party/python/Include/token.h"
|
|
/* clang-format off */
|
|
|
|
extern int Py_DebugFlag;
|
|
|
|
grammar *
|
|
newgrammar(int start)
|
|
{
|
|
grammar *g;
|
|
|
|
g = (grammar *)PyObject_MALLOC(sizeof(grammar));
|
|
if (g == NULL)
|
|
Py_FatalError("no mem for new grammar");
|
|
g->g_ndfas = 0;
|
|
g->g_dfa = NULL;
|
|
g->g_start = start;
|
|
g->g_ll.ll_nlabels = 0;
|
|
g->g_ll.ll_label = NULL;
|
|
g->g_accel = 0;
|
|
return g;
|
|
}
|
|
|
|
void
|
|
freegrammar(grammar *g)
|
|
{
|
|
int i;
|
|
for (i = 0; i < g->g_ndfas; i++) {
|
|
free(g->g_dfa[i].d_name);
|
|
for (int j = 0; j < g->g_dfa[i].d_nstates; j++)
|
|
PyObject_FREE(g->g_dfa[i].d_state[j].s_arc);
|
|
PyObject_FREE(g->g_dfa[i].d_state);
|
|
}
|
|
PyObject_FREE(g->g_dfa);
|
|
for (i = 0; i < g->g_ll.ll_nlabels; i++)
|
|
free(g->g_ll.ll_label[i].lb_str);
|
|
PyObject_FREE(g->g_ll.ll_label);
|
|
PyObject_FREE(g);
|
|
}
|
|
|
|
dfa *
|
|
adddfa(grammar *g, int type, const char *name)
|
|
{
|
|
dfa *d;
|
|
|
|
g->g_dfa = (dfa *)PyObject_REALLOC(g->g_dfa,
|
|
sizeof(dfa) * (g->g_ndfas + 1));
|
|
if (g->g_dfa == NULL)
|
|
Py_FatalError("no mem to resize dfa in adddfa");
|
|
d = &g->g_dfa[g->g_ndfas++];
|
|
d->d_type = type;
|
|
d->d_name = strdup(name);
|
|
d->d_nstates = 0;
|
|
d->d_state = NULL;
|
|
d->d_initial = -1;
|
|
d->d_first = NULL;
|
|
return d; /* Only use while fresh! */
|
|
}
|
|
|
|
int
|
|
addstate(dfa *d)
|
|
{
|
|
state *s;
|
|
|
|
d->d_state = (state *)PyObject_REALLOC(d->d_state,
|
|
sizeof(state) * (d->d_nstates + 1));
|
|
if (d->d_state == NULL)
|
|
Py_FatalError("no mem to resize state in addstate");
|
|
s = &d->d_state[d->d_nstates++];
|
|
s->s_narcs = 0;
|
|
s->s_arc = NULL;
|
|
s->s_lower = 0;
|
|
s->s_upper = 0;
|
|
s->s_accel = NULL;
|
|
s->s_accept = 0;
|
|
return Py_SAFE_DOWNCAST(s - d->d_state, intptr_t, int);
|
|
}
|
|
|
|
void
|
|
addarc(dfa *d, int from, int to, int lbl)
|
|
{
|
|
state *s;
|
|
arc *a;
|
|
|
|
assert(0 <= from && from < d->d_nstates);
|
|
assert(0 <= to && to < d->d_nstates);
|
|
|
|
s = &d->d_state[from];
|
|
s->s_arc = (arc *)PyObject_REALLOC(s->s_arc, sizeof(arc) * (s->s_narcs + 1));
|
|
if (s->s_arc == NULL)
|
|
Py_FatalError("no mem to resize arc list in addarc");
|
|
a = &s->s_arc[s->s_narcs++];
|
|
a->a_lbl = lbl;
|
|
a->a_arrow = to;
|
|
}
|
|
|
|
int
|
|
addlabel(labellist *ll, int type, const char *str)
|
|
{
|
|
int i;
|
|
label *lb;
|
|
|
|
for (i = 0; i < ll->ll_nlabels; i++) {
|
|
if (ll->ll_label[i].lb_type == type &&
|
|
strcmp(ll->ll_label[i].lb_str, str) == 0)
|
|
return i;
|
|
}
|
|
ll->ll_label = (label *)PyObject_REALLOC(ll->ll_label,
|
|
sizeof(label) * (ll->ll_nlabels + 1));
|
|
if (ll->ll_label == NULL)
|
|
Py_FatalError("no mem to resize labellist in addlabel");
|
|
lb = &ll->ll_label[ll->ll_nlabels++];
|
|
lb->lb_type = type;
|
|
lb->lb_str = strdup(str);
|
|
if (Py_DebugFlag)
|
|
printf("Label @ %8p, %d: %s\n", ll, ll->ll_nlabels,
|
|
PyGrammar_LabelRepr(lb));
|
|
return Py_SAFE_DOWNCAST(lb - ll->ll_label, intptr_t, int);
|
|
}
|
|
|
|
/* Same, but rather dies than adds */
|
|
|
|
int
|
|
findlabel(labellist *ll, int type, const char *str)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ll->ll_nlabels; i++) {
|
|
if (ll->ll_label[i].lb_type == type /*&&
|
|
strcmp(ll->ll_label[i].lb_str, str) == 0*/)
|
|
return i;
|
|
}
|
|
fprintf(stderr, "Label %d/'%s' not found\n", type, str);
|
|
Py_FatalError("grammar.c:findlabel()");
|
|
|
|
/* Py_FatalError() is declared with __attribute__((__noreturn__)).
|
|
GCC emits a warning without "return 0;" (compiler bug!), but Clang is
|
|
smarter and emits a warning on the return... */
|
|
#ifndef __clang__
|
|
return 0; /* Make gcc -Wall happy */
|
|
#endif
|
|
}
|
|
|
|
/* Forward */
|
|
static void translabel(grammar *, label *);
|
|
|
|
void
|
|
translatelabels(grammar *g)
|
|
{
|
|
int i;
|
|
|
|
#ifdef Py_DEBUG
|
|
printf("Translating labels ...\n");
|
|
#endif
|
|
/* Don't translate EMPTY */
|
|
for (i = EMPTY+1; i < g->g_ll.ll_nlabels; i++)
|
|
translabel(g, &g->g_ll.ll_label[i]);
|
|
}
|
|
|
|
static void
|
|
translabel(grammar *g, label *lb)
|
|
{
|
|
int i;
|
|
|
|
if (Py_DebugFlag)
|
|
printf("Translating label %s ...\n", PyGrammar_LabelRepr(lb));
|
|
|
|
if (lb->lb_type == NAME) {
|
|
for (i = 0; i < g->g_ndfas; i++) {
|
|
if (strcmp(lb->lb_str, g->g_dfa[i].d_name) == 0) {
|
|
if (Py_DebugFlag)
|
|
printf(
|
|
"Label %s is non-terminal %d.\n",
|
|
lb->lb_str,
|
|
g->g_dfa[i].d_type);
|
|
lb->lb_type = g->g_dfa[i].d_type;
|
|
free(lb->lb_str);
|
|
lb->lb_str = NULL;
|
|
return;
|
|
}
|
|
}
|
|
for (i = 0; i < (int)N_TOKENS; i++) {
|
|
if (strcmp(lb->lb_str, _PyParser_TokenNames[i]) == 0) {
|
|
if (Py_DebugFlag)
|
|
printf("Label %s is terminal %d.\n",
|
|
lb->lb_str, i);
|
|
lb->lb_type = i;
|
|
free(lb->lb_str);
|
|
lb->lb_str = NULL;
|
|
return;
|
|
}
|
|
}
|
|
printf("Can't translate NAME label '%s'\n", lb->lb_str);
|
|
return;
|
|
}
|
|
|
|
if (lb->lb_type == STRING) {
|
|
if (isalpha(Py_CHARMASK(lb->lb_str[1])) ||
|
|
lb->lb_str[1] == '_') {
|
|
char *p;
|
|
char *src;
|
|
char *dest;
|
|
size_t name_len;
|
|
if (Py_DebugFlag)
|
|
printf("Label %s is a keyword\n", lb->lb_str);
|
|
lb->lb_type = NAME;
|
|
src = lb->lb_str + 1;
|
|
p = strchr(src, '\'');
|
|
if (p)
|
|
name_len = p - src;
|
|
else
|
|
name_len = strlen(src);
|
|
dest = (char *)malloc(name_len + 1);
|
|
if (!dest) {
|
|
printf("Can't alloc dest '%s'\n", src);
|
|
return;
|
|
}
|
|
strncpy(dest, src, name_len);
|
|
dest[name_len] = '\0';
|
|
free(lb->lb_str);
|
|
lb->lb_str = dest;
|
|
}
|
|
else if (lb->lb_str[2] == lb->lb_str[0]) {
|
|
int type = (int) PyToken_OneChar(lb->lb_str[1]);
|
|
if (type != OP) {
|
|
lb->lb_type = type;
|
|
free(lb->lb_str);
|
|
lb->lb_str = NULL;
|
|
}
|
|
else
|
|
printf("Unknown OP label %s\n",
|
|
lb->lb_str);
|
|
}
|
|
else if (lb->lb_str[2] && lb->lb_str[3] == lb->lb_str[0]) {
|
|
int type = (int) PyToken_TwoChars(lb->lb_str[1],
|
|
lb->lb_str[2]);
|
|
if (type != OP) {
|
|
lb->lb_type = type;
|
|
free(lb->lb_str);
|
|
lb->lb_str = NULL;
|
|
}
|
|
else
|
|
printf("Unknown OP label %s\n",
|
|
lb->lb_str);
|
|
}
|
|
else if (lb->lb_str[2] && lb->lb_str[3] && lb->lb_str[4] == lb->lb_str[0]) {
|
|
int type = (int) PyToken_ThreeChars(lb->lb_str[1],
|
|
lb->lb_str[2],
|
|
lb->lb_str[3]);
|
|
if (type != OP) {
|
|
lb->lb_type = type;
|
|
free(lb->lb_str);
|
|
lb->lb_str = NULL;
|
|
}
|
|
else
|
|
printf("Unknown OP label %s\n",
|
|
lb->lb_str);
|
|
}
|
|
else
|
|
printf("Can't translate STRING label %s\n",
|
|
lb->lb_str);
|
|
}
|
|
else
|
|
printf("Can't translate label '%s'\n",
|
|
PyGrammar_LabelRepr(lb));
|
|
}
|