lexer.l

%option nostdinit never-interactive nounput noinput
%{
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define __PARSER_H_INTERNAL_INCLUDE
#include "parser.h"
#include "parser.tab.h"

#ifndef YY_SKIP_YYWRAP
#  define YY_SKIP_YYWRAP 1
#endif


int yywrap(void)
{
	return 1;
}

#define UPD_LOCATION \
	yylloc.first_column = yylloc.last_column; \
	yylloc.last_column += yyleng

%}


digit				[0-9]
letter				[a-zA-Z]
envVarName 			((_|{letter})(_|{letter}|{digit})*)
parameterValue 			(({letter}|{digit}|[\-\\+:._%?*~/,])+)
whitespace			[ \t]
newLine				(\r?\n)
substitutionCharacter		[$]
setValueCharacter		[=]
charStateAny			[']
allButCharStateAny		[^']
charStateAnyAndExpansion	["]
allButCharStateAnyAndExpansion	[^"$]
anyChar				(.|\n)
pipeChar			[|]
andChar				[&]
gtChar				[>]
gtgtChar			[>][>]
ltChar				[<]
semicolon			[;]


%s ACCEPT_ANY ACCEPT_ANY_AND_EXPANSION


%%
<INITIAL><<EOF>> {
	return END_OF_FILE;
}
<INITIAL>{newLine}{anyChar} {
	UPD_LOCATION;
	return CHARS_AFTER_EOL;
}
<INITIAL>{newLine} {
	UPD_LOCATION;
	return END_OF_LINE;
}
<INITIAL>{charStateAny} {
	UPD_LOCATION;
	BEGIN(ACCEPT_ANY);
}
<INITIAL>{charStateAnyAndExpansion} {
	UPD_LOCATION;
	BEGIN(ACCEPT_ANY_AND_EXPANSION);
}
<INITIAL>{semicolon} {
	UPD_LOCATION;
	return SEQUENTIAL;
}
<INITIAL>{pipeChar}{pipeChar} {
	UPD_LOCATION;
	return CONDITIONAL_NZERO;
}
<INITIAL>{pipeChar} {
	UPD_LOCATION;
	return PIPE;
}
<INITIAL>{andChar}{andChar} {
	UPD_LOCATION;
	return CONDITIONAL_ZERO;
}
<INITIAL>{andChar}{gtChar} {
	UPD_LOCATION;
	return REDIRECT_OE;
}
<INITIAL>{andChar} {
	UPD_LOCATION;
	return PARALLEL;
}
<INITIAL>[2]{gtgtChar} {
	UPD_LOCATION;
	return REDIRECT_APPEND_E;
}
<INITIAL>{gtgtChar} {
	UPD_LOCATION;
	return REDIRECT_APPEND_O;
}
<INITIAL>[2]{gtChar} {
	UPD_LOCATION;
	return REDIRECT_E;
}
<INITIAL>{gtChar} {
	UPD_LOCATION;
	return REDIRECT_O;
}
<INITIAL>{ltChar} {
	UPD_LOCATION;
	return INDIRECT;
}
<INITIAL>{whitespace}+ {
	UPD_LOCATION;
	return BLANK;
}
<INITIAL>{setValueCharacter} {
	UPD_LOCATION;
	yylval.string_un = strdup(yytext);
	add_to_memory_pool(yylval.string_un);
	return WORD;
}
<INITIAL>{substitutionCharacter}{envVarName} {
	UPD_LOCATION;
	yylval.string_un = strdup(yytext + 1);
	add_to_memory_pool(yylval.string_un);
	return ENV_VAR;
}
<INITIAL>{substitutionCharacter} {
	UPD_LOCATION;
	return INVALID_ENVIRONMENT_VAR;
}
<INITIAL>{parameterValue} {
	UPD_LOCATION;
	yylval.string_un = strdup(yytext);
	add_to_memory_pool(yylval.string_un);
	return WORD;
}
<ACCEPT_ANY><<EOF>> {
	return UNEXPECTED_EOF;
}
<ACCEPT_ANY>{charStateAny} {
	UPD_LOCATION;
	BEGIN(INITIAL);
}
<ACCEPT_ANY>{allButCharStateAny}* {
	UPD_LOCATION;
	yylval.string_un = strdup(yytext);
	add_to_memory_pool(yylval.string_un);
	return WORD;
}
<ACCEPT_ANY_AND_EXPANSION><<EOF>> {
	return UNEXPECTED_EOF;
}
<ACCEPT_ANY_AND_EXPANSION>{charStateAnyAndExpansion} {
	UPD_LOCATION;
	BEGIN(INITIAL);
}
<ACCEPT_ANY_AND_EXPANSION>{substitutionCharacter}{envVarName} {
	UPD_LOCATION;
	yylval.string_un = strdup(yytext + 1);
	add_to_memory_pool(yylval.string_un);
	return ENV_VAR;
}
<ACCEPT_ANY_AND_EXPANSION>{substitutionCharacter} {
	UPD_LOCATION;
	return INVALID_ENVIRONMENT_VAR;
}
<ACCEPT_ANY_AND_EXPANSION>{allButCharStateAnyAndExpansion}* {
	UPD_LOCATION;
	yylval.string_un = strdup(yytext);
	add_to_memory_pool(yylval.string_un);
	return WORD;
}
{anyChar} {
	UPD_LOCATION;
	return NOT_ACCEPTED_CHAR;
}
%%


YY_BUFFER_STATE buf_state;
bool buffer_active = false;


void flex_parse_string(const char * str)
{
	flex_free_buffers();
	buf_state = yy_scan_string(str);
	BEGIN(INITIAL);

	buffer_active = true;
}


void flex_free_buffers()
{
	if (buffer_active) {
		yy_delete_buffer(buf_state);
		buffer_active = false;
	}
}