- Reverted mem alloc function change

- Fixed lineno on method declarations

Makefile.frag

@@ -1,3 +1,8 @@
+#
+# Lemon
+#
+lemon: lemon.c
+	$(CC) -o $@ -Wall $?
 
 #
 # Zend
@@ -7,17 +12,17 @@ $(builddir)/zend_language_scanner.lo: $(srcdir)/zend_language_parser.h
 $(builddir)/zend_ini_scanner.lo: $(srcdir)/zend_ini_parser.h
 
 $(srcdir)/zend_language_scanner.c: $(srcdir)/zend_language_scanner.l
-	@(cd $(top_srcdir); $(RE2C) $(RE2C_FLAGS) --case-inverted -cbdFt Zend/zend_language_scanner_defs.h -oZend/zend_language_scanner.c Zend/zend_language_scanner.l)
+	@(cd $(top_srcdir); $(RE2C) $(RE2C_FLAGS) --no-generation-date --case-inverted -cbdFt Zend/zend_language_scanner_defs.h -oZend/zend_language_scanner.c Zend/zend_language_scanner.l)
 
 $(srcdir)/zend_language_parser.h: $(srcdir)/zend_language_parser.c
-$(srcdir)/zend_language_parser.c: $(srcdir)/zend_language_parser.y
-	@$(YACC) -p zend -v -d $(srcdir)/zend_language_parser.y -o $@
+$(srcdir)/zend_language_parser.c: lemon $(srcdir)/zend_language_parser.y
+	$(LEMON) $(LEMON_FLAGS) $(srcdir)/zend_language_parser.y || test $$? -eq 2
 
 $(srcdir)/zend_ini_parser.h: $(srcdir)/zend_ini_parser.c
-$(srcdir)/zend_ini_parser.c: $(srcdir)/zend_ini_parser.y
-	@$(YACC) -p ini_ -v -d $(srcdir)/zend_ini_parser.y -o $@
+$(srcdir)/zend_ini_parser.c: lemon $(srcdir)/zend_ini_parser.y
+	@$(LEMON) $(LEMON_FLAGS) $(srcdir)/zend_ini_parser.y 
 
 $(srcdir)/zend_ini_scanner.c: $(srcdir)/zend_ini_scanner.l
-	@(cd $(top_srcdir); $(RE2C) $(RE2C_FLAGS) --case-inverted -cbdFt Zend/zend_ini_scanner_defs.h -oZend/zend_ini_scanner.c Zend/zend_ini_scanner.l)
+	@(cd $(top_srcdir); $(RE2C) $(RE2C_FLAGS) --no-generation-date --case-inverted -cbdFt Zend/zend_ini_scanner_defs.h -oZend/zend_ini_scanner.c Zend/zend_ini_scanner.l)
 
 $(builddir)/zend_indent.lo $(builddir)/zend_highlight.lo $(builddir)/zend_compile.lo: $(srcdir)/zend_language_parser.h

Makefile.global

@@ -1,3 +1,4 @@
+LEMON = $(top_srcdir)/lemon
 mkinstalldirs = $(top_srcdir)/build/shtool mkdir -p
 INSTALL = $(top_srcdir)/build/shtool install -c
 INSTALL_DATA = $(INSTALL) -m 644
@@ -111,7 +112,7 @@ clean:
 	rm -f libphp$(PHP_MAJOR_VERSION).la $(SAPI_CLI_PATH) $(OVERALL_TARGET) modules/* libs/*
 
 distclean: clean
-	rm -f Makefile config.cache config.log config.status Makefile.objects Makefile.fragments libtool main/php_config.h stamp-h sapi/apache/libphp$(PHP_MAJOR_VERSION).module buildmk.stamp
+	rm -f Makefile lemon config.cache config.log config.status Makefile.objects Makefile.fragments libtool main/php_config.h stamp-h sapi/apache/libphp$(PHP_MAJOR_VERSION).module buildmk.stamp
 	$(EGREP) define'.*include/php' $(top_srcdir)/configure | $(SED) 's/.*>//'|xargs rm -f
 
 .PHONY: all clean install distclean test

Zend/Makefile.am

@@ -31,19 +31,20 @@ zend_ini_scanner.lo: zend_ini_parser.h
 # Language parser/scanner rules
 
 zend_language_scanner.c: $(srcdir)/zend_language_scanner.l
-	$(RE2C) $(RE2C_FLAGS) --case-inverted -cbdFt $(srcdir)/zend_language_scanner_defs.h -o$@ $(srcdir)/zend_language_scanner.l
+	$(RE2C) $(RE2C_FLAGS) --no-generation-date --case-inverted -cbdFt $(srcdir)/zend_language_scanner_defs.h -o$@ $(srcdir)/zend_language_scanner.l
 
 zend_language_parser.h: zend_language_parser.c
 zend_language_parser.c: $(srcdir)/zend_language_parser.y
-	$(YACC) -p zend -v -d $(srcdir)/zend_language_parser.y -o zend_language_parser.c
+	$(LEMON) $(LEMON_FLAGS) $(srcdir)/zend_language_parser.y || test $$? -eq 2
+
 
 # INI parser/scanner rules
 
 zend_ini_parser.c: $(srcdir)/zend_ini_parser.y
-	$(YACC) -p ini_ -v -d $(srcdir)/zend_ini_parser.y -o zend_ini_parser.c
+	$(LEMON) $(LEMON_FLAGS) $(srcdir)/zend_ini_parser.y
 
 zend_ini_scanner.c: $(srcdir)/zend_ini_scanner.l
-	$(RE2C) $(RE2C_FLAGS) --case-inverted -cbdFt $(srcdir)/zend_ini_scanner_defs.h -o$@ $(srcdir)/zend_ini_scanner.l
+	$(RE2C) $(RE2C_FLAGS) --no-generation-date --case-inverted -cbdFt $(srcdir)/zend_ini_scanner_defs.h -o$@ $(srcdir)/zend_ini_scanner.l
 
 zend_ini_parser.h: zend_ini_parser.c
 

Zend/acinclude.m4

@@ -2,39 +2,6 @@ dnl $Id$
 dnl
 dnl This file contains local autoconf functions.
 
-AC_DEFUN([LIBZEND_BISON_CHECK],[
-  # we only support certain bison versions
-  bison_version_list="1.28 1.35 1.75 1.875 2.0 2.1 2.2 2.3 2.4 2.4.1 2.4.2"
-
-  # for standalone build of Zend Engine
-  test -z "$SED" && SED=sed
-
-  bison_version=none
-  if test "$YACC"; then
-    AC_CACHE_CHECK([for bison version], php_cv_bison_version, [
-      bison_version_vars=`bison --version 2> /dev/null | grep 'GNU Bison' | cut -d ' ' -f 4 | $SED -e 's/\./ /' | tr -d a-z`
-      php_cv_bison_version=invalid
-      if test -n "$bison_version_vars"; then
-        set $bison_version_vars
-        bison_version="${1}.${2}"
-        for bison_check_version in $bison_version_list; do
-          if test "$bison_version" = "$bison_check_version"; then
-            php_cv_bison_version="$bison_check_version (ok)"
-            break
-          fi
-        done
-      fi
-    ])
-  fi
-  case $php_cv_bison_version in
-    ""|invalid[)]
-      bison_msg="bison versions supported for regeneration of the Zend/PHP parsers: $bison_version_list (found: $bison_version)."
-      AC_MSG_WARN([$bison_msg])
-      YACC="exit 0;"
-      ;;
-  esac
-])
-
 AC_DEFUN([ZEND_FP_EXCEPT],[
   AC_CACHE_CHECK(whether fp_except is defined, ac_cv_type_fp_except,[
     AC_TRY_COMPILE([

Zend/zend_compile.c

@@ -611,8 +611,14 @@ static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {
 
 void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
 {
-	int last_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	int last_op_number = 0;
+	zend_op *opline    = NULL;
+
+	zend_check_writable_variable(op1);
+	zend_do_end_variable_parse(op1, BP_VAR_RW, 0 TSRMLS_CC);
+
+	last_op_number = get_next_op_number(CG(active_op_array));
+	opline         = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	if (last_op_number > 0) {
 		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
@@ -655,12 +661,14 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
 	zend_op opline;
 	zend_op *opline_ptr;
 	zend_llist *fetch_list_ptr;
+	zend_bool is_auto_global = 0;
 
 	if (varname->op_type == IS_CONST) {
 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
 			convert_to_string(&varname->u.constant);
 		}
-		if (!zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC) &&
+		is_auto_global = zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC);
+		if (!is_auto_global &&
 		    !(varname->u.constant.value.str.len == (sizeof("this")-1) &&
 		      !memcmp(varname->u.constant.value.str.val, "this", sizeof("this"))) &&
 		    (CG(active_op_array)->last == 0 ||
@@ -690,7 +698,7 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
 
 	if (varname->op_type == IS_CONST) {
 		CALCULATE_LITERAL_HASH(opline_ptr->op1.constant);
-		if (zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC)) {
+		if (is_auto_global) {
 			opline_ptr->extended_value = ZEND_FETCH_GLOBAL;
 		}
 	}
@@ -792,7 +800,7 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
 
 void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */
 {
-	fetch_simple_variable(result, varname, 1 TSRMLS_CC);
+	fetch_simple_variable_ex(result, varname, 1, ZEND_FETCH_W TSRMLS_CC);
 
 	fetch_array_dim(result, result, first_dim TSRMLS_CC);
 }
@@ -5412,7 +5420,7 @@ void zend_do_fetch_static_variable(znode *varname, const znode *static_assignmen
 	if (varname->op_type == IS_CONST) {
 		zval_copy_ctor(&varname->u.constant);
 	}
-	fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+	fetch_simple_variable_ex(&lval, varname, 0, ZEND_FETCH_W TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
 
 	if (fetch_type == ZEND_FETCH_LEXICAL) {
 		znode dummy;
@@ -5474,7 +5482,7 @@ void zend_do_fetch_global_variable(znode *varname, const znode *static_assignmen
 	if (varname->op_type == IS_CONST) {
 		zval_copy_ctor(&varname->u.constant);
 	}
-	fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+	fetch_simple_variable_ex(&lval, varname, 0, ZEND_FETCH_W TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
 
 	zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
 	CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED;
@@ -5523,7 +5531,7 @@ void zend_do_indirect_references(znode *result, const znode *num_references, zno
 		*variable = *result;
 	}
 	zend_do_begin_variable_parse(TSRMLS_C);
-	fetch_simple_variable(result, variable, 1 TSRMLS_CC);
+	fetch_simple_variable_ex(result, variable, 1, ZEND_FETCH_W TSRMLS_CC);
 }
 /* }}} */
 
@@ -6101,45 +6109,80 @@ int zend_register_auto_global(const char *name, uint name_len, zend_auto_global_
 }
 /* }}} */
 
-int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
+int zendparse(TSRMLS_D) /* {{{ */
 {
-	int retval;
+	int token, halting = 0, old_exit_status;
+	void *pParser;
 
-	if (CG(increment_lineno)) {
-		CG(zend_lineno)++;
-		CG(increment_lineno) = 0;
+	if ((pParser = zend_lang_parseAlloc(malloc)) == NULL) {
+		zend_lang_parseFree(pParser, free);
+		return 1;
 	}
+	
+	old_exit_status = EG(exit_status);
+	EG(exit_status) = 0;
 
+	while (1) {
+		znode zendlval;
+
+		zendlval.op_type = IS_CONST;
+		INIT_PZVAL(&zendlval.u.constant);
+
+		if (CG(increment_lineno)) {
+			CG(zend_lineno)++;
+			CG(increment_lineno) = 0;
+		}		
 again:
-	Z_TYPE(zendlval->u.constant) = IS_LONG;
-	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
-	switch (retval) {
-		case T_COMMENT:
-		case T_DOC_COMMENT:
-		case T_OPEN_TAG:
-		case T_WHITESPACE:
-			goto again;
+		Z_TYPE(zendlval.u.constant) = IS_LONG;
 
-		case T_CLOSE_TAG:
-			if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
-				CG(increment_lineno) = 1;
-			}
-			if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
-				goto again;				
-			}
-			retval = ';'; /* implicit ; */
+		/* Call the scanner */
+		token = lex_scan(&zendlval.u.constant, &CG(zend_lineno) TSRMLS_CC);
+
+		switch (token) {
+			case T_COMMENT:
+			case T_DOC_COMMENT:
+			case T_OPEN_TAG:
+			case T_WHITESPACE:
+				goto again;
+			case T_HALT_COMPILER:
+				halting = 1;
+				break;
+			case T_END_HEREDOC:
+				efree(Z_STRVAL(zendlval.u.constant));
+				break;
+			case T_OPEN_TAG_WITH_ECHO:
+				token = T_ECHO;
+				break;
+			case T_CLOSE_TAG:
+				if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
+					CG(increment_lineno) = 1;
+				}
+				if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
+					goto again;
+				}
+				token = T_SEMICOLON;
+			default:
+				break;
+		}
+		zend_lang_parse(pParser, token, zendlval TSRMLS_CC);
+		
+		if (token == 0 || EG(exit_status) == 255) {
 			break;
-		case T_OPEN_TAG_WITH_ECHO:
-			retval = T_ECHO;
-			break;
-		case T_END_HEREDOC:
-			efree(Z_STRVAL(zendlval->u.constant));
+		} else if (halting == 1 && token == T_SEMICOLON){
+			/* Handles __HALT_COMPILER(); */
+			zend_lang_parse(pParser, 0, zendlval TSRMLS_CC);
 			break;
+		}
 	}
+	zend_lang_parseFree(pParser, free);
 
-	INIT_PZVAL(&zendlval->u.constant);
-	zendlval->op_type = IS_CONST;
-	return retval;
+	if (EG(exit_status) == 255) {
+		/* We got an E_PARSE */
+		return 1;
+	}
+	EG(exit_status) = old_exit_status;
+
+	return 0;
 }
 /* }}} */
 

Zend/zend_compile.h

@@ -83,6 +83,8 @@ typedef struct _znode { /* used only during compilation */
 	zend_uint EA;      /* extended attributes */
 } znode;
 
+typedef znode znode_array[5];
+
 typedef struct _zend_execute_data zend_execute_data;
 
 #define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data TSRMLS_DC
@@ -378,7 +380,7 @@ void zend_init_compiler_data_structures(TSRMLS_D);
 extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
 extern ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
 
-ZEND_API int lex_scan(zval *zendlval TSRMLS_DC);
+ZEND_API int lex_scan(zval *zendlval, int *lineno TSRMLS_DC);
 void startup_scanner(TSRMLS_D);
 void shutdown_scanner(TSRMLS_D);
 
@@ -660,7 +662,11 @@ ZEND_API zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC
 ZEND_API int zend_auto_global_disable_jit(const char *varname, zend_uint varname_length TSRMLS_DC);
 ZEND_API size_t zend_dirname(char *path, size_t len);
 
-int zendlex(znode *zendlval TSRMLS_DC);
+/* Parser */
+int zendparse(TSRMLS_D);
+void *zend_lang_parseAlloc(void *(*mallocProc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC));
+void zend_lang_parseFree(void *p, void (*freeProc)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC));
+void zend_lang_parse(void *yyp, int yymajor, znode yyminor TSRMLS_DC);
 
 int zend_add_literal(zend_op_array *op_array, const zval *zv);
 

Zend/zend_globals_macros.h

@@ -32,11 +32,9 @@ BEGIN_EXTERN_C()
 /* Compiler */
 #ifdef ZTS
 # define CG(v) TSRMG(compiler_globals_id, zend_compiler_globals *, v)
-int zendparse(void *compiler_globals);
 #else
 # define CG(v) (compiler_globals.v)
 extern ZEND_API struct _zend_compiler_globals compiler_globals;
-int zendparse(void);
 #endif
 
 

Zend/zend_highlight.c

@@ -90,7 +90,7 @@ ZEND_API void zend_html_puts(const char *s, uint len TSRMLS_DC)
 ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)
 {
 	zval token;
-	int token_type;
+	int token_type, lineno = 0;
 	char *last_color = syntax_highlighter_ini->highlight_html;
 	char *next_color;
 
@@ -98,7 +98,7 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 	zend_printf("<span style=\"color: %s\">\n", last_color);
 	/* highlight stuff coming back from zendlex() */
 	token.type = 0;
-	while ((token_type=lex_scan(&token TSRMLS_CC))) {
+	while ((token_type=lex_scan(&token, &lineno TSRMLS_CC))) {
 		switch (token_type) {
 			case T_INLINE_HTML:
 				next_color = syntax_highlighter_ini->highlight_html;
@@ -174,11 +174,11 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 ZEND_API void zend_strip(TSRMLS_D)
 {
 	zval token;
-	int token_type;
+	int token_type, lineno = 0;
 	int prev_space = 0;
 
 	token.type = 0;
-	while ((token_type=lex_scan(&token TSRMLS_CC))) {
+	while ((token_type=lex_scan(&token, &lineno TSRMLS_CC))) {
 		switch (token_type) {
 			case T_WHITESPACE:
 				if (!prev_space) {
@@ -195,7 +195,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 				zend_write(LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
 				efree(token.value.str.val);
 				/* read the following character, either newline or ; */
-				if (lex_scan(&token TSRMLS_CC) != T_WHITESPACE) {
+				if (lex_scan(&token, &lineno TSRMLS_CC) != T_WHITESPACE) {
 					zend_write(LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
 				}
 				zend_write("\n", sizeof("\n") - 1);

Zend/zend_indent.c

@@ -52,7 +52,7 @@ ZEND_API void zend_indent()
 	zval token;
 	int token_type;
 	int in_string=0;
-	int nest_level=0;
+	int nest_level=0, lineno = 0;
 	int emit_whitespace[256];
 	int i;
 	TSRMLS_FETCH();
@@ -61,7 +61,7 @@ ZEND_API void zend_indent()
 
 	/* highlight stuff coming back from zendlex() */
 	token.type = 0;
-	while ((token_type=lex_scan(&token TSRMLS_CC))) {
+	while ((token_type=lex_scan(&token, &lineno TSRMLS_CC))) {
 		switch (token_type) {
 			case T_INLINE_HTML:
 				zend_write(LANG_SCNG(yy_text), LANG_SCNG(yy_leng));

Zend/zend_ini.h

@@ -208,6 +208,7 @@ END_EXTERN_C()
 typedef struct _zend_ini_parser_param {
 	zend_ini_parser_cb_t ini_parser_cb;
 	void *arg;
+	zend_bool syntax_error;
 } zend_ini_parser_param;
 
 #endif /* ZEND_INI_H */

Zend/zend_ini_parser.y

@@ -1,4 +1,4 @@
-%{
+%include{
 /*
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
@@ -13,7 +13,9 @@
    | obtain it through the world-wide-web, please send a note to          |
    | license@zend.com so we can mail you a copy immediately.              |
    +----------------------------------------------------------------------+
-   | Authors: Zeev Suraski <zeev@zend.com>                                |
+   | Author:  Pierrick Charron <pierrick@php.net>                         |
+   | Yacc version authors:                                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
    |          Jani Taskinen <jani@php.net>                                |
    +----------------------------------------------------------------------+
 */
@@ -29,19 +31,17 @@
 #include "zend_ini_scanner.h"
 #include "zend_extensions.h"
 
-#define YYERROR_VERBOSE
-#define YYSTYPE zval
-
-#ifdef ZTS
-#define YYPARSE_PARAM tsrm_ls
-#define YYLEX_PARAM tsrm_ls
-int ini_parse(void *arg);
-#else
-int ini_parse(void);
-#endif
+#define NDEBUG
+#define YYNOERRORRECOVERY
 
 #define ZEND_INI_PARSER_CB	(CG(ini_parser_param))->ini_parser_cb
 #define ZEND_INI_PARSER_ARG	(CG(ini_parser_param))->arg
+#define ZEND_INI_PARSER_SE 	(CG(ini_parser_param))->syntax_error
+
+int ini_parse(TSRMLS_D);
+void *zend_ini_parseAlloc(void *(*mallocProc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC));
+void zend_ini_parseFree(void *p, void (*freeProc)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC));
+void zend_ini_parse(void *yyp, int yymajor, zval yyminor TSRMLS_DC);
 
 /* {{{ zend_ini_do_op()
 */
@@ -90,7 +90,7 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
 */
 static void zend_ini_init_string(zval *result)
 {
-	Z_STRVAL_P(result) = malloc(1);
+	Z_STRVAL_P(result) = (char *) malloc(1);
 	Z_STRVAL_P(result)[0] = 0;
 	Z_STRLEN_P(result) = 0;
 	Z_TYPE_P(result) = IS_STRING;
@@ -144,49 +144,19 @@ static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
 	if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &curval) == SUCCESS) {
 		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(curval), Z_STRLEN(curval));
 		Z_STRLEN_P(result) = Z_STRLEN(curval);
+		Z_TYPE_P(result) = IS_STRING;
 	/* ..or if not found, try ENV */
 	} else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL ||
 			   (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
 		Z_STRVAL_P(result) = strdup(envvar);
 		Z_STRLEN_P(result) = strlen(envvar);
+		Z_TYPE_P(result) = IS_STRING;
 	} else {
 		zend_ini_init_string(result);
 	}
 }
 /* }}} */
 
-/* {{{ ini_error()
-*/
-static void ini_error(char *msg)
-{
-	char *error_buf;
-	int error_buf_len;
-	char *currently_parsed_filename;
-	TSRMLS_FETCH();
-
-	currently_parsed_filename = zend_ini_scanner_get_filename(TSRMLS_C);
-	if (currently_parsed_filename) {
-		error_buf_len = 128 + strlen(msg) + strlen(currently_parsed_filename); /* should be more than enough */
-		error_buf = (char *) emalloc(error_buf_len);
-
-		sprintf(error_buf, "%s in %s on line %d\n", msg, currently_parsed_filename, zend_ini_scanner_get_lineno(TSRMLS_C));
-	} else {
-		error_buf = estrdup("Invalid configuration directive\n");
-	}
-
-	if (CG(ini_parser_unbuffered_errors)) {
-#ifdef PHP_WIN32
-		MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
-#else
-		fprintf(stderr, "PHP:  %s", error_buf);
-#endif
-	} else {
-		zend_error(E_WARNING, "%s", error_buf);
-	}
-	efree(error_buf);
-}
-/* }}} */
-
 /* {{{ zend_parse_ini_file()
 */
 ZEND_API int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, int scanner_mode, zend_ini_parser_cb_t ini_parser_cb, void *arg TSRMLS_DC)
@@ -196,6 +166,7 @@ ZEND_API int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_erro
 
 	ini_parser_param.ini_parser_cb = ini_parser_cb;
 	ini_parser_param.arg = arg;
+	ini_parser_param.syntax_error = 0;
 	CG(ini_parser_param) = &ini_parser_param;
 
 	if (zend_ini_open_file_for_scanning(fh, scanner_mode TSRMLS_CC) == FAILURE) {
@@ -225,6 +196,7 @@ ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, int s
 
 	ini_parser_param.ini_parser_cb = ini_parser_cb;
 	ini_parser_param.arg = arg;
+	ini_parser_param.syntax_error = 0;
 	CG(ini_parser_param) = &ini_parser_param;
 
 	if (zend_ini_prepare_string_for_scanning(str, scanner_mode TSRMLS_CC) == FAILURE) {
@@ -244,134 +216,160 @@ ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, int s
 }
 /* }}} */
 
-%}
+int ini_parse(TSRMLS_D) /* {{{ */
+{
+	int token;
+	void *pParser = zend_ini_parseAlloc(malloc);
 
-%expect 0
-%pure_parser
+	if (pParser == NULL) {
+		zend_ini_parseFree(pParser, free);
+		return 1;
+	}
 
-%token TC_SECTION
-%token TC_RAW
-%token TC_CONSTANT
-%token TC_NUMBER
-%token TC_STRING
-%token TC_WHITESPACE
-%token TC_LABEL
-%token TC_OFFSET
-%token TC_DOLLAR_CURLY
-%token TC_VARNAME
-%token TC_QUOTED_STRING
-%token BOOL_TRUE
-%token BOOL_FALSE
-%token END_OF_LINE
-%token '=' ':' ',' '.' '"' '\'' '^' '+' '-' '/' '*' '%' '$' '~' '<' '>' '?' '@' '{' '}'
-%left '|' '&'
-%right '~' '!'
+	while (1) {
+		zval zendval;
+		token = ini_lex(&zendval TSRMLS_CC);
+		zend_ini_parse(pParser, token, zendval TSRMLS_CC);
 
-%%
-
-statement_list:
-		statement_list statement
-	|	/* empty */
-;
-
-statement:
-		TC_SECTION section_string_or_value ']' {
-#if DEBUG_CFG_PARSER
-			printf("SECTION: [%s]\n", Z_STRVAL($2));
-#endif
-			ZEND_INI_PARSER_CB(&$2, NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG TSRMLS_CC);
-			free(Z_STRVAL($2));
+		if (token == 0 || ZEND_INI_PARSER_SE) {
+			break;
 		}
-	|	TC_LABEL '=' string_or_value {
-#if DEBUG_CFG_PARSER
-			printf("NORMAL: '%s' = '%s'\n", Z_STRVAL($1), Z_STRVAL($3));
+	}
+
+	zend_ini_parseFree(pParser, free);
+	if (ZEND_INI_PARSER_SE) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+/* }}} */
+
+}
+
+%syntax_error {
+	char *error_buf;
+	int error_buf_len;
+	char *currently_parsed_filename;
+
+	ZEND_INI_PARSER_SE = 1;
+
+	currently_parsed_filename = zend_ini_scanner_get_filename(TSRMLS_C);
+	if (currently_parsed_filename) {
+		error_buf_len = 128 + INI_SCNG(yy_leng) + strlen(currently_parsed_filename); /* should be more than enough */
+		error_buf = (char *) emalloc(error_buf_len);
+		sprintf(error_buf, "syntax error, unexpected '%.*s' in %s on line %d\n", INI_SCNG(yy_leng), INI_SCNG(yy_text), currently_parsed_filename, zend_ini_scanner_get_lineno(TSRMLS_C));
+	} else {
+		error_buf = estrdup("Invalid configuration directive\n");
+	}
+
+	if (CG(ini_parser_unbuffered_errors)) {
+#ifdef PHP_WIN32
+		MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
+#else
+		fprintf(stderr, "PHP:  %s", error_buf);
 #endif
-			ZEND_INI_PARSER_CB(&$1, &$3, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
-			free(Z_STRVAL($1));
-			free(Z_STRVAL($3));
-		}
-	|	TC_OFFSET option_offset ']' '=' string_or_value {
+	} else {
+		zend_error(E_WARNING, "%s", error_buf);
+	}
+	efree(error_buf);
+}
+
+%token_type {zval}
+
+%name zend_ini_parse
+
+%ifdef ZTS
+	%extra_argument {void ***tsrm_ls}
+%endif
+
+%token_prefix TC_
+
+/* Precedences */
+%left BW_OR BW_AND.
+%right BW_NOT BOOL_NOT.
+
+start ::= statement_list.
+
+statement_list ::= statement_list statement.
+statement_list ::= .
+
+statement ::= SECTION section_string_or_value(C) RBRACKET. {
 #if DEBUG_CFG_PARSER
-			printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL($1), Z_STRVAL($2), Z_STRVAL($5));
+			printf("SECTION: [%s]\n", Z_STRVAL(C));
 #endif
-			ZEND_INI_PARSER_CB(&$1, &$5, &$2, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
-			free(Z_STRVAL($1));
-			free(Z_STRVAL($2));
-			free(Z_STRVAL($5));
-		}
-	|	TC_LABEL	{ ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); free(Z_STRVAL($1)); }
-	|	END_OF_LINE
-;
+			ZEND_INI_PARSER_CB(&C, NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG TSRMLS_CC);
+			free(Z_STRVAL(C));
+}
+statement ::= LABEL(B) EQUAL string_or_value(D). {
+#if DEBUG_CFG_PARSER
+			printf("NORMAL: '%s' = '%s'\n", Z_STRVAL(B), Z_STRVAL(D));
+#endif
+			ZEND_INI_PARSER_CB(&B, &D, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
+			free(Z_STRVAL(B));
+			free(Z_STRVAL(D));
+}
+statement ::= OFFSET(B) option_offset(C) RBRACKET EQUAL string_or_value(F). {
+#if DEBUG_CFG_PARSER
+			printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL(B), Z_STRVAL(C), Z_STRVAL(F));
+#endif
+			ZEND_INI_PARSER_CB(&B, &F, &C, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC);
+			free(Z_STRVAL(B));
+			free(Z_STRVAL(C));
+			free(Z_STRVAL(F));
+}
+statement ::= LABEL(B). { ZEND_INI_PARSER_CB(&B, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); free(Z_STRVAL(B)); }
+statement ::= END_OF_LINE.
 
-section_string_or_value:
-		var_string_list_section			{ $$ = $1; }
-	|	/* empty */						{ zend_ini_init_string(&$$); }
-;
+section_string_or_value(A) ::= var_string_list_section(B). { A = B; }
+section_string_or_value(A) ::= . { zend_ini_init_string(&A); }
 
-string_or_value:
-		expr							{ $$ = $1; }
-	|	BOOL_TRUE						{ $$ = $1; }
-	|	BOOL_FALSE						{ $$ = $1; }
-	|	END_OF_LINE						{ zend_ini_init_string(&$$); }
-;
+string_or_value(A) ::= expr(B). { A = B; }
+string_or_value(A) ::= BOOL_TRUE(B). { A = B; }
+string_or_value(A) ::= BOOL_FALSE(B). { A = B; }
+string_or_value(A) ::= END_OF_LINE. { zend_ini_init_string(&A); }
 
-option_offset:
-		var_string_list					{ $$ = $1; }
-	|	/* empty */						{ zend_ini_init_string(&$$); }
-;
+option_offset(A) ::= var_string_list(B). { A = B; }
+option_offset(A) ::= . { zend_ini_init_string(&A); }
 
-encapsed_list:
-		encapsed_list cfg_var_ref		{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	encapsed_list TC_QUOTED_STRING	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	/* empty */						{ zend_ini_init_string(&$$); }
-;
+encapsed_list(A) ::= encapsed_list(B) cfg_var_ref(C). { zend_ini_add_string(&A, &B, &C); free(Z_STRVAL(C)); }
+encapsed_list(A) ::= encapsed_list(B) QUOTED_STRING(C). { zend_ini_add_string(&A, &B, &C); free(Z_STRVAL(C)); }
+encapsed_list(A) ::= . { zend_ini_init_string(&A); }
 
-var_string_list_section:
-		cfg_var_ref						{ $$ = $1; }
-	|	constant_literal				{ $$ = $1; }
-	|	'"' encapsed_list '"'			{ $$ = $2; }
-	|	var_string_list_section cfg_var_ref 	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list_section constant_literal	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list_section '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); free(Z_STRVAL($3)); }
-;
+var_string_list_section(A) ::= cfg_var_ref(B). { A = B; }
+var_string_list_section(A) ::= constant_literal(B). { A = B; }
+var_string_list_section(A) ::= QUOTE encapsed_list(C) QUOTE. { A = C; }
+var_string_list_section(A) ::= var_string_list_section(B) cfg_var_ref(C). { zend_ini_add_string(&A, &B, &C); free(Z_STRVAL(C)); }
+var_string_list_section(A) ::= var_string_list_section(B) constant_literal(C). { zend_ini_add_string(&A, &B, &C); free(Z_STRVAL(C)); }
+var_string_list_section(A) ::= var_string_list_section(B) QUOTE encapsed_list(D) QUOTE. { zend_ini_add_string(&A, &B, &D); free(Z_STRVAL(D)); }
 
-var_string_list:
-		cfg_var_ref						{ $$ = $1; }
-	|	constant_string					{ $$ = $1; }
-	|	'"' encapsed_list '"'			{ $$ = $2; }
-	|	var_string_list cfg_var_ref 	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list constant_string	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); free(Z_STRVAL($3)); }
-;
+var_string_list(A) ::= cfg_var_ref(B). { A = B; }
+var_string_list(A) ::= constant_string(B). { A = B; }
+var_string_list(A) ::= QUOTE encapsed_list(C) QUOTE. { A = C; }
+var_string_list(A) ::= var_string_list(B) cfg_var_ref(C). { zend_ini_add_string(&A, &B, &C); free(Z_STRVAL(C)); }
+var_string_list(A) ::= var_string_list(B) constant_string(C). { zend_ini_add_string(&A, &B, &C); free(Z_STRVAL(C)); }
+var_string_list(A) ::= var_string_list(B) QUOTE encapsed_list(D) QUOTE. { zend_ini_add_string(&A, &B, &D); free(Z_STRVAL(D)); }
 
-expr:
-		var_string_list					{ $$ = $1; }
-	|	expr '|' expr					{ zend_ini_do_op('|', &$$, &$1, &$3); }
-	|	expr '&' expr					{ zend_ini_do_op('&', &$$, &$1, &$3); }
-	|	'~' expr						{ zend_ini_do_op('~', &$$, &$2, NULL); }
-	|	'!'	expr						{ zend_ini_do_op('!', &$$, &$2, NULL); }
-	|	'(' expr ')'					{ $$ = $2; }
-;
+expr(A) ::= var_string_list(B).		{ A = B; }
+expr(A) ::= expr(B) BW_OR expr(D).	{ zend_ini_do_op('|', &A, &B, &D); }
+expr(A) ::= expr(B) BW_AND expr(D).	{ zend_ini_do_op('&', &A, &B, &D); }
+expr(A) ::= BW_NOT expr(C).			{ zend_ini_do_op('~', &A, &C, NULL); }
+expr(A) ::= BOOL_NOT expr(C).		{ zend_ini_do_op('!', &A, &C, NULL); }
+expr(A) ::= LPAREN expr(C) RPAREN.	{ A = C; }
 
-cfg_var_ref:
-		TC_DOLLAR_CURLY TC_VARNAME '}'	{ zend_ini_get_var(&$$, &$2 TSRMLS_CC); free(Z_STRVAL($2)); }
-;
+cfg_var_ref(A) ::= DOLLAR_CURLY VARNAME(C) RBRACE. { zend_ini_get_var(&A, &C TSRMLS_CC); free(Z_STRVAL(C)); }
 
-constant_literal:
-		TC_CONSTANT						{ $$ = $1; }
-	|	TC_RAW							{ $$ = $1; /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
-	|	TC_NUMBER						{ $$ = $1; /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
-	|	TC_STRING						{ $$ = $1; /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
-	|	TC_WHITESPACE					{ $$ = $1; /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
-;
+constant_literal(A) ::= CONSTANT(B).	{ A = B; }
+constant_literal(A) ::= RAW(B).			{ A = B; }
+constant_literal(A) ::= NUMBER(B).		{ A = B; }
+constant_literal(A) ::= STRING(B).		{ A = B; }
+constant_literal(A) ::= WHITESPACE(B).	{ A = B; }
 
-constant_string:
-		TC_CONSTANT						{ zend_ini_get_constant(&$$, &$1 TSRMLS_CC); }
-	|	TC_RAW							{ $$ = $1; /*printf("TC_RAW: '%s'\n", Z_STRVAL($1));*/ }
-	|	TC_NUMBER						{ $$ = $1; /*printf("TC_NUMBER: '%s'\n", Z_STRVAL($1));*/ }
-	|	TC_STRING						{ $$ = $1; /*printf("TC_STRING: '%s'\n", Z_STRVAL($1));*/ }
-	|	TC_WHITESPACE					{ $$ = $1; /*printf("TC_WHITESPACE: '%s'\n", Z_STRVAL($1));*/ }
-;
+constant_string(A) ::= CONSTANT(B).		{ zend_ini_get_constant(&A, &B TSRMLS_CC); }
+constant_string(A) ::= RAW(B).			{ A = B; }
+constant_string(A) ::= NUMBER(B).		{ A = B; }
+constant_string(A) ::= STRING(B).		{ A = B; }
+constant_string(A) ::= WHITESPACE(B).	{ A = B; }
 
 /*
  * Local variables:

Zend/zend_ini_scanner.l

@@ -315,7 +315,7 @@ restart:
 	if (YYCURSOR >= YYLIMIT) {
 		if (YYSTATE == STATE(ST_VALUE) || YYSTATE == STATE(ST_RAW)) {
 			BEGIN(INITIAL);
-			return END_OF_LINE;
+			return TC_END_OF_LINE;
 		}
 		return 0;
 	}
@@ -374,7 +374,7 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 <ST_SECTION_RAW,ST_SECTION_VALUE>"]"{TABS_AND_SPACES}*{NEWLINE}? { /* End of section */
 	BEGIN(INITIAL);
 	SCNG(lineno)++;
-	return ']';
+	return TC_RBRACKET;
 }
 
 <INITIAL>{LABEL}"["{TABS_AND_SPACES}* { /* Start of option with offset */
@@ -392,7 +392,7 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 
 <ST_OFFSET>{TABS_AND_SPACES}*"]" { /* End of section or an option offset */
 	BEGIN(INITIAL);
-	return ']';
+	return TC_RBRACKET;
 }
 
 <ST_DOUBLE_QUOTES,ST_SECTION_VALUE,ST_VALUE,ST_OFFSET>{DOLLAR_CURLY} { /* Variable start */
@@ -412,15 +412,15 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 
 <ST_VARNAME>"}" { /* Variable end */
 	yy_pop_state(TSRMLS_C);
-	return '}';
+	return TC_RBRACE;
 }
 
 <INITIAL,ST_VALUE>("true"|"on"|"yes"){TABS_AND_SPACES}* { /* TRUE value (when used outside option value/offset this causes parse error!) */
-	RETURN_TOKEN(BOOL_TRUE, "1", 1);
+	RETURN_TOKEN(TC_BOOL_TRUE, "1", 1);
 }
 
 <INITIAL,ST_VALUE>("false"|"off"|"no"|"none"|"null"){TABS_AND_SPACES}* { /* FALSE value (when used outside option value/offset this causes parse error!)*/
-	RETURN_TOKEN(BOOL_FALSE, "", 0);
+	RETURN_TOKEN(TC_BOOL_FALSE, "", 0);
 }
 
 <INITIAL>{LABEL} { /* Get option name */
@@ -439,7 +439,7 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 	} else {
 		yy_push_state(ST_VALUE TSRMLS_CC);
 	}
-	return '=';
+	return TC_EQUAL;
 }
 
 <ST_RAW>{RAW_VALUE_CHARS}+ { /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */
@@ -458,7 +458,7 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 <ST_VALUE,ST_RAW>{TABS_AND_SPACES}*{NEWLINE} { /* End of option value */
 	BEGIN(INITIAL);
 	SCNG(lineno)++;
-	return END_OF_LINE;
+	return TC_END_OF_LINE;
 }
 
 <ST_SECTION_VALUE,ST_VALUE,ST_OFFSET>{CONSTANT} { /* Get constant option value */
@@ -473,14 +473,34 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 	return yytext[0];
 }
 
-<ST_VALUE>{OPERATORS}{TABS_AND_SPACES}* { /* Boolean operators */
-	return yytext[0];
+<ST_VALUE>"|"{TABS_AND_SPACES}* {
+	return TC_BW_OR;
+}
+
+<ST_VALUE>"&"{TABS_AND_SPACES}* {
+	return TC_BW_AND;
+}
+
+<ST_VALUE>"~"{TABS_AND_SPACES}* {
+	return TC_BW_NOT;
+}
+
+<ST_VALUE>"!"{TABS_AND_SPACES}* {
+	return TC_BOOL_NOT;
+}
+
+<ST_VALUE>"("{TABS_AND_SPACES}* {
+	return TC_LPAREN;
+}
+
+<ST_VALUE>")"{TABS_AND_SPACES}* {
+	return TC_RPAREN;
 }
 
 <ST_VALUE>[=] { /* Make = used in option value to trigger error */
 	yyless(0);
 	BEGIN(INITIAL);
-	return END_OF_LINE;
+	return TC_END_OF_LINE;
 }
 
 <ST_VALUE>{VALUE_CHARS}+ { /* Get everything else as option/offset value */
@@ -493,12 +513,12 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 
 <ST_SECTION_VALUE,ST_VALUE,ST_OFFSET>{TABS_AND_SPACES}*["] { /* Double quoted '"' string start */
 	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);
-	return '"';
+	return TC_QUOTE;
 }
 
 <ST_DOUBLE_QUOTES>["]{TABS_AND_SPACES}* { /* Double quoted '"' string ends */
 	yy_pop_state(TSRMLS_C);
-	return '"';
+	return TC_QUOTE;
 }
 
 <ST_DOUBLE_QUOTES>[^] { /* Escape double quoted string contents */
@@ -548,25 +568,25 @@ SECTION_VALUE_CHARS ([^$\n\r;"'\]\\]|("\\"{ANY_CHAR})|{LITERAL_DOLLAR})
 
 <INITIAL>{TABS_AND_SPACES}*{NEWLINE} {
 	SCNG(lineno)++;
-	return END_OF_LINE;
+	return TC_END_OF_LINE;
 }
 
 <INITIAL,ST_VALUE,ST_RAW>{TABS_AND_SPACES}*[;][^\r\n]*{NEWLINE} { /* Comment */
 	BEGIN(INITIAL);
 	SCNG(lineno)++;
-	return END_OF_LINE;
+	return TC_END_OF_LINE;
 }
 
 <INITIAL>{TABS_AND_SPACES}*[#][^\r\n]*{NEWLINE} { /* #Comment */
 	zend_error(E_DEPRECATED, "Comments starting with '#' are deprecated in %s on line %d", zend_ini_scanner_get_filename(TSRMLS_C), SCNG(lineno));
 	BEGIN(INITIAL);
 	SCNG(lineno)++;
-	return END_OF_LINE;
+	return TC_END_OF_LINE;
 }
 
 <ST_VALUE,ST_RAW>[^] { /* End of option value (if EOF is reached before EOL */
 	BEGIN(INITIAL);
-	return END_OF_LINE;
+	return TC_END_OF_LINE;
 }
 
 <*>[^] {

Zend/zend_ini_scanner_defs.h

@@ -1,4 +1,4 @@
-/* Generated by re2c 0.13.5 on Tue May 25 22:53:58 2010 */
+/* Generated by re2c 0.13.5 on Sun Jul 11 15:00:59 2010 */
 #line 3 "Zend/zend_ini_scanner_defs.h"
 
 enum YYCONDTYPE {

Zend/zend_language_scanner.l

@@ -96,7 +96,7 @@ do {																			\
 																				\
 	while (p<boundary) {														\
 		if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) {					\
-			CG(zend_lineno)++;													\
+			++(*lineno);														\
 		}																		\
 		p++;																	\
 	}																			\
@@ -105,7 +105,7 @@ do {																			\
 #define HANDLE_NEWLINE(c) \
 { \
 	if (c == '\n' || c == '\r') { \
-		CG(zend_lineno)++; \
+		++(*lineno); \
 	} \
 }
 
@@ -728,7 +728,7 @@ ZEND_API int zend_multibyte_read_script(unsigned char *buf, size_t n TSRMLS_DC)
 	zendlval->value.str.len = yyleng;
 #endif /* ZEND_MULTIBYTE */
 
-static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
+static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type, int *lineno TSRMLS_DC)
 {
 	register char *s, *t;
 	char *end;
@@ -825,7 +825,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
 		}
 
 		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
-			CG(zend_lineno)++;
+			++(*lineno);
 		}
 		s++;
 	}
@@ -842,7 +842,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
 }
 
 
-int lex_scan(zval *zendlval TSRMLS_DC)
+int lex_scan(zval *zendlval, int *lineno TSRMLS_DC)
 {
 restart:
 	SCNG(yy_text) = YYCURSOR;
@@ -858,13 +858,15 @@ HNUM	"0x"[0-9a-fA-F]+
 LABEL	[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
 WHITESPACE [ \n\r\t]+
 TABS_AND_SPACES [ \t]*
-TOKENS [;:,.\[\]()|^&+-/*=%!~$<>?@]
 ANY_CHAR [^]
 NEWLINE ("\r"|"\n"|"\r\n")
 
 /* compute yyleng before each rule */
 <!*> := yyleng = YYCURSOR - SCNG(yy_text);
 
+<ST_IN_SCRIPTING>"?" {
+	return T_QUESTION_MARK;
+}
 
 <ST_IN_SCRIPTING>"exit" {
 	return T_EXIT;
@@ -1044,10 +1046,26 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	goto restart;
 }
 
+<ST_IN_SCRIPTING>";" {
+	return T_SEMICOLON;
+}
+
+<ST_IN_SCRIPTING>"," {
+	return T_COMMA;
+}
+
+<ST_IN_SCRIPTING>"." {
+	return T_DOT;
+}
+
 <ST_IN_SCRIPTING>"::" {
 	return T_PAAMAYIM_NEKUDOTAYIM;
 }
 
+<ST_IN_SCRIPTING>":" {
+	return T_COLON;
+}
+
 <ST_IN_SCRIPTING>"\\" {
 	return T_NS_SEPARATOR;
 }
@@ -1260,18 +1278,39 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	return T_IS_EQUAL;
 }
 
+<ST_IN_SCRIPTING>"=" {
+	return T_EQUAL;
+}
+
 <ST_IN_SCRIPTING>"!="|"<>" {
 	return T_IS_NOT_EQUAL;
 }
 
+<ST_IN_SCRIPTING>"!" {
+	return T_BOOL_NOT;
+}
+
+<ST_IN_SCRIPTING>"~" {
+	return T_BW_NOT;
+}
+
+
 <ST_IN_SCRIPTING>"<=" {
 	return T_IS_SMALLER_OR_EQUAL;
 }
 
+<ST_IN_SCRIPTING>"<" {
+	return T_IS_SMALLER;
+}
+
 <ST_IN_SCRIPTING>">=" {
 	return T_IS_GREATER_OR_EQUAL;
 }
 
+<ST_IN_SCRIPTING>">" {
+	return T_IS_GREATER;
+}
+
 <ST_IN_SCRIPTING>"+=" {
 	return T_PLUS_EQUAL;
 }
@@ -1344,14 +1383,65 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	return T_SR;
 }
 
-<ST_IN_SCRIPTING>{TOKENS} {
-	return yytext[0];
+<ST_IN_SCRIPTING>"|" {
+	return T_BW_OR;
 }
 
+<ST_IN_SCRIPTING>"&" {
+	return T_BW_AND;
+}
+
+<ST_IN_SCRIPTING>"^" {
+	return T_BW_XOR;
+}
+
+<ST_IN_SCRIPTING>"+" {
+	return T_PLUS;
+}
+
+<ST_IN_SCRIPTING>"-" {
+	return T_MINUS;
+}
+
+<ST_IN_SCRIPTING>"/" {
+	return T_DIV;
+}
+
+<ST_IN_SCRIPTING>"*" {
+	return T_MULT;
+}
+
+<ST_IN_SCRIPTING>"%" {
+	return T_MOD;
+}
+
+<ST_IN_SCRIPTING>"(" {
+	return T_LPAREN;
+}
+
+<ST_IN_SCRIPTING>")" {
+	return T_RPAREN;
+}
+
+<ST_IN_SCRIPTING>"[" {
+	return T_LBRACKET;
+}
+
+<ST_IN_SCRIPTING>"]" {
+	return T_RBRACKET;
+}
+
+<ST_IN_SCRIPTING>"@" {
+	return T_AT;
+}
+
+<ST_IN_SCRIPTING>"$" {
+	return T_DOLLAR;
+}
 
 <ST_IN_SCRIPTING>"{" {
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
-	return '{';
+	return T_LBRACE;
 }
 
 
@@ -1366,7 +1456,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	if (!zend_stack_is_empty(&SCNG(state_stack))) {
 		yy_pop_state(TSRMLS_C);
 	}
-	return '}';
+	return T_RBRACE;
 }
 
 
@@ -1508,7 +1598,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"__LINE__" {
-	zendlval->value.lval = CG(zend_lineno);
+	zendlval->value.lval = *lineno;
 	zendlval->type = IS_LONG;
 	return T_LINE;
 }
@@ -1734,14 +1824,13 @@ inline_html:
 	return T_VARIABLE;
 }
 
-<ST_VAR_OFFSET>"]" {
-	yy_pop_state(TSRMLS_C);
-	return ']';
+<ST_VAR_OFFSET>"[" {
+	return T_LBRACKET;
 }
 
-<ST_VAR_OFFSET>{TOKENS}|[{}"`] {
-	/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
-	return yytext[0];
+<ST_VAR_OFFSET>"]" {
+	yy_pop_state(TSRMLS_C);
+	return T_RBRACKET;
 }
 
 <ST_VAR_OFFSET>[ \n\r\t\\'#] {
@@ -1751,6 +1840,22 @@ inline_html:
 	return T_ENCAPSED_AND_WHITESPACE;
 }
 
+<ST_VAR_OFFSET>'"' {
+	return T_QUOTE;
+}
+
+<ST_VAR_OFFSET>'{' {
+	return T_LBRACE;
+}
+
+<ST_VAR_OFFSET>'}' {
+	return T_RBRACE;
+}
+
+<ST_VAR_OFFSET>'`' {
+	return T_BACKQUOTE;
+}
+
 <ST_IN_SCRIPTING,ST_VAR_OFFSET>{LABEL} {
 	zend_copy_value(zendlval, yytext, yyleng);
 	zendlval->type = IS_STRING;
@@ -1767,7 +1872,7 @@ inline_html:
 				}
 				/* fall through */
 			case '\n':
-				CG(zend_lineno)++;
+				++(*lineno);
 				break;
 			case '%':
 				if (!CG(asp_tags)) {
@@ -1844,7 +1949,7 @@ inline_html:
 		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 	} else {
 		yyless(1);
-		return yytext[0];
+		return T_MOD;
 	}
 }
 
@@ -1901,7 +2006,7 @@ inline_html:
 		}
 
 		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
-			CG(zend_lineno)++;
+			++(*lineno);
 		}
 		s++;
 	}
@@ -1927,7 +2032,7 @@ inline_html:
 		switch (*YYCURSOR++) {
 			case '"':
 				yyleng = YYCURSOR - SCNG(yy_text);
-				zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"' TSRMLS_CC);
+				zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"', lineno TSRMLS_CC);
 				return T_CONSTANT_ENCAPSED_STRING;
 			case '$':
 				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
@@ -1958,7 +2063,7 @@ inline_html:
 	YYCURSOR = SCNG(yy_text) + yyleng;
 
 	BEGIN(ST_DOUBLE_QUOTES);
-	return '"';
+	return T_QUOTE;
 }
 
 
@@ -1970,7 +2075,7 @@ inline_html:
 	Z_STRVAL_P(zendlval) = CG(heredoc);
 	Z_STRLEN_P(zendlval) = CG(heredoc_len);
 
-	CG(zend_lineno)++;
+	++(*lineno);
 	CG(heredoc_len) = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
 	s = yytext+bprefix+3;
 	while ((*s == ' ') || (*s == '\t')) {
@@ -2013,7 +2118,7 @@ inline_html:
 
 <ST_IN_SCRIPTING>[`] {
 	BEGIN(ST_BACKQUOTE);
-	return '`';
+	return T_BACKQUOTE;
 }
 
 
@@ -2040,12 +2145,12 @@ inline_html:
 
 <ST_DOUBLE_QUOTES>["] {
 	BEGIN(ST_IN_SCRIPTING);
-	return '"';
+	return T_QUOTE;
 }
 
 <ST_BACKQUOTE>[`] {
 	BEGIN(ST_IN_SCRIPTING);
-	return '`';
+	return T_BACKQUOTE;
 }
 
 
@@ -2094,7 +2199,7 @@ inline_html:
 double_quotes_scan_done:
 	yyleng = YYCURSOR - SCNG(yy_text);
 
-	zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
+	zend_scan_escape_string(zendlval, yytext, yyleng, '"', lineno TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
 
@@ -2136,7 +2241,7 @@ double_quotes_scan_done:
 
 	yyleng = YYCURSOR - SCNG(yy_text);
 
-	zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
+	zend_scan_escape_string(zendlval, yytext, yyleng, '`', lineno TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
 
@@ -2208,7 +2313,7 @@ double_quotes_scan_done:
 heredoc_scan_done:
 	yyleng = YYCURSOR - SCNG(yy_text);
 
-	zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
+	zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0, lineno TSRMLS_CC);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
 
@@ -2268,7 +2373,6 @@ nowdoc_scan_done:
 	return T_ENCAPSED_AND_WHITESPACE;
 }
 
-
 <ST_IN_SCRIPTING,ST_VAR_OFFSET>{ANY_CHAR} {
 	if (YYCURSOR > YYLIMIT) {
 		return 0;

Zend/zend_language_scanner_defs.h

@@ -1,4 +1,4 @@
-/* Generated by re2c 0.13.5 on Mon May 24 14:07:57 2010 */
+/* Generated by re2c 0.13.5 */
 #line 3 "Zend/zend_language_scanner_defs.h"
 
 enum YYCONDTYPE {

acinclude.m4

@@ -2085,17 +2085,6 @@ AC_DEFUN([PHP_PROG_AWK], [
   PHP_SUBST(AWK)
 ])
 
-dnl
-dnl PHP_PROG_BISON
-dnl
-dnl Search for bison and check it's version
-dnl
-AC_DEFUN([PHP_PROG_BISON], [
-  AC_PROG_YACC
-  LIBZEND_BISON_CHECK
-  PHP_SUBST(YACC)
-])
-
 dnl
 dnl PHP_PROG_LEX
 dnl

configure.in

@@ -148,18 +148,8 @@ PHP_RUNPATH_SWITCH
 
 dnl Checks for some support/generator progs
 PHP_PROG_AWK
-PHP_PROG_BISON
 PHP_PROG_RE2C
 
-dnl Check if bison generated files exist when bison does not..
-case $php_cv_bison_version in
-  ""|invalid[)]
-    if ! test -f "$abs_srcdir/Zend/zend_language_parser.h" || ! test -f "$abs_srcdir/Zend/zend_language_parser.c" ; then
-      AC_MSG_ERROR([bison is required to build PHP/Zend when building a SVN checkout!])
-    fi
-    ;;
-esac
-
 PHP_ARG_ENABLE(re2c-cgoto, whether to enable computed goto gcc extension with re2c,
 [  --enable-re2c-cgoto     Enable -g flag to re2c to use computed goto gcc extension], no, no)
 
@@ -1053,9 +1043,12 @@ LIBZEND_OTHER_CHECKS
 if test "$ZEND_MAINTAINER_ZTS" = "yes"; then
   AC_DEFINE(ZTS,1,[ ])
   PHP_THREAD_SAFETY=yes
+  LEMON_FLAGS="-l -q D=ZTS"
 else
   PHP_THREAD_SAFETY=no
+  LEMON_FLAGS="-l -q"
 fi
+PHP_SUBST(LEMON_FLAGS)
 
 INCLUDES="$INCLUDES -I\$(top_builddir)/TSRM"
 INCLUDES="$INCLUDES -I\$(top_builddir)/Zend"

ext/pcre/pcrelib/pcre_internal.h

@@ -192,7 +192,9 @@ stdint.h is available, include it; it may define INT64_MAX. Systems that do not
 have stdint.h (e.g. Solaris) may have inttypes.h. The macro int64_t may be set
 by "configure". */
 
-#if HAVE_STDINT_H
+#ifdef PHP_WIN32
+#include "win32/php_stdint.h"
+#elif HAVE_STDINT_H
 #include <stdint.h>
 #elif HAVE_INTTYPES_H
 #include <inttypes.h>

ext/tokenizer/tokenizer.c

@@ -110,12 +110,12 @@ static void tokenize(zval *return_value TSRMLS_DC)
 	array_init(return_value);
 
 	ZVAL_NULL(&token);
-	while ((token_type = lex_scan(&token TSRMLS_CC))) {
+	while ((token_type = lex_scan(&token, &token_line TSRMLS_CC))) {
 		destroy = 1;
 		switch (token_type) {
 			case T_CLOSE_TAG:
 				if (zendtext[zendleng - 1] != '>') {
-					CG(zend_lineno)++;
+					++token_line;
 				}
 			case T_OPEN_TAG:
 			case T_OPEN_TAG_WITH_ECHO:
@@ -126,31 +126,62 @@ static void tokenize(zval *return_value TSRMLS_DC)
 				break;
 		}
 
-		if (token_type >= 256) {
-			MAKE_STD_ZVAL(keyword);
-			array_init(keyword);
-			add_next_index_long(keyword, token_type);
-			if (token_type == T_END_HEREDOC) {
-				if (CG(increment_lineno)) {
-					token_line = ++CG(zend_lineno);
-					CG(increment_lineno) = 0;
+		switch (token_type) {
+			case T_DOT:
+			case T_AT:
+			case T_BOOL_NOT:
+			case T_BW_AND:
+			case T_BW_OR:
+			case T_BW_XOR:
+			case T_BW_NOT:
+			case T_PLUS:
+			case T_MINUS:
+			case T_MOD:
+			case T_DIV:
+			case T_MULT:
+			case T_SEMICOLON:
+			case T_COLON:
+			case T_COMMA:
+			case T_LBRACE:
+			case T_RBRACE:
+			case T_LBRACKET:
+			case T_RBRACKET:
+			case T_LPAREN:
+			case T_RPAREN:
+			case T_EQUAL:
+			case T_QUOTE:
+			case T_BACKQUOTE:
+			case T_QUESTION_MARK:
+			case T_IS_GREATER:
+			case T_DOLLAR:
+			case T_IS_SMALLER:
+				 add_next_index_stringl(return_value, (char *)zendtext, zendleng, 1);
+				 break;
+			default:
+				MAKE_STD_ZVAL(keyword);
+				array_init(keyword);
+				add_next_index_long(keyword, token_type);
+				if (token_type == T_END_HEREDOC) {
+					add_next_index_stringl(keyword, Z_STRVAL(token), Z_STRLEN(token), 1);
+					efree(Z_STRVAL(token));
+				} else {
+					add_next_index_stringl(keyword, (char *)zendtext, zendleng, 1);
 				}
-				add_next_index_stringl(keyword, Z_STRVAL(token), Z_STRLEN(token), 1);
-				efree(Z_STRVAL(token));
-			} else {
-				add_next_index_stringl(keyword, (char *)zendtext, zendleng, 1);
-			}
-			add_next_index_long(keyword, token_line);
-			add_next_index_zval(return_value, keyword);
-		} else {
-			add_next_index_stringl(return_value, (char *)zendtext, zendleng, 1);
+				add_next_index_long(keyword, CG(zend_lineno));
+				add_next_index_zval(return_value, keyword);
+				break;
+		}
+		CG(zend_lineno) = token_line;
+		
+		if (CG(increment_lineno)) {
+			++CG(zend_lineno);
+			CG(increment_lineno) = 0;
+			token_line = CG(zend_lineno);
 		}
 		if (destroy && Z_TYPE(token) != IS_NULL) {
 			zval_dtor(&token);
 		}
 		ZVAL_NULL(&token);
-
-		token_line = CG(zend_lineno);
 	}
 }
 

ext/tokenizer/tokenizer_data.c

@@ -2,7 +2,7 @@
    +----------------------------------------------------------------------+
    | PHP Version 5                                                        |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2010 The PHP Group                                |
+   | Copyright (c) 1997-2008 The PHP Group                                |
    +----------------------------------------------------------------------+
    | This source file is subject to version 3.01 of the PHP license,      |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -29,129 +29,167 @@
 
 
 void tokenizer_register_constants(INIT_FUNC_ARGS) {
-	REGISTER_LONG_CONSTANT("T_REQUIRE_ONCE", T_REQUIRE_ONCE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_REQUIRE", T_REQUIRE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_EVAL", T_EVAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_INCLUDE_ONCE", T_INCLUDE_ONCE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_INCLUDE", T_INCLUDE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INCLUDE_ONCE", T_INCLUDE_ONCE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_EVAL", T_EVAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_REQUIRE", T_REQUIRE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_REQUIRE_ONCE", T_REQUIRE_ONCE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_COMMA", T_COMMA, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_LOGICAL_OR", T_LOGICAL_OR, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_LOGICAL_XOR", T_LOGICAL_XOR, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_LOGICAL_AND", T_LOGICAL_AND, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_PRINT", T_PRINT, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_SR_EQUAL", T_SR_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_SL_EQUAL", T_SL_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_XOR_EQUAL", T_XOR_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_OR_EQUAL", T_OR_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_AND_EQUAL", T_AND_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_MOD_EQUAL", T_MOD_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CONCAT_EQUAL", T_CONCAT_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DIV_EQUAL", T_DIV_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_MUL_EQUAL", T_MUL_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_MINUS_EQUAL", T_MINUS_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_EQUAL", T_EQUAL, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_PLUS_EQUAL", T_PLUS_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MINUS_EQUAL", T_MINUS_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MUL_EQUAL", T_MUL_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DIV_EQUAL", T_DIV_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_CONCAT_EQUAL", T_CONCAT_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MOD_EQUAL", T_MOD_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_AND_EQUAL", T_AND_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_OR_EQUAL", T_OR_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_XOR_EQUAL", T_XOR_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SL_EQUAL", T_SL_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SR_EQUAL", T_SR_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_QUESTION_MARK", T_QUESTION_MARK, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_COLON", T_COLON, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_BOOLEAN_OR", T_BOOLEAN_OR, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_BOOLEAN_AND", T_BOOLEAN_AND, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_IS_NOT_IDENTICAL", T_IS_NOT_IDENTICAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_IS_IDENTICAL", T_IS_IDENTICAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_IS_NOT_EQUAL", T_IS_NOT_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BW_OR", T_BW_OR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BW_XOR", T_BW_XOR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BW_AND", T_BW_AND, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_IS_EQUAL", T_IS_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_IS_GREATER_OR_EQUAL", T_IS_GREATER_OR_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS_NOT_EQUAL", T_IS_NOT_EQUAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS_IDENTICAL", T_IS_IDENTICAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS_NOT_IDENTICAL", T_IS_NOT_IDENTICAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS_SMALLER", T_IS_SMALLER, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_IS_SMALLER_OR_EQUAL", T_IS_SMALLER_OR_EQUAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_SR", T_SR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS_GREATER", T_IS_GREATER, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS_GREATER_OR_EQUAL", T_IS_GREATER_OR_EQUAL, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_SL", T_SL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SR", T_SR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_PLUS", T_PLUS, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MINUS", T_MINUS, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DOT", T_DOT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MULT", T_MULT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DIV", T_DIV, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MOD", T_MOD, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BOOL_NOT", T_BOOL_NOT, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_INSTANCEOF", T_INSTANCEOF, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_UNSET_CAST", T_UNSET_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_BOOL_CAST", T_BOOL_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_OBJECT_CAST", T_OBJECT_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ARRAY_CAST", T_ARRAY_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_STRING_CAST", T_STRING_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DOUBLE_CAST", T_DOUBLE_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_INT_CAST", T_INT_CAST, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DEC", T_DEC, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BW_NOT", T_BW_NOT, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_INC", T_INC, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CLONE", T_CLONE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DEC", T_DEC, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INT_CAST", T_INT_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_NUMERIC_CAST", T_NUMERIC_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SCALAR_CAST", T_SCALAR_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DOUBLE_CAST", T_DOUBLE_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_STRING_CAST", T_STRING_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ARRAY_CAST", T_ARRAY_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_OBJECT_CAST", T_OBJECT_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BOOL_CAST", T_BOOL_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_UNSET_CAST", T_UNSET_CAST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_AT", T_AT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_RBRACKET", T_RBRACKET, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_NEW", T_NEW, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_CLONE", T_CLONE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_EXIT", T_EXIT, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_IF", T_IF, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_ELSEIF", T_ELSEIF, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_ELSE", T_ELSE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_ENDIF", T_ENDIF, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_LNUMBER", T_LNUMBER, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DNUMBER", T_DNUMBER, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_STATIC", T_STATIC, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ABSTRACT", T_ABSTRACT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_FINAL", T_FINAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_PRIVATE", T_PRIVATE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_PROTECTED", T_PROTECTED, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_PUBLIC", T_PUBLIC, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_OPEN_TAG", T_OPEN_TAG, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_OPEN_TAG_WITH_ECHO", T_OPEN_TAG_WITH_ECHO, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_WHITESPACE", T_WHITESPACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_COMMENT", T_COMMENT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_CLOSE_TAG", T_CLOSE_TAG, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DOC_COMMENT", T_DOC_COMMENT, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_STRING", T_STRING, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_STRING_VARNAME", T_STRING_VARNAME, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_VARIABLE", T_VARIABLE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_NUM_STRING", T_NUM_STRING, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_INLINE_HTML", T_INLINE_HTML, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CHARACTER", T_CHARACTER, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_BAD_CHARACTER", T_BAD_CHARACTER, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ENCAPSED_AND_WHITESPACE", T_ENCAPSED_AND_WHITESPACE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CONSTANT_ENCAPSED_STRING", T_CONSTANT_ENCAPSED_STRING, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ECHO", T_ECHO, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DO", T_DO, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_WHILE", T_WHILE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ENDWHILE", T_ENDWHILE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_FOR", T_FOR, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ENDFOR", T_ENDFOR, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_FOREACH", T_FOREACH, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ENDFOREACH", T_ENDFOREACH, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DECLARE", T_DECLARE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ENDDECLARE", T_ENDDECLARE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_NS_SEPARATOR", T_NS_SEPARATOR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_NAMESPACE", T_NAMESPACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_LBRACE", T_LBRACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_HALT_COMPILER", T_HALT_COMPILER, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_LPAREN", T_LPAREN, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_RPAREN", T_RPAREN, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SEMICOLON", T_SEMICOLON, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_RBRACE", T_RBRACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_USE", T_USE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_AS", T_AS, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_SWITCH", T_SWITCH, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_CONST", T_CONST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ENDWHILE", T_ENDWHILE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_WHILE", T_WHILE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DO", T_DO, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ENDFOR", T_ENDFOR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_FOR", T_FOR, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_ENDSWITCH", T_ENDSWITCH, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CASE", T_CASE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_DEFAULT", T_DEFAULT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SWITCH", T_SWITCH, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ENDDECLARE", T_ENDDECLARE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DECLARE", T_DECLARE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DOUBLE_ARROW", T_DOUBLE_ARROW, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ENDFOREACH", T_ENDFOREACH, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_FOREACH", T_FOREACH, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_CATCH", T_CATCH, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_VARIABLE", T_VARIABLE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_TRY", T_TRY, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_GLOBAL", T_GLOBAL, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ECHO", T_ECHO, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_UNSET", T_UNSET, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_BREAK", T_BREAK, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CONTINUE", T_CONTINUE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_GOTO", T_GOTO, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_FUNCTION", T_FUNCTION, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CONST", T_CONST, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_RETURN", T_RETURN, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_TRY", T_TRY, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CATCH", T_CATCH, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INLINE_HTML", T_INLINE_HTML, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_THROW", T_THROW, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_USE", T_USE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_GLOBAL", T_GLOBAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_PUBLIC", T_PUBLIC, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_PROTECTED", T_PROTECTED, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_PRIVATE", T_PRIVATE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_FINAL", T_FINAL, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ABSTRACT", T_ABSTRACT, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_STATIC", T_STATIC, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_VAR", T_VAR, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_UNSET", T_UNSET, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_ISSET", T_ISSET, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_EMPTY", T_EMPTY, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_HALT_COMPILER", T_HALT_COMPILER, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_GOTO", T_GOTO, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CLASS", T_CLASS, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_INTERFACE", T_INTERFACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_TRAIT", T_TRAIT, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_EXTENDS", T_EXTENDS, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INTERFACE", T_INTERFACE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_IMPLEMENTS", T_IMPLEMENTS, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_OBJECT_OPERATOR", T_OBJECT_OPERATOR, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DOUBLE_ARROW", T_DOUBLE_ARROW, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_LIST", T_LIST, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_ARRAY", T_ARRAY, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BOOL_HINT", T_BOOL_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_STRING_HINT", T_STRING_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INT_HINT", T_INT_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DOUBLE_HINT", T_DOUBLE_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_RESOURCE_HINT", T_RESOURCE_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_OBJECT_HINT", T_OBJECT_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_SCALAR_HINT", T_SCALAR_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_NUMERIC_HINT", T_NUMERIC_HINT, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DOLLAR", T_DOLLAR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INSTEADOF", T_INSTEADOF, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_PAAMAYIM_NEKUDOTAYIM", T_PAAMAYIM_NEKUDOTAYIM, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_VAR", T_VAR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_LIST", T_LIST, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_BACKQUOTE", T_BACKQUOTE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_FUNCTION", T_FUNCTION, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_OBJECT_OPERATOR", T_OBJECT_OPERATOR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ENCAPSED_AND_WHITESPACE", T_ENCAPSED_AND_WHITESPACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_LNUMBER", T_LNUMBER, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DNUMBER", T_DNUMBER, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_CONSTANT_ENCAPSED_STRING", T_CONSTANT_ENCAPSED_STRING, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_LINE", T_LINE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_FILE", T_FILE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_DIR", T_DIR, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CLASS_C", T_CLASS_C, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_METHOD_C", T_METHOD_C, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_FUNC_C", T_FUNC_C, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_LINE", T_LINE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_FILE", T_FILE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_COMMENT", T_COMMENT, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DOC_COMMENT", T_DOC_COMMENT, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_OPEN_TAG", T_OPEN_TAG, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_OPEN_TAG_WITH_ECHO", T_OPEN_TAG_WITH_ECHO, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_CLOSE_TAG", T_CLOSE_TAG, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_WHITESPACE", T_WHITESPACE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_NS_C", T_NS_C, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_START_HEREDOC", T_START_HEREDOC, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_END_HEREDOC", T_END_HEREDOC, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_STRING_VARNAME", T_STRING_VARNAME, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_QUOTE", T_QUOTE, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_LBRACKET", T_LBRACKET, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_DOLLAR_OPEN_CURLY_BRACES", T_DOLLAR_OPEN_CURLY_BRACES, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CURLY_OPEN", T_CURLY_OPEN, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_PAAMAYIM_NEKUDOTAYIM", T_PAAMAYIM_NEKUDOTAYIM, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_NAMESPACE", T_NAMESPACE, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_NS_C", T_NS_C, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_DIR", T_DIR, CONST_CS | CONST_PERSISTENT);
-	REGISTER_LONG_CONSTANT("T_NS_SEPARATOR", T_NS_SEPARATOR, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_NUM_STRING", T_NUM_STRING, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_ISSET", T_ISSET, CONST_CS | CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_EMPTY", T_EMPTY, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_DOUBLE_COLON", T_PAAMAYIM_NEKUDOTAYIM, CONST_CS | CONST_PERSISTENT);
 }
 
@@ -159,129 +197,167 @@ char *get_token_type_name(int token_type)
 {
 	switch (token_type) {
 
-		case T_REQUIRE_ONCE: return "T_REQUIRE_ONCE";
-		case T_REQUIRE: return "T_REQUIRE";
-		case T_EVAL: return "T_EVAL";
-		case T_INCLUDE_ONCE: return "T_INCLUDE_ONCE";
 		case T_INCLUDE: return "T_INCLUDE";
+		case T_INCLUDE_ONCE: return "T_INCLUDE_ONCE";
+		case T_EVAL: return "T_EVAL";
+		case T_REQUIRE: return "T_REQUIRE";
+		case T_REQUIRE_ONCE: return "T_REQUIRE_ONCE";
+		case T_COMMA: return "T_COMMA";
 		case T_LOGICAL_OR: return "T_LOGICAL_OR";
 		case T_LOGICAL_XOR: return "T_LOGICAL_XOR";
 		case T_LOGICAL_AND: return "T_LOGICAL_AND";
 		case T_PRINT: return "T_PRINT";
-		case T_SR_EQUAL: return "T_SR_EQUAL";
-		case T_SL_EQUAL: return "T_SL_EQUAL";
-		case T_XOR_EQUAL: return "T_XOR_EQUAL";
-		case T_OR_EQUAL: return "T_OR_EQUAL";
-		case T_AND_EQUAL: return "T_AND_EQUAL";
-		case T_MOD_EQUAL: return "T_MOD_EQUAL";
-		case T_CONCAT_EQUAL: return "T_CONCAT_EQUAL";
-		case T_DIV_EQUAL: return "T_DIV_EQUAL";
-		case T_MUL_EQUAL: return "T_MUL_EQUAL";
-		case T_MINUS_EQUAL: return "T_MINUS_EQUAL";
+		case T_EQUAL: return "T_EQUAL";
 		case T_PLUS_EQUAL: return "T_PLUS_EQUAL";
+		case T_MINUS_EQUAL: return "T_MINUS_EQUAL";
+		case T_MUL_EQUAL: return "T_MUL_EQUAL";
+		case T_DIV_EQUAL: return "T_DIV_EQUAL";
+		case T_CONCAT_EQUAL: return "T_CONCAT_EQUAL";
+		case T_MOD_EQUAL: return "T_MOD_EQUAL";
+		case T_AND_EQUAL: return "T_AND_EQUAL";
+		case T_OR_EQUAL: return "T_OR_EQUAL";
+		case T_XOR_EQUAL: return "T_XOR_EQUAL";
+		case T_SL_EQUAL: return "T_SL_EQUAL";
+		case T_SR_EQUAL: return "T_SR_EQUAL";
+		case T_QUESTION_MARK: return "T_QUESTION_MARK";
+		case T_COLON: return "T_COLON";
 		case T_BOOLEAN_OR: return "T_BOOLEAN_OR";
 		case T_BOOLEAN_AND: return "T_BOOLEAN_AND";
-		case T_IS_NOT_IDENTICAL: return "T_IS_NOT_IDENTICAL";
-		case T_IS_IDENTICAL: return "T_IS_IDENTICAL";
-		case T_IS_NOT_EQUAL: return "T_IS_NOT_EQUAL";
+		case T_BW_OR: return "T_BW_OR";
+		case T_BW_XOR: return "T_BW_XOR";
+		case T_BW_AND: return "T_BW_AND";
 		case T_IS_EQUAL: return "T_IS_EQUAL";
-		case T_IS_GREATER_OR_EQUAL: return "T_IS_GREATER_OR_EQUAL";
+		case T_IS_NOT_EQUAL: return "T_IS_NOT_EQUAL";
+		case T_IS_IDENTICAL: return "T_IS_IDENTICAL";
+		case T_IS_NOT_IDENTICAL: return "T_IS_NOT_IDENTICAL";
+		case T_IS_SMALLER: return "T_IS_SMALLER";
 		case T_IS_SMALLER_OR_EQUAL: return "T_IS_SMALLER_OR_EQUAL";
-		case T_SR: return "T_SR";
+		case T_IS_GREATER: return "T_IS_GREATER";
+		case T_IS_GREATER_OR_EQUAL: return "T_IS_GREATER_OR_EQUAL";
 		case T_SL: return "T_SL";
+		case T_SR: return "T_SR";
+		case T_PLUS: return "T_PLUS";
+		case T_MINUS: return "T_MINUS";
+		case T_DOT: return "T_DOT";
+		case T_MULT: return "T_MULT";
+		case T_DIV: return "T_DIV";
+		case T_MOD: return "T_MOD";
+		case T_BOOL_NOT: return "T_BOOL_NOT";
 		case T_INSTANCEOF: return "T_INSTANCEOF";
-		case T_UNSET_CAST: return "T_UNSET_CAST";
-		case T_BOOL_CAST: return "T_BOOL_CAST";
-		case T_OBJECT_CAST: return "T_OBJECT_CAST";
-		case T_ARRAY_CAST: return "T_ARRAY_CAST";
-		case T_STRING_CAST: return "T_STRING_CAST";
-		case T_DOUBLE_CAST: return "T_DOUBLE_CAST";
-		case T_INT_CAST: return "T_INT_CAST";
-		case T_DEC: return "T_DEC";
+		case T_BW_NOT: return "T_BW_NOT";
 		case T_INC: return "T_INC";
-		case T_CLONE: return "T_CLONE";
+		case T_DEC: return "T_DEC";
+		case T_INT_CAST: return "T_INT_CAST";
+		case T_NUMERIC_CAST: return "T_NUMERIC_CAST";
+		case T_SCALAR_CAST: return "T_SCALAR_CAST";
+		case T_DOUBLE_CAST: return "T_DOUBLE_CAST";
+		case T_STRING_CAST: return "T_STRING_CAST";
+		case T_ARRAY_CAST: return "T_ARRAY_CAST";
+		case T_OBJECT_CAST: return "T_OBJECT_CAST";
+		case T_BOOL_CAST: return "T_BOOL_CAST";
+		case T_UNSET_CAST: return "T_UNSET_CAST";
+		case T_AT: return "T_AT";
+		case T_RBRACKET: return "T_RBRACKET";
 		case T_NEW: return "T_NEW";
+		case T_CLONE: return "T_CLONE";
 		case T_EXIT: return "T_EXIT";
 		case T_IF: return "T_IF";
 		case T_ELSEIF: return "T_ELSEIF";
 		case T_ELSE: return "T_ELSE";
 		case T_ENDIF: return "T_ENDIF";
-		case T_LNUMBER: return "T_LNUMBER";
-		case T_DNUMBER: return "T_DNUMBER";
+		case T_STATIC: return "T_STATIC";
+		case T_ABSTRACT: return "T_ABSTRACT";
+		case T_FINAL: return "T_FINAL";
+		case T_PRIVATE: return "T_PRIVATE";
+		case T_PROTECTED: return "T_PROTECTED";
+		case T_PUBLIC: return "T_PUBLIC";
+		case T_OPEN_TAG: return "T_OPEN_TAG";
+		case T_OPEN_TAG_WITH_ECHO: return "T_OPEN_TAG_WITH_ECHO";
+		case T_WHITESPACE: return "T_WHITESPACE";
+		case T_COMMENT: return "T_COMMENT";
+		case T_CLOSE_TAG: return "T_CLOSE_TAG";
+		case T_DOC_COMMENT: return "T_DOC_COMMENT";
 		case T_STRING: return "T_STRING";
-		case T_STRING_VARNAME: return "T_STRING_VARNAME";
-		case T_VARIABLE: return "T_VARIABLE";
-		case T_NUM_STRING: return "T_NUM_STRING";
-		case T_INLINE_HTML: return "T_INLINE_HTML";
-		case T_CHARACTER: return "T_CHARACTER";
-		case T_BAD_CHARACTER: return "T_BAD_CHARACTER";
-		case T_ENCAPSED_AND_WHITESPACE: return "T_ENCAPSED_AND_WHITESPACE";
-		case T_CONSTANT_ENCAPSED_STRING: return "T_CONSTANT_ENCAPSED_STRING";
-		case T_ECHO: return "T_ECHO";
-		case T_DO: return "T_DO";
-		case T_WHILE: return "T_WHILE";
-		case T_ENDWHILE: return "T_ENDWHILE";
-		case T_FOR: return "T_FOR";
-		case T_ENDFOR: return "T_ENDFOR";
-		case T_FOREACH: return "T_FOREACH";
-		case T_ENDFOREACH: return "T_ENDFOREACH";
-		case T_DECLARE: return "T_DECLARE";
-		case T_ENDDECLARE: return "T_ENDDECLARE";
+		case T_NS_SEPARATOR: return "T_NS_SEPARATOR";
+		case T_NAMESPACE: return "T_NAMESPACE";
+		case T_LBRACE: return "T_LBRACE";
+		case T_HALT_COMPILER: return "T_HALT_COMPILER";
+		case T_LPAREN: return "T_LPAREN";
+		case T_RPAREN: return "T_RPAREN";
+		case T_SEMICOLON: return "T_SEMICOLON";
+		case T_RBRACE: return "T_RBRACE";
+		case T_USE: return "T_USE";
 		case T_AS: return "T_AS";
-		case T_SWITCH: return "T_SWITCH";
+		case T_CONST: return "T_CONST";
+		case T_ENDWHILE: return "T_ENDWHILE";
+		case T_WHILE: return "T_WHILE";
+		case T_DO: return "T_DO";
+		case T_ENDFOR: return "T_ENDFOR";
+		case T_FOR: return "T_FOR";
 		case T_ENDSWITCH: return "T_ENDSWITCH";
 		case T_CASE: return "T_CASE";
 		case T_DEFAULT: return "T_DEFAULT";
+		case T_SWITCH: return "T_SWITCH";
+		case T_ENDDECLARE: return "T_ENDDECLARE";
+		case T_DECLARE: return "T_DECLARE";
+		case T_DOUBLE_ARROW: return "T_DOUBLE_ARROW";
+		case T_ENDFOREACH: return "T_ENDFOREACH";
+		case T_FOREACH: return "T_FOREACH";
+		case T_CATCH: return "T_CATCH";
+		case T_VARIABLE: return "T_VARIABLE";
+		case T_TRY: return "T_TRY";
+		case T_GLOBAL: return "T_GLOBAL";
+		case T_ECHO: return "T_ECHO";
+		case T_UNSET: return "T_UNSET";
 		case T_BREAK: return "T_BREAK";
 		case T_CONTINUE: return "T_CONTINUE";
-		case T_GOTO: return "T_GOTO";
-		case T_FUNCTION: return "T_FUNCTION";
-		case T_CONST: return "T_CONST";
 		case T_RETURN: return "T_RETURN";
-		case T_TRY: return "T_TRY";
-		case T_CATCH: return "T_CATCH";
+		case T_INLINE_HTML: return "T_INLINE_HTML";
 		case T_THROW: return "T_THROW";
-		case T_USE: return "T_USE";
-		case T_GLOBAL: return "T_GLOBAL";
-		case T_PUBLIC: return "T_PUBLIC";
-		case T_PROTECTED: return "T_PROTECTED";
-		case T_PRIVATE: return "T_PRIVATE";
-		case T_FINAL: return "T_FINAL";
-		case T_ABSTRACT: return "T_ABSTRACT";
-		case T_STATIC: return "T_STATIC";
-		case T_VAR: return "T_VAR";
-		case T_UNSET: return "T_UNSET";
-		case T_ISSET: return "T_ISSET";
-		case T_EMPTY: return "T_EMPTY";
-		case T_HALT_COMPILER: return "T_HALT_COMPILER";
+		case T_GOTO: return "T_GOTO";
 		case T_CLASS: return "T_CLASS";
-		case T_INTERFACE: return "T_INTERFACE";
+		case T_TRAIT: return "T_TRAIT";
 		case T_EXTENDS: return "T_EXTENDS";
+		case T_INTERFACE: return "T_INTERFACE";
 		case T_IMPLEMENTS: return "T_IMPLEMENTS";
-		case T_OBJECT_OPERATOR: return "T_OBJECT_OPERATOR";
-		case T_DOUBLE_ARROW: return "T_DOUBLE_ARROW";
-		case T_LIST: return "T_LIST";
 		case T_ARRAY: return "T_ARRAY";
+		case T_BOOL_HINT: return "T_BOOL_HINT";
+		case T_STRING_HINT: return "T_STRING_HINT";
+		case T_INT_HINT: return "T_INT_HINT";
+		case T_DOUBLE_HINT: return "T_DOUBLE_HINT";
+		case T_RESOURCE_HINT: return "T_RESOURCE_HINT";
+		case T_OBJECT_HINT: return "T_OBJECT_HINT";
+		case T_SCALAR_HINT: return "T_SCALAR_HINT";
+		case T_NUMERIC_HINT: return "T_NUMERIC_HINT";
+		case T_DOLLAR: return "T_DOLLAR";
+		case T_INSTEADOF: return "T_INSTEADOF";
+		case T_PAAMAYIM_NEKUDOTAYIM: return "T_DOUBLE_COLON";
+		case T_VAR: return "T_VAR";
+		case T_LIST: return "T_LIST";
+		case T_BACKQUOTE: return "T_BACKQUOTE";
+		case T_FUNCTION: return "T_FUNCTION";
+		case T_OBJECT_OPERATOR: return "T_OBJECT_OPERATOR";
+		case T_ENCAPSED_AND_WHITESPACE: return "T_ENCAPSED_AND_WHITESPACE";
+		case T_LNUMBER: return "T_LNUMBER";
+		case T_DNUMBER: return "T_DNUMBER";
+		case T_CONSTANT_ENCAPSED_STRING: return "T_CONSTANT_ENCAPSED_STRING";
+		case T_LINE: return "T_LINE";
+		case T_FILE: return "T_FILE";
+		case T_DIR: return "T_DIR";
 		case T_CLASS_C: return "T_CLASS_C";
 		case T_METHOD_C: return "T_METHOD_C";
 		case T_FUNC_C: return "T_FUNC_C";
-		case T_LINE: return "T_LINE";
-		case T_FILE: return "T_FILE";
-		case T_COMMENT: return "T_COMMENT";
-		case T_DOC_COMMENT: return "T_DOC_COMMENT";
-		case T_OPEN_TAG: return "T_OPEN_TAG";
-		case T_OPEN_TAG_WITH_ECHO: return "T_OPEN_TAG_WITH_ECHO";
-		case T_CLOSE_TAG: return "T_CLOSE_TAG";
-		case T_WHITESPACE: return "T_WHITESPACE";
+		case T_NS_C: return "T_NS_C";
 		case T_START_HEREDOC: return "T_START_HEREDOC";
 		case T_END_HEREDOC: return "T_END_HEREDOC";
+		case T_STRING_VARNAME: return "T_STRING_VARNAME";
+		case T_QUOTE: return "T_QUOTE";
+		case T_LBRACKET: return "T_LBRACKET";
 		case T_DOLLAR_OPEN_CURLY_BRACES: return "T_DOLLAR_OPEN_CURLY_BRACES";
 		case T_CURLY_OPEN: return "T_CURLY_OPEN";
-		case T_PAAMAYIM_NEKUDOTAYIM: return "T_DOUBLE_COLON";
-		case T_NAMESPACE: return "T_NAMESPACE";
-		case T_NS_C: return "T_NS_C";
-		case T_DIR: return "T_DIR";
-		case T_NS_SEPARATOR: return "T_NS_SEPARATOR";
+		case T_NUM_STRING: return "T_NUM_STRING";
+		case T_ISSET: return "T_ISSET";
+		case T_EMPTY: return "T_EMPTY";
 
 	}
 	return "UNKNOWN";

lempar.c

@@ -0,0 +1,843 @@
+/* Driver template for the LEMON parser generator.
+** The author disclaims copyright to this source code.
+*/
+/* First off, code is included that follows the "include" declaration
+** in the input grammar file. */
+#include <stdio.h>
+%%
+/* Next is all token values, in a form suitable for use by makeheaders.
+** This section will be null unless lemon is run with the -m switch.
+*/
+/* 
+** These constants (all generated automatically by the parser generator)
+** specify the various kinds of tokens (terminals) that the parser
+** understands. 
+**
+** Each symbol here is a terminal symbol in the grammar.
+*/
+%%
+/* Make sure the INTERFACE macro is defined.
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/* The next thing included is series of defines which control
+** various aspects of the generated parser.
+**    YYCODETYPE         is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 terminals
+**                       and nonterminals.  "int" is used otherwise.
+**    YYNOCODE           is a number of type YYCODETYPE which corresponds
+**                       to no legal terminal or nonterminal number.  This
+**                       number is used to fill in empty slots of the hash 
+**                       table.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       have fall-back values which should be used if the
+**                       original value of the token will not parse.
+**    YYACTIONTYPE       is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 rules and
+**                       states combined.  "int" is used otherwise.
+**    ParseTOKENTYPE     is the data type used for minor tokens given 
+**                       directly to the parser from the tokenizer.
+**    YYMINORTYPE        is the data type used for all minor tokens.
+**                       This is typically a union of many types, one of
+**                       which is ParseTOKENTYPE.  The entry in the union
+**                       for base tokens is called "yy0".
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    ParseARG_SDECL     A static variable declaration for the %extra_argument
+**    ParseARG_PDECL     A parameter declaration for the %extra_argument
+**    ParseARG_STORE     Code to store %extra_argument into yypParser
+**    ParseARG_FETCH     Code to extract %extra_argument from yypParser
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+*/
+%%
+#define YY_NO_ACTION      (YYNSTATE+YYNRULE+2)
+#define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)
+#define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)
+
+/* The yyzerominor constant is used to initialize instances of
+** YYMINORTYPE objects to zero. */
+static const YYMINORTYPE yyzerominor = { 0 };
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage.  For production
+** code the yytestcase() macro should be turned off.  But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+# define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.  
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N < YYNSTATE                  Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   YYNSTATE <= N < YYNSTATE+YYNRULE   Reduce by rule N-YYNSTATE.
+**
+**   N == YYNSTATE+YYNRULE              A syntax error has occurred.
+**
+**   N == YYNSTATE+YYNRULE+1            The parser accepts its input.
+**
+**   N == YYNSTATE+YYNRULE+2            No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as
+**
+**      yy_action[ yy_shift_ofst[S] + X ]
+**
+** If the index value yy_shift_ofst[S]+X is out of range or if the value
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
+** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
+** and that yy_default[S] should be used instead.  
+**
+** The formula above is for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  yy_default[]       Default action for each state.
+*/
+%%
+#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0]))
+
+/* The next table maps tokens into fallback tokens.  If a construct
+** like the following:
+** 
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+%%
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+*/
+struct yyStackEntry {
+  YYACTIONTYPE stateno;  /* The state-number */
+  YYCODETYPE major;      /* The major token value.  This is the code
+                         ** number for the token at this stack level */
+  YYMINORTYPE minor;     /* The user-supplied minor token value.  This
+                         ** is the value of the token  */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+  int yyidx;                    /* Index of top element in stack */
+#ifdef YYTRACKMAXSTACKDEPTH
+  int yyidxMax;                 /* Maximum value of yyidx */
+#endif
+  int yyerrcnt;                 /* Shifts left before out of the error */
+  ParseARG_SDECL                /* A place to hold %extra_argument */
+#if YYSTACKDEPTH<=0
+  int yystksz;                  /* Current side of the stack */
+  yyStackEntry *yystack;        /* The parser's stack */
+#else
+  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* 
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL 
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output.  If NULL, then tracing is
+**      turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt){
+  yyTraceFILE = TraceFILE;
+  yyTracePrompt = zTracePrompt;
+  if( yyTraceFILE==0 ) yyTracePrompt = 0;
+  else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+static const char *const yyTokenName[] = { 
+%%
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+%%
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.
+*/
+static void yyGrowStack(yyParser *p){
+  int newSize;
+  yyStackEntry *pNew;
+
+  newSize = p->yystksz*2 + 100;
+  pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+  if( pNew ){
+    p->yystack = pNew;
+    p->yystksz = newSize;
+#ifndef NDEBUG
+    if( yyTraceFILE ){
+      fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
+              yyTracePrompt, p->yystksz);
+    }
+#endif
+  }
+}
+#endif
+
+/* 
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser.  This pointer is used in subsequent calls
+** to Parse and ParseFree.
+*/
+void *ParseAlloc(void *(*mallocProc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)){
+  yyParser *pParser;
+  pParser = (yyParser*)(*mallocProc)( ((size_t)sizeof(yyParser)) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
+  if( pParser ){
+    pParser->yyidx = -1;
+#ifdef YYTRACKMAXSTACKDEPTH
+    pParser->yyidxMax = 0;
+#endif
+#if YYSTACKDEPTH<=0
+    pParser->yystack = NULL;
+    pParser->yystksz = 0;
+    yyGrowStack(pParser);
+#endif
+  }
+  return pParser;
+}
+
+/* The following function deletes the value associated with a
+** symbol.  The symbol can be either a terminal or nonterminal.
+** "yymajor" is the symbol code, and "yypminor" is a pointer to
+** the value.
+*/
+static zend_always_inline void yy_destructor(
+  yyParser *yypParser,    /* The parser */
+  YYCODETYPE yymajor,     /* Type code for object to destroy */
+  YYMINORTYPE *yypminor   /* The object to be destroyed */
+){
+  ParseARG_FETCH;
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+  switch( yymajor ){
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is 
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are not used
+    ** inside the C code.
+    */
+%%
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+**
+** Return the major token number for the symbol popped.
+*/
+static zend_always_inline int yy_pop_parser_stack(yyParser *pParser){
+  YYCODETYPE yymajor;
+  yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
+
+  if( pParser->yyidx<0 ) return 0;
+#ifndef NDEBUG
+  if( yyTraceFILE && pParser->yyidx>=0 ){
+    fprintf(yyTraceFILE,"%sPopping %s\n",
+      yyTracePrompt,
+      yyTokenName[yytos->major]);
+  }
+#endif
+  yymajor = yytos->major;
+  yy_destructor(pParser, yymajor, &yytos->minor);
+  pParser->yyidx--;
+  return yymajor;
+}
+
+/* 
+** Deallocate and destroy a parser.  Destructors are all called for
+** all stack elements before shutting the parser down.
+**
+** Inputs:
+** <ul>
+** <li>  A pointer to the parser.  This should be a pointer
+**       obtained from ParseAlloc.
+** <li>  A pointer to a function used to reclaim memory obtained
+**       from malloc.
+** </ul>
+*/
+void ParseFree(
+  void *p,                    /* The parser to be deleted */
+  void (*freeProc)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)     /* Function used to reclaim memory */
+){
+  yyParser *pParser = (yyParser*)p;
+  if( pParser==0 ) return;
+  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+  free(pParser->yystack);
+#endif
+  (*freeProc)((void*)pParser ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int ParseStackPeak(void *p){
+  yyParser *pParser = (yyParser*)p;
+  return pParser->yyidxMax;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static zend_always_inline int yy_find_shift_action(
+  yyParser *pParser,        /* The parser */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+  int stateno = pParser->yystack[pParser->yyidx].stateno;
+ 
+  if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
+    return yy_default[stateno];
+  }
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+  if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
+    if( iLookAhead>0 ){
+#ifdef YYFALLBACK
+      YYCODETYPE iFallback;            /* Fallback token */
+      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+             && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+        }
+#endif
+        return yy_find_shift_action(pParser, iFallback);
+      }
+#endif
+#ifdef YYWILDCARD
+      {
+        int j = i - iLookAhead + YYWILDCARD;
+        if( j>=0 && j<YY_SZ_ACTTAB && yy_lookahead[j]==YYWILDCARD ){
+#ifndef NDEBUG
+          if( yyTraceFILE ){
+            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+               yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
+          }
+#endif /* NDEBUG */
+          return yy_action[j];
+        }
+      }
+#endif /* YYWILDCARD */
+    }
+    return yy_default[stateno];
+  }else{
+    return yy_action[i];
+  }
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static zend_always_inline int yy_find_reduce_action(
+  int stateno,              /* Current state number */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+#ifdef YYERRORSYMBOL
+  if( stateno>YY_REDUCE_MAX ){
+    return yy_default[stateno];
+  }
+#else
+  assert( stateno<=YY_REDUCE_MAX );
+#endif
+  i = yy_reduce_ofst[stateno];
+  assert( i!=YY_REDUCE_USE_DFLT );
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+#ifdef YYERRORSYMBOL
+  if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){
+    return yy_default[stateno];
+  }
+#else
+  assert( i>=0 && i<YY_SZ_ACTTAB );
+  assert( yy_lookahead[i]==iLookAhead );
+#endif
+  return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
+   ParseARG_FETCH;
+   yypParser->yyidx--;
+#ifndef NDEBUG
+   if( yyTraceFILE ){
+     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+   }
+#endif
+   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+   /* Here code is inserted which will execute if the parser
+   ** stack every overflows */
+%%
+   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Perform a shift action.
+*/
+static zend_always_inline void yy_shift(
+  yyParser *yypParser,          /* The parser to be shifted */
+  int yyNewState,               /* The new state to shift in */
+  int yyMajor,                  /* The major token to shift in */
+  YYMINORTYPE *yypMinor         /* Pointer to the minor token to shift in */
+){
+  yyStackEntry *yytos;
+  yypParser->yyidx++;
+#ifdef YYTRACKMAXSTACKDEPTH
+  if( yypParser->yyidx>yypParser->yyidxMax ){
+    yypParser->yyidxMax = yypParser->yyidx;
+  }
+#endif
+#if YYSTACKDEPTH>0 
+  if( yypParser->yyidx>=YYSTACKDEPTH ){
+    yyStackOverflow(yypParser, yypMinor);
+    return;
+  }
+#else
+  if( yypParser->yyidx>=yypParser->yystksz ){
+    yyGrowStack(yypParser);
+    if( yypParser->yyidx>=yypParser->yystksz ){
+      yyStackOverflow(yypParser, yypMinor);
+      return;
+    }
+  }
+#endif
+  yytos = &yypParser->yystack[yypParser->yyidx];
+  yytos->stateno = (YYACTIONTYPE)yyNewState;
+  yytos->major = (YYCODETYPE)yyMajor;
+  yytos->minor = *yypMinor;
+#ifndef NDEBUG
+  if( yyTraceFILE && yypParser->yyidx>0 ){
+    int i;
+    fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
+    fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
+    for(i=1; i<=yypParser->yyidx; i++)
+      fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
+    fprintf(yyTraceFILE,"\n");
+  }
+#endif
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+  YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
+  unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
+} yyRuleInfo[] = {
+%%
+};
+
+static zend_always_inline void yy_accept(yyParser*);  /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static zend_always_inline void yy_reduce(
+  yyParser *yypParser,         /* The parser */
+  int yyruleno                 /* Number of the rule by which to reduce */
+){
+  int yygoto;                     /* The next state */
+  int yyact;                      /* The next action */
+  YYMINORTYPE yygotominor;        /* The LHS of the rule reduced */
+  yyStackEntry *yymsp;            /* The top of the parser's stack */
+  int yysize;                     /* Amount to pop the stack */
+  ParseARG_FETCH;
+  yymsp = &yypParser->yystack[yypParser->yyidx];
+#ifndef NDEBUG
+  if( yyTraceFILE && yyruleno>=0 
+        && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+    fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
+      yyRuleName[yyruleno]);
+  }
+#endif /* NDEBUG */
+
+  /* Silence complaints from purify about yygotominor being uninitialized
+  ** in some cases when it is copied into the stack after the following
+  ** switch.  yygotominor is uninitialized when a rule reduces that does
+  ** not set the value of its left-hand side nonterminal.  Leaving the
+  ** value of the nonterminal uninitialized is utterly harmless as long
+  ** as the value is never used.  So really the only thing this code
+  ** accomplishes is to quieten purify.  
+  **
+  ** 2007-01-16:  The wireshark project (www.wireshark.org) reports that
+  ** without this code, their parser segfaults.  I'm not sure what there
+  ** parser is doing to make this happen.  This is the second bug report
+  ** from wireshark this week.  Clearly they are stressing Lemon in ways
+  ** that it has not been previously stressed...  (SQLite ticket #2172)
+  */
+  /*memset(&yygotominor, 0, sizeof(yygotominor));*/
+  yygotominor = yyzerominor;
+
+
+  switch( yyruleno ){
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+%%
+  };
+  yygoto = yyRuleInfo[yyruleno].lhs;
+  yysize = yyRuleInfo[yyruleno].nrhs;
+  yypParser->yyidx -= yysize;
+  yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
+  if( yyact < YYNSTATE ){
+#ifdef NDEBUG
+    /* If we are not debugging and the reduce action popped at least
+    ** one element off the stack, then we can push the new element back
+    ** onto the stack here, and skip the stack overflow test in yy_shift().
+    ** That gives a significant speed improvement. */
+    if( yysize ){
+      yypParser->yyidx++;
+      yymsp -= yysize-1;
+      yymsp->stateno = (YYACTIONTYPE)yyact;
+      yymsp->major = (YYCODETYPE)yygoto;
+      yymsp->minor = yygotominor;
+    }else
+#endif
+    {
+      yy_shift(yypParser,yyact,yygoto,&yygotominor);
+    }
+  }else{
+    assert( yyact == YYNSTATE + YYNRULE + 1 );
+    yy_accept(yypParser);
+  }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+#ifndef YYNOERRORRECOVERY
+static void yy_parse_failed(
+  yyParser *yypParser           /* The parser */
+){
+  ParseARG_FETCH;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser fails */
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+#endif /* YYNOERRORRECOVERY */
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static zend_always_inline void yy_syntax_error(
+  yyParser *yypParser,           /* The parser */
+  int yymajor,                   /* The major type of the error token */
+  YYMINORTYPE yyminor            /* The minor type of the error token */
+){
+  ParseARG_FETCH;
+#define TOKEN (yyminor.yy0)
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static zend_always_inline void yy_accept(
+  yyParser *yypParser           /* The parser */
+){
+  ParseARG_FETCH;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser accepts */
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "ParseAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void Parse(
+  void *yyp,                   /* The parser */
+  int yymajor,                 /* The major token code number */
+  ParseTOKENTYPE yyminor       /* The value for the token */
+  ParseARG_PDECL               /* Optional %extra_argument parameter */
+){
+  YYMINORTYPE yyminorunion;
+  int yyact;            /* The parser action. */
+  int yyendofinput;     /* True if we are at the end of input */
+#ifdef YYERRORSYMBOL
+  int yyerrorhit = 0;   /* True if yymajor has invoked an error */
+#endif
+  yyParser *yypParser;  /* The parser */
+
+  /* (re)initialize the parser, if necessary */
+  yypParser = (yyParser*)yyp;
+  if( yypParser->yyidx<0 ){
+#if YYSTACKDEPTH<=0
+    if( yypParser->yystksz <=0 ){
+      /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
+      yyminorunion = yyzerominor;
+      yyStackOverflow(yypParser, &yyminorunion);
+      return;
+    }
+#endif
+    yypParser->yyidx = 0;
+    yypParser->yyerrcnt = -1;
+    yypParser->yystack[0].stateno = 0;
+    yypParser->yystack[0].major = 0;
+  }
+  yyminorunion.yy0 = yyminor;
+  yyendofinput = (yymajor==0);
+  ParseARG_STORE;
+
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
+  }
+#endif
+
+  do{
+    yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
+    if( yyact<YYNSTATE ){
+      assert( !yyendofinput );  /* Impossible to shift the $ token */
+      yy_shift(yypParser,yyact,yymajor,&yyminorunion);
+      yypParser->yyerrcnt--;
+      yymajor = YYNOCODE;
+    }else if( yyact < YYNSTATE + YYNRULE ){
+      yy_reduce(yypParser,yyact-YYNSTATE);
+    }else{
+      assert( yyact == YY_ERROR_ACTION );
+#ifdef YYERRORSYMBOL
+      int yymx;
+#endif
+#ifndef NDEBUG
+      if( yyTraceFILE ){
+        fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
+      }
+#endif
+#ifdef YYERRORSYMBOL
+      /* A syntax error has occurred.
+      ** The response to an error depends upon whether or not the
+      ** grammar defines an error token "ERROR".  
+      **
+      ** This is what we do if the grammar does define ERROR:
+      **
+      **  * Call the %syntax_error function.
+      **
+      **  * Begin popping the stack until we enter a state where
+      **    it is legal to shift the error symbol, then shift
+      **    the error symbol.
+      **
+      **  * Set the error count to three.
+      **
+      **  * Begin accepting and shifting new tokens.  No new error
+      **    processing will occur until three tokens have been
+      **    shifted successfully.
+      **
+      */
+      if( yypParser->yyerrcnt<0 ){
+        yy_syntax_error(yypParser,yymajor,yyminorunion);
+      }
+      yymx = yypParser->yystack[yypParser->yyidx].major;
+      if( yymx==YYERRORSYMBOL || yyerrorhit ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE,"%sDiscard input token %s\n",
+             yyTracePrompt,yyTokenName[yymajor]);
+        }
+#endif
+        yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
+        yymajor = YYNOCODE;
+      }else{
+         while(
+          yypParser->yyidx >= 0 &&
+          yymx != YYERRORSYMBOL &&
+          (yyact = yy_find_reduce_action(
+                        yypParser->yystack[yypParser->yyidx].stateno,
+                        YYERRORSYMBOL)) >= YYNSTATE
+        ){
+          yy_pop_parser_stack(yypParser);
+        }
+        if( yypParser->yyidx < 0 || yymajor==0 ){
+          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+          yy_parse_failed(yypParser);
+          yymajor = YYNOCODE;
+        }else if( yymx!=YYERRORSYMBOL ){
+          YYMINORTYPE u2;
+          u2.YYERRSYMDT = 0;
+          yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
+        }
+      }
+      yypParser->yyerrcnt = 3;
+      yyerrorhit = 1;
+#elif defined(YYNOERRORRECOVERY)
+      /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+      ** do any kind of error recovery.  Instead, simply invoke the syntax
+      ** error routine and continue going as if nothing had happened.
+      **
+      ** Applications can set this macro (for example inside %include) if
+      ** they intend to abandon the parse upon the first syntax error seen.
+      */
+      yy_syntax_error(yypParser,yymajor,yyminorunion);
+      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+      yymajor = YYNOCODE;
+      
+#else  /* YYERRORSYMBOL is not defined */
+      /* This is what we do if the grammar does not define ERROR:
+      **
+      **  * Report an error message, and throw away the input token.
+      **
+      **  * If the input token is $, then fail the parse.
+      **
+      ** As before, subsequent error messages are suppressed until
+      ** three input tokens have been successfully shifted.
+      */
+      if( yypParser->yyerrcnt<=0 ){
+        yy_syntax_error(yypParser,yymajor,yyminorunion);
+      }
+      yypParser->yyerrcnt = 3;
+      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+      if( yyendofinput ){
+        yy_parse_failed(yypParser);
+      }
+      yymajor = YYNOCODE;
+#endif
+    }
+  }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
+  return;
+}

main/main.c

@@ -507,6 +507,11 @@ static int module_initialized = 0;
 static int module_startup = 1;
 static int module_shutdown = 0;
 
+PHPAPI int php_module_initialized(void)
+{
+	return module_initialized;
+}
+
 /* {{{ php_during_module_startup */
 static int php_during_module_startup(void)
 {

main/php_main.h

@@ -27,6 +27,7 @@
 #include "SAPI.h"
 
 BEGIN_EXTERN_C()
+PHPAPI int php_module_initialized(void);
 PHPAPI int php_request_startup(TSRMLS_D);
 PHPAPI void php_request_shutdown(void *dummy);
 PHPAPI void php_request_shutdown_for_exec(void *dummy);

win32/build/Makefile

@@ -26,7 +26,9 @@ PHP_BUILD=$(PHP_BUILD)
 
 MCFILE=$(BUILD_DIR)\wsyslog.rc
 
-all: generated_files $(EXT_TARGETS) $(PECL_TARGETS) $(SAPI_TARGETS)
+all: $(BUILD_DIR)\lemon.exe generated_files $(EXT_TARGETS) $(PECL_TARGETS) $(SAPI_TARGETS)
+
+LEMON=$(BUILD_DIR)\lemon.exe
 
 build_dirs: $(BUILD_DIR) $(BUILD_DIRS_SUB)
 
@@ -45,17 +47,17 @@ $(BUILD_DIR)\$(PHPDLL).def: $(PHP_DLL_DEF_SOURCES)
 	type $(PHP_DLL_DEF_SOURCES) > $(BUILD_DIR)\$(PHPDLL).def
 
 Zend\zend_ini_parser.c Zend\zend_ini_parser.h: Zend\zend_ini_parser.y
-	$(BISON) --output=Zend/zend_ini_parser.c -v -d -p ini_ Zend/zend_ini_parser.y
+	$(LEMON) $(LEMON_FLAGS) Zend/zend_ini_parser.y
 
 Zend\zend_language_parser.c Zend\zend_language_parser.h: Zend\zend_language_parser.y
-	$(BISON) --output=Zend/zend_language_parser.c -v -d -p zend Zend/zend_language_parser.y
+	$(LEMON) $(LEMON_FLAGS) Zend/zend_language_parser.y
 
 !if $(RE2C) != ""
 Zend\zend_ini_scanner.c: Zend\zend_ini_scanner.l
-	$(RE2C) $(RE2C_FLAGS) --case-inverted -cbdFt Zend/zend_ini_scanner_defs.h -oZend/zend_ini_scanner.c Zend/zend_ini_scanner.l
+	$(RE2C) $(RE2C_FLAGS) --no-generation-date --case-inverted -cbdFt Zend/zend_ini_scanner_defs.h -oZend/zend_ini_scanner.c Zend/zend_ini_scanner.l
 
 Zend\zend_language_scanner.c: Zend\zend_language_scanner.l
-	$(RE2C) $(RE2C_FLAGS) --case-inverted -cbdFt Zend/zend_language_scanner_defs.h -oZend/zend_language_scanner.c Zend/zend_language_scanner.l
+	$(RE2C) $(RE2C_FLAGS) --no-generation-date --case-inverted -cbdFt Zend/zend_language_scanner_defs.h -oZend/zend_language_scanner.c Zend/zend_language_scanner.l
 !endif
 
 PHPDLL_RES=$(BUILD_DIR)\$(PHPDLL).res
@@ -97,12 +99,16 @@ clean-sapi:
 	@for %D in (_x $(SAPI_TARGETS)) do @if exist $(BUILD_DIR)\%D @del /F /Q $(BUILD_DIR)\%D > NUL
 	-@del /F /Q $(BUILD_DIR)\$(PHPDLL)
 
-clean: clean-sapi
+clean: clean-sapi clean-lemon
 	@echo Cleaning distribution build dirs
 	@for %D in (_x $(BUILD_DIRS_SUB)) do @if exist %D @del /F /Q %D\*.* > NUL
 	-@del /F /Q $(BUILD_DIR)\*.res $(BUILD_DIR)\*.lib $(BUILD_DIR)\*.ilk $(BUILD_DIR)\*.pdb $(BUILD_DIR)\*.exp $(PHPDEF) $(BUILD_DIR)\php-$(PHP_VERSION_STRING)-Win32.zip $(BUILD_DIR)\pecl-$(PHP_VERSION_STRING)-Win32.zip > NUL
 	-rd /s /q $(BUILD_DIR)\php-$(PHP_VERSION_STRING)
 
+clean-lemon:
+	@echo Cleaning lemon build dirs
+	-@del $(BUILD_DIR)\lemon.*
+
 clean-pecl:
 	@echo Cleaning PECL targets only
 	-rd /s /q $(BUILD_DIR)\pecl
@@ -148,6 +154,10 @@ snap: build-snap build-dist
 $(BUILD_DIR)\deplister.exe:	win32\build\deplister.c
 	$(CL) /Fo$(BUILD_DIR)\ /Fd$(BUILD_DIR)\ /Fp$(BUILD_DIR)\ /FR$(BUILD_DIR) /Fe$(BUILD_DIR)\deplister.exe win32\build\deplister.c imagehlp.lib
 
+
+$(BUILD_DIR)\lemon.exe:	lemon.c
+	$(CL) /Fo$(BUILD_DIR)\ /Fd$(BUILD_DIR)\ /Fp$(BUILD_DIR)\ /FR$(BUILD_DIR) /Fe$(BUILD_DIR)\lemon.exe lemon.c
+
 msi-installer: dist
 	$(BUILD_DIR)\php.exe ..\php-installer\build-installer.php "$(BUILD_DIR)" "$(PHPDLL)" "$(SAPI_TARGETS)" "$(EXT_TARGETS)" "$(PECL_TARGETS)"
 

win32/build/config.w32

@@ -46,9 +46,6 @@ PATH_PROG('nmake');
 // we don't want to define LIB, as that will override the default library path
 // that is set in that env var
 PATH_PROG('lib', null, 'MAKE_LIB');
-if (!PATH_PROG('bison')) {
-	ERROR('bison is required')
-}
 
 // There's a minimum requirement for re2c..
 MINRE2C = "0.13.4";
@@ -204,6 +201,9 @@ if (PHP_DEBUG == "yes") {
 
 if (PHP_ZTS == "yes") {
 	ADD_FLAG("CFLAGS", "/D ZTS=1");
+	DEFINE("LEMON_FLAGS", "-l -q D=ZTS");
+} else {
+	DEFINE("LEMON_FLAGS", "-l -q");
 }
 
 DEFINE("PHP_ZTS_ARCHIVE_POSTFIX", PHP_ZTS == "yes" ? '' : "-nts");