From: Xinchen Hui <laruence@php.net>
Date: Tue, 14 Aug 2012 00:59:40 +0000 (+0800)
Subject: Add functions declarations, use tabs
X-Git-Tag: php-5.5.0alpha1~20^2~87
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=c64f4e736c07fdb10dfe624e4b548a1b0d9fbbcd;p=php

Add functions declarations, use tabs
---

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 1e995b6738..48b85f0b70 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2722,7 +2722,7 @@ void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */
 /* }}} */
 
 void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */ {
-    finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
+	finally_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 } /* }}} */
 
 void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */
@@ -2776,34 +2776,30 @@ void zend_do_end_catch(znode *catch_token TSRMLS_DC) /* {{{ */
 /* }}} */
 
 void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC) /* {{{ */ {
-    if (catch_token->op_type != IS_UNUSED) {
-       zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC);
-    }
+	if (catch_token->op_type != IS_UNUSED) {
+		zend_add_catch_element(try_token->u.op.opline_num, catch_token->EA TSRMLS_CC);
+	}
 }
 /* }}} */
 
-
 void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-    if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) {
-        zend_error(E_COMPILE_ERROR, "Cannot use try without catch or finally");
-    } 
-    if (finally_token->op_type != IS_UNUSED) {
-        CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num;
-        //try_token->u.op.opline_num = catch_token->u.op.opline_num;
-
-        opline->opcode = ZEND_LEAVE;
-        SET_UNUSED(opline->op1);
-        SET_UNUSED(opline->op2);
-    } 
-    if (catch_token->op_type == IS_UNUSED) {
-        CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].catch_op = 0;
-    } //else {
-    //    try_token->u.op.opline_num = catch_token->u.op.opline_num;
-    //}
+	if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) {
+		zend_error(E_COMPILE_ERROR, "Cannot use try without catch or finally");
+	} 
+	if (finally_token->op_type != IS_UNUSED) {
+		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num;
+		//try_token->u.op.opline_num = catch_token->u.op.opline_num;
 
+		opline->opcode = ZEND_LEAVE;
+		SET_UNUSED(opline->op1);
+		SET_UNUSED(opline->op2);
+	} 
+	if (catch_token->op_type == IS_UNUSED) {
+		CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].catch_op = 0;
+	}
 }
 /* }}} */
 
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index f604de4699..550fb0e931 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -499,6 +499,8 @@ void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC);
 void zend_do_try(znode *try_token TSRMLS_DC);
 void zend_do_begin_catch(znode *try_token, znode *catch_class, znode *catch_var, znode *first_catch TSRMLS_DC);
 void zend_do_end_catch(znode *catch_token TSRMLS_DC);
