File: [local] / src / usr.bin / awk / Attic / lexyy.c (download)
Revision 1.1, Fri Jan 24 23:11:30 1997 UTC (27 years, 4 months ago) by millert
Branch: MAIN
Basically stock AT&T resarch awk until the awk vs. flex problems
have a better resolution.
|
typedef unsigned char Uchar;
# include <stdio.h>
# define U(x) x
# define NLSTATE yyprevious=YYNEWLINE
# define BEGIN yybgin = yysvec + 1 +
# define INITIAL 0
# define YYLERR yysvec
# define YYSTATE (yyestate-yysvec-1)
# define YYOPTIM 1
# define YYLMAX 200
# define output(c) putc(c,yyout)
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
# define yymore() (yymorfg=1)
# define ECHO fprintf(yyout, "%s",yytext)
# define REJECT { nstr = yyreject(); goto yyfussy;}
int yyleng; extern char yytext[];
int yymorfg;
extern Uchar *yysptr, yysbuf[];
int yytchar;
FILE *yyin = {stdin}, *yyout = {stdout};
extern int yylineno;
struct yysvf {
struct yywork *yystoff;
struct yysvf *yyother;
int *yystops;};
struct yysvf *yyestate;
extern struct yysvf yysvec[], *yybgin;
int yylook(void), yywrap(void), yyback(int *, int);
#define A 2
#define str 4
#define sc 6
#define reg 8
#define comment 10
/****************************************************************
Copyright (C) AT&T and Lucent Technologies 1996
All Rights Reserved
Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the names of AT&T or Lucent Technologies
or any of their entities not be used in advertising or publicity
pertaining to distribution of the software without specific,
written prior permission.
AT&T AND LUCENT DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL AT&T OR LUCENT OR ANY OF THEIR
ENTITIES BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
USE OR PERFORMANCE OF THIS SOFTWARE.
****************************************************************/
/* some of this depends on behavior of lex that
may not be preserved in other implementations of lex.
*/
#undef input /* defeat lex */
#undef unput
#include <stdlib.h>
#include <string.h>
#include "awk.h"
#include "awkgram.h"
extern YYSTYPE yylval;
extern int infunc;
int lineno = 1;
int bracecnt = 0;
int brackcnt = 0;
int parencnt = 0;
#define DEBUG
#ifdef DEBUG
# define RET(x) {if(dbg)printf("lex %s [%s]\n", tokname(x), yytext); return(x); }
#else
# define RET(x) return(x)
#endif
#define CADD if (cadd(gs, yytext[0]) == 0) { \
ERROR "string/reg expr %.30s... too long", gs->cbuf SYNTAX; \
BEGIN A; \
}
char *s;
Gstring *gs = 0; /* initialized in main() */
int cflag;
#define YYNEWLINE 10
yylex(void){
int nstr; extern int yyprevious;
switch (yybgin-yysvec-1) { /* witchcraft */
case 0:
BEGIN A;
break;
case sc:
BEGIN A;
RET('}');
}
while((nstr = yylook()) >= 0)
yyfussy: switch(nstr){
case 0:
if(yywrap()) return(0); break;
case 1:
{ lineno++; RET(NL); }
break;
case 2:
{ ; }
break;
case 3:
{ ; }
break;
case 4:
{ RET(';'); }
break;
case 5:
{ lineno++; }
break;
case 6:
{ RET(XBEGIN); }
break;
case 7:
{ RET(XEND); }
break;
case 8:
{ if (infunc) ERROR "illegal nested function" SYNTAX; RET(FUNC); }
break;
case 9:
{ if (!infunc) ERROR "return not in function" SYNTAX; RET(RETURN); }
break;
case 10:
{ RET(AND); }
break;
case 11:
{ RET(BOR); }
break;
case 12:
{ RET(NOT); }
break;
case 13:
{ yylval.i = NE; RET(NE); }
break;
case 14:
{ yylval.i = MATCH; RET(MATCHOP); }
break;
case 15:
{ yylval.i = NOTMATCH; RET(MATCHOP); }
break;
case 16:
{ yylval.i = LT; RET(LT); }
break;
case 17:
{ yylval.i = LE; RET(LE); }
break;
case 18:
{ yylval.i = EQ; RET(EQ); }
break;
case 19:
{ yylval.i = GE; RET(GE); }
break;
case 20:
{ yylval.i = GT; RET(GT); }
break;
case 21:
{ yylval.i = APPEND; RET(APPEND); }
break;
case 22:
{ yylval.i = INCR; RET(INCR); }
break;
case 23:
{ yylval.i = DECR; RET(DECR); }
break;
case 24:
{ yylval.i = ADDEQ; RET(ASGNOP); }
break;
case 25:
{ yylval.i = SUBEQ; RET(ASGNOP); }
break;
case 26:
{ yylval.i = MULTEQ; RET(ASGNOP); }
break;
case 27:
{ yylval.i = DIVEQ; RET(ASGNOP); }
break;
case 28:
{ yylval.i = MODEQ; RET(ASGNOP); }
break;
case 29:
{ yylval.i = POWEQ; RET(ASGNOP); }
break;
case 30:
{ yylval.i = POWEQ; RET(ASGNOP); }
break;
case 31:
{ yylval.i = ASSIGN; RET(ASGNOP); }
break;
case 32:
{ RET(POWER); }
break;
case 33:
{ RET(POWER); }
break;
case 34:
{ yylval.cp = fieldadr(atoi(yytext+1)); RET(FIELD); }
break;
case 35:
{ unputstr("(NF)"); return(INDIRECT); }
break;
case 36:
{ int c, n;
c = input(); unput(c);
if (c == '(' || c == '[' || (infunc && (n=isarg(yytext+1)) >= 0)) {
unputstr(yytext+1);
return(INDIRECT);
} else {
yylval.cp = setsymtab(yytext+1, "", 0.0, STR|NUM, symtab);
RET(IVAR);
}
}
break;
case 37:
{ RET(INDIRECT); }
break;
case 38:
{ yylval.cp = setsymtab(yytext, "", 0.0, NUM, symtab); RET(VARNF); }
break;
case 39:
{
yylval.cp = setsymtab(yytext, tostring(yytext), atof(yytext), CON|NUM, symtab);
/* should this also have STR set? */
RET(NUMBER); }
break;
case 40:
{ RET(WHILE); }
break;
case 41:
{ RET(FOR); }
break;
case 42:
{ RET(DO); }
break;
case 43:
{ RET(IF); }
break;
case 44:
{ RET(ELSE); }
break;
case 45:
{ RET(NEXT); }
break;
case 46:
{ RET(NEXTFILE); }
break;
case 47:
{ RET(EXIT); }
break;
case 48:
{ RET(BREAK); }
break;
case 49:
{ RET(CONTINUE); }
break;
case 50:
{ yylval.i = PRINT; RET(PRINT); }
break;
case 51:
{ yylval.i = PRINTF; RET(PRINTF); }
break;
case 52:
{ yylval.i = SPRINTF; RET(SPRINTF); }
break;
case 53:
{ yylval.i = SPLIT; RET(SPLIT); }
break;
case 54:
{ RET(SUBSTR); }
break;
case 55:
{ yylval.i = SUB; RET(SUB); }
break;
case 56:
{ yylval.i = GSUB; RET(GSUB); }
break;
case 57:
{ RET(INDEX); }
break;
case 58:
{ RET(MATCHFCN); }
break;
case 59:
{ RET(IN); }
break;
case 60:
{ RET(GETLINE); }
break;
case 61:
{ RET(CLOSE); }
break;
case 62:
{ RET(DELETE); }
break;
case 63:
{ yylval.i = FLENGTH; RET(BLTIN); }
break;
case 64:
{ yylval.i = FLOG; RET(BLTIN); }
break;
case 65:
{ yylval.i = FINT; RET(BLTIN); }
break;
case 66:
{ yylval.i = FEXP; RET(BLTIN); }
break;
case 67:
{ yylval.i = FSQRT; RET(BLTIN); }
break;
case 68:
{ yylval.i = FSIN; RET(BLTIN); }
break;
case 69:
{ yylval.i = FCOS; RET(BLTIN); }
break;
case 70:
{ yylval.i = FATAN; RET(BLTIN); }
break;
case 71:
{ yylval.i = FSYSTEM; RET(BLTIN); }
break;
case 72:
{ yylval.i = FRAND; RET(BLTIN); }
break;
case 73:
{ yylval.i = FSRAND; RET(BLTIN); }
break;
case 74:
{ yylval.i = FTOUPPER; RET(BLTIN); }
break;
case 75:
{ yylval.i = FTOLOWER; RET(BLTIN); }
break;
case 76:
{ yylval.i = FFLUSH; RET(BLTIN); }
break;
case 77:
{ int n, c;
c = input(); unput(c); /* look for '(' */
if (c != '(' && infunc && (n=isarg(yytext)) >= 0) {
yylval.i = n;
RET(ARG);
} else {
yylval.cp = setsymtab(yytext, "", 0.0, STR|NUM, symtab);
if (c == '(') {
RET(CALL);
} else {
RET(VAR);
}
}
}
break;
case 78:
{ BEGIN str; caddreset(gs); }
break;
case 79:
{ if (--bracecnt < 0) ERROR "extra }" SYNTAX; BEGIN sc; RET(';'); }
break;
case 80:
{ if (--brackcnt < 0) ERROR "extra ]" SYNTAX; RET(']'); }
break;
case 81:
{ if (--parencnt < 0) ERROR "extra )" SYNTAX; RET(')'); }
break;
case 82:
{ if (yytext[0] == '{') bracecnt++;
else if (yytext[0] == '[') brackcnt++;
else if (yytext[0] == '(') parencnt++;
RET(yylval.i = yytext[0]); /* everything else */ }
break;
case 83:
{ cadd(gs, '\\'); cadd(gs, yytext[1]); }
break;
case 84:
{ ERROR "newline in regular expression %.10s...", gs->cbuf SYNTAX; lineno++; BEGIN A; }
break;
case 85:
{ BEGIN A;
cadd(gs, 0);
yylval.s = tostring(gs->cbuf);
unput('/');
RET(REGEXPR); }
break;
case 86:
{ CADD; }
break;
case 87:
{ BEGIN A;
cadd(gs, 0); s = tostring(gs->cbuf);
cunadd(gs);
cadd(gs, ' '); cadd(gs, 0);
yylval.cp = setsymtab(gs->cbuf, s, 0.0, CON|STR, symtab);
RET(STRING); }
break;
case 88:
{ ERROR "newline in string %.10s...", gs->cbuf SYNTAX; lineno++; BEGIN A; }
break;
case 89:
{ cadd(gs, '"'); }
break;
case 90:
{ cadd(gs, '\n'); }
break;
case 91:
{ cadd(gs, '\t'); }
break;
case 92:
{ cadd(gs, '\f'); }
break;
case 93:
{ cadd(gs, '\r'); }
break;
case 94:
{ cadd(gs, '\b'); }
break;
case 95:
{ cadd(gs, '\v'); }
break;
case 96:
{ cadd(gs, '\007'); }
break;
case 97:
{ cadd(gs, '\\'); }
break;
case 98:
{ int n;
sscanf(yytext+1, "%o", &n); cadd(gs, n); }
break;
case 99:
{ int n; /* ANSI permits any number! */
sscanf(yytext+2, "%x", &n); cadd(gs, n); }
break;
case 100:
{ cadd(gs, yytext[1]); }
break;
case 101:
{ CADD; }
break;
case -1:
break;
default:
fprintf(yyout,"bad switch yylook %d",nstr);
} return(0); }
/* end of yylex */
void startreg(void) /* start parsing a regular expression */
{
BEGIN reg;
caddreset(gs);
}
/* input() and unput() are transcriptions of the standard lex
macros for input and output with additions for error message
printing. God help us all if someone changes how lex works.
*/
char ebuf[300];
char *ep = ebuf;
int input(void) /* get next lexical input character */
{
int c;
extern char *lexprog;
if (yysptr > yysbuf)
c = U(*--yysptr);
else if (lexprog != NULL) { /* awk '...' */
if ((c = *lexprog) != 0)
lexprog++;
} else /* awk -f ... */
c = pgetc();
if (c == '\n')
yylineno++;
else if (c == EOF)
c = 0;
if (ep >= ebuf + sizeof ebuf)
ep = ebuf;
return *ep++ = c;
}
void unput(int c) /* put lexical character back on input */
{
yytchar = c;
if (yytchar == '\n')
yylineno--;
*yysptr++ = yytchar;
if (--ep < ebuf)
ep = ebuf + sizeof(ebuf) - 1;
}
void unputstr(char *s) /* put a string back on input */
{
int i;
for (i = strlen(s)-1; i >= 0; i--)
unput(s[i]);
}
/* growing-string code */
const int CBUFLEN = 400;
Gstring *newGstring()
{
Gstring *gs = (Gstring *) malloc(sizeof(Gstring));
char *cp = (char *) malloc(CBUFLEN);
if (gs == 0 || cp == 0)
ERROR "Out of space for strings" FATAL;
gs->cbuf = cp;
gs->cmax = CBUFLEN;
gs->clen = 0;
return gs;
}
char *cadd(Gstring *gs, int c) /* add one char to gs->cbuf, grow as needed */
{
if (gs->clen >= gs->cmax) { /* need to grow */
gs->cmax *= 4;
gs->cbuf = (char *) realloc((void *) gs->cbuf, gs->cmax);
}
if (gs->cbuf != 0)
gs->cbuf[gs->clen++] = c;
return gs->cbuf;
}
void caddreset(Gstring *gs)
{
gs->clen = 0;
}
void cunadd(Gstring *gs)
{
if (gs->clen > 0)
gs->clen--;
}
void delGstring(Gstring *gs)
{
free((void *) gs->cbuf);
free((void *) gs);
}
int yyvstop[] = {
0,
82,
0,
3,
82,
0,
1,
0,
12,
82,
0,
78,
82,
0,
2,
82,
0,
37,
82,
0,
82,
0,
82,
0,
81,
82,
0,
82,
0,
82,
0,
82,
0,
82,
0,
82,
0,
39,
82,
0,
4,
82,
0,
16,
82,
0,
31,
82,
0,
20,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
82,
0,
80,
82,
0,
33,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
77,
82,
0,
82,
0,
79,
82,
0,
14,
82,
0,
101,
0,
88,
0,
87,
101,
0,
101,
0,
86,
0,
84,
0,
85,
86,
0,
86,
0,
3,
0,
13,
0,
15,
0,
2,
0,
34,
0,
36,
0,
36,
0,
28,
0,
10,
0,
32,
0,
26,
0,
22,
0,
24,
0,
23,
0,
25,
0,
39,
0,
27,
0,
39,
0,
39,
0,
17,
0,
18,
0,
19,
0,
21,
0,
77,
0,
77,
0,
77,
0,
38,
77,
0,
5,
0,
29,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
42,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
43,
77,
0,
59,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
11,
0,
100,
0,
89,
100,
0,
98,
100,
0,
97,
100,
0,
96,
100,
0,
94,
100,
0,
92,
100,
0,
90,
100,
0,
93,
100,
0,
91,
100,
0,
95,
100,
0,
100,
0,
83,
0,
35,
36,
0,
30,
0,
39,
0,
77,
0,
7,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
69,
77,
0,
77,
0,
77,
0,
77,
0,
66,
77,
0,
77,
0,
41,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
65,
77,
0,
77,
0,
64,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
68,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
55,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
98,
0,
99,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
44,
77,
0,
47,
77,
0,
77,
0,
8,
77,
0,
77,
0,
56,
77,
0,
77,
0,
77,
0,
77,
0,
45,
77,
0,
77,
0,
72,
77,
0,
77,
0,
77,
0,
77,
0,
67,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
98,
0,
6,
77,
0,
70,
77,
0,
48,
77,
0,
61,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
57,
77,
0,
77,
0,
58,
77,
0,
77,
0,
50,
77,
0,
77,
0,
53,
77,
0,
77,
0,
73,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
40,
77,
0,
77,
0,
62,
77,
0,
76,
77,
0,
77,
0,
77,
0,
63,
77,
0,
77,
0,
51,
77,
0,
9,
77,
0,
77,
0,
54,
77,
0,
71,
77,
0,
77,
0,
77,
0,
77,
0,
77,
0,
60,
77,
0,
77,
0,
52,
77,
0,
75,
77,
0,
74,
77,
0,
49,
77,
0,
8,
77,
0,
46,
77,
0,
0};
# define YYTYPE int
struct yywork { YYTYPE verify, advance; } yycrank[] = {
0,0, 0,0, 3,13, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 0,0, 3,14, 3,15,
0,0, 0,0, 0,0, 0,0,
0,0, 14,67, 0,0, 0,0,
0,0, 5,59, 0,0, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 5,59, 5,60, 0,0,
0,0, 0,0, 3,16, 3,17,
3,18, 3,19, 3,20, 3,21,
14,67, 37,95, 3,22, 3,23,
3,24, 70,0, 3,25, 3,26,
3,27, 3,28, 6,61, 0,0,
0,0, 0,0, 5,61, 0,0,
0,0, 3,28, 0,0, 0,0,
3,29, 3,30, 3,31, 3,32,
0,0, 21,75, 3,33, 3,34,
5,59, 10,65, 3,35, 23,76,
3,33, 0,0, 16,68, 0,0,
5,59, 0,0, 0,0, 3,36,
0,0, 0,0, 0,0, 0,0,
0,0, 5,59, 0,0, 24,78,
9,63, 20,74, 23,77, 5,59,
27,83, 3,37, 3,38, 3,39,
9,63, 9,64, 3,40, 3,41,
3,42, 3,43, 3,44, 3,45,
3,46, 24,79, 3,47, 25,80,
6,62, 3,48, 3,49, 3,50,
5,62, 3,51, 10,66, 3,52,
3,53, 3,54, 30,87, 31,88,
3,55, 32,89, 32,90, 25,81,
34,92, 3,56, 3,57, 3,58,
4,16, 4,17, 4,18, 4,19,
4,20, 4,21, 9,65, 9,63,
4,22, 4,23, 4,24, 16,69,
4,25, 4,26, 4,27, 9,63,
35,93, 36,94, 39,96, 40,97,
41,98, 43,101, 42,99, 44,103,
9,63, 42,100, 4,29, 4,30,
4,31, 4,32, 9,63, 43,102,
45,105, 4,34, 47,110, 44,104,
4,35, 49,114, 46,108, 50,115,
18,70, 45,106, 47,111, 48,112,
51,116, 4,36, 52,117, 45,107,
18,70, 18,0, 52,118, 9,66,
46,109, 48,113, 54,125, 55,126,
56,127, 76,142, 82,86, 4,37,
4,38, 4,39, 92,145, 93,146,
4,40, 4,41, 4,42, 4,43,
4,44, 4,45, 4,46, 97,147,
4,47, 98,148, 99,149, 4,48,
4,49, 4,50, 101,152, 4,51,
100,150, 4,52, 4,53, 4,54,
103,153, 100,151, 4,55, 18,70,
105,156, 53,119, 82,86, 4,56,
4,57, 4,58, 106,157, 18,70,
53,120, 53,121, 53,122, 104,154,
107,158, 53,123, 108,159, 109,160,
18,70, 53,124, 104,155, 111,161,
112,163, 113,164, 18,70, 19,71,
19,71, 19,71, 19,71, 19,71,
19,71, 19,71, 19,71, 19,71,
19,71, 114,165, 115,166, 111,162,
116,167, 117,168, 118,169, 119,170,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,73, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 121,173, 122,174,
123,175, 124,176, 19,72, 126,179,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 19,72, 19,72,
19,72, 19,72, 26,82, 26,82,
26,82, 26,82, 26,82, 26,82,
26,82, 26,82, 26,82, 26,82,
28,84, 145,182, 28,85, 28,85,
28,85, 28,85, 28,85, 28,85,
28,85, 28,85, 28,85, 28,85,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 120,171, 28,86,
147,183, 148,184, 149,185, 150,186,
120,172, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 28,86,
152,187, 153,188, 154,189, 33,91,
156,190, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 33,91,
33,91, 33,91, 33,91, 62,128,
158,191, 66,140, 159,192, 160,193,
161,194, 163,195, 165,196, 62,128,
62,0, 66,140, 66,0, 71,71,
71,71, 71,71, 71,71, 71,71,
71,71, 71,71, 71,71, 71,71,
71,71, 72,72, 72,72, 72,72,
72,72, 72,72, 72,72, 72,72,
72,72, 72,72, 72,72, 166,197,
62,129, 167,198, 168,199, 169,200,
73,72, 73,72, 73,72, 73,72,
73,72, 73,72, 73,72, 73,72,
73,72, 73,72, 62,130, 171,201,
66,140, 172,202, 125,177, 72,72,
173,203, 174,204, 62,128, 175,205,
66,140, 176,206, 73,141, 125,178,
177,207, 178,208, 179,209, 62,128,
182,211, 66,140, 73,72, 183,212,
184,213, 62,128, 185,214, 66,140,
84,84, 84,84, 84,84, 84,84,
84,84, 84,84, 84,84, 84,84,
84,84, 84,84, 130,180, 130,180,
130,180, 130,180, 130,180, 130,180,
130,180, 130,180, 62,131, 186,215,
187,216, 84,86, 190,217, 62,132,
62,133, 191,218, 192,219, 194,220,
62,134, 195,221, 196,222, 197,223,
198,224, 200,225, 201,226, 202,227,
62,135, 204,228, 205,229, 206,230,
62,136, 207,231, 62,137, 208,232,
62,138, 209,233, 62,139, 215,234,
216,235, 86,143, 217,236, 86,143,
218,237, 84,86, 86,144, 86,144,
86,144, 86,144, 86,144, 86,144,
86,144, 86,144, 86,144, 86,144,
139,181, 139,181, 139,181, 139,181,
139,181, 139,181, 139,181, 139,181,
139,181, 139,181, 219,238, 221,239,
223,240, 224,241, 225,242, 227,243,
229,244, 139,181, 139,181, 139,181,
139,181, 139,181, 139,181, 230,245,
231,246, 141,72, 141,72, 141,72,
141,72, 141,72, 141,72, 141,72,
141,72, 141,72, 141,72, 143,144,
143,144, 143,144, 143,144, 143,144,
143,144, 143,144, 143,144, 143,144,
143,144, 232,247, 234,248, 237,249,
238,250, 139,181, 139,181, 139,181,
139,181, 139,181, 139,181, 141,72,
180,210, 180,210, 180,210, 180,210,
180,210, 180,210, 180,210, 180,210,
240,251, 243,252, 246,253, 247,254,
248,255, 249,256, 251,257, 0,0,
0,0};
struct yysvf yysvec[] = {
0, 0, 0,
yycrank+0, 0, 0,
yycrank+0, 0, 0,
yycrank+-1, 0, 0,
yycrank+-95, yysvec+3, 0,
yycrank+-20, 0, 0,
yycrank+-16, yysvec+5, 0,
yycrank+0, 0, 0,
yycrank+0, 0, 0,
yycrank+-87, 0, 0,
yycrank+-22, yysvec+9, 0,
yycrank+0, 0, 0,
yycrank+0, 0, 0,
yycrank+0, 0, yyvstop+1,
yycrank+8, 0, yyvstop+3,
yycrank+0, 0, yyvstop+6,
yycrank+13, 0, yyvstop+8,
yycrank+0, 0, yyvstop+11,
yycrank+-167, 0, yyvstop+14,
yycrank+191, 0, yyvstop+17,
yycrank+28, 0, yyvstop+20,
yycrank+27, 0, yyvstop+22,
yycrank+0, 0, yyvstop+24,
yycrank+29, 0, yyvstop+27,
yycrank+44, 0, yyvstop+29,
yycrank+62, 0, yyvstop+31,
yycrank+266, 0, yyvstop+33,
yycrank+31, 0, yyvstop+35,
yycrank+278, 0, yyvstop+37,
yycrank+0, 0, yyvstop+40,
yycrank+57, 0, yyvstop+43,
yycrank+58, 0, yyvstop+46,
yycrank+60, 0, yyvstop+49,
yycrank+288, 0, yyvstop+52,
yycrank+55, yysvec+33, yyvstop+55,
yycrank+66, yysvec+33, yyvstop+58,
yycrank+75, yysvec+33, yyvstop+61,
yycrank+31, 0, yyvstop+64,
yycrank+0, 0, yyvstop+66,
yycrank+85, 0, yyvstop+69,
yycrank+31, yysvec+33, yyvstop+72,
yycrank+34, yysvec+33, yyvstop+75,
yycrank+42, yysvec+33, yyvstop+78,
yycrank+48, yysvec+33, yyvstop+81,
yycrank+43, yysvec+33, yyvstop+84,
yycrank+58, yysvec+33, yyvstop+87,
yycrank+65, yysvec+33, yyvstop+90,
yycrank+60, yysvec+33, yyvstop+93,
yycrank+70, yysvec+33, yyvstop+96,
yycrank+68, yysvec+33, yyvstop+99,
yycrank+66, yysvec+33, yyvstop+102,
yycrank+58, yysvec+33, yyvstop+105,
yycrank+77, yysvec+33, yyvstop+108,
yycrank+112, yysvec+33, yyvstop+111,
yycrank+71, yysvec+33, yyvstop+114,
yycrank+79, yysvec+33, yyvstop+117,
yycrank+60, 0, yyvstop+120,
yycrank+0, 0, yyvstop+122,
yycrank+0, 0, yyvstop+125,
yycrank+0, 0, yyvstop+128,
yycrank+0, 0, yyvstop+130,
yycrank+0, 0, yyvstop+132,
yycrank+-410, 0, yyvstop+135,
yycrank+0, 0, yyvstop+137,
yycrank+0, 0, yyvstop+139,
yycrank+0, 0, yyvstop+141,
yycrank+-412, 0, yyvstop+144,
yycrank+0, yysvec+14, yyvstop+146,
yycrank+0, 0, yyvstop+148,
yycrank+0, 0, yyvstop+150,
yycrank+-35, yysvec+18, yyvstop+152,
yycrank+375, 0, yyvstop+154,
yycrank+385, yysvec+19, yyvstop+156,
yycrank+400, yysvec+19, yyvstop+158,
yycrank+0, 0, yyvstop+160,
yycrank+0, 0, yyvstop+162,
yycrank+124, 0, yyvstop+164,
yycrank+0, 0, yyvstop+166,
yycrank+0, 0, yyvstop+168,
yycrank+0, 0, yyvstop+170,
yycrank+0, 0, yyvstop+172,
yycrank+0, 0, yyvstop+174,
yycrank+117, yysvec+26, yyvstop+176,
yycrank+0, 0, yyvstop+178,
yycrank+436, 0, yyvstop+180,
yycrank+0, yysvec+28, yyvstop+182,
yycrank+490, 0, 0,
yycrank+0, 0, yyvstop+184,
yycrank+0, 0, yyvstop+186,
yycrank+0, 0, yyvstop+188,
yycrank+0, 0, yyvstop+190,
yycrank+0, yysvec+33, yyvstop+192,
yycrank+119, yysvec+33, yyvstop+194,
yycrank+123, yysvec+33, yyvstop+196,
yycrank+0, yysvec+33, yyvstop+198,
yycrank+0, 0, yyvstop+201,
yycrank+0, 0, yyvstop+203,
yycrank+102, yysvec+33, yyvstop+205,
yycrank+100, yysvec+33, yyvstop+207,
yycrank+91, yysvec+33, yyvstop+209,
yycrank+98, yysvec+33, yyvstop+211,
yycrank+98, yysvec+33, yyvstop+213,
yycrank+0, yysvec+33, yyvstop+215,
yycrank+97, yysvec+33, yyvstop+218,
yycrank+122, yysvec+33, yyvstop+220,
yycrank+108, yysvec+33, yyvstop+222,
yycrank+108, yysvec+33, yyvstop+224,
yycrank+118, yysvec+33, yyvstop+226,
yycrank+114, yysvec+33, yyvstop+228,
yycrank+114, yysvec+33, yyvstop+230,
yycrank+0, yysvec+33, yyvstop+232,
yycrank+135, yysvec+33, yyvstop+235,
yycrank+126, yysvec+33, yyvstop+238,
yycrank+134, yysvec+33, yyvstop+240,
yycrank+133, yysvec+33, yyvstop+242,
yycrank+130, yysvec+33, yyvstop+244,
yycrank+147, yysvec+33, yyvstop+246,
yycrank+143, yysvec+33, yyvstop+248,
yycrank+138, yysvec+33, yyvstop+250,
yycrank+145, yysvec+33, yyvstop+252,
yycrank+238, yysvec+33, yyvstop+254,
yycrank+168, yysvec+33, yyvstop+256,
yycrank+186, yysvec+33, yyvstop+258,
yycrank+186, yysvec+33, yyvstop+260,
yycrank+170, yysvec+33, yyvstop+262,
yycrank+354, yysvec+33, yyvstop+264,
yycrank+182, yysvec+33, yyvstop+266,
yycrank+0, 0, yyvstop+268,
yycrank+0, 0, yyvstop+270,
yycrank+0, 0, yyvstop+272,
yycrank+446, 0, yyvstop+275,
yycrank+0, 0, yyvstop+278,
yycrank+0, 0, yyvstop+281,
yycrank+0, 0, yyvstop+284,
yycrank+0, 0, yyvstop+287,
yycrank+0, 0, yyvstop+290,
yycrank+0, 0, yyvstop+293,
yycrank+0, 0, yyvstop+296,
yycrank+0, 0, yyvstop+299,
yycrank+500, 0, yyvstop+302,
yycrank+0, 0, yyvstop+304,
yycrank+525, yysvec+19, yyvstop+306,
yycrank+0, 0, yyvstop+309,
yycrank+535, 0, 0,
yycrank+0, yysvec+143, yyvstop+311,
yycrank+252, yysvec+33, yyvstop+313,
yycrank+0, yysvec+33, yyvstop+315,
yycrank+238, yysvec+33, yyvstop+318,
yycrank+252, yysvec+33, yyvstop+320,
yycrank+235, yysvec+33, yyvstop+322,
yycrank+235, yysvec+33, yyvstop+324,
yycrank+0, yysvec+33, yyvstop+326,
yycrank+279, yysvec+33, yyvstop+329,
yycrank+280, yysvec+33, yyvstop+331,
yycrank+266, yysvec+33, yyvstop+333,
yycrank+0, yysvec+33, yyvstop+335,
yycrank+267, yysvec+33, yyvstop+338,
yycrank+0, yysvec+33, yyvstop+340,
yycrank+313, yysvec+33, yyvstop+343,
yycrank+306, yysvec+33, yyvstop+345,
yycrank+317, yysvec+33, yyvstop+347,
yycrank+315, yysvec+33, yyvstop+349,
yycrank+0, yysvec+33, yyvstop+351,
yycrank+314, yysvec+33, yyvstop+354,
yycrank+0, yysvec+33, yyvstop+356,
yycrank+319, yysvec+33, yyvstop+359,
yycrank+327, yysvec+33, yyvstop+361,
yycrank+335, yysvec+33, yyvstop+363,
yycrank+346, yysvec+33, yyvstop+365,
yycrank+330, yysvec+33, yyvstop+367,
yycrank+0, yysvec+33, yyvstop+369,
yycrank+354, yysvec+33, yyvstop+372,
yycrank+356, yysvec+33, yyvstop+374,
yycrank+348, yysvec+33, yyvstop+376,
yycrank+355, yysvec+33, yyvstop+378,
yycrank+352, yysvec+33, yyvstop+380,
yycrank+353, yysvec+33, yyvstop+383,
yycrank+361, yysvec+33, yyvstop+385,
yycrank+361, yysvec+33, yyvstop+387,
yycrank+366, yysvec+33, yyvstop+389,
yycrank+556, 0, yyvstop+391,
yycrank+0, yysvec+139, yyvstop+393,
yycrank+398, yysvec+33, yyvstop+395,
yycrank+429, yysvec+33, yyvstop+397,
yycrank+373, yysvec+33, yyvstop+399,
yycrank+381, yysvec+33, yyvstop+401,
yycrank+398, yysvec+33, yyvstop+403,
yycrank+388, yysvec+33, yyvstop+405,
yycrank+0, yysvec+33, yyvstop+407,
yycrank+0, yysvec+33, yyvstop+410,
yycrank+391, yysvec+33, yyvstop+413,
yycrank+393, yysvec+33, yyvstop+415,
yycrank+405, yysvec+33, yyvstop+418,
yycrank+0, yysvec+33, yyvstop+420,
yycrank+391, yysvec+33, yyvstop+423,
yycrank+397, yysvec+33, yyvstop+425,
yycrank+410, yysvec+33, yyvstop+427,
yycrank+413, yysvec+33, yyvstop+429,
yycrank+400, yysvec+33, yyvstop+432,
yycrank+0, yysvec+33, yyvstop+434,
yycrank+403, yysvec+33, yyvstop+437,
yycrank+402, yysvec+33, yyvstop+439,
yycrank+409, yysvec+33, yyvstop+441,
yycrank+0, yysvec+33, yyvstop+443,
yycrank+421, yysvec+33, yyvstop+446,
yycrank+406, yysvec+33, yyvstop+448,
yycrank+422, yysvec+33, yyvstop+450,
yycrank+406, yysvec+33, yyvstop+452,
yycrank+415, yysvec+33, yyvstop+454,
yycrank+428, yysvec+33, yyvstop+456,
yycrank+0, 0, yyvstop+458,
yycrank+0, yysvec+33, yyvstop+460,
yycrank+0, yysvec+33, yyvstop+463,
yycrank+0, yysvec+33, yyvstop+466,
yycrank+0, yysvec+33, yyvstop+469,
yycrank+421, yysvec+33, yyvstop+472,
yycrank+431, yysvec+33, yyvstop+474,
yycrank+430, yysvec+33, yyvstop+476,
yycrank+431, yysvec+33, yyvstop+478,
yycrank+448, yysvec+33, yyvstop+480,
yycrank+0, yysvec+33, yyvstop+482,
yycrank+455, yysvec+33, yyvstop+485,
yycrank+0, yysvec+33, yyvstop+487,
yycrank+455, yysvec+33, yyvstop+490,
yycrank+459, yysvec+33, yyvstop+492,
yycrank+452, yysvec+33, yyvstop+495,
yycrank+0, yysvec+33, yyvstop+497,
yycrank+447, yysvec+33, yyvstop+500,
yycrank+0, yysvec+33, yyvstop+502,
yycrank+450, yysvec+33, yyvstop+505,
yycrank+462, yysvec+33, yyvstop+507,
yycrank+471, yysvec+33, yyvstop+509,
yycrank+492, yysvec+33, yyvstop+511,
yycrank+0, yysvec+33, yyvstop+513,
yycrank+477, yysvec+33, yyvstop+516,
yycrank+0, yysvec+33, yyvstop+518,
yycrank+0, yysvec+33, yyvstop+521,
yycrank+484, yysvec+33, yyvstop+524,
yycrank+495, yysvec+33, yyvstop+526,
yycrank+0, yysvec+33, yyvstop+528,
yycrank+504, yysvec+33, yyvstop+531,
yycrank+0, yysvec+33, yyvstop+533,
yycrank+0, yysvec+33, yyvstop+536,
yycrank+511, yysvec+33, yyvstop+539,
yycrank+0, yysvec+33, yyvstop+541,
yycrank+0, yysvec+33, yyvstop+544,
yycrank+500, yysvec+33, yyvstop+547,
yycrank+501, yysvec+33, yyvstop+549,
yycrank+515, yysvec+33, yyvstop+551,
yycrank+507, yysvec+33, yyvstop+553,
yycrank+0, yysvec+33, yyvstop+555,
yycrank+517, yysvec+33, yyvstop+558,
yycrank+0, yysvec+33, yyvstop+560,
yycrank+0, yysvec+33, yyvstop+563,
yycrank+0, yysvec+33, yyvstop+566,
yycrank+0, yysvec+33, yyvstop+569,
yycrank+0, yysvec+33, yyvstop+572,
yycrank+0, yysvec+33, yyvstop+575,
0, 0, 0};
struct yywork *yytop = yycrank+618;
struct yysvf *yybgin = yysvec+1;
Uchar yymatch[] = {
00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
011 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
'8' ,'8' ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
'G' ,'G' ,'G' ,01 ,01 ,01 ,01 ,'G' ,
01 ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
'G' ,'G' ,'G' ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
0};
Uchar yyextra[] = {
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};
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){
return(input());
}
void
yyoutput(int c)
{
output(c);
}
void
yyunput(int c)
{
unput(c);
}
![[BACK]](/icons/back.gif){kind=icon}
Return to lexyy.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / awk