lex.par

词法分析器自动生成工具。 the lexcal is generated

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <fcntl.h>
#include <io.h>

#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 <eMark )
	{
		eMark =Next ;
	}
	return( 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 <stdio.h>
#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 ;
            }
		}
	}
}