+void zend_do_finally(znode *finally_token TSRMLS_DC);
+void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC);
 void zend_do_throw(const znode *expr TSRMLS_DC);
 
 ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time);
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index 80760a5a54..a508fc7362 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -315,23 +315,23 @@ unticked_statement:
 	|	T_DECLARE { $1.u.op.opline_num = get_next_op_number(CG(active_op_array)); zend_do_declare_begin(TSRMLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(&$1 TSRMLS_CC); }
 	|	';'		/* empty statement */
 	|	T_TRY { zend_do_try(&$1 TSRMLS_CC); } '{' inner_statement_list '}'
-        catch_statement { zend_do_bind_catch(&$1, &$6 TSRMLS_CC); }
-        finally_statement { zend_do_end_finally(&$1, &$6, &$8 TSRMLS_CC); }
+		catch_statement { zend_do_bind_catch(&$1, &$6 TSRMLS_CC); }
+		finally_statement { zend_do_end_finally(&$1, &$6, &$8 TSRMLS_CC); }
 	|	T_THROW expr ';' { zend_do_throw(&$2 TSRMLS_CC); }
 	|	T_GOTO T_STRING ';' { zend_do_goto(&$2 TSRMLS_CC); }
 ;
 
 catch_statement:
-       /* empty */ { $$.op_type = IS_UNUSED; }
-    |   T_CATCH '(' { zend_initialize_try_catch_element(&$1 TSRMLS_CC); } 
-        fully_qualified_class_name { zend_do_first_catch(&$2 TSRMLS_CC); }
-        T_VARIABLE ')' { zend_do_begin_catch(&$1, &$4, &$6, &$2 TSRMLS_CC); }
+				/* empty */ { $$.op_type = IS_UNUSED; }
+	|	T_CATCH '(' { zend_initialize_try_catch_element(&$1 TSRMLS_CC); } 
+		fully_qualified_class_name { zend_do_first_catch(&$2 TSRMLS_CC); }
+		T_VARIABLE ')' { zend_do_begin_catch(&$1, &$4, &$6, &$2 TSRMLS_CC); }
 		'{' inner_statement_list '}' { zend_do_end_catch(&$1 TSRMLS_CC); }
 		additional_catches { zend_do_mark_last_catch(&$2, &$13 TSRMLS_CC); $$ = $1;}
 
 finally_statement:
-       /* empty */ { $$.op_type = IS_UNUSED; }
-    |  T_FINALLY { zend_do_finally(&$1 TSRMLS_CC); } '{' inner_statement_list '}' { $$ = $1; }
+					/* empty */ { $$.op_type = IS_UNUSED; }
+	|	T_FINALLY { zend_do_finally(&$1 TSRMLS_CC); } '{' inner_statement_list '}' { $$ = $1; }
 ;
 
 additional_catches:
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 1aded4e4a2..17dfb5fd81 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1187,18 +1187,18 @@ ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	    EX_T(opline->op1.var).var.ptr_ptr) {
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
-    
-    if (OP1_TYPE == IS_TMP_VAR || OP1_TYPE == IS_CONST) {
-        zval *container = GET_OP1_ZVAL_PTR(BP_VAR_R);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
-        FREE_OP2();
-        FREE_OP1();
-    } else {
-        container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
-        FREE_OP2();
-        FREE_OP1_VAR_PTR();
-    }
+
+	if (OP1_TYPE == IS_TMP_VAR || OP1_TYPE == IS_CONST) {
+		zval *container = GET_OP1_ZVAL_PTR(BP_VAR_R);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+		FREE_OP2();
+		FREE_OP1();
+	} else {
+		container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+		FREE_OP2();
+		FREE_OP1_VAR_PTR();
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -2133,9 +2133,9 @@ ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
 	USE_OPLINE
 
 	SAVE_OPLINE();
-    if (EG(exception)) {
-        zend_exception_save(TSRMLS_C);
-    }
+	if (EG(exception)) {
+		zend_exception_save(TSRMLS_C);
+	}
 	if (OP2_TYPE == IS_UNUSED) {
 		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
@@ -2835,7 +2835,7 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 	USE_OPLINE
 	zval *retval_ptr;
 	zend_free_op free_op1;
-    
+
 	SAVE_OPLINE();
 	retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
@@ -2844,9 +2844,9 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 			FREE_OP1();
 		}
 	} else if (!IS_OP1_TMP_FREE()) { /* Not a temp var */
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 		if (OP1_TYPE == IS_CONST ||
 		    (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
 			zval *ret;
@@ -2868,9 +2868,9 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 	} else {
 		zval *ret;
 
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		ALLOC_ZVAL(ret);
 		INIT_PZVAL_COPY(ret, retval_ptr);
@@ -2878,49 +2878,49 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 	}
 	FREE_OP1_IF_VAR();
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            } 
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			} 
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
+		}
+	}
 }
 
 ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
@@ -2933,9 +2933,9 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 
 	do {
-        if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
 			/* Not supposed to happen, but we'll allow it */
@@ -2993,49 +2993,49 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
 
 	FREE_OP1_IF_VAR();
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            } 
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			} 
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
+		}
+	}
 }
 
 ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
@@ -3816,7 +3816,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 	zend_op_array *new_op_array=NULL;
 	zend_free_op free_op1;
 	zval *inc_filename;
-    zval *tmp_inc_filename = NULL;
+	zval *tmp_inc_filename = NULL;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
@@ -5113,14 +5113,14 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 			/* further blocks will not be relevant... */
 			break;
 		} 
