view release on metacpan or  search on metacpan

Compiler/lexer.c  view on Meta::CPAN

#else
static void amd_yy_push_state( new_state )
int new_state;
#endif
	{
	if ( amd_yy_start_stack_ptr >= amd_yy_start_stack_depth )
		{
		amd_yy_size_t new_size;

		amd_yy_start_stack_depth += YY_START_STACK_INCR;
		new_size = amd_yy_start_stack_depth * sizeof( int );

		if ( ! amd_yy_start_stack )
			amd_yy_start_stack = (int *) amd_yy_flex_alloc( new_size );

		else
			amd_yy_start_stack = (int *) amd_yy_flex_realloc(
					(void *) amd_yy_start_stack, new_size );

		if ( ! amd_yy_start_stack )
			YY_FATAL_ERROR(
			"out of memory expanding start-condition stack" );
		}

	amd_yy_start_stack[amd_yy_start_stack_ptr++] = YY_START;

	BEGIN(new_state);
	}
#endif


#ifndef YY_NO_POP_STATE
static void amd_yy_pop_state()
	{
	if ( --amd_yy_start_stack_ptr < 0 )
		YY_FATAL_ERROR( "start-condition stack underflow" );

	BEGIN(amd_yy_start_stack[amd_yy_start_stack_ptr]);
	}
#endif


#ifndef YY_NO_TOP_STATE
static int amd_yy_top_state()
	{
	return amd_yy_start_stack[amd_yy_start_stack_ptr - 1];
	}
#endif

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

#ifdef YY_USE_PROTOS
static void amd_yy_fatal_error( amd_yyconst char msg[] )
#else
static void amd_yy_fatal_error( msg )
char msg[];
#endif
	{
	(void) fprintf( stderr, "%s\n", msg );
	exit( YY_EXIT_FAILURE );
	}



/* Redefine amd_yyless() so it works in section 3 code. */

#undef amd_yyless
#define amd_yyless(n) \
	do \
		{ \
		/* Undo effects of setting up amd_yytext. */ \
		amd_yytext[amd_yyleng] = amd_yy_hold_char; \
		amd_yy_c_buf_p = amd_yytext + n; \
		amd_yy_hold_char = *amd_yy_c_buf_p; \
		*amd_yy_c_buf_p = '\0'; \
		amd_yyleng = n; \
		} \
	while ( 0 )


/* Internal utility routines. */

#ifndef amd_yytext_ptr
#ifdef YY_USE_PROTOS
static void amd_yy_flex_strncpy( char *s1, amd_yyconst char *s2, int n )
#else
static void amd_yy_flex_strncpy( s1, s2, n )
char *s1;
amd_yyconst char *s2;
int n;
#endif
	{
	register int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
	}
#endif

#ifdef YY_NEED_STRLEN
#ifdef YY_USE_PROTOS
static int amd_yy_flex_strlen( amd_yyconst char *s )
#else
static int amd_yy_flex_strlen( s )
amd_yyconst char *s;
#endif
	{
	register int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
	}
#endif


#ifdef YY_USE_PROTOS
static void *amd_yy_flex_alloc( amd_yy_size_t size )
#else
static void *amd_yy_flex_alloc( size )
amd_yy_size_t size;
#endif
	{
	return (void *) malloc( size );
	}

#ifdef YY_USE_PROTOS
static void *amd_yy_flex_realloc( void *ptr, amd_yy_size_t size )
#else
static void *amd_yy_flex_realloc( ptr, size )
void *ptr;
amd_yy_size_t size;
#endif
	{
	/* The cast to (char *) in the following accommodates both
	 * implementations that use char* generic pointers, and those
	 * that use void* generic pointers.  It works with the latter
	 * because both ANSI C and C++ allow castless assignment from
	 * any pointer type to void*, and deal with argument conversions
	 * as though doing an assignment.
	 */
	return (void *) realloc( (char *) ptr, size );
	}

#ifdef YY_USE_PROTOS
static void amd_yy_flex_free( void *ptr )
#else
static void amd_yy_flex_free( ptr )
void *ptr;
#endif
	{
	free( ptr );
	}

#if YY_MAIN
int main()
	{
	amd_yylex();
	return 0;
	}
#endif
#line 150 "lexer.yy"


void
amd_yywarnv(const char *fmt, va_list args)
{
	char	 msg[BUFSIZ];
	vsnprintf(msg, BUFSIZ, fmt, args);
	fprintf(stderr, "%s", msg);
}

void
amd_yywarnf(const char *fmt, ...)
{
	va_list	 args;
	va_start(args, fmt);
	amd_yywarnv(fmt, args);
	va_end(args);
}

void
amd_yyerrorf(const char *fmt, ...)
{
	va_list	 args;
	va_start(args, fmt);
	amd_yywarnv(fmt, args);
	va_end(args);
	exit(1);
}

void
amd_yyerror(const char *str)
{
	amd_yyerrorf("Parse error: %s\n", str);
}

static int
amd_yyinteger(AMD_YYSTYPE *lvalp)
{
	unsigned long	 val;
	char			*ep;

	val = strtoul(amd_yytext, &ep, 0);
	if (*ep) {
		amd_yywarnf("Invalid integer %s: character %c is invalid\n",
						amd_yytext, *ep);
		val = 0;
	}

	lvalp->number = val;

	return L_INTEGER;
}

static int
amd_yyidentifier(AMD_YYSTYPE *lvalp, amd_parse_param_t *param)
{
	SV	**svp;
	SV	 *sv;
	SV	**lvp;

#if 0
	fprintf(stderr, "amd_yyidentifier: %s\n", amd_yytext);
	fflush(stderr);
#endif

	svp = hv_fetch(amd_kwtab, amd_yytext, amd_yyleng, FALSE);
	if (svp) {
		lvalp->number = 0;
		lvp = hv_fetch(amd_lvaltab, amd_yytext, amd_yyleng, FALSE);
		if (lvp) {
			*lvalp = *(INT2PTR(AMD_YYSTYPE *, SvIV(*lvp)));
		}

		return SvIV(*svp);
	}

	/* Throw the thing in some sort of hash table so we get an SV? */
	svp = hv_fetch(param->symtab, amd_yytext, amd_yyleng, FALSE);
	if (svp) {
		sv = *svp;
	}
	else {
		sv = newSVpv(amd_yytext, amd_yyleng);
		hv_store(param->symtab, amd_yytext, amd_yyleng, sv, 0);
	}

	lvalp->sv = sv;

	return L_IDENTIFIER;
}

void
amd_yyunput_map_end()
{
	amd_yyless(1);
}

void
amd_yylex_init(const char *str)
{
	amd_yy_scan_string(str);
	BEGIN(BLANK);
}

int
amd_yylex_verbose(AMD_YYSTYPE *amd_yylval, amd_parse_param_t *param)
{
	int	 tok;

	tok = amd_yylex(amd_yylval, param);
	fprintf(stderr, "L: %d (%s) [%s]\n", tok, amd_yytokname(tok), amd_yytext);

	return tok;
}

int
test_lexer(const char *str)
{
	AMD_YYSTYPE	 amd_yylval;

	amd_parse_param_t	 param;

	memset(&param, 0, sizeof(param));
	param.program = NULL;
	param.symtab = newHV();


	amd_yylex_init(str);

	while (amd_yylex_verbose(&amd_yylval, &param))
		;

	return 0;
}