1991-02-19 08:39:46 -04:00
|
|
|
/***********************************************************
|
1995-01-04 15:08:09 -04:00
|
|
|
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
|
|
|
|
The Netherlands.
|
1991-02-19 08:39:46 -04:00
|
|
|
|
|
|
|
All Rights Reserved
|
|
|
|
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
|
|
documentation for any purpose and without fee is hereby granted,
|
|
|
|
provided that the above copyright notice appear in all copies and that
|
|
|
|
both that copyright notice and this permission notice appear in
|
|
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
|
|
|
Centrum or CWI not be used in advertising or publicity pertaining to
|
|
|
|
distribution of the software without specific, written prior permission.
|
|
|
|
|
|
|
|
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
|
|
|
|
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
|
|
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
|
|
|
|
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
|
|
|
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
|
|
|
|
******************************************************************/
|
|
|
|
|
1990-10-14 09:07:46 -03:00
|
|
|
/* Parser-tokenizer link implementation */
|
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
#include "pgenheaders.h"
|
1990-10-14 09:07:46 -03:00
|
|
|
#include "tokenizer.h"
|
|
|
|
#include "node.h"
|
|
|
|
#include "grammar.h"
|
|
|
|
#include "parser.h"
|
1990-12-20 11:06:42 -04:00
|
|
|
#include "parsetok.h"
|
1990-10-14 09:07:46 -03:00
|
|
|
#include "errcode.h"
|
|
|
|
|
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
/* Forward */
|
1994-08-29 09:25:45 -03:00
|
|
|
static node *parsetok PROTO((struct tok_state *, grammar *, int,
|
|
|
|
perrdetail *));
|
1990-10-14 09:07:46 -03:00
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
/* Parse input coming from a string. Return error code, print some errors. */
|
1990-10-14 09:07:46 -03:00
|
|
|
|
1994-08-29 09:25:45 -03:00
|
|
|
node *
|
|
|
|
parsestring(s, g, start, err_ret)
|
1990-10-14 09:07:46 -03:00
|
|
|
char *s;
|
|
|
|
grammar *g;
|
|
|
|
int start;
|
1994-08-29 09:25:45 -03:00
|
|
|
perrdetail *err_ret;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1994-08-29 09:25:45 -03:00
|
|
|
struct tok_state *tok;
|
|
|
|
|
|
|
|
err_ret->error = E_OK;
|
|
|
|
err_ret->filename = NULL;
|
|
|
|
err_ret->lineno = 0;
|
|
|
|
err_ret->offset = 0;
|
|
|
|
err_ret->text = NULL;
|
|
|
|
|
|
|
|
if ((tok = tok_setups(s)) == NULL) {
|
|
|
|
err_ret->error = E_NOMEM;
|
|
|
|
return NULL;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
1994-08-29 09:25:45 -03:00
|
|
|
|
|
|
|
return parsetok(tok, g, start, err_ret);
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
/* Parse input coming from a file. Return error code, print some errors. */
|
1990-10-14 09:07:46 -03:00
|
|
|
|
1994-08-29 09:25:45 -03:00
|
|
|
node *
|
|
|
|
parsefile(fp, filename, g, start, ps1, ps2, err_ret)
|
1990-10-14 09:07:46 -03:00
|
|
|
FILE *fp;
|
1990-12-20 11:06:42 -04:00
|
|
|
char *filename;
|
1990-10-14 09:07:46 -03:00
|
|
|
grammar *g;
|
|
|
|
int start;
|
|
|
|
char *ps1, *ps2;
|
1994-08-29 09:25:45 -03:00
|
|
|
perrdetail *err_ret;
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
1994-08-29 09:25:45 -03:00
|
|
|
struct tok_state *tok;
|
|
|
|
|
|
|
|
err_ret->error = E_OK;
|
|
|
|
err_ret->filename = filename;
|
|
|
|
err_ret->lineno = 0;
|
|
|
|
err_ret->offset = 0;
|
|
|
|
err_ret->text = NULL;
|
|
|
|
|
|
|
|
if ((tok = tok_setupf(fp, ps1, ps2)) == NULL) {
|
|
|
|
err_ret->error = E_NOMEM;
|
|
|
|
return NULL;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
1994-08-29 09:25:45 -03:00
|
|
|
|
1992-03-25 18:32:00 -04:00
|
|
|
#ifdef macintosh
|
|
|
|
{
|
|
|
|
int tabsize = guesstabsize(filename);
|
|
|
|
if (tabsize > 0)
|
|
|
|
tok->tabsize = tabsize;
|
|
|
|
}
|
|
|
|
#endif
|
1990-12-20 11:06:42 -04:00
|
|
|
|
1994-08-29 09:25:45 -03:00
|
|
|
return parsetok(tok, g, start, err_ret);
|
|
|
|
}
|
1990-12-20 11:06:42 -04:00
|
|
|
|
|
|
|
/* Parse input coming from the given tokenizer structure.
|
|
|
|
Return error code. */
|
|
|
|
|
1994-08-29 09:25:45 -03:00
|
|
|
static node *
|
|
|
|
parsetok(tok, g, start, err_ret)
|
1990-12-20 11:06:42 -04:00
|
|
|
struct tok_state *tok;
|
|
|
|
grammar *g;
|
|
|
|
int start;
|
1994-08-29 09:25:45 -03:00
|
|
|
perrdetail *err_ret;
|
1990-12-20 11:06:42 -04:00
|
|
|
{
|
|
|
|
parser_state *ps;
|
1994-08-29 09:25:45 -03:00
|
|
|
node *n;
|
1992-03-04 12:40:44 -04:00
|
|
|
int started = 0;
|
1994-08-29 09:25:45 -03:00
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
if ((ps = newparser(g, start)) == NULL) {
|
|
|
|
fprintf(stderr, "no mem for new parser\n");
|
1994-08-29 09:25:45 -03:00
|
|
|
err_ret->error = E_NOMEM;
|
|
|
|
return NULL;
|
1990-12-20 11:06:42 -04:00
|
|
|
}
|
1994-08-29 09:25:45 -03:00
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
for (;;) {
|
|
|
|
char *a, *b;
|
|
|
|
int type;
|
|
|
|
int len;
|
|
|
|
char *str;
|
1994-08-29 09:25:45 -03:00
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
type = tok_get(tok, &a, &b);
|
|
|
|
if (type == ERRORTOKEN) {
|
1994-08-29 09:25:45 -03:00
|
|
|
err_ret->error = tok->done;
|
1990-12-20 11:06:42 -04:00
|
|
|
break;
|
|
|
|
}
|
1992-03-04 12:40:44 -04:00
|
|
|
if (type == ENDMARKER && started) {
|
|
|
|
type = NEWLINE; /* Add an extra newline */
|
|
|
|
started = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
started = 1;
|
1994-08-29 09:25:45 -03:00
|
|
|
len = b - a; /* XXX this may compute NULL - NULL */
|
1990-12-20 11:06:42 -04:00
|
|
|
str = NEW(char, len + 1);
|
|
|
|
if (str == NULL) {
|
|
|
|
fprintf(stderr, "no mem for next token\n");
|
1994-08-29 09:25:45 -03:00
|
|
|
err_ret->error = E_NOMEM;
|
1990-12-20 11:06:42 -04:00
|
|
|
break;
|
|
|
|
}
|
1994-08-29 09:25:45 -03:00
|
|
|
if (len > 0)
|
|
|
|
strncpy(str, a, len);
|
1990-12-20 11:06:42 -04:00
|
|
|
str[len] = '\0';
|
1994-08-29 09:25:45 -03:00
|
|
|
if ((err_ret->error =
|
|
|
|
addtoken(ps, (int)type, str, tok->lineno)) != E_OK)
|
1990-12-20 11:06:42 -04:00
|
|
|
break;
|
|
|
|
}
|
1994-08-29 09:25:45 -03:00
|
|
|
|
|
|
|
if (err_ret->error == E_DONE) {
|
|
|
|
n = ps->p_tree;
|
|
|
|
ps->p_tree = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
n = NULL;
|
|
|
|
|
1990-12-20 11:06:42 -04:00
|
|
|
delparser(ps);
|
1994-08-29 09:25:45 -03:00
|
|
|
|
|
|
|
if (n == NULL) {
|
|
|
|
if (tok->lineno <= 1 && tok->done == E_EOF)
|
|
|
|
err_ret->error = E_EOF;
|
|
|
|
err_ret->lineno = tok->lineno;
|
|
|
|
err_ret->offset = tok->cur - tok->buf;
|
|
|
|
if (tok->buf != NULL) {
|
|
|
|
int len = tok->inp - tok->buf;
|
|
|
|
err_ret->text = malloc(len + 1);
|
|
|
|
if (err_ret->text != NULL) {
|
1995-01-20 12:59:12 -04:00
|
|
|
if (len > 0)
|
|
|
|
strncpy(err_ret->text, tok->buf, len);
|
1994-08-29 09:25:45 -03:00
|
|
|
err_ret->text[len] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tok_free(tok);
|
|
|
|
|
|
|
|
return n;
|
1990-12-20 11:06:42 -04:00
|
|
|
}
|