-        if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+		if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
 			catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
 			catched = i + 1;
 		}
-        if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-            finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
-            finally = i + 1;
-        }
+		if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+			finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
+			finally = i + 1;
+		}
 	}
 
 	while (EX(fbc)) {
@@ -5178,28 +5178,28 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 	EX(old_error_reporting) = NULL;
 
 	if (catched && finally) {
-        if (finally_op_num > catch_op_num) {
-            EX(leaving) = 0;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else {
-            zend_exception_save(TSRMLS_C);
-            EX(leaving) = finally;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        }
-    } else if (catched) { 
-        EX(leaving) = 0;
-        ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-        ZEND_VM_CONTINUE();
-    } else if (finally) {
-        zend_exception_save(TSRMLS_C);
-        EX(leaving) = finally;
-        ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-        ZEND_VM_CONTINUE();
-    } else {
-        ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
-    }
+		if (finally_op_num > catch_op_num) {
+			EX(leaving) = 0;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else {
+			zend_exception_save(TSRMLS_C);
+			EX(leaving) = finally;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		}
+	} else if (catched) { 
+		EX(leaving) = 0;
+		ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+		ZEND_VM_CONTINUE();
+	} else if (finally) {
+		zend_exception_save(TSRMLS_C);
+		EX(leaving) = finally;
+		ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+		ZEND_VM_CONTINUE();
+	} else {
+		ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
+	}
 }
 
 ZEND_VM_HANDLER(146, ZEND_VERIFY_ABSTRACT_CLASS, ANY, ANY)
@@ -5304,8 +5304,8 @@ ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
 	SAVE_OPLINE();
 	var_ptr = EX_T(opline->op1.var).var.ptr;
 	if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
-	    !PZVAL_IS_REF(var_ptr) &&
-	    Z_REFCOUNT_P(var_ptr) > 1) {
+			!PZVAL_IS_REF(var_ptr) &&
+			Z_REFCOUNT_P(var_ptr) > 1) {
 
 		Z_DELREF_P(var_ptr);
 		ALLOC_ZVAL(new_zv);
@@ -5318,49 +5318,49 @@ ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
 }
 
 ZEND_VM_HANDLER(159, ZEND_LEAVE, ANY, ANY) {
-{
-    USE_OPLINE
-    zend_uint i, op_num = opline - EG(active_op_array)->opcodes;
-
-    SAVE_OPLINE();
-    zend_exception_restore(TSRMLS_C);
-    if (EX(leaving)) {
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i = 0; i < EX(leaving); i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            } 
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(exception)) {
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else {
-            ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
-        }
-    } else {
-        ZEND_VM_NEXT_OPCODE();
-    }
+	{
+	USE_OPLINE
+		zend_uint i, op_num = opline - EG(active_op_array)->opcodes;
+
+	SAVE_OPLINE();
+	zend_exception_restore(TSRMLS_C);
+	if (EX(leaving)) {
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i = 0; i < EX(leaving); i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			} 
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(exception)) {
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else {
+			ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
+		}
+	} else {
+		ZEND_VM_NEXT_OPCODE();
+	}
 }
 
 ZEND_VM_EXPORT_HELPER(zend_do_fcall, zend_do_fcall_common_helper)
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index c4fe9a92d8..6fd7f0790d 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1051,14 +1051,14 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 			/* further blocks will not be relevant... */
 			break;
 		}
-        if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+		if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
 			catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
 			catched = i + 1;
 		}
