[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Bug#860798: jessie-pu: yara/3.1.0-2+deb8u1



Package: release.debian.org
Severity: normal
Tags: jessie
User: release.debian.org@packages.debian.org
Usertags: pu

Hi,

I would like to update yara in jessie to include fixes for 4 bugs in the
rule parsing code that have been assigned CVE-2016-10210,
CVE-2016-10211, CVE-2017-5923, CVE-2017-5924.

Cheers,
-Hilko
diff -Nru yara-3.1.0/debian/changelog yara-3.1.0/debian/changelog
--- yara-3.1.0/debian/changelog	2014-08-30 10:25:02.000000000 +0200
+++ yara-3.1.0/debian/changelog	2017-04-09 14:38:30.000000000 +0200
@@ -1,3 +1,10 @@
+yara (3.1.0-2+deb8u1) jessie-security; urgency=high
+
+  * Add patches for CVE-2016-10210, CVE-2016-10211, CVE-2017-5923,
+    CVE-2017-5924 (Closes: #859821)
+
+ -- Hilko Bengen <bengen@debian.org>  Sun, 09 Apr 2017 14:38:30 +0200
+
 yara (3.1.0-2) unstable; urgency=medium
 
   * Re-addded patches for FTBFS on kFreeBSD, Hurd
diff -Nru yara-3.1.0/debian/patches/0003-Fix-issue-576.patch yara-3.1.0/debian/patches/0003-Fix-issue-576.patch
--- yara-3.1.0/debian/patches/0003-Fix-issue-576.patch	1970-01-01 01:00:00.000000000 +0100
+++ yara-3.1.0/debian/patches/0003-Fix-issue-576.patch	2017-04-09 14:38:30.000000000 +0200
@@ -0,0 +1,383 @@
+From: plusvic <plusvic@gmail.com>
+Date: Wed, 4 Jan 2017 16:18:03 +0100
+Subject: Fix issue #576
+
+(cherry picked from commit eb491e03851a11bc811173f5e13c89cefa7257ac)
+---
+ libyara/lexer.c | 104 ++++++++++++++++++++++++++++++++++++--------------------
+ libyara/lexer.l |   7 ++++
+ 2 files changed, 75 insertions(+), 36 deletions(-)
+
+diff --git a/libyara/lexer.c b/libyara/lexer.c
+index 8d114c8..2fce34b 100644
+--- a/libyara/lexer.c
++++ b/libyara/lexer.c
+@@ -9,7 +9,7 @@
+ #define FLEX_SCANNER
+ #define YY_FLEX_MAJOR_VERSION 2
+ #define YY_FLEX_MINOR_VERSION 5
+-#define YY_FLEX_SUBMINOR_VERSION 35
++#define YY_FLEX_SUBMINOR_VERSION 39
+ #if YY_FLEX_SUBMINOR_VERSION > 0
+ #define FLEX_BETA
+ #endif
+@@ -54,7 +54,6 @@ typedef int flex_int32_t;
+ typedef unsigned char flex_uint8_t; 
+ typedef unsigned short int flex_uint16_t;
+ typedef unsigned int flex_uint32_t;
+-#endif /* ! C99 */
+ 
+ /* Limits of integral types. */
+ #ifndef INT8_MIN
+@@ -85,6 +84,8 @@ typedef unsigned int flex_uint32_t;
+ #define UINT32_MAX             (4294967295U)
+ #endif
+ 
++#endif /* ! C99 */
++
+ #endif /* ! FLEXINT_H */
+ 
+ #ifdef __cplusplus
+@@ -158,7 +159,15 @@ typedef void* yyscan_t;
+ 
+ /* Size of default input buffer. */
+ #ifndef YY_BUF_SIZE
++#ifdef __ia64__
++/* On IA-64, the buffer size is 16k, not 8k.
++ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
++ * Ditto for the __ia64__ case accordingly.
++ */
++#define YY_BUF_SIZE 32768
++#else
+ #define YY_BUF_SIZE 16384
++#endif /* __ia64__ */
+ #endif
+ 
+ /* The state buf must be large enough to hold one state per character in the main buffer.
+@@ -188,11 +197,18 @@ typedef size_t yy_size_t;
+      */
+     #define  YY_LESS_LINENO(n) \
+             do { \
+-                yy_size_t yyl;\
++                int yyl;\
+                 for ( yyl = n; yyl < yyleng; ++yyl )\
+                     if ( yytext[yyl] == '\n' )\
+                         --yylineno;\
+             }while(0)
++    #define YY_LINENO_REWIND_TO(dst) \
++            do {\
++                const char *p;\
++                for ( p = yy_cp-1; p >= (dst); --p)\
++                    if ( *p == '\n' )\
++                        --yylineno;\
++            }while(0)
+     
+ /* Return all but the first "n" matched characters back to the input stream. */
+ #define yyless(n) \
+@@ -338,7 +354,7 @@ void yara_yyfree (void * ,yyscan_t yyscanner );
+ 
+ /* Begin user sect3 */
+ 
+-#define yara_yywrap(n) 1
++#define yara_yywrap(yyscanner) 1
+ #define YY_SKIP_YYWRAP
+ 
+ typedef unsigned char YY_CHAR;
+@@ -680,7 +696,7 @@ limitations under the License.
+ 
+ 
+ 
+-#line 684 "lexer.c"
++#line 700 "lexer.c"
+ 
+ #define INITIAL 0
+ #define str 1
+@@ -775,6 +791,10 @@ int yara_yyget_lineno (yyscan_t yyscanner );
+ 
+ void yara_yyset_lineno (int line_number ,yyscan_t yyscanner );
+ 
++int yara_yyget_column  (yyscan_t yyscanner );
++
++void yara_yyset_column (int column_no ,yyscan_t yyscanner );
++
+ YYSTYPE * yara_yyget_lval (yyscan_t yyscanner );
+ 
+ void yara_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
+@@ -811,7 +831,12 @@ static int input (yyscan_t yyscanner );
+ 
+ /* Amount of stuff to slurp up with each read. */
+ #ifndef YY_READ_BUF_SIZE
++#ifdef __ia64__
++/* On IA-64, the buffer size is 16k, not 8k */
++#define YY_READ_BUF_SIZE 16384
++#else
+ #define YY_READ_BUF_SIZE 8192
++#endif /* __ia64__ */
+ #endif
+ 
+ /* Copy whatever the last rule matched to the standard output. */
+@@ -819,7 +844,7 @@ static int input (yyscan_t yyscanner );
+ /* This used to be an fputs(), but since the string might contain NUL's,
+  * we now use fwrite().
+  */
+-#define ECHO fwrite( yytext, yyleng, 1, yyout )
++#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
+ #endif
+ 
+ /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+@@ -830,7 +855,7 @@ static int input (yyscan_t yyscanner );
+ 	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+ 		{ \
+ 		int c = '*'; \
+-		yy_size_t n; \
++		int n; \
+ 		for ( n = 0; n < max_size && \
+ 			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+ 			buf[n] = (char) c; \
+@@ -843,7 +868,7 @@ static int input (yyscan_t yyscanner );
+ 	else \
+ 		{ \
+ 		errno=0; \
+-		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
++		while ( (result = fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+ 			{ \
+ 			if( errno != EINTR) \
+ 				{ \
+@@ -915,11 +940,6 @@ YY_DECL
+ 	register int yy_act;
+     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ 
+-#line 83 "lexer.l"
+-
+-
+-#line 922 "lexer.c"
+-
+     yylval = yylval_param;
+ 
+ 	if ( !yyg->yy_init )
+@@ -948,6 +968,12 @@ YY_DECL
+ 		yara_yy_load_buffer_state(yyscanner );
+ 		}
+ 
++	{
++#line 83 "lexer.l"
++
++
++#line 976 "lexer.c"
++
+ 	while ( 1 )		/* loops until end-of-file is reached */
+ 		{
+ 		yy_cp = yyg->yy_c_buf_p;
+@@ -964,7 +990,7 @@ YY_DECL
+ yy_match:
+ 		do
+ 			{
+-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
++			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+ 			if ( yy_accept[yy_current_state] )
+ 				{
+ 				yyg->yy_last_accepting_state = yy_current_state;
+@@ -1650,6 +1676,13 @@ YY_RULE_SETUP
+ {
+ 
+   LEX_CHECK_SPACE_OK("\\.", yyextra->lex_buf_len, LEX_BUF_SIZE);
++
++  if (yytext[1] == 0)
++  {
++    yyerror(yyscanner, compiler, "malformed regular expression");
++    yyterminate();
++  }
++
+   *yyextra->lex_buf_ptr++ = yytext[0];
+   *yyextra->lex_buf_ptr++ = yytext[1];
+   yyextra->lex_buf_len += 2;
+@@ -1657,13 +1690,13 @@ YY_RULE_SETUP
+ 	YY_BREAK
+ case 68:
+ YY_RULE_SETUP
+-#line 498 "lexer.l"
++#line 505 "lexer.l"
+ { YYTEXT_TO_BUFFER; }
+ 	YY_BREAK
+ case 69:
+ /* rule 69 can match eol */
+ YY_RULE_SETUP
+-#line 501 "lexer.l"
++#line 508 "lexer.l"
+ {
+ 
+   yyerror(yyscanner, compiler, "unterminated regular expression");
+@@ -1672,7 +1705,7 @@ YY_RULE_SETUP
+ 	YY_BREAK
+ case 70:
+ YY_RULE_SETUP
+-#line 508 "lexer.l"
++#line 515 "lexer.l"
+ {
+ 
+   yyextra->lex_buf_ptr = yyextra->lex_buf;
+@@ -1682,7 +1715,7 @@ YY_RULE_SETUP
+ 	YY_BREAK
+ case 71:
+ YY_RULE_SETUP
+-#line 516 "lexer.l"
++#line 523 "lexer.l"
+ {
+ 
+   yyextra->lex_buf_ptr = yyextra->lex_buf;
+@@ -1693,7 +1726,7 @@ YY_RULE_SETUP
+ case 72:
+ /* rule 72 can match eol */
+ YY_RULE_SETUP
+-#line 524 "lexer.l"
++#line 531 "lexer.l"
+ {
+ 
+   int len = strlen(yytext);
+@@ -1711,12 +1744,12 @@ YY_RULE_SETUP
+ case 73:
+ /* rule 73 can match eol */
+ YY_RULE_SETUP
+-#line 539 "lexer.l"
++#line 546 "lexer.l"
+ /* skip whitespace */
+ 	YY_BREAK
+ case 74:
+ YY_RULE_SETUP
+-#line 541 "lexer.l"
++#line 548 "lexer.l"
+ {
+ 
+   if (yytext[0] >= 32 && yytext[0] < 127)
+@@ -1732,10 +1765,10 @@ YY_RULE_SETUP
+ 	YY_BREAK
+ case 75:
+ YY_RULE_SETUP
+-#line 554 "lexer.l"
++#line 561 "lexer.l"
+ ECHO;
+ 	YY_BREAK
+-#line 1739 "lexer.c"
++#line 1772 "lexer.c"
+ 
+ 	case YY_END_OF_BUFFER:
+ 		{
+@@ -1864,6 +1897,7 @@ ECHO;
+ 			"fatal flex scanner internal error--no action found" );
+ 	} /* end of action switch */
+ 		} /* end of scanning one token */
++	} /* end of user's declarations */
+ } /* end of yara_yylex */
+ 
+ /* yy_get_next_buffer - try to read in a new buffer
+@@ -1920,14 +1954,14 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
+ 
+ 	else
+ 		{
+-			yy_size_t num_to_read =
++			int num_to_read =
+ 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+ 
+ 		while ( num_to_read <= 0 )
+ 			{ /* Not enough room in the buffer - grow it. */
+ 
+ 			/* just a shorter name for the current buffer */
+-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
++			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+ 
+ 			int yy_c_buf_p_offset =
+ 				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+@@ -2062,6 +2096,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
+ 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ 	yy_is_jam = (yy_current_state == 218);
+ 
++	(void)yyg;
+ 	return yy_is_jam ? 0 : yy_current_state;
+ }
+ 
+@@ -2114,7 +2149,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
+ 				case EOB_ACT_END_OF_FILE:
+ 					{
+ 					if ( yara_yywrap(yyscanner ) )
+-						return 0;
++						return EOF;
+ 
+ 					if ( ! yyg->yy_did_buffer_switch_on_eof )
+ 						YY_NEW_FILE;
+@@ -2261,10 +2296,6 @@ static void yara_yy_load_buffer_state  (yyscan_t yyscanner)
+ 	yara_yyfree((void *) b ,yyscanner );
+ }
+ 
+-#ifndef __cplusplus
+-extern int isatty (int );
+-#endif /* __cplusplus */
+-    
+ /* Initializes or reinitializes a buffer.
+  * This function is sometimes called more than once on the same buffer,
+  * such as during a yara_yyrestart() or at EOF.
+@@ -2474,8 +2505,8 @@ YY_BUFFER_STATE yara_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
+ 
+ /** Setup the input buffer state to scan the given bytes. The next call to yara_yylex() will
+  * scan from a @e copy of @a bytes.
+- * @param bytes the byte buffer to scan
+- * @param len the number of bytes in the buffer pointed to by @a bytes.
++ * @param yybytes the byte buffer to scan
++ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+  * @param yyscanner The scanner object.
+  * @return the newly allocated buffer state object.
+  */
+@@ -2483,7 +2514,8 @@ YY_BUFFER_STATE yara_yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes
+ {
+ 	YY_BUFFER_STATE b;
+ 	char *buf;
+-	yy_size_t n, i;
++	yy_size_t n;
++	yy_size_t i;
+     
+ 	/* Get memory for full buffer, including space for trailing EOB's. */
+ 	n = _yybytes_len + 2;
+@@ -2629,7 +2661,7 @@ void yara_yyset_lineno (int  line_number , yyscan_t yyscanner)
+ 
+         /* lineno is only valid if an input buffer exists. */
+         if (! YY_CURRENT_BUFFER )
+-           yy_fatal_error( "yara_yyset_lineno called with no buffer" , yyscanner); 
++           YY_FATAL_ERROR( "yara_yyset_lineno called with no buffer" );
+     
+     yylineno = line_number;
+ }
+@@ -2644,7 +2676,7 @@ void yara_yyset_column (int  column_no , yyscan_t yyscanner)
+ 
+         /* column is only valid if an input buffer exists. */
+         if (! YY_CURRENT_BUFFER )
+-           yy_fatal_error( "yara_yyset_column called with no buffer" , yyscanner); 
++           YY_FATAL_ERROR( "yara_yyset_column called with no buffer" );
+     
+     yycolumn = column_no;
+ }
+@@ -2868,7 +2900,7 @@ void yara_yyfree (void * ptr , yyscan_t yyscanner)
+ 
+ #define YYTABLES_NAME "yytables"
+ 
+-#line 554 "lexer.l"
++#line 560 "lexer.l"
+ 
+ 
+ 
+diff --git a/libyara/lexer.l b/libyara/lexer.l
+index 25c948e..1c0ccf7 100644
+--- a/libyara/lexer.l
++++ b/libyara/lexer.l
+@@ -489,6 +489,13 @@ $({letter}|{digit}|_)*  {
+ <regexp>\\. {
+ 
+   LEX_CHECK_SPACE_OK("\\.", yyextra->lex_buf_len, LEX_BUF_SIZE);
++
++  if (yytext[1] == 0)
++  {
++    yyerror(yyscanner, compiler, "malformed regular expression");
++    yyterminate();
++  }
++
+   *yyextra->lex_buf_ptr++ = yytext[0];
+   *yyextra->lex_buf_ptr++ = yytext[1];
+   yyextra->lex_buf_len += 2;
diff -Nru yara-3.1.0/debian/patches/0004-Fix-issue-575.patch yara-3.1.0/debian/patches/0004-Fix-issue-575.patch
--- yara-3.1.0/debian/patches/0004-Fix-issue-575.patch	1970-01-01 01:00:00.000000000 +0100
+++ yara-3.1.0/debian/patches/0004-Fix-issue-575.patch	2017-04-09 14:38:30.000000000 +0200
@@ -0,0 +1,4713 @@
+From: plusvic <plusvic@gmail.com>
+Date: Wed, 4 Jan 2017 17:09:35 +0100
+Subject: Fix issue #575
+
+(cherry picked from commit 890c3f850293176c0e996a602ffa88b315f4e98f)
+---
+ libyara/grammar.c | 2767 ++++++++++++++++++++++++++---------------------------
+ libyara/grammar.h |  177 ++--
+ libyara/grammar.y |    5 +
+ 3 files changed, 1470 insertions(+), 1479 deletions(-)
+
+diff --git a/libyara/grammar.c b/libyara/grammar.c
+index b39e4e8..f88bbcb 100644
+--- a/libyara/grammar.c
++++ b/libyara/grammar.c
+@@ -1,14 +1,13 @@
+-/* A Bison parser, made by GNU Bison 2.3.  */
++/* A Bison parser, made by GNU Bison 3.0.2.  */
+ 
+-/* Skeleton implementation for Bison's Yacc-like parsers in C
++/* Bison implementation for Yacc-like parsers in C
+ 
+-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+-   Free Software Foundation, Inc.
++   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+ 
+-   This program is free software; you can redistribute it and/or modify
++   This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+-   the Free Software Foundation; either version 2, or (at your option)
+-   any later version.
++   the Free Software Foundation, either version 3 of the License, or
++   (at your option) any later version.
+ 
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+@@ -16,9 +15,7 @@
+    GNU General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+-   along with this program; if not, write to the Free Software
+-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+-   Boston, MA 02110-1301, USA.  */
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+ 
+ /* As a special exception, you may create a larger work that contains
+    part or all of the Bison parser skeleton and distribute that work
+@@ -47,7 +44,7 @@
+ #define YYBISON 1
+ 
+ /* Bison version.  */
+-#define YYBISON_VERSION "2.3"
++#define YYBISON_VERSION "3.0.2"
+ 
+ /* Skeleton name.  */
+ #define YYSKELETON_NAME "yacc.c"
+@@ -55,136 +52,23 @@
+ /* Pure parsers.  */
+ #define YYPURE 1
+ 
+-/* Using locations.  */
+-#define YYLSP_NEEDED 0
++/* Push parsers.  */
++#define YYPUSH 0
+ 
+-/* Substitute the variable and function names.  */
+-#define yyparse yara_yyparse
+-#define yylex   yara_yylex
+-#define yyerror yara_yyerror
+-#define yylval  yara_yylval
+-#define yychar  yara_yychar
+-#define yydebug yara_yydebug
+-#define yynerrs yara_yynerrs
+-
+-
+-/* Tokens.  */
+-#ifndef YYTOKENTYPE
+-# define YYTOKENTYPE
+-   /* Put the tokens into the symbol table, so that GDB and other debuggers
+-      know about them.  */
+-   enum yytokentype {
+-     _RULE_ = 258,
+-     _PRIVATE_ = 259,
+-     _GLOBAL_ = 260,
+-     _META_ = 261,
+-     _STRINGS_ = 262,
+-     _CONDITION_ = 263,
+-     _IDENTIFIER_ = 264,
+-     _STRING_IDENTIFIER_ = 265,
+-     _STRING_COUNT_ = 266,
+-     _STRING_OFFSET_ = 267,
+-     _STRING_IDENTIFIER_WITH_WILDCARD_ = 268,
+-     _NUMBER_ = 269,
+-     _TEXT_STRING_ = 270,
+-     _HEX_STRING_ = 271,
+-     _REGEXP_ = 272,
+-     _ASCII_ = 273,
+-     _WIDE_ = 274,
+-     _NOCASE_ = 275,
+-     _FULLWORD_ = 276,
+-     _AT_ = 277,
+-     _FILESIZE_ = 278,
+-     _ENTRYPOINT_ = 279,
+-     _ALL_ = 280,
+-     _ANY_ = 281,
+-     _IN_ = 282,
+-     _OF_ = 283,
+-     _FOR_ = 284,
+-     _THEM_ = 285,
+-     _INT8_ = 286,
+-     _INT16_ = 287,
+-     _INT32_ = 288,
+-     _UINT8_ = 289,
+-     _UINT16_ = 290,
+-     _UINT32_ = 291,
+-     _MATCHES_ = 292,
+-     _CONTAINS_ = 293,
+-     _IMPORT_ = 294,
+-     _TRUE_ = 295,
+-     _FALSE_ = 296,
+-     _OR_ = 297,
+-     _AND_ = 298,
+-     _IS_ = 299,
+-     _NEQ_ = 300,
+-     _EQ_ = 301,
+-     _GE_ = 302,
+-     _GT_ = 303,
+-     _LE_ = 304,
+-     _LT_ = 305,
+-     _SHIFT_RIGHT_ = 306,
+-     _SHIFT_LEFT_ = 307,
+-     _NOT_ = 308
+-   };
+-#endif
+-/* Tokens.  */
+-#define _RULE_ 258
+-#define _PRIVATE_ 259
+-#define _GLOBAL_ 260
+-#define _META_ 261
+-#define _STRINGS_ 262
+-#define _CONDITION_ 263
+-#define _IDENTIFIER_ 264
+-#define _STRING_IDENTIFIER_ 265
+-#define _STRING_COUNT_ 266
+-#define _STRING_OFFSET_ 267
+-#define _STRING_IDENTIFIER_WITH_WILDCARD_ 268
+-#define _NUMBER_ 269
+-#define _TEXT_STRING_ 270
+-#define _HEX_STRING_ 271
+-#define _REGEXP_ 272
+-#define _ASCII_ 273
+-#define _WIDE_ 274
+-#define _NOCASE_ 275
+-#define _FULLWORD_ 276
+-#define _AT_ 277
+-#define _FILESIZE_ 278
+-#define _ENTRYPOINT_ 279
+-#define _ALL_ 280
+-#define _ANY_ 281
+-#define _IN_ 282
+-#define _OF_ 283
+-#define _FOR_ 284
+-#define _THEM_ 285
+-#define _INT8_ 286
+-#define _INT16_ 287
+-#define _INT32_ 288
+-#define _UINT8_ 289
+-#define _UINT16_ 290
+-#define _UINT32_ 291
+-#define _MATCHES_ 292
+-#define _CONTAINS_ 293
+-#define _IMPORT_ 294
+-#define _TRUE_ 295
+-#define _FALSE_ 296
+-#define _OR_ 297
+-#define _AND_ 298
+-#define _IS_ 299
+-#define _NEQ_ 300
+-#define _EQ_ 301
+-#define _GE_ 302
+-#define _GT_ 303
+-#define _LE_ 304
+-#define _LT_ 305
+-#define _SHIFT_RIGHT_ 306
+-#define _SHIFT_LEFT_ 307
+-#define _NOT_ 308
++/* Pull parsers.  */
++#define YYPULL 1
+ 
+ 
++/* Substitute the variable and function names.  */
++#define yyparse         yara_yyparse
++#define yylex           yara_yylex
++#define yyerror         yara_yyerror
++#define yydebug         yara_yydebug
++#define yynerrs         yara_yynerrs
+ 
+ 
+ /* Copy the first part of user declarations.  */
+-#line 17 "grammar.y"
++#line 17 "grammar.y" /* yacc.c:339  */
+ 
+ 
+ #include <assert.h>
+@@ -252,11 +136,15 @@
+ #define MSG(op)  "wrong type \"string\" for \"" op "\" operator"
+ 
+ 
++#line 140 "grammar.c" /* yacc.c:339  */
+ 
+-/* Enabling traces.  */
+-#ifndef YYDEBUG
+-# define YYDEBUG 1
+-#endif
++# ifndef YY_NULLPTR
++#  if defined __cplusplus && 201103L <= __cplusplus
++#   define YY_NULLPTR nullptr
++#  else
++#   define YY_NULLPTR 0
++#  endif
++# endif
+ 
+ /* Enabling verbose error messages.  */
+ #ifdef YYERROR_VERBOSE
+@@ -266,15 +154,136 @@
+ # define YYERROR_VERBOSE 0
+ #endif
+ 
+-/* Enabling the token table.  */
+-#ifndef YYTOKEN_TABLE
+-# define YYTOKEN_TABLE 0
++/* In a future release of Bison, this section will be replaced
++   by #include "y.tab.h".  */
++#ifndef YY_YARA_YY_GRAMMAR_H_INCLUDED
++# define YY_YARA_YY_GRAMMAR_H_INCLUDED
++/* Debug traces.  */
++#ifndef YYDEBUG
++# define YYDEBUG 1
++#endif
++#if YYDEBUG
++extern int yara_yydebug;
++#endif
++
++/* Token type.  */
++#ifndef YYTOKENTYPE
++# define YYTOKENTYPE
++  enum yytokentype
++  {
++    _RULE_ = 258,
++    _PRIVATE_ = 259,
++    _GLOBAL_ = 260,
++    _META_ = 261,
++    _STRINGS_ = 262,
++    _CONDITION_ = 263,
++    _IDENTIFIER_ = 264,
++    _STRING_IDENTIFIER_ = 265,
++    _STRING_COUNT_ = 266,
++    _STRING_OFFSET_ = 267,
++    _STRING_IDENTIFIER_WITH_WILDCARD_ = 268,
++    _NUMBER_ = 269,
++    _TEXT_STRING_ = 270,
++    _HEX_STRING_ = 271,
++    _REGEXP_ = 272,
++    _ASCII_ = 273,
++    _WIDE_ = 274,
++    _NOCASE_ = 275,
++    _FULLWORD_ = 276,
++    _AT_ = 277,
++    _FILESIZE_ = 278,
++    _ENTRYPOINT_ = 279,
++    _ALL_ = 280,
++    _ANY_ = 281,
++    _IN_ = 282,
++    _OF_ = 283,
++    _FOR_ = 284,
++    _THEM_ = 285,
++    _INT8_ = 286,
++    _INT16_ = 287,
++    _INT32_ = 288,
++    _UINT8_ = 289,
++    _UINT16_ = 290,
++    _UINT32_ = 291,
++    _MATCHES_ = 292,
++    _CONTAINS_ = 293,
++    _IMPORT_ = 294,
++    _TRUE_ = 295,
++    _FALSE_ = 296,
++    _OR_ = 297,
++    _AND_ = 298,
++    _LT_ = 299,
++    _LE_ = 300,
++    _GT_ = 301,
++    _GE_ = 302,
++    _EQ_ = 303,
++    _NEQ_ = 304,
++    _IS_ = 305,
++    _SHIFT_LEFT_ = 306,
++    _SHIFT_RIGHT_ = 307,
++    _NOT_ = 308
++  };
+ #endif
++/* Tokens.  */
++#define _RULE_ 258
++#define _PRIVATE_ 259
++#define _GLOBAL_ 260
++#define _META_ 261
++#define _STRINGS_ 262
++#define _CONDITION_ 263
++#define _IDENTIFIER_ 264
++#define _STRING_IDENTIFIER_ 265
++#define _STRING_COUNT_ 266
++#define _STRING_OFFSET_ 267
++#define _STRING_IDENTIFIER_WITH_WILDCARD_ 268
++#define _NUMBER_ 269
++#define _TEXT_STRING_ 270
++#define _HEX_STRING_ 271
++#define _REGEXP_ 272
++#define _ASCII_ 273
++#define _WIDE_ 274
++#define _NOCASE_ 275
++#define _FULLWORD_ 276
++#define _AT_ 277
++#define _FILESIZE_ 278
++#define _ENTRYPOINT_ 279
++#define _ALL_ 280
++#define _ANY_ 281
++#define _IN_ 282
++#define _OF_ 283
++#define _FOR_ 284
++#define _THEM_ 285
++#define _INT8_ 286
++#define _INT16_ 287
++#define _INT32_ 288
++#define _UINT8_ 289
++#define _UINT16_ 290
++#define _UINT32_ 291
++#define _MATCHES_ 292
++#define _CONTAINS_ 293
++#define _IMPORT_ 294
++#define _TRUE_ 295
++#define _FALSE_ 296
++#define _OR_ 297
++#define _AND_ 298
++#define _LT_ 299
++#define _LE_ 300
++#define _GT_ 301
++#define _GE_ 302
++#define _EQ_ 303
++#define _NEQ_ 304
++#define _IS_ 305
++#define _SHIFT_LEFT_ 306
++#define _SHIFT_RIGHT_ 307
++#define _NOT_ 308
+ 
++/* Value type.  */
+ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+-typedef union YYSTYPE
+-#line 185 "grammar.y"
++typedef union YYSTYPE YYSTYPE;
++union YYSTYPE
+ {
++#line 185 "grammar.y" /* yacc.c:355  */
++
+   SIZED_STRING*   sized_string;
+   char*           c_string;
+   int8_t          expression_type;
+@@ -282,22 +291,22 @@ typedef union YYSTYPE
+   YR_STRING*      string;
+   YR_META*        meta;
+   YR_OBJECT*      object;
+-}
+-/* Line 193 of yacc.c.  */
+-#line 288 "grammar.c"
+-	YYSTYPE;
+-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+-# define YYSTYPE_IS_DECLARED 1
++
++#line 296 "grammar.c" /* yacc.c:355  */
++};
+ # define YYSTYPE_IS_TRIVIAL 1
++# define YYSTYPE_IS_DECLARED 1
+ #endif
+ 
+ 
+ 
+-/* Copy the second part of user declarations.  */
++int yara_yyparse (void *yyscanner, YR_COMPILER* compiler);
++
++#endif /* !YY_YARA_YY_GRAMMAR_H_INCLUDED  */
+ 
++/* Copy the second part of user declarations.  */
+ 
+-/* Line 216 of yacc.c.  */
+-#line 301 "grammar.c"
++#line 310 "grammar.c" /* yacc.c:358  */
+ 
+ #ifdef short
+ # undef short
+@@ -311,11 +320,8 @@ typedef unsigned char yytype_uint8;
+ 
+ #ifdef YYTYPE_INT8
+ typedef YYTYPE_INT8 yytype_int8;
+-#elif (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-typedef signed char yytype_int8;
+ #else
+-typedef short int yytype_int8;
++typedef signed char yytype_int8;
+ #endif
+ 
+ #ifdef YYTYPE_UINT16
+@@ -335,8 +341,7 @@ typedef short int yytype_int16;
+ #  define YYSIZE_T __SIZE_TYPE__
+ # elif defined size_t
+ #  define YYSIZE_T size_t
+-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++# elif ! defined YYSIZE_T
+ #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+ #  define YYSIZE_T size_t
+ # else
+@@ -350,38 +355,67 @@ typedef short int yytype_int16;
+ # if defined YYENABLE_NLS && YYENABLE_NLS
+ #  if ENABLE_NLS
+ #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
++#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+ #  endif
+ # endif
+ # ifndef YY_
+-#  define YY_(msgid) msgid
++#  define YY_(Msgid) Msgid
++# endif
++#endif
++
++#ifndef YY_ATTRIBUTE
++# if (defined __GNUC__                                               \
++      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
++     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
++#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
++# else
++#  define YY_ATTRIBUTE(Spec) /* empty */
++# endif
++#endif
++
++#ifndef YY_ATTRIBUTE_PURE
++# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
++#endif
++
++#ifndef YY_ATTRIBUTE_UNUSED
++# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
++#endif
++
++#if !defined _Noreturn \
++     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
++# if defined _MSC_VER && 1200 <= _MSC_VER
++#  define _Noreturn __declspec (noreturn)
++# else
++#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+ # endif
+ #endif
+ 
+ /* Suppress unused-variable warnings by "using" E.  */
+ #if ! defined lint || defined __GNUC__
+-# define YYUSE(e) ((void) (e))
++# define YYUSE(E) ((void) (E))
+ #else
+-# define YYUSE(e) /* empty */
++# define YYUSE(E) /* empty */
+ #endif
+ 
+-/* Identity function, used to suppress warnings about constant conditions.  */
+-#ifndef lint
+-# define YYID(n) (n)
+-#else
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-static int
+-YYID (int i)
++#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
++/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
++# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
++    _Pragma ("GCC diagnostic push") \
++    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
++    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
++# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
++    _Pragma ("GCC diagnostic pop")
+ #else
+-static int
+-YYID (i)
+-    int i;
++# define YY_INITIAL_VALUE(Value) Value
+ #endif
+-{
+-  return i;
+-}
++#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
++# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+ #endif
++#ifndef YY_INITIAL_VALUE
++# define YY_INITIAL_VALUE(Value) /* Nothing. */
++#endif
++
+ 
+ #if ! defined yyoverflow || YYERROR_VERBOSE
+ 
+@@ -400,11 +434,11 @@ YYID (i)
+ #    define alloca _alloca
+ #   else
+ #    define YYSTACK_ALLOC alloca
+-#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+ #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+-#     ifndef _STDLIB_H
+-#      define _STDLIB_H 1
++      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
++#     ifndef EXIT_SUCCESS
++#      define EXIT_SUCCESS 0
+ #     endif
+ #    endif
+ #   endif
+@@ -412,8 +446,8 @@ YYID (i)
+ # endif
+ 
+ # ifdef YYSTACK_ALLOC
+-   /* Pacify GCC's `empty if-body' warning.  */
+-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
++   /* Pacify GCC's 'empty if-body' warning.  */
++#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+ #  ifndef YYSTACK_ALLOC_MAXIMUM
+     /* The OS might guarantee only one guard page at the bottom of the stack,
+        and a page size can be as small as 4096 bytes.  So we cannot safely
+@@ -427,25 +461,23 @@ YYID (i)
+ #  ifndef YYSTACK_ALLOC_MAXIMUM
+ #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+ #  endif
+-#  if (defined __cplusplus && ! defined _STDLIB_H \
++#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+        && ! ((defined YYMALLOC || defined malloc) \
+-	     && (defined YYFREE || defined free)))
++             && (defined YYFREE || defined free)))
+ #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+-#   ifndef _STDLIB_H
+-#    define _STDLIB_H 1
++#   ifndef EXIT_SUCCESS
++#    define EXIT_SUCCESS 0
+ #   endif
+ #  endif
+ #  ifndef YYMALLOC
+ #   define YYMALLOC malloc
+-#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++#   if ! defined malloc && ! defined EXIT_SUCCESS
+ void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+ #   endif
+ #  endif
+ #  ifndef YYFREE
+ #   define YYFREE free
+-#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
++#   if ! defined free && ! defined EXIT_SUCCESS
+ void free (void *); /* INFRINGES ON USER NAME SPACE */
+ #   endif
+ #  endif
+@@ -455,14 +487,14 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
+ 
+ #if (! defined yyoverflow \
+      && (! defined __cplusplus \
+-	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
++         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+ 
+ /* A type that is properly aligned for any stack member.  */
+ union yyalloc
+ {
+-  yytype_int16 yyss;
+-  YYSTYPE yyvs;
+-  };
++  yytype_int16 yyss_alloc;
++  YYSTYPE yyvs_alloc;
++};
+ 
+ /* The size of the maximum gap between one aligned stack and the next.  */
+ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+@@ -473,64 +505,70 @@ union yyalloc
+      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+       + YYSTACK_GAP_MAXIMUM)
+ 
+-/* Copy COUNT objects from FROM to TO.  The source and destination do
+-   not overlap.  */
+-# ifndef YYCOPY
+-#  if defined __GNUC__ && 1 < __GNUC__
+-#   define YYCOPY(To, From, Count) \
+-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+-#  else
+-#   define YYCOPY(To, From, Count)		\
+-      do					\
+-	{					\
+-	  YYSIZE_T yyi;				\
+-	  for (yyi = 0; yyi < (Count); yyi++)	\
+-	    (To)[yyi] = (From)[yyi];		\
+-	}					\
+-      while (YYID (0))
+-#  endif
+-# endif
++# define YYCOPY_NEEDED 1
+ 
+ /* Relocate STACK from its old location to the new one.  The
+    local variables YYSIZE and YYSTACKSIZE give the old and new number of
+    elements in the stack, and YYPTR gives the new location of the
+    stack.  Advance YYPTR to a properly aligned location for the next
+    stack.  */
+-# define YYSTACK_RELOCATE(Stack)					\
+-    do									\
+-      {									\
+-	YYSIZE_T yynewbytes;						\
+-	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+-	Stack = &yyptr->Stack;						\
+-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+-	yyptr += yynewbytes / sizeof (*yyptr);				\
+-      }									\
+-    while (YYID (0))
++# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
++    do                                                                  \
++      {                                                                 \
++        YYSIZE_T yynewbytes;                                            \
++        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
++        Stack = &yyptr->Stack_alloc;                                    \
++        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
++        yyptr += yynewbytes / sizeof (*yyptr);                          \
++      }                                                                 \
++    while (0)
+ 
+ #endif
+ 
++#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
++/* Copy COUNT objects from SRC to DST.  The source and destination do
++   not overlap.  */
++# ifndef YYCOPY
++#  if defined __GNUC__ && 1 < __GNUC__
++#   define YYCOPY(Dst, Src, Count) \
++      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
++#  else
++#   define YYCOPY(Dst, Src, Count)              \
++      do                                        \
++        {                                       \
++          YYSIZE_T yyi;                         \
++          for (yyi = 0; yyi < (Count); yyi++)   \
++            (Dst)[yyi] = (Src)[yyi];            \
++        }                                       \
++      while (0)
++#  endif
++# endif
++#endif /* !YYCOPY_NEEDED */
++
+ /* YYFINAL -- State number of the termination state.  */
+ #define YYFINAL  2
+ /* YYLAST -- Last index in YYTABLE.  */
+-#define YYLAST   433
++#define YYLAST   434
+ 
+ /* YYNTOKENS -- Number of terminals.  */
+ #define YYNTOKENS  74
+ /* YYNNTS -- Number of nonterminals.  */
+ #define YYNNTS  35
+ /* YYNRULES -- Number of rules.  */
+-#define YYNRULES  115
+-/* YYNRULES -- Number of states.  */
+-#define YYNSTATES  216
++#define YYNRULES  116
++/* YYNSTATES -- Number of states.  */
++#define YYNSTATES  217
+ 
+-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
++/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
++   by yylex, with out-of-bounds checking.  */
+ #define YYUNDEFTOK  2
+ #define YYMAXUTOK   308
+ 
+-#define YYTRANSLATE(YYX)						\
++#define YYTRANSLATE(YYX)                                                \
+   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+ 
+-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
++/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
++   as returned by yylex, without out-of-bounds checking.  */
+ static const yytype_uint8 yytranslate[] =
+ {
+        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+@@ -567,68 +605,7 @@ static const yytype_uint8 yytranslate[] =
+ };
+ 
+ #if YYDEBUG
+-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+-   YYRHS.  */
+-static const yytype_uint16 yyprhs[] =
+-{
+-       0,     0,     3,     4,     7,    10,    14,    18,    21,    31,
+-      32,    36,    37,    41,    45,    46,    49,    51,    53,    54,
+-      57,    59,    62,    64,    67,    71,    75,    79,    83,    85,
+-      88,    93,    94,   100,   104,   105,   108,   110,   112,   114,
+-     116,   118,   122,   127,   132,   133,   135,   139,   141,   143,
+-     145,   147,   151,   155,   157,   161,   165,   166,   167,   179,
+-     180,   190,   194,   197,   201,   205,   209,   213,   217,   221,
+-     225,   229,   233,   235,   239,   243,   245,   252,   254,   258,
+-     259,   264,   266,   268,   272,   274,   276,   278,   280,   282,
+-     286,   288,   290,   295,   300,   305,   310,   315,   320,   322,
+-     324,   326,   331,   333,   335,   339,   343,   347,   351,   355,
+-     359,   363,   367,   370,   374,   378
+-};
+-
+-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+-static const yytype_int8 yyrhs[] =
+-{
+-      75,     0,    -1,    -1,    75,    77,    -1,    75,    76,    -1,
+-      75,     1,    77,    -1,    75,     1,    63,    -1,    39,    15,
+-      -1,    81,     3,     9,    83,    64,    78,    79,    80,    65,
+-      -1,    -1,     6,    66,    85,    -1,    -1,     7,    66,    87,
+-      -1,     8,    66,    95,    -1,    -1,    81,    82,    -1,     4,
+-      -1,     5,    -1,    -1,    66,    84,    -1,     9,    -1,    84,
+-       9,    -1,    86,    -1,    85,    86,    -1,     9,    67,    15,
+-      -1,     9,    67,    14,    -1,     9,    67,    40,    -1,     9,
+-      67,    41,    -1,    88,    -1,    87,    88,    -1,    10,    67,
+-      15,    90,    -1,    -1,    10,    67,    89,    17,    90,    -1,
+-      10,    67,    16,    -1,    -1,    90,    91,    -1,    19,    -1,
+-      18,    -1,    20,    -1,    21,    -1,     9,    -1,    92,    68,
+-       9,    -1,    92,    69,   108,    70,    -1,    92,    71,    93,
+-      72,    -1,    -1,    96,    -1,    93,    73,    96,    -1,    17,
+-      -1,    96,    -1,    40,    -1,    41,    -1,   108,    37,    94,
+-      -1,   108,    38,   108,    -1,    10,    -1,    10,    22,   108,
+-      -1,    10,    27,   101,    -1,    -1,    -1,    29,   107,     9,
+-      27,    97,   100,    66,    98,    71,    95,    72,    -1,    -1,
+-      29,   107,    28,   103,    66,    99,    71,    95,    72,    -1,
+-     107,    28,   103,    -1,    61,    95,    -1,    95,    43,    95,
+-      -1,    95,    42,    95,    -1,   108,    53,   108,    -1,   108,
+-      51,   108,    -1,   108,    52,   108,    -1,   108,    50,   108,
+-      -1,   108,    49,   108,    -1,   108,    47,   108,    -1,   108,
+-      48,   108,    -1,   108,    -1,    71,    96,    72,    -1,    71,
+-     102,    72,    -1,   101,    -1,    71,   108,    68,    68,   108,
+-      72,    -1,   108,    -1,   102,    73,   108,    -1,    -1,    71,
+-     104,   105,    72,    -1,    30,    -1,   106,    -1,   105,    73,
+-     106,    -1,    10,    -1,    13,    -1,   108,    -1,    25,    -1,
+-      26,    -1,    71,   108,    72,    -1,    23,    -1,    24,    -1,
+-      31,    71,   108,    72,    -1,    32,    71,   108,    72,    -1,
+-      33,    71,   108,    72,    -1,    34,    71,   108,    72,    -1,
+-      35,    71,   108,    72,    -1,    36,    71,   108,    72,    -1,
+-      14,    -1,    15,    -1,    11,    -1,    12,    69,   108,    70,
+-      -1,    12,    -1,    92,    -1,   108,    56,   108,    -1,   108,
+-      57,   108,    -1,   108,    58,   108,    -1,   108,    59,   108,
+-      -1,   108,    60,   108,    -1,   108,    46,   108,    -1,   108,
+-      44,   108,    -1,   108,    45,   108,    -1,    62,   108,    -1,
+-     108,    55,   108,    -1,   108,    54,   108,    -1,    94,    -1
+-};
+-
+-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
++  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+ static const yytype_uint16 yyrline[] =
+ {
+        0,   198,   198,   200,   201,   202,   203,   208,   220,   239,
+@@ -636,17 +613,17 @@ static const yytype_uint16 yyrline[] =
+      341,   354,   391,   392,   397,   413,   426,   439,   456,   457,
+      462,   476,   475,   492,   509,   510,   515,   516,   517,   518,
+      523,   611,   660,   683,   723,   726,   748,   781,   826,   844,
+-     853,   862,   877,   891,   904,   919,   933,   968,   932,  1079,
+-    1078,  1155,  1161,  1167,  1173,  1181,  1190,  1199,  1208,  1217,
+-    1244,  1271,  1298,  1302,  1310,  1311,  1316,  1338,  1350,  1366,
+-    1365,  1371,  1380,  1381,  1386,  1391,  1400,  1401,  1405,  1413,
+-    1417,  1426,  1438,  1449,  1460,  1471,  1482,  1493,  1504,  1513,
+-    1536,  1549,  1562,  1582,  1617,  1626,  1635,  1644,  1653,  1662,
+-    1671,  1680,  1689,  1697,  1706,  1715
++     853,   862,   877,   891,   904,   919,   932,   938,   973,   937,
++    1084,  1083,  1160,  1166,  1172,  1178,  1186,  1195,  1204,  1213,
++    1222,  1249,  1276,  1303,  1307,  1315,  1316,  1321,  1343,  1355,
++    1371,  1370,  1376,  1385,  1386,  1391,  1396,  1405,  1406,  1410,
++    1418,  1422,  1431,  1443,  1454,  1465,  1476,  1487,  1498,  1509,
++    1518,  1541,  1554,  1567,  1587,  1622,  1631,  1640,  1649,  1658,
++    1667,  1676,  1685,  1694,  1702,  1711,  1720
+ };
+ #endif
+ 
+-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
++#if YYDEBUG || YYERROR_VERBOSE || 0
+ /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+ static const char *const yytname[] =
+@@ -659,24 +636,24 @@ static const char *const yytname[] =
+   "_FULLWORD_", "_AT_", "_FILESIZE_", "_ENTRYPOINT_", "_ALL_", "_ANY_",
+   "_IN_", "_OF_", "_FOR_", "_THEM_", "_INT8_", "_INT16_", "_INT32_",
+   "_UINT8_", "_UINT16_", "_UINT32_", "_MATCHES_", "_CONTAINS_", "_IMPORT_",
+-  "_TRUE_", "_FALSE_", "_OR_", "_AND_", "'&'", "'|'", "'^'", "_IS_",
+-  "_NEQ_", "_EQ_", "_GE_", "_GT_", "_LE_", "_LT_", "_SHIFT_RIGHT_",
+-  "_SHIFT_LEFT_", "'+'", "'-'", "'*'", "'\\\\'", "'%'", "_NOT_", "'~'",
+-  "'include'", "'{'", "'}'", "':'", "'='", "'.'", "'['", "']'", "'('",
+-  "')'", "','", "$accept", "rules", "import", "rule", "meta", "strings",
++  "_TRUE_", "_FALSE_", "_OR_", "_AND_", "'&'", "'|'", "'^'", "_LT_",
++  "_LE_", "_GT_", "_GE_", "_EQ_", "_NEQ_", "_IS_", "_SHIFT_LEFT_",
++  "_SHIFT_RIGHT_", "'+'", "'-'", "'*'", "'\\\\'", "'%'", "_NOT_", "'~'",
++  "'i'", "'{'", "'}'", "':'", "'='", "'.'", "'['", "']'", "'('", "')'",
++  "','", "$accept", "rules", "import", "rule", "meta", "strings",
+   "condition", "rule_modifiers", "rule_modifier", "tags", "tag_list",
+   "meta_declarations", "meta_declaration", "string_declarations",
+-  "string_declaration", "@1", "string_modifiers", "string_modifier",
++  "string_declaration", "$@1", "string_modifiers", "string_modifier",
+   "identifier", "arguments_list", "regexp", "boolean_expression",
+-  "expression", "@2", "@3", "@4", "integer_set", "range",
+-  "integer_enumeration", "string_set", "@5", "string_enumeration",
+-  "string_enumeration_item", "for_expression", "primary_expression", 0
++  "expression", "$@2", "$@3", "$@4", "integer_set", "range",
++  "integer_enumeration", "string_set", "$@5", "string_enumeration",
++  "string_enumeration_item", "for_expression", "primary_expression", YY_NULLPTR
+ };
+ #endif
+ 
+ # ifdef YYPRINT
+-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+-   token YYLEX-NUM.  */
++/* YYTOKNUM[NUM] -- (External) token number corresponding to the
++   (internal) symbol number NUM (which must be that of a token).  */
+ static const yytype_uint16 yytoknum[] =
+ {
+        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+@@ -690,199 +667,175 @@ static const yytype_uint16 yytoknum[] =
+ };
+ # endif
+ 
+-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+-static const yytype_uint8 yyr1[] =
+-{
+-       0,    74,    75,    75,    75,    75,    75,    76,    77,    78,
+-      78,    79,    79,    80,    81,    81,    82,    82,    83,    83,
+-      84,    84,    85,    85,    86,    86,    86,    86,    87,    87,
+-      88,    89,    88,    88,    90,    90,    91,    91,    91,    91,
+-      92,    92,    92,    92,    93,    93,    93,    94,    95,    96,
+-      96,    96,    96,    96,    96,    96,    97,    98,    96,    99,
+-      96,    96,    96,    96,    96,    96,    96,    96,    96,    96,
+-      96,    96,    96,    96,   100,   100,   101,   102,   102,   104,
+-     103,   103,   105,   105,   106,   106,   107,   107,   107,   108,
+-     108,   108,   108,   108,   108,   108,   108,   108,   108,   108,
+-     108,   108,   108,   108,   108,   108,   108,   108,   108,   108,
+-     108,   108,   108,   108,   108,   108
+-};
++#define YYPACT_NINF -66
+ 
+-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+-static const yytype_uint8 yyr2[] =
++#define yypact_value_is_default(Yystate) \
++  (!!((Yystate) == (-66)))
++
++#define YYTABLE_NINF -88
++
++#define yytable_value_is_error(Yytable_value) \
++  0
++
++  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
++     STATE-NUM.  */
++static const yytype_int16 yypact[] =
+ {
+-       0,     2,     0,     2,     2,     3,     3,     2,     9,     0,
+-       3,     0,     3,     3,     0,     2,     1,     1,     0,     2,
+-       1,     2,     1,     2,     3,     3,     3,     3,     1,     2,
+-       4,     0,     5,     3,     0,     2,     1,     1,     1,     1,
+-       1,     3,     4,     4,     0,     1,     3,     1,     1,     1,
+-       1,     3,     3,     1,     3,     3,     0,     0,    11,     0,
+-       9,     3,     2,     3,     3,     3,     3,     3,     3,     3,
+-       3,     3,     1,     3,     3,     1,     6,     1,     3,     0,
+-       4,     1,     1,     3,     1,     1,     1,     1,     1,     3,
+-       1,     1,     4,     4,     4,     4,     4,     4,     1,     1,
+-       1,     4,     1,     1,     3,     3,     3,     3,     3,     3,
+-       3,     3,     2,     3,     3,     1
++     -66,     6,   -66,   -61,   -11,   -66,   -66,    59,   -66,   -66,
++     -66,     9,   -66,   -66,   -66,   -51,    20,   -27,   -66,    31,
++      87,   -66,    30,   103,   113,    58,   119,    63,   113,   -66,
++     124,    69,    71,    -2,   -66,    76,   124,   -66,    80,   -66,
++     -66,   -66,   -66,   -66,    10,   -66,   -66,    -8,   -66,    75,
++     -66,   -66,   -66,   -66,   -66,   -66,   -66,   114,    81,    82,
++      83,    84,    85,    95,   -66,   -66,    80,   169,    80,   -35,
++     -66,   -21,   -66,   140,   206,   -66,   -66,   152,   169,    99,
++     169,   169,    26,   373,   169,   169,   169,   169,   169,   169,
++     -66,   -66,   -21,   101,   170,   162,   169,    80,    80,    80,
++     -29,   157,   169,   169,   169,   169,   169,   169,   169,   169,
++     169,   169,   169,   169,   169,   169,   169,   169,   169,   169,
++      37,   -66,   373,   169,   -66,   339,   223,   -66,   150,   -29,
++     230,   252,   259,   281,   288,   310,   -66,   -66,   -66,   346,
++      15,    65,   136,   -66,   -66,   -66,   -66,   -66,   373,   105,
++     105,   105,   373,   373,   373,   373,   373,   373,   373,    42,
++      42,    25,    25,   -66,   -66,   -66,   -66,   -66,   -66,   -66,
++     -66,    37,   366,   -66,   -66,   116,   -66,   -66,   -66,   -66,
++     -66,   -66,   -66,   -66,    80,    -5,   120,   118,   -66,    65,
++     -66,   -66,    45,   -66,   169,   169,   121,   -66,   123,   -66,
++      -5,   317,    60,   366,   -66,    80,   -66,   -66,   -66,   169,
++     125,   -26,   373,    80,   -66,   -19,   -66
+ };
+ 
+-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+-   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+-   means the default is an error.  */
++  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
++     Performed when YYTABLE does not specify something else to do.  Zero
++     means the default is an error.  */
+ static const yytype_uint8 yydefact[] =
+ {
+        2,     0,     1,    14,     0,     4,     3,     0,     6,     5,
+        7,     0,    16,    17,    15,    18,     0,     0,    20,    19,
+        9,    21,     0,    11,     0,     0,     0,     0,    10,    22,
+        0,     0,     0,     0,    23,     0,    12,    28,     0,     8,
+-      25,    24,    26,    27,    31,    29,    40,    53,   100,   102,
+-      98,    99,    47,    90,    91,    87,    88,     0,     0,     0,
+-       0,     0,     0,     0,    49,    50,     0,     0,     0,   103,
+-     115,    13,    48,     0,    72,    34,    33,     0,     0,     0,
+-       0,     0,     0,    86,     0,     0,     0,     0,     0,     0,
+-      62,   112,     0,    48,    72,     0,     0,    44,     0,     0,
++      25,    24,    26,    27,    31,    29,    40,    53,   101,   103,
++      99,   100,    47,    91,    92,    88,    89,     0,     0,     0,
++       0,     0,     0,     0,    49,    50,     0,     0,     0,   104,
++     116,    13,    48,     0,    73,    34,    33,     0,     0,     0,
++       0,     0,     0,    87,     0,     0,     0,     0,     0,     0,
++      63,   113,     0,    48,    73,     0,     0,    44,     0,     0,
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+-      30,    34,    54,     0,    55,     0,     0,     0,     0,     0,
+-       0,     0,     0,     0,     0,    73,    89,    41,     0,     0,
+-      45,    64,    63,    81,    79,    61,    51,    52,   110,   111,
+-     109,    70,    71,    69,    68,    66,    67,    65,   114,   113,
+-     104,   105,   106,   107,   108,    37,    36,    38,    39,    35,
+-      32,     0,   101,    56,     0,    92,    93,    94,    95,    96,
+-      97,    42,    43,     0,     0,     0,     0,    59,    46,    84,
+-      85,     0,    82,     0,     0,     0,    75,     0,    80,     0,
+-       0,     0,    77,    57,     0,    83,    76,    74,     0,     0,
+-       0,    78,     0,    60,     0,    58
+-};
+-
+-/* YYDEFGOTO[NTERM-NUM].  */
+-static const yytype_int16 yydefgoto[] =
+-{
+-      -1,     1,     5,     6,    23,    26,    32,     7,    14,    17,
+-      19,    28,    29,    36,    37,    77,   120,   169,    69,   139,
+-      70,    92,    72,   186,   209,   197,   195,   124,   201,   145,
+-     184,   191,   192,    73,    74
++      30,    34,    54,     0,    55,     0,     0,    56,     0,     0,
++       0,     0,     0,     0,     0,     0,    74,    90,    41,     0,
++       0,    45,    65,    64,    82,    80,    62,    51,    52,   111,
++     112,   110,    66,    68,    67,    69,    70,    72,    71,   114,
++     115,   105,   106,   107,   108,   109,    37,    36,    38,    39,
++      35,    32,     0,   102,    57,     0,    93,    94,    95,    96,
++      97,    98,    42,    43,     0,     0,     0,     0,    60,    46,
++      85,    86,     0,    83,     0,     0,     0,    76,     0,    81,
++       0,     0,     0,    78,    58,     0,    84,    77,    75,     0,
++       0,     0,    79,     0,    61,     0,    59
+ };
+ 
+-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+-   STATE-NUM.  */
+-#define YYPACT_NINF -66
+-static const yytype_int16 yypact[] =
++  /* YYPGOTO[NTERM-NUM].  */
++static const yytype_int16 yypgoto[] =
+ {
+-     -66,     6,   -66,   -59,     0,   -66,   -66,    59,   -66,   -66,
+-     -66,     9,   -66,   -66,   -66,   -44,    16,   -24,   -66,    49,
+-      81,   -66,    26,    88,    92,    43,   115,    54,    92,   -66,
+-     116,    63,    66,    -2,   -66,    75,   116,   -66,    79,   -66,
+-     -66,   -66,   -66,   -66,    82,   -66,   -66,    -8,   -66,    83,
+-     -66,   -66,   -66,   -66,   -66,   -66,   -66,   113,    72,    80,
+-      84,    94,    96,    97,   -66,   -66,    79,   168,    79,   -42,
+-     -66,    57,   -66,   125,   205,   -66,   -66,   137,   168,    98,
+-     168,   168,    -7,   372,   168,   168,   168,   168,   168,   168,
+-     -66,   -66,    57,   100,   169,   161,   168,    79,    79,    79,
+-     -29,   156,   168,   168,   168,   168,   168,   168,   168,   168,
+-     168,   168,   168,   168,   168,   168,   168,   168,   168,   168,
+-      36,   -66,   372,   168,   -66,   338,   222,   149,   -29,   229,
+-     251,   258,   280,   287,   309,   -66,   -66,   -66,   345,    34,
+-      74,   135,   -66,   -66,   -66,   -66,   -66,   372,   104,   104,
+-     104,   372,   372,   372,   372,   372,   372,   372,   -23,   -23,
+-      25,    25,   -66,   -66,   -66,   -66,   -66,   -66,   -66,   -66,
+-      36,   365,   -66,   -66,   120,   -66,   -66,   -66,   -66,   -66,
+-     -66,   -66,   -66,    79,    -5,   119,   110,   -66,    74,   -66,
+-     -66,    60,   -66,   168,   168,   122,   -66,   118,   -66,    -5,
+-     316,    62,   365,   -66,    79,   -66,   -66,   -66,   168,   123,
+-     -26,   372,    79,   -66,   -19,   -66
++     -66,   -66,   -66,   187,   -66,   -66,   -66,   -66,   -66,   -66,
++     -66,   -66,   163,   -66,   159,   -66,    78,   -66,   -66,   -66,
++      96,   -38,   -65,   -66,   -66,   -66,   -66,    19,   -66,   104,
++     -66,   -66,    11,   153,   -37
+ };
+ 
+-/* YYPGOTO[NTERM-NUM].  */
+-static const yytype_int16 yypgoto[] =
++  /* YYDEFGOTO[NTERM-NUM].  */
++static const yytype_int16 yydefgoto[] =
+ {
+-     -66,   -66,   -66,   187,   -66,   -66,   -66,   -66,   -66,   -66,
+-     -66,   -66,   165,   -66,   159,   -66,    77,   -66,   -66,   -66,
+-      95,   -38,   -65,   -66,   -66,   -66,   -66,    19,   -66,   103,
+-     -66,   -66,    10,   151,   -37
++      -1,     1,     5,     6,    23,    26,    32,     7,    14,    17,
++      19,    28,    29,    36,    37,    77,   120,   170,    69,   140,
++      70,    92,    72,   187,   210,   198,   196,   124,   202,   146,
++     185,   192,   193,    73,    74
+ };
+ 
+-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+-   positive, shift that token.  If negative, reduce the rule which
+-   number is the opposite.  If zero, do what YYDEFACT says.
+-   If YYTABLE_NINF, syntax error.  */
+-#define YYTABLE_NINF -87
++  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
++     positive, shift that token.  If negative, reduce the rule whose
++     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+ static const yytype_int16 yytable[] =
+ {
+-      71,   143,   127,    93,     8,   189,     2,     3,   190,   -14,
+-     -14,   -14,    40,    41,    78,    10,    98,    99,    15,    79,
+-      83,   128,    16,    98,    99,    18,    95,    96,    90,    97,
+-      91,    94,   140,   115,   116,   117,   118,   119,    42,    43,
+-      20,   122,   144,   125,   126,     4,   213,   129,   130,   131,
+-     132,   133,   134,   215,   165,   166,   167,   168,    21,   138,
+-     141,   142,    11,    12,    13,   147,   148,   149,   150,   151,
+-     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+-     162,   163,   164,   117,   118,   119,   171,    22,    46,    47,
+-      48,    49,    24,    50,    51,    25,    52,    75,    76,    98,
+-      99,    27,    53,    54,    55,    56,   182,   183,    57,    30,
+-      58,    59,    60,    61,    62,    63,   -48,   -48,   188,    64,
+-      65,    33,    46,    31,    48,    49,    35,    50,    51,    38,
+-      52,    39,   198,   199,   207,   208,    53,    54,    55,    56,
+-      66,    67,    44,    84,    58,    59,    60,    61,    62,    63,
+-      68,    85,    80,   100,   121,    86,   200,   202,   113,   114,
+-     115,   116,   117,   118,   119,    87,   210,    88,    89,   123,
+-     137,   211,   135,    52,   214,    67,   173,    46,    99,    48,
+-      49,   194,    50,    51,    81,    52,   187,   193,   203,   204,
+-       9,    53,    54,    34,   212,    45,   146,   -86,   170,    58,
+-      59,    60,    61,    62,    63,   196,   101,   102,    82,   205,
+-       0,     0,     0,   103,   104,   105,   106,   107,   108,   109,
+-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+-      67,   174,     0,   -86,     0,     0,     0,     0,     0,    81,
+-       0,   136,   101,   102,     0,     0,     0,     0,     0,   103,
+-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+-     114,   115,   116,   117,   118,   119,   103,   104,   105,     0,
+-       0,     0,     0,   103,   104,   105,   113,   114,   115,   116,
++      71,   144,     8,    93,    10,   190,     2,     3,   191,   -14,
++     -14,   -14,    40,    41,    78,    16,    98,    99,    15,    79,
++      83,    98,    99,    98,    99,    75,    76,   127,    90,    18,
++      91,    94,   141,    95,    96,   128,    97,    20,    42,    43,
++      21,   122,   145,   125,   126,     4,   214,   130,   131,   132,
++     133,   134,   135,   216,   129,   166,   167,   168,   169,   139,
++     142,   143,    11,    12,    13,   148,   149,   150,   151,   152,
++     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
++     163,   164,   165,   117,   118,   119,   172,   183,   184,    46,
++      47,    48,    49,    22,    50,    51,    24,    52,   115,   116,
++     117,   118,   119,    53,    54,    55,    56,   -48,   -48,    57,
++      25,    58,    59,    60,    61,    62,    63,   199,   200,   189,
++      64,    65,    27,    46,    30,    48,    49,    31,    50,    51,
++      33,    52,   208,   209,    35,    38,    39,    53,    54,    55,
++      56,    66,    67,    44,    80,    58,    59,    60,    61,    62,
++      63,    68,    84,    85,    86,    87,    88,   201,   203,   113,
++     114,   115,   116,   117,   118,   119,    89,   211,   100,   121,
++     123,   138,   212,   136,    52,   215,    67,   174,    46,    99,
++      48,    49,   188,    50,    51,    81,    52,   204,   194,   195,
++       9,    34,    53,    54,   205,    45,   213,   147,   -87,   171,
++      58,    59,    60,    61,    62,    63,   197,   101,   102,     0,
++      82,   206,     0,     0,   103,   104,   105,   106,   107,   108,
++     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
++     119,    67,     0,   175,   -87,     0,     0,     0,     0,     0,
++      81,     0,   137,   101,   102,     0,     0,     0,     0,     0,
++     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
++     113,   114,   115,   116,   117,   118,   119,   103,   104,   105,
++       0,     0,     0,     0,   103,   104,   105,   113,   114,   115,
++     116,   117,   118,   119,   113,   114,   115,   116,   117,   118,
++     119,     0,     0,     0,     0,   137,   103,   104,   105,     0,
++       0,     0,   176,   103,   104,   105,   113,   114,   115,   116,
+      117,   118,   119,   113,   114,   115,   116,   117,   118,   119,
+-       0,     0,     0,     0,   136,   103,   104,   105,     0,     0,
+-       0,   175,   103,   104,   105,   113,   114,   115,   116,   117,
++       0,     0,     0,     0,   177,   103,   104,   105,     0,     0,
++       0,   178,   103,   104,   105,   113,   114,   115,   116,   117,
+      118,   119,   113,   114,   115,   116,   117,   118,   119,     0,
+-       0,     0,     0,   176,   103,   104,   105,     0,     0,     0,
+-     177,   103,   104,   105,   113,   114,   115,   116,   117,   118,
++       0,     0,     0,   179,   103,   104,   105,     0,     0,     0,
++     180,   103,   104,   105,   113,   114,   115,   116,   117,   118,
+      119,   113,   114,   115,   116,   117,   118,   119,     0,     0,
+-       0,     0,   178,   103,   104,   105,     0,     0,     0,   179,
++       0,     0,   181,   103,   104,   105,     0,     0,     0,   207,
+      103,   104,   105,   113,   114,   115,   116,   117,   118,   119,
+-     113,   114,   115,   116,   117,   118,   119,     0,     0,     0,
+-       0,   180,   103,   104,   105,     0,     0,     0,   206,   103,
+-     104,   105,   113,   114,   115,   116,   117,   118,   119,   113,
+-     114,   115,   116,   117,   118,   119,     0,     0,   172,   103,
+-     104,   105,     0,     0,     0,   181,   103,   104,   105,   113,
+-     114,   115,   116,   117,   118,   119,   113,   114,   115,   116,
+-     117,   118,   119,   185
++     113,   114,   115,   116,   117,   118,   119,     0,     0,   173,
++     103,   104,   105,     0,     0,     0,   182,   103,   104,   105,
++     113,   114,   115,   116,   117,   118,   119,   113,   114,   115,
++     116,   117,   118,   119,   186
+ };
+ 
+ static const yytype_int16 yycheck[] =
+ {
+-      38,    30,     9,    68,    63,    10,     0,     1,    13,     3,
+-       4,     5,    14,    15,    22,    15,    42,    43,     9,    27,
+-      57,    28,    66,    42,    43,     9,    68,    69,    66,    71,
+-      67,    68,    97,    56,    57,    58,    59,    60,    40,    41,
+-      64,    78,    71,    80,    81,    39,    72,    84,    85,    86,
+-      87,    88,    89,    72,    18,    19,    20,    21,     9,    96,
++      38,    30,    63,    68,    15,    10,     0,     1,    13,     3,
++       4,     5,    14,    15,    22,    66,    42,    43,     9,    27,
++      57,    42,    43,    42,    43,    15,    16,     1,    66,     9,
++      67,    68,    97,    68,    69,     9,    71,    64,    40,    41,
++       9,    78,    71,    80,    81,    39,    72,    84,    85,    86,
++      87,    88,    89,    72,    28,    18,    19,    20,    21,    96,
+       98,    99,     3,     4,     5,   102,   103,   104,   105,   106,
+      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+-     117,   118,   119,    58,    59,    60,   123,     6,     9,    10,
+-      11,    12,    66,    14,    15,     7,    17,    15,    16,    42,
+-      43,     9,    23,    24,    25,    26,    72,    73,    29,    66,
+-      31,    32,    33,    34,    35,    36,    42,    43,   183,    40,
+-      41,    67,     9,     8,    11,    12,    10,    14,    15,    66,
+-      17,    65,    72,    73,    72,    73,    23,    24,    25,    26,
+-      61,    62,    67,    71,    31,    32,    33,    34,    35,    36,
+-      71,    71,    69,    28,    17,    71,   193,   194,    54,    55,
+-      56,    57,    58,    59,    60,    71,   204,    71,    71,    71,
+-       9,   208,    72,    17,   212,    62,    27,     9,    43,    11,
+-      12,    71,    14,    15,    71,    17,    66,    68,    66,    71,
+-       3,    23,    24,    28,    71,    36,   101,    28,   121,    31,
+-      32,    33,    34,    35,    36,   186,    37,    38,    57,   199,
+-      -1,    -1,    -1,    44,    45,    46,    47,    48,    49,    50,
+-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
+-      62,   128,    -1,    28,    -1,    -1,    -1,    -1,    -1,    71,
+-      -1,    72,    37,    38,    -1,    -1,    -1,    -1,    -1,    44,
+-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+-      55,    56,    57,    58,    59,    60,    44,    45,    46,    -1,
+-      -1,    -1,    -1,    44,    45,    46,    54,    55,    56,    57,
++     117,   118,   119,    58,    59,    60,   123,    72,    73,     9,
++      10,    11,    12,     6,    14,    15,    66,    17,    56,    57,
++      58,    59,    60,    23,    24,    25,    26,    42,    43,    29,
++       7,    31,    32,    33,    34,    35,    36,    72,    73,   184,
++      40,    41,     9,     9,    66,    11,    12,     8,    14,    15,
++      67,    17,    72,    73,    10,    66,    65,    23,    24,    25,
++      26,    61,    62,    67,    69,    31,    32,    33,    34,    35,
++      36,    71,    71,    71,    71,    71,    71,   194,   195,    54,
++      55,    56,    57,    58,    59,    60,    71,   205,    28,    17,
++      71,     9,   209,    72,    17,   213,    62,    27,     9,    43,
++      11,    12,    66,    14,    15,    71,    17,    66,    68,    71,
++       3,    28,    23,    24,    71,    36,    71,   101,    28,   121,
++      31,    32,    33,    34,    35,    36,   187,    37,    38,    -1,
++      57,   200,    -1,    -1,    44,    45,    46,    47,    48,    49,
++      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
++      60,    62,    -1,   129,    28,    -1,    -1,    -1,    -1,    -1,
++      71,    -1,    72,    37,    38,    -1,    -1,    -1,    -1,    -1,
++      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
++      54,    55,    56,    57,    58,    59,    60,    44,    45,    46,
++      -1,    -1,    -1,    -1,    44,    45,    46,    54,    55,    56,
++      57,    58,    59,    60,    54,    55,    56,    57,    58,    59,
++      60,    -1,    -1,    -1,    -1,    72,    44,    45,    46,    -1,
++      -1,    -1,    72,    44,    45,    46,    54,    55,    56,    57,
+       58,    59,    60,    54,    55,    56,    57,    58,    59,    60,
+       -1,    -1,    -1,    -1,    72,    44,    45,    46,    -1,    -1,
+       -1,    72,    44,    45,    46,    54,    55,    56,    57,    58,
+@@ -892,17 +845,14 @@ static const yytype_int16 yycheck[] =
+       60,    54,    55,    56,    57,    58,    59,    60,    -1,    -1,
+       -1,    -1,    72,    44,    45,    46,    -1,    -1,    -1,    72,
+       44,    45,    46,    54,    55,    56,    57,    58,    59,    60,
+-      54,    55,    56,    57,    58,    59,    60,    -1,    -1,    -1,
+-      -1,    72,    44,    45,    46,    -1,    -1,    -1,    72,    44,
+-      45,    46,    54,    55,    56,    57,    58,    59,    60,    54,
+-      55,    56,    57,    58,    59,    60,    -1,    -1,    70,    44,
+-      45,    46,    -1,    -1,    -1,    70,    44,    45,    46,    54,
+-      55,    56,    57,    58,    59,    60,    54,    55,    56,    57,
+-      58,    59,    60,    68
++      54,    55,    56,    57,    58,    59,    60,    -1,    -1,    70,
++      44,    45,    46,    -1,    -1,    -1,    70,    44,    45,    46,
++      54,    55,    56,    57,    58,    59,    60,    54,    55,    56,
++      57,    58,    59,    60,    68
+ };
+ 
+-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+-   symbol of state STATE-NUM.  */
++  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
++     symbol of state STATE-NUM.  */
+ static const yytype_uint8 yystos[] =
+ {
+        0,    75,     0,     1,    39,    76,    77,    81,    63,    77,
+@@ -917,107 +867,87 @@ static const yytype_uint8 yystos[] =
+       95,   108,    95,    96,   108,    68,    69,    71,    42,    43,
+       28,    37,    38,    44,    45,    46,    47,    48,    49,    50,
+       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
+-      90,    17,   108,    71,   101,   108,   108,     9,    28,   108,
+-     108,   108,   108,   108,   108,    72,    72,     9,   108,    93,
+-      96,    95,    95,    30,    71,   103,    94,   108,   108,   108,
++      90,    17,   108,    71,   101,   108,   108,     1,     9,    28,
++     108,   108,   108,   108,   108,   108,    72,    72,     9,   108,
++      93,    96,    95,    95,    30,    71,   103,    94,   108,   108,
+      108,   108,   108,   108,   108,   108,   108,   108,   108,   108,
+-     108,   108,   108,   108,   108,    18,    19,    20,    21,    91,
+-      90,   108,    70,    27,   103,    72,    72,    72,    72,    72,
+-      72,    70,    72,    73,   104,    68,    97,    66,    96,    10,
+-      13,   105,   106,    68,    71,   100,   101,    99,    72,    73,
+-     108,   102,   108,    66,    71,   106,    72,    72,    73,    98,
+-      95,   108,    71,    72,    95,    72
++     108,   108,   108,   108,   108,   108,    18,    19,    20,    21,
++      91,    90,   108,    70,    27,   103,    72,    72,    72,    72,
++      72,    72,    70,    72,    73,   104,    68,    97,    66,    96,
++      10,    13,   105,   106,    68,    71,   100,   101,    99,    72,
++      73,   108,   102,   108,    66,    71,   106,    72,    72,    73,
++      98,    95,   108,    71,    72,    95,    72
+ };
+ 
+-#define yyerrok		(yyerrstatus = 0)
+-#define yyclearin	(yychar = YYEMPTY)
+-#define YYEMPTY		(-2)
+-#define YYEOF		0
++  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
++static const yytype_uint8 yyr1[] =
++{
++       0,    74,    75,    75,    75,    75,    75,    76,    77,    78,
++      78,    79,    79,    80,    81,    81,    82,    82,    83,    83,
++      84,    84,    85,    85,    86,    86,    86,    86,    87,    87,
++      88,    89,    88,    88,    90,    90,    91,    91,    91,    91,
++      92,    92,    92,    92,    93,    93,    93,    94,    95,    96,
++      96,    96,    96,    96,    96,    96,    96,    97,    98,    96,
++      99,    96,    96,    96,    96,    96,    96,    96,    96,    96,
++      96,    96,    96,    96,    96,   100,   100,   101,   102,   102,
++     104,   103,   103,   105,   105,   106,   106,   107,   107,   107,
++     108,   108,   108,   108,   108,   108,   108,   108,   108,   108,
++     108,   108,   108,   108,   108,   108,   108,   108,   108,   108,
++     108,   108,   108,   108,   108,   108,   108
++};
++
++  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
++static const yytype_uint8 yyr2[] =
++{
++       0,     2,     0,     2,     2,     3,     3,     2,     9,     0,
++       3,     0,     3,     3,     0,     2,     1,     1,     0,     2,
++       1,     2,     1,     2,     3,     3,     3,     3,     1,     2,
++       4,     0,     5,     3,     0,     2,     1,     1,     1,     1,
++       1,     3,     4,     4,     0,     1,     3,     1,     1,     1,
++       1,     3,     3,     1,     3,     3,     3,     0,     0,    11,
++       0,     9,     3,     2,     3,     3,     3,     3,     3,     3,
++       3,     3,     3,     1,     3,     3,     1,     6,     1,     3,
++       0,     4,     1,     1,     3,     1,     1,     1,     1,     1,
++       3,     1,     1,     4,     4,     4,     4,     4,     4,     1,
++       1,     1,     4,     1,     1,     3,     3,     3,     3,     3,
++       3,     3,     3,     2,     3,     3,     1
++};
+ 
+-#define YYACCEPT	goto yyacceptlab
+-#define YYABORT		goto yyabortlab
+-#define YYERROR		goto yyerrorlab
+ 
++#define yyerrok         (yyerrstatus = 0)
++#define yyclearin       (yychar = YYEMPTY)
++#define YYEMPTY         (-2)
++#define YYEOF           0
+ 
+-/* Like YYERROR except do call yyerror.  This remains here temporarily
+-   to ease the transition to the new meaning of YYERROR, for GCC.
+-   Once GCC version 2 has supplanted version 1, this can go.  */
++#define YYACCEPT        goto yyacceptlab
++#define YYABORT         goto yyabortlab
++#define YYERROR         goto yyerrorlab
+ 
+-#define YYFAIL		goto yyerrlab
+ 
+ #define YYRECOVERING()  (!!yyerrstatus)
+ 
+-#define YYBACKUP(Token, Value)					\
+-do								\
+-  if (yychar == YYEMPTY && yylen == 1)				\
+-    {								\
+-      yychar = (Token);						\
+-      yylval = (Value);						\
+-      yytoken = YYTRANSLATE (yychar);				\
+-      YYPOPSTACK (1);						\
+-      goto yybackup;						\
+-    }								\
+-  else								\
+-    {								\
++#define YYBACKUP(Token, Value)                                  \
++do                                                              \
++  if (yychar == YYEMPTY)                                        \
++    {                                                           \
++      yychar = (Token);                                         \
++      yylval = (Value);                                         \
++      YYPOPSTACK (yylen);                                       \
++      yystate = *yyssp;                                         \
++      goto yybackup;                                            \
++    }                                                           \
++  else                                                          \
++    {                                                           \
+       yyerror (yyscanner, compiler, YY_("syntax error: cannot back up")); \
+-      YYERROR;							\
+-    }								\
+-while (YYID (0))
+-
+-
+-#define YYTERROR	1
+-#define YYERRCODE	256
+-
+-
+-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+-   If N is 0, then set CURRENT to the empty location which ends
+-   the previous symbol: RHS[0] (always defined).  */
+-
+-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+-#ifndef YYLLOC_DEFAULT
+-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+-    do									\
+-      if (YYID (N))                                                    \
+-	{								\
+-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+-	}								\
+-      else								\
+-	{								\
+-	  (Current).first_line   = (Current).last_line   =		\
+-	    YYRHSLOC (Rhs, 0).last_line;				\
+-	  (Current).first_column = (Current).last_column =		\
+-	    YYRHSLOC (Rhs, 0).last_column;				\
+-	}								\
+-    while (YYID (0))
+-#endif
++      YYERROR;                                                  \
++    }                                                           \
++while (0)
+ 
++/* Error token number */
++#define YYTERROR        1
++#define YYERRCODE       256
+ 
+-/* YY_LOCATION_PRINT -- Print the location on the stream.
+-   This macro was not mandated originally: define only if we know
+-   we won't break user code: when these are the locations we know.  */
+ 
+-#ifndef YY_LOCATION_PRINT
+-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+-#  define YY_LOCATION_PRINT(File, Loc)			\
+-     fprintf (File, "%d.%d-%d.%d",			\
+-	      (Loc).first_line, (Loc).first_column,	\
+-	      (Loc).last_line,  (Loc).last_column)
+-# else
+-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+-# endif
+-#endif
+-
+-
+-/* YYLEX -- calling `yylex' with the right arguments.  */
+-
+-#ifdef YYLEX_PARAM
+-# define YYLEX yylex (&yylval, YYLEX_PARAM)
+-#else
+-# define YYLEX yylex (&yylval, yyscanner, compiler)
+-#endif
+ 
+ /* Enable debugging if requested.  */
+ #if YYDEBUG
+@@ -1027,58 +957,48 @@ while (YYID (0))
+ #  define YYFPRINTF fprintf
+ # endif
+ 
+-# define YYDPRINTF(Args)			\
+-do {						\
+-  if (yydebug)					\
+-    YYFPRINTF Args;				\
+-} while (YYID (0))
++# define YYDPRINTF(Args)                        \
++do {                                            \
++  if (yydebug)                                  \
++    YYFPRINTF Args;                             \
++} while (0)
+ 
+-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+-do {									  \
+-  if (yydebug)								  \
+-    {									  \
+-      YYFPRINTF (stderr, "%s ", Title);					  \
+-      yy_symbol_print (stderr,						  \
+-		  Type, Value, yyscanner, compiler); \
+-      YYFPRINTF (stderr, "\n");						  \
+-    }									  \
+-} while (YYID (0))
++/* This macro is provided for backward compatibility. */
++#ifndef YY_LOCATION_PRINT
++# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
++#endif
+ 
+ 
+-/*--------------------------------.
+-| Print this symbol on YYOUTPUT.  |
+-`--------------------------------*/
++# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
++do {                                                                      \
++  if (yydebug)                                                            \
++    {                                                                     \
++      YYFPRINTF (stderr, "%s ", Title);                                   \
++      yy_symbol_print (stderr,                                            \
++                  Type, Value, yyscanner, compiler); \
++      YYFPRINTF (stderr, "\n");                                           \
++    }                                                                     \
++} while (0)
++
++
++/*----------------------------------------.
++| Print this symbol's value on YYOUTPUT.  |
++`----------------------------------------*/
+ 
+-/*ARGSUSED*/
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void *yyscanner, YR_COMPILER* compiler)
+-#else
+-static void
+-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner, compiler)
+-    FILE *yyoutput;
+-    int yytype;
+-    YYSTYPE const * const yyvaluep;
+-    void *yyscanner;
+-    YR_COMPILER* compiler;
+-#endif
+ {
+-  if (!yyvaluep)
+-    return;
++  FILE *yyo = yyoutput;
++  YYUSE (yyo);
+   YYUSE (yyscanner);
+   YYUSE (compiler);
++  if (!yyvaluep)
++    return;
+ # ifdef YYPRINT
+   if (yytype < YYNTOKENS)
+     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+-# else
+-  YYUSE (yyoutput);
+ # endif
+-  switch (yytype)
+-    {
+-      default:
+-	break;
+-    }
++  YYUSE (yytype);
+ }
+ 
+ 
+@@ -1086,24 +1006,11 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner, compiler)
+ | Print this symbol on YYOUTPUT.  |
+ `--------------------------------*/
+ 
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void *yyscanner, YR_COMPILER* compiler)
+-#else
+-static void
+-yy_symbol_print (yyoutput, yytype, yyvaluep, yyscanner, compiler)
+-    FILE *yyoutput;
+-    int yytype;
+-    YYSTYPE const * const yyvaluep;
+-    void *yyscanner;
+-    YR_COMPILER* compiler;
+-#endif
+ {
+-  if (yytype < YYNTOKENS)
+-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+-  else
+-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
++  YYFPRINTF (yyoutput, "%s %s (",
++             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+ 
+   yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner, compiler);
+   YYFPRINTF (yyoutput, ")");
+@@ -1114,68 +1021,54 @@ yy_symbol_print (yyoutput, yytype, yyvaluep, yyscanner, compiler)
+ | TOP (included).                                                   |
+ `------------------------------------------------------------------*/
+ 
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-static void
+-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+-#else
+ static void
+-yy_stack_print (bottom, top)
+-    yytype_int16 *bottom;
+-    yytype_int16 *top;
+-#endif
++yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+ {
+   YYFPRINTF (stderr, "Stack now");
+-  for (; bottom <= top; ++bottom)
+-    YYFPRINTF (stderr, " %d", *bottom);
++  for (; yybottom <= yytop; yybottom++)
++    {
++      int yybot = *yybottom;
++      YYFPRINTF (stderr, " %d", yybot);
++    }
+   YYFPRINTF (stderr, "\n");
+ }
+ 
+-# define YY_STACK_PRINT(Bottom, Top)				\
+-do {								\
+-  if (yydebug)							\
+-    yy_stack_print ((Bottom), (Top));				\
+-} while (YYID (0))
++# define YY_STACK_PRINT(Bottom, Top)                            \
++do {                                                            \
++  if (yydebug)                                                  \
++    yy_stack_print ((Bottom), (Top));                           \
++} while (0)
+ 
+ 
+ /*------------------------------------------------.
+ | Report that the YYRULE is going to be reduced.  |
+ `------------------------------------------------*/
+ 
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+-yy_reduce_print (YYSTYPE *yyvsp, int yyrule, void *yyscanner, YR_COMPILER* compiler)
+-#else
+-static void
+-yy_reduce_print (yyvsp, yyrule, yyscanner, compiler)
+-    YYSTYPE *yyvsp;
+-    int yyrule;
+-    void *yyscanner;
+-    YR_COMPILER* compiler;
+-#endif
++yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, void *yyscanner, YR_COMPILER* compiler)
+ {
++  unsigned long int yylno = yyrline[yyrule];
+   int yynrhs = yyr2[yyrule];
+   int yyi;
+-  unsigned long int yylno = yyrline[yyrule];
+   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+-	     yyrule - 1, yylno);
++             yyrule - 1, yylno);
+   /* The symbols being reduced.  */
+   for (yyi = 0; yyi < yynrhs; yyi++)
+     {
+-      fprintf (stderr, "   $%d = ", yyi + 1);
+-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+-		       &(yyvsp[(yyi + 1) - (yynrhs)])
+-		       		       , yyscanner, compiler);
+-      fprintf (stderr, "\n");
++      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
++      yy_symbol_print (stderr,
++                       yystos[yyssp[yyi + 1 - yynrhs]],
++                       &(yyvsp[(yyi + 1) - (yynrhs)])
++                                              , yyscanner, compiler);
++      YYFPRINTF (stderr, "\n");
+     }
+ }
+ 
+-# define YY_REDUCE_PRINT(Rule)		\
+-do {					\
+-  if (yydebug)				\
+-    yy_reduce_print (yyvsp, Rule, yyscanner, compiler); \
+-} while (YYID (0))
++# define YY_REDUCE_PRINT(Rule)          \
++do {                                    \
++  if (yydebug)                          \
++    yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, compiler); \
++} while (0)
+ 
+ /* Nonzero means print parse trace.  It is left uninitialized so that
+    multiple parsers can coexist.  */
+@@ -1189,7 +1082,7 @@ int yydebug;
+ 
+ 
+ /* YYINITDEPTH -- initial size of the parser's stacks.  */
+-#ifndef	YYINITDEPTH
++#ifndef YYINITDEPTH
+ # define YYINITDEPTH 200
+ #endif
+ 
+@@ -1204,7 +1097,6 @@ int yydebug;
+ # define YYMAXDEPTH 10000
+ #endif
+ 
+-
+ 
+ #if YYERROR_VERBOSE
+ 
+@@ -1213,15 +1105,8 @@ int yydebug;
+ #   define yystrlen strlen
+ #  else
+ /* Return the length of YYSTR.  */
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static YYSIZE_T
+ yystrlen (const char *yystr)
+-#else
+-static YYSIZE_T
+-yystrlen (yystr)
+-    const char *yystr;
+-#endif
+ {
+   YYSIZE_T yylen;
+   for (yylen = 0; yystr[yylen]; yylen++)
+@@ -1237,16 +1122,8 @@ yystrlen (yystr)
+ #  else
+ /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+    YYDEST.  */
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static char *
+ yystpcpy (char *yydest, const char *yysrc)
+-#else
+-static char *
+-yystpcpy (yydest, yysrc)
+-    char *yydest;
+-    const char *yysrc;
+-#endif
+ {
+   char *yyd = yydest;
+   const char *yys = yysrc;
+@@ -1276,27 +1153,27 @@ yytnamerr (char *yyres, const char *yystr)
+       char const *yyp = yystr;
+ 
+       for (;;)
+-	switch (*++yyp)
+-	  {
+-	  case '\'':
+-	  case ',':
+-	    goto do_not_strip_quotes;
+-
+-	  case '\\':
+-	    if (*++yyp != '\\')
+-	      goto do_not_strip_quotes;
+-	    /* Fall through.  */
+-	  default:
+-	    if (yyres)
+-	      yyres[yyn] = *yyp;
+-	    yyn++;
+-	    break;
+-
+-	  case '"':
+-	    if (yyres)
+-	      yyres[yyn] = '\0';
+-	    return yyn;
+-	  }
++        switch (*++yyp)
++          {
++          case '\'':
++          case ',':
++            goto do_not_strip_quotes;
++
++          case '\\':
++            if (*++yyp != '\\')
++              goto do_not_strip_quotes;
++            /* Fall through.  */
++          default:
++            if (yyres)
++              yyres[yyn] = *yyp;
++            yyn++;
++            break;
++
++          case '"':
++            if (yyres)
++              yyres[yyn] = '\0';
++            return yyn;
++          }
+     do_not_strip_quotes: ;
+     }
+ 
+@@ -1307,209 +1184,213 @@ yytnamerr (char *yyres, const char *yystr)
+ }
+ # endif
+ 
+-/* Copy into YYRESULT an error message about the unexpected token
+-   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+-   including the terminating null byte.  If YYRESULT is null, do not
+-   copy anything; just return the number of bytes that would be
+-   copied.  As a special case, return 0 if an ordinary "syntax error"
+-   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+-   size calculation.  */
+-static YYSIZE_T
+-yysyntax_error (char *yyresult, int yystate, int yychar)
++/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
++   about the unexpected token YYTOKEN for the state stack whose top is
++   YYSSP.
++
++   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
++   not large enough to hold the message.  In that case, also set
++   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
++   required number of bytes is too large to store.  */
++static int
++yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
++                yytype_int16 *yyssp, int yytoken)
+ {
+-  int yyn = yypact[yystate];
++  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
++  YYSIZE_T yysize = yysize0;
++  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
++  /* Internationalized format string. */
++  const char *yyformat = YY_NULLPTR;
++  /* Arguments of yyformat. */
++  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
++  /* Number of reported tokens (one for the "unexpected", one per
++     "expected"). */
++  int yycount = 0;
++
++  /* There are many possibilities here to consider:
++     - If this state is a consistent state with a default action, then
++       the only way this function was invoked is if the default action
++       is an error action.  In that case, don't check for expected
++       tokens because there are none.
++     - The only way there can be no lookahead present (in yychar) is if
++       this state is a consistent state with a default action.  Thus,
++       detecting the absence of a lookahead is sufficient to determine
++       that there is no unexpected or expected token to report.  In that
++       case, just report a simple "syntax error".
++     - Don't assume there isn't a lookahead just because this state is a
++       consistent state with a default action.  There might have been a
++       previous inconsistent state, consistent state with a non-default
++       action, or user semantic action that manipulated yychar.
++     - Of course, the expected token list depends on states to have
++       correct lookahead information, and it depends on the parser not
++       to perform extra reductions after fetching a lookahead from the
++       scanner and before detecting a syntax error.  Thus, state merging
++       (from LALR or IELR) and default reductions corrupt the expected
++       token list.  However, the list is correct for canonical LR with
++       one exception: it will still contain any token that will not be
++       accepted due to an error action in a later state.
++  */
++  if (yytoken != YYEMPTY)
++    {
++      int yyn = yypact[*yyssp];
++      yyarg[yycount++] = yytname[yytoken];
++      if (!yypact_value_is_default (yyn))
++        {
++          /* Start YYX at -YYN if negative to avoid negative indexes in
++             YYCHECK.  In other words, skip the first -YYN actions for
++             this state because they are default actions.  */
++          int yyxbegin = yyn < 0 ? -yyn : 0;
++          /* Stay within bounds of both yycheck and yytname.  */
++          int yychecklim = YYLAST - yyn + 1;
++          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
++          int yyx;
++
++          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
++            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
++                && !yytable_value_is_error (yytable[yyx + yyn]))
++              {
++                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
++                  {
++                    yycount = 1;
++                    yysize = yysize0;
++                    break;
++                  }
++                yyarg[yycount++] = yytname[yyx];
++                {
++                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
++                  if (! (yysize <= yysize1
++                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
++                    return 2;
++                  yysize = yysize1;
++                }
++              }
++        }
++    }
+ 
+-  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+-    return 0;
+-  else
++  switch (yycount)
++    {
++# define YYCASE_(N, S)                      \
++      case N:                               \
++        yyformat = S;                       \
++      break
++      YYCASE_(0, YY_("syntax error"));
++      YYCASE_(1, YY_("syntax error, unexpected %s"));
++      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
++      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
++      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
++      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
++# undef YYCASE_
++    }
++
++  {
++    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
++    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
++      return 2;
++    yysize = yysize1;
++  }
++
++  if (*yymsg_alloc < yysize)
+     {
+-      int yytype = YYTRANSLATE (yychar);
+-      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+-      YYSIZE_T yysize = yysize0;
+-      YYSIZE_T yysize1;
+-      int yysize_overflow = 0;
+-      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+-      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+-      int yyx;
+-
+-# if 0
+-      /* This is so xgettext sees the translatable formats that are
+-	 constructed on the fly.  */
+-      YY_("syntax error, unexpected %s");
+-      YY_("syntax error, unexpected %s, expecting %s");
+-      YY_("syntax error, unexpected %s, expecting %s or %s");
+-      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+-      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+-# endif
+-      char *yyfmt;
+-      char const *yyf;
+-      static char const yyunexpected[] = "syntax error, unexpected %s";
+-      static char const yyexpecting[] = ", expecting %s";
+-      static char const yyor[] = " or %s";
+-      char yyformat[sizeof yyunexpected
+-		    + sizeof yyexpecting - 1
+-		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+-		       * (sizeof yyor - 1))];
+-      char const *yyprefix = yyexpecting;
+-
+-      /* Start YYX at -YYN if negative to avoid negative indexes in
+-	 YYCHECK.  */
+-      int yyxbegin = yyn < 0 ? -yyn : 0;
+-
+-      /* Stay within bounds of both yycheck and yytname.  */
+-      int yychecklim = YYLAST - yyn + 1;
+-      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+-      int yycount = 1;
+-
+-      yyarg[0] = yytname[yytype];
+-      yyfmt = yystpcpy (yyformat, yyunexpected);
+-
+-      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+-	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+-	  {
+-	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+-	      {
+-		yycount = 1;
+-		yysize = yysize0;
+-		yyformat[sizeof yyunexpected - 1] = '\0';
+-		break;
+-	      }
+-	    yyarg[yycount++] = yytname[yyx];
+-	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+-	    yysize_overflow |= (yysize1 < yysize);
+-	    yysize = yysize1;
+-	    yyfmt = yystpcpy (yyfmt, yyprefix);
+-	    yyprefix = yyor;
+-	  }
+-
+-      yyf = YY_(yyformat);
+-      yysize1 = yysize + yystrlen (yyf);
+-      yysize_overflow |= (yysize1 < yysize);
+-      yysize = yysize1;
+-
+-      if (yysize_overflow)
+-	return YYSIZE_MAXIMUM;
+-
+-      if (yyresult)
+-	{
+-	  /* Avoid sprintf, as that infringes on the user's name space.
+-	     Don't have undefined behavior even if the translation
+-	     produced a string with the wrong number of "%s"s.  */
+-	  char *yyp = yyresult;
+-	  int yyi = 0;
+-	  while ((*yyp = *yyf) != '\0')
+-	    {
+-	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+-		{
+-		  yyp += yytnamerr (yyp, yyarg[yyi++]);
+-		  yyf += 2;
+-		}
+-	      else
+-		{
+-		  yyp++;
+-		  yyf++;
+-		}
+-	    }
+-	}
+-      return yysize;
++      *yymsg_alloc = 2 * yysize;
++      if (! (yysize <= *yymsg_alloc
++             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
++        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
++      return 1;
+     }
++
++  /* Avoid sprintf, as that infringes on the user's name space.
++     Don't have undefined behavior even if the translation
++     produced a string with the wrong number of "%s"s.  */
++  {
++    char *yyp = *yymsg;
++    int yyi = 0;
++    while ((*yyp = *yyformat) != '\0')
++      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
++        {
++          yyp += yytnamerr (yyp, yyarg[yyi++]);
++          yyformat += 2;
++        }
++      else
++        {
++          yyp++;
++          yyformat++;
++        }
++  }
++  return 0;
+ }
+ #endif /* YYERROR_VERBOSE */
+-
+ 
+ /*-----------------------------------------------.
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
+ 
+-/*ARGSUSED*/
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ static void
+ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void *yyscanner, YR_COMPILER* compiler)
+-#else
+-static void
+-yydestruct (yymsg, yytype, yyvaluep, yyscanner, compiler)
+-    const char *yymsg;
+-    int yytype;
+-    YYSTYPE *yyvaluep;
+-    void *yyscanner;
+-    YR_COMPILER* compiler;
+-#endif
+ {
+   YYUSE (yyvaluep);
+   YYUSE (yyscanner);
+   YYUSE (compiler);
+-
+   if (!yymsg)
+     yymsg = "Deleting";
+   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+ 
++  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+   switch (yytype)
+     {
+-      case 9: /* "_IDENTIFIER_" */
+-#line 176 "grammar.y"
+-	{ yr_free((yyvaluep->c_string)); };
+-#line 1453 "grammar.c"
+-	break;
+-      case 10: /* "_STRING_IDENTIFIER_" */
+-#line 177 "grammar.y"
+-	{ yr_free((yyvaluep->c_string)); };
+-#line 1458 "grammar.c"
+-	break;
+-      case 11: /* "_STRING_COUNT_" */
+-#line 178 "grammar.y"
+-	{ yr_free((yyvaluep->c_string)); };
+-#line 1463 "grammar.c"
+-	break;
+-      case 12: /* "_STRING_OFFSET_" */
+-#line 179 "grammar.y"
+-	{ yr_free((yyvaluep->c_string)); };
+-#line 1468 "grammar.c"
+-	break;
+-      case 13: /* "_STRING_IDENTIFIER_WITH_WILDCARD_" */
+-#line 180 "grammar.y"
+-	{ yr_free((yyvaluep->c_string)); };
+-#line 1473 "grammar.c"
+-	break;
+-      case 15: /* "_TEXT_STRING_" */
+-#line 181 "grammar.y"
+-	{ yr_free((yyvaluep->sized_string)); };
+-#line 1478 "grammar.c"
+-	break;
+-      case 16: /* "_HEX_STRING_" */
+-#line 182 "grammar.y"
+-	{ yr_free((yyvaluep->sized_string)); };
+-#line 1483 "grammar.c"
+-	break;
+-      case 17: /* "_REGEXP_" */
+-#line 183 "grammar.y"
+-	{ yr_free((yyvaluep->sized_string)); };
+-#line 1488 "grammar.c"
+-	break;
++          case 9: /* _IDENTIFIER_  */
++#line 176 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).c_string)); }
++#line 1344 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 10: /* _STRING_IDENTIFIER_  */
++#line 177 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).c_string)); }
++#line 1350 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 11: /* _STRING_COUNT_  */
++#line 178 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).c_string)); }
++#line 1356 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 12: /* _STRING_OFFSET_  */
++#line 179 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).c_string)); }
++#line 1362 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 13: /* _STRING_IDENTIFIER_WITH_WILDCARD_  */
++#line 180 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).c_string)); }
++#line 1368 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 15: /* _TEXT_STRING_  */
++#line 181 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).sized_string)); }
++#line 1374 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 16: /* _HEX_STRING_  */
++#line 182 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).sized_string)); }
++#line 1380 "grammar.c" /* yacc.c:1257  */
++        break;
++
++    case 17: /* _REGEXP_  */
++#line 183 "grammar.y" /* yacc.c:1257  */
++      { yr_free(((*yyvaluep).sized_string)); }
++#line 1386 "grammar.c" /* yacc.c:1257  */
++        break;
++
+ 
+       default:
+-	break;
++        break;
+     }
++  YY_IGNORE_MAYBE_UNINITIALIZED_END
+ }
+-
+-
+-/* Prevent warnings from -Wmissing-prototypes.  */
+-
+-#ifdef YYPARSE_PARAM
+-#if defined __STDC__ || defined __cplusplus
+-int yyparse (void *YYPARSE_PARAM);
+-#else
+-int yyparse ();
+-#endif
+-#else /* ! YYPARSE_PARAM */
+-#if defined __STDC__ || defined __cplusplus
+-int yyparse (void *yyscanner, YR_COMPILER* compiler);
+-#else
+-int yyparse ();
+-#endif
+-#endif /* ! YYPARSE_PARAM */
+-
+-
+ 
+ 
+ 
+@@ -1518,100 +1399,76 @@ int yyparse ();
+ | yyparse.  |
+ `----------*/
+ 
+-#ifdef YYPARSE_PARAM
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+-int
+-yyparse (void *YYPARSE_PARAM)
+-#else
+-int
+-yyparse (YYPARSE_PARAM)
+-    void *YYPARSE_PARAM;
+-#endif
+-#else /* ! YYPARSE_PARAM */
+-#if (defined __STDC__ || defined __C99__FUNC__ \
+-     || defined __cplusplus || defined _MSC_VER)
+ int
+ yyparse (void *yyscanner, YR_COMPILER* compiler)
+-#else
+-int
+-yyparse (yyscanner, compiler)
+-    void *yyscanner;
+-    YR_COMPILER* compiler;
+-#endif
+-#endif
+ {
+-  /* The look-ahead symbol.  */
++/* The lookahead symbol.  */
+ int yychar;
+ 
+-/* The semantic value of the look-ahead symbol.  */
+-YYSTYPE yylval;
+-
+-/* Number of syntax errors so far.  */
+-int yynerrs;
+-
+-  int yystate;
+-  int yyn;
+-  int yyresult;
+-  /* Number of tokens to shift before error messages enabled.  */
+-  int yyerrstatus;
+-  /* Look-ahead token as an internal (translated) token number.  */
+-  int yytoken = 0;
+-#if YYERROR_VERBOSE
+-  /* Buffer for error messages, and its allocated size.  */
+-  char yymsgbuf[128];
+-  char *yymsg = yymsgbuf;
+-  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+-#endif
+ 
+-  /* Three stacks and their tools:
+-     `yyss': related to states,
+-     `yyvs': related to semantic values,
+-     `yyls': related to locations.
++/* The semantic value of the lookahead symbol.  */
++/* Default value used for initialization, for pacifying older GCCs
++   or non-GCC compilers.  */
++YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
++YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+ 
+-     Refer to the stacks thru separate pointers, to allow yyoverflow
+-     to reallocate them elsewhere.  */
++    /* Number of syntax errors so far.  */
++    int yynerrs;
+ 
+-  /* The state stack.  */
+-  yytype_int16 yyssa[YYINITDEPTH];
+-  yytype_int16 *yyss = yyssa;
+-  yytype_int16 *yyssp;
++    int yystate;
++    /* Number of tokens to shift before error messages enabled.  */
++    int yyerrstatus;
+ 
+-  /* The semantic value stack.  */
+-  YYSTYPE yyvsa[YYINITDEPTH];
+-  YYSTYPE *yyvs = yyvsa;
+-  YYSTYPE *yyvsp;
++    /* The stacks and their tools:
++       'yyss': related to states.
++       'yyvs': related to semantic values.
+ 
++       Refer to the stacks through separate pointers, to allow yyoverflow
++       to reallocate them elsewhere.  */
+ 
++    /* The state stack.  */
++    yytype_int16 yyssa[YYINITDEPTH];
++    yytype_int16 *yyss;
++    yytype_int16 *yyssp;
+ 
+-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
++    /* The semantic value stack.  */
++    YYSTYPE yyvsa[YYINITDEPTH];
++    YYSTYPE *yyvs;
++    YYSTYPE *yyvsp;
+ 
+-  YYSIZE_T yystacksize = YYINITDEPTH;
++    YYSIZE_T yystacksize;
+ 
++  int yyn;
++  int yyresult;
++  /* Lookahead token as an internal (translated) token number.  */
++  int yytoken = 0;
+   /* The variables used to return semantic value and location from the
+      action routines.  */
+   YYSTYPE yyval;
+ 
++#if YYERROR_VERBOSE
++  /* Buffer for error messages, and its allocated size.  */
++  char yymsgbuf[128];
++  char *yymsg = yymsgbuf;
++  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
++#endif
++
++#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+ 
+   /* The number of symbols on the RHS of the reduced rule.
+      Keep to zero when no symbol should be popped.  */
+   int yylen = 0;
+ 
++  yyssp = yyss = yyssa;
++  yyvsp = yyvs = yyvsa;
++  yystacksize = YYINITDEPTH;
++
+   YYDPRINTF ((stderr, "Starting parse\n"));
+ 
+   yystate = 0;
+   yyerrstatus = 0;
+   yynerrs = 0;
+-  yychar = YYEMPTY;		/* Cause a token to be read.  */
+-
+-  /* Initialize stack pointers.
+-     Waste one element of value and location stack
+-     so that they stay on the same level as the state stack.
+-     The wasted elements are never initialized.  */
+-
+-  yyssp = yyss;
+-  yyvsp = yyvs;
+-
++  yychar = YYEMPTY; /* Cause a token to be read.  */
+   goto yysetstate;
+ 
+ /*------------------------------------------------------------.
+@@ -1632,25 +1489,23 @@ int yynerrs;
+ 
+ #ifdef yyoverflow
+       {
+-	/* Give user a chance to reallocate the stack.  Use copies of
+-	   these so that the &'s don't force the real ones into
+-	   memory.  */
+-	YYSTYPE *yyvs1 = yyvs;
+-	yytype_int16 *yyss1 = yyss;
+-
+-
+-	/* Each stack pointer address is followed by the size of the
+-	   data in use in that stack, in bytes.  This used to be a
+-	   conditional around just the two extra args, but that might
+-	   be undefined if yyoverflow is a macro.  */
+-	yyoverflow (YY_("memory exhausted"),
+-		    &yyss1, yysize * sizeof (*yyssp),
+-		    &yyvs1, yysize * sizeof (*yyvsp),
+-
+-		    &yystacksize);
+-
+-	yyss = yyss1;
+-	yyvs = yyvs1;
++        /* Give user a chance to reallocate the stack.  Use copies of
++           these so that the &'s don't force the real ones into
++           memory.  */
++        YYSTYPE *yyvs1 = yyvs;
++        yytype_int16 *yyss1 = yyss;
++
++        /* Each stack pointer address is followed by the size of the
++           data in use in that stack, in bytes.  This used to be a
++           conditional around just the two extra args, but that might
++           be undefined if yyoverflow is a macro.  */
++        yyoverflow (YY_("memory exhausted"),
++                    &yyss1, yysize * sizeof (*yyssp),
++                    &yyvs1, yysize * sizeof (*yyvsp),
++                    &yystacksize);
++
++        yyss = yyss1;
++        yyvs = yyvs1;
+       }
+ #else /* no yyoverflow */
+ # ifndef YYSTACK_RELOCATE
+@@ -1658,23 +1513,22 @@ int yynerrs;
+ # else
+       /* Extend the stack our own way.  */
+       if (YYMAXDEPTH <= yystacksize)
+-	goto yyexhaustedlab;
++        goto yyexhaustedlab;
+       yystacksize *= 2;
+       if (YYMAXDEPTH < yystacksize)
+-	yystacksize = YYMAXDEPTH;
++        yystacksize = YYMAXDEPTH;
+ 
+       {
+-	yytype_int16 *yyss1 = yyss;
+-	union yyalloc *yyptr =
+-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+-	if (! yyptr)
+-	  goto yyexhaustedlab;
+-	YYSTACK_RELOCATE (yyss);
+-	YYSTACK_RELOCATE (yyvs);
+-
++        yytype_int16 *yyss1 = yyss;
++        union yyalloc *yyptr =
++          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
++        if (! yyptr)
++          goto yyexhaustedlab;
++        YYSTACK_RELOCATE (yyss_alloc, yyss);
++        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+ #  undef YYSTACK_RELOCATE
+-	if (yyss1 != yyssa)
+-	  YYSTACK_FREE (yyss1);
++        if (yyss1 != yyssa)
++          YYSTACK_FREE (yyss1);
+       }
+ # endif
+ #endif /* no yyoverflow */
+@@ -1682,16 +1536,18 @@ int yynerrs;
+       yyssp = yyss + yysize - 1;
+       yyvsp = yyvs + yysize - 1;
+ 
+-
+       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+-		  (unsigned long int) yystacksize));
++                  (unsigned long int) yystacksize));
+ 
+       if (yyss + yystacksize - 1 <= yyssp)
+-	YYABORT;
++        YYABORT;
+     }
+ 
+   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ 
++  if (yystate == YYFINAL)
++    YYACCEPT;
++
+   goto yybackup;
+ 
+ /*-----------.
+@@ -1700,20 +1556,20 @@ int yynerrs;
+ yybackup:
+ 
+   /* Do appropriate processing given the current state.  Read a
+-     look-ahead token if we need one and don't already have one.  */
++     lookahead token if we need one and don't already have one.  */
+ 
+-  /* First try to decide what to do without reference to look-ahead token.  */
++  /* First try to decide what to do without reference to lookahead token.  */
+   yyn = yypact[yystate];
+-  if (yyn == YYPACT_NINF)
++  if (yypact_value_is_default (yyn))
+     goto yydefault;
+ 
+-  /* Not known => get a look-ahead token if don't already have one.  */
++  /* Not known => get a lookahead token if don't already have one.  */
+ 
+-  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
++  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+   if (yychar == YYEMPTY)
+     {
+       YYDPRINTF ((stderr, "Reading a token: "));
+-      yychar = YYLEX;
++      yychar = yylex (&yylval, yyscanner, compiler);
+     }
+ 
+   if (yychar <= YYEOF)
+@@ -1735,29 +1591,27 @@ yybackup:
+   yyn = yytable[yyn];
+   if (yyn <= 0)
+     {
+-      if (yyn == 0 || yyn == YYTABLE_NINF)
+-	goto yyerrlab;
++      if (yytable_value_is_error (yyn))
++        goto yyerrlab;
+       yyn = -yyn;
+       goto yyreduce;
+     }
+ 
+-  if (yyn == YYFINAL)
+-    YYACCEPT;
+-
+   /* Count tokens shifted since error; after three, turn off error
+      status.  */
+   if (yyerrstatus)
+     yyerrstatus--;
+ 
+-  /* Shift the look-ahead token.  */
++  /* Shift the lookahead token.  */
+   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+ 
+-  /* Discard the shifted token unless it is eof.  */
+-  if (yychar != YYEOF)
+-    yychar = YYEMPTY;
++  /* Discard the shifted token.  */
++  yychar = YYEMPTY;
+ 
+   yystate = yyn;
++  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+   *++yyvsp = yylval;
++  YY_IGNORE_MAYBE_UNINITIALIZED_END
+ 
+   goto yynewstate;
+ 
+@@ -1780,7 +1634,7 @@ yyreduce:
+   yylen = yyr2[yyn];
+ 
+   /* If YYLEN is nonzero, implement the default value of the action:
+-     `$$ = $1'.
++     '$$ = $1'.
+ 
+      Otherwise, the following line sets YYVAL to garbage.
+      This behavior is undocumented and Bison
+@@ -1794,42 +1648,45 @@ yyreduce:
+   switch (yyn)
+     {
+         case 7:
+-#line 209 "grammar.y"
++#line 209 "grammar.y" /* yacc.c:1646  */
+     {
+-        int result = yr_parser_reduce_import(yyscanner, (yyvsp[(2) - (2)].sized_string));
++        int result = yr_parser_reduce_import(yyscanner, (yyvsp[0].sized_string));
+ 
+-        yr_free((yyvsp[(2) - (2)].sized_string));
++        yr_free((yyvsp[0].sized_string));
+ 
+         ERROR_IF(result != ERROR_SUCCESS);
+       }
++#line 1660 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 8:
+-#line 221 "grammar.y"
++#line 221 "grammar.y" /* yacc.c:1646  */
+     {
+         int result = yr_parser_reduce_rule_declaration(
+             yyscanner,
+-            (yyvsp[(1) - (9)].integer),
+-            (yyvsp[(3) - (9)].c_string),
+-            (yyvsp[(4) - (9)].c_string),
+-            (yyvsp[(7) - (9)].string),
+-            (yyvsp[(6) - (9)].meta));
++            (yyvsp[-8].integer),
++            (yyvsp[-6].c_string),
++            (yyvsp[-5].c_string),
++            (yyvsp[-2].string),
++            (yyvsp[-3].meta));
+ 
+-        yr_free((yyvsp[(3) - (9)].c_string));
++        yr_free((yyvsp[-6].c_string));
+ 
+         ERROR_IF(result != ERROR_SUCCESS);
+       }
++#line 1678 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 9:
+-#line 239 "grammar.y"
++#line 239 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.meta) = NULL;
+       }
++#line 1686 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 10:
+-#line 243 "grammar.y"
++#line 243 "grammar.y" /* yacc.c:1646  */
+     {
+         // Each rule have a list of meta-data info, consisting in a
+         // sequence of YR_META structures. The last YR_META structure does
+@@ -1848,22 +1705,24 @@ yyreduce:
+             sizeof(YR_META),
+             NULL);
+ 
+-        (yyval.meta) = (yyvsp[(3) - (3)].meta);
++        (yyval.meta) = (yyvsp[0].meta);
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 1713 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 11:
+-#line 270 "grammar.y"
++#line 270 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.string) = NULL;
+         compiler->current_rule_strings = (yyval.string);
+       }
++#line 1722 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 12:
+-#line 275 "grammar.y"
++#line 275 "grammar.y" /* yacc.c:1646  */
+     {
+         // Each rule have a list of strings, consisting in a sequence
+         // of YR_STRING structures. The last YR_STRING structure does not
+@@ -1884,40 +1743,46 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+-        compiler->current_rule_strings = (yyvsp[(3) - (3)].string);
+-        (yyval.string) = (yyvsp[(3) - (3)].string);
++        compiler->current_rule_strings = (yyvsp[0].string);
++        (yyval.string) = (yyvsp[0].string);
+       }
++#line 1750 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 14:
+-#line 307 "grammar.y"
++#line 307 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = 0;  }
++#line 1756 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 15:
+-#line 308 "grammar.y"
+-    { (yyval.integer) = (yyvsp[(1) - (2)].integer) | (yyvsp[(2) - (2)].integer); }
++#line 308 "grammar.y" /* yacc.c:1646  */
++    { (yyval.integer) = (yyvsp[-1].integer) | (yyvsp[0].integer); }
++#line 1762 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 16:
+-#line 313 "grammar.y"
++#line 313 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = RULE_GFLAGS_PRIVATE; }
++#line 1768 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 17:
+-#line 314 "grammar.y"
++#line 314 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = RULE_GFLAGS_GLOBAL; }
++#line 1774 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 18:
+-#line 320 "grammar.y"
++#line 320 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.c_string) = NULL;
+       }
++#line 1782 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 19:
+-#line 324 "grammar.y"
++#line 324 "grammar.y" /* yacc.c:1646  */
+     {
+         // Tags list is represented in the arena as a sequence
+         // of null-terminated strings, the sequence ends with an
+@@ -1929,35 +1794,37 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+-        (yyval.c_string) = (yyvsp[(2) - (2)].c_string);
++        (yyval.c_string) = (yyvsp[0].c_string);
+       }
++#line 1800 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 20:
+-#line 342 "grammar.y"
++#line 342 "grammar.y" /* yacc.c:1646  */
+     {
+         char* identifier;
+ 
+         compiler->last_result = yr_arena_write_string(
+-            yyget_extra(yyscanner)->sz_arena, (yyvsp[(1) - (1)].c_string), &identifier);
++            yyget_extra(yyscanner)->sz_arena, (yyvsp[0].c_string), &identifier);
+ 
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+         (yyval.c_string) = identifier;
+       }
++#line 1817 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 21:
+-#line 355 "grammar.y"
++#line 355 "grammar.y" /* yacc.c:1646  */
+     {
+-        char* tag_name = (yyvsp[(1) - (2)].c_string);
++        char* tag_name = (yyvsp[-1].c_string);
+         size_t tag_length = tag_name != NULL ? strlen(tag_name) : 0;
+ 
+         while (tag_length > 0)
+         {
+-          if (strcmp(tag_name, (yyvsp[(2) - (2)].c_string)) == 0)
++          if (strcmp(tag_name, (yyvsp[0].c_string)) == 0)
+           {
+             yr_compiler_set_error_extra_info(compiler, tag_name);
+             compiler->last_result = ERROR_DUPLICATE_TAG_IDENTIFIER;
+@@ -1974,190 +1841,209 @@ yyreduce:
+ 
+         if (compiler->last_result == ERROR_SUCCESS)
+           compiler->last_result = yr_arena_write_string(
+-              yyget_extra(yyscanner)->sz_arena, (yyvsp[(2) - (2)].c_string), NULL);
++              yyget_extra(yyscanner)->sz_arena, (yyvsp[0].c_string), NULL);
+ 
+-        yr_free((yyvsp[(2) - (2)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+-        (yyval.c_string) = (yyvsp[(1) - (2)].c_string);
++        (yyval.c_string) = (yyvsp[-1].c_string);
+       }
++#line 1853 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 22:
+-#line 391 "grammar.y"
+-    {  (yyval.meta) = (yyvsp[(1) - (1)].meta); }
++#line 391 "grammar.y" /* yacc.c:1646  */
++    {  (yyval.meta) = (yyvsp[0].meta); }
++#line 1859 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 23:
+-#line 392 "grammar.y"
+-    {  (yyval.meta) = (yyvsp[(1) - (2)].meta); }
++#line 392 "grammar.y" /* yacc.c:1646  */
++    {  (yyval.meta) = (yyvsp[-1].meta); }
++#line 1865 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 24:
+-#line 398 "grammar.y"
++#line 398 "grammar.y" /* yacc.c:1646  */
+     {
+-        SIZED_STRING* sized_string = (yyvsp[(3) - (3)].sized_string);
++        SIZED_STRING* sized_string = (yyvsp[0].sized_string);
+ 
+         (yyval.meta) = yr_parser_reduce_meta_declaration(
+             yyscanner,
+             META_TYPE_STRING,
+-            (yyvsp[(1) - (3)].c_string),
++            (yyvsp[-2].c_string),
+             sized_string->c_string,
+             0);
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
+-        yr_free((yyvsp[(3) - (3)].sized_string));
++        yr_free((yyvsp[-2].c_string));
++        yr_free((yyvsp[0].sized_string));
+ 
+         ERROR_IF((yyval.meta) == NULL);
+       }
++#line 1885 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 25:
+-#line 414 "grammar.y"
++#line 414 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.meta) = yr_parser_reduce_meta_declaration(
+             yyscanner,
+             META_TYPE_INTEGER,
+-            (yyvsp[(1) - (3)].c_string),
++            (yyvsp[-2].c_string),
+             NULL,
+-            (yyvsp[(3) - (3)].integer));
++            (yyvsp[0].integer));
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
++        yr_free((yyvsp[-2].c_string));
+ 
+         ERROR_IF((yyval.meta) == NULL);
+       }
++#line 1902 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 26:
+-#line 427 "grammar.y"
++#line 427 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.meta) = yr_parser_reduce_meta_declaration(
+             yyscanner,
+             META_TYPE_BOOLEAN,
+-            (yyvsp[(1) - (3)].c_string),
++            (yyvsp[-2].c_string),
+             NULL,
+             TRUE);
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
++        yr_free((yyvsp[-2].c_string));
+ 
+         ERROR_IF((yyval.meta) == NULL);
+       }
++#line 1919 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 27:
+-#line 440 "grammar.y"
++#line 440 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.meta) = yr_parser_reduce_meta_declaration(
+             yyscanner,
+             META_TYPE_BOOLEAN,
+-            (yyvsp[(1) - (3)].c_string),
++            (yyvsp[-2].c_string),
+             NULL,
+             FALSE);
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
++        yr_free((yyvsp[-2].c_string));
+ 
+         ERROR_IF((yyval.meta) == NULL);
+       }
++#line 1936 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 28:
+-#line 456 "grammar.y"
+-    { (yyval.string) = (yyvsp[(1) - (1)].string); }
++#line 456 "grammar.y" /* yacc.c:1646  */
++    { (yyval.string) = (yyvsp[0].string); }
++#line 1942 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 29:
+-#line 457 "grammar.y"
+-    { (yyval.string) = (yyvsp[(1) - (2)].string); }
++#line 457 "grammar.y" /* yacc.c:1646  */
++    { (yyval.string) = (yyvsp[-1].string); }
++#line 1948 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 30:
+-#line 463 "grammar.y"
++#line 463 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.string) = yr_parser_reduce_string_declaration(
+             yyscanner,
+-            (yyvsp[(4) - (4)].integer),
+-            (yyvsp[(1) - (4)].c_string),
+-            (yyvsp[(3) - (4)].sized_string));
++            (yyvsp[0].integer),
++            (yyvsp[-3].c_string),
++            (yyvsp[-1].sized_string));
+ 
+-        yr_free((yyvsp[(1) - (4)].c_string));
+-        yr_free((yyvsp[(3) - (4)].sized_string));
++        yr_free((yyvsp[-3].c_string));
++        yr_free((yyvsp[-1].sized_string));
+ 
+         ERROR_IF((yyval.string) == NULL);
+       }
++#line 1965 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 31:
+-#line 476 "grammar.y"
++#line 476 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->error_line = yyget_lineno(yyscanner);
+       }
++#line 1973 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 32:
+-#line 480 "grammar.y"
++#line 480 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.string) = yr_parser_reduce_string_declaration(
+             yyscanner,
+-            (yyvsp[(5) - (5)].integer) | STRING_GFLAGS_REGEXP,
+-            (yyvsp[(1) - (5)].c_string),
+-            (yyvsp[(4) - (5)].sized_string));
++            (yyvsp[0].integer) | STRING_GFLAGS_REGEXP,
++            (yyvsp[-4].c_string),
++            (yyvsp[-1].sized_string));
+ 
+-        yr_free((yyvsp[(1) - (5)].c_string));
+-        yr_free((yyvsp[(4) - (5)].sized_string));
++        yr_free((yyvsp[-4].c_string));
++        yr_free((yyvsp[-1].sized_string));
+ 
+         ERROR_IF((yyval.string) == NULL);
+       }
++#line 1990 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 33:
+-#line 493 "grammar.y"
++#line 493 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.string) = yr_parser_reduce_string_declaration(
+             yyscanner,
+             STRING_GFLAGS_HEXADECIMAL,
+-            (yyvsp[(1) - (3)].c_string),
+-            (yyvsp[(3) - (3)].sized_string));
++            (yyvsp[-2].c_string),
++            (yyvsp[0].sized_string));
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
+-        yr_free((yyvsp[(3) - (3)].sized_string));
++        yr_free((yyvsp[-2].c_string));
++        yr_free((yyvsp[0].sized_string));
+ 
+         ERROR_IF((yyval.string) == NULL);
+       }
++#line 2007 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 34:
+-#line 509 "grammar.y"
++#line 509 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = 0; }
++#line 2013 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 35:
+-#line 510 "grammar.y"
+-    { (yyval.integer) = (yyvsp[(1) - (2)].integer) | (yyvsp[(2) - (2)].integer); }
++#line 510 "grammar.y" /* yacc.c:1646  */
++    { (yyval.integer) = (yyvsp[-1].integer) | (yyvsp[0].integer); }
++#line 2019 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 36:
+-#line 515 "grammar.y"
++#line 515 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = STRING_GFLAGS_WIDE; }
++#line 2025 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 37:
+-#line 516 "grammar.y"
++#line 516 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = STRING_GFLAGS_ASCII; }
++#line 2031 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 38:
+-#line 517 "grammar.y"
++#line 517 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = STRING_GFLAGS_NO_CASE; }
++#line 2037 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 39:
+-#line 518 "grammar.y"
++#line 518 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = STRING_GFLAGS_FULL_WORD; }
++#line 2043 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 40:
+-#line 524 "grammar.y"
++#line 524 "grammar.y" /* yacc.c:1646  */
+     {
+         YR_OBJECT* object = NULL;
+         YR_RULE* rule;
+@@ -2167,7 +2053,7 @@ yyreduce:
+ 
+         int var_index;
+ 
+-        var_index = yr_parser_lookup_loop_variable(yyscanner, (yyvsp[(1) - (1)].c_string));
++        var_index = yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string));
+ 
+         if (var_index >= 0)
+         {
+@@ -2186,7 +2072,7 @@ yyreduce:
+ 
+           object = (YR_OBJECT*) yr_hash_table_lookup(
+                 compiler->objects_table,
+-                (yyvsp[(1) - (1)].c_string),
++                (yyvsp[0].c_string),
+                 NULL);
+ 
+           if (object == NULL)
+@@ -2196,7 +2082,7 @@ yyreduce:
+             ns = compiler->current_namespace->name;
+             object = (YR_OBJECT*) yr_hash_table_lookup(
+                 compiler->objects_table,
+-                (yyvsp[(1) - (1)].c_string),
++                (yyvsp[0].c_string),
+                 ns);
+           }
+ 
+@@ -2204,7 +2090,7 @@ yyreduce:
+           {
+             compiler->last_result = yr_arena_write_string(
+                 compiler->sz_arena,
+-                (yyvsp[(1) - (1)].c_string),
++                (yyvsp[0].c_string),
+                 &id);
+ 
+             if (compiler->last_result == ERROR_SUCCESS)
+@@ -2220,7 +2106,7 @@ yyreduce:
+           {
+             rule = (YR_RULE*) yr_hash_table_lookup(
+                 compiler->rules_table,
+-                (yyvsp[(1) - (1)].c_string),
++                (yyvsp[0].c_string),
+                 compiler->current_namespace->name);
+ 
+             if (rule != NULL)
+@@ -2233,7 +2119,7 @@ yyreduce:
+             }
+             else
+             {
+-              yr_compiler_set_error_extra_info(compiler, (yyvsp[(1) - (1)].c_string));
++              yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string));
+               compiler->last_result = ERROR_UNDEFINED_IDENTIFIER;
+             }
+ 
+@@ -2241,16 +2127,17 @@ yyreduce:
+           }
+         }
+ 
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 2135 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 41:
+-#line 612 "grammar.y"
++#line 612 "grammar.y" /* yacc.c:1646  */
+     {
+-        YR_OBJECT* object = (yyvsp[(1) - (3)].object);
++        YR_OBJECT* object = (yyvsp[-2].object);
+         YR_OBJECT* field = NULL;
+ 
+         char* ident;
+@@ -2260,13 +2147,13 @@ yyreduce:
+             object != (YR_OBJECT*) -2 &&    // not a rule identifier
+             object->type == OBJECT_TYPE_STRUCTURE)
+         {
+-          field = yr_object_lookup_field(object, (yyvsp[(3) - (3)].c_string));
++          field = yr_object_lookup_field(object, (yyvsp[0].c_string));
+ 
+           if (field != NULL)
+           {
+             compiler->last_result = yr_arena_write_string(
+               compiler->sz_arena,
+-              (yyvsp[(3) - (3)].c_string),
++              (yyvsp[0].c_string),
+               &ident);
+ 
+             if (compiler->last_result == ERROR_SUCCESS)
+@@ -2278,7 +2165,7 @@ yyreduce:
+           }
+           else
+           {
+-            yr_compiler_set_error_extra_info(compiler, (yyvsp[(3) - (3)].c_string));
++            yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string));
+             compiler->last_result = ERROR_INVALID_FIELD_NAME;
+           }
+         }
+@@ -2293,50 +2180,52 @@ yyreduce:
+ 
+         (yyval.object) = field;
+ 
+-        yr_free((yyvsp[(3) - (3)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 2188 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 42:
+-#line 661 "grammar.y"
++#line 661 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (4)].object) != NULL && (yyvsp[(1) - (4)].object)->type == OBJECT_TYPE_ARRAY)
++        if ((yyvsp[-3].object) != NULL && (yyvsp[-3].object)->type == OBJECT_TYPE_ARRAY)
+         {
+           compiler->last_result = yr_parser_emit(
+               yyscanner,
+               OP_INDEX_ARRAY,
+               NULL);
+ 
+-          (yyval.object) = ((YR_OBJECT_ARRAY*) (yyvsp[(1) - (4)].object))->items->objects[0];
++          (yyval.object) = ((YR_OBJECT_ARRAY*) (yyvsp[-3].object))->items->objects[0];
+         }
+         else
+         {
+           yr_compiler_set_error_extra_info(
+               compiler,
+-              (yyvsp[(1) - (4)].object)->identifier);
++              (yyvsp[-3].object)->identifier);
+ 
+           compiler->last_result = ERROR_NOT_AN_ARRAY;
+         }
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 2214 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 43:
+-#line 684 "grammar.y"
++#line 684 "grammar.y" /* yacc.c:1646  */
+     {
+         int args_count;
+ 
+-        if ((yyvsp[(1) - (4)].object) != NULL && (yyvsp[(1) - (4)].object)->type == OBJECT_TYPE_FUNCTION)
++        if ((yyvsp[-3].object) != NULL && (yyvsp[-3].object)->type == OBJECT_TYPE_FUNCTION)
+         {
+           compiler->last_result = yr_parser_check_types(
+-              compiler, (YR_OBJECT_FUNCTION*) (yyvsp[(1) - (4)].object), (yyvsp[(3) - (4)].c_string));
++              compiler, (YR_OBJECT_FUNCTION*) (yyvsp[-3].object), (yyvsp[-1].c_string));
+ 
+           if (compiler->last_result == ERROR_SUCCESS)
+           {
+-            args_count = strlen((yyvsp[(3) - (4)].c_string));
++            args_count = strlen((yyvsp[-1].c_string));
+ 
+             compiler->last_result = yr_parser_emit_with_arg(
+                 yyscanner,
+@@ -2345,36 +2234,38 @@ yyreduce:
+                 NULL);
+           }
+ 
+-          (yyval.object) = ((YR_OBJECT_FUNCTION*) (yyvsp[(1) - (4)].object))->return_obj;
++          (yyval.object) = ((YR_OBJECT_FUNCTION*) (yyvsp[-3].object))->return_obj;
+         }
+         else
+         {
+           yr_compiler_set_error_extra_info(
+               compiler,
+-              (yyvsp[(1) - (4)].object)->identifier);
++              (yyvsp[-3].object)->identifier);
+ 
+           compiler->last_result = ERROR_NOT_A_FUNCTION;
+         }
+ 
+-        yr_free((yyvsp[(3) - (4)].c_string));
++        yr_free((yyvsp[-1].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 2253 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 44:
+-#line 723 "grammar.y"
++#line 723 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.c_string) = yr_strdup("");
+       }
++#line 2261 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 45:
+-#line 727 "grammar.y"
++#line 727 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.c_string) = yr_malloc(MAX_FUNCTION_ARGS + 1);
+ 
+-        switch((yyvsp[(1) - (1)].expression_type))
++        switch((yyvsp[0].expression_type))
+         {
+           case EXPRESSION_TYPE_INTEGER:
+             strlcpy((yyval.c_string), "i", MAX_FUNCTION_ARGS);
+@@ -2392,44 +2283,46 @@ yyreduce:
+ 
+         ERROR_IF((yyval.c_string) == NULL);
+       }
++#line 2287 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 46:
+-#line 749 "grammar.y"
++#line 749 "grammar.y" /* yacc.c:1646  */
+     {
+-        if (strlen((yyvsp[(1) - (3)].c_string)) == MAX_FUNCTION_ARGS)
++        if (strlen((yyvsp[-2].c_string)) == MAX_FUNCTION_ARGS)
+         {
+           compiler->last_result = ERROR_TOO_MANY_ARGUMENTS;
+         }
+         else
+         {
+-          switch((yyvsp[(3) - (3)].expression_type))
++          switch((yyvsp[0].expression_type))
+           {
+             case EXPRESSION_TYPE_INTEGER:
+-              strlcat((yyvsp[(1) - (3)].c_string), "i", MAX_FUNCTION_ARGS);
++              strlcat((yyvsp[-2].c_string), "i", MAX_FUNCTION_ARGS);
+               break;
+             case EXPRESSION_TYPE_BOOLEAN:
+-              strlcat((yyvsp[(1) - (3)].c_string), "b", MAX_FUNCTION_ARGS);
++              strlcat((yyvsp[-2].c_string), "b", MAX_FUNCTION_ARGS);
+               break;
+             case EXPRESSION_TYPE_STRING:
+-              strlcat((yyvsp[(1) - (3)].c_string), "s", MAX_FUNCTION_ARGS);
++              strlcat((yyvsp[-2].c_string), "s", MAX_FUNCTION_ARGS);
+               break;
+             case EXPRESSION_TYPE_REGEXP:
+-              strlcat((yyvsp[(1) - (3)].c_string), "r", MAX_FUNCTION_ARGS);
++              strlcat((yyvsp[-2].c_string), "r", MAX_FUNCTION_ARGS);
+               break;
+           }
+         }
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+-        (yyval.c_string) = (yyvsp[(1) - (3)].c_string);
++        (yyval.c_string) = (yyvsp[-2].c_string);
+       }
++#line 2320 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 47:
+-#line 782 "grammar.y"
++#line 782 "grammar.y" /* yacc.c:1646  */
+     {
+-        SIZED_STRING* sized_string = (yyvsp[(1) - (1)].sized_string);
++        SIZED_STRING* sized_string = (yyvsp[0].sized_string);
+         RE* re;
+         RE_ERROR error;
+ 
+@@ -2448,7 +2341,7 @@ yyreduce:
+             &re,
+             &error);
+ 
+-        yr_free((yyvsp[(1) - (1)].sized_string));
++        yr_free((yyvsp[0].sized_string));
+ 
+         if (compiler->last_result == ERROR_INVALID_REGULAR_EXPRESSION)
+           yr_compiler_set_error_extra_info(compiler, error.message);
+@@ -2468,12 +2361,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_REGEXP;
+       }
++#line 2365 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 48:
+-#line 827 "grammar.y"
++#line 827 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (1)].expression_type) == EXPRESSION_TYPE_STRING)
++        if ((yyvsp[0].expression_type) == EXPRESSION_TYPE_STRING)
+         {
+           compiler->last_result = yr_parser_emit(
+               yyscanner,
+@@ -2486,10 +2380,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2384 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 49:
+-#line 845 "grammar.y"
++#line 845 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner, OP_PUSH, 1, NULL);
+@@ -2498,10 +2393,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2397 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 50:
+-#line 854 "grammar.y"
++#line 854 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner, OP_PUSH, 0, NULL);
+@@ -2510,13 +2406,14 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2410 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 51:
+-#line 863 "grammar.y"
++#line 863 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_STRING, "matches");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_REGEXP, "matches");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_STRING, "matches");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_REGEXP, "matches");
+ 
+         if (compiler->last_result == ERROR_SUCCESS)
+           compiler->last_result = yr_parser_emit(
+@@ -2528,13 +2425,14 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2429 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 52:
+-#line 878 "grammar.y"
++#line 878 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_STRING, "contains");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_STRING, "contains");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_STRING, "contains");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_STRING, "contains");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner,
+@@ -2545,60 +2443,73 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2447 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 53:
+-#line 892 "grammar.y"
++#line 892 "grammar.y" /* yacc.c:1646  */
+     {
+         int result = yr_parser_reduce_string_identifier(
+             yyscanner,
+-            (yyvsp[(1) - (1)].c_string),
++            (yyvsp[0].c_string),
+             OP_STR_FOUND);
+ 
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(result != ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2464 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 54:
+-#line 905 "grammar.y"
++#line 905 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "at");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "at");
+ 
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+-            (yyvsp[(1) - (3)].c_string),
++            (yyvsp[-2].c_string),
+             OP_STR_FOUND_AT);
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
++        yr_free((yyvsp[-2].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2483 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 55:
+-#line 920 "grammar.y"
++#line 920 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+-            (yyvsp[(1) - (3)].c_string),
++            (yyvsp[-2].c_string),
+             OP_STR_FOUND_IN);
+ 
+-        yr_free((yyvsp[(1) - (3)].c_string));
++        yr_free((yyvsp[-2].c_string));
+ 
+         ERROR_IF(compiler->last_result!= ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2500 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 56:
+-#line 933 "grammar.y"
++#line 933 "grammar.y" /* yacc.c:1646  */
++    {
++        compiler->loop_depth--;
++        compiler->loop_identifier[compiler->loop_depth] = NULL;
++      }
++#line 2509 "grammar.c" /* yacc.c:1646  */
++    break;
++
++  case 57:
++#line 938 "grammar.y" /* yacc.c:1646  */
+     {
+         int var_index;
+ 
+@@ -2610,13 +2521,13 @@ yyreduce:
+ 
+         var_index = yr_parser_lookup_loop_variable(
+             yyscanner,
+-            (yyvsp[(3) - (4)].c_string));
++            (yyvsp[-1].c_string));
+ 
+         if (var_index >= 0)
+         {
+           yr_compiler_set_error_extra_info(
+               compiler,
+-              (yyvsp[(3) - (4)].c_string));
++              (yyvsp[-1].c_string));
+ 
+           compiler->last_result = \
+               ERROR_DUPLICATE_LOOP_IDENTIFIER;
+@@ -2633,10 +2544,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 2548 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 57:
+-#line 968 "grammar.y"
++  case 58:
++#line 973 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset = LOOP_LOCAL_VARS * compiler->loop_depth;
+         int8_t* addr;
+@@ -2650,7 +2562,7 @@ yyreduce:
+         yr_parser_emit_with_arg(
+             yyscanner, OP_CLEAR_M, mem_offset + 2, NULL);
+ 
+-        if ((yyvsp[(6) - (7)].integer) == INTEGER_SET_ENUMERATION)
++        if ((yyvsp[-1].integer) == INTEGER_SET_ENUMERATION)
+         {
+           // Pop the first integer
+           yr_parser_emit_with_arg(
+@@ -2668,13 +2580,14 @@ yyreduce:
+         }
+ 
+         compiler->loop_address[compiler->loop_depth] = addr;
+-        compiler->loop_identifier[compiler->loop_depth] = (yyvsp[(3) - (7)].c_string);
++        compiler->loop_identifier[compiler->loop_depth] = (yyvsp[-4].c_string);
+         compiler->loop_depth++;
+       }
++#line 2587 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 58:
+-#line 1003 "grammar.y"
++  case 59:
++#line 1008 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset;
+ 
+@@ -2692,7 +2605,7 @@ yyreduce:
+         yr_parser_emit_with_arg(
+             yyscanner, OP_INCR_M, mem_offset + 2, NULL);
+ 
+-        if ((yyvsp[(6) - (11)].integer) == INTEGER_SET_ENUMERATION)
++        if ((yyvsp[-5].integer) == INTEGER_SET_ENUMERATION)
+         {
+           yr_parser_emit_with_arg_reloc(
+               yyscanner,
+@@ -2746,14 +2659,15 @@ yyreduce:
+         yr_parser_emit(yyscanner, OP_LE, NULL);
+ 
+         compiler->loop_identifier[compiler->loop_depth] = NULL;
+-        yr_free((yyvsp[(3) - (11)].c_string));
++        yr_free((yyvsp[-8].c_string));
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2667 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 59:
+-#line 1079 "grammar.y"
++  case 60:
++#line 1084 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset = LOOP_LOCAL_VARS * compiler->loop_depth;
+         int8_t* addr;
+@@ -2783,10 +2697,11 @@ yyreduce:
+         compiler->loop_identifier[compiler->loop_depth] = NULL;
+         compiler->loop_depth++;
+       }
++#line 2701 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 60:
+-#line 1109 "grammar.y"
++  case 61:
++#line 1114 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset;
+ 
+@@ -2833,104 +2748,113 @@ yyreduce:
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+ 
+       }
++#line 2752 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 61:
+-#line 1156 "grammar.y"
++  case 62:
++#line 1161 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit(yyscanner, OP_OF, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2762 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 62:
+-#line 1162 "grammar.y"
++  case 63:
++#line 1167 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit(yyscanner, OP_NOT, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2772 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 63:
+-#line 1168 "grammar.y"
++  case 64:
++#line 1173 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit(yyscanner, OP_AND, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2782 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 64:
+-#line 1174 "grammar.y"
++  case 65:
++#line 1179 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_BOOLEAN, "or");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_BOOLEAN, "or");
+ 
+         yr_parser_emit(yyscanner, OP_OR, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2794 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 65:
+-#line 1182 "grammar.y"
++  case 66:
++#line 1187 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "<");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "<");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "<");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "<");
+ 
+         yr_parser_emit(yyscanner, OP_LT, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2807 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 66:
+-#line 1191 "grammar.y"
++  case 67:
++#line 1196 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, ">");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, ">");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, ">");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, ">");
+ 
+         yr_parser_emit(yyscanner, OP_GT, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2820 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 67:
+-#line 1200 "grammar.y"
++  case 68:
++#line 1205 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "<=");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "<=");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "<=");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "<=");
+ 
+         yr_parser_emit(yyscanner, OP_LE, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2833 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 68:
+-#line 1209 "grammar.y"
++  case 69:
++#line 1214 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, ">=");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, ">=");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, ">=");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, ">=");
+ 
+         yr_parser_emit(yyscanner, OP_GE, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2846 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 69:
+-#line 1218 "grammar.y"
++  case 70:
++#line 1223 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (3)].expression_type) != (yyvsp[(3) - (3)].expression_type))
++        if ((yyvsp[-2].expression_type) != (yyvsp[0].expression_type))
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "mismatching types for == operator");
+           compiler->last_result = ERROR_WRONG_TYPE;
+         }
+-        else if ((yyvsp[(1) - (3)].expression_type) == EXPRESSION_TYPE_STRING)
++        else if ((yyvsp[-2].expression_type) == EXPRESSION_TYPE_STRING)
+         {
+           compiler->last_result = yr_parser_emit(
+               yyscanner,
+@@ -2949,18 +2873,19 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2877 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 70:
+-#line 1245 "grammar.y"
++  case 71:
++#line 1250 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (3)].expression_type) != (yyvsp[(3) - (3)].expression_type))
++        if ((yyvsp[-2].expression_type) != (yyvsp[0].expression_type))
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "mismatching types for == operator");
+           compiler->last_result = ERROR_WRONG_TYPE;
+         }
+-        else if ((yyvsp[(1) - (3)].expression_type) == EXPRESSION_TYPE_STRING)
++        else if ((yyvsp[-2].expression_type) == EXPRESSION_TYPE_STRING)
+         {
+           compiler->last_result = yr_parser_emit(
+               yyscanner,
+@@ -2979,18 +2904,19 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2908 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 71:
+-#line 1272 "grammar.y"
++  case 72:
++#line 1277 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (3)].expression_type) != (yyvsp[(3) - (3)].expression_type))
++        if ((yyvsp[-2].expression_type) != (yyvsp[0].expression_type))
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "mismatching types for != operator");
+           compiler->last_result = ERROR_WRONG_TYPE;
+         }
+-        else if ((yyvsp[(1) - (3)].expression_type) == EXPRESSION_TYPE_STRING)
++        else if ((yyvsp[-2].expression_type) == EXPRESSION_TYPE_STRING)
+         {
+           compiler->last_result = yr_parser_emit(
+               yyscanner,
+@@ -3009,43 +2935,48 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
++#line 2939 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 72:
+-#line 1299 "grammar.y"
++  case 73:
++#line 1304 "grammar.y" /* yacc.c:1646  */
+     {
+-        (yyval.expression_type) = (yyvsp[(1) - (1)].expression_type);
++        (yyval.expression_type) = (yyvsp[0].expression_type);
+       }
++#line 2947 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 73:
+-#line 1303 "grammar.y"
++  case 74:
++#line 1308 "grammar.y" /* yacc.c:1646  */
+     {
+-        (yyval.expression_type) = (yyvsp[(2) - (3)].expression_type);
++        (yyval.expression_type) = (yyvsp[-1].expression_type);
+       }
++#line 2955 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 74:
+-#line 1310 "grammar.y"
++  case 75:
++#line 1315 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = INTEGER_SET_ENUMERATION; }
++#line 2961 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 75:
+-#line 1311 "grammar.y"
++  case 76:
++#line 1316 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = INTEGER_SET_RANGE; }
++#line 2967 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 76:
+-#line 1317 "grammar.y"
++  case 77:
++#line 1322 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(2) - (6)].expression_type) != EXPRESSION_TYPE_INTEGER)
++        if ((yyvsp[-4].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "wrong type for range's lower bound");
+           compiler->last_result = ERROR_WRONG_TYPE;
+         }
+ 
+-        if ((yyvsp[(5) - (6)].expression_type) != EXPRESSION_TYPE_INTEGER)
++        if ((yyvsp[-1].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "wrong type for range's upper bound");
+@@ -3054,12 +2985,13 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 2989 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 77:
+-#line 1339 "grammar.y"
++  case 78:
++#line 1344 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (1)].expression_type) != EXPRESSION_TYPE_INTEGER)
++        if ((yyvsp[0].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "wrong type for enumeration item");
+@@ -3069,12 +3001,13 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 3005 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 78:
+-#line 1351 "grammar.y"
++  case 79:
++#line 1356 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(3) - (3)].expression_type) != EXPRESSION_TYPE_INTEGER)
++        if ((yyvsp[0].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+           yr_compiler_set_error_extra_info(
+               compiler, "wrong type for enumeration item");
+@@ -3083,63 +3016,71 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 3020 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 79:
+-#line 1366 "grammar.y"
++  case 80:
++#line 1371 "grammar.y" /* yacc.c:1646  */
+     {
+         // Push end-of-list marker
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, UNDEFINED, NULL);
+       }
++#line 3029 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 81:
+-#line 1372 "grammar.y"
++  case 82:
++#line 1377 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, UNDEFINED, NULL);
+         yr_parser_emit_pushes_for_strings(yyscanner, "$*");
+       }
++#line 3038 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 84:
+-#line 1387 "grammar.y"
++  case 85:
++#line 1392 "grammar.y" /* yacc.c:1646  */
+     {
+-        yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[(1) - (1)].c_string));
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string));
++        yr_free((yyvsp[0].c_string));
+       }
++#line 3047 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 85:
+-#line 1392 "grammar.y"
++  case 86:
++#line 1397 "grammar.y" /* yacc.c:1646  */
+     {
+-        yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[(1) - (1)].c_string));
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string));
++        yr_free((yyvsp[0].c_string));
+       }
++#line 3056 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 87:
+-#line 1402 "grammar.y"
++  case 88:
++#line 1407 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, UNDEFINED, NULL);
+       }
++#line 3064 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 88:
+-#line 1406 "grammar.y"
++  case 89:
++#line 1411 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, 1, NULL);
+       }
++#line 3072 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 89:
+-#line 1414 "grammar.y"
++  case 90:
++#line 1419 "grammar.y" /* yacc.c:1646  */
+     {
+-        (yyval.expression_type) = (yyvsp[(2) - (3)].expression_type);
++        (yyval.expression_type) = (yyvsp[-1].expression_type);
+       }
++#line 3080 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 90:
+-#line 1418 "grammar.y"
++  case 91:
++#line 1423 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_FILESIZE, NULL);
+@@ -3148,10 +3089,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 3093 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 91:
+-#line 1427 "grammar.y"
++  case 92:
++#line 1432 "grammar.y" /* yacc.c:1646  */
+     {
+         yywarning(yyscanner,
+             "Using deprecated \"entrypoint\" keyword. Use the \"entry_point\" " "function from PE module instead.");
+@@ -3163,12 +3105,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3109 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 92:
+-#line 1439 "grammar.y"
++  case 93:
++#line 1444 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (4)].expression_type), EXPRESSION_TYPE_INTEGER, "int8");
++        CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "int8");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_INT8, NULL);
+@@ -3177,12 +3120,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3124 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 93:
+-#line 1450 "grammar.y"
++  case 94:
++#line 1455 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (4)].expression_type), EXPRESSION_TYPE_INTEGER, "int16");
++        CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "int16");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_INT16, NULL);
+@@ -3191,12 +3135,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3139 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 94:
+-#line 1461 "grammar.y"
++  case 95:
++#line 1466 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (4)].expression_type), EXPRESSION_TYPE_INTEGER, "int32");
++        CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "int32");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_INT32, NULL);
+@@ -3205,12 +3150,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3154 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 95:
+-#line 1472 "grammar.y"
++  case 96:
++#line 1477 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (4)].expression_type), EXPRESSION_TYPE_INTEGER, "uint8");
++        CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "uint8");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_UINT8, NULL);
+@@ -3219,12 +3165,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3169 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 96:
+-#line 1483 "grammar.y"
++  case 97:
++#line 1488 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (4)].expression_type), EXPRESSION_TYPE_INTEGER, "uint16");
++        CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "uint16");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_UINT16, NULL);
+@@ -3233,12 +3180,13 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3184 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 97:
+-#line 1494 "grammar.y"
++  case 98:
++#line 1499 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(3) - (4)].expression_type), EXPRESSION_TYPE_INTEGER, "uint32");
++        CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "uint32");
+ 
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_UINT32, NULL);
+@@ -3247,24 +3195,26 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3199 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 98:
+-#line 1505 "grammar.y"
++  case 99:
++#line 1510 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+-            yyscanner, OP_PUSH, (yyvsp[(1) - (1)].integer), NULL);
++            yyscanner, OP_PUSH, (yyvsp[0].integer), NULL);
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3212 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 99:
+-#line 1514 "grammar.y"
++  case 100:
++#line 1519 "grammar.y" /* yacc.c:1646  */
+     {
+-        SIZED_STRING* sized_string = (yyvsp[(1) - (1)].sized_string);
++        SIZED_STRING* sized_string = (yyvsp[0].sized_string);
+         char* string;
+ 
+         compiler->last_result = yr_arena_write_string(
+@@ -3272,7 +3222,7 @@ yyreduce:
+             sized_string->c_string,
+             &string);
+ 
+-        yr_free((yyvsp[(1) - (1)].sized_string));
++        yr_free((yyvsp[0].sized_string));
+ 
+         if (compiler->last_result == ERROR_SUCCESS)
+           compiler->last_result = yr_parser_emit_with_arg_reloc(
+@@ -3285,42 +3235,45 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_STRING;
+       }
++#line 3239 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 100:
+-#line 1537 "grammar.y"
++  case 101:
++#line 1542 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+-            (yyvsp[(1) - (1)].c_string),
++            (yyvsp[0].c_string),
+             OP_STR_COUNT);
+ 
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3256 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 101:
+-#line 1550 "grammar.y"
++  case 102:
++#line 1555 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+-            (yyvsp[(1) - (4)].c_string),
++            (yyvsp[-3].c_string),
+             OP_STR_OFFSET);
+ 
+-        yr_free((yyvsp[(1) - (4)].c_string));
++        yr_free((yyvsp[-3].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3273 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 102:
+-#line 1563 "grammar.y"
++  case 103:
++#line 1568 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner,
+@@ -3331,34 +3284,35 @@ yyreduce:
+         if (compiler->last_result == ERROR_SUCCESS)
+           compiler->last_result = yr_parser_reduce_string_identifier(
+               yyscanner,
+-              (yyvsp[(1) - (1)].c_string),
++              (yyvsp[0].c_string),
+               OP_STR_OFFSET);
+ 
+-        yr_free((yyvsp[(1) - (1)].c_string));
++        yr_free((yyvsp[0].c_string));
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3297 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 103:
+-#line 1583 "grammar.y"
++  case 104:
++#line 1588 "grammar.y" /* yacc.c:1646  */
+     {
+-        if ((yyvsp[(1) - (1)].object) == (YR_OBJECT*) -1)  // loop identifier
++        if ((yyvsp[0].object) == (YR_OBJECT*) -1)  // loop identifier
+         {
+           (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+         }
+-        else if ((yyvsp[(1) - (1)].object) == (YR_OBJECT*) -2)  // rule identifier
++        else if ((yyvsp[0].object) == (YR_OBJECT*) -2)  // rule identifier
+         {
+           (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+         }
+-        else if ((yyvsp[(1) - (1)].object) != NULL)
++        else if ((yyvsp[0].object) != NULL)
+         {
+           compiler->last_result = yr_parser_emit(
+               yyscanner, OP_OBJ_VALUE, NULL);
+ 
+-          switch((yyvsp[(1) - (1)].object)->type)
++          switch((yyvsp[0].object)->type)
+           {
+             case OBJECT_TYPE_INTEGER:
+               (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+@@ -3372,157 +3326,180 @@ yyreduce:
+         }
+         else
+         {
+-          yr_compiler_set_error_extra_info(compiler, (yyvsp[(1) - (1)].object)->identifier);
++          yr_compiler_set_error_extra_info(compiler, (yyvsp[0].object)->identifier);
+           compiler->last_result = ERROR_WRONG_TYPE;
+         }
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
++#line 3336 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 104:
+-#line 1618 "grammar.y"
++  case 105:
++#line 1623 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "+");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "+");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "+");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "+");
+ 
+         yr_parser_emit(yyscanner, OP_ADD, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3349 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 105:
+-#line 1627 "grammar.y"
++  case 106:
++#line 1632 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "-");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "-");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "-");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "-");
+ 
+         yr_parser_emit(yyscanner, OP_SUB, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3362 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 106:
+-#line 1636 "grammar.y"
++  case 107:
++#line 1641 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "*");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "*");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "*");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "*");
+ 
+         yr_parser_emit(yyscanner, OP_MUL, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3375 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 107:
+-#line 1645 "grammar.y"
++  case 108:
++#line 1650 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "\\");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "\\");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "\\");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "\\");
+ 
+         yr_parser_emit(yyscanner, OP_DIV, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3388 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 108:
+-#line 1654 "grammar.y"
++  case 109:
++#line 1659 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "%");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "%");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "%");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "%");
+ 
+         yr_parser_emit(yyscanner, OP_MOD, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3401 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 109:
+-#line 1663 "grammar.y"
++  case 110:
++#line 1668 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "^");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "^");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+ 
+         yr_parser_emit(yyscanner, OP_XOR, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3414 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 110:
+-#line 1672 "grammar.y"
++  case 111:
++#line 1677 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "^");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "^");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+ 
+         yr_parser_emit(yyscanner, OP_AND, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3427 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 111:
+-#line 1681 "grammar.y"
++  case 112:
++#line 1686 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "|");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "|");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "|");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "|");
+ 
+         yr_parser_emit(yyscanner, OP_OR, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3440 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 112:
+-#line 1690 "grammar.y"
++  case 113:
++#line 1695 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(2) - (2)].expression_type), EXPRESSION_TYPE_INTEGER, "~");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "~");
+ 
+         yr_parser_emit(yyscanner, OP_NEG, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3452 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 113:
+-#line 1698 "grammar.y"
++  case 114:
++#line 1703 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "<<");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, "<<");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "<<");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "<<");
+ 
+         yr_parser_emit(yyscanner, OP_SHL, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3465 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 114:
+-#line 1707 "grammar.y"
++  case 115:
++#line 1712 "grammar.y" /* yacc.c:1646  */
+     {
+-        CHECK_TYPE((yyvsp[(1) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, ">>");
+-        CHECK_TYPE((yyvsp[(3) - (3)].expression_type), EXPRESSION_TYPE_INTEGER, ">>");
++        CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, ">>");
++        CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, ">>");
+ 
+         yr_parser_emit(yyscanner, OP_SHR, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
++#line 3478 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+-  case 115:
+-#line 1716 "grammar.y"
++  case 116:
++#line 1721 "grammar.y" /* yacc.c:1646  */
+     {
+-        (yyval.expression_type) = (yyvsp[(1) - (1)].expression_type);
++        (yyval.expression_type) = (yyvsp[0].expression_type);
+       }
++#line 3486 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+ 
+-/* Line 1267 of yacc.c.  */
+-#line 3524 "grammar.c"
++#line 3490 "grammar.c" /* yacc.c:1646  */
+       default: break;
+     }
++  /* User semantic actions sometimes alter yychar, and that requires
++     that yytoken be updated with the new translation.  We take the
++     approach of translating immediately before every use of yytoken.
++     One alternative is translating here after every semantic action,
++     but that translation would be missed if the semantic action invokes
++     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
++     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
++     incorrect destructor might then be invoked immediately.  In the
++     case of YYERROR or YYBACKUP, subsequent parser actions might lead
++     to an incorrect destructor call or verbose syntax error message
++     before the lookahead is translated.  */
+   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+ 
+   YYPOPSTACK (yylen);
+@@ -3531,8 +3508,7 @@ yyreduce:
+ 
+   *++yyvsp = yyval;
+ 
+-
+-  /* Now `shift' the result of the reduction.  Determine what state
++  /* Now 'shift' the result of the reduction.  Determine what state
+      that goes to, based on the state we popped back to and the rule
+      number reduced by.  */
+ 
+@@ -3547,10 +3523,14 @@ yyreduce:
+   goto yynewstate;
+ 
+ 
+-/*------------------------------------.
+-| yyerrlab -- here on detecting error |
+-`------------------------------------*/
++/*--------------------------------------.
++| yyerrlab -- here on detecting error.  |
++`--------------------------------------*/
+ yyerrlab:
++  /* Make sure we have latest lookahead translation.  See comments at
++     user semantic actions for why this is necessary.  */
++  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
++
+   /* If not already recovering from an error, report this error.  */
+   if (!yyerrstatus)
+     {
+@@ -3558,37 +3538,36 @@ yyerrlab:
+ #if ! YYERROR_VERBOSE
+       yyerror (yyscanner, compiler, YY_("syntax error"));
+ #else
++# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
++                                        yyssp, yytoken)
+       {
+-	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+-	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+-	  {
+-	    YYSIZE_T yyalloc = 2 * yysize;
+-	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+-	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
+-	    if (yymsg != yymsgbuf)
+-	      YYSTACK_FREE (yymsg);
+-	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+-	    if (yymsg)
+-	      yymsg_alloc = yyalloc;
+-	    else
+-	      {
+-		yymsg = yymsgbuf;
+-		yymsg_alloc = sizeof yymsgbuf;
+-	      }
+-	  }
+-
+-	if (0 < yysize && yysize <= yymsg_alloc)
+-	  {
+-	    (void) yysyntax_error (yymsg, yystate, yychar);
+-	    yyerror (yyscanner, compiler, yymsg);
+-	  }
+-	else
+-	  {
+-	    yyerror (yyscanner, compiler, YY_("syntax error"));
+-	    if (yysize != 0)
+-	      goto yyexhaustedlab;
+-	  }
++        char const *yymsgp = YY_("syntax error");
++        int yysyntax_error_status;
++        yysyntax_error_status = YYSYNTAX_ERROR;
++        if (yysyntax_error_status == 0)
++          yymsgp = yymsg;
++        else if (yysyntax_error_status == 1)
++          {
++            if (yymsg != yymsgbuf)
++              YYSTACK_FREE (yymsg);
++            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
++            if (!yymsg)
++              {
++                yymsg = yymsgbuf;
++                yymsg_alloc = sizeof yymsgbuf;
++                yysyntax_error_status = 2;
++              }
++            else
++              {
++                yysyntax_error_status = YYSYNTAX_ERROR;
++                yymsgp = yymsg;
++              }
++          }
++        yyerror (yyscanner, compiler, yymsgp);
++        if (yysyntax_error_status == 2)
++          goto yyexhaustedlab;
+       }
++# undef YYSYNTAX_ERROR
+ #endif
+     }
+ 
+@@ -3596,24 +3575,24 @@ yyerrlab:
+ 
+   if (yyerrstatus == 3)
+     {
+-      /* If just tried and failed to reuse look-ahead token after an
+-	 error, discard it.  */
++      /* If just tried and failed to reuse lookahead token after an
++         error, discard it.  */
+ 
+       if (yychar <= YYEOF)
+-	{
+-	  /* Return failure if at end of input.  */
+-	  if (yychar == YYEOF)
+-	    YYABORT;
+-	}
++        {
++          /* Return failure if at end of input.  */
++          if (yychar == YYEOF)
++            YYABORT;
++        }
+       else
+-	{
+-	  yydestruct ("Error: discarding",
+-		      yytoken, &yylval, yyscanner, compiler);
+-	  yychar = YYEMPTY;
+-	}
++        {
++          yydestruct ("Error: discarding",
++                      yytoken, &yylval, yyscanner, compiler);
++          yychar = YYEMPTY;
++        }
+     }
+ 
+-  /* Else will try to reuse look-ahead token after shifting the error
++  /* Else will try to reuse lookahead token after shifting the error
+      token.  */
+   goto yyerrlab1;
+ 
+@@ -3629,7 +3608,7 @@ yyerrorlab:
+   if (/*CONSTCOND*/ 0)
+      goto yyerrorlab;
+ 
+-  /* Do not reclaim the symbols of the rule which action triggered
++  /* Do not reclaim the symbols of the rule whose action triggered
+      this YYERROR.  */
+   YYPOPSTACK (yylen);
+   yylen = 0;
+@@ -3642,38 +3621,37 @@ yyerrorlab:
+ | yyerrlab1 -- common code for both syntax error and YYERROR.  |
+ `-------------------------------------------------------------*/
+ yyerrlab1:
+-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
++  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+ 
+   for (;;)
+     {
+       yyn = yypact[yystate];
+-      if (yyn != YYPACT_NINF)
+-	{
+-	  yyn += YYTERROR;
+-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+-	    {
+-	      yyn = yytable[yyn];
+-	      if (0 < yyn)
+-		break;
+-	    }
+-	}
++      if (!yypact_value_is_default (yyn))
++        {
++          yyn += YYTERROR;
++          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
++            {
++              yyn = yytable[yyn];
++              if (0 < yyn)
++                break;
++            }
++        }
+ 
+       /* Pop the current state because it cannot handle the error token.  */
+       if (yyssp == yyss)
+-	YYABORT;
++        YYABORT;
+ 
+ 
+       yydestruct ("Error: popping",
+-		  yystos[yystate], yyvsp, yyscanner, compiler);
++                  yystos[yystate], yyvsp, yyscanner, compiler);
+       YYPOPSTACK (1);
+       yystate = *yyssp;
+       YY_STACK_PRINT (yyss, yyssp);
+     }
+ 
+-  if (yyn == YYFINAL)
+-    YYACCEPT;
+-
++  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+   *++yyvsp = yylval;
++  YY_IGNORE_MAYBE_UNINITIALIZED_END
+ 
+ 
+   /* Shift the error token.  */
+@@ -3697,7 +3675,7 @@ yyabortlab:
+   yyresult = 1;
+   goto yyreturn;
+ 
+-#ifndef yyoverflow
++#if !defined yyoverflow || YYERROR_VERBOSE
+ /*-------------------------------------------------.
+ | yyexhaustedlab -- memory exhaustion comes here.  |
+ `-------------------------------------------------*/
+@@ -3708,17 +3686,22 @@ yyexhaustedlab:
+ #endif
+ 
+ yyreturn:
+-  if (yychar != YYEOF && yychar != YYEMPTY)
+-     yydestruct ("Cleanup: discarding lookahead",
+-		 yytoken, &yylval, yyscanner, compiler);
+-  /* Do not reclaim the symbols of the rule which action triggered
++  if (yychar != YYEMPTY)
++    {
++      /* Make sure we have latest lookahead translation.  See comments at
++         user semantic actions for why this is necessary.  */
++      yytoken = YYTRANSLATE (yychar);
++      yydestruct ("Cleanup: discarding lookahead",
++                  yytoken, &yylval, yyscanner, compiler);
++    }
++  /* Do not reclaim the symbols of the rule whose action triggered
+      this YYABORT or YYACCEPT.  */
+   YYPOPSTACK (yylen);
+   YY_STACK_PRINT (yyss, yyssp);
+   while (yyssp != yyss)
+     {
+       yydestruct ("Cleanup: popping",
+-		  yystos[*yyssp], yyvsp, yyscanner, compiler);
++                  yystos[*yyssp], yyvsp, yyscanner, compiler);
+       YYPOPSTACK (1);
+     }
+ #ifndef yyoverflow
+@@ -3729,11 +3712,7 @@ yyreturn:
+   if (yymsg != yymsgbuf)
+     YYSTACK_FREE (yymsg);
+ #endif
+-  /* Make sure YYID is used.  */
+-  return YYID (yyresult);
++  return yyresult;
+ }
+-
+-
+-#line 1721 "grammar.y"
+-
++#line 1726 "grammar.y" /* yacc.c:1906  */
+ 
+diff --git a/libyara/grammar.h b/libyara/grammar.h
+index 641f93e..19d75b9 100644
+--- a/libyara/grammar.h
++++ b/libyara/grammar.h
+@@ -1,14 +1,13 @@
+-/* A Bison parser, made by GNU Bison 2.3.  */
++/* A Bison parser, made by GNU Bison 3.0.2.  */
+ 
+-/* Skeleton interface for Bison's Yacc-like parsers in C
++/* Bison interface for Yacc-like parsers in C
+ 
+-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+-   Free Software Foundation, Inc.
++   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+ 
+-   This program is free software; you can redistribute it and/or modify
++   This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+-   the Free Software Foundation; either version 2, or (at your option)
+-   any later version.
++   the Free Software Foundation, either version 3 of the License, or
++   (at your option) any later version.
+ 
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+@@ -16,9 +15,7 @@
+    GNU General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+-   along with this program; if not, write to the Free Software
+-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+-   Boston, MA 02110-1301, USA.  */
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+ 
+ /* As a special exception, you may create a larger work that contains
+    part or all of the Bison parser skeleton and distribute that work
+@@ -33,64 +30,73 @@
+    This special exception was added by the Free Software Foundation in
+    version 2.2 of Bison.  */
+ 
+-/* Tokens.  */
++#ifndef YY_YARA_YY_GRAMMAR_H_INCLUDED
++# define YY_YARA_YY_GRAMMAR_H_INCLUDED
++/* Debug traces.  */
++#ifndef YYDEBUG
++# define YYDEBUG 1
++#endif
++#if YYDEBUG
++extern int yara_yydebug;
++#endif
++
++/* Token type.  */
+ #ifndef YYTOKENTYPE
+ # define YYTOKENTYPE
+-   /* Put the tokens into the symbol table, so that GDB and other debuggers
+-      know about them.  */
+-   enum yytokentype {
+-     _RULE_ = 258,
+-     _PRIVATE_ = 259,
+-     _GLOBAL_ = 260,
+-     _META_ = 261,
+-     _STRINGS_ = 262,
+-     _CONDITION_ = 263,
+-     _IDENTIFIER_ = 264,
+-     _STRING_IDENTIFIER_ = 265,
+-     _STRING_COUNT_ = 266,
+-     _STRING_OFFSET_ = 267,
+-     _STRING_IDENTIFIER_WITH_WILDCARD_ = 268,
+-     _NUMBER_ = 269,
+-     _TEXT_STRING_ = 270,
+-     _HEX_STRING_ = 271,
+-     _REGEXP_ = 272,
+-     _ASCII_ = 273,
+-     _WIDE_ = 274,
+-     _NOCASE_ = 275,
+-     _FULLWORD_ = 276,
+-     _AT_ = 277,
+-     _FILESIZE_ = 278,
+-     _ENTRYPOINT_ = 279,
+-     _ALL_ = 280,
+-     _ANY_ = 281,
+-     _IN_ = 282,
+-     _OF_ = 283,
+-     _FOR_ = 284,
+-     _THEM_ = 285,
+-     _INT8_ = 286,
+-     _INT16_ = 287,
+-     _INT32_ = 288,
+-     _UINT8_ = 289,
+-     _UINT16_ = 290,
+-     _UINT32_ = 291,
+-     _MATCHES_ = 292,
+-     _CONTAINS_ = 293,
+-     _IMPORT_ = 294,
+-     _TRUE_ = 295,
+-     _FALSE_ = 296,
+-     _OR_ = 297,
+-     _AND_ = 298,
+-     _IS_ = 299,
+-     _NEQ_ = 300,
+-     _EQ_ = 301,
+-     _GE_ = 302,
+-     _GT_ = 303,
+-     _LE_ = 304,
+-     _LT_ = 305,
+-     _SHIFT_RIGHT_ = 306,
+-     _SHIFT_LEFT_ = 307,
+-     _NOT_ = 308
+-   };
++  enum yytokentype
++  {
++    _RULE_ = 258,
++    _PRIVATE_ = 259,
++    _GLOBAL_ = 260,
++    _META_ = 261,
++    _STRINGS_ = 262,
++    _CONDITION_ = 263,
++    _IDENTIFIER_ = 264,
++    _STRING_IDENTIFIER_ = 265,
++    _STRING_COUNT_ = 266,
++    _STRING_OFFSET_ = 267,
++    _STRING_IDENTIFIER_WITH_WILDCARD_ = 268,
++    _NUMBER_ = 269,
++    _TEXT_STRING_ = 270,
++    _HEX_STRING_ = 271,
++    _REGEXP_ = 272,
++    _ASCII_ = 273,
++    _WIDE_ = 274,
++    _NOCASE_ = 275,
++    _FULLWORD_ = 276,
++    _AT_ = 277,
++    _FILESIZE_ = 278,
++    _ENTRYPOINT_ = 279,
++    _ALL_ = 280,
++    _ANY_ = 281,
++    _IN_ = 282,
++    _OF_ = 283,
++    _FOR_ = 284,
++    _THEM_ = 285,
++    _INT8_ = 286,
++    _INT16_ = 287,
++    _INT32_ = 288,
++    _UINT8_ = 289,
++    _UINT16_ = 290,
++    _UINT32_ = 291,
++    _MATCHES_ = 292,
++    _CONTAINS_ = 293,
++    _IMPORT_ = 294,
++    _TRUE_ = 295,
++    _FALSE_ = 296,
++    _OR_ = 297,
++    _AND_ = 298,
++    _LT_ = 299,
++    _LE_ = 300,
++    _GT_ = 301,
++    _GE_ = 302,
++    _EQ_ = 303,
++    _NEQ_ = 304,
++    _IS_ = 305,
++    _SHIFT_LEFT_ = 306,
++    _SHIFT_RIGHT_ = 307,
++    _NOT_ = 308
++  };
+ #endif
+ /* Tokens.  */
+ #define _RULE_ 258
+@@ -134,24 +140,24 @@
+ #define _FALSE_ 296
+ #define _OR_ 297
+ #define _AND_ 298
+-#define _IS_ 299
+-#define _NEQ_ 300
+-#define _EQ_ 301
++#define _LT_ 299
++#define _LE_ 300
++#define _GT_ 301
+ #define _GE_ 302
+-#define _GT_ 303
+-#define _LE_ 304
+-#define _LT_ 305
+-#define _SHIFT_RIGHT_ 306
+-#define _SHIFT_LEFT_ 307
++#define _EQ_ 303
++#define _NEQ_ 304
++#define _IS_ 305
++#define _SHIFT_LEFT_ 306
++#define _SHIFT_RIGHT_ 307
+ #define _NOT_ 308
+ 
+-
+-
+-
++/* Value type.  */
+ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+-typedef union YYSTYPE
+-#line 185 "grammar.y"
++typedef union YYSTYPE YYSTYPE;
++union YYSTYPE
+ {
++#line 185 "grammar.y" /* yacc.c:1909  */
++
+   SIZED_STRING*   sized_string;
+   char*           c_string;
+   int8_t          expression_type;
+@@ -159,14 +165,15 @@ typedef union YYSTYPE
+   YR_STRING*      string;
+   YR_META*        meta;
+   YR_OBJECT*      object;
+-}
+-/* Line 1529 of yacc.c.  */
+-#line 165 "grammar.h"
+-	YYSTYPE;
+-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+-# define YYSTYPE_IS_DECLARED 1
++
++#line 170 "grammar.h" /* yacc.c:1909  */
++};
+ # define YYSTYPE_IS_TRIVIAL 1
++# define YYSTYPE_IS_DECLARED 1
+ #endif
+ 
+ 
+ 
++int yara_yyparse (void *yyscanner, YR_COMPILER* compiler);
++
++#endif /* !YY_YARA_YY_GRAMMAR_H_INCLUDED  */
+diff --git a/libyara/grammar.y b/libyara/grammar.y
+index 1bb51f3..6980c52 100644
+--- a/libyara/grammar.y
++++ b/libyara/grammar.y
+@@ -929,6 +929,11 @@ expression
+ 
+         $$ = EXPRESSION_TYPE_BOOLEAN;
+       }
++    | _FOR_ for_expression error
++      {
++        compiler->loop_depth--;
++        compiler->loop_identifier[compiler->loop_depth] = NULL;
++      }
+     | _FOR_ for_expression _IDENTIFIER_ _IN_
+       {
+         int var_index;
diff -Nru yara-3.1.0/debian/patches/0005-Make-sure-that-loop-depth-is-greater-than-0-before-d.patch yara-3.1.0/debian/patches/0005-Make-sure-that-loop-depth-is-greater-than-0-before-d.patch
--- yara-3.1.0/debian/patches/0005-Make-sure-that-loop-depth-is-greater-than-0-before-d.patch	1970-01-01 01:00:00.000000000 +0100
+++ yara-3.1.0/debian/patches/0005-Make-sure-that-loop-depth-is-greater-than-0-before-d.patch	2017-04-09 14:38:30.000000000 +0200
@@ -0,0 +1,27 @@
+From: plusvic <plusvic@gmail.com>
+Date: Mon, 9 Jan 2017 13:17:39 +0100
+Subject: Make sure that loop depth is greater than 0 before decrementing it.
+
+(cherry picked from commit 7f02eca670f29c00a1d2c305e96febae6ce5d37b)
+---
+ libyara/grammar.y | 7 +++++--
+ 1 file changed, 5 insertions(+), 2 deletions(-)
+
+diff --git a/libyara/grammar.y b/libyara/grammar.y
+index 6980c52..eafdf24 100644
+--- a/libyara/grammar.y
++++ b/libyara/grammar.y
+@@ -931,8 +931,11 @@ expression
+       }
+     | _FOR_ for_expression error
+       {
+-        compiler->loop_depth--;
+-        compiler->loop_identifier[compiler->loop_depth] = NULL;
++        if (compiler->loop_depth > 0)
++        {
++          compiler->loop_depth--;
++          compiler->loop_identifier[compiler->loop_depth] = NULL;
++        }
+       }
+     | _FOR_ for_expression _IDENTIFIER_ _IN_
+       {
diff -Nru yara-3.1.0/debian/patches/0006-Fix-issue-597.patch yara-3.1.0/debian/patches/0006-Fix-issue-597.patch
--- yara-3.1.0/debian/patches/0006-Fix-issue-597.patch	1970-01-01 01:00:00.000000000 +0100
+++ yara-3.1.0/debian/patches/0006-Fix-issue-597.patch	2017-04-09 14:38:30.000000000 +0200
@@ -0,0 +1,992 @@
+From: plusvic <plusvic@gmail.com>
+Date: Mon, 23 Jan 2017 18:08:51 +0100
+Subject: Fix issue #597
+
+(cherry picked from commit ab906da53ff2a68c6fd6d1fa73f2b7c7bf0bc636)
+---
+ libyara/grammar.c | 303 ++++++++++++++++++++++++++++--------------------------
+ libyara/grammar.y |   6 ++
+ 2 files changed, 162 insertions(+), 147 deletions(-)
+
+diff --git a/libyara/grammar.c b/libyara/grammar.c
+index f88bbcb..1e74e8c 100644
+--- a/libyara/grammar.c
++++ b/libyara/grammar.c
+@@ -612,14 +612,14 @@ static const yytype_uint16 yyrline[] =
+      242,   270,   274,   302,   307,   308,   313,   314,   320,   323,
+      341,   354,   391,   392,   397,   413,   426,   439,   456,   457,
+      462,   476,   475,   492,   509,   510,   515,   516,   517,   518,
+-     523,   611,   660,   683,   723,   726,   748,   781,   826,   844,
+-     853,   862,   877,   891,   904,   919,   932,   938,   973,   937,
+-    1084,  1083,  1160,  1166,  1172,  1178,  1186,  1195,  1204,  1213,
+-    1222,  1249,  1276,  1303,  1307,  1315,  1316,  1321,  1343,  1355,
+-    1371,  1370,  1376,  1385,  1386,  1391,  1396,  1405,  1406,  1410,
+-    1418,  1422,  1431,  1443,  1454,  1465,  1476,  1487,  1498,  1509,
+-    1518,  1541,  1554,  1567,  1587,  1622,  1631,  1640,  1649,  1658,
+-    1667,  1676,  1685,  1694,  1702,  1711,  1720
++     523,   611,   660,   683,   723,   726,   750,   785,   830,   848,
++     857,   866,   881,   895,   908,   923,   936,   947,   982,   946,
++    1093,  1092,  1169,  1175,  1181,  1187,  1195,  1204,  1213,  1222,
++    1231,  1258,  1285,  1312,  1316,  1324,  1325,  1330,  1352,  1364,
++    1380,  1379,  1385,  1394,  1395,  1400,  1405,  1414,  1415,  1419,
++    1427,  1431,  1440,  1452,  1463,  1474,  1485,  1496,  1507,  1518,
++    1527,  1550,  1563,  1576,  1596,  1631,  1640,  1649,  1658,  1667,
++    1676,  1685,  1694,  1703,  1711,  1720,  1729
+ };
+ #endif
+ 
+@@ -2279,15 +2279,17 @@ yyreduce:
+           case EXPRESSION_TYPE_REGEXP:
+             strlcpy((yyval.c_string), "r", MAX_FUNCTION_ARGS);
+             break;
++          default:
++            assert(FALSE);
+         }
+ 
+         ERROR_IF((yyval.c_string) == NULL);
+       }
+-#line 2287 "grammar.c" /* yacc.c:1646  */
++#line 2289 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 46:
+-#line 749 "grammar.y" /* yacc.c:1646  */
++#line 751 "grammar.y" /* yacc.c:1646  */
+     {
+         if (strlen((yyvsp[-2].c_string)) == MAX_FUNCTION_ARGS)
+         {
+@@ -2309,6 +2311,8 @@ yyreduce:
+             case EXPRESSION_TYPE_REGEXP:
+               strlcat((yyvsp[-2].c_string), "r", MAX_FUNCTION_ARGS);
+               break;
++            default:
++              assert(FALSE);
+           }
+         }
+ 
+@@ -2316,11 +2320,11 @@ yyreduce:
+ 
+         (yyval.c_string) = (yyvsp[-2].c_string);
+       }
+-#line 2320 "grammar.c" /* yacc.c:1646  */
++#line 2324 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 47:
+-#line 782 "grammar.y" /* yacc.c:1646  */
++#line 786 "grammar.y" /* yacc.c:1646  */
+     {
+         SIZED_STRING* sized_string = (yyvsp[0].sized_string);
+         RE* re;
+@@ -2361,11 +2365,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_REGEXP;
+       }
+-#line 2365 "grammar.c" /* yacc.c:1646  */
++#line 2369 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 48:
+-#line 827 "grammar.y" /* yacc.c:1646  */
++#line 831 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[0].expression_type) == EXPRESSION_TYPE_STRING)
+         {
+@@ -2380,11 +2384,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2384 "grammar.c" /* yacc.c:1646  */
++#line 2388 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 49:
+-#line 845 "grammar.y" /* yacc.c:1646  */
++#line 849 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner, OP_PUSH, 1, NULL);
+@@ -2393,11 +2397,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2397 "grammar.c" /* yacc.c:1646  */
++#line 2401 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 50:
+-#line 854 "grammar.y" /* yacc.c:1646  */
++#line 858 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner, OP_PUSH, 0, NULL);
+@@ -2406,11 +2410,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2410 "grammar.c" /* yacc.c:1646  */
++#line 2414 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 51:
+-#line 863 "grammar.y" /* yacc.c:1646  */
++#line 867 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_STRING, "matches");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_REGEXP, "matches");
+@@ -2425,11 +2429,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2429 "grammar.c" /* yacc.c:1646  */
++#line 2433 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 52:
+-#line 878 "grammar.y" /* yacc.c:1646  */
++#line 882 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_STRING, "contains");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_STRING, "contains");
+@@ -2443,11 +2447,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2447 "grammar.c" /* yacc.c:1646  */
++#line 2451 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 53:
+-#line 892 "grammar.y" /* yacc.c:1646  */
++#line 896 "grammar.y" /* yacc.c:1646  */
+     {
+         int result = yr_parser_reduce_string_identifier(
+             yyscanner,
+@@ -2460,11 +2464,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2464 "grammar.c" /* yacc.c:1646  */
++#line 2468 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 54:
+-#line 905 "grammar.y" /* yacc.c:1646  */
++#line 909 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "at");
+ 
+@@ -2479,11 +2483,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2483 "grammar.c" /* yacc.c:1646  */
++#line 2487 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 55:
+-#line 920 "grammar.y" /* yacc.c:1646  */
++#line 924 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+@@ -2496,20 +2500,25 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2500 "grammar.c" /* yacc.c:1646  */
++#line 2504 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 56:
+-#line 933 "grammar.y" /* yacc.c:1646  */
++#line 937 "grammar.y" /* yacc.c:1646  */
+     {
+-        compiler->loop_depth--;
+-        compiler->loop_identifier[compiler->loop_depth] = NULL;
++        if (compiler->loop_depth > 0)
++        {
++          compiler->loop_depth--;
++          compiler->loop_identifier[compiler->loop_depth] = NULL;
++        }
++
++        YYERROR;
+       }
+-#line 2509 "grammar.c" /* yacc.c:1646  */
++#line 2518 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 57:
+-#line 938 "grammar.y" /* yacc.c:1646  */
++#line 947 "grammar.y" /* yacc.c:1646  */
+     {
+         int var_index;
+ 
+@@ -2544,11 +2553,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
+-#line 2548 "grammar.c" /* yacc.c:1646  */
++#line 2557 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 58:
+-#line 973 "grammar.y" /* yacc.c:1646  */
++#line 982 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset = LOOP_LOCAL_VARS * compiler->loop_depth;
+         int8_t* addr;
+@@ -2583,11 +2592,11 @@ yyreduce:
+         compiler->loop_identifier[compiler->loop_depth] = (yyvsp[-4].c_string);
+         compiler->loop_depth++;
+       }
+-#line 2587 "grammar.c" /* yacc.c:1646  */
++#line 2596 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 59:
+-#line 1008 "grammar.y" /* yacc.c:1646  */
++#line 1017 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset;
+ 
+@@ -2663,11 +2672,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2667 "grammar.c" /* yacc.c:1646  */
++#line 2676 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 60:
+-#line 1084 "grammar.y" /* yacc.c:1646  */
++#line 1093 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset = LOOP_LOCAL_VARS * compiler->loop_depth;
+         int8_t* addr;
+@@ -2697,11 +2706,11 @@ yyreduce:
+         compiler->loop_identifier[compiler->loop_depth] = NULL;
+         compiler->loop_depth++;
+       }
+-#line 2701 "grammar.c" /* yacc.c:1646  */
++#line 2710 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 61:
+-#line 1114 "grammar.y" /* yacc.c:1646  */
++#line 1123 "grammar.y" /* yacc.c:1646  */
+     {
+         int mem_offset;
+ 
+@@ -2748,41 +2757,41 @@ yyreduce:
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+ 
+       }
+-#line 2752 "grammar.c" /* yacc.c:1646  */
++#line 2761 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 62:
+-#line 1161 "grammar.y" /* yacc.c:1646  */
++#line 1170 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit(yyscanner, OP_OF, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2762 "grammar.c" /* yacc.c:1646  */
++#line 2771 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 63:
+-#line 1167 "grammar.y" /* yacc.c:1646  */
++#line 1176 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit(yyscanner, OP_NOT, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2772 "grammar.c" /* yacc.c:1646  */
++#line 2781 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 64:
+-#line 1173 "grammar.y" /* yacc.c:1646  */
++#line 1182 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit(yyscanner, OP_AND, NULL);
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2782 "grammar.c" /* yacc.c:1646  */
++#line 2791 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 65:
+-#line 1179 "grammar.y" /* yacc.c:1646  */
++#line 1188 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_BOOLEAN, "or");
+ 
+@@ -2790,11 +2799,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2794 "grammar.c" /* yacc.c:1646  */
++#line 2803 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 66:
+-#line 1187 "grammar.y" /* yacc.c:1646  */
++#line 1196 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "<");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "<");
+@@ -2803,11 +2812,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2807 "grammar.c" /* yacc.c:1646  */
++#line 2816 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 67:
+-#line 1196 "grammar.y" /* yacc.c:1646  */
++#line 1205 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, ">");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, ">");
+@@ -2816,11 +2825,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2820 "grammar.c" /* yacc.c:1646  */
++#line 2829 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 68:
+-#line 1205 "grammar.y" /* yacc.c:1646  */
++#line 1214 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "<=");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "<=");
+@@ -2829,11 +2838,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2833 "grammar.c" /* yacc.c:1646  */
++#line 2842 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 69:
+-#line 1214 "grammar.y" /* yacc.c:1646  */
++#line 1223 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, ">=");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, ">=");
+@@ -2842,11 +2851,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2846 "grammar.c" /* yacc.c:1646  */
++#line 2855 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 70:
+-#line 1223 "grammar.y" /* yacc.c:1646  */
++#line 1232 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[-2].expression_type) != (yyvsp[0].expression_type))
+         {
+@@ -2873,11 +2882,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2877 "grammar.c" /* yacc.c:1646  */
++#line 2886 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 71:
+-#line 1250 "grammar.y" /* yacc.c:1646  */
++#line 1259 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[-2].expression_type) != (yyvsp[0].expression_type))
+         {
+@@ -2904,11 +2913,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2908 "grammar.c" /* yacc.c:1646  */
++#line 2917 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 72:
+-#line 1277 "grammar.y" /* yacc.c:1646  */
++#line 1286 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[-2].expression_type) != (yyvsp[0].expression_type))
+         {
+@@ -2935,39 +2944,39 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_BOOLEAN;
+       }
+-#line 2939 "grammar.c" /* yacc.c:1646  */
++#line 2948 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 73:
+-#line 1304 "grammar.y" /* yacc.c:1646  */
++#line 1313 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.expression_type) = (yyvsp[0].expression_type);
+       }
+-#line 2947 "grammar.c" /* yacc.c:1646  */
++#line 2956 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 74:
+-#line 1308 "grammar.y" /* yacc.c:1646  */
++#line 1317 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.expression_type) = (yyvsp[-1].expression_type);
+       }
+-#line 2955 "grammar.c" /* yacc.c:1646  */
++#line 2964 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 75:
+-#line 1315 "grammar.y" /* yacc.c:1646  */
++#line 1324 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = INTEGER_SET_ENUMERATION; }
+-#line 2961 "grammar.c" /* yacc.c:1646  */
++#line 2970 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 76:
+-#line 1316 "grammar.y" /* yacc.c:1646  */
++#line 1325 "grammar.y" /* yacc.c:1646  */
+     { (yyval.integer) = INTEGER_SET_RANGE; }
+-#line 2967 "grammar.c" /* yacc.c:1646  */
++#line 2976 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 77:
+-#line 1322 "grammar.y" /* yacc.c:1646  */
++#line 1331 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[-4].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+@@ -2985,11 +2994,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
+-#line 2989 "grammar.c" /* yacc.c:1646  */
++#line 2998 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 78:
+-#line 1344 "grammar.y" /* yacc.c:1646  */
++#line 1353 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[0].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+@@ -3001,11 +3010,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
+-#line 3005 "grammar.c" /* yacc.c:1646  */
++#line 3014 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 79:
+-#line 1356 "grammar.y" /* yacc.c:1646  */
++#line 1365 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[0].expression_type) != EXPRESSION_TYPE_INTEGER)
+         {
+@@ -3016,71 +3025,71 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
+-#line 3020 "grammar.c" /* yacc.c:1646  */
++#line 3029 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 80:
+-#line 1371 "grammar.y" /* yacc.c:1646  */
++#line 1380 "grammar.y" /* yacc.c:1646  */
+     {
+         // Push end-of-list marker
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, UNDEFINED, NULL);
+       }
+-#line 3029 "grammar.c" /* yacc.c:1646  */
++#line 3038 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 82:
+-#line 1377 "grammar.y" /* yacc.c:1646  */
++#line 1386 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, UNDEFINED, NULL);
+         yr_parser_emit_pushes_for_strings(yyscanner, "$*");
+       }
+-#line 3038 "grammar.c" /* yacc.c:1646  */
++#line 3047 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 85:
+-#line 1392 "grammar.y" /* yacc.c:1646  */
++#line 1401 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string));
+         yr_free((yyvsp[0].c_string));
+       }
+-#line 3047 "grammar.c" /* yacc.c:1646  */
++#line 3056 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 86:
+-#line 1397 "grammar.y" /* yacc.c:1646  */
++#line 1406 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string));
+         yr_free((yyvsp[0].c_string));
+       }
+-#line 3056 "grammar.c" /* yacc.c:1646  */
++#line 3065 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 88:
+-#line 1407 "grammar.y" /* yacc.c:1646  */
++#line 1416 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, UNDEFINED, NULL);
+       }
+-#line 3064 "grammar.c" /* yacc.c:1646  */
++#line 3073 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 89:
+-#line 1411 "grammar.y" /* yacc.c:1646  */
++#line 1420 "grammar.y" /* yacc.c:1646  */
+     {
+         yr_parser_emit_with_arg(yyscanner, OP_PUSH, 1, NULL);
+       }
+-#line 3072 "grammar.c" /* yacc.c:1646  */
++#line 3081 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 90:
+-#line 1419 "grammar.y" /* yacc.c:1646  */
++#line 1428 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.expression_type) = (yyvsp[-1].expression_type);
+       }
+-#line 3080 "grammar.c" /* yacc.c:1646  */
++#line 3089 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 91:
+-#line 1423 "grammar.y" /* yacc.c:1646  */
++#line 1432 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit(
+             yyscanner, OP_FILESIZE, NULL);
+@@ -3089,11 +3098,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
+-#line 3093 "grammar.c" /* yacc.c:1646  */
++#line 3102 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 92:
+-#line 1432 "grammar.y" /* yacc.c:1646  */
++#line 1441 "grammar.y" /* yacc.c:1646  */
+     {
+         yywarning(yyscanner,
+             "Using deprecated \"entrypoint\" keyword. Use the \"entry_point\" " "function from PE module instead.");
+@@ -3105,11 +3114,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3109 "grammar.c" /* yacc.c:1646  */
++#line 3118 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 93:
+-#line 1444 "grammar.y" /* yacc.c:1646  */
++#line 1453 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "int8");
+ 
+@@ -3120,11 +3129,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3124 "grammar.c" /* yacc.c:1646  */
++#line 3133 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 94:
+-#line 1455 "grammar.y" /* yacc.c:1646  */
++#line 1464 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "int16");
+ 
+@@ -3135,11 +3144,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3139 "grammar.c" /* yacc.c:1646  */
++#line 3148 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 95:
+-#line 1466 "grammar.y" /* yacc.c:1646  */
++#line 1475 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "int32");
+ 
+@@ -3150,11 +3159,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3154 "grammar.c" /* yacc.c:1646  */
++#line 3163 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 96:
+-#line 1477 "grammar.y" /* yacc.c:1646  */
++#line 1486 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "uint8");
+ 
+@@ -3165,11 +3174,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3169 "grammar.c" /* yacc.c:1646  */
++#line 3178 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 97:
+-#line 1488 "grammar.y" /* yacc.c:1646  */
++#line 1497 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "uint16");
+ 
+@@ -3180,11 +3189,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3184 "grammar.c" /* yacc.c:1646  */
++#line 3193 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 98:
+-#line 1499 "grammar.y" /* yacc.c:1646  */
++#line 1508 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-1].expression_type), EXPRESSION_TYPE_INTEGER, "uint32");
+ 
+@@ -3195,11 +3204,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3199 "grammar.c" /* yacc.c:1646  */
++#line 3208 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 99:
+-#line 1510 "grammar.y" /* yacc.c:1646  */
++#line 1519 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner, OP_PUSH, (yyvsp[0].integer), NULL);
+@@ -3208,11 +3217,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3212 "grammar.c" /* yacc.c:1646  */
++#line 3221 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 100:
+-#line 1519 "grammar.y" /* yacc.c:1646  */
++#line 1528 "grammar.y" /* yacc.c:1646  */
+     {
+         SIZED_STRING* sized_string = (yyvsp[0].sized_string);
+         char* string;
+@@ -3235,11 +3244,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_STRING;
+       }
+-#line 3239 "grammar.c" /* yacc.c:1646  */
++#line 3248 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 101:
+-#line 1542 "grammar.y" /* yacc.c:1646  */
++#line 1551 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+@@ -3252,11 +3261,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3256 "grammar.c" /* yacc.c:1646  */
++#line 3265 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 102:
+-#line 1555 "grammar.y" /* yacc.c:1646  */
++#line 1564 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_reduce_string_identifier(
+             yyscanner,
+@@ -3269,11 +3278,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3273 "grammar.c" /* yacc.c:1646  */
++#line 3282 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 103:
+-#line 1568 "grammar.y" /* yacc.c:1646  */
++#line 1577 "grammar.y" /* yacc.c:1646  */
+     {
+         compiler->last_result = yr_parser_emit_with_arg(
+             yyscanner,
+@@ -3293,11 +3302,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3297 "grammar.c" /* yacc.c:1646  */
++#line 3306 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 104:
+-#line 1588 "grammar.y" /* yacc.c:1646  */
++#line 1597 "grammar.y" /* yacc.c:1646  */
+     {
+         if ((yyvsp[0].object) == (YR_OBJECT*) -1)  // loop identifier
+         {
+@@ -3332,11 +3341,11 @@ yyreduce:
+ 
+         ERROR_IF(compiler->last_result != ERROR_SUCCESS);
+       }
+-#line 3336 "grammar.c" /* yacc.c:1646  */
++#line 3345 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 105:
+-#line 1623 "grammar.y" /* yacc.c:1646  */
++#line 1632 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "+");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "+");
+@@ -3345,11 +3354,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3349 "grammar.c" /* yacc.c:1646  */
++#line 3358 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 106:
+-#line 1632 "grammar.y" /* yacc.c:1646  */
++#line 1641 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "-");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "-");
+@@ -3358,11 +3367,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3362 "grammar.c" /* yacc.c:1646  */
++#line 3371 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 107:
+-#line 1641 "grammar.y" /* yacc.c:1646  */
++#line 1650 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "*");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "*");
+@@ -3371,11 +3380,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3375 "grammar.c" /* yacc.c:1646  */
++#line 3384 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 108:
+-#line 1650 "grammar.y" /* yacc.c:1646  */
++#line 1659 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "\\");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "\\");
+@@ -3384,11 +3393,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3388 "grammar.c" /* yacc.c:1646  */
++#line 3397 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 109:
+-#line 1659 "grammar.y" /* yacc.c:1646  */
++#line 1668 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "%");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "%");
+@@ -3397,11 +3406,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3401 "grammar.c" /* yacc.c:1646  */
++#line 3410 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 110:
+-#line 1668 "grammar.y" /* yacc.c:1646  */
++#line 1677 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+@@ -3410,11 +3419,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3414 "grammar.c" /* yacc.c:1646  */
++#line 3423 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 111:
+-#line 1677 "grammar.y" /* yacc.c:1646  */
++#line 1686 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "^");
+@@ -3423,11 +3432,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3427 "grammar.c" /* yacc.c:1646  */
++#line 3436 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 112:
+-#line 1686 "grammar.y" /* yacc.c:1646  */
++#line 1695 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "|");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "|");
+@@ -3436,11 +3445,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3440 "grammar.c" /* yacc.c:1646  */
++#line 3449 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 113:
+-#line 1695 "grammar.y" /* yacc.c:1646  */
++#line 1704 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "~");
+ 
+@@ -3448,11 +3457,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3452 "grammar.c" /* yacc.c:1646  */
++#line 3461 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 114:
+-#line 1703 "grammar.y" /* yacc.c:1646  */
++#line 1712 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, "<<");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, "<<");
+@@ -3461,11 +3470,11 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3465 "grammar.c" /* yacc.c:1646  */
++#line 3474 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 115:
+-#line 1712 "grammar.y" /* yacc.c:1646  */
++#line 1721 "grammar.y" /* yacc.c:1646  */
+     {
+         CHECK_TYPE((yyvsp[-2].expression_type), EXPRESSION_TYPE_INTEGER, ">>");
+         CHECK_TYPE((yyvsp[0].expression_type), EXPRESSION_TYPE_INTEGER, ">>");
+@@ -3474,19 +3483,19 @@ yyreduce:
+ 
+         (yyval.expression_type) = EXPRESSION_TYPE_INTEGER;
+       }
+-#line 3478 "grammar.c" /* yacc.c:1646  */
++#line 3487 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+   case 116:
+-#line 1721 "grammar.y" /* yacc.c:1646  */
++#line 1730 "grammar.y" /* yacc.c:1646  */
+     {
+         (yyval.expression_type) = (yyvsp[0].expression_type);
+       }
+-#line 3486 "grammar.c" /* yacc.c:1646  */
++#line 3495 "grammar.c" /* yacc.c:1646  */
+     break;
+ 
+ 
+-#line 3490 "grammar.c" /* yacc.c:1646  */
++#line 3499 "grammar.c" /* yacc.c:1646  */
+       default: break;
+     }
+   /* User semantic actions sometimes alter yychar, and that requires
+@@ -3714,5 +3723,5 @@ yyreturn:
+ #endif
+   return yyresult;
+ }
+-#line 1726 "grammar.y" /* yacc.c:1906  */
++#line 1735 "grammar.y" /* yacc.c:1906  */
+ 
+diff --git a/libyara/grammar.y b/libyara/grammar.y
+index eafdf24..463af85 100644
+--- a/libyara/grammar.y
++++ b/libyara/grammar.y
+@@ -741,6 +741,8 @@ arguments_list
+           case EXPRESSION_TYPE_REGEXP:
+             strlcpy($$, "r", MAX_FUNCTION_ARGS);
+             break;
++          default:
++            assert(FALSE);
+         }
+ 
+         ERROR_IF($$ == NULL);
+@@ -767,6 +769,8 @@ arguments_list
+             case EXPRESSION_TYPE_REGEXP:
+               strlcat($1, "r", MAX_FUNCTION_ARGS);
+               break;
++            default:
++              assert(FALSE);
+           }
+         }
+ 
+@@ -936,6 +940,8 @@ expression
+           compiler->loop_depth--;
+           compiler->loop_identifier[compiler->loop_depth] = NULL;
+         }
++
++        YYERROR;
+       }
+     | _FOR_ for_expression _IDENTIFIER_ _IN_
+       {
diff -Nru yara-3.1.0/debian/patches/series yara-3.1.0/debian/patches/series
--- yara-3.1.0/debian/patches/series	2014-08-30 10:19:27.000000000 +0200
+++ yara-3.1.0/debian/patches/series	2017-04-09 14:38:30.000000000 +0200
@@ -1,2 +1,6 @@
 0001-Added-library-path-so-Python-bindings-are-linked-aga.patch
 0002-Add-ifdefs-for-kFreeBSD-and-Hurd.patch
+0003-Fix-issue-576.patch
+0004-Fix-issue-575.patch
+0005-Make-sure-that-loop-depth-is-greater-than-0-before-d.patch
+0006-Fix-issue-597.patch

Reply to: