view release on metacpan or  search on metacpan

Compiler/lexer.yy  view on Meta::CPAN

{NL}					{ BEGIN(BLANK); /* increment lineno */ }
	/* \\ \n should never happen after the preprocessor */

\|\|=				{ return L_LOR_EQ; }
&&=					{ return L_LAND_EQ; }

\+=					{ return L_PLUS_EQ; }
-=					{ return L_MINUS_EQ; }
\/=					{ return L_DIV_EQ; }
\*=					{ return L_TIMES_EQ; }
%=					{ return L_MOD_EQ; }
&=					{ return L_AND_EQ; }
\|=					{ return L_OR_EQ; }
\^=					{ return L_XOR_EQ; }
\.=					{ return L_DOT_EQ; }

==					{ return L_EQ; }
!=					{ return L_NE; }
\<=					{ return L_LE; }
>=					{ return L_GE; }

\|\|				{ return L_LOR; }
&&					{ return L_LAND; }

\+\+				{ return L_INC; }
--					{ return L_DEC; }

>>					{ return L_RSH; }
\<<					{ return L_LSH; }

\(\[				{ return L_MAP_START; }
\]\)				{ return L_MAP_END; }
\(\{				{ return L_ARRAY_START; }
\}\)				{ return L_ARRAY_END; }
\(:					{ return L_FUNCTION_START; }
:\)					{ return L_FUNCTION_END; }

::					{ return L_COLONCOLON; }
->					{ return L_ARROW; }
\.\.				{ return L_RANGE; }

\.\.\.				{ return L_ELLIPSIS; }

[\+-/\*#%&\|<>\^~\?\.\{\},;:\(\)\[\]!=\$]	{ return *yytext; }

		/* Strays */

\\					{ yyerrorf("Stray \\ in program\n");  }
[[:print:]]			{ yyerrorf("Illegal character (hex %d) '%c'\n",
										*yytext, *yytext); }
<*>[^[:print:]]		{ yyerrorf("Unexpected non-ASCII %d\n", *yytext); }
<*><<EOF>>			{ return 0; }

%%

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

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

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

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

static int
yyinteger(YYSTYPE *lvalp)
{
	unsigned long	 val;
	char			*ep;

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

	lvalp->number = val;

	return L_INTEGER;
}

static int
yyidentifier(YYSTYPE *lvalp, amd_parse_param_t *param)
{
	SV	**svp;
	SV	 *sv;
	SV	**lvp;

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

	svp = hv_fetch(amd_kwtab, yytext, yyleng, FALSE);
	if (svp) {
		lvalp->number = 0;
		lvp = hv_fetch(amd_lvaltab, yytext, yyleng, FALSE);
		if (lvp) {
			*lvalp = *(INT2PTR(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, yytext, yyleng, FALSE);
	if (svp) {
		sv = *svp;
	}
	else {
		sv = newSVpv(yytext, yyleng);
		hv_store(param->symtab, yytext, yyleng, sv, 0);
	}

	lvalp->sv = sv;

	return L_IDENTIFIER;
}

void
yyunput_map_end()
{
	yyless(1);
}

void
yylex_init(const char *str)
{
	yy_scan_string(str);
	BEGIN(BLANK);
}

int
yylex_verbose(YYSTYPE *yylval, amd_parse_param_t *param)
{
	int	 tok;

	tok = yylex(yylval, param);
	fprintf(stderr, "L: %d (%s) [%s]\n", tok, yytokname(tok), yytext);

	return tok;
}

int
test_lexer(const char *str)
{
	YYSTYPE	 yylval;

	amd_parse_param_t	 param;

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


	yylex_init(str);

	while (yylex_verbose(&yylval, &param))
		;

	return 0;
}