-        if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-            finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
-            finally = i + 1;
-        }
+		if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+			finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
+			finally = i + 1;
+		}
 	}
 
 	while (EX(fbc)) {
@@ -1116,28 +1116,28 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 	EX(old_error_reporting) = NULL;
 
 	if (catched && finally) {
-        if (finally_op_num > catch_op_num) {
-            EX(leaving) = 0;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else {
-            zend_exception_save(TSRMLS_C);
-            EX(leaving) = finally;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        }
-    } else if (catched) {
-        EX(leaving) = 0;
-        ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-        ZEND_VM_CONTINUE();
-    } else if (finally) {
-        zend_exception_save(TSRMLS_C);
-        EX(leaving) = finally;
-        ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-        ZEND_VM_CONTINUE();
-    } else {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    }
+		if (finally_op_num > catch_op_num) {
+			EX(leaving) = 0;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else {
+			zend_exception_save(TSRMLS_C);
+			EX(leaving) = finally;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		}
+	} else if (catched) {
+		EX(leaving) = 0;
+		ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+		ZEND_VM_CONTINUE();
+	} else if (finally) {
+		zend_exception_save(TSRMLS_C);
+		EX(leaving) = finally;
+		ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+		ZEND_VM_CONTINUE();
+	} else {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -1176,49 +1176,49 @@ static int ZEND_FASTCALL  ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 }
 
 static int ZEND_FASTCALL  ZEND_LEAVE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-    USE_OPLINE
-    zend_uint i, op_num = opline - EG(active_op_array)->opcodes;
-
-    SAVE_OPLINE();
-    zend_exception_restore(TSRMLS_C);
-    if (EX(leaving)) {
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i = 0; i < EX(leaving); i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(exception)) {
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    } else {
-        ZEND_VM_NEXT_OPCODE();
-    }
+	{
+	USE_OPLINE
+		zend_uint i, op_num = opline - EG(active_op_array)->opcodes;
+
+	SAVE_OPLINE();
+	zend_exception_restore(TSRMLS_C);
+	if (EX(leaving)) {
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i = 0; i < EX(leaving); i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(exception)) {
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	} else {
+		ZEND_VM_NEXT_OPCODE();
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -1226,9 +1226,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 	USE_OPLINE
 
 	SAVE_OPLINE();
-    if (EG(exception)) {
-        zend_exception_save(TSRMLS_C);
-    }
+	if (EG(exception)) {
+		zend_exception_save(TSRMLS_C);
+	}
 	if (IS_CONST == IS_UNUSED) {
 		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
@@ -1529,9 +1529,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 	USE_OPLINE
 
 	SAVE_OPLINE();
-    if (EG(exception)) {
-        zend_exception_save(TSRMLS_C);
-    }
+	if (EG(exception)) {
+		zend_exception_save(TSRMLS_C);
+	}
 	if (IS_TMP_VAR == IS_UNUSED) {
 		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
@@ -1695,9 +1695,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 	USE_OPLINE
 
 	SAVE_OPLINE();
-    if (EG(exception)) {
-        zend_exception_save(TSRMLS_C);
-    }
+	if (EG(exception)) {
+		zend_exception_save(TSRMLS_C);
+	}
 	if (IS_VAR == IS_UNUSED) {
 		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
@@ -1861,9 +1861,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 	USE_OPLINE
 
 	SAVE_OPLINE();
-    if (EG(exception)) {
-        zend_exception_save(TSRMLS_C);
-    }
+	if (EG(exception)) {
+		zend_exception_save(TSRMLS_C);
+	}
 	if (IS_UNUSED == IS_UNUSED) {
 		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
@@ -1897,9 +1897,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 	USE_OPLINE
 
 	SAVE_OPLINE();
-    if (EG(exception)) {
-        zend_exception_save(TSRMLS_C);
-    }
+	if (EG(exception)) {
+		zend_exception_save(TSRMLS_C);
+	}
 	if (IS_CV == IS_UNUSED) {
 		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
@@ -2312,9 +2312,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 		}
 	} else if (!0) { /* Not a temp var */
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 		if (IS_CONST == IS_CONST ||
 		    (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
 			zval *ret;
@@ -2336,58 +2336,58 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	} else {
 		zval *ret;
 
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		ALLOC_ZVAL(ret);
 		INIT_PZVAL_COPY(ret, retval_ptr);
 		*EG(return_value_ptr_ptr) = ret;
 	}
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -2400,9 +2400,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
 	SAVE_OPLINE();
 
 	do {
-        if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
 			/* Not supposed to happen, but we'll allow it */
@@ -2458,49 +2458,49 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
 		}
 	} while (0);
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -2700,7 +2700,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 	zend_op_array *new_op_array=NULL;
 
 	zval *inc_filename;
-    zval *tmp_inc_filename = NULL;
+	zval *tmp_inc_filename = NULL;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
@@ -3562,17 +3562,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
-        zval *container = opline->op1.zv;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
+		zval *container = opline->op1.zv;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -4418,17 +4418,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HA
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
-        zval *container = opline->op1.zv;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
+	if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
+		zval *container = opline->op1.zv;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
 
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5122,17 +5122,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HA
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
-        zval *container = opline->op1.zv;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+	if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
+		zval *container = opline->op1.zv;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -6382,17 +6382,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
-        zval *container = opline->op1.zv;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	if (IS_CONST == IS_TMP_VAR || IS_CONST == IS_CONST) {
+		zval *container = opline->op1.zv;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -6940,9 +6940,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			zval_dtor(free_op1.var);
 		}
 	} else if (!1) { /* Not a temp var */
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 		if (IS_TMP_VAR == IS_CONST ||
 		    (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
 			zval *ret;
@@ -6964,58 +6964,58 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	} else {
 		zval *ret;
 
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		ALLOC_ZVAL(ret);
 		INIT_PZVAL_COPY(ret, retval_ptr);
 		*EG(return_value_ptr_ptr) = ret;
 	}
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7028,9 +7028,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
 	SAVE_OPLINE();
 
 	do {
-        if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
 			/* Not supposed to happen, but we'll allow it */
@@ -7086,49 +7086,49 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
 		}
 	} while (0);
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7329,7 +7329,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
 	zend_op_array *new_op_array=NULL;
 	zend_free_op free_op1;
 	zval *inc_filename;
-    zval *tmp_inc_filename = NULL;
+	zval *tmp_inc_filename = NULL;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
@@ -8243,17 +8243,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HA
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
-        zval_dtor(free_op1.var);
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op1.var);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -8967,17 +8967,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAND
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
-        zval_dtor(free_op1.var);
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
+	if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
+		zval_dtor(free_op1.var);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -9671,17 +9671,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAND
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
-        zval_dtor(free_op1.var);
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+	if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+		zval_dtor(free_op1.var);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -10797,17 +10797,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	if (IS_TMP_VAR == IS_TMP_VAR || IS_TMP_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
-        zval_dtor(free_op1.var);
-    } else {
-        container = NULL;
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op1.var);
+	} else {
+		container = NULL;
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -11473,9 +11473,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
 		}
 	} else if (!0) { /* Not a temp var */
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 		if (IS_VAR == IS_CONST ||
 		    (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
 			zval *ret;
@@ -11497,9 +11497,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	} else {
 		zval *ret;
 
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		ALLOC_ZVAL(ret);
 		INIT_PZVAL_COPY(ret, retval_ptr);
@@ -11507,49 +11507,49 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	}
 	if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11562,9 +11562,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
 	SAVE_OPLINE();
 
 	do {
-        if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
 			/* Not supposed to happen, but we'll allow it */
@@ -11622,49 +11622,49 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
 
 	if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11974,7 +11974,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 	zend_op_array *new_op_array=NULL;
 	zend_free_op free_op1;
 	zval *inc_filename;
-    zval *tmp_inc_filename = NULL;
+	zval *tmp_inc_filename = NULL;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
@@ -13465,17 +13465,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    } else {
-        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	} else {
+		container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    }
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15642,17 +15642,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    } else {
-        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    }
+	if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	} else {
+		container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -17733,17 +17733,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    } else {
-        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    }
+	if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	} else {
+		container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -20094,8 +20094,8 @@ static int ZEND_FASTCALL  ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAND
 	SAVE_OPLINE();
 	var_ptr = EX_T(opline->op1.var).var.ptr;
 	if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
-	    !PZVAL_IS_REF(var_ptr) &&
-	    Z_REFCOUNT_P(var_ptr) > 1) {
+			!PZVAL_IS_REF(var_ptr) &&
+			Z_REFCOUNT_P(var_ptr) > 1) {
 
 		Z_DELREF_P(var_ptr);
 		ALLOC_ZVAL(new_zv);
@@ -20859,17 +20859,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
-        zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	if (IS_VAR == IS_TMP_VAR || IS_VAR == IS_CONST) {
+		zval *container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    } else {
-        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	} else {
+		container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
-        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-    }
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -27571,9 +27571,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 		}
 	} else if (!0) { /* Not a temp var */
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 		if (IS_CV == IS_CONST ||
 		    (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
 			zval *ret;
@@ -27595,58 +27595,58 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	} else {
 		zval *ret;
 
-        if (*EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (*EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		ALLOC_ZVAL(ret);
 		INIT_PZVAL_COPY(ret, retval_ptr);
 		*EG(return_value_ptr_ptr) = ret;
 	}
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -27659,9 +27659,9 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
 	SAVE_OPLINE();
 
 	do {
-        if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-            zval_ptr_dtor(EG(return_value_ptr_ptr));
-        }
+		if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+		}
 
 		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
 			/* Not supposed to happen, but we'll allow it */
@@ -27717,49 +27717,49 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
 		}
 	} while (0);
 
-    if (!(EG(active_op_array)->last_try_catch)) {
-        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-    } else {
-        zend_uint i, op_num = opline - EX(op_array)->opcodes;
-        zend_uint catch_op_num = 0, finally_op_num = 0;
-        for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
-            if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
-                break;
-            }
-            if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
-                finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
-            }
-            if (EG(prev_exception)) {
-                /* leaving */
-                if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
-                    catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
-                }
-            }
-        }
-
-        if (catch_op_num && finally_op_num) {
-            if (catch_op_num > finally_op_num) {
-                EX(leaving) = 1;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-                ZEND_VM_CONTINUE();
-            } else {
-                EX(leaving) = 0;
-                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-                ZEND_VM_CONTINUE();
-            }
-        } else if (catch_op_num) {
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (finally_op_num) {
-            EX(leaving) = 1;
-            ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
-            ZEND_VM_CONTINUE();
-        } else if (EX(leaving)) {
-            ZEND_VM_NEXT_OPCODE();
-        } else {
-            return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-        }
-    }
+	if (!(EG(active_op_array)->last_try_catch)) {
+		return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zend_uint i, op_num = opline - EX(op_array)->opcodes;
+		zend_uint catch_op_num = 0, finally_op_num = 0;
+		for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
+			if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
+				break;
+			}
+			if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
+				finally_op_num = EG(active_op_array)->try_catch_array[i].finally_op;
+			}
+			if (EG(prev_exception)) {
+				/* leaving */
+				if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
+					catch_op_num = EG(active_op_array)->try_catch_array[i].catch_op;
+				}
+			}
+		}
+
+		if (catch_op_num && finally_op_num) {
+			if (catch_op_num > finally_op_num) {
+				EX(leaving) = 1;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+				ZEND_VM_CONTINUE();
+			} else {
+				EX(leaving) = 0;
+				ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+				ZEND_VM_CONTINUE();
+			}
+		} else if (catch_op_num) {
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (finally_op_num) {
+			EX(leaving) = 1;
+			ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
+			ZEND_VM_CONTINUE();
+		} else if (EX(leaving)) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+		}
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -28057,7 +28057,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 	zend_op_array *new_op_array=NULL;
 
 	zval *inc_filename;
-    zval *tmp_inc_filename = NULL;
+	zval *tmp_inc_filename = NULL;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
@@ -29401,17 +29401,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
-        zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
+		zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
-    } else {
-        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	} else {
+		container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -31357,17 +31357,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
-        zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
+	if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
+		zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
 
-    } else {
-        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-        zval_dtor(free_op2.var);
+	} else {
+		container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zval_dtor(free_op2.var);
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -33319,17 +33319,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
-        zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+	if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
+		zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
-    } else {
-        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+	} else {
+		container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+		if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -36176,17 +36176,17 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 		PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
 	}
 
-    if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
-        zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	if (IS_CV == IS_TMP_VAR || IS_CV == IS_CONST) {
+		zval *container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), &container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
-    } else {
-        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	} else {
+		container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
-    }
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();