Implement a standard C thread safe scanner within flex

14 files changed, 352 insertions, 193 deletions

diff --git a/Zend/Zend.dsp b/Zend/Zend.dsp
index e2a8fe6611..6184c60d57 100644
--- a/Zend/Zend.dsp
+++ b/Zend/Zend.dsp
@@ -405,6 +405,10 @@ BuildCmds= \
 # PROP Default_Filter "l"

 # Begin Source File

 

+SOURCE=.\flex.skl

+# End Source File

+# Begin Source File

+

 SOURCE=.\zend_ini_scanner.l

 

 !IF  "$(CFG)" == "Zend - Win32 Release"

diff --git a/Zend/ZendTS.dsp b/Zend/ZendTS.dsp
index 0a1bfdd446..699601644d 100644
--- a/Zend/ZendTS.dsp
+++ b/Zend/ZendTS.dsp
@@ -192,7 +192,7 @@ SOURCE=.\zend_ini_parser.c
 # End Source File

 # Begin Source File

 

-SOURCE=.\zend_ini_scanner.cpp

+SOURCE=.\zend_ini_scanner.c

 # End Source File

 # Begin Source File

 

@@ -200,7 +200,7 @@ SOURCE=".\zend_language_parser.c"
 # End Source File

 # Begin Source File

 

-SOURCE=".\zend_language_scanner.cpp"

+SOURCE=.\zend_language_scanner.c

 # End Source File

 # Begin Source File

 

@@ -518,6 +518,10 @@ BuildCmds= \
 # PROP Default_Filter "l"

 # Begin Source File

 

+SOURCE=.\flex.skl

+# End Source File

+# Begin Source File

+

 SOURCE=.\zend_ini_scanner.l

 

 !IF  "$(CFG)" == "ZendTS - Win32 Release_TS"

@@ -535,8 +539,8 @@ InputPath=.\zend_ini_scanner.l
 # Begin Custom Build

 InputPath=.\zend_ini_scanner.l

 

-"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

-	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l

+"zend_ini_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+	flex -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.c zend_ini_scanner.l

 

 # End Custom Build

 

@@ -582,8 +586,8 @@ InputPath=".\zend_language_scanner.l"
 # Begin Custom Build

 InputPath=".\zend_language_scanner.l"

 

-"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

-	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l

+"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

+	flex -B -i -Sflex.skl -Pzend -ozend_language_scanner.c zend_language_scanner.l

 

 # End Custom Build

 

diff --git a/Zend/flex.skl b/Zend/flex.skl
index fb60c3ec9f..3e642b469f 100644
--- a/Zend/flex.skl
+++ b/Zend/flex.skl
@@ -62,6 +62,8 @@ class istream;
 #define yyconst
 #endif
 
+#undef YY_USE_PROTOS
+#define YY_USE_PROTOS
 
 #ifdef YY_USE_PROTOS
 #define YY_PROTO(proto) proto
@@ -96,7 +98,7 @@ class istream;
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin )
+#define YY_NEW_FILE yyrestart( yyin TSRMLS_CC )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
@@ -105,11 +107,12 @@ class istream;
 
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
-extern int yyleng;
+//FIXextern int yyleng;
 %-
-extern FILE *yyin, *yyout;
+//FIX extern FILE *yyin, *yyout;
 %*
 
+
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
@@ -140,7 +143,7 @@ extern FILE *yyin, *yyout;
 		} \
 	while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr )
+#define unput(c) yyunput( c, yytext_ptr TSRMLS_CC )
 
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
@@ -211,7 +214,8 @@ struct yy_buffer_state
 	};
 
 %- Standard (non-C++) definition
-static YY_BUFFER_STATE yy_current_buffer = 0;
+//FIXstatic YY_BUFFER_STATE yy_current_buffer = 0;
+#define yy_current_buffer SCNG(current_buffer)
 %*
 
 /* We provide macros for accessing buffer states in case in the
@@ -228,31 +232,44 @@ static char yy_hold_char;
 static int yy_n_chars;		/* number of characters read into yy_ch_buf */
 
 
-int yyleng;
+//FIXint yyleng;
 
 /* Points to current character in buffer. */
