Plan 9 lex (to be installed as lex.9, if at all).
This commit is contained in:
wkj
parent
7d3bbe1652
commit
e37302c4b9
8 changed files with 2903 additions and 0 deletions
115
src/cmd/lex/header.c
Normal file
115
src/cmd/lex/header.c
Normal file
|
|
@ -0,0 +1,115 @@
|
||||||
|
# include "ldefs.h"
|
||||||
|
|
||||||
|
extern int nine;
|
||||||
|
|
||||||
|
void
|
||||||
|
phead1(void)
|
||||||
|
{
|
||||||
|
Bprint(&fout,"typedef unsigned char Uchar;\n");
|
||||||
|
if (nine) {
|
||||||
|
Bprint(&fout,"# include <u.h>\n");
|
||||||
|
Bprint(&fout,"# include <libc.h>\n");
|
||||||
|
}
|
||||||
|
Bprint(&fout,"# include <stdio.h>\n");
|
||||||
|
Bprint(&fout, "# define U(x) x\n");
|
||||||
|
Bprint(&fout, "# define NLSTATE yyprevious=YYNEWLINE\n");
|
||||||
|
Bprint(&fout,"# define BEGIN yybgin = yysvec + 1 +\n");
|
||||||
|
Bprint(&fout,"# define INITIAL 0\n");
|
||||||
|
Bprint(&fout,"# define YYLERR yysvec\n");
|
||||||
|
Bprint(&fout,"# define YYSTATE (yyestate-yysvec-1)\n");
|
||||||
|
Bprint(&fout,"# define YYOPTIM 1\n");
|
||||||
|
# ifdef DEBUG
|
||||||
|
Bprint(&fout,"# define LEXDEBUG 1\n");
|
||||||
|
# endif
|
||||||
|
Bprint(&fout,"# define YYLMAX 200\n");
|
||||||
|
Bprint(&fout,
|
||||||
|
"# define unput(c) {yytchar= (c);if(yytchar=='\\n')yylineno--;*yysptr++=yytchar;}\n");
|
||||||
|
Bprint(&fout,"# define yymore() (yymorfg=1)\n");
|
||||||
|
Bprint(&fout,"# define ECHO fprintf(yyout, \"%%s\",yytext)\n");
|
||||||
|
Bprint(&fout,"# define REJECT { nstr = yyreject(); goto yyfussy;}\n");
|
||||||
|
Bprint(&fout,"int yyleng; extern char yytext[];\n");
|
||||||
|
Bprint(&fout,"int yymorfg;\n");
|
||||||
|
Bprint(&fout,"extern Uchar *yysptr, yysbuf[];\n");
|
||||||
|
Bprint(&fout,"int yytchar;\n");
|
||||||
|
// Bprint(&fout,"FILE *yyin = stdin, *yyout = stdout;\n");
|
||||||
|
Bprint(&fout,"FILE *yyin, *yyout;\n");
|
||||||
|
Bprint(&fout,"extern int yylineno;\n");
|
||||||
|
Bprint(&fout,"struct yysvf { \n");
|
||||||
|
Bprint(&fout,"\tstruct yywork *yystoff;\n");
|
||||||
|
Bprint(&fout,"\tstruct yysvf *yyother;\n");
|
||||||
|
Bprint(&fout,"\tint *yystops;};\n");
|
||||||
|
Bprint(&fout,"struct yysvf *yyestate;\n");
|
||||||
|
Bprint(&fout,"extern struct yysvf yysvec[], *yybgin;\n");
|
||||||
|
Bprint(&fout,"int yylook(void), yywrap(void), yyback(int *, int);\n");
|
||||||
|
if(nine) {
|
||||||
|
Bprint(&fout,
|
||||||
|
"int infd, outfd;\n"
|
||||||
|
"\n"
|
||||||
|
"void\n"
|
||||||
|
"output(char c)\n"
|
||||||
|
"{\n"
|
||||||
|
" int rv;\n"
|
||||||
|
" if ((rv = write(outfd, &c, 1)) < 0)\n"
|
||||||
|
" sysfatal(\"output: %%r\");\n"
|
||||||
|
" if (rv == 0)\n"
|
||||||
|
" sysfatal(\"output: EOF?\");\n"
|
||||||
|
"}\n"
|
||||||
|
"\n"
|
||||||
|
"int\n"
|
||||||
|
"input(void)\n"
|
||||||
|
"{\n"
|
||||||
|
" if(yysptr > yysbuf)\n"
|
||||||
|
" yytchar = U(*--yysptr);\n"
|
||||||
|
" else {\n"
|
||||||
|
" int rv;\n"
|
||||||
|
" if ((rv = read(infd, &yytchar, 1)) < 0)\n"
|
||||||
|
" sysfatal(\"input: %%r\");\n"
|
||||||
|
" if (rv == 0)\n"
|
||||||
|
" return 0;\n"
|
||||||
|
" }\n"
|
||||||
|
" if (yytchar == '\\n')\n"
|
||||||
|
" yylineno++;\n"
|
||||||
|
" return yytchar;\n"
|
||||||
|
"}\n");
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
Bprint(&fout,"# define output(c) putc(c,yyout)\n");
|
||||||
|
Bprint(&fout, "%s%d%s\n",
|
||||||
|
"# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==",
|
||||||
|
'\n',
|
||||||
|
"?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
phead2(void)
|
||||||
|
{
|
||||||
|
Bprint(&fout,"while((nstr = yylook()) >= 0)\n");
|
||||||
|
Bprint(&fout,"yyfussy: switch(nstr){\n");
|
||||||
|
Bprint(&fout,"case 0:\n");
|
||||||
|
Bprint(&fout,"if(yywrap()) return(0); break;\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
ptail(void)
|
||||||
|
{
|
||||||
|
if(!pflag){
|
||||||
|
Bprint(&fout,"case -1:\nbreak;\n"); /* for reject */
|
||||||
|
Bprint(&fout,"default:\n");
|
||||||
|
Bprint(&fout,"fprintf(yyout,\"bad switch yylook %%d\",nstr);\n");
|
||||||
|
Bprint(&fout,"} return(0); }\n");
|
||||||
|
Bprint(&fout,"/* end of yylex */\n");
|
||||||
|
}
|
||||||
|
pflag = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
statistics(void)
|
||||||
|
{
|
||||||
|
fprint(errorf,"%d/%d nodes(%%e), %d/%d positions(%%p), %d/%d (%%n), %ld transitions\n",
|
||||||
|
tptr, treesize, (int)(nxtpos-positions), maxpos, stnum+1, nstates, rcount);
|
||||||
|
fprint(errorf, ", %d/%d packed char classes(%%k)", (int)(pcptr-pchar), pchlen);
|
||||||
|
fprint(errorf,", %d/%d packed transitions(%%a)",nptr, ntrans);
|
||||||
|
fprint(errorf, ", %d/%d output slots(%%o)", yytop, outsize);
|
||||||
|
fprint(errorf,"\n");
|
||||||
|
}
|
||||||
180
src/cmd/lex/ldefs.h
Normal file
180
src/cmd/lex/ldefs.h
Normal file
|
|
@ -0,0 +1,180 @@
|
||||||
|
# include <u.h>
|
||||||
|
# include <libc.h>
|
||||||
|
# include <ctype.h>
|
||||||
|
# include <bio.h>
|
||||||
|
# define PP 1
|
||||||
|
|
||||||
|
#ifdef NOTDEF
|
||||||
|
# define CWIDTH 8
|
||||||
|
# define CMASK 0377
|
||||||
|
#endif
|
||||||
|
# define NCH 256
|
||||||
|
|
||||||
|
|
||||||
|
# define TOKENSIZE 1000
|
||||||
|
# define DEFSIZE 40
|
||||||
|
# define DEFCHAR 1000
|
||||||
|
# define STARTCHAR 100
|
||||||
|
# define STARTSIZE 256
|
||||||
|
# define CCLSIZE 1000
|
||||||
|
|
||||||
|
# define TREESIZE 1000
|
||||||
|
# define NSTATES 500
|
||||||
|
# define MAXPOS 2500
|
||||||
|
# define NTRANS 2000
|
||||||
|
# define NOUTPUT 5000
|
||||||
|
|
||||||
|
# define NACTIONS 100
|
||||||
|
# define ALITTLEEXTRA 30
|
||||||
|
|
||||||
|
# define RCCL NCH+90
|
||||||
|
# define RNCCL NCH+91
|
||||||
|
# define RSTR NCH+92
|
||||||
|
# define RSCON NCH+93
|
||||||
|
# define RNEWE NCH+94
|
||||||
|
# define FINAL NCH+95
|
||||||
|
# define RNULLS NCH+96
|
||||||
|
# define RCAT NCH+97
|
||||||
|
# define STAR NCH+98
|
||||||
|
# define PLUS NCH+99
|
||||||
|
# define QUEST NCH+100
|
||||||
|
# define DIV NCH+101
|
||||||
|
# define BAR NCH+102
|
||||||
|
# define CARAT NCH+103
|
||||||
|
# define S1FINAL NCH+104
|
||||||
|
# define S2FINAL NCH+105
|
||||||
|
|
||||||
|
# define DEFSECTION 1
|
||||||
|
# define RULESECTION 2
|
||||||
|
# define ENDSECTION 5
|
||||||
|
# define TRUE 1
|
||||||
|
# define FALSE 0
|
||||||
|
|
||||||
|
# define PC 1
|
||||||
|
# define PS 1
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
# define LINESIZE 110
|
||||||
|
extern int yydebug;
|
||||||
|
extern int debug; /* 1 = on */
|
||||||
|
extern int charc;
|
||||||
|
# endif
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
extern int freturn(int);
|
||||||
|
# else
|
||||||
|
# define freturn(s) s
|
||||||
|
# endif
|
||||||
|
|
||||||
|
extern int sargc;
|
||||||
|
extern char **sargv;
|
||||||
|
extern uchar buf[520];
|
||||||
|
extern int yyline; /* line number of file */
|
||||||
|
extern int sect;
|
||||||
|
extern int eof;
|
||||||
|
extern int lgatflg;
|
||||||
|
extern int divflg;
|
||||||
|
extern int funcflag;
|
||||||
|
extern int pflag;
|
||||||
|
extern int casecount;
|
||||||
|
extern int chset; /* 1 = char set modified */
|
||||||
|
extern Biobuf *fin, fout, *fother;
|
||||||
|
extern int foutopen;
|
||||||
|
extern int errorf;
|
||||||
|
extern int fptr;
|
||||||
|
extern char *cname;
|
||||||
|
extern int prev; /* previous input character */
|
||||||
|
extern int pres; /* present input character */
|
||||||
|
extern int peek; /* next input character */
|
||||||
|
extern int *name;
|
||||||
|
extern int *left;
|
||||||
|
extern int *right;
|
||||||
|
extern int *parent;
|
||||||
|
extern uchar *nullstr;
|
||||||
|
extern int tptr;
|
||||||
|
extern uchar pushc[TOKENSIZE];
|
||||||
|
extern uchar *pushptr;
|
||||||
|
extern uchar slist[STARTSIZE];
|
||||||
|
extern uchar *slptr;
|
||||||
|
extern uchar **def, **subs, *dchar;
|
||||||
|
extern uchar **sname, *stchar;
|
||||||
|
extern uchar *ccl;
|
||||||
|
extern uchar *ccptr;
|
||||||
|
extern uchar *dp, *sp;
|
||||||
|
extern int dptr, sptr;
|
||||||
|
extern uchar *bptr; /* store input position */
|
||||||
|
extern uchar *tmpstat;
|
||||||
|
extern int count;
|
||||||
|
extern int **foll;
|
||||||
|
extern int *nxtpos;
|
||||||
|
extern int *positions;
|
||||||
|
extern int *gotof;
|
||||||
|
extern int *nexts;
|
||||||
|
extern uchar *nchar;
|
||||||
|
extern int **state;
|
||||||
|
extern int *sfall; /* fallback state num */
|
||||||
|
extern uchar *cpackflg; /* true if state has been character packed */
|
||||||
|
extern int *atable, aptr;
|
||||||
|
extern int nptr;
|
||||||
|
extern uchar symbol[NCH];
|
||||||
|
extern uchar cindex[NCH];
|
||||||
|
extern int xstate;
|
||||||
|
extern int stnum;
|
||||||
|
extern int ccount;
|
||||||
|
extern uchar match[NCH];
|
||||||
|
extern uchar extra[NACTIONS];
|
||||||
|
extern uchar *pcptr, *pchar;
|
||||||
|
extern int pchlen;
|
||||||
|
extern int nstates, maxpos;
|
||||||
|
extern int yytop;
|
||||||
|
extern int report;
|
||||||
|
extern int ntrans, treesize, outsize;
|
||||||
|
extern long rcount;
|
||||||
|
extern int *verify, *advance, *stoff;
|
||||||
|
extern int scon;
|
||||||
|
extern uchar *psave;
|
||||||
|
|
||||||
|
extern void acompute(int);
|
||||||
|
extern void add(int **, int);
|
||||||
|
extern void allprint(int);
|
||||||
|
extern void cclinter(int);
|
||||||
|
extern void cgoto(void);
|
||||||
|
extern void cfoll(int);
|
||||||
|
extern int cpyact(void);
|
||||||
|
extern int dupl(int);
|
||||||
|
extern void error(char *,...);
|
||||||
|
extern void first(int);
|
||||||
|
extern void follow(int);
|
||||||
|
extern int gch(void);
|
||||||
|
extern uchar *getl(uchar *);
|
||||||
|
extern void layout(void);
|
||||||
|
extern void lgate(void);
|
||||||
|
extern int lookup(uchar *, uchar **);
|
||||||
|
extern int member(int, uchar *);
|
||||||
|
extern void mkmatch(void);
|
||||||
|
extern int mn0(int);
|
||||||
|
extern int mn1(int, int);
|
||||||
|
extern int mn2(int, int, int);
|
||||||
|
extern void munputc(int);
|
||||||
|
extern void munputs(uchar *);
|
||||||
|
extern void *myalloc(int, int);
|
||||||
|
extern void nextstate(int, int);
|
||||||
|
extern int notin(int);
|
||||||
|
extern void packtrans(int, uchar *, int *, int, int);
|
||||||
|
extern void padd(int **, int);
|
||||||
|
extern void pccl(void);
|
||||||
|
extern void pfoll(void);
|
||||||
|
extern void phead1(void);
|
||||||
|
extern void phead2(void);
|
||||||
|
extern void pstate(int);
|
||||||
|
extern void ptail(void);
|
||||||
|
extern void sect1dump(void);
|
||||||
|
extern void sect2dump(void);
|
||||||
|
extern void statistics(void);
|
||||||
|
extern void stprt(int);
|
||||||
|
extern void strpt(uchar *);
|
||||||
|
extern void treedump(void);
|
||||||
|
extern int usescape(int);
|
||||||
|
extern void warning(char *,...);
|
||||||
|
extern int yyparse(void);
|
||||||
|
extern void yyerror(char *);
|
||||||
292
src/cmd/lex/lmain.c
Normal file
292
src/cmd/lex/lmain.c
Normal file
|
|
@ -0,0 +1,292 @@
|
||||||
|
/* lex [-[dynvt]] [file] ... [file] */
|
||||||
|
|
||||||
|
/* Copyright 1976, Bell Telephone Laboratories, Inc.,
|
||||||
|
written by Eric Schmidt, August 27, 1976 */
|
||||||
|
|
||||||
|
# include "ldefs.h"
|
||||||
|
Biobuf fout;
|
||||||
|
int foutopen;
|
||||||
|
int errorf = 1;
|
||||||
|
int sect = DEFSECTION;
|
||||||
|
int prev = '\n'; /* previous input character */
|
||||||
|
int pres = '\n'; /* present input character */
|
||||||
|
int peek = '\n'; /* next input character */
|
||||||
|
uchar *pushptr = pushc;
|
||||||
|
uchar *slptr = slist;
|
||||||
|
|
||||||
|
char *cname = SYS9 "/sys/lib/lex/ncform";
|
||||||
|
|
||||||
|
int nine;
|
||||||
|
int ccount = 1;
|
||||||
|
int casecount = 1;
|
||||||
|
int aptr = 1;
|
||||||
|
int nstates = NSTATES, maxpos = MAXPOS;
|
||||||
|
int treesize = TREESIZE, ntrans = NTRANS;
|
||||||
|
int yytop;
|
||||||
|
int outsize = NOUTPUT;
|
||||||
|
int sptr = 1;
|
||||||
|
int report = 2;
|
||||||
|
int debug; /* 1 = on */
|
||||||
|
int charc;
|
||||||
|
int sargc;
|
||||||
|
char **sargv;
|
||||||
|
uchar buf[520];
|
||||||
|
int yyline; /* line number of file */
|
||||||
|
int eof;
|
||||||
|
int lgatflg;
|
||||||
|
int divflg;
|
||||||
|
int funcflag;
|
||||||
|
int pflag;
|
||||||
|
int chset; /* 1 = char set modified */
|
||||||
|
Biobuf *fin, *fother;
|
||||||
|
int fptr;
|
||||||
|
int *name;
|
||||||
|
int *left;
|
||||||
|
int *right;
|
||||||
|
int *parent;
|
||||||
|
uchar *nullstr;
|
||||||
|
int tptr;
|
||||||
|
uchar pushc[TOKENSIZE];
|
||||||
|
uchar slist[STARTSIZE];
|
||||||
|
uchar **def, **subs, *dchar;
|
||||||
|
uchar **sname, *stchar;
|
||||||
|
uchar *ccl;
|
||||||
|
uchar *ccptr;
|
||||||
|
uchar *dp, *sp;
|
||||||
|
int dptr;
|
||||||
|
uchar *bptr; /* store input position */
|
||||||
|
uchar *tmpstat;
|
||||||
|
int count;
|
||||||
|
int **foll;
|
||||||
|
int *nxtpos;
|
||||||
|
int *positions;
|
||||||
|
int *gotof;
|
||||||
|
int *nexts;
|
||||||
|
uchar *nchar;
|
||||||
|
int **state;
|
||||||
|
int *sfall; /* fallback state num */
|
||||||
|
uchar *cpackflg; /* true if state has been character packed */
|
||||||
|
int *atable;
|
||||||
|
int nptr;
|
||||||
|
uchar symbol[NCH];
|
||||||
|
uchar cindex[NCH];
|
||||||
|
int xstate;
|
||||||
|
int stnum;
|
||||||
|
uchar match[NCH];
|
||||||
|
uchar extra[NACTIONS];
|
||||||
|
uchar *pchar, *pcptr;
|
||||||
|
int pchlen = TOKENSIZE;
|
||||||
|
long rcount;
|
||||||
|
int *verify, *advance, *stoff;
|
||||||
|
int scon;
|
||||||
|
uchar *psave;
|
||||||
|
|
||||||
|
static void free1core(void);
|
||||||
|
static void free2core(void);
|
||||||
|
#ifdef DEBUG
|
||||||
|
static void free3core(void);
|
||||||
|
#endif
|
||||||
|
static void get1core(void);
|
||||||
|
static void get2core(void);
|
||||||
|
static void get3core(void);
|
||||||
|
|
||||||
|
void
|
||||||
|
main(int argc, char **argv)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
ARGBEGIN {
|
||||||
|
# ifdef DEBUG
|
||||||
|
case 'd': debug++; break;
|
||||||
|
case 'y': yydebug = TRUE; break;
|
||||||
|
# endif
|
||||||
|
case 't': case 'T':
|
||||||
|
Binit(&fout, 1, OWRITE);
|
||||||
|
errorf= 2;
|
||||||
|
foutopen = 1;
|
||||||
|
break;
|
||||||
|
case 'v': case 'V':
|
||||||
|
report = 1;
|
||||||
|
break;
|
||||||
|
case 'n': case 'N':
|
||||||
|
report = 0;
|
||||||
|
break;
|
||||||
|
case '9':
|
||||||
|
nine = 1;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
warning("Unknown option %c", ARGC());
|
||||||
|
} ARGEND
|
||||||
|
sargc = argc;
|
||||||
|
sargv = argv;
|
||||||
|
if (argc > 0){
|
||||||
|
fin = Bopen(argv[fptr++], OREAD);
|
||||||
|
if(fin == 0)
|
||||||
|
error ("Can't read input file %s",argv[0]);
|
||||||
|
sargc--;
|
||||||
|
sargv++;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
fin = myalloc(sizeof(Biobuf), 1);
|
||||||
|
if(fin == 0)
|
||||||
|
exits("core");
|
||||||
|
Binit(fin, 0, OREAD);
|
||||||
|
}
|
||||||
|
if(Bgetc(fin) == Beof) /* no input */
|
||||||
|
exits(0);
|
||||||
|
Bseek(fin, 0, 0);
|
||||||
|
gch();
|
||||||
|
/* may be gotten: def, subs, sname, stchar, ccl, dchar */
|
||||||
|
get1core();
|
||||||
|
/* may be gotten: name, left, right, nullstr, parent */
|
||||||
|
strcpy((char*)sp, "INITIAL");
|
||||||
|
sname[0] = sp;
|
||||||
|
sp += strlen("INITIAL") + 1;
|
||||||
|
sname[1] = 0;
|
||||||
|
if(yyparse()) exits("error"); /* error return code */
|
||||||
|
/* may be disposed of: def, subs, dchar */
|
||||||
|
free1core();
|
||||||
|
/* may be gotten: tmpstat, foll, positions, gotof, nexts, nchar, state, atable, sfall, cpackflg */
|
||||||
|
get2core();
|
||||||
|
ptail();
|
||||||
|
mkmatch();
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug) pccl();
|
||||||
|
# endif
|
||||||
|
sect = ENDSECTION;
|
||||||
|
if(tptr>0)cfoll(tptr-1);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)pfoll();
|
||||||
|
# endif
|
||||||
|
cgoto();
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug){
|
||||||
|
print("Print %d states:\n",stnum+1);
|
||||||
|
for(i=0;i<=stnum;i++)stprt(i);
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
/* may be disposed of: positions, tmpstat, foll, state, name, left, right, parent, ccl, stchar, sname */
|
||||||
|
/* may be gotten: verify, advance, stoff */
|
||||||
|
free2core();
|
||||||
|
get3core();
|
||||||
|
layout();
|
||||||
|
/* may be disposed of: verify, advance, stoff, nexts, nchar,
|
||||||
|
gotof, atable, ccpackflg, sfall */
|
||||||
|
# ifdef DEBUG
|
||||||
|
free3core();
|
||||||
|
# endif
|
||||||
|
fother = Bopen(cname,OREAD);
|
||||||
|
if(fother == 0)
|
||||||
|
error("Lex driver missing, file %s",cname);
|
||||||
|
while ( (i=Bgetc(fother)) != Beof)
|
||||||
|
Bputc(&fout, i);
|
||||||
|
|
||||||
|
Bterm(fother);
|
||||||
|
Bterm(&fout);
|
||||||
|
if(
|
||||||
|
# ifdef DEBUG
|
||||||
|
debug ||
|
||||||
|
# endif
|
||||||
|
report == 1)statistics();
|
||||||
|
Bterm(fin);
|
||||||
|
exits(0); /* success return code */
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
get1core(void)
|
||||||
|
{
|
||||||
|
ccptr = ccl = myalloc(CCLSIZE,sizeof(*ccl));
|
||||||
|
pcptr = pchar = myalloc(pchlen, sizeof(*pchar));
|
||||||
|
def = myalloc(DEFSIZE,sizeof(*def));
|
||||||
|
subs = myalloc(DEFSIZE,sizeof(*subs));
|
||||||
|
dp = dchar = myalloc(DEFCHAR,sizeof(*dchar));
|
||||||
|
sname = myalloc(STARTSIZE,sizeof(*sname));
|
||||||
|
sp = stchar = myalloc(STARTCHAR,sizeof(*stchar));
|
||||||
|
if(ccl == 0 || def == 0 || subs == 0 || dchar == 0 || sname == 0 || stchar == 0)
|
||||||
|
error("Too little core to begin");
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
free1core(void)
|
||||||
|
{
|
||||||
|
free(def);
|
||||||
|
free(subs);
|
||||||
|
free(dchar);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
get2core(void)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
gotof = myalloc(nstates,sizeof(*gotof));
|
||||||
|
nexts = myalloc(ntrans,sizeof(*nexts));
|
||||||
|
nchar = myalloc(ntrans,sizeof(*nchar));
|
||||||
|
state = myalloc(nstates,sizeof(*state));
|
||||||
|
atable = myalloc(nstates,sizeof(*atable));
|
||||||
|
sfall = myalloc(nstates,sizeof(*sfall));
|
||||||
|
cpackflg = myalloc(nstates,sizeof(*cpackflg));
|
||||||
|
tmpstat = myalloc(tptr+1,sizeof(*tmpstat));
|
||||||
|
foll = myalloc(tptr+1,sizeof(*foll));
|
||||||
|
nxtpos = positions = myalloc(maxpos,sizeof(*positions));
|
||||||
|
if(tmpstat == 0 || foll == 0 || positions == 0 ||
|
||||||
|
gotof == 0 || nexts == 0 || nchar == 0 || state == 0 || atable == 0 || sfall == 0 || cpackflg == 0 )
|
||||||
|
error("Too little core for state generation");
|
||||||
|
for(i=0;i<=tptr;i++)foll[i] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
free2core(void)
|
||||||
|
{
|
||||||
|
free(positions);
|
||||||
|
free(tmpstat);
|
||||||
|
free(foll);
|
||||||
|
free(name);
|
||||||
|
free(left);
|
||||||
|
free(right);
|
||||||
|
free(parent);
|
||||||
|
free(nullstr);
|
||||||
|
free(state);
|
||||||
|
free(sname);
|
||||||
|
free(stchar);
|
||||||
|
free(ccl);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
get3core(void)
|
||||||
|
{
|
||||||
|
verify = myalloc(outsize,sizeof(*verify));
|
||||||
|
advance = myalloc(outsize,sizeof(*advance));
|
||||||
|
stoff = myalloc(stnum+2,sizeof(*stoff));
|
||||||
|
if(verify == 0 || advance == 0 || stoff == 0)
|
||||||
|
error("Too little core for final packing");
|
||||||
|
}
|
||||||
|
# ifdef DEBUG
|
||||||
|
static void
|
||||||
|
free3core(void){
|
||||||
|
free(advance);
|
||||||
|
free(verify);
|
||||||
|
free(stoff);
|
||||||
|
free(gotof);
|
||||||
|
free(nexts);
|
||||||
|
free(nchar);
|
||||||
|
free(atable);
|
||||||
|
free(sfall);
|
||||||
|
free(cpackflg);
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
void *
|
||||||
|
myalloc(int a, int b)
|
||||||
|
{
|
||||||
|
void *i;
|
||||||
|
i = calloc(a, b);
|
||||||
|
if(i==0)
|
||||||
|
warning("OOPS - calloc returns a 0");
|
||||||
|
return(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
yyerror(char *s)
|
||||||
|
{
|
||||||
|
fprint(2, "line %d: %s\n", yyline, s);
|
||||||
|
}
|
||||||
30
src/cmd/lex/mkfile
Normal file
30
src/cmd/lex/mkfile
Normal file
|
|
@ -0,0 +1,30 @@
|
||||||
|
<$PLAN9/src/mkhdr
|
||||||
|
|
||||||
|
#TARG=lex
|
||||||
|
TARG=lex.9
|
||||||
|
OFILES=lmain.$O\
|
||||||
|
y.tab.$O\
|
||||||
|
sub1.$O\
|
||||||
|
sub2.$O\
|
||||||
|
header.$O\
|
||||||
|
|
||||||
|
HFILES=ldefs.h\
|
||||||
|
|
||||||
|
YFILES=parser.y\
|
||||||
|
|
||||||
|
SHORTLIB=bio 9
|
||||||
|
UPDATE=\
|
||||||
|
mkfile\
|
||||||
|
$HFILES\
|
||||||
|
lmain.c\
|
||||||
|
sub1.c\
|
||||||
|
sub2.c\
|
||||||
|
header.c
|
||||||
|
|
||||||
|
<$PLAN9/src/mkone
|
||||||
|
|
||||||
|
installall:V:
|
||||||
|
for objtype in $CPUS ; do
|
||||||
|
mk install
|
||||||
|
done
|
||||||
|
cp ncform $SYS9/lib/lex
|
||||||
188
src/cmd/lex/ncform
Normal file
188
src/cmd/lex/ncform
Normal file
|
|
@ -0,0 +1,188 @@
|
||||||
|
#pragma lib "libl.a"
|
||||||
|
int yylineno =1;
|
||||||
|
# define YYU(x) x
|
||||||
|
char yytext[YYLMAX];
|
||||||
|
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
|
||||||
|
Uchar yysbuf[YYLMAX];
|
||||||
|
Uchar *yysptr = yysbuf;
|
||||||
|
int *yyfnd;
|
||||||
|
extern struct yysvf *yyestate;
|
||||||
|
int yyprevious = YYNEWLINE;
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
extern void allprint(char);
|
||||||
|
# endif
|
||||||
|
yylook(void){
|
||||||
|
struct yysvf *yystate, **lsp;
|
||||||
|
struct yywork *yyt;
|
||||||
|
struct yysvf *yyz;
|
||||||
|
int yych;
|
||||||
|
struct yywork *yyr;
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
int debug;
|
||||||
|
# endif
|
||||||
|
Uchar *yylastch;
|
||||||
|
/* start off machines */
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
debug = 0;
|
||||||
|
# endif
|
||||||
|
if (!yymorfg)
|
||||||
|
yylastch = (Uchar*)yytext;
|
||||||
|
else {
|
||||||
|
yymorfg=0;
|
||||||
|
yylastch = (Uchar*)yytext+yyleng;
|
||||||
|
}
|
||||||
|
for(;;){
|
||||||
|
lsp = yylstate;
|
||||||
|
yyestate = yystate = yybgin;
|
||||||
|
if (yyprevious==YYNEWLINE) yystate++;
|
||||||
|
for (;;){
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
|
||||||
|
# endif
|
||||||
|
yyt = yystate->yystoff;
|
||||||
|
if(yyt == yycrank){ /* may not be any transitions */
|
||||||
|
yyz = yystate->yyother;
|
||||||
|
if(yyz == 0)break;
|
||||||
|
if(yyz->yystoff == yycrank)break;
|
||||||
|
}
|
||||||
|
*yylastch++ = yych = input();
|
||||||
|
tryagain:
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug){
|
||||||
|
fprintf(yyout,"char ");
|
||||||
|
allprint(yych);
|
||||||
|
putchar('\n');
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
yyr = yyt;
|
||||||
|
if ( (int)yyt > (int)yycrank){
|
||||||
|
yyt = yyr + yych;
|
||||||
|
if (yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||||
|
if(yyt->advance+yysvec == YYLERR) /* error transitions */
|
||||||
|
{unput(*--yylastch);break;}
|
||||||
|
*lsp++ = yystate = yyt->advance+yysvec;
|
||||||
|
goto contin;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
# ifdef YYOPTIM
|
||||||
|
else if((int)yyt < (int)yycrank) { /* r < yycrank */
|
||||||
|
yyt = yyr = yycrank+(yycrank-yyt);
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug)fprintf(yyout,"compressed state\n");
|
||||||
|
# endif
|
||||||
|
yyt = yyt + yych;
|
||||||
|
if(yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||||
|
if(yyt->advance+yysvec == YYLERR) /* error transitions */
|
||||||
|
{unput(*--yylastch);break;}
|
||||||
|
*lsp++ = yystate = yyt->advance+yysvec;
|
||||||
|
goto contin;
|
||||||
|
}
|
||||||
|
yyt = yyr + YYU(yymatch[yych]);
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug){
|
||||||
|
fprintf(yyout,"try fall back character ");
|
||||||
|
allprint(YYU(yymatch[yych]));
|
||||||
|
putchar('\n');
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
if(yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||||
|
if(yyt->advance+yysvec == YYLERR) /* error transition */
|
||||||
|
{unput(*--yylastch);break;}
|
||||||
|
*lsp++ = yystate = yyt->advance+yysvec;
|
||||||
|
goto contin;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
|
||||||
|
# endif
|
||||||
|
goto tryagain;
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
else
|
||||||
|
{unput(*--yylastch);break;}
|
||||||
|
contin:
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug){
|
||||||
|
fprintf(yyout,"state %d char ",yystate-yysvec-1);
|
||||||
|
allprint(yych);
|
||||||
|
putchar('\n');
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
;
|
||||||
|
}
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug){
|
||||||
|
fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
|
||||||
|
allprint(yych);
|
||||||
|
putchar('\n');
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
while (lsp-- > yylstate){
|
||||||
|
*yylastch-- = 0;
|
||||||
|
if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
|
||||||
|
yyolsp = lsp;
|
||||||
|
if(yyextra[*yyfnd]){ /* must backup */
|
||||||
|
while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
|
||||||
|
lsp--;
|
||||||
|
unput(*yylastch--);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
yyprevious = YYU(*yylastch);
|
||||||
|
yylsp = lsp;
|
||||||
|
yyleng = yylastch-(Uchar*)yytext+1;
|
||||||
|
yytext[yyleng] = 0;
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug){
|
||||||
|
fprintf(yyout,"\nmatch '%s'", yytext);
|
||||||
|
fprintf(yyout," action %d\n",*yyfnd);
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
return(*yyfnd++);
|
||||||
|
}
|
||||||
|
unput(*yylastch);
|
||||||
|
}
|
||||||
|
if (yytext[0] == 0 /* && feof(yyin) */)
|
||||||
|
{
|
||||||
|
yysptr=yysbuf;
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
yyprevious = input();
|
||||||
|
yytext[0] = yyprevious;
|
||||||
|
if (yyprevious>0)
|
||||||
|
output(yyprevious);
|
||||||
|
yylastch = (Uchar*)yytext;
|
||||||
|
# ifdef LEXDEBUG
|
||||||
|
if(debug)putchar('\n');
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
return(0); /* shut up the compiler; i have no idea what should be returned */
|
||||||
|
}
|
||||||
|
yyback(int *p, int m)
|
||||||
|
{
|
||||||
|
if (p==0) return(0);
|
||||||
|
while (*p)
|
||||||
|
{
|
||||||
|
if (*p++ == m)
|
||||||
|
return(1);
|
||||||
|
}
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
/* the following are only used in the lex library */
|
||||||
|
yyinput(void){
|
||||||
|
if(yyin == ((void*)0))
|
||||||
|
yyin = stdin;
|
||||||
|
return(input());
|
||||||
|
}
|
||||||
|
void
|
||||||
|
yyoutput(int c)
|
||||||
|
{
|
||||||
|
if(yyout == ((void*)0))
|
||||||
|
yyout = stdin;
|
||||||
|
output(c);
|
||||||
|
}
|
||||||
|
void
|
||||||
|
yyunput(int c)
|
||||||
|
{
|
||||||
|
unput(c);
|
||||||
|
}
|
||||||
651
src/cmd/lex/parser.y
Normal file
651
src/cmd/lex/parser.y
Normal file
|
|
@ -0,0 +1,651 @@
|
||||||
|
%token CHAR CCL NCCL STR DELIM SCON ITER NEWE NULLS
|
||||||
|
%left SCON '/' NEWE
|
||||||
|
%left '|'
|
||||||
|
%left '$' '^'
|
||||||
|
%left CHAR CCL NCCL '(' '.' STR NULLS
|
||||||
|
%left ITER
|
||||||
|
%left CAT
|
||||||
|
%left '*' '+' '?'
|
||||||
|
|
||||||
|
%{
|
||||||
|
# include "ldefs.h"
|
||||||
|
#define YYSTYPE union _yystype_
|
||||||
|
union _yystype_
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
uchar *cp;
|
||||||
|
};
|
||||||
|
%}
|
||||||
|
%%
|
||||||
|
%{
|
||||||
|
int i;
|
||||||
|
int j,k;
|
||||||
|
int g;
|
||||||
|
uchar *p;
|
||||||
|
%}
|
||||||
|
acc : lexinput
|
||||||
|
={
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug) sect2dump();
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
;
|
||||||
|
lexinput: defns delim prods end
|
||||||
|
| defns delim end
|
||||||
|
={
|
||||||
|
if(!funcflag)phead2();
|
||||||
|
funcflag = TRUE;
|
||||||
|
}
|
||||||
|
| error
|
||||||
|
={
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug) {
|
||||||
|
sect1dump();
|
||||||
|
sect2dump();
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
;
|
||||||
|
end: delim | ;
|
||||||
|
defns: defns STR STR
|
||||||
|
={ strcpy((char*)dp,(char*)$2.cp);
|
||||||
|
def[dptr] = dp;
|
||||||
|
dp += strlen((char*)$2.cp) + 1;
|
||||||
|
strcpy((char*)dp,(char*)$3.cp);
|
||||||
|
subs[dptr++] = dp;
|
||||||
|
if(dptr >= DEFSIZE)
|
||||||
|
error("Too many definitions");
|
||||||
|
dp += strlen((char*)$3.cp) + 1;
|
||||||
|
if(dp >= dchar+DEFCHAR)
|
||||||
|
error("Definitions too long");
|
||||||
|
subs[dptr]=def[dptr]=0; /* for lookup - require ending null */
|
||||||
|
}
|
||||||
|
|
|
||||||
|
;
|
||||||
|
delim: DELIM
|
||||||
|
={
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(sect == DEFSECTION && debug) sect1dump();
|
||||||
|
# endif
|
||||||
|
sect++;
|
||||||
|
}
|
||||||
|
;
|
||||||
|
prods: prods pr
|
||||||
|
={ $$.i = mn2(RNEWE,$1.i,$2.i);
|
||||||
|
}
|
||||||
|
| pr
|
||||||
|
={ $$.i = $1.i;}
|
||||||
|
;
|
||||||
|
pr: r NEWE
|
||||||
|
={
|
||||||
|
if(divflg == TRUE)
|
||||||
|
i = mn1(S1FINAL,casecount);
|
||||||
|
else i = mn1(FINAL,casecount);
|
||||||
|
$$.i = mn2(RCAT,$1.i,i);
|
||||||
|
divflg = FALSE;
|
||||||
|
casecount++;
|
||||||
|
}
|
||||||
|
| error NEWE
|
||||||
|
={
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug) sect2dump();
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
r: CHAR
|
||||||
|
={ $$.i = mn0($1.i); }
|
||||||
|
| STR
|
||||||
|
={
|
||||||
|
p = $1.cp;
|
||||||
|
i = mn0(*p++);
|
||||||
|
while(*p)
|
||||||
|
i = mn2(RSTR,i,*p++);
|
||||||
|
$$.i = i;
|
||||||
|
}
|
||||||
|
| '.'
|
||||||
|
={ symbol['\n'] = 0;
|
||||||
|
if(psave == FALSE){
|
||||||
|
p = ccptr;
|
||||||
|
psave = ccptr;
|
||||||
|
for(i=1;i<'\n';i++){
|
||||||
|
symbol[i] = 1;
|
||||||
|
*ccptr++ = i;
|
||||||
|
}
|
||||||
|
for(i='\n'+1;i<NCH;i++){
|
||||||
|
symbol[i] = 1;
|
||||||
|
*ccptr++ = i;
|
||||||
|
}
|
||||||
|
*ccptr++ = 0;
|
||||||
|
if(ccptr > ccl+CCLSIZE)
|
||||||
|
error("Too many large character classes");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
p = psave;
|
||||||
|
$$.i = mn1(RCCL,(int)p);
|
||||||
|
cclinter(1);
|
||||||
|
}
|
||||||
|
| CCL
|
||||||
|
={ $$.i = mn1(RCCL,$1.i); }
|
||||||
|
| NCCL
|
||||||
|
={ $$.i = mn1(RNCCL,$1.i); }
|
||||||
|
| r '*'
|
||||||
|
={ $$.i = mn1(STAR,$1.i); }
|
||||||
|
| r '+'
|
||||||
|
={ $$.i = mn1(PLUS,$1.i); }
|
||||||
|
| r '?'
|
||||||
|
={ $$.i = mn1(QUEST,$1.i); }
|
||||||
|
| r '|' r
|
||||||
|
={ $$.i = mn2(BAR,$1.i,$3.i); }
|
||||||
|
| r r %prec CAT
|
||||||
|
={ $$.i = mn2(RCAT,$1.i,$2.i); }
|
||||||
|
| r '/' r
|
||||||
|
={ if(!divflg){
|
||||||
|
j = mn1(S2FINAL,-casecount);
|
||||||
|
i = mn2(RCAT,$1.i,j);
|
||||||
|
$$.i = mn2(DIV,i,$3.i);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
$$.i = mn2(RCAT,$1.i,$3.i);
|
||||||
|
warning("Extra slash removed");
|
||||||
|
}
|
||||||
|
divflg = TRUE;
|
||||||
|
}
|
||||||
|
| r ITER ',' ITER '}'
|
||||||
|
={ if($2.i > $4.i){
|
||||||
|
i = $2.i;
|
||||||
|
$2.i = $4.i;
|
||||||
|
$4.i = i;
|
||||||
|
}
|
||||||
|
if($4.i <= 0)
|
||||||
|
warning("Iteration range must be positive");
|
||||||
|
else {
|
||||||
|
j = $1.i;
|
||||||
|
for(k = 2; k<=$2.i;k++)
|
||||||
|
j = mn2(RCAT,j,dupl($1.i));
|
||||||
|
for(i = $2.i+1; i<=$4.i; i++){
|
||||||
|
g = dupl($1.i);
|
||||||
|
for(k=2;k<=i;k++)
|
||||||
|
g = mn2(RCAT,g,dupl($1.i));
|
||||||
|
j = mn2(BAR,j,g);
|
||||||
|
}
|
||||||
|
$$.i = j;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
| r ITER '}'
|
||||||
|
={
|
||||||
|
if($2.i < 0)warning("Can't have negative iteration");
|
||||||
|
else if($2.i == 0) $$.i = mn0(RNULLS);
|
||||||
|
else {
|
||||||
|
j = $1.i;
|
||||||
|
for(k=2;k<=$2.i;k++)
|
||||||
|
j = mn2(RCAT,j,dupl($1.i));
|
||||||
|
$$.i = j;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
| r ITER ',' '}'
|
||||||
|
={
|
||||||
|
/* from n to infinity */
|
||||||
|
if($2.i < 0)warning("Can't have negative iteration");
|
||||||
|
else if($2.i == 0) $$.i = mn1(STAR,$1.i);
|
||||||
|
else if($2.i == 1)$$.i = mn1(PLUS,$1.i);
|
||||||
|
else { /* >= 2 iterations minimum */
|
||||||
|
j = $1.i;
|
||||||
|
for(k=2;k<$2.i;k++)
|
||||||
|
j = mn2(RCAT,j,dupl($1.i));
|
||||||
|
k = mn1(PLUS,dupl($1.i));
|
||||||
|
$$.i = mn2(RCAT,j,k);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
| SCON r
|
||||||
|
={ $$.i = mn2(RSCON,$2.i,$1.i); }
|
||||||
|
| '^' r
|
||||||
|
={ $$.i = mn1(CARAT,$2.i); }
|
||||||
|
| r '$'
|
||||||
|
={ i = mn0('\n');
|
||||||
|
if(!divflg){
|
||||||
|
j = mn1(S2FINAL,-casecount);
|
||||||
|
k = mn2(RCAT,$1.i,j);
|
||||||
|
$$.i = mn2(DIV,k,i);
|
||||||
|
}
|
||||||
|
else $$.i = mn2(RCAT,$1.i,i);
|
||||||
|
divflg = TRUE;
|
||||||
|
}
|
||||||
|
| '(' r ')'
|
||||||
|
={ $$.i = $2.i; }
|
||||||
|
| NULLS
|
||||||
|
={ $$.i = mn0(RNULLS); }
|
||||||
|
;
|
||||||
|
%%
|
||||||
|
int
|
||||||
|
yylex(void)
|
||||||
|
{
|
||||||
|
uchar *p;
|
||||||
|
int c, i;
|
||||||
|
uchar *t, *xp;
|
||||||
|
int n, j, k, x;
|
||||||
|
static int sectbegin;
|
||||||
|
static uchar token[TOKENSIZE];
|
||||||
|
static int iter;
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
yylval.i = 0;
|
||||||
|
# endif
|
||||||
|
|
||||||
|
if(sect == DEFSECTION) { /* definitions section */
|
||||||
|
while(!eof) {
|
||||||
|
if(prev == '\n'){ /* next char is at beginning of line */
|
||||||
|
getl(p=buf);
|
||||||
|
switch(*p){
|
||||||
|
case '%':
|
||||||
|
switch(*(p+1)){
|
||||||
|
case '%':
|
||||||
|
lgate();
|
||||||
|
Bprint(&fout,"#define YYNEWLINE %d\n",'\n');
|
||||||
|
Bprint(&fout,"yylex(void){\nint nstr; extern int yyprevious;\n");
|
||||||
|
sectbegin = TRUE;
|
||||||
|
i = treesize*(sizeof(*name)+sizeof(*left)+
|
||||||
|
sizeof(*right)+sizeof(*nullstr)+sizeof(*parent))+ALITTLEEXTRA;
|
||||||
|
p = myalloc(i,1);
|
||||||
|
if(p == 0)
|
||||||
|
error("Too little core for parse tree");
|
||||||
|
free(p);
|
||||||
|
name = myalloc(treesize,sizeof(*name));
|
||||||
|
left = myalloc(treesize,sizeof(*left));
|
||||||
|
right = myalloc(treesize,sizeof(*right));
|
||||||
|
nullstr = myalloc(treesize,sizeof(*nullstr));
|
||||||
|
parent = myalloc(treesize,sizeof(*parent));
|
||||||
|
if(name == 0 || left == 0 || right == 0 || parent == 0 || nullstr == 0)
|
||||||
|
error("Too little core for parse tree");
|
||||||
|
return(freturn(DELIM));
|
||||||
|
case 'p': case 'P': /* has overridden number of positions */
|
||||||
|
while(*p && !isdigit(*p))p++;
|
||||||
|
maxpos = atol((char*)p);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug) print("positions (%%p) now %d\n",maxpos);
|
||||||
|
# endif
|
||||||
|
if(report == 2)report = 1;
|
||||||
|
continue;
|
||||||
|
case 'n': case 'N': /* has overridden number of states */
|
||||||
|
while(*p && !isdigit(*p))p++;
|
||||||
|
nstates = atol((char*)p);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)print( " no. states (%%n) now %d\n",nstates);
|
||||||
|
# endif
|
||||||
|
if(report == 2)report = 1;
|
||||||
|
continue;
|
||||||
|
case 'e': case 'E': /* has overridden number of tree nodes */
|
||||||
|
while(*p && !isdigit(*p))p++;
|
||||||
|
treesize = atol((char*)p);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug) print("treesize (%%e) now %d\n",treesize);
|
||||||
|
# endif
|
||||||
|
if(report == 2)report = 1;
|
||||||
|
continue;
|
||||||
|
case 'o': case 'O':
|
||||||
|
while (*p && !isdigit(*p))p++;
|
||||||
|
outsize = atol((char*)p);
|
||||||
|
if (report ==2) report=1;
|
||||||
|
continue;
|
||||||
|
case 'a': case 'A': /* has overridden number of transitions */
|
||||||
|
while(*p && !isdigit(*p))p++;
|
||||||
|
if(report == 2)report = 1;
|
||||||
|
ntrans = atol((char*)p);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug)print("N. trans (%%a) now %d\n",ntrans);
|
||||||
|
# endif
|
||||||
|
continue;
|
||||||
|
case 'k': case 'K': /* overriden packed char classes */
|
||||||
|
while (*p && !isdigit(*p))p++;
|
||||||
|
if (report==2) report=1;
|
||||||
|
free(pchar);
|
||||||
|
pchlen = atol((char*)p);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug) print( "Size classes (%%k) now %d\n",pchlen);
|
||||||
|
# endif
|
||||||
|
pchar=pcptr=myalloc(pchlen, sizeof(*pchar));
|
||||||
|
continue;
|
||||||
|
case '{':
|
||||||
|
lgate();
|
||||||
|
while(getl(p) && strcmp((char*)p,"%}") != 0)
|
||||||
|
Bprint(&fout, "%s\n",(char*)p);
|
||||||
|
if(p[0] == '%') continue;
|
||||||
|
error("Premature eof");
|
||||||
|
case 's': case 'S': /* start conditions */
|
||||||
|
lgate();
|
||||||
|
while(*p && strchr(" \t,", *p) == 0) p++;
|
||||||
|
n = TRUE;
|
||||||
|
while(n){
|
||||||
|
while(*p && strchr(" \t,", *p)) p++;
|
||||||
|
t = p;
|
||||||
|
while(*p && strchr(" \t,", *p) == 0)p++;
|
||||||
|
if(!*p) n = FALSE;
|
||||||
|
*p++ = 0;
|
||||||
|
if (*t == 0) continue;
|
||||||
|
i = sptr*2;
|
||||||
|
Bprint(&fout,"#define %s %d\n",(char*)t,i);
|
||||||
|
strcpy((char*)sp, (char*)t);
|
||||||
|
sname[sptr++] = sp;
|
||||||
|
sname[sptr] = 0; /* required by lookup */
|
||||||
|
if(sptr >= STARTSIZE)
|
||||||
|
error("Too many start conditions");
|
||||||
|
sp += strlen((char*)sp) + 1;
|
||||||
|
if(sp >= stchar+STARTCHAR)
|
||||||
|
error("Start conditions too long");
|
||||||
|
}
|
||||||
|
continue;
|
||||||
|
default:
|
||||||
|
warning("Invalid request %s",p);
|
||||||
|
continue;
|
||||||
|
} /* end of switch after seeing '%' */
|
||||||
|
case ' ': case '\t': /* must be code */
|
||||||
|
lgate();
|
||||||
|
Bprint(&fout, "%s\n",(char*)p);
|
||||||
|
continue;
|
||||||
|
default: /* definition */
|
||||||
|
while(*p && !isspace(*p)) p++;
|
||||||
|
if(*p == 0)
|
||||||
|
continue;
|
||||||
|
prev = *p;
|
||||||
|
*p = 0;
|
||||||
|
bptr = p+1;
|
||||||
|
yylval.cp = buf;
|
||||||
|
if(isdigit(buf[0]))
|
||||||
|
warning("Substitution strings may not begin with digits");
|
||||||
|
return(freturn(STR));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* still sect 1, but prev != '\n' */
|
||||||
|
else {
|
||||||
|
p = bptr;
|
||||||
|
while(*p && isspace(*p)) p++;
|
||||||
|
if(*p == 0)
|
||||||
|
warning("No translation given - null string assumed");
|
||||||
|
strcpy((char*)token, (char*)p);
|
||||||
|
yylval.cp = token;
|
||||||
|
prev = '\n';
|
||||||
|
return(freturn(STR));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* end of section one processing */
|
||||||
|
} else if(sect == RULESECTION){ /* rules and actions */
|
||||||
|
while(!eof){
|
||||||
|
switch(c=gch()){
|
||||||
|
case '\0':
|
||||||
|
return(freturn(0));
|
||||||
|
case '\n':
|
||||||
|
if(prev == '\n') continue;
|
||||||
|
x = NEWE;
|
||||||
|
break;
|
||||||
|
case ' ':
|
||||||
|
case '\t':
|
||||||
|
if(sectbegin == TRUE){
|
||||||
|
cpyact();
|
||||||
|
while((c=gch()) && c != '\n');
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if(!funcflag)phead2();
|
||||||
|
funcflag = TRUE;
|
||||||
|
Bprint(&fout,"case %d:\n",casecount);
|
||||||
|
if(cpyact())
|
||||||
|
Bprint(&fout,"break;\n");
|
||||||
|
while((c=gch()) && c != '\n');
|
||||||
|
if(peek == ' ' || peek == '\t' || sectbegin == TRUE){
|
||||||
|
warning("Executable statements should occur right after %%");
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
x = NEWE;
|
||||||
|
break;
|
||||||
|
case '%':
|
||||||
|
if(prev != '\n') goto character;
|
||||||
|
if(peek == '{'){ /* included code */
|
||||||
|
getl(buf);
|
||||||
|
while(!eof && getl(buf) && strcmp("%}",(char*)buf) != 0)
|
||||||
|
Bprint(&fout,"%s\n",(char*)buf);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if(peek == '%'){
|
||||||
|
gch();
|
||||||
|
gch();
|
||||||
|
x = DELIM;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
goto character;
|
||||||
|
case '|':
|
||||||
|
if(peek == ' ' || peek == '\t' || peek == '\n'){
|
||||||
|
Bprint(&fout,"%d\n",30000+casecount++);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
x = '|';
|
||||||
|
break;
|
||||||
|
case '$':
|
||||||
|
if(peek == '\n' || peek == ' ' || peek == '\t' || peek == '|' || peek == '/'){
|
||||||
|
x = c;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
goto character;
|
||||||
|
case '^':
|
||||||
|
if(prev != '\n' && scon != TRUE) goto character; /* valid only at line begin */
|
||||||
|
x = c;
|
||||||
|
break;
|
||||||
|
case '?':
|
||||||
|
case '+':
|
||||||
|
case '.':
|
||||||
|
case '*':
|
||||||
|
case '(':
|
||||||
|
case ')':
|
||||||
|
case ',':
|
||||||
|
case '/':
|
||||||
|
x = c;
|
||||||
|
break;
|
||||||
|
case '}':
|
||||||
|
iter = FALSE;
|
||||||
|
x = c;
|
||||||
|
break;
|
||||||
|
case '{': /* either iteration or definition */
|
||||||
|
if(isdigit(c=gch())){ /* iteration */
|
||||||
|
iter = TRUE;
|
||||||
|
ieval:
|
||||||
|
i = 0;
|
||||||
|
while(isdigit(c)){
|
||||||
|
token[i++] = c;
|
||||||
|
c = gch();
|
||||||
|
}
|
||||||
|
token[i] = 0;
|
||||||
|
yylval.i = atol((char*)token);
|
||||||
|
munputc(c);
|
||||||
|
x = ITER;
|
||||||
|
break;
|
||||||
|
} else { /* definition */
|
||||||
|
i = 0;
|
||||||
|
while(c && c!='}'){
|
||||||
|
token[i++] = c;
|
||||||
|
c = gch();
|
||||||
|
}
|
||||||
|
token[i] = 0;
|
||||||
|
i = lookup(token,def);
|
||||||
|
if(i < 0)
|
||||||
|
warning("Definition %s not found",token);
|
||||||
|
else
|
||||||
|
munputs(subs[i]);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
case '<': /* start condition ? */
|
||||||
|
if(prev != '\n') /* not at line begin, not start */
|
||||||
|
goto character;
|
||||||
|
t = slptr;
|
||||||
|
do {
|
||||||
|
i = 0;
|
||||||
|
c = gch();
|
||||||
|
while(c != ',' && c && c != '>'){
|
||||||
|
token[i++] = c;
|
||||||
|
c = gch();
|
||||||
|
}
|
||||||
|
token[i] = 0;
|
||||||
|
if(i == 0)
|
||||||
|
goto character;
|
||||||
|
i = lookup(token,sname);
|
||||||
|
if(i < 0) {
|
||||||
|
warning("Undefined start condition %s",token);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
*slptr++ = i+1;
|
||||||
|
} while(c && c != '>');
|
||||||
|
*slptr++ = 0;
|
||||||
|
/* check if previous value re-usable */
|
||||||
|
for (xp=slist; xp<t; ){
|
||||||
|
if (strcmp((char*)xp, (char*)t)==0)
|
||||||
|
break;
|
||||||
|
while (*xp++);
|
||||||
|
}
|
||||||
|
if (xp<t){
|
||||||
|
/* re-use previous pointer to string */
|
||||||
|
slptr=t;
|
||||||
|
t=xp;
|
||||||
|
}
|
||||||
|
if(slptr > slist+STARTSIZE) /* note not packed ! */
|
||||||
|
error("Too many start conditions used");
|
||||||
|
yylval.cp = t;
|
||||||
|
x = SCON;
|
||||||
|
break;
|
||||||
|
case '"':
|
||||||
|
i = 0;
|
||||||
|
while((c=gch()) && c != '"' && c != '\n'){
|
||||||
|
if(c == '\\') c = usescape(gch());
|
||||||
|
token[i++] = c;
|
||||||
|
if(i > TOKENSIZE){
|
||||||
|
warning("String too long");
|
||||||
|
i = TOKENSIZE-1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(c == '\n') {
|
||||||
|
yyline--;
|
||||||
|
warning("Non-terminated string");
|
||||||
|
yyline++;
|
||||||
|
}
|
||||||
|
token[i] = 0;
|
||||||
|
if(i == 0)x = NULLS;
|
||||||
|
else if(i == 1){
|
||||||
|
yylval.i = token[0];
|
||||||
|
x = CHAR;
|
||||||
|
} else {
|
||||||
|
yylval.cp = token;
|
||||||
|
x = STR;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case '[':
|
||||||
|
for(i=1;i<NCH;i++) symbol[i] = 0;
|
||||||
|
x = CCL;
|
||||||
|
if((c = gch()) == '^'){
|
||||||
|
x = NCCL;
|
||||||
|
c = gch();
|
||||||
|
}
|
||||||
|
while(c != ']' && c){
|
||||||
|
if(c == '\\') c = usescape(gch());
|
||||||
|
symbol[c] = 1;
|
||||||
|
j = c;
|
||||||
|
if((c=gch()) == '-' && peek != ']'){ /* range specified */
|
||||||
|
c = gch();
|
||||||
|
if(c == '\\') c = usescape(gch());
|
||||||
|
k = c;
|
||||||
|
if(j > k) {
|
||||||
|
n = j;
|
||||||
|
j = k;
|
||||||
|
k = n;
|
||||||
|
}
|
||||||
|
if(!(('A' <= j && k <= 'Z') ||
|
||||||
|
('a' <= j && k <= 'z') ||
|
||||||
|
('0' <= j && k <= '9')))
|
||||||
|
warning("Non-portable Character Class");
|
||||||
|
for(n=j+1;n<=k;n++)
|
||||||
|
symbol[n] = 1; /* implementation dependent */
|
||||||
|
c = gch();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* try to pack ccl's */
|
||||||
|
i = 0;
|
||||||
|
for(j=0;j<NCH;j++)
|
||||||
|
if(symbol[j])token[i++] = j;
|
||||||
|
token[i] = 0;
|
||||||
|
p = ccl;
|
||||||
|
while(p <ccptr && strcmp((char*)token,(char*)p) != 0)p++;
|
||||||
|
if(p < ccptr) /* found it */
|
||||||
|
yylval.cp = p;
|
||||||
|
else {
|
||||||
|
yylval.cp = ccptr;
|
||||||
|
strcpy((char*)ccptr,(char*)token);
|
||||||
|
ccptr += strlen((char*)token) + 1;
|
||||||
|
if(ccptr >= ccl+CCLSIZE)
|
||||||
|
error("Too many large character classes");
|
||||||
|
}
|
||||||
|
cclinter(x==CCL);
|
||||||
|
break;
|
||||||
|
case '\\':
|
||||||
|
c = usescape(gch());
|
||||||
|
default:
|
||||||
|
character:
|
||||||
|
if(iter){ /* second part of an iteration */
|
||||||
|
iter = FALSE;
|
||||||
|
if('0' <= c && c <= '9')
|
||||||
|
goto ieval;
|
||||||
|
}
|
||||||
|
if(isalpha(peek)){
|
||||||
|
i = 0;
|
||||||
|
yylval.cp = token;
|
||||||
|
token[i++] = c;
|
||||||
|
while(isalpha(peek))
|
||||||
|
token[i++] = gch();
|
||||||
|
if(peek == '?' || peek == '*' || peek == '+')
|
||||||
|
munputc(token[--i]);
|
||||||
|
token[i] = 0;
|
||||||
|
if(i == 1){
|
||||||
|
yylval.i = token[0];
|
||||||
|
x = CHAR;
|
||||||
|
}
|
||||||
|
else x = STR;
|
||||||
|
} else {
|
||||||
|
yylval.i = c;
|
||||||
|
x = CHAR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
scon = FALSE;
|
||||||
|
if(x == SCON)scon = TRUE;
|
||||||
|
sectbegin = FALSE;
|
||||||
|
return(freturn(x));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* section three */
|
||||||
|
ptail();
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)
|
||||||
|
Bprint(&fout,"\n/*this comes from section three - debug */\n");
|
||||||
|
# endif
|
||||||
|
while(getl(buf) && !eof)
|
||||||
|
Bprint(&fout,"%s\n",(char*)buf);
|
||||||
|
return(freturn(0));
|
||||||
|
}
|
||||||
|
/* end of yylex */
|
||||||
|
# ifdef DEBUG
|
||||||
|
int
|
||||||
|
freturn(int i)
|
||||||
|
{
|
||||||
|
if(yydebug) {
|
||||||
|
print("now return ");
|
||||||
|
if(i < NCH) allprint(i);
|
||||||
|
else print("%d",i);
|
||||||
|
printf(" yylval = ");
|
||||||
|
switch(i){
|
||||||
|
case STR: case CCL: case NCCL:
|
||||||
|
strpt(yylval.cp);
|
||||||
|
break;
|
||||||
|
case CHAR:
|
||||||
|
allprint(yylval.i);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
print("%d",yylval.i);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
return(i);
|
||||||
|
}
|
||||||
|
# endif
|
||||||
591
src/cmd/lex/sub1.c
Normal file
591
src/cmd/lex/sub1.c
Normal file
|
|
@ -0,0 +1,591 @@
|
||||||
|
# include "ldefs.h"
|
||||||
|
uchar *
|
||||||
|
getl(uchar *p) /* return next line of input, throw away trailing '\n' */
|
||||||
|
/* returns 0 if eof is had immediately */
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
uchar *s, *t;
|
||||||
|
|
||||||
|
t = s = p;
|
||||||
|
while(((c = gch()) != 0) && c != '\n')
|
||||||
|
*t++ = c;
|
||||||
|
*t = 0;
|
||||||
|
if(c == 0 && s == t) return((uchar *)0);
|
||||||
|
prev = '\n';
|
||||||
|
pres = '\n';
|
||||||
|
return(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
printerr(char *type, char *fmt, va_list argl)
|
||||||
|
{
|
||||||
|
char buf[1024];
|
||||||
|
|
||||||
|
if(!eof)fprint(errorf,"%d: ",yyline);
|
||||||
|
fprint(errorf,"(%s) ", type);
|
||||||
|
vseprint(buf, buf+sizeof(buf), fmt, argl);
|
||||||
|
fprint(errorf, "%s\n", buf);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
error(char *s,...)
|
||||||
|
{
|
||||||
|
va_list argl;
|
||||||
|
|
||||||
|
va_start(argl, s);
|
||||||
|
printerr("Error", s, argl);
|
||||||
|
va_end(argl);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug && sect != ENDSECTION) {
|
||||||
|
sect1dump();
|
||||||
|
sect2dump();
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
if(
|
||||||
|
# ifdef DEBUG
|
||||||
|
debug ||
|
||||||
|
# endif
|
||||||
|
report == 1) statistics();
|
||||||
|
exits("error"); /* error return code */
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
warning(char *s,...)
|
||||||
|
{
|
||||||
|
va_list argl;
|
||||||
|
|
||||||
|
va_start(argl, s);
|
||||||
|
printerr("Warning", s, argl);
|
||||||
|
va_end(argl);
|
||||||
|
Bflush(&fout);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
lgate(void)
|
||||||
|
{
|
||||||
|
int fd;
|
||||||
|
|
||||||
|
if (lgatflg) return;
|
||||||
|
lgatflg=1;
|
||||||
|
if(foutopen == 0){
|
||||||
|
fd = create("lex.yy.c", OWRITE, 0666);
|
||||||
|
if(fd < 0)
|
||||||
|
error("Can't open lex.yy.c");
|
||||||
|
Binit(&fout, fd, OWRITE);
|
||||||
|
foutopen = 1;
|
||||||
|
}
|
||||||
|
phead1();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
cclinter(int sw)
|
||||||
|
{
|
||||||
|
/* sw = 1 ==> ccl */
|
||||||
|
int i, j, k;
|
||||||
|
int m;
|
||||||
|
if(!sw){ /* is NCCL */
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
symbol[i] ^= 1; /* reverse value */
|
||||||
|
}
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
if(symbol[i]) break;
|
||||||
|
if(i >= NCH) return;
|
||||||
|
i = cindex[i];
|
||||||
|
/* see if ccl is already in our table */
|
||||||
|
j = 0;
|
||||||
|
if(i){
|
||||||
|
for(j=1;j<NCH;j++){
|
||||||
|
if((symbol[j] && cindex[j] != i) ||
|
||||||
|
(!symbol[j] && cindex[j] == i)) break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(j >= NCH) return; /* already in */
|
||||||
|
m = 0;
|
||||||
|
k = 0;
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
if(symbol[i]){
|
||||||
|
if(!cindex[i]){
|
||||||
|
cindex[i] = ccount;
|
||||||
|
symbol[i] = 0;
|
||||||
|
m = 1;
|
||||||
|
} else k = 1;
|
||||||
|
}
|
||||||
|
/* m == 1 implies last value of ccount has been used */
|
||||||
|
if(m)ccount++;
|
||||||
|
if(k == 0) return; /* is now in as ccount wholly */
|
||||||
|
/* intersection must be computed */
|
||||||
|
for(i=1;i<NCH;i++){
|
||||||
|
if(symbol[i]){
|
||||||
|
m = 0;
|
||||||
|
j = cindex[i]; /* will be non-zero */
|
||||||
|
for(k=1;k<NCH;k++){
|
||||||
|
if(cindex[k] == j){
|
||||||
|
if(symbol[k]) symbol[k] = 0;
|
||||||
|
else {
|
||||||
|
cindex[k] = ccount;
|
||||||
|
m = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(m)ccount++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
usescape(int c)
|
||||||
|
{
|
||||||
|
int d;
|
||||||
|
switch(c){
|
||||||
|
case 'n': c = '\n'; break;
|
||||||
|
case 'r': c = '\r'; break;
|
||||||
|
case 't': c = '\t'; break;
|
||||||
|
case 'b': c = '\b'; break;
|
||||||
|
case 'f': c = 014; break; /* form feed for ascii */
|
||||||
|
case '0': case '1': case '2': case '3':
|
||||||
|
case '4': case '5': case '6': case '7':
|
||||||
|
c -= '0';
|
||||||
|
while('0' <= (d=gch()) && d <= '7'){
|
||||||
|
c = c * 8 + (d-'0');
|
||||||
|
if(!('0' <= peek && peek <= '7')) break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
lookup(uchar *s, uchar **t)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
i = 0;
|
||||||
|
while(*t){
|
||||||
|
if(strcmp((char *)s, *(char **)t) == 0)
|
||||||
|
return(i);
|
||||||
|
i++;
|
||||||
|
t++;
|
||||||
|
}
|
||||||
|
return(-1);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
cpyact(void)
|
||||||
|
{ /* copy C action to the next ; or closing } */
|
||||||
|
int brac, c, mth;
|
||||||
|
int savline, sw;
|
||||||
|
|
||||||
|
brac = 0;
|
||||||
|
sw = TRUE;
|
||||||
|
savline = 0;
|
||||||
|
|
||||||
|
while(!eof){
|
||||||
|
c = gch();
|
||||||
|
swt:
|
||||||
|
switch( c ){
|
||||||
|
|
||||||
|
case '|': if(brac == 0 && sw == TRUE){
|
||||||
|
if(peek == '|')gch(); /* eat up an extra '|' */
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case ';':
|
||||||
|
if( brac == 0 ){
|
||||||
|
Bputc(&fout, c);
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
return(1);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case '{':
|
||||||
|
brac++;
|
||||||
|
savline=yyline;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case '}':
|
||||||
|
brac--;
|
||||||
|
if( brac == 0 ){
|
||||||
|
Bputc(&fout, c);
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
return(1);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case '/': /* look for comments */
|
||||||
|
Bputc(&fout, c);
|
||||||
|
c = gch();
|
||||||
|
if( c != '*' ) goto swt;
|
||||||
|
|
||||||
|
/* it really is a comment */
|
||||||
|
|
||||||
|
Bputc(&fout, c);
|
||||||
|
savline=yyline;
|
||||||
|
while( c=gch() ){
|
||||||
|
if( c=='*' ){
|
||||||
|
Bputc(&fout, c);
|
||||||
|
if( (c=gch()) == '/' ) goto loop;
|
||||||
|
}
|
||||||
|
Bputc(&fout, c);
|
||||||
|
}
|
||||||
|
yyline=savline;
|
||||||
|
error( "EOF inside comment" );
|
||||||
|
|
||||||
|
case '\'': /* character constant */
|
||||||
|
mth = '\'';
|
||||||
|
goto string;
|
||||||
|
|
||||||
|
case '"': /* character string */
|
||||||
|
mth = '"';
|
||||||
|
|
||||||
|
string:
|
||||||
|
|
||||||
|
Bputc(&fout, c);
|
||||||
|
while( c=gch() ){
|
||||||
|
if( c=='\\' ){
|
||||||
|
Bputc(&fout, c);
|
||||||
|
c=gch();
|
||||||
|
}
|
||||||
|
else if( c==mth ) goto loop;
|
||||||
|
Bputc(&fout, c);
|
||||||
|
if (c == '\n') {
|
||||||
|
yyline--;
|
||||||
|
error( "Non-terminated string or character constant");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
error( "EOF in string or character constant" );
|
||||||
|
|
||||||
|
case '\0':
|
||||||
|
yyline = savline;
|
||||||
|
error("Action does not terminate");
|
||||||
|
default:
|
||||||
|
break; /* usual character */
|
||||||
|
}
|
||||||
|
loop:
|
||||||
|
if(c != ' ' && c != '\t' && c != '\n') sw = FALSE;
|
||||||
|
Bputc(&fout, c);
|
||||||
|
}
|
||||||
|
error("Premature EOF");
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
gch(void){
|
||||||
|
int c;
|
||||||
|
prev = pres;
|
||||||
|
c = pres = peek;
|
||||||
|
peek = pushptr > pushc ? *--pushptr : Bgetc(fin);
|
||||||
|
if(peek == Beof && sargc > 1){
|
||||||
|
Bterm(fin);
|
||||||
|
fin = Bopen(sargv[fptr++],OREAD);
|
||||||
|
if(fin == 0)
|
||||||
|
error("Cannot open file %s",sargv[fptr-1]);
|
||||||
|
peek = Bgetc(fin);
|
||||||
|
sargc--;
|
||||||
|
sargv++;
|
||||||
|
}
|
||||||
|
if(c == Beof) {
|
||||||
|
eof = TRUE;
|
||||||
|
Bterm(fin);
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
if(c == '\n')yyline++;
|
||||||
|
return(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
mn2(int a, int d, int c)
|
||||||
|
{
|
||||||
|
name[tptr] = a;
|
||||||
|
left[tptr] = d;
|
||||||
|
right[tptr] = c;
|
||||||
|
parent[tptr] = 0;
|
||||||
|
nullstr[tptr] = 0;
|
||||||
|
switch(a){
|
||||||
|
case RSTR:
|
||||||
|
parent[d] = tptr;
|
||||||
|
break;
|
||||||
|
case BAR:
|
||||||
|
case RNEWE:
|
||||||
|
if(nullstr[d] || nullstr[c]) nullstr[tptr] = TRUE;
|
||||||
|
parent[d] = parent[c] = tptr;
|
||||||
|
break;
|
||||||
|
case RCAT:
|
||||||
|
case DIV:
|
||||||
|
if(nullstr[d] && nullstr[c])nullstr[tptr] = TRUE;
|
||||||
|
parent[d] = parent[c] = tptr;
|
||||||
|
break;
|
||||||
|
case RSCON:
|
||||||
|
parent[d] = tptr;
|
||||||
|
nullstr[tptr] = nullstr[d];
|
||||||
|
break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
default:
|
||||||
|
warning("bad switch mn2 %d %d",a,d);
|
||||||
|
break;
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
if(tptr > treesize)
|
||||||
|
error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
|
||||||
|
return(tptr++);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
mn1(int a, int d)
|
||||||
|
{
|
||||||
|
name[tptr] = a;
|
||||||
|
left[tptr] = d;
|
||||||
|
parent[tptr] = 0;
|
||||||
|
nullstr[tptr] = 0;
|
||||||
|
switch(a){
|
||||||
|
case RCCL:
|
||||||
|
case RNCCL:
|
||||||
|
if(strlen((char *)d) == 0) nullstr[tptr] = TRUE;
|
||||||
|
break;
|
||||||
|
case STAR:
|
||||||
|
case QUEST:
|
||||||
|
nullstr[tptr] = TRUE;
|
||||||
|
parent[d] = tptr;
|
||||||
|
break;
|
||||||
|
case PLUS:
|
||||||
|
case CARAT:
|
||||||
|
nullstr[tptr] = nullstr[d];
|
||||||
|
parent[d] = tptr;
|
||||||
|
break;
|
||||||
|
case S2FINAL:
|
||||||
|
nullstr[tptr] = TRUE;
|
||||||
|
break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
case FINAL:
|
||||||
|
case S1FINAL:
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
warning("bad switch mn1 %d %d",a,d);
|
||||||
|
break;
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
if(tptr > treesize)
|
||||||
|
error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
|
||||||
|
return(tptr++);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
mn0(int a)
|
||||||
|
{
|
||||||
|
name[tptr] = a;
|
||||||
|
parent[tptr] = 0;
|
||||||
|
nullstr[tptr] = 0;
|
||||||
|
if(a >= NCH) switch(a){
|
||||||
|
case RNULLS: nullstr[tptr] = TRUE; break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
default:
|
||||||
|
warning("bad switch mn0 %d",a);
|
||||||
|
break;
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
if(tptr > treesize)
|
||||||
|
error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
|
||||||
|
return(tptr++);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
munputc(int p)
|
||||||
|
{
|
||||||
|
*pushptr++ = peek; /* watch out for this */
|
||||||
|
peek = p;
|
||||||
|
if(pushptr >= pushc+TOKENSIZE)
|
||||||
|
error("Too many characters pushed");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
munputs(uchar *p)
|
||||||
|
{
|
||||||
|
int i,j;
|
||||||
|
*pushptr++ = peek;
|
||||||
|
peek = p[0];
|
||||||
|
i = strlen((char*)p);
|
||||||
|
for(j = i-1; j>=1; j--)
|
||||||
|
*pushptr++ = p[j];
|
||||||
|
if(pushptr >= pushc+TOKENSIZE)
|
||||||
|
error("Too many characters pushed");
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
dupl(int n)
|
||||||
|
{
|
||||||
|
/* duplicate the subtree whose root is n, return ptr to it */
|
||||||
|
int i;
|
||||||
|
|
||||||
|
i = name[n];
|
||||||
|
if(i < NCH) return(mn0(i));
|
||||||
|
switch(i){
|
||||||
|
case RNULLS:
|
||||||
|
return(mn0(i));
|
||||||
|
case RCCL: case RNCCL: case FINAL: case S1FINAL: case S2FINAL:
|
||||||
|
return(mn1(i,left[n]));
|
||||||
|
case STAR: case QUEST: case PLUS: case CARAT:
|
||||||
|
return(mn1(i,dupl(left[n])));
|
||||||
|
case RSTR: case RSCON:
|
||||||
|
return(mn2(i,dupl(left[n]),right[n]));
|
||||||
|
case BAR: case RNEWE: case RCAT: case DIV:
|
||||||
|
return(mn2(i,dupl(left[n]),dupl(right[n])));
|
||||||
|
# ifdef DEBUG
|
||||||
|
default:
|
||||||
|
warning("bad switch dupl %d",n);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
void
|
||||||
|
allprint(int c)
|
||||||
|
{
|
||||||
|
switch(c){
|
||||||
|
case 014:
|
||||||
|
print("\\f");
|
||||||
|
charc++;
|
||||||
|
break;
|
||||||
|
case '\n':
|
||||||
|
print("\\n");
|
||||||
|
charc++;
|
||||||
|
break;
|
||||||
|
case '\t':
|
||||||
|
print("\\t");
|
||||||
|
charc++;
|
||||||
|
break;
|
||||||
|
case '\b':
|
||||||
|
print("\\b");
|
||||||
|
charc++;
|
||||||
|
break;
|
||||||
|
case ' ':
|
||||||
|
print("\\\bb");
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
if(!isprint(c)){
|
||||||
|
print("\\%-3o",c);
|
||||||
|
charc += 3;
|
||||||
|
} else
|
||||||
|
print("%c", c);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
charc++;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
strpt(uchar *s)
|
||||||
|
{
|
||||||
|
charc = 0;
|
||||||
|
while(*s){
|
||||||
|
allprint(*s++);
|
||||||
|
if(charc > LINESIZE){
|
||||||
|
charc = 0;
|
||||||
|
print("\n\t");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
sect1dump(void)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
print("Sect 1:\n");
|
||||||
|
if(def[0]){
|
||||||
|
print("str trans\n");
|
||||||
|
i = -1;
|
||||||
|
while(def[++i])
|
||||||
|
print("%s\t%s\n",def[i],subs[i]);
|
||||||
|
}
|
||||||
|
if(sname[0]){
|
||||||
|
print("start names\n");
|
||||||
|
i = -1;
|
||||||
|
while(sname[++i])
|
||||||
|
print("%s\n",sname[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
sect2dump(void)
|
||||||
|
{
|
||||||
|
print("Sect 2:\n");
|
||||||
|
treedump();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
treedump(void)
|
||||||
|
{
|
||||||
|
int t;
|
||||||
|
uchar *p;
|
||||||
|
print("treedump %d nodes:\n",tptr);
|
||||||
|
for(t=0;t<tptr;t++){
|
||||||
|
print("%4d ",t);
|
||||||
|
parent[t] ? print("p=%4d",parent[t]) : print(" ");
|
||||||
|
print(" ");
|
||||||
|
if(name[t] < NCH)
|
||||||
|
allprint(name[t]);
|
||||||
|
else switch(name[t]){
|
||||||
|
case RSTR:
|
||||||
|
print("%d ",left[t]);
|
||||||
|
allprint(right[t]);
|
||||||
|
break;
|
||||||
|
case RCCL:
|
||||||
|
print("ccl ");
|
||||||
|
strpt(left[t]);
|
||||||
|
break;
|
||||||
|
case RNCCL:
|
||||||
|
print("nccl ");
|
||||||
|
strpt(left[t]);
|
||||||
|
break;
|
||||||
|
case DIV:
|
||||||
|
print("/ %d %d",left[t],right[t]);
|
||||||
|
break;
|
||||||
|
case BAR:
|
||||||
|
print("| %d %d",left[t],right[t]);
|
||||||
|
break;
|
||||||
|
case RCAT:
|
||||||
|
print("cat %d %d",left[t],right[t]);
|
||||||
|
break;
|
||||||
|
case PLUS:
|
||||||
|
print("+ %d",left[t]);
|
||||||
|
break;
|
||||||
|
case STAR:
|
||||||
|
print("* %d",left[t]);
|
||||||
|
break;
|
||||||
|
case CARAT:
|
||||||
|
print("^ %d",left[t]);
|
||||||
|
break;
|
||||||
|
case QUEST:
|
||||||
|
print("? %d",left[t]);
|
||||||
|
break;
|
||||||
|
case RNULLS:
|
||||||
|
print("nullstring");
|
||||||
|
break;
|
||||||
|
case FINAL:
|
||||||
|
print("final %d",left[t]);
|
||||||
|
break;
|
||||||
|
case S1FINAL:
|
||||||
|
print("s1final %d",left[t]);
|
||||||
|
break;
|
||||||
|
case S2FINAL:
|
||||||
|
print("s2final %d",left[t]);
|
||||||
|
break;
|
||||||
|
case RNEWE:
|
||||||
|
print("new %d %d",left[t],right[t]);
|
||||||
|
break;
|
||||||
|
case RSCON:
|
||||||
|
p = (uchar *)right[t];
|
||||||
|
print("start %s",sname[*p++-1]);
|
||||||
|
while(*p)
|
||||||
|
print(", %s",sname[*p++-1]);
|
||||||
|
print(" %d",left[t]);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
print("unknown %d %d %d",name[t],left[t],right[t]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if(nullstr[t])print("\t(null poss.)");
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
# endif
|
||||||
856
src/cmd/lex/sub2.c
Normal file
856
src/cmd/lex/sub2.c
Normal file
|
|
@ -0,0 +1,856 @@
|
||||||
|
# include "ldefs.h"
|
||||||
|
void
|
||||||
|
cfoll(int v)
|
||||||
|
{
|
||||||
|
int i,j,k;
|
||||||
|
uchar *p;
|
||||||
|
i = name[v];
|
||||||
|
if(i < NCH) i = 1; /* character */
|
||||||
|
switch(i){
|
||||||
|
case 1: case RSTR: case RCCL: case RNCCL: case RNULLS:
|
||||||
|
for(j=0;j<tptr;j++)
|
||||||
|
tmpstat[j] = FALSE;
|
||||||
|
count = 0;
|
||||||
|
follow(v);
|
||||||
|
# ifdef PP
|
||||||
|
padd(foll,v); /* packing version */
|
||||||
|
# endif
|
||||||
|
# ifndef PP
|
||||||
|
add(foll,v); /* no packing version */
|
||||||
|
# endif
|
||||||
|
if(i == RSTR) cfoll(left[v]);
|
||||||
|
else if(i == RCCL || i == RNCCL){ /* compress ccl list */
|
||||||
|
for(j=1; j<NCH;j++)
|
||||||
|
symbol[j] = (i==RNCCL);
|
||||||
|
p = (uchar *)left[v];
|
||||||
|
while(*p)
|
||||||
|
symbol[*p++] = (i == RCCL);
|
||||||
|
p = pcptr;
|
||||||
|
for(j=1;j<NCH;j++)
|
||||||
|
if(symbol[j]){
|
||||||
|
for(k=0;p+k < pcptr; k++)
|
||||||
|
if(cindex[j] == *(p+k))
|
||||||
|
break;
|
||||||
|
if(p+k >= pcptr)*pcptr++ = cindex[j];
|
||||||
|
}
|
||||||
|
*pcptr++ = 0;
|
||||||
|
if(pcptr > pchar + pchlen)
|
||||||
|
error("Too many packed character classes");
|
||||||
|
left[v] = (int)p;
|
||||||
|
name[v] = RCCL; /* RNCCL eliminated */
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug && *p){
|
||||||
|
print("ccl %d: %d",v,*p++);
|
||||||
|
while(*p)
|
||||||
|
print(", %d",*p++);
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case CARAT:
|
||||||
|
cfoll(left[v]);
|
||||||
|
break;
|
||||||
|
case STAR: case PLUS: case QUEST: case RSCON:
|
||||||
|
cfoll(left[v]);
|
||||||
|
break;
|
||||||
|
case BAR: case RCAT: case DIV: case RNEWE:
|
||||||
|
cfoll(left[v]);
|
||||||
|
cfoll(right[v]);
|
||||||
|
break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
case FINAL:
|
||||||
|
case S1FINAL:
|
||||||
|
case S2FINAL:
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
warning("bad switch cfoll %d",v);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
void
|
||||||
|
pfoll(void)
|
||||||
|
{
|
||||||
|
int i,k,*p;
|
||||||
|
int j;
|
||||||
|
/* print sets of chars which may follow positions */
|
||||||
|
print("pos\tchars\n");
|
||||||
|
for(i=0;i<tptr;i++)
|
||||||
|
if(p=foll[i]){
|
||||||
|
j = *p++;
|
||||||
|
if(j >= 1){
|
||||||
|
print("%d:\t%d",i,*p++);
|
||||||
|
for(k=2;k<=j;k++)
|
||||||
|
print(", %d",*p++);
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
void
|
||||||
|
add(int **array, int n)
|
||||||
|
{
|
||||||
|
int i, *temp;
|
||||||
|
uchar *ctemp;
|
||||||
|
|
||||||
|
temp = nxtpos;
|
||||||
|
ctemp = tmpstat;
|
||||||
|
array[n] = nxtpos; /* note no packing is done in positions */
|
||||||
|
*temp++ = count;
|
||||||
|
for(i=0;i<tptr;i++)
|
||||||
|
if(ctemp[i] == TRUE)
|
||||||
|
*temp++ = i;
|
||||||
|
nxtpos = temp;
|
||||||
|
if(nxtpos >= positions+maxpos)
|
||||||
|
error("Too many positions %s",(maxpos== MAXPOS?"\nTry using %p num":""));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
follow(int v)
|
||||||
|
{
|
||||||
|
int p;
|
||||||
|
if(v >= tptr-1)return;
|
||||||
|
p = parent[v];
|
||||||
|
if(p == 0) return;
|
||||||
|
switch(name[p]){
|
||||||
|
/* will not be CHAR RNULLS FINAL S1FINAL S2FINAL RCCL RNCCL */
|
||||||
|
case RSTR:
|
||||||
|
if(tmpstat[p] == FALSE){
|
||||||
|
count++;
|
||||||
|
tmpstat[p] = TRUE;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case STAR: case PLUS:
|
||||||
|
first(v);
|
||||||
|
follow(p);
|
||||||
|
break;
|
||||||
|
case BAR: case QUEST: case RNEWE:
|
||||||
|
follow(p);
|
||||||
|
break;
|
||||||
|
case RCAT: case DIV:
|
||||||
|
if(v == left[p]){
|
||||||
|
if(nullstr[right[p]])
|
||||||
|
follow(p);
|
||||||
|
first(right[p]);
|
||||||
|
}
|
||||||
|
else follow(p);
|
||||||
|
break;
|
||||||
|
case RSCON: case CARAT:
|
||||||
|
follow(p);
|
||||||
|
break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
default:
|
||||||
|
warning("bad switch follow %d",p);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
first(int v) /* calculate set of positions with v as root which can be active initially */
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
uchar *p;
|
||||||
|
i = name[v];
|
||||||
|
if(i < NCH)i = 1;
|
||||||
|
switch(i){
|
||||||
|
case 1: case RCCL: case RNCCL: case RNULLS: case FINAL: case S1FINAL: case S2FINAL:
|
||||||
|
if(tmpstat[v] == FALSE){
|
||||||
|
count++;
|
||||||
|
tmpstat[v] = TRUE;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case BAR: case RNEWE:
|
||||||
|
first(left[v]);
|
||||||
|
first(right[v]);
|
||||||
|
break;
|
||||||
|
case CARAT:
|
||||||
|
if(stnum % 2 == 1)
|
||||||
|
first(left[v]);
|
||||||
|
break;
|
||||||
|
case RSCON:
|
||||||
|
i = stnum/2 +1;
|
||||||
|
p = (uchar *)right[v];
|
||||||
|
while(*p)
|
||||||
|
if(*p++ == i){
|
||||||
|
first(left[v]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case STAR: case QUEST: case PLUS: case RSTR:
|
||||||
|
first(left[v]);
|
||||||
|
break;
|
||||||
|
case RCAT: case DIV:
|
||||||
|
first(left[v]);
|
||||||
|
if(nullstr[left[v]])
|
||||||
|
first(right[v]);
|
||||||
|
break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
default:
|
||||||
|
warning("bad switch first %d",v);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
cgoto(void)
|
||||||
|
{
|
||||||
|
int i, j, s;
|
||||||
|
int npos, curpos, n;
|
||||||
|
int tryit;
|
||||||
|
uchar tch[NCH];
|
||||||
|
int tst[NCH];
|
||||||
|
uchar *q;
|
||||||
|
|
||||||
|
/* generate initial state, for each start condition */
|
||||||
|
Bprint(&fout,"int yyvstop[] = {\n0,\n");
|
||||||
|
while(stnum < 2 || stnum/2 < sptr){
|
||||||
|
for(i = 0; i<tptr; i++) tmpstat[i] = 0;
|
||||||
|
count = 0;
|
||||||
|
if(tptr > 0)first(tptr-1);
|
||||||
|
add(state,stnum);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug){
|
||||||
|
if(stnum > 1)
|
||||||
|
print("%s:\n",sname[stnum/2]);
|
||||||
|
pstate(stnum);
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
stnum++;
|
||||||
|
}
|
||||||
|
stnum--;
|
||||||
|
/* even stnum = might not be at line begin */
|
||||||
|
/* odd stnum = must be at line begin */
|
||||||
|
/* even states can occur anywhere, odd states only at line begin */
|
||||||
|
for(s = 0; s <= stnum; s++){
|
||||||
|
tryit = FALSE;
|
||||||
|
cpackflg[s] = FALSE;
|
||||||
|
sfall[s] = -1;
|
||||||
|
acompute(s);
|
||||||
|
for(i=0;i<NCH;i++) symbol[i] = 0;
|
||||||
|
npos = *state[s];
|
||||||
|
for(i = 1; i<=npos; i++){
|
||||||
|
curpos = *(state[s]+i);
|
||||||
|
if(name[curpos] < NCH) symbol[name[curpos]] = TRUE;
|
||||||
|
else switch(name[curpos]){
|
||||||
|
case RCCL:
|
||||||
|
tryit = TRUE;
|
||||||
|
q = (uchar *)left[curpos];
|
||||||
|
while(*q){
|
||||||
|
for(j=1;j<NCH;j++)
|
||||||
|
if(cindex[j] == *q)
|
||||||
|
symbol[j] = TRUE;
|
||||||
|
q++;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case RSTR:
|
||||||
|
symbol[right[curpos]] = TRUE;
|
||||||
|
break;
|
||||||
|
# ifdef DEBUG
|
||||||
|
case RNULLS:
|
||||||
|
case FINAL:
|
||||||
|
case S1FINAL:
|
||||||
|
case S2FINAL:
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
warning("bad switch cgoto %d state %d",curpos,s);
|
||||||
|
break;
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug){
|
||||||
|
print("State %d transitions on:\n\t",s);
|
||||||
|
charc = 0;
|
||||||
|
for(i = 1; i<NCH; i++){
|
||||||
|
if(symbol[i]) allprint(i);
|
||||||
|
if(charc > LINESIZE){
|
||||||
|
charc = 0;
|
||||||
|
print("\n\t");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
/* for each char, calculate next state */
|
||||||
|
n = 0;
|
||||||
|
for(i = 1; i<NCH; i++){
|
||||||
|
if(symbol[i]){
|
||||||
|
nextstate(s,i); /* executed for each state, transition pair */
|
||||||
|
xstate = notin(stnum);
|
||||||
|
if(xstate == -2) warning("bad state %d %o",s,i);
|
||||||
|
else if(xstate == -1){
|
||||||
|
if(stnum >= nstates)
|
||||||
|
error("Too many states %s",(nstates == NSTATES ? "\nTry using %n num":""));
|
||||||
|
add(state,++stnum);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)pstate(stnum);
|
||||||
|
# endif
|
||||||
|
tch[n] = i;
|
||||||
|
tst[n++] = stnum;
|
||||||
|
} else { /* xstate >= 0 ==> state exists */
|
||||||
|
tch[n] = i;
|
||||||
|
tst[n++] = xstate;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
tch[n] = 0;
|
||||||
|
tst[n] = -1;
|
||||||
|
/* pack transitions into permanent array */
|
||||||
|
if(n > 0) packtrans(s,tch,tst,n,tryit);
|
||||||
|
else gotof[s] = -1;
|
||||||
|
}
|
||||||
|
Bprint(&fout,"0};\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Beware -- 70% of total CPU time is spent in this subroutine -
|
||||||
|
if you don't believe me - try it yourself ! */
|
||||||
|
void
|
||||||
|
nextstate(int s, int c)
|
||||||
|
{
|
||||||
|
int j, *newpos;
|
||||||
|
uchar *temp, *tz;
|
||||||
|
int *pos, i, *f, num, curpos, number;
|
||||||
|
/* state to goto from state s on char c */
|
||||||
|
num = *state[s];
|
||||||
|
temp = tmpstat;
|
||||||
|
pos = state[s] + 1;
|
||||||
|
for(i = 0; i<num; i++){
|
||||||
|
curpos = *pos++;
|
||||||
|
j = name[curpos];
|
||||||
|
if(j < NCH && j == c
|
||||||
|
|| j == RSTR && c == right[curpos]
|
||||||
|
|| j == RCCL && member(c, (uchar *)left[curpos])){
|
||||||
|
f = foll[curpos];
|
||||||
|
number = *f;
|
||||||
|
newpos = f+1;
|
||||||
|
for(j=0;j<number;j++)
|
||||||
|
temp[*newpos++] = 2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
j = 0;
|
||||||
|
tz = temp + tptr;
|
||||||
|
while(temp < tz){
|
||||||
|
if(*temp == 2){
|
||||||
|
j++;
|
||||||
|
*temp++ = 1;
|
||||||
|
}
|
||||||
|
else *temp++ = 0;
|
||||||
|
}
|
||||||
|
count = j;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
notin(int n)
|
||||||
|
{ /* see if tmpstat occurs previously */
|
||||||
|
int *j,k;
|
||||||
|
uchar *temp;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
if(count == 0)
|
||||||
|
return(-2);
|
||||||
|
temp = tmpstat;
|
||||||
|
for(i=n;i>=0;i--){ /* for each state */
|
||||||
|
j = state[i];
|
||||||
|
if(count == *j++){
|
||||||
|
for(k=0;k<count;k++)
|
||||||
|
if(!temp[*j++])break;
|
||||||
|
if(k >= count)
|
||||||
|
return(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return(-1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
packtrans(int st, uchar *tch, int *tst, int cnt, int tryit)
|
||||||
|
{
|
||||||
|
/* pack transitions into nchar, nexts */
|
||||||
|
/* nchar is terminated by '\0', nexts uses cnt, followed by elements */
|
||||||
|
/* gotof[st] = index into nchr, nexts for state st */
|
||||||
|
|
||||||
|
/* sfall[st] = t implies t is fall back state for st */
|
||||||
|
/* == -1 implies no fall back */
|
||||||
|
|
||||||
|
int i,j,k;
|
||||||
|
int cmin, cval, tcnt, diff, p, *ast;
|
||||||
|
uchar *ach;
|
||||||
|
int go[NCH], temp[NCH], c;
|
||||||
|
int swork[NCH];
|
||||||
|
uchar cwork[NCH];
|
||||||
|
int upper;
|
||||||
|
|
||||||
|
rcount += cnt;
|
||||||
|
cmin = -1;
|
||||||
|
cval = NCH;
|
||||||
|
ast = tst;
|
||||||
|
ach = tch;
|
||||||
|
/* try to pack transitions using ccl's */
|
||||||
|
if(tryit){ /* ccl's used */
|
||||||
|
for(i=1;i<NCH;i++){
|
||||||
|
go[i] = temp[i] = -1;
|
||||||
|
symbol[i] = 1;
|
||||||
|
}
|
||||||
|
for(i=0;i<cnt;i++){
|
||||||
|
go[tch[i]] = tst[i];
|
||||||
|
symbol[tch[i]] = 0;
|
||||||
|
}
|
||||||
|
for(i=0; i<cnt;i++){
|
||||||
|
c = match[tch[i]];
|
||||||
|
if(go[c] != tst[i] || c == tch[i])
|
||||||
|
temp[tch[i]] = tst[i];
|
||||||
|
}
|
||||||
|
/* fill in error entries */
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
if(symbol[i]) temp[i] = -2; /* error trans */
|
||||||
|
/* count them */
|
||||||
|
k = 0;
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
if(temp[i] != -1)k++;
|
||||||
|
if(k <cnt){ /* compress by char */
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug) print("use compression %d, %d vs %d\n",st,k,cnt);
|
||||||
|
# endif
|
||||||
|
k = 0;
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
if(temp[i] != -1){
|
||||||
|
cwork[k] = i;
|
||||||
|
swork[k++] = (temp[i] == -2 ? -1 : temp[i]);
|
||||||
|
}
|
||||||
|
cwork[k] = 0;
|
||||||
|
# ifdef PC
|
||||||
|
ach = cwork;
|
||||||
|
ast = swork;
|
||||||
|
cnt = k;
|
||||||
|
cpackflg[st] = TRUE;
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for(i=0; i<st; i++){ /* get most similar state */
|
||||||
|
/* reject state with more transitions, state already represented by a third state,
|
||||||
|
and state which is compressed by char if ours is not to be */
|
||||||
|
if(sfall[i] != -1) continue;
|
||||||
|
if(cpackflg[st] == 1) if(!(cpackflg[i] == 1)) continue;
|
||||||
|
p = gotof[i];
|
||||||
|
if(p == -1) /* no transitions */ continue;
|
||||||
|
tcnt = nexts[p];
|
||||||
|
if(tcnt > cnt) continue;
|
||||||
|
diff = 0;
|
||||||
|
j = 0;
|
||||||
|
upper = p + tcnt;
|
||||||
|
while(ach[j] && p < upper){
|
||||||
|
while(ach[j] < nchar[p] && ach[j]){diff++; j++; }
|
||||||
|
if(ach[j] == 0)break;
|
||||||
|
if(ach[j] > nchar[p]){diff=NCH;break;}
|
||||||
|
/* ach[j] == nchar[p] */
|
||||||
|
if(ast[j] != nexts[++p] || ast[j] == -1 || (cpackflg[st] && ach[j] != match[ach[j]]))diff++;
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
while(ach[j]){
|
||||||
|
diff++;
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
if(p < upper)diff = NCH;
|
||||||
|
if(diff < cval && diff < tcnt){
|
||||||
|
cval = diff;
|
||||||
|
cmin = i;
|
||||||
|
if(cval == 0)break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* cmin = state "most like" state st */
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)print("select st %d for st %d diff %d\n",cmin,st,cval);
|
||||||
|
# endif
|
||||||
|
# ifdef PS
|
||||||
|
if(cmin != -1){ /* if we can use st cmin */
|
||||||
|
gotof[st] = nptr;
|
||||||
|
k = 0;
|
||||||
|
sfall[st] = cmin;
|
||||||
|
p = gotof[cmin]+1;
|
||||||
|
j = 0;
|
||||||
|
while(ach[j]){
|
||||||
|
/* if cmin has a transition on c, then so will st */
|
||||||
|
/* st may be "larger" than cmin, however */
|
||||||
|
while(ach[j] < nchar[p-1] && ach[j]){
|
||||||
|
k++;
|
||||||
|
nchar[nptr] = ach[j];
|
||||||
|
nexts[++nptr] = ast[j];
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
if(nchar[p-1] == 0)break;
|
||||||
|
if(ach[j] > nchar[p-1]){
|
||||||
|
warning("bad transition %d %d",st,cmin);
|
||||||
|
goto nopack;
|
||||||
|
}
|
||||||
|
/* ach[j] == nchar[p-1] */
|
||||||
|
if(ast[j] != nexts[p] || ast[j] == -1 || (cpackflg[st] && ach[j] != match[ach[j]])){
|
||||||
|
k++;
|
||||||
|
nchar[nptr] = ach[j];
|
||||||
|
nexts[++nptr] = ast[j];
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
while(ach[j]){
|
||||||
|
nchar[nptr] = ach[j];
|
||||||
|
nexts[++nptr] = ast[j++];
|
||||||
|
k++;
|
||||||
|
}
|
||||||
|
nexts[gotof[st]] = cnt = k;
|
||||||
|
nchar[nptr++] = 0;
|
||||||
|
} else {
|
||||||
|
# endif
|
||||||
|
nopack:
|
||||||
|
/* stick it in */
|
||||||
|
gotof[st] = nptr;
|
||||||
|
nexts[nptr] = cnt;
|
||||||
|
for(i=0;i<cnt;i++){
|
||||||
|
nchar[nptr] = ach[i];
|
||||||
|
nexts[++nptr] = ast[i];
|
||||||
|
}
|
||||||
|
nchar[nptr++] = 0;
|
||||||
|
# ifdef PS
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
if(cnt < 1){
|
||||||
|
gotof[st] = -1;
|
||||||
|
nptr--;
|
||||||
|
} else
|
||||||
|
if(nptr > ntrans)
|
||||||
|
error("Too many transitions %s",(ntrans==NTRANS?"\nTry using %a num":""));
|
||||||
|
}
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
void
|
||||||
|
pstate(int s)
|
||||||
|
{
|
||||||
|
int *p,i,j;
|
||||||
|
print("State %d:\n",s);
|
||||||
|
p = state[s];
|
||||||
|
i = *p++;
|
||||||
|
if(i == 0) return;
|
||||||
|
print("%4d",*p++);
|
||||||
|
for(j = 1; j<i; j++){
|
||||||
|
print(", %4d",*p++);
|
||||||
|
if(j%30 == 0)print("\n");
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
int
|
||||||
|
member(int d, uchar *t)
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
uchar *s;
|
||||||
|
|
||||||
|
c = d;
|
||||||
|
s = t;
|
||||||
|
c = cindex[c];
|
||||||
|
while(*s)
|
||||||
|
if(*s++ == c) return(1);
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
void
|
||||||
|
stprt(int i)
|
||||||
|
{
|
||||||
|
int p, t;
|
||||||
|
|
||||||
|
print("State %d:",i);
|
||||||
|
/* print actions, if any */
|
||||||
|
t = atable[i];
|
||||||
|
if(t != -1)print(" final");
|
||||||
|
print("\n");
|
||||||
|
if(cpackflg[i] == TRUE)print("backup char in use\n");
|
||||||
|
if(sfall[i] != -1)print("fall back state %d\n",sfall[i]);
|
||||||
|
p = gotof[i];
|
||||||
|
if(p == -1) return;
|
||||||
|
print("(%d transitions)\n",nexts[p]);
|
||||||
|
while(nchar[p]){
|
||||||
|
charc = 0;
|
||||||
|
if(nexts[p+1] >= 0)
|
||||||
|
print("%d\t",nexts[p+1]);
|
||||||
|
else print("err\t");
|
||||||
|
allprint(nchar[p++]);
|
||||||
|
while(nexts[p] == nexts[p+1] && nchar[p]){
|
||||||
|
if(charc > LINESIZE){
|
||||||
|
charc = 0;
|
||||||
|
print("\n\t");
|
||||||
|
}
|
||||||
|
allprint(nchar[p++]);
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
void
|
||||||
|
acompute(int s) /* compute action list = set of poss. actions */
|
||||||
|
{
|
||||||
|
int *p, i, j;
|
||||||
|
int cnt, m;
|
||||||
|
int temp[300], k, neg[300], n;
|
||||||
|
|
||||||
|
k = 0;
|
||||||
|
n = 0;
|
||||||
|
p = state[s];
|
||||||
|
cnt = *p++;
|
||||||
|
if(cnt > 300)
|
||||||
|
error("Too many positions for one state - acompute");
|
||||||
|
for(i=0;i<cnt;i++){
|
||||||
|
if(name[*p] == FINAL)temp[k++] = left[*p];
|
||||||
|
else if(name[*p] == S1FINAL){temp[k++] = left[*p];
|
||||||
|
if (left[*p] >= NACTIONS) error("Too many right contexts");
|
||||||
|
extra[left[*p]] = 1;
|
||||||
|
} else if(name[*p] == S2FINAL)neg[n++] = left[*p];
|
||||||
|
p++;
|
||||||
|
}
|
||||||
|
atable[s] = -1;
|
||||||
|
if(k < 1 && n < 1) return;
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug) print("final %d actions:",s);
|
||||||
|
# endif
|
||||||
|
/* sort action list */
|
||||||
|
for(i=0; i<k; i++)
|
||||||
|
for(j=i+1;j<k;j++)
|
||||||
|
if(temp[j] < temp[i]){
|
||||||
|
m = temp[j];
|
||||||
|
temp[j] = temp[i];
|
||||||
|
temp[i] = m;
|
||||||
|
}
|
||||||
|
/* remove dups */
|
||||||
|
for(i=0;i<k-1;i++)
|
||||||
|
if(temp[i] == temp[i+1]) temp[i] = 0;
|
||||||
|
/* copy to permanent quarters */
|
||||||
|
atable[s] = aptr;
|
||||||
|
# ifdef DEBUG
|
||||||
|
Bprint(&fout,"/* actions for state %d */",s);
|
||||||
|
# endif
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
for(i=0;i<k;i++)
|
||||||
|
if(temp[i] != 0){
|
||||||
|
Bprint(&fout,"%d,\n",temp[i]);
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)
|
||||||
|
print("%d ",temp[i]);
|
||||||
|
# endif
|
||||||
|
aptr++;
|
||||||
|
}
|
||||||
|
for(i=0;i<n;i++){ /* copy fall back actions - all neg */
|
||||||
|
Bprint(&fout,"%d,\n",neg[i]);
|
||||||
|
aptr++;
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)print("%d ",neg[i]);
|
||||||
|
# endif
|
||||||
|
}
|
||||||
|
# ifdef DEBUG
|
||||||
|
if(debug)print("\n");
|
||||||
|
# endif
|
||||||
|
Bprint(&fout,"0,\n");
|
||||||
|
aptr++;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
# ifdef DEBUG
|
||||||
|
void
|
||||||
|
pccl(void) {
|
||||||
|
/* print character class sets */
|
||||||
|
int i, j;
|
||||||
|
|
||||||
|
print("char class intersection\n");
|
||||||
|
for(i=0; i< ccount; i++){
|
||||||
|
charc = 0;
|
||||||
|
print("class %d:\n\t",i);
|
||||||
|
for(j=1;j<NCH;j++)
|
||||||
|
if(cindex[j] == i){
|
||||||
|
allprint(j);
|
||||||
|
if(charc > LINESIZE){
|
||||||
|
print("\n\t");
|
||||||
|
charc = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
charc = 0;
|
||||||
|
print("match:\n");
|
||||||
|
for(i=0;i<NCH;i++){
|
||||||
|
allprint(match[i]);
|
||||||
|
if(charc > LINESIZE){
|
||||||
|
print("\n");
|
||||||
|
charc = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
|
||||||
|
void
|
||||||
|
mkmatch(void)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
uchar tab[NCH];
|
||||||
|
|
||||||
|
for(i=0; i<ccount; i++)
|
||||||
|
tab[i] = 0;
|
||||||
|
for(i=1;i<NCH;i++)
|
||||||
|
if(tab[cindex[i]] == 0)
|
||||||
|
tab[cindex[i]] = i;
|
||||||
|
/* tab[i] = principal char for new ccl i */
|
||||||
|
for(i = 1; i<NCH; i++)
|
||||||
|
match[i] = tab[cindex[i]];
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
layout(void)
|
||||||
|
{
|
||||||
|
/* format and output final program's tables */
|
||||||
|
int i, j, k;
|
||||||
|
int top, bot, startup, omin;
|
||||||
|
|
||||||
|
for(i=0; i<outsize;i++)
|
||||||
|
verify[i] = advance[i] = 0;
|
||||||
|
omin = 0;
|
||||||
|
yytop = 0;
|
||||||
|
for(i=0; i<= stnum; i++){ /* for each state */
|
||||||
|
j = gotof[i];
|
||||||
|
if(j == -1){
|
||||||
|
stoff[i] = 0;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
bot = j;
|
||||||
|
while(nchar[j])j++;
|
||||||
|
top = j - 1;
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug) {
|
||||||
|
print("State %d: (layout)\n", i);
|
||||||
|
for(j=bot; j<=top;j++) {
|
||||||
|
print(" %o", nchar[j]);
|
||||||
|
if (j%10==0) print("\n");
|
||||||
|
}
|
||||||
|
print("\n");
|
||||||
|
}
|
||||||
|
# endif
|
||||||
|
while(verify[omin+NCH]) omin++;
|
||||||
|
startup = omin;
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug) print("bot,top %d, %d startup begins %d\n",bot,top,startup);
|
||||||
|
# endif
|
||||||
|
do {
|
||||||
|
startup += 1;
|
||||||
|
if(startup > outsize - NCH)
|
||||||
|
error("output table overflow");
|
||||||
|
for(j = bot; j<= top; j++){
|
||||||
|
k = startup + nchar[j];
|
||||||
|
if(verify[k])break;
|
||||||
|
}
|
||||||
|
} while (j <= top);
|
||||||
|
/* have found place */
|
||||||
|
# ifdef DEBUG
|
||||||
|
if (debug) print(" startup going to be %d\n", startup);
|
||||||
|
# endif
|
||||||
|
for(j = bot; j<= top; j++){
|
||||||
|
k = startup + nchar[j];
|
||||||
|
verify[k] = i+1; /* state number + 1*/
|
||||||
|
advance[k] = nexts[j+1]+1; /* state number + 1*/
|
||||||
|
if(yytop < k) yytop = k;
|
||||||
|
}
|
||||||
|
stoff[i] = startup;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* stoff[i] = offset into verify, advance for trans for state i */
|
||||||
|
/* put out yywork */
|
||||||
|
Bprint(&fout,"# define YYTYPE %s\n",stnum+1 >= NCH ? "int" : "Uchar");
|
||||||
|
Bprint(&fout,"struct yywork { YYTYPE verify, advance; } yycrank[] = {\n");
|
||||||
|
for(i=0;i<=yytop;i+=4){
|
||||||
|
for(j=0;j<4;j++){
|
||||||
|
k = i+j;
|
||||||
|
if(verify[k])
|
||||||
|
Bprint(&fout,"%d,%d,\t",verify[k],advance[k]);
|
||||||
|
else
|
||||||
|
Bprint(&fout,"0,0,\t");
|
||||||
|
}
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
}
|
||||||
|
Bprint(&fout,"0,0};\n");
|
||||||
|
|
||||||
|
/* put out yysvec */
|
||||||
|
|
||||||
|
Bprint(&fout,"struct yysvf yysvec[] = {\n");
|
||||||
|
Bprint(&fout,"0,\t0,\t0,\n");
|
||||||
|
for(i=0;i<=stnum;i++){ /* for each state */
|
||||||
|
if(cpackflg[i])stoff[i] = -stoff[i];
|
||||||
|
Bprint(&fout,"yycrank+%d,\t",stoff[i]);
|
||||||
|
if(sfall[i] != -1)
|
||||||
|
Bprint(&fout,"yysvec+%d,\t", sfall[i]+1); /* state + 1 */
|
||||||
|
else Bprint(&fout,"0,\t\t");
|
||||||
|
if(atable[i] != -1)
|
||||||
|
Bprint(&fout,"yyvstop+%d,",atable[i]);
|
||||||
|
else Bprint(&fout,"0,\t");
|
||||||
|
# ifdef DEBUG
|
||||||
|
Bprint(&fout,"\t\t/* state %d */",i);
|
||||||
|
# endif
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
}
|
||||||
|
Bprint(&fout,"0,\t0,\t0};\n");
|
||||||
|
|
||||||
|
/* put out yymatch */
|
||||||
|
|
||||||
|
Bprint(&fout,"struct yywork *yytop = yycrank+%d;\n",yytop);
|
||||||
|
Bprint(&fout,"struct yysvf *yybgin = yysvec+1;\n");
|
||||||
|
Bprint(&fout,"Uchar yymatch[] = {\n");
|
||||||
|
for(i=0; i<NCH; i+=8){
|
||||||
|
for(j=0; j<8; j++){
|
||||||
|
int fbch;
|
||||||
|
fbch = match[i+j];
|
||||||
|
if(isprint(fbch) && fbch != '\'' && fbch != '\\')
|
||||||
|
Bprint(&fout,"'%c' ,",fbch);
|
||||||
|
else Bprint(&fout,"0%-3o,",fbch);
|
||||||
|
}
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
}
|
||||||
|
Bprint(&fout,"0};\n");
|
||||||
|
/* put out yyextra */
|
||||||
|
Bprint(&fout,"Uchar yyextra[] = {\n");
|
||||||
|
for(i=0;i<casecount;i+=8){
|
||||||
|
for(j=0;j<8;j++)
|
||||||
|
Bprint(&fout, "%d,", i+j<NACTIONS ?
|
||||||
|
extra[i+j] : 0);
|
||||||
|
Bputc(&fout, '\n');
|
||||||
|
}
|
||||||
|
Bprint(&fout,"0};\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
# ifdef PP
|
||||||
|
void
|
||||||
|
padd(int **array, int n)
|
||||||
|
{
|
||||||
|
int i, *j, k;
|
||||||
|
|
||||||
|
array[n] = nxtpos;
|
||||||
|
if(count == 0){
|
||||||
|
*nxtpos++ = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
for(i=tptr-1;i>=0;i--){
|
||||||
|
j = array[i];
|
||||||
|
if(j && *j++ == count){
|
||||||
|
for(k=0;k<count;k++)
|
||||||
|
if(!tmpstat[*j++])break;
|
||||||
|
if(k >= count){
|
||||||
|
array[n] = array[i];
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
add(array,n);
|
||||||
|
}
|
||||||
|
# endif
|
||||||
Loading…
Add table
Add a link
Reference in a new issue