view release on metacpan or  search on metacpan

Compiler/lexer.yy  view on Meta::CPAN

	/* %option debug */

%s CODE
%x BLANK
%x STRING
%x PPLINE
%x CCOMMENT
%x CPPCOMMENT

WHITE			[ \f\t\v]+
NONWHITE		[^ \f\t\v\r\n]
NL				(\r|\r\n|\n)

MESS			[^ \f\t\v\r\n]

LETTER			[[:alpha:]_]
NONLETTER		[^[:alpha:][:space:]_]

CHAR			[[:alnum:]_]
NONCHAR			[^[:alnum:][:space:]_]

TOKEN			{LETTER}{CHAR}*
NONTOKEN		[[:digit:]]({CHAR}|[[:digit:]])*

MACRO			{TOKEN}
NONMACRO		{NONLETTER}{NONWHITE}*

NONNUMBER		[[:digit:]]{CHAR}+

%%

<BLANK>{WHITE}		{ BEGIN(CODE); }
<BLANK>{NL}			{ /* Optimise for blank lines. */ }
<BLANK>#			{ BEGIN(PPLINE); }
<BLANK>[^#]			{ yyless(0); BEGIN(CODE); }

<PPLINE>{NL}		{ BEGIN(BLANK); }
<PPLINE>\\{NL}		{ }
<PPLINE>{WHITE}		{ }
<PPLINE>[^\\\n]+	{ }
<PPLINE>\\			{ }


\"					{ BEGIN(STRING); yylval->sv = newSVpv("", 0); }
<STRING>\"			{ BEGIN(INITIAL); return L_STRING; }
<STRING>[^\"\\]*	{ sv_catpv(yylval->sv, yytext); }

<STRING>\\[0-7]{1,2}			{ /* octal char */ }
<STRING>\\[0-3][0-7]{1,2}		{ /* octal char */ }
<STRING>\\x[[:xdigit:]]{1,2}	{ /* hex char */ }
<STRING>\\n					{ sv_catpv(yylval->sv, "\n"); }
<STRING>\\t					{ sv_catpv(yylval->sv, "\t"); }
<STRING>\\v					{ sv_catpv(yylval->sv, "\v"); }
<STRING>\\b					{ sv_catpv(yylval->sv, "\b"); }
<STRING>\\r					{ sv_catpv(yylval->sv, "\r"); }
<STRING>\\f					{ sv_catpv(yylval->sv, "\f"); }
<STRING>\\a					{ sv_catpv(yylval->sv, "\a"); }
<STRING>\\[\\\?\'\"]    	{ sv_catpvn(yylval->sv, (yytext + 1), 1); }
<STRING>\\x[^[:xdigit:]]{1,2}	{
						yywarnf("Bad hexadecimal escape %s", yytext);
						sv_catpv(yylval->sv, yytext);
							}
<STRING>\\[0-9]{1,2}		{
						yywarnf("Bad octal escape %s", yytext);
						sv_catpv(yylval->sv, yytext);
							}
<STRING>\\[^\\\?\'\"ntvbrfa0-9]	{
						warn("Unknown escape character \\%c",yytext[1]);
						sv_catpvn(yylval->sv, (yytext + 1), 1);
							}

[[:digit:]]+			{ return yyinteger(yylval); }
0x[[:xdigit:]]+			{ return yyinteger(yylval); }
\$[[:digit:]]+			{ yylval->number = atol(yytext); return L_PARAMETER; }
{TOKEN}					{ return yyidentifier(yylval, param); }
{NONNUMBER}				{ warn("Letters in number and not hex"); }

{WHITE}					{ }
{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); }