ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_TYPE_SPEC_HANDLER(ZEND_ADD, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
+ZEND_VM_HANDLER(187, ZEND_SWITCH_LONG, CONST|TMPVAR|CV, CONST, JMP_ADDR)
+{
+ USE_OPLINE
+ zend_free_op free_op1, free_op2;
+ zval *op, *jump_zv;
+ HashTable *jumptable;
+
+ op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+ jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
+
+ if (Z_TYPE_P(op) != IS_LONG) {
+ ZVAL_DEREF(op);
+ if (Z_TYPE_P(op) != IS_LONG) {
+ /* Wrong type, fall back to ZEND_CASE chain */
+ ZEND_VM_NEXT_OPCODE();
+ }
+ }
+
+ jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
+ if (jump_zv != NULL) {
+ ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
+ ZEND_VM_CONTINUE();
+ } else {
+ /* default */
+ ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+ ZEND_VM_CONTINUE();
+ }
+}
+
+ZEND_VM_HANDLER(188, ZEND_SWITCH_STRING, CONST|TMPVAR|CV, CONST, JMP_ADDR)
+{
+ USE_OPLINE
+ zend_free_op free_op1, free_op2;
+ zval *op, *jump_zv;
+ HashTable *jumptable;
+
+ op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+ jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
+
+ if (Z_TYPE_P(op) != IS_STRING) {
+ ZVAL_DEREF(op);
+ if (Z_TYPE_P(op) != IS_STRING) {
+ /* Wrong type, fall back to ZEND_CASE chain */
+ ZEND_VM_NEXT_OPCODE();
+ }
+ }
+
+ jump_zv = zend_hash_find(jumptable, Z_STR_P(op));
+ if (jump_zv != NULL) {
+ ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
+ ZEND_VM_CONTINUE();
+ } else {
+ /* default */
+ ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+ ZEND_VM_CONTINUE();
+ }
+}
+
+ZEND_VM_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM)
+{
+ USE_OPLINE
+ zend_free_op free_op1;
+ zval *op1;
+ HashTable *ht = Z_ARRVAL_P(EX_CONSTANT(opline->op2));
+ int result;
+
+ SAVE_OPLINE();
+ op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+ if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
+ result = zend_hash_exists(ht, Z_STR_P(op1));
+ } else if (opline->extended_value) {
+ if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+ result = zend_hash_index_exists(ht, Z_LVAL_P(op1));
+ } else {
+ result = 0;
+ }
+ } else if (Z_TYPE_P(op1) <= IS_FALSE) {
+ result = zend_hash_exists(ht, ZSTR_EMPTY_ALLOC());
+ } else {
+ zend_string *key;
+ zval tmp;
+
+ result = 0;
+ ZEND_HASH_FOREACH_STR_KEY(ht, key) {
+ ZVAL_STR(&tmp, key);
+ compare_function(&tmp, op1, &tmp);
+ if (Z_LVAL(tmp) == 0) {
+ result = 1;
+ break;
+ }
+ } ZEND_HASH_FOREACH_END();
+ }
+ FREE_OP1();
+ ZEND_VM_SMART_BRANCH(result, 1);
+ ZVAL_BOOL(EX_VAR(opline->result.var), result);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(190, ZEND_COUNT, CONST|TMP|VAR|CV, UNUSED)
+{
+ USE_OPLINE
+ zend_free_op free_op1;
+ zval *op1;
+ zend_long count;
+
+ SAVE_OPLINE();
+ op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+ do {
+ if (Z_TYPE_P(op1) == IS_ARRAY) {
+ count = zend_array_count(Z_ARRVAL_P(op1));
+ break;
+ } else if (Z_TYPE_P(op1) == IS_OBJECT) {
+ /* first, we check if the handler is defined */
+ if (Z_OBJ_HT_P(op1)->count_elements) {
+ if (SUCCESS == Z_OBJ_HT_P(op1)->count_elements(op1, &count)) {
+ break;
+ }
+ }
+
+ /* if not and the object implements Countable we call its count() method */
+ if (instanceof_function(Z_OBJCE_P(op1), zend_ce_countable)) {
+ zval retval;
+
+ zend_call_method_with_0_params(op1, NULL, NULL, "count", &retval);
+ count = zval_get_long(&retval);
+ zval_ptr_dtor(&retval);
+ break;
+ }
+
+ /* If There's no handler and it doesn't implement Countable then add a warning */
+ count = 1;
+ } else if (Z_TYPE_P(op1) == IS_NULL) {
+ count = 0;
+ } else {
+ count = 1;
+ }
+ zend_error(E_WARNING, "count(): Parameter must be an array or an object that implements Countable");
+ } while (0);
+
+ ZVAL_LONG(EX_VAR(opline->result.var), count);
+ FREE_OP1();
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(191, ZEND_GET_CLASS, UNUSED|CONST|TMP|VAR|CV, UNUSED)
+{
+ USE_OPLINE
+
+ if (OP1_TYPE == IS_UNUSED) {
+ if (UNEXPECTED(!EX(func)->common.scope)) {
+ SAVE_OPLINE();
+ zend_error(E_WARNING, "get_class() called without object from outside a class");
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ } else {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
+ ZEND_VM_NEXT_OPCODE();
+ }
+ } else {
+ zend_free_op free_op1;
+ zval *op1;
+
+ SAVE_OPLINE();
+ op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+ if (Z_TYPE_P(op1) == IS_OBJECT) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
+ } else {
+ zend_error(E_WARNING, "get_class() expects parameter 1 to be object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ }
+ FREE_OP1();
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ }
+}
+
+ZEND_VM_HANDLER(192, ZEND_GET_CALLED_CLASS, UNUSED, UNUSED)
+{
+ USE_OPLINE
+
+ if (Z_TYPE(EX(This)) == IS_OBJECT) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
+ } else if (Z_CE(EX(This))) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
+ } else {
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ if (UNEXPECTED(!EX(func)->common.scope)) {
+ SAVE_OPLINE();
+ zend_error(E_WARNING, "get_called_class() called from outside a class");
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ }
+ }
+ ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HANDLER(193, ZEND_GET_TYPE, CONST|TMP|VAR|CV, UNUSED)
+{
+ USE_OPLINE
+ zend_free_op free_op1;
+ zval *op1;
+ zend_string *type;
+
+ SAVE_OPLINE();
+ op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+ type = zend_zval_get_type(op1);
+ if (EXPECTED(type)) {
+ ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
+ } else {
+ ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
+ }
+ FREE_OP1();
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(194, ZEND_FUNC_NUM_ARGS, UNUSED, UNUSED)
+{
+ USE_OPLINE
+
+ ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
+ ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HANDLER(195, ZEND_FUNC_GET_ARGS, UNUSED|CONST, UNUSED)
+{
+ USE_OPLINE
+ zend_array *ht;
+ uint32_t arg_count, first_extra_arg, i, n;
+ zval *p, *q;
+
+ arg_count = EX_NUM_ARGS();
+ ht = (zend_array *) emalloc(sizeof(zend_array));
+ if (OP1_TYPE == IS_CONST) {
+ i = Z_LVAL_P(EX_CONSTANT(opline->op1));
+ if (arg_count < i) {
+ i = 0;
+ } else {
+ i = arg_count - i;
+ }
+ zend_hash_init(ht, i, NULL, ZVAL_PTR_DTOR, 0);
+ } else {
+ zend_hash_init(ht, arg_count, NULL, ZVAL_PTR_DTOR, 0);
+ }
+ ZVAL_ARR(EX_VAR(opline->result.var), ht);
+ if (arg_count) {
+ first_extra_arg = EX(func)->op_array.num_args;
+ zend_hash_real_init(ht, 1);
+ ZEND_HASH_FILL_PACKED(ht) {
+ i = 0;
+ n = 0;
+ if (OP1_TYPE == IS_CONST) {
+ i = Z_LVAL_P(EX_CONSTANT(opline->op1));
+ }
+ p = EX_VAR_NUM(i);
+ if (arg_count > first_extra_arg) {
+ while (i < first_extra_arg) {
+ q = p;
+ if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
+ ZVAL_DEREF(q);
+ if (Z_OPT_REFCOUNTED_P(q)) {
+ Z_ADDREF_P(q);
+ }
- n++;
++ } else {
++ q = &EG(uninitialized_zval);
+ }
+ ZEND_HASH_FILL_ADD(q);
++ n++;
+ p++;
+ i++;
+ }
+ p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
+ }
+ while (i < arg_count) {
+ q = p;
+ if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
+ ZVAL_DEREF(q);
+ if (Z_OPT_REFCOUNTED_P(q)) {
+ Z_ADDREF_P(q);
+ }
- n++;
++ } else {
++ q = &EG(uninitialized_zval);
+ }
+ ZEND_HASH_FILL_ADD(q);
++ n++;
+ p++;
+ i++;
+ }
+ } ZEND_HASH_FILL_END();
+ ht->nNumOfElements = n;
+ }
+ ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_ADD, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
{
USE_OPLINE
zval *op1, *op2, *result;
ZEND_VM_RETURN();
}
- n++;
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+
+ zval *op1;
+ zend_long count;
+
+ SAVE_OPLINE();
+ op1 = EX_CONSTANT(opline->op1);
+ do {
+ if (Z_TYPE_P(op1) == IS_ARRAY) {
+ count = zend_array_count(Z_ARRVAL_P(op1));
+ break;
+ } else if (Z_TYPE_P(op1) == IS_OBJECT) {
+ /* first, we check if the handler is defined */
+ if (Z_OBJ_HT_P(op1)->count_elements) {
+ if (SUCCESS == Z_OBJ_HT_P(op1)->count_elements(op1, &count)) {
+ break;
+ }
+ }
+
+ /* if not and the object implements Countable we call its count() method */
+ if (instanceof_function(Z_OBJCE_P(op1), zend_ce_countable)) {
+ zval retval;
+
+ zend_call_method_with_0_params(op1, NULL, NULL, "count", &retval);
+ count = zval_get_long(&retval);
+ zval_ptr_dtor(&retval);
+ break;
+ }
+
+ /* If There's no handler and it doesn't implement Countable then add a warning */
+ count = 1;
+ } else if (Z_TYPE_P(op1) == IS_NULL) {
+ count = 0;
+ } else {
+ count = 1;
+ }
+ zend_error(E_WARNING, "count(): Parameter must be an array or an object that implements Countable");
+ } while (0);
+
+ ZVAL_LONG(EX_VAR(opline->result.var), count);
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+
+ if (IS_CONST == IS_UNUSED) {
+ if (UNEXPECTED(!EX(func)->common.scope)) {
+ SAVE_OPLINE();
+ zend_error(E_WARNING, "get_class() called without object from outside a class");
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ } else {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
+ ZEND_VM_NEXT_OPCODE();
+ }
+ } else {
+
+ zval *op1;
+
+ SAVE_OPLINE();
+ op1 = EX_CONSTANT(opline->op1);
+ if (Z_TYPE_P(op1) == IS_OBJECT) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
+ } else {
+ zend_error(E_WARNING, "get_class() expects parameter 1 to be object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ }
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ }
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+
+ zval *op1;
+ zend_string *type;
+
+ SAVE_OPLINE();
+ op1 = EX_CONSTANT(opline->op1);
+ type = zend_zval_get_type(op1);
+ if (EXPECTED(type)) {
+ ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
+ } else {
+ ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
+ }
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_array *ht;
+ uint32_t arg_count, first_extra_arg, i, n;
+ zval *p, *q;
+
+ arg_count = EX_NUM_ARGS();
+ ht = (zend_array *) emalloc(sizeof(zend_array));
+ if (IS_CONST == IS_CONST) {
+ i = Z_LVAL_P(EX_CONSTANT(opline->op1));
+ if (arg_count < i) {
+ i = 0;
+ } else {
+ i = arg_count - i;
+ }
+ zend_hash_init(ht, i, NULL, ZVAL_PTR_DTOR, 0);
+ } else {
+ zend_hash_init(ht, arg_count, NULL, ZVAL_PTR_DTOR, 0);
+ }
+ ZVAL_ARR(EX_VAR(opline->result.var), ht);
+ if (arg_count) {
+ first_extra_arg = EX(func)->op_array.num_args;
+ zend_hash_real_init(ht, 1);
+ ZEND_HASH_FILL_PACKED(ht) {
+ i = 0;
+ n = 0;
+ if (IS_CONST == IS_CONST) {
+ i = Z_LVAL_P(EX_CONSTANT(opline->op1));
+ }
+ p = EX_VAR_NUM(i);
+ if (arg_count > first_extra_arg) {
+ while (i < first_extra_arg) {
+ q = p;
+ if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
+ ZVAL_DEREF(q);
+ if (Z_OPT_REFCOUNTED_P(q)) {
+ Z_ADDREF_P(q);
+ }
- n++;
++ } else {
++ q = &EG(uninitialized_zval);
+ }
+ ZEND_HASH_FILL_ADD(q);
++ n++;
+ p++;
+ i++;
+ }
+ p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
+ }
+ while (i < arg_count) {
+ q = p;
+ if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
+ ZVAL_DEREF(q);
+ if (Z_OPT_REFCOUNTED_P(q)) {
+ Z_ADDREF_P(q);
+ }
++ } else {
++ q = &EG(uninitialized_zval);
+ }
+ ZEND_HASH_FILL_ADD(q);
++ n++;
+ p++;
+ i++;
+ }
+ } ZEND_HASH_FILL_END();
+ ht->nNumOfElements = n;
+ }
+ ZEND_VM_NEXT_OPCODE();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
ZEND_VM_NEXT_OPCODE();
}
- n++;
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+
+ if (IS_UNUSED == IS_UNUSED) {
+ if (UNEXPECTED(!EX(func)->common.scope)) {
+ SAVE_OPLINE();
+ zend_error(E_WARNING, "get_class() called without object from outside a class");
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ } else {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
+ ZEND_VM_NEXT_OPCODE();
+ }
+ } else {
+
+ zval *op1;
+
+ SAVE_OPLINE();
+ op1 = NULL;
+ if (Z_TYPE_P(op1) == IS_OBJECT) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
+ } else {
+ zend_error(E_WARNING, "get_class() expects parameter 1 to be object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ }
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ }
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+
+ if (Z_TYPE(EX(This)) == IS_OBJECT) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
+ } else if (Z_CE(EX(This))) {
+ ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
+ } else {
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ if (UNEXPECTED(!EX(func)->common.scope)) {
+ SAVE_OPLINE();
+ zend_error(E_WARNING, "get_called_class() called from outside a class");
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ }
+ }
+ ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+
+ ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
+ ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_array *ht;
+ uint32_t arg_count, first_extra_arg, i, n;
+ zval *p, *q;
+
+ arg_count = EX_NUM_ARGS();
+ ht = (zend_array *) emalloc(sizeof(zend_array));
+ if (IS_UNUSED == IS_CONST) {
+ i = Z_LVAL_P(EX_CONSTANT(opline->op1));
+ if (arg_count < i) {
+ i = 0;
+ } else {
+ i = arg_count - i;
+ }
+ zend_hash_init(ht, i, NULL, ZVAL_PTR_DTOR, 0);
+ } else {
+ zend_hash_init(ht, arg_count, NULL, ZVAL_PTR_DTOR, 0);
+ }
+ ZVAL_ARR(EX_VAR(opline->result.var), ht);
+ if (arg_count) {
+ first_extra_arg = EX(func)->op_array.num_args;
+ zend_hash_real_init(ht, 1);
+ ZEND_HASH_FILL_PACKED(ht) {
+ i = 0;
+ n = 0;
+ if (IS_UNUSED == IS_CONST) {
+ i = Z_LVAL_P(EX_CONSTANT(opline->op1));
+ }
+ p = EX_VAR_NUM(i);
+ if (arg_count > first_extra_arg) {
+ while (i < first_extra_arg) {
+ q = p;
+ if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
+ ZVAL_DEREF(q);
+ if (Z_OPT_REFCOUNTED_P(q)) {
+ Z_ADDREF_P(q);
+ }
- n++;
++ } else {
++ q = &EG(uninitialized_zval);
+ }
+ ZEND_HASH_FILL_ADD(q);
++ n++;
+ p++;
+ i++;
+ }
+ p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
+ }
+ while (i < arg_count) {
+ q = p;
+ if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
+ ZVAL_DEREF(q);
+ if (Z_OPT_REFCOUNTED_P(q)) {
+ Z_ADDREF_P(q);
+ }
++ } else {
++ q = &EG(uninitialized_zval);
+ }
+ ZEND_HASH_FILL_ADD(q);
++ n++;
+ p++;
+ i++;
+ }
+ } ZEND_HASH_FILL_END();
+ ht->nNumOfElements = n;
+ }
+ ZEND_VM_NEXT_OPCODE();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
{
USE_OPLINE
projects / php / commitdiff