#define LEX
/*** Just added by Bub ***/
# 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 BUFSIZ
# 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 char *yysptr, yysbuf[];
int yytchar;
/*** The VAX doesn't like this declaration..... Lets try.... (bub) ***/
/*FILE *yyin = {stdin}, *yyout = {stdout};*/
#define yyin stdin
#define yyout stdout
extern int yylineno;
struct yysvf {
struct yywork *yystoff;
struct yysvf *yyother;
int *yystops;};
struct yysvf *yyestate;
extern struct yysvf yysvec[], *yybgin;
/* next error will still return 1 by default */
#include "y-tab.h"
#define FLEX_SCANNER
#include "lint.h"
#include <string.h>
#include "lnode.h"
#include "config.h"
int current_line;
int total_lines; /* Used to compute average compiled lines/s */
char *current_file;
extern char *argument_name;
int number(), lookup_table(), string(), atoi();
/*
* Flex doesn't handle negative characters, but this change will at least
* not crash the game.
*/
#ifdef YY_FATAL_ERROR
#undef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) \
{ \
fputs( msg, stderr ); \
putc( '\n', stderr ); \
error(msg); \
}
#endif
#ifdef FLEX
#define yywrap() 1
#endif
/*
* using a lookup table cuts the size of the lexer down
*/
struct tl {
char *name;
int ret_val;
};
static struct tl table[] = {
{"remote_command" , F_REMOTE_COMMAND },
{"ls" , F_LS },
{"cat" , F_CAT },
{"grep" , F_GREP },
{"rm" , F_RM },
{"log_file" , F_LOG_FILE },
{"else" , F_ELSE },
{"reallocate" , F_REALLOCATE },
{"index" , F_INDEX },
{"searcha" , F_SEARCHA },
{"in_editor" , F_IN_EDITOR },
{"contents" , F_CONTENTS },
{"find_living" , F_FIND_LIVING },
{"find_player" , F_FIND_PLAYER },
{"previous_object" , F_PREVIOUS_OBJECT },
{"inherit" , F_INHERIT },
{"tell_object" , F_TELL_OBJECT },
{"query_host_name" , F_QUERY_HOST_NAME },
{"tail" , F_TAIL },
{"file_name" , F_FILE_NAME },
{"query_verb" , F_QUERY_VERB },
{"this_verb" , F_QUERY_VERB },
{"snoop" , F_SNOOP },
{"input_to" , F_INPUT_TO },
{"rmdir" , F_RMDIR },
{"mkdir" , F_MKDIR },
{"crypt" , F_CRYPT },
{"first_inventory" , F_FIRST_INVENTORY },
{"regcomp" , F_REGCOMP },
{"regexec" , F_REGEXEC },
{"transfer" , F_TRANSFER },
{"next_inventory" , F_NEXT_INVENTORY },
{"string" , F_STRING_DECL },
{"shout" , F_SHOUT },
{"sscanf" , F_SSCANF },
{"extract" , F_EXTRACT },
{"ed" , F_ED },
{"localcmd" , F_LOCALCMD },
{"swap" , F_SWAP },
{"explode" , F_EXPLODE },
{"break" , F_BREAK },
{"intp" , F_INTP },
{"pointerp" , F_POINTERP },
{"objectp" , F_OBJECTP },
{"stringp" , F_STRINGP },
{"users" , F_USERS },
{"ctime" , F_CTIME },
{"disable_commands" , F_DISABLE_COMMANDS },
{"allocate" , F_ALLOCATE },
{"combine_free_list" , F_COMBINE_FREE_LIST },
{"continue" , F_CONTINUE },
{"while" , F_WHILE },
{"capitalize" , F_CAPITALIZE },
{"living" , F_LIVING },
{"interactive" , F_INTERACTIVE },
{"lower_case" , F_LOWER_CASE },
{"set_heart_beat" , F_SET_HEART_BEAT },
{"strlen" , F_STRLEN },
{"say" , F_SAY },
{"tell_room" , F_TELL_ROOM },
{"find_object" , F_FIND_OBJECT },
{"add_worth" , F_ADD_WORTH },
{"time" , F_TIME },
{"create_wizard" , F_CREATE_WIZARD },
{"destruct" , F_DESTRUCT },
{"static" , F_STATIC },
{"environment" , F_ENVIRONMENT },
{"save_object" , F_SAVE_OBJECT },
{"enable_commands" , F_ENABLE_COMMANDS },
{"sizeof" , F_SIZEOF },
{"random" , F_RANDOM },
{"restore_object" , F_RESTORE_OBJECT },
{"this_object" , F_THIS_OBJECT },
{"clone_object" , F_CLONE_OBJECT },
{"this_player" , F_THIS_PLAYER },
{"if" , F_IF },
{"status" , F_STATUS },
{"object" , F_STATUS },
{"return" , F_RETURN },
{"write" , F_WRITE },
{"add_verb" , F_ADD_VERB },
{"add_xverb" , F_ADD_XVERB },
{"add_adj" , F_ADD_ADJ },
{"add_subst" , F_ADD_SUBST },
{"add_action" , F_ADD_ACTION },
{"move_object" , F_MOVE_OBJECT },
{"present" , F_PRESENT },
{"call_out" , F_CALL_OUT },
{"remove_call_out" , F_REMOVE_CALL_OUT },
{"find_call_out" , F_FIND_CALL_OUT },
{"creator" , F_CREATOR },
{"caller" , F_CALLER },
{"query_ip_number" , F_QUERY_IP_NUMBER },
{"command" , F_COMMAND },
{"set_light" , F_SET_LIGHT },
{"int" , F_INT },
{"call_other" , F_CALL_OTHER },
{"shutdown" , F_SHUTDOWN },
{"typeof" , F_TYPEOF },
{"cp" , F_CP },
{"rename" , F_RENAME },
{"read_file" , F_READ_FILE },
{"query_snoop" , F_QUERY_SNOOP },
{"write_file" , F_WRITE_FILE },
{"file_size" , F_FILE_SIZE },
{"parse_command" , F_PARSE_COMMAND },
{"implode" , F_IMPLODE },
{"query_idle" , F_QUERY_IDLE },
{"do" , F_DO },
{"for" , F_FOR },
{"filter_objects" , F_FILTER_OBJECTS },
{"query_load_average" , F_QUERY_LOAD_AVERAGE },
{"catch" , F_CATCH },
{"throw" , F_THROW },
{"set_bit" , F_SET_BIT },
{"clear_bit" , F_CLEAR_BIT },
{"test_bit" , F_TEST_BIT },
{"notify_fail" , F_NOTIFY_FAIL },
{"set_living_name" , F_SET_LIVING_NAME },
{ 0, 0}
};
extern char *local_names[];
extern int current_number_of_locals;
extern char *string_copy();
void pre_processor_info();
# define YYNEWLINE 10
yylex(){
int nstr; extern int yyprevious;
while((nstr = yylook()) >= 0)
yyfussy: switch(nstr){
case 0:
if(yywrap()) return(0); break;
case 1:
{ return ';'; }
break;
case 2:
{ return '('; }
break;
case 3:
{ return ')'; }
break;
case 4:
{ return ','; }
break;
case 5:
{ return '{'; }
break;
case 6:
{ return '}'; }
break;
case 7:
{ return F_INC; }
break;
case 8:
{ return F_DEC; }
break;
case 9:
{ return '?'; }
break;
case 10:
{ return ':'; }
break;
case 11:
{ return '~'; }
break;
case 12:
{ return F_LAND; }
break;
case 13:
{ return '&'; }
break;
case 14:
{ return F_AND_EQ; }
break;
case 15:
{ return F_LOR; }
break;
case 16:
{ return '|'; }
break;
case 17:
{ return F_OR_EQ; }
break;
case 18:
{ return '^'; }
break;
case 19:
{ return F_XOR_EQ; }
break;
case 20:
{ return F_LSH; }
break;
case 21:
{ return F_LSH_EQ; }
break;
case 22:
{ return F_RSH; }
break;
case 23:
{ return F_RSH_EQ; }
break;
case 24:
{ return F_NOT; }
break;
case 25:
{ return F_ARROW; }
break;
case 26:
{ return '='; }
break;
case 27:
{ return '-'; }
break;
case 28:
{ return F_SUB_EQ; }
break;
case 29:
{ return '+'; }
break;
case 30:
{ return F_ADD_EQ; }
break;
case 31:
{ return '*'; }
break;
case 32:
{ return F_MULT_EQ; }
break;
case 33:
{ return '%'; }
break;
case 34:
{ return F_MOD_EQ; }
break;
case 35:
{ return '/'; }
break;
case 36:
{ return F_DIV_EQ; }
break;
case 37:
{ return '<'; }
break;
case 38:
{ return '>'; }
break;
case 39:
{ return F_GE; }
break;
case 40:
{ return F_LE; }
break;
case 41:
{ return F_EQ; }
break;
case 42:
{ return F_NE; }
break;
case 43:
{ return F_COLON_COLON; }
break;
case 44:
{ pre_processor_info(yytext); }
break;
case 45:
{ return '['; }
break;
case 46:
{ return ']'; }
break;
case 47:
{ return dec(yytext); }
break;
case 48:
{ return hex(yytext); }
break;
case 49:
{ return oct(yytext); }
break;
case 50:
{ yylval.lnode = (struct lnode *)alloc_lnode_number(F_NUMBER,
yytext[1]);
return F_NUMBER; }
break;
case 51:
{ return lookup_table(yytext); }
break;
case 52:
{ return string(yytext); }
break;
case 53:
{ break; }
break;
case 54:
{ current_line++;
if (current_line & L_MASK) {
yyerror("Too many lines.\n");
current_line = 0;
}
total_lines++;
}
break;
case 55:
{ char buff[100]; sprintf(buff, "Illegal character '%c'", yytext[0]);
yyerror(buff); }
break;
case -1:
break;
default:
fprintf(yyout,"bad switch yylook %d",nstr);
} return(0); }
/* end of yylex */
extern YYSTYPE yylval;
#ifdef LEX
int yywrap() { return 1; }
#endif
int lookup_table(str)
char *str;
{
int i;
for (i=0; table[i].name; i++) {
if (*str != table[i].name[0]) continue;
if (strcmp(str, table[i].name) == 0) return(table[i].ret_val);
}
for (i=current_number_of_locals-1; i>=0; i--) {
if (strcmp(local_names[i], str) == 0) {
yylval.lnode = (struct lnode *)alloc_lnode_number(F_LOCAL_NAME, i);
return F_LOCAL_NAME;
}
}
if (argument_name && strcmp(str, argument_name) == 0)
return F_ARGUMENT;
yylval.string = string_copy(str);
return F_IDENTIFIER;
}
/*
* debugging, gives the name of a single.
*/
static char cbuf[100];
char * cmdname(c)
int c;
{
int i;
switch (c) {
case F_LOCAL_NAME: return "Local var def";
case F_ARGUMENT: return "First Argument";
}
for (i=0; table[i].name; i++) {
if (c == table[i].ret_val) return table[i].name;
}
sprintf(cbuf, "Identifier? (%d)", c);
return cbuf;
}
int string(str)
char *str;
{
char *p;
p = (char *)string_copy(str);
yylval.string = p;
for (str++; str[1] != '\0'; str++, p++) {
if (str[0] == '\\' && str[1] == 'n') {
*p = '\n';
str++;
} else if (str[0] == '\\' && str[1] == 't') {
*p = '\t';
str++;
} else if (str[0] == '\\' && str[1] == '"') { /* LA */
*p = '"'; /* LA */
str++; /* LA */
if (!str[1]) {
yyerror("Unterminated string");
break;
}
} else if (str[0] == '\\') {
*p = str[1];
str++;
} else
*p = *str;
}
*p = '\0';
return F_STRING;
}
int dec(str)
char *str;
{
int i;
i = atoi(str);
return number(i);
}
int hex(str)
char *str;
{
int i;
sscanf(str, "%x", &i);
return number(i);
}
int oct(str)
char *str;
{
int i;
sscanf(str, "%x", &i);
return number(i);
}
int number(i)
int i;
{
if (i == 0) {
yylval.lnode = (struct lnode *)alloc_lnode_single(F_CONST0);
return F_CONST0;
}
if (i == 1) {
yylval.lnode = (struct lnode *)alloc_lnode_single(F_CONST1);
return F_CONST1;
}
yylval.lnode =(struct lnode *)alloc_lnode_number(F_NUMBER, i);
return F_NUMBER;
}
void start_new_file(f)
FILE *f;
{
extern int yyprevious;
#ifdef FLEX
yy_init = 1;
#endif
#ifdef LEX
extern int yyprevious; /* KLUDGE! */
NLSTATE;
yysptr = yysbuf;
#endif
yyin = f;
}
void pre_processor_info(str)
char *str;
{
int line,i;
char file[100];
if (sscanf(str, "# %d \"%s\"", &line, file) != 2)
return;
i = strlen(file);
if (file[i-1] == '"')
file[i-1] = '\0';
free(current_file);
current_file = string_copy(file);
current_line = line - 1;
}
/*** VMS doesn't like #ifdef 0 (bub) ***/
#ifdef ZERO0ZERO
#ifdef LEX
void fix_vars()
{
extern int yyprevious;
current_line = 0;
yyprevious = 10;
yylineno = 1;
yysptr = yysbuf;
}
#endif
#endif
int yyvstop[] = {
0,
55,
0,
53,
55,
0,
54,
0,
24,
55,
0,
55,
0,
33,
55,
0,
13,
55,
0,
55,
0,
2,
55,
0,
3,
55,
0,
31,
55,
0,
29,
55,
0,
4,
55,
0,
27,
55,
0,
35,
55,
0,
47,
55,
0,
47,
55,
0,
10,
55,
0,
1,
55,
0,
37,
55,
0,
26,
55,
0,
38,
55,
0,
9,
55,
0,
51,
55,
0,
45,
55,
0,
46,
55,
0,
18,
55,
0,
5,
55,
0,
16,
55,
0,
6,
55,
0,
11,
55,
0,
55,
-44,
0,
42,
0,
52,
0,
34,
0,
12,
0,
14,
0,
32,
0,
7,
0,
30,
0,
8,
0,
28,
0,
25,
0,
36,
0,
49,
0,
47,
0,
43,
0,
20,
0,
40,
0,
41,
0,
39,
0,
22,
0,
51,
0,
19,
0,
17,
0,
15,
0,
-44,
0,
44,
0,
52,
0,
50,
0,
48,
0,
21,
0,
23,
0,
0};
# define YYTYPE char
struct yywork { YYTYPE verify, advance; } yycrank[] = {
0,0, 0,0, 1,3, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 0,0, 1,4, 1,5,
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, 36,0, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 0,0, 1,6, 1,7,
0,0, 0,0, 1,8, 1,9,
1,10, 1,11, 1,12, 1,13,
1,14, 1,15, 1,16, 9,40,
1,17, 1,18, 1,19, 14,44,
42,66, 0,0, 65,0, 0,0,
0,0, 1,19, 0,0, 1,20,
1,21, 1,22, 1,23, 1,24,
1,25, 6,35, 1,26, 8,39,
13,43, 14,45, 9,41, 2,6,
1,26, 2,34, 16,46, 2,8,
2,9, 2,10, 2,11, 2,12,
2,13, 2,14, 2,15, 2,16,
17,49, 2,17, 20,53, 22,54,
22,55, 1,26, 16,47, 16,48,
1,27, 23,56, 1,28, 1,29,
2,20, 2,21, 2,22, 2,23,
2,24, 2,25, 7,36, 29,60,
10,42, 24,57, 24,58, 31,61,
36,38, 54,68, 7,36, 7,0,
10,42, 10,0, 18,50, 18,50,
18,50, 18,50, 18,50, 18,50,
18,50, 18,50, 58,69, 0,0,
1,30, 1,31, 1,32, 1,33,
0,0, 2,27, 0,0, 2,28,
2,29, 0,0, 0,0, 7,37,
65,38, 10,42, 19,52, 19,52,
19,52, 19,52, 19,52, 19,52,
19,52, 19,52, 19,52, 19,52,
0,0, 7,36, 7,36, 10,42,
10,42, 0,0, 18,51, 38,0,
0,0, 7,36, 0,0, 10,42,
0,0, 2,30, 2,31, 2,32,
2,33, 0,0, 7,36, 0,0,
10,42, 0,0, 31,62, 0,0,
7,36, 0,0, 10,42, 0,0,
0,0, 0,0, 0,0, 38,65,
0,0, 0,0, 0,0, 0,0,
0,0, 0,0, 18,51, 0,0,
0,0, 7,36, 0,0, 10,42,
0,0, 7,38, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
0,0, 0,0, 0,0, 0,0,
0,0, 0,0, 0,0, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 38,38, 0,0, 0,0,
0,0, 26,59, 0,0, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 26,59, 26,59, 26,59,
26,59, 34,63, 0,0, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 34,63, 34,64, 50,50,
50,50, 50,50, 50,50, 50,50,
50,50, 50,50, 50,50, 0,0,
0,0, 0,0, 0,0, 51,67,
51,67, 51,67, 51,67, 51,67,
51,67, 51,67, 51,67, 51,67,
51,67, 0,0, 34,63, 0,0,
0,0, 0,0, 0,0, 0,0,
51,67, 51,67, 51,67, 51,67,
51,67, 51,67, 0,0, 0,0,
34,63, 34,63, 0,0, 0,0,
0,0, 0,0, 0,0, 0,0,
34,63, 0,0, 0,0, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 34,63, 0,0, 0,0,
0,0, 0,0, 0,0, 34,63,
51,67, 51,67, 51,67, 51,67,
51,67, 51,67, 0,0, 0,0,
0,0, 0,0, 0,0, 0,0,
0,0, 0,0, 0,0, 0,0,
34,63, 0,0, 0,0, 0,0,
0,0};
struct yysvf yysvec[] = {
0, 0, 0,
yycrank+-1, 0, 0,
yycrank+-38, yysvec+1, 0,
yycrank+0, 0, yyvstop+1,
yycrank+0, 0, yyvstop+3,
yycrank+0, 0, yyvstop+6,
yycrank+4, 0, yyvstop+8,
yycrank+-101, 0, yyvstop+11,
yycrank+6, 0, yyvstop+13,
yycrank+9, 0, yyvstop+16,
yycrank+-103, 0, yyvstop+19,
yycrank+0, 0, yyvstop+21,
yycrank+0, 0, yyvstop+24,
yycrank+7, 0, yyvstop+27,
yycrank+8, 0, yyvstop+30,
yycrank+0, 0, yyvstop+33,
yycrank+29, 0, yyvstop+36,
yycrank+23, 0, yyvstop+39,
yycrank+66, 0, yyvstop+42,
yycrank+90, 0, yyvstop+45,
yycrank+28, 0, yyvstop+48,
yycrank+0, 0, yyvstop+51,
yycrank+27, 0, yyvstop+54,
yycrank+32, 0, yyvstop+57,
yycrank+44, 0, yyvstop+60,
yycrank+0, 0, yyvstop+63,
yycrank+146, 0, yyvstop+66,
yycrank+0, 0, yyvstop+69,
yycrank+0, 0, yyvstop+72,
yycrank+42, 0, yyvstop+75,
yycrank+0, 0, yyvstop+78,
yycrank+46, 0, yyvstop+81,
yycrank+0, 0, yyvstop+84,
yycrank+0, 0, yyvstop+87,
yycrank+-268, 0, yyvstop+90,
yycrank+0, 0, yyvstop+93,
yycrank+-16, yysvec+7, 0,
yycrank+0, 0, yyvstop+95,
yycrank+-145, yysvec+7, 0,
yycrank+0, 0, yyvstop+97,
yycrank+0, 0, yyvstop+99,
yycrank+0, 0, yyvstop+101,
yycrank+13, 0, 0,
yycrank+0, 0, yyvstop+103,
yycrank+0, 0, yyvstop+105,
yycrank+0, 0, yyvstop+107,
yycrank+0, 0, yyvstop+109,
yycrank+0, 0, yyvstop+111,
yycrank+0, 0, yyvstop+113,
yycrank+0, 0, yyvstop+115,
yycrank+231, 0, yyvstop+117,
yycrank+243, 0, 0,
yycrank+0, yysvec+19, yyvstop+119,
yycrank+0, 0, yyvstop+121,
yycrank+48, 0, yyvstop+123,
yycrank+0, 0, yyvstop+125,
yycrank+0, 0, yyvstop+127,
yycrank+0, 0, yyvstop+129,
yycrank+61, 0, yyvstop+131,
yycrank+0, yysvec+26, yyvstop+133,
yycrank+0, 0, yyvstop+135,
yycrank+0, 0, yyvstop+137,
yycrank+0, 0, yyvstop+139,
yycrank+0, yysvec+34, yyvstop+141,
yycrank+0, 0, yyvstop+143,
yycrank+-44, yysvec+7, yyvstop+145,
yycrank+0, 0, yyvstop+147,
yycrank+0, yysvec+51, yyvstop+149,
yycrank+0, 0, yyvstop+151,
yycrank+0, 0, yyvstop+153,
0, 0, 0};
struct yywork *yytop = yycrank+356;
struct yysvf *yybgin = yysvec+1;
char 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 ,
'0' ,'1' ,'1' ,'1' ,'1' ,'1' ,'1' ,'1' ,
'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' ,
'X' ,'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' ,
'X' ,'G' ,'G' ,01 ,01 ,01 ,01 ,01 ,
0};
char 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,1,0,0,0,
0,0,0,0,0,0,0,0,
0};
#ifndef lint
static char ncform_sccsid[] = "@(#)ncform 1.6 88/02/08 SMI"; /* from S5R2 1.2 */
#endif
int yylineno =1;
# define YYU(x) x
# define NLSTATE yyprevious=YYNEWLINE
char yytext[YYLMAX];
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
char yysbuf[YYLMAX];
char *yysptr = yysbuf;
int *yyfnd;
extern struct yysvf *yyestate;
int yyprevious = YYNEWLINE;
yylook(){
register struct yysvf *yystate, **lsp;
register struct yywork *yyt;
struct yysvf *yyz;
int yych, yyfirst;
struct yywork *yyr;
# ifdef LEXDEBUG
int debug;
# endif
char *yylastch;
/* start off machines */
# ifdef LEXDEBUG
debug = 0;
# endif
yyfirst=1;
if (!yymorfg)
yylastch = yytext;
else {
yymorfg=0;
yylastch = 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 && !yyfirst){ /* may not be any transitions */
yyz = yystate->yyother;
if(yyz == 0)break;
if(yyz->yystoff == yycrank)break;
}
*yylastch++ = yych = input();
yyfirst=0;
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-yytext+1;
yytext[yyleng] = 0;
# ifdef LEXDEBUG
if(debug){
fprintf(yyout,"\nmatch ");
sprint(yytext);
fprintf(yyout," action %d\n",*yyfnd);
}
# endif
return(*yyfnd++);
}
unput(*yylastch);
}
if (yytext[0] == 0 /* && feof(yyin) */)
{
yysptr=yysbuf;
return(0);
}
yyprevious = yytext[0] = input();
if (yyprevious>0)
output(yyprevious);
yylastch=yytext;
# ifdef LEXDEBUG
if(debug)putchar('\n');
# endif
}
}
yyback(p, m)
int *p;
{
if (p==0) return(0);
while (*p)
{
if (*p++ == m)
return(1);
}
return(0);
}
/* the following are only used in the lex library */
yyinput(){
return(input());
}
yyoutput(c)
int c; {
output(c);
}
yyunput(c)
int c; {
unput(c);
}