github.com/PDP-10.its
1
0
Fork 0
mirror of https://github.com/PDP-10/its.git synced 2026-03-26 18:14:05 +00:00
Code Issues Releases Wiki Activity
Files
lars/snyder
PDP-10.its/c20/lex/ytab.old
Lars Brinkhoff 3774f5986a C20, port to TOPS-20.
2018-05-15 07:06:17 +02:00

947 lines
19 KiB
Plaintext
Raw Permalink Blame History

/*
* * * * W A R N I N G * * *
*
* This file has been hand-modified from that which was produced by Yacc
* from 'lex.y'. If you plan on rebuilding this with Yacc, be SURE to run
* the virgin supplied 'lex.y' thru Yacc first, do a source compare of it's
* output 'ytab.c' with this file, and note & understand the manual mods
* that were made here.
* Bob Denny
*
* Modified 02-Dec-80 Bob Denny -- Conditionalized debug code for smaller size
* YYSMALL no longer used.
* Removed hackish accent grave's.
* 01 Moved calls do dfa build, min, print and
* write, and to stat() to lex.c, so this
* module could be put in overlay region.
* Moved impure data out into ytdata.c to
* go to the root.
*
* 29-May-81 Bob Denny -- Define yysterm fwd. Remove from LEXLEX.H.
* for RSX overlaying.
* 19-Mar-82 Bob Denny -- New compiler and library. Typcasts needed.
* Conditionally compile remote formats, not
* supported in VAX C.
* More 03-May-82 Bob Denny -- Final touches, remove unreferenced autos
*/
#include <stdio.h>
#include "ytab.h"
#ifdef vms
#include <ctype.h>
#endif
extern char *yysterm[]; /* Hack forward definition */
#line 9 "lex.y"
#include "lexlex.h"
/* char copr[] = "Copyright (c) 1978 Charles H. Forsyth";*/
struct des {
struct nfa *d_start;
struct nfa *d_final;
};
extern struct nlist { /* 01+ */
struct nlist *nl_next;
struct nfa *nl_base;
struct nfa *nl_end;
struct nfa *nl_start;
struct nfa *nl_final;
char *nl_name;
} *nlist; /* 01- */
extern int str_length;
extern struct nfa *elem();
extern struct des *newdp();
extern struct nlist *lookup();
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar, yyerrflag;
#ifndef YYSTYPE
#define YYSTYPE int
#endif
#ifndef YYVCOPY
#define YYVCOPY(x,y) (x)=(y)
#endif
extern YYSTYPE yyval; /* 01+ */
extern YYSTYPE *yypv;
extern YYSTYPE yylval;
extern int nlook;
extern int yyline;
extern char *breakc;
extern char *ignore;
extern char *illeg; /* 01- */
yyactr(__np__){
#line 40 "lex.y"
struct nfa *np, *nbase;
char *cp;
struct des *dp;
struct trans *tp;
struct nlist *nl;
int i, c;
switch(__np__){
case 7:
#line 64 "lex.y"
{
dp = yypv[3];
nl = yypv[1];
np = nl->nl_base;
nl->nl_start = dp->d_start;
nl->nl_final = dp->d_final;
nl->nl_end = nfap;
#ifdef DEBUG
fprintf(lexlog, "NFA (auxiliary definition) for %s\n",
nl->nl_name);
nfaprint(dp->d_start, nl->nl_base);
#endif
nbase = lalloc(i = nl->nl_end-nl->nl_base, sizeof(*nbase),
"nfa storage");
copynfa(nl, nbase, dp);
nl->nl_start = dp->d_start;
nl->nl_final = dp->d_final;
nl->nl_end = nbase+i;
nl->nl_base = nbase;
nfap = np;
spccl(nl->nl_name, "ignore", dp, &ignore);
spccl(nl->nl_name, "break", dp, &breakc);
spccl(nl->nl_name, "illegal", dp, &illeg);
} break;
case 8:
#line 85 "lex.y"
{ copycode(); } break;
case 9:
#line 89 "lex.y"
{
yyval = lookup(yypv[1]);
((struct nlist *)yyval)->nl_base = nfap;
if (((struct nlist *)yyval)->nl_start)
#ifdef vms
yyerror("redefined", ((struct nlist *)yyval)->nl_name);
#else
yyerror("%s redefined", ((struct nlist *)yyval)->nl_name);
#endif
} break;
case 10:
#line 98 "lex.y"
{ yyval = lookup(yypv[1]); } break;
case 11:
#line 102 "lex.y"
{
np = elem(CCL, yypv[1]);
yyval = newdp(np, np->n_succ[0] = elem(FIN));
} break;
case 12:
#line 106 "lex.y"
{
cp = yypv[1];
if (str_length == 0) {
np = elem(EPSILON);
yyval = newdp(np, np->n_succ[0] = elem(FIN));
return;
}
yyval = np = elem(*cp++);
while (--str_length > 0)
np = np->n_succ[0] = elem(*cp++);
yyval = newdp(yyval, np->n_succ[0] = elem(FIN));
} break;
case 13:
#line 118 "lex.y"
{
if ((nl = yypv[1])->nl_end == 0) {
#ifdef vms
yyerror("not defined", nl->nl_name);
#else
yyerror("%s not defined", nl->nl_name);
#endif
nl->nl_base = nl->nl_end = elem(FIN);
nl->nl_start = nl->nl_final = nl->nl_base;
}
yyval = dp = lalloc(1, sizeof(*dp), "dfa input");
nbase = nfap;
i = nl->nl_end-nl->nl_base;
if ((nfap += i) >= &nfa[MAXNFA]) {
yyerror("Out of NFA nodes", NULL);
exit(1);
}
copynfa(nl, nbase, dp);
} break;
case 14:
#line 133 "lex.y"
{
yyval = dp = yypv[1];
dp->d_start = newnfa(EPSILON, np = dp->d_start, 0);
dp->d_final->n_char = EPSILON;
dp->d_final->n_succ[0] = np;
dp->d_final->n_succ[1] = np = elem(FIN);
dp->d_start->n_succ[1] = np;
dp->d_final = np;
} break;
case 15:
#line 142 "lex.y"
{
yyval = dp = yypv[1];
dp->d_start = newnfa(EPSILON, dp->d_start,
((struct des *)yypv[3])->d_start);
dp->d_final->n_char = EPSILON;
dp->d_final = dp->d_final->n_succ[0] = np = elem(FIN);
dp = yypv[3];
dp->d_final->n_char = EPSILON;
dp->d_final->n_succ[0] = np;
free(yypv[3]);
} break;
case 16:
#line 152 "lex.y"
{
yyval = yypv[1];
dp = yypv[2];
np = ((struct des *)yyval)->d_final;
((struct des *)yyval)->d_final = dp->d_final;
np->n_char = dp->d_start->n_char;
np->n_ccl = dp->d_start->n_ccl;
np->n_succ[0] = dp->d_start->n_succ[0];
np->n_succ[1] = dp->d_start->n_succ[1];
free(yypv[2]);
} break;
case 17:
#line 163 "lex.y"
{ yyval = yypv[2]; } break;
case 18:
#line 167 "lex.y"
{
ending();
trans1:
#ifdef DEBUG
fprintf(lexlog, "\nNFA for complete syntax\n");
fprintf(lexlog, "state 0\n");
for (tp = trans; tp < transp; tp++)
fprintf(lexlog, "\tepsilon\t%d\n", tp->t_start-nfa);
for (tp = trans; tp < transp; tp++)
nfaprint(tp->t_start, nfa);
#else
;
#endif
/* 01 */
} break;
case 19:
#line 182 "lex.y"
{ goto trans1; } break;
case 22:
#line 191 "lex.y"
{
llactr();
} break;
case 23:
#line 197 "lex.y"
{ dp = yypv[1]; newtrans(dp->d_start, dp->d_final); } break;
case 24:
#line 198 "lex.y"
{ copycode(); } break;
case 25:
#line 199 "lex.y"
{
ending();
while ((c = get()) != EOF)
putc(c, llout);
} break;
case 26:
#line 207 "lex.y"
{ action(); } break;
case 27:
#line 211 "lex.y"
{
if (nlook >= NBPW)
#ifdef vms
yyerror("Too many translations with lookahead", NULL);
#else
yyerror("More than %d translations with lookahead",
NBPW);
#endif
yyval = dp = yypv[1];
np = dp->d_final;
np->n_char = EPSILON;
np->n_flag |= LOOK;
np->n_succ[0] = ((struct des *)yypv[3])->d_start;
dp->d_final = ((struct des *)yypv[3])->d_final;
np->n_look = nlook;
dp->d_final->n_look = nlook++;
dp->d_final->n_flag |= FLOOK;
free(yypv[3]);
} break;
}
}
int yyerrval = 256;
#line 228 "lex.y"
/*
* Lexical analyser
* (it isn't done with lex...)
*/
extern char buffer[150]; /* 01 */
extern int str_length; /* 01 */
yylex()
{
register c;
register char *cp;
int lno;
if (yyline == 0)
yyline++;
loop:
c = get();
if (isupper(c)) {
name(c);
for (cp = yylval; c = *cp; cp++)
if (isupper(c))
*cp = tolower(c);
return(STRING);
} else if (islower(c) || c == '_') {
name(c);
return(NAME);
}
switch (c) {
case EOF:
return(0);
case '[':
return(cclass());
case '(':
case ')':
case '{':
case '}':
case '*':
case '|':
case '=':
case ';':
case '%':
return(c);
case '/':
if ((c = get()) != '*') {
unget(c);
return('/');
}
lno = yyline;
for (; c != EOF; c = get())
if (c == '*')
if ((c = get()) == '/')
goto loop; else
unget(c);
yyline = lno;
yyerror("End of file in comment", NULL);
case '\'':
case '"':
yylval = buffer;
string(c);
return(STRING);
case '\n':
case ' ':
case '\t':
goto loop;
default:
yylval = buffer;
buffer[0] = c;
buffer[1] = 0;
str_length = 1;
return(STRING);
}
}
extern char ccl[(NCHARS+1)/NBPC]; /* 01 */
cclass()
{
register c, i, lc;
int compl;
compl = 0;
for (i = 0; i < sizeof ccl; i++)
ccl[i] = 0;
if ((c = get()) == '^')
compl++; else
unget(c);
lc = -1;
while ((c = mapc(']')) != EOF) {
if (c == '-' && lc >= 0) {
if ((c = mapc(']')) == EOF)
break;
for (i = lc; i <= c; i++)
ccl[i/NBPC] |= 1<<(i%NBPC);
lc = -1;
continue;
}
ccl[c/NBPC] |= 1<<(c%NBPC);
lc = c;
}
if (compl) {
for (i = 0; i < sizeof ccl; i++)
ccl[i] ^= -1;
if (aflag == 0)
for (i = 0200; i < (1<<NBPC); i++)
ccl[i/NBPC] &= ~(1 << (i%NBPC));
}
yylval = newccl(ccl);
return(CCLASS);
}
string(ec)
{
register char *cp;
register c;
for (cp = buffer; (c = mapc(ec)) != EOF;)
*cp++ = c;
*cp = 0;
str_length = cp-buffer;
}
mapc(ec)
{
register c, v, i;
if ((c = get()) == ec)
return(EOF);
switch(c) {
case EOF:
yyerror("End of file in string", NULL);
return(c);
case '\\':
if ((c = get()) >= '0' && c <= '7') {
i = 0;
for (v = 0; c>='0' && c<='7' && i++<3; c = get())
v = v*010 + c-'0';
unget(c);
return(v&0377);
}
switch (c) {
case 'n':
return('\n');
case 't':
return('\t');
case 'b':
return('\b');
case 'r':
return('\r');
case '\n':
yyline++;
return(mapc(ec));
}
default:
return(c);
}
}
name(c)
register c;
{
register char *cp;
for (yylval=cp=buffer; isalpha(c) || isdigit(c) || c=='_'; c=get())
*cp++ = c;
*cp = 0;
str_length = cp-buffer;
unget(c);
}
/*
* Miscellaneous functions
* used only by lex.y
*/
struct nfa *
elem(k, v)
{
struct nfa *fp;
fp = newnfa(k, 0, 0);
if (k == CCL)
fp->n_ccl = v;
return(fp);
}
struct des *
newdp(st, fi)
struct nfa *st, *fi;
{
register struct des *dp;
dp = lalloc(1, sizeof(*dp), "dfa input");
dp->d_start = st;
dp->d_final = fi;
return(dp);
}
action()
{
register c;
int lno, lev;
newcase(transp-trans);
lno = yyline;
lev = 0;
for (; (c = get()) != EOF && (c != '}' || lev); putc(c, llout))
if (c == '{')
lev++;
else if (c == '}')
lev--;
else if (c == '\'' || c == '"') {
putc(c, llout);
skipstr(c);
}
fprintf(llout, "\n break;\n");
if (c == EOF) {
yyline = lno;
yyerror("End of file in action", NULL);
}
}
skipstr(ec)
register ec;
{
register c;
while ((c = get()) != ec && c != EOF) {
putc(c, llout);
if (c == '\\' && (c = get()) != EOF)
putc(c, llout);
}
}
copycode()
{
int lno;
register c;
setline();
lno = yyline;
for (; (c = get()) != EOF; putc(c, llout))
if (c == '%') {
if ((c = get()) == '}')
return;
unget(c);
c = '%';
}
yyline = lno;
yyerror("Incomplete %{ declaration", NULL);
exit(1);
}
struct nlist *
lookup(s)
register char *s;
{
register struct nlist *nl;
register char *cp;
int i;
for (nl = nlist; nl; nl = nl->nl_next)
if (streq(s, nl->nl_name))
return(nl);
nl = lalloc(1, sizeof(*nl), "namelist");
nl->nl_start = nl->nl_end = nl->nl_base = nl->nl_end = 0;
nl->nl_next = nlist;
nlist = nl;
i = 0;
nl->nl_name = cp = lalloc(strlen(s) + 1, sizeof(*cp), "namelist");
strcpy(cp, s);
return(nl);
}
copynfa(nl, nbase, dp)
struct nlist *nl;
struct des *dp;
struct nfa *nbase;
{
register struct nfa *np, *ob;
register j;
int i;
ob = nl->nl_base;
i = nl->nl_end-ob;
/*
* Assumes Decus compiler: copy(out, in, nbytes)
*/
copy(nbase, ob, sizeof(*np) * i);
for (np = nbase; i-- > 0; np++) {
np->n_flag &= ~NPRT;
for (j = 0; j < 2; j++)
if (np->n_succ[j])
np->n_succ[j] = (np->n_succ[j]-ob)+nbase;
}
dp->d_start = (nl->nl_start-ob)+nbase;
dp->d_final = (nl->nl_final-ob)+nbase;
}
#ifdef vms
copy(out, in, count)
register char *out;
register char *in;
register int count;
/*
* Block copy for vms -- should be in stdio.lib (in macro)
*/
{
while (--count >= 0)
*out++ = *in++;
}
#endif
spccl(nm, isit, dp, where)
char *nm;
char *isit;
register struct des *dp;
char **where;
{
if (streq(nm, isit)) {
if (*where != 0)
#ifdef vms
yyerror("Redefinition of class", isit);
#else
yyerror("Redefinition of %s class", isit);
#endif
if (dp->d_start->n_char == CCL &&
dp->d_start->n_succ[0] == dp->d_final)
*where = dp->d_start->n_ccl;
else
#ifdef vms
yyerror("Illegal class", isit);
#else
yyerror("Illegal %s class", isit);
#endif
}
}
get()
{
register int c;
if ((c = getc(lexin)) == '\n')
yyline++;
return(c);
}
unget(c)
register c;
{
if (c == '\n')
yyline--;
ungetc(c, lexin);
}
#ifdef vms
yyerror(s, arg)
char *s;
char *arg;
{
if (yyline)
fprintf(stderr, "%d: ", yyline);
fprintf(stderr, "%s", s);
if(arg != NULL)
fprintf(stderr, ": \"%s\"", arg);
#else
yyerror(s)
char *s;
{
if (yyline)
fprintf(stderr, "%d: ", yyline);
fprintf(stderr, "%r", &s);
#endif
if (yychar > 256)
fprintf(stderr, " near '%s'", yysterm[yychar-256]);
else if (yychar < 256 && yychar > 0)
fprintf(stderr, " near '%c'", yychar);
fprintf(stderr, "\n");
}
int nterms = 15;
int nnonter = 13;
int nstate = 41;
char *yysterm[] = {
"error",
"NAME",
"CCLASS",
"STRING",
"CONCAT",
0 };
char *yysnter[] = {
"$accept",
"lexfile",
"auxiliary_section",
"translation_section",
"auxiliaries",
"auxiliary",
"namedef",
"regexp",
"name",
"translations",
"translation",
"llactr",
"pattern",
"action" };
#
extern int yychar;
int yylast = 245;
yyexcp(s){
extern int yydef[];
switch(s){
case 1:
if( yychar == 0 ) return( -1 );
return( 0 );
case 2:
if( yychar == 0 ) return( 19 );
return( 22 );
}
}
yyact[] = {
23, 40, 32, 23, 29, 32, 23, 15, 32, 23,
31, 32, 23, 35, 32, 18, 26, 13, 23, 32,
34, 23, 37, 11, 4, 5, 16, 28, 17, 12,
19, 19, 10, 9, 22, 6, 27, 25, 3, 8,
2, 1, 0, 0, 36, 0, 0, 0, 0, 0,
0, 0, 0, 0, 38, 0, 39, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 33, 0, 0, 33, 0, 0,
33, 0, 0, 33, 0, 0, 30, 0, 0, 0,
0, 0, 14, 14, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 24, 20, 21,
24, 20, 21, 24, 20, 21, 24, 20, 21, 24,
20, 21, 0, 0, 0, 24, 20, 21, 24, 20,
21, 0, 0, 7, 7 };
yypact[] = {
-13,-2000,-2000, -14, -20,-1000, -54,-1000,-1000, -22,
-22, -21,-1000,-1000,-1000, -19,-1000,-119, -27, -34,
-1000,-1000,-1000, -19,-1000,-1000,-1000, -37,-1000,-1000,
-1000,-1000,-1000, -19, -23, -19, -40,-1000, -28, -31,
-1000 };
yypgo[] = {
0, 41, 40, 39, 38, 25, 35, 20, 34, 33,
26, 32, 28, 27 };
yyr1[] = {
0, 1, 1, 2, 2, 4, 4, 5, 5, 6,
8, 7, 7, 7, 7, 7, 7, 7, 3, 3,
9, 9, 11, 10, 10, 10, 13, 12, 12, -1 };
yyr2[] = {
0, 2, 0, 3, 2, 2, 1, 4, 2, 1,
1, 1, 1, 1, 2, 3, 2, 3, 1, 0,
2, 2, 0, 2, 2, 2, 1, 3, 1, -1 };
yychk[] = {
0, -1, -2, -4, 37, -5, -6, 257, -3, -9,
-11, 37, -5, 37, 123, 61, -10, -12, 37, -7,
258, 259, -8, 40, 257, -10, 37, -7, -13, 123,
123, 37, 42, 124, -7, 47, -7, 59, -7, -7,
41 };
yydef[] = {
2, -2, -2, 0, 0, 6, 0, 9, 1, 18,
0, 0, 5, 4, 8, 0, 20, 0, 0, 28,
11, 12, 13, 0, 10, 21, 3, 0, 23, 26,
24, 25, 14, 0, 16, 0, 0, 7, 15, 27,
17 };
# define YYFLAG1 -1000
# define YYFLAG2 -2000
/* test me on cases where there are more than one reduction
per state, leading to the necessity to look ahead, and other
arcane flows of control.
*/
# define YYMAXDEPTH 150
/* parser for yacc output */
/* extern YYSTYPE yyval; -- defined in the table file
* extern YYSTYPE yylval; -- defined in the table file
* extern YYSTYPE *yypv; -- defined in the table file
*/
#ifdef DEBUG
#define LOGOUT lexlog
#endif
extern int yydebug; /* 1 for debugging */ /* 01+ */
extern YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
extern int yychar; /* current input token number */
extern int yynerrs ; /* number of errors */
extern int yyerrflag ; /* error recovery flag */ /* 01- */
yyparse() {
/* extern int yypgo[], yyr1[], yyr2[], yyact[], yypact[];
* extern int yydef[], yychk[];
* extern int yylast, yyerrval;
*/
int yys[YYMAXDEPTH];
int yyj;
register yyn, yystate, *yyps;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyps= &yys[0]-1;
yypv= &yyv[0]-1;
yystack: /* put a state and value onto the stack */
#ifdef DEBUG
if( yydebug )
fprintf(LOGOUT, "state %d, value %d, char %d\n",yystate,yyval,yychar);
#endif
*++yyps = yystate;
*++yypv = yyval;
yynewstate:
yyn = yypact[yystate];
if( yyn<= YYFLAG1 ){ /* simple state */
if( yyn == YYFLAG2 && yychar<0 ) yychar = yylex();
goto yydefault;
}
if( yychar<0 ) yychar = yylex();
if( (yyn += yychar)<0 || yyn >= yylast ) goto yydefault;
if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if( yyerrflag > 0 ) --yyerrflag;
goto yystack;
}
yydefault:
/* default state action */
if( (yyn=yydef[yystate]) == -2 ) yyn = yyexcp( yystate );
if( yyn == -1 ){ /* accept */
return( 0 );
}
if( yyn == 0 ){ /* error */
/* error ... attempt to resume parsing */
switch( yyerrflag ){
case 0: /* brand new error */
++yynerrs;
yyerror("syntax error", NULL);
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while ( yyps >= yys ) {
yyn = yypact[*yyps] + yyerrval;
if( yyn>= 0 && yyn < yylast && yychk[yyact[yyn]] == yyerrval ){
yystate = yyact[yyn]; /* simulate a shift of "error" */
goto yystack;
}
yyn = yypact[*yyps];
/* the current yyps has no shift onn "error", pop stack */
#ifdef DEBUG
if(yydebug)
fprintf(LOGOUT, "error recovery pops state %d, uncovers %d\n",
*yyps, yyps[-1]);
#endif
--yyps;
--yypv;
}
/* there is no state on the stack with an error shift ... abort */
abort:
return(1);
case 3: /* no shift yet; clobber input char */
#ifdef DEBUG
if (yydebug)
fprintf(LOGOUT, "error recovery discards char %d\n", yychar );
#endif
if( yychar == 0 ) goto abort; /* don't discard EOF, quit */
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
#ifdef DEBUG
if(yydebug) fprintf(LOGOUT, "reduce %d\n",yyn);
#endif
yyps -= yyr2[yyn];
yypv -= yyr2[yyn];
/* YYVCOPY(yyval,yypv[1]);
*/ yyval = yypv[1];
yyactr(yyn);
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyj = yypgo[yyn] + *yyps + 1;
if( yyj>=yylast || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
goto yystack; /* stack new state and value */
}
Reference in New Issue View Git Blame Copy Permalink