]> granicus.if.org Git - php/commitdiff
projects / php / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 5bf4c5f)
Add functions declarations, use tabs
authorXinchen Hui <laruence@php.net>
Tue, 14 Aug 2012 00:59:40 +0000 (08:59 +0800)
committerXinchen Hui <laruence@php.net>
Tue, 14 Aug 2012 00:59:40 +0000 (08:59 +0800)
Zend/zend_compile.c patch | blob | history
Zend/zend_compile.h patch | blob | history
Zend/zend_language_parser.y patch | blob | history
Zend/zend_vm_def.h patch | blob | history
Zend/zend_vm_execute.h patch | blob | history

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 1e995b6738a01af1970f792524bfb8f5027dae66..48b85f0b7091c9d646404f29e9b862ca9325b547 100644 (file)
--- 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 f604de4699cf578e6a989aadb268c6ee87d32a6c..550fb0e9318dc4bd9403bcac06de6497b690119b 100644 (file)
--- 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 80760a5a543057563f3f7546421688e924eead04..a508fc736292ff5ae0ce2446cce1643b79acaf91 100644 (file)
--- 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 1aded4e4a2c28c06d6d72c1a68bca87773515c8a..17dfb5fd81b56c90fe38b804fda45efa58e9c65e 100644 (file)
--- 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 c4fe9a92d8c7e23aa21ebe75d35dd7a6c3683fbb..6fd7f0790dc63037f69f697633a2f680c381c1cc 100644 (file)
--- 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();
Unnamed repository; edit this file 'description' to name the repository.