Annotation of embedaddon/php/Zend/zend_vm_def.h, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | Zend Engine |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 2.00 of the Zend license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.zend.com/license/2_00.txt. |
! 11: | If you did not receive a copy of the Zend license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@zend.com so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Andi Gutmans <andi@zend.com> |
! 16: | Zeev Suraski <zeev@zend.com> |
! 17: | Dmitry Stogov <dmitry@zend.com> |
! 18: +----------------------------------------------------------------------+
! 19: */
! 20:
! 21: /* $Id: zend_vm_def.h 321634 2012-01-01 13:15:04Z felipe $ */
! 22:
! 23: /* If you change this file, please regenerate the zend_vm_execute.h and
! 24: * zend_vm_opcodes.h files by running:
! 25: * php zend_vm_gen.php
! 26: */
! 27:
! 28: ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 29: {
! 30: zend_op *opline = EX(opline);
! 31: zend_free_op free_op1, free_op2;
! 32:
! 33: add_function(&EX_T(opline->result.u.var).tmp_var,
! 34: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 35: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 36: FREE_OP1();
! 37: FREE_OP2();
! 38: ZEND_VM_NEXT_OPCODE();
! 39: }
! 40:
! 41: ZEND_VM_HANDLER(2, ZEND_SUB, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 42: {
! 43: zend_op *opline = EX(opline);
! 44: zend_free_op free_op1, free_op2;
! 45:
! 46: sub_function(&EX_T(opline->result.u.var).tmp_var,
! 47: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 48: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 49: FREE_OP1();
! 50: FREE_OP2();
! 51: ZEND_VM_NEXT_OPCODE();
! 52: }
! 53:
! 54: ZEND_VM_HANDLER(3, ZEND_MUL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 55: {
! 56: zend_op *opline = EX(opline);
! 57: zend_free_op free_op1, free_op2;
! 58:
! 59: mul_function(&EX_T(opline->result.u.var).tmp_var,
! 60: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 61: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 62: FREE_OP1();
! 63: FREE_OP2();
! 64: ZEND_VM_NEXT_OPCODE();
! 65: }
! 66:
! 67: ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 68: {
! 69: zend_op *opline = EX(opline);
! 70: zend_free_op free_op1, free_op2;
! 71:
! 72: div_function(&EX_T(opline->result.u.var).tmp_var,
! 73: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 74: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 75: FREE_OP1();
! 76: FREE_OP2();
! 77: ZEND_VM_NEXT_OPCODE();
! 78: }
! 79:
! 80: ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 81: {
! 82: zend_op *opline = EX(opline);
! 83: zend_free_op free_op1, free_op2;
! 84:
! 85: mod_function(&EX_T(opline->result.u.var).tmp_var,
! 86: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 87: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 88: FREE_OP1();
! 89: FREE_OP2();
! 90: ZEND_VM_NEXT_OPCODE();
! 91: }
! 92:
! 93: ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 94: {
! 95: zend_op *opline = EX(opline);
! 96: zend_free_op free_op1, free_op2;
! 97:
! 98: shift_left_function(&EX_T(opline->result.u.var).tmp_var,
! 99: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 100: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 101: FREE_OP1();
! 102: FREE_OP2();
! 103: ZEND_VM_NEXT_OPCODE();
! 104: }
! 105:
! 106: ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 107: {
! 108: zend_op *opline = EX(opline);
! 109: zend_free_op free_op1, free_op2;
! 110:
! 111: shift_right_function(&EX_T(opline->result.u.var).tmp_var,
! 112: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 113: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 114: FREE_OP1();
! 115: FREE_OP2();
! 116: ZEND_VM_NEXT_OPCODE();
! 117: }
! 118:
! 119: ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 120: {
! 121: zend_op *opline = EX(opline);
! 122: zend_free_op free_op1, free_op2;
! 123:
! 124: concat_function(&EX_T(opline->result.u.var).tmp_var,
! 125: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 126: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 127: FREE_OP1();
! 128: FREE_OP2();
! 129: ZEND_VM_NEXT_OPCODE();
! 130: }
! 131:
! 132: ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 133: {
! 134: zend_op *opline = EX(opline);
! 135: zend_free_op free_op1, free_op2;
! 136:
! 137: is_identical_function(&EX_T(opline->result.u.var).tmp_var,
! 138: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 139: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 140: FREE_OP1();
! 141: FREE_OP2();
! 142: ZEND_VM_NEXT_OPCODE();
! 143: }
! 144:
! 145: ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 146: {
! 147: zend_op *opline = EX(opline);
! 148: zend_free_op free_op1, free_op2;
! 149: zval *result = &EX_T(opline->result.u.var).tmp_var;
! 150:
! 151: is_identical_function(result,
! 152: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 153: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 154: Z_LVAL_P(result) = !Z_LVAL_P(result);
! 155: FREE_OP1();
! 156: FREE_OP2();
! 157: ZEND_VM_NEXT_OPCODE();
! 158: }
! 159:
! 160: ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 161: {
! 162: zend_op *opline = EX(opline);
! 163: zend_free_op free_op1, free_op2;
! 164: zval *result = &EX_T(opline->result.u.var).tmp_var;
! 165:
! 166: compare_function(result,
! 167: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 168: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 169: ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
! 170: FREE_OP1();
! 171: FREE_OP2();
! 172: ZEND_VM_NEXT_OPCODE();
! 173: }
! 174:
! 175: ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 176: {
! 177: zend_op *opline = EX(opline);
! 178: zend_free_op free_op1, free_op2;
! 179: zval *result = &EX_T(opline->result.u.var).tmp_var;
! 180:
! 181: compare_function(result,
! 182: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 183: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 184: ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
! 185: FREE_OP1();
! 186: FREE_OP2();
! 187: ZEND_VM_NEXT_OPCODE();
! 188: }
! 189:
! 190: ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 191: {
! 192: zend_op *opline = EX(opline);
! 193: zend_free_op free_op1, free_op2;
! 194: zval *result = &EX_T(opline->result.u.var).tmp_var;
! 195:
! 196: compare_function(result,
! 197: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 198: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 199: ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
! 200: FREE_OP1();
! 201: FREE_OP2();
! 202: ZEND_VM_NEXT_OPCODE();
! 203: }
! 204:
! 205: ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 206: {
! 207: zend_op *opline = EX(opline);
! 208: zend_free_op free_op1, free_op2;
! 209: zval *result = &EX_T(opline->result.u.var).tmp_var;
! 210:
! 211: compare_function(result,
! 212: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 213: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 214: ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
! 215: FREE_OP1();
! 216: FREE_OP2();
! 217: ZEND_VM_NEXT_OPCODE();
! 218: }
! 219:
! 220: ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 221: {
! 222: zend_op *opline = EX(opline);
! 223: zend_free_op free_op1, free_op2;
! 224:
! 225: bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
! 226: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 227: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 228: FREE_OP1();
! 229: FREE_OP2();
! 230: ZEND_VM_NEXT_OPCODE();
! 231: }
! 232:
! 233: ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 234: {
! 235: zend_op *opline = EX(opline);
! 236: zend_free_op free_op1, free_op2;
! 237:
! 238: bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
! 239: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 240: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 241: FREE_OP1();
! 242: FREE_OP2();
! 243: ZEND_VM_NEXT_OPCODE();
! 244: }
! 245:
! 246: ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 247: {
! 248: zend_op *opline = EX(opline);
! 249: zend_free_op free_op1, free_op2;
! 250:
! 251: bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
! 252: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 253: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 254: FREE_OP1();
! 255: FREE_OP2();
! 256: ZEND_VM_NEXT_OPCODE();
! 257: }
! 258:
! 259: ZEND_VM_HANDLER(14, ZEND_BOOL_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 260: {
! 261: zend_op *opline = EX(opline);
! 262: zend_free_op free_op1, free_op2;
! 263:
! 264: boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
! 265: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 266: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 267: FREE_OP1();
! 268: FREE_OP2();
! 269: ZEND_VM_NEXT_OPCODE();
! 270: }
! 271:
! 272: ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMP|VAR|CV, ANY)
! 273: {
! 274: zend_op *opline = EX(opline);
! 275: zend_free_op free_op1;
! 276:
! 277: bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
! 278: GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 279: FREE_OP1();
! 280: ZEND_VM_NEXT_OPCODE();
! 281: }
! 282:
! 283: ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMP|VAR|CV, ANY)
! 284: {
! 285: zend_op *opline = EX(opline);
! 286: zend_free_op free_op1;
! 287:
! 288: boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
! 289: GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 290: FREE_OP1();
! 291: ZEND_VM_NEXT_OPCODE();
! 292: }
! 293:
! 294: ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
! 295: {
! 296: zend_op *opline = EX(opline);
! 297: zend_op *op_data = opline+1;
! 298: zend_free_op free_op1, free_op2, free_op_data1;
! 299: zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
! 300: zval *object;
! 301: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 302: zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
! 303: znode *result = &opline->result;
! 304: int have_get_ptr = 0;
! 305:
! 306: if (OP1_TYPE == IS_VAR && !object_ptr) {
! 307: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
! 308: }
! 309:
! 310: EX_T(result->u.var).var.ptr_ptr = NULL;
! 311: make_real_object(object_ptr TSRMLS_CC);
! 312: object = *object_ptr;
! 313:
! 314: if (Z_TYPE_P(object) != IS_OBJECT) {
! 315: zend_error(E_WARNING, "Attempt to assign property of non-object");
! 316: FREE_OP2();
! 317: FREE_OP(free_op_data1);
! 318:
! 319: if (!RETURN_VALUE_UNUSED(result)) {
! 320: EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
! 321: EX_T(result->u.var).var.ptr_ptr = NULL;
! 322: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 323: }
! 324: } else {
! 325: /* here we are sure we are dealing with an object */
! 326: if (IS_OP2_TMP_FREE()) {
! 327: MAKE_REAL_ZVAL_PTR(property);
! 328: }
! 329:
! 330: /* here property is a string */
! 331: if (opline->extended_value == ZEND_ASSIGN_OBJ
! 332: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
! 333: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
! 334: if (zptr != NULL) { /* NULL means no success in getting PTR */
! 335: SEPARATE_ZVAL_IF_NOT_REF(zptr);
! 336:
! 337: have_get_ptr = 1;
! 338: binary_op(*zptr, *zptr, value TSRMLS_CC);
! 339: if (!RETURN_VALUE_UNUSED(result)) {
! 340: EX_T(result->u.var).var.ptr = *zptr;
! 341: EX_T(result->u.var).var.ptr_ptr = NULL;
! 342: PZVAL_LOCK(*zptr);
! 343: }
! 344: }
! 345: }
! 346:
! 347: if (!have_get_ptr) {
! 348: zval *z = NULL;
! 349:
! 350: if (opline->extended_value == ZEND_ASSIGN_OBJ) {
! 351: if (Z_OBJ_HT_P(object)->read_property) {
! 352: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
! 353: }
! 354: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
! 355: if (Z_OBJ_HT_P(object)->read_dimension) {
! 356: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
! 357: }
! 358: }
! 359: if (z) {
! 360: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
! 361: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
! 362:
! 363: if (Z_REFCOUNT_P(z) == 0) {
! 364: GC_REMOVE_ZVAL_FROM_BUFFER(z);
! 365: zval_dtor(z);
! 366: FREE_ZVAL(z);
! 367: }
! 368: z = value;
! 369: }
! 370: Z_ADDREF_P(z);
! 371: SEPARATE_ZVAL_IF_NOT_REF(&z);
! 372: binary_op(z, z, value TSRMLS_CC);
! 373: if (opline->extended_value == ZEND_ASSIGN_OBJ) {
! 374: Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
! 375: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
! 376: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
! 377: }
! 378: if (!RETURN_VALUE_UNUSED(result)) {
! 379: EX_T(result->u.var).var.ptr = z;
! 380: EX_T(result->u.var).var.ptr_ptr = NULL;
! 381: PZVAL_LOCK(z);
! 382: }
! 383: zval_ptr_dtor(&z);
! 384: } else {
! 385: zend_error(E_WARNING, "Attempt to assign property of non-object");
! 386: if (!RETURN_VALUE_UNUSED(result)) {
! 387: EX_T(result->u.var).var.ptr = EG(uninitialized_zval_ptr);
! 388: EX_T(result->u.var).var.ptr_ptr = NULL;
! 389: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 390: }
! 391: }
! 392: }
! 393:
! 394: if (IS_OP2_TMP_FREE()) {
! 395: zval_ptr_dtor(&property);
! 396: } else {
! 397: FREE_OP2();
! 398: }
! 399: FREE_OP(free_op_data1);
! 400: }
! 401:
! 402: FREE_OP1_VAR_PTR();
! 403: /* assign_obj has two opcodes! */
! 404: ZEND_VM_INC_OPCODE();
! 405: ZEND_VM_NEXT_OPCODE();
! 406: }
! 407:
! 408: ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
! 409: {
! 410: zend_op *opline = EX(opline);
! 411: zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
! 412: zval **var_ptr;
! 413: zval *value;
! 414:
! 415: switch (opline->extended_value) {
! 416: case ZEND_ASSIGN_OBJ:
! 417: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
! 418: break;
! 419: case ZEND_ASSIGN_DIM: {
! 420: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
! 421:
! 422: if (OP1_TYPE == IS_VAR && !container) {
! 423: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 424: } else if (Z_TYPE_PP(container) == IS_OBJECT) {
! 425: if (OP1_TYPE == IS_VAR && !OP1_FREE) {
! 426: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */
! 427: }
! 428: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
! 429: } else {
! 430: zend_op *op_data = opline+1;
! 431: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 432:
! 433: zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_RW TSRMLS_CC);
! 434: value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
! 435: var_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
! 436: ZEND_VM_INC_OPCODE();
! 437: }
! 438: }
! 439: break;
! 440: default:
! 441: value = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 442: var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
! 443: /* do nothing */
! 444: break;
! 445: }
! 446:
! 447: if (!var_ptr) {
! 448: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
! 449: }
! 450:
! 451: if (*var_ptr == EG(error_zval_ptr)) {
! 452: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 453: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 454: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 455: }
! 456: FREE_OP2();
! 457: FREE_OP1_VAR_PTR();
! 458: ZEND_VM_NEXT_OPCODE();
! 459: }
! 460:
! 461: SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
! 462:
! 463: if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
! 464: && Z_OBJ_HANDLER_PP(var_ptr, set)) {
! 465: /* proxy object */
! 466: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
! 467: Z_ADDREF_P(objval);
! 468: binary_op(objval, objval, value TSRMLS_CC);
! 469: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
! 470: zval_ptr_dtor(&objval);
! 471: } else {
! 472: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
! 473: }
! 474:
! 475: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 476: AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
! 477: PZVAL_LOCK(*var_ptr);
! 478: }
! 479: FREE_OP2();
! 480:
! 481: if (opline->extended_value == ZEND_ASSIGN_DIM) {
! 482: FREE_OP(free_op_data1);
! 483: FREE_OP_VAR_PTR(free_op_data2);
! 484: }
! 485: FREE_OP1_VAR_PTR();
! 486: ZEND_VM_NEXT_OPCODE();
! 487: }
! 488:
! 489: ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 490: {
! 491: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, add_function);
! 492: }
! 493:
! 494: ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 495: {
! 496: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, sub_function);
! 497: }
! 498:
! 499: ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 500: {
! 501: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mul_function);
! 502: }
! 503:
! 504: ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 505: {
! 506: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, div_function);
! 507: }
! 508:
! 509: ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 510: {
! 511: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mod_function);
! 512: }
! 513:
! 514: ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 515: {
! 516: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_left_function);
! 517: }
! 518:
! 519: ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 520: {
! 521: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_right_function);
! 522: }
! 523:
! 524: ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 525: {
! 526: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, concat_function);
! 527: }
! 528:
! 529: ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 530: {
! 531: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
! 532: }
! 533:
! 534: ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 535: {
! 536: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
! 537: }
! 538:
! 539: ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 540: {
! 541: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
! 542: }
! 543:
! 544: ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
! 545: {
! 546: zend_op *opline = EX(opline);
! 547: zend_free_op free_op1, free_op2;
! 548: zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
! 549: zval *object;
! 550: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 551: zval **retval = &EX_T(opline->result.u.var).var.ptr;
! 552: int have_get_ptr = 0;
! 553:
! 554: if (OP1_TYPE == IS_VAR && !object_ptr) {
! 555: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
! 556: }
! 557:
! 558: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
! 559: object = *object_ptr;
! 560:
! 561: if (Z_TYPE_P(object) != IS_OBJECT) {
! 562: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
! 563: FREE_OP2();
! 564: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 565: *retval = EG(uninitialized_zval_ptr);
! 566: PZVAL_LOCK(*retval);
! 567: }
! 568: FREE_OP1_VAR_PTR();
! 569: ZEND_VM_NEXT_OPCODE();
! 570: }
! 571:
! 572: /* here we are sure we are dealing with an object */
! 573:
! 574: if (IS_OP2_TMP_FREE()) {
! 575: MAKE_REAL_ZVAL_PTR(property);
! 576: }
! 577:
! 578: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
! 579: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
! 580: if (zptr != NULL) { /* NULL means no success in getting PTR */
! 581: SEPARATE_ZVAL_IF_NOT_REF(zptr);
! 582:
! 583: have_get_ptr = 1;
! 584: incdec_op(*zptr);
! 585: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 586: *retval = *zptr;
! 587: PZVAL_LOCK(*retval);
! 588: }
! 589: }
! 590: }
! 591:
! 592: if (!have_get_ptr) {
! 593: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
! 594: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
! 595:
! 596: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
! 597: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
! 598:
! 599: if (Z_REFCOUNT_P(z) == 0) {
! 600: GC_REMOVE_ZVAL_FROM_BUFFER(z);
! 601: zval_dtor(z);
! 602: FREE_ZVAL(z);
! 603: }
! 604: z = value;
! 605: }
! 606: Z_ADDREF_P(z);
! 607: SEPARATE_ZVAL_IF_NOT_REF(&z);
! 608: incdec_op(z);
! 609: *retval = z;
! 610: Z_OBJ_HT_P(object)->write_property(object, property, z TSRMLS_CC);
! 611: SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
! 612: zval_ptr_dtor(&z);
! 613: } else {
! 614: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
! 615: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 616: *retval = EG(uninitialized_zval_ptr);
! 617: PZVAL_LOCK(*retval);
! 618: }
! 619: }
! 620: }
! 621:
! 622: if (IS_OP2_TMP_FREE()) {
! 623: zval_ptr_dtor(&property);
! 624: } else {
! 625: FREE_OP2();
! 626: }
! 627: FREE_OP1_VAR_PTR();
! 628: ZEND_VM_NEXT_OPCODE();
! 629: }
! 630:
! 631: ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 632: {
! 633: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, incdec_op, increment_function);
! 634: }
! 635:
! 636: ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 637: {
! 638: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_pre_incdec_property_helper, incdec_op, decrement_function);
! 639: }
! 640:
! 641: ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
! 642: {
! 643: zend_op *opline = EX(opline);
! 644: zend_free_op free_op1, free_op2;
! 645: zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
! 646: zval *object;
! 647: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 648: zval *retval = &EX_T(opline->result.u.var).tmp_var;
! 649: int have_get_ptr = 0;
! 650:
! 651: if (OP1_TYPE == IS_VAR && !object_ptr) {
! 652: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
! 653: }
! 654:
! 655: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
! 656: object = *object_ptr;
! 657:
! 658: if (Z_TYPE_P(object) != IS_OBJECT) {
! 659: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
! 660: FREE_OP2();
! 661: *retval = *EG(uninitialized_zval_ptr);
! 662: FREE_OP1_VAR_PTR();
! 663: ZEND_VM_NEXT_OPCODE();
! 664: }
! 665:
! 666: /* here we are sure we are dealing with an object */
! 667:
! 668: if (IS_OP2_TMP_FREE()) {
! 669: MAKE_REAL_ZVAL_PTR(property);
! 670: }
! 671:
! 672: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
! 673: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
! 674: if (zptr != NULL) { /* NULL means no success in getting PTR */
! 675: have_get_ptr = 1;
! 676: SEPARATE_ZVAL_IF_NOT_REF(zptr);
! 677:
! 678: *retval = **zptr;
! 679: zendi_zval_copy_ctor(*retval);
! 680:
! 681: incdec_op(*zptr);
! 682:
! 683: }
! 684: }
! 685:
! 686: if (!have_get_ptr) {
! 687: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
! 688: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R TSRMLS_CC);
! 689: zval *z_copy;
! 690:
! 691: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
! 692: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
! 693:
! 694: if (Z_REFCOUNT_P(z) == 0) {
! 695: GC_REMOVE_ZVAL_FROM_BUFFER(z);
! 696: zval_dtor(z);
! 697: FREE_ZVAL(z);
! 698: }
! 699: z = value;
! 700: }
! 701: *retval = *z;
! 702: zendi_zval_copy_ctor(*retval);
! 703: ALLOC_ZVAL(z_copy);
! 704: *z_copy = *z;
! 705: zendi_zval_copy_ctor(*z_copy);
! 706: INIT_PZVAL(z_copy);
! 707: incdec_op(z_copy);
! 708: Z_ADDREF_P(z);
! 709: Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
! 710: zval_ptr_dtor(&z_copy);
! 711: zval_ptr_dtor(&z);
! 712: } else {
! 713: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
! 714: *retval = *EG(uninitialized_zval_ptr);
! 715: }
! 716: }
! 717:
! 718: if (IS_OP2_TMP_FREE()) {
! 719: zval_ptr_dtor(&property);
! 720: } else {
! 721: FREE_OP2();
! 722: }
! 723: FREE_OP1_VAR_PTR();
! 724: ZEND_VM_NEXT_OPCODE();
! 725: }
! 726:
! 727: ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 728: {
! 729: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, incdec_op, increment_function);
! 730: }
! 731:
! 732: ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 733: {
! 734: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_post_incdec_property_helper, incdec_op, decrement_function);
! 735: }
! 736:
! 737: ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
! 738: {
! 739: zend_op *opline = EX(opline);
! 740: zend_free_op free_op1;
! 741: zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
! 742:
! 743: if (OP1_TYPE == IS_VAR && !var_ptr) {
! 744: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
! 745: }
! 746: if (OP1_TYPE == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
! 747: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 748: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 749: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 750: }
! 751: FREE_OP1_VAR_PTR();
! 752: ZEND_VM_NEXT_OPCODE();
! 753: }
! 754:
! 755: SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
! 756:
! 757: if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
! 758: && Z_OBJ_HANDLER_PP(var_ptr, set)) {
! 759: /* proxy object */
! 760: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
! 761: Z_ADDREF_P(val);
! 762: increment_function(val);
! 763: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
! 764: zval_ptr_dtor(&val);
! 765: } else {
! 766: increment_function(*var_ptr);
! 767: }
! 768:
! 769: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 770: AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
! 771: PZVAL_LOCK(*var_ptr);
! 772: }
! 773:
! 774: FREE_OP1_VAR_PTR();
! 775: ZEND_VM_NEXT_OPCODE();
! 776: }
! 777:
! 778: ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
! 779: {
! 780: zend_op *opline = EX(opline);
! 781: zend_free_op free_op1;
! 782: zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
! 783:
! 784: if (OP1_TYPE == IS_VAR && !var_ptr) {
! 785: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
! 786: }
! 787: if (OP1_TYPE == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
! 788: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 789: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 790: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 791: }
! 792: FREE_OP1_VAR_PTR();
! 793: ZEND_VM_NEXT_OPCODE();
! 794: }
! 795:
! 796: SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
! 797:
! 798: if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
! 799: && Z_OBJ_HANDLER_PP(var_ptr, set)) {
! 800: /* proxy object */
! 801: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
! 802: Z_ADDREF_P(val);
! 803: decrement_function(val);
! 804: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
! 805: zval_ptr_dtor(&val);
! 806: } else {
! 807: decrement_function(*var_ptr);
! 808: }
! 809:
! 810: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 811: AI_SET_PTR(EX_T(opline->result.u.var).var, *var_ptr);
! 812: PZVAL_LOCK(*var_ptr);
! 813: }
! 814:
! 815: FREE_OP1_VAR_PTR();
! 816: ZEND_VM_NEXT_OPCODE();
! 817: }
! 818:
! 819: ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
! 820: {
! 821: zend_op *opline = EX(opline);
! 822: zend_free_op free_op1;
! 823: zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
! 824:
! 825: if (OP1_TYPE == IS_VAR && !var_ptr) {
! 826: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
! 827: }
! 828: if (OP1_TYPE == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
! 829: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 830: EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
! 831: }
! 832: FREE_OP1_VAR_PTR();
! 833: ZEND_VM_NEXT_OPCODE();
! 834: }
! 835:
! 836: EX_T(opline->result.u.var).tmp_var = **var_ptr;
! 837: zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
! 838:
! 839: SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
! 840:
! 841: if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
! 842: && Z_OBJ_HANDLER_PP(var_ptr, set)) {
! 843: /* proxy object */
! 844: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
! 845: Z_ADDREF_P(val);
! 846: increment_function(val);
! 847: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
! 848: zval_ptr_dtor(&val);
! 849: } else {
! 850: increment_function(*var_ptr);
! 851: }
! 852:
! 853: FREE_OP1_VAR_PTR();
! 854: ZEND_VM_NEXT_OPCODE();
! 855: }
! 856:
! 857: ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
! 858: {
! 859: zend_op *opline = EX(opline);
! 860: zend_free_op free_op1;
! 861: zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
! 862:
! 863: if (OP1_TYPE == IS_VAR && !var_ptr) {
! 864: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
! 865: }
! 866: if (OP1_TYPE == IS_VAR && *var_ptr == EG(error_zval_ptr)) {
! 867: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 868: EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
! 869: }
! 870: FREE_OP1_VAR_PTR();
! 871: ZEND_VM_NEXT_OPCODE();
! 872: }
! 873:
! 874: EX_T(opline->result.u.var).tmp_var = **var_ptr;
! 875: zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
! 876:
! 877: SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
! 878:
! 879: if(Z_TYPE_PP(var_ptr) == IS_OBJECT && Z_OBJ_HANDLER_PP(var_ptr, get)
! 880: && Z_OBJ_HANDLER_PP(var_ptr, set)) {
! 881: /* proxy object */
! 882: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
! 883: Z_ADDREF_P(val);
! 884: decrement_function(val);
! 885: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
! 886: zval_ptr_dtor(&val);
! 887: } else {
! 888: decrement_function(*var_ptr);
! 889: }
! 890:
! 891: FREE_OP1_VAR_PTR();
! 892: ZEND_VM_NEXT_OPCODE();
! 893: }
! 894:
! 895: ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
! 896: {
! 897: zend_op *opline = EX(opline);
! 898: zend_free_op free_op1;
! 899: zval z_copy;
! 900: zval *z = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 901:
! 902: if (OP1_TYPE != IS_CONST &&
! 903: Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get_method != NULL) {
! 904: if (OP1_TYPE == IS_TMP_VAR) {
! 905: INIT_PZVAL(z);
! 906: }
! 907: if (zend_std_cast_object_tostring(z, &z_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
! 908: zend_print_variable(&z_copy);
! 909: zval_dtor(&z_copy);
! 910: } else {
! 911: zend_print_variable(z);
! 912: }
! 913: } else {
! 914: zend_print_variable(z);
! 915: }
! 916:
! 917: FREE_OP1();
! 918: ZEND_VM_NEXT_OPCODE();
! 919: }
! 920:
! 921: ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY)
! 922: {
! 923: zend_op *opline = EX(opline);
! 924:
! 925: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
! 926: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
! 927:
! 928: ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO);
! 929: }
! 930:
! 931: ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type)
! 932: {
! 933: zend_op *opline = EX(opline);
! 934: zend_free_op free_op1;
! 935: zval *varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 936: zval **retval;
! 937: zval tmp_varname;
! 938: HashTable *target_symbol_table;
! 939:
! 940: if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
! 941: tmp_varname = *varname;
! 942: zval_copy_ctor(&tmp_varname);
! 943: convert_to_string(&tmp_varname);
! 944: varname = &tmp_varname;
! 945: }
! 946:
! 947: if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
! 948: retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
! 949: FREE_OP1();
! 950: } else {
! 951: target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
! 952: /*
! 953: if (!target_symbol_table) {
! 954: ZEND_VM_NEXT_OPCODE();
! 955: }
! 956: */
! 957: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &retval) == FAILURE) {
! 958: switch (type) {
! 959: case BP_VAR_R:
! 960: case BP_VAR_UNSET:
! 961: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
! 962: /* break missing intentionally */
! 963: case BP_VAR_IS:
! 964: retval = &EG(uninitialized_zval_ptr);
! 965: break;
! 966: case BP_VAR_RW:
! 967: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
! 968: /* break missing intentionally */
! 969: case BP_VAR_W: {
! 970: zval *new_zval = &EG(uninitialized_zval);
! 971:
! 972: Z_ADDREF_P(new_zval);
! 973: zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
! 974: }
! 975: break;
! 976: EMPTY_SWITCH_DEFAULT_CASE()
! 977: }
! 978: }
! 979: switch (opline->op2.u.EA.type) {
! 980: case ZEND_FETCH_GLOBAL:
! 981: if (OP1_TYPE != IS_TMP_VAR) {
! 982: FREE_OP1();
! 983: }
! 984: break;
! 985: case ZEND_FETCH_LOCAL:
! 986: FREE_OP1();
! 987: break;
! 988: case ZEND_FETCH_STATIC:
! 989: zval_update_constant(retval, (void*) 1 TSRMLS_CC);
! 990: break;
! 991: case ZEND_FETCH_GLOBAL_LOCK:
! 992: if (OP1_TYPE == IS_VAR && !free_op1.var) {
! 993: PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
! 994: }
! 995: break;
! 996: }
! 997: }
! 998:
! 999:
! 1000: if (OP1_TYPE != IS_CONST && varname == &tmp_varname) {
! 1001: zval_dtor(varname);
! 1002: }
! 1003: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1004: if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
! 1005: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
! 1006: }
! 1007: PZVAL_LOCK(*retval);
! 1008: switch (type) {
! 1009: case BP_VAR_R:
! 1010: case BP_VAR_IS:
! 1011: AI_SET_PTR(EX_T(opline->result.u.var).var, *retval);
! 1012: break;
! 1013: case BP_VAR_UNSET: {
! 1014: zend_free_op free_res;
! 1015:
! 1016: EX_T(opline->result.u.var).var.ptr_ptr = retval;
! 1017: PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
! 1018: if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
! 1019: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
! 1020: }
! 1021: PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
! 1022: FREE_OP_VAR_PTR(free_res);
! 1023: break;
! 1024: default:
! 1025: EX_T(opline->result.u.var).var.ptr_ptr = retval;
! 1026: break;
! 1027: }
! 1028: }
! 1029: }
! 1030: ZEND_VM_NEXT_OPCODE();
! 1031: }
! 1032:
! 1033: ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMP|VAR|CV, ANY)
! 1034: {
! 1035: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
! 1036: }
! 1037:
! 1038: ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMP|VAR|CV, ANY)
! 1039: {
! 1040: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
! 1041: }
! 1042:
! 1043: ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMP|VAR|CV, ANY)
! 1044: {
! 1045: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_RW);
! 1046: }
! 1047:
! 1048: ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMP|VAR|CV, ANY)
! 1049: {
! 1050: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type,
! 1051: ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), EX(opline)->extended_value)?BP_VAR_W:BP_VAR_R);
! 1052: }
! 1053:
! 1054: ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMP|VAR|CV, ANY)
! 1055: {
! 1056: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
! 1057: }
! 1058:
! 1059: ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMP|VAR|CV, ANY)
! 1060: {
! 1061: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
! 1062: }
! 1063:
! 1064: ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, VAR|CV, CONST|TMP|VAR|CV)
! 1065: {
! 1066: zend_op *opline = EX(opline);
! 1067: zend_free_op free_op1, free_op2;
! 1068: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1069: zval **container;
! 1070:
! 1071: if (opline->extended_value == ZEND_FETCH_ADD_LOCK &&
! 1072: OP1_TYPE != IS_CV &&
! 1073: EX_T(opline->op1.u.var).var.ptr_ptr) {
! 1074: PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
! 1075: }
! 1076: container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
! 1077: if (OP1_TYPE == IS_VAR && !container) {
! 1078: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1079: }
! 1080: zend_fetch_dimension_address_read(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_R TSRMLS_CC);
! 1081: FREE_OP2();
! 1082: FREE_OP1_VAR_PTR();
! 1083: ZEND_VM_NEXT_OPCODE();
! 1084: }
! 1085:
! 1086: ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
! 1087: {
! 1088: zend_op *opline = EX(opline);
! 1089: zend_free_op free_op1, free_op2;
! 1090: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1091: zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 1092:
! 1093: if (OP1_TYPE == IS_VAR && !container) {
! 1094: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1095: }
! 1096: zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_W TSRMLS_CC);
! 1097: FREE_OP2();
! 1098: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1099: READY_TO_DESTROY(free_op1.var)) {
! 1100: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1101: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1102: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1103: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1104: }
! 1105: }
! 1106: FREE_OP1_VAR_PTR();
! 1107:
! 1108: /* We are going to assign the result by reference */
! 1109: if (opline->extended_value && EX_T(opline->result.u.var).var.ptr_ptr) {
! 1110: Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
! 1111: SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
! 1112: Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
! 1113: }
! 1114:
! 1115: ZEND_VM_NEXT_OPCODE();
! 1116: }
! 1117:
! 1118: ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
! 1119: {
! 1120: zend_op *opline = EX(opline);
! 1121: zend_free_op free_op1, free_op2;
! 1122: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1123: zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
! 1124:
! 1125: if (OP1_TYPE == IS_VAR && !container) {
! 1126: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1127: }
! 1128: zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_RW TSRMLS_CC);
! 1129: FREE_OP2();
! 1130: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1131: READY_TO_DESTROY(free_op1.var)) {
! 1132: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1133: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1134: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1135: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1136: }
! 1137: }
! 1138: FREE_OP1_VAR_PTR();
! 1139: ZEND_VM_NEXT_OPCODE();
! 1140: }
! 1141:
! 1142: ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
! 1143: {
! 1144: zend_op *opline = EX(opline);
! 1145: zend_free_op free_op1, free_op2;
! 1146: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1147: zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_IS);
! 1148:
! 1149: if (OP1_TYPE == IS_VAR && !container) {
! 1150: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1151: }
! 1152: zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_IS TSRMLS_CC);
! 1153: FREE_OP2();
! 1154: FREE_OP1_VAR_PTR();
! 1155: ZEND_VM_NEXT_OPCODE();
! 1156: }
! 1157:
! 1158: ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
! 1159: {
! 1160: zend_op *opline = EX(opline);
! 1161: zend_free_op free_op1, free_op2;
! 1162: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1163: zval **container;
! 1164:
! 1165: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
! 1166: container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 1167: if (OP1_TYPE == IS_VAR && !container) {
! 1168: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1169: }
! 1170: zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_W TSRMLS_CC);
! 1171: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1172: READY_TO_DESTROY(free_op1.var)) {
! 1173: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1174: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1175: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1176: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1177: }
! 1178: }
! 1179: } else {
! 1180: if (OP2_TYPE == IS_UNUSED) {
! 1181: zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
! 1182: }
! 1183: container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
! 1184: if (OP1_TYPE == IS_VAR && !container) {
! 1185: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1186: }
! 1187: zend_fetch_dimension_address_read(&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_R TSRMLS_CC);
! 1188: }
! 1189: FREE_OP2();
! 1190: FREE_OP1_VAR_PTR();
! 1191: ZEND_VM_NEXT_OPCODE();
! 1192: }
! 1193:
! 1194: ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
! 1195: {
! 1196: zend_op *opline = EX(opline);
! 1197: zend_free_op free_op1, free_op2;
! 1198: zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET);
! 1199: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1200:
! 1201: /* Not needed in DIM_UNSET
! 1202: if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
! 1203: PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
! 1204: }
! 1205: */
! 1206: if (OP1_TYPE == IS_CV) {
! 1207: if (container != &EG(uninitialized_zval_ptr)) {
! 1208: SEPARATE_ZVAL_IF_NOT_REF(container);
! 1209: }
! 1210: }
! 1211: if (OP1_TYPE == IS_VAR && !container) {
! 1212: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1213: }
! 1214: zend_fetch_dimension_address(&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_UNSET TSRMLS_CC);
! 1215: FREE_OP2();
! 1216: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1217: READY_TO_DESTROY(free_op1.var)) {
! 1218: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1219: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1220: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1221: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1222: }
! 1223: }
! 1224: FREE_OP1_VAR_PTR();
! 1225: if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
! 1226: zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
! 1227: } else {
! 1228: zend_free_op free_res;
! 1229:
! 1230: PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
! 1231: if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
! 1232: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
! 1233: }
! 1234: PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
! 1235: FREE_OP_VAR_PTR(free_res);
! 1236: }
! 1237: ZEND_VM_NEXT_OPCODE();
! 1238: }
! 1239:
! 1240: ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int type)
! 1241: {
! 1242: zend_op *opline = EX(opline);
! 1243: zend_free_op free_op1;
! 1244: zval *container = GET_OP1_OBJ_ZVAL_PTR(type);
! 1245: zend_free_op free_op2;
! 1246: zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1247:
! 1248: if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
! 1249: if (type != BP_VAR_IS) {
! 1250: zend_error(E_NOTICE, "Trying to get property of non-object");
! 1251: }
! 1252: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1253: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 1254: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 1255: }
! 1256: FREE_OP2();
! 1257: } else {
! 1258: zval *retval;
! 1259:
! 1260: if (IS_OP2_TMP_FREE()) {
! 1261: MAKE_REAL_ZVAL_PTR(offset);
! 1262: }
! 1263:
! 1264: /* here we are sure we are dealing with an object */
! 1265: retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
! 1266:
! 1267: if (RETURN_VALUE_UNUSED(&opline->result)) {
! 1268: if (Z_REFCOUNT_P(retval) == 0) {
! 1269: GC_REMOVE_ZVAL_FROM_BUFFER(retval);
! 1270: zval_dtor(retval);
! 1271: FREE_ZVAL(retval);
! 1272: }
! 1273: } else {
! 1274: AI_SET_PTR(EX_T(opline->result.u.var).var, retval);
! 1275: PZVAL_LOCK(retval);
! 1276: }
! 1277:
! 1278: if (IS_OP2_TMP_FREE()) {
! 1279: zval_ptr_dtor(&offset);
! 1280: } else {
! 1281: FREE_OP2();
! 1282: }
! 1283: }
! 1284:
! 1285: FREE_OP1();
! 1286: ZEND_VM_NEXT_OPCODE();
! 1287: }
! 1288:
! 1289: ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1290: {
! 1291: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_property_address_read_helper, type, BP_VAR_R);
! 1292: }
! 1293:
! 1294: ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1295: {
! 1296: zend_op *opline = EX(opline);
! 1297: zend_free_op free_op1, free_op2;
! 1298: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1299: zval **container;
! 1300:
! 1301: if (OP1_TYPE == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
! 1302: PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
! 1303: EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
! 1304: }
! 1305:
! 1306: if (IS_OP2_TMP_FREE()) {
! 1307: MAKE_REAL_ZVAL_PTR(property);
! 1308: }
! 1309: container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
! 1310: if (OP1_TYPE == IS_VAR && !container) {
! 1311: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
! 1312: }
! 1313: zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
! 1314: if (IS_OP2_TMP_FREE()) {
! 1315: zval_ptr_dtor(&property);
! 1316: } else {
! 1317: FREE_OP2();
! 1318: }
! 1319: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1320: READY_TO_DESTROY(free_op1.var)) {
! 1321: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1322: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1323: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1324: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1325: }
! 1326: }
! 1327: FREE_OP1_VAR_PTR();
! 1328:
! 1329: /* We are going to assign the result by reference */
! 1330: if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
! 1331: Z_DELREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
! 1332: SEPARATE_ZVAL_TO_MAKE_IS_REF(EX_T(opline->result.u.var).var.ptr_ptr);
! 1333: Z_ADDREF_PP(EX_T(opline->result.u.var).var.ptr_ptr);
! 1334: }
! 1335:
! 1336: ZEND_VM_NEXT_OPCODE();
! 1337: }
! 1338:
! 1339: ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1340: {
! 1341: zend_op *opline = EX(opline);
! 1342: zend_free_op free_op1, free_op2;
! 1343: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1344: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
! 1345:
! 1346: if (IS_OP2_TMP_FREE()) {
! 1347: MAKE_REAL_ZVAL_PTR(property);
! 1348: }
! 1349: if (OP1_TYPE == IS_VAR && !container) {
! 1350: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
! 1351: }
! 1352: zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_RW TSRMLS_CC);
! 1353: if (IS_OP2_TMP_FREE()) {
! 1354: zval_ptr_dtor(&property);
! 1355: } else {
! 1356: FREE_OP2();
! 1357: }
! 1358: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1359: READY_TO_DESTROY(free_op1.var)) {
! 1360: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1361: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1362: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1363: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1364: }
! 1365: }
! 1366: FREE_OP1_VAR_PTR();
! 1367: ZEND_VM_NEXT_OPCODE();
! 1368: }
! 1369:
! 1370: ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1371: {
! 1372: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_property_address_read_helper, type, BP_VAR_IS);
! 1373: }
! 1374:
! 1375: ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1376: {
! 1377: zend_op *opline = EX(opline);
! 1378:
! 1379: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
! 1380: /* Behave like FETCH_OBJ_W */
! 1381: zend_free_op free_op1, free_op2;
! 1382: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1383: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
! 1384:
! 1385: if (IS_OP2_TMP_FREE()) {
! 1386: MAKE_REAL_ZVAL_PTR(property);
! 1387: }
! 1388: if (OP1_TYPE == IS_VAR && !container) {
! 1389: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
! 1390: }
! 1391: zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_W TSRMLS_CC);
! 1392: if (IS_OP2_TMP_FREE()) {
! 1393: zval_ptr_dtor(&property);
! 1394: } else {
! 1395: FREE_OP2();
! 1396: }
! 1397: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1398: READY_TO_DESTROY(free_op1.var)) {
! 1399: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1400: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1401: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1402: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1403: }
! 1404: }
! 1405: FREE_OP1_VAR_PTR();
! 1406: ZEND_VM_NEXT_OPCODE();
! 1407: } else {
! 1408: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_property_address_read_helper, type, BP_VAR_R);
! 1409: }
! 1410: }
! 1411:
! 1412: ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1413: {
! 1414: zend_op *opline = EX(opline);
! 1415: zend_free_op free_op1, free_op2, free_res;
! 1416: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_R);
! 1417: zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1418:
! 1419: if (OP1_TYPE == IS_CV) {
! 1420: if (container != &EG(uninitialized_zval_ptr)) {
! 1421: SEPARATE_ZVAL_IF_NOT_REF(container);
! 1422: }
! 1423: }
! 1424: if (IS_OP2_TMP_FREE()) {
! 1425: MAKE_REAL_ZVAL_PTR(property);
! 1426: }
! 1427: if (OP1_TYPE == IS_VAR && !container) {
! 1428: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
! 1429: }
! 1430: zend_fetch_property_address(&EX_T(opline->result.u.var), container, property, BP_VAR_UNSET TSRMLS_CC);
! 1431: if (IS_OP2_TMP_FREE()) {
! 1432: zval_ptr_dtor(&property);
! 1433: } else {
! 1434: FREE_OP2();
! 1435: }
! 1436: if (OP1_TYPE == IS_VAR && OP1_FREE &&
! 1437: READY_TO_DESTROY(free_op1.var)) {
! 1438: AI_USE_PTR(EX_T(opline->result.u.var).var);
! 1439: if (!PZVAL_IS_REF(*EX_T(opline->result.u.var).var.ptr_ptr) &&
! 1440: Z_REFCOUNT_PP(EX_T(opline->result.u.var).var.ptr_ptr) > 2) {
! 1441: SEPARATE_ZVAL(EX_T(opline->result.u.var).var.ptr_ptr);
! 1442: }
! 1443: }
! 1444: FREE_OP1_VAR_PTR();
! 1445:
! 1446: PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
! 1447: if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
! 1448: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
! 1449: }
! 1450: PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
! 1451: FREE_OP_VAR_PTR(free_res);
! 1452: ZEND_VM_NEXT_OPCODE();
! 1453: }
! 1454:
! 1455: ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, CONST|TMP, CONST)
! 1456: {
! 1457: zend_op *opline = EX(opline);
! 1458: zend_free_op free_op1;
! 1459: zval *container = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 1460:
! 1461: if (Z_TYPE_P(container) != IS_ARRAY) {
! 1462: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1463: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 1464: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 1465: }
! 1466: } else {
! 1467: zend_free_op free_op2;
! 1468: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1469:
! 1470: AI_SET_PTR(EX_T(opline->result.u.var).var, *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC));
! 1471: SELECTIVE_PZVAL_LOCK(EX_T(opline->result.u.var).var.ptr, &opline->result);
! 1472: FREE_OP2();
! 1473: }
! 1474: ZEND_VM_NEXT_OPCODE();
! 1475: }
! 1476:
! 1477: ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1478: {
! 1479: zend_op *opline = EX(opline);
! 1480: zend_op *op_data = opline+1;
! 1481: zend_free_op free_op1, free_op2;
! 1482: zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
! 1483: zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1484:
! 1485: if (IS_OP2_TMP_FREE()) {
! 1486: MAKE_REAL_ZVAL_PTR(property_name);
! 1487: }
! 1488: if (OP1_TYPE == IS_VAR && !object_ptr) {
! 1489: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1490: }
! 1491: zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_OBJ TSRMLS_CC);
! 1492: if (IS_OP2_TMP_FREE()) {
! 1493: zval_ptr_dtor(&property_name);
! 1494: } else {
! 1495: FREE_OP2();
! 1496: }
! 1497: FREE_OP1_VAR_PTR();
! 1498: /* assign_obj has two opcodes! */
! 1499: ZEND_VM_INC_OPCODE();
! 1500: ZEND_VM_NEXT_OPCODE();
! 1501: }
! 1502:
! 1503: ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
! 1504: {
! 1505: zend_op *opline = EX(opline);
! 1506: zend_op *op_data = opline+1;
! 1507: zend_free_op free_op1;
! 1508: zval **object_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 1509:
! 1510: if (OP1_TYPE == IS_VAR && !object_ptr) {
! 1511: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
! 1512: }
! 1513: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
! 1514: zend_free_op free_op2;
! 1515: zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1516:
! 1517: if (IS_OP2_TMP_FREE()) {
! 1518: MAKE_REAL_ZVAL_PTR(property_name);
! 1519: }
! 1520: zend_assign_to_object(&opline->result, object_ptr, property_name, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
! 1521: if (IS_OP2_TMP_FREE()) {
! 1522: zval_ptr_dtor(&property_name);
! 1523: } else {
! 1524: FREE_OP2();
! 1525: }
! 1526: } else {
! 1527: zend_free_op free_op2, free_op_data1, free_op_data2;
! 1528: zval *value;
! 1529: zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1530: zval **variable_ptr_ptr;
! 1531:
! 1532: zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, IS_OP2_TMP_FREE(), BP_VAR_W TSRMLS_CC);
! 1533: FREE_OP2();
! 1534:
! 1535: value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
! 1536: variable_ptr_ptr = _get_zval_ptr_ptr_var(&op_data->op2, EX(Ts), &free_op_data2 TSRMLS_CC);
! 1537: if (!variable_ptr_ptr) {
! 1538: if (zend_assign_to_string_offset(&EX_T(op_data->op2.u.var), value, op_data->op1.op_type TSRMLS_CC)) {
! 1539: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1540: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 1541: ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 1542: INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
! 1543: ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(op_data->op2.u.var).str_offset.str)+EX_T(op_data->op2.u.var).str_offset.offset, 1, 1);
! 1544: }
! 1545: } else if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1546: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 1547: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 1548: }
! 1549: } else {
! 1550: value = zend_assign_to_variable(variable_ptr_ptr, value, IS_TMP_FREE(free_op_data1) TSRMLS_CC);
! 1551: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1552: AI_SET_PTR(EX_T(opline->result.u.var).var, value);
! 1553: PZVAL_LOCK(value);
! 1554: }
! 1555: }
! 1556: FREE_OP_VAR_PTR(free_op_data2);
! 1557: FREE_OP_IF_VAR(free_op_data1);
! 1558: }
! 1559: FREE_OP1_VAR_PTR();
! 1560: /* assign_dim has two opcodes! */
! 1561: ZEND_VM_INC_OPCODE();
! 1562: ZEND_VM_NEXT_OPCODE();
! 1563: }
! 1564:
! 1565: ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
! 1566: {
! 1567: zend_op *opline = EX(opline);
! 1568: zend_free_op free_op1, free_op2;
! 1569: zval *value = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1570: zval **variable_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 1571:
! 1572: if (OP1_TYPE == IS_VAR && !variable_ptr_ptr) {
! 1573: if (zend_assign_to_string_offset(&EX_T(opline->op1.u.var), value, OP2_TYPE TSRMLS_CC)) {
! 1574: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1575: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 1576: ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 1577: INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
! 1578: ZVAL_STRINGL(EX_T(opline->result.u.var).var.ptr, Z_STRVAL_P(EX_T(opline->op1.u.var).str_offset.str)+EX_T(opline->op1.u.var).str_offset.offset, 1, 1);
! 1579: }
! 1580: } else if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1581: AI_SET_PTR(EX_T(opline->result.u.var).var, EG(uninitialized_zval_ptr));
! 1582: PZVAL_LOCK(EG(uninitialized_zval_ptr));
! 1583: }
! 1584: } else {
! 1585: value = zend_assign_to_variable(variable_ptr_ptr, value, IS_OP2_TMP_FREE() TSRMLS_CC);
! 1586: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1587: AI_SET_PTR(EX_T(opline->result.u.var).var, value);
! 1588: PZVAL_LOCK(value);
! 1589: }
! 1590: }
! 1591:
! 1592: FREE_OP1_VAR_PTR();
! 1593:
! 1594: /* zend_assign_to_variable() always takes care of op2, never free it! */
! 1595: FREE_OP2_IF_VAR();
! 1596:
! 1597: ZEND_VM_NEXT_OPCODE();
! 1598: }
! 1599:
! 1600: ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
! 1601: {
! 1602: zend_op *opline = EX(opline);
! 1603: zend_free_op free_op1, free_op2;
! 1604: zval **variable_ptr_ptr;
! 1605: zval **value_ptr_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
! 1606:
! 1607: if (OP2_TYPE == IS_VAR &&
! 1608: value_ptr_ptr &&
! 1609: !Z_ISREF_PP(value_ptr_ptr) &&
! 1610: opline->extended_value == ZEND_RETURNS_FUNCTION &&
! 1611: !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
! 1612: if (free_op2.var == NULL) {
! 1613: PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
! 1614: }
! 1615: zend_error(E_STRICT, "Only variables should be assigned by reference");
! 1616: if (UNEXPECTED(EG(exception) != NULL)) {
! 1617: FREE_OP2_VAR_PTR();
! 1618: ZEND_VM_NEXT_OPCODE();
! 1619: }
! 1620: ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
! 1621: } else if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
! 1622: PZVAL_LOCK(*value_ptr_ptr);
! 1623: }
! 1624: if (OP1_TYPE == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
! 1625: zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
! 1626: }
! 1627:
! 1628: variable_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 1629: if ((OP2_TYPE == IS_VAR && !value_ptr_ptr) ||
! 1630: (OP1_TYPE == IS_VAR && !variable_ptr_ptr)) {
! 1631: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
! 1632: }
! 1633: zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
! 1634:
! 1635: if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
! 1636: Z_DELREF_PP(variable_ptr_ptr);
! 1637: }
! 1638:
! 1639: if (!RETURN_VALUE_UNUSED(&opline->result)) {
! 1640: AI_SET_PTR(EX_T(opline->result.u.var).var, *variable_ptr_ptr);
! 1641: PZVAL_LOCK(*variable_ptr_ptr);
! 1642: }
! 1643:
! 1644: FREE_OP1_VAR_PTR();
! 1645: FREE_OP2_VAR_PTR();
! 1646:
! 1647: ZEND_VM_NEXT_OPCODE();
! 1648: }
! 1649:
! 1650: ZEND_VM_HANDLER(42, ZEND_JMP, ANY, ANY)
! 1651: {
! 1652: #if DEBUG_ZEND>=2
! 1653: printf("Jumping to %d\n", EX(opline)->op1.u.opline_num);
! 1654: #endif
! 1655: ZEND_VM_SET_OPCODE(EX(opline)->op1.u.jmp_addr);
! 1656: ZEND_VM_CONTINUE(); /* CHECK_ME */
! 1657: }
! 1658:
! 1659: ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
! 1660: {
! 1661: zend_op *opline = EX(opline);
! 1662: zend_free_op free_op1;
! 1663: zval *val = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 1664: int ret;
! 1665:
! 1666: if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
! 1667: ret = Z_LVAL_P(val);
! 1668: } else {
! 1669: ret = i_zend_is_true(val);
! 1670: FREE_OP1();
! 1671: if (UNEXPECTED(EG(exception) != NULL)) {
! 1672: ZEND_VM_CONTINUE();
! 1673: }
! 1674: }
! 1675: if (!ret) {
! 1676: #if DEBUG_ZEND>=2
! 1677: printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
! 1678: #endif
! 1679: ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
! 1680: ZEND_VM_CONTINUE();
! 1681: }
! 1682:
! 1683: ZEND_VM_NEXT_OPCODE();
! 1684: }
! 1685:
! 1686: ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
! 1687: {
! 1688: zend_op *opline = EX(opline);
! 1689: zend_free_op free_op1;
! 1690: zval *val = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 1691: int ret;
! 1692:
! 1693: if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
! 1694: ret = Z_LVAL_P(val);
! 1695: } else {
! 1696: ret = i_zend_is_true(val);
! 1697: FREE_OP1();
! 1698: if (UNEXPECTED(EG(exception) != NULL)) {
! 1699: ZEND_VM_CONTINUE();
! 1700: }
! 1701: }
! 1702: if (ret) {
! 1703: #if DEBUG_ZEND>=2
! 1704: printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
! 1705: #endif
! 1706: ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
! 1707: ZEND_VM_CONTINUE();
! 1708: }
! 1709:
! 1710: ZEND_VM_NEXT_OPCODE();
! 1711: }
! 1712:
! 1713: ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
! 1714: {
! 1715: zend_op *opline = EX(opline);
! 1716: zend_free_op free_op1;
! 1717: zval *val = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 1718: int retval;
! 1719:
! 1720: if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
! 1721: retval = Z_LVAL_P(val);
! 1722: } else {
! 1723: retval = i_zend_is_true(val);
! 1724: FREE_OP1();
! 1725: if (UNEXPECTED(EG(exception) != NULL)) {
! 1726: ZEND_VM_CONTINUE();
! 1727: }
! 1728: }
! 1729: if (EXPECTED(retval != 0)) {
! 1730: #if DEBUG_ZEND>=2
! 1731: printf("Conditional jmp on true to %d\n", opline->extended_value);
! 1732: #endif
! 1733: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
! 1734: ZEND_VM_CONTINUE(); /* CHECK_ME */
! 1735: } else {
! 1736: #if DEBUG_ZEND>=2
! 1737: printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num);
! 1738: #endif
! 1739: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.u.opline_num]);
! 1740: ZEND_VM_CONTINUE(); /* CHECK_ME */
! 1741: }
! 1742: }
! 1743:
! 1744: ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
! 1745: {
! 1746: zend_op *opline = EX(opline);
! 1747: zend_free_op free_op1;
! 1748: zval *val = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 1749: int retval;
! 1750:
! 1751: if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
! 1752: retval = Z_LVAL_P(val);
! 1753: } else {
! 1754: retval = i_zend_is_true(val);
! 1755: FREE_OP1();
! 1756: if (UNEXPECTED(EG(exception) != NULL)) {
! 1757: ZEND_VM_CONTINUE();
! 1758: }
! 1759: }
! 1760: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
! 1761: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
! 1762: if (!retval) {
! 1763: #if DEBUG_ZEND>=2
! 1764: printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
! 1765: #endif
! 1766: ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
! 1767: ZEND_VM_CONTINUE();
! 1768: }
! 1769: ZEND_VM_NEXT_OPCODE();
! 1770: }
! 1771:
! 1772: ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
! 1773: {
! 1774: zend_op *opline = EX(opline);
! 1775: zend_free_op free_op1;
! 1776: zval *val = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 1777: int retval;
! 1778:
! 1779: if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(val) == IS_BOOL) {
! 1780: retval = Z_LVAL_P(val);
! 1781: } else {
! 1782: retval = i_zend_is_true(val);
! 1783: FREE_OP1();
! 1784: if (UNEXPECTED(EG(exception) != NULL)) {
! 1785: ZEND_VM_CONTINUE();
! 1786: }
! 1787: }
! 1788: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
! 1789: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
! 1790: if (retval) {
! 1791: #if DEBUG_ZEND>=2
! 1792: printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
! 1793: #endif
! 1794: ZEND_VM_SET_OPCODE(opline->op2.u.jmp_addr);
! 1795: ZEND_VM_CONTINUE();
! 1796: }
! 1797: ZEND_VM_NEXT_OPCODE();
! 1798: }
! 1799:
! 1800: ZEND_VM_HANDLER(70, ZEND_FREE, TMP, ANY)
! 1801: {
! 1802: zendi_zval_dtor(EX_T(EX(opline)->op1.u.var).tmp_var);
! 1803: ZEND_VM_NEXT_OPCODE();
! 1804: }
! 1805:
! 1806: ZEND_VM_HANDLER(53, ZEND_INIT_STRING, ANY, ANY)
! 1807: {
! 1808: zval *tmp = &EX_T(EX(opline)->result.u.var).tmp_var;
! 1809:
! 1810: tmp->value.str.val = emalloc(1);
! 1811: tmp->value.str.val[0] = 0;
! 1812: tmp->value.str.len = 0;
! 1813: Z_SET_REFCOUNT_P(tmp, 1);
! 1814: tmp->type = IS_STRING;
! 1815: Z_UNSET_ISREF_P(tmp);
! 1816: ZEND_VM_NEXT_OPCODE();
! 1817: }
! 1818:
! 1819: ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP|UNUSED, CONST)
! 1820: {
! 1821: zend_op *opline = EX(opline);
! 1822: zval *str = &EX_T(opline->result.u.var).tmp_var;
! 1823:
! 1824: if (OP1_TYPE == IS_UNUSED) {
! 1825: /* Initialize for erealloc in add_char_to_string */
! 1826: Z_STRVAL_P(str) = NULL;
! 1827: Z_STRLEN_P(str) = 0;
! 1828: Z_TYPE_P(str) = IS_STRING;
! 1829:
! 1830: INIT_PZVAL(str);
! 1831: }
! 1832:
! 1833: add_char_to_string(str, str, &opline->op2.u.constant);
! 1834:
! 1835: /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
! 1836: ZEND_VM_NEXT_OPCODE();
! 1837: }
! 1838:
! 1839: ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TMP|UNUSED, CONST)
! 1840: {
! 1841: zend_op *opline = EX(opline);
! 1842: zval *str = &EX_T(opline->result.u.var).tmp_var;
! 1843:
! 1844: if (OP1_TYPE == IS_UNUSED) {
! 1845: /* Initialize for erealloc in add_string_to_string */
! 1846: Z_STRVAL_P(str) = NULL;
! 1847: Z_STRLEN_P(str) = 0;
! 1848: Z_TYPE_P(str) = IS_STRING;
! 1849:
! 1850: INIT_PZVAL(str);
! 1851: }
! 1852:
! 1853: add_string_to_string(str, str, &opline->op2.u.constant);
! 1854:
! 1855: /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
! 1856: ZEND_VM_NEXT_OPCODE();
! 1857: }
! 1858:
! 1859: ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP|UNUSED, TMP|VAR|CV)
! 1860: {
! 1861: zend_op *opline = EX(opline);
! 1862: zend_free_op free_op2;
! 1863: zval *str = &EX_T(opline->result.u.var).tmp_var;
! 1864: zval *var = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1865: zval var_copy;
! 1866: int use_copy = 0;
! 1867:
! 1868: if (OP1_TYPE == IS_UNUSED) {
! 1869: /* Initialize for erealloc in add_string_to_string */
! 1870: Z_STRVAL_P(str) = NULL;
! 1871: Z_STRLEN_P(str) = 0;
! 1872: Z_TYPE_P(str) = IS_STRING;
! 1873:
! 1874: INIT_PZVAL(str);
! 1875: }
! 1876:
! 1877: if (Z_TYPE_P(var) != IS_STRING) {
! 1878: zend_make_printable_zval(var, &var_copy, &use_copy);
! 1879:
! 1880: if (use_copy) {
! 1881: var = &var_copy;
! 1882: }
! 1883: }
! 1884: add_string_to_string(str, str, var);
! 1885:
! 1886: if (use_copy) {
! 1887: zval_dtor(var);
! 1888: }
! 1889: /* original comment, possibly problematic:
! 1890: * FREE_OP is missing intentionally here - we're always working on the same temporary variable
! 1891: * (Zeev): I don't think it's problematic, we only use variables
! 1892: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
! 1893: * string offsets or overloaded objects
! 1894: */
! 1895: FREE_OP2();
! 1896:
! 1897: ZEND_VM_NEXT_OPCODE();
! 1898: }
! 1899:
! 1900: ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
! 1901: {
! 1902: zend_op *opline = EX(opline);
! 1903:
! 1904:
! 1905: if (OP2_TYPE == IS_UNUSED) {
! 1906: EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
! 1907: ZEND_VM_NEXT_OPCODE();
! 1908: } else {
! 1909: zend_free_op free_op2;
! 1910: zval *class_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1911:
! 1912: if (OP2_TYPE != IS_CONST && Z_TYPE_P(class_name) == IS_OBJECT) {
! 1913: EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
! 1914: } else if (Z_TYPE_P(class_name) == IS_STRING) {
! 1915: EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
! 1916: } else {
! 1917: zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
! 1918: }
! 1919:
! 1920: FREE_OP2();
! 1921: ZEND_VM_NEXT_OPCODE();
! 1922: }
! 1923: }
! 1924:
! 1925: ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 1926: {
! 1927: zend_op *opline = EX(opline);
! 1928: zval *function_name;
! 1929: char *function_name_strval;
! 1930: int function_name_strlen;
! 1931: zend_free_op free_op1, free_op2;
! 1932:
! 1933: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
! 1934:
! 1935: function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 1936:
! 1937: if (Z_TYPE_P(function_name)!=IS_STRING) {
! 1938: zend_error_noreturn(E_ERROR, "Method name must be a string");
! 1939: }
! 1940:
! 1941: function_name_strval = Z_STRVAL_P(function_name);
! 1942: function_name_strlen = Z_STRLEN_P(function_name);
! 1943:
! 1944: EX(object) = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
! 1945:
! 1946: if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
! 1947: if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
! 1948: zend_error_noreturn(E_ERROR, "Object does not support method calls");
! 1949: }
! 1950:
! 1951: /* First, locate the function. */
! 1952: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
! 1953: if (!EX(fbc)) {
! 1954: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
! 1955: }
! 1956:
! 1957: EX(called_scope) = Z_OBJCE_P(EX(object));
! 1958: } else {
! 1959: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
! 1960: }
! 1961:
! 1962: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) {
! 1963: EX(object) = NULL;
! 1964: } else {
! 1965: if (!PZVAL_IS_REF(EX(object))) {
! 1966: Z_ADDREF_P(EX(object)); /* For $this pointer */
! 1967: } else {
! 1968: zval *this_ptr;
! 1969: ALLOC_ZVAL(this_ptr);
! 1970: INIT_PZVAL_COPY(this_ptr, EX(object));
! 1971: zval_copy_ctor(this_ptr);
! 1972: EX(object) = this_ptr;
! 1973: }
! 1974: }
! 1975:
! 1976: FREE_OP2();
! 1977: FREE_OP1_IF_VAR();
! 1978:
! 1979: ZEND_VM_NEXT_OPCODE();
! 1980: }
! 1981:
! 1982: ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUSED|CV)
! 1983: {
! 1984: zend_op *opline = EX(opline);
! 1985: zval *function_name;
! 1986: zend_class_entry *ce;
! 1987:
! 1988: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
! 1989:
! 1990: if (OP1_TYPE == IS_CONST) {
! 1991: /* no function found. try a static method in class */
! 1992: ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
! 1993: if (!ce) {
! 1994: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL(opline->op1.u.constant));
! 1995: }
! 1996: EX(called_scope) = ce;
! 1997: } else {
! 1998: ce = EX_T(opline->op1.u.var).class_entry;
! 1999:
! 2000: if (opline->op1.u.EA.type == ZEND_FETCH_CLASS_PARENT || opline->op1.u.EA.type == ZEND_FETCH_CLASS_SELF) {
! 2001: EX(called_scope) = EG(called_scope);
! 2002: } else {
! 2003: EX(called_scope) = ce;
! 2004: }
! 2005: }
! 2006: if(OP2_TYPE != IS_UNUSED) {
! 2007: char *function_name_strval = NULL;
! 2008: int function_name_strlen = 0;
! 2009: zend_free_op free_op2;
! 2010:
! 2011: if (OP2_TYPE == IS_CONST) {
! 2012: function_name_strval = Z_STRVAL(opline->op2.u.constant);
! 2013: function_name_strlen = Z_STRLEN(opline->op2.u.constant);
! 2014: } else {
! 2015: function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 2016:
! 2017: if (Z_TYPE_P(function_name) != IS_STRING) {
! 2018: zend_error_noreturn(E_ERROR, "Function name must be a string");
! 2019: } else {
! 2020: function_name_strval = Z_STRVAL_P(function_name);
! 2021: function_name_strlen = Z_STRLEN_P(function_name);
! 2022: }
! 2023: }
! 2024:
! 2025: if (function_name_strval) {
! 2026: if (ce->get_static_method) {
! 2027: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
! 2028: } else {
! 2029: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
! 2030: }
! 2031: if (!EX(fbc)) {
! 2032: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
! 2033: }
! 2034: }
! 2035:
! 2036: if (OP2_TYPE != IS_CONST) {
! 2037: FREE_OP2();
! 2038: }
! 2039: } else {
! 2040: if(!ce->constructor) {
! 2041: zend_error_noreturn(E_ERROR, "Cannot call constructor");
! 2042: }
! 2043: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
! 2044: zend_error(E_COMPILE_ERROR, "Cannot call private %s::__construct()", ce->name);
! 2045: }
! 2046: EX(fbc) = ce->constructor;
! 2047: }
! 2048:
! 2049: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
! 2050: EX(object) = NULL;
! 2051: } else {
! 2052: if (EG(This) &&
! 2053: Z_OBJ_HT_P(EG(This))->get_class_entry &&
! 2054: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
! 2055: /* We are calling method of the other (incompatible) class,
! 2056: but passing $this. This is done for compatibility with php-4. */
! 2057: int severity;
! 2058: char *verb;
! 2059: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
! 2060: severity = E_STRICT;
! 2061: verb = "should not";
! 2062: } else {
! 2063: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
! 2064: severity = E_ERROR;
! 2065: verb = "cannot";
! 2066: }
! 2067: zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name, verb);
! 2068:
! 2069: }
! 2070: if ((EX(object) = EG(This))) {
! 2071: Z_ADDREF_P(EX(object));
! 2072: EX(called_scope) = Z_OBJCE_P(EX(object));
! 2073: }
! 2074: }
! 2075:
! 2076: ZEND_VM_NEXT_OPCODE();
! 2077: }
! 2078:
! 2079: ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
! 2080: {
! 2081: zend_op *opline = EX(opline);
! 2082: zval *function_name;
! 2083: char *function_name_strval, *lcname;
! 2084: int function_name_strlen;
! 2085: zend_free_op free_op2;
! 2086:
! 2087: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
! 2088:
! 2089: if (OP2_TYPE == IS_CONST) {
! 2090: if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc)) == FAILURE) {
! 2091: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
! 2092: }
! 2093: } else {
! 2094: function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 2095:
! 2096: if (OP2_TYPE != IS_CONST && OP2_TYPE != IS_TMP_VAR &&
! 2097: Z_TYPE_P(function_name) == IS_OBJECT &&
! 2098: Z_OBJ_HANDLER_P(function_name, get_closure) &&
! 2099: Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) {
! 2100: if (EX(object)) {
! 2101: Z_ADDREF_P(EX(object));
! 2102: }
! 2103: if (OP2_TYPE == IS_VAR && OP2_FREE &&
! 2104: EX(fbc)->common.fn_flags & ZEND_ACC_CLOSURE) {
! 2105: /* Delay closure destruction until its invocation */
! 2106: EX(fbc)->common.prototype = (zend_function*)function_name;
! 2107: } else {
! 2108: FREE_OP2();
! 2109: }
! 2110: ZEND_VM_NEXT_OPCODE();
! 2111: }
! 2112:
! 2113: if (Z_TYPE_P(function_name) != IS_STRING) {
! 2114: zend_error_noreturn(E_ERROR, "Function name must be a string");
! 2115: }
! 2116: function_name_strval = Z_STRVAL_P(function_name);
! 2117: function_name_strlen = Z_STRLEN_P(function_name);
! 2118: if (function_name_strval[0] == '\\') {
! 2119:
! 2120: function_name_strlen -= 1;
! 2121: lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
! 2122: } else {
! 2123: lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
! 2124: }
! 2125: if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE) {
! 2126: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
! 2127: }
! 2128: efree(lcname);
! 2129: FREE_OP2();
! 2130: }
! 2131:
! 2132: EX(object) = NULL;
! 2133: ZEND_VM_NEXT_OPCODE();
! 2134: }
! 2135:
! 2136:
! 2137: ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
! 2138: {
! 2139: zend_op *opline = EX(opline);
! 2140: zend_op *op_data = opline + 1;
! 2141:
! 2142: ZEND_VM_INC_OPCODE();
! 2143: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
! 2144:
! 2145: if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant)+1, opline->extended_value, (void **) &EX(fbc))==FAILURE) {
! 2146: char *short_name = Z_STRVAL(opline->op1.u.constant)+Z_LVAL(op_data->op1.u.constant);
! 2147: if (zend_hash_quick_find(EG(function_table), short_name, Z_STRLEN(opline->op1.u.constant)-Z_LVAL(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==FAILURE) {
! 2148: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL(opline->op2.u.constant));
! 2149: }
! 2150: }
! 2151:
! 2152: EX(object) = NULL;
! 2153: ZEND_VM_NEXT_OPCODE();
! 2154: }
! 2155:
! 2156: ZEND_VM_HELPER(zend_leave_helper, ANY, ANY)
! 2157: {
! 2158: zend_bool nested;
! 2159: zend_op_array *op_array = EX(op_array);
! 2160:
! 2161: EG(current_execute_data) = EX(prev_execute_data);
! 2162: EG(opline_ptr) = NULL;
! 2163: if (!EG(active_symbol_table)) {
! 2164: zval ***cv = EX(CVs);
! 2165: zval ***end = cv + EX(op_array)->last_var;
! 2166: while (cv != end) {
! 2167: if (*cv) {
! 2168: zval_ptr_dtor(*cv);
! 2169: }
! 2170: cv++;
! 2171: }
! 2172: }
! 2173:
! 2174: if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
! 2175: zval_ptr_dtor((zval**)&op_array->prototype);
! 2176: }
! 2177:
! 2178: nested = EX(nested);
! 2179:
! 2180: zend_vm_stack_free(execute_data TSRMLS_CC);
! 2181:
! 2182: if (nested) {
! 2183: execute_data = EG(current_execute_data);
! 2184:
! 2185: if (EX(call_opline)->opcode == ZEND_INCLUDE_OR_EVAL) {
! 2186:
! 2187: EX(function_state).function = (zend_function *) EX(op_array);
! 2188: EX(function_state).arguments = NULL;
! 2189: EX(object) = EX(current_object);
! 2190:
! 2191: if (RETURN_VALUE_USED(EX(call_opline))) {
! 2192: if (!EX_T(EX(call_opline)->result.u.var).var.ptr) { /* there was no return statement */
! 2193: ALLOC_ZVAL(EX_T(EX(call_opline)->result.u.var).var.ptr);
! 2194: INIT_PZVAL(EX_T(EX(call_opline)->result.u.var).var.ptr);
! 2195: Z_LVAL_P(EX_T(EX(call_opline)->result.u.var).var.ptr) = 1;
! 2196: Z_TYPE_P(EX_T(EX(call_opline)->result.u.var).var.ptr) = IS_BOOL;
! 2197: }
! 2198: }
! 2199:
! 2200: EG(opline_ptr) = &EX(opline);
! 2201: EG(active_op_array) = EX(op_array);
! 2202: EG(return_value_ptr_ptr) = EX(original_return_value);
! 2203: destroy_op_array(op_array TSRMLS_CC);
! 2204: efree(op_array);
! 2205: if (EG(exception)) {
! 2206: zend_throw_exception_internal(NULL TSRMLS_CC);
! 2207: }
! 2208:
! 2209: EX(opline)++;
! 2210: ZEND_VM_LEAVE();
! 2211: } else {
! 2212:
! 2213: EG(opline_ptr) = &EX(opline);
! 2214: EG(active_op_array) = EX(op_array);
! 2215: EG(return_value_ptr_ptr) = EX(original_return_value);
! 2216: if (EG(active_symbol_table)) {
! 2217: if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
! 2218: zend_hash_destroy(EG(active_symbol_table));
! 2219: FREE_HASHTABLE(EG(active_symbol_table));
! 2220: } else {
! 2221: /* clean before putting into the cache, since clean
! 2222: could call dtors, which could use cached hash */
! 2223: zend_hash_clean(EG(active_symbol_table));
! 2224: *(++EG(symtable_cache_ptr)) = EG(active_symbol_table);
! 2225: }
! 2226: }
! 2227: EG(active_symbol_table) = EX(symbol_table);
! 2228:
! 2229: EX(function_state).function = (zend_function *) EX(op_array);
! 2230: EX(function_state).arguments = NULL;
! 2231:
! 2232: if (EG(This)) {
! 2233: if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
! 2234: if (IS_CTOR_USED(EX(called_scope))) {
! 2235: Z_DELREF_P(EG(This));
! 2236: }
! 2237: if (Z_REFCOUNT_P(EG(This)) == 1) {
! 2238: zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
! 2239: }
! 2240: }
! 2241: zval_ptr_dtor(&EG(This));
! 2242: }
! 2243: EG(This) = EX(current_this);
! 2244: EG(scope) = EX(current_scope);
! 2245: EG(called_scope) = EX(current_called_scope);
! 2246:
! 2247: EX(object) = EX(current_object);
! 2248: EX(called_scope) = DECODE_CTOR(EX(called_scope));
! 2249:
! 2250: zend_vm_stack_clear_multiple(TSRMLS_C);
! 2251:
! 2252: if (EG(exception)) {
! 2253: zend_throw_exception_internal(NULL TSRMLS_CC);
! 2254: if (RETURN_VALUE_USED(EX(call_opline)) && EX_T(EX(call_opline)->result.u.var).var.ptr) {
! 2255: zval_ptr_dtor(&EX_T(EX(call_opline)->result.u.var).var.ptr);
! 2256: }
! 2257: }
! 2258:
! 2259: EX(opline)++;
! 2260: ZEND_VM_LEAVE();
! 2261: }
! 2262: }
! 2263: ZEND_VM_RETURN();
! 2264: }
! 2265:
! 2266: ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
! 2267: {
! 2268: zend_op *opline = EX(opline);
! 2269: zend_bool should_change_scope = 0;
! 2270:
! 2271: if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
! 2272: if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
! 2273: zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
! 2274: ZEND_VM_NEXT_OPCODE(); /* Never reached */
! 2275: }
! 2276: if (EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED) {
! 2277: zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
! 2278: EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
! 2279: EX(function_state).function->common.scope ? "::" : "",
! 2280: EX(function_state).function->common.function_name);
! 2281: }
! 2282: }
! 2283: if (EX(function_state).function->common.scope &&
! 2284: !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC) &&
! 2285: !EX(object)) {
! 2286:
! 2287: if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
! 2288: /* FIXME: output identifiers properly */
! 2289: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
! 2290: } else {
! 2291: /* FIXME: output identifiers properly */
! 2292: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
! 2293: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
! 2294: }
! 2295: }
! 2296:
! 2297: if (EX(function_state).function->type == ZEND_USER_FUNCTION ||
! 2298: EX(function_state).function->common.scope) {
! 2299: should_change_scope = 1;
! 2300: EX(current_this) = EG(This);
! 2301: EX(current_scope) = EG(scope);
! 2302: EX(current_called_scope) = EG(called_scope);
! 2303: EG(This) = EX(object);
! 2304: EG(scope) = (EX(function_state).function->type == ZEND_USER_FUNCTION || !EX(object)) ? EX(function_state).function->common.scope : NULL;
! 2305: EG(called_scope) = EX(called_scope);
! 2306: }
! 2307:
! 2308: zend_arg_types_stack_3_pop(&EG(arg_types_stack), &EX(called_scope), &EX(current_object), &EX(fbc));
! 2309: EX(function_state).arguments = zend_vm_stack_push_args(opline->extended_value TSRMLS_CC);
! 2310:
! 2311: if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
! 2312: ALLOC_INIT_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 2313: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 2314: EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
! 2315:
! 2316: if (EX(function_state).function->common.arg_info) {
! 2317: zend_uint i=0;
! 2318: zval **p = (zval**)EX(function_state).arguments;
! 2319: ulong arg_count = opline->extended_value;
! 2320:
! 2321: while (arg_count>0) {
! 2322: zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count), 0 TSRMLS_CC);
! 2323: arg_count--;
! 2324: }
! 2325: }
! 2326: if (!zend_execute_internal) {
! 2327: /* saves one function call if zend_execute_internal is not used */
! 2328: ((zend_internal_function *) EX(function_state).function)->handler(opline->extended_value, EX_T(opline->result.u.var).var.ptr, EX(function_state).function->common.return_reference?&EX_T(opline->result.u.var).var.ptr:NULL, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
! 2329: } else {
! 2330: zend_execute_internal(EXECUTE_DATA, RETURN_VALUE_USED(opline) TSRMLS_CC);
! 2331: }
! 2332:
! 2333: if (!RETURN_VALUE_USED(opline)) {
! 2334: zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
! 2335: }
! 2336: } else if (EX(function_state).function->type == ZEND_USER_FUNCTION) {
! 2337: EX(original_return_value) = EG(return_value_ptr_ptr);
! 2338: EG(active_symbol_table) = NULL;
! 2339: EG(active_op_array) = &EX(function_state).function->op_array;
! 2340: EG(return_value_ptr_ptr) = NULL;
! 2341: if (RETURN_VALUE_USED(opline)) {
! 2342: EG(return_value_ptr_ptr) = &EX_T(opline->result.u.var).var.ptr;
! 2343: EX_T(opline->result.u.var).var.ptr = NULL;
! 2344: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 2345: EX_T(opline->result.u.var).var.fcall_returned_reference = EX(function_state).function->common.return_reference;
! 2346: }
! 2347:
! 2348: if (zend_execute == execute && !EG(exception)) {
! 2349: EX(call_opline) = opline;
! 2350: ZEND_VM_ENTER();
! 2351: } else {
! 2352: zend_execute(EG(active_op_array) TSRMLS_CC);
! 2353: }
! 2354:
! 2355: EG(opline_ptr) = &EX(opline);
! 2356: EG(active_op_array) = EX(op_array);
! 2357: EG(return_value_ptr_ptr) = EX(original_return_value);
! 2358: if (EG(active_symbol_table)) {
! 2359: if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) {
! 2360: zend_hash_destroy(EG(active_symbol_table));
! 2361: FREE_HASHTABLE(EG(active_symbol_table));
! 2362: } else {
! 2363: /* clean before putting into the cache, since clean
! 2364: could call dtors, which could use cached hash */
! 2365: zend_hash_clean(EG(active_symbol_table));
! 2366: *(++EG(symtable_cache_ptr)) = EG(active_symbol_table);
! 2367: }
! 2368: }
! 2369: EG(active_symbol_table) = EX(symbol_table);
! 2370: } else { /* ZEND_OVERLOADED_FUNCTION */
! 2371: ALLOC_INIT_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 2372:
! 2373: /* Not sure what should be done here if it's a static method */
! 2374: if (EX(object)) {
! 2375: Z_OBJ_HT_P(EX(object))->call_method(EX(function_state).function->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
! 2376: } else {
! 2377: zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
! 2378: }
! 2379:
! 2380: if (EX(function_state).function->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
! 2381: efree(EX(function_state).function->common.function_name);
! 2382: }
! 2383: efree(EX(function_state).function);
! 2384:
! 2385: if (!RETURN_VALUE_USED(opline)) {
! 2386: zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
! 2387: } else {
! 2388: Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
! 2389: Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
! 2390: EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
! 2391: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 2392: }
! 2393: }
! 2394:
! 2395: EX(function_state).function = (zend_function *) EX(op_array);
! 2396: EX(function_state).arguments = NULL;
! 2397:
! 2398: if (should_change_scope) {
! 2399: if (EG(This)) {
! 2400: if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
! 2401: if (IS_CTOR_USED(EX(called_scope))) {
! 2402: Z_DELREF_P(EG(This));
! 2403: }
! 2404: if (Z_REFCOUNT_P(EG(This)) == 1) {
! 2405: zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
! 2406: }
! 2407: }
! 2408: zval_ptr_dtor(&EG(This));
! 2409: }
! 2410: EG(This) = EX(current_this);
! 2411: EG(scope) = EX(current_scope);
! 2412: EG(called_scope) = EX(current_called_scope);
! 2413: }
! 2414:
! 2415: EX(object) = EX(current_object);
! 2416: EX(called_scope) = DECODE_CTOR(EX(called_scope));
! 2417:
! 2418: zend_vm_stack_clear_multiple(TSRMLS_C);
! 2419:
! 2420: if (EG(exception)) {
! 2421: zend_throw_exception_internal(NULL TSRMLS_CC);
! 2422: if (RETURN_VALUE_USED(opline) && EX_T(opline->result.u.var).var.ptr) {
! 2423: zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
! 2424: }
! 2425: }
! 2426:
! 2427: ZEND_VM_NEXT_OPCODE();
! 2428: }
! 2429:
! 2430: ZEND_VM_HANDLER(61, ZEND_DO_FCALL_BY_NAME, ANY, ANY)
! 2431: {
! 2432: EX(function_state).function = EX(fbc);
! 2433: ZEND_VM_DISPATCH_TO_HELPER(zend_do_fcall_common_helper);
! 2434: }
! 2435:
! 2436: ZEND_VM_HANDLER(60, ZEND_DO_FCALL, CONST, ANY)
! 2437: {
! 2438: zend_op *opline = EX(opline);
! 2439: zend_free_op free_op1;
! 2440: zval *fname = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 2441:
! 2442: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope));
! 2443:
! 2444: if (zend_hash_quick_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, Z_LVAL(opline->op2.u.constant), (void **) &EX(function_state).function)==FAILURE) {
! 2445: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
! 2446: }
! 2447: EX(object) = NULL;
! 2448:
! 2449: FREE_OP1();
! 2450:
! 2451: ZEND_VM_DISPATCH_TO_HELPER(zend_do_fcall_common_helper);
! 2452: }
! 2453:
! 2454: ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
! 2455: {
! 2456: zend_op *opline = EX(opline);
! 2457: zval *retval_ptr;
! 2458: zval **retval_ptr_ptr;
! 2459: zend_free_op free_op1;
! 2460:
! 2461: if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
! 2462:
! 2463: if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
! 2464: /* Not supposed to happen, but we'll allow it */
! 2465: zend_error(E_NOTICE, "Only variable references should be returned by reference");
! 2466: ZEND_VM_C_GOTO(return_by_value);
! 2467: }
! 2468:
! 2469: retval_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 2470:
! 2471: if (OP1_TYPE == IS_VAR && !retval_ptr_ptr) {
! 2472: zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
! 2473: }
! 2474:
! 2475: if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
! 2476: if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
! 2477: EX_T(opline->op1.u.var).var.fcall_returned_reference) {
! 2478: } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
! 2479: if (OP1_TYPE == IS_VAR && !OP1_FREE) {
! 2480: PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
! 2481: }
! 2482: zend_error(E_NOTICE, "Only variable references should be returned by reference");
! 2483: ZEND_VM_C_GOTO(return_by_value);
! 2484: }
! 2485: }
! 2486:
! 2487: if (EG(return_value_ptr_ptr)) {
! 2488: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
! 2489: Z_ADDREF_PP(retval_ptr_ptr);
! 2490:
! 2491: (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
! 2492: }
! 2493: } else {
! 2494: ZEND_VM_C_LABEL(return_by_value):
! 2495:
! 2496: retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 2497:
! 2498: if (!EG(return_value_ptr_ptr)) {
! 2499: if (OP1_TYPE == IS_TMP_VAR) {
! 2500: FREE_OP1();
! 2501: }
! 2502: } else if (!IS_OP1_TMP_FREE()) { /* Not a temp var */
! 2503: if (OP1_TYPE == IS_CONST ||
! 2504: EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
! 2505: (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
! 2506: zval *ret;
! 2507:
! 2508: ALLOC_ZVAL(ret);
! 2509: INIT_PZVAL_COPY(ret, retval_ptr);
! 2510: zval_copy_ctor(ret);
! 2511: *EG(return_value_ptr_ptr) = ret;
! 2512: } else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
! 2513: retval_ptr == &EG(uninitialized_zval)) {
! 2514: zval *ret;
! 2515:
! 2516: ALLOC_INIT_ZVAL(ret);
! 2517: *EG(return_value_ptr_ptr) = ret;
! 2518: } else {
! 2519: *EG(return_value_ptr_ptr) = retval_ptr;
! 2520: Z_ADDREF_P(retval_ptr);
! 2521: }
! 2522: } else {
! 2523: zval *ret;
! 2524:
! 2525: ALLOC_ZVAL(ret);
! 2526: INIT_PZVAL_COPY(ret, retval_ptr);
! 2527: *EG(return_value_ptr_ptr) = ret;
! 2528: }
! 2529: }
! 2530: FREE_OP1_IF_VAR();
! 2531: ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
! 2532: }
! 2533:
! 2534: ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
! 2535: {
! 2536: zend_op *opline = EX(opline);
! 2537: zval *value;
! 2538: zval *exception;
! 2539: zend_free_op free_op1;
! 2540:
! 2541: value = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 2542:
! 2543: if (OP1_TYPE == IS_CONST || Z_TYPE_P(value) != IS_OBJECT) {
! 2544: zend_error_noreturn(E_ERROR, "Can only throw objects");
! 2545: }
! 2546: zend_exception_save(TSRMLS_C);
! 2547: /* Not sure if a complete copy is what we want here */
! 2548: ALLOC_ZVAL(exception);
! 2549: INIT_PZVAL_COPY(exception, value);
! 2550: if (!IS_OP1_TMP_FREE()) {
! 2551: zval_copy_ctor(exception);
! 2552: }
! 2553:
! 2554: zend_throw_exception_object(exception TSRMLS_CC);
! 2555: zend_exception_restore(TSRMLS_C);
! 2556: FREE_OP1_IF_VAR();
! 2557: ZEND_VM_NEXT_OPCODE();
! 2558: }
! 2559:
! 2560: ZEND_VM_HANDLER(107, ZEND_CATCH, ANY, CV)
! 2561: {
! 2562: zend_op *opline = EX(opline);
! 2563: zend_class_entry *ce;
! 2564:
! 2565: /* Check whether an exception has been thrown, if not, jump over code */
! 2566: zend_exception_restore(TSRMLS_C);
! 2567: if (EG(exception) == NULL) {
! 2568: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
! 2569: ZEND_VM_CONTINUE(); /* CHECK_ME */
! 2570: }
! 2571: ce = Z_OBJCE_P(EG(exception));
! 2572: if (ce != EX_T(opline->op1.u.var).class_entry) {
! 2573: if (!instanceof_function(ce, EX_T(opline->op1.u.var).class_entry TSRMLS_CC)) {
! 2574: if (opline->op1.u.EA.type) {
! 2575: zend_throw_exception_internal(NULL TSRMLS_CC);
! 2576: ZEND_VM_NEXT_OPCODE();
! 2577: }
! 2578: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
! 2579: ZEND_VM_CONTINUE(); /* CHECK_ME */
! 2580: }
! 2581: }
! 2582:
! 2583: if (!EG(active_symbol_table)) {
! 2584: if (EX(CVs)[opline->op2.u.var]) {
! 2585: zval_ptr_dtor(EX(CVs)[opline->op2.u.var]);
! 2586: }
! 2587: EX(CVs)[opline->op2.u.var] = (zval**)EX(CVs) + (EX(op_array)->last_var + opline->op2.u.var);
! 2588: *EX(CVs)[opline->op2.u.var] = EG(exception);
! 2589: } else {
! 2590: zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.u.var);
! 2591: zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
! 2592: &EG(exception), sizeof(zval *), (void**)&EX(CVs)[opline->op2.u.var]);
! 2593: }
! 2594: EG(exception) = NULL;
! 2595: ZEND_VM_NEXT_OPCODE();
! 2596: }
! 2597:
! 2598: ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP|VAR|CV, ANY)
! 2599: {
! 2600: zend_op *opline = EX(opline);
! 2601: if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
! 2602: && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
! 2603: zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
! 2604: }
! 2605: {
! 2606: zval *valptr;
! 2607: zval *value;
! 2608: zend_free_op free_op1;
! 2609:
! 2610: value = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 2611:
! 2612: ALLOC_ZVAL(valptr);
! 2613: INIT_PZVAL_COPY(valptr, value);
! 2614: if (!IS_OP1_TMP_FREE()) {
! 2615: zval_copy_ctor(valptr);
! 2616: }
! 2617: zend_vm_stack_push(valptr TSRMLS_CC);
! 2618: FREE_OP1_IF_VAR();
! 2619: }
! 2620: ZEND_VM_NEXT_OPCODE();
! 2621: }
! 2622:
! 2623: ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
! 2624: {
! 2625: zend_op *opline = EX(opline);
! 2626: zval *varptr;
! 2627: zend_free_op free_op1;
! 2628: varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 2629:
! 2630: if (varptr == &EG(uninitialized_zval)) {
! 2631: ALLOC_ZVAL(varptr);
! 2632: INIT_ZVAL(*varptr);
! 2633: Z_SET_REFCOUNT_P(varptr, 0);
! 2634: } else if (PZVAL_IS_REF(varptr)) {
! 2635: zval *original_var = varptr;
! 2636:
! 2637: ALLOC_ZVAL(varptr);
! 2638: *varptr = *original_var;
! 2639: Z_UNSET_ISREF_P(varptr);
! 2640: Z_SET_REFCOUNT_P(varptr, 0);
! 2641: zval_copy_ctor(varptr);
! 2642: }
! 2643: Z_ADDREF_P(varptr);
! 2644: zend_vm_stack_push(varptr TSRMLS_CC);
! 2645: FREE_OP1(); /* for string offsets */
! 2646:
! 2647: ZEND_VM_NEXT_OPCODE();
! 2648: }
! 2649:
! 2650: ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
! 2651: {
! 2652: zend_op *opline = EX(opline);
! 2653: zend_free_op free_op1;
! 2654: zval *varptr;
! 2655:
! 2656: if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
! 2657: if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
! 2658: ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
! 2659: }
! 2660: } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
! 2661: ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
! 2662: }
! 2663:
! 2664: if (OP1_TYPE == IS_VAR &&
! 2665: (opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
! 2666: EX_T(opline->op1.u.var).var.fcall_returned_reference &&
! 2667: EX_T(opline->op1.u.var).var.ptr) {
! 2668: varptr = EX_T(opline->op1.u.var).var.ptr;
! 2669: PZVAL_UNLOCK_EX(varptr, &free_op1, 0);
! 2670: } else {
! 2671: varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 2672: }
! 2673: if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
! 2674: EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
! 2675: varptr != &EG(uninitialized_zval) &&
! 2676: (PZVAL_IS_REF(varptr) ||
! 2677: (Z_REFCOUNT_P(varptr) == 1 && (OP1_TYPE == IS_CV || free_op1.var)))) {
! 2678: Z_SET_ISREF_P(varptr);
! 2679: Z_ADDREF_P(varptr);
! 2680: zend_vm_stack_push(varptr TSRMLS_CC);
! 2681: } else {
! 2682: zval *valptr;
! 2683:
! 2684: if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
! 2685: !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
! 2686: !ARG_MAY_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
! 2687: zend_error(E_STRICT, "Only variables should be passed by reference");
! 2688: }
! 2689: ALLOC_ZVAL(valptr);
! 2690: INIT_PZVAL_COPY(valptr, varptr);
! 2691: if (!IS_OP1_TMP_FREE()) {
! 2692: zval_copy_ctor(valptr);
! 2693: }
! 2694: zend_vm_stack_push(valptr TSRMLS_CC);
! 2695: }
! 2696: FREE_OP1_IF_VAR();
! 2697: ZEND_VM_NEXT_OPCODE();
! 2698: }
! 2699:
! 2700: ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
! 2701: {
! 2702: zend_op *opline = EX(opline);
! 2703: zend_free_op free_op1;
! 2704: zval **varptr_ptr;
! 2705: zval *varptr;
! 2706: varptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 2707:
! 2708: if (OP1_TYPE == IS_VAR && !varptr_ptr) {
! 2709: zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
! 2710: }
! 2711:
! 2712: if (OP1_TYPE == IS_VAR && *varptr_ptr == EG(error_zval_ptr)) {
! 2713: ALLOC_INIT_ZVAL(varptr);
! 2714: zend_vm_stack_push(varptr TSRMLS_CC);
! 2715: ZEND_VM_NEXT_OPCODE();
! 2716: }
! 2717:
! 2718: if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION && !ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
! 2719: ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
! 2720: }
! 2721:
! 2722: SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
! 2723: varptr = *varptr_ptr;
! 2724: Z_ADDREF_P(varptr);
! 2725: zend_vm_stack_push(varptr TSRMLS_CC);
! 2726:
! 2727: FREE_OP1_VAR_PTR();
! 2728: ZEND_VM_NEXT_OPCODE();
! 2729: }
! 2730:
! 2731: ZEND_VM_HANDLER(66, ZEND_SEND_VAR, VAR|CV, ANY)
! 2732: {
! 2733: zend_op *opline = EX(opline);
! 2734:
! 2735: if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
! 2736: && ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
! 2737: ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
! 2738: }
! 2739: ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
! 2740: }
! 2741:
! 2742: ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
! 2743: {
! 2744: zend_op *opline = EX(opline);
! 2745: zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
! 2746: zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
! 2747:
! 2748: if (param == NULL) {
! 2749: char *space;
! 2750: char *class_name = get_active_class_name(&space TSRMLS_CC);
! 2751: zend_execute_data *ptr = EX(prev_execute_data);
! 2752:
! 2753: if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) {
! 2754: if(ptr && ptr->op_array) {
! 2755: zend_error(E_WARNING, "Missing argument %ld for %s%s%s(), called in %s on line %d and defined", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
! 2756: } else {
! 2757: zend_error(E_WARNING, "Missing argument %ld for %s%s%s()", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C));
! 2758: }
! 2759: }
! 2760: if (opline->result.op_type == IS_VAR) {
! 2761: PZVAL_UNLOCK_FREE(*EX_T(opline->result.u.var).var.ptr_ptr);
! 2762: }
! 2763: } else {
! 2764: zend_free_op free_res;
! 2765: zval **var_ptr;
! 2766:
! 2767: zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
! 2768: var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
! 2769: Z_DELREF_PP(var_ptr);
! 2770: *var_ptr = *param;
! 2771: Z_ADDREF_PP(var_ptr);
! 2772: }
! 2773:
! 2774: ZEND_VM_NEXT_OPCODE();
! 2775: }
! 2776:
! 2777: ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
! 2778: {
! 2779: zend_op *opline = EX(opline);
! 2780: zval *assignment_value;
! 2781: zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
! 2782: zend_free_op free_res;
! 2783: zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
! 2784: zval **var_ptr;
! 2785:
! 2786: if (param == NULL) {
! 2787: ALLOC_ZVAL(assignment_value);
! 2788: *assignment_value = opline->op2.u.constant;
! 2789: if ((Z_TYPE(opline->op2.u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
! 2790: Z_SET_REFCOUNT_P(assignment_value, 1);
! 2791: zval_update_constant(&assignment_value, 0 TSRMLS_CC);
! 2792: } else {
! 2793: zval_copy_ctor(assignment_value);
! 2794: }
! 2795: INIT_PZVAL(assignment_value);
! 2796: } else {
! 2797: assignment_value = *param;
! 2798: Z_ADDREF_P(assignment_value);
! 2799: }
! 2800:
! 2801: zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC);
! 2802: var_ptr = get_zval_ptr_ptr(&opline->result, EX(Ts), &free_res, BP_VAR_W);
! 2803: Z_DELREF_PP(var_ptr);
! 2804: *var_ptr = assignment_value;
! 2805:
! 2806: ZEND_VM_NEXT_OPCODE();
! 2807: }
! 2808:
! 2809: ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMP|VAR|CV, ANY)
! 2810: {
! 2811: zend_op *opline = EX(opline);
! 2812: zend_free_op free_op1;
! 2813:
! 2814: /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
! 2815: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
! 2816: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
! 2817: FREE_OP1();
! 2818:
! 2819: ZEND_VM_NEXT_OPCODE();
! 2820: }
! 2821:
! 2822: ZEND_VM_HANDLER(50, ZEND_BRK, ANY, CONST|TMP|VAR|CV)
! 2823: {
! 2824: zend_op *opline = EX(opline);
! 2825: zend_free_op free_op2;
! 2826: zend_brk_cont_element *el;
! 2827:
! 2828: el = zend_brk_cont(GET_OP2_ZVAL_PTR(BP_VAR_R), opline->op1.u.opline_num,
! 2829: EX(op_array), EX(Ts) TSRMLS_CC);
! 2830: FREE_OP2();
! 2831: ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
! 2832: }
! 2833:
! 2834: ZEND_VM_HANDLER(51, ZEND_CONT, ANY, CONST|TMP|VAR|CV)
! 2835: {
! 2836: zend_op *opline = EX(opline);
! 2837: zend_free_op free_op2;
! 2838: zend_brk_cont_element *el;
! 2839:
! 2840: el = zend_brk_cont(GET_OP2_ZVAL_PTR(BP_VAR_R), opline->op1.u.opline_num,
! 2841: EX(op_array), EX(Ts) TSRMLS_CC);
! 2842: FREE_OP2();
! 2843: ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
! 2844: }
! 2845:
! 2846: ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST)
! 2847: {
! 2848: zend_op *brk_opline;
! 2849: zend_op *opline = EX(opline);
! 2850: zend_brk_cont_element *el;
! 2851:
! 2852: el = zend_brk_cont(&opline->op2.u.constant, opline->extended_value,
! 2853: EX(op_array), EX(Ts) TSRMLS_CC);
! 2854:
! 2855: brk_opline = EX(op_array)->opcodes + el->brk;
! 2856:
! 2857: switch (brk_opline->opcode) {
! 2858: case ZEND_SWITCH_FREE:
! 2859: if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
! 2860: zend_switch_free(&EX_T(brk_opline->op1.u.var), brk_opline->extended_value TSRMLS_CC);
! 2861: }
! 2862: break;
! 2863: case ZEND_FREE:
! 2864: if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
! 2865: zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
! 2866: }
! 2867: break;
! 2868: }
! 2869: ZEND_VM_JMP(opline->op1.u.jmp_addr);
! 2870: }
! 2871:
! 2872: ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
! 2873: {
! 2874: zend_op *opline = EX(opline);
! 2875: int switch_expr_is_overloaded=0;
! 2876: zend_free_op free_op1, free_op2;
! 2877:
! 2878: if (OP1_TYPE==IS_VAR) {
! 2879: if (EX_T(opline->op1.u.var).var.ptr_ptr) {
! 2880: PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
! 2881: } else {
! 2882: switch_expr_is_overloaded = 1;
! 2883: Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
! 2884: }
! 2885: }
! 2886: is_equal_function(&EX_T(opline->result.u.var).tmp_var,
! 2887: GET_OP1_ZVAL_PTR(BP_VAR_R),
! 2888: GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
! 2889:
! 2890: FREE_OP2();
! 2891: if (switch_expr_is_overloaded) {
! 2892: /* We only free op1 if this is a string offset,
! 2893: * Since if it is a TMP_VAR, it'll be reused by
! 2894: * other CASE opcodes (whereas string offsets
! 2895: * are allocated at each get_zval_ptr())
! 2896: */
! 2897: FREE_OP1();
! 2898: EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
! 2899: EX_T(opline->op1.u.var).var.ptr = NULL;
! 2900: }
! 2901: ZEND_VM_NEXT_OPCODE();
! 2902: }
! 2903:
! 2904: ZEND_VM_HANDLER(49, ZEND_SWITCH_FREE, VAR, ANY)
! 2905: {
! 2906: zend_op *opline = EX(opline);
! 2907:
! 2908: zend_switch_free(&EX_T(opline->op1.u.var), opline->extended_value TSRMLS_CC);
! 2909: ZEND_VM_NEXT_OPCODE();
! 2910: }
! 2911:
! 2912: ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
! 2913: {
! 2914: zend_op *opline = EX(opline);
! 2915: zval *object_zval;
! 2916: zend_function *constructor;
! 2917:
! 2918: if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
! 2919: char *class_type;
! 2920:
! 2921: if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
! 2922: class_type = "interface";
! 2923: } else {
! 2924: class_type = "abstract class";
! 2925: }
! 2926: zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type, EX_T(opline->op1.u.var).class_entry->name);
! 2927: }
! 2928: ALLOC_ZVAL(object_zval);
! 2929: object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
! 2930: INIT_PZVAL(object_zval);
! 2931:
! 2932: constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
! 2933:
! 2934: if (constructor == NULL) {
! 2935: if (RETURN_VALUE_USED(opline)) {
! 2936: AI_SET_PTR(EX_T(opline->result.u.var).var, object_zval);
! 2937: } else {
! 2938: zval_ptr_dtor(&object_zval);
! 2939: }
! 2940: ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.u.opline_num);
! 2941: } else {
! 2942: if (RETURN_VALUE_USED(opline)) {
! 2943: AI_SET_PTR(EX_T(opline->result.u.var).var, object_zval);
! 2944: PZVAL_LOCK(object_zval);
! 2945: }
! 2946:
! 2947: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), ENCODE_CTOR(EX(called_scope), RETURN_VALUE_USED(opline)));
! 2948:
! 2949: /* We are not handling overloaded classes right now */
! 2950: EX(object) = object_zval;
! 2951: EX(fbc) = constructor;
! 2952: EX(called_scope) = EX_T(opline->op1.u.var).class_entry;
! 2953:
! 2954: ZEND_VM_NEXT_OPCODE();
! 2955: }
! 2956: }
! 2957:
! 2958: ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
! 2959: {
! 2960: zend_op *opline = EX(opline);
! 2961: zend_free_op free_op1;
! 2962: zval *obj = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
! 2963: zend_class_entry *ce;
! 2964: zend_function *clone;
! 2965: zend_object_clone_obj_t clone_call;
! 2966:
! 2967: if (OP1_TYPE == IS_CONST ||
! 2968: (OP1_TYPE == IS_VAR && !obj) ||
! 2969: Z_TYPE_P(obj) != IS_OBJECT) {
! 2970: zend_error_noreturn(E_ERROR, "__clone method called on non-object");
! 2971: }
! 2972:
! 2973: ce = Z_OBJCE_P(obj);
! 2974: clone = ce ? ce->clone : NULL;
! 2975: clone_call = Z_OBJ_HT_P(obj)->clone_obj;
! 2976: if (!clone_call) {
! 2977: if (ce) {
! 2978: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
! 2979: } else {
! 2980: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
! 2981: }
! 2982: }
! 2983:
! 2984: if (ce && clone) {
! 2985: if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
! 2986: /* Ensure that if we're calling a private function, we're allowed to do so.
! 2987: */
! 2988: if (ce != EG(scope)) {
! 2989: zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
! 2990: }
! 2991: } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
! 2992: /* Ensure that if we're calling a protected function, we're allowed to do so.
! 2993: */
! 2994: if (!zend_check_protected(clone->common.scope, EG(scope))) {
! 2995: zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
! 2996: }
! 2997: }
! 2998: }
! 2999:
! 3000: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 3001: if (!EG(exception)) {
! 3002: ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 3003: Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
! 3004: Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
! 3005: Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
! 3006: Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
! 3007: if (!RETURN_VALUE_USED(opline) || EG(exception)) {
! 3008: zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
! 3009: }
! 3010: }
! 3011: FREE_OP1_IF_VAR();
! 3012: ZEND_VM_NEXT_OPCODE();
! 3013: }
! 3014:
! 3015: ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
! 3016: {
! 3017: zend_op *opline = EX(opline);
! 3018:
! 3019: if (OP1_TYPE == IS_UNUSED) {
! 3020: /* namespaced constant */
! 3021: if (!zend_get_constant_ex(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), &EX_T(opline->result.u.var).tmp_var, NULL, opline->extended_value TSRMLS_CC)) {
! 3022: if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
! 3023: char *actual = (char *)zend_memrchr(Z_STRVAL(opline->op2.u.constant), '\\', Z_STRLEN(opline->op2.u.constant));
! 3024: if(!actual) {
! 3025: actual = Z_STRVAL(opline->op2.u.constant);
! 3026: } else {
! 3027: actual++;
! 3028: }
! 3029: /* non-qualified constant - allow text substitution */
! 3030: zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
! 3031: ZVAL_STRINGL(&EX_T(opline->result.u.var).tmp_var, actual, Z_STRLEN(opline->op2.u.constant)-(actual - Z_STRVAL(opline->op2.u.constant)), 1);
! 3032: } else {
! 3033: zend_error_noreturn(E_ERROR, "Undefined constant '%s'",
! 3034: Z_STRVAL(opline->op2.u.constant), Z_STRVAL(opline->op2.u.constant));
! 3035: }
! 3036: }
! 3037: ZEND_VM_NEXT_OPCODE();
! 3038: } else {
! 3039: /* class constant */
! 3040: zend_class_entry *ce;
! 3041: zval **value;
! 3042:
! 3043: if (OP1_TYPE == IS_CONST) {
! 3044:
! 3045: ce = zend_fetch_class(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), opline->extended_value TSRMLS_CC);
! 3046: if (!ce) {
! 3047: zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
! 3048: }
! 3049: } else {
! 3050: ce = EX_T(opline->op1.u.var).class_entry;
! 3051: }
! 3052:
! 3053: if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
! 3054: if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY ||
! 3055: (Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
! 3056: zend_class_entry *old_scope = EG(scope);
! 3057:
! 3058: EG(scope) = ce;
! 3059: zval_update_constant(value, (void *) 1 TSRMLS_CC);
! 3060: EG(scope) = old_scope;
! 3061: }
! 3062: EX_T(opline->result.u.var).tmp_var = **value;
! 3063: zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
! 3064: } else {
! 3065: zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL(opline->op2.u.constant));
! 3066: }
! 3067:
! 3068: ZEND_VM_NEXT_OPCODE();
! 3069: }
! 3070: }
! 3071:
! 3072: ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUSED|CV)
! 3073: {
! 3074: zend_op *opline = EX(opline);
! 3075: zend_free_op free_op1, free_op2;
! 3076: zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
! 3077: zval *expr_ptr;
! 3078: zval *offset=GET_OP2_ZVAL_PTR(BP_VAR_R);
! 3079:
! 3080: #if !defined(ZEND_VM_SPEC) || OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV
! 3081: zval **expr_ptr_ptr = NULL;
! 3082:
! 3083: if (opline->extended_value) {
! 3084: expr_ptr_ptr=GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
! 3085: expr_ptr = *expr_ptr_ptr;
! 3086: } else {
! 3087: expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
! 3088: }
! 3089: #else
! 3090: expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
! 3091: #endif
! 3092:
! 3093: if (IS_OP1_TMP_FREE()) { /* temporary variable */
! 3094: zval *new_expr;
! 3095:
! 3096: ALLOC_ZVAL(new_expr);
! 3097: INIT_PZVAL_COPY(new_expr, expr_ptr);
! 3098: expr_ptr = new_expr;
! 3099: } else {
! 3100: #if !defined(ZEND_VM_SPEC) || OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV
! 3101: if (opline->extended_value) {
! 3102: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
! 3103: expr_ptr = *expr_ptr_ptr;
! 3104: Z_ADDREF_P(expr_ptr);
! 3105: } else
! 3106: #endif
! 3107: if (OP1_TYPE == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
! 3108: zval *new_expr;
! 3109:
! 3110: ALLOC_ZVAL(new_expr);
! 3111: INIT_PZVAL_COPY(new_expr, expr_ptr);
! 3112: expr_ptr = new_expr;
! 3113: zendi_zval_copy_ctor(*expr_ptr);
! 3114: } else {
! 3115: Z_ADDREF_P(expr_ptr);
! 3116: }
! 3117: }
! 3118: if (offset) {
! 3119: switch (Z_TYPE_P(offset)) {
! 3120: case IS_DOUBLE:
! 3121: zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
! 3122: break;
! 3123: case IS_LONG:
! 3124: case IS_BOOL:
! 3125: zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
! 3126: break;
! 3127: case IS_STRING:
! 3128: zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
! 3129: break;
! 3130: case IS_NULL:
! 3131: zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
! 3132: break;
! 3133: default:
! 3134: zend_error(E_WARNING, "Illegal offset type");
! 3135: zval_ptr_dtor(&expr_ptr);
! 3136: /* do nothing */
! 3137: break;
! 3138: }
! 3139: FREE_OP2();
! 3140: } else {
! 3141: zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
! 3142: }
! 3143: if (opline->extended_value) {
! 3144: FREE_OP1_VAR_PTR();
! 3145: } else {
! 3146: FREE_OP1_IF_VAR();
! 3147: }
! 3148: ZEND_VM_NEXT_OPCODE();
! 3149: }
! 3150:
! 3151: ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
! 3152: {
! 3153: zend_op *opline = EX(opline);
! 3154:
! 3155: array_init(&EX_T(opline->result.u.var).tmp_var);
! 3156: if (OP1_TYPE == IS_UNUSED) {
! 3157: ZEND_VM_NEXT_OPCODE();
! 3158: #if !defined(ZEND_VM_SPEC) || OP1_TYPE != IS_UNUSED
! 3159: } else {
! 3160: ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
! 3161: #endif
! 3162: }
! 3163: }
! 3164:
! 3165: ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
! 3166: {
! 3167: zend_op *opline = EX(opline);
! 3168: zend_free_op free_op1;
! 3169: zval *expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 3170: zval *result = &EX_T(opline->result.u.var).tmp_var;
! 3171:
! 3172: if (opline->extended_value != IS_STRING) {
! 3173: *result = *expr;
! 3174: if (!IS_OP1_TMP_FREE()) {
! 3175: zendi_zval_copy_ctor(*result);
! 3176: }
! 3177: }
! 3178: switch (opline->extended_value) {
! 3179: case IS_NULL:
! 3180: convert_to_null(result);
! 3181: break;
! 3182: case IS_BOOL:
! 3183: convert_to_boolean(result);
! 3184: break;
! 3185: case IS_LONG:
! 3186: convert_to_long(result);
! 3187: break;
! 3188: case IS_DOUBLE:
! 3189: convert_to_double(result);
! 3190: break;
! 3191: case IS_STRING: {
! 3192: zval var_copy;
! 3193: int use_copy;
! 3194:
! 3195: zend_make_printable_zval(expr, &var_copy, &use_copy);
! 3196: if (use_copy) {
! 3197: *result = var_copy;
! 3198: if (IS_OP1_TMP_FREE()) {
! 3199: FREE_OP1();
! 3200: }
! 3201: } else {
! 3202: *result = *expr;
! 3203: if (!IS_OP1_TMP_FREE()) {
! 3204: zendi_zval_copy_ctor(*result);
! 3205: }
! 3206: }
! 3207: break;
! 3208: }
! 3209: case IS_ARRAY:
! 3210: convert_to_array(result);
! 3211: break;
! 3212: case IS_OBJECT:
! 3213: convert_to_object(result);
! 3214: break;
! 3215: }
! 3216: FREE_OP1_IF_VAR();
! 3217: ZEND_VM_NEXT_OPCODE();
! 3218: }
! 3219:
! 3220: ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
! 3221: {
! 3222: zend_op *opline = EX(opline);
! 3223: zend_op_array *new_op_array=NULL;
! 3224: int return_value_used;
! 3225: zend_free_op free_op1;
! 3226: zval *inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 3227: zval tmp_inc_filename;
! 3228: zend_bool failure_retval=0;
! 3229:
! 3230: if (inc_filename->type!=IS_STRING) {
! 3231: tmp_inc_filename = *inc_filename;
! 3232: zval_copy_ctor(&tmp_inc_filename);
! 3233: convert_to_string(&tmp_inc_filename);
! 3234: inc_filename = &tmp_inc_filename;
! 3235: }
! 3236:
! 3237: return_value_used = RETURN_VALUE_USED(opline);
! 3238:
! 3239: if (Z_LVAL(opline->op2.u.constant) != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
! 3240: if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE || Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE) {
! 3241: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
! 3242: } else {
! 3243: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
! 3244: }
! 3245: } else {
! 3246: switch (Z_LVAL(opline->op2.u.constant)) {
! 3247: case ZEND_INCLUDE_ONCE:
! 3248: case ZEND_REQUIRE_ONCE: {
! 3249: zend_file_handle file_handle;
! 3250: char *resolved_path;
! 3251:
! 3252: resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
! 3253: if (resolved_path) {
! 3254: failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
! 3255: } else {
! 3256: resolved_path = Z_STRVAL_P(inc_filename);
! 3257: }
! 3258:
! 3259: if (failure_retval) {
! 3260: /* do nothing, file already included */
! 3261: } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
! 3262:
! 3263: if (!file_handle.opened_path) {
! 3264: file_handle.opened_path = estrdup(resolved_path);
! 3265: }
! 3266:
! 3267: if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
! 3268: new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
! 3269: zend_destroy_file_handle(&file_handle TSRMLS_CC);
! 3270: } else {
! 3271: zend_file_handle_dtor(&file_handle TSRMLS_CC);
! 3272: failure_retval=1;
! 3273: }
! 3274: } else {
! 3275: if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
! 3276: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
! 3277: } else {
! 3278: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
! 3279: }
! 3280: }
! 3281: if (resolved_path != Z_STRVAL_P(inc_filename)) {
! 3282: efree(resolved_path);
! 3283: }
! 3284: }
! 3285: break;
! 3286: case ZEND_INCLUDE:
! 3287: case ZEND_REQUIRE:
! 3288: new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
! 3289: break;
! 3290: case ZEND_EVAL: {
! 3291: char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
! 3292:
! 3293: new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
! 3294: efree(eval_desc);
! 3295: }
! 3296: break;
! 3297: EMPTY_SWITCH_DEFAULT_CASE()
! 3298: }
! 3299: }
! 3300: if (inc_filename==&tmp_inc_filename) {
! 3301: zval_dtor(&tmp_inc_filename);
! 3302: }
! 3303: FREE_OP1();
! 3304: EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
! 3305: if (new_op_array && !EG(exception)) {
! 3306: EX(original_return_value) = EG(return_value_ptr_ptr);
! 3307: EG(return_value_ptr_ptr) = return_value_used ? EX_T(opline->result.u.var).var.ptr_ptr : NULL;
! 3308: EG(active_op_array) = new_op_array;
! 3309: EX_T(opline->result.u.var).var.ptr = NULL;
! 3310:
! 3311: EX(current_object) = EX(object);
! 3312:
! 3313: EX(function_state).function = (zend_function *) new_op_array;
! 3314: EX(object) = NULL;
! 3315:
! 3316: if (!EG(active_symbol_table)) {
! 3317: zend_rebuild_symbol_table(TSRMLS_C);
! 3318: }
! 3319:
! 3320: if (zend_execute == execute) {
! 3321: EX(call_opline) = opline;
! 3322: ZEND_VM_ENTER();
! 3323: } else {
! 3324: zend_execute(new_op_array TSRMLS_CC);
! 3325: }
! 3326:
! 3327: EX(function_state).function = (zend_function *) EX(op_array);
! 3328: EX(object) = EX(current_object);
! 3329:
! 3330: if (return_value_used) {
! 3331: if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
! 3332: ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 3333: INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
! 3334: Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
! 3335: Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
! 3336: }
! 3337: }
! 3338:
! 3339: EG(opline_ptr) = &EX(opline);
! 3340: EG(active_op_array) = EX(op_array);
! 3341: EG(return_value_ptr_ptr) = EX(original_return_value);
! 3342: destroy_op_array(new_op_array TSRMLS_CC);
! 3343: efree(new_op_array);
! 3344: if (EG(exception)) {
! 3345: zend_throw_exception_internal(NULL TSRMLS_CC);
! 3346: }
! 3347: } else {
! 3348: if (return_value_used) {
! 3349: ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
! 3350: INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
! 3351: Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
! 3352: Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
! 3353: }
! 3354: }
! 3355: ZEND_VM_NEXT_OPCODE();
! 3356: }
! 3357:
! 3358: ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, ANY)
! 3359: {
! 3360: zend_op *opline = EX(opline);
! 3361: zval tmp, *varname;
! 3362: HashTable *target_symbol_table;
! 3363: zend_free_op free_op1;
! 3364:
! 3365: if (OP1_TYPE == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
! 3366: if (EG(active_symbol_table)) {
! 3367: zend_execute_data *ex = EX(prev_execute_data);
! 3368: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
! 3369:
! 3370: if (zend_hash_quick_del(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value) == SUCCESS) {
! 3371: while (ex && ex->symbol_table == EG(active_symbol_table)) {
! 3372: int i;
! 3373:
! 3374: if (ex->op_array) {
! 3375: for (i = 0; i < ex->op_array->last_var; i++) {
! 3376: if (ex->op_array->vars[i].hash_value == cv->hash_value &&
! 3377: ex->op_array->vars[i].name_len == cv->name_len &&
! 3378: !memcmp(ex->op_array->vars[i].name, cv->name, cv->name_len)) {
! 3379: ex->CVs[i] = NULL;
! 3380: break;
! 3381: }
! 3382: }
! 3383: }
! 3384: ex = ex->prev_execute_data;
! 3385: }
! 3386: }
! 3387: EX(CVs)[opline->op1.u.var] = NULL;
! 3388: } else if (EX(CVs)[opline->op1.u.var]) {
! 3389: zval_ptr_dtor(EX(CVs)[opline->op1.u.var]);
! 3390: EX(CVs)[opline->op1.u.var] = NULL;
! 3391: }
! 3392: ZEND_VM_NEXT_OPCODE();
! 3393: }
! 3394:
! 3395: varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 3396:
! 3397: if (Z_TYPE_P(varname) != IS_STRING) {
! 3398: tmp = *varname;
! 3399: zval_copy_ctor(&tmp);
! 3400: convert_to_string(&tmp);
! 3401: varname = &tmp;
! 3402: } else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
! 3403: Z_ADDREF_P(varname);
! 3404: }
! 3405:
! 3406: if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
! 3407: zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
! 3408: } else {
! 3409: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
! 3410:
! 3411: target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
! 3412: if (zend_hash_quick_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value) == SUCCESS) {
! 3413: zend_execute_data *ex = EXECUTE_DATA;
! 3414:
! 3415: do {
! 3416: int i;
! 3417:
! 3418: if (ex->op_array) {
! 3419: for (i = 0; i < ex->op_array->last_var; i++) {
! 3420: if (ex->op_array->vars[i].hash_value == hash_value &&
! 3421: ex->op_array->vars[i].name_len == varname->value.str.len &&
! 3422: !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) {
! 3423: ex->CVs[i] = NULL;
! 3424: break;
! 3425: }
! 3426: }
! 3427: }
! 3428: ex = ex->prev_execute_data;
! 3429: } while (ex && ex->symbol_table == target_symbol_table);
! 3430: }
! 3431: }
! 3432:
! 3433: if (varname == &tmp) {
! 3434: zval_dtor(&tmp);
! 3435: } else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
! 3436: zval_ptr_dtor(&varname);
! 3437: }
! 3438: FREE_OP1();
! 3439: ZEND_VM_NEXT_OPCODE();
! 3440: }
! 3441:
! 3442: ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 3443: {
! 3444: zend_op *opline = EX(opline);
! 3445: zend_free_op free_op1, free_op2;
! 3446: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
! 3447: zval *offset;
! 3448:
! 3449: if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
! 3450: SEPARATE_ZVAL_IF_NOT_REF(container);
! 3451: }
! 3452: offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 3453:
! 3454: if (OP1_TYPE != IS_VAR || container) {
! 3455: switch (Z_TYPE_PP(container)) {
! 3456: case IS_ARRAY: {
! 3457: HashTable *ht = Z_ARRVAL_PP(container);
! 3458:
! 3459: switch (Z_TYPE_P(offset)) {
! 3460: case IS_DOUBLE:
! 3461: zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
! 3462: break;
! 3463: case IS_RESOURCE:
! 3464: case IS_BOOL:
! 3465: case IS_LONG:
! 3466: zend_hash_index_del(ht, Z_LVAL_P(offset));
! 3467: break;
! 3468: case IS_STRING:
! 3469: if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
! 3470: Z_ADDREF_P(offset);
! 3471: }
! 3472: if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
! 3473: ht == &EG(symbol_table)) {
! 3474: zend_execute_data *ex;
! 3475: ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
! 3476:
! 3477: for (ex = EXECUTE_DATA; ex; ex = ex->prev_execute_data) {
! 3478: if (ex->op_array && ex->symbol_table == ht) {
! 3479: int i;
! 3480:
! 3481: for (i = 0; i < ex->op_array->last_var; i++) {
! 3482: if (ex->op_array->vars[i].hash_value == hash_value &&
! 3483: ex->op_array->vars[i].name_len == offset->value.str.len &&
! 3484: !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
! 3485: ex->CVs[i] = NULL;
! 3486: break;
! 3487: }
! 3488: }
! 3489: }
! 3490: }
! 3491: }
! 3492: if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
! 3493: zval_ptr_dtor(&offset);
! 3494: }
! 3495: break;
! 3496: case IS_NULL:
! 3497: zend_hash_del(ht, "", sizeof(""));
! 3498: break;
! 3499: default:
! 3500: zend_error(E_WARNING, "Illegal offset type in unset");
! 3501: break;
! 3502: }
! 3503: FREE_OP2();
! 3504: break;
! 3505: }
! 3506: case IS_OBJECT:
! 3507: if (!Z_OBJ_HT_P(*container)->unset_dimension) {
! 3508: zend_error_noreturn(E_ERROR, "Cannot use object as array");
! 3509: }
! 3510: if (IS_OP2_TMP_FREE()) {
! 3511: MAKE_REAL_ZVAL_PTR(offset);
! 3512: }
! 3513: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
! 3514: if (IS_OP2_TMP_FREE()) {
! 3515: zval_ptr_dtor(&offset);
! 3516: } else {
! 3517: FREE_OP2();
! 3518: }
! 3519: break;
! 3520: case IS_STRING:
! 3521: zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
! 3522: ZEND_VM_CONTINUE(); /* bailed out before */
! 3523: default:
! 3524: FREE_OP2();
! 3525: break;
! 3526: }
! 3527: } else {
! 3528: FREE_OP2();
! 3529: }
! 3530: FREE_OP1_VAR_PTR();
! 3531:
! 3532: ZEND_VM_NEXT_OPCODE();
! 3533: }
! 3534:
! 3535: ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 3536: {
! 3537: zend_op *opline = EX(opline);
! 3538: zend_free_op free_op1, free_op2;
! 3539: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
! 3540: zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 3541:
! 3542: if (OP1_TYPE != IS_VAR || container) {
! 3543: if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
! 3544: SEPARATE_ZVAL_IF_NOT_REF(container);
! 3545: }
! 3546: if (Z_TYPE_PP(container) == IS_OBJECT) {
! 3547: if (IS_OP2_TMP_FREE()) {
! 3548: MAKE_REAL_ZVAL_PTR(offset);
! 3549: }
! 3550: if (Z_OBJ_HT_P(*container)->unset_property) {
! 3551: Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
! 3552: } else {
! 3553: zend_error(E_NOTICE, "Trying to unset property of non-object");
! 3554: }
! 3555: if (IS_OP2_TMP_FREE()) {
! 3556: zval_ptr_dtor(&offset);
! 3557: } else {
! 3558: FREE_OP2();
! 3559: }
! 3560: } else {
! 3561: FREE_OP2();
! 3562: }
! 3563: } else {
! 3564: FREE_OP2();
! 3565: }
! 3566: FREE_OP1_VAR_PTR();
! 3567:
! 3568: ZEND_VM_NEXT_OPCODE();
! 3569: }
! 3570:
! 3571: ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
! 3572: {
! 3573: zend_op *opline = EX(opline);
! 3574: zend_free_op free_op1;
! 3575: zval *array_ptr, **array_ptr_ptr;
! 3576: HashTable *fe_ht;
! 3577: zend_object_iterator *iter = NULL;
! 3578: zend_class_entry *ce = NULL;
! 3579: zend_bool is_empty = 0;
! 3580:
! 3581: if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
! 3582: array_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
! 3583: if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
! 3584: ALLOC_INIT_ZVAL(array_ptr);
! 3585: } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
! 3586: if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
! 3587: zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
! 3588: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3589: }
! 3590:
! 3591: ce = Z_OBJCE_PP(array_ptr_ptr);
! 3592: if (!ce || ce->get_iterator == NULL) {
! 3593: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
! 3594: Z_ADDREF_PP(array_ptr_ptr);
! 3595: }
! 3596: array_ptr = *array_ptr_ptr;
! 3597: } else {
! 3598: if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
! 3599: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
! 3600: if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
! 3601: Z_SET_ISREF_PP(array_ptr_ptr);
! 3602: }
! 3603: }
! 3604: array_ptr = *array_ptr_ptr;
! 3605: Z_ADDREF_P(array_ptr);
! 3606: }
! 3607: } else {
! 3608: array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 3609: if (IS_OP1_TMP_FREE()) { /* IS_TMP_VAR */
! 3610: zval *tmp;
! 3611:
! 3612: ALLOC_ZVAL(tmp);
! 3613: INIT_PZVAL_COPY(tmp, array_ptr);
! 3614: array_ptr = tmp;
! 3615: if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
! 3616: ce = Z_OBJCE_P(array_ptr);
! 3617: if (ce && ce->get_iterator) {
! 3618: Z_DELREF_P(array_ptr);
! 3619: }
! 3620: }
! 3621: } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
! 3622: ce = Z_OBJCE_P(array_ptr);
! 3623: if (!ce || !ce->get_iterator) {
! 3624: Z_ADDREF_P(array_ptr);
! 3625: }
! 3626: } else if (OP1_TYPE == IS_CONST ||
! 3627: ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
! 3628: !Z_ISREF_P(array_ptr) &&
! 3629: Z_REFCOUNT_P(array_ptr) > 1)) {
! 3630: zval *tmp;
! 3631:
! 3632: ALLOC_ZVAL(tmp);
! 3633: INIT_PZVAL_COPY(tmp, array_ptr);
! 3634: zval_copy_ctor(tmp);
! 3635: array_ptr = tmp;
! 3636: } else {
! 3637: Z_ADDREF_P(array_ptr);
! 3638: }
! 3639: }
! 3640:
! 3641: if (ce && ce->get_iterator) {
! 3642: iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
! 3643:
! 3644: if (iter && !EG(exception)) {
! 3645: array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
! 3646: } else {
! 3647: if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
! 3648: FREE_OP1_VAR_PTR();
! 3649: } else {
! 3650: FREE_OP1_IF_VAR();
! 3651: }
! 3652: if (!EG(exception)) {
! 3653: zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
! 3654: }
! 3655: zend_throw_exception_internal(NULL TSRMLS_CC);
! 3656: ZEND_VM_NEXT_OPCODE();
! 3657: }
! 3658: }
! 3659:
! 3660: AI_SET_PTR(EX_T(opline->result.u.var).var, array_ptr);
! 3661: PZVAL_LOCK(array_ptr);
! 3662:
! 3663: if (iter) {
! 3664: iter->index = 0;
! 3665: if (iter->funcs->rewind) {
! 3666: iter->funcs->rewind(iter TSRMLS_CC);
! 3667: if (EG(exception)) {
! 3668: Z_DELREF_P(array_ptr);
! 3669: zval_ptr_dtor(&array_ptr);
! 3670: if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
! 3671: FREE_OP1_VAR_PTR();
! 3672: } else {
! 3673: FREE_OP1_IF_VAR();
! 3674: }
! 3675: ZEND_VM_NEXT_OPCODE();
! 3676: }
! 3677: }
! 3678: is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
! 3679: if (EG(exception)) {
! 3680: Z_DELREF_P(array_ptr);
! 3681: zval_ptr_dtor(&array_ptr);
! 3682: if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
! 3683: FREE_OP1_VAR_PTR();
! 3684: } else {
! 3685: FREE_OP1_IF_VAR();
! 3686: }
! 3687: ZEND_VM_NEXT_OPCODE();
! 3688: }
! 3689: iter->index = -1; /* will be set to 0 before using next handler */
! 3690: } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
! 3691: zend_hash_internal_pointer_reset(fe_ht);
! 3692: if (ce) {
! 3693: zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
! 3694: while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
! 3695: char *str_key;
! 3696: uint str_key_len;
! 3697: ulong int_key;
! 3698: zend_uchar key_type;
! 3699:
! 3700: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
! 3701: if (key_type != HASH_KEY_NON_EXISTANT &&
! 3702: (key_type == HASH_KEY_IS_LONG ||
! 3703: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
! 3704: break;
! 3705: }
! 3706: zend_hash_move_forward(fe_ht);
! 3707: }
! 3708: }
! 3709: is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
! 3710: zend_hash_get_pointer(fe_ht, &EX_T(opline->result.u.var).fe.fe_pos);
! 3711: } else {
! 3712: zend_error(E_WARNING, "Invalid argument supplied for foreach()");
! 3713: is_empty = 1;
! 3714: }
! 3715:
! 3716: if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
! 3717: FREE_OP1_VAR_PTR();
! 3718: } else {
! 3719: FREE_OP1_IF_VAR();
! 3720: }
! 3721: if (is_empty) {
! 3722: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3723: } else {
! 3724: ZEND_VM_NEXT_OPCODE();
! 3725: }
! 3726: }
! 3727:
! 3728: ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
! 3729: {
! 3730: zend_op *opline = EX(opline);
! 3731: zend_free_op free_op1;
! 3732: zval *array = EX_T(opline->op1.u.var).var.ptr;
! 3733: zval **value;
! 3734: char *str_key;
! 3735: uint str_key_len;
! 3736: ulong int_key;
! 3737: HashTable *fe_ht;
! 3738: zend_object_iterator *iter = NULL;
! 3739: int key_type = 0;
! 3740: zend_bool use_key = (zend_bool)(opline->extended_value & ZEND_FE_FETCH_WITH_KEY);
! 3741:
! 3742: switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
! 3743: default:
! 3744: case ZEND_ITER_INVALID:
! 3745: zend_error(E_WARNING, "Invalid argument supplied for foreach()");
! 3746: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3747:
! 3748: case ZEND_ITER_PLAIN_OBJECT: {
! 3749: char *class_name, *prop_name;
! 3750: zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
! 3751:
! 3752: fe_ht = HASH_OF(array);
! 3753: zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
! 3754: do {
! 3755: if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
! 3756: /* reached end of iteration */
! 3757: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3758: }
! 3759: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
! 3760:
! 3761: zend_hash_move_forward(fe_ht);
! 3762: } while (key_type == HASH_KEY_NON_EXISTANT ||
! 3763: (key_type != HASH_KEY_IS_LONG &&
! 3764: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) != SUCCESS));
! 3765: zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
! 3766: if (use_key && key_type != HASH_KEY_IS_LONG) {
! 3767: zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name);
! 3768: str_key_len = strlen(prop_name);
! 3769: str_key = estrndup(prop_name, str_key_len);
! 3770: str_key_len++;
! 3771: }
! 3772: break;
! 3773: }
! 3774:
! 3775: case ZEND_ITER_PLAIN_ARRAY:
! 3776: fe_ht = HASH_OF(array);
! 3777: zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
! 3778: if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
! 3779: /* reached end of iteration */
! 3780: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3781: }
! 3782: if (use_key) {
! 3783: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 1, NULL);
! 3784: }
! 3785: zend_hash_move_forward(fe_ht);
! 3786: zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.u.var).fe.fe_pos);
! 3787: break;
! 3788:
! 3789: case ZEND_ITER_OBJECT:
! 3790: /* !iter happens from exception */
! 3791: if (iter && ++iter->index > 0) {
! 3792: /* This could cause an endless loop if index becomes zero again.
! 3793: * In case that ever happens we need an additional flag. */
! 3794: iter->funcs->move_forward(iter TSRMLS_CC);
! 3795: if (EG(exception)) {
! 3796: Z_DELREF_P(array);
! 3797: zval_ptr_dtor(&array);
! 3798: ZEND_VM_NEXT_OPCODE();
! 3799: }
! 3800: }
! 3801: /* If index is zero we come from FE_RESET and checked valid() already. */
! 3802: if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
! 3803: /* reached end of iteration */
! 3804: if (EG(exception)) {
! 3805: Z_DELREF_P(array);
! 3806: zval_ptr_dtor(&array);
! 3807: ZEND_VM_NEXT_OPCODE();
! 3808: }
! 3809: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3810: }
! 3811: iter->funcs->get_current_data(iter, &value TSRMLS_CC);
! 3812: if (EG(exception)) {
! 3813: Z_DELREF_P(array);
! 3814: zval_ptr_dtor(&array);
! 3815: ZEND_VM_NEXT_OPCODE();
! 3816: }
! 3817: if (!value) {
! 3818: /* failure in get_current_data */
! 3819: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
! 3820: }
! 3821: if (use_key) {
! 3822: if (iter->funcs->get_current_key) {
! 3823: key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
! 3824: if (EG(exception)) {
! 3825: Z_DELREF_P(array);
! 3826: zval_ptr_dtor(&array);
! 3827: ZEND_VM_NEXT_OPCODE();
! 3828: }
! 3829: } else {
! 3830: key_type = HASH_KEY_IS_LONG;
! 3831: int_key = iter->index;
! 3832: }
! 3833: }
! 3834: break;
! 3835: }
! 3836:
! 3837: if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
! 3838: SEPARATE_ZVAL_IF_NOT_REF(value);
! 3839: Z_SET_ISREF_PP(value);
! 3840: EX_T(opline->result.u.var).var.ptr_ptr = value;
! 3841: Z_ADDREF_PP(value);
! 3842: } else {
! 3843: AI_SET_PTR(EX_T(opline->result.u.var).var, *value);
! 3844: PZVAL_LOCK(*value);
! 3845: }
! 3846:
! 3847: if (use_key) {
! 3848: zend_op *op_data = opline+1;
! 3849: zval *key = &EX_T(op_data->result.u.var).tmp_var;
! 3850:
! 3851: switch (key_type) {
! 3852: case HASH_KEY_IS_STRING:
! 3853: Z_STRVAL_P(key) = str_key;
! 3854: Z_STRLEN_P(key) = str_key_len-1;
! 3855: Z_TYPE_P(key) = IS_STRING;
! 3856: break;
! 3857: case HASH_KEY_IS_LONG:
! 3858: Z_LVAL_P(key) = int_key;
! 3859: Z_TYPE_P(key) = IS_LONG;
! 3860: break;
! 3861: default:
! 3862: case HASH_KEY_NON_EXISTANT:
! 3863: ZVAL_NULL(key);
! 3864: break;
! 3865: }
! 3866: }
! 3867:
! 3868: ZEND_VM_INC_OPCODE();
! 3869: ZEND_VM_NEXT_OPCODE();
! 3870: }
! 3871:
! 3872: ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
! 3873: {
! 3874: zend_op *opline = EX(opline);
! 3875: zval **value;
! 3876: zend_bool isset = 1;
! 3877:
! 3878: if (OP1_TYPE == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
! 3879: if (EX(CVs)[opline->op1.u.var]) {
! 3880: value = EX(CVs)[opline->op1.u.var];
! 3881: } else if (EG(active_symbol_table)) {
! 3882: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.u.var);
! 3883:
! 3884: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
! 3885: isset = 0;
! 3886: }
! 3887: } else {
! 3888: isset = 0;
! 3889: }
! 3890: } else {
! 3891: HashTable *target_symbol_table;
! 3892: zend_free_op free_op1;
! 3893: zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
! 3894:
! 3895: if (Z_TYPE_P(varname) != IS_STRING) {
! 3896: tmp = *varname;
! 3897: zval_copy_ctor(&tmp);
! 3898: convert_to_string(&tmp);
! 3899: varname = &tmp;
! 3900: }
! 3901:
! 3902: if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
! 3903: value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
! 3904: if (!value) {
! 3905: isset = 0;
! 3906: }
! 3907: } else {
! 3908: target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);
! 3909: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
! 3910: isset = 0;
! 3911: }
! 3912: }
! 3913:
! 3914: if (varname == &tmp) {
! 3915: zval_dtor(&tmp);
! 3916: }
! 3917: FREE_OP1();
! 3918: }
! 3919:
! 3920: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
! 3921:
! 3922: switch (opline->extended_value & ZEND_ISSET_ISEMPTY_MASK) {
! 3923: case ZEND_ISSET:
! 3924: if (isset && Z_TYPE_PP(value) == IS_NULL) {
! 3925: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
! 3926: } else {
! 3927: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
! 3928: }
! 3929: break;
! 3930: case ZEND_ISEMPTY:
! 3931: if (!isset || !i_zend_is_true(*value)) {
! 3932: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
! 3933: } else {
! 3934: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
! 3935: }
! 3936: break;
! 3937: }
! 3938:
! 3939: ZEND_VM_NEXT_OPCODE();
! 3940: }
! 3941:
! 3942: ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int prop_dim)
! 3943: {
! 3944: zend_op *opline = EX(opline);
! 3945: zend_free_op free_op1;
! 3946: zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_IS);
! 3947: zval **value = NULL;
! 3948: int result = 0;
! 3949:
! 3950: if (OP1_TYPE != IS_VAR || container) {
! 3951: zend_free_op free_op2;
! 3952: zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 3953:
! 3954: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) {
! 3955: HashTable *ht;
! 3956: int isset = 0;
! 3957:
! 3958: ht = Z_ARRVAL_PP(container);
! 3959:
! 3960: switch (Z_TYPE_P(offset)) {
! 3961: case IS_DOUBLE:
! 3962: if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
! 3963: isset = 1;
! 3964: }
! 3965: break;
! 3966: case IS_RESOURCE:
! 3967: case IS_BOOL:
! 3968: case IS_LONG:
! 3969: if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
! 3970: isset = 1;
! 3971: }
! 3972: break;
! 3973: case IS_STRING:
! 3974: if (zend_symtable_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
! 3975: isset = 1;
! 3976: }
! 3977: break;
! 3978: case IS_NULL:
! 3979: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
! 3980: isset = 1;
! 3981: }
! 3982: break;
! 3983: default:
! 3984: zend_error(E_WARNING, "Illegal offset type in isset or empty");
! 3985:
! 3986: break;
! 3987: }
! 3988:
! 3989: switch (opline->extended_value) {
! 3990: case ZEND_ISSET:
! 3991: if (isset && Z_TYPE_PP(value) == IS_NULL) {
! 3992: result = 0;
! 3993: } else {
! 3994: result = isset;
! 3995: }
! 3996: break;
! 3997: case ZEND_ISEMPTY:
! 3998: if (!isset || !i_zend_is_true(*value)) {
! 3999: result = 0;
! 4000: } else {
! 4001: result = 1;
! 4002: }
! 4003: break;
! 4004: }
! 4005: FREE_OP2();
! 4006: } else if (Z_TYPE_PP(container) == IS_OBJECT) {
! 4007: if (IS_OP2_TMP_FREE()) {
! 4008: MAKE_REAL_ZVAL_PTR(offset);
! 4009: }
! 4010: if (prop_dim) {
! 4011: if (Z_OBJ_HT_P(*container)->has_property) {
! 4012: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
! 4013: } else {
! 4014: zend_error(E_NOTICE, "Trying to check property of non-object");
! 4015: result = 0;
! 4016: }
! 4017: } else {
! 4018: if (Z_OBJ_HT_P(*container)->has_dimension) {
! 4019: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
! 4020: } else {
! 4021: zend_error(E_NOTICE, "Trying to check element of non-array");
! 4022: result = 0;
! 4023: }
! 4024: }
! 4025: if (IS_OP2_TMP_FREE()) {
! 4026: zval_ptr_dtor(&offset);
! 4027: } else {
! 4028: FREE_OP2();
! 4029: }
! 4030: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
! 4031: zval tmp;
! 4032:
! 4033: if (Z_TYPE_P(offset) != IS_LONG) {
! 4034: tmp = *offset;
! 4035: zval_copy_ctor(&tmp);
! 4036: convert_to_long(&tmp);
! 4037: offset = &tmp;
! 4038: }
! 4039: if (Z_TYPE_P(offset) == IS_LONG) {
! 4040: switch (opline->extended_value) {
! 4041: case ZEND_ISSET:
! 4042: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) {
! 4043: result = 1;
! 4044: }
! 4045: break;
! 4046: case ZEND_ISEMPTY:
! 4047: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') {
! 4048: result = 1;
! 4049: }
! 4050: break;
! 4051: }
! 4052: }
! 4053: FREE_OP2();
! 4054: } else {
! 4055: FREE_OP2();
! 4056: }
! 4057: }
! 4058:
! 4059: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
! 4060:
! 4061: switch (opline->extended_value) {
! 4062: case ZEND_ISSET:
! 4063: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
! 4064: break;
! 4065: case ZEND_ISEMPTY:
! 4066: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
! 4067: break;
! 4068: }
! 4069:
! 4070: FREE_OP1_VAR_PTR();
! 4071:
! 4072: ZEND_VM_NEXT_OPCODE();
! 4073: }
! 4074:
! 4075: ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 4076: {
! 4077: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 0);
! 4078: }
! 4079:
! 4080: ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
! 4081: {
! 4082: ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 1);
! 4083: }
! 4084:
! 4085: ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY)
! 4086: {
! 4087: #if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
! 4088: zend_op *opline = EX(opline);
! 4089: if (OP1_TYPE != IS_UNUSED) {
! 4090: zend_free_op free_op1;
! 4091: zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 4092:
! 4093: if (Z_TYPE_P(ptr) == IS_LONG) {
! 4094: EG(exit_status) = Z_LVAL_P(ptr);
! 4095: } else {
! 4096: zend_print_variable(ptr);
! 4097: }
! 4098: FREE_OP1();
! 4099: }
! 4100: #endif
! 4101: zend_bailout();
! 4102: ZEND_VM_NEXT_OPCODE();
! 4103: }
! 4104:
! 4105: ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
! 4106: {
! 4107: zend_op *opline = EX(opline);
! 4108:
! 4109: Z_LVAL(EX_T(opline->result.u.var).tmp_var) = EG(error_reporting);
! 4110: Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG; /* shouldn't be necessary */
! 4111: if (EX(old_error_reporting) == NULL) {
! 4112: EX(old_error_reporting) = &EX_T(opline->result.u.var).tmp_var;
! 4113: }
! 4114:
! 4115: if (EG(error_reporting)) {
! 4116: zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), "0", 1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
! 4117: }
! 4118: ZEND_VM_NEXT_OPCODE();
! 4119: }
! 4120:
! 4121: ZEND_VM_HANDLER(142, ZEND_RAISE_ABSTRACT_ERROR, ANY, ANY)
! 4122: {
! 4123: zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
! 4124: ZEND_VM_NEXT_OPCODE(); /* Never reached */
! 4125: }
! 4126:
! 4127: ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
! 4128: {
! 4129: zend_op *opline = EX(opline);
! 4130: zval restored_error_reporting;
! 4131:
! 4132: if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.u.var).tmp_var) != 0) {
! 4133: Z_TYPE(restored_error_reporting) = IS_LONG;
! 4134: Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.u.var).tmp_var);
! 4135: convert_to_string(&restored_error_reporting);
! 4136: zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
! 4137: zendi_zval_dtor(restored_error_reporting);
! 4138: }
! 4139: if (EX(old_error_reporting) == &EX_T(opline->op1.u.var).tmp_var) {
! 4140: EX(old_error_reporting) = NULL;
! 4141: }
! 4142: ZEND_VM_NEXT_OPCODE();
! 4143: }
! 4144:
! 4145: ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY)
! 4146: {
! 4147: zend_op *opline = EX(opline);
! 4148: zend_free_op free_op1;
! 4149: zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 4150:
! 4151: if (i_zend_is_true(value)) {
! 4152: EX_T(opline->result.u.var).tmp_var = *value;
! 4153: zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
! 4154: FREE_OP1();
! 4155: #if DEBUG_ZEND>=2
! 4156: printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
! 4157: #endif
! 4158: ZEND_VM_JMP(opline->op2.u.jmp_addr);
! 4159: }
! 4160:
! 4161: FREE_OP1();
! 4162: ZEND_VM_NEXT_OPCODE();
! 4163: }
! 4164:
! 4165: ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
! 4166: {
! 4167: zend_op *opline = EX(opline);
! 4168: zend_free_op free_op1;
! 4169: zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 4170:
! 4171: EX_T(opline->result.u.var).tmp_var = *value;
! 4172: if (!IS_OP1_TMP_FREE()) {
! 4173: zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
! 4174: }
! 4175: FREE_OP1_IF_VAR();
! 4176: ZEND_VM_NEXT_OPCODE();
! 4177: }
! 4178:
! 4179: ZEND_VM_HANDLER(101, ZEND_EXT_STMT, ANY, ANY)
! 4180: {
! 4181: if (!EG(no_extensions)) {
! 4182: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
! 4183: }
! 4184: ZEND_VM_NEXT_OPCODE();
! 4185: }
! 4186:
! 4187: ZEND_VM_HANDLER(102, ZEND_EXT_FCALL_BEGIN, ANY, ANY)
! 4188: {
! 4189: if (!EG(no_extensions)) {
! 4190: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
! 4191: }
! 4192: ZEND_VM_NEXT_OPCODE();
! 4193: }
! 4194:
! 4195: ZEND_VM_HANDLER(103, ZEND_EXT_FCALL_END, ANY, ANY)
! 4196: {
! 4197: if (!EG(no_extensions)) {
! 4198: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
! 4199: }
! 4200: ZEND_VM_NEXT_OPCODE();
! 4201: }
! 4202:
! 4203: ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
! 4204: {
! 4205: zend_op *opline = EX(opline);
! 4206:
! 4207: EX_T(opline->result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
! 4208: ZEND_VM_NEXT_OPCODE();
! 4209: }
! 4210:
! 4211: ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
! 4212: {
! 4213: zend_op *opline = EX(opline);
! 4214:
! 4215: EX_T(opline->result.u.var).class_entry = do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
! 4216: ZEND_VM_NEXT_OPCODE();
! 4217: }
! 4218:
! 4219: ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY)
! 4220: {
! 4221: zend_op *opline = EX(opline);
! 4222: zend_class_entry **pce, **pce_orig;
! 4223:
! 4224: if (zend_hash_find(EG(class_table), Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void**)&pce) == FAILURE ||
! 4225: (zend_hash_find(EG(class_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
! 4226: *pce != *pce_orig)) {
! 4227: do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
! 4228: }
! 4229: ZEND_VM_NEXT_OPCODE();
! 4230: }
! 4231:
! 4232: ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
! 4233: {
! 4234: do_bind_function(EX(opline), EG(function_table), 0);
! 4235: ZEND_VM_NEXT_OPCODE();
! 4236: }
! 4237:
! 4238: ZEND_VM_HANDLER(105, ZEND_TICKS, CONST, ANY)
! 4239: {
! 4240: zend_op *opline = EX(opline);
! 4241:
! 4242: if (++EG(ticks_count)>=Z_LVAL(opline->op1.u.constant)) {
! 4243: EG(ticks_count)=0;
! 4244: if (zend_ticks_function) {
! 4245: zend_ticks_function(Z_LVAL(opline->op1.u.constant));
! 4246: }
! 4247: }
! 4248: ZEND_VM_NEXT_OPCODE();
! 4249: }
! 4250:
! 4251: ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMP|VAR|CV, ANY)
! 4252: {
! 4253: zend_op *opline = EX(opline);
! 4254: zend_free_op free_op1;
! 4255: zval *expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 4256: zend_bool result;
! 4257:
! 4258: if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
! 4259: result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
! 4260: } else {
! 4261: result = 0;
! 4262: }
! 4263: ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
! 4264: FREE_OP1();
! 4265: ZEND_VM_NEXT_OPCODE();
! 4266: }
! 4267:
! 4268: ZEND_VM_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
! 4269: {
! 4270: ZEND_VM_NEXT_OPCODE();
! 4271: }
! 4272:
! 4273: ZEND_VM_HANDLER(0, ZEND_NOP, ANY, ANY)
! 4274: {
! 4275: ZEND_VM_NEXT_OPCODE();
! 4276: }
! 4277:
! 4278: ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
! 4279: {
! 4280: zend_op *opline = EX(opline);
! 4281: zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
! 4282: zend_class_entry *iface = zend_fetch_class(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant), opline->extended_value TSRMLS_CC);
! 4283:
! 4284: if (iface) {
! 4285: if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
! 4286: zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
! 4287: }
! 4288: zend_do_implement_interface(ce, iface TSRMLS_CC);
! 4289: }
! 4290:
! 4291: ZEND_VM_NEXT_OPCODE();
! 4292: }
! 4293:
! 4294: ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
! 4295: {
! 4296: zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
! 4297: int i;
! 4298: zend_uint catch_op_num;
! 4299: int catched = 0;
! 4300: zval restored_error_reporting;
! 4301:
! 4302: void **stack_frame = (void**)(((char*)EX(Ts)) +
! 4303: (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * EX(op_array)->T));
! 4304:
! 4305: while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
! 4306: zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
! 4307: zval_ptr_dtor(&stack_zval_p);
! 4308: }
! 4309:
! 4310: for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
! 4311: if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
! 4312: /* further blocks will not be relevant... */
! 4313: break;
! 4314: }
! 4315: if (op_num >= EG(active_op_array)->try_catch_array[i].try_op
! 4316: && op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
! 4317: catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
! 4318: catched = 1;
! 4319: }
! 4320: }
! 4321:
! 4322: while (EX(fbc)) {
! 4323: EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
! 4324: if (EX(object)) {
! 4325: if (IS_CTOR_CALL(EX(called_scope))) {
! 4326: if (IS_CTOR_USED(EX(called_scope))) {
! 4327: Z_DELREF_P(EX(object));
! 4328: }
! 4329: if (Z_REFCOUNT_P(EX(object)) == 1) {
! 4330: zend_object_store_ctor_failed(EX(object) TSRMLS_CC);
! 4331: }
! 4332: }
! 4333: zval_ptr_dtor(&EX(object));
! 4334: }
! 4335: EX(called_scope) = DECODE_CTOR(EX(called_scope));
! 4336: zend_arg_types_stack_2_pop(&EG(arg_types_stack), &EX(object), &EX(fbc));
! 4337: }
! 4338:
! 4339: for (i=0; i<EX(op_array)->last_brk_cont; i++) {
! 4340: if (EX(op_array)->brk_cont_array[i].start < 0) {
! 4341: continue;
! 4342: } else if (EX(op_array)->brk_cont_array[i].start > op_num) {
! 4343: /* further blocks will not be relevant... */
! 4344: break;
! 4345: } else if (op_num < EX(op_array)->brk_cont_array[i].brk) {
! 4346: if (!catched ||
! 4347: catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
! 4348: zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
! 4349:
! 4350: switch (brk_opline->opcode) {
! 4351: case ZEND_SWITCH_FREE:
! 4352: if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
! 4353: zend_switch_free(&EX_T(brk_opline->op1.u.var), brk_opline->extended_value TSRMLS_CC);
! 4354: }
! 4355: break;
! 4356: case ZEND_FREE:
! 4357: if (brk_opline->op1.u.EA.type != EXT_TYPE_FREE_ON_RETURN) {
! 4358: zendi_zval_dtor(EX_T(brk_opline->op1.u.var).tmp_var);
! 4359: }
! 4360: break;
! 4361: }
! 4362: }
! 4363: }
! 4364: }
! 4365:
! 4366: /* restore previous error_reporting value */
! 4367: if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
! 4368: Z_TYPE(restored_error_reporting) = IS_LONG;
! 4369: Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
! 4370: convert_to_string(&restored_error_reporting);
! 4371: zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
! 4372: zendi_zval_dtor(restored_error_reporting);
! 4373: }
! 4374: EX(old_error_reporting) = NULL;
! 4375:
! 4376: if (!catched) {
! 4377: ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
! 4378: } else {
! 4379: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
! 4380: ZEND_VM_CONTINUE();
! 4381: }
! 4382: }
! 4383:
! 4384: ZEND_VM_HANDLER(146, ZEND_VERIFY_ABSTRACT_CLASS, ANY, ANY)
! 4385: {
! 4386: zend_verify_abstract_class(EX_T(EX(opline)->op1.u.var).class_entry TSRMLS_CC);
! 4387: ZEND_VM_NEXT_OPCODE();
! 4388: }
! 4389:
! 4390: ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY)
! 4391: {
! 4392: int ret = zend_user_opcode_handlers[EX(opline)->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
! 4393:
! 4394: switch (ret) {
! 4395: case ZEND_USER_OPCODE_CONTINUE:
! 4396: ZEND_VM_CONTINUE();
! 4397: case ZEND_USER_OPCODE_RETURN:
! 4398: ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
! 4399: case ZEND_USER_OPCODE_ENTER:
! 4400: ZEND_VM_ENTER();
! 4401: case ZEND_USER_OPCODE_LEAVE:
! 4402: ZEND_VM_LEAVE();
! 4403: case ZEND_USER_OPCODE_DISPATCH:
! 4404: ZEND_VM_DISPATCH(EX(opline)->opcode, EX(opline));
! 4405: default:
! 4406: ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), EX(opline));
! 4407: }
! 4408: }
! 4409:
! 4410: ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
! 4411: {
! 4412: zend_op *opline = EX(opline);
! 4413: zend_free_op free_op1, free_op2;
! 4414: zval *name = GET_OP1_ZVAL_PTR(BP_VAR_R);
! 4415: zval *val = GET_OP2_ZVAL_PTR(BP_VAR_R);
! 4416: zend_constant c;
! 4417:
! 4418: if ((Z_TYPE_P(val) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
! 4419: zval tmp = *val;
! 4420: zval *tmp_ptr = &tmp;
! 4421:
! 4422: if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
! 4423: zval_copy_ctor(&tmp);
! 4424: }
! 4425: INIT_PZVAL(&tmp);
! 4426: zval_update_constant(&tmp_ptr, NULL TSRMLS_CC);
! 4427: c.value = *tmp_ptr;
! 4428: } else {
! 4429: c.value = *val;
! 4430: zval_copy_ctor(&c.value);
! 4431: }
! 4432: c.flags = CONST_CS; /* non persistent, case sensetive */
! 4433: c.name = zend_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
! 4434: c.name_len = Z_STRLEN_P(name)+1;
! 4435: c.module_number = PHP_USER_CONSTANT;
! 4436:
! 4437: if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
! 4438: }
! 4439:
! 4440: FREE_OP1();
! 4441: FREE_OP2();
! 4442: ZEND_VM_NEXT_OPCODE();
! 4443: }
! 4444:
! 4445: ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, CONST)
! 4446: {
! 4447: zend_op *opline = EX(opline);
! 4448: zend_function *op_array;
! 4449:
! 4450: if (zend_hash_quick_find(EG(function_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), Z_LVAL(opline->op2.u.constant), (void *) &op_array) == FAILURE ||
! 4451: op_array->type != ZEND_USER_FUNCTION) {
! 4452: zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
! 4453: }
! 4454:
! 4455: zend_create_closure(&EX_T(opline->result.u.var).tmp_var, op_array TSRMLS_CC);
! 4456:
! 4457: ZEND_VM_NEXT_OPCODE();
! 4458: }
! 4459:
! 4460: ZEND_VM_EXPORT_HELPER(zend_do_fcall, zend_do_fcall_common_helper)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_vm_def.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend