www.pudn.com > LEX.rar > LEX.PAR

#include  
#include  
#include  
#include  
#include  
#include  
 
#define COPY(d,s,a) memmove(d,s,a) 
 
#define STDIN	0 
 
#define BUFSIZE 1024 
 
#define EOLN    257 
 
typedef unsigned char	uchar ; 
 
uchar Start_buf[BUFSIZE] ; 
uchar *End_buf = Start_buf; 
uchar *Next = Start_buf; 
uchar *sMark = Start_buf; 
uchar *eMark = Start_buf; 
 
int Inp_file = STDIN; 
int	Lineno = 0; 
int	Mline = 0; 
int Termchar = 0; 
 
 
int	(*Openp)() =(int (*)())open; 
int	(*Closep)() =(int (*)())close; 
int	(*Readp)(int, char *, int ) =(int (*)(int,char *, int))read; 
 
 
char 	*ii_mark_start( void ); 
char 	*ii_mark_end( void ); 
char 	*ii_to_mark( void ); 
int 	ii_advance( void ); 
int 	ii_fillbuf( unsigned char *starting_at ); 
int		ii_look( int ); 
int 	ii_pushback( int ); 
void 	ii_term( void ); 
void 	ii_unterm( void ); 
 
 
void prnt( int (*ofunct)(char,void *), void *funct_arg, char *format, va_list args ) 
{ 
	char buf[256], *p; 
	vsprintf( buf, format, args ); 
	for ( p = buf; *p; p ++ ) 
		(*ofunct)( *p, funct_arg ); 
} 
 
int on_ferr( void ) 
{ 
	extern int errno ; 
	return errno ; 
} 
 
int ferr( char *fmt, ... ) 
{ 
	va_list	args ; 
	va_start( args, fmt ) ; 
 
	if( fmt ) prnt ( (int(*)(char,void *))fputc, stderr, fmt , args ) ; 
	else	perror( va_arg( args, char* ) ) ; 
 
	va_end( args ) ; 
	exit ( on_ferr() ) ; 
	return 0; 
} 
 
/*------------------------------------------------------------------------- 
  VISIT ROUTINE & MARK-MOVING 
*/ 
 
char *ii_text	(void) { return sMark ; } 
int	ii_length	(void) { return eMark-sMark ; } 
int	ii_lineno	(void) { return Lineno ; } 
 
char *ii_mark_start(void) 
{ 
	if ( Next >= End_buf ) 
	{ 
		ii_fillbuf( Start_buf ); 
		Next = Start_buf; 
		Lineno ++; 
	} 
	Mline = Lineno; 
	eMark = sMark = Next; 
	return sMark; 
} 
 
char *ii_mark_end(void) 
{ 
	Mline =Lineno ; 
	return( eMark =Next ) ; 
} 
 
char *ii_to_mark(void) 
{ 
	Lineno =Mline ; 
	return( Next =eMark ) ; 
} 
 
 
/*------------------------------------------------------------------------- 
  INPUT ROUTINE 
*/ 
 
int ii_advance(void) 
{ 
	return( *Next++ ) ; 
} 
 
/*-------------------------------------------------------------------------*/ 
 
int ii_fillbuf( unsigned char *starting_at ) 
{ 
	int got; 
 
	if( (got =(*Readp)(Inp_file, starting_at, BUFSIZE)) ==-1 ) 
		ferr("Cannot erad input file \n"); 
 
	End_buf =starting_at + got; 
 
	return got ; 
} 
 
/*------------------------------------------------------------------------- 
  LOOKAHEAD 
*/ 
 
int	ii_look( int n ) 
{ 
	uchar	*p ; 
 
	p =Next +(n-1) ; 
 
	return (p>=End_buf)? EOLN : *p ; 
} 
 
/*------------------------------------------------------------------------- 
  PUSH n CHARACTERS BACK INTO THE INPUT. 
*/ 
 
int ii_pushback( int n ) 
{ 
	while( --n >=0 && Next >sMark ) 
	{ 
		--Next; 
	} 
 
	if( Next  sMark ) ; 
} 
 
/*-------------------------------------------------------------------------*/ 
 
void ii_term(void) 
{ 
	Termchar =*Next ; 
	*Next ='\0' ; 
} 
 
void ii_unterm(void) 
{ 
	if( Termchar ) 
	{ 
		*Next =Termchar ; 
		Termchar =0 ; 
	} 
} 
 
/*-------------------------------------------------------------*/ 
#ifndef	YYPRIVATE 
#	define YYPRIVATE 	static 
#endif 
 
#ifndef	NULL 
# 	include  
#endif 
 
#ifdef	YYDEBUG 
	int yydebug =0 ; 
#	define YY_D(x) 	if( yydebug ) { x; } else 
#else 
#	define YY_D(x) 
#endif 
 
typedef unsigned    char    YY_TTYPE ; 
#define	YYF	(( YY_TTYPE )(-1) ) 
 
 
 
/* Global variables used by the parser. */ 
char	*yytext ; 
int		yyleng ; 
int		yylineno ; 
FILE	*yyout =stdout ; 
 
#define output(c) 	putc(c,yyout) 
#define ECHO		fprintf(yyout,"%s", yytext) 
 
#ifndef	YYERROR 
#	define	YYERROR(t)	fprintf(stderr,"%s", t ) 
#endif 
 
#define yymore()	yymoreflg=1 
 
#define	unput(c)	(ii_unput(c), --yyleng ) 
#define	yyless(n)	(  ii_unterm(), \ 
								( yyleng -=ii_pushback(n)? n:yyleng ), \ 
								ii_term() \ 
							) 
 
#define yywrap()	1 
 
/*-------------------------------------------------------------------*/ 
 
yylex() 
{ 
	int	yymoreflg ; 
	static int 	yystate =-1 ; 
	int	yylastaccept ; 
	int yyprev ; 
	int yynstate ; 
	int	yylook ; 
	int	yyanchor ; 
 
	yystate =0 ; 
	yylastaccept =0; 
	yymoreflg =0 ; 
	ii_unterm(); 
	ii_mark_start(); 
 
	while(1) 
	{ 
		while(1) 
		{ 
			yylook = ii_look(1); 
			if( yylook == EOLN ) 
			{ 
				yynstate = YYF; 
				break; 
			} 
			if( yylook !=EOF ) 
			{ 
				yynstate =yy_next( yystate, yylook ); 
				break ; 
			} 
			else 
			{ 
				if( yylastaccept ) 
				{ 
					yynstate =YYF ; 
					break ; 
				} 
				else if( yywrap() ) 
				{ 
					yytext ="" ; 
					yyleng =0 ; 
					return 0 ; 
				} 
				else 
				{ 
					ii_advance() ; 
					ii_pushback(1) ; 
				} 
			} 
		} 
 
		if( yynstate !=YYF ) 
		{ 
			YY_D( printf("  Transition from state %d", yystate)  ) ; 
			YY_D( printf(" to state %d on <%c>\n", yynstate, yylook ) ); 
 
			ii_advance(); 
 
			if( (yyanchor =Yyaccept[ yynstate ]) != 0) 
			{ 
				yyprev =yystate; 
				yylastaccept =yynstate; 
				ii_mark_end(); 
			} 
			yystate =yynstate; 
		} 
		else 
		{ 
			if( !yylastaccept ) 
			{ 
#ifdef	YYBADINP 
				YYERROR("Ignoring bad input\n") ; 
#endif 
				ii_advance() ; 
			} 
			else 
			{ 
				ii_to_mark(); 
 
				ii_term(); 
				yyleng =ii_length(); 
				yytext =ii_text() ; 
				yylineno =ii_lineno() ; 
 
				YY_D( printf("Accepting state %d, ", yylastaccept ) ) ; 
				YY_D( printf("line %d: <%s>\n", yylineno, yytext ) ); 
 
				switch( yylastaccept ) 
				{ 
 
				default: 
						YYERROR( "Internal error, yylex\n") ; 
						break ; 
				} 
			} 
 
			ii_unterm() ; 
			yylastaccept =0 ; 
 
			if( !yymoreflg ) 
			{ 
				yystate=0 ; 
				ii_mark_start() ; 
			} 
			else 
			{ 
				yystate =yyprev ; 
				yymoreflg =0 ; 
            } 
		} 
	} 
}