mirror of
https://github.com/python/cpython
synced 2024-11-05 18:12:54 +00:00
131 lines
2.4 KiB
C
131 lines
2.4 KiB
C
/* Parser-tokenizer link implementation */
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "PROTO.h"
|
|
#include "malloc.h"
|
|
#include "tokenizer.h"
|
|
#include "node.h"
|
|
#include "grammar.h"
|
|
#include "parser.h"
|
|
#include "errcode.h"
|
|
|
|
extern int debugging;
|
|
|
|
|
|
/* Parse input coming from the given tokenizer structure.
|
|
Return error code. */
|
|
|
|
static int
|
|
parsetok(tok, g, start, n_ret)
|
|
struct tok_state *tok;
|
|
grammar *g;
|
|
int start;
|
|
node **n_ret;
|
|
{
|
|
parser_state *ps;
|
|
int ret;
|
|
|
|
if ((ps = newparser(g, start)) == NULL) {
|
|
fprintf(stderr, "no mem for new parser\n");
|
|
return E_NOMEM;
|
|
}
|
|
|
|
for (;;) {
|
|
char *a, *b;
|
|
int type;
|
|
int len;
|
|
char *str;
|
|
|
|
type = tok_get(tok, &a, &b);
|
|
if (type == ERRORTOKEN) {
|
|
ret = tok->done;
|
|
break;
|
|
}
|
|
len = b - a;
|
|
str = NEW(char, len + 1);
|
|
if (str == NULL) {
|
|
fprintf(stderr, "no mem for next token\n");
|
|
ret = E_NOMEM;
|
|
break;
|
|
}
|
|
strncpy(str, a, len);
|
|
str[len] = '\0';
|
|
ret = addtoken(ps, (int)type, str);
|
|
if (ret != E_OK) {
|
|
if (ret == E_DONE)
|
|
*n_ret = ps->p_tree;
|
|
else if (tok->lineno <= 1 && tok->done == E_EOF)
|
|
ret = E_EOF;
|
|
break;
|
|
}
|
|
}
|
|
|
|
delparser(ps);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* Parse input coming from a string. Return error code. */
|
|
|
|
int
|
|
parsestring(s, g, start, n_ret)
|
|
char *s;
|
|
grammar *g;
|
|
int start;
|
|
node **n_ret;
|
|
{
|
|
struct tok_state *tok = tok_setups(s);
|
|
int ret;
|
|
|
|
if (tok == NULL) {
|
|
fprintf(stderr, "no mem for tok_setups\n");
|
|
return E_NOMEM;
|
|
}
|
|
ret = parsetok(tok, g, start, n_ret);
|
|
if (ret == E_TOKEN || ret == E_SYNTAX) {
|
|
fprintf(stderr, "String parsing error at line %d\n",
|
|
tok->lineno);
|
|
}
|
|
tok_free(tok);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* Parse input coming from a file. Return error code. */
|
|
|
|
int
|
|
parsefile(fp, g, start, ps1, ps2, n_ret)
|
|
FILE *fp;
|
|
grammar *g;
|
|
int start;
|
|
char *ps1, *ps2;
|
|
node **n_ret;
|
|
{
|
|
struct tok_state *tok = tok_setupf(fp, ps1, ps2);
|
|
int ret;
|
|
|
|
if (tok == NULL) {
|
|
fprintf(stderr, "no mem for tok_setupf\n");
|
|
return E_NOMEM;
|
|
}
|
|
ret = parsetok(tok, g, start, n_ret);
|
|
if (ret == E_TOKEN || ret == E_SYNTAX) {
|
|
char *p;
|
|
fprintf(stderr, "Parsing error at line %d:\n",
|
|
tok->lineno);
|
|
*tok->inp = '\0';
|
|
if (tok->inp > tok->buf && tok->inp[-1] == '\n')
|
|
tok->inp[-1] = '\0';
|
|
fprintf(stderr, "%s\n", tok->buf);
|
|
for (p = tok->buf; p < tok->cur; p++) {
|
|
if (*p == '\t')
|
|
putc('\t', stderr);
|
|
else
|
|
putc(' ', stderr);
|
|
}
|
|
fprintf(stderr, "^\n");
|
|
}
|
|
tok_free(tok);
|
|
return ret;
|
|
}
|