-static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;		/* whether we need to initialize */
-static int yy_start = 0;	/* start state number */
+#define yy_c_buf_p SCNG(c_buf_p)
+#define yy_init SCNG(init)
+#define yy_start SCNG(start)
+
+#ifdef ZTS
+#define TSRMLS_D	void ***tsrm_ls
+#define TSRMLS_DC	, TSRMLS_D
+#define TSRMLS_C	tsrm_ls
+#define TSRMLS_CC	, TSRMLS_C
+#else
+#define TSRMLS_D
+#define TSRMLS_DC
+#define TSRMLS_C
+#define TSRMLS_CC
+#endif
 
 /* Flag which is used to allow yywrap()'s to do buffer switches
  * instead of setting up a fresh yyin.  A bit of a hack ...
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( FILE *input_file ));
+void yyrestart YY_PROTO(( FILE *input_file TSRMLS_DC ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer TSRMLS_DC ));
+void yy_load_buffer_state YY_PROTO(( TSRMLS_D ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size TSRMLS_DC ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b TSRMLS_DC ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file TSRMLS_DC ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b TSRMLS_DC ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer TSRMLS_CC )
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size TSRMLS_DC ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str TSRMLS_DC ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len TSRMLS_DC ));
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 %*
 
 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
@@ -264,28 +281,41 @@ static void yy_flex_free YY_PROTO(( void * ));
 #define yy_set_interactive(is_interactive) \
 	{ \
 	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+		yy_current_buffer = yy_create_buffer( SCNG(yyin), YY_BUF_SIZE TSRMLS_CC ); \
 	yy_current_buffer->yy_is_interactive = is_interactive; \
 	}
 
 #define yy_set_bol(at_bol) \
 	{ \
 	if ( ! yy_current_buffer ) \
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+		yy_current_buffer = yy_create_buffer( SCNG(yyin), YY_BUF_SIZE TSRMLS_CC ); \
 	yy_current_buffer->yy_at_bol = at_bol; \
 	}
 
 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 
 %% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
+#undef yyleng
+#define yyleng SCNG(yy_leng)
+#undef yytext
+#define yytext SCNG(yy_text)
+#undef yytext_ptr
+#define yytext_ptr SCNG(yy_text)
+
+
 
 %- Standard (non-C++) definition
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
+static yy_state_type yy_get_previous_state YY_PROTO(( TSRMLS_D ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state TSRMLS_DC ));
+static int yy_get_next_buffer YY_PROTO(( TSRMLS_D ));
 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 %*
 
+#undef TSRMLS_D
+#undef TSRMLS_DC
+#undef TSRMLS_C
+#undef TSRMLS_CC
+
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
@@ -313,7 +343,7 @@ extern int yywrap YY_PROTO(( void ));
 
 %-
 #ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+static void yyunput YY_PROTO(( int c, char *buf_ptr TSRMLS_DC ));
 #endif
 %*
 
@@ -328,9 +358,9 @@ static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 #ifndef YY_NO_INPUT
 %- Standard (non-C++) definition
 #ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
+static int 3 YY_PROTO(( TSRMLS_D ));
 #else
-static int input YY_PROTO(( void ));
+static int input YY_PROTO(( TSRMLS_D ));
 #endif
 %*
 #endif
@@ -340,10 +370,10 @@ static int yy_start_stack_ptr = 0;
 static int yy_start_stack_depth = 0;
 static int *yy_start_stack = 0;
 #ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
+static void yy_push_state YY_PROTO(( int new_state TSRMLS_DC ));
 #endif
 #ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
+static void yy_pop_state YY_PROTO(( TSRMLS_D ));
 #endif
 #ifndef YY_NO_TOP_STATE
 static int yy_top_state YY_PROTO(( void ));
@@ -382,7 +412,7 @@ YY_MALLOC_DECL
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#define ECHO (void) fwrite( yytext, yyleng, 1, SCNG(yyout) )
 %+ C++ definition
 #define ECHO LexerOutput( yytext, yyleng )
 %*
@@ -422,6 +452,7 @@ YY_MALLOC_DECL
 %*
 #endif
 
+
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
@@ -466,25 +497,25 @@ YY_DECL
 		if ( ! yy_start )
 			yy_start = 1;	/* first start state */
 
-		if ( ! yyin )
+		if ( ! SCNG(yyin) )
 %-
-			yyin = stdin;
+			SCNG(yyin) = stdin;
 %+
-			yyin = &cin;
+			SCNG(yyin) = &cin;
 %*
 
-		if ( ! yyout )
+		if ( ! SCNG(yyout) )
 %-
-			yyout = stdout;
+			SCNG(yyout) = stdout;
 %+
-			yyout = &cout;
+			SCNG(yyout) = &cout;
 %*
 
 		if ( ! yy_current_buffer )
 			yy_current_buffer =
-				yy_create_buffer( yyin, YY_BUF_SIZE );
+				yy_create_buffer( SCNG(yyin), YY_BUF_SIZE TSRMLS_CC );
 
-		yy_load_buffer_state();
+		yy_load_buffer_state(TSRMLS_C);
 		}
 
 	while ( 1 )		/* loops until end-of-file is reached */
@@ -554,7 +585,7 @@ do_action:	/* This label is used only to access EOF actions. */
 
 			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 
-			yy_current_state = yy_get_previous_state();
+			yy_current_state = yy_get_previous_state(TSRMLS_C);
 
 			/* Okay, we're now positioned to make the NUL
 			 * transition.  We couldn't have
@@ -565,7 +596,7 @@ do_action:	/* This label is used only to access EOF actions. */
 			 * will run more slowly).
 			 */
 
-			yy_next_state = yy_try_NUL_trans( yy_current_state );
+			yy_next_state = yy_try_NUL_trans( yy_current_state TSRMLS_CC );
 
 			yy_bp = yytext_ptr + YY_MORE_ADJ;
 
@@ -584,7 +615,7 @@ do_action:	/* This label is used only to access EOF actions. */
 				}
 			}
 
-		else switch ( yy_get_next_buffer() )
+		else switch ( yy_get_next_buffer(TSRMLS_C) )
 			{
 			case EOB_ACT_END_OF_FILE:
 				{
@@ -619,7 +650,7 @@ do_action:	/* This label is used only to access EOF actions. */
 				yy_c_buf_p =
 					yytext_ptr + yy_amount_of_matched_text;
 
-				yy_current_state = yy_get_previous_state();
+				yy_current_state = yy_get_previous_state(TSRMLS_C);
 
 				yy_cp = yy_c_buf_p;
 				yy_bp = yytext_ptr + YY_MORE_ADJ;
@@ -629,7 +660,7 @@ do_action:	/* This label is used only to access EOF actions. */
 				yy_c_buf_p =
 				&yy_current_buffer->yy_ch_buf[yy_n_chars];
 
-				yy_current_state = yy_get_previous_state();
+				yy_current_state = yy_get_previous_state(TSRMLS_C);
 
 				yy_cp = yy_c_buf_p;
 				yy_bp = yytext_ptr + YY_MORE_ADJ;
@@ -648,8 +679,8 @@ do_action:	/* This label is used only to access EOF actions. */
 %+
 yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
 	{
-	yyin = arg_yyin;
-	yyout = arg_yyout;
+	SCNG(yyin) = arg_yyin;
+	SCNG(yyout) = arg_yyout;
 	yy_c_buf_p = 0;
 	yy_init = 1;
 	yy_start = 0;
@@ -678,49 +709,49 @@ yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
 yyFlexLexer::~yyFlexLexer()
 	{
 	delete yy_state_buf;
-	yy_delete_buffer( yy_current_buffer );
+	yy_delete_buffer( yy_current_buffer TSRMLS_CC );
 	}
 
 void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )
 	{
 	if ( new_in )
 		{
-		yy_delete_buffer( yy_current_buffer );
-		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
+		yy_delete_buffer( SCNG(yy_current_buffer TSRMLS_CC ) );
+		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE TSRMLS_CC ) TSRMLS_CC );
 		}
 
 	if ( new_out )
-		yyout = new_out;
+		SCNG(yyout) = new_out;
 	}
 
 int yyFlexLexer::LexerInput( char* buf, int max_size )
 	{
-		if ( yyin->eof() || yyin->fail() )
+		if ( SCNG(yyin)->eof() || SCNG(yyin)->fail() )
 			return 0;
 
 		if (yy_current_buffer->yy_is_interactive) {
-			yyin->get( buf[0] );
+			SCNG(yyin)->get( buf[0] );
 
-			if ( yyin->eof() )
+			if ( SCNG(yyin)->eof() )
 				return 0;
 
-			if ( yyin->bad() )
+			if ( SCNG(yyin)->bad() )
 				return -1;
 
 			return 1;
 		} else {
-			(void) yyin->read( buf, max_size );
+			(void) SCNG(yyin)->read( buf, max_size );
 
-			if ( yyin->bad() )
+			if ( SCNG(yyin)->bad() )
 				return -1;
 			else
-				return yyin->gcount();
+				return SCNG(yyin)->gcount();
 		}
 	}
 
 void yyFlexLexer::LexerOutput( const char* buf, int size )
 	{
-	(void) yyout->write( buf, size );
+	(void) SCNG(yyout)->write( buf, size );
 	}
 %*
 
@@ -733,9 +764,9 @@ void yyFlexLexer::LexerOutput( const char* buf, int size )
  */
 
 %-
-static int yy_get_next_buffer()
+static int yy_get_next_buffer(TSRMLS_D)
 %+
-int yyFlexLexer::yy_get_next_buffer()
+int yyFlexLexer::yy_get_next_buffer(TSRMLS_D)
 %*
 	{
 	register char *dest = yy_current_buffer->yy_ch_buf;
@@ -842,7 +873,7 @@ int yyFlexLexer::yy_get_next_buffer()
 		if ( number_to_move == YY_MORE_ADJ )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart( yyin );
+			yyrestart( SCNG(yyin) TSRMLS_CC );
 			}
 
 		else
@@ -869,9 +900,9 @@ int yyFlexLexer::yy_get_next_buffer()
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
 %-
-static yy_state_type yy_get_previous_state()
+static yy_state_type yy_get_previous_state(TSRMLS_D)
 %+
-yy_state_type yyFlexLexer::yy_get_previous_state()
+yy_state_type yyFlexLexer::yy_get_previous_state(TSRMLS_D)
 %*
 	{
 	register yy_state_type yy_current_state;
@@ -896,13 +927,16 @@ yy_state_type yyFlexLexer::yy_get_previous_state()
 
 %-
 #ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state TSRMLS_DC )
 #else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
+static yy_state_type yy_try_NUL_trans( yy_current_state TSRMLS_CC )
 yy_state_type yy_current_state;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
+yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state TSRMLS_DC )
 %*
 	{
 	register int yy_is_jam;
@@ -915,14 +949,17 @@ yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
 %-
 #ifndef YY_NO_UNPUT
 #ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
+static void yyunput( int c, register char *yy_bp TSRMLS_DC )
 #else
-static void yyunput( c, yy_bp )
+static void yyunput( c, yy_bp TSRMLS_CC )
 int c;
 register char *yy_bp;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-void yyFlexLexer::yyunput( int c, register char* yy_bp )
+void yyFlexLexer::yyunput( int c, register char* yy_bp TSRMLS_DC )
 %*
 	{
 	register char *yy_cp = yy_c_buf_p;
@@ -966,12 +1003,15 @@ void yyFlexLexer::yyunput( int c, register char* yy_bp )
 
 %-
 #ifdef __cplusplus
-static int yyinput()
+static int yyinput(TSRMLS_D)
 #else
-static int input()
+static int input(TSRMLS_C)
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-int yyFlexLexer::yyinput()
+int yyFlexLexer::yyinput(TSRMLS_D)
 %*
 	{
 	int c;
@@ -993,7 +1033,7 @@ int yyFlexLexer::yyinput()
 			int offset = yy_c_buf_p - yytext_ptr;
 			++yy_c_buf_p;
 
-			switch ( yy_get_next_buffer() )
+			switch ( yy_get_next_buffer(TSRMLS_C) )
 				{
 				case EOB_ACT_LAST_MATCH:
 					/* This happens because yy_g_n_b()
@@ -1007,7 +1047,7 @@ int yyFlexLexer::yyinput()
 					 */
 
 					/* Reset buffer status. */
-					yyrestart( yyin );
+					yyrestart( SCNG(yyin) TSRMLS_CC );
 
 					/* fall through */
 
@@ -1019,9 +1059,9 @@ int yyFlexLexer::yyinput()
 					if ( ! yy_did_buffer_switch_on_eof )
 						YY_NEW_FILE;
 #ifdef __cplusplus
-					return yyinput();
+					return yyinput(TSRMLS_C);
 #else
-					return input();
+					return input(TSRMLS_C);
 #endif
 					}
 
@@ -1044,32 +1084,35 @@ int yyFlexLexer::yyinput()
 
 %-
 #ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
+void yyrestart( FILE *input_file TSRMLS_DC )
 #else
-void yyrestart( input_file )
+void yyrestart( input_file TSRMLS_CC )
 FILE *input_file;
 #endif
 %+
-void yyFlexLexer::yyrestart( istream* input_file )
+void yyFlexLexer::yyrestart( istream* input_file TSRMLS_DC )
 %*
 	{
 	if ( ! yy_current_buffer )
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+		yy_current_buffer = yy_create_buffer( SCNG(yyin), YY_BUF_SIZE TSRMLS_CC );
 
-	yy_init_buffer( yy_current_buffer, input_file );
-	yy_load_buffer_state();
+	yy_init_buffer( yy_current_buffer, input_file TSRMLS_CC );
+	yy_load_buffer_state(TSRMLS_C);
 	}
 
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC)
 #else
-void yy_switch_to_buffer( new_buffer )
+void yy_switch_to_buffer( new_buffer TSRMLS_CC)
 YY_BUFFER_STATE new_buffer;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer TSRMLS_DC )
 %*
 	{
 	if ( yy_current_buffer == new_buffer )
@@ -1084,7 +1127,7 @@ void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
 		}
 
 	yy_current_buffer = new_buffer;
-	yy_load_buffer_state();
+	yy_load_buffer_state(TSRMLS_C);
 
 	/* We don't actually know whether we did this switch during
 	 * EOF (yywrap()) processing, but the only time this flag
@@ -1097,9 +1140,12 @@ void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
+void yy_load_buffer_state( TSRMLS_D )
 #else
-void yy_load_buffer_state()
+void yy_load_buffer_state(TSRMLS_C)
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
 void yyFlexLexer::yy_load_buffer_state()
@@ -1107,21 +1153,24 @@ void yyFlexLexer::yy_load_buffer_state()
 	{
 	yy_n_chars = yy_current_buffer->yy_n_chars;
 	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-	yyin = yy_current_buffer->yy_input_file;
+	SCNG(yyin) = yy_current_buffer->yy_input_file;
 	yy_hold_char = *yy_c_buf_p;
 	}
 
 
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size TSRMLS_DC )
 #else
-YY_BUFFER_STATE yy_create_buffer( file, size )
+YY_BUFFER_STATE yy_create_buffer( file, size TSRMLS_CC )
 FILE *file;
 int size;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
+YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size TSRMLS_DC )
 %*
 	{
 	YY_BUFFER_STATE b;
@@ -1141,7 +1190,7 @@ YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
 
 	b->yy_is_our_buffer = 1;
 
-	yy_init_buffer( b, file );
+	yy_init_buffer( b, file TSRMLS_CC );
 
 	return b;
 	}
@@ -1149,13 +1198,16 @@ YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
+void yy_delete_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 #else
-void yy_delete_buffer( b )
+void yy_delete_buffer( b TSRMLS_CC )
 YY_BUFFER_STATE b;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
+void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 %*
 	{
 	if ( ! b )
@@ -1179,20 +1231,23 @@ extern int isatty YY_PROTO(( int ));
 #endif
 
 #ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file TSRMLS_DC )
 #else
-void yy_init_buffer( b, file )
+void yy_init_buffer( b, file TSRMLS_CC )
 YY_BUFFER_STATE b;
 FILE *file;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 
 %+
 extern "C" int isatty YY_PROTO(( int ));
-void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
+void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file TSRMLS_DC )
 %*
 
 	{
-	yy_flush_buffer( b );
+	yy_flush_buffer( b TSRMLS_CC );
 
 	b->yy_input_file = file;
 	b->yy_fill_buffer = 1;
@@ -1215,14 +1270,17 @@ void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
 
 %-
 #ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
+void yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 #else
-void yy_flush_buffer( b )
+void yy_flush_buffer( b TSRMLS_CC )
 YY_BUFFER_STATE b;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 
 %+
-void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
+void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b TSRMLS_DC )
 %*
 	{
 	if ( ! b )
@@ -1243,7 +1301,7 @@ void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
 	if ( b == yy_current_buffer )
-		yy_load_buffer_state();
+		yy_load_buffer_state(TSRMLS_C);
 	}
 %*
 
@@ -1251,11 +1309,14 @@ void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
 #ifndef YY_NO_SCAN_BUFFER
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size TSRMLS_DC )
 #else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
+YY_BUFFER_STATE yy_scan_buffer( base, size TSRMLS_CC )
 char *base;
 yy_size_t size;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 	{
 	YY_BUFFER_STATE b;
@@ -1280,7 +1341,7 @@ yy_size_t size;
 	b->yy_fill_buffer = 0;
 	b->yy_buffer_status = YY_BUFFER_NEW;
 
-	yy_switch_to_buffer( b );
+	yy_switch_to_buffer( b TSRMLS_CC );
 
 	return b;
 	}
@@ -1291,17 +1352,20 @@ yy_size_t size;
 #ifndef YY_NO_SCAN_STRING
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str TSRMLS_DC )
 #else
-YY_BUFFER_STATE yy_scan_string( yy_str )
+YY_BUFFER_STATE yy_scan_string( yy_str TSRMLS_CC )
 yyconst char *yy_str;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 	{
 	int len;
 	for ( len = 0; yy_str[len]; ++len )
 		;
 
-	return yy_scan_bytes( yy_str, len );
+	return yy_scan_bytes( yy_str, len TSRMLS_CC );
 	}
 %*
 #endif
@@ -1310,11 +1374,14 @@ yyconst char *yy_str;
 #ifndef YY_NO_SCAN_BYTES
 %-
 #ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len TSRMLS_DC )
 #else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+YY_BUFFER_STATE yy_scan_bytes( bytes, len TSRMLS_CC )
 yyconst char *bytes;
 int len;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 	{
 	YY_BUFFER_STATE b;
@@ -1333,7 +1400,7 @@ int len;
 
 	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
 
-	b = yy_scan_buffer( buf, n );
+	b = yy_scan_buffer( buf, n TSRMLS_CC);
 	if ( ! b )
 		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -1351,13 +1418,16 @@ int len;
 #ifndef YY_NO_PUSH_STATE
 %-
 #ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
+static void yy_push_state( int new_state TSRMLS_DC )
 #else
-static void yy_push_state( new_state )
+static void yy_push_state( new_state TSRMLS_CC )
 int new_state;
+#ifdef ZTS
+void ***tsrm_ls;
+#endif
 #endif
 %+
-void yyFlexLexer::yy_push_state( int new_state )
+void yyFlexLexer::yy_push_state( int new_state TSRMLS_DC )
 %*
 	{
 	if ( yy_start_stack_ptr >= yy_start_stack_depth )
@@ -1388,9 +1458,9 @@ void yyFlexLexer::yy_push_state( int new_state )
 
 #ifndef YY_NO_POP_STATE
 %-
-static void yy_pop_state()
+static void yy_pop_state(TSRMLS_D)
 %+
-void yyFlexLexer::yy_pop_state()
+void yyFlexLexer::yy_pop_state(TSRMLS_D)
 %*
 	{
 	if ( --yy_start_stack_ptr < 0 )
diff --git a/Zend/zend.c b/Zend/zend.c
index a44c9bfd7b..d28eac94a9 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -325,6 +325,12 @@ static void alloc_globals_ctor(zend_alloc_globals *alloc_globals_p TSRMLS_DC)
 	start_memory_manager(TSRMLS_C);
 }
 
+static void zend_new_thread_end_handler(THREAD_T thread_id TSRMLS_DC)
+{
+	zend_copy_ini_directives(TSRMLS_C);
+	zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP TSRMLS_CC);
+}
+
 #endif
 
 #ifdef __FreeBSD__
@@ -332,13 +338,15 @@ static void alloc_globals_ctor(zend_alloc_globals *alloc_globals_p TSRMLS_DC)
 #include <floatingpoint.h>
 #endif
 
-#ifdef ZTS
-static void zend_new_thread_end_handler(THREAD_T thread_id TSRMLS_DC)
+
+static void scanner_globals_ctor(zend_scanner_globals *scanner_globals_p TSRMLS_DC)
 {
-	zend_copy_ini_directives(TSRMLS_C);
-	zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP TSRMLS_CC);
+	scanner_globals_p->c_buf_p = (char *) 0;
+	scanner_globals_p->init = 1;
+	scanner_globals_p->start = 0;
+	scanner_globals_p->current_buffer = NULL;
 }
-#endif
+
 
 
 int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions)
@@ -347,6 +355,13 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
 	zend_compiler_globals *compiler_globals;
 	zend_executor_globals *executor_globals;
 	void ***tsrm_ls;
+#ifdef ZTS
+	extern ZEND_API ts_rsrc_id ini_scanner_globals_id;
+	extern ZEND_API ts_rsrc_id language_scanner_globals_id;
+#else
+	extern zend_scanner_globals ini_scanner_globals;
+	extern zend_scanner_globals language_scanner_globals;
+#endif
 
 	ts_allocate_id(&alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
 #else
@@ -398,6 +413,8 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
 	global_constants_table = NULL;
 	ts_allocate_id(&compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
 	ts_allocate_id(&executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
+	ts_allocate_id(&language_scanner_globals_id, sizeof(zend_scanner_globals), (ts_allocate_ctor) scanner_globals_ctor, NULL);
+	ts_allocate_id(&ini_scanner_globals_id, sizeof(zend_scanner_globals), (ts_allocate_ctor) scanner_globals_ctor, NULL);
 	compiler_globals = ts_resource(compiler_globals_id);
 	executor_globals = ts_resource(executor_globals_id);
 	tsrm_ls = ts_resource_ex(0, NULL);
@@ -407,6 +424,8 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
 	zend_startup_constants(tsrm_ls);
 	GLOBAL_CONSTANTS_TABLE = EG(zend_constants);
 #else
+	scanner_globals_ctor(&ini_scanner_globals TSRMLS_CC);
+	scanner_globals_ctor(&language_scanner_globals TSRMLS_CC);
 	zend_startup_constants();
 	zend_set_default_compile_time_values(TSRMLS_C);
 	EG(user_error_handler) = NULL;
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 7b55b2ae2a..0825e5f181 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -119,6 +119,8 @@ struct _zend_compiler_globals {
 	void *ini_parser;
 #endif
 
+	struct _zend_ini_parser_param *ini_parser_param;
+
 	int interactive;
 };
 
@@ -221,4 +223,16 @@ struct _zend_alloc_globals {
 #endif
 };
 
+
+struct _zend_scanner_globals {
+	FILE *yyin;
+	FILE *yyout;
+	int yy_leng;
+	char *yy_text;
+	struct yy_buffer_state *current_buffer;
+	char *c_buf_p;
+	int init;
+	int start;
+};
+
 #endif /* ZEND_GLOBALS_H */
diff --git a/Zend/zend_globals_macros.h b/Zend/zend_globals_macros.h
index 5ad45d4675..6e86a28bcd 100644
--- a/Zend/zend_globals_macros.h
+++ b/Zend/zend_globals_macros.h
@@ -24,6 +24,7 @@
 typedef struct _zend_compiler_globals zend_compiler_globals;
 typedef struct _zend_executor_globals zend_executor_globals;
 typedef struct _zend_alloc_globals zend_alloc_globals;
+typedef struct _zend_scanner_globals zend_scanner_globals;
 
 /* Compiler */
 #ifdef ZTS
@@ -55,5 +56,25 @@ extern ZEND_API zend_executor_globals executor_globals;
 extern ZEND_API zend_alloc_globals alloc_globals;
 #endif
 
+
+/* Language Scanner */
+#ifdef ZTS
+# define LANG_SCNG(v) TSRMG(language_scanner_globals_id, zend_scanner_globals *, v)
+extern ZEND_API ts_rsrc_id language_scanner_globals_id;
+#else
+# define LANG_SCNG(v) (language_scanner_globals.v)
+extern ZEND_API zend_scanner_globals language_scanner_globals;
+#endif
+
+
+/* INI Scanner */
+#ifdef ZTS
+# define INI_SCNG(v) TSRMG(ini_scanner_globals_id, zend_scanner_globals *, v)
+extern ZEND_API ts_rsrc_id ini_scanner_globals_id;
+#else
+# define INI_SCNG(v) (ini_scanner_globals.v)
+extern ZEND_API zend_scanner_globals ini_scanner_globals;
+#endif
+
 #endif /* ZEND_GLOBALS_MACROS_H */
 
diff --git a/Zend/zend_highlight.c b/Zend/zend_highlight.c
index c8af224c60..d03c42b41e 100644
--- a/Zend/zend_highlight.c
+++ b/Zend/zend_highlight.c
@@ -29,8 +29,11 @@
 extern char *zendtext;
 extern int zendleng;
 #else
-#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
-#define zendleng zend_get_zendleng(TSRMLS_C)
+//FIX#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
+//FIX#define zendleng zend_get_zendleng(TSRMLS_C)
+#define zendtext LANG_SCNG(yy_text)
+#define zendleng LANG_SCNG(yy_leng)
+
 #endif
 
 ZEND_API void zend_html_putc(char c)
diff --git a/Zend/zend_indent.c b/Zend/zend_indent.c
index ff9d41f0a4..ccc599e92d 100644
--- a/Zend/zend_indent.c
+++ b/Zend/zend_indent.c
@@ -30,8 +30,10 @@
 extern char *zendtext;
 extern int zendleng;
 #else
-#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
-#define zendleng zend_get_zendleng(TSRMLS_C)
+//FIX#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
+//FIX#define zendleng zend_get_zendleng(TSRMLS_C)
+#define zendtext LANG_SCNG(yy_text)
+#define zendleng LANG_SCNG(yy_leng)
 #endif
 
 
diff --git a/Zend/zend_ini.h b/Zend/zend_ini.h
index 16896792d6..47a13091d4 100644
--- a/Zend/zend_ini.h
+++ b/Zend/zend_ini.h
@@ -191,4 +191,9 @@ int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_
 #define ZEND_INI_PARSER_ENTRY	1
 #define ZEND_INI_PARSER_SECTION	2
 
+typedef struct _zend_ini_parser_param {
+	zend_ini_parser_cb_t ini_parser_cb;
+	void *arg;
+} zend_ini_parser_param;
+
 #endif /* ZEND_INI_H */
diff --git a/Zend/zend_ini_parser.y b/Zend/zend_ini_parser.y
index d673316fe8..b30a834224 100644
--- a/Zend/zend_ini_parser.y
+++ b/Zend/zend_ini_parser.y
@@ -35,25 +35,23 @@
 #include <winbase.h>
 #endif
 
-
-typedef struct _zend_ini_parser_param {
-	zend_ini_parser_cb_t ini_parser_cb;
-	void *arg;
-} zend_ini_parser_param;
-
 #define YYSTYPE zval
-#define YYPARSE_PARAM ini_parser_param
 
-#define ZEND_INI_PARSER_CB	((zend_ini_parser_param *) ini_parser_param)->ini_parser_cb
-#define ZEND_INI_PARSER_ARG	((zend_ini_parser_param *) ini_parser_param)->arg
+#ifdef ZTS
+#define YYPARSE_PARAM tsrm_ls
+#define YYLEX_PARAM tsrm_ls
+#endif
+
+#define ZEND_INI_PARSER_CB	(CG(ini_parser_param))->ini_parser_cb
+#define ZEND_INI_PARSER_ARG	(CG(ini_parser_param))->arg
 
-int ini_lex(zval *ini_lval);
-int ini_parse(void *ini_parser_param);
+int ini_lex(zval *ini_lval TSRMLS_DC);
+int ini_parse(void *arg);
 
 zval yylval;
 
 #ifndef ZTS
-extern int ini_lex(zval *ini_lval);
+extern int ini_lex(zval *ini_lval TSRMLS_DC);
 extern FILE *ini_in;
 extern int ini_lineno;
 extern void init_cfg_scanner(void);
@@ -147,19 +145,20 @@ static void ini_error(char *str)
 
 int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg)
 {
-	zend_ini_parser_param ini_parser_param;
 	int retval;
+	zend_ini_parser_param ini_parser_param;
 	TSRMLS_FETCH();
 
 	ini_parser_param.ini_parser_cb = ini_parser_cb;
 	ini_parser_param.arg = arg;
 
+	CG(ini_parser_param) = &ini_parser_param;
 	if (zend_ini_open_file_for_scanning(fh TSRMLS_CC)==FAILURE) {
 		return FAILURE;
 	}
 
 	CG(ini_parser_unbuffered_errors) = unbuffered_errors;
-	retval = ini_parse(&ini_parser_param);
+	retval = ini_parse(TSRMLS_C);
 
 	zend_ini_close_file(fh TSRMLS_CC);
 
diff --git a/Zend/zend_ini_scanner.h b/Zend/zend_ini_scanner.h
index 4b2e824d68..1be587fa40 100644
--- a/Zend/zend_ini_scanner.h
+++ b/Zend/zend_ini_scanner.h
@@ -18,7 +18,7 @@ int zend_ini_scanner_get_lineno(TSRMLS_D);
 char *zend_ini_scanner_get_filename(TSRMLS_D);
 int zend_ini_open_file_for_scanning(zend_file_handle *fh TSRMLS_DC);
 void zend_ini_close_file(zend_file_handle *fh TSRMLS_DC);
-int ini_lex(zval *ini_lval);
+int ini_lex(zval *ini_lval TSRMLS_DC);
 END_EXTERN_C()
 
 #endif /* _ZEND_INI_SCANNER_H */
diff --git a/Zend/zend_ini_scanner.l b/Zend/zend_ini_scanner.l
index de981e2cb0..715f49904f 100644
--- a/Zend/zend_ini_scanner.l
+++ b/Zend/zend_ini_scanner.l
@@ -39,16 +39,24 @@
 #undef YYSTYPE
 #define YYSTYPE zval
 
-#ifdef ZTS
-#define YY_DECL int ZendIniFlexLexer::lex_scan(zval *ini_lval)
+#ifdef __cplusplus
+#define YY_DECL int ZendIniFlexLexer::lex_scan(zval *ini_lval TSRMLS_DC)
 #else
-#define YY_DECL int ini_lex(zval *ini_lval)
+#define YY_DECL int ini_lex(zval *ini_lval TSRMLS_DC)
 #endif
 
 #include "zend_istdiostream.h"
 
+/* Globals Macros */
+#define SCNG	INI_SCNG
+#ifdef ZTS
+ZEND_API ts_rsrc_id ini_scanner_globals_id;
+#else
+ZEND_API zend_scanner_globals ini_scanner_globals;
+#endif
+
 
-#ifndef ZTS
+#ifndef __cplusplus
 static char *ini_filename;
 
 void init_ini_scanner()
@@ -57,7 +65,7 @@ void init_ini_scanner()
 }
 
 
-int zend_ini_scanner_get_lineno()
+int zend_ini_scanner_get_lineno(TSRMLS_D)
 {
 	return ini_lineno;
 }
@@ -119,7 +127,7 @@ int zend_ini_open_file_for_scanning(zend_file_handle *fh TSRMLS_DC)
 			return FAILURE;
 	}
 
-#ifdef ZTS
+#ifdef __cplusplus
 	if (!fp) {
 		return FAILURE;
 	}
@@ -132,7 +140,7 @@ int zend_ini_open_file_for_scanning(zend_file_handle *fh TSRMLS_DC)
 #else
 	init_ini_scanner();
 	yyin = fp;
-	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
+	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE TSRMLS_CC) TSRMLS_CC);
 	ini_filename = fh->filename;
 #endif
 	return SUCCESS;
@@ -145,7 +153,7 @@ void zend_ini_close_file(zend_file_handle *fh TSRMLS_DC)
 		case ZEND_HANDLE_FP:
 			fclose(fh->handle.fp);
 			break;
-#ifdef ZTS
+#ifdef __cplusplus
 		case ZEND_HANDLE_STDIOSTREAM: {
 				TSRMLS_FETCH();
 				delete CG(ini_scanner);
@@ -278,6 +286,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <<EOF>> {
-	yy_delete_buffer(YY_CURRENT_BUFFER);
+	yy_delete_buffer(YY_CURRENT_BUFFER TSRMLS_CC);
 	yyterminate();
 }
diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h
index f3b478d06b..b8819a350b 100644
--- a/Zend/zend_language_scanner.h
+++ b/Zend/zend_language_scanner.h
@@ -21,7 +21,7 @@
 #ifndef ZEND_SCANNER_H
 #define ZEND_SCANNER_H
 
-#ifdef ZTS
+#ifdef __cplusplus
 class ZendFlexLexer : public yyFlexLexer
 {
 public:
@@ -34,7 +34,7 @@ public:
 
 
 typedef struct _zend_lex_state {
-#ifndef ZTS
+#ifndef __cplusplus
 	YY_BUFFER_STATE buffer_state;
 	int state;
 	FILE *in;
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 9b19423fc2..05036f7d07 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -72,7 +72,7 @@
 # include <unistd.h>
 #endif
 
-#ifdef ZTS
+#ifdef __cplusplus
 #define YY_DECL int ZendFlexLexer::lex_scan(zval *zendlval TSRMLS_DC)
 #else
 #define YY_DECL int lex_scan(zval *zendlval TSRMLS_DC)
@@ -88,6 +88,16 @@
 
 #include "zend_istdiostream.h"
 
+
+/* Globals Macros */
+#define SCNG	LANG_SCNG
+#ifdef ZTS
+ZEND_API ts_rsrc_id language_scanner_globals_id;
+#else
+ZEND_API zend_scanner_globals language_scanner_globals;
+#endif
+
+
 #define YY_FATAL_ERROR zend_fatal_scanner_error
 
 #define HANDLE_NEWLINES(s,l)													\
@@ -141,7 +151,7 @@ END_EXTERN_C()
 
 static inline void save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
 {
-#ifndef ZTS
+#ifndef __cplusplus
 	memcpy(&lex_state->buffer_state,&YY_CURRENT_BUFFER,sizeof(YY_BUFFER_STATE));
 	lex_state->in = yyin;
 	lex_state->state = YYSTATE;
@@ -155,16 +165,16 @@ static inline void save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
 
 static inline void restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
 {
-#ifndef ZTS
+#ifndef __cplusplus
 	YY_BUFFER_STATE original_buffer_state = YY_CURRENT_BUFFER;
 
 	if (lex_state->buffer_state) {
-		yy_switch_to_buffer(lex_state->buffer_state);
+		yy_switch_to_buffer(lex_state->buffer_state TSRMLS_CC);
 	} else {
 		YY_CURRENT_BUFFER = NULL;
 	}
 		
-	yy_delete_buffer(original_buffer_state);
+	yy_delete_buffer(original_buffer_state TSRMLS_CC);
 	yyin = lex_state->in;
 	BEGIN(lex_state->state);
 #else
@@ -190,7 +200,7 @@ ZEND_API void zend_file_handle_dtor(zend_file_handle *fh)
 			 * which doesn't really contain open files, but references to their names/paths
 			 */
 			break;
-#ifdef ZTS
+#ifdef __cplusplus
 		case ZEND_HANDLE_FSTREAM:
 			delete ((ifstream *) fh->handle.is);
 			break;
@@ -220,7 +230,7 @@ int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2)
 		case ZEND_HANDLE_FP:
 			return fh1->handle.fp==fh2->handle.fp;
 			break;
-#ifdef ZTS
+#ifdef __cplusplus
 		case ZEND_HANDLE_FSTREAM:
 		case ZEND_HANDLE_STDIOSTREAM:
 			return fh1->handle.is==fh2->handle.is;
@@ -241,7 +251,7 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
 {
 	char *file_path=NULL;
 
-#ifndef ZTS
+#ifndef __cplusplus
 	switch (file_handle->type) {
 		case ZEND_HANDLE_FILENAME:
 			file_handle->handle.fp = zend_fopen(file_handle->filename, &file_handle->opened_path);
@@ -263,7 +273,7 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
 	}
 	/* Reset the scanner for scanning the new file */
 	yyin = file_handle->handle.fp;
-	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
+	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE TSRMLS_CC) TSRMLS_CC);
 	BEGIN(INITIAL);
 #else
 	switch (file_handle->type) {
@@ -409,20 +419,20 @@ zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
 	return retval;
 }
 
-#ifndef ZTS
-static inline int prepare_string_for_scanning(zval *str, char *filename)
+#ifndef __cplusplus
+static inline int prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
 #else
 static inline int prepare_string_for_scanning(zval *str, istrstream **input_stream, char *filename TSRMLS_DC)
 #endif
 {
-#ifndef ZTS
+#ifndef __cplusplus
 	/* enforce two trailing NULLs for flex... */
 	STR_REALLOC(str->value.str.val, str->value.str.len+2);
 
 	str->value.str.val[str->value.str.len+1]=0;
 
 	yyin=NULL;
-	yy_scan_buffer(str->value.str.val, str->value.str.len+2);
+	yy_scan_buffer(str->value.str.val, str->value.str.len+2 TSRMLS_CC);
 #else
 	*input_stream = new istrstream(str->value.str.val, str->value.str.len);
 	CG(ZFL) = new ZendFlexLexer;
@@ -444,7 +454,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 	zval tmp;
 	int compiler_result;
 	zend_bool original_in_compilation = CG(in_compilation);
-#ifdef ZTS
+#ifdef __cplusplus
 	istrstream *input_stream;
 #endif
 
@@ -461,8 +471,8 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 	source_string = &tmp;
 
 	save_lexical_state(&original_lex_state TSRMLS_CC);
-#ifndef ZTS
-	if (prepare_string_for_scanning(source_string, filename)==FAILURE) {
+#ifndef __cplusplus
+	if (prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {
 #else
 	if (prepare_string_for_scanning(source_string, &input_stream, filename TSRMLS_CC)==FAILURE) {
 #endif
@@ -471,7 +481,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 	} else {
 		init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 		CG(active_op_array) = op_array;
-#ifndef ZTS
+#ifndef __cplusplus
 		BEGIN(ST_IN_SCRIPTING);
 #else
 		CG(ZFL)->BeginState(ST_IN_SCRIPTING);
@@ -490,7 +500,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 		}
 		restore_lexical_state(&original_lex_state TSRMLS_CC);
 	}
-#ifdef ZTS
+#ifdef __cplusplus
 	delete input_stream;
 #endif
 	zval_dtor(&tmp);
@@ -524,15 +534,15 @@ int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_
 {
 	zend_lex_state original_lex_state;
 	zval tmp = *str;
-#ifdef ZTS
+#ifdef __cplusplus
 	istrstream *input_stream;
 #endif
 
 	str = &tmp;
 	zval_copy_ctor(str);
 	save_lexical_state(&original_lex_state TSRMLS_CC);
-#ifndef ZTS
-	if (prepare_string_for_scanning(str, str_name)==FAILURE) {
+#ifndef __cplusplus
+	if (prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {
 #else
 	if (prepare_string_for_scanning(str, &input_stream, str_name TSRMLS_CC)==FAILURE) {
 #endif
@@ -540,7 +550,7 @@ int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_
 	}
 	zend_highlight(syntax_highlighter_ini TSRMLS_CC);
 	restore_lexical_state(&original_lex_state TSRMLS_CC);
-#ifdef ZTS
+#ifdef __cplusplus
 	delete input_stream;
 #endif
 	zval_dtor(str);
@@ -548,7 +558,7 @@ int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_
 }
 END_EXTERN_C()
 
-#ifdef ZTS
+#ifdef __cplusplus
 BEGIN_EXTERN_C()
 int lex_scan(zval *zendlval TSRMLS_DC)
 {
@@ -731,12 +741,12 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"->" {
-	yy_push_state(ST_LOOKING_FOR_PROPERTY);
+	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	return T_OBJECT_OPERATOR;
 }
 
 <ST_LOOKING_FOR_PROPERTY>{LABEL} {
-	yy_pop_state();
+	yy_pop_state(TSRMLS_C);
 	zendlval->value.str.val = (char *)estrndup(yytext, yyleng);
 	zendlval->value.str.len = yyleng;
 	zendlval->type = IS_STRING;
@@ -745,7 +755,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <ST_LOOKING_FOR_PROPERTY>{ANY_CHAR} {
 	yyless(0);
-	yy_pop_state();
+	yy_pop_state(TSRMLS_C);
 }
 
 <ST_IN_SCRIPTING>"::" {
@@ -954,13 +964,13 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <ST_IN_SCRIPTING>"{" {
-	yy_push_state(ST_IN_SCRIPTING);
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return '{';
 }
 
 
 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"${" {
-	yy_push_state(ST_LOOKING_FOR_VARNAME);
+	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
 	return T_DOLLAR_OPEN_CURLY_BRACES;
 }
 
@@ -968,7 +978,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 <ST_IN_SCRIPTING>"}" {
 	/* This is a temporary fix which is dependant on flex and it's implementation */
 	if (yy_start_stack_ptr) {
-		yy_pop_state();
+		yy_pop_state(TSRMLS_C);
 	}
 	return '}';
 }
@@ -978,16 +988,16 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
 	zendlval->value.str.len = yyleng;
 	zendlval->type = IS_STRING;
-	yy_pop_state();
-	yy_push_state(ST_IN_SCRIPTING);
+	yy_pop_state(TSRMLS_C);
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return T_STRING_VARNAME;
 }
 
 
 <ST_LOOKING_FOR_VARNAME>{ANY_CHAR} {
 	yyless(0);
-	yy_pop_state();
-	yy_push_state(ST_IN_SCRIPTING);
+	yy_pop_state(TSRMLS_C);
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 }
 
 
@@ -1488,7 +1498,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
 	zendlval->value.lval = (long) yytext[0];
-	yy_push_state(ST_IN_SCRIPTING);
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	yyless(1);
 	return T_CURLY_OPEN;
 }