path: root/epan/dfilter/grammar.lemon

%include {
#include "config.h"

#include <assert.h>

#include "dfilter-int.h"
#include "syntax-tree.h"
#include "sttype-range.h"
#include "sttype-test.h"
#include "sttype-function.h"
#include "sttype-set.h"
#include "drange.h"

#include "grammar.h"

#ifdef _WIN32
#pragma warning(disable:4671)
#endif

/* End of C code */
}

/* Parser Information */
%name		Dfilter
%token_prefix	TOKEN_
%extra_argument	{dfwork_t *dfw}

/* Terminal and Non-Terminal types and destructors */
%token_type			{stnode_t*}
%token_destructor		{
	(void) dfw; /* Mark unused, similar to Q_UNUSED */
	stnode_free($$);
}

%type		sentence	{stnode_t*}


%type		expr		{stnode_t*}
%destructor	expr		{stnode_free($$);}

%type		entity		{stnode_t*}
%destructor	entity		{stnode_free($$);}

%type		relation_test	{stnode_t*}
%destructor	relation_test	{stnode_free($$);}

%type		logical_test	{stnode_t*}
%destructor	logical_test	{stnode_free($$);}

%type		rel_binop	{test_op_t}

%type		range		{stnode_t*}
%destructor	range		{stnode_free($$);}

%type		range_node	{drange_node*}
%destructor	range_node	{drange_node_free($$);}

%type		range_node_list	{GSList*}
%destructor	range_node_list	{drange_node_free_list($$);}

%type		function_params	{GSList*}
%destructor	function_params	{st_funcparams_free($$);}

%type		set_node_list	{GSList*}
%destructor	set_node_list	{set_nodelist_free($$);}

/* This is called as soon as a syntax error happens. After that, 
any "error" symbols are shifted, if possible. */
%syntax_error {

	if (!TOKEN) {
		dfilter_fail(dfw, "Unexpected end of filter string.");
		dfw->syntax_error = TRUE;
		return;
	}

	switch(stnode_type_id(TOKEN)) {
		case STTYPE_UNINITIALIZED: /* fall-through */
		case STTYPE_UNPARSED:
			if (stnode_token_value(TOKEN) != NULL)
				dfilter_fail(dfw, "\"%s\" was unexpected in this context.",
						stnode_token_value(TOKEN));
			else
				dfilter_fail(dfw, "Syntax error.");
			break;
		case STTYPE_STRING:
			dfilter_fail(dfw, "The string \"%s\" was unexpected in this context.",
				(char *)stnode_data(TOKEN));
			break;
		case STTYPE_CHARCONST:
			dfilter_fail(dfw, "The character constant \"%s\" was unexpected in this context.",
				(char *)stnode_data(TOKEN));
			break;
		/* These aren't handed to use as terminal tokens from
		   the scanner, so was can assert that we'll never
		   see them here. */
		case STTYPE_NUM_TYPES:
		case STTYPE_FIELD:
		case STTYPE_FUNCTION:
		case STTYPE_RANGE:
		case STTYPE_FVALUE:
		case STTYPE_PCRE:
		case STTYPE_SET:
		case STTYPE_TEST:
			ws_assert_not_reached();
			break;
	}
	dfw->syntax_error = TRUE;
}

/* When a parse fails, mark an error. This occurs after
the above syntax_error code and after the parser fails to
use error recovery, shifting an "error" symbol and successfully
shifting 3 more symbols. */
%parse_failure {
	dfw->syntax_error = TRUE;
}

/* ----------------- The grammar -------------- */

/* Associativity */
%left TEST_AND.
%left TEST_OR.
%nonassoc TEST_EQ TEST_NE TEST_LT TEST_LE TEST_GT TEST_GE TEST_CONTAINS TEST_MATCHES TEST_BITWISE_AND.
%right TEST_NOT.

/* Top-level targets */
sentence ::= expr(X).		{ dfw->st_root = X; }
sentence ::= .			{ dfw->st_root = NULL; }

expr(X) ::= relation_test(R).	{ X = R; }
expr(X) ::= logical_test(L).	{ X = L; }


/* Logical tests */
logical_test(T) ::= expr(E) TEST_AND expr(F).
{
	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set2(T, TEST_OP_AND, E, F);
}

logical_test(T) ::= expr(E) TEST_OR expr(F).
{
	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set2(T, TEST_OP_OR, E, F);
}

logical_test(T) ::= TEST_NOT expr(E).
{
	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set1(T, TEST_OP_NOT, E);
}

logical_test(T) ::= entity(E).
{
	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set1(T, TEST_OP_EXISTS, E);
}



/* Entities, or things that can be compared/tested/checked */
entity(E) ::= STRING(S).	{ E = S; }
entity(E) ::= CHARCONST(C).	{ E = C; }
entity(E) ::= UNPARSED(U).	{ E = dfilter_resolve_unparsed(dfw, U); }
entity(E) ::= range(R).		{ E = R; }
entity(E) ::= function(F).	{ E = F; }


/* Ranges */
range(R) ::= entity(E) LBRACKET range_node_list(L) RBRACKET.
{
	R = stnode_new(STTYPE_RANGE, NULL, NULL);
	sttype_range_set(R, E, L);

	/* Delete the list, but not the drange_nodes that
	 * the list contains. */
	g_slist_free(L);
}

range_node_list(L) ::= range_node(D).
{
	L = g_slist_append(NULL, D);
}

range_node_list(L) ::= range_node_list(P) COMMA range_node(D).
{
	L = g_slist_append(P, D);
}

/* x:y */
range_node(D) ::= INTEGER(X) COLON INTEGER(Y).
{
	int32_t start = 0, length = 0;

	dfilter_str_to_gint32(dfw, stnode_token_value(X), &start);
	dfilter_str_to_gint32(dfw, stnode_token_value(Y), &length);

	D = drange_node_new();
	drange_node_set_start_offset(D, start);
	drange_node_set_length(D, length);

	stnode_free(X);
	stnode_free(Y);
}

/* x-y */
range_node(D) ::= INTEGER(X) HYPHEN INTEGER(Y).
{
	int32_t start = 0, offset = 0;

	dfilter_str_to_gint32(dfw, stnode_token_value(X), &start);
	dfilter_str_to_gint32(dfw, stnode_token_value(Y), &offset);

	D = drange_node_new();
	drange_node_set_start_offset(D, start);
	drange_node_set_end_offset(D, offset);

	stnode_free(X);
	stnode_free(Y);
}


/* :y = 0:y*/
range_node(D) ::= COLON INTEGER(Y).
{
	int32_t length = 0;

	dfilter_str_to_gint32(dfw, stnode_token_value(Y), &length);

	D = drange_node_new();
	drange_node_set_start_offset(D, 0);
	drange_node_set_length(D, length);

	stnode_free(Y);
}

/* x: = x:-1 */
range_node(D) ::= INTEGER(X) COLON.
{
	int32_t start = 0;

	dfilter_str_to_gint32(dfw, stnode_token_value(X), &start);

	D = drange_node_new();
	drange_node_set_start_offset(D, start);
	drange_node_set_to_the_end(D);

	stnode_free(X);
}

/* x = x:1 */
range_node(D) ::= INTEGER(X).
{
	int32_t start = 0;

	dfilter_str_to_gint32(dfw, stnode_token_value(X), &start);

	D = drange_node_new();
	drange_node_set_start_offset(D, start);
	drange_node_set_length(D, 1);

	stnode_free(X);
}

rel_binop(O) ::= TEST_EQ.	{ O = TEST_OP_EQ; }
rel_binop(O) ::= TEST_NE.	{ O = TEST_OP_NE; }
rel_binop(O) ::= TEST_GT.	{ O = TEST_OP_GT; }
rel_binop(O) ::= TEST_GE.	{ O = TEST_OP_GE; }
rel_binop(O) ::= TEST_LT.	{ O = TEST_OP_LT; }
rel_binop(O) ::= TEST_LE.	{ O = TEST_OP_LE; }
rel_binop(O) ::= TEST_BITWISE_AND. { O = TEST_OP_BITWISE_AND; }
rel_binop(O) ::= TEST_CONTAINS.	{ O = TEST_OP_CONTAINS; }

/* Relational tests */
relation_test(T) ::= entity(E) rel_binop(O) entity(F).
{
	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set2(T, O, E, F);
}

/* 'a == b == c' or 'a < b <= c <= d < e' */
relation_test(T) ::= entity(E) rel_binop(O) relation_test(R).
{
	stnode_t *L, *F;
	/* for now generate it like E O F  TEST_OP_AND  F P G, later it could be optimized
	   or semantically checked (to make a <= b >= c or a == b != c invalid)?
	 */

	F = R;
	do {
		ws_assert(F != NULL && stnode_type_id(F) == STTYPE_TEST);
		sttype_test_get(F, NULL, &F, NULL);
	} while (stnode_type_id(F) == STTYPE_TEST);

	L = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set2(L, O, E, stnode_dup(F));

	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set2(T, TEST_OP_AND, L, R);
}

/* "matches" does not chain with other relational tests. */ 
relation_test(T) ::= entity(E) TEST_MATCHES entity(F).
{
	stnode_t *R = dfilter_new_regex(dfw, F);

	T = stnode_new(STTYPE_TEST, NULL, NULL);
	sttype_test_set2(T, TEST_OP_MATCHES, E, R);
}

relation_test(T) ::= entity(E) TEST_IN LBRACE set_node_list(L) RBRACE.
{
	stnode_t *S;
	T = stnode_new(STTYPE_TEST, NULL, NULL);
	S = stnode_new(STTYPE_SET, L, NULL);
	sttype_test_set2(T, TEST_OP_IN, E, S);
}

set_node_list(L) ::= entity(E).
{
	L = g_slist_append(NULL, E);
	L = g_slist_append(L, NULL);
}

set_node_list(L) ::= set_node_list(P) WHITESPACE entity(E).
{
	L = g_slist_append(P, E);
	L = g_slist_append(L, NULL);
}

/* Set elements. */
set_node_list(L) ::= entity(X) DOTDOT entity(Y).
{
	L = g_slist_append(NULL, X);
	L = g_slist_append(L, Y);
}

set_node_list(L) ::= set_node_list(P) WHITESPACE entity(X) DOTDOT entity(Y).
{
	L = g_slist_append(P, X);
	L = g_slist_append(L, Y);
}

/* Functions */

/* A function can have one or more parameters */
function(F) ::= UNPARSED(U) LPAREN function_params(P) RPAREN.
{
	F = dfilter_new_function(dfw, stnode_token_value(U));
	stnode_free(U);
	sttype_function_set_params(F, P);
}

/* A function can have zero parameters. */
function(F) ::= UNPARSED(U) LPAREN RPAREN.
{
	F = dfilter_new_function(dfw, stnode_token_value(U));
	stnode_free(U);
}

function_params(P) ::= entity(E).
{
	P = g_slist_append(NULL, E);
}

function_params(P) ::= function_params(L) COMMA entity(E).
{
	P = g_slist_append(L, E);
}


/* Any expression inside parens is simply that expression */
expr(X) ::= LPAREN expr(Y) RPAREN.
{
	X = Y;
	stnode_set_inside_parens(X, TRUE);
}