embedaddon/php/Zend/zend_vm_execute.h - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend / zend_vm_execute.h
Revision 1.1.1.4 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Mon Oct 14 08:02:49 2013 UTC (10 years, 8 months ago) by misho
Branches: php, MAIN
CVS tags: v5_4_29p0, v5_4_20p0, v5_4_20, HEAD

v 5.4.20

1: /* 2: +----------------------------------------------------------------------+ 3: | Zend Engine | 4: +----------------------------------------------------------------------+ 5: | Copyright (c) 1998-2013 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: #ifdef ZEND_WIN32 22: # pragma warning(once : 4101) 23: #endif 24: static user_opcode_handler_t zend_user_opcode_handlers[256] = { 25: (user_opcode_handler_t)NULL, 26: (user_opcode_handler_t)NULL, 27: (user_opcode_handler_t)NULL, 28: (user_opcode_handler_t)NULL, 29: (user_opcode_handler_t)NULL, 30: (user_opcode_handler_t)NULL, 31: (user_opcode_handler_t)NULL, 32: (user_opcode_handler_t)NULL, 33: (user_opcode_handler_t)NULL, 34: (user_opcode_handler_t)NULL, 35: (user_opcode_handler_t)NULL, 36: (user_opcode_handler_t)NULL, 37: (user_opcode_handler_t)NULL, 38: (user_opcode_handler_t)NULL, 39: (user_opcode_handler_t)NULL, 40: (user_opcode_handler_t)NULL, 41: (user_opcode_handler_t)NULL, 42: (user_opcode_handler_t)NULL, 43: (user_opcode_handler_t)NULL, 44: (user_opcode_handler_t)NULL, 45: (user_opcode_handler_t)NULL, 46: (user_opcode_handler_t)NULL, 47: (user_opcode_handler_t)NULL, 48: (user_opcode_handler_t)NULL, 49: (user_opcode_handler_t)NULL, 50: (user_opcode_handler_t)NULL, 51: (user_opcode_handler_t)NULL, 52: (user_opcode_handler_t)NULL, 53: (user_opcode_handler_t)NULL, 54: (user_opcode_handler_t)NULL, 55: (user_opcode_handler_t)NULL, 56: (user_opcode_handler_t)NULL, 57: (user_opcode_handler_t)NULL, 58: (user_opcode_handler_t)NULL, 59: (user_opcode_handler_t)NULL, 60: (user_opcode_handler_t)NULL, 61: (user_opcode_handler_t)NULL, 62: (user_opcode_handler_t)NULL, 63: (user_opcode_handler_t)NULL, 64: (user_opcode_handler_t)NULL, 65: (user_opcode_handler_t)NULL, 66: (user_opcode_handler_t)NULL, 67: (user_opcode_handler_t)NULL, 68: (user_opcode_handler_t)NULL, 69: (user_opcode_handler_t)NULL, 70: (user_opcode_handler_t)NULL, 71: (user_opcode_handler_t)NULL, 72: (user_opcode_handler_t)NULL, 73: (user_opcode_handler_t)NULL, 74: (user_opcode_handler_t)NULL, 75: (user_opcode_handler_t)NULL, 76: (user_opcode_handler_t)NULL, 77: (user_opcode_handler_t)NULL, 78: (user_opcode_handler_t)NULL, 79: (user_opcode_handler_t)NULL, 80: (user_opcode_handler_t)NULL, 81: (user_opcode_handler_t)NULL, 82: (user_opcode_handler_t)NULL, 83: (user_opcode_handler_t)NULL, 84: (user_opcode_handler_t)NULL, 85: (user_opcode_handler_t)NULL, 86: (user_opcode_handler_t)NULL, 87: (user_opcode_handler_t)NULL, 88: (user_opcode_handler_t)NULL, 89: (user_opcode_handler_t)NULL, 90: (user_opcode_handler_t)NULL, 91: (user_opcode_handler_t)NULL, 92: (user_opcode_handler_t)NULL, 93: (user_opcode_handler_t)NULL, 94: (user_opcode_handler_t)NULL, 95: (user_opcode_handler_t)NULL, 96: (user_opcode_handler_t)NULL, 97: (user_opcode_handler_t)NULL, 98: (user_opcode_handler_t)NULL, 99: (user_opcode_handler_t)NULL, 100: (user_opcode_handler_t)NULL, 101: (user_opcode_handler_t)NULL, 102: (user_opcode_handler_t)NULL, 103: (user_opcode_handler_t)NULL, 104: (user_opcode_handler_t)NULL, 105: (user_opcode_handler_t)NULL, 106: (user_opcode_handler_t)NULL, 107: (user_opcode_handler_t)NULL, 108: (user_opcode_handler_t)NULL, 109: (user_opcode_handler_t)NULL, 110: (user_opcode_handler_t)NULL, 111: (user_opcode_handler_t)NULL, 112: (user_opcode_handler_t)NULL, 113: (user_opcode_handler_t)NULL, 114: (user_opcode_handler_t)NULL, 115: (user_opcode_handler_t)NULL, 116: (user_opcode_handler_t)NULL, 117: (user_opcode_handler_t)NULL, 118: (user_opcode_handler_t)NULL, 119: (user_opcode_handler_t)NULL, 120: (user_opcode_handler_t)NULL, 121: (user_opcode_handler_t)NULL, 122: (user_opcode_handler_t)NULL, 123: (user_opcode_handler_t)NULL, 124: (user_opcode_handler_t)NULL, 125: (user_opcode_handler_t)NULL, 126: (user_opcode_handler_t)NULL, 127: (user_opcode_handler_t)NULL, 128: (user_opcode_handler_t)NULL, 129: (user_opcode_handler_t)NULL, 130: (user_opcode_handler_t)NULL, 131: (user_opcode_handler_t)NULL, 132: (user_opcode_handler_t)NULL, 133: (user_opcode_handler_t)NULL, 134: (user_opcode_handler_t)NULL, 135: (user_opcode_handler_t)NULL, 136: (user_opcode_handler_t)NULL, 137: (user_opcode_handler_t)NULL, 138: (user_opcode_handler_t)NULL, 139: (user_opcode_handler_t)NULL, 140: (user_opcode_handler_t)NULL, 141: (user_opcode_handler_t)NULL, 142: (user_opcode_handler_t)NULL, 143: (user_opcode_handler_t)NULL, 144: (user_opcode_handler_t)NULL, 145: (user_opcode_handler_t)NULL, 146: (user_opcode_handler_t)NULL, 147: (user_opcode_handler_t)NULL, 148: (user_opcode_handler_t)NULL, 149: (user_opcode_handler_t)NULL, 150: (user_opcode_handler_t)NULL, 151: (user_opcode_handler_t)NULL, 152: (user_opcode_handler_t)NULL, 153: (user_opcode_handler_t)NULL, 154: (user_opcode_handler_t)NULL, 155: (user_opcode_handler_t)NULL, 156: (user_opcode_handler_t)NULL, 157: (user_opcode_handler_t)NULL, 158: (user_opcode_handler_t)NULL, 159: (user_opcode_handler_t)NULL, 160: (user_opcode_handler_t)NULL, 161: (user_opcode_handler_t)NULL, 162: (user_opcode_handler_t)NULL, 163: (user_opcode_handler_t)NULL, 164: (user_opcode_handler_t)NULL, 165: (user_opcode_handler_t)NULL, 166: (user_opcode_handler_t)NULL, 167: (user_opcode_handler_t)NULL, 168: (user_opcode_handler_t)NULL, 169: (user_opcode_handler_t)NULL, 170: (user_opcode_handler_t)NULL, 171: (user_opcode_handler_t)NULL, 172: (user_opcode_handler_t)NULL, 173: (user_opcode_handler_t)NULL, 174: (user_opcode_handler_t)NULL, 175: (user_opcode_handler_t)NULL, 176: (user_opcode_handler_t)NULL, 177: (user_opcode_handler_t)NULL, 178: (user_opcode_handler_t)NULL, 179: (user_opcode_handler_t)NULL, 180: (user_opcode_handler_t)NULL, 181: (user_opcode_handler_t)NULL, 182: (user_opcode_handler_t)NULL, 183: (user_opcode_handler_t)NULL, 184: (user_opcode_handler_t)NULL, 185: (user_opcode_handler_t)NULL, 186: (user_opcode_handler_t)NULL, 187: (user_opcode_handler_t)NULL, 188: (user_opcode_handler_t)NULL, 189: (user_opcode_handler_t)NULL, 190: (user_opcode_handler_t)NULL, 191: (user_opcode_handler_t)NULL, 192: (user_opcode_handler_t)NULL, 193: (user_opcode_handler_t)NULL, 194: (user_opcode_handler_t)NULL, 195: (user_opcode_handler_t)NULL, 196: (user_opcode_handler_t)NULL, 197: (user_opcode_handler_t)NULL, 198: (user_opcode_handler_t)NULL, 199: (user_opcode_handler_t)NULL, 200: (user_opcode_handler_t)NULL, 201: (user_opcode_handler_t)NULL, 202: (user_opcode_handler_t)NULL, 203: (user_opcode_handler_t)NULL, 204: (user_opcode_handler_t)NULL, 205: (user_opcode_handler_t)NULL, 206: (user_opcode_handler_t)NULL, 207: (user_opcode_handler_t)NULL, 208: (user_opcode_handler_t)NULL, 209: (user_opcode_handler_t)NULL, 210: (user_opcode_handler_t)NULL, 211: (user_opcode_handler_t)NULL, 212: (user_opcode_handler_t)NULL, 213: (user_opcode_handler_t)NULL, 214: (user_opcode_handler_t)NULL, 215: (user_opcode_handler_t)NULL, 216: (user_opcode_handler_t)NULL, 217: (user_opcode_handler_t)NULL, 218: (user_opcode_handler_t)NULL, 219: (user_opcode_handler_t)NULL, 220: (user_opcode_handler_t)NULL, 221: (user_opcode_handler_t)NULL, 222: (user_opcode_handler_t)NULL, 223: (user_opcode_handler_t)NULL, 224: (user_opcode_handler_t)NULL, 225: (user_opcode_handler_t)NULL, 226: (user_opcode_handler_t)NULL, 227: (user_opcode_handler_t)NULL, 228: (user_opcode_handler_t)NULL, 229: (user_opcode_handler_t)NULL, 230: (user_opcode_handler_t)NULL, 231: (user_opcode_handler_t)NULL, 232: (user_opcode_handler_t)NULL, 233: (user_opcode_handler_t)NULL, 234: (user_opcode_handler_t)NULL, 235: (user_opcode_handler_t)NULL, 236: (user_opcode_handler_t)NULL, 237: (user_opcode_handler_t)NULL, 238: (user_opcode_handler_t)NULL, 239: (user_opcode_handler_t)NULL, 240: (user_opcode_handler_t)NULL, 241: (user_opcode_handler_t)NULL, 242: (user_opcode_handler_t)NULL, 243: (user_opcode_handler_t)NULL, 244: (user_opcode_handler_t)NULL, 245: (user_opcode_handler_t)NULL, 246: (user_opcode_handler_t)NULL, 247: (user_opcode_handler_t)NULL, 248: (user_opcode_handler_t)NULL, 249: (user_opcode_handler_t)NULL, 250: (user_opcode_handler_t)NULL, 251: (user_opcode_handler_t)NULL, 252: (user_opcode_handler_t)NULL, 253: (user_opcode_handler_t)NULL, 254: (user_opcode_handler_t)NULL, 255: (user_opcode_handler_t)NULL, 256: (user_opcode_handler_t)NULL, 257: (user_opcode_handler_t)NULL, 258: (user_opcode_handler_t)NULL, 259: (user_opcode_handler_t)NULL, 260: (user_opcode_handler_t)NULL, 261: (user_opcode_handler_t)NULL, 262: (user_opcode_handler_t)NULL, 263: (user_opcode_handler_t)NULL, 264: (user_opcode_handler_t)NULL, 265: (user_opcode_handler_t)NULL, 266: (user_opcode_handler_t)NULL, 267: (user_opcode_handler_t)NULL, 268: (user_opcode_handler_t)NULL, 269: (user_opcode_handler_t)NULL, 270: (user_opcode_handler_t)NULL, 271: (user_opcode_handler_t)NULL, 272: (user_opcode_handler_t)NULL, 273: (user_opcode_handler_t)NULL, 274: (user_opcode_handler_t)NULL, 275: (user_opcode_handler_t)NULL, 276: (user_opcode_handler_t)NULL, 277: (user_opcode_handler_t)NULL, 278: (user_opcode_handler_t)NULL, 279: (user_opcode_handler_t)NULL, 280: (user_opcode_handler_t)NULL 281: }; 282: 283: static zend_uchar zend_user_opcodes[256] = {0, 284: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16, 285: 17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32, 286: 33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48, 287: 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64, 288: 65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80, 289: 81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96, 290: 97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112, 291: 113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128, 292: 129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144, 293: 145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160, 294: 161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176, 295: 177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192, 296: 193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208, 297: 209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224, 298: 225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240, 299: 241,242,243,244,245,246,247,248,249,250,251,252,253,254,255 300: }; 301: 302: static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op); 303: 304: 305: #undef OPLINE 306: #undef DCL_OPLINE 307: #undef USE_OPLINE 308: #undef LOAD_OPLINE 309: #undef SAVE_OPLINE 310: #define OPLINE EX(opline) 311: #define DCL_OPLINE 312: #define USE_OPLINE zend_op *opline = EX(opline); 313: #define LOAD_OPLINE() 314: #define SAVE_OPLINE() 315: #undef CHECK_EXCEPTION 316: #undef HANDLE_EXCEPTION 317: #undef HANDLE_EXCEPTION_LEAVE 318: #define CHECK_EXCEPTION() LOAD_OPLINE() 319: #define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE() 320: #define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE() 321: #define LOAD_REGS() 322: #define ZEND_VM_CONTINUE() return 0 323: #define ZEND_VM_RETURN() return 1 324: #define ZEND_VM_ENTER() return 2 325: #define ZEND_VM_LEAVE() return 3 326: #define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 327: 328: #define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC 329: #undef EX 330: #define EX(element) execute_data->element 331: 332: #undef EX_CV 333: #define EX_CV(var) EX(CVs)[var] 334: #undef EX_CVs 335: #define EX_CVs() EX(CVs) 336: #undef EX_T 337: #define EX_T(offset) (*(temp_variable *)((char *) EX(Ts) + offset)) 338: #undef EX_Ts 339: #define EX_Ts() EX(Ts) 340: 341: 342: ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) 343: { 344: DCL_OPLINE 345: zend_execute_data *execute_data; 346: zend_bool nested = 0; 347: zend_bool original_in_execution = EG(in_execution); 348: 349: 350: if (EG(exception)) { 351: return; 352: } 353: 354: EG(in_execution) = 1; 355: 356: zend_vm_enter: 357: /* Initialize execute_data */ 358: execute_data = (zend_execute_data *)zend_vm_stack_alloc( 359: ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data)) + 360: ZEND_MM_ALIGNED_SIZE(sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2)) + 361: ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T TSRMLS_CC); 362: 363: EX(CVs) = (zval***)((char*)execute_data + ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data))); 364: memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var); 365: EX(Ts) = (temp_variable *)(((char*)EX(CVs)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval**) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2))); 366: EX(fbc) = NULL; 367: EX(called_scope) = NULL; 368: EX(object) = NULL; 369: EX(old_error_reporting) = NULL; 370: EX(op_array) = op_array; 371: EX(symbol_table) = EG(active_symbol_table); 372: EX(prev_execute_data) = EG(current_execute_data); 373: EG(current_execute_data) = execute_data; 374: EX(nested) = nested; 375: nested = 1; 376: 377: LOAD_REGS(); 378: 379: if (!op_array->run_time_cache && op_array->last_cache_slot) { 380: op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*)); 381: } 382: 383: if (op_array->this_var != -1 && EG(This)) { 384: Z_ADDREF_P(EG(This)); /* For $this pointer */ 385: if (!EG(active_symbol_table)) { 386: EX_CV(op_array->this_var) = (zval**)EX_CVs() + (op_array->last_var + op_array->this_var); 387: *EX_CV(op_array->this_var) = EG(This); 388: } else { 389: if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void**)&EX_CV(op_array->this_var))==FAILURE) { 390: Z_DELREF_P(EG(This)); 391: } 392: } 393: } 394: 395: EX(opline) = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes; 396: EG(opline_ptr) = &EX(opline); 397: LOAD_OPLINE(); 398: 399: EX(function_state).function = (zend_function *) op_array; 400: EX(function_state).arguments = NULL; 401: 402: while (1) { 403: int ret; 404: #ifdef ZEND_WIN32 405: if (EG(timed_out)) { 406: zend_timeout(0); 407: } 408: #endif 409: 410: if ((ret = OPLINE->handler(execute_data TSRMLS_CC)) > 0) { 411: switch (ret) { 412: case 1: 413: EG(in_execution) = original_in_execution; 414: return; 415: case 2: 416: op_array = EG(active_op_array); 417: goto zend_vm_enter; 418: case 3: 419: execute_data = EG(current_execute_data); 420: default: 421: break; 422: } 423: } 424: 425: } 426: zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen"); 427: } 428: 429: static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 430: { 431: USE_OPLINE 432: 433: #if DEBUG_ZEND>=2 434: printf("Jumping to %d\n", opline->op1.opline_num); 435: #endif 436: ZEND_VM_SET_OPCODE(opline->op1.jmp_addr); 437: ZEND_VM_CONTINUE(); /* CHECK_ME */ 438: } 439: 440: static int ZEND_FASTCALL ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 441: { 442: USE_OPLINE 443: zval *tmp = &EX_T(opline->result.var).tmp_var; 444: 445: SAVE_OPLINE(); 446: tmp->value.str.val = emalloc(1); 447: tmp->value.str.val[0] = 0; 448: tmp->value.str.len = 0; 449: Z_SET_REFCOUNT_P(tmp, 1); 450: tmp->type = IS_STRING; 451: Z_UNSET_ISREF_P(tmp); 452: /*CHECK_EXCEPTION();*/ 453: ZEND_VM_NEXT_OPCODE(); 454: } 455: 456: static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) 457: { 458: zend_bool nested; 459: zend_op_array *op_array = EX(op_array); 460: 461: EG(current_execute_data) = EX(prev_execute_data); 462: EG(opline_ptr) = NULL; 463: if (!EG(active_symbol_table)) { 464: zval ***cv = EX_CVs(); 465: zval ***end = cv + op_array->last_var; 466: while (cv != end) { 467: if (*cv) { 468: zval_ptr_dtor(*cv); 469: } 470: cv++; 471: } 472: } 473: 474: if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) { 475: zval_ptr_dtor((zval**)&op_array->prototype); 476: } 477: 478: nested = EX(nested); 479: 480: zend_vm_stack_free(execute_data TSRMLS_CC); 481: 482: if (nested) { 483: execute_data = EG(current_execute_data); 484: } 485: if (nested) { 486: USE_OPLINE 487: 488: LOAD_REGS(); 489: LOAD_OPLINE(); 490: if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) { 491: 492: EX(function_state).function = (zend_function *) EX(op_array); 493: EX(function_state).arguments = NULL; 494: EX(object) = EX(current_object); 495: 496: EG(opline_ptr) = &EX(opline); 497: EG(active_op_array) = EX(op_array); 498: EG(return_value_ptr_ptr) = EX(original_return_value); 499: destroy_op_array(op_array TSRMLS_CC); 500: efree(op_array); 501: if (UNEXPECTED(EG(exception) != NULL)) { 502: zend_throw_exception_internal(NULL TSRMLS_CC); 503: HANDLE_EXCEPTION_LEAVE(); 504: } else if (RETURN_VALUE_USED(opline)) { 505: if (!EX_T(opline->result.var).var.ptr) { /* there was no return statement */ 506: zval *retval; 507: 508: ALLOC_ZVAL(retval); 509: ZVAL_BOOL(retval, 1); 510: INIT_PZVAL(retval); 511: EX_T(opline->result.var).var.ptr = retval; 512: } 513: } 514: 515: ZEND_VM_INC_OPCODE(); 516: ZEND_VM_LEAVE(); 517: } else { 518: 519: EG(opline_ptr) = &EX(opline); 520: EG(active_op_array) = EX(op_array); 521: EG(return_value_ptr_ptr) = EX(original_return_value); 522: if (EG(active_symbol_table)) { 523: if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) { 524: zend_hash_destroy(EG(active_symbol_table)); 525: FREE_HASHTABLE(EG(active_symbol_table)); 526: } else { 527: /* clean before putting into the cache, since clean 528: could call dtors, which could use cached hash */ 529: zend_hash_clean(EG(active_symbol_table)); 530: *(++EG(symtable_cache_ptr)) = EG(active_symbol_table); 531: } 532: } 533: EG(active_symbol_table) = EX(symbol_table); 534: 535: EX(function_state).function = (zend_function *) EX(op_array); 536: EX(function_state).arguments = NULL; 537: 538: if (EG(This)) { 539: if (UNEXPECTED(EG(exception) != NULL) && IS_CTOR_CALL(EX(called_scope))) { 540: if (IS_CTOR_USED(EX(called_scope))) { 541: Z_DELREF_P(EG(This)); 542: } 543: if (Z_REFCOUNT_P(EG(This)) == 1) { 544: zend_object_store_ctor_failed(EG(This) TSRMLS_CC); 545: } 546: } 547: zval_ptr_dtor(&EG(This)); 548: } 549: EG(This) = EX(current_this); 550: EG(scope) = EX(current_scope); 551: EG(called_scope) = EX(current_called_scope); 552: 553: EX(object) = EX(current_object); 554: EX(called_scope) = DECODE_CTOR(EX(called_scope)); 555: 556: zend_vm_stack_clear_multiple(TSRMLS_C); 557: 558: if (UNEXPECTED(EG(exception) != NULL)) { 559: zend_throw_exception_internal(NULL TSRMLS_CC); 560: if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) { 561: zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); 562: } 563: HANDLE_EXCEPTION_LEAVE(); 564: } 565: 566: ZEND_VM_INC_OPCODE(); 567: ZEND_VM_LEAVE(); 568: } 569: } 570: ZEND_VM_RETURN(); 571: } 572: 573: static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) 574: { 575: USE_OPLINE 576: zend_bool should_change_scope = 0; 577: zend_function *fbc = EX(function_state).function; 578: 579: SAVE_OPLINE(); 580: if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { 581: if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) { 582: zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name); 583: CHECK_EXCEPTION(); 584: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 585: } 586: if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { 587: zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", 588: fbc->common.scope ? fbc->common.scope->name : "", 589: fbc->common.scope ? "::" : "", 590: fbc->common.function_name); 591: } 592: } 593: if (fbc->common.scope && 594: !(fbc->common.fn_flags & ZEND_ACC_STATIC) && 595: !EX(object)) { 596: 597: if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 598: /* FIXME: output identifiers properly */ 599: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name); 600: } else { 601: /* FIXME: output identifiers properly */ 602: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 603: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name); 604: } 605: } 606: 607: if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) { 608: should_change_scope = 1; 609: EX(current_this) = EG(This); 610: EX(current_scope) = EG(scope); 611: EX(current_called_scope) = EG(called_scope); 612: EG(This) = EX(object); 613: EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL; 614: EG(called_scope) = EX(called_scope); 615: } 616: 617: zend_arg_types_stack_3_pop(&EG(arg_types_stack), &EX(called_scope), &EX(current_object), &EX(fbc)); 618: EX(function_state).arguments = zend_vm_stack_push_args(opline->extended_value TSRMLS_CC); 619: LOAD_OPLINE(); 620: 621: if (fbc->type == ZEND_INTERNAL_FUNCTION) { 622: temp_variable *ret = &EX_T(opline->result.var); 623: 624: if (fbc->common.arg_info) { 625: zend_uint i=0; 626: zval **p = (zval**)EX(function_state).arguments; 627: ulong arg_count = opline->extended_value; 628: 629: while (arg_count>0) { 630: zend_verify_arg_type(fbc, ++i, *(p-arg_count), 0 TSRMLS_CC); 631: arg_count--; 632: } 633: } 634: 635: if (EXPECTED(EG(exception) == NULL)) { 636: MAKE_STD_ZVAL(ret->var.ptr); 637: ZVAL_NULL(ret->var.ptr); 638: ret->var.ptr_ptr = &ret->var.ptr; 639: ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; 640: 641: if (!zend_execute_internal) { 642: /* saves one function call if zend_execute_internal is not used */ 643: fbc->internal_function.handler(opline->extended_value, ret->var.ptr, (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) ? &ret->var.ptr : NULL, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC); 644: } else { 645: zend_execute_internal(execute_data, RETURN_VALUE_USED(opline) TSRMLS_CC); 646: } 647: 648: if (!RETURN_VALUE_USED(opline)) { 649: zval_ptr_dtor(&ret->var.ptr); 650: } 651: } else if (RETURN_VALUE_USED(opline)) { 652: EX_T(opline->result.var).var.ptr = NULL; 653: } 654: } else if (fbc->type == ZEND_USER_FUNCTION) { 655: EX(original_return_value) = EG(return_value_ptr_ptr); 656: EG(active_symbol_table) = NULL; 657: EG(active_op_array) = &fbc->op_array; 658: EG(return_value_ptr_ptr) = NULL; 659: if (RETURN_VALUE_USED(opline)) { 660: temp_variable *ret = &EX_T(opline->result.var); 661: 662: ret->var.ptr = NULL; 663: EG(return_value_ptr_ptr) = &ret->var.ptr; 664: ret->var.ptr_ptr = &ret->var.ptr; 665: ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; 666: } 667: 668: if (EXPECTED(zend_execute == execute)) { 669: if (EXPECTED(EG(exception) == NULL)) { 670: ZEND_VM_ENTER(); 671: } 672: } else { 673: zend_execute(EG(active_op_array) TSRMLS_CC); 674: } 675: 676: EG(opline_ptr) = &EX(opline); 677: EG(active_op_array) = EX(op_array); 678: EG(return_value_ptr_ptr) = EX(original_return_value); 679: if (EG(active_symbol_table)) { 680: if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) { 681: zend_hash_destroy(EG(active_symbol_table)); 682: FREE_HASHTABLE(EG(active_symbol_table)); 683: } else { 684: /* clean before putting into the cache, since clean 685: could call dtors, which could use cached hash */ 686: zend_hash_clean(EG(active_symbol_table)); 687: *(++EG(symtable_cache_ptr)) = EG(active_symbol_table); 688: } 689: } 690: EG(active_symbol_table) = EX(symbol_table); 691: } else { /* ZEND_OVERLOADED_FUNCTION */ 692: MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr); 693: ZVAL_NULL(EX_T(opline->result.var).var.ptr); 694: 695: /* Not sure what should be done here if it's a static method */ 696: if (EXPECTED(EX(object) != NULL)) { 697: Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, opline->extended_value, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC); 698: } else { 699: zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object"); 700: } 701: 702: if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { 703: efree((char*)fbc->common.function_name); 704: } 705: efree(fbc); 706: 707: if (!RETURN_VALUE_USED(opline)) { 708: zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); 709: } else { 710: Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr); 711: Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1); 712: EX_T(opline->result.var).var.fcall_returned_reference = 0; 713: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 714: } 715: } 716: 717: EX(function_state).function = (zend_function *) EX(op_array); 718: EX(function_state).arguments = NULL; 719: 720: if (should_change_scope) { 721: if (EG(This)) { 722: if (UNEXPECTED(EG(exception) != NULL) && IS_CTOR_CALL(EX(called_scope))) { 723: if (IS_CTOR_USED(EX(called_scope))) { 724: Z_DELREF_P(EG(This)); 725: } 726: if (Z_REFCOUNT_P(EG(This)) == 1) { 727: zend_object_store_ctor_failed(EG(This) TSRMLS_CC); 728: } 729: } 730: zval_ptr_dtor(&EG(This)); 731: } 732: EG(This) = EX(current_this); 733: EG(scope) = EX(current_scope); 734: EG(called_scope) = EX(current_called_scope); 735: } 736: 737: EX(object) = EX(current_object); 738: EX(called_scope) = DECODE_CTOR(EX(called_scope)); 739: 740: zend_vm_stack_clear_multiple(TSRMLS_C); 741: 742: if (UNEXPECTED(EG(exception) != NULL)) { 743: zend_throw_exception_internal(NULL TSRMLS_CC); 744: if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) { 745: zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); 746: } 747: HANDLE_EXCEPTION(); 748: } 749: 750: ZEND_VM_NEXT_OPCODE(); 751: } 752: 753: static int ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 754: { 755: EX(function_state).function = EX(fbc); 756: return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 757: } 758: 759: static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 760: { 761: USE_OPLINE 762: zend_uint arg_num = opline->op1.num; 763: zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC); 764: 765: SAVE_OPLINE(); 766: if (UNEXPECTED(param == NULL)) { 767: if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) { 768: const char *space; 769: const char *class_name; 770: zend_execute_data *ptr; 771: 772: if (EG(active_op_array)->scope) { 773: class_name = EG(active_op_array)->scope->name; 774: space = "::"; 775: } else { 776: class_name = space = ""; 777: } 778: ptr = EX(prev_execute_data); 779: 780: if(ptr && ptr->op_array) { 781: zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno); 782: } else { 783: zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C)); 784: } 785: } 786: } else { 787: zval **var_ptr; 788: 789: zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC); 790: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->result.var TSRMLS_CC); 791: Z_DELREF_PP(var_ptr); 792: *var_ptr = *param; 793: Z_ADDREF_PP(var_ptr); 794: } 795: 796: CHECK_EXCEPTION(); 797: ZEND_VM_NEXT_OPCODE(); 798: } 799: 800: static int ZEND_FASTCALL ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 801: { 802: USE_OPLINE 803: zval *object_zval; 804: zend_function *constructor; 805: 806: SAVE_OPLINE(); 807: if (UNEXPECTED((EX_T(opline->op1.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) { 808: if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) { 809: zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name); 810: } else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { 811: zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name); 812: } else { 813: zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name); 814: } 815: } 816: ALLOC_ZVAL(object_zval); 817: object_init_ex(object_zval, EX_T(opline->op1.var).class_entry); 818: INIT_PZVAL(object_zval); 819: 820: constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC); 821: 822: if (constructor == NULL) { 823: if (RETURN_VALUE_USED(opline)) { 824: AI_SET_PTR(&EX_T(opline->result.var), object_zval); 825: } else { 826: zval_ptr_dtor(&object_zval); 827: } 828: ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.opline_num); 829: } else { 830: if (RETURN_VALUE_USED(opline)) { 831: PZVAL_LOCK(object_zval); 832: AI_SET_PTR(&EX_T(opline->result.var), object_zval); 833: } 834: 835: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), ENCODE_CTOR(EX(called_scope), RETURN_VALUE_USED(opline))); 836: 837: /* We are not handling overloaded classes right now */ 838: EX(object) = object_zval; 839: EX(fbc) = constructor; 840: EX(called_scope) = EX_T(opline->op1.var).class_entry; 841: 842: CHECK_EXCEPTION(); 843: ZEND_VM_NEXT_OPCODE(); 844: } 845: } 846: 847: static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 848: { 849: USE_OPLINE 850: 851: SAVE_OPLINE(); 852: Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting); 853: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG; /* shouldn't be necessary */ 854: if (EX(old_error_reporting) == NULL) { 855: EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var; 856: } 857: 858: if (EG(error_reporting)) { 859: do { 860: EG(error_reporting) = 0; 861: if (!EG(error_reporting_ini_entry)) { 862: if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) { 863: break; 864: } 865: } 866: if (!EG(error_reporting_ini_entry)->modified) { 867: if (!EG(modified_ini_directives)) { 868: ALLOC_HASHTABLE(EG(modified_ini_directives)); 869: zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0); 870: } 871: if (EXPECTED(zend_hash_add(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting"), &EG(error_reporting_ini_entry), sizeof(zend_ini_entry*), NULL) == SUCCESS)) { 872: EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value; 873: EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length; 874: EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable; 875: EG(error_reporting_ini_entry)->modified = 1; 876: } 877: } else if (EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value) { 878: efree(EG(error_reporting_ini_entry)->value); 879: } 880: EG(error_reporting_ini_entry)->value = estrndup("0", sizeof("0")-1); 881: EG(error_reporting_ini_entry)->value_length = sizeof("0")-1; 882: } while (0); 883: } 884: CHECK_EXCEPTION(); 885: ZEND_VM_NEXT_OPCODE(); 886: } 887: 888: static int ZEND_FASTCALL ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 889: { 890: SAVE_OPLINE(); 891: zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name); 892: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 893: } 894: 895: static int ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 896: { 897: SAVE_OPLINE(); 898: if (!EG(no_extensions)) { 899: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC); 900: } 901: CHECK_EXCEPTION(); 902: ZEND_VM_NEXT_OPCODE(); 903: } 904: 905: static int ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 906: { 907: SAVE_OPLINE(); 908: if (!EG(no_extensions)) { 909: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC); 910: } 911: CHECK_EXCEPTION(); 912: ZEND_VM_NEXT_OPCODE(); 913: } 914: 915: static int ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 916: { 917: SAVE_OPLINE(); 918: if (!EG(no_extensions)) { 919: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC); 920: } 921: CHECK_EXCEPTION(); 922: ZEND_VM_NEXT_OPCODE(); 923: } 924: 925: static int ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 926: { 927: USE_OPLINE 928: 929: SAVE_OPLINE(); 930: EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC); 931: CHECK_EXCEPTION(); 932: ZEND_VM_NEXT_OPCODE(); 933: } 934: 935: static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 936: { 937: USE_OPLINE 938: 939: SAVE_OPLINE(); 940: EX_T(opline->result.var).class_entry = do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC); 941: CHECK_EXCEPTION(); 942: ZEND_VM_NEXT_OPCODE(); 943: } 944: 945: static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 946: { 947: USE_OPLINE 948: zend_class_entry **pce, **pce_orig; 949: 950: SAVE_OPLINE(); 951: if (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void**)&pce) == FAILURE || 952: (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void**)&pce_orig) == SUCCESS && 953: *pce != *pce_orig)) { 954: do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC); 955: } 956: CHECK_EXCEPTION(); 957: ZEND_VM_NEXT_OPCODE(); 958: } 959: 960: static int ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 961: { 962: USE_OPLINE 963: 964: SAVE_OPLINE(); 965: do_bind_function(EX(op_array), opline, EG(function_table), 0); 966: CHECK_EXCEPTION(); 967: ZEND_VM_NEXT_OPCODE(); 968: } 969: 970: static int ZEND_FASTCALL ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 971: { 972: USE_OPLINE 973: 974: SAVE_OPLINE(); 975: if (++EG(ticks_count)>=opline->extended_value) { 976: EG(ticks_count)=0; 977: if (zend_ticks_function) { 978: zend_ticks_function(opline->extended_value); 979: } 980: } 981: CHECK_EXCEPTION(); 982: ZEND_VM_NEXT_OPCODE(); 983: } 984: 985: static int ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 986: { 987: ZEND_VM_NEXT_OPCODE(); 988: } 989: 990: static int ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 991: { 992: ZEND_VM_NEXT_OPCODE(); 993: } 994: 995: static int ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 996: { 997: USE_OPLINE 998: zend_class_entry *ce = EX_T(opline->op1.var).class_entry; 999: zend_class_entry *trait; 1000: 1001: SAVE_OPLINE(); 1002: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1003: trait = CACHED_PTR(opline->op2.literal->cache_slot); 1004: } else { 1005: trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), 1006: Z_STRLEN_P(opline->op2.zv), 1007: opline->op2.literal + 1, 1008: opline->extended_value TSRMLS_CC); 1009: if (UNEXPECTED(trait == NULL)) { 1010: CHECK_EXCEPTION(); 1011: ZEND_VM_NEXT_OPCODE(); 1012: } 1013: if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) { 1014: zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name); 1015: } 1016: CACHE_PTR(opline->op2.literal->cache_slot, trait); 1017: } 1018: 1019: zend_do_implement_trait(ce, trait TSRMLS_CC); 1020: 1021: CHECK_EXCEPTION(); 1022: ZEND_VM_NEXT_OPCODE(); 1023: } 1024: 1025: static int ZEND_FASTCALL ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1026: { 1027: USE_OPLINE 1028: zend_class_entry *ce = EX_T(opline->op1.var).class_entry; 1029: 1030: SAVE_OPLINE(); 1031: zend_do_bind_traits(ce TSRMLS_CC); 1032: CHECK_EXCEPTION(); 1033: ZEND_VM_NEXT_OPCODE(); 1034: } 1035: 1036: static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1037: { 1038: zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes; 1039: int i; 1040: zend_uint catch_op_num = 0; 1041: int catched = 0; 1042: zval restored_error_reporting; 1043: 1044: void **stack_frame = (void**)(((char*)EX_Ts()) + 1045: (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * EX(op_array)->T)); 1046: 1047: while (zend_vm_stack_top(TSRMLS_C) != stack_frame) { 1048: zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C); 1049: zval_ptr_dtor(&stack_zval_p); 1050: } 1051: 1052: for (i=0; i<EG(active_op_array)->last_try_catch; i++) { 1053: if (EG(active_op_array)->try_catch_array[i].try_op > op_num) { 1054: /* further blocks will not be relevant... */ 1055: break; 1056: } else if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) { 1057: catch_op_num = EX(op_array)->try_catch_array[i].catch_op; 1058: catched = 1; 1059: } 1060: } 1061: 1062: while (EX(fbc)) { 1063: EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack)); 1064: if (EX(object)) { 1065: if (IS_CTOR_CALL(EX(called_scope))) { 1066: if (IS_CTOR_USED(EX(called_scope))) { 1067: Z_DELREF_P(EX(object)); 1068: } 1069: if (Z_REFCOUNT_P(EX(object)) == 1) { 1070: zend_object_store_ctor_failed(EX(object) TSRMLS_CC); 1071: } 1072: } 1073: zval_ptr_dtor(&EX(object)); 1074: } 1075: EX(called_scope) = DECODE_CTOR(EX(called_scope)); 1076: zend_arg_types_stack_2_pop(&EG(arg_types_stack), &EX(object), &EX(fbc)); 1077: } 1078: 1079: for (i=0; i<EX(op_array)->last_brk_cont; i++) { 1080: if (EX(op_array)->brk_cont_array[i].start < 0) { 1081: continue; 1082: } else if (EX(op_array)->brk_cont_array[i].start > op_num) { 1083: /* further blocks will not be relevant... */ 1084: break; 1085: } else if (op_num < EX(op_array)->brk_cont_array[i].brk) { 1086: if (!catched || 1087: catch_op_num >= EX(op_array)->brk_cont_array[i].brk) { 1088: zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk]; 1089: 1090: switch (brk_opline->opcode) { 1091: case ZEND_SWITCH_FREE: 1092: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { 1093: zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr); 1094: } 1095: break; 1096: case ZEND_FREE: 1097: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { 1098: zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var); 1099: } 1100: break; 1101: } 1102: } 1103: } 1104: } 1105: 1106: /* restore previous error_reporting value */ 1107: if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) { 1108: Z_TYPE(restored_error_reporting) = IS_LONG; 1109: Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting)); 1110: convert_to_string(&restored_error_reporting); 1111: 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); 1112: zendi_zval_dtor(restored_error_reporting); 1113: } 1114: EX(old_error_reporting) = NULL; 1115: 1116: if (!catched) { 1117: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 1118: } else { 1119: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]); 1120: ZEND_VM_CONTINUE(); 1121: } 1122: } 1123: 1124: static int ZEND_FASTCALL ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1125: { 1126: USE_OPLINE 1127: 1128: SAVE_OPLINE(); 1129: zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC); 1130: CHECK_EXCEPTION(); 1131: ZEND_VM_NEXT_OPCODE(); 1132: } 1133: 1134: static int ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1135: { 1136: USE_OPLINE 1137: int ret; 1138: 1139: SAVE_OPLINE(); 1140: ret = zend_user_opcode_handlers[opline->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL); 1141: LOAD_OPLINE(); 1142: 1143: switch (ret) { 1144: case ZEND_USER_OPCODE_CONTINUE: 1145: ZEND_VM_CONTINUE(); 1146: case ZEND_USER_OPCODE_RETURN: 1147: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 1148: case ZEND_USER_OPCODE_ENTER: 1149: ZEND_VM_ENTER(); 1150: case ZEND_USER_OPCODE_LEAVE: 1151: ZEND_VM_LEAVE(); 1152: case ZEND_USER_OPCODE_DISPATCH: 1153: ZEND_VM_DISPATCH(opline->opcode, opline); 1154: default: 1155: ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline); 1156: } 1157: } 1158: 1159: static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1160: { 1161: USE_OPLINE 1162: 1163: SAVE_OPLINE(); 1164: EG(exception) = NULL; 1165: if (IS_CONST == IS_UNUSED) { 1166: EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); 1167: CHECK_EXCEPTION(); 1168: ZEND_VM_NEXT_OPCODE(); 1169: } else { 1170: 1171: zval *class_name = opline->op2.zv; 1172: 1173: if (IS_CONST == IS_CONST) { 1174: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1175: EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); 1176: } else { 1177: EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); 1178: CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); 1179: } 1180: } else if (Z_TYPE_P(class_name) == IS_OBJECT) { 1181: EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); 1182: } else if (Z_TYPE_P(class_name) == IS_STRING) { 1183: EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); 1184: } else { 1185: zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); 1186: } 1187: 1188: CHECK_EXCEPTION(); 1189: ZEND_VM_NEXT_OPCODE(); 1190: } 1191: } 1192: 1193: static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1194: { 1195: USE_OPLINE 1196: zval *function_name; 1197: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 1198: 1199: if (IS_CONST == IS_CONST) { 1200: function_name = (zval*)(opline->op2.literal+1); 1201: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1202: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 1203: } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &EX(fbc)) == FAILURE)) { 1204: SAVE_OPLINE(); 1205: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); 1206: } else { 1207: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 1208: } 1209: EX(object) = NULL; 1210: /*CHECK_EXCEPTION();*/ 1211: ZEND_VM_NEXT_OPCODE(); 1212: } else { 1213: char *function_name_strval, *lcname; 1214: int function_name_strlen; 1215: 1216: 1217: SAVE_OPLINE(); 1218: function_name = opline->op2.zv; 1219: 1220: if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { 1221: function_name_strval = Z_STRVAL_P(function_name); 1222: function_name_strlen = Z_STRLEN_P(function_name); 1223: if (function_name_strval[0] == '\\') { 1224: function_name_strlen -= 1; 1225: lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); 1226: } else { 1227: lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); 1228: } 1229: if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE)) { 1230: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); 1231: } 1232: efree(lcname); 1233: 1234: EX(object) = NULL; 1235: CHECK_EXCEPTION(); 1236: ZEND_VM_NEXT_OPCODE(); 1237: } else if (IS_CONST != IS_CONST && IS_CONST != IS_TMP_VAR && 1238: EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && 1239: Z_OBJ_HANDLER_P(function_name, get_closure) && 1240: Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) { 1241: if (EX(object)) { 1242: Z_ADDREF_P(EX(object)); 1243: } 1244: if (IS_CONST == IS_VAR && 0 && 1245: EX(fbc)->common.fn_flags & ZEND_ACC_CLOSURE) { 1246: /* Delay closure destruction until its invocation */ 1247: EX(fbc)->common.prototype = (zend_function*)function_name; 1248: } else { 1249: 1250: } 1251: CHECK_EXCEPTION(); 1252: ZEND_VM_NEXT_OPCODE(); 1253: } else if (IS_CONST != IS_CONST && 1254: EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && 1255: zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { 1256: zend_class_entry *ce; 1257: zval **method = NULL; 1258: zval **obj = NULL; 1259: 1260: zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); 1261: zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); 1262: 1263: if (!obj || !method) { 1264: zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); 1265: } 1266: 1267: if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { 1268: zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); 1269: } 1270: 1271: if (Z_TYPE_PP(method) != IS_STRING) { 1272: zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); 1273: } 1274: 1275: if (Z_TYPE_PP(obj) == IS_STRING) { 1276: ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); 1277: if (UNEXPECTED(EG(exception) != NULL)) { 1278: HANDLE_EXCEPTION(); 1279: } 1280: if (UNEXPECTED(ce == NULL)) { 1281: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_PP(obj)); 1282: } 1283: EX(called_scope) = ce; 1284: EX(object) = NULL; 1285: 1286: if (ce->get_static_method) { 1287: EX(fbc) = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); 1288: } else { 1289: EX(fbc) = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1290: } 1291: } else { 1292: EX(object) = *obj; 1293: ce = EX(called_scope) = Z_OBJCE_PP(obj); 1294: 1295: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1296: if (UNEXPECTED(EX(fbc) == NULL)) { 1297: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), Z_STRVAL_PP(method)); 1298: } 1299: 1300: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 1301: EX(object) = NULL; 1302: } else { 1303: if (!PZVAL_IS_REF(EX(object))) { 1304: Z_ADDREF_P(EX(object)); /* For $this pointer */ 1305: } else { 1306: zval *this_ptr; 1307: ALLOC_ZVAL(this_ptr); 1308: INIT_PZVAL_COPY(this_ptr, EX(object)); 1309: zval_copy_ctor(this_ptr); 1310: EX(object) = this_ptr; 1311: } 1312: } 1313: } 1314: 1315: if (UNEXPECTED(EX(fbc) == NULL)) { 1316: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); 1317: } 1318: 1319: CHECK_EXCEPTION(); 1320: ZEND_VM_NEXT_OPCODE(); 1321: } else { 1322: zend_error_noreturn(E_ERROR, "Function name must be a string"); 1323: } 1324: } 1325: } 1326: 1327: 1328: static int ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1329: { 1330: USE_OPLINE 1331: zend_literal *func_name; 1332: 1333: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 1334: 1335: func_name = opline->op2.literal + 1; 1336: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1337: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 1338: } else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &EX(fbc))==FAILURE) { 1339: func_name++; 1340: if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &EX(fbc))==FAILURE)) { 1341: SAVE_OPLINE(); 1342: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); 1343: } else { 1344: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 1345: } 1346: } else { 1347: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 1348: } 1349: 1350: EX(object) = NULL; 1351: ZEND_VM_NEXT_OPCODE(); 1352: } 1353: 1354: static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1355: { 1356: USE_OPLINE 1357: zval *assignment_value; 1358: zend_uint arg_num = opline->op1.num; 1359: zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC); 1360: zval **var_ptr; 1361: 1362: SAVE_OPLINE(); 1363: if (param == NULL) { 1364: ALLOC_ZVAL(assignment_value); 1365: *assignment_value = *opline->op2.zv; 1366: if ((Z_TYPE_P(assignment_value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || 1367: Z_TYPE_P(assignment_value)==IS_CONSTANT_ARRAY) { 1368: Z_SET_REFCOUNT_P(assignment_value, 1); 1369: zval_update_constant(&assignment_value, 0 TSRMLS_CC); 1370: } else { 1371: zval_copy_ctor(assignment_value); 1372: } 1373: INIT_PZVAL(assignment_value); 1374: } else { 1375: assignment_value = *param; 1376: Z_ADDREF_P(assignment_value); 1377: } 1378: 1379: zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC); 1380: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->result.var TSRMLS_CC); 1381: zval_ptr_dtor(var_ptr); 1382: *var_ptr = assignment_value; 1383: 1384: CHECK_EXCEPTION(); 1385: ZEND_VM_NEXT_OPCODE(); 1386: } 1387: 1388: static int ZEND_FASTCALL ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1389: { 1390: USE_OPLINE 1391: zend_brk_cont_element *el; 1392: 1393: SAVE_OPLINE(); 1394: el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, 1395: EX(op_array), EX_Ts() TSRMLS_CC); 1396: ZEND_VM_JMP(EX(op_array)->opcodes + el->brk); 1397: } 1398: 1399: static int ZEND_FASTCALL ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1400: { 1401: USE_OPLINE 1402: zend_brk_cont_element *el; 1403: 1404: SAVE_OPLINE(); 1405: el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, 1406: EX(op_array), EX_Ts() TSRMLS_CC); 1407: ZEND_VM_JMP(EX(op_array)->opcodes + el->cont); 1408: } 1409: 1410: static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1411: { 1412: zend_op *brk_opline; 1413: USE_OPLINE 1414: zend_brk_cont_element *el; 1415: 1416: SAVE_OPLINE(); 1417: el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value, 1418: EX(op_array), EX_Ts() TSRMLS_CC); 1419: 1420: brk_opline = EX(op_array)->opcodes + el->brk; 1421: 1422: switch (brk_opline->opcode) { 1423: case ZEND_SWITCH_FREE: 1424: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { 1425: zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr); 1426: } 1427: break; 1428: case ZEND_FREE: 1429: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { 1430: zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var); 1431: } 1432: break; 1433: } 1434: ZEND_VM_JMP(opline->op1.jmp_addr); 1435: } 1436: 1437: static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1438: { 1439: USE_OPLINE 1440: zend_class_entry *ce = EX_T(opline->op1.var).class_entry; 1441: zend_class_entry *iface; 1442: 1443: SAVE_OPLINE(); 1444: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1445: iface = CACHED_PTR(opline->op2.literal->cache_slot); 1446: } else { 1447: iface = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); 1448: if (UNEXPECTED(iface == NULL)) { 1449: CHECK_EXCEPTION(); 1450: ZEND_VM_NEXT_OPCODE(); 1451: } 1452: CACHE_PTR(opline->op2.literal->cache_slot, iface); 1453: } 1454: 1455: if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) { 1456: zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name); 1457: } 1458: zend_do_implement_interface(ce, iface TSRMLS_CC); 1459: 1460: CHECK_EXCEPTION(); 1461: ZEND_VM_NEXT_OPCODE(); 1462: } 1463: 1464: static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1465: { 1466: USE_OPLINE 1467: 1468: SAVE_OPLINE(); 1469: EG(exception) = NULL; 1470: if (IS_TMP_VAR == IS_UNUSED) { 1471: EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); 1472: CHECK_EXCEPTION(); 1473: ZEND_VM_NEXT_OPCODE(); 1474: } else { 1475: zend_free_op free_op2; 1476: zval *class_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 1477: 1478: if (IS_TMP_VAR == IS_CONST) { 1479: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1480: EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); 1481: } else { 1482: EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); 1483: CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); 1484: } 1485: } else if (Z_TYPE_P(class_name) == IS_OBJECT) { 1486: EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); 1487: } else if (Z_TYPE_P(class_name) == IS_STRING) { 1488: EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); 1489: } else { 1490: zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); 1491: } 1492: 1493: zval_dtor(free_op2.var); 1494: CHECK_EXCEPTION(); 1495: ZEND_VM_NEXT_OPCODE(); 1496: } 1497: } 1498: 1499: static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1500: { 1501: USE_OPLINE 1502: zval *function_name; 1503: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 1504: 1505: if (IS_TMP_VAR == IS_CONST) { 1506: function_name = (zval*)(opline->op2.literal+1); 1507: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1508: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 1509: } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &EX(fbc)) == FAILURE)) { 1510: SAVE_OPLINE(); 1511: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); 1512: } else { 1513: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 1514: } 1515: EX(object) = NULL; 1516: /*CHECK_EXCEPTION();*/ 1517: ZEND_VM_NEXT_OPCODE(); 1518: } else { 1519: char *function_name_strval, *lcname; 1520: int function_name_strlen; 1521: zend_free_op free_op2; 1522: 1523: SAVE_OPLINE(); 1524: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 1525: 1526: if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { 1527: function_name_strval = Z_STRVAL_P(function_name); 1528: function_name_strlen = Z_STRLEN_P(function_name); 1529: if (function_name_strval[0] == '\\') { 1530: function_name_strlen -= 1; 1531: lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); 1532: } else { 1533: lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); 1534: } 1535: if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE)) { 1536: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); 1537: } 1538: efree(lcname); 1539: zval_dtor(free_op2.var); 1540: EX(object) = NULL; 1541: CHECK_EXCEPTION(); 1542: ZEND_VM_NEXT_OPCODE(); 1543: } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_TMP_VAR && 1544: EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && 1545: Z_OBJ_HANDLER_P(function_name, get_closure) && 1546: Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) { 1547: if (EX(object)) { 1548: Z_ADDREF_P(EX(object)); 1549: } 1550: if (IS_TMP_VAR == IS_VAR && 1 && 1551: EX(fbc)->common.fn_flags & ZEND_ACC_CLOSURE) { 1552: /* Delay closure destruction until its invocation */ 1553: EX(fbc)->common.prototype = (zend_function*)function_name; 1554: } else { 1555: zval_dtor(free_op2.var); 1556: } 1557: CHECK_EXCEPTION(); 1558: ZEND_VM_NEXT_OPCODE(); 1559: } else if (IS_TMP_VAR != IS_CONST && 1560: EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && 1561: zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { 1562: zend_class_entry *ce; 1563: zval **method = NULL; 1564: zval **obj = NULL; 1565: 1566: zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); 1567: zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); 1568: 1569: if (!obj || !method) { 1570: zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); 1571: } 1572: 1573: if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { 1574: zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); 1575: } 1576: 1577: if (Z_TYPE_PP(method) != IS_STRING) { 1578: zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); 1579: } 1580: 1581: if (Z_TYPE_PP(obj) == IS_STRING) { 1582: ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); 1583: if (UNEXPECTED(EG(exception) != NULL)) { 1584: HANDLE_EXCEPTION(); 1585: } 1586: if (UNEXPECTED(ce == NULL)) { 1587: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_PP(obj)); 1588: } 1589: EX(called_scope) = ce; 1590: EX(object) = NULL; 1591: 1592: if (ce->get_static_method) { 1593: EX(fbc) = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); 1594: } else { 1595: EX(fbc) = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1596: } 1597: } else { 1598: EX(object) = *obj; 1599: ce = EX(called_scope) = Z_OBJCE_PP(obj); 1600: 1601: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1602: if (UNEXPECTED(EX(fbc) == NULL)) { 1603: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), Z_STRVAL_PP(method)); 1604: } 1605: 1606: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 1607: EX(object) = NULL; 1608: } else { 1609: if (!PZVAL_IS_REF(EX(object))) { 1610: Z_ADDREF_P(EX(object)); /* For $this pointer */ 1611: } else { 1612: zval *this_ptr; 1613: ALLOC_ZVAL(this_ptr); 1614: INIT_PZVAL_COPY(this_ptr, EX(object)); 1615: zval_copy_ctor(this_ptr); 1616: EX(object) = this_ptr; 1617: } 1618: } 1619: } 1620: 1621: if (UNEXPECTED(EX(fbc) == NULL)) { 1622: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); 1623: } 1624: zval_dtor(free_op2.var); 1625: CHECK_EXCEPTION(); 1626: ZEND_VM_NEXT_OPCODE(); 1627: } else { 1628: zend_error_noreturn(E_ERROR, "Function name must be a string"); 1629: } 1630: } 1631: } 1632: 1633: 1634: static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1635: { 1636: USE_OPLINE 1637: 1638: SAVE_OPLINE(); 1639: EG(exception) = NULL; 1640: if (IS_VAR == IS_UNUSED) { 1641: EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); 1642: CHECK_EXCEPTION(); 1643: ZEND_VM_NEXT_OPCODE(); 1644: } else { 1645: zend_free_op free_op2; 1646: zval *class_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 1647: 1648: if (IS_VAR == IS_CONST) { 1649: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1650: EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); 1651: } else { 1652: EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); 1653: CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); 1654: } 1655: } else if (Z_TYPE_P(class_name) == IS_OBJECT) { 1656: EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); 1657: } else if (Z_TYPE_P(class_name) == IS_STRING) { 1658: EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); 1659: } else { 1660: zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); 1661: } 1662: 1663: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 1664: CHECK_EXCEPTION(); 1665: ZEND_VM_NEXT_OPCODE(); 1666: } 1667: } 1668: 1669: static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1670: { 1671: USE_OPLINE 1672: zval *function_name; 1673: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 1674: 1675: if (IS_VAR == IS_CONST) { 1676: function_name = (zval*)(opline->op2.literal+1); 1677: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1678: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 1679: } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &EX(fbc)) == FAILURE)) { 1680: SAVE_OPLINE(); 1681: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); 1682: } else { 1683: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 1684: } 1685: EX(object) = NULL; 1686: /*CHECK_EXCEPTION();*/ 1687: ZEND_VM_NEXT_OPCODE(); 1688: } else { 1689: char *function_name_strval, *lcname; 1690: int function_name_strlen; 1691: zend_free_op free_op2; 1692: 1693: SAVE_OPLINE(); 1694: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 1695: 1696: if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { 1697: function_name_strval = Z_STRVAL_P(function_name); 1698: function_name_strlen = Z_STRLEN_P(function_name); 1699: if (function_name_strval[0] == '\\') { 1700: function_name_strlen -= 1; 1701: lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); 1702: } else { 1703: lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); 1704: } 1705: if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE)) { 1706: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); 1707: } 1708: efree(lcname); 1709: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 1710: EX(object) = NULL; 1711: CHECK_EXCEPTION(); 1712: ZEND_VM_NEXT_OPCODE(); 1713: } else if (IS_VAR != IS_CONST && IS_VAR != IS_TMP_VAR && 1714: EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && 1715: Z_OBJ_HANDLER_P(function_name, get_closure) && 1716: Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) { 1717: if (EX(object)) { 1718: Z_ADDREF_P(EX(object)); 1719: } 1720: if (IS_VAR == IS_VAR && (free_op2.var != NULL) && 1721: EX(fbc)->common.fn_flags & ZEND_ACC_CLOSURE) { 1722: /* Delay closure destruction until its invocation */ 1723: EX(fbc)->common.prototype = (zend_function*)function_name; 1724: } else { 1725: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 1726: } 1727: CHECK_EXCEPTION(); 1728: ZEND_VM_NEXT_OPCODE(); 1729: } else if (IS_VAR != IS_CONST && 1730: EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && 1731: zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { 1732: zend_class_entry *ce; 1733: zval **method = NULL; 1734: zval **obj = NULL; 1735: 1736: zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); 1737: zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); 1738: 1739: if (!obj || !method) { 1740: zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); 1741: } 1742: 1743: if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { 1744: zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); 1745: } 1746: 1747: if (Z_TYPE_PP(method) != IS_STRING) { 1748: zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); 1749: } 1750: 1751: if (Z_TYPE_PP(obj) == IS_STRING) { 1752: ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); 1753: if (UNEXPECTED(EG(exception) != NULL)) { 1754: HANDLE_EXCEPTION(); 1755: } 1756: if (UNEXPECTED(ce == NULL)) { 1757: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_PP(obj)); 1758: } 1759: EX(called_scope) = ce; 1760: EX(object) = NULL; 1761: 1762: if (ce->get_static_method) { 1763: EX(fbc) = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); 1764: } else { 1765: EX(fbc) = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1766: } 1767: } else { 1768: EX(object) = *obj; 1769: ce = EX(called_scope) = Z_OBJCE_PP(obj); 1770: 1771: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1772: if (UNEXPECTED(EX(fbc) == NULL)) { 1773: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), Z_STRVAL_PP(method)); 1774: } 1775: 1776: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 1777: EX(object) = NULL; 1778: } else { 1779: if (!PZVAL_IS_REF(EX(object))) { 1780: Z_ADDREF_P(EX(object)); /* For $this pointer */ 1781: } else { 1782: zval *this_ptr; 1783: ALLOC_ZVAL(this_ptr); 1784: INIT_PZVAL_COPY(this_ptr, EX(object)); 1785: zval_copy_ctor(this_ptr); 1786: EX(object) = this_ptr; 1787: } 1788: } 1789: } 1790: 1791: if (UNEXPECTED(EX(fbc) == NULL)) { 1792: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); 1793: } 1794: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 1795: CHECK_EXCEPTION(); 1796: ZEND_VM_NEXT_OPCODE(); 1797: } else { 1798: zend_error_noreturn(E_ERROR, "Function name must be a string"); 1799: } 1800: } 1801: } 1802: 1803: 1804: static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1805: { 1806: USE_OPLINE 1807: 1808: SAVE_OPLINE(); 1809: EG(exception) = NULL; 1810: if (IS_UNUSED == IS_UNUSED) { 1811: EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); 1812: CHECK_EXCEPTION(); 1813: ZEND_VM_NEXT_OPCODE(); 1814: } else { 1815: 1816: zval *class_name = NULL; 1817: 1818: if (IS_UNUSED == IS_CONST) { 1819: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1820: EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); 1821: } else { 1822: EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); 1823: CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); 1824: } 1825: } else if (Z_TYPE_P(class_name) == IS_OBJECT) { 1826: EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); 1827: } else if (Z_TYPE_P(class_name) == IS_STRING) { 1828: EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); 1829: } else { 1830: zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); 1831: } 1832: 1833: CHECK_EXCEPTION(); 1834: ZEND_VM_NEXT_OPCODE(); 1835: } 1836: } 1837: 1838: static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1839: { 1840: USE_OPLINE 1841: 1842: SAVE_OPLINE(); 1843: EG(exception) = NULL; 1844: if (IS_CV == IS_UNUSED) { 1845: EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); 1846: CHECK_EXCEPTION(); 1847: ZEND_VM_NEXT_OPCODE(); 1848: } else { 1849: 1850: zval *class_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 1851: 1852: if (IS_CV == IS_CONST) { 1853: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1854: EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); 1855: } else { 1856: EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); 1857: CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); 1858: } 1859: } else if (Z_TYPE_P(class_name) == IS_OBJECT) { 1860: EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); 1861: } else if (Z_TYPE_P(class_name) == IS_STRING) { 1862: EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); 1863: } else { 1864: zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); 1865: } 1866: 1867: CHECK_EXCEPTION(); 1868: ZEND_VM_NEXT_OPCODE(); 1869: } 1870: } 1871: 1872: static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 1873: { 1874: USE_OPLINE 1875: zval *function_name; 1876: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 1877: 1878: if (IS_CV == IS_CONST) { 1879: function_name = (zval*)(opline->op2.literal+1); 1880: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 1881: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 1882: } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &EX(fbc)) == FAILURE)) { 1883: SAVE_OPLINE(); 1884: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); 1885: } else { 1886: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 1887: } 1888: EX(object) = NULL; 1889: /*CHECK_EXCEPTION();*/ 1890: ZEND_VM_NEXT_OPCODE(); 1891: } else { 1892: char *function_name_strval, *lcname; 1893: int function_name_strlen; 1894: 1895: 1896: SAVE_OPLINE(); 1897: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 1898: 1899: if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { 1900: function_name_strval = Z_STRVAL_P(function_name); 1901: function_name_strlen = Z_STRLEN_P(function_name); 1902: if (function_name_strval[0] == '\\') { 1903: function_name_strlen -= 1; 1904: lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); 1905: } else { 1906: lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); 1907: } 1908: if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE)) { 1909: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); 1910: } 1911: efree(lcname); 1912: 1913: EX(object) = NULL; 1914: CHECK_EXCEPTION(); 1915: ZEND_VM_NEXT_OPCODE(); 1916: } else if (IS_CV != IS_CONST && IS_CV != IS_TMP_VAR && 1917: EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && 1918: Z_OBJ_HANDLER_P(function_name, get_closure) && 1919: Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) { 1920: if (EX(object)) { 1921: Z_ADDREF_P(EX(object)); 1922: } 1923: if (IS_CV == IS_VAR && 0 && 1924: EX(fbc)->common.fn_flags & ZEND_ACC_CLOSURE) { 1925: /* Delay closure destruction until its invocation */ 1926: EX(fbc)->common.prototype = (zend_function*)function_name; 1927: } else { 1928: 1929: } 1930: CHECK_EXCEPTION(); 1931: ZEND_VM_NEXT_OPCODE(); 1932: } else if (IS_CV != IS_CONST && 1933: EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && 1934: zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { 1935: zend_class_entry *ce; 1936: zval **method = NULL; 1937: zval **obj = NULL; 1938: 1939: zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); 1940: zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); 1941: 1942: if (!obj || !method) { 1943: zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); 1944: } 1945: 1946: if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { 1947: zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); 1948: } 1949: 1950: if (Z_TYPE_PP(method) != IS_STRING) { 1951: zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); 1952: } 1953: 1954: if (Z_TYPE_PP(obj) == IS_STRING) { 1955: ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); 1956: if (UNEXPECTED(EG(exception) != NULL)) { 1957: HANDLE_EXCEPTION(); 1958: } 1959: if (UNEXPECTED(ce == NULL)) { 1960: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_PP(obj)); 1961: } 1962: EX(called_scope) = ce; 1963: EX(object) = NULL; 1964: 1965: if (ce->get_static_method) { 1966: EX(fbc) = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); 1967: } else { 1968: EX(fbc) = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1969: } 1970: } else { 1971: EX(object) = *obj; 1972: ce = EX(called_scope) = Z_OBJCE_PP(obj); 1973: 1974: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); 1975: if (UNEXPECTED(EX(fbc) == NULL)) { 1976: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), Z_STRVAL_PP(method)); 1977: } 1978: 1979: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 1980: EX(object) = NULL; 1981: } else { 1982: if (!PZVAL_IS_REF(EX(object))) { 1983: Z_ADDREF_P(EX(object)); /* For $this pointer */ 1984: } else { 1985: zval *this_ptr; 1986: ALLOC_ZVAL(this_ptr); 1987: INIT_PZVAL_COPY(this_ptr, EX(object)); 1988: zval_copy_ctor(this_ptr); 1989: EX(object) = this_ptr; 1990: } 1991: } 1992: } 1993: 1994: if (UNEXPECTED(EX(fbc) == NULL)) { 1995: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); 1996: } 1997: 1998: CHECK_EXCEPTION(); 1999: ZEND_VM_NEXT_OPCODE(); 2000: } else { 2001: zend_error_noreturn(E_ERROR, "Function name must be a string"); 2002: } 2003: } 2004: } 2005: 2006: 2007: static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2008: { 2009: USE_OPLINE 2010: 2011: 2012: SAVE_OPLINE(); 2013: bitwise_not_function(&EX_T(opline->result.var).tmp_var, 2014: opline->op1.zv TSRMLS_CC); 2015: 2016: CHECK_EXCEPTION(); 2017: ZEND_VM_NEXT_OPCODE(); 2018: } 2019: 2020: static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2021: { 2022: USE_OPLINE 2023: 2024: 2025: SAVE_OPLINE(); 2026: boolean_not_function(&EX_T(opline->result.var).tmp_var, 2027: opline->op1.zv TSRMLS_CC); 2028: 2029: CHECK_EXCEPTION(); 2030: ZEND_VM_NEXT_OPCODE(); 2031: } 2032: 2033: static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2034: { 2035: USE_OPLINE 2036: 2037: zval *z; 2038: 2039: SAVE_OPLINE(); 2040: z = opline->op1.zv; 2041: 2042: if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { 2043: INIT_PZVAL(z); 2044: } 2045: zend_print_variable(z); 2046: 2047: CHECK_EXCEPTION(); 2048: ZEND_VM_NEXT_OPCODE(); 2049: } 2050: 2051: static int ZEND_FASTCALL ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2052: { 2053: USE_OPLINE 2054: 2055: ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); 2056: return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 2057: } 2058: 2059: static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2060: { 2061: USE_OPLINE 2062: 2063: zval *val; 2064: int ret; 2065: 2066: SAVE_OPLINE(); 2067: val = opline->op1.zv; 2068: 2069: if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 2070: ret = Z_LVAL_P(val); 2071: } else { 2072: ret = i_zend_is_true(val); 2073: 2074: if (UNEXPECTED(EG(exception) != NULL)) { 2075: HANDLE_EXCEPTION(); 2076: } 2077: } 2078: if (!ret) { 2079: #if DEBUG_ZEND>=2 2080: printf("Conditional jmp to %d\n", opline->op2.opline_num); 2081: #endif 2082: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 2083: ZEND_VM_CONTINUE(); 2084: } 2085: 2086: ZEND_VM_NEXT_OPCODE(); 2087: } 2088: 2089: static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2090: { 2091: USE_OPLINE 2092: 2093: zval *val; 2094: int ret; 2095: 2096: SAVE_OPLINE(); 2097: val = opline->op1.zv; 2098: 2099: if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 2100: ret = Z_LVAL_P(val); 2101: } else { 2102: ret = i_zend_is_true(val); 2103: 2104: if (UNEXPECTED(EG(exception) != NULL)) { 2105: HANDLE_EXCEPTION(); 2106: } 2107: } 2108: if (ret) { 2109: #if DEBUG_ZEND>=2 2110: printf("Conditional jmp to %d\n", opline->op2.opline_num); 2111: #endif 2112: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 2113: ZEND_VM_CONTINUE(); 2114: } 2115: 2116: ZEND_VM_NEXT_OPCODE(); 2117: } 2118: 2119: static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2120: { 2121: USE_OPLINE 2122: 2123: zval *val; 2124: int retval; 2125: 2126: SAVE_OPLINE(); 2127: val = opline->op1.zv; 2128: 2129: if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 2130: retval = Z_LVAL_P(val); 2131: } else { 2132: retval = i_zend_is_true(val); 2133: 2134: if (UNEXPECTED(EG(exception) != NULL)) { 2135: HANDLE_EXCEPTION(); 2136: } 2137: } 2138: if (EXPECTED(retval != 0)) { 2139: #if DEBUG_ZEND>=2 2140: printf("Conditional jmp on true to %d\n", opline->extended_value); 2141: #endif 2142: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); 2143: ZEND_VM_CONTINUE(); /* CHECK_ME */ 2144: } else { 2145: #if DEBUG_ZEND>=2 2146: printf("Conditional jmp on false to %d\n", opline->op2.opline_num); 2147: #endif 2148: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); 2149: ZEND_VM_CONTINUE(); /* CHECK_ME */ 2150: } 2151: } 2152: 2153: static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2154: { 2155: USE_OPLINE 2156: 2157: zval *val; 2158: int retval; 2159: 2160: SAVE_OPLINE(); 2161: val = opline->op1.zv; 2162: 2163: if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 2164: retval = Z_LVAL_P(val); 2165: } else { 2166: retval = i_zend_is_true(val); 2167: 2168: if (UNEXPECTED(EG(exception) != NULL)) { 2169: HANDLE_EXCEPTION(); 2170: } 2171: } 2172: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 2173: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 2174: if (!retval) { 2175: #if DEBUG_ZEND>=2 2176: printf("Conditional jmp to %d\n", opline->op2.opline_num); 2177: #endif 2178: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 2179: ZEND_VM_CONTINUE(); 2180: } 2181: ZEND_VM_NEXT_OPCODE(); 2182: } 2183: 2184: static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2185: { 2186: USE_OPLINE 2187: 2188: zval *val; 2189: int retval; 2190: 2191: SAVE_OPLINE(); 2192: val = opline->op1.zv; 2193: 2194: if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 2195: retval = Z_LVAL_P(val); 2196: } else { 2197: retval = i_zend_is_true(val); 2198: 2199: if (UNEXPECTED(EG(exception) != NULL)) { 2200: HANDLE_EXCEPTION(); 2201: } 2202: } 2203: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 2204: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 2205: if (retval) { 2206: #if DEBUG_ZEND>=2 2207: printf("Conditional jmp to %d\n", opline->op2.opline_num); 2208: #endif 2209: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 2210: ZEND_VM_CONTINUE(); 2211: } 2212: ZEND_VM_NEXT_OPCODE(); 2213: } 2214: 2215: static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2216: { 2217: USE_OPLINE 2218: 2219: zval *fname = opline->op1.zv; 2220: 2221: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 2222: 2223: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 2224: EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot); 2225: } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(fname), Z_STRLEN_P(fname)+1, Z_HASH_P(fname), (void **) &EX(function_state).function)==FAILURE)) { 2226: SAVE_OPLINE(); 2227: zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val); 2228: } else { 2229: CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function); 2230: } 2231: EX(object) = NULL; 2232: 2233: return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 2234: } 2235: 2236: static int ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2237: { 2238: USE_OPLINE 2239: zval *retval_ptr; 2240: 2241: 2242: SAVE_OPLINE(); 2243: retval_ptr = opline->op1.zv; 2244: 2245: if (!EG(return_value_ptr_ptr)) { 2246: if (IS_CONST == IS_TMP_VAR) { 2247: 2248: } 2249: } else if (!0) { /* Not a temp var */ 2250: if (IS_CONST == IS_CONST || 2251: (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) { 2252: zval *ret; 2253: 2254: ALLOC_ZVAL(ret); 2255: INIT_PZVAL_COPY(ret, retval_ptr); 2256: zval_copy_ctor(ret); 2257: *EG(return_value_ptr_ptr) = ret; 2258: } else if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && 2259: retval_ptr == &EG(uninitialized_zval)) { 2260: zval *ret; 2261: 2262: ALLOC_INIT_ZVAL(ret); 2263: *EG(return_value_ptr_ptr) = ret; 2264: } else { 2265: *EG(return_value_ptr_ptr) = retval_ptr; 2266: Z_ADDREF_P(retval_ptr); 2267: } 2268: } else { 2269: zval *ret; 2270: 2271: ALLOC_ZVAL(ret); 2272: INIT_PZVAL_COPY(ret, retval_ptr); 2273: *EG(return_value_ptr_ptr) = ret; 2274: } 2275: 2276: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 2277: } 2278: 2279: static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2280: { 2281: USE_OPLINE 2282: zval *retval_ptr; 2283: zval **retval_ptr_ptr; 2284: 2285: 2286: SAVE_OPLINE(); 2287: 2288: do { 2289: if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { 2290: /* Not supposed to happen, but we'll allow it */ 2291: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 2292: 2293: retval_ptr = opline->op1.zv; 2294: if (!EG(return_value_ptr_ptr)) { 2295: if (IS_CONST == IS_TMP_VAR) { 2296: 2297: } 2298: } else if (!0) { /* Not a temp var */ 2299: zval *ret; 2300: 2301: ALLOC_ZVAL(ret); 2302: INIT_PZVAL_COPY(ret, retval_ptr); 2303: zval_copy_ctor(ret); 2304: *EG(return_value_ptr_ptr) = ret; 2305: } else { 2306: zval *ret; 2307: 2308: ALLOC_ZVAL(ret); 2309: INIT_PZVAL_COPY(ret, retval_ptr); 2310: *EG(return_value_ptr_ptr) = ret; 2311: } 2312: break; 2313: } 2314: 2315: retval_ptr_ptr = NULL; 2316: 2317: if (IS_CONST == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { 2318: zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); 2319: } 2320: 2321: if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { 2322: if (opline->extended_value == ZEND_RETURNS_FUNCTION && 2323: EX_T(opline->op1.var).var.fcall_returned_reference) { 2324: } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { 2325: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 2326: if (EG(return_value_ptr_ptr)) { 2327: zval *ret; 2328: 2329: ALLOC_ZVAL(ret); 2330: INIT_PZVAL_COPY(ret, *retval_ptr_ptr); 2331: zval_copy_ctor(ret); 2332: *EG(return_value_ptr_ptr) = ret; 2333: } 2334: break; 2335: } 2336: } 2337: 2338: if (EG(return_value_ptr_ptr)) { 2339: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); 2340: Z_ADDREF_PP(retval_ptr_ptr); 2341: 2342: *EG(return_value_ptr_ptr) = *retval_ptr_ptr; 2343: } 2344: } while (0); 2345: 2346: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 2347: } 2348: 2349: static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2350: { 2351: USE_OPLINE 2352: zval *value; 2353: zval *exception; 2354: 2355: 2356: SAVE_OPLINE(); 2357: value = opline->op1.zv; 2358: 2359: if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { 2360: zend_error_noreturn(E_ERROR, "Can only throw objects"); 2361: } 2362: zend_exception_save(TSRMLS_C); 2363: /* Not sure if a complete copy is what we want here */ 2364: ALLOC_ZVAL(exception); 2365: INIT_PZVAL_COPY(exception, value); 2366: if (!0) { 2367: zval_copy_ctor(exception); 2368: } 2369: 2370: zend_throw_exception_object(exception TSRMLS_CC); 2371: zend_exception_restore(TSRMLS_C); 2372: 2373: HANDLE_EXCEPTION(); 2374: } 2375: 2376: static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2377: { 2378: USE_OPLINE 2379: 2380: SAVE_OPLINE(); 2381: if (opline->extended_value==ZEND_DO_FCALL_BY_NAME 2382: && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 2383: zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.opline_num); 2384: } 2385: { 2386: zval *valptr; 2387: zval *value; 2388: 2389: 2390: value = opline->op1.zv; 2391: 2392: ALLOC_ZVAL(valptr); 2393: INIT_PZVAL_COPY(valptr, value); 2394: if (!0) { 2395: zval_copy_ctor(valptr); 2396: } 2397: zend_vm_stack_push(valptr TSRMLS_CC); 2398: 2399: } 2400: CHECK_EXCEPTION(); 2401: ZEND_VM_NEXT_OPCODE(); 2402: } 2403: 2404: static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2405: { 2406: USE_OPLINE 2407: 2408: zval *retval = &EX_T(opline->result.var).tmp_var; 2409: 2410: SAVE_OPLINE(); 2411: /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ 2412: ZVAL_BOOL(retval, i_zend_is_true(opline->op1.zv)); 2413: 2414: CHECK_EXCEPTION(); 2415: ZEND_VM_NEXT_OPCODE(); 2416: } 2417: 2418: static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2419: { 2420: USE_OPLINE 2421: 2422: zval *obj; 2423: zend_class_entry *ce; 2424: zend_function *clone; 2425: zend_object_clone_obj_t clone_call; 2426: 2427: SAVE_OPLINE(); 2428: obj = opline->op1.zv; 2429: 2430: if (IS_CONST == IS_CONST || 2431: UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) { 2432: zend_error_noreturn(E_ERROR, "__clone method called on non-object"); 2433: } 2434: 2435: ce = Z_OBJCE_P(obj); 2436: clone = ce ? ce->clone : NULL; 2437: clone_call = Z_OBJ_HT_P(obj)->clone_obj; 2438: if (UNEXPECTED(clone_call == NULL)) { 2439: if (ce) { 2440: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); 2441: } else { 2442: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); 2443: } 2444: } 2445: 2446: if (ce && clone) { 2447: if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { 2448: /* Ensure that if we're calling a private function, we're allowed to do so. 2449: */ 2450: if (UNEXPECTED(ce != EG(scope))) { 2451: zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 2452: } 2453: } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { 2454: /* Ensure that if we're calling a protected function, we're allowed to do so. 2455: */ 2456: if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { 2457: zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 2458: } 2459: } 2460: } 2461: 2462: if (EXPECTED(EG(exception) == NULL)) { 2463: zval *retval; 2464: 2465: ALLOC_ZVAL(retval); 2466: Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); 2467: Z_TYPE_P(retval) = IS_OBJECT; 2468: Z_SET_REFCOUNT_P(retval, 1); 2469: Z_SET_ISREF_P(retval); 2470: if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { 2471: zval_ptr_dtor(&retval); 2472: } else { 2473: AI_SET_PTR(&EX_T(opline->result.var), retval); 2474: } 2475: } 2476: 2477: CHECK_EXCEPTION(); 2478: ZEND_VM_NEXT_OPCODE(); 2479: } 2480: 2481: static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2482: { 2483: USE_OPLINE 2484: 2485: zval *expr; 2486: zval *result = &EX_T(opline->result.var).tmp_var; 2487: 2488: SAVE_OPLINE(); 2489: expr = opline->op1.zv; 2490: 2491: if (opline->extended_value != IS_STRING) { 2492: ZVAL_COPY_VALUE(result, expr); 2493: if (!0) { 2494: zendi_zval_copy_ctor(*result); 2495: } 2496: } 2497: switch (opline->extended_value) { 2498: case IS_NULL: 2499: convert_to_null(result); 2500: break; 2501: case IS_BOOL: 2502: convert_to_boolean(result); 2503: break; 2504: case IS_LONG: 2505: convert_to_long(result); 2506: break; 2507: case IS_DOUBLE: 2508: convert_to_double(result); 2509: break; 2510: case IS_STRING: { 2511: zval var_copy; 2512: int use_copy; 2513: 2514: zend_make_printable_zval(expr, &var_copy, &use_copy); 2515: if (use_copy) { 2516: ZVAL_COPY_VALUE(result, &var_copy); 2517: if (0) { 2518: 2519: } 2520: } else { 2521: ZVAL_COPY_VALUE(result, expr); 2522: if (!0) { 2523: zendi_zval_copy_ctor(*result); 2524: } 2525: } 2526: break; 2527: } 2528: case IS_ARRAY: 2529: convert_to_array(result); 2530: break; 2531: case IS_OBJECT: 2532: convert_to_object(result); 2533: break; 2534: } 2535: 2536: CHECK_EXCEPTION(); 2537: ZEND_VM_NEXT_OPCODE(); 2538: } 2539: 2540: static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2541: { 2542: USE_OPLINE 2543: zend_op_array *new_op_array=NULL; 2544: 2545: zval *inc_filename; 2546: zval *tmp_inc_filename = NULL; 2547: zend_bool failure_retval=0; 2548: 2549: SAVE_OPLINE(); 2550: inc_filename = opline->op1.zv; 2551: 2552: if (inc_filename->type!=IS_STRING) { 2553: MAKE_STD_ZVAL(tmp_inc_filename); 2554: ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); 2555: zval_copy_ctor(tmp_inc_filename); 2556: convert_to_string(tmp_inc_filename); 2557: inc_filename = tmp_inc_filename; 2558: } 2559: 2560: if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { 2561: if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { 2562: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 2563: } else { 2564: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 2565: } 2566: } else { 2567: switch (opline->extended_value) { 2568: case ZEND_INCLUDE_ONCE: 2569: case ZEND_REQUIRE_ONCE: { 2570: zend_file_handle file_handle; 2571: char *resolved_path; 2572: 2573: resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); 2574: if (resolved_path) { 2575: failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); 2576: } else { 2577: resolved_path = Z_STRVAL_P(inc_filename); 2578: } 2579: 2580: if (failure_retval) { 2581: /* do nothing, file already included */ 2582: } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) { 2583: 2584: if (!file_handle.opened_path) { 2585: file_handle.opened_path = estrdup(resolved_path); 2586: } 2587: 2588: if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { 2589: new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); 2590: zend_destroy_file_handle(&file_handle TSRMLS_CC); 2591: } else { 2592: zend_file_handle_dtor(&file_handle TSRMLS_CC); 2593: failure_retval=1; 2594: } 2595: } else { 2596: if (opline->extended_value == ZEND_INCLUDE_ONCE) { 2597: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 2598: } else { 2599: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 2600: } 2601: } 2602: if (resolved_path != Z_STRVAL_P(inc_filename)) { 2603: efree(resolved_path); 2604: } 2605: } 2606: break; 2607: case ZEND_INCLUDE: 2608: case ZEND_REQUIRE: 2609: new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC); 2610: break; 2611: case ZEND_EVAL: { 2612: char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC); 2613: 2614: new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC); 2615: efree(eval_desc); 2616: } 2617: break; 2618: EMPTY_SWITCH_DEFAULT_CASE() 2619: } 2620: } 2621: if (tmp_inc_filename) { 2622: zval_ptr_dtor(&tmp_inc_filename); 2623: } 2624: 2625: if (UNEXPECTED(EG(exception) != NULL)) { 2626: HANDLE_EXCEPTION(); 2627: } else if (EXPECTED(new_op_array != NULL)) { 2628: EX(original_return_value) = EG(return_value_ptr_ptr); 2629: EG(active_op_array) = new_op_array; 2630: if (RETURN_VALUE_USED(opline)) { 2631: EX_T(opline->result.var).var.ptr = NULL; 2632: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 2633: EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; 2634: } else { 2635: EG(return_value_ptr_ptr) = NULL; 2636: } 2637: 2638: EX(current_object) = EX(object); 2639: 2640: EX(function_state).function = (zend_function *) new_op_array; 2641: EX(object) = NULL; 2642: 2643: if (!EG(active_symbol_table)) { 2644: zend_rebuild_symbol_table(TSRMLS_C); 2645: } 2646: 2647: if (EXPECTED(zend_execute == execute)) { 2648: ZEND_VM_ENTER(); 2649: } else { 2650: zend_execute(new_op_array TSRMLS_CC); 2651: } 2652: 2653: EX(function_state).function = (zend_function *) EX(op_array); 2654: EX(object) = EX(current_object); 2655: 2656: EG(opline_ptr) = &EX(opline); 2657: EG(active_op_array) = EX(op_array); 2658: EG(return_value_ptr_ptr) = EX(original_return_value); 2659: destroy_op_array(new_op_array TSRMLS_CC); 2660: efree(new_op_array); 2661: if (UNEXPECTED(EG(exception) != NULL)) { 2662: zend_throw_exception_internal(NULL TSRMLS_CC); 2663: HANDLE_EXCEPTION(); 2664: } else if (RETURN_VALUE_USED(opline)) { 2665: if (!EX_T(opline->result.var).var.ptr) { /* there was no return statement */ 2666: zval *retval; 2667: 2668: ALLOC_ZVAL(retval); 2669: ZVAL_BOOL(retval, 1); 2670: INIT_PZVAL(retval); 2671: EX_T(opline->result.var).var.ptr = retval; 2672: } 2673: } 2674: 2675: } else if (RETURN_VALUE_USED(opline)) { 2676: zval *retval; 2677: 2678: ALLOC_ZVAL(retval); 2679: ZVAL_BOOL(retval, failure_retval); 2680: INIT_PZVAL(retval); 2681: AI_SET_PTR(&EX_T(opline->result.var), retval); 2682: } 2683: ZEND_VM_NEXT_OPCODE(); 2684: } 2685: 2686: static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2687: { 2688: USE_OPLINE 2689: 2690: zval *array_ptr, **array_ptr_ptr; 2691: HashTable *fe_ht; 2692: zend_object_iterator *iter = NULL; 2693: zend_class_entry *ce = NULL; 2694: zend_bool is_empty = 0; 2695: 2696: SAVE_OPLINE(); 2697: 2698: if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && 2699: (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { 2700: array_ptr_ptr = NULL; 2701: if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { 2702: MAKE_STD_ZVAL(array_ptr); 2703: ZVAL_NULL(array_ptr); 2704: } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { 2705: if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { 2706: zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); 2707: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 2708: } 2709: 2710: ce = Z_OBJCE_PP(array_ptr_ptr); 2711: if (!ce || ce->get_iterator == NULL) { 2712: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 2713: Z_ADDREF_PP(array_ptr_ptr); 2714: } 2715: array_ptr = *array_ptr_ptr; 2716: } else { 2717: if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { 2718: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 2719: if (opline->extended_value & ZEND_FE_FETCH_BYREF) { 2720: Z_SET_ISREF_PP(array_ptr_ptr); 2721: } 2722: } 2723: array_ptr = *array_ptr_ptr; 2724: Z_ADDREF_P(array_ptr); 2725: } 2726: } else { 2727: array_ptr = opline->op1.zv; 2728: if (0) { /* IS_TMP_VAR */ 2729: zval *tmp; 2730: 2731: ALLOC_ZVAL(tmp); 2732: INIT_PZVAL_COPY(tmp, array_ptr); 2733: array_ptr = tmp; 2734: if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 2735: ce = Z_OBJCE_P(array_ptr); 2736: if (ce && ce->get_iterator) { 2737: Z_DELREF_P(array_ptr); 2738: } 2739: } 2740: } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 2741: ce = Z_OBJCE_P(array_ptr); 2742: if (!ce || !ce->get_iterator) { 2743: Z_ADDREF_P(array_ptr); 2744: } 2745: } else if (IS_CONST == IS_CONST || 2746: ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && 2747: !Z_ISREF_P(array_ptr) && 2748: Z_REFCOUNT_P(array_ptr) > 1)) { 2749: zval *tmp; 2750: 2751: ALLOC_ZVAL(tmp); 2752: INIT_PZVAL_COPY(tmp, array_ptr); 2753: zval_copy_ctor(tmp); 2754: array_ptr = tmp; 2755: } else { 2756: Z_ADDREF_P(array_ptr); 2757: } 2758: } 2759: 2760: if (ce && ce->get_iterator) { 2761: iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC); 2762: 2763: if (iter && EXPECTED(EG(exception) == NULL)) { 2764: array_ptr = zend_iterator_wrap(iter TSRMLS_CC); 2765: } else { 2766: 2767: if (!EG(exception)) { 2768: zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); 2769: } 2770: zend_throw_exception_internal(NULL TSRMLS_CC); 2771: HANDLE_EXCEPTION(); 2772: } 2773: } 2774: 2775: EX_T(opline->result.var).fe.ptr = array_ptr; 2776: 2777: if (iter) { 2778: iter->index = 0; 2779: if (iter->funcs->rewind) { 2780: iter->funcs->rewind(iter TSRMLS_CC); 2781: if (UNEXPECTED(EG(exception) != NULL)) { 2782: zval_ptr_dtor(&array_ptr); 2783: 2784: HANDLE_EXCEPTION(); 2785: } 2786: } 2787: is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; 2788: if (UNEXPECTED(EG(exception) != NULL)) { 2789: zval_ptr_dtor(&array_ptr); 2790: 2791: HANDLE_EXCEPTION(); 2792: } 2793: iter->index = -1; /* will be set to 0 before using next handler */ 2794: } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { 2795: zend_hash_internal_pointer_reset(fe_ht); 2796: if (ce) { 2797: zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); 2798: while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { 2799: char *str_key; 2800: uint str_key_len; 2801: ulong int_key; 2802: zend_uchar key_type; 2803: 2804: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); 2805: if (key_type != HASH_KEY_NON_EXISTANT && 2806: (key_type == HASH_KEY_IS_LONG || 2807: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { 2808: break; 2809: } 2810: zend_hash_move_forward(fe_ht); 2811: } 2812: } 2813: is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; 2814: zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); 2815: } else { 2816: zend_error(E_WARNING, "Invalid argument supplied for foreach()"); 2817: is_empty = 1; 2818: } 2819: 2820: if (is_empty) { 2821: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 2822: } else { 2823: CHECK_EXCEPTION(); 2824: ZEND_VM_NEXT_OPCODE(); 2825: } 2826: } 2827: 2828: static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2829: { 2830: #if 0 || (IS_CONST != IS_UNUSED) 2831: USE_OPLINE 2832: 2833: SAVE_OPLINE(); 2834: if (IS_CONST != IS_UNUSED) { 2835: 2836: zval *ptr = opline->op1.zv; 2837: 2838: if (Z_TYPE_P(ptr) == IS_LONG) { 2839: EG(exit_status) = Z_LVAL_P(ptr); 2840: } else { 2841: zend_print_variable(ptr); 2842: } 2843: 2844: } 2845: #endif 2846: zend_bailout(); 2847: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 2848: } 2849: 2850: static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2851: { 2852: USE_OPLINE 2853: 2854: zval *value; 2855: 2856: SAVE_OPLINE(); 2857: value = opline->op1.zv; 2858: 2859: if (i_zend_is_true(value)) { 2860: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 2861: if (!0) { 2862: zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); 2863: } 2864: 2865: #if DEBUG_ZEND>=2 2866: printf("Conditional jmp to %d\n", opline->op2.opline_num); 2867: #endif 2868: ZEND_VM_JMP(opline->op2.jmp_addr); 2869: } 2870: 2871: CHECK_EXCEPTION(); 2872: ZEND_VM_NEXT_OPCODE(); 2873: } 2874: 2875: static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2876: { 2877: USE_OPLINE 2878: 2879: zval *value, *ret; 2880: 2881: SAVE_OPLINE(); 2882: value = opline->op1.zv; 2883: 2884: if (i_zend_is_true(value)) { 2885: if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 2886: Z_ADDREF_P(value); 2887: EX_T(opline->result.var).var.ptr = value; 2888: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 2889: } else { 2890: ALLOC_ZVAL(ret); 2891: INIT_PZVAL_COPY(ret, value); 2892: EX_T(opline->result.var).var.ptr = ret; 2893: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 2894: if (!0) { 2895: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 2896: } 2897: } 2898: 2899: #if DEBUG_ZEND>=2 2900: printf("Conditional jmp to %d\n", opline->op2.opline_num); 2901: #endif 2902: ZEND_VM_JMP(opline->op2.jmp_addr); 2903: } 2904: 2905: CHECK_EXCEPTION(); 2906: ZEND_VM_NEXT_OPCODE(); 2907: } 2908: 2909: static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2910: { 2911: USE_OPLINE 2912: 2913: zval *value; 2914: 2915: SAVE_OPLINE(); 2916: value = opline->op1.zv; 2917: 2918: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 2919: if (!0) { 2920: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 2921: } 2922: 2923: CHECK_EXCEPTION(); 2924: ZEND_VM_NEXT_OPCODE(); 2925: } 2926: 2927: static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2928: { 2929: USE_OPLINE 2930: 2931: zval *value, *ret; 2932: 2933: SAVE_OPLINE(); 2934: value = opline->op1.zv; 2935: 2936: if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 2937: Z_ADDREF_P(value); 2938: EX_T(opline->result.var).var.ptr = value; 2939: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 2940: } else { 2941: ALLOC_ZVAL(ret); 2942: INIT_PZVAL_COPY(ret, value); 2943: EX_T(opline->result.var).var.ptr = ret; 2944: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 2945: if (!0) { 2946: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 2947: } 2948: } 2949: 2950: CHECK_EXCEPTION(); 2951: ZEND_VM_NEXT_OPCODE(); 2952: } 2953: 2954: static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2955: { 2956: USE_OPLINE 2957: 2958: 2959: SAVE_OPLINE(); 2960: fast_add_function(&EX_T(opline->result.var).tmp_var, 2961: opline->op1.zv, 2962: opline->op2.zv TSRMLS_CC); 2963: 2964: 2965: CHECK_EXCEPTION(); 2966: ZEND_VM_NEXT_OPCODE(); 2967: } 2968: 2969: static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2970: { 2971: USE_OPLINE 2972: 2973: 2974: SAVE_OPLINE(); 2975: fast_sub_function(&EX_T(opline->result.var).tmp_var, 2976: opline->op1.zv, 2977: opline->op2.zv TSRMLS_CC); 2978: 2979: 2980: CHECK_EXCEPTION(); 2981: ZEND_VM_NEXT_OPCODE(); 2982: } 2983: 2984: static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 2985: { 2986: USE_OPLINE 2987: 2988: 2989: SAVE_OPLINE(); 2990: fast_mul_function(&EX_T(opline->result.var).tmp_var, 2991: opline->op1.zv, 2992: opline->op2.zv TSRMLS_CC); 2993: 2994: 2995: CHECK_EXCEPTION(); 2996: ZEND_VM_NEXT_OPCODE(); 2997: } 2998: 2999: static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3000: { 3001: USE_OPLINE 3002: 3003: 3004: SAVE_OPLINE(); 3005: fast_div_function(&EX_T(opline->result.var).tmp_var, 3006: opline->op1.zv, 3007: opline->op2.zv TSRMLS_CC); 3008: 3009: 3010: CHECK_EXCEPTION(); 3011: ZEND_VM_NEXT_OPCODE(); 3012: } 3013: 3014: static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3015: { 3016: USE_OPLINE 3017: 3018: 3019: SAVE_OPLINE(); 3020: fast_mod_function(&EX_T(opline->result.var).tmp_var, 3021: opline->op1.zv, 3022: opline->op2.zv TSRMLS_CC); 3023: 3024: 3025: CHECK_EXCEPTION(); 3026: ZEND_VM_NEXT_OPCODE(); 3027: } 3028: 3029: static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3030: { 3031: USE_OPLINE 3032: 3033: 3034: SAVE_OPLINE(); 3035: shift_left_function(&EX_T(opline->result.var).tmp_var, 3036: opline->op1.zv, 3037: opline->op2.zv TSRMLS_CC); 3038: 3039: 3040: CHECK_EXCEPTION(); 3041: ZEND_VM_NEXT_OPCODE(); 3042: } 3043: 3044: static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3045: { 3046: USE_OPLINE 3047: 3048: 3049: SAVE_OPLINE(); 3050: shift_right_function(&EX_T(opline->result.var).tmp_var, 3051: opline->op1.zv, 3052: opline->op2.zv TSRMLS_CC); 3053: 3054: 3055: CHECK_EXCEPTION(); 3056: ZEND_VM_NEXT_OPCODE(); 3057: } 3058: 3059: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3060: { 3061: USE_OPLINE 3062: 3063: 3064: SAVE_OPLINE(); 3065: concat_function(&EX_T(opline->result.var).tmp_var, 3066: opline->op1.zv, 3067: opline->op2.zv TSRMLS_CC); 3068: 3069: 3070: CHECK_EXCEPTION(); 3071: ZEND_VM_NEXT_OPCODE(); 3072: } 3073: 3074: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3075: { 3076: USE_OPLINE 3077: 3078: 3079: SAVE_OPLINE(); 3080: is_identical_function(&EX_T(opline->result.var).tmp_var, 3081: opline->op1.zv, 3082: opline->op2.zv TSRMLS_CC); 3083: 3084: 3085: CHECK_EXCEPTION(); 3086: ZEND_VM_NEXT_OPCODE(); 3087: } 3088: 3089: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3090: { 3091: USE_OPLINE 3092: 3093: zval *result = &EX_T(opline->result.var).tmp_var; 3094: 3095: SAVE_OPLINE(); 3096: is_identical_function(result, 3097: opline->op1.zv, 3098: opline->op2.zv TSRMLS_CC); 3099: Z_LVAL_P(result) = !Z_LVAL_P(result); 3100: 3101: 3102: CHECK_EXCEPTION(); 3103: ZEND_VM_NEXT_OPCODE(); 3104: } 3105: 3106: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3107: { 3108: USE_OPLINE 3109: 3110: zval *result = &EX_T(opline->result.var).tmp_var; 3111: 3112: SAVE_OPLINE(); 3113: ZVAL_BOOL(result, fast_equal_function(result, 3114: opline->op1.zv, 3115: opline->op2.zv TSRMLS_CC)); 3116: 3117: 3118: CHECK_EXCEPTION(); 3119: ZEND_VM_NEXT_OPCODE(); 3120: } 3121: 3122: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3123: { 3124: USE_OPLINE 3125: 3126: zval *result = &EX_T(opline->result.var).tmp_var; 3127: 3128: SAVE_OPLINE(); 3129: ZVAL_BOOL(result, fast_not_equal_function(result, 3130: opline->op1.zv, 3131: opline->op2.zv TSRMLS_CC)); 3132: 3133: 3134: CHECK_EXCEPTION(); 3135: ZEND_VM_NEXT_OPCODE(); 3136: } 3137: 3138: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3139: { 3140: USE_OPLINE 3141: 3142: zval *result = &EX_T(opline->result.var).tmp_var; 3143: 3144: SAVE_OPLINE(); 3145: ZVAL_BOOL(result, fast_is_smaller_function(result, 3146: opline->op1.zv, 3147: opline->op2.zv TSRMLS_CC)); 3148: 3149: 3150: CHECK_EXCEPTION(); 3151: ZEND_VM_NEXT_OPCODE(); 3152: } 3153: 3154: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3155: { 3156: USE_OPLINE 3157: 3158: zval *result = &EX_T(opline->result.var).tmp_var; 3159: 3160: SAVE_OPLINE(); 3161: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 3162: opline->op1.zv, 3163: opline->op2.zv TSRMLS_CC)); 3164: 3165: 3166: CHECK_EXCEPTION(); 3167: ZEND_VM_NEXT_OPCODE(); 3168: } 3169: 3170: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3171: { 3172: USE_OPLINE 3173: 3174: 3175: SAVE_OPLINE(); 3176: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 3177: opline->op1.zv, 3178: opline->op2.zv TSRMLS_CC); 3179: 3180: 3181: CHECK_EXCEPTION(); 3182: ZEND_VM_NEXT_OPCODE(); 3183: } 3184: 3185: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3186: { 3187: USE_OPLINE 3188: 3189: 3190: SAVE_OPLINE(); 3191: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 3192: opline->op1.zv, 3193: opline->op2.zv TSRMLS_CC); 3194: 3195: 3196: CHECK_EXCEPTION(); 3197: ZEND_VM_NEXT_OPCODE(); 3198: } 3199: 3200: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3201: { 3202: USE_OPLINE 3203: 3204: 3205: SAVE_OPLINE(); 3206: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 3207: opline->op1.zv, 3208: opline->op2.zv TSRMLS_CC); 3209: 3210: 3211: CHECK_EXCEPTION(); 3212: ZEND_VM_NEXT_OPCODE(); 3213: } 3214: 3215: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3216: { 3217: USE_OPLINE 3218: 3219: 3220: SAVE_OPLINE(); 3221: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 3222: opline->op1.zv, 3223: opline->op2.zv TSRMLS_CC); 3224: 3225: 3226: CHECK_EXCEPTION(); 3227: ZEND_VM_NEXT_OPCODE(); 3228: } 3229: 3230: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) 3231: { 3232: USE_OPLINE 3233: zend_free_op free_op1; 3234: zval *varname; 3235: zval **retval; 3236: zval tmp_varname; 3237: HashTable *target_symbol_table; 3238: ulong hash_value; 3239: 3240: SAVE_OPLINE(); 3241: varname = opline->op1.zv; 3242: 3243: if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 3244: ZVAL_COPY_VALUE(&tmp_varname, varname); 3245: zval_copy_ctor(&tmp_varname); 3246: Z_SET_REFCOUNT(tmp_varname, 1); 3247: Z_UNSET_ISREF(tmp_varname); 3248: convert_to_string(&tmp_varname); 3249: varname = &tmp_varname; 3250: } 3251: 3252: if (IS_CONST != IS_UNUSED) { 3253: zend_class_entry *ce; 3254: 3255: if (IS_CONST == IS_CONST) { 3256: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 3257: ce = CACHED_PTR(opline->op2.literal->cache_slot); 3258: } else { 3259: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 3260: if (UNEXPECTED(ce == NULL)) { 3261: if (IS_CONST != IS_CONST && varname == &tmp_varname) { 3262: zval_dtor(&tmp_varname); 3263: } 3264: 3265: CHECK_EXCEPTION(); 3266: ZEND_VM_NEXT_OPCODE(); 3267: } 3268: CACHE_PTR(opline->op2.literal->cache_slot, ce); 3269: } 3270: } else { 3271: ce = EX_T(opline->op2.var).class_entry; 3272: } 3273: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 3274: 3275: } else { 3276: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 3277: /* 3278: if (!target_symbol_table) { 3279: CHECK_EXCEPTION(); 3280: ZEND_VM_NEXT_OPCODE(); 3281: } 3282: */ 3283: if (IS_CONST == IS_CONST) { 3284: hash_value = Z_HASH_P(varname); 3285: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 3286: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 3287: } else { 3288: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 3289: } 3290: 3291: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 3292: switch (type) { 3293: case BP_VAR_R: 3294: case BP_VAR_UNSET: 3295: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 3296: /* break missing intentionally */ 3297: case BP_VAR_IS: 3298: retval = &EG(uninitialized_zval_ptr); 3299: break; 3300: case BP_VAR_RW: 3301: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 3302: /* break missing intentionally */ 3303: case BP_VAR_W: 3304: Z_ADDREF_P(&EG(uninitialized_zval)); 3305: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 3306: break; 3307: EMPTY_SWITCH_DEFAULT_CASE() 3308: } 3309: } 3310: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 3311: case ZEND_FETCH_GLOBAL: 3312: if (IS_CONST != IS_TMP_VAR) { 3313: 3314: } 3315: break; 3316: case ZEND_FETCH_LOCAL: 3317: 3318: break; 3319: case ZEND_FETCH_STATIC: 3320: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 3321: break; 3322: case ZEND_FETCH_GLOBAL_LOCK: 3323: if (IS_CONST == IS_VAR && !free_op1.var) { 3324: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 3325: } 3326: break; 3327: } 3328: } 3329: 3330: 3331: if (IS_CONST != IS_CONST && varname == &tmp_varname) { 3332: zval_dtor(&tmp_varname); 3333: } 3334: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 3335: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 3336: } 3337: PZVAL_LOCK(*retval); 3338: switch (type) { 3339: case BP_VAR_R: 3340: case BP_VAR_IS: 3341: AI_SET_PTR(&EX_T(opline->result.var), *retval); 3342: break; 3343: case BP_VAR_UNSET: { 3344: zend_free_op free_res; 3345: 3346: PZVAL_UNLOCK(*retval, &free_res); 3347: if (retval != &EG(uninitialized_zval_ptr)) { 3348: SEPARATE_ZVAL_IF_NOT_REF(retval); 3349: } 3350: PZVAL_LOCK(*retval); 3351: FREE_OP_VAR_PTR(free_res); 3352: } 3353: /* break missing intentionally */ 3354: default: 3355: EX_T(opline->result.var).var.ptr_ptr = retval; 3356: break; 3357: } 3358: CHECK_EXCEPTION(); 3359: ZEND_VM_NEXT_OPCODE(); 3360: } 3361: 3362: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3363: { 3364: return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3365: } 3366: 3367: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3368: { 3369: return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3370: } 3371: 3372: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3373: { 3374: return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3375: } 3376: 3377: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3378: { 3379: USE_OPLINE 3380: 3381: return zend_fetch_var_address_helper_SPEC_CONST_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3382: } 3383: 3384: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3385: { 3386: return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3387: } 3388: 3389: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3390: { 3391: return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3392: } 3393: 3394: static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3395: { 3396: USE_OPLINE 3397: 3398: zval *container; 3399: 3400: SAVE_OPLINE(); 3401: container = opline->op1.zv; 3402: 3403: if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { 3404: PZVAL_LOCK(&EG(uninitialized_zval)); 3405: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 3406: } else { 3407: 3408: zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); 3409: 3410: PZVAL_LOCK(value); 3411: AI_SET_PTR(&EX_T(opline->result.var), value); 3412: 3413: } 3414: CHECK_EXCEPTION(); 3415: ZEND_VM_NEXT_OPCODE(); 3416: } 3417: 3418: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3419: { 3420: USE_OPLINE 3421: zval *function_name; 3422: zend_class_entry *ce; 3423: 3424: SAVE_OPLINE(); 3425: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 3426: 3427: if (IS_CONST == IS_CONST) { 3428: /* no function found. try a static method in class */ 3429: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 3430: ce = CACHED_PTR(opline->op1.literal->cache_slot); 3431: } else { 3432: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 3433: if (UNEXPECTED(EG(exception) != NULL)) { 3434: HANDLE_EXCEPTION(); 3435: } 3436: if (UNEXPECTED(ce == NULL)) { 3437: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 3438: } 3439: CACHE_PTR(opline->op1.literal->cache_slot, ce); 3440: } 3441: EX(called_scope) = ce; 3442: } else { 3443: ce = EX_T(opline->op1.var).class_entry; 3444: 3445: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 3446: EX(called_scope) = EG(called_scope); 3447: } else { 3448: EX(called_scope) = ce; 3449: } 3450: } 3451: 3452: if (IS_CONST == IS_CONST && 3453: IS_CONST == IS_CONST && 3454: CACHED_PTR(opline->op2.literal->cache_slot)) { 3455: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 3456: } else if (IS_CONST != IS_CONST && 3457: IS_CONST == IS_CONST && 3458: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 3459: /* do nothing */ 3460: } else if (IS_CONST != IS_UNUSED) { 3461: char *function_name_strval = NULL; 3462: int function_name_strlen = 0; 3463: 3464: 3465: if (IS_CONST == IS_CONST) { 3466: function_name_strval = Z_STRVAL_P(opline->op2.zv); 3467: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 3468: } else { 3469: function_name = opline->op2.zv; 3470: 3471: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 3472: zend_error_noreturn(E_ERROR, "Function name must be a string"); 3473: } else { 3474: function_name_strval = Z_STRVAL_P(function_name); 3475: function_name_strlen = Z_STRLEN_P(function_name); 3476: } 3477: } 3478: 3479: if (function_name_strval) { 3480: if (ce->get_static_method) { 3481: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 3482: } else { 3483: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 3484: } 3485: if (UNEXPECTED(EX(fbc) == NULL)) { 3486: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 3487: } 3488: if (IS_CONST == IS_CONST && 3489: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 3490: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 3491: if (IS_CONST == IS_CONST) { 3492: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 3493: } else { 3494: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 3495: } 3496: } 3497: } 3498: if (IS_CONST != IS_CONST) { 3499: 3500: } 3501: } else { 3502: if (UNEXPECTED(ce->constructor == NULL)) { 3503: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 3504: } 3505: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 3506: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 3507: } 3508: EX(fbc) = ce->constructor; 3509: } 3510: 3511: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 3512: EX(object) = NULL; 3513: } else { 3514: if (EG(This) && 3515: Z_OBJ_HT_P(EG(This))->get_class_entry && 3516: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 3517: /* We are calling method of the other (incompatible) class, 3518: but passing $this. This is done for compatibility with php-4. */ 3519: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 3520: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 3521: } else { 3522: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 3523: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 3524: } 3525: } 3526: if ((EX(object) = EG(This))) { 3527: Z_ADDREF_P(EX(object)); 3528: EX(called_scope) = Z_OBJCE_P(EX(object)); 3529: } 3530: } 3531: 3532: CHECK_EXCEPTION(); 3533: ZEND_VM_NEXT_OPCODE(); 3534: } 3535: 3536: static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3537: { 3538: USE_OPLINE 3539: 3540: 3541: SAVE_OPLINE(); 3542: if (IS_CONST==IS_VAR) { 3543: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 3544: } 3545: is_equal_function(&EX_T(opline->result.var).tmp_var, 3546: opline->op1.zv, 3547: opline->op2.zv TSRMLS_CC); 3548: 3549: CHECK_EXCEPTION(); 3550: ZEND_VM_NEXT_OPCODE(); 3551: } 3552: 3553: static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3554: { 3555: USE_OPLINE 3556: 3557: SAVE_OPLINE(); 3558: if (IS_CONST == IS_UNUSED) { 3559: zend_constant *c; 3560: zval *retval; 3561: 3562: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 3563: c = CACHED_PTR(opline->op2.literal->cache_slot); 3564: } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) { 3565: if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { 3566: char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); 3567: if(!actual) { 3568: actual = Z_STRVAL_P(opline->op2.zv); 3569: } else { 3570: actual++; 3571: } 3572: /* non-qualified constant - allow text substitution */ 3573: zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); 3574: ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1); 3575: CHECK_EXCEPTION(); 3576: ZEND_VM_NEXT_OPCODE(); 3577: } else { 3578: zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); 3579: } 3580: } else { 3581: CACHE_PTR(opline->op2.literal->cache_slot, c); 3582: } 3583: retval = &EX_T(opline->result.var).tmp_var; 3584: ZVAL_COPY_VALUE(retval, &c->value); 3585: zval_copy_ctor(retval); 3586: CHECK_EXCEPTION(); 3587: ZEND_VM_NEXT_OPCODE(); 3588: } else { 3589: /* class constant */ 3590: zend_class_entry *ce; 3591: zval **value; 3592: 3593: if (IS_CONST == IS_CONST) { 3594: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 3595: value = CACHED_PTR(opline->op2.literal->cache_slot); 3596: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 3597: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 3598: CHECK_EXCEPTION(); 3599: ZEND_VM_NEXT_OPCODE(); 3600: } else if (CACHED_PTR(opline->op1.literal->cache_slot)) { 3601: ce = CACHED_PTR(opline->op1.literal->cache_slot); 3602: } else { 3603: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 3604: if (UNEXPECTED(EG(exception) != NULL)) { 3605: HANDLE_EXCEPTION(); 3606: } 3607: if (UNEXPECTED(ce == NULL)) { 3608: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 3609: } 3610: CACHE_PTR(opline->op1.literal->cache_slot, ce); 3611: } 3612: } else { 3613: ce = EX_T(opline->op1.var).class_entry; 3614: if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) { 3615: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 3616: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 3617: CHECK_EXCEPTION(); 3618: ZEND_VM_NEXT_OPCODE(); 3619: } 3620: } 3621: 3622: if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) { 3623: if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY || 3624: (Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) { 3625: zend_class_entry *old_scope = EG(scope); 3626: 3627: EG(scope) = ce; 3628: zval_update_constant(value, (void *) 1 TSRMLS_CC); 3629: EG(scope) = old_scope; 3630: } 3631: if (IS_CONST == IS_CONST) { 3632: CACHE_PTR(opline->op2.literal->cache_slot, value); 3633: } else { 3634: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value); 3635: } 3636: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 3637: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 3638: } else { 3639: zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); 3640: } 3641: 3642: CHECK_EXCEPTION(); 3643: ZEND_VM_NEXT_OPCODE(); 3644: } 3645: } 3646: 3647: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3648: { 3649: USE_OPLINE 3650: 3651: zval *expr_ptr; 3652: 3653: SAVE_OPLINE(); 3654: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 3655: zval **expr_ptr_ptr = NULL; 3656: 3657: if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 3658: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 3659: } 3660: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 3661: expr_ptr = *expr_ptr_ptr; 3662: Z_ADDREF_P(expr_ptr); 3663: } else { 3664: expr_ptr=opline->op1.zv; 3665: if (0) { /* temporary variable */ 3666: zval *new_expr; 3667: 3668: ALLOC_ZVAL(new_expr); 3669: INIT_PZVAL_COPY(new_expr, expr_ptr); 3670: expr_ptr = new_expr; 3671: } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 3672: zval *new_expr; 3673: 3674: ALLOC_ZVAL(new_expr); 3675: INIT_PZVAL_COPY(new_expr, expr_ptr); 3676: expr_ptr = new_expr; 3677: zendi_zval_copy_ctor(*expr_ptr); 3678: } else { 3679: Z_ADDREF_P(expr_ptr); 3680: } 3681: } 3682: 3683: if (IS_CONST != IS_UNUSED) { 3684: 3685: zval *offset = opline->op2.zv; 3686: ulong hval; 3687: 3688: switch (Z_TYPE_P(offset)) { 3689: case IS_DOUBLE: 3690: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 3691: goto num_index; 3692: case IS_LONG: 3693: case IS_BOOL: 3694: hval = Z_LVAL_P(offset); 3695: num_index: 3696: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 3697: break; 3698: case IS_STRING: 3699: if (IS_CONST == IS_CONST) { 3700: hval = Z_HASH_P(offset); 3701: } else { 3702: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 3703: if (IS_INTERNED(Z_STRVAL_P(offset))) { 3704: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 3705: } else { 3706: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 3707: } 3708: } 3709: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 3710: break; 3711: case IS_NULL: 3712: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 3713: break; 3714: default: 3715: zend_error(E_WARNING, "Illegal offset type"); 3716: zval_ptr_dtor(&expr_ptr); 3717: /* do nothing */ 3718: break; 3719: } 3720: 3721: } else { 3722: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 3723: } 3724: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 3725: 3726: } else { 3727: 3728: } 3729: CHECK_EXCEPTION(); 3730: ZEND_VM_NEXT_OPCODE(); 3731: } 3732: 3733: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3734: { 3735: USE_OPLINE 3736: 3737: array_init(&EX_T(opline->result.var).tmp_var); 3738: if (IS_CONST == IS_UNUSED) { 3739: ZEND_VM_NEXT_OPCODE(); 3740: #if 0 || IS_CONST != IS_UNUSED 3741: } else { 3742: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 3743: #endif 3744: } 3745: } 3746: 3747: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3748: { 3749: USE_OPLINE 3750: zval tmp, *varname; 3751: HashTable *target_symbol_table; 3752: 3753: 3754: SAVE_OPLINE(); 3755: if (IS_CONST == IS_CV && 3756: IS_CONST == IS_UNUSED && 3757: (opline->extended_value & ZEND_QUICK_SET)) { 3758: if (EG(active_symbol_table)) { 3759: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 3760: 3761: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 3762: EX_CV(opline->op1.var) = NULL; 3763: } else if (EX_CV(opline->op1.var)) { 3764: zval_ptr_dtor(EX_CV(opline->op1.var)); 3765: EX_CV(opline->op1.var) = NULL; 3766: } 3767: CHECK_EXCEPTION(); 3768: ZEND_VM_NEXT_OPCODE(); 3769: } 3770: 3771: varname = opline->op1.zv; 3772: 3773: if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 3774: ZVAL_COPY_VALUE(&tmp, varname); 3775: zval_copy_ctor(&tmp); 3776: convert_to_string(&tmp); 3777: varname = &tmp; 3778: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 3779: Z_ADDREF_P(varname); 3780: } 3781: 3782: if (IS_CONST != IS_UNUSED) { 3783: zend_class_entry *ce; 3784: 3785: if (IS_CONST == IS_CONST) { 3786: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 3787: ce = CACHED_PTR(opline->op2.literal->cache_slot); 3788: } else { 3789: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 3790: if (UNEXPECTED(EG(exception) != NULL)) { 3791: if (IS_CONST != IS_CONST && varname == &tmp) { 3792: zval_dtor(&tmp); 3793: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 3794: zval_ptr_dtor(&varname); 3795: } 3796: 3797: HANDLE_EXCEPTION(); 3798: } 3799: if (UNEXPECTED(ce == NULL)) { 3800: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 3801: } 3802: CACHE_PTR(opline->op2.literal->cache_slot, ce); 3803: } 3804: } else { 3805: ce = EX_T(opline->op2.var).class_entry; 3806: } 3807: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 3808: } else { 3809: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 3810: 3811: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 3812: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 3813: } 3814: 3815: if (IS_CONST != IS_CONST && varname == &tmp) { 3816: zval_dtor(&tmp); 3817: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 3818: zval_ptr_dtor(&varname); 3819: } 3820: 3821: CHECK_EXCEPTION(); 3822: ZEND_VM_NEXT_OPCODE(); 3823: } 3824: 3825: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3826: { 3827: USE_OPLINE 3828: zval **value; 3829: zend_bool isset = 1; 3830: 3831: SAVE_OPLINE(); 3832: if (IS_CONST == IS_CV && 3833: IS_CONST == IS_UNUSED && 3834: (opline->extended_value & ZEND_QUICK_SET)) { 3835: if (EX_CV(opline->op1.var)) { 3836: value = EX_CV(opline->op1.var); 3837: } else if (EG(active_symbol_table)) { 3838: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 3839: 3840: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 3841: isset = 0; 3842: } 3843: } else { 3844: isset = 0; 3845: } 3846: } else { 3847: HashTable *target_symbol_table; 3848: 3849: zval tmp, *varname = opline->op1.zv; 3850: 3851: if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 3852: ZVAL_COPY_VALUE(&tmp, varname); 3853: zval_copy_ctor(&tmp); 3854: convert_to_string(&tmp); 3855: varname = &tmp; 3856: } 3857: 3858: if (IS_CONST != IS_UNUSED) { 3859: zend_class_entry *ce; 3860: 3861: if (IS_CONST == IS_CONST) { 3862: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 3863: ce = CACHED_PTR(opline->op2.literal->cache_slot); 3864: } else { 3865: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 3866: if (UNEXPECTED(ce == NULL)) { 3867: CHECK_EXCEPTION(); 3868: ZEND_VM_NEXT_OPCODE(); 3869: } 3870: CACHE_PTR(opline->op2.literal->cache_slot, ce); 3871: } 3872: } else { 3873: ce = EX_T(opline->op2.var).class_entry; 3874: } 3875: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 3876: if (!value) { 3877: isset = 0; 3878: } 3879: } else { 3880: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 3881: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 3882: isset = 0; 3883: } 3884: } 3885: 3886: if (IS_CONST != IS_CONST && varname == &tmp) { 3887: zval_dtor(&tmp); 3888: } 3889: 3890: } 3891: 3892: if (opline->extended_value & ZEND_ISSET) { 3893: if (isset && Z_TYPE_PP(value) != IS_NULL) { 3894: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 3895: } else { 3896: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 3897: } 3898: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 3899: if (!isset || !i_zend_is_true(*value)) { 3900: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 3901: } else { 3902: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 3903: } 3904: } 3905: 3906: CHECK_EXCEPTION(); 3907: ZEND_VM_NEXT_OPCODE(); 3908: } 3909: 3910: static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3911: { 3912: USE_OPLINE 3913: 3914: zval *name; 3915: zval *val; 3916: zend_constant c; 3917: 3918: SAVE_OPLINE(); 3919: name = opline->op1.zv; 3920: val = opline->op2.zv; 3921: 3922: if ((Z_TYPE_P(val) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT || Z_TYPE_P(val) == IS_CONSTANT_ARRAY) { 3923: zval tmp; 3924: zval *tmp_ptr = &tmp; 3925: 3926: ZVAL_COPY_VALUE(&tmp, val); 3927: if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) { 3928: zval_copy_ctor(&tmp); 3929: } 3930: INIT_PZVAL(&tmp); 3931: zval_update_constant(&tmp_ptr, NULL TSRMLS_CC); 3932: c.value = *tmp_ptr; 3933: } else { 3934: INIT_PZVAL_COPY(&c.value, val); 3935: zval_copy_ctor(&c.value); 3936: } 3937: c.flags = CONST_CS; /* non persistent, case sensetive */ 3938: c.name = IS_INTERNED(Z_STRVAL_P(name)) ? Z_STRVAL_P(name) : zend_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name)); 3939: c.name_len = Z_STRLEN_P(name)+1; 3940: c.module_number = PHP_USER_CONSTANT; 3941: 3942: if (zend_register_constant(&c TSRMLS_CC) == FAILURE) { 3943: } 3944: 3945: 3946: CHECK_EXCEPTION(); 3947: ZEND_VM_NEXT_OPCODE(); 3948: } 3949: 3950: static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3951: { 3952: USE_OPLINE 3953: zend_free_op free_op2; 3954: 3955: SAVE_OPLINE(); 3956: fast_add_function(&EX_T(opline->result.var).tmp_var, 3957: opline->op1.zv, 3958: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 3959: 3960: zval_dtor(free_op2.var); 3961: CHECK_EXCEPTION(); 3962: ZEND_VM_NEXT_OPCODE(); 3963: } 3964: 3965: static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3966: { 3967: USE_OPLINE 3968: zend_free_op free_op2; 3969: 3970: SAVE_OPLINE(); 3971: fast_sub_function(&EX_T(opline->result.var).tmp_var, 3972: opline->op1.zv, 3973: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 3974: 3975: zval_dtor(free_op2.var); 3976: CHECK_EXCEPTION(); 3977: ZEND_VM_NEXT_OPCODE(); 3978: } 3979: 3980: static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3981: { 3982: USE_OPLINE 3983: zend_free_op free_op2; 3984: 3985: SAVE_OPLINE(); 3986: fast_mul_function(&EX_T(opline->result.var).tmp_var, 3987: opline->op1.zv, 3988: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 3989: 3990: zval_dtor(free_op2.var); 3991: CHECK_EXCEPTION(); 3992: ZEND_VM_NEXT_OPCODE(); 3993: } 3994: 3995: static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 3996: { 3997: USE_OPLINE 3998: zend_free_op free_op2; 3999: 4000: SAVE_OPLINE(); 4001: fast_div_function(&EX_T(opline->result.var).tmp_var, 4002: opline->op1.zv, 4003: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4004: 4005: zval_dtor(free_op2.var); 4006: CHECK_EXCEPTION(); 4007: ZEND_VM_NEXT_OPCODE(); 4008: } 4009: 4010: static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4011: { 4012: USE_OPLINE 4013: zend_free_op free_op2; 4014: 4015: SAVE_OPLINE(); 4016: fast_mod_function(&EX_T(opline->result.var).tmp_var, 4017: opline->op1.zv, 4018: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4019: 4020: zval_dtor(free_op2.var); 4021: CHECK_EXCEPTION(); 4022: ZEND_VM_NEXT_OPCODE(); 4023: } 4024: 4025: static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4026: { 4027: USE_OPLINE 4028: zend_free_op free_op2; 4029: 4030: SAVE_OPLINE(); 4031: shift_left_function(&EX_T(opline->result.var).tmp_var, 4032: opline->op1.zv, 4033: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4034: 4035: zval_dtor(free_op2.var); 4036: CHECK_EXCEPTION(); 4037: ZEND_VM_NEXT_OPCODE(); 4038: } 4039: 4040: static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4041: { 4042: USE_OPLINE 4043: zend_free_op free_op2; 4044: 4045: SAVE_OPLINE(); 4046: shift_right_function(&EX_T(opline->result.var).tmp_var, 4047: opline->op1.zv, 4048: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4049: 4050: zval_dtor(free_op2.var); 4051: CHECK_EXCEPTION(); 4052: ZEND_VM_NEXT_OPCODE(); 4053: } 4054: 4055: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4056: { 4057: USE_OPLINE 4058: zend_free_op free_op2; 4059: 4060: SAVE_OPLINE(); 4061: concat_function(&EX_T(opline->result.var).tmp_var, 4062: opline->op1.zv, 4063: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4064: 4065: zval_dtor(free_op2.var); 4066: CHECK_EXCEPTION(); 4067: ZEND_VM_NEXT_OPCODE(); 4068: } 4069: 4070: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4071: { 4072: USE_OPLINE 4073: zend_free_op free_op2; 4074: 4075: SAVE_OPLINE(); 4076: is_identical_function(&EX_T(opline->result.var).tmp_var, 4077: opline->op1.zv, 4078: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4079: 4080: zval_dtor(free_op2.var); 4081: CHECK_EXCEPTION(); 4082: ZEND_VM_NEXT_OPCODE(); 4083: } 4084: 4085: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4086: { 4087: USE_OPLINE 4088: zend_free_op free_op2; 4089: zval *result = &EX_T(opline->result.var).tmp_var; 4090: 4091: SAVE_OPLINE(); 4092: is_identical_function(result, 4093: opline->op1.zv, 4094: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4095: Z_LVAL_P(result) = !Z_LVAL_P(result); 4096: 4097: zval_dtor(free_op2.var); 4098: CHECK_EXCEPTION(); 4099: ZEND_VM_NEXT_OPCODE(); 4100: } 4101: 4102: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4103: { 4104: USE_OPLINE 4105: zend_free_op free_op2; 4106: zval *result = &EX_T(opline->result.var).tmp_var; 4107: 4108: SAVE_OPLINE(); 4109: ZVAL_BOOL(result, fast_equal_function(result, 4110: opline->op1.zv, 4111: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4112: 4113: zval_dtor(free_op2.var); 4114: CHECK_EXCEPTION(); 4115: ZEND_VM_NEXT_OPCODE(); 4116: } 4117: 4118: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4119: { 4120: USE_OPLINE 4121: zend_free_op free_op2; 4122: zval *result = &EX_T(opline->result.var).tmp_var; 4123: 4124: SAVE_OPLINE(); 4125: ZVAL_BOOL(result, fast_not_equal_function(result, 4126: opline->op1.zv, 4127: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4128: 4129: zval_dtor(free_op2.var); 4130: CHECK_EXCEPTION(); 4131: ZEND_VM_NEXT_OPCODE(); 4132: } 4133: 4134: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4135: { 4136: USE_OPLINE 4137: zend_free_op free_op2; 4138: zval *result = &EX_T(opline->result.var).tmp_var; 4139: 4140: SAVE_OPLINE(); 4141: ZVAL_BOOL(result, fast_is_smaller_function(result, 4142: opline->op1.zv, 4143: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4144: 4145: zval_dtor(free_op2.var); 4146: CHECK_EXCEPTION(); 4147: ZEND_VM_NEXT_OPCODE(); 4148: } 4149: 4150: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4151: { 4152: USE_OPLINE 4153: zend_free_op free_op2; 4154: zval *result = &EX_T(opline->result.var).tmp_var; 4155: 4156: SAVE_OPLINE(); 4157: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 4158: opline->op1.zv, 4159: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4160: 4161: zval_dtor(free_op2.var); 4162: CHECK_EXCEPTION(); 4163: ZEND_VM_NEXT_OPCODE(); 4164: } 4165: 4166: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4167: { 4168: USE_OPLINE 4169: zend_free_op free_op2; 4170: 4171: SAVE_OPLINE(); 4172: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 4173: opline->op1.zv, 4174: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4175: 4176: zval_dtor(free_op2.var); 4177: CHECK_EXCEPTION(); 4178: ZEND_VM_NEXT_OPCODE(); 4179: } 4180: 4181: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4182: { 4183: USE_OPLINE 4184: zend_free_op free_op2; 4185: 4186: SAVE_OPLINE(); 4187: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 4188: opline->op1.zv, 4189: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4190: 4191: zval_dtor(free_op2.var); 4192: CHECK_EXCEPTION(); 4193: ZEND_VM_NEXT_OPCODE(); 4194: } 4195: 4196: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4197: { 4198: USE_OPLINE 4199: zend_free_op free_op2; 4200: 4201: SAVE_OPLINE(); 4202: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 4203: opline->op1.zv, 4204: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4205: 4206: zval_dtor(free_op2.var); 4207: CHECK_EXCEPTION(); 4208: ZEND_VM_NEXT_OPCODE(); 4209: } 4210: 4211: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4212: { 4213: USE_OPLINE 4214: zend_free_op free_op2; 4215: 4216: SAVE_OPLINE(); 4217: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 4218: opline->op1.zv, 4219: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4220: 4221: zval_dtor(free_op2.var); 4222: CHECK_EXCEPTION(); 4223: ZEND_VM_NEXT_OPCODE(); 4224: } 4225: 4226: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4227: { 4228: USE_OPLINE 4229: zval *function_name; 4230: zend_class_entry *ce; 4231: 4232: SAVE_OPLINE(); 4233: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 4234: 4235: if (IS_CONST == IS_CONST) { 4236: /* no function found. try a static method in class */ 4237: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 4238: ce = CACHED_PTR(opline->op1.literal->cache_slot); 4239: } else { 4240: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 4241: if (UNEXPECTED(EG(exception) != NULL)) { 4242: HANDLE_EXCEPTION(); 4243: } 4244: if (UNEXPECTED(ce == NULL)) { 4245: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 4246: } 4247: CACHE_PTR(opline->op1.literal->cache_slot, ce); 4248: } 4249: EX(called_scope) = ce; 4250: } else { 4251: ce = EX_T(opline->op1.var).class_entry; 4252: 4253: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 4254: EX(called_scope) = EG(called_scope); 4255: } else { 4256: EX(called_scope) = ce; 4257: } 4258: } 4259: 4260: if (IS_CONST == IS_CONST && 4261: IS_TMP_VAR == IS_CONST && 4262: CACHED_PTR(opline->op2.literal->cache_slot)) { 4263: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 4264: } else if (IS_CONST != IS_CONST && 4265: IS_TMP_VAR == IS_CONST && 4266: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 4267: /* do nothing */ 4268: } else if (IS_TMP_VAR != IS_UNUSED) { 4269: char *function_name_strval = NULL; 4270: int function_name_strlen = 0; 4271: zend_free_op free_op2; 4272: 4273: if (IS_TMP_VAR == IS_CONST) { 4274: function_name_strval = Z_STRVAL_P(opline->op2.zv); 4275: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 4276: } else { 4277: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 4278: 4279: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 4280: zend_error_noreturn(E_ERROR, "Function name must be a string"); 4281: } else { 4282: function_name_strval = Z_STRVAL_P(function_name); 4283: function_name_strlen = Z_STRLEN_P(function_name); 4284: } 4285: } 4286: 4287: if (function_name_strval) { 4288: if (ce->get_static_method) { 4289: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 4290: } else { 4291: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 4292: } 4293: if (UNEXPECTED(EX(fbc) == NULL)) { 4294: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 4295: } 4296: if (IS_TMP_VAR == IS_CONST && 4297: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 4298: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 4299: if (IS_CONST == IS_CONST) { 4300: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 4301: } else { 4302: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 4303: } 4304: } 4305: } 4306: if (IS_TMP_VAR != IS_CONST) { 4307: zval_dtor(free_op2.var); 4308: } 4309: } else { 4310: if (UNEXPECTED(ce->constructor == NULL)) { 4311: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 4312: } 4313: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 4314: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 4315: } 4316: EX(fbc) = ce->constructor; 4317: } 4318: 4319: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 4320: EX(object) = NULL; 4321: } else { 4322: if (EG(This) && 4323: Z_OBJ_HT_P(EG(This))->get_class_entry && 4324: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 4325: /* We are calling method of the other (incompatible) class, 4326: but passing $this. This is done for compatibility with php-4. */ 4327: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 4328: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 4329: } else { 4330: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 4331: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 4332: } 4333: } 4334: if ((EX(object) = EG(This))) { 4335: Z_ADDREF_P(EX(object)); 4336: EX(called_scope) = Z_OBJCE_P(EX(object)); 4337: } 4338: } 4339: 4340: CHECK_EXCEPTION(); 4341: ZEND_VM_NEXT_OPCODE(); 4342: } 4343: 4344: static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4345: { 4346: USE_OPLINE 4347: zend_free_op free_op2; 4348: 4349: SAVE_OPLINE(); 4350: if (IS_CONST==IS_VAR) { 4351: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 4352: } 4353: is_equal_function(&EX_T(opline->result.var).tmp_var, 4354: opline->op1.zv, 4355: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4356: 4357: zval_dtor(free_op2.var); 4358: CHECK_EXCEPTION(); 4359: ZEND_VM_NEXT_OPCODE(); 4360: } 4361: 4362: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4363: { 4364: USE_OPLINE 4365: 4366: zval *expr_ptr; 4367: 4368: SAVE_OPLINE(); 4369: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 4370: zval **expr_ptr_ptr = NULL; 4371: 4372: if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 4373: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 4374: } 4375: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 4376: expr_ptr = *expr_ptr_ptr; 4377: Z_ADDREF_P(expr_ptr); 4378: } else { 4379: expr_ptr=opline->op1.zv; 4380: if (0) { /* temporary variable */ 4381: zval *new_expr; 4382: 4383: ALLOC_ZVAL(new_expr); 4384: INIT_PZVAL_COPY(new_expr, expr_ptr); 4385: expr_ptr = new_expr; 4386: } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 4387: zval *new_expr; 4388: 4389: ALLOC_ZVAL(new_expr); 4390: INIT_PZVAL_COPY(new_expr, expr_ptr); 4391: expr_ptr = new_expr; 4392: zendi_zval_copy_ctor(*expr_ptr); 4393: } else { 4394: Z_ADDREF_P(expr_ptr); 4395: } 4396: } 4397: 4398: if (IS_TMP_VAR != IS_UNUSED) { 4399: zend_free_op free_op2; 4400: zval *offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 4401: ulong hval; 4402: 4403: switch (Z_TYPE_P(offset)) { 4404: case IS_DOUBLE: 4405: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 4406: goto num_index; 4407: case IS_LONG: 4408: case IS_BOOL: 4409: hval = Z_LVAL_P(offset); 4410: num_index: 4411: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 4412: break; 4413: case IS_STRING: 4414: if (IS_TMP_VAR == IS_CONST) { 4415: hval = Z_HASH_P(offset); 4416: } else { 4417: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 4418: if (IS_INTERNED(Z_STRVAL_P(offset))) { 4419: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 4420: } else { 4421: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 4422: } 4423: } 4424: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 4425: break; 4426: case IS_NULL: 4427: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 4428: break; 4429: default: 4430: zend_error(E_WARNING, "Illegal offset type"); 4431: zval_ptr_dtor(&expr_ptr); 4432: /* do nothing */ 4433: break; 4434: } 4435: zval_dtor(free_op2.var); 4436: } else { 4437: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 4438: } 4439: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 4440: 4441: } else { 4442: 4443: } 4444: CHECK_EXCEPTION(); 4445: ZEND_VM_NEXT_OPCODE(); 4446: } 4447: 4448: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4449: { 4450: USE_OPLINE 4451: 4452: array_init(&EX_T(opline->result.var).tmp_var); 4453: if (IS_CONST == IS_UNUSED) { 4454: ZEND_VM_NEXT_OPCODE(); 4455: #if 0 || IS_CONST != IS_UNUSED 4456: } else { 4457: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4458: #endif 4459: } 4460: } 4461: 4462: static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4463: { 4464: USE_OPLINE 4465: zend_free_op free_op2; 4466: 4467: SAVE_OPLINE(); 4468: fast_add_function(&EX_T(opline->result.var).tmp_var, 4469: opline->op1.zv, 4470: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4471: 4472: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4473: CHECK_EXCEPTION(); 4474: ZEND_VM_NEXT_OPCODE(); 4475: } 4476: 4477: static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4478: { 4479: USE_OPLINE 4480: zend_free_op free_op2; 4481: 4482: SAVE_OPLINE(); 4483: fast_sub_function(&EX_T(opline->result.var).tmp_var, 4484: opline->op1.zv, 4485: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4486: 4487: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4488: CHECK_EXCEPTION(); 4489: ZEND_VM_NEXT_OPCODE(); 4490: } 4491: 4492: static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4493: { 4494: USE_OPLINE 4495: zend_free_op free_op2; 4496: 4497: SAVE_OPLINE(); 4498: fast_mul_function(&EX_T(opline->result.var).tmp_var, 4499: opline->op1.zv, 4500: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4501: 4502: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4503: CHECK_EXCEPTION(); 4504: ZEND_VM_NEXT_OPCODE(); 4505: } 4506: 4507: static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4508: { 4509: USE_OPLINE 4510: zend_free_op free_op2; 4511: 4512: SAVE_OPLINE(); 4513: fast_div_function(&EX_T(opline->result.var).tmp_var, 4514: opline->op1.zv, 4515: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4516: 4517: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4518: CHECK_EXCEPTION(); 4519: ZEND_VM_NEXT_OPCODE(); 4520: } 4521: 4522: static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4523: { 4524: USE_OPLINE 4525: zend_free_op free_op2; 4526: 4527: SAVE_OPLINE(); 4528: fast_mod_function(&EX_T(opline->result.var).tmp_var, 4529: opline->op1.zv, 4530: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4531: 4532: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4533: CHECK_EXCEPTION(); 4534: ZEND_VM_NEXT_OPCODE(); 4535: } 4536: 4537: static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4538: { 4539: USE_OPLINE 4540: zend_free_op free_op2; 4541: 4542: SAVE_OPLINE(); 4543: shift_left_function(&EX_T(opline->result.var).tmp_var, 4544: opline->op1.zv, 4545: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4546: 4547: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4548: CHECK_EXCEPTION(); 4549: ZEND_VM_NEXT_OPCODE(); 4550: } 4551: 4552: static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4553: { 4554: USE_OPLINE 4555: zend_free_op free_op2; 4556: 4557: SAVE_OPLINE(); 4558: shift_right_function(&EX_T(opline->result.var).tmp_var, 4559: opline->op1.zv, 4560: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4561: 4562: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4563: CHECK_EXCEPTION(); 4564: ZEND_VM_NEXT_OPCODE(); 4565: } 4566: 4567: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4568: { 4569: USE_OPLINE 4570: zend_free_op free_op2; 4571: 4572: SAVE_OPLINE(); 4573: concat_function(&EX_T(opline->result.var).tmp_var, 4574: opline->op1.zv, 4575: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4576: 4577: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4578: CHECK_EXCEPTION(); 4579: ZEND_VM_NEXT_OPCODE(); 4580: } 4581: 4582: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4583: { 4584: USE_OPLINE 4585: zend_free_op free_op2; 4586: 4587: SAVE_OPLINE(); 4588: is_identical_function(&EX_T(opline->result.var).tmp_var, 4589: opline->op1.zv, 4590: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4591: 4592: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4593: CHECK_EXCEPTION(); 4594: ZEND_VM_NEXT_OPCODE(); 4595: } 4596: 4597: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4598: { 4599: USE_OPLINE 4600: zend_free_op free_op2; 4601: zval *result = &EX_T(opline->result.var).tmp_var; 4602: 4603: SAVE_OPLINE(); 4604: is_identical_function(result, 4605: opline->op1.zv, 4606: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4607: Z_LVAL_P(result) = !Z_LVAL_P(result); 4608: 4609: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4610: CHECK_EXCEPTION(); 4611: ZEND_VM_NEXT_OPCODE(); 4612: } 4613: 4614: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4615: { 4616: USE_OPLINE 4617: zend_free_op free_op2; 4618: zval *result = &EX_T(opline->result.var).tmp_var; 4619: 4620: SAVE_OPLINE(); 4621: ZVAL_BOOL(result, fast_equal_function(result, 4622: opline->op1.zv, 4623: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4624: 4625: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4626: CHECK_EXCEPTION(); 4627: ZEND_VM_NEXT_OPCODE(); 4628: } 4629: 4630: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4631: { 4632: USE_OPLINE 4633: zend_free_op free_op2; 4634: zval *result = &EX_T(opline->result.var).tmp_var; 4635: 4636: SAVE_OPLINE(); 4637: ZVAL_BOOL(result, fast_not_equal_function(result, 4638: opline->op1.zv, 4639: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4640: 4641: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4642: CHECK_EXCEPTION(); 4643: ZEND_VM_NEXT_OPCODE(); 4644: } 4645: 4646: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4647: { 4648: USE_OPLINE 4649: zend_free_op free_op2; 4650: zval *result = &EX_T(opline->result.var).tmp_var; 4651: 4652: SAVE_OPLINE(); 4653: ZVAL_BOOL(result, fast_is_smaller_function(result, 4654: opline->op1.zv, 4655: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4656: 4657: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4658: CHECK_EXCEPTION(); 4659: ZEND_VM_NEXT_OPCODE(); 4660: } 4661: 4662: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4663: { 4664: USE_OPLINE 4665: zend_free_op free_op2; 4666: zval *result = &EX_T(opline->result.var).tmp_var; 4667: 4668: SAVE_OPLINE(); 4669: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 4670: opline->op1.zv, 4671: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 4672: 4673: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4674: CHECK_EXCEPTION(); 4675: ZEND_VM_NEXT_OPCODE(); 4676: } 4677: 4678: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4679: { 4680: USE_OPLINE 4681: zend_free_op free_op2; 4682: 4683: SAVE_OPLINE(); 4684: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 4685: opline->op1.zv, 4686: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4687: 4688: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4689: CHECK_EXCEPTION(); 4690: ZEND_VM_NEXT_OPCODE(); 4691: } 4692: 4693: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4694: { 4695: USE_OPLINE 4696: zend_free_op free_op2; 4697: 4698: SAVE_OPLINE(); 4699: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 4700: opline->op1.zv, 4701: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4702: 4703: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4704: CHECK_EXCEPTION(); 4705: ZEND_VM_NEXT_OPCODE(); 4706: } 4707: 4708: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4709: { 4710: USE_OPLINE 4711: zend_free_op free_op2; 4712: 4713: SAVE_OPLINE(); 4714: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 4715: opline->op1.zv, 4716: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4717: 4718: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4719: CHECK_EXCEPTION(); 4720: ZEND_VM_NEXT_OPCODE(); 4721: } 4722: 4723: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4724: { 4725: USE_OPLINE 4726: zend_free_op free_op2; 4727: 4728: SAVE_OPLINE(); 4729: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 4730: opline->op1.zv, 4731: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 4732: 4733: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4734: CHECK_EXCEPTION(); 4735: ZEND_VM_NEXT_OPCODE(); 4736: } 4737: 4738: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) 4739: { 4740: USE_OPLINE 4741: zend_free_op free_op1; 4742: zval *varname; 4743: zval **retval; 4744: zval tmp_varname; 4745: HashTable *target_symbol_table; 4746: ulong hash_value; 4747: 4748: SAVE_OPLINE(); 4749: varname = opline->op1.zv; 4750: 4751: if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 4752: ZVAL_COPY_VALUE(&tmp_varname, varname); 4753: zval_copy_ctor(&tmp_varname); 4754: Z_SET_REFCOUNT(tmp_varname, 1); 4755: Z_UNSET_ISREF(tmp_varname); 4756: convert_to_string(&tmp_varname); 4757: varname = &tmp_varname; 4758: } 4759: 4760: if (IS_VAR != IS_UNUSED) { 4761: zend_class_entry *ce; 4762: 4763: if (IS_VAR == IS_CONST) { 4764: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 4765: ce = CACHED_PTR(opline->op2.literal->cache_slot); 4766: } else { 4767: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 4768: if (UNEXPECTED(ce == NULL)) { 4769: if (IS_CONST != IS_CONST && varname == &tmp_varname) { 4770: zval_dtor(&tmp_varname); 4771: } 4772: 4773: CHECK_EXCEPTION(); 4774: ZEND_VM_NEXT_OPCODE(); 4775: } 4776: CACHE_PTR(opline->op2.literal->cache_slot, ce); 4777: } 4778: } else { 4779: ce = EX_T(opline->op2.var).class_entry; 4780: } 4781: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 4782: 4783: } else { 4784: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 4785: /* 4786: if (!target_symbol_table) { 4787: CHECK_EXCEPTION(); 4788: ZEND_VM_NEXT_OPCODE(); 4789: } 4790: */ 4791: if (IS_CONST == IS_CONST) { 4792: hash_value = Z_HASH_P(varname); 4793: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 4794: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 4795: } else { 4796: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 4797: } 4798: 4799: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 4800: switch (type) { 4801: case BP_VAR_R: 4802: case BP_VAR_UNSET: 4803: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 4804: /* break missing intentionally */ 4805: case BP_VAR_IS: 4806: retval = &EG(uninitialized_zval_ptr); 4807: break; 4808: case BP_VAR_RW: 4809: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 4810: /* break missing intentionally */ 4811: case BP_VAR_W: 4812: Z_ADDREF_P(&EG(uninitialized_zval)); 4813: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 4814: break; 4815: EMPTY_SWITCH_DEFAULT_CASE() 4816: } 4817: } 4818: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 4819: case ZEND_FETCH_GLOBAL: 4820: if (IS_CONST != IS_TMP_VAR) { 4821: 4822: } 4823: break; 4824: case ZEND_FETCH_LOCAL: 4825: 4826: break; 4827: case ZEND_FETCH_STATIC: 4828: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 4829: break; 4830: case ZEND_FETCH_GLOBAL_LOCK: 4831: if (IS_CONST == IS_VAR && !free_op1.var) { 4832: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 4833: } 4834: break; 4835: } 4836: } 4837: 4838: 4839: if (IS_CONST != IS_CONST && varname == &tmp_varname) { 4840: zval_dtor(&tmp_varname); 4841: } 4842: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 4843: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 4844: } 4845: PZVAL_LOCK(*retval); 4846: switch (type) { 4847: case BP_VAR_R: 4848: case BP_VAR_IS: 4849: AI_SET_PTR(&EX_T(opline->result.var), *retval); 4850: break; 4851: case BP_VAR_UNSET: { 4852: zend_free_op free_res; 4853: 4854: PZVAL_UNLOCK(*retval, &free_res); 4855: if (retval != &EG(uninitialized_zval_ptr)) { 4856: SEPARATE_ZVAL_IF_NOT_REF(retval); 4857: } 4858: PZVAL_LOCK(*retval); 4859: FREE_OP_VAR_PTR(free_res); 4860: } 4861: /* break missing intentionally */ 4862: default: 4863: EX_T(opline->result.var).var.ptr_ptr = retval; 4864: break; 4865: } 4866: CHECK_EXCEPTION(); 4867: ZEND_VM_NEXT_OPCODE(); 4868: } 4869: 4870: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4871: { 4872: return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4873: } 4874: 4875: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4876: { 4877: return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4878: } 4879: 4880: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4881: { 4882: return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4883: } 4884: 4885: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4886: { 4887: USE_OPLINE 4888: 4889: return zend_fetch_var_address_helper_SPEC_CONST_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4890: } 4891: 4892: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4893: { 4894: return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4895: } 4896: 4897: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4898: { 4899: return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 4900: } 4901: 4902: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 4903: { 4904: USE_OPLINE 4905: zval *function_name; 4906: zend_class_entry *ce; 4907: 4908: SAVE_OPLINE(); 4909: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 4910: 4911: if (IS_CONST == IS_CONST) { 4912: /* no function found. try a static method in class */ 4913: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 4914: ce = CACHED_PTR(opline->op1.literal->cache_slot); 4915: } else { 4916: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 4917: if (UNEXPECTED(EG(exception) != NULL)) { 4918: HANDLE_EXCEPTION(); 4919: } 4920: if (UNEXPECTED(ce == NULL)) { 4921: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 4922: } 4923: CACHE_PTR(opline->op1.literal->cache_slot, ce); 4924: } 4925: EX(called_scope) = ce; 4926: } else { 4927: ce = EX_T(opline->op1.var).class_entry; 4928: 4929: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 4930: EX(called_scope) = EG(called_scope); 4931: } else { 4932: EX(called_scope) = ce; 4933: } 4934: } 4935: 4936: if (IS_CONST == IS_CONST && 4937: IS_VAR == IS_CONST && 4938: CACHED_PTR(opline->op2.literal->cache_slot)) { 4939: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 4940: } else if (IS_CONST != IS_CONST && 4941: IS_VAR == IS_CONST && 4942: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 4943: /* do nothing */ 4944: } else if (IS_VAR != IS_UNUSED) { 4945: char *function_name_strval = NULL; 4946: int function_name_strlen = 0; 4947: zend_free_op free_op2; 4948: 4949: if (IS_VAR == IS_CONST) { 4950: function_name_strval = Z_STRVAL_P(opline->op2.zv); 4951: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 4952: } else { 4953: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 4954: 4955: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 4956: zend_error_noreturn(E_ERROR, "Function name must be a string"); 4957: } else { 4958: function_name_strval = Z_STRVAL_P(function_name); 4959: function_name_strlen = Z_STRLEN_P(function_name); 4960: } 4961: } 4962: 4963: if (function_name_strval) { 4964: if (ce->get_static_method) { 4965: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 4966: } else { 4967: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 4968: } 4969: if (UNEXPECTED(EX(fbc) == NULL)) { 4970: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 4971: } 4972: if (IS_VAR == IS_CONST && 4973: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 4974: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 4975: if (IS_CONST == IS_CONST) { 4976: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 4977: } else { 4978: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 4979: } 4980: } 4981: } 4982: if (IS_VAR != IS_CONST) { 4983: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 4984: } 4985: } else { 4986: if (UNEXPECTED(ce->constructor == NULL)) { 4987: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 4988: } 4989: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 4990: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 4991: } 4992: EX(fbc) = ce->constructor; 4993: } 4994: 4995: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 4996: EX(object) = NULL; 4997: } else { 4998: if (EG(This) && 4999: Z_OBJ_HT_P(EG(This))->get_class_entry && 5000: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 5001: /* We are calling method of the other (incompatible) class, 5002: but passing $this. This is done for compatibility with php-4. */ 5003: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 5004: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 5005: } else { 5006: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 5007: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 5008: } 5009: } 5010: if ((EX(object) = EG(This))) { 5011: Z_ADDREF_P(EX(object)); 5012: EX(called_scope) = Z_OBJCE_P(EX(object)); 5013: } 5014: } 5015: 5016: CHECK_EXCEPTION(); 5017: ZEND_VM_NEXT_OPCODE(); 5018: } 5019: 5020: static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5021: { 5022: USE_OPLINE 5023: zend_free_op free_op2; 5024: 5025: SAVE_OPLINE(); 5026: if (IS_CONST==IS_VAR) { 5027: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 5028: } 5029: is_equal_function(&EX_T(opline->result.var).tmp_var, 5030: opline->op1.zv, 5031: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 5032: 5033: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 5034: CHECK_EXCEPTION(); 5035: ZEND_VM_NEXT_OPCODE(); 5036: } 5037: 5038: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5039: { 5040: USE_OPLINE 5041: 5042: zval *expr_ptr; 5043: 5044: SAVE_OPLINE(); 5045: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 5046: zval **expr_ptr_ptr = NULL; 5047: 5048: if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 5049: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 5050: } 5051: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 5052: expr_ptr = *expr_ptr_ptr; 5053: Z_ADDREF_P(expr_ptr); 5054: } else { 5055: expr_ptr=opline->op1.zv; 5056: if (0) { /* temporary variable */ 5057: zval *new_expr; 5058: 5059: ALLOC_ZVAL(new_expr); 5060: INIT_PZVAL_COPY(new_expr, expr_ptr); 5061: expr_ptr = new_expr; 5062: } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 5063: zval *new_expr; 5064: 5065: ALLOC_ZVAL(new_expr); 5066: INIT_PZVAL_COPY(new_expr, expr_ptr); 5067: expr_ptr = new_expr; 5068: zendi_zval_copy_ctor(*expr_ptr); 5069: } else { 5070: Z_ADDREF_P(expr_ptr); 5071: } 5072: } 5073: 5074: if (IS_VAR != IS_UNUSED) { 5075: zend_free_op free_op2; 5076: zval *offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 5077: ulong hval; 5078: 5079: switch (Z_TYPE_P(offset)) { 5080: case IS_DOUBLE: 5081: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 5082: goto num_index; 5083: case IS_LONG: 5084: case IS_BOOL: 5085: hval = Z_LVAL_P(offset); 5086: num_index: 5087: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 5088: break; 5089: case IS_STRING: 5090: if (IS_VAR == IS_CONST) { 5091: hval = Z_HASH_P(offset); 5092: } else { 5093: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 5094: if (IS_INTERNED(Z_STRVAL_P(offset))) { 5095: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 5096: } else { 5097: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 5098: } 5099: } 5100: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 5101: break; 5102: case IS_NULL: 5103: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 5104: break; 5105: default: 5106: zend_error(E_WARNING, "Illegal offset type"); 5107: zval_ptr_dtor(&expr_ptr); 5108: /* do nothing */ 5109: break; 5110: } 5111: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 5112: } else { 5113: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 5114: } 5115: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 5116: 5117: } else { 5118: 5119: } 5120: CHECK_EXCEPTION(); 5121: ZEND_VM_NEXT_OPCODE(); 5122: } 5123: 5124: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5125: { 5126: USE_OPLINE 5127: 5128: array_init(&EX_T(opline->result.var).tmp_var); 5129: if (IS_CONST == IS_UNUSED) { 5130: ZEND_VM_NEXT_OPCODE(); 5131: #if 0 || IS_CONST != IS_UNUSED 5132: } else { 5133: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5134: #endif 5135: } 5136: } 5137: 5138: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5139: { 5140: USE_OPLINE 5141: zval tmp, *varname; 5142: HashTable *target_symbol_table; 5143: 5144: 5145: SAVE_OPLINE(); 5146: if (IS_CONST == IS_CV && 5147: IS_VAR == IS_UNUSED && 5148: (opline->extended_value & ZEND_QUICK_SET)) { 5149: if (EG(active_symbol_table)) { 5150: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 5151: 5152: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 5153: EX_CV(opline->op1.var) = NULL; 5154: } else if (EX_CV(opline->op1.var)) { 5155: zval_ptr_dtor(EX_CV(opline->op1.var)); 5156: EX_CV(opline->op1.var) = NULL; 5157: } 5158: CHECK_EXCEPTION(); 5159: ZEND_VM_NEXT_OPCODE(); 5160: } 5161: 5162: varname = opline->op1.zv; 5163: 5164: if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 5165: ZVAL_COPY_VALUE(&tmp, varname); 5166: zval_copy_ctor(&tmp); 5167: convert_to_string(&tmp); 5168: varname = &tmp; 5169: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 5170: Z_ADDREF_P(varname); 5171: } 5172: 5173: if (IS_VAR != IS_UNUSED) { 5174: zend_class_entry *ce; 5175: 5176: if (IS_VAR == IS_CONST) { 5177: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 5178: ce = CACHED_PTR(opline->op2.literal->cache_slot); 5179: } else { 5180: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 5181: if (UNEXPECTED(EG(exception) != NULL)) { 5182: if (IS_CONST != IS_CONST && varname == &tmp) { 5183: zval_dtor(&tmp); 5184: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 5185: zval_ptr_dtor(&varname); 5186: } 5187: 5188: HANDLE_EXCEPTION(); 5189: } 5190: if (UNEXPECTED(ce == NULL)) { 5191: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 5192: } 5193: CACHE_PTR(opline->op2.literal->cache_slot, ce); 5194: } 5195: } else { 5196: ce = EX_T(opline->op2.var).class_entry; 5197: } 5198: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 5199: } else { 5200: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 5201: 5202: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 5203: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 5204: } 5205: 5206: if (IS_CONST != IS_CONST && varname == &tmp) { 5207: zval_dtor(&tmp); 5208: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 5209: zval_ptr_dtor(&varname); 5210: } 5211: 5212: CHECK_EXCEPTION(); 5213: ZEND_VM_NEXT_OPCODE(); 5214: } 5215: 5216: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5217: { 5218: USE_OPLINE 5219: zval **value; 5220: zend_bool isset = 1; 5221: 5222: SAVE_OPLINE(); 5223: if (IS_CONST == IS_CV && 5224: IS_VAR == IS_UNUSED && 5225: (opline->extended_value & ZEND_QUICK_SET)) { 5226: if (EX_CV(opline->op1.var)) { 5227: value = EX_CV(opline->op1.var); 5228: } else if (EG(active_symbol_table)) { 5229: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 5230: 5231: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 5232: isset = 0; 5233: } 5234: } else { 5235: isset = 0; 5236: } 5237: } else { 5238: HashTable *target_symbol_table; 5239: 5240: zval tmp, *varname = opline->op1.zv; 5241: 5242: if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 5243: ZVAL_COPY_VALUE(&tmp, varname); 5244: zval_copy_ctor(&tmp); 5245: convert_to_string(&tmp); 5246: varname = &tmp; 5247: } 5248: 5249: if (IS_VAR != IS_UNUSED) { 5250: zend_class_entry *ce; 5251: 5252: if (IS_VAR == IS_CONST) { 5253: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 5254: ce = CACHED_PTR(opline->op2.literal->cache_slot); 5255: } else { 5256: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 5257: if (UNEXPECTED(ce == NULL)) { 5258: CHECK_EXCEPTION(); 5259: ZEND_VM_NEXT_OPCODE(); 5260: } 5261: CACHE_PTR(opline->op2.literal->cache_slot, ce); 5262: } 5263: } else { 5264: ce = EX_T(opline->op2.var).class_entry; 5265: } 5266: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 5267: if (!value) { 5268: isset = 0; 5269: } 5270: } else { 5271: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 5272: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 5273: isset = 0; 5274: } 5275: } 5276: 5277: if (IS_CONST != IS_CONST && varname == &tmp) { 5278: zval_dtor(&tmp); 5279: } 5280: 5281: } 5282: 5283: if (opline->extended_value & ZEND_ISSET) { 5284: if (isset && Z_TYPE_PP(value) != IS_NULL) { 5285: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 5286: } else { 5287: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 5288: } 5289: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 5290: if (!isset || !i_zend_is_true(*value)) { 5291: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 5292: } else { 5293: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 5294: } 5295: } 5296: 5297: CHECK_EXCEPTION(); 5298: ZEND_VM_NEXT_OPCODE(); 5299: } 5300: 5301: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) 5302: { 5303: USE_OPLINE 5304: zend_free_op free_op1; 5305: zval *varname; 5306: zval **retval; 5307: zval tmp_varname; 5308: HashTable *target_symbol_table; 5309: ulong hash_value; 5310: 5311: SAVE_OPLINE(); 5312: varname = opline->op1.zv; 5313: 5314: if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 5315: ZVAL_COPY_VALUE(&tmp_varname, varname); 5316: zval_copy_ctor(&tmp_varname); 5317: Z_SET_REFCOUNT(tmp_varname, 1); 5318: Z_UNSET_ISREF(tmp_varname); 5319: convert_to_string(&tmp_varname); 5320: varname = &tmp_varname; 5321: } 5322: 5323: if (IS_UNUSED != IS_UNUSED) { 5324: zend_class_entry *ce; 5325: 5326: if (IS_UNUSED == IS_CONST) { 5327: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 5328: ce = CACHED_PTR(opline->op2.literal->cache_slot); 5329: } else { 5330: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 5331: if (UNEXPECTED(ce == NULL)) { 5332: if (IS_CONST != IS_CONST && varname == &tmp_varname) { 5333: zval_dtor(&tmp_varname); 5334: } 5335: 5336: CHECK_EXCEPTION(); 5337: ZEND_VM_NEXT_OPCODE(); 5338: } 5339: CACHE_PTR(opline->op2.literal->cache_slot, ce); 5340: } 5341: } else { 5342: ce = EX_T(opline->op2.var).class_entry; 5343: } 5344: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 5345: 5346: } else { 5347: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 5348: /* 5349: if (!target_symbol_table) { 5350: CHECK_EXCEPTION(); 5351: ZEND_VM_NEXT_OPCODE(); 5352: } 5353: */ 5354: if (IS_CONST == IS_CONST) { 5355: hash_value = Z_HASH_P(varname); 5356: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 5357: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 5358: } else { 5359: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 5360: } 5361: 5362: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 5363: switch (type) { 5364: case BP_VAR_R: 5365: case BP_VAR_UNSET: 5366: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 5367: /* break missing intentionally */ 5368: case BP_VAR_IS: 5369: retval = &EG(uninitialized_zval_ptr); 5370: break; 5371: case BP_VAR_RW: 5372: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 5373: /* break missing intentionally */ 5374: case BP_VAR_W: 5375: Z_ADDREF_P(&EG(uninitialized_zval)); 5376: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 5377: break; 5378: EMPTY_SWITCH_DEFAULT_CASE() 5379: } 5380: } 5381: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 5382: case ZEND_FETCH_GLOBAL: 5383: if (IS_CONST != IS_TMP_VAR) { 5384: 5385: } 5386: break; 5387: case ZEND_FETCH_LOCAL: 5388: 5389: break; 5390: case ZEND_FETCH_STATIC: 5391: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 5392: break; 5393: case ZEND_FETCH_GLOBAL_LOCK: 5394: if (IS_CONST == IS_VAR && !free_op1.var) { 5395: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 5396: } 5397: break; 5398: } 5399: } 5400: 5401: 5402: if (IS_CONST != IS_CONST && varname == &tmp_varname) { 5403: zval_dtor(&tmp_varname); 5404: } 5405: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 5406: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 5407: } 5408: PZVAL_LOCK(*retval); 5409: switch (type) { 5410: case BP_VAR_R: 5411: case BP_VAR_IS: 5412: AI_SET_PTR(&EX_T(opline->result.var), *retval); 5413: break; 5414: case BP_VAR_UNSET: { 5415: zend_free_op free_res; 5416: 5417: PZVAL_UNLOCK(*retval, &free_res); 5418: if (retval != &EG(uninitialized_zval_ptr)) { 5419: SEPARATE_ZVAL_IF_NOT_REF(retval); 5420: } 5421: PZVAL_LOCK(*retval); 5422: FREE_OP_VAR_PTR(free_res); 5423: } 5424: /* break missing intentionally */ 5425: default: 5426: EX_T(opline->result.var).var.ptr_ptr = retval; 5427: break; 5428: } 5429: CHECK_EXCEPTION(); 5430: ZEND_VM_NEXT_OPCODE(); 5431: } 5432: 5433: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5434: { 5435: return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5436: } 5437: 5438: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5439: { 5440: return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5441: } 5442: 5443: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5444: { 5445: return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5446: } 5447: 5448: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5449: { 5450: USE_OPLINE 5451: 5452: return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5453: } 5454: 5455: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5456: { 5457: return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5458: } 5459: 5460: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5461: { 5462: return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5463: } 5464: 5465: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5466: { 5467: USE_OPLINE 5468: zval *function_name; 5469: zend_class_entry *ce; 5470: 5471: SAVE_OPLINE(); 5472: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 5473: 5474: if (IS_CONST == IS_CONST) { 5475: /* no function found. try a static method in class */ 5476: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 5477: ce = CACHED_PTR(opline->op1.literal->cache_slot); 5478: } else { 5479: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 5480: if (UNEXPECTED(EG(exception) != NULL)) { 5481: HANDLE_EXCEPTION(); 5482: } 5483: if (UNEXPECTED(ce == NULL)) { 5484: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 5485: } 5486: CACHE_PTR(opline->op1.literal->cache_slot, ce); 5487: } 5488: EX(called_scope) = ce; 5489: } else { 5490: ce = EX_T(opline->op1.var).class_entry; 5491: 5492: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 5493: EX(called_scope) = EG(called_scope); 5494: } else { 5495: EX(called_scope) = ce; 5496: } 5497: } 5498: 5499: if (IS_CONST == IS_CONST && 5500: IS_UNUSED == IS_CONST && 5501: CACHED_PTR(opline->op2.literal->cache_slot)) { 5502: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 5503: } else if (IS_CONST != IS_CONST && 5504: IS_UNUSED == IS_CONST && 5505: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 5506: /* do nothing */ 5507: } else if (IS_UNUSED != IS_UNUSED) { 5508: char *function_name_strval = NULL; 5509: int function_name_strlen = 0; 5510: 5511: 5512: if (IS_UNUSED == IS_CONST) { 5513: function_name_strval = Z_STRVAL_P(opline->op2.zv); 5514: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 5515: } else { 5516: function_name = NULL; 5517: 5518: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 5519: zend_error_noreturn(E_ERROR, "Function name must be a string"); 5520: } else { 5521: function_name_strval = Z_STRVAL_P(function_name); 5522: function_name_strlen = Z_STRLEN_P(function_name); 5523: } 5524: } 5525: 5526: if (function_name_strval) { 5527: if (ce->get_static_method) { 5528: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 5529: } else { 5530: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 5531: } 5532: if (UNEXPECTED(EX(fbc) == NULL)) { 5533: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 5534: } 5535: if (IS_UNUSED == IS_CONST && 5536: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 5537: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 5538: if (IS_CONST == IS_CONST) { 5539: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 5540: } else { 5541: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 5542: } 5543: } 5544: } 5545: if (IS_UNUSED != IS_CONST) { 5546: 5547: } 5548: } else { 5549: if (UNEXPECTED(ce->constructor == NULL)) { 5550: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 5551: } 5552: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 5553: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 5554: } 5555: EX(fbc) = ce->constructor; 5556: } 5557: 5558: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 5559: EX(object) = NULL; 5560: } else { 5561: if (EG(This) && 5562: Z_OBJ_HT_P(EG(This))->get_class_entry && 5563: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 5564: /* We are calling method of the other (incompatible) class, 5565: but passing $this. This is done for compatibility with php-4. */ 5566: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 5567: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 5568: } else { 5569: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 5570: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 5571: } 5572: } 5573: if ((EX(object) = EG(This))) { 5574: Z_ADDREF_P(EX(object)); 5575: EX(called_scope) = Z_OBJCE_P(EX(object)); 5576: } 5577: } 5578: 5579: CHECK_EXCEPTION(); 5580: ZEND_VM_NEXT_OPCODE(); 5581: } 5582: 5583: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5584: { 5585: USE_OPLINE 5586: 5587: zval *expr_ptr; 5588: 5589: SAVE_OPLINE(); 5590: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 5591: zval **expr_ptr_ptr = NULL; 5592: 5593: if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 5594: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 5595: } 5596: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 5597: expr_ptr = *expr_ptr_ptr; 5598: Z_ADDREF_P(expr_ptr); 5599: } else { 5600: expr_ptr=opline->op1.zv; 5601: if (0) { /* temporary variable */ 5602: zval *new_expr; 5603: 5604: ALLOC_ZVAL(new_expr); 5605: INIT_PZVAL_COPY(new_expr, expr_ptr); 5606: expr_ptr = new_expr; 5607: } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 5608: zval *new_expr; 5609: 5610: ALLOC_ZVAL(new_expr); 5611: INIT_PZVAL_COPY(new_expr, expr_ptr); 5612: expr_ptr = new_expr; 5613: zendi_zval_copy_ctor(*expr_ptr); 5614: } else { 5615: Z_ADDREF_P(expr_ptr); 5616: } 5617: } 5618: 5619: if (IS_UNUSED != IS_UNUSED) { 5620: 5621: zval *offset = NULL; 5622: ulong hval; 5623: 5624: switch (Z_TYPE_P(offset)) { 5625: case IS_DOUBLE: 5626: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 5627: goto num_index; 5628: case IS_LONG: 5629: case IS_BOOL: 5630: hval = Z_LVAL_P(offset); 5631: num_index: 5632: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 5633: break; 5634: case IS_STRING: 5635: if (IS_UNUSED == IS_CONST) { 5636: hval = Z_HASH_P(offset); 5637: } else { 5638: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 5639: if (IS_INTERNED(Z_STRVAL_P(offset))) { 5640: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 5641: } else { 5642: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 5643: } 5644: } 5645: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 5646: break; 5647: case IS_NULL: 5648: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 5649: break; 5650: default: 5651: zend_error(E_WARNING, "Illegal offset type"); 5652: zval_ptr_dtor(&expr_ptr); 5653: /* do nothing */ 5654: break; 5655: } 5656: 5657: } else { 5658: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 5659: } 5660: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 5661: 5662: } else { 5663: 5664: } 5665: CHECK_EXCEPTION(); 5666: ZEND_VM_NEXT_OPCODE(); 5667: } 5668: 5669: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5670: { 5671: USE_OPLINE 5672: 5673: array_init(&EX_T(opline->result.var).tmp_var); 5674: if (IS_CONST == IS_UNUSED) { 5675: ZEND_VM_NEXT_OPCODE(); 5676: #if 0 || IS_CONST != IS_UNUSED 5677: } else { 5678: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 5679: #endif 5680: } 5681: } 5682: 5683: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5684: { 5685: USE_OPLINE 5686: zval tmp, *varname; 5687: HashTable *target_symbol_table; 5688: 5689: 5690: SAVE_OPLINE(); 5691: if (IS_CONST == IS_CV && 5692: IS_UNUSED == IS_UNUSED && 5693: (opline->extended_value & ZEND_QUICK_SET)) { 5694: if (EG(active_symbol_table)) { 5695: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 5696: 5697: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 5698: EX_CV(opline->op1.var) = NULL; 5699: } else if (EX_CV(opline->op1.var)) { 5700: zval_ptr_dtor(EX_CV(opline->op1.var)); 5701: EX_CV(opline->op1.var) = NULL; 5702: } 5703: CHECK_EXCEPTION(); 5704: ZEND_VM_NEXT_OPCODE(); 5705: } 5706: 5707: varname = opline->op1.zv; 5708: 5709: if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 5710: ZVAL_COPY_VALUE(&tmp, varname); 5711: zval_copy_ctor(&tmp); 5712: convert_to_string(&tmp); 5713: varname = &tmp; 5714: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 5715: Z_ADDREF_P(varname); 5716: } 5717: 5718: if (IS_UNUSED != IS_UNUSED) { 5719: zend_class_entry *ce; 5720: 5721: if (IS_UNUSED == IS_CONST) { 5722: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 5723: ce = CACHED_PTR(opline->op2.literal->cache_slot); 5724: } else { 5725: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 5726: if (UNEXPECTED(EG(exception) != NULL)) { 5727: if (IS_CONST != IS_CONST && varname == &tmp) { 5728: zval_dtor(&tmp); 5729: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 5730: zval_ptr_dtor(&varname); 5731: } 5732: 5733: HANDLE_EXCEPTION(); 5734: } 5735: if (UNEXPECTED(ce == NULL)) { 5736: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 5737: } 5738: CACHE_PTR(opline->op2.literal->cache_slot, ce); 5739: } 5740: } else { 5741: ce = EX_T(opline->op2.var).class_entry; 5742: } 5743: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 5744: } else { 5745: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 5746: 5747: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 5748: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 5749: } 5750: 5751: if (IS_CONST != IS_CONST && varname == &tmp) { 5752: zval_dtor(&tmp); 5753: } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { 5754: zval_ptr_dtor(&varname); 5755: } 5756: 5757: CHECK_EXCEPTION(); 5758: ZEND_VM_NEXT_OPCODE(); 5759: } 5760: 5761: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5762: { 5763: USE_OPLINE 5764: zval **value; 5765: zend_bool isset = 1; 5766: 5767: SAVE_OPLINE(); 5768: if (IS_CONST == IS_CV && 5769: IS_UNUSED == IS_UNUSED && 5770: (opline->extended_value & ZEND_QUICK_SET)) { 5771: if (EX_CV(opline->op1.var)) { 5772: value = EX_CV(opline->op1.var); 5773: } else if (EG(active_symbol_table)) { 5774: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 5775: 5776: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 5777: isset = 0; 5778: } 5779: } else { 5780: isset = 0; 5781: } 5782: } else { 5783: HashTable *target_symbol_table; 5784: 5785: zval tmp, *varname = opline->op1.zv; 5786: 5787: if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 5788: ZVAL_COPY_VALUE(&tmp, varname); 5789: zval_copy_ctor(&tmp); 5790: convert_to_string(&tmp); 5791: varname = &tmp; 5792: } 5793: 5794: if (IS_UNUSED != IS_UNUSED) { 5795: zend_class_entry *ce; 5796: 5797: if (IS_UNUSED == IS_CONST) { 5798: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 5799: ce = CACHED_PTR(opline->op2.literal->cache_slot); 5800: } else { 5801: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 5802: if (UNEXPECTED(ce == NULL)) { 5803: CHECK_EXCEPTION(); 5804: ZEND_VM_NEXT_OPCODE(); 5805: } 5806: CACHE_PTR(opline->op2.literal->cache_slot, ce); 5807: } 5808: } else { 5809: ce = EX_T(opline->op2.var).class_entry; 5810: } 5811: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 5812: if (!value) { 5813: isset = 0; 5814: } 5815: } else { 5816: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 5817: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 5818: isset = 0; 5819: } 5820: } 5821: 5822: if (IS_CONST != IS_CONST && varname == &tmp) { 5823: zval_dtor(&tmp); 5824: } 5825: 5826: } 5827: 5828: if (opline->extended_value & ZEND_ISSET) { 5829: if (isset && Z_TYPE_PP(value) != IS_NULL) { 5830: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 5831: } else { 5832: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 5833: } 5834: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 5835: if (!isset || !i_zend_is_true(*value)) { 5836: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 5837: } else { 5838: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 5839: } 5840: } 5841: 5842: CHECK_EXCEPTION(); 5843: ZEND_VM_NEXT_OPCODE(); 5844: } 5845: 5846: static int ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5847: { 5848: USE_OPLINE 5849: zend_function *op_array; 5850: 5851: SAVE_OPLINE(); 5852: 5853: if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void *) &op_array) == FAILURE) || 5854: UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) { 5855: zend_error_noreturn(E_ERROR, "Base lambda function for closure not found"); 5856: } 5857: 5858: zend_create_closure(&EX_T(opline->result.var).tmp_var, op_array, EG(scope), EG(This) TSRMLS_CC); 5859: 5860: CHECK_EXCEPTION(); 5861: ZEND_VM_NEXT_OPCODE(); 5862: } 5863: 5864: static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5865: { 5866: USE_OPLINE 5867: 5868: 5869: SAVE_OPLINE(); 5870: fast_add_function(&EX_T(opline->result.var).tmp_var, 5871: opline->op1.zv, 5872: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5873: 5874: 5875: CHECK_EXCEPTION(); 5876: ZEND_VM_NEXT_OPCODE(); 5877: } 5878: 5879: static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5880: { 5881: USE_OPLINE 5882: 5883: 5884: SAVE_OPLINE(); 5885: fast_sub_function(&EX_T(opline->result.var).tmp_var, 5886: opline->op1.zv, 5887: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5888: 5889: 5890: CHECK_EXCEPTION(); 5891: ZEND_VM_NEXT_OPCODE(); 5892: } 5893: 5894: static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5895: { 5896: USE_OPLINE 5897: 5898: 5899: SAVE_OPLINE(); 5900: fast_mul_function(&EX_T(opline->result.var).tmp_var, 5901: opline->op1.zv, 5902: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5903: 5904: 5905: CHECK_EXCEPTION(); 5906: ZEND_VM_NEXT_OPCODE(); 5907: } 5908: 5909: static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5910: { 5911: USE_OPLINE 5912: 5913: 5914: SAVE_OPLINE(); 5915: fast_div_function(&EX_T(opline->result.var).tmp_var, 5916: opline->op1.zv, 5917: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5918: 5919: 5920: CHECK_EXCEPTION(); 5921: ZEND_VM_NEXT_OPCODE(); 5922: } 5923: 5924: static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5925: { 5926: USE_OPLINE 5927: 5928: 5929: SAVE_OPLINE(); 5930: fast_mod_function(&EX_T(opline->result.var).tmp_var, 5931: opline->op1.zv, 5932: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5933: 5934: 5935: CHECK_EXCEPTION(); 5936: ZEND_VM_NEXT_OPCODE(); 5937: } 5938: 5939: static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5940: { 5941: USE_OPLINE 5942: 5943: 5944: SAVE_OPLINE(); 5945: shift_left_function(&EX_T(opline->result.var).tmp_var, 5946: opline->op1.zv, 5947: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5948: 5949: 5950: CHECK_EXCEPTION(); 5951: ZEND_VM_NEXT_OPCODE(); 5952: } 5953: 5954: static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5955: { 5956: USE_OPLINE 5957: 5958: 5959: SAVE_OPLINE(); 5960: shift_right_function(&EX_T(opline->result.var).tmp_var, 5961: opline->op1.zv, 5962: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5963: 5964: 5965: CHECK_EXCEPTION(); 5966: ZEND_VM_NEXT_OPCODE(); 5967: } 5968: 5969: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5970: { 5971: USE_OPLINE 5972: 5973: 5974: SAVE_OPLINE(); 5975: concat_function(&EX_T(opline->result.var).tmp_var, 5976: opline->op1.zv, 5977: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5978: 5979: 5980: CHECK_EXCEPTION(); 5981: ZEND_VM_NEXT_OPCODE(); 5982: } 5983: 5984: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 5985: { 5986: USE_OPLINE 5987: 5988: 5989: SAVE_OPLINE(); 5990: is_identical_function(&EX_T(opline->result.var).tmp_var, 5991: opline->op1.zv, 5992: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 5993: 5994: 5995: CHECK_EXCEPTION(); 5996: ZEND_VM_NEXT_OPCODE(); 5997: } 5998: 5999: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6000: { 6001: USE_OPLINE 6002: 6003: zval *result = &EX_T(opline->result.var).tmp_var; 6004: 6005: SAVE_OPLINE(); 6006: is_identical_function(result, 6007: opline->op1.zv, 6008: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 6009: Z_LVAL_P(result) = !Z_LVAL_P(result); 6010: 6011: 6012: CHECK_EXCEPTION(); 6013: ZEND_VM_NEXT_OPCODE(); 6014: } 6015: 6016: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6017: { 6018: USE_OPLINE 6019: 6020: zval *result = &EX_T(opline->result.var).tmp_var; 6021: 6022: SAVE_OPLINE(); 6023: ZVAL_BOOL(result, fast_equal_function(result, 6024: opline->op1.zv, 6025: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 6026: 6027: 6028: CHECK_EXCEPTION(); 6029: ZEND_VM_NEXT_OPCODE(); 6030: } 6031: 6032: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6033: { 6034: USE_OPLINE 6035: 6036: zval *result = &EX_T(opline->result.var).tmp_var; 6037: 6038: SAVE_OPLINE(); 6039: ZVAL_BOOL(result, fast_not_equal_function(result, 6040: opline->op1.zv, 6041: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 6042: 6043: 6044: CHECK_EXCEPTION(); 6045: ZEND_VM_NEXT_OPCODE(); 6046: } 6047: 6048: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6049: { 6050: USE_OPLINE 6051: 6052: zval *result = &EX_T(opline->result.var).tmp_var; 6053: 6054: SAVE_OPLINE(); 6055: ZVAL_BOOL(result, fast_is_smaller_function(result, 6056: opline->op1.zv, 6057: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 6058: 6059: 6060: CHECK_EXCEPTION(); 6061: ZEND_VM_NEXT_OPCODE(); 6062: } 6063: 6064: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6065: { 6066: USE_OPLINE 6067: 6068: zval *result = &EX_T(opline->result.var).tmp_var; 6069: 6070: SAVE_OPLINE(); 6071: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 6072: opline->op1.zv, 6073: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 6074: 6075: 6076: CHECK_EXCEPTION(); 6077: ZEND_VM_NEXT_OPCODE(); 6078: } 6079: 6080: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6081: { 6082: USE_OPLINE 6083: 6084: 6085: SAVE_OPLINE(); 6086: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 6087: opline->op1.zv, 6088: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 6089: 6090: 6091: CHECK_EXCEPTION(); 6092: ZEND_VM_NEXT_OPCODE(); 6093: } 6094: 6095: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6096: { 6097: USE_OPLINE 6098: 6099: 6100: SAVE_OPLINE(); 6101: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 6102: opline->op1.zv, 6103: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 6104: 6105: 6106: CHECK_EXCEPTION(); 6107: ZEND_VM_NEXT_OPCODE(); 6108: } 6109: 6110: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6111: { 6112: USE_OPLINE 6113: 6114: 6115: SAVE_OPLINE(); 6116: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 6117: opline->op1.zv, 6118: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 6119: 6120: 6121: CHECK_EXCEPTION(); 6122: ZEND_VM_NEXT_OPCODE(); 6123: } 6124: 6125: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6126: { 6127: USE_OPLINE 6128: 6129: 6130: SAVE_OPLINE(); 6131: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 6132: opline->op1.zv, 6133: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 6134: 6135: 6136: CHECK_EXCEPTION(); 6137: ZEND_VM_NEXT_OPCODE(); 6138: } 6139: 6140: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6141: { 6142: USE_OPLINE 6143: zval *function_name; 6144: zend_class_entry *ce; 6145: 6146: SAVE_OPLINE(); 6147: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 6148: 6149: if (IS_CONST == IS_CONST) { 6150: /* no function found. try a static method in class */ 6151: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 6152: ce = CACHED_PTR(opline->op1.literal->cache_slot); 6153: } else { 6154: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 6155: if (UNEXPECTED(EG(exception) != NULL)) { 6156: HANDLE_EXCEPTION(); 6157: } 6158: if (UNEXPECTED(ce == NULL)) { 6159: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 6160: } 6161: CACHE_PTR(opline->op1.literal->cache_slot, ce); 6162: } 6163: EX(called_scope) = ce; 6164: } else { 6165: ce = EX_T(opline->op1.var).class_entry; 6166: 6167: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 6168: EX(called_scope) = EG(called_scope); 6169: } else { 6170: EX(called_scope) = ce; 6171: } 6172: } 6173: 6174: if (IS_CONST == IS_CONST && 6175: IS_CV == IS_CONST && 6176: CACHED_PTR(opline->op2.literal->cache_slot)) { 6177: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 6178: } else if (IS_CONST != IS_CONST && 6179: IS_CV == IS_CONST && 6180: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 6181: /* do nothing */ 6182: } else if (IS_CV != IS_UNUSED) { 6183: char *function_name_strval = NULL; 6184: int function_name_strlen = 0; 6185: 6186: 6187: if (IS_CV == IS_CONST) { 6188: function_name_strval = Z_STRVAL_P(opline->op2.zv); 6189: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 6190: } else { 6191: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 6192: 6193: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 6194: zend_error_noreturn(E_ERROR, "Function name must be a string"); 6195: } else { 6196: function_name_strval = Z_STRVAL_P(function_name); 6197: function_name_strlen = Z_STRLEN_P(function_name); 6198: } 6199: } 6200: 6201: if (function_name_strval) { 6202: if (ce->get_static_method) { 6203: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 6204: } else { 6205: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 6206: } 6207: if (UNEXPECTED(EX(fbc) == NULL)) { 6208: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 6209: } 6210: if (IS_CV == IS_CONST && 6211: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 6212: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 6213: if (IS_CONST == IS_CONST) { 6214: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 6215: } else { 6216: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 6217: } 6218: } 6219: } 6220: if (IS_CV != IS_CONST) { 6221: 6222: } 6223: } else { 6224: if (UNEXPECTED(ce->constructor == NULL)) { 6225: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 6226: } 6227: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 6228: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 6229: } 6230: EX(fbc) = ce->constructor; 6231: } 6232: 6233: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 6234: EX(object) = NULL; 6235: } else { 6236: if (EG(This) && 6237: Z_OBJ_HT_P(EG(This))->get_class_entry && 6238: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 6239: /* We are calling method of the other (incompatible) class, 6240: but passing $this. This is done for compatibility with php-4. */ 6241: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 6242: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 6243: } else { 6244: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 6245: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 6246: } 6247: } 6248: if ((EX(object) = EG(This))) { 6249: Z_ADDREF_P(EX(object)); 6250: EX(called_scope) = Z_OBJCE_P(EX(object)); 6251: } 6252: } 6253: 6254: CHECK_EXCEPTION(); 6255: ZEND_VM_NEXT_OPCODE(); 6256: } 6257: 6258: static int ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6259: { 6260: USE_OPLINE 6261: zend_class_entry *ce, *catch_ce; 6262: zval *exception; 6263: 6264: SAVE_OPLINE(); 6265: /* Check whether an exception has been thrown, if not, jump over code */ 6266: zend_exception_restore(TSRMLS_C); 6267: if (EG(exception) == NULL) { 6268: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); 6269: ZEND_VM_CONTINUE(); /* CHECK_ME */ 6270: } 6271: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 6272: catch_ce = CACHED_PTR(opline->op1.literal->cache_slot); 6273: } else { 6274: catch_ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); 6275: 6276: CACHE_PTR(opline->op1.literal->cache_slot, catch_ce); 6277: } 6278: ce = Z_OBJCE_P(EG(exception)); 6279: 6280: #ifdef HAVE_DTRACE 6281: if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { 6282: DTRACE_EXCEPTION_CAUGHT((char *)ce->name); 6283: } 6284: #endif /* HAVE_DTRACE */ 6285: 6286: if (ce != catch_ce) { 6287: if (!instanceof_function(ce, catch_ce TSRMLS_CC)) { 6288: if (opline->result.num) { 6289: zend_throw_exception_internal(NULL TSRMLS_CC); 6290: HANDLE_EXCEPTION(); 6291: } 6292: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); 6293: ZEND_VM_CONTINUE(); /* CHECK_ME */ 6294: } 6295: } 6296: 6297: exception = EG(exception); 6298: if (!EG(active_symbol_table)) { 6299: if (EX_CV(opline->op2.var)) { 6300: zval_ptr_dtor(EX_CV(opline->op2.var)); 6301: } 6302: EX_CV(opline->op2.var) = (zval**)EX_CVs() + (EX(op_array)->last_var + opline->op2.var); 6303: *EX_CV(opline->op2.var) = EG(exception); 6304: } else { 6305: zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var); 6306: zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, 6307: &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var)); 6308: } 6309: if (UNEXPECTED(EG(exception) != exception)) { 6310: Z_ADDREF_P(EG(exception)); 6311: HANDLE_EXCEPTION(); 6312: } else { 6313: EG(exception) = NULL; 6314: ZEND_VM_NEXT_OPCODE(); 6315: } 6316: } 6317: 6318: static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6319: { 6320: USE_OPLINE 6321: 6322: 6323: SAVE_OPLINE(); 6324: if (IS_CONST==IS_VAR) { 6325: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 6326: } 6327: is_equal_function(&EX_T(opline->result.var).tmp_var, 6328: opline->op1.zv, 6329: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 6330: 6331: CHECK_EXCEPTION(); 6332: ZEND_VM_NEXT_OPCODE(); 6333: } 6334: 6335: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6336: { 6337: USE_OPLINE 6338: 6339: zval *expr_ptr; 6340: 6341: SAVE_OPLINE(); 6342: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 6343: zval **expr_ptr_ptr = NULL; 6344: 6345: if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 6346: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 6347: } 6348: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 6349: expr_ptr = *expr_ptr_ptr; 6350: Z_ADDREF_P(expr_ptr); 6351: } else { 6352: expr_ptr=opline->op1.zv; 6353: if (0) { /* temporary variable */ 6354: zval *new_expr; 6355: 6356: ALLOC_ZVAL(new_expr); 6357: INIT_PZVAL_COPY(new_expr, expr_ptr); 6358: expr_ptr = new_expr; 6359: } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 6360: zval *new_expr; 6361: 6362: ALLOC_ZVAL(new_expr); 6363: INIT_PZVAL_COPY(new_expr, expr_ptr); 6364: expr_ptr = new_expr; 6365: zendi_zval_copy_ctor(*expr_ptr); 6366: } else { 6367: Z_ADDREF_P(expr_ptr); 6368: } 6369: } 6370: 6371: if (IS_CV != IS_UNUSED) { 6372: 6373: zval *offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 6374: ulong hval; 6375: 6376: switch (Z_TYPE_P(offset)) { 6377: case IS_DOUBLE: 6378: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 6379: goto num_index; 6380: case IS_LONG: 6381: case IS_BOOL: 6382: hval = Z_LVAL_P(offset); 6383: num_index: 6384: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 6385: break; 6386: case IS_STRING: 6387: if (IS_CV == IS_CONST) { 6388: hval = Z_HASH_P(offset); 6389: } else { 6390: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 6391: if (IS_INTERNED(Z_STRVAL_P(offset))) { 6392: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 6393: } else { 6394: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 6395: } 6396: } 6397: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 6398: break; 6399: case IS_NULL: 6400: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 6401: break; 6402: default: 6403: zend_error(E_WARNING, "Illegal offset type"); 6404: zval_ptr_dtor(&expr_ptr); 6405: /* do nothing */ 6406: break; 6407: } 6408: 6409: } else { 6410: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 6411: } 6412: if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { 6413: 6414: } else { 6415: 6416: } 6417: CHECK_EXCEPTION(); 6418: ZEND_VM_NEXT_OPCODE(); 6419: } 6420: 6421: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6422: { 6423: USE_OPLINE 6424: 6425: array_init(&EX_T(opline->result.var).tmp_var); 6426: if (IS_CONST == IS_UNUSED) { 6427: ZEND_VM_NEXT_OPCODE(); 6428: #if 0 || IS_CONST != IS_UNUSED 6429: } else { 6430: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 6431: #endif 6432: } 6433: } 6434: 6435: static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6436: { 6437: USE_OPLINE 6438: zend_free_op free_op1; 6439: 6440: SAVE_OPLINE(); 6441: bitwise_not_function(&EX_T(opline->result.var).tmp_var, 6442: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC) TSRMLS_CC); 6443: zval_dtor(free_op1.var); 6444: CHECK_EXCEPTION(); 6445: ZEND_VM_NEXT_OPCODE(); 6446: } 6447: 6448: static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6449: { 6450: USE_OPLINE 6451: zend_free_op free_op1; 6452: 6453: SAVE_OPLINE(); 6454: boolean_not_function(&EX_T(opline->result.var).tmp_var, 6455: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC) TSRMLS_CC); 6456: zval_dtor(free_op1.var); 6457: CHECK_EXCEPTION(); 6458: ZEND_VM_NEXT_OPCODE(); 6459: } 6460: 6461: static int ZEND_FASTCALL ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6462: { 6463: USE_OPLINE 6464: zend_free_op free_op1; 6465: zval *z; 6466: 6467: SAVE_OPLINE(); 6468: z = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6469: 6470: if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { 6471: INIT_PZVAL(z); 6472: } 6473: zend_print_variable(z); 6474: 6475: zval_dtor(free_op1.var); 6476: CHECK_EXCEPTION(); 6477: ZEND_VM_NEXT_OPCODE(); 6478: } 6479: 6480: static int ZEND_FASTCALL ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6481: { 6482: USE_OPLINE 6483: 6484: ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); 6485: return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 6486: } 6487: 6488: static int ZEND_FASTCALL ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6489: { 6490: USE_OPLINE 6491: zend_free_op free_op1; 6492: zval *val; 6493: int ret; 6494: 6495: SAVE_OPLINE(); 6496: val = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6497: 6498: if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 6499: ret = Z_LVAL_P(val); 6500: } else { 6501: ret = i_zend_is_true(val); 6502: zval_dtor(free_op1.var); 6503: if (UNEXPECTED(EG(exception) != NULL)) { 6504: HANDLE_EXCEPTION(); 6505: } 6506: } 6507: if (!ret) { 6508: #if DEBUG_ZEND>=2 6509: printf("Conditional jmp to %d\n", opline->op2.opline_num); 6510: #endif 6511: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 6512: ZEND_VM_CONTINUE(); 6513: } 6514: 6515: ZEND_VM_NEXT_OPCODE(); 6516: } 6517: 6518: static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6519: { 6520: USE_OPLINE 6521: zend_free_op free_op1; 6522: zval *val; 6523: int ret; 6524: 6525: SAVE_OPLINE(); 6526: val = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6527: 6528: if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 6529: ret = Z_LVAL_P(val); 6530: } else { 6531: ret = i_zend_is_true(val); 6532: zval_dtor(free_op1.var); 6533: if (UNEXPECTED(EG(exception) != NULL)) { 6534: HANDLE_EXCEPTION(); 6535: } 6536: } 6537: if (ret) { 6538: #if DEBUG_ZEND>=2 6539: printf("Conditional jmp to %d\n", opline->op2.opline_num); 6540: #endif 6541: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 6542: ZEND_VM_CONTINUE(); 6543: } 6544: 6545: ZEND_VM_NEXT_OPCODE(); 6546: } 6547: 6548: static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6549: { 6550: USE_OPLINE 6551: zend_free_op free_op1; 6552: zval *val; 6553: int retval; 6554: 6555: SAVE_OPLINE(); 6556: val = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6557: 6558: if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 6559: retval = Z_LVAL_P(val); 6560: } else { 6561: retval = i_zend_is_true(val); 6562: zval_dtor(free_op1.var); 6563: if (UNEXPECTED(EG(exception) != NULL)) { 6564: HANDLE_EXCEPTION(); 6565: } 6566: } 6567: if (EXPECTED(retval != 0)) { 6568: #if DEBUG_ZEND>=2 6569: printf("Conditional jmp on true to %d\n", opline->extended_value); 6570: #endif 6571: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); 6572: ZEND_VM_CONTINUE(); /* CHECK_ME */ 6573: } else { 6574: #if DEBUG_ZEND>=2 6575: printf("Conditional jmp on false to %d\n", opline->op2.opline_num); 6576: #endif 6577: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); 6578: ZEND_VM_CONTINUE(); /* CHECK_ME */ 6579: } 6580: } 6581: 6582: static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6583: { 6584: USE_OPLINE 6585: zend_free_op free_op1; 6586: zval *val; 6587: int retval; 6588: 6589: SAVE_OPLINE(); 6590: val = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6591: 6592: if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 6593: retval = Z_LVAL_P(val); 6594: } else { 6595: retval = i_zend_is_true(val); 6596: zval_dtor(free_op1.var); 6597: if (UNEXPECTED(EG(exception) != NULL)) { 6598: HANDLE_EXCEPTION(); 6599: } 6600: } 6601: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 6602: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 6603: if (!retval) { 6604: #if DEBUG_ZEND>=2 6605: printf("Conditional jmp to %d\n", opline->op2.opline_num); 6606: #endif 6607: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 6608: ZEND_VM_CONTINUE(); 6609: } 6610: ZEND_VM_NEXT_OPCODE(); 6611: } 6612: 6613: static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6614: { 6615: USE_OPLINE 6616: zend_free_op free_op1; 6617: zval *val; 6618: int retval; 6619: 6620: SAVE_OPLINE(); 6621: val = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6622: 6623: if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 6624: retval = Z_LVAL_P(val); 6625: } else { 6626: retval = i_zend_is_true(val); 6627: zval_dtor(free_op1.var); 6628: if (UNEXPECTED(EG(exception) != NULL)) { 6629: HANDLE_EXCEPTION(); 6630: } 6631: } 6632: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 6633: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 6634: if (retval) { 6635: #if DEBUG_ZEND>=2 6636: printf("Conditional jmp to %d\n", opline->op2.opline_num); 6637: #endif 6638: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 6639: ZEND_VM_CONTINUE(); 6640: } 6641: ZEND_VM_NEXT_OPCODE(); 6642: } 6643: 6644: static int ZEND_FASTCALL ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6645: { 6646: USE_OPLINE 6647: 6648: SAVE_OPLINE(); 6649: if (IS_TMP_VAR == IS_TMP_VAR) { 6650: zendi_zval_dtor(EX_T(opline->op1.var).tmp_var); 6651: } else { 6652: zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); 6653: } 6654: CHECK_EXCEPTION(); 6655: ZEND_VM_NEXT_OPCODE(); 6656: } 6657: 6658: static int ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6659: { 6660: USE_OPLINE 6661: zval *retval_ptr; 6662: zend_free_op free_op1; 6663: 6664: SAVE_OPLINE(); 6665: retval_ptr = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6666: 6667: if (!EG(return_value_ptr_ptr)) { 6668: if (IS_TMP_VAR == IS_TMP_VAR) { 6669: zval_dtor(free_op1.var); 6670: } 6671: } else if (!1) { /* Not a temp var */ 6672: if (IS_TMP_VAR == IS_CONST || 6673: (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) { 6674: zval *ret; 6675: 6676: ALLOC_ZVAL(ret); 6677: INIT_PZVAL_COPY(ret, retval_ptr); 6678: zval_copy_ctor(ret); 6679: *EG(return_value_ptr_ptr) = ret; 6680: } else if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && 6681: retval_ptr == &EG(uninitialized_zval)) { 6682: zval *ret; 6683: 6684: ALLOC_INIT_ZVAL(ret); 6685: *EG(return_value_ptr_ptr) = ret; 6686: } else { 6687: *EG(return_value_ptr_ptr) = retval_ptr; 6688: Z_ADDREF_P(retval_ptr); 6689: } 6690: } else { 6691: zval *ret; 6692: 6693: ALLOC_ZVAL(ret); 6694: INIT_PZVAL_COPY(ret, retval_ptr); 6695: *EG(return_value_ptr_ptr) = ret; 6696: } 6697: 6698: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 6699: } 6700: 6701: static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6702: { 6703: USE_OPLINE 6704: zval *retval_ptr; 6705: zval **retval_ptr_ptr; 6706: zend_free_op free_op1; 6707: 6708: SAVE_OPLINE(); 6709: 6710: do { 6711: if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { 6712: /* Not supposed to happen, but we'll allow it */ 6713: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 6714: 6715: retval_ptr = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6716: if (!EG(return_value_ptr_ptr)) { 6717: if (IS_TMP_VAR == IS_TMP_VAR) { 6718: zval_dtor(free_op1.var); 6719: } 6720: } else if (!1) { /* Not a temp var */ 6721: zval *ret; 6722: 6723: ALLOC_ZVAL(ret); 6724: INIT_PZVAL_COPY(ret, retval_ptr); 6725: zval_copy_ctor(ret); 6726: *EG(return_value_ptr_ptr) = ret; 6727: } else { 6728: zval *ret; 6729: 6730: ALLOC_ZVAL(ret); 6731: INIT_PZVAL_COPY(ret, retval_ptr); 6732: *EG(return_value_ptr_ptr) = ret; 6733: } 6734: break; 6735: } 6736: 6737: retval_ptr_ptr = NULL; 6738: 6739: if (IS_TMP_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { 6740: zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); 6741: } 6742: 6743: if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { 6744: if (opline->extended_value == ZEND_RETURNS_FUNCTION && 6745: EX_T(opline->op1.var).var.fcall_returned_reference) { 6746: } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { 6747: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 6748: if (EG(return_value_ptr_ptr)) { 6749: zval *ret; 6750: 6751: ALLOC_ZVAL(ret); 6752: INIT_PZVAL_COPY(ret, *retval_ptr_ptr); 6753: zval_copy_ctor(ret); 6754: *EG(return_value_ptr_ptr) = ret; 6755: } 6756: break; 6757: } 6758: } 6759: 6760: if (EG(return_value_ptr_ptr)) { 6761: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); 6762: Z_ADDREF_PP(retval_ptr_ptr); 6763: 6764: *EG(return_value_ptr_ptr) = *retval_ptr_ptr; 6765: } 6766: } while (0); 6767: 6768: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 6769: } 6770: 6771: static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6772: { 6773: USE_OPLINE 6774: zval *value; 6775: zval *exception; 6776: zend_free_op free_op1; 6777: 6778: SAVE_OPLINE(); 6779: value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6780: 6781: if (IS_TMP_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { 6782: zend_error_noreturn(E_ERROR, "Can only throw objects"); 6783: } 6784: zend_exception_save(TSRMLS_C); 6785: /* Not sure if a complete copy is what we want here */ 6786: ALLOC_ZVAL(exception); 6787: INIT_PZVAL_COPY(exception, value); 6788: if (!1) { 6789: zval_copy_ctor(exception); 6790: } 6791: 6792: zend_throw_exception_object(exception TSRMLS_CC); 6793: zend_exception_restore(TSRMLS_C); 6794: 6795: HANDLE_EXCEPTION(); 6796: } 6797: 6798: static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6799: { 6800: USE_OPLINE 6801: 6802: SAVE_OPLINE(); 6803: if (opline->extended_value==ZEND_DO_FCALL_BY_NAME 6804: && ARG_MUST_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 6805: zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.opline_num); 6806: } 6807: { 6808: zval *valptr; 6809: zval *value; 6810: zend_free_op free_op1; 6811: 6812: value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6813: 6814: ALLOC_ZVAL(valptr); 6815: INIT_PZVAL_COPY(valptr, value); 6816: if (!1) { 6817: zval_copy_ctor(valptr); 6818: } 6819: zend_vm_stack_push(valptr TSRMLS_CC); 6820: 6821: } 6822: CHECK_EXCEPTION(); 6823: ZEND_VM_NEXT_OPCODE(); 6824: } 6825: 6826: static int ZEND_FASTCALL ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6827: { 6828: USE_OPLINE 6829: zend_free_op free_op1; 6830: zval *retval = &EX_T(opline->result.var).tmp_var; 6831: 6832: SAVE_OPLINE(); 6833: /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ 6834: ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC))); 6835: zval_dtor(free_op1.var); 6836: 6837: CHECK_EXCEPTION(); 6838: ZEND_VM_NEXT_OPCODE(); 6839: } 6840: 6841: static int ZEND_FASTCALL ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6842: { 6843: USE_OPLINE 6844: zend_free_op free_op1; 6845: zval *obj; 6846: zend_class_entry *ce; 6847: zend_function *clone; 6848: zend_object_clone_obj_t clone_call; 6849: 6850: SAVE_OPLINE(); 6851: obj = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6852: 6853: if (IS_TMP_VAR == IS_CONST || 6854: UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) { 6855: zend_error_noreturn(E_ERROR, "__clone method called on non-object"); 6856: } 6857: 6858: ce = Z_OBJCE_P(obj); 6859: clone = ce ? ce->clone : NULL; 6860: clone_call = Z_OBJ_HT_P(obj)->clone_obj; 6861: if (UNEXPECTED(clone_call == NULL)) { 6862: if (ce) { 6863: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); 6864: } else { 6865: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); 6866: } 6867: } 6868: 6869: if (ce && clone) { 6870: if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { 6871: /* Ensure that if we're calling a private function, we're allowed to do so. 6872: */ 6873: if (UNEXPECTED(ce != EG(scope))) { 6874: zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 6875: } 6876: } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { 6877: /* Ensure that if we're calling a protected function, we're allowed to do so. 6878: */ 6879: if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { 6880: zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 6881: } 6882: } 6883: } 6884: 6885: if (EXPECTED(EG(exception) == NULL)) { 6886: zval *retval; 6887: 6888: ALLOC_ZVAL(retval); 6889: Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); 6890: Z_TYPE_P(retval) = IS_OBJECT; 6891: Z_SET_REFCOUNT_P(retval, 1); 6892: Z_SET_ISREF_P(retval); 6893: if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { 6894: zval_ptr_dtor(&retval); 6895: } else { 6896: AI_SET_PTR(&EX_T(opline->result.var), retval); 6897: } 6898: } 6899: 6900: CHECK_EXCEPTION(); 6901: ZEND_VM_NEXT_OPCODE(); 6902: } 6903: 6904: static int ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6905: { 6906: USE_OPLINE 6907: zend_free_op free_op1; 6908: zval *expr; 6909: zval *result = &EX_T(opline->result.var).tmp_var; 6910: 6911: SAVE_OPLINE(); 6912: expr = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6913: 6914: if (opline->extended_value != IS_STRING) { 6915: ZVAL_COPY_VALUE(result, expr); 6916: if (!1) { 6917: zendi_zval_copy_ctor(*result); 6918: } 6919: } 6920: switch (opline->extended_value) { 6921: case IS_NULL: 6922: convert_to_null(result); 6923: break; 6924: case IS_BOOL: 6925: convert_to_boolean(result); 6926: break; 6927: case IS_LONG: 6928: convert_to_long(result); 6929: break; 6930: case IS_DOUBLE: 6931: convert_to_double(result); 6932: break; 6933: case IS_STRING: { 6934: zval var_copy; 6935: int use_copy; 6936: 6937: zend_make_printable_zval(expr, &var_copy, &use_copy); 6938: if (use_copy) { 6939: ZVAL_COPY_VALUE(result, &var_copy); 6940: if (1) { 6941: zval_dtor(free_op1.var); 6942: } 6943: } else { 6944: ZVAL_COPY_VALUE(result, expr); 6945: if (!1) { 6946: zendi_zval_copy_ctor(*result); 6947: } 6948: } 6949: break; 6950: } 6951: case IS_ARRAY: 6952: convert_to_array(result); 6953: break; 6954: case IS_OBJECT: 6955: convert_to_object(result); 6956: break; 6957: } 6958: 6959: CHECK_EXCEPTION(); 6960: ZEND_VM_NEXT_OPCODE(); 6961: } 6962: 6963: static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 6964: { 6965: USE_OPLINE 6966: zend_op_array *new_op_array=NULL; 6967: zend_free_op free_op1; 6968: zval *inc_filename; 6969: zval *tmp_inc_filename = NULL; 6970: zend_bool failure_retval=0; 6971: 6972: SAVE_OPLINE(); 6973: inc_filename = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 6974: 6975: if (inc_filename->type!=IS_STRING) { 6976: MAKE_STD_ZVAL(tmp_inc_filename); 6977: ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); 6978: zval_copy_ctor(tmp_inc_filename); 6979: convert_to_string(tmp_inc_filename); 6980: inc_filename = tmp_inc_filename; 6981: } 6982: 6983: if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { 6984: if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { 6985: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 6986: } else { 6987: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 6988: } 6989: } else { 6990: switch (opline->extended_value) { 6991: case ZEND_INCLUDE_ONCE: 6992: case ZEND_REQUIRE_ONCE: { 6993: zend_file_handle file_handle; 6994: char *resolved_path; 6995: 6996: resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); 6997: if (resolved_path) { 6998: failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); 6999: } else { 7000: resolved_path = Z_STRVAL_P(inc_filename); 7001: } 7002: 7003: if (failure_retval) { 7004: /* do nothing, file already included */ 7005: } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) { 7006: 7007: if (!file_handle.opened_path) { 7008: file_handle.opened_path = estrdup(resolved_path); 7009: } 7010: 7011: if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { 7012: new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); 7013: zend_destroy_file_handle(&file_handle TSRMLS_CC); 7014: } else { 7015: zend_file_handle_dtor(&file_handle TSRMLS_CC); 7016: failure_retval=1; 7017: } 7018: } else { 7019: if (opline->extended_value == ZEND_INCLUDE_ONCE) { 7020: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 7021: } else { 7022: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 7023: } 7024: } 7025: if (resolved_path != Z_STRVAL_P(inc_filename)) { 7026: efree(resolved_path); 7027: } 7028: } 7029: break; 7030: case ZEND_INCLUDE: 7031: case ZEND_REQUIRE: 7032: new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC); 7033: break; 7034: case ZEND_EVAL: { 7035: char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC); 7036: 7037: new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC); 7038: efree(eval_desc); 7039: } 7040: break; 7041: EMPTY_SWITCH_DEFAULT_CASE() 7042: } 7043: } 7044: if (tmp_inc_filename) { 7045: zval_ptr_dtor(&tmp_inc_filename); 7046: } 7047: zval_dtor(free_op1.var); 7048: if (UNEXPECTED(EG(exception) != NULL)) { 7049: HANDLE_EXCEPTION(); 7050: } else if (EXPECTED(new_op_array != NULL)) { 7051: EX(original_return_value) = EG(return_value_ptr_ptr); 7052: EG(active_op_array) = new_op_array; 7053: if (RETURN_VALUE_USED(opline)) { 7054: EX_T(opline->result.var).var.ptr = NULL; 7055: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 7056: EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; 7057: } else { 7058: EG(return_value_ptr_ptr) = NULL; 7059: } 7060: 7061: EX(current_object) = EX(object); 7062: 7063: EX(function_state).function = (zend_function *) new_op_array; 7064: EX(object) = NULL; 7065: 7066: if (!EG(active_symbol_table)) { 7067: zend_rebuild_symbol_table(TSRMLS_C); 7068: } 7069: 7070: if (EXPECTED(zend_execute == execute)) { 7071: ZEND_VM_ENTER(); 7072: } else { 7073: zend_execute(new_op_array TSRMLS_CC); 7074: } 7075: 7076: EX(function_state).function = (zend_function *) EX(op_array); 7077: EX(object) = EX(current_object); 7078: 7079: EG(opline_ptr) = &EX(opline); 7080: EG(active_op_array) = EX(op_array); 7081: EG(return_value_ptr_ptr) = EX(original_return_value); 7082: destroy_op_array(new_op_array TSRMLS_CC); 7083: efree(new_op_array); 7084: if (UNEXPECTED(EG(exception) != NULL)) { 7085: zend_throw_exception_internal(NULL TSRMLS_CC); 7086: HANDLE_EXCEPTION(); 7087: } else if (RETURN_VALUE_USED(opline)) { 7088: if (!EX_T(opline->result.var).var.ptr) { /* there was no return statement */ 7089: zval *retval; 7090: 7091: ALLOC_ZVAL(retval); 7092: ZVAL_BOOL(retval, 1); 7093: INIT_PZVAL(retval); 7094: EX_T(opline->result.var).var.ptr = retval; 7095: } 7096: } 7097: 7098: } else if (RETURN_VALUE_USED(opline)) { 7099: zval *retval; 7100: 7101: ALLOC_ZVAL(retval); 7102: ZVAL_BOOL(retval, failure_retval); 7103: INIT_PZVAL(retval); 7104: AI_SET_PTR(&EX_T(opline->result.var), retval); 7105: } 7106: ZEND_VM_NEXT_OPCODE(); 7107: } 7108: 7109: static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7110: { 7111: USE_OPLINE 7112: zend_free_op free_op1; 7113: zval *array_ptr, **array_ptr_ptr; 7114: HashTable *fe_ht; 7115: zend_object_iterator *iter = NULL; 7116: zend_class_entry *ce = NULL; 7117: zend_bool is_empty = 0; 7118: 7119: SAVE_OPLINE(); 7120: 7121: if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && 7122: (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { 7123: array_ptr_ptr = NULL; 7124: if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { 7125: MAKE_STD_ZVAL(array_ptr); 7126: ZVAL_NULL(array_ptr); 7127: } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { 7128: if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { 7129: zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); 7130: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 7131: } 7132: 7133: ce = Z_OBJCE_PP(array_ptr_ptr); 7134: if (!ce || ce->get_iterator == NULL) { 7135: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 7136: Z_ADDREF_PP(array_ptr_ptr); 7137: } 7138: array_ptr = *array_ptr_ptr; 7139: } else { 7140: if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { 7141: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 7142: if (opline->extended_value & ZEND_FE_FETCH_BYREF) { 7143: Z_SET_ISREF_PP(array_ptr_ptr); 7144: } 7145: } 7146: array_ptr = *array_ptr_ptr; 7147: Z_ADDREF_P(array_ptr); 7148: } 7149: } else { 7150: array_ptr = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7151: if (1) { /* IS_TMP_VAR */ 7152: zval *tmp; 7153: 7154: ALLOC_ZVAL(tmp); 7155: INIT_PZVAL_COPY(tmp, array_ptr); 7156: array_ptr = tmp; 7157: if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 7158: ce = Z_OBJCE_P(array_ptr); 7159: if (ce && ce->get_iterator) { 7160: Z_DELREF_P(array_ptr); 7161: } 7162: } 7163: } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 7164: ce = Z_OBJCE_P(array_ptr); 7165: if (!ce || !ce->get_iterator) { 7166: Z_ADDREF_P(array_ptr); 7167: } 7168: } else if (IS_TMP_VAR == IS_CONST || 7169: ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && 7170: !Z_ISREF_P(array_ptr) && 7171: Z_REFCOUNT_P(array_ptr) > 1)) { 7172: zval *tmp; 7173: 7174: ALLOC_ZVAL(tmp); 7175: INIT_PZVAL_COPY(tmp, array_ptr); 7176: zval_copy_ctor(tmp); 7177: array_ptr = tmp; 7178: } else { 7179: Z_ADDREF_P(array_ptr); 7180: } 7181: } 7182: 7183: if (ce && ce->get_iterator) { 7184: iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC); 7185: 7186: if (iter && EXPECTED(EG(exception) == NULL)) { 7187: array_ptr = zend_iterator_wrap(iter TSRMLS_CC); 7188: } else { 7189: 7190: if (!EG(exception)) { 7191: zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); 7192: } 7193: zend_throw_exception_internal(NULL TSRMLS_CC); 7194: HANDLE_EXCEPTION(); 7195: } 7196: } 7197: 7198: EX_T(opline->result.var).fe.ptr = array_ptr; 7199: 7200: if (iter) { 7201: iter->index = 0; 7202: if (iter->funcs->rewind) { 7203: iter->funcs->rewind(iter TSRMLS_CC); 7204: if (UNEXPECTED(EG(exception) != NULL)) { 7205: zval_ptr_dtor(&array_ptr); 7206: 7207: HANDLE_EXCEPTION(); 7208: } 7209: } 7210: is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; 7211: if (UNEXPECTED(EG(exception) != NULL)) { 7212: zval_ptr_dtor(&array_ptr); 7213: 7214: HANDLE_EXCEPTION(); 7215: } 7216: iter->index = -1; /* will be set to 0 before using next handler */ 7217: } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { 7218: zend_hash_internal_pointer_reset(fe_ht); 7219: if (ce) { 7220: zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); 7221: while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { 7222: char *str_key; 7223: uint str_key_len; 7224: ulong int_key; 7225: zend_uchar key_type; 7226: 7227: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); 7228: if (key_type != HASH_KEY_NON_EXISTANT && 7229: (key_type == HASH_KEY_IS_LONG || 7230: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { 7231: break; 7232: } 7233: zend_hash_move_forward(fe_ht); 7234: } 7235: } 7236: is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; 7237: zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); 7238: } else { 7239: zend_error(E_WARNING, "Invalid argument supplied for foreach()"); 7240: is_empty = 1; 7241: } 7242: 7243: if (is_empty) { 7244: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 7245: } else { 7246: CHECK_EXCEPTION(); 7247: ZEND_VM_NEXT_OPCODE(); 7248: } 7249: } 7250: 7251: static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7252: { 7253: #if 0 || (IS_TMP_VAR != IS_UNUSED) 7254: USE_OPLINE 7255: 7256: SAVE_OPLINE(); 7257: if (IS_TMP_VAR != IS_UNUSED) { 7258: zend_free_op free_op1; 7259: zval *ptr = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7260: 7261: if (Z_TYPE_P(ptr) == IS_LONG) { 7262: EG(exit_status) = Z_LVAL_P(ptr); 7263: } else { 7264: zend_print_variable(ptr); 7265: } 7266: zval_dtor(free_op1.var); 7267: } 7268: #endif 7269: zend_bailout(); 7270: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 7271: } 7272: 7273: static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7274: { 7275: USE_OPLINE 7276: zval restored_error_reporting; 7277: 7278: SAVE_OPLINE(); 7279: if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) { 7280: Z_TYPE(restored_error_reporting) = IS_LONG; 7281: Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var); 7282: EG(error_reporting) = Z_LVAL(restored_error_reporting); 7283: convert_to_string(&restored_error_reporting); 7284: if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) { 7285: if (EXPECTED(EG(error_reporting_ini_entry)->modified && 7286: EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) { 7287: efree(EG(error_reporting_ini_entry)->value); 7288: } 7289: EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting); 7290: EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting); 7291: } else { 7292: zendi_zval_dtor(restored_error_reporting); 7293: } 7294: } 7295: if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) { 7296: EX(old_error_reporting) = NULL; 7297: } 7298: CHECK_EXCEPTION(); 7299: ZEND_VM_NEXT_OPCODE(); 7300: } 7301: 7302: static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7303: { 7304: USE_OPLINE 7305: zend_free_op free_op1; 7306: zval *value; 7307: 7308: SAVE_OPLINE(); 7309: value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7310: 7311: if (i_zend_is_true(value)) { 7312: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 7313: if (!1) { 7314: zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); 7315: } 7316: 7317: #if DEBUG_ZEND>=2 7318: printf("Conditional jmp to %d\n", opline->op2.opline_num); 7319: #endif 7320: ZEND_VM_JMP(opline->op2.jmp_addr); 7321: } 7322: 7323: zval_dtor(free_op1.var); 7324: CHECK_EXCEPTION(); 7325: ZEND_VM_NEXT_OPCODE(); 7326: } 7327: 7328: static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7329: { 7330: USE_OPLINE 7331: zend_free_op free_op1; 7332: zval *value, *ret; 7333: 7334: SAVE_OPLINE(); 7335: value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7336: 7337: if (i_zend_is_true(value)) { 7338: if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 7339: Z_ADDREF_P(value); 7340: EX_T(opline->result.var).var.ptr = value; 7341: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 7342: } else { 7343: ALLOC_ZVAL(ret); 7344: INIT_PZVAL_COPY(ret, value); 7345: EX_T(opline->result.var).var.ptr = ret; 7346: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 7347: if (!1) { 7348: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 7349: } 7350: } 7351: 7352: #if DEBUG_ZEND>=2 7353: printf("Conditional jmp to %d\n", opline->op2.opline_num); 7354: #endif 7355: ZEND_VM_JMP(opline->op2.jmp_addr); 7356: } 7357: 7358: zval_dtor(free_op1.var); 7359: CHECK_EXCEPTION(); 7360: ZEND_VM_NEXT_OPCODE(); 7361: } 7362: 7363: static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7364: { 7365: USE_OPLINE 7366: zend_free_op free_op1; 7367: zval *value; 7368: 7369: SAVE_OPLINE(); 7370: value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7371: 7372: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 7373: if (!1) { 7374: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 7375: } 7376: 7377: CHECK_EXCEPTION(); 7378: ZEND_VM_NEXT_OPCODE(); 7379: } 7380: 7381: static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7382: { 7383: USE_OPLINE 7384: zend_free_op free_op1; 7385: zval *value, *ret; 7386: 7387: SAVE_OPLINE(); 7388: value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7389: 7390: if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 7391: Z_ADDREF_P(value); 7392: EX_T(opline->result.var).var.ptr = value; 7393: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 7394: } else { 7395: ALLOC_ZVAL(ret); 7396: INIT_PZVAL_COPY(ret, value); 7397: EX_T(opline->result.var).var.ptr = ret; 7398: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 7399: if (!1) { 7400: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 7401: } 7402: } 7403: 7404: CHECK_EXCEPTION(); 7405: ZEND_VM_NEXT_OPCODE(); 7406: } 7407: 7408: static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7409: { 7410: USE_OPLINE 7411: zend_free_op free_op1; 7412: zval *expr; 7413: zend_bool result; 7414: 7415: SAVE_OPLINE(); 7416: expr = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7417: 7418: if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { 7419: result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); 7420: } else { 7421: result = 0; 7422: } 7423: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); 7424: zval_dtor(free_op1.var); 7425: CHECK_EXCEPTION(); 7426: ZEND_VM_NEXT_OPCODE(); 7427: } 7428: 7429: static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7430: { 7431: USE_OPLINE 7432: zend_free_op free_op1; 7433: 7434: SAVE_OPLINE(); 7435: fast_add_function(&EX_T(opline->result.var).tmp_var, 7436: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7437: opline->op2.zv TSRMLS_CC); 7438: zval_dtor(free_op1.var); 7439: 7440: CHECK_EXCEPTION(); 7441: ZEND_VM_NEXT_OPCODE(); 7442: } 7443: 7444: static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7445: { 7446: USE_OPLINE 7447: zend_free_op free_op1; 7448: 7449: SAVE_OPLINE(); 7450: fast_sub_function(&EX_T(opline->result.var).tmp_var, 7451: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7452: opline->op2.zv TSRMLS_CC); 7453: zval_dtor(free_op1.var); 7454: 7455: CHECK_EXCEPTION(); 7456: ZEND_VM_NEXT_OPCODE(); 7457: } 7458: 7459: static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7460: { 7461: USE_OPLINE 7462: zend_free_op free_op1; 7463: 7464: SAVE_OPLINE(); 7465: fast_mul_function(&EX_T(opline->result.var).tmp_var, 7466: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7467: opline->op2.zv TSRMLS_CC); 7468: zval_dtor(free_op1.var); 7469: 7470: CHECK_EXCEPTION(); 7471: ZEND_VM_NEXT_OPCODE(); 7472: } 7473: 7474: static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7475: { 7476: USE_OPLINE 7477: zend_free_op free_op1; 7478: 7479: SAVE_OPLINE(); 7480: fast_div_function(&EX_T(opline->result.var).tmp_var, 7481: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7482: opline->op2.zv TSRMLS_CC); 7483: zval_dtor(free_op1.var); 7484: 7485: CHECK_EXCEPTION(); 7486: ZEND_VM_NEXT_OPCODE(); 7487: } 7488: 7489: static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7490: { 7491: USE_OPLINE 7492: zend_free_op free_op1; 7493: 7494: SAVE_OPLINE(); 7495: fast_mod_function(&EX_T(opline->result.var).tmp_var, 7496: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7497: opline->op2.zv TSRMLS_CC); 7498: zval_dtor(free_op1.var); 7499: 7500: CHECK_EXCEPTION(); 7501: ZEND_VM_NEXT_OPCODE(); 7502: } 7503: 7504: static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7505: { 7506: USE_OPLINE 7507: zend_free_op free_op1; 7508: 7509: SAVE_OPLINE(); 7510: shift_left_function(&EX_T(opline->result.var).tmp_var, 7511: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7512: opline->op2.zv TSRMLS_CC); 7513: zval_dtor(free_op1.var); 7514: 7515: CHECK_EXCEPTION(); 7516: ZEND_VM_NEXT_OPCODE(); 7517: } 7518: 7519: static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7520: { 7521: USE_OPLINE 7522: zend_free_op free_op1; 7523: 7524: SAVE_OPLINE(); 7525: shift_right_function(&EX_T(opline->result.var).tmp_var, 7526: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7527: opline->op2.zv TSRMLS_CC); 7528: zval_dtor(free_op1.var); 7529: 7530: CHECK_EXCEPTION(); 7531: ZEND_VM_NEXT_OPCODE(); 7532: } 7533: 7534: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7535: { 7536: USE_OPLINE 7537: zend_free_op free_op1; 7538: 7539: SAVE_OPLINE(); 7540: concat_function(&EX_T(opline->result.var).tmp_var, 7541: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7542: opline->op2.zv TSRMLS_CC); 7543: zval_dtor(free_op1.var); 7544: 7545: CHECK_EXCEPTION(); 7546: ZEND_VM_NEXT_OPCODE(); 7547: } 7548: 7549: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7550: { 7551: USE_OPLINE 7552: zend_free_op free_op1; 7553: 7554: SAVE_OPLINE(); 7555: is_identical_function(&EX_T(opline->result.var).tmp_var, 7556: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7557: opline->op2.zv TSRMLS_CC); 7558: zval_dtor(free_op1.var); 7559: 7560: CHECK_EXCEPTION(); 7561: ZEND_VM_NEXT_OPCODE(); 7562: } 7563: 7564: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7565: { 7566: USE_OPLINE 7567: zend_free_op free_op1; 7568: zval *result = &EX_T(opline->result.var).tmp_var; 7569: 7570: SAVE_OPLINE(); 7571: is_identical_function(result, 7572: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7573: opline->op2.zv TSRMLS_CC); 7574: Z_LVAL_P(result) = !Z_LVAL_P(result); 7575: zval_dtor(free_op1.var); 7576: 7577: CHECK_EXCEPTION(); 7578: ZEND_VM_NEXT_OPCODE(); 7579: } 7580: 7581: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7582: { 7583: USE_OPLINE 7584: zend_free_op free_op1; 7585: zval *result = &EX_T(opline->result.var).tmp_var; 7586: 7587: SAVE_OPLINE(); 7588: ZVAL_BOOL(result, fast_equal_function(result, 7589: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7590: opline->op2.zv TSRMLS_CC)); 7591: zval_dtor(free_op1.var); 7592: 7593: CHECK_EXCEPTION(); 7594: ZEND_VM_NEXT_OPCODE(); 7595: } 7596: 7597: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7598: { 7599: USE_OPLINE 7600: zend_free_op free_op1; 7601: zval *result = &EX_T(opline->result.var).tmp_var; 7602: 7603: SAVE_OPLINE(); 7604: ZVAL_BOOL(result, fast_not_equal_function(result, 7605: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7606: opline->op2.zv TSRMLS_CC)); 7607: zval_dtor(free_op1.var); 7608: 7609: CHECK_EXCEPTION(); 7610: ZEND_VM_NEXT_OPCODE(); 7611: } 7612: 7613: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7614: { 7615: USE_OPLINE 7616: zend_free_op free_op1; 7617: zval *result = &EX_T(opline->result.var).tmp_var; 7618: 7619: SAVE_OPLINE(); 7620: ZVAL_BOOL(result, fast_is_smaller_function(result, 7621: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7622: opline->op2.zv TSRMLS_CC)); 7623: zval_dtor(free_op1.var); 7624: 7625: CHECK_EXCEPTION(); 7626: ZEND_VM_NEXT_OPCODE(); 7627: } 7628: 7629: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7630: { 7631: USE_OPLINE 7632: zend_free_op free_op1; 7633: zval *result = &EX_T(opline->result.var).tmp_var; 7634: 7635: SAVE_OPLINE(); 7636: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 7637: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7638: opline->op2.zv TSRMLS_CC)); 7639: zval_dtor(free_op1.var); 7640: 7641: CHECK_EXCEPTION(); 7642: ZEND_VM_NEXT_OPCODE(); 7643: } 7644: 7645: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7646: { 7647: USE_OPLINE 7648: zend_free_op free_op1; 7649: 7650: SAVE_OPLINE(); 7651: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 7652: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7653: opline->op2.zv TSRMLS_CC); 7654: zval_dtor(free_op1.var); 7655: 7656: CHECK_EXCEPTION(); 7657: ZEND_VM_NEXT_OPCODE(); 7658: } 7659: 7660: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7661: { 7662: USE_OPLINE 7663: zend_free_op free_op1; 7664: 7665: SAVE_OPLINE(); 7666: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 7667: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7668: opline->op2.zv TSRMLS_CC); 7669: zval_dtor(free_op1.var); 7670: 7671: CHECK_EXCEPTION(); 7672: ZEND_VM_NEXT_OPCODE(); 7673: } 7674: 7675: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7676: { 7677: USE_OPLINE 7678: zend_free_op free_op1; 7679: 7680: SAVE_OPLINE(); 7681: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 7682: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7683: opline->op2.zv TSRMLS_CC); 7684: zval_dtor(free_op1.var); 7685: 7686: CHECK_EXCEPTION(); 7687: ZEND_VM_NEXT_OPCODE(); 7688: } 7689: 7690: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7691: { 7692: USE_OPLINE 7693: zend_free_op free_op1; 7694: 7695: SAVE_OPLINE(); 7696: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 7697: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 7698: opline->op2.zv TSRMLS_CC); 7699: zval_dtor(free_op1.var); 7700: 7701: CHECK_EXCEPTION(); 7702: ZEND_VM_NEXT_OPCODE(); 7703: } 7704: 7705: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) 7706: { 7707: USE_OPLINE 7708: zend_free_op free_op1; 7709: zval *varname; 7710: zval **retval; 7711: zval tmp_varname; 7712: HashTable *target_symbol_table; 7713: ulong hash_value; 7714: 7715: SAVE_OPLINE(); 7716: varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7717: 7718: if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 7719: ZVAL_COPY_VALUE(&tmp_varname, varname); 7720: zval_copy_ctor(&tmp_varname); 7721: Z_SET_REFCOUNT(tmp_varname, 1); 7722: Z_UNSET_ISREF(tmp_varname); 7723: convert_to_string(&tmp_varname); 7724: varname = &tmp_varname; 7725: } 7726: 7727: if (IS_CONST != IS_UNUSED) { 7728: zend_class_entry *ce; 7729: 7730: if (IS_CONST == IS_CONST) { 7731: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 7732: ce = CACHED_PTR(opline->op2.literal->cache_slot); 7733: } else { 7734: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 7735: if (UNEXPECTED(ce == NULL)) { 7736: if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { 7737: zval_dtor(&tmp_varname); 7738: } 7739: zval_dtor(free_op1.var); 7740: CHECK_EXCEPTION(); 7741: ZEND_VM_NEXT_OPCODE(); 7742: } 7743: CACHE_PTR(opline->op2.literal->cache_slot, ce); 7744: } 7745: } else { 7746: ce = EX_T(opline->op2.var).class_entry; 7747: } 7748: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 7749: zval_dtor(free_op1.var); 7750: } else { 7751: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 7752: /* 7753: if (!target_symbol_table) { 7754: CHECK_EXCEPTION(); 7755: ZEND_VM_NEXT_OPCODE(); 7756: } 7757: */ 7758: if (IS_TMP_VAR == IS_CONST) { 7759: hash_value = Z_HASH_P(varname); 7760: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 7761: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 7762: } else { 7763: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 7764: } 7765: 7766: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 7767: switch (type) { 7768: case BP_VAR_R: 7769: case BP_VAR_UNSET: 7770: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 7771: /* break missing intentionally */ 7772: case BP_VAR_IS: 7773: retval = &EG(uninitialized_zval_ptr); 7774: break; 7775: case BP_VAR_RW: 7776: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 7777: /* break missing intentionally */ 7778: case BP_VAR_W: 7779: Z_ADDREF_P(&EG(uninitialized_zval)); 7780: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 7781: break; 7782: EMPTY_SWITCH_DEFAULT_CASE() 7783: } 7784: } 7785: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 7786: case ZEND_FETCH_GLOBAL: 7787: if (IS_TMP_VAR != IS_TMP_VAR) { 7788: zval_dtor(free_op1.var); 7789: } 7790: break; 7791: case ZEND_FETCH_LOCAL: 7792: zval_dtor(free_op1.var); 7793: break; 7794: case ZEND_FETCH_STATIC: 7795: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 7796: break; 7797: case ZEND_FETCH_GLOBAL_LOCK: 7798: if (IS_TMP_VAR == IS_VAR && !free_op1.var) { 7799: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 7800: } 7801: break; 7802: } 7803: } 7804: 7805: 7806: if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { 7807: zval_dtor(&tmp_varname); 7808: } 7809: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 7810: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 7811: } 7812: PZVAL_LOCK(*retval); 7813: switch (type) { 7814: case BP_VAR_R: 7815: case BP_VAR_IS: 7816: AI_SET_PTR(&EX_T(opline->result.var), *retval); 7817: break; 7818: case BP_VAR_UNSET: { 7819: zend_free_op free_res; 7820: 7821: PZVAL_UNLOCK(*retval, &free_res); 7822: if (retval != &EG(uninitialized_zval_ptr)) { 7823: SEPARATE_ZVAL_IF_NOT_REF(retval); 7824: } 7825: PZVAL_LOCK(*retval); 7826: FREE_OP_VAR_PTR(free_res); 7827: } 7828: /* break missing intentionally */ 7829: default: 7830: EX_T(opline->result.var).var.ptr_ptr = retval; 7831: break; 7832: } 7833: CHECK_EXCEPTION(); 7834: ZEND_VM_NEXT_OPCODE(); 7835: } 7836: 7837: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7838: { 7839: return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 7840: } 7841: 7842: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7843: { 7844: return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 7845: } 7846: 7847: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7848: { 7849: return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 7850: } 7851: 7852: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7853: { 7854: USE_OPLINE 7855: 7856: return zend_fetch_var_address_helper_SPEC_TMP_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 7857: } 7858: 7859: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7860: { 7861: return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 7862: } 7863: 7864: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7865: { 7866: return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 7867: } 7868: 7869: static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7870: { 7871: USE_OPLINE 7872: zend_free_op free_op1; 7873: zval *container; 7874: 7875: SAVE_OPLINE(); 7876: container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7877: 7878: if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { 7879: PZVAL_LOCK(&EG(uninitialized_zval)); 7880: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 7881: } else { 7882: 7883: zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); 7884: 7885: PZVAL_LOCK(value); 7886: AI_SET_PTR(&EX_T(opline->result.var), value); 7887: 7888: } 7889: CHECK_EXCEPTION(); 7890: ZEND_VM_NEXT_OPCODE(); 7891: } 7892: 7893: static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7894: { 7895: USE_OPLINE 7896: zval *str = &EX_T(opline->result.var).tmp_var; 7897: 7898: SAVE_OPLINE(); 7899: 7900: if (IS_TMP_VAR == IS_UNUSED) { 7901: /* Initialize for erealloc in add_char_to_string */ 7902: Z_STRVAL_P(str) = NULL; 7903: Z_STRLEN_P(str) = 0; 7904: Z_TYPE_P(str) = IS_STRING; 7905: 7906: INIT_PZVAL(str); 7907: } 7908: 7909: add_char_to_string(str, str, opline->op2.zv); 7910: 7911: /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ 7912: /*CHECK_EXCEPTION();*/ 7913: ZEND_VM_NEXT_OPCODE(); 7914: } 7915: 7916: static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7917: { 7918: USE_OPLINE 7919: zval *str = &EX_T(opline->result.var).tmp_var; 7920: 7921: SAVE_OPLINE(); 7922: 7923: if (IS_TMP_VAR == IS_UNUSED) { 7924: /* Initialize for erealloc in add_string_to_string */ 7925: Z_STRVAL_P(str) = NULL; 7926: Z_STRLEN_P(str) = 0; 7927: Z_TYPE_P(str) = IS_STRING; 7928: 7929: INIT_PZVAL(str); 7930: } 7931: 7932: add_string_to_string(str, str, opline->op2.zv); 7933: 7934: /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ 7935: /*CHECK_EXCEPTION();*/ 7936: ZEND_VM_NEXT_OPCODE(); 7937: } 7938: 7939: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 7940: { 7941: USE_OPLINE 7942: zval *function_name; 7943: char *function_name_strval; 7944: int function_name_strlen; 7945: zend_free_op free_op1; 7946: 7947: SAVE_OPLINE(); 7948: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 7949: 7950: function_name = opline->op2.zv; 7951: 7952: if (IS_CONST != IS_CONST && 7953: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 7954: zend_error_noreturn(E_ERROR, "Method name must be a string"); 7955: } 7956: 7957: function_name_strval = Z_STRVAL_P(function_name); 7958: function_name_strlen = Z_STRLEN_P(function_name); 7959: 7960: EX(object) = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 7961: 7962: if (EXPECTED(EX(object) != NULL) && 7963: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 7964: EX(called_scope) = Z_OBJCE_P(EX(object)); 7965: 7966: if (IS_CONST != IS_CONST || 7967: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 7968: zval *object = EX(object); 7969: 7970: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 7971: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 7972: } 7973: 7974: /* First, locate the function. */ 7975: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 7976: if (UNEXPECTED(EX(fbc) == NULL)) { 7977: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 7978: } 7979: if (IS_CONST == IS_CONST && 7980: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 7981: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 7982: EXPECTED(EX(object) == object)) { 7983: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 7984: } 7985: } 7986: } else { 7987: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 7988: } 7989: 7990: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 7991: EX(object) = NULL; 7992: } else { 7993: if (!PZVAL_IS_REF(EX(object))) { 7994: Z_ADDREF_P(EX(object)); /* For $this pointer */ 7995: } else { 7996: zval *this_ptr; 7997: ALLOC_ZVAL(this_ptr); 7998: INIT_PZVAL_COPY(this_ptr, EX(object)); 7999: zval_copy_ctor(this_ptr); 8000: EX(object) = this_ptr; 8001: } 8002: } 8003: 8004: 8005: CHECK_EXCEPTION(); 8006: ZEND_VM_NEXT_OPCODE(); 8007: } 8008: 8009: static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8010: { 8011: USE_OPLINE 8012: zend_free_op free_op1; 8013: 8014: SAVE_OPLINE(); 8015: if (IS_TMP_VAR==IS_VAR) { 8016: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 8017: } 8018: is_equal_function(&EX_T(opline->result.var).tmp_var, 8019: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8020: opline->op2.zv TSRMLS_CC); 8021: 8022: CHECK_EXCEPTION(); 8023: ZEND_VM_NEXT_OPCODE(); 8024: } 8025: 8026: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8027: { 8028: USE_OPLINE 8029: zend_free_op free_op1; 8030: zval *expr_ptr; 8031: 8032: SAVE_OPLINE(); 8033: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 8034: zval **expr_ptr_ptr = NULL; 8035: 8036: if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 8037: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 8038: } 8039: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 8040: expr_ptr = *expr_ptr_ptr; 8041: Z_ADDREF_P(expr_ptr); 8042: } else { 8043: expr_ptr=_get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 8044: if (1) { /* temporary variable */ 8045: zval *new_expr; 8046: 8047: ALLOC_ZVAL(new_expr); 8048: INIT_PZVAL_COPY(new_expr, expr_ptr); 8049: expr_ptr = new_expr; 8050: } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 8051: zval *new_expr; 8052: 8053: ALLOC_ZVAL(new_expr); 8054: INIT_PZVAL_COPY(new_expr, expr_ptr); 8055: expr_ptr = new_expr; 8056: zendi_zval_copy_ctor(*expr_ptr); 8057: } else { 8058: Z_ADDREF_P(expr_ptr); 8059: } 8060: } 8061: 8062: if (IS_CONST != IS_UNUSED) { 8063: 8064: zval *offset = opline->op2.zv; 8065: ulong hval; 8066: 8067: switch (Z_TYPE_P(offset)) { 8068: case IS_DOUBLE: 8069: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 8070: goto num_index; 8071: case IS_LONG: 8072: case IS_BOOL: 8073: hval = Z_LVAL_P(offset); 8074: num_index: 8075: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 8076: break; 8077: case IS_STRING: 8078: if (IS_CONST == IS_CONST) { 8079: hval = Z_HASH_P(offset); 8080: } else { 8081: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 8082: if (IS_INTERNED(Z_STRVAL_P(offset))) { 8083: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 8084: } else { 8085: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 8086: } 8087: } 8088: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 8089: break; 8090: case IS_NULL: 8091: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 8092: break; 8093: default: 8094: zend_error(E_WARNING, "Illegal offset type"); 8095: zval_ptr_dtor(&expr_ptr); 8096: /* do nothing */ 8097: break; 8098: } 8099: 8100: } else { 8101: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 8102: } 8103: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 8104: 8105: } else { 8106: 8107: } 8108: CHECK_EXCEPTION(); 8109: ZEND_VM_NEXT_OPCODE(); 8110: } 8111: 8112: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8113: { 8114: USE_OPLINE 8115: 8116: array_init(&EX_T(opline->result.var).tmp_var); 8117: if (IS_TMP_VAR == IS_UNUSED) { 8118: ZEND_VM_NEXT_OPCODE(); 8119: #if 0 || IS_TMP_VAR != IS_UNUSED 8120: } else { 8121: return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 8122: #endif 8123: } 8124: } 8125: 8126: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8127: { 8128: USE_OPLINE 8129: zval tmp, *varname; 8130: HashTable *target_symbol_table; 8131: zend_free_op free_op1; 8132: 8133: SAVE_OPLINE(); 8134: if (IS_TMP_VAR == IS_CV && 8135: IS_CONST == IS_UNUSED && 8136: (opline->extended_value & ZEND_QUICK_SET)) { 8137: if (EG(active_symbol_table)) { 8138: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 8139: 8140: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 8141: EX_CV(opline->op1.var) = NULL; 8142: } else if (EX_CV(opline->op1.var)) { 8143: zval_ptr_dtor(EX_CV(opline->op1.var)); 8144: EX_CV(opline->op1.var) = NULL; 8145: } 8146: CHECK_EXCEPTION(); 8147: ZEND_VM_NEXT_OPCODE(); 8148: } 8149: 8150: varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 8151: 8152: if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 8153: ZVAL_COPY_VALUE(&tmp, varname); 8154: zval_copy_ctor(&tmp); 8155: convert_to_string(&tmp); 8156: varname = &tmp; 8157: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 8158: Z_ADDREF_P(varname); 8159: } 8160: 8161: if (IS_CONST != IS_UNUSED) { 8162: zend_class_entry *ce; 8163: 8164: if (IS_CONST == IS_CONST) { 8165: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 8166: ce = CACHED_PTR(opline->op2.literal->cache_slot); 8167: } else { 8168: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 8169: if (UNEXPECTED(EG(exception) != NULL)) { 8170: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 8171: zval_dtor(&tmp); 8172: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 8173: zval_ptr_dtor(&varname); 8174: } 8175: zval_dtor(free_op1.var); 8176: HANDLE_EXCEPTION(); 8177: } 8178: if (UNEXPECTED(ce == NULL)) { 8179: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 8180: } 8181: CACHE_PTR(opline->op2.literal->cache_slot, ce); 8182: } 8183: } else { 8184: ce = EX_T(opline->op2.var).class_entry; 8185: } 8186: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 8187: } else { 8188: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 8189: 8190: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 8191: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 8192: } 8193: 8194: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 8195: zval_dtor(&tmp); 8196: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 8197: zval_ptr_dtor(&varname); 8198: } 8199: zval_dtor(free_op1.var); 8200: CHECK_EXCEPTION(); 8201: ZEND_VM_NEXT_OPCODE(); 8202: } 8203: 8204: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8205: { 8206: USE_OPLINE 8207: zval **value; 8208: zend_bool isset = 1; 8209: 8210: SAVE_OPLINE(); 8211: if (IS_TMP_VAR == IS_CV && 8212: IS_CONST == IS_UNUSED && 8213: (opline->extended_value & ZEND_QUICK_SET)) { 8214: if (EX_CV(opline->op1.var)) { 8215: value = EX_CV(opline->op1.var); 8216: } else if (EG(active_symbol_table)) { 8217: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 8218: 8219: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 8220: isset = 0; 8221: } 8222: } else { 8223: isset = 0; 8224: } 8225: } else { 8226: HashTable *target_symbol_table; 8227: zend_free_op free_op1; 8228: zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 8229: 8230: if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 8231: ZVAL_COPY_VALUE(&tmp, varname); 8232: zval_copy_ctor(&tmp); 8233: convert_to_string(&tmp); 8234: varname = &tmp; 8235: } 8236: 8237: if (IS_CONST != IS_UNUSED) { 8238: zend_class_entry *ce; 8239: 8240: if (IS_CONST == IS_CONST) { 8241: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 8242: ce = CACHED_PTR(opline->op2.literal->cache_slot); 8243: } else { 8244: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 8245: if (UNEXPECTED(ce == NULL)) { 8246: CHECK_EXCEPTION(); 8247: ZEND_VM_NEXT_OPCODE(); 8248: } 8249: CACHE_PTR(opline->op2.literal->cache_slot, ce); 8250: } 8251: } else { 8252: ce = EX_T(opline->op2.var).class_entry; 8253: } 8254: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 8255: if (!value) { 8256: isset = 0; 8257: } 8258: } else { 8259: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 8260: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 8261: isset = 0; 8262: } 8263: } 8264: 8265: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 8266: zval_dtor(&tmp); 8267: } 8268: zval_dtor(free_op1.var); 8269: } 8270: 8271: if (opline->extended_value & ZEND_ISSET) { 8272: if (isset && Z_TYPE_PP(value) != IS_NULL) { 8273: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 8274: } else { 8275: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 8276: } 8277: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 8278: if (!isset || !i_zend_is_true(*value)) { 8279: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 8280: } else { 8281: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 8282: } 8283: } 8284: 8285: CHECK_EXCEPTION(); 8286: ZEND_VM_NEXT_OPCODE(); 8287: } 8288: 8289: static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8290: { 8291: USE_OPLINE 8292: zend_free_op free_op1, free_op2; 8293: 8294: SAVE_OPLINE(); 8295: fast_add_function(&EX_T(opline->result.var).tmp_var, 8296: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8297: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8298: zval_dtor(free_op1.var); 8299: zval_dtor(free_op2.var); 8300: CHECK_EXCEPTION(); 8301: ZEND_VM_NEXT_OPCODE(); 8302: } 8303: 8304: static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8305: { 8306: USE_OPLINE 8307: zend_free_op free_op1, free_op2; 8308: 8309: SAVE_OPLINE(); 8310: fast_sub_function(&EX_T(opline->result.var).tmp_var, 8311: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8312: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8313: zval_dtor(free_op1.var); 8314: zval_dtor(free_op2.var); 8315: CHECK_EXCEPTION(); 8316: ZEND_VM_NEXT_OPCODE(); 8317: } 8318: 8319: static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8320: { 8321: USE_OPLINE 8322: zend_free_op free_op1, free_op2; 8323: 8324: SAVE_OPLINE(); 8325: fast_mul_function(&EX_T(opline->result.var).tmp_var, 8326: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8327: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8328: zval_dtor(free_op1.var); 8329: zval_dtor(free_op2.var); 8330: CHECK_EXCEPTION(); 8331: ZEND_VM_NEXT_OPCODE(); 8332: } 8333: 8334: static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8335: { 8336: USE_OPLINE 8337: zend_free_op free_op1, free_op2; 8338: 8339: SAVE_OPLINE(); 8340: fast_div_function(&EX_T(opline->result.var).tmp_var, 8341: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8342: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8343: zval_dtor(free_op1.var); 8344: zval_dtor(free_op2.var); 8345: CHECK_EXCEPTION(); 8346: ZEND_VM_NEXT_OPCODE(); 8347: } 8348: 8349: static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8350: { 8351: USE_OPLINE 8352: zend_free_op free_op1, free_op2; 8353: 8354: SAVE_OPLINE(); 8355: fast_mod_function(&EX_T(opline->result.var).tmp_var, 8356: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8357: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8358: zval_dtor(free_op1.var); 8359: zval_dtor(free_op2.var); 8360: CHECK_EXCEPTION(); 8361: ZEND_VM_NEXT_OPCODE(); 8362: } 8363: 8364: static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8365: { 8366: USE_OPLINE 8367: zend_free_op free_op1, free_op2; 8368: 8369: SAVE_OPLINE(); 8370: shift_left_function(&EX_T(opline->result.var).tmp_var, 8371: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8372: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8373: zval_dtor(free_op1.var); 8374: zval_dtor(free_op2.var); 8375: CHECK_EXCEPTION(); 8376: ZEND_VM_NEXT_OPCODE(); 8377: } 8378: 8379: static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8380: { 8381: USE_OPLINE 8382: zend_free_op free_op1, free_op2; 8383: 8384: SAVE_OPLINE(); 8385: shift_right_function(&EX_T(opline->result.var).tmp_var, 8386: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8387: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8388: zval_dtor(free_op1.var); 8389: zval_dtor(free_op2.var); 8390: CHECK_EXCEPTION(); 8391: ZEND_VM_NEXT_OPCODE(); 8392: } 8393: 8394: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8395: { 8396: USE_OPLINE 8397: zend_free_op free_op1, free_op2; 8398: 8399: SAVE_OPLINE(); 8400: concat_function(&EX_T(opline->result.var).tmp_var, 8401: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8402: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8403: zval_dtor(free_op1.var); 8404: zval_dtor(free_op2.var); 8405: CHECK_EXCEPTION(); 8406: ZEND_VM_NEXT_OPCODE(); 8407: } 8408: 8409: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8410: { 8411: USE_OPLINE 8412: zend_free_op free_op1, free_op2; 8413: 8414: SAVE_OPLINE(); 8415: is_identical_function(&EX_T(opline->result.var).tmp_var, 8416: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8417: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8418: zval_dtor(free_op1.var); 8419: zval_dtor(free_op2.var); 8420: CHECK_EXCEPTION(); 8421: ZEND_VM_NEXT_OPCODE(); 8422: } 8423: 8424: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8425: { 8426: USE_OPLINE 8427: zend_free_op free_op1, free_op2; 8428: zval *result = &EX_T(opline->result.var).tmp_var; 8429: 8430: SAVE_OPLINE(); 8431: is_identical_function(result, 8432: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8433: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8434: Z_LVAL_P(result) = !Z_LVAL_P(result); 8435: zval_dtor(free_op1.var); 8436: zval_dtor(free_op2.var); 8437: CHECK_EXCEPTION(); 8438: ZEND_VM_NEXT_OPCODE(); 8439: } 8440: 8441: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8442: { 8443: USE_OPLINE 8444: zend_free_op free_op1, free_op2; 8445: zval *result = &EX_T(opline->result.var).tmp_var; 8446: 8447: SAVE_OPLINE(); 8448: ZVAL_BOOL(result, fast_equal_function(result, 8449: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8450: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8451: zval_dtor(free_op1.var); 8452: zval_dtor(free_op2.var); 8453: CHECK_EXCEPTION(); 8454: ZEND_VM_NEXT_OPCODE(); 8455: } 8456: 8457: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8458: { 8459: USE_OPLINE 8460: zend_free_op free_op1, free_op2; 8461: zval *result = &EX_T(opline->result.var).tmp_var; 8462: 8463: SAVE_OPLINE(); 8464: ZVAL_BOOL(result, fast_not_equal_function(result, 8465: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8466: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8467: zval_dtor(free_op1.var); 8468: zval_dtor(free_op2.var); 8469: CHECK_EXCEPTION(); 8470: ZEND_VM_NEXT_OPCODE(); 8471: } 8472: 8473: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8474: { 8475: USE_OPLINE 8476: zend_free_op free_op1, free_op2; 8477: zval *result = &EX_T(opline->result.var).tmp_var; 8478: 8479: SAVE_OPLINE(); 8480: ZVAL_BOOL(result, fast_is_smaller_function(result, 8481: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8482: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8483: zval_dtor(free_op1.var); 8484: zval_dtor(free_op2.var); 8485: CHECK_EXCEPTION(); 8486: ZEND_VM_NEXT_OPCODE(); 8487: } 8488: 8489: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8490: { 8491: USE_OPLINE 8492: zend_free_op free_op1, free_op2; 8493: zval *result = &EX_T(opline->result.var).tmp_var; 8494: 8495: SAVE_OPLINE(); 8496: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 8497: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8498: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8499: zval_dtor(free_op1.var); 8500: zval_dtor(free_op2.var); 8501: CHECK_EXCEPTION(); 8502: ZEND_VM_NEXT_OPCODE(); 8503: } 8504: 8505: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8506: { 8507: USE_OPLINE 8508: zend_free_op free_op1, free_op2; 8509: 8510: SAVE_OPLINE(); 8511: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 8512: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8513: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8514: zval_dtor(free_op1.var); 8515: zval_dtor(free_op2.var); 8516: CHECK_EXCEPTION(); 8517: ZEND_VM_NEXT_OPCODE(); 8518: } 8519: 8520: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8521: { 8522: USE_OPLINE 8523: zend_free_op free_op1, free_op2; 8524: 8525: SAVE_OPLINE(); 8526: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 8527: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8528: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8529: zval_dtor(free_op1.var); 8530: zval_dtor(free_op2.var); 8531: CHECK_EXCEPTION(); 8532: ZEND_VM_NEXT_OPCODE(); 8533: } 8534: 8535: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8536: { 8537: USE_OPLINE 8538: zend_free_op free_op1, free_op2; 8539: 8540: SAVE_OPLINE(); 8541: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 8542: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8543: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8544: zval_dtor(free_op1.var); 8545: zval_dtor(free_op2.var); 8546: CHECK_EXCEPTION(); 8547: ZEND_VM_NEXT_OPCODE(); 8548: } 8549: 8550: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8551: { 8552: USE_OPLINE 8553: zend_free_op free_op1, free_op2; 8554: 8555: SAVE_OPLINE(); 8556: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 8557: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8558: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8559: zval_dtor(free_op1.var); 8560: zval_dtor(free_op2.var); 8561: CHECK_EXCEPTION(); 8562: ZEND_VM_NEXT_OPCODE(); 8563: } 8564: 8565: static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8566: { 8567: USE_OPLINE 8568: zend_free_op free_op2; 8569: zval *str = &EX_T(opline->result.var).tmp_var; 8570: zval *var; 8571: zval var_copy; 8572: int use_copy = 0; 8573: 8574: SAVE_OPLINE(); 8575: var = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 8576: 8577: if (IS_TMP_VAR == IS_UNUSED) { 8578: /* Initialize for erealloc in add_string_to_string */ 8579: Z_STRVAL_P(str) = NULL; 8580: Z_STRLEN_P(str) = 0; 8581: Z_TYPE_P(str) = IS_STRING; 8582: 8583: INIT_PZVAL(str); 8584: } 8585: 8586: if (Z_TYPE_P(var) != IS_STRING) { 8587: zend_make_printable_zval(var, &var_copy, &use_copy); 8588: 8589: if (use_copy) { 8590: var = &var_copy; 8591: } 8592: } 8593: add_string_to_string(str, str, var); 8594: 8595: if (use_copy) { 8596: zval_dtor(var); 8597: } 8598: /* original comment, possibly problematic: 8599: * FREE_OP is missing intentionally here - we're always working on the same temporary variable 8600: * (Zeev): I don't think it's problematic, we only use variables 8601: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're 8602: * string offsets or overloaded objects 8603: */ 8604: zval_dtor(free_op2.var); 8605: 8606: CHECK_EXCEPTION(); 8607: ZEND_VM_NEXT_OPCODE(); 8608: } 8609: 8610: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8611: { 8612: USE_OPLINE 8613: zval *function_name; 8614: char *function_name_strval; 8615: int function_name_strlen; 8616: zend_free_op free_op1, free_op2; 8617: 8618: SAVE_OPLINE(); 8619: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 8620: 8621: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 8622: 8623: if (IS_TMP_VAR != IS_CONST && 8624: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 8625: zend_error_noreturn(E_ERROR, "Method name must be a string"); 8626: } 8627: 8628: function_name_strval = Z_STRVAL_P(function_name); 8629: function_name_strlen = Z_STRLEN_P(function_name); 8630: 8631: EX(object) = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 8632: 8633: if (EXPECTED(EX(object) != NULL) && 8634: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 8635: EX(called_scope) = Z_OBJCE_P(EX(object)); 8636: 8637: if (IS_TMP_VAR != IS_CONST || 8638: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 8639: zval *object = EX(object); 8640: 8641: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 8642: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 8643: } 8644: 8645: /* First, locate the function. */ 8646: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 8647: if (UNEXPECTED(EX(fbc) == NULL)) { 8648: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 8649: } 8650: if (IS_TMP_VAR == IS_CONST && 8651: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 8652: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 8653: EXPECTED(EX(object) == object)) { 8654: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 8655: } 8656: } 8657: } else { 8658: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 8659: } 8660: 8661: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 8662: EX(object) = NULL; 8663: } else { 8664: if (!PZVAL_IS_REF(EX(object))) { 8665: Z_ADDREF_P(EX(object)); /* For $this pointer */ 8666: } else { 8667: zval *this_ptr; 8668: ALLOC_ZVAL(this_ptr); 8669: INIT_PZVAL_COPY(this_ptr, EX(object)); 8670: zval_copy_ctor(this_ptr); 8671: EX(object) = this_ptr; 8672: } 8673: } 8674: 8675: zval_dtor(free_op2.var); 8676: 8677: CHECK_EXCEPTION(); 8678: ZEND_VM_NEXT_OPCODE(); 8679: } 8680: 8681: static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8682: { 8683: USE_OPLINE 8684: zend_free_op free_op1, free_op2; 8685: 8686: SAVE_OPLINE(); 8687: if (IS_TMP_VAR==IS_VAR) { 8688: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 8689: } 8690: is_equal_function(&EX_T(opline->result.var).tmp_var, 8691: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8692: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8693: 8694: zval_dtor(free_op2.var); 8695: CHECK_EXCEPTION(); 8696: ZEND_VM_NEXT_OPCODE(); 8697: } 8698: 8699: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8700: { 8701: USE_OPLINE 8702: zend_free_op free_op1; 8703: zval *expr_ptr; 8704: 8705: SAVE_OPLINE(); 8706: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 8707: zval **expr_ptr_ptr = NULL; 8708: 8709: if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 8710: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 8711: } 8712: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 8713: expr_ptr = *expr_ptr_ptr; 8714: Z_ADDREF_P(expr_ptr); 8715: } else { 8716: expr_ptr=_get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 8717: if (1) { /* temporary variable */ 8718: zval *new_expr; 8719: 8720: ALLOC_ZVAL(new_expr); 8721: INIT_PZVAL_COPY(new_expr, expr_ptr); 8722: expr_ptr = new_expr; 8723: } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 8724: zval *new_expr; 8725: 8726: ALLOC_ZVAL(new_expr); 8727: INIT_PZVAL_COPY(new_expr, expr_ptr); 8728: expr_ptr = new_expr; 8729: zendi_zval_copy_ctor(*expr_ptr); 8730: } else { 8731: Z_ADDREF_P(expr_ptr); 8732: } 8733: } 8734: 8735: if (IS_TMP_VAR != IS_UNUSED) { 8736: zend_free_op free_op2; 8737: zval *offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 8738: ulong hval; 8739: 8740: switch (Z_TYPE_P(offset)) { 8741: case IS_DOUBLE: 8742: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 8743: goto num_index; 8744: case IS_LONG: 8745: case IS_BOOL: 8746: hval = Z_LVAL_P(offset); 8747: num_index: 8748: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 8749: break; 8750: case IS_STRING: 8751: if (IS_TMP_VAR == IS_CONST) { 8752: hval = Z_HASH_P(offset); 8753: } else { 8754: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 8755: if (IS_INTERNED(Z_STRVAL_P(offset))) { 8756: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 8757: } else { 8758: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 8759: } 8760: } 8761: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 8762: break; 8763: case IS_NULL: 8764: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 8765: break; 8766: default: 8767: zend_error(E_WARNING, "Illegal offset type"); 8768: zval_ptr_dtor(&expr_ptr); 8769: /* do nothing */ 8770: break; 8771: } 8772: zval_dtor(free_op2.var); 8773: } else { 8774: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 8775: } 8776: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 8777: 8778: } else { 8779: 8780: } 8781: CHECK_EXCEPTION(); 8782: ZEND_VM_NEXT_OPCODE(); 8783: } 8784: 8785: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8786: { 8787: USE_OPLINE 8788: 8789: array_init(&EX_T(opline->result.var).tmp_var); 8790: if (IS_TMP_VAR == IS_UNUSED) { 8791: ZEND_VM_NEXT_OPCODE(); 8792: #if 0 || IS_TMP_VAR != IS_UNUSED 8793: } else { 8794: return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 8795: #endif 8796: } 8797: } 8798: 8799: static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8800: { 8801: USE_OPLINE 8802: zend_free_op free_op1, free_op2; 8803: 8804: SAVE_OPLINE(); 8805: fast_add_function(&EX_T(opline->result.var).tmp_var, 8806: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8807: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8808: zval_dtor(free_op1.var); 8809: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8810: CHECK_EXCEPTION(); 8811: ZEND_VM_NEXT_OPCODE(); 8812: } 8813: 8814: static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8815: { 8816: USE_OPLINE 8817: zend_free_op free_op1, free_op2; 8818: 8819: SAVE_OPLINE(); 8820: fast_sub_function(&EX_T(opline->result.var).tmp_var, 8821: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8822: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8823: zval_dtor(free_op1.var); 8824: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8825: CHECK_EXCEPTION(); 8826: ZEND_VM_NEXT_OPCODE(); 8827: } 8828: 8829: static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8830: { 8831: USE_OPLINE 8832: zend_free_op free_op1, free_op2; 8833: 8834: SAVE_OPLINE(); 8835: fast_mul_function(&EX_T(opline->result.var).tmp_var, 8836: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8837: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8838: zval_dtor(free_op1.var); 8839: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8840: CHECK_EXCEPTION(); 8841: ZEND_VM_NEXT_OPCODE(); 8842: } 8843: 8844: static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8845: { 8846: USE_OPLINE 8847: zend_free_op free_op1, free_op2; 8848: 8849: SAVE_OPLINE(); 8850: fast_div_function(&EX_T(opline->result.var).tmp_var, 8851: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8852: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8853: zval_dtor(free_op1.var); 8854: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8855: CHECK_EXCEPTION(); 8856: ZEND_VM_NEXT_OPCODE(); 8857: } 8858: 8859: static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8860: { 8861: USE_OPLINE 8862: zend_free_op free_op1, free_op2; 8863: 8864: SAVE_OPLINE(); 8865: fast_mod_function(&EX_T(opline->result.var).tmp_var, 8866: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8867: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8868: zval_dtor(free_op1.var); 8869: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8870: CHECK_EXCEPTION(); 8871: ZEND_VM_NEXT_OPCODE(); 8872: } 8873: 8874: static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8875: { 8876: USE_OPLINE 8877: zend_free_op free_op1, free_op2; 8878: 8879: SAVE_OPLINE(); 8880: shift_left_function(&EX_T(opline->result.var).tmp_var, 8881: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8882: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8883: zval_dtor(free_op1.var); 8884: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8885: CHECK_EXCEPTION(); 8886: ZEND_VM_NEXT_OPCODE(); 8887: } 8888: 8889: static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8890: { 8891: USE_OPLINE 8892: zend_free_op free_op1, free_op2; 8893: 8894: SAVE_OPLINE(); 8895: shift_right_function(&EX_T(opline->result.var).tmp_var, 8896: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8897: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8898: zval_dtor(free_op1.var); 8899: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8900: CHECK_EXCEPTION(); 8901: ZEND_VM_NEXT_OPCODE(); 8902: } 8903: 8904: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8905: { 8906: USE_OPLINE 8907: zend_free_op free_op1, free_op2; 8908: 8909: SAVE_OPLINE(); 8910: concat_function(&EX_T(opline->result.var).tmp_var, 8911: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8912: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8913: zval_dtor(free_op1.var); 8914: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8915: CHECK_EXCEPTION(); 8916: ZEND_VM_NEXT_OPCODE(); 8917: } 8918: 8919: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8920: { 8921: USE_OPLINE 8922: zend_free_op free_op1, free_op2; 8923: 8924: SAVE_OPLINE(); 8925: is_identical_function(&EX_T(opline->result.var).tmp_var, 8926: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8927: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8928: zval_dtor(free_op1.var); 8929: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8930: CHECK_EXCEPTION(); 8931: ZEND_VM_NEXT_OPCODE(); 8932: } 8933: 8934: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8935: { 8936: USE_OPLINE 8937: zend_free_op free_op1, free_op2; 8938: zval *result = &EX_T(opline->result.var).tmp_var; 8939: 8940: SAVE_OPLINE(); 8941: is_identical_function(result, 8942: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8943: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 8944: Z_LVAL_P(result) = !Z_LVAL_P(result); 8945: zval_dtor(free_op1.var); 8946: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8947: CHECK_EXCEPTION(); 8948: ZEND_VM_NEXT_OPCODE(); 8949: } 8950: 8951: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8952: { 8953: USE_OPLINE 8954: zend_free_op free_op1, free_op2; 8955: zval *result = &EX_T(opline->result.var).tmp_var; 8956: 8957: SAVE_OPLINE(); 8958: ZVAL_BOOL(result, fast_equal_function(result, 8959: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8960: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8961: zval_dtor(free_op1.var); 8962: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8963: CHECK_EXCEPTION(); 8964: ZEND_VM_NEXT_OPCODE(); 8965: } 8966: 8967: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8968: { 8969: USE_OPLINE 8970: zend_free_op free_op1, free_op2; 8971: zval *result = &EX_T(opline->result.var).tmp_var; 8972: 8973: SAVE_OPLINE(); 8974: ZVAL_BOOL(result, fast_not_equal_function(result, 8975: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8976: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8977: zval_dtor(free_op1.var); 8978: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8979: CHECK_EXCEPTION(); 8980: ZEND_VM_NEXT_OPCODE(); 8981: } 8982: 8983: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 8984: { 8985: USE_OPLINE 8986: zend_free_op free_op1, free_op2; 8987: zval *result = &EX_T(opline->result.var).tmp_var; 8988: 8989: SAVE_OPLINE(); 8990: ZVAL_BOOL(result, fast_is_smaller_function(result, 8991: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 8992: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 8993: zval_dtor(free_op1.var); 8994: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 8995: CHECK_EXCEPTION(); 8996: ZEND_VM_NEXT_OPCODE(); 8997: } 8998: 8999: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9000: { 9001: USE_OPLINE 9002: zend_free_op free_op1, free_op2; 9003: zval *result = &EX_T(opline->result.var).tmp_var; 9004: 9005: SAVE_OPLINE(); 9006: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 9007: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 9008: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 9009: zval_dtor(free_op1.var); 9010: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9011: CHECK_EXCEPTION(); 9012: ZEND_VM_NEXT_OPCODE(); 9013: } 9014: 9015: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9016: { 9017: USE_OPLINE 9018: zend_free_op free_op1, free_op2; 9019: 9020: SAVE_OPLINE(); 9021: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 9022: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 9023: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 9024: zval_dtor(free_op1.var); 9025: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9026: CHECK_EXCEPTION(); 9027: ZEND_VM_NEXT_OPCODE(); 9028: } 9029: 9030: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9031: { 9032: USE_OPLINE 9033: zend_free_op free_op1, free_op2; 9034: 9035: SAVE_OPLINE(); 9036: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 9037: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 9038: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 9039: zval_dtor(free_op1.var); 9040: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9041: CHECK_EXCEPTION(); 9042: ZEND_VM_NEXT_OPCODE(); 9043: } 9044: 9045: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9046: { 9047: USE_OPLINE 9048: zend_free_op free_op1, free_op2; 9049: 9050: SAVE_OPLINE(); 9051: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 9052: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 9053: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 9054: zval_dtor(free_op1.var); 9055: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9056: CHECK_EXCEPTION(); 9057: ZEND_VM_NEXT_OPCODE(); 9058: } 9059: 9060: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9061: { 9062: USE_OPLINE 9063: zend_free_op free_op1, free_op2; 9064: 9065: SAVE_OPLINE(); 9066: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 9067: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 9068: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 9069: zval_dtor(free_op1.var); 9070: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9071: CHECK_EXCEPTION(); 9072: ZEND_VM_NEXT_OPCODE(); 9073: } 9074: 9075: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) 9076: { 9077: USE_OPLINE 9078: zend_free_op free_op1; 9079: zval *varname; 9080: zval **retval; 9081: zval tmp_varname; 9082: HashTable *target_symbol_table; 9083: ulong hash_value; 9084: 9085: SAVE_OPLINE(); 9086: varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9087: 9088: if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 9089: ZVAL_COPY_VALUE(&tmp_varname, varname); 9090: zval_copy_ctor(&tmp_varname); 9091: Z_SET_REFCOUNT(tmp_varname, 1); 9092: Z_UNSET_ISREF(tmp_varname); 9093: convert_to_string(&tmp_varname); 9094: varname = &tmp_varname; 9095: } 9096: 9097: if (IS_VAR != IS_UNUSED) { 9098: zend_class_entry *ce; 9099: 9100: if (IS_VAR == IS_CONST) { 9101: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 9102: ce = CACHED_PTR(opline->op2.literal->cache_slot); 9103: } else { 9104: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 9105: if (UNEXPECTED(ce == NULL)) { 9106: if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { 9107: zval_dtor(&tmp_varname); 9108: } 9109: zval_dtor(free_op1.var); 9110: CHECK_EXCEPTION(); 9111: ZEND_VM_NEXT_OPCODE(); 9112: } 9113: CACHE_PTR(opline->op2.literal->cache_slot, ce); 9114: } 9115: } else { 9116: ce = EX_T(opline->op2.var).class_entry; 9117: } 9118: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 9119: zval_dtor(free_op1.var); 9120: } else { 9121: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 9122: /* 9123: if (!target_symbol_table) { 9124: CHECK_EXCEPTION(); 9125: ZEND_VM_NEXT_OPCODE(); 9126: } 9127: */ 9128: if (IS_TMP_VAR == IS_CONST) { 9129: hash_value = Z_HASH_P(varname); 9130: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 9131: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 9132: } else { 9133: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 9134: } 9135: 9136: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 9137: switch (type) { 9138: case BP_VAR_R: 9139: case BP_VAR_UNSET: 9140: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 9141: /* break missing intentionally */ 9142: case BP_VAR_IS: 9143: retval = &EG(uninitialized_zval_ptr); 9144: break; 9145: case BP_VAR_RW: 9146: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 9147: /* break missing intentionally */ 9148: case BP_VAR_W: 9149: Z_ADDREF_P(&EG(uninitialized_zval)); 9150: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 9151: break; 9152: EMPTY_SWITCH_DEFAULT_CASE() 9153: } 9154: } 9155: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 9156: case ZEND_FETCH_GLOBAL: 9157: if (IS_TMP_VAR != IS_TMP_VAR) { 9158: zval_dtor(free_op1.var); 9159: } 9160: break; 9161: case ZEND_FETCH_LOCAL: 9162: zval_dtor(free_op1.var); 9163: break; 9164: case ZEND_FETCH_STATIC: 9165: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 9166: break; 9167: case ZEND_FETCH_GLOBAL_LOCK: 9168: if (IS_TMP_VAR == IS_VAR && !free_op1.var) { 9169: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 9170: } 9171: break; 9172: } 9173: } 9174: 9175: 9176: if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { 9177: zval_dtor(&tmp_varname); 9178: } 9179: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 9180: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 9181: } 9182: PZVAL_LOCK(*retval); 9183: switch (type) { 9184: case BP_VAR_R: 9185: case BP_VAR_IS: 9186: AI_SET_PTR(&EX_T(opline->result.var), *retval); 9187: break; 9188: case BP_VAR_UNSET: { 9189: zend_free_op free_res; 9190: 9191: PZVAL_UNLOCK(*retval, &free_res); 9192: if (retval != &EG(uninitialized_zval_ptr)) { 9193: SEPARATE_ZVAL_IF_NOT_REF(retval); 9194: } 9195: PZVAL_LOCK(*retval); 9196: FREE_OP_VAR_PTR(free_res); 9197: } 9198: /* break missing intentionally */ 9199: default: 9200: EX_T(opline->result.var).var.ptr_ptr = retval; 9201: break; 9202: } 9203: CHECK_EXCEPTION(); 9204: ZEND_VM_NEXT_OPCODE(); 9205: } 9206: 9207: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9208: { 9209: return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9210: } 9211: 9212: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9213: { 9214: return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9215: } 9216: 9217: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9218: { 9219: return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9220: } 9221: 9222: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9223: { 9224: USE_OPLINE 9225: 9226: return zend_fetch_var_address_helper_SPEC_TMP_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9227: } 9228: 9229: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9230: { 9231: return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9232: } 9233: 9234: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9235: { 9236: return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9237: } 9238: 9239: static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9240: { 9241: USE_OPLINE 9242: zend_free_op free_op2; 9243: zval *str = &EX_T(opline->result.var).tmp_var; 9244: zval *var; 9245: zval var_copy; 9246: int use_copy = 0; 9247: 9248: SAVE_OPLINE(); 9249: var = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 9250: 9251: if (IS_TMP_VAR == IS_UNUSED) { 9252: /* Initialize for erealloc in add_string_to_string */ 9253: Z_STRVAL_P(str) = NULL; 9254: Z_STRLEN_P(str) = 0; 9255: Z_TYPE_P(str) = IS_STRING; 9256: 9257: INIT_PZVAL(str); 9258: } 9259: 9260: if (Z_TYPE_P(var) != IS_STRING) { 9261: zend_make_printable_zval(var, &var_copy, &use_copy); 9262: 9263: if (use_copy) { 9264: var = &var_copy; 9265: } 9266: } 9267: add_string_to_string(str, str, var); 9268: 9269: if (use_copy) { 9270: zval_dtor(var); 9271: } 9272: /* original comment, possibly problematic: 9273: * FREE_OP is missing intentionally here - we're always working on the same temporary variable 9274: * (Zeev): I don't think it's problematic, we only use variables 9275: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're 9276: * string offsets or overloaded objects 9277: */ 9278: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9279: 9280: CHECK_EXCEPTION(); 9281: ZEND_VM_NEXT_OPCODE(); 9282: } 9283: 9284: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9285: { 9286: USE_OPLINE 9287: zval *function_name; 9288: char *function_name_strval; 9289: int function_name_strlen; 9290: zend_free_op free_op1, free_op2; 9291: 9292: SAVE_OPLINE(); 9293: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 9294: 9295: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 9296: 9297: if (IS_VAR != IS_CONST && 9298: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 9299: zend_error_noreturn(E_ERROR, "Method name must be a string"); 9300: } 9301: 9302: function_name_strval = Z_STRVAL_P(function_name); 9303: function_name_strlen = Z_STRLEN_P(function_name); 9304: 9305: EX(object) = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9306: 9307: if (EXPECTED(EX(object) != NULL) && 9308: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 9309: EX(called_scope) = Z_OBJCE_P(EX(object)); 9310: 9311: if (IS_VAR != IS_CONST || 9312: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 9313: zval *object = EX(object); 9314: 9315: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 9316: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 9317: } 9318: 9319: /* First, locate the function. */ 9320: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 9321: if (UNEXPECTED(EX(fbc) == NULL)) { 9322: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 9323: } 9324: if (IS_VAR == IS_CONST && 9325: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 9326: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 9327: EXPECTED(EX(object) == object)) { 9328: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 9329: } 9330: } 9331: } else { 9332: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 9333: } 9334: 9335: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 9336: EX(object) = NULL; 9337: } else { 9338: if (!PZVAL_IS_REF(EX(object))) { 9339: Z_ADDREF_P(EX(object)); /* For $this pointer */ 9340: } else { 9341: zval *this_ptr; 9342: ALLOC_ZVAL(this_ptr); 9343: INIT_PZVAL_COPY(this_ptr, EX(object)); 9344: zval_copy_ctor(this_ptr); 9345: EX(object) = this_ptr; 9346: } 9347: } 9348: 9349: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9350: 9351: CHECK_EXCEPTION(); 9352: ZEND_VM_NEXT_OPCODE(); 9353: } 9354: 9355: static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9356: { 9357: USE_OPLINE 9358: zend_free_op free_op1, free_op2; 9359: 9360: SAVE_OPLINE(); 9361: if (IS_TMP_VAR==IS_VAR) { 9362: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 9363: } 9364: is_equal_function(&EX_T(opline->result.var).tmp_var, 9365: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 9366: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 9367: 9368: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9369: CHECK_EXCEPTION(); 9370: ZEND_VM_NEXT_OPCODE(); 9371: } 9372: 9373: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9374: { 9375: USE_OPLINE 9376: zend_free_op free_op1; 9377: zval *expr_ptr; 9378: 9379: SAVE_OPLINE(); 9380: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 9381: zval **expr_ptr_ptr = NULL; 9382: 9383: if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 9384: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 9385: } 9386: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 9387: expr_ptr = *expr_ptr_ptr; 9388: Z_ADDREF_P(expr_ptr); 9389: } else { 9390: expr_ptr=_get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9391: if (1) { /* temporary variable */ 9392: zval *new_expr; 9393: 9394: ALLOC_ZVAL(new_expr); 9395: INIT_PZVAL_COPY(new_expr, expr_ptr); 9396: expr_ptr = new_expr; 9397: } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 9398: zval *new_expr; 9399: 9400: ALLOC_ZVAL(new_expr); 9401: INIT_PZVAL_COPY(new_expr, expr_ptr); 9402: expr_ptr = new_expr; 9403: zendi_zval_copy_ctor(*expr_ptr); 9404: } else { 9405: Z_ADDREF_P(expr_ptr); 9406: } 9407: } 9408: 9409: if (IS_VAR != IS_UNUSED) { 9410: zend_free_op free_op2; 9411: zval *offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 9412: ulong hval; 9413: 9414: switch (Z_TYPE_P(offset)) { 9415: case IS_DOUBLE: 9416: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 9417: goto num_index; 9418: case IS_LONG: 9419: case IS_BOOL: 9420: hval = Z_LVAL_P(offset); 9421: num_index: 9422: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 9423: break; 9424: case IS_STRING: 9425: if (IS_VAR == IS_CONST) { 9426: hval = Z_HASH_P(offset); 9427: } else { 9428: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 9429: if (IS_INTERNED(Z_STRVAL_P(offset))) { 9430: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 9431: } else { 9432: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 9433: } 9434: } 9435: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 9436: break; 9437: case IS_NULL: 9438: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 9439: break; 9440: default: 9441: zend_error(E_WARNING, "Illegal offset type"); 9442: zval_ptr_dtor(&expr_ptr); 9443: /* do nothing */ 9444: break; 9445: } 9446: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 9447: } else { 9448: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 9449: } 9450: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 9451: 9452: } else { 9453: 9454: } 9455: CHECK_EXCEPTION(); 9456: ZEND_VM_NEXT_OPCODE(); 9457: } 9458: 9459: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9460: { 9461: USE_OPLINE 9462: 9463: array_init(&EX_T(opline->result.var).tmp_var); 9464: if (IS_TMP_VAR == IS_UNUSED) { 9465: ZEND_VM_NEXT_OPCODE(); 9466: #if 0 || IS_TMP_VAR != IS_UNUSED 9467: } else { 9468: return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9469: #endif 9470: } 9471: } 9472: 9473: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9474: { 9475: USE_OPLINE 9476: zval tmp, *varname; 9477: HashTable *target_symbol_table; 9478: zend_free_op free_op1; 9479: 9480: SAVE_OPLINE(); 9481: if (IS_TMP_VAR == IS_CV && 9482: IS_VAR == IS_UNUSED && 9483: (opline->extended_value & ZEND_QUICK_SET)) { 9484: if (EG(active_symbol_table)) { 9485: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 9486: 9487: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 9488: EX_CV(opline->op1.var) = NULL; 9489: } else if (EX_CV(opline->op1.var)) { 9490: zval_ptr_dtor(EX_CV(opline->op1.var)); 9491: EX_CV(opline->op1.var) = NULL; 9492: } 9493: CHECK_EXCEPTION(); 9494: ZEND_VM_NEXT_OPCODE(); 9495: } 9496: 9497: varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9498: 9499: if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 9500: ZVAL_COPY_VALUE(&tmp, varname); 9501: zval_copy_ctor(&tmp); 9502: convert_to_string(&tmp); 9503: varname = &tmp; 9504: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 9505: Z_ADDREF_P(varname); 9506: } 9507: 9508: if (IS_VAR != IS_UNUSED) { 9509: zend_class_entry *ce; 9510: 9511: if (IS_VAR == IS_CONST) { 9512: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 9513: ce = CACHED_PTR(opline->op2.literal->cache_slot); 9514: } else { 9515: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 9516: if (UNEXPECTED(EG(exception) != NULL)) { 9517: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 9518: zval_dtor(&tmp); 9519: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 9520: zval_ptr_dtor(&varname); 9521: } 9522: zval_dtor(free_op1.var); 9523: HANDLE_EXCEPTION(); 9524: } 9525: if (UNEXPECTED(ce == NULL)) { 9526: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 9527: } 9528: CACHE_PTR(opline->op2.literal->cache_slot, ce); 9529: } 9530: } else { 9531: ce = EX_T(opline->op2.var).class_entry; 9532: } 9533: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 9534: } else { 9535: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 9536: 9537: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 9538: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 9539: } 9540: 9541: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 9542: zval_dtor(&tmp); 9543: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 9544: zval_ptr_dtor(&varname); 9545: } 9546: zval_dtor(free_op1.var); 9547: CHECK_EXCEPTION(); 9548: ZEND_VM_NEXT_OPCODE(); 9549: } 9550: 9551: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9552: { 9553: USE_OPLINE 9554: zval **value; 9555: zend_bool isset = 1; 9556: 9557: SAVE_OPLINE(); 9558: if (IS_TMP_VAR == IS_CV && 9559: IS_VAR == IS_UNUSED && 9560: (opline->extended_value & ZEND_QUICK_SET)) { 9561: if (EX_CV(opline->op1.var)) { 9562: value = EX_CV(opline->op1.var); 9563: } else if (EG(active_symbol_table)) { 9564: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 9565: 9566: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 9567: isset = 0; 9568: } 9569: } else { 9570: isset = 0; 9571: } 9572: } else { 9573: HashTable *target_symbol_table; 9574: zend_free_op free_op1; 9575: zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9576: 9577: if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 9578: ZVAL_COPY_VALUE(&tmp, varname); 9579: zval_copy_ctor(&tmp); 9580: convert_to_string(&tmp); 9581: varname = &tmp; 9582: } 9583: 9584: if (IS_VAR != IS_UNUSED) { 9585: zend_class_entry *ce; 9586: 9587: if (IS_VAR == IS_CONST) { 9588: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 9589: ce = CACHED_PTR(opline->op2.literal->cache_slot); 9590: } else { 9591: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 9592: if (UNEXPECTED(ce == NULL)) { 9593: CHECK_EXCEPTION(); 9594: ZEND_VM_NEXT_OPCODE(); 9595: } 9596: CACHE_PTR(opline->op2.literal->cache_slot, ce); 9597: } 9598: } else { 9599: ce = EX_T(opline->op2.var).class_entry; 9600: } 9601: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 9602: if (!value) { 9603: isset = 0; 9604: } 9605: } else { 9606: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 9607: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 9608: isset = 0; 9609: } 9610: } 9611: 9612: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 9613: zval_dtor(&tmp); 9614: } 9615: zval_dtor(free_op1.var); 9616: } 9617: 9618: if (opline->extended_value & ZEND_ISSET) { 9619: if (isset && Z_TYPE_PP(value) != IS_NULL) { 9620: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 9621: } else { 9622: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 9623: } 9624: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 9625: if (!isset || !i_zend_is_true(*value)) { 9626: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 9627: } else { 9628: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 9629: } 9630: } 9631: 9632: CHECK_EXCEPTION(); 9633: ZEND_VM_NEXT_OPCODE(); 9634: } 9635: 9636: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) 9637: { 9638: USE_OPLINE 9639: zend_free_op free_op1; 9640: zval *varname; 9641: zval **retval; 9642: zval tmp_varname; 9643: HashTable *target_symbol_table; 9644: ulong hash_value; 9645: 9646: SAVE_OPLINE(); 9647: varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9648: 9649: if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 9650: ZVAL_COPY_VALUE(&tmp_varname, varname); 9651: zval_copy_ctor(&tmp_varname); 9652: Z_SET_REFCOUNT(tmp_varname, 1); 9653: Z_UNSET_ISREF(tmp_varname); 9654: convert_to_string(&tmp_varname); 9655: varname = &tmp_varname; 9656: } 9657: 9658: if (IS_UNUSED != IS_UNUSED) { 9659: zend_class_entry *ce; 9660: 9661: if (IS_UNUSED == IS_CONST) { 9662: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 9663: ce = CACHED_PTR(opline->op2.literal->cache_slot); 9664: } else { 9665: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 9666: if (UNEXPECTED(ce == NULL)) { 9667: if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { 9668: zval_dtor(&tmp_varname); 9669: } 9670: zval_dtor(free_op1.var); 9671: CHECK_EXCEPTION(); 9672: ZEND_VM_NEXT_OPCODE(); 9673: } 9674: CACHE_PTR(opline->op2.literal->cache_slot, ce); 9675: } 9676: } else { 9677: ce = EX_T(opline->op2.var).class_entry; 9678: } 9679: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 9680: zval_dtor(free_op1.var); 9681: } else { 9682: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 9683: /* 9684: if (!target_symbol_table) { 9685: CHECK_EXCEPTION(); 9686: ZEND_VM_NEXT_OPCODE(); 9687: } 9688: */ 9689: if (IS_TMP_VAR == IS_CONST) { 9690: hash_value = Z_HASH_P(varname); 9691: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 9692: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 9693: } else { 9694: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 9695: } 9696: 9697: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 9698: switch (type) { 9699: case BP_VAR_R: 9700: case BP_VAR_UNSET: 9701: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 9702: /* break missing intentionally */ 9703: case BP_VAR_IS: 9704: retval = &EG(uninitialized_zval_ptr); 9705: break; 9706: case BP_VAR_RW: 9707: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 9708: /* break missing intentionally */ 9709: case BP_VAR_W: 9710: Z_ADDREF_P(&EG(uninitialized_zval)); 9711: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 9712: break; 9713: EMPTY_SWITCH_DEFAULT_CASE() 9714: } 9715: } 9716: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 9717: case ZEND_FETCH_GLOBAL: 9718: if (IS_TMP_VAR != IS_TMP_VAR) { 9719: zval_dtor(free_op1.var); 9720: } 9721: break; 9722: case ZEND_FETCH_LOCAL: 9723: zval_dtor(free_op1.var); 9724: break; 9725: case ZEND_FETCH_STATIC: 9726: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 9727: break; 9728: case ZEND_FETCH_GLOBAL_LOCK: 9729: if (IS_TMP_VAR == IS_VAR && !free_op1.var) { 9730: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 9731: } 9732: break; 9733: } 9734: } 9735: 9736: 9737: if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { 9738: zval_dtor(&tmp_varname); 9739: } 9740: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 9741: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 9742: } 9743: PZVAL_LOCK(*retval); 9744: switch (type) { 9745: case BP_VAR_R: 9746: case BP_VAR_IS: 9747: AI_SET_PTR(&EX_T(opline->result.var), *retval); 9748: break; 9749: case BP_VAR_UNSET: { 9750: zend_free_op free_res; 9751: 9752: PZVAL_UNLOCK(*retval, &free_res); 9753: if (retval != &EG(uninitialized_zval_ptr)) { 9754: SEPARATE_ZVAL_IF_NOT_REF(retval); 9755: } 9756: PZVAL_LOCK(*retval); 9757: FREE_OP_VAR_PTR(free_res); 9758: } 9759: /* break missing intentionally */ 9760: default: 9761: EX_T(opline->result.var).var.ptr_ptr = retval; 9762: break; 9763: } 9764: CHECK_EXCEPTION(); 9765: ZEND_VM_NEXT_OPCODE(); 9766: } 9767: 9768: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9769: { 9770: return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9771: } 9772: 9773: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9774: { 9775: return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9776: } 9777: 9778: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9779: { 9780: return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9781: } 9782: 9783: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9784: { 9785: USE_OPLINE 9786: 9787: return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9788: } 9789: 9790: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9791: { 9792: return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9793: } 9794: 9795: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9796: { 9797: return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9798: } 9799: 9800: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9801: { 9802: USE_OPLINE 9803: zend_free_op free_op1; 9804: zval *expr_ptr; 9805: 9806: SAVE_OPLINE(); 9807: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 9808: zval **expr_ptr_ptr = NULL; 9809: 9810: if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 9811: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 9812: } 9813: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 9814: expr_ptr = *expr_ptr_ptr; 9815: Z_ADDREF_P(expr_ptr); 9816: } else { 9817: expr_ptr=_get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9818: if (1) { /* temporary variable */ 9819: zval *new_expr; 9820: 9821: ALLOC_ZVAL(new_expr); 9822: INIT_PZVAL_COPY(new_expr, expr_ptr); 9823: expr_ptr = new_expr; 9824: } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 9825: zval *new_expr; 9826: 9827: ALLOC_ZVAL(new_expr); 9828: INIT_PZVAL_COPY(new_expr, expr_ptr); 9829: expr_ptr = new_expr; 9830: zendi_zval_copy_ctor(*expr_ptr); 9831: } else { 9832: Z_ADDREF_P(expr_ptr); 9833: } 9834: } 9835: 9836: if (IS_UNUSED != IS_UNUSED) { 9837: 9838: zval *offset = NULL; 9839: ulong hval; 9840: 9841: switch (Z_TYPE_P(offset)) { 9842: case IS_DOUBLE: 9843: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 9844: goto num_index; 9845: case IS_LONG: 9846: case IS_BOOL: 9847: hval = Z_LVAL_P(offset); 9848: num_index: 9849: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 9850: break; 9851: case IS_STRING: 9852: if (IS_UNUSED == IS_CONST) { 9853: hval = Z_HASH_P(offset); 9854: } else { 9855: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 9856: if (IS_INTERNED(Z_STRVAL_P(offset))) { 9857: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 9858: } else { 9859: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 9860: } 9861: } 9862: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 9863: break; 9864: case IS_NULL: 9865: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 9866: break; 9867: default: 9868: zend_error(E_WARNING, "Illegal offset type"); 9869: zval_ptr_dtor(&expr_ptr); 9870: /* do nothing */ 9871: break; 9872: } 9873: 9874: } else { 9875: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 9876: } 9877: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 9878: 9879: } else { 9880: 9881: } 9882: CHECK_EXCEPTION(); 9883: ZEND_VM_NEXT_OPCODE(); 9884: } 9885: 9886: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9887: { 9888: USE_OPLINE 9889: 9890: array_init(&EX_T(opline->result.var).tmp_var); 9891: if (IS_TMP_VAR == IS_UNUSED) { 9892: ZEND_VM_NEXT_OPCODE(); 9893: #if 0 || IS_TMP_VAR != IS_UNUSED 9894: } else { 9895: return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 9896: #endif 9897: } 9898: } 9899: 9900: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9901: { 9902: USE_OPLINE 9903: zval tmp, *varname; 9904: HashTable *target_symbol_table; 9905: zend_free_op free_op1; 9906: 9907: SAVE_OPLINE(); 9908: if (IS_TMP_VAR == IS_CV && 9909: IS_UNUSED == IS_UNUSED && 9910: (opline->extended_value & ZEND_QUICK_SET)) { 9911: if (EG(active_symbol_table)) { 9912: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 9913: 9914: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 9915: EX_CV(opline->op1.var) = NULL; 9916: } else if (EX_CV(opline->op1.var)) { 9917: zval_ptr_dtor(EX_CV(opline->op1.var)); 9918: EX_CV(opline->op1.var) = NULL; 9919: } 9920: CHECK_EXCEPTION(); 9921: ZEND_VM_NEXT_OPCODE(); 9922: } 9923: 9924: varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 9925: 9926: if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 9927: ZVAL_COPY_VALUE(&tmp, varname); 9928: zval_copy_ctor(&tmp); 9929: convert_to_string(&tmp); 9930: varname = &tmp; 9931: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 9932: Z_ADDREF_P(varname); 9933: } 9934: 9935: if (IS_UNUSED != IS_UNUSED) { 9936: zend_class_entry *ce; 9937: 9938: if (IS_UNUSED == IS_CONST) { 9939: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 9940: ce = CACHED_PTR(opline->op2.literal->cache_slot); 9941: } else { 9942: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 9943: if (UNEXPECTED(EG(exception) != NULL)) { 9944: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 9945: zval_dtor(&tmp); 9946: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 9947: zval_ptr_dtor(&varname); 9948: } 9949: zval_dtor(free_op1.var); 9950: HANDLE_EXCEPTION(); 9951: } 9952: if (UNEXPECTED(ce == NULL)) { 9953: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 9954: } 9955: CACHE_PTR(opline->op2.literal->cache_slot, ce); 9956: } 9957: } else { 9958: ce = EX_T(opline->op2.var).class_entry; 9959: } 9960: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 9961: } else { 9962: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 9963: 9964: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 9965: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 9966: } 9967: 9968: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 9969: zval_dtor(&tmp); 9970: } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { 9971: zval_ptr_dtor(&varname); 9972: } 9973: zval_dtor(free_op1.var); 9974: CHECK_EXCEPTION(); 9975: ZEND_VM_NEXT_OPCODE(); 9976: } 9977: 9978: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 9979: { 9980: USE_OPLINE 9981: zval **value; 9982: zend_bool isset = 1; 9983: 9984: SAVE_OPLINE(); 9985: if (IS_TMP_VAR == IS_CV && 9986: IS_UNUSED == IS_UNUSED && 9987: (opline->extended_value & ZEND_QUICK_SET)) { 9988: if (EX_CV(opline->op1.var)) { 9989: value = EX_CV(opline->op1.var); 9990: } else if (EG(active_symbol_table)) { 9991: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 9992: 9993: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 9994: isset = 0; 9995: } 9996: } else { 9997: isset = 0; 9998: } 9999: } else { 10000: HashTable *target_symbol_table; 10001: zend_free_op free_op1; 10002: zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10003: 10004: if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 10005: ZVAL_COPY_VALUE(&tmp, varname); 10006: zval_copy_ctor(&tmp); 10007: convert_to_string(&tmp); 10008: varname = &tmp; 10009: } 10010: 10011: if (IS_UNUSED != IS_UNUSED) { 10012: zend_class_entry *ce; 10013: 10014: if (IS_UNUSED == IS_CONST) { 10015: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 10016: ce = CACHED_PTR(opline->op2.literal->cache_slot); 10017: } else { 10018: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 10019: if (UNEXPECTED(ce == NULL)) { 10020: CHECK_EXCEPTION(); 10021: ZEND_VM_NEXT_OPCODE(); 10022: } 10023: CACHE_PTR(opline->op2.literal->cache_slot, ce); 10024: } 10025: } else { 10026: ce = EX_T(opline->op2.var).class_entry; 10027: } 10028: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 10029: if (!value) { 10030: isset = 0; 10031: } 10032: } else { 10033: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 10034: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 10035: isset = 0; 10036: } 10037: } 10038: 10039: if (IS_TMP_VAR != IS_CONST && varname == &tmp) { 10040: zval_dtor(&tmp); 10041: } 10042: zval_dtor(free_op1.var); 10043: } 10044: 10045: if (opline->extended_value & ZEND_ISSET) { 10046: if (isset && Z_TYPE_PP(value) != IS_NULL) { 10047: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 10048: } else { 10049: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 10050: } 10051: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 10052: if (!isset || !i_zend_is_true(*value)) { 10053: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 10054: } else { 10055: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 10056: } 10057: } 10058: 10059: CHECK_EXCEPTION(); 10060: ZEND_VM_NEXT_OPCODE(); 10061: } 10062: 10063: static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10064: { 10065: USE_OPLINE 10066: zend_free_op free_op1; 10067: 10068: SAVE_OPLINE(); 10069: fast_add_function(&EX_T(opline->result.var).tmp_var, 10070: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10071: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10072: zval_dtor(free_op1.var); 10073: 10074: CHECK_EXCEPTION(); 10075: ZEND_VM_NEXT_OPCODE(); 10076: } 10077: 10078: static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10079: { 10080: USE_OPLINE 10081: zend_free_op free_op1; 10082: 10083: SAVE_OPLINE(); 10084: fast_sub_function(&EX_T(opline->result.var).tmp_var, 10085: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10086: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10087: zval_dtor(free_op1.var); 10088: 10089: CHECK_EXCEPTION(); 10090: ZEND_VM_NEXT_OPCODE(); 10091: } 10092: 10093: static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10094: { 10095: USE_OPLINE 10096: zend_free_op free_op1; 10097: 10098: SAVE_OPLINE(); 10099: fast_mul_function(&EX_T(opline->result.var).tmp_var, 10100: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10101: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10102: zval_dtor(free_op1.var); 10103: 10104: CHECK_EXCEPTION(); 10105: ZEND_VM_NEXT_OPCODE(); 10106: } 10107: 10108: static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10109: { 10110: USE_OPLINE 10111: zend_free_op free_op1; 10112: 10113: SAVE_OPLINE(); 10114: fast_div_function(&EX_T(opline->result.var).tmp_var, 10115: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10116: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10117: zval_dtor(free_op1.var); 10118: 10119: CHECK_EXCEPTION(); 10120: ZEND_VM_NEXT_OPCODE(); 10121: } 10122: 10123: static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10124: { 10125: USE_OPLINE 10126: zend_free_op free_op1; 10127: 10128: SAVE_OPLINE(); 10129: fast_mod_function(&EX_T(opline->result.var).tmp_var, 10130: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10131: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10132: zval_dtor(free_op1.var); 10133: 10134: CHECK_EXCEPTION(); 10135: ZEND_VM_NEXT_OPCODE(); 10136: } 10137: 10138: static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10139: { 10140: USE_OPLINE 10141: zend_free_op free_op1; 10142: 10143: SAVE_OPLINE(); 10144: shift_left_function(&EX_T(opline->result.var).tmp_var, 10145: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10146: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10147: zval_dtor(free_op1.var); 10148: 10149: CHECK_EXCEPTION(); 10150: ZEND_VM_NEXT_OPCODE(); 10151: } 10152: 10153: static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10154: { 10155: USE_OPLINE 10156: zend_free_op free_op1; 10157: 10158: SAVE_OPLINE(); 10159: shift_right_function(&EX_T(opline->result.var).tmp_var, 10160: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10161: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10162: zval_dtor(free_op1.var); 10163: 10164: CHECK_EXCEPTION(); 10165: ZEND_VM_NEXT_OPCODE(); 10166: } 10167: 10168: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10169: { 10170: USE_OPLINE 10171: zend_free_op free_op1; 10172: 10173: SAVE_OPLINE(); 10174: concat_function(&EX_T(opline->result.var).tmp_var, 10175: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10176: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10177: zval_dtor(free_op1.var); 10178: 10179: CHECK_EXCEPTION(); 10180: ZEND_VM_NEXT_OPCODE(); 10181: } 10182: 10183: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10184: { 10185: USE_OPLINE 10186: zend_free_op free_op1; 10187: 10188: SAVE_OPLINE(); 10189: is_identical_function(&EX_T(opline->result.var).tmp_var, 10190: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10191: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10192: zval_dtor(free_op1.var); 10193: 10194: CHECK_EXCEPTION(); 10195: ZEND_VM_NEXT_OPCODE(); 10196: } 10197: 10198: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10199: { 10200: USE_OPLINE 10201: zend_free_op free_op1; 10202: zval *result = &EX_T(opline->result.var).tmp_var; 10203: 10204: SAVE_OPLINE(); 10205: is_identical_function(result, 10206: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10207: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10208: Z_LVAL_P(result) = !Z_LVAL_P(result); 10209: zval_dtor(free_op1.var); 10210: 10211: CHECK_EXCEPTION(); 10212: ZEND_VM_NEXT_OPCODE(); 10213: } 10214: 10215: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10216: { 10217: USE_OPLINE 10218: zend_free_op free_op1; 10219: zval *result = &EX_T(opline->result.var).tmp_var; 10220: 10221: SAVE_OPLINE(); 10222: ZVAL_BOOL(result, fast_equal_function(result, 10223: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10224: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 10225: zval_dtor(free_op1.var); 10226: 10227: CHECK_EXCEPTION(); 10228: ZEND_VM_NEXT_OPCODE(); 10229: } 10230: 10231: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10232: { 10233: USE_OPLINE 10234: zend_free_op free_op1; 10235: zval *result = &EX_T(opline->result.var).tmp_var; 10236: 10237: SAVE_OPLINE(); 10238: ZVAL_BOOL(result, fast_not_equal_function(result, 10239: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10240: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 10241: zval_dtor(free_op1.var); 10242: 10243: CHECK_EXCEPTION(); 10244: ZEND_VM_NEXT_OPCODE(); 10245: } 10246: 10247: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10248: { 10249: USE_OPLINE 10250: zend_free_op free_op1; 10251: zval *result = &EX_T(opline->result.var).tmp_var; 10252: 10253: SAVE_OPLINE(); 10254: ZVAL_BOOL(result, fast_is_smaller_function(result, 10255: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10256: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 10257: zval_dtor(free_op1.var); 10258: 10259: CHECK_EXCEPTION(); 10260: ZEND_VM_NEXT_OPCODE(); 10261: } 10262: 10263: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10264: { 10265: USE_OPLINE 10266: zend_free_op free_op1; 10267: zval *result = &EX_T(opline->result.var).tmp_var; 10268: 10269: SAVE_OPLINE(); 10270: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 10271: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10272: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 10273: zval_dtor(free_op1.var); 10274: 10275: CHECK_EXCEPTION(); 10276: ZEND_VM_NEXT_OPCODE(); 10277: } 10278: 10279: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10280: { 10281: USE_OPLINE 10282: zend_free_op free_op1; 10283: 10284: SAVE_OPLINE(); 10285: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 10286: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10287: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10288: zval_dtor(free_op1.var); 10289: 10290: CHECK_EXCEPTION(); 10291: ZEND_VM_NEXT_OPCODE(); 10292: } 10293: 10294: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10295: { 10296: USE_OPLINE 10297: zend_free_op free_op1; 10298: 10299: SAVE_OPLINE(); 10300: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 10301: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10302: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10303: zval_dtor(free_op1.var); 10304: 10305: CHECK_EXCEPTION(); 10306: ZEND_VM_NEXT_OPCODE(); 10307: } 10308: 10309: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10310: { 10311: USE_OPLINE 10312: zend_free_op free_op1; 10313: 10314: SAVE_OPLINE(); 10315: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 10316: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10317: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10318: zval_dtor(free_op1.var); 10319: 10320: CHECK_EXCEPTION(); 10321: ZEND_VM_NEXT_OPCODE(); 10322: } 10323: 10324: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10325: { 10326: USE_OPLINE 10327: zend_free_op free_op1; 10328: 10329: SAVE_OPLINE(); 10330: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 10331: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10332: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10333: zval_dtor(free_op1.var); 10334: 10335: CHECK_EXCEPTION(); 10336: ZEND_VM_NEXT_OPCODE(); 10337: } 10338: 10339: static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10340: { 10341: USE_OPLINE 10342: 10343: zval *str = &EX_T(opline->result.var).tmp_var; 10344: zval *var; 10345: zval var_copy; 10346: int use_copy = 0; 10347: 10348: SAVE_OPLINE(); 10349: var = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 10350: 10351: if (IS_TMP_VAR == IS_UNUSED) { 10352: /* Initialize for erealloc in add_string_to_string */ 10353: Z_STRVAL_P(str) = NULL; 10354: Z_STRLEN_P(str) = 0; 10355: Z_TYPE_P(str) = IS_STRING; 10356: 10357: INIT_PZVAL(str); 10358: } 10359: 10360: if (Z_TYPE_P(var) != IS_STRING) { 10361: zend_make_printable_zval(var, &var_copy, &use_copy); 10362: 10363: if (use_copy) { 10364: var = &var_copy; 10365: } 10366: } 10367: add_string_to_string(str, str, var); 10368: 10369: if (use_copy) { 10370: zval_dtor(var); 10371: } 10372: /* original comment, possibly problematic: 10373: * FREE_OP is missing intentionally here - we're always working on the same temporary variable 10374: * (Zeev): I don't think it's problematic, we only use variables 10375: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're 10376: * string offsets or overloaded objects 10377: */ 10378: 10379: CHECK_EXCEPTION(); 10380: ZEND_VM_NEXT_OPCODE(); 10381: } 10382: 10383: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10384: { 10385: USE_OPLINE 10386: zval *function_name; 10387: char *function_name_strval; 10388: int function_name_strlen; 10389: zend_free_op free_op1; 10390: 10391: SAVE_OPLINE(); 10392: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 10393: 10394: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 10395: 10396: if (IS_CV != IS_CONST && 10397: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 10398: zend_error_noreturn(E_ERROR, "Method name must be a string"); 10399: } 10400: 10401: function_name_strval = Z_STRVAL_P(function_name); 10402: function_name_strlen = Z_STRLEN_P(function_name); 10403: 10404: EX(object) = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10405: 10406: if (EXPECTED(EX(object) != NULL) && 10407: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 10408: EX(called_scope) = Z_OBJCE_P(EX(object)); 10409: 10410: if (IS_CV != IS_CONST || 10411: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 10412: zval *object = EX(object); 10413: 10414: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 10415: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 10416: } 10417: 10418: /* First, locate the function. */ 10419: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 10420: if (UNEXPECTED(EX(fbc) == NULL)) { 10421: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 10422: } 10423: if (IS_CV == IS_CONST && 10424: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 10425: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 10426: EXPECTED(EX(object) == object)) { 10427: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 10428: } 10429: } 10430: } else { 10431: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 10432: } 10433: 10434: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 10435: EX(object) = NULL; 10436: } else { 10437: if (!PZVAL_IS_REF(EX(object))) { 10438: Z_ADDREF_P(EX(object)); /* For $this pointer */ 10439: } else { 10440: zval *this_ptr; 10441: ALLOC_ZVAL(this_ptr); 10442: INIT_PZVAL_COPY(this_ptr, EX(object)); 10443: zval_copy_ctor(this_ptr); 10444: EX(object) = this_ptr; 10445: } 10446: } 10447: 10448: 10449: CHECK_EXCEPTION(); 10450: ZEND_VM_NEXT_OPCODE(); 10451: } 10452: 10453: static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10454: { 10455: USE_OPLINE 10456: zend_free_op free_op1; 10457: 10458: SAVE_OPLINE(); 10459: if (IS_TMP_VAR==IS_VAR) { 10460: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 10461: } 10462: is_equal_function(&EX_T(opline->result.var).tmp_var, 10463: _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 10464: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 10465: 10466: CHECK_EXCEPTION(); 10467: ZEND_VM_NEXT_OPCODE(); 10468: } 10469: 10470: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10471: { 10472: USE_OPLINE 10473: zend_free_op free_op1; 10474: zval *expr_ptr; 10475: 10476: SAVE_OPLINE(); 10477: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 10478: zval **expr_ptr_ptr = NULL; 10479: 10480: if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 10481: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 10482: } 10483: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 10484: expr_ptr = *expr_ptr_ptr; 10485: Z_ADDREF_P(expr_ptr); 10486: } else { 10487: expr_ptr=_get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10488: if (1) { /* temporary variable */ 10489: zval *new_expr; 10490: 10491: ALLOC_ZVAL(new_expr); 10492: INIT_PZVAL_COPY(new_expr, expr_ptr); 10493: expr_ptr = new_expr; 10494: } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 10495: zval *new_expr; 10496: 10497: ALLOC_ZVAL(new_expr); 10498: INIT_PZVAL_COPY(new_expr, expr_ptr); 10499: expr_ptr = new_expr; 10500: zendi_zval_copy_ctor(*expr_ptr); 10501: } else { 10502: Z_ADDREF_P(expr_ptr); 10503: } 10504: } 10505: 10506: if (IS_CV != IS_UNUSED) { 10507: 10508: zval *offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 10509: ulong hval; 10510: 10511: switch (Z_TYPE_P(offset)) { 10512: case IS_DOUBLE: 10513: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 10514: goto num_index; 10515: case IS_LONG: 10516: case IS_BOOL: 10517: hval = Z_LVAL_P(offset); 10518: num_index: 10519: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 10520: break; 10521: case IS_STRING: 10522: if (IS_CV == IS_CONST) { 10523: hval = Z_HASH_P(offset); 10524: } else { 10525: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 10526: if (IS_INTERNED(Z_STRVAL_P(offset))) { 10527: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 10528: } else { 10529: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 10530: } 10531: } 10532: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 10533: break; 10534: case IS_NULL: 10535: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 10536: break; 10537: default: 10538: zend_error(E_WARNING, "Illegal offset type"); 10539: zval_ptr_dtor(&expr_ptr); 10540: /* do nothing */ 10541: break; 10542: } 10543: 10544: } else { 10545: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 10546: } 10547: if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { 10548: 10549: } else { 10550: 10551: } 10552: CHECK_EXCEPTION(); 10553: ZEND_VM_NEXT_OPCODE(); 10554: } 10555: 10556: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10557: { 10558: USE_OPLINE 10559: 10560: array_init(&EX_T(opline->result.var).tmp_var); 10561: if (IS_TMP_VAR == IS_UNUSED) { 10562: ZEND_VM_NEXT_OPCODE(); 10563: #if 0 || IS_TMP_VAR != IS_UNUSED 10564: } else { 10565: return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 10566: #endif 10567: } 10568: } 10569: 10570: static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10571: { 10572: USE_OPLINE 10573: zend_free_op free_op1; 10574: 10575: SAVE_OPLINE(); 10576: bitwise_not_function(&EX_T(opline->result.var).tmp_var, 10577: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC) TSRMLS_CC); 10578: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10579: CHECK_EXCEPTION(); 10580: ZEND_VM_NEXT_OPCODE(); 10581: } 10582: 10583: static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10584: { 10585: USE_OPLINE 10586: zend_free_op free_op1; 10587: 10588: SAVE_OPLINE(); 10589: boolean_not_function(&EX_T(opline->result.var).tmp_var, 10590: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC) TSRMLS_CC); 10591: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10592: CHECK_EXCEPTION(); 10593: ZEND_VM_NEXT_OPCODE(); 10594: } 10595: 10596: static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10597: { 10598: USE_OPLINE 10599: zend_free_op free_op1; 10600: zval **var_ptr; 10601: 10602: SAVE_OPLINE(); 10603: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10604: 10605: if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 10606: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 10607: } 10608: if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 10609: if (RETURN_VALUE_USED(opline)) { 10610: PZVAL_LOCK(&EG(uninitialized_zval)); 10611: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 10612: } 10613: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10614: CHECK_EXCEPTION(); 10615: ZEND_VM_NEXT_OPCODE(); 10616: } 10617: 10618: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 10619: 10620: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 10621: && Z_OBJ_HANDLER_PP(var_ptr, get) 10622: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 10623: /* proxy object */ 10624: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 10625: Z_ADDREF_P(val); 10626: fast_increment_function(val); 10627: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 10628: zval_ptr_dtor(&val); 10629: } else { 10630: fast_increment_function(*var_ptr); 10631: } 10632: 10633: if (RETURN_VALUE_USED(opline)) { 10634: PZVAL_LOCK(*var_ptr); 10635: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 10636: } 10637: 10638: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10639: CHECK_EXCEPTION(); 10640: ZEND_VM_NEXT_OPCODE(); 10641: } 10642: 10643: static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10644: { 10645: USE_OPLINE 10646: zend_free_op free_op1; 10647: zval **var_ptr; 10648: 10649: SAVE_OPLINE(); 10650: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10651: 10652: if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 10653: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 10654: } 10655: if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 10656: if (RETURN_VALUE_USED(opline)) { 10657: PZVAL_LOCK(&EG(uninitialized_zval)); 10658: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 10659: } 10660: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10661: CHECK_EXCEPTION(); 10662: ZEND_VM_NEXT_OPCODE(); 10663: } 10664: 10665: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 10666: 10667: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 10668: && Z_OBJ_HANDLER_PP(var_ptr, get) 10669: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 10670: /* proxy object */ 10671: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 10672: Z_ADDREF_P(val); 10673: fast_decrement_function(val); 10674: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 10675: zval_ptr_dtor(&val); 10676: } else { 10677: fast_decrement_function(*var_ptr); 10678: } 10679: 10680: if (RETURN_VALUE_USED(opline)) { 10681: PZVAL_LOCK(*var_ptr); 10682: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 10683: } 10684: 10685: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10686: CHECK_EXCEPTION(); 10687: ZEND_VM_NEXT_OPCODE(); 10688: } 10689: 10690: static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10691: { 10692: USE_OPLINE 10693: zend_free_op free_op1; 10694: zval **var_ptr, *retval; 10695: 10696: SAVE_OPLINE(); 10697: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10698: 10699: if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 10700: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 10701: } 10702: if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 10703: ZVAL_NULL(&EX_T(opline->result.var).tmp_var); 10704: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10705: CHECK_EXCEPTION(); 10706: ZEND_VM_NEXT_OPCODE(); 10707: } 10708: 10709: retval = &EX_T(opline->result.var).tmp_var; 10710: ZVAL_COPY_VALUE(retval, *var_ptr); 10711: zendi_zval_copy_ctor(*retval); 10712: 10713: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 10714: 10715: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 10716: && Z_OBJ_HANDLER_PP(var_ptr, get) 10717: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 10718: /* proxy object */ 10719: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 10720: Z_ADDREF_P(val); 10721: fast_increment_function(val); 10722: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 10723: zval_ptr_dtor(&val); 10724: } else { 10725: fast_increment_function(*var_ptr); 10726: } 10727: 10728: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10729: CHECK_EXCEPTION(); 10730: ZEND_VM_NEXT_OPCODE(); 10731: } 10732: 10733: static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10734: { 10735: USE_OPLINE 10736: zend_free_op free_op1; 10737: zval **var_ptr, *retval; 10738: 10739: SAVE_OPLINE(); 10740: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10741: 10742: if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 10743: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 10744: } 10745: if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 10746: ZVAL_NULL(&EX_T(opline->result.var).tmp_var); 10747: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10748: CHECK_EXCEPTION(); 10749: ZEND_VM_NEXT_OPCODE(); 10750: } 10751: 10752: retval = &EX_T(opline->result.var).tmp_var; 10753: ZVAL_COPY_VALUE(retval, *var_ptr); 10754: zendi_zval_copy_ctor(*retval); 10755: 10756: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 10757: 10758: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 10759: && Z_OBJ_HANDLER_PP(var_ptr, get) 10760: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 10761: /* proxy object */ 10762: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 10763: Z_ADDREF_P(val); 10764: fast_decrement_function(val); 10765: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 10766: zval_ptr_dtor(&val); 10767: } else { 10768: fast_decrement_function(*var_ptr); 10769: } 10770: 10771: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10772: CHECK_EXCEPTION(); 10773: ZEND_VM_NEXT_OPCODE(); 10774: } 10775: 10776: static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10777: { 10778: USE_OPLINE 10779: zend_free_op free_op1; 10780: zval *z; 10781: 10782: SAVE_OPLINE(); 10783: z = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10784: 10785: if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { 10786: INIT_PZVAL(z); 10787: } 10788: zend_print_variable(z); 10789: 10790: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10791: CHECK_EXCEPTION(); 10792: ZEND_VM_NEXT_OPCODE(); 10793: } 10794: 10795: static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10796: { 10797: USE_OPLINE 10798: 10799: ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); 10800: return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 10801: } 10802: 10803: static int ZEND_FASTCALL ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10804: { 10805: USE_OPLINE 10806: zend_free_op free_op1; 10807: zval *val; 10808: int ret; 10809: 10810: SAVE_OPLINE(); 10811: val = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10812: 10813: if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 10814: ret = Z_LVAL_P(val); 10815: } else { 10816: ret = i_zend_is_true(val); 10817: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10818: if (UNEXPECTED(EG(exception) != NULL)) { 10819: HANDLE_EXCEPTION(); 10820: } 10821: } 10822: if (!ret) { 10823: #if DEBUG_ZEND>=2 10824: printf("Conditional jmp to %d\n", opline->op2.opline_num); 10825: #endif 10826: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 10827: ZEND_VM_CONTINUE(); 10828: } 10829: 10830: ZEND_VM_NEXT_OPCODE(); 10831: } 10832: 10833: static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10834: { 10835: USE_OPLINE 10836: zend_free_op free_op1; 10837: zval *val; 10838: int ret; 10839: 10840: SAVE_OPLINE(); 10841: val = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10842: 10843: if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 10844: ret = Z_LVAL_P(val); 10845: } else { 10846: ret = i_zend_is_true(val); 10847: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10848: if (UNEXPECTED(EG(exception) != NULL)) { 10849: HANDLE_EXCEPTION(); 10850: } 10851: } 10852: if (ret) { 10853: #if DEBUG_ZEND>=2 10854: printf("Conditional jmp to %d\n", opline->op2.opline_num); 10855: #endif 10856: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 10857: ZEND_VM_CONTINUE(); 10858: } 10859: 10860: ZEND_VM_NEXT_OPCODE(); 10861: } 10862: 10863: static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10864: { 10865: USE_OPLINE 10866: zend_free_op free_op1; 10867: zval *val; 10868: int retval; 10869: 10870: SAVE_OPLINE(); 10871: val = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10872: 10873: if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 10874: retval = Z_LVAL_P(val); 10875: } else { 10876: retval = i_zend_is_true(val); 10877: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10878: if (UNEXPECTED(EG(exception) != NULL)) { 10879: HANDLE_EXCEPTION(); 10880: } 10881: } 10882: if (EXPECTED(retval != 0)) { 10883: #if DEBUG_ZEND>=2 10884: printf("Conditional jmp on true to %d\n", opline->extended_value); 10885: #endif 10886: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); 10887: ZEND_VM_CONTINUE(); /* CHECK_ME */ 10888: } else { 10889: #if DEBUG_ZEND>=2 10890: printf("Conditional jmp on false to %d\n", opline->op2.opline_num); 10891: #endif 10892: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); 10893: ZEND_VM_CONTINUE(); /* CHECK_ME */ 10894: } 10895: } 10896: 10897: static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10898: { 10899: USE_OPLINE 10900: zend_free_op free_op1; 10901: zval *val; 10902: int retval; 10903: 10904: SAVE_OPLINE(); 10905: val = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10906: 10907: if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 10908: retval = Z_LVAL_P(val); 10909: } else { 10910: retval = i_zend_is_true(val); 10911: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10912: if (UNEXPECTED(EG(exception) != NULL)) { 10913: HANDLE_EXCEPTION(); 10914: } 10915: } 10916: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 10917: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 10918: if (!retval) { 10919: #if DEBUG_ZEND>=2 10920: printf("Conditional jmp to %d\n", opline->op2.opline_num); 10921: #endif 10922: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 10923: ZEND_VM_CONTINUE(); 10924: } 10925: ZEND_VM_NEXT_OPCODE(); 10926: } 10927: 10928: static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10929: { 10930: USE_OPLINE 10931: zend_free_op free_op1; 10932: zval *val; 10933: int retval; 10934: 10935: SAVE_OPLINE(); 10936: val = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10937: 10938: if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 10939: retval = Z_LVAL_P(val); 10940: } else { 10941: retval = i_zend_is_true(val); 10942: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10943: if (UNEXPECTED(EG(exception) != NULL)) { 10944: HANDLE_EXCEPTION(); 10945: } 10946: } 10947: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 10948: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 10949: if (retval) { 10950: #if DEBUG_ZEND>=2 10951: printf("Conditional jmp to %d\n", opline->op2.opline_num); 10952: #endif 10953: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 10954: ZEND_VM_CONTINUE(); 10955: } 10956: ZEND_VM_NEXT_OPCODE(); 10957: } 10958: 10959: static int ZEND_FASTCALL ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10960: { 10961: USE_OPLINE 10962: 10963: SAVE_OPLINE(); 10964: if (IS_VAR == IS_TMP_VAR) { 10965: zendi_zval_dtor(EX_T(opline->op1.var).tmp_var); 10966: } else { 10967: zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); 10968: } 10969: CHECK_EXCEPTION(); 10970: ZEND_VM_NEXT_OPCODE(); 10971: } 10972: 10973: static int ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 10974: { 10975: USE_OPLINE 10976: zval *retval_ptr; 10977: zend_free_op free_op1; 10978: 10979: SAVE_OPLINE(); 10980: retval_ptr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 10981: 10982: if (!EG(return_value_ptr_ptr)) { 10983: if (IS_VAR == IS_TMP_VAR) { 10984: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 10985: } 10986: } else if (!0) { /* Not a temp var */ 10987: if (IS_VAR == IS_CONST || 10988: (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) { 10989: zval *ret; 10990: 10991: ALLOC_ZVAL(ret); 10992: INIT_PZVAL_COPY(ret, retval_ptr); 10993: zval_copy_ctor(ret); 10994: *EG(return_value_ptr_ptr) = ret; 10995: } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && 10996: retval_ptr == &EG(uninitialized_zval)) { 10997: zval *ret; 10998: 10999: ALLOC_INIT_ZVAL(ret); 11000: *EG(return_value_ptr_ptr) = ret; 11001: } else { 11002: *EG(return_value_ptr_ptr) = retval_ptr; 11003: Z_ADDREF_P(retval_ptr); 11004: } 11005: } else { 11006: zval *ret; 11007: 11008: ALLOC_ZVAL(ret); 11009: INIT_PZVAL_COPY(ret, retval_ptr); 11010: *EG(return_value_ptr_ptr) = ret; 11011: } 11012: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11013: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11014: } 11015: 11016: static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11017: { 11018: USE_OPLINE 11019: zval *retval_ptr; 11020: zval **retval_ptr_ptr; 11021: zend_free_op free_op1; 11022: 11023: SAVE_OPLINE(); 11024: 11025: do { 11026: if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { 11027: /* Not supposed to happen, but we'll allow it */ 11028: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 11029: 11030: retval_ptr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11031: if (!EG(return_value_ptr_ptr)) { 11032: if (IS_VAR == IS_TMP_VAR) { 11033: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11034: } 11035: } else if (!0) { /* Not a temp var */ 11036: zval *ret; 11037: 11038: ALLOC_ZVAL(ret); 11039: INIT_PZVAL_COPY(ret, retval_ptr); 11040: zval_copy_ctor(ret); 11041: *EG(return_value_ptr_ptr) = ret; 11042: } else { 11043: zval *ret; 11044: 11045: ALLOC_ZVAL(ret); 11046: INIT_PZVAL_COPY(ret, retval_ptr); 11047: *EG(return_value_ptr_ptr) = ret; 11048: } 11049: break; 11050: } 11051: 11052: retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11053: 11054: if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { 11055: zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); 11056: } 11057: 11058: if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { 11059: if (opline->extended_value == ZEND_RETURNS_FUNCTION && 11060: EX_T(opline->op1.var).var.fcall_returned_reference) { 11061: } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { 11062: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 11063: if (EG(return_value_ptr_ptr)) { 11064: zval *ret; 11065: 11066: ALLOC_ZVAL(ret); 11067: INIT_PZVAL_COPY(ret, *retval_ptr_ptr); 11068: zval_copy_ctor(ret); 11069: *EG(return_value_ptr_ptr) = ret; 11070: } 11071: break; 11072: } 11073: } 11074: 11075: if (EG(return_value_ptr_ptr)) { 11076: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); 11077: Z_ADDREF_PP(retval_ptr_ptr); 11078: 11079: *EG(return_value_ptr_ptr) = *retval_ptr_ptr; 11080: } 11081: } while (0); 11082: 11083: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11084: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11085: } 11086: 11087: static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11088: { 11089: USE_OPLINE 11090: zval *value; 11091: zval *exception; 11092: zend_free_op free_op1; 11093: 11094: SAVE_OPLINE(); 11095: value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11096: 11097: if (IS_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { 11098: zend_error_noreturn(E_ERROR, "Can only throw objects"); 11099: } 11100: zend_exception_save(TSRMLS_C); 11101: /* Not sure if a complete copy is what we want here */ 11102: ALLOC_ZVAL(exception); 11103: INIT_PZVAL_COPY(exception, value); 11104: if (!0) { 11105: zval_copy_ctor(exception); 11106: } 11107: 11108: zend_throw_exception_object(exception TSRMLS_CC); 11109: zend_exception_restore(TSRMLS_C); 11110: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11111: HANDLE_EXCEPTION(); 11112: } 11113: 11114: static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS) 11115: { 11116: USE_OPLINE 11117: zval *varptr; 11118: zend_free_op free_op1; 11119: varptr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11120: 11121: if (varptr == &EG(uninitialized_zval)) { 11122: ALLOC_ZVAL(varptr); 11123: INIT_ZVAL(*varptr); 11124: Z_SET_REFCOUNT_P(varptr, 0); 11125: } else if (PZVAL_IS_REF(varptr)) { 11126: zval *original_var = varptr; 11127: 11128: ALLOC_ZVAL(varptr); 11129: ZVAL_COPY_VALUE(varptr, original_var); 11130: Z_UNSET_ISREF_P(varptr); 11131: Z_SET_REFCOUNT_P(varptr, 0); 11132: zval_copy_ctor(varptr); 11133: } 11134: Z_ADDREF_P(varptr); 11135: zend_vm_stack_push(varptr TSRMLS_CC); 11136: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; /* for string offsets */ 11137: 11138: CHECK_EXCEPTION(); 11139: ZEND_VM_NEXT_OPCODE(); 11140: } 11141: 11142: static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11143: { 11144: USE_OPLINE 11145: zend_free_op free_op1; 11146: zval *varptr; 11147: 11148: SAVE_OPLINE(); 11149: if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */ 11150: if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) { 11151: return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11152: } 11153: } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 11154: return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11155: } 11156: 11157: if (IS_VAR == IS_VAR && 11158: (opline->extended_value & ZEND_ARG_SEND_FUNCTION) && 11159: EX_T(opline->op1.var).var.fcall_returned_reference && 11160: EX_T(opline->op1.var).var.ptr) { 11161: varptr = EX_T(opline->op1.var).var.ptr; 11162: PZVAL_UNLOCK_EX(varptr, &free_op1, 0); 11163: } else { 11164: varptr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11165: } 11166: if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) || 11167: EX_T(opline->op1.var).var.fcall_returned_reference) && 11168: varptr != &EG(uninitialized_zval) && 11169: (PZVAL_IS_REF(varptr) || 11170: (Z_REFCOUNT_P(varptr) == 1 && (IS_VAR == IS_CV || free_op1.var)))) { 11171: Z_SET_ISREF_P(varptr); 11172: Z_ADDREF_P(varptr); 11173: zend_vm_stack_push(varptr TSRMLS_CC); 11174: } else { 11175: zval *valptr; 11176: 11177: if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? 11178: !(opline->extended_value & ZEND_ARG_SEND_SILENT) : 11179: !ARG_MAY_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 11180: zend_error(E_STRICT, "Only variables should be passed by reference"); 11181: } 11182: ALLOC_ZVAL(valptr); 11183: INIT_PZVAL_COPY(valptr, varptr); 11184: if (!0) { 11185: zval_copy_ctor(valptr); 11186: } 11187: zend_vm_stack_push(valptr TSRMLS_CC); 11188: } 11189: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11190: CHECK_EXCEPTION(); 11191: ZEND_VM_NEXT_OPCODE(); 11192: } 11193: 11194: static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11195: { 11196: USE_OPLINE 11197: zend_free_op free_op1; 11198: zval **varptr_ptr; 11199: zval *varptr; 11200: 11201: SAVE_OPLINE(); 11202: varptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11203: 11204: if (IS_VAR == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) { 11205: zend_error_noreturn(E_ERROR, "Only variables can be passed by reference"); 11206: } 11207: 11208: if (IS_VAR == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) { 11209: ALLOC_INIT_ZVAL(varptr); 11210: zend_vm_stack_push(varptr TSRMLS_CC); 11211: CHECK_EXCEPTION(); 11212: ZEND_VM_NEXT_OPCODE(); 11213: } 11214: 11215: if (opline->extended_value == ZEND_DO_FCALL_BY_NAME && 11216: EX(function_state).function->type == ZEND_INTERNAL_FUNCTION && 11217: !ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 11218: return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11219: } 11220: 11221: SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr); 11222: varptr = *varptr_ptr; 11223: Z_ADDREF_P(varptr); 11224: zend_vm_stack_push(varptr TSRMLS_CC); 11225: 11226: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11227: CHECK_EXCEPTION(); 11228: ZEND_VM_NEXT_OPCODE(); 11229: } 11230: 11231: static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11232: { 11233: USE_OPLINE 11234: 11235: if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME) 11236: && ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 11237: return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11238: } 11239: SAVE_OPLINE(); 11240: return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 11241: } 11242: 11243: static int ZEND_FASTCALL ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11244: { 11245: USE_OPLINE 11246: zend_free_op free_op1; 11247: zval *retval = &EX_T(opline->result.var).tmp_var; 11248: 11249: SAVE_OPLINE(); 11250: /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ 11251: ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC))); 11252: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11253: 11254: CHECK_EXCEPTION(); 11255: ZEND_VM_NEXT_OPCODE(); 11256: } 11257: 11258: static int ZEND_FASTCALL ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11259: { 11260: USE_OPLINE 11261: 11262: SAVE_OPLINE(); 11263: zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); 11264: CHECK_EXCEPTION(); 11265: ZEND_VM_NEXT_OPCODE(); 11266: } 11267: 11268: static int ZEND_FASTCALL ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11269: { 11270: USE_OPLINE 11271: zend_free_op free_op1; 11272: zval *obj; 11273: zend_class_entry *ce; 11274: zend_function *clone; 11275: zend_object_clone_obj_t clone_call; 11276: 11277: SAVE_OPLINE(); 11278: obj = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11279: 11280: if (IS_VAR == IS_CONST || 11281: UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) { 11282: zend_error_noreturn(E_ERROR, "__clone method called on non-object"); 11283: } 11284: 11285: ce = Z_OBJCE_P(obj); 11286: clone = ce ? ce->clone : NULL; 11287: clone_call = Z_OBJ_HT_P(obj)->clone_obj; 11288: if (UNEXPECTED(clone_call == NULL)) { 11289: if (ce) { 11290: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); 11291: } else { 11292: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); 11293: } 11294: } 11295: 11296: if (ce && clone) { 11297: if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { 11298: /* Ensure that if we're calling a private function, we're allowed to do so. 11299: */ 11300: if (UNEXPECTED(ce != EG(scope))) { 11301: zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 11302: } 11303: } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { 11304: /* Ensure that if we're calling a protected function, we're allowed to do so. 11305: */ 11306: if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { 11307: zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 11308: } 11309: } 11310: } 11311: 11312: if (EXPECTED(EG(exception) == NULL)) { 11313: zval *retval; 11314: 11315: ALLOC_ZVAL(retval); 11316: Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); 11317: Z_TYPE_P(retval) = IS_OBJECT; 11318: Z_SET_REFCOUNT_P(retval, 1); 11319: Z_SET_ISREF_P(retval); 11320: if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { 11321: zval_ptr_dtor(&retval); 11322: } else { 11323: AI_SET_PTR(&EX_T(opline->result.var), retval); 11324: } 11325: } 11326: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11327: CHECK_EXCEPTION(); 11328: ZEND_VM_NEXT_OPCODE(); 11329: } 11330: 11331: static int ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11332: { 11333: USE_OPLINE 11334: zend_free_op free_op1; 11335: zval *expr; 11336: zval *result = &EX_T(opline->result.var).tmp_var; 11337: 11338: SAVE_OPLINE(); 11339: expr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11340: 11341: if (opline->extended_value != IS_STRING) { 11342: ZVAL_COPY_VALUE(result, expr); 11343: if (!0) { 11344: zendi_zval_copy_ctor(*result); 11345: } 11346: } 11347: switch (opline->extended_value) { 11348: case IS_NULL: 11349: convert_to_null(result); 11350: break; 11351: case IS_BOOL: 11352: convert_to_boolean(result); 11353: break; 11354: case IS_LONG: 11355: convert_to_long(result); 11356: break; 11357: case IS_DOUBLE: 11358: convert_to_double(result); 11359: break; 11360: case IS_STRING: { 11361: zval var_copy; 11362: int use_copy; 11363: 11364: zend_make_printable_zval(expr, &var_copy, &use_copy); 11365: if (use_copy) { 11366: ZVAL_COPY_VALUE(result, &var_copy); 11367: if (0) { 11368: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11369: } 11370: } else { 11371: ZVAL_COPY_VALUE(result, expr); 11372: if (!0) { 11373: zendi_zval_copy_ctor(*result); 11374: } 11375: } 11376: break; 11377: } 11378: case IS_ARRAY: 11379: convert_to_array(result); 11380: break; 11381: case IS_OBJECT: 11382: convert_to_object(result); 11383: break; 11384: } 11385: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11386: CHECK_EXCEPTION(); 11387: ZEND_VM_NEXT_OPCODE(); 11388: } 11389: 11390: static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11391: { 11392: USE_OPLINE 11393: zend_op_array *new_op_array=NULL; 11394: zend_free_op free_op1; 11395: zval *inc_filename; 11396: zval *tmp_inc_filename = NULL; 11397: zend_bool failure_retval=0; 11398: 11399: SAVE_OPLINE(); 11400: inc_filename = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11401: 11402: if (inc_filename->type!=IS_STRING) { 11403: MAKE_STD_ZVAL(tmp_inc_filename); 11404: ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); 11405: zval_copy_ctor(tmp_inc_filename); 11406: convert_to_string(tmp_inc_filename); 11407: inc_filename = tmp_inc_filename; 11408: } 11409: 11410: if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { 11411: if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { 11412: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 11413: } else { 11414: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 11415: } 11416: } else { 11417: switch (opline->extended_value) { 11418: case ZEND_INCLUDE_ONCE: 11419: case ZEND_REQUIRE_ONCE: { 11420: zend_file_handle file_handle; 11421: char *resolved_path; 11422: 11423: resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); 11424: if (resolved_path) { 11425: failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); 11426: } else { 11427: resolved_path = Z_STRVAL_P(inc_filename); 11428: } 11429: 11430: if (failure_retval) { 11431: /* do nothing, file already included */ 11432: } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) { 11433: 11434: if (!file_handle.opened_path) { 11435: file_handle.opened_path = estrdup(resolved_path); 11436: } 11437: 11438: if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { 11439: new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); 11440: zend_destroy_file_handle(&file_handle TSRMLS_CC); 11441: } else { 11442: zend_file_handle_dtor(&file_handle TSRMLS_CC); 11443: failure_retval=1; 11444: } 11445: } else { 11446: if (opline->extended_value == ZEND_INCLUDE_ONCE) { 11447: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 11448: } else { 11449: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 11450: } 11451: } 11452: if (resolved_path != Z_STRVAL_P(inc_filename)) { 11453: efree(resolved_path); 11454: } 11455: } 11456: break; 11457: case ZEND_INCLUDE: 11458: case ZEND_REQUIRE: 11459: new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC); 11460: break; 11461: case ZEND_EVAL: { 11462: char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC); 11463: 11464: new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC); 11465: efree(eval_desc); 11466: } 11467: break; 11468: EMPTY_SWITCH_DEFAULT_CASE() 11469: } 11470: } 11471: if (tmp_inc_filename) { 11472: zval_ptr_dtor(&tmp_inc_filename); 11473: } 11474: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11475: if (UNEXPECTED(EG(exception) != NULL)) { 11476: HANDLE_EXCEPTION(); 11477: } else if (EXPECTED(new_op_array != NULL)) { 11478: EX(original_return_value) = EG(return_value_ptr_ptr); 11479: EG(active_op_array) = new_op_array; 11480: if (RETURN_VALUE_USED(opline)) { 11481: EX_T(opline->result.var).var.ptr = NULL; 11482: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 11483: EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; 11484: } else { 11485: EG(return_value_ptr_ptr) = NULL; 11486: } 11487: 11488: EX(current_object) = EX(object); 11489: 11490: EX(function_state).function = (zend_function *) new_op_array; 11491: EX(object) = NULL; 11492: 11493: if (!EG(active_symbol_table)) { 11494: zend_rebuild_symbol_table(TSRMLS_C); 11495: } 11496: 11497: if (EXPECTED(zend_execute == execute)) { 11498: ZEND_VM_ENTER(); 11499: } else { 11500: zend_execute(new_op_array TSRMLS_CC); 11501: } 11502: 11503: EX(function_state).function = (zend_function *) EX(op_array); 11504: EX(object) = EX(current_object); 11505: 11506: EG(opline_ptr) = &EX(opline); 11507: EG(active_op_array) = EX(op_array); 11508: EG(return_value_ptr_ptr) = EX(original_return_value); 11509: destroy_op_array(new_op_array TSRMLS_CC); 11510: efree(new_op_array); 11511: if (UNEXPECTED(EG(exception) != NULL)) { 11512: zend_throw_exception_internal(NULL TSRMLS_CC); 11513: HANDLE_EXCEPTION(); 11514: } else if (RETURN_VALUE_USED(opline)) { 11515: if (!EX_T(opline->result.var).var.ptr) { /* there was no return statement */ 11516: zval *retval; 11517: 11518: ALLOC_ZVAL(retval); 11519: ZVAL_BOOL(retval, 1); 11520: INIT_PZVAL(retval); 11521: EX_T(opline->result.var).var.ptr = retval; 11522: } 11523: } 11524: 11525: } else if (RETURN_VALUE_USED(opline)) { 11526: zval *retval; 11527: 11528: ALLOC_ZVAL(retval); 11529: ZVAL_BOOL(retval, failure_retval); 11530: INIT_PZVAL(retval); 11531: AI_SET_PTR(&EX_T(opline->result.var), retval); 11532: } 11533: ZEND_VM_NEXT_OPCODE(); 11534: } 11535: 11536: static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11537: { 11538: USE_OPLINE 11539: zend_free_op free_op1; 11540: zval *array_ptr, **array_ptr_ptr; 11541: HashTable *fe_ht; 11542: zend_object_iterator *iter = NULL; 11543: zend_class_entry *ce = NULL; 11544: zend_bool is_empty = 0; 11545: 11546: SAVE_OPLINE(); 11547: 11548: if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && 11549: (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { 11550: array_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11551: if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { 11552: MAKE_STD_ZVAL(array_ptr); 11553: ZVAL_NULL(array_ptr); 11554: } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { 11555: if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { 11556: zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); 11557: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11558: } 11559: 11560: ce = Z_OBJCE_PP(array_ptr_ptr); 11561: if (!ce || ce->get_iterator == NULL) { 11562: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 11563: Z_ADDREF_PP(array_ptr_ptr); 11564: } 11565: array_ptr = *array_ptr_ptr; 11566: } else { 11567: if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { 11568: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 11569: if (opline->extended_value & ZEND_FE_FETCH_BYREF) { 11570: Z_SET_ISREF_PP(array_ptr_ptr); 11571: } 11572: } 11573: array_ptr = *array_ptr_ptr; 11574: Z_ADDREF_P(array_ptr); 11575: } 11576: } else { 11577: array_ptr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11578: if (0) { /* IS_TMP_VAR */ 11579: zval *tmp; 11580: 11581: ALLOC_ZVAL(tmp); 11582: INIT_PZVAL_COPY(tmp, array_ptr); 11583: array_ptr = tmp; 11584: if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 11585: ce = Z_OBJCE_P(array_ptr); 11586: if (ce && ce->get_iterator) { 11587: Z_DELREF_P(array_ptr); 11588: } 11589: } 11590: } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 11591: ce = Z_OBJCE_P(array_ptr); 11592: if (!ce || !ce->get_iterator) { 11593: Z_ADDREF_P(array_ptr); 11594: } 11595: } else if (IS_VAR == IS_CONST || 11596: ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && 11597: !Z_ISREF_P(array_ptr) && 11598: Z_REFCOUNT_P(array_ptr) > 1)) { 11599: zval *tmp; 11600: 11601: ALLOC_ZVAL(tmp); 11602: INIT_PZVAL_COPY(tmp, array_ptr); 11603: zval_copy_ctor(tmp); 11604: array_ptr = tmp; 11605: } else { 11606: Z_ADDREF_P(array_ptr); 11607: } 11608: } 11609: 11610: if (ce && ce->get_iterator) { 11611: iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC); 11612: 11613: if (iter && EXPECTED(EG(exception) == NULL)) { 11614: array_ptr = zend_iterator_wrap(iter TSRMLS_CC); 11615: } else { 11616: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11617: if (!EG(exception)) { 11618: zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); 11619: } 11620: zend_throw_exception_internal(NULL TSRMLS_CC); 11621: HANDLE_EXCEPTION(); 11622: } 11623: } 11624: 11625: EX_T(opline->result.var).fe.ptr = array_ptr; 11626: 11627: if (iter) { 11628: iter->index = 0; 11629: if (iter->funcs->rewind) { 11630: iter->funcs->rewind(iter TSRMLS_CC); 11631: if (UNEXPECTED(EG(exception) != NULL)) { 11632: zval_ptr_dtor(&array_ptr); 11633: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11634: HANDLE_EXCEPTION(); 11635: } 11636: } 11637: is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; 11638: if (UNEXPECTED(EG(exception) != NULL)) { 11639: zval_ptr_dtor(&array_ptr); 11640: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11641: HANDLE_EXCEPTION(); 11642: } 11643: iter->index = -1; /* will be set to 0 before using next handler */ 11644: } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { 11645: zend_hash_internal_pointer_reset(fe_ht); 11646: if (ce) { 11647: zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); 11648: while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { 11649: char *str_key; 11650: uint str_key_len; 11651: ulong int_key; 11652: zend_uchar key_type; 11653: 11654: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); 11655: if (key_type != HASH_KEY_NON_EXISTANT && 11656: (key_type == HASH_KEY_IS_LONG || 11657: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { 11658: break; 11659: } 11660: zend_hash_move_forward(fe_ht); 11661: } 11662: } 11663: is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; 11664: zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); 11665: } else { 11666: zend_error(E_WARNING, "Invalid argument supplied for foreach()"); 11667: is_empty = 1; 11668: } 11669: 11670: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11671: if (is_empty) { 11672: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11673: } else { 11674: CHECK_EXCEPTION(); 11675: ZEND_VM_NEXT_OPCODE(); 11676: } 11677: } 11678: 11679: static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11680: { 11681: USE_OPLINE 11682: 11683: zval *array = EX_T(opline->op1.var).fe.ptr; 11684: zval **value; 11685: char *str_key; 11686: uint str_key_len; 11687: ulong int_key; 11688: HashTable *fe_ht; 11689: zend_object_iterator *iter = NULL; 11690: int key_type = 0; 11691: zend_bool use_key = (zend_bool)(opline->extended_value & ZEND_FE_FETCH_WITH_KEY); 11692: 11693: SAVE_OPLINE(); 11694: 11695: switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) { 11696: default: 11697: case ZEND_ITER_INVALID: 11698: zend_error(E_WARNING, "Invalid argument supplied for foreach()"); 11699: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11700: 11701: case ZEND_ITER_PLAIN_OBJECT: { 11702: const char *class_name, *prop_name; 11703: zend_object *zobj = zend_objects_get_address(array TSRMLS_CC); 11704: 11705: fe_ht = Z_OBJPROP_P(array); 11706: zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); 11707: do { 11708: if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) { 11709: /* reached end of iteration */ 11710: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11711: } 11712: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); 11713: 11714: zend_hash_move_forward(fe_ht); 11715: } while (key_type == HASH_KEY_NON_EXISTANT || 11716: (key_type != HASH_KEY_IS_LONG && 11717: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) != SUCCESS)); 11718: zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); 11719: if (use_key && key_type != HASH_KEY_IS_LONG) { 11720: zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name); 11721: str_key_len = strlen(prop_name); 11722: str_key = estrndup(prop_name, str_key_len); 11723: str_key_len++; 11724: } 11725: break; 11726: } 11727: 11728: case ZEND_ITER_PLAIN_ARRAY: 11729: fe_ht = Z_ARRVAL_P(array); 11730: zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); 11731: if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) { 11732: /* reached end of iteration */ 11733: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11734: } 11735: if (use_key) { 11736: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 1, NULL); 11737: } 11738: zend_hash_move_forward(fe_ht); 11739: zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); 11740: break; 11741: 11742: case ZEND_ITER_OBJECT: 11743: /* !iter happens from exception */ 11744: if (iter && ++iter->index > 0) { 11745: /* This could cause an endless loop if index becomes zero again. 11746: * In case that ever happens we need an additional flag. */ 11747: iter->funcs->move_forward(iter TSRMLS_CC); 11748: if (UNEXPECTED(EG(exception) != NULL)) { 11749: zval_ptr_dtor(&array); 11750: HANDLE_EXCEPTION(); 11751: } 11752: } 11753: /* If index is zero we come from FE_RESET and checked valid() already. */ 11754: if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) { 11755: /* reached end of iteration */ 11756: if (UNEXPECTED(EG(exception) != NULL)) { 11757: zval_ptr_dtor(&array); 11758: HANDLE_EXCEPTION(); 11759: } 11760: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11761: } 11762: iter->funcs->get_current_data(iter, &value TSRMLS_CC); 11763: if (UNEXPECTED(EG(exception) != NULL)) { 11764: zval_ptr_dtor(&array); 11765: HANDLE_EXCEPTION(); 11766: } 11767: if (!value) { 11768: /* failure in get_current_data */ 11769: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 11770: } 11771: if (use_key) { 11772: if (iter->funcs->get_current_key) { 11773: key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC); 11774: if (UNEXPECTED(EG(exception) != NULL)) { 11775: zval_ptr_dtor(&array); 11776: HANDLE_EXCEPTION(); 11777: } 11778: } else { 11779: key_type = HASH_KEY_IS_LONG; 11780: int_key = iter->index; 11781: } 11782: } 11783: break; 11784: } 11785: 11786: if (opline->extended_value & ZEND_FE_FETCH_BYREF) { 11787: SEPARATE_ZVAL_IF_NOT_REF(value); 11788: Z_SET_ISREF_PP(value); 11789: EX_T(opline->result.var).var.ptr_ptr = value; 11790: Z_ADDREF_PP(value); 11791: } else { 11792: PZVAL_LOCK(*value); 11793: AI_SET_PTR(&EX_T(opline->result.var), *value); 11794: } 11795: 11796: if (use_key) { 11797: zval *key = &EX_T((opline+1)->result.var).tmp_var; 11798: 11799: switch (key_type) { 11800: case HASH_KEY_IS_STRING: 11801: Z_STRVAL_P(key) = (char*)str_key; 11802: Z_STRLEN_P(key) = str_key_len-1; 11803: Z_TYPE_P(key) = IS_STRING; 11804: break; 11805: case HASH_KEY_IS_LONG: 11806: Z_LVAL_P(key) = int_key; 11807: Z_TYPE_P(key) = IS_LONG; 11808: break; 11809: default: 11810: case HASH_KEY_NON_EXISTANT: 11811: ZVAL_NULL(key); 11812: break; 11813: } 11814: } 11815: 11816: CHECK_EXCEPTION(); 11817: ZEND_VM_INC_OPCODE(); 11818: ZEND_VM_NEXT_OPCODE(); 11819: } 11820: 11821: static int ZEND_FASTCALL ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11822: { 11823: #if 0 || (IS_VAR != IS_UNUSED) 11824: USE_OPLINE 11825: 11826: SAVE_OPLINE(); 11827: if (IS_VAR != IS_UNUSED) { 11828: zend_free_op free_op1; 11829: zval *ptr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11830: 11831: if (Z_TYPE_P(ptr) == IS_LONG) { 11832: EG(exit_status) = Z_LVAL_P(ptr); 11833: } else { 11834: zend_print_variable(ptr); 11835: } 11836: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11837: } 11838: #endif 11839: zend_bailout(); 11840: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 11841: } 11842: 11843: static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11844: { 11845: USE_OPLINE 11846: zend_free_op free_op1; 11847: zval *value; 11848: 11849: SAVE_OPLINE(); 11850: value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11851: 11852: if (i_zend_is_true(value)) { 11853: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 11854: if (!0) { 11855: zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); 11856: } 11857: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11858: #if DEBUG_ZEND>=2 11859: printf("Conditional jmp to %d\n", opline->op2.opline_num); 11860: #endif 11861: ZEND_VM_JMP(opline->op2.jmp_addr); 11862: } 11863: 11864: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11865: CHECK_EXCEPTION(); 11866: ZEND_VM_NEXT_OPCODE(); 11867: } 11868: 11869: static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11870: { 11871: USE_OPLINE 11872: zend_free_op free_op1; 11873: zval *value, *ret; 11874: 11875: SAVE_OPLINE(); 11876: value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11877: 11878: if (i_zend_is_true(value)) { 11879: if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 11880: Z_ADDREF_P(value); 11881: EX_T(opline->result.var).var.ptr = value; 11882: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 11883: } else { 11884: ALLOC_ZVAL(ret); 11885: INIT_PZVAL_COPY(ret, value); 11886: EX_T(opline->result.var).var.ptr = ret; 11887: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 11888: if (!0) { 11889: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 11890: } 11891: } 11892: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11893: #if DEBUG_ZEND>=2 11894: printf("Conditional jmp to %d\n", opline->op2.opline_num); 11895: #endif 11896: ZEND_VM_JMP(opline->op2.jmp_addr); 11897: } 11898: 11899: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11900: CHECK_EXCEPTION(); 11901: ZEND_VM_NEXT_OPCODE(); 11902: } 11903: 11904: static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11905: { 11906: USE_OPLINE 11907: zend_free_op free_op1; 11908: zval *value; 11909: 11910: SAVE_OPLINE(); 11911: value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11912: 11913: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 11914: if (!0) { 11915: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 11916: } 11917: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11918: CHECK_EXCEPTION(); 11919: ZEND_VM_NEXT_OPCODE(); 11920: } 11921: 11922: static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11923: { 11924: USE_OPLINE 11925: zend_free_op free_op1; 11926: zval *value, *ret; 11927: 11928: SAVE_OPLINE(); 11929: value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11930: 11931: if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 11932: Z_ADDREF_P(value); 11933: EX_T(opline->result.var).var.ptr = value; 11934: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 11935: } else { 11936: ALLOC_ZVAL(ret); 11937: INIT_PZVAL_COPY(ret, value); 11938: EX_T(opline->result.var).var.ptr = ret; 11939: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 11940: if (!0) { 11941: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 11942: } 11943: } 11944: 11945: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11946: CHECK_EXCEPTION(); 11947: ZEND_VM_NEXT_OPCODE(); 11948: } 11949: 11950: static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11951: { 11952: USE_OPLINE 11953: zend_free_op free_op1; 11954: zval *expr; 11955: zend_bool result; 11956: 11957: SAVE_OPLINE(); 11958: expr = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 11959: 11960: if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { 11961: result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); 11962: } else { 11963: result = 0; 11964: } 11965: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); 11966: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11967: CHECK_EXCEPTION(); 11968: ZEND_VM_NEXT_OPCODE(); 11969: } 11970: 11971: static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11972: { 11973: USE_OPLINE 11974: zend_free_op free_op1; 11975: 11976: SAVE_OPLINE(); 11977: fast_add_function(&EX_T(opline->result.var).tmp_var, 11978: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 11979: opline->op2.zv TSRMLS_CC); 11980: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11981: 11982: CHECK_EXCEPTION(); 11983: ZEND_VM_NEXT_OPCODE(); 11984: } 11985: 11986: static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 11987: { 11988: USE_OPLINE 11989: zend_free_op free_op1; 11990: 11991: SAVE_OPLINE(); 11992: fast_sub_function(&EX_T(opline->result.var).tmp_var, 11993: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 11994: opline->op2.zv TSRMLS_CC); 11995: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 11996: 11997: CHECK_EXCEPTION(); 11998: ZEND_VM_NEXT_OPCODE(); 11999: } 12000: 12001: static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12002: { 12003: USE_OPLINE 12004: zend_free_op free_op1; 12005: 12006: SAVE_OPLINE(); 12007: fast_mul_function(&EX_T(opline->result.var).tmp_var, 12008: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12009: opline->op2.zv TSRMLS_CC); 12010: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12011: 12012: CHECK_EXCEPTION(); 12013: ZEND_VM_NEXT_OPCODE(); 12014: } 12015: 12016: static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12017: { 12018: USE_OPLINE 12019: zend_free_op free_op1; 12020: 12021: SAVE_OPLINE(); 12022: fast_div_function(&EX_T(opline->result.var).tmp_var, 12023: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12024: opline->op2.zv TSRMLS_CC); 12025: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12026: 12027: CHECK_EXCEPTION(); 12028: ZEND_VM_NEXT_OPCODE(); 12029: } 12030: 12031: static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12032: { 12033: USE_OPLINE 12034: zend_free_op free_op1; 12035: 12036: SAVE_OPLINE(); 12037: fast_mod_function(&EX_T(opline->result.var).tmp_var, 12038: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12039: opline->op2.zv TSRMLS_CC); 12040: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12041: 12042: CHECK_EXCEPTION(); 12043: ZEND_VM_NEXT_OPCODE(); 12044: } 12045: 12046: static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12047: { 12048: USE_OPLINE 12049: zend_free_op free_op1; 12050: 12051: SAVE_OPLINE(); 12052: shift_left_function(&EX_T(opline->result.var).tmp_var, 12053: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12054: opline->op2.zv TSRMLS_CC); 12055: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12056: 12057: CHECK_EXCEPTION(); 12058: ZEND_VM_NEXT_OPCODE(); 12059: } 12060: 12061: static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12062: { 12063: USE_OPLINE 12064: zend_free_op free_op1; 12065: 12066: SAVE_OPLINE(); 12067: shift_right_function(&EX_T(opline->result.var).tmp_var, 12068: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12069: opline->op2.zv TSRMLS_CC); 12070: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12071: 12072: CHECK_EXCEPTION(); 12073: ZEND_VM_NEXT_OPCODE(); 12074: } 12075: 12076: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12077: { 12078: USE_OPLINE 12079: zend_free_op free_op1; 12080: 12081: SAVE_OPLINE(); 12082: concat_function(&EX_T(opline->result.var).tmp_var, 12083: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12084: opline->op2.zv TSRMLS_CC); 12085: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12086: 12087: CHECK_EXCEPTION(); 12088: ZEND_VM_NEXT_OPCODE(); 12089: } 12090: 12091: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12092: { 12093: USE_OPLINE 12094: zend_free_op free_op1; 12095: 12096: SAVE_OPLINE(); 12097: is_identical_function(&EX_T(opline->result.var).tmp_var, 12098: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12099: opline->op2.zv TSRMLS_CC); 12100: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12101: 12102: CHECK_EXCEPTION(); 12103: ZEND_VM_NEXT_OPCODE(); 12104: } 12105: 12106: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12107: { 12108: USE_OPLINE 12109: zend_free_op free_op1; 12110: zval *result = &EX_T(opline->result.var).tmp_var; 12111: 12112: SAVE_OPLINE(); 12113: is_identical_function(result, 12114: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12115: opline->op2.zv TSRMLS_CC); 12116: Z_LVAL_P(result) = !Z_LVAL_P(result); 12117: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12118: 12119: CHECK_EXCEPTION(); 12120: ZEND_VM_NEXT_OPCODE(); 12121: } 12122: 12123: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12124: { 12125: USE_OPLINE 12126: zend_free_op free_op1; 12127: zval *result = &EX_T(opline->result.var).tmp_var; 12128: 12129: SAVE_OPLINE(); 12130: ZVAL_BOOL(result, fast_equal_function(result, 12131: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12132: opline->op2.zv TSRMLS_CC)); 12133: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12134: 12135: CHECK_EXCEPTION(); 12136: ZEND_VM_NEXT_OPCODE(); 12137: } 12138: 12139: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12140: { 12141: USE_OPLINE 12142: zend_free_op free_op1; 12143: zval *result = &EX_T(opline->result.var).tmp_var; 12144: 12145: SAVE_OPLINE(); 12146: ZVAL_BOOL(result, fast_not_equal_function(result, 12147: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12148: opline->op2.zv TSRMLS_CC)); 12149: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12150: 12151: CHECK_EXCEPTION(); 12152: ZEND_VM_NEXT_OPCODE(); 12153: } 12154: 12155: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12156: { 12157: USE_OPLINE 12158: zend_free_op free_op1; 12159: zval *result = &EX_T(opline->result.var).tmp_var; 12160: 12161: SAVE_OPLINE(); 12162: ZVAL_BOOL(result, fast_is_smaller_function(result, 12163: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12164: opline->op2.zv TSRMLS_CC)); 12165: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12166: 12167: CHECK_EXCEPTION(); 12168: ZEND_VM_NEXT_OPCODE(); 12169: } 12170: 12171: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12172: { 12173: USE_OPLINE 12174: zend_free_op free_op1; 12175: zval *result = &EX_T(opline->result.var).tmp_var; 12176: 12177: SAVE_OPLINE(); 12178: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 12179: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12180: opline->op2.zv TSRMLS_CC)); 12181: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12182: 12183: CHECK_EXCEPTION(); 12184: ZEND_VM_NEXT_OPCODE(); 12185: } 12186: 12187: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12188: { 12189: USE_OPLINE 12190: zend_free_op free_op1; 12191: 12192: SAVE_OPLINE(); 12193: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 12194: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12195: opline->op2.zv TSRMLS_CC); 12196: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12197: 12198: CHECK_EXCEPTION(); 12199: ZEND_VM_NEXT_OPCODE(); 12200: } 12201: 12202: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12203: { 12204: USE_OPLINE 12205: zend_free_op free_op1; 12206: 12207: SAVE_OPLINE(); 12208: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 12209: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12210: opline->op2.zv TSRMLS_CC); 12211: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12212: 12213: CHECK_EXCEPTION(); 12214: ZEND_VM_NEXT_OPCODE(); 12215: } 12216: 12217: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12218: { 12219: USE_OPLINE 12220: zend_free_op free_op1; 12221: 12222: SAVE_OPLINE(); 12223: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 12224: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12225: opline->op2.zv TSRMLS_CC); 12226: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12227: 12228: CHECK_EXCEPTION(); 12229: ZEND_VM_NEXT_OPCODE(); 12230: } 12231: 12232: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12233: { 12234: USE_OPLINE 12235: zend_free_op free_op1; 12236: 12237: SAVE_OPLINE(); 12238: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 12239: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 12240: opline->op2.zv TSRMLS_CC); 12241: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12242: 12243: CHECK_EXCEPTION(); 12244: ZEND_VM_NEXT_OPCODE(); 12245: } 12246: 12247: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 12248: { 12249: USE_OPLINE 12250: zend_free_op free_op1, free_op_data1; 12251: zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12252: zval *object; 12253: zval *property = opline->op2.zv; 12254: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 12255: int have_get_ptr = 0; 12256: 12257: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 12258: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 12259: } 12260: 12261: make_real_object(object_ptr TSRMLS_CC); 12262: object = *object_ptr; 12263: 12264: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 12265: zend_error(E_WARNING, "Attempt to assign property of non-object"); 12266: 12267: FREE_OP(free_op_data1); 12268: 12269: if (RETURN_VALUE_USED(opline)) { 12270: PZVAL_LOCK(&EG(uninitialized_zval)); 12271: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 12272: EX_T(opline->result.var).var.ptr_ptr = NULL; 12273: } 12274: } else { 12275: /* here we are sure we are dealing with an object */ 12276: if (0) { 12277: MAKE_REAL_ZVAL_PTR(property); 12278: } 12279: 12280: /* here property is a string */ 12281: if (opline->extended_value == ZEND_ASSIGN_OBJ 12282: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 12283: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12284: if (zptr != NULL) { /* NULL means no success in getting PTR */ 12285: SEPARATE_ZVAL_IF_NOT_REF(zptr); 12286: 12287: have_get_ptr = 1; 12288: binary_op(*zptr, *zptr, value TSRMLS_CC); 12289: if (RETURN_VALUE_USED(opline)) { 12290: PZVAL_LOCK(*zptr); 12291: EX_T(opline->result.var).var.ptr = *zptr; 12292: EX_T(opline->result.var).var.ptr_ptr = NULL; 12293: } 12294: } 12295: } 12296: 12297: if (!have_get_ptr) { 12298: zval *z = NULL; 12299: 12300: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 12301: if (Z_OBJ_HT_P(object)->read_property) { 12302: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12303: } 12304: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 12305: if (Z_OBJ_HT_P(object)->read_dimension) { 12306: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 12307: } 12308: } 12309: if (z) { 12310: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 12311: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 12312: 12313: if (Z_REFCOUNT_P(z) == 0) { 12314: GC_REMOVE_ZVAL_FROM_BUFFER(z); 12315: zval_dtor(z); 12316: FREE_ZVAL(z); 12317: } 12318: z = value; 12319: } 12320: Z_ADDREF_P(z); 12321: SEPARATE_ZVAL_IF_NOT_REF(&z); 12322: binary_op(z, z, value TSRMLS_CC); 12323: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 12324: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12325: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 12326: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 12327: } 12328: if (RETURN_VALUE_USED(opline)) { 12329: PZVAL_LOCK(z); 12330: EX_T(opline->result.var).var.ptr = z; 12331: EX_T(opline->result.var).var.ptr_ptr = NULL; 12332: } 12333: zval_ptr_dtor(&z); 12334: } else { 12335: zend_error(E_WARNING, "Attempt to assign property of non-object"); 12336: if (RETURN_VALUE_USED(opline)) { 12337: PZVAL_LOCK(&EG(uninitialized_zval)); 12338: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 12339: EX_T(opline->result.var).var.ptr_ptr = NULL; 12340: } 12341: } 12342: } 12343: 12344: if (0) { 12345: zval_ptr_dtor(&property); 12346: } else { 12347: 12348: } 12349: FREE_OP(free_op_data1); 12350: } 12351: 12352: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12353: /* assign_obj has two opcodes! */ 12354: CHECK_EXCEPTION(); 12355: ZEND_VM_INC_OPCODE(); 12356: ZEND_VM_NEXT_OPCODE(); 12357: } 12358: 12359: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 12360: { 12361: USE_OPLINE 12362: zend_free_op free_op1, free_op_data2, free_op_data1; 12363: zval **var_ptr; 12364: zval *value; 12365: 12366: SAVE_OPLINE(); 12367: switch (opline->extended_value) { 12368: case ZEND_ASSIGN_OBJ: 12369: return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12370: break; 12371: case ZEND_ASSIGN_DIM: { 12372: zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12373: 12374: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 12375: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 12376: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 12377: if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { 12378: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 12379: } 12380: return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12381: } else { 12382: zval *dim = opline->op2.zv; 12383: 12384: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); 12385: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 12386: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 12387: } 12388: } 12389: break; 12390: default: 12391: value = opline->op2.zv; 12392: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12393: /* do nothing */ 12394: break; 12395: } 12396: 12397: if (UNEXPECTED(var_ptr == NULL)) { 12398: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 12399: } 12400: 12401: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 12402: if (RETURN_VALUE_USED(opline)) { 12403: PZVAL_LOCK(&EG(uninitialized_zval)); 12404: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 12405: } 12406: 12407: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12408: CHECK_EXCEPTION(); 12409: if (opline->extended_value == ZEND_ASSIGN_DIM) { 12410: ZEND_VM_INC_OPCODE(); 12411: } 12412: ZEND_VM_NEXT_OPCODE(); 12413: } 12414: 12415: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 12416: 12417: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 12418: && Z_OBJ_HANDLER_PP(var_ptr, get) 12419: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 12420: /* proxy object */ 12421: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 12422: Z_ADDREF_P(objval); 12423: binary_op(objval, objval, value TSRMLS_CC); 12424: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 12425: zval_ptr_dtor(&objval); 12426: } else { 12427: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 12428: } 12429: 12430: if (RETURN_VALUE_USED(opline)) { 12431: PZVAL_LOCK(*var_ptr); 12432: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 12433: } 12434: 12435: if (opline->extended_value == ZEND_ASSIGN_DIM) { 12436: FREE_OP(free_op_data1); 12437: FREE_OP_VAR_PTR(free_op_data2); 12438: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12439: CHECK_EXCEPTION(); 12440: ZEND_VM_INC_OPCODE(); 12441: } else { 12442: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12443: CHECK_EXCEPTION(); 12444: } 12445: ZEND_VM_NEXT_OPCODE(); 12446: } 12447: 12448: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12449: { 12450: return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12451: } 12452: 12453: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12454: { 12455: return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12456: } 12457: 12458: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12459: { 12460: return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12461: } 12462: 12463: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12464: { 12465: return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12466: } 12467: 12468: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12469: { 12470: return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12471: } 12472: 12473: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12474: { 12475: return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12476: } 12477: 12478: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12479: { 12480: return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12481: } 12482: 12483: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12484: { 12485: return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12486: } 12487: 12488: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12489: { 12490: return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12491: } 12492: 12493: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12494: { 12495: return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12496: } 12497: 12498: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12499: { 12500: return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12501: } 12502: 12503: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 12504: { 12505: USE_OPLINE 12506: zend_free_op free_op1; 12507: zval **object_ptr; 12508: zval *object; 12509: zval *property; 12510: zval **retval; 12511: int have_get_ptr = 0; 12512: 12513: SAVE_OPLINE(); 12514: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12515: property = opline->op2.zv; 12516: retval = &EX_T(opline->result.var).var.ptr; 12517: 12518: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 12519: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 12520: } 12521: 12522: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 12523: object = *object_ptr; 12524: 12525: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 12526: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 12527: 12528: if (RETURN_VALUE_USED(opline)) { 12529: PZVAL_LOCK(&EG(uninitialized_zval)); 12530: *retval = &EG(uninitialized_zval); 12531: } 12532: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12533: CHECK_EXCEPTION(); 12534: ZEND_VM_NEXT_OPCODE(); 12535: } 12536: 12537: /* here we are sure we are dealing with an object */ 12538: 12539: if (0) { 12540: MAKE_REAL_ZVAL_PTR(property); 12541: } 12542: 12543: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 12544: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12545: if (zptr != NULL) { /* NULL means no success in getting PTR */ 12546: SEPARATE_ZVAL_IF_NOT_REF(zptr); 12547: 12548: have_get_ptr = 1; 12549: incdec_op(*zptr); 12550: if (RETURN_VALUE_USED(opline)) { 12551: *retval = *zptr; 12552: PZVAL_LOCK(*retval); 12553: } 12554: } 12555: } 12556: 12557: if (!have_get_ptr) { 12558: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 12559: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12560: 12561: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 12562: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 12563: 12564: if (Z_REFCOUNT_P(z) == 0) { 12565: GC_REMOVE_ZVAL_FROM_BUFFER(z); 12566: zval_dtor(z); 12567: FREE_ZVAL(z); 12568: } 12569: z = value; 12570: } 12571: Z_ADDREF_P(z); 12572: SEPARATE_ZVAL_IF_NOT_REF(&z); 12573: incdec_op(z); 12574: *retval = z; 12575: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12576: SELECTIVE_PZVAL_LOCK(*retval, opline); 12577: zval_ptr_dtor(&z); 12578: } else { 12579: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 12580: if (RETURN_VALUE_USED(opline)) { 12581: PZVAL_LOCK(&EG(uninitialized_zval)); 12582: *retval = &EG(uninitialized_zval); 12583: } 12584: } 12585: } 12586: 12587: if (0) { 12588: zval_ptr_dtor(&property); 12589: } else { 12590: 12591: } 12592: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12593: CHECK_EXCEPTION(); 12594: ZEND_VM_NEXT_OPCODE(); 12595: } 12596: 12597: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12598: { 12599: return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12600: } 12601: 12602: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12603: { 12604: return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12605: } 12606: 12607: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 12608: { 12609: USE_OPLINE 12610: zend_free_op free_op1; 12611: zval **object_ptr; 12612: zval *object; 12613: zval *property; 12614: zval *retval; 12615: int have_get_ptr = 0; 12616: 12617: SAVE_OPLINE(); 12618: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12619: property = opline->op2.zv; 12620: retval = &EX_T(opline->result.var).tmp_var; 12621: 12622: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 12623: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 12624: } 12625: 12626: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 12627: object = *object_ptr; 12628: 12629: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 12630: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 12631: 12632: ZVAL_NULL(retval); 12633: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12634: CHECK_EXCEPTION(); 12635: ZEND_VM_NEXT_OPCODE(); 12636: } 12637: 12638: /* here we are sure we are dealing with an object */ 12639: 12640: if (0) { 12641: MAKE_REAL_ZVAL_PTR(property); 12642: } 12643: 12644: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 12645: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12646: if (zptr != NULL) { /* NULL means no success in getting PTR */ 12647: have_get_ptr = 1; 12648: SEPARATE_ZVAL_IF_NOT_REF(zptr); 12649: 12650: ZVAL_COPY_VALUE(retval, *zptr); 12651: zendi_zval_copy_ctor(*retval); 12652: 12653: incdec_op(*zptr); 12654: 12655: } 12656: } 12657: 12658: if (!have_get_ptr) { 12659: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 12660: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12661: zval *z_copy; 12662: 12663: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 12664: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 12665: 12666: if (Z_REFCOUNT_P(z) == 0) { 12667: GC_REMOVE_ZVAL_FROM_BUFFER(z); 12668: zval_dtor(z); 12669: FREE_ZVAL(z); 12670: } 12671: z = value; 12672: } 12673: ZVAL_COPY_VALUE(retval, z); 12674: zendi_zval_copy_ctor(*retval); 12675: ALLOC_ZVAL(z_copy); 12676: INIT_PZVAL_COPY(z_copy, z); 12677: zendi_zval_copy_ctor(*z_copy); 12678: incdec_op(z_copy); 12679: Z_ADDREF_P(z); 12680: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 12681: zval_ptr_dtor(&z_copy); 12682: zval_ptr_dtor(&z); 12683: } else { 12684: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 12685: ZVAL_NULL(retval); 12686: } 12687: } 12688: 12689: if (0) { 12690: zval_ptr_dtor(&property); 12691: } else { 12692: 12693: } 12694: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12695: CHECK_EXCEPTION(); 12696: ZEND_VM_NEXT_OPCODE(); 12697: } 12698: 12699: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12700: { 12701: return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12702: } 12703: 12704: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12705: { 12706: return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12707: } 12708: 12709: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) 12710: { 12711: USE_OPLINE 12712: zend_free_op free_op1; 12713: zval *varname; 12714: zval **retval; 12715: zval tmp_varname; 12716: HashTable *target_symbol_table; 12717: ulong hash_value; 12718: 12719: SAVE_OPLINE(); 12720: varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12721: 12722: if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 12723: ZVAL_COPY_VALUE(&tmp_varname, varname); 12724: zval_copy_ctor(&tmp_varname); 12725: Z_SET_REFCOUNT(tmp_varname, 1); 12726: Z_UNSET_ISREF(tmp_varname); 12727: convert_to_string(&tmp_varname); 12728: varname = &tmp_varname; 12729: } 12730: 12731: if (IS_CONST != IS_UNUSED) { 12732: zend_class_entry *ce; 12733: 12734: if (IS_CONST == IS_CONST) { 12735: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 12736: ce = CACHED_PTR(opline->op2.literal->cache_slot); 12737: } else { 12738: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 12739: if (UNEXPECTED(ce == NULL)) { 12740: if (IS_VAR != IS_CONST && varname == &tmp_varname) { 12741: zval_dtor(&tmp_varname); 12742: } 12743: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12744: CHECK_EXCEPTION(); 12745: ZEND_VM_NEXT_OPCODE(); 12746: } 12747: CACHE_PTR(opline->op2.literal->cache_slot, ce); 12748: } 12749: } else { 12750: ce = EX_T(opline->op2.var).class_entry; 12751: } 12752: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 12753: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12754: } else { 12755: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 12756: /* 12757: if (!target_symbol_table) { 12758: CHECK_EXCEPTION(); 12759: ZEND_VM_NEXT_OPCODE(); 12760: } 12761: */ 12762: if (IS_VAR == IS_CONST) { 12763: hash_value = Z_HASH_P(varname); 12764: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 12765: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 12766: } else { 12767: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 12768: } 12769: 12770: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 12771: switch (type) { 12772: case BP_VAR_R: 12773: case BP_VAR_UNSET: 12774: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 12775: /* break missing intentionally */ 12776: case BP_VAR_IS: 12777: retval = &EG(uninitialized_zval_ptr); 12778: break; 12779: case BP_VAR_RW: 12780: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 12781: /* break missing intentionally */ 12782: case BP_VAR_W: 12783: Z_ADDREF_P(&EG(uninitialized_zval)); 12784: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 12785: break; 12786: EMPTY_SWITCH_DEFAULT_CASE() 12787: } 12788: } 12789: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 12790: case ZEND_FETCH_GLOBAL: 12791: if (IS_VAR != IS_TMP_VAR) { 12792: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12793: } 12794: break; 12795: case ZEND_FETCH_LOCAL: 12796: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12797: break; 12798: case ZEND_FETCH_STATIC: 12799: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 12800: break; 12801: case ZEND_FETCH_GLOBAL_LOCK: 12802: if (IS_VAR == IS_VAR && !free_op1.var) { 12803: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 12804: } 12805: break; 12806: } 12807: } 12808: 12809: 12810: if (IS_VAR != IS_CONST && varname == &tmp_varname) { 12811: zval_dtor(&tmp_varname); 12812: } 12813: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 12814: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 12815: } 12816: PZVAL_LOCK(*retval); 12817: switch (type) { 12818: case BP_VAR_R: 12819: case BP_VAR_IS: 12820: AI_SET_PTR(&EX_T(opline->result.var), *retval); 12821: break; 12822: case BP_VAR_UNSET: { 12823: zend_free_op free_res; 12824: 12825: PZVAL_UNLOCK(*retval, &free_res); 12826: if (retval != &EG(uninitialized_zval_ptr)) { 12827: SEPARATE_ZVAL_IF_NOT_REF(retval); 12828: } 12829: PZVAL_LOCK(*retval); 12830: FREE_OP_VAR_PTR(free_res); 12831: } 12832: /* break missing intentionally */ 12833: default: 12834: EX_T(opline->result.var).var.ptr_ptr = retval; 12835: break; 12836: } 12837: CHECK_EXCEPTION(); 12838: ZEND_VM_NEXT_OPCODE(); 12839: } 12840: 12841: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12842: { 12843: return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12844: } 12845: 12846: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12847: { 12848: return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12849: } 12850: 12851: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12852: { 12853: return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12854: } 12855: 12856: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12857: { 12858: USE_OPLINE 12859: 12860: return zend_fetch_var_address_helper_SPEC_VAR_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12861: } 12862: 12863: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12864: { 12865: return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12866: } 12867: 12868: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12869: { 12870: return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 12871: } 12872: 12873: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12874: { 12875: USE_OPLINE 12876: zend_free_op free_op1; 12877: zval **container; 12878: 12879: SAVE_OPLINE(); 12880: 12881: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 12882: IS_VAR != IS_CV && 12883: EX_T(opline->op1.var).var.ptr_ptr) { 12884: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 12885: } 12886: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12887: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); 12888: 12889: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12890: CHECK_EXCEPTION(); 12891: ZEND_VM_NEXT_OPCODE(); 12892: } 12893: 12894: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12895: { 12896: USE_OPLINE 12897: zend_free_op free_op1; 12898: zval **container; 12899: 12900: SAVE_OPLINE(); 12901: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12902: 12903: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 12904: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 12905: } 12906: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); 12907: 12908: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 12909: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 12910: } 12911: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12912: 12913: /* We are going to assign the result by reference */ 12914: if (UNEXPECTED(opline->extended_value != 0)) { 12915: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 12916: 12917: if (retval_ptr) { 12918: Z_DELREF_PP(retval_ptr); 12919: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 12920: Z_ADDREF_PP(retval_ptr); 12921: } 12922: } 12923: 12924: CHECK_EXCEPTION(); 12925: ZEND_VM_NEXT_OPCODE(); 12926: } 12927: 12928: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12929: { 12930: USE_OPLINE 12931: zend_free_op free_op1; 12932: zval **container; 12933: 12934: SAVE_OPLINE(); 12935: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12936: 12937: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 12938: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 12939: } 12940: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC); 12941: 12942: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 12943: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 12944: } 12945: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12946: CHECK_EXCEPTION(); 12947: ZEND_VM_NEXT_OPCODE(); 12948: } 12949: 12950: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12951: { 12952: USE_OPLINE 12953: zend_free_op free_op1; 12954: zval **container; 12955: 12956: SAVE_OPLINE(); 12957: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12958: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC); 12959: 12960: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12961: CHECK_EXCEPTION(); 12962: ZEND_VM_NEXT_OPCODE(); 12963: } 12964: 12965: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12966: { 12967: USE_OPLINE 12968: zend_free_op free_op1; 12969: zval **container; 12970: 12971: SAVE_OPLINE(); 12972: 12973: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 12974: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12975: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 12976: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 12977: } 12978: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); 12979: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 12980: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 12981: } 12982: } else { 12983: if (IS_CONST == IS_UNUSED) { 12984: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 12985: } 12986: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 12987: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); 12988: } 12989: 12990: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 12991: CHECK_EXCEPTION(); 12992: ZEND_VM_NEXT_OPCODE(); 12993: } 12994: 12995: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 12996: { 12997: USE_OPLINE 12998: zend_free_op free_op1; 12999: zval **container; 13000: 13001: SAVE_OPLINE(); 13002: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13003: 13004: if (IS_VAR == IS_CV) { 13005: if (container != &EG(uninitialized_zval_ptr)) { 13006: SEPARATE_ZVAL_IF_NOT_REF(container); 13007: } 13008: } 13009: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 13010: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 13011: } 13012: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC); 13013: 13014: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 13015: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 13016: } 13017: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13018: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 13019: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 13020: } else { 13021: zend_free_op free_res; 13022: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 13023: 13024: PZVAL_UNLOCK(*retval_ptr, &free_res); 13025: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 13026: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 13027: } 13028: PZVAL_LOCK(*retval_ptr); 13029: FREE_OP_VAR_PTR(free_res); 13030: CHECK_EXCEPTION(); 13031: ZEND_VM_NEXT_OPCODE(); 13032: } 13033: } 13034: 13035: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS) 13036: { 13037: USE_OPLINE 13038: zend_free_op free_op1; 13039: zval *container; 13040: 13041: zval *offset; 13042: 13043: SAVE_OPLINE(); 13044: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13045: offset = opline->op2.zv; 13046: 13047: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 13048: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 13049: zend_error(E_NOTICE, "Trying to get property of non-object"); 13050: PZVAL_LOCK(&EG(uninitialized_zval)); 13051: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 13052: 13053: } else { 13054: zval *retval; 13055: 13056: if (0) { 13057: MAKE_REAL_ZVAL_PTR(offset); 13058: } 13059: 13060: /* here we are sure we are dealing with an object */ 13061: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 13062: 13063: PZVAL_LOCK(retval); 13064: AI_SET_PTR(&EX_T(opline->result.var), retval); 13065: 13066: if (0) { 13067: zval_ptr_dtor(&offset); 13068: } else { 13069: 13070: } 13071: } 13072: 13073: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13074: CHECK_EXCEPTION(); 13075: ZEND_VM_NEXT_OPCODE(); 13076: } 13077: 13078: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13079: { 13080: return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 13081: } 13082: 13083: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13084: { 13085: USE_OPLINE 13086: zend_free_op free_op1; 13087: zval *property; 13088: zval **container; 13089: 13090: SAVE_OPLINE(); 13091: property = opline->op2.zv; 13092: 13093: if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 13094: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 13095: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 13096: } 13097: 13098: if (0) { 13099: MAKE_REAL_ZVAL_PTR(property); 13100: } 13101: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13102: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 13103: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 13104: } 13105: 13106: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 13107: if (0) { 13108: zval_ptr_dtor(&property); 13109: } else { 13110: 13111: } 13112: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 13113: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 13114: } 13115: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13116: 13117: /* We are going to assign the result by reference */ 13118: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 13119: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 13120: 13121: Z_DELREF_PP(retval_ptr); 13122: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 13123: Z_ADDREF_PP(retval_ptr); 13124: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 13125: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 13126: } 13127: 13128: CHECK_EXCEPTION(); 13129: ZEND_VM_NEXT_OPCODE(); 13130: } 13131: 13132: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13133: { 13134: USE_OPLINE 13135: zend_free_op free_op1; 13136: zval *property; 13137: zval **container; 13138: 13139: SAVE_OPLINE(); 13140: property = opline->op2.zv; 13141: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13142: 13143: if (0) { 13144: MAKE_REAL_ZVAL_PTR(property); 13145: } 13146: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 13147: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 13148: } 13149: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 13150: if (0) { 13151: zval_ptr_dtor(&property); 13152: } else { 13153: 13154: } 13155: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 13156: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 13157: } 13158: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13159: CHECK_EXCEPTION(); 13160: ZEND_VM_NEXT_OPCODE(); 13161: } 13162: 13163: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13164: { 13165: USE_OPLINE 13166: zend_free_op free_op1; 13167: zval *container; 13168: 13169: zval *offset; 13170: 13171: SAVE_OPLINE(); 13172: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13173: offset = opline->op2.zv; 13174: 13175: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 13176: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 13177: PZVAL_LOCK(&EG(uninitialized_zval)); 13178: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 13179: 13180: } else { 13181: zval *retval; 13182: 13183: if (0) { 13184: MAKE_REAL_ZVAL_PTR(offset); 13185: } 13186: 13187: /* here we are sure we are dealing with an object */ 13188: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 13189: 13190: PZVAL_LOCK(retval); 13191: AI_SET_PTR(&EX_T(opline->result.var), retval); 13192: 13193: if (0) { 13194: zval_ptr_dtor(&offset); 13195: } else { 13196: 13197: } 13198: } 13199: 13200: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13201: CHECK_EXCEPTION(); 13202: ZEND_VM_NEXT_OPCODE(); 13203: } 13204: 13205: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13206: { 13207: USE_OPLINE 13208: 13209: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 13210: /* Behave like FETCH_OBJ_W */ 13211: zend_free_op free_op1; 13212: zval *property; 13213: zval **container; 13214: 13215: SAVE_OPLINE(); 13216: property = opline->op2.zv; 13217: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13218: 13219: if (0) { 13220: MAKE_REAL_ZVAL_PTR(property); 13221: } 13222: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 13223: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 13224: } 13225: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 13226: if (0) { 13227: zval_ptr_dtor(&property); 13228: } else { 13229: 13230: } 13231: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 13232: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 13233: } 13234: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13235: CHECK_EXCEPTION(); 13236: ZEND_VM_NEXT_OPCODE(); 13237: } else { 13238: return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 13239: } 13240: } 13241: 13242: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13243: { 13244: USE_OPLINE 13245: zend_free_op free_op1, free_res; 13246: zval **container; 13247: zval *property; 13248: 13249: SAVE_OPLINE(); 13250: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13251: property = opline->op2.zv; 13252: 13253: if (IS_VAR == IS_CV) { 13254: if (container != &EG(uninitialized_zval_ptr)) { 13255: SEPARATE_ZVAL_IF_NOT_REF(container); 13256: } 13257: } 13258: if (0) { 13259: MAKE_REAL_ZVAL_PTR(property); 13260: } 13261: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 13262: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 13263: } 13264: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 13265: if (0) { 13266: zval_ptr_dtor(&property); 13267: } else { 13268: 13269: } 13270: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 13271: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 13272: } 13273: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13274: 13275: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 13276: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 13277: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 13278: } 13279: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 13280: FREE_OP_VAR_PTR(free_res); 13281: CHECK_EXCEPTION(); 13282: ZEND_VM_NEXT_OPCODE(); 13283: } 13284: 13285: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13286: { 13287: USE_OPLINE 13288: zend_free_op free_op1; 13289: zval **object_ptr; 13290: zval *property_name; 13291: 13292: SAVE_OPLINE(); 13293: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13294: property_name = opline->op2.zv; 13295: 13296: if (0) { 13297: MAKE_REAL_ZVAL_PTR(property_name); 13298: } 13299: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 13300: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 13301: } 13302: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 13303: if (0) { 13304: zval_ptr_dtor(&property_name); 13305: } else { 13306: 13307: } 13308: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13309: /* assign_obj has two opcodes! */ 13310: CHECK_EXCEPTION(); 13311: ZEND_VM_INC_OPCODE(); 13312: ZEND_VM_NEXT_OPCODE(); 13313: } 13314: 13315: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13316: { 13317: USE_OPLINE 13318: zend_free_op free_op1; 13319: zval **object_ptr; 13320: 13321: SAVE_OPLINE(); 13322: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13323: 13324: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 13325: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 13326: } 13327: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 13328: 13329: zval *property_name = opline->op2.zv; 13330: 13331: if (0) { 13332: MAKE_REAL_ZVAL_PTR(property_name); 13333: } 13334: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 13335: if (0) { 13336: zval_ptr_dtor(&property_name); 13337: } else { 13338: 13339: } 13340: } else { 13341: zend_free_op free_op_data1, free_op_data2; 13342: zval *value; 13343: zval *dim = opline->op2.zv; 13344: zval **variable_ptr_ptr; 13345: 13346: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC); 13347: 13348: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 13349: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 13350: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 13351: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 13352: if (RETURN_VALUE_USED(opline)) { 13353: zval *retval; 13354: 13355: ALLOC_ZVAL(retval); 13356: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 13357: INIT_PZVAL(retval); 13358: AI_SET_PTR(&EX_T(opline->result.var), retval); 13359: } 13360: } else if (RETURN_VALUE_USED(opline)) { 13361: PZVAL_LOCK(&EG(uninitialized_zval)); 13362: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 13363: } 13364: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 13365: if (IS_TMP_FREE(free_op_data1)) { 13366: zval_dtor(value); 13367: } 13368: if (RETURN_VALUE_USED(opline)) { 13369: PZVAL_LOCK(&EG(uninitialized_zval)); 13370: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 13371: } 13372: } else { 13373: if ((opline+1)->op1_type == IS_TMP_VAR) { 13374: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 13375: } else if ((opline+1)->op1_type == IS_CONST) { 13376: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 13377: } else { 13378: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 13379: } 13380: if (RETURN_VALUE_USED(opline)) { 13381: PZVAL_LOCK(value); 13382: AI_SET_PTR(&EX_T(opline->result.var), value); 13383: } 13384: } 13385: FREE_OP_VAR_PTR(free_op_data2); 13386: FREE_OP_IF_VAR(free_op_data1); 13387: } 13388: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13389: /* assign_dim has two opcodes! */ 13390: CHECK_EXCEPTION(); 13391: ZEND_VM_INC_OPCODE(); 13392: ZEND_VM_NEXT_OPCODE(); 13393: } 13394: 13395: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13396: { 13397: USE_OPLINE 13398: zend_free_op free_op1; 13399: zval *value; 13400: zval **variable_ptr_ptr; 13401: 13402: SAVE_OPLINE(); 13403: value = opline->op2.zv; 13404: variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13405: 13406: if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 13407: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) { 13408: if (RETURN_VALUE_USED(opline)) { 13409: zval *retval; 13410: 13411: ALLOC_ZVAL(retval); 13412: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 13413: INIT_PZVAL(retval); 13414: AI_SET_PTR(&EX_T(opline->result.var), retval); 13415: } 13416: } else if (RETURN_VALUE_USED(opline)) { 13417: PZVAL_LOCK(&EG(uninitialized_zval)); 13418: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 13419: } 13420: } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 13421: if (0) { 13422: zval_dtor(value); 13423: } 13424: if (RETURN_VALUE_USED(opline)) { 13425: PZVAL_LOCK(&EG(uninitialized_zval)); 13426: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 13427: } 13428: } else { 13429: if (IS_CONST == IS_TMP_VAR) { 13430: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 13431: } else if (IS_CONST == IS_CONST) { 13432: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 13433: } else { 13434: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 13435: } 13436: if (RETURN_VALUE_USED(opline)) { 13437: PZVAL_LOCK(value); 13438: AI_SET_PTR(&EX_T(opline->result.var), value); 13439: } 13440: } 13441: 13442: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13443: 13444: /* zend_assign_to_variable() always takes care of op2, never free it! */ 13445: 13446: CHECK_EXCEPTION(); 13447: ZEND_VM_NEXT_OPCODE(); 13448: } 13449: 13450: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13451: { 13452: USE_OPLINE 13453: zval *function_name; 13454: char *function_name_strval; 13455: int function_name_strlen; 13456: zend_free_op free_op1; 13457: 13458: SAVE_OPLINE(); 13459: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 13460: 13461: function_name = opline->op2.zv; 13462: 13463: if (IS_CONST != IS_CONST && 13464: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 13465: zend_error_noreturn(E_ERROR, "Method name must be a string"); 13466: } 13467: 13468: function_name_strval = Z_STRVAL_P(function_name); 13469: function_name_strlen = Z_STRLEN_P(function_name); 13470: 13471: EX(object) = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13472: 13473: if (EXPECTED(EX(object) != NULL) && 13474: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 13475: EX(called_scope) = Z_OBJCE_P(EX(object)); 13476: 13477: if (IS_CONST != IS_CONST || 13478: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 13479: zval *object = EX(object); 13480: 13481: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 13482: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 13483: } 13484: 13485: /* First, locate the function. */ 13486: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 13487: if (UNEXPECTED(EX(fbc) == NULL)) { 13488: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 13489: } 13490: if (IS_CONST == IS_CONST && 13491: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 13492: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 13493: EXPECTED(EX(object) == object)) { 13494: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 13495: } 13496: } 13497: } else { 13498: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 13499: } 13500: 13501: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 13502: EX(object) = NULL; 13503: } else { 13504: if (!PZVAL_IS_REF(EX(object))) { 13505: Z_ADDREF_P(EX(object)); /* For $this pointer */ 13506: } else { 13507: zval *this_ptr; 13508: ALLOC_ZVAL(this_ptr); 13509: INIT_PZVAL_COPY(this_ptr, EX(object)); 13510: zval_copy_ctor(this_ptr); 13511: EX(object) = this_ptr; 13512: } 13513: } 13514: 13515: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13516: 13517: CHECK_EXCEPTION(); 13518: ZEND_VM_NEXT_OPCODE(); 13519: } 13520: 13521: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13522: { 13523: USE_OPLINE 13524: zval *function_name; 13525: zend_class_entry *ce; 13526: 13527: SAVE_OPLINE(); 13528: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 13529: 13530: if (IS_VAR == IS_CONST) { 13531: /* no function found. try a static method in class */ 13532: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 13533: ce = CACHED_PTR(opline->op1.literal->cache_slot); 13534: } else { 13535: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 13536: if (UNEXPECTED(EG(exception) != NULL)) { 13537: HANDLE_EXCEPTION(); 13538: } 13539: if (UNEXPECTED(ce == NULL)) { 13540: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 13541: } 13542: CACHE_PTR(opline->op1.literal->cache_slot, ce); 13543: } 13544: EX(called_scope) = ce; 13545: } else { 13546: ce = EX_T(opline->op1.var).class_entry; 13547: 13548: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 13549: EX(called_scope) = EG(called_scope); 13550: } else { 13551: EX(called_scope) = ce; 13552: } 13553: } 13554: 13555: if (IS_VAR == IS_CONST && 13556: IS_CONST == IS_CONST && 13557: CACHED_PTR(opline->op2.literal->cache_slot)) { 13558: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 13559: } else if (IS_VAR != IS_CONST && 13560: IS_CONST == IS_CONST && 13561: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 13562: /* do nothing */ 13563: } else if (IS_CONST != IS_UNUSED) { 13564: char *function_name_strval = NULL; 13565: int function_name_strlen = 0; 13566: 13567: 13568: if (IS_CONST == IS_CONST) { 13569: function_name_strval = Z_STRVAL_P(opline->op2.zv); 13570: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 13571: } else { 13572: function_name = opline->op2.zv; 13573: 13574: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 13575: zend_error_noreturn(E_ERROR, "Function name must be a string"); 13576: } else { 13577: function_name_strval = Z_STRVAL_P(function_name); 13578: function_name_strlen = Z_STRLEN_P(function_name); 13579: } 13580: } 13581: 13582: if (function_name_strval) { 13583: if (ce->get_static_method) { 13584: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 13585: } else { 13586: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 13587: } 13588: if (UNEXPECTED(EX(fbc) == NULL)) { 13589: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 13590: } 13591: if (IS_CONST == IS_CONST && 13592: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 13593: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 13594: if (IS_VAR == IS_CONST) { 13595: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 13596: } else { 13597: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 13598: } 13599: } 13600: } 13601: if (IS_CONST != IS_CONST) { 13602: 13603: } 13604: } else { 13605: if (UNEXPECTED(ce->constructor == NULL)) { 13606: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 13607: } 13608: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 13609: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 13610: } 13611: EX(fbc) = ce->constructor; 13612: } 13613: 13614: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 13615: EX(object) = NULL; 13616: } else { 13617: if (EG(This) && 13618: Z_OBJ_HT_P(EG(This))->get_class_entry && 13619: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 13620: /* We are calling method of the other (incompatible) class, 13621: but passing $this. This is done for compatibility with php-4. */ 13622: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 13623: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 13624: } else { 13625: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 13626: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 13627: } 13628: } 13629: if ((EX(object) = EG(This))) { 13630: Z_ADDREF_P(EX(object)); 13631: EX(called_scope) = Z_OBJCE_P(EX(object)); 13632: } 13633: } 13634: 13635: CHECK_EXCEPTION(); 13636: ZEND_VM_NEXT_OPCODE(); 13637: } 13638: 13639: static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13640: { 13641: USE_OPLINE 13642: zend_free_op free_op1; 13643: 13644: SAVE_OPLINE(); 13645: if (IS_VAR==IS_VAR) { 13646: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 13647: } 13648: is_equal_function(&EX_T(opline->result.var).tmp_var, 13649: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 13650: opline->op2.zv TSRMLS_CC); 13651: 13652: CHECK_EXCEPTION(); 13653: ZEND_VM_NEXT_OPCODE(); 13654: } 13655: 13656: static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13657: { 13658: USE_OPLINE 13659: 13660: SAVE_OPLINE(); 13661: if (IS_VAR == IS_UNUSED) { 13662: zend_constant *c; 13663: zval *retval; 13664: 13665: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 13666: c = CACHED_PTR(opline->op2.literal->cache_slot); 13667: } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) { 13668: if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { 13669: char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); 13670: if(!actual) { 13671: actual = Z_STRVAL_P(opline->op2.zv); 13672: } else { 13673: actual++; 13674: } 13675: /* non-qualified constant - allow text substitution */ 13676: zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); 13677: ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1); 13678: CHECK_EXCEPTION(); 13679: ZEND_VM_NEXT_OPCODE(); 13680: } else { 13681: zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); 13682: } 13683: } else { 13684: CACHE_PTR(opline->op2.literal->cache_slot, c); 13685: } 13686: retval = &EX_T(opline->result.var).tmp_var; 13687: ZVAL_COPY_VALUE(retval, &c->value); 13688: zval_copy_ctor(retval); 13689: CHECK_EXCEPTION(); 13690: ZEND_VM_NEXT_OPCODE(); 13691: } else { 13692: /* class constant */ 13693: zend_class_entry *ce; 13694: zval **value; 13695: 13696: if (IS_VAR == IS_CONST) { 13697: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 13698: value = CACHED_PTR(opline->op2.literal->cache_slot); 13699: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 13700: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 13701: CHECK_EXCEPTION(); 13702: ZEND_VM_NEXT_OPCODE(); 13703: } else if (CACHED_PTR(opline->op1.literal->cache_slot)) { 13704: ce = CACHED_PTR(opline->op1.literal->cache_slot); 13705: } else { 13706: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 13707: if (UNEXPECTED(EG(exception) != NULL)) { 13708: HANDLE_EXCEPTION(); 13709: } 13710: if (UNEXPECTED(ce == NULL)) { 13711: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 13712: } 13713: CACHE_PTR(opline->op1.literal->cache_slot, ce); 13714: } 13715: } else { 13716: ce = EX_T(opline->op1.var).class_entry; 13717: if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) { 13718: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 13719: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 13720: CHECK_EXCEPTION(); 13721: ZEND_VM_NEXT_OPCODE(); 13722: } 13723: } 13724: 13725: if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) { 13726: if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY || 13727: (Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) { 13728: zend_class_entry *old_scope = EG(scope); 13729: 13730: EG(scope) = ce; 13731: zval_update_constant(value, (void *) 1 TSRMLS_CC); 13732: EG(scope) = old_scope; 13733: } 13734: if (IS_VAR == IS_CONST) { 13735: CACHE_PTR(opline->op2.literal->cache_slot, value); 13736: } else { 13737: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value); 13738: } 13739: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 13740: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 13741: } else { 13742: zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); 13743: } 13744: 13745: CHECK_EXCEPTION(); 13746: ZEND_VM_NEXT_OPCODE(); 13747: } 13748: } 13749: 13750: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13751: { 13752: USE_OPLINE 13753: zend_free_op free_op1; 13754: zval *expr_ptr; 13755: 13756: SAVE_OPLINE(); 13757: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 13758: zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13759: 13760: if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 13761: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 13762: } 13763: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 13764: expr_ptr = *expr_ptr_ptr; 13765: Z_ADDREF_P(expr_ptr); 13766: } else { 13767: expr_ptr=_get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13768: if (0) { /* temporary variable */ 13769: zval *new_expr; 13770: 13771: ALLOC_ZVAL(new_expr); 13772: INIT_PZVAL_COPY(new_expr, expr_ptr); 13773: expr_ptr = new_expr; 13774: } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 13775: zval *new_expr; 13776: 13777: ALLOC_ZVAL(new_expr); 13778: INIT_PZVAL_COPY(new_expr, expr_ptr); 13779: expr_ptr = new_expr; 13780: zendi_zval_copy_ctor(*expr_ptr); 13781: } else { 13782: Z_ADDREF_P(expr_ptr); 13783: } 13784: } 13785: 13786: if (IS_CONST != IS_UNUSED) { 13787: 13788: zval *offset = opline->op2.zv; 13789: ulong hval; 13790: 13791: switch (Z_TYPE_P(offset)) { 13792: case IS_DOUBLE: 13793: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 13794: goto num_index; 13795: case IS_LONG: 13796: case IS_BOOL: 13797: hval = Z_LVAL_P(offset); 13798: num_index: 13799: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 13800: break; 13801: case IS_STRING: 13802: if (IS_CONST == IS_CONST) { 13803: hval = Z_HASH_P(offset); 13804: } else { 13805: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 13806: if (IS_INTERNED(Z_STRVAL_P(offset))) { 13807: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 13808: } else { 13809: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 13810: } 13811: } 13812: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 13813: break; 13814: case IS_NULL: 13815: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 13816: break; 13817: default: 13818: zend_error(E_WARNING, "Illegal offset type"); 13819: zval_ptr_dtor(&expr_ptr); 13820: /* do nothing */ 13821: break; 13822: } 13823: 13824: } else { 13825: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 13826: } 13827: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 13828: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13829: } else { 13830: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13831: } 13832: CHECK_EXCEPTION(); 13833: ZEND_VM_NEXT_OPCODE(); 13834: } 13835: 13836: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13837: { 13838: USE_OPLINE 13839: 13840: array_init(&EX_T(opline->result.var).tmp_var); 13841: if (IS_VAR == IS_UNUSED) { 13842: ZEND_VM_NEXT_OPCODE(); 13843: #if 0 || IS_VAR != IS_UNUSED 13844: } else { 13845: return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 13846: #endif 13847: } 13848: } 13849: 13850: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13851: { 13852: USE_OPLINE 13853: zval tmp, *varname; 13854: HashTable *target_symbol_table; 13855: zend_free_op free_op1; 13856: 13857: SAVE_OPLINE(); 13858: if (IS_VAR == IS_CV && 13859: IS_CONST == IS_UNUSED && 13860: (opline->extended_value & ZEND_QUICK_SET)) { 13861: if (EG(active_symbol_table)) { 13862: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 13863: 13864: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 13865: EX_CV(opline->op1.var) = NULL; 13866: } else if (EX_CV(opline->op1.var)) { 13867: zval_ptr_dtor(EX_CV(opline->op1.var)); 13868: EX_CV(opline->op1.var) = NULL; 13869: } 13870: CHECK_EXCEPTION(); 13871: ZEND_VM_NEXT_OPCODE(); 13872: } 13873: 13874: varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13875: 13876: if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 13877: ZVAL_COPY_VALUE(&tmp, varname); 13878: zval_copy_ctor(&tmp); 13879: convert_to_string(&tmp); 13880: varname = &tmp; 13881: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 13882: Z_ADDREF_P(varname); 13883: } 13884: 13885: if (IS_CONST != IS_UNUSED) { 13886: zend_class_entry *ce; 13887: 13888: if (IS_CONST == IS_CONST) { 13889: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 13890: ce = CACHED_PTR(opline->op2.literal->cache_slot); 13891: } else { 13892: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 13893: if (UNEXPECTED(EG(exception) != NULL)) { 13894: if (IS_VAR != IS_CONST && varname == &tmp) { 13895: zval_dtor(&tmp); 13896: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 13897: zval_ptr_dtor(&varname); 13898: } 13899: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13900: HANDLE_EXCEPTION(); 13901: } 13902: if (UNEXPECTED(ce == NULL)) { 13903: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 13904: } 13905: CACHE_PTR(opline->op2.literal->cache_slot, ce); 13906: } 13907: } else { 13908: ce = EX_T(opline->op2.var).class_entry; 13909: } 13910: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 13911: } else { 13912: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 13913: 13914: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 13915: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 13916: } 13917: 13918: if (IS_VAR != IS_CONST && varname == &tmp) { 13919: zval_dtor(&tmp); 13920: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 13921: zval_ptr_dtor(&varname); 13922: } 13923: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 13924: CHECK_EXCEPTION(); 13925: ZEND_VM_NEXT_OPCODE(); 13926: } 13927: 13928: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 13929: { 13930: USE_OPLINE 13931: zend_free_op free_op1; 13932: zval **container; 13933: zval *offset; 13934: ulong hval; 13935: 13936: SAVE_OPLINE(); 13937: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 13938: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 13939: SEPARATE_ZVAL_IF_NOT_REF(container); 13940: } 13941: offset = opline->op2.zv; 13942: 13943: if (IS_VAR != IS_VAR || container) { 13944: switch (Z_TYPE_PP(container)) { 13945: case IS_ARRAY: { 13946: HashTable *ht = Z_ARRVAL_PP(container); 13947: 13948: switch (Z_TYPE_P(offset)) { 13949: case IS_DOUBLE: 13950: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 13951: zend_hash_index_del(ht, hval); 13952: break; 13953: case IS_RESOURCE: 13954: case IS_BOOL: 13955: case IS_LONG: 13956: hval = Z_LVAL_P(offset); 13957: zend_hash_index_del(ht, hval); 13958: break; 13959: case IS_STRING: 13960: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 13961: Z_ADDREF_P(offset); 13962: } 13963: if (IS_CONST == IS_CONST) { 13964: hval = Z_HASH_P(offset); 13965: } else { 13966: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 13967: if (IS_INTERNED(Z_STRVAL_P(offset))) { 13968: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 13969: } else { 13970: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 13971: } 13972: } 13973: if (ht == &EG(symbol_table)) { 13974: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 13975: } else { 13976: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 13977: } 13978: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 13979: zval_ptr_dtor(&offset); 13980: } 13981: break; 13982: num_index_dim: 13983: zend_hash_index_del(ht, hval); 13984: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 13985: zval_ptr_dtor(&offset); 13986: } 13987: break; 13988: case IS_NULL: 13989: zend_hash_del(ht, "", sizeof("")); 13990: break; 13991: default: 13992: zend_error(E_WARNING, "Illegal offset type in unset"); 13993: break; 13994: } 13995: 13996: break; 13997: } 13998: case IS_OBJECT: 13999: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 14000: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 14001: } 14002: if (0) { 14003: MAKE_REAL_ZVAL_PTR(offset); 14004: } 14005: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 14006: if (0) { 14007: zval_ptr_dtor(&offset); 14008: } else { 14009: 14010: } 14011: break; 14012: case IS_STRING: 14013: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 14014: ZEND_VM_CONTINUE(); /* bailed out before */ 14015: default: 14016: 14017: break; 14018: } 14019: } else { 14020: 14021: } 14022: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14023: 14024: CHECK_EXCEPTION(); 14025: ZEND_VM_NEXT_OPCODE(); 14026: } 14027: 14028: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14029: { 14030: USE_OPLINE 14031: zend_free_op free_op1; 14032: zval **container; 14033: zval *offset; 14034: 14035: SAVE_OPLINE(); 14036: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14037: offset = opline->op2.zv; 14038: 14039: if (IS_VAR != IS_VAR || container) { 14040: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 14041: SEPARATE_ZVAL_IF_NOT_REF(container); 14042: } 14043: if (Z_TYPE_PP(container) == IS_OBJECT) { 14044: if (0) { 14045: MAKE_REAL_ZVAL_PTR(offset); 14046: } 14047: if (Z_OBJ_HT_P(*container)->unset_property) { 14048: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14049: } else { 14050: zend_error(E_NOTICE, "Trying to unset property of non-object"); 14051: } 14052: if (0) { 14053: zval_ptr_dtor(&offset); 14054: } else { 14055: 14056: } 14057: } else { 14058: 14059: } 14060: } else { 14061: 14062: } 14063: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14064: 14065: CHECK_EXCEPTION(); 14066: ZEND_VM_NEXT_OPCODE(); 14067: } 14068: 14069: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14070: { 14071: USE_OPLINE 14072: zval **value; 14073: zend_bool isset = 1; 14074: 14075: SAVE_OPLINE(); 14076: if (IS_VAR == IS_CV && 14077: IS_CONST == IS_UNUSED && 14078: (opline->extended_value & ZEND_QUICK_SET)) { 14079: if (EX_CV(opline->op1.var)) { 14080: value = EX_CV(opline->op1.var); 14081: } else if (EG(active_symbol_table)) { 14082: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 14083: 14084: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 14085: isset = 0; 14086: } 14087: } else { 14088: isset = 0; 14089: } 14090: } else { 14091: HashTable *target_symbol_table; 14092: zend_free_op free_op1; 14093: zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14094: 14095: if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 14096: ZVAL_COPY_VALUE(&tmp, varname); 14097: zval_copy_ctor(&tmp); 14098: convert_to_string(&tmp); 14099: varname = &tmp; 14100: } 14101: 14102: if (IS_CONST != IS_UNUSED) { 14103: zend_class_entry *ce; 14104: 14105: if (IS_CONST == IS_CONST) { 14106: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 14107: ce = CACHED_PTR(opline->op2.literal->cache_slot); 14108: } else { 14109: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 14110: if (UNEXPECTED(ce == NULL)) { 14111: CHECK_EXCEPTION(); 14112: ZEND_VM_NEXT_OPCODE(); 14113: } 14114: CACHE_PTR(opline->op2.literal->cache_slot, ce); 14115: } 14116: } else { 14117: ce = EX_T(opline->op2.var).class_entry; 14118: } 14119: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 14120: if (!value) { 14121: isset = 0; 14122: } 14123: } else { 14124: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 14125: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 14126: isset = 0; 14127: } 14128: } 14129: 14130: if (IS_VAR != IS_CONST && varname == &tmp) { 14131: zval_dtor(&tmp); 14132: } 14133: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14134: } 14135: 14136: if (opline->extended_value & ZEND_ISSET) { 14137: if (isset && Z_TYPE_PP(value) != IS_NULL) { 14138: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 14139: } else { 14140: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 14141: } 14142: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 14143: if (!isset || !i_zend_is_true(*value)) { 14144: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 14145: } else { 14146: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 14147: } 14148: } 14149: 14150: CHECK_EXCEPTION(); 14151: ZEND_VM_NEXT_OPCODE(); 14152: } 14153: 14154: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 14155: { 14156: USE_OPLINE 14157: zend_free_op free_op1; 14158: zval **container; 14159: zval **value = NULL; 14160: int result = 0; 14161: ulong hval; 14162: zval *offset; 14163: 14164: SAVE_OPLINE(); 14165: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14166: 14167: offset = opline->op2.zv; 14168: 14169: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 14170: HashTable *ht; 14171: int isset = 0; 14172: 14173: ht = Z_ARRVAL_PP(container); 14174: 14175: switch (Z_TYPE_P(offset)) { 14176: case IS_DOUBLE: 14177: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 14178: goto num_index_prop; 14179: case IS_RESOURCE: 14180: case IS_BOOL: 14181: case IS_LONG: 14182: hval = Z_LVAL_P(offset); 14183: num_index_prop: 14184: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 14185: isset = 1; 14186: } 14187: break; 14188: case IS_STRING: 14189: if (IS_CONST == IS_CONST) { 14190: hval = Z_HASH_P(offset); 14191: } else { 14192: if (!prop_dim) { 14193: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 14194: } 14195: if (IS_INTERNED(Z_STRVAL_P(offset))) { 14196: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 14197: } else { 14198: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 14199: } 14200: } 14201: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 14202: isset = 1; 14203: } 14204: break; 14205: case IS_NULL: 14206: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 14207: isset = 1; 14208: } 14209: break; 14210: default: 14211: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 14212: break; 14213: } 14214: 14215: if (opline->extended_value & ZEND_ISSET) { 14216: if (isset && Z_TYPE_PP(value) == IS_NULL) { 14217: result = 0; 14218: } else { 14219: result = isset; 14220: } 14221: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 14222: if (!isset || !i_zend_is_true(*value)) { 14223: result = 0; 14224: } else { 14225: result = 1; 14226: } 14227: } 14228: 14229: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 14230: if (0) { 14231: MAKE_REAL_ZVAL_PTR(offset); 14232: } 14233: if (prop_dim) { 14234: if (Z_OBJ_HT_P(*container)->has_property) { 14235: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14236: } else { 14237: zend_error(E_NOTICE, "Trying to check property of non-object"); 14238: result = 0; 14239: } 14240: } else { 14241: if (Z_OBJ_HT_P(*container)->has_dimension) { 14242: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 14243: } else { 14244: zend_error(E_NOTICE, "Trying to check element of non-array"); 14245: result = 0; 14246: } 14247: } 14248: if (0) { 14249: zval_ptr_dtor(&offset); 14250: } else { 14251: 14252: } 14253: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 14254: zval tmp; 14255: 14256: if (Z_TYPE_P(offset) != IS_LONG) { 14257: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 14258: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 14259: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 14260: ZVAL_COPY_VALUE(&tmp, offset); 14261: zval_copy_ctor(&tmp); 14262: convert_to_long(&tmp); 14263: offset = &tmp; 14264: } else { 14265: /* can not be converted to proper offset, return "not set" */ 14266: result = 0; 14267: } 14268: } 14269: if (Z_TYPE_P(offset) == IS_LONG) { 14270: if (opline->extended_value & ZEND_ISSET) { 14271: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 14272: result = 1; 14273: } 14274: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 14275: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 14276: result = 1; 14277: } 14278: } 14279: } 14280: 14281: } else { 14282: 14283: } 14284: 14285: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 14286: if (opline->extended_value & ZEND_ISSET) { 14287: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 14288: } else { 14289: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 14290: } 14291: 14292: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14293: 14294: CHECK_EXCEPTION(); 14295: ZEND_VM_NEXT_OPCODE(); 14296: } 14297: 14298: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14299: { 14300: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14301: } 14302: 14303: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14304: { 14305: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14306: } 14307: 14308: static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14309: { 14310: USE_OPLINE 14311: zend_free_op free_op1, free_op2; 14312: 14313: SAVE_OPLINE(); 14314: fast_add_function(&EX_T(opline->result.var).tmp_var, 14315: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14316: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14317: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14318: zval_dtor(free_op2.var); 14319: CHECK_EXCEPTION(); 14320: ZEND_VM_NEXT_OPCODE(); 14321: } 14322: 14323: static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14324: { 14325: USE_OPLINE 14326: zend_free_op free_op1, free_op2; 14327: 14328: SAVE_OPLINE(); 14329: fast_sub_function(&EX_T(opline->result.var).tmp_var, 14330: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14331: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14332: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14333: zval_dtor(free_op2.var); 14334: CHECK_EXCEPTION(); 14335: ZEND_VM_NEXT_OPCODE(); 14336: } 14337: 14338: static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14339: { 14340: USE_OPLINE 14341: zend_free_op free_op1, free_op2; 14342: 14343: SAVE_OPLINE(); 14344: fast_mul_function(&EX_T(opline->result.var).tmp_var, 14345: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14346: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14347: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14348: zval_dtor(free_op2.var); 14349: CHECK_EXCEPTION(); 14350: ZEND_VM_NEXT_OPCODE(); 14351: } 14352: 14353: static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14354: { 14355: USE_OPLINE 14356: zend_free_op free_op1, free_op2; 14357: 14358: SAVE_OPLINE(); 14359: fast_div_function(&EX_T(opline->result.var).tmp_var, 14360: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14361: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14362: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14363: zval_dtor(free_op2.var); 14364: CHECK_EXCEPTION(); 14365: ZEND_VM_NEXT_OPCODE(); 14366: } 14367: 14368: static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14369: { 14370: USE_OPLINE 14371: zend_free_op free_op1, free_op2; 14372: 14373: SAVE_OPLINE(); 14374: fast_mod_function(&EX_T(opline->result.var).tmp_var, 14375: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14376: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14377: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14378: zval_dtor(free_op2.var); 14379: CHECK_EXCEPTION(); 14380: ZEND_VM_NEXT_OPCODE(); 14381: } 14382: 14383: static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14384: { 14385: USE_OPLINE 14386: zend_free_op free_op1, free_op2; 14387: 14388: SAVE_OPLINE(); 14389: shift_left_function(&EX_T(opline->result.var).tmp_var, 14390: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14391: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14392: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14393: zval_dtor(free_op2.var); 14394: CHECK_EXCEPTION(); 14395: ZEND_VM_NEXT_OPCODE(); 14396: } 14397: 14398: static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14399: { 14400: USE_OPLINE 14401: zend_free_op free_op1, free_op2; 14402: 14403: SAVE_OPLINE(); 14404: shift_right_function(&EX_T(opline->result.var).tmp_var, 14405: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14406: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14407: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14408: zval_dtor(free_op2.var); 14409: CHECK_EXCEPTION(); 14410: ZEND_VM_NEXT_OPCODE(); 14411: } 14412: 14413: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14414: { 14415: USE_OPLINE 14416: zend_free_op free_op1, free_op2; 14417: 14418: SAVE_OPLINE(); 14419: concat_function(&EX_T(opline->result.var).tmp_var, 14420: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14421: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14422: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14423: zval_dtor(free_op2.var); 14424: CHECK_EXCEPTION(); 14425: ZEND_VM_NEXT_OPCODE(); 14426: } 14427: 14428: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14429: { 14430: USE_OPLINE 14431: zend_free_op free_op1, free_op2; 14432: 14433: SAVE_OPLINE(); 14434: is_identical_function(&EX_T(opline->result.var).tmp_var, 14435: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14436: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14437: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14438: zval_dtor(free_op2.var); 14439: CHECK_EXCEPTION(); 14440: ZEND_VM_NEXT_OPCODE(); 14441: } 14442: 14443: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14444: { 14445: USE_OPLINE 14446: zend_free_op free_op1, free_op2; 14447: zval *result = &EX_T(opline->result.var).tmp_var; 14448: 14449: SAVE_OPLINE(); 14450: is_identical_function(result, 14451: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14452: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14453: Z_LVAL_P(result) = !Z_LVAL_P(result); 14454: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14455: zval_dtor(free_op2.var); 14456: CHECK_EXCEPTION(); 14457: ZEND_VM_NEXT_OPCODE(); 14458: } 14459: 14460: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14461: { 14462: USE_OPLINE 14463: zend_free_op free_op1, free_op2; 14464: zval *result = &EX_T(opline->result.var).tmp_var; 14465: 14466: SAVE_OPLINE(); 14467: ZVAL_BOOL(result, fast_equal_function(result, 14468: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14469: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 14470: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14471: zval_dtor(free_op2.var); 14472: CHECK_EXCEPTION(); 14473: ZEND_VM_NEXT_OPCODE(); 14474: } 14475: 14476: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14477: { 14478: USE_OPLINE 14479: zend_free_op free_op1, free_op2; 14480: zval *result = &EX_T(opline->result.var).tmp_var; 14481: 14482: SAVE_OPLINE(); 14483: ZVAL_BOOL(result, fast_not_equal_function(result, 14484: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14485: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 14486: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14487: zval_dtor(free_op2.var); 14488: CHECK_EXCEPTION(); 14489: ZEND_VM_NEXT_OPCODE(); 14490: } 14491: 14492: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14493: { 14494: USE_OPLINE 14495: zend_free_op free_op1, free_op2; 14496: zval *result = &EX_T(opline->result.var).tmp_var; 14497: 14498: SAVE_OPLINE(); 14499: ZVAL_BOOL(result, fast_is_smaller_function(result, 14500: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14501: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 14502: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14503: zval_dtor(free_op2.var); 14504: CHECK_EXCEPTION(); 14505: ZEND_VM_NEXT_OPCODE(); 14506: } 14507: 14508: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14509: { 14510: USE_OPLINE 14511: zend_free_op free_op1, free_op2; 14512: zval *result = &EX_T(opline->result.var).tmp_var; 14513: 14514: SAVE_OPLINE(); 14515: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 14516: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14517: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 14518: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14519: zval_dtor(free_op2.var); 14520: CHECK_EXCEPTION(); 14521: ZEND_VM_NEXT_OPCODE(); 14522: } 14523: 14524: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14525: { 14526: USE_OPLINE 14527: zend_free_op free_op1, free_op2; 14528: 14529: SAVE_OPLINE(); 14530: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 14531: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14532: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14533: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14534: zval_dtor(free_op2.var); 14535: CHECK_EXCEPTION(); 14536: ZEND_VM_NEXT_OPCODE(); 14537: } 14538: 14539: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14540: { 14541: USE_OPLINE 14542: zend_free_op free_op1, free_op2; 14543: 14544: SAVE_OPLINE(); 14545: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 14546: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14547: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14548: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14549: zval_dtor(free_op2.var); 14550: CHECK_EXCEPTION(); 14551: ZEND_VM_NEXT_OPCODE(); 14552: } 14553: 14554: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14555: { 14556: USE_OPLINE 14557: zend_free_op free_op1, free_op2; 14558: 14559: SAVE_OPLINE(); 14560: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 14561: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14562: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14563: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14564: zval_dtor(free_op2.var); 14565: CHECK_EXCEPTION(); 14566: ZEND_VM_NEXT_OPCODE(); 14567: } 14568: 14569: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14570: { 14571: USE_OPLINE 14572: zend_free_op free_op1, free_op2; 14573: 14574: SAVE_OPLINE(); 14575: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 14576: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 14577: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 14578: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14579: zval_dtor(free_op2.var); 14580: CHECK_EXCEPTION(); 14581: ZEND_VM_NEXT_OPCODE(); 14582: } 14583: 14584: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 14585: { 14586: USE_OPLINE 14587: zend_free_op free_op1, free_op2, free_op_data1; 14588: zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14589: zval *object; 14590: zval *property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 14591: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 14592: int have_get_ptr = 0; 14593: 14594: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 14595: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 14596: } 14597: 14598: make_real_object(object_ptr TSRMLS_CC); 14599: object = *object_ptr; 14600: 14601: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 14602: zend_error(E_WARNING, "Attempt to assign property of non-object"); 14603: zval_dtor(free_op2.var); 14604: FREE_OP(free_op_data1); 14605: 14606: if (RETURN_VALUE_USED(opline)) { 14607: PZVAL_LOCK(&EG(uninitialized_zval)); 14608: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 14609: EX_T(opline->result.var).var.ptr_ptr = NULL; 14610: } 14611: } else { 14612: /* here we are sure we are dealing with an object */ 14613: if (1) { 14614: MAKE_REAL_ZVAL_PTR(property); 14615: } 14616: 14617: /* here property is a string */ 14618: if (opline->extended_value == ZEND_ASSIGN_OBJ 14619: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 14620: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14621: if (zptr != NULL) { /* NULL means no success in getting PTR */ 14622: SEPARATE_ZVAL_IF_NOT_REF(zptr); 14623: 14624: have_get_ptr = 1; 14625: binary_op(*zptr, *zptr, value TSRMLS_CC); 14626: if (RETURN_VALUE_USED(opline)) { 14627: PZVAL_LOCK(*zptr); 14628: EX_T(opline->result.var).var.ptr = *zptr; 14629: EX_T(opline->result.var).var.ptr_ptr = NULL; 14630: } 14631: } 14632: } 14633: 14634: if (!have_get_ptr) { 14635: zval *z = NULL; 14636: 14637: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 14638: if (Z_OBJ_HT_P(object)->read_property) { 14639: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14640: } 14641: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 14642: if (Z_OBJ_HT_P(object)->read_dimension) { 14643: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 14644: } 14645: } 14646: if (z) { 14647: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 14648: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 14649: 14650: if (Z_REFCOUNT_P(z) == 0) { 14651: GC_REMOVE_ZVAL_FROM_BUFFER(z); 14652: zval_dtor(z); 14653: FREE_ZVAL(z); 14654: } 14655: z = value; 14656: } 14657: Z_ADDREF_P(z); 14658: SEPARATE_ZVAL_IF_NOT_REF(&z); 14659: binary_op(z, z, value TSRMLS_CC); 14660: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 14661: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14662: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 14663: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 14664: } 14665: if (RETURN_VALUE_USED(opline)) { 14666: PZVAL_LOCK(z); 14667: EX_T(opline->result.var).var.ptr = z; 14668: EX_T(opline->result.var).var.ptr_ptr = NULL; 14669: } 14670: zval_ptr_dtor(&z); 14671: } else { 14672: zend_error(E_WARNING, "Attempt to assign property of non-object"); 14673: if (RETURN_VALUE_USED(opline)) { 14674: PZVAL_LOCK(&EG(uninitialized_zval)); 14675: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 14676: EX_T(opline->result.var).var.ptr_ptr = NULL; 14677: } 14678: } 14679: } 14680: 14681: if (1) { 14682: zval_ptr_dtor(&property); 14683: } else { 14684: zval_dtor(free_op2.var); 14685: } 14686: FREE_OP(free_op_data1); 14687: } 14688: 14689: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14690: /* assign_obj has two opcodes! */ 14691: CHECK_EXCEPTION(); 14692: ZEND_VM_INC_OPCODE(); 14693: ZEND_VM_NEXT_OPCODE(); 14694: } 14695: 14696: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 14697: { 14698: USE_OPLINE 14699: zend_free_op free_op1, free_op2, free_op_data2, free_op_data1; 14700: zval **var_ptr; 14701: zval *value; 14702: 14703: SAVE_OPLINE(); 14704: switch (opline->extended_value) { 14705: case ZEND_ASSIGN_OBJ: 14706: return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14707: break; 14708: case ZEND_ASSIGN_DIM: { 14709: zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14710: 14711: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 14712: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 14713: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 14714: if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { 14715: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 14716: } 14717: return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14718: } else { 14719: zval *dim = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 14720: 14721: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); 14722: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 14723: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 14724: } 14725: } 14726: break; 14727: default: 14728: value = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 14729: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14730: /* do nothing */ 14731: break; 14732: } 14733: 14734: if (UNEXPECTED(var_ptr == NULL)) { 14735: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 14736: } 14737: 14738: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 14739: if (RETURN_VALUE_USED(opline)) { 14740: PZVAL_LOCK(&EG(uninitialized_zval)); 14741: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 14742: } 14743: zval_dtor(free_op2.var); 14744: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14745: CHECK_EXCEPTION(); 14746: if (opline->extended_value == ZEND_ASSIGN_DIM) { 14747: ZEND_VM_INC_OPCODE(); 14748: } 14749: ZEND_VM_NEXT_OPCODE(); 14750: } 14751: 14752: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 14753: 14754: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 14755: && Z_OBJ_HANDLER_PP(var_ptr, get) 14756: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 14757: /* proxy object */ 14758: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 14759: Z_ADDREF_P(objval); 14760: binary_op(objval, objval, value TSRMLS_CC); 14761: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 14762: zval_ptr_dtor(&objval); 14763: } else { 14764: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 14765: } 14766: 14767: if (RETURN_VALUE_USED(opline)) { 14768: PZVAL_LOCK(*var_ptr); 14769: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 14770: } 14771: zval_dtor(free_op2.var); 14772: 14773: if (opline->extended_value == ZEND_ASSIGN_DIM) { 14774: FREE_OP(free_op_data1); 14775: FREE_OP_VAR_PTR(free_op_data2); 14776: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14777: CHECK_EXCEPTION(); 14778: ZEND_VM_INC_OPCODE(); 14779: } else { 14780: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14781: CHECK_EXCEPTION(); 14782: } 14783: ZEND_VM_NEXT_OPCODE(); 14784: } 14785: 14786: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14787: { 14788: return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14789: } 14790: 14791: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14792: { 14793: return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14794: } 14795: 14796: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14797: { 14798: return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14799: } 14800: 14801: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14802: { 14803: return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14804: } 14805: 14806: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14807: { 14808: return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14809: } 14810: 14811: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14812: { 14813: return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14814: } 14815: 14816: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14817: { 14818: return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14819: } 14820: 14821: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14822: { 14823: return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14824: } 14825: 14826: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14827: { 14828: return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14829: } 14830: 14831: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14832: { 14833: return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14834: } 14835: 14836: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14837: { 14838: return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14839: } 14840: 14841: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 14842: { 14843: USE_OPLINE 14844: zend_free_op free_op1, free_op2; 14845: zval **object_ptr; 14846: zval *object; 14847: zval *property; 14848: zval **retval; 14849: int have_get_ptr = 0; 14850: 14851: SAVE_OPLINE(); 14852: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14853: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 14854: retval = &EX_T(opline->result.var).var.ptr; 14855: 14856: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 14857: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 14858: } 14859: 14860: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 14861: object = *object_ptr; 14862: 14863: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 14864: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 14865: zval_dtor(free_op2.var); 14866: if (RETURN_VALUE_USED(opline)) { 14867: PZVAL_LOCK(&EG(uninitialized_zval)); 14868: *retval = &EG(uninitialized_zval); 14869: } 14870: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14871: CHECK_EXCEPTION(); 14872: ZEND_VM_NEXT_OPCODE(); 14873: } 14874: 14875: /* here we are sure we are dealing with an object */ 14876: 14877: if (1) { 14878: MAKE_REAL_ZVAL_PTR(property); 14879: } 14880: 14881: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 14882: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14883: if (zptr != NULL) { /* NULL means no success in getting PTR */ 14884: SEPARATE_ZVAL_IF_NOT_REF(zptr); 14885: 14886: have_get_ptr = 1; 14887: incdec_op(*zptr); 14888: if (RETURN_VALUE_USED(opline)) { 14889: *retval = *zptr; 14890: PZVAL_LOCK(*retval); 14891: } 14892: } 14893: } 14894: 14895: if (!have_get_ptr) { 14896: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 14897: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14898: 14899: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 14900: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 14901: 14902: if (Z_REFCOUNT_P(z) == 0) { 14903: GC_REMOVE_ZVAL_FROM_BUFFER(z); 14904: zval_dtor(z); 14905: FREE_ZVAL(z); 14906: } 14907: z = value; 14908: } 14909: Z_ADDREF_P(z); 14910: SEPARATE_ZVAL_IF_NOT_REF(&z); 14911: incdec_op(z); 14912: *retval = z; 14913: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14914: SELECTIVE_PZVAL_LOCK(*retval, opline); 14915: zval_ptr_dtor(&z); 14916: } else { 14917: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 14918: if (RETURN_VALUE_USED(opline)) { 14919: PZVAL_LOCK(&EG(uninitialized_zval)); 14920: *retval = &EG(uninitialized_zval); 14921: } 14922: } 14923: } 14924: 14925: if (1) { 14926: zval_ptr_dtor(&property); 14927: } else { 14928: zval_dtor(free_op2.var); 14929: } 14930: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14931: CHECK_EXCEPTION(); 14932: ZEND_VM_NEXT_OPCODE(); 14933: } 14934: 14935: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14936: { 14937: return zend_pre_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14938: } 14939: 14940: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 14941: { 14942: return zend_pre_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 14943: } 14944: 14945: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 14946: { 14947: USE_OPLINE 14948: zend_free_op free_op1, free_op2; 14949: zval **object_ptr; 14950: zval *object; 14951: zval *property; 14952: zval *retval; 14953: int have_get_ptr = 0; 14954: 14955: SAVE_OPLINE(); 14956: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 14957: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 14958: retval = &EX_T(opline->result.var).tmp_var; 14959: 14960: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 14961: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 14962: } 14963: 14964: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 14965: object = *object_ptr; 14966: 14967: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 14968: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 14969: zval_dtor(free_op2.var); 14970: ZVAL_NULL(retval); 14971: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 14972: CHECK_EXCEPTION(); 14973: ZEND_VM_NEXT_OPCODE(); 14974: } 14975: 14976: /* here we are sure we are dealing with an object */ 14977: 14978: if (1) { 14979: MAKE_REAL_ZVAL_PTR(property); 14980: } 14981: 14982: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 14983: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14984: if (zptr != NULL) { /* NULL means no success in getting PTR */ 14985: have_get_ptr = 1; 14986: SEPARATE_ZVAL_IF_NOT_REF(zptr); 14987: 14988: ZVAL_COPY_VALUE(retval, *zptr); 14989: zendi_zval_copy_ctor(*retval); 14990: 14991: incdec_op(*zptr); 14992: 14993: } 14994: } 14995: 14996: if (!have_get_ptr) { 14997: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 14998: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 14999: zval *z_copy; 15000: 15001: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 15002: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 15003: 15004: if (Z_REFCOUNT_P(z) == 0) { 15005: GC_REMOVE_ZVAL_FROM_BUFFER(z); 15006: zval_dtor(z); 15007: FREE_ZVAL(z); 15008: } 15009: z = value; 15010: } 15011: ZVAL_COPY_VALUE(retval, z); 15012: zendi_zval_copy_ctor(*retval); 15013: ALLOC_ZVAL(z_copy); 15014: INIT_PZVAL_COPY(z_copy, z); 15015: zendi_zval_copy_ctor(*z_copy); 15016: incdec_op(z_copy); 15017: Z_ADDREF_P(z); 15018: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 15019: zval_ptr_dtor(&z_copy); 15020: zval_ptr_dtor(&z); 15021: } else { 15022: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 15023: ZVAL_NULL(retval); 15024: } 15025: } 15026: 15027: if (1) { 15028: zval_ptr_dtor(&property); 15029: } else { 15030: zval_dtor(free_op2.var); 15031: } 15032: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15033: CHECK_EXCEPTION(); 15034: ZEND_VM_NEXT_OPCODE(); 15035: } 15036: 15037: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15038: { 15039: return zend_post_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 15040: } 15041: 15042: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15043: { 15044: return zend_post_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 15045: } 15046: 15047: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15048: { 15049: USE_OPLINE 15050: zend_free_op free_op1, free_op2; 15051: zval **container; 15052: 15053: SAVE_OPLINE(); 15054: 15055: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 15056: IS_VAR != IS_CV && 15057: EX_T(opline->op1.var).var.ptr_ptr) { 15058: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 15059: } 15060: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15061: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); 15062: zval_dtor(free_op2.var); 15063: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15064: CHECK_EXCEPTION(); 15065: ZEND_VM_NEXT_OPCODE(); 15066: } 15067: 15068: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15069: { 15070: USE_OPLINE 15071: zend_free_op free_op1, free_op2; 15072: zval **container; 15073: 15074: SAVE_OPLINE(); 15075: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15076: 15077: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15078: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 15079: } 15080: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); 15081: zval_dtor(free_op2.var); 15082: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15083: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15084: } 15085: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15086: 15087: /* We are going to assign the result by reference */ 15088: if (UNEXPECTED(opline->extended_value != 0)) { 15089: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 15090: 15091: if (retval_ptr) { 15092: Z_DELREF_PP(retval_ptr); 15093: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 15094: Z_ADDREF_PP(retval_ptr); 15095: } 15096: } 15097: 15098: CHECK_EXCEPTION(); 15099: ZEND_VM_NEXT_OPCODE(); 15100: } 15101: 15102: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15103: { 15104: USE_OPLINE 15105: zend_free_op free_op1, free_op2; 15106: zval **container; 15107: 15108: SAVE_OPLINE(); 15109: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15110: 15111: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15112: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 15113: } 15114: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); 15115: zval_dtor(free_op2.var); 15116: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15117: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15118: } 15119: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15120: CHECK_EXCEPTION(); 15121: ZEND_VM_NEXT_OPCODE(); 15122: } 15123: 15124: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15125: { 15126: USE_OPLINE 15127: zend_free_op free_op1, free_op2; 15128: zval **container; 15129: 15130: SAVE_OPLINE(); 15131: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15132: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC); 15133: zval_dtor(free_op2.var); 15134: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15135: CHECK_EXCEPTION(); 15136: ZEND_VM_NEXT_OPCODE(); 15137: } 15138: 15139: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15140: { 15141: USE_OPLINE 15142: zend_free_op free_op1, free_op2; 15143: zval **container; 15144: 15145: SAVE_OPLINE(); 15146: 15147: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 15148: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15149: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15150: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 15151: } 15152: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); 15153: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15154: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15155: } 15156: } else { 15157: if (IS_TMP_VAR == IS_UNUSED) { 15158: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 15159: } 15160: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15161: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); 15162: } 15163: zval_dtor(free_op2.var); 15164: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15165: CHECK_EXCEPTION(); 15166: ZEND_VM_NEXT_OPCODE(); 15167: } 15168: 15169: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15170: { 15171: USE_OPLINE 15172: zend_free_op free_op1, free_op2; 15173: zval **container; 15174: 15175: SAVE_OPLINE(); 15176: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15177: 15178: if (IS_VAR == IS_CV) { 15179: if (container != &EG(uninitialized_zval_ptr)) { 15180: SEPARATE_ZVAL_IF_NOT_REF(container); 15181: } 15182: } 15183: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15184: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 15185: } 15186: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC); 15187: zval_dtor(free_op2.var); 15188: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15189: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15190: } 15191: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15192: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 15193: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 15194: } else { 15195: zend_free_op free_res; 15196: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 15197: 15198: PZVAL_UNLOCK(*retval_ptr, &free_res); 15199: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 15200: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 15201: } 15202: PZVAL_LOCK(*retval_ptr); 15203: FREE_OP_VAR_PTR(free_res); 15204: CHECK_EXCEPTION(); 15205: ZEND_VM_NEXT_OPCODE(); 15206: } 15207: } 15208: 15209: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS) 15210: { 15211: USE_OPLINE 15212: zend_free_op free_op1; 15213: zval *container; 15214: zend_free_op free_op2; 15215: zval *offset; 15216: 15217: SAVE_OPLINE(); 15218: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15219: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15220: 15221: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 15222: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 15223: zend_error(E_NOTICE, "Trying to get property of non-object"); 15224: PZVAL_LOCK(&EG(uninitialized_zval)); 15225: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 15226: zval_dtor(free_op2.var); 15227: } else { 15228: zval *retval; 15229: 15230: if (1) { 15231: MAKE_REAL_ZVAL_PTR(offset); 15232: } 15233: 15234: /* here we are sure we are dealing with an object */ 15235: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 15236: 15237: PZVAL_LOCK(retval); 15238: AI_SET_PTR(&EX_T(opline->result.var), retval); 15239: 15240: if (1) { 15241: zval_ptr_dtor(&offset); 15242: } else { 15243: zval_dtor(free_op2.var); 15244: } 15245: } 15246: 15247: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15248: CHECK_EXCEPTION(); 15249: ZEND_VM_NEXT_OPCODE(); 15250: } 15251: 15252: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15253: { 15254: return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 15255: } 15256: 15257: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15258: { 15259: USE_OPLINE 15260: zend_free_op free_op1, free_op2; 15261: zval *property; 15262: zval **container; 15263: 15264: SAVE_OPLINE(); 15265: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15266: 15267: if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 15268: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 15269: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 15270: } 15271: 15272: if (1) { 15273: MAKE_REAL_ZVAL_PTR(property); 15274: } 15275: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15276: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15277: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 15278: } 15279: 15280: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 15281: if (1) { 15282: zval_ptr_dtor(&property); 15283: } else { 15284: zval_dtor(free_op2.var); 15285: } 15286: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15287: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15288: } 15289: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15290: 15291: /* We are going to assign the result by reference */ 15292: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 15293: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 15294: 15295: Z_DELREF_PP(retval_ptr); 15296: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 15297: Z_ADDREF_PP(retval_ptr); 15298: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 15299: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 15300: } 15301: 15302: CHECK_EXCEPTION(); 15303: ZEND_VM_NEXT_OPCODE(); 15304: } 15305: 15306: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15307: { 15308: USE_OPLINE 15309: zend_free_op free_op1, free_op2; 15310: zval *property; 15311: zval **container; 15312: 15313: SAVE_OPLINE(); 15314: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15315: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15316: 15317: if (1) { 15318: MAKE_REAL_ZVAL_PTR(property); 15319: } 15320: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15321: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 15322: } 15323: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 15324: if (1) { 15325: zval_ptr_dtor(&property); 15326: } else { 15327: zval_dtor(free_op2.var); 15328: } 15329: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15330: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15331: } 15332: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15333: CHECK_EXCEPTION(); 15334: ZEND_VM_NEXT_OPCODE(); 15335: } 15336: 15337: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15338: { 15339: USE_OPLINE 15340: zend_free_op free_op1; 15341: zval *container; 15342: zend_free_op free_op2; 15343: zval *offset; 15344: 15345: SAVE_OPLINE(); 15346: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15347: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15348: 15349: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 15350: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 15351: PZVAL_LOCK(&EG(uninitialized_zval)); 15352: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 15353: zval_dtor(free_op2.var); 15354: } else { 15355: zval *retval; 15356: 15357: if (1) { 15358: MAKE_REAL_ZVAL_PTR(offset); 15359: } 15360: 15361: /* here we are sure we are dealing with an object */ 15362: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 15363: 15364: PZVAL_LOCK(retval); 15365: AI_SET_PTR(&EX_T(opline->result.var), retval); 15366: 15367: if (1) { 15368: zval_ptr_dtor(&offset); 15369: } else { 15370: zval_dtor(free_op2.var); 15371: } 15372: } 15373: 15374: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15375: CHECK_EXCEPTION(); 15376: ZEND_VM_NEXT_OPCODE(); 15377: } 15378: 15379: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15380: { 15381: USE_OPLINE 15382: 15383: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 15384: /* Behave like FETCH_OBJ_W */ 15385: zend_free_op free_op1, free_op2; 15386: zval *property; 15387: zval **container; 15388: 15389: SAVE_OPLINE(); 15390: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15391: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15392: 15393: if (1) { 15394: MAKE_REAL_ZVAL_PTR(property); 15395: } 15396: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15397: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 15398: } 15399: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 15400: if (1) { 15401: zval_ptr_dtor(&property); 15402: } else { 15403: zval_dtor(free_op2.var); 15404: } 15405: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15406: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15407: } 15408: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15409: CHECK_EXCEPTION(); 15410: ZEND_VM_NEXT_OPCODE(); 15411: } else { 15412: return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 15413: } 15414: } 15415: 15416: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15417: { 15418: USE_OPLINE 15419: zend_free_op free_op1, free_op2, free_res; 15420: zval **container; 15421: zval *property; 15422: 15423: SAVE_OPLINE(); 15424: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15425: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15426: 15427: if (IS_VAR == IS_CV) { 15428: if (container != &EG(uninitialized_zval_ptr)) { 15429: SEPARATE_ZVAL_IF_NOT_REF(container); 15430: } 15431: } 15432: if (1) { 15433: MAKE_REAL_ZVAL_PTR(property); 15434: } 15435: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 15436: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 15437: } 15438: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 15439: if (1) { 15440: zval_ptr_dtor(&property); 15441: } else { 15442: zval_dtor(free_op2.var); 15443: } 15444: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 15445: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 15446: } 15447: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15448: 15449: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 15450: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 15451: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 15452: } 15453: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 15454: FREE_OP_VAR_PTR(free_res); 15455: CHECK_EXCEPTION(); 15456: ZEND_VM_NEXT_OPCODE(); 15457: } 15458: 15459: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15460: { 15461: USE_OPLINE 15462: zend_free_op free_op1, free_op2; 15463: zval **object_ptr; 15464: zval *property_name; 15465: 15466: SAVE_OPLINE(); 15467: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15468: property_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15469: 15470: if (1) { 15471: MAKE_REAL_ZVAL_PTR(property_name); 15472: } 15473: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 15474: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 15475: } 15476: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 15477: if (1) { 15478: zval_ptr_dtor(&property_name); 15479: } else { 15480: zval_dtor(free_op2.var); 15481: } 15482: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15483: /* assign_obj has two opcodes! */ 15484: CHECK_EXCEPTION(); 15485: ZEND_VM_INC_OPCODE(); 15486: ZEND_VM_NEXT_OPCODE(); 15487: } 15488: 15489: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15490: { 15491: USE_OPLINE 15492: zend_free_op free_op1; 15493: zval **object_ptr; 15494: 15495: SAVE_OPLINE(); 15496: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15497: 15498: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 15499: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 15500: } 15501: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 15502: zend_free_op free_op2; 15503: zval *property_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15504: 15505: if (1) { 15506: MAKE_REAL_ZVAL_PTR(property_name); 15507: } 15508: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 15509: if (1) { 15510: zval_ptr_dtor(&property_name); 15511: } else { 15512: zval_dtor(free_op2.var); 15513: } 15514: } else { 15515: zend_free_op free_op2, free_op_data1, free_op_data2; 15516: zval *value; 15517: zval *dim = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15518: zval **variable_ptr_ptr; 15519: 15520: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC); 15521: zval_dtor(free_op2.var); 15522: 15523: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 15524: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 15525: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 15526: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 15527: if (RETURN_VALUE_USED(opline)) { 15528: zval *retval; 15529: 15530: ALLOC_ZVAL(retval); 15531: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 15532: INIT_PZVAL(retval); 15533: AI_SET_PTR(&EX_T(opline->result.var), retval); 15534: } 15535: } else if (RETURN_VALUE_USED(opline)) { 15536: PZVAL_LOCK(&EG(uninitialized_zval)); 15537: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 15538: } 15539: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 15540: if (IS_TMP_FREE(free_op_data1)) { 15541: zval_dtor(value); 15542: } 15543: if (RETURN_VALUE_USED(opline)) { 15544: PZVAL_LOCK(&EG(uninitialized_zval)); 15545: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 15546: } 15547: } else { 15548: if ((opline+1)->op1_type == IS_TMP_VAR) { 15549: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 15550: } else if ((opline+1)->op1_type == IS_CONST) { 15551: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 15552: } else { 15553: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 15554: } 15555: if (RETURN_VALUE_USED(opline)) { 15556: PZVAL_LOCK(value); 15557: AI_SET_PTR(&EX_T(opline->result.var), value); 15558: } 15559: } 15560: FREE_OP_VAR_PTR(free_op_data2); 15561: FREE_OP_IF_VAR(free_op_data1); 15562: } 15563: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15564: /* assign_dim has two opcodes! */ 15565: CHECK_EXCEPTION(); 15566: ZEND_VM_INC_OPCODE(); 15567: ZEND_VM_NEXT_OPCODE(); 15568: } 15569: 15570: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15571: { 15572: USE_OPLINE 15573: zend_free_op free_op1, free_op2; 15574: zval *value; 15575: zval **variable_ptr_ptr; 15576: 15577: SAVE_OPLINE(); 15578: value = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15579: variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15580: 15581: if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 15582: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) { 15583: if (RETURN_VALUE_USED(opline)) { 15584: zval *retval; 15585: 15586: ALLOC_ZVAL(retval); 15587: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 15588: INIT_PZVAL(retval); 15589: AI_SET_PTR(&EX_T(opline->result.var), retval); 15590: } 15591: } else if (RETURN_VALUE_USED(opline)) { 15592: PZVAL_LOCK(&EG(uninitialized_zval)); 15593: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 15594: } 15595: } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 15596: if (1) { 15597: zval_dtor(value); 15598: } 15599: if (RETURN_VALUE_USED(opline)) { 15600: PZVAL_LOCK(&EG(uninitialized_zval)); 15601: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 15602: } 15603: } else { 15604: if (IS_TMP_VAR == IS_TMP_VAR) { 15605: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 15606: } else if (IS_TMP_VAR == IS_CONST) { 15607: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 15608: } else { 15609: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 15610: } 15611: if (RETURN_VALUE_USED(opline)) { 15612: PZVAL_LOCK(value); 15613: AI_SET_PTR(&EX_T(opline->result.var), value); 15614: } 15615: } 15616: 15617: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15618: 15619: /* zend_assign_to_variable() always takes care of op2, never free it! */ 15620: 15621: CHECK_EXCEPTION(); 15622: ZEND_VM_NEXT_OPCODE(); 15623: } 15624: 15625: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15626: { 15627: USE_OPLINE 15628: zval *function_name; 15629: char *function_name_strval; 15630: int function_name_strlen; 15631: zend_free_op free_op1, free_op2; 15632: 15633: SAVE_OPLINE(); 15634: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 15635: 15636: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15637: 15638: if (IS_TMP_VAR != IS_CONST && 15639: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 15640: zend_error_noreturn(E_ERROR, "Method name must be a string"); 15641: } 15642: 15643: function_name_strval = Z_STRVAL_P(function_name); 15644: function_name_strlen = Z_STRLEN_P(function_name); 15645: 15646: EX(object) = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15647: 15648: if (EXPECTED(EX(object) != NULL) && 15649: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 15650: EX(called_scope) = Z_OBJCE_P(EX(object)); 15651: 15652: if (IS_TMP_VAR != IS_CONST || 15653: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 15654: zval *object = EX(object); 15655: 15656: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 15657: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 15658: } 15659: 15660: /* First, locate the function. */ 15661: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 15662: if (UNEXPECTED(EX(fbc) == NULL)) { 15663: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 15664: } 15665: if (IS_TMP_VAR == IS_CONST && 15666: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 15667: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 15668: EXPECTED(EX(object) == object)) { 15669: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 15670: } 15671: } 15672: } else { 15673: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 15674: } 15675: 15676: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 15677: EX(object) = NULL; 15678: } else { 15679: if (!PZVAL_IS_REF(EX(object))) { 15680: Z_ADDREF_P(EX(object)); /* For $this pointer */ 15681: } else { 15682: zval *this_ptr; 15683: ALLOC_ZVAL(this_ptr); 15684: INIT_PZVAL_COPY(this_ptr, EX(object)); 15685: zval_copy_ctor(this_ptr); 15686: EX(object) = this_ptr; 15687: } 15688: } 15689: 15690: zval_dtor(free_op2.var); 15691: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15692: 15693: CHECK_EXCEPTION(); 15694: ZEND_VM_NEXT_OPCODE(); 15695: } 15696: 15697: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15698: { 15699: USE_OPLINE 15700: zval *function_name; 15701: zend_class_entry *ce; 15702: 15703: SAVE_OPLINE(); 15704: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 15705: 15706: if (IS_VAR == IS_CONST) { 15707: /* no function found. try a static method in class */ 15708: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 15709: ce = CACHED_PTR(opline->op1.literal->cache_slot); 15710: } else { 15711: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 15712: if (UNEXPECTED(EG(exception) != NULL)) { 15713: HANDLE_EXCEPTION(); 15714: } 15715: if (UNEXPECTED(ce == NULL)) { 15716: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 15717: } 15718: CACHE_PTR(opline->op1.literal->cache_slot, ce); 15719: } 15720: EX(called_scope) = ce; 15721: } else { 15722: ce = EX_T(opline->op1.var).class_entry; 15723: 15724: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 15725: EX(called_scope) = EG(called_scope); 15726: } else { 15727: EX(called_scope) = ce; 15728: } 15729: } 15730: 15731: if (IS_VAR == IS_CONST && 15732: IS_TMP_VAR == IS_CONST && 15733: CACHED_PTR(opline->op2.literal->cache_slot)) { 15734: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 15735: } else if (IS_VAR != IS_CONST && 15736: IS_TMP_VAR == IS_CONST && 15737: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 15738: /* do nothing */ 15739: } else if (IS_TMP_VAR != IS_UNUSED) { 15740: char *function_name_strval = NULL; 15741: int function_name_strlen = 0; 15742: zend_free_op free_op2; 15743: 15744: if (IS_TMP_VAR == IS_CONST) { 15745: function_name_strval = Z_STRVAL_P(opline->op2.zv); 15746: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 15747: } else { 15748: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15749: 15750: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 15751: zend_error_noreturn(E_ERROR, "Function name must be a string"); 15752: } else { 15753: function_name_strval = Z_STRVAL_P(function_name); 15754: function_name_strlen = Z_STRLEN_P(function_name); 15755: } 15756: } 15757: 15758: if (function_name_strval) { 15759: if (ce->get_static_method) { 15760: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 15761: } else { 15762: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 15763: } 15764: if (UNEXPECTED(EX(fbc) == NULL)) { 15765: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 15766: } 15767: if (IS_TMP_VAR == IS_CONST && 15768: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 15769: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 15770: if (IS_VAR == IS_CONST) { 15771: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 15772: } else { 15773: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 15774: } 15775: } 15776: } 15777: if (IS_TMP_VAR != IS_CONST) { 15778: zval_dtor(free_op2.var); 15779: } 15780: } else { 15781: if (UNEXPECTED(ce->constructor == NULL)) { 15782: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 15783: } 15784: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 15785: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 15786: } 15787: EX(fbc) = ce->constructor; 15788: } 15789: 15790: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 15791: EX(object) = NULL; 15792: } else { 15793: if (EG(This) && 15794: Z_OBJ_HT_P(EG(This))->get_class_entry && 15795: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 15796: /* We are calling method of the other (incompatible) class, 15797: but passing $this. This is done for compatibility with php-4. */ 15798: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 15799: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 15800: } else { 15801: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 15802: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 15803: } 15804: } 15805: if ((EX(object) = EG(This))) { 15806: Z_ADDREF_P(EX(object)); 15807: EX(called_scope) = Z_OBJCE_P(EX(object)); 15808: } 15809: } 15810: 15811: CHECK_EXCEPTION(); 15812: ZEND_VM_NEXT_OPCODE(); 15813: } 15814: 15815: static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15816: { 15817: USE_OPLINE 15818: zend_free_op free_op1, free_op2; 15819: 15820: SAVE_OPLINE(); 15821: if (IS_VAR==IS_VAR) { 15822: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 15823: } 15824: is_equal_function(&EX_T(opline->result.var).tmp_var, 15825: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 15826: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 15827: 15828: zval_dtor(free_op2.var); 15829: CHECK_EXCEPTION(); 15830: ZEND_VM_NEXT_OPCODE(); 15831: } 15832: 15833: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15834: { 15835: USE_OPLINE 15836: zend_free_op free_op1; 15837: zval *expr_ptr; 15838: 15839: SAVE_OPLINE(); 15840: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 15841: zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15842: 15843: if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 15844: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 15845: } 15846: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 15847: expr_ptr = *expr_ptr_ptr; 15848: Z_ADDREF_P(expr_ptr); 15849: } else { 15850: expr_ptr=_get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15851: if (0) { /* temporary variable */ 15852: zval *new_expr; 15853: 15854: ALLOC_ZVAL(new_expr); 15855: INIT_PZVAL_COPY(new_expr, expr_ptr); 15856: expr_ptr = new_expr; 15857: } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 15858: zval *new_expr; 15859: 15860: ALLOC_ZVAL(new_expr); 15861: INIT_PZVAL_COPY(new_expr, expr_ptr); 15862: expr_ptr = new_expr; 15863: zendi_zval_copy_ctor(*expr_ptr); 15864: } else { 15865: Z_ADDREF_P(expr_ptr); 15866: } 15867: } 15868: 15869: if (IS_TMP_VAR != IS_UNUSED) { 15870: zend_free_op free_op2; 15871: zval *offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15872: ulong hval; 15873: 15874: switch (Z_TYPE_P(offset)) { 15875: case IS_DOUBLE: 15876: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 15877: goto num_index; 15878: case IS_LONG: 15879: case IS_BOOL: 15880: hval = Z_LVAL_P(offset); 15881: num_index: 15882: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 15883: break; 15884: case IS_STRING: 15885: if (IS_TMP_VAR == IS_CONST) { 15886: hval = Z_HASH_P(offset); 15887: } else { 15888: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 15889: if (IS_INTERNED(Z_STRVAL_P(offset))) { 15890: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 15891: } else { 15892: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 15893: } 15894: } 15895: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 15896: break; 15897: case IS_NULL: 15898: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 15899: break; 15900: default: 15901: zend_error(E_WARNING, "Illegal offset type"); 15902: zval_ptr_dtor(&expr_ptr); 15903: /* do nothing */ 15904: break; 15905: } 15906: zval_dtor(free_op2.var); 15907: } else { 15908: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 15909: } 15910: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 15911: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15912: } else { 15913: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 15914: } 15915: CHECK_EXCEPTION(); 15916: ZEND_VM_NEXT_OPCODE(); 15917: } 15918: 15919: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15920: { 15921: USE_OPLINE 15922: 15923: array_init(&EX_T(opline->result.var).tmp_var); 15924: if (IS_VAR == IS_UNUSED) { 15925: ZEND_VM_NEXT_OPCODE(); 15926: #if 0 || IS_VAR != IS_UNUSED 15927: } else { 15928: return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 15929: #endif 15930: } 15931: } 15932: 15933: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 15934: { 15935: USE_OPLINE 15936: zend_free_op free_op1, free_op2; 15937: zval **container; 15938: zval *offset; 15939: ulong hval; 15940: 15941: SAVE_OPLINE(); 15942: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 15943: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 15944: SEPARATE_ZVAL_IF_NOT_REF(container); 15945: } 15946: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 15947: 15948: if (IS_VAR != IS_VAR || container) { 15949: switch (Z_TYPE_PP(container)) { 15950: case IS_ARRAY: { 15951: HashTable *ht = Z_ARRVAL_PP(container); 15952: 15953: switch (Z_TYPE_P(offset)) { 15954: case IS_DOUBLE: 15955: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 15956: zend_hash_index_del(ht, hval); 15957: break; 15958: case IS_RESOURCE: 15959: case IS_BOOL: 15960: case IS_LONG: 15961: hval = Z_LVAL_P(offset); 15962: zend_hash_index_del(ht, hval); 15963: break; 15964: case IS_STRING: 15965: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 15966: Z_ADDREF_P(offset); 15967: } 15968: if (IS_TMP_VAR == IS_CONST) { 15969: hval = Z_HASH_P(offset); 15970: } else { 15971: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 15972: if (IS_INTERNED(Z_STRVAL_P(offset))) { 15973: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 15974: } else { 15975: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 15976: } 15977: } 15978: if (ht == &EG(symbol_table)) { 15979: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 15980: } else { 15981: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 15982: } 15983: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 15984: zval_ptr_dtor(&offset); 15985: } 15986: break; 15987: num_index_dim: 15988: zend_hash_index_del(ht, hval); 15989: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 15990: zval_ptr_dtor(&offset); 15991: } 15992: break; 15993: case IS_NULL: 15994: zend_hash_del(ht, "", sizeof("")); 15995: break; 15996: default: 15997: zend_error(E_WARNING, "Illegal offset type in unset"); 15998: break; 15999: } 16000: zval_dtor(free_op2.var); 16001: break; 16002: } 16003: case IS_OBJECT: 16004: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 16005: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 16006: } 16007: if (1) { 16008: MAKE_REAL_ZVAL_PTR(offset); 16009: } 16010: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 16011: if (1) { 16012: zval_ptr_dtor(&offset); 16013: } else { 16014: zval_dtor(free_op2.var); 16015: } 16016: break; 16017: case IS_STRING: 16018: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 16019: ZEND_VM_CONTINUE(); /* bailed out before */ 16020: default: 16021: zval_dtor(free_op2.var); 16022: break; 16023: } 16024: } else { 16025: zval_dtor(free_op2.var); 16026: } 16027: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16028: 16029: CHECK_EXCEPTION(); 16030: ZEND_VM_NEXT_OPCODE(); 16031: } 16032: 16033: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16034: { 16035: USE_OPLINE 16036: zend_free_op free_op1, free_op2; 16037: zval **container; 16038: zval *offset; 16039: 16040: SAVE_OPLINE(); 16041: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16042: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16043: 16044: if (IS_VAR != IS_VAR || container) { 16045: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 16046: SEPARATE_ZVAL_IF_NOT_REF(container); 16047: } 16048: if (Z_TYPE_PP(container) == IS_OBJECT) { 16049: if (1) { 16050: MAKE_REAL_ZVAL_PTR(offset); 16051: } 16052: if (Z_OBJ_HT_P(*container)->unset_property) { 16053: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16054: } else { 16055: zend_error(E_NOTICE, "Trying to unset property of non-object"); 16056: } 16057: if (1) { 16058: zval_ptr_dtor(&offset); 16059: } else { 16060: zval_dtor(free_op2.var); 16061: } 16062: } else { 16063: zval_dtor(free_op2.var); 16064: } 16065: } else { 16066: zval_dtor(free_op2.var); 16067: } 16068: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16069: 16070: CHECK_EXCEPTION(); 16071: ZEND_VM_NEXT_OPCODE(); 16072: } 16073: 16074: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 16075: { 16076: USE_OPLINE 16077: zend_free_op free_op1, free_op2; 16078: zval **container; 16079: zval **value = NULL; 16080: int result = 0; 16081: ulong hval; 16082: zval *offset; 16083: 16084: SAVE_OPLINE(); 16085: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16086: 16087: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16088: 16089: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 16090: HashTable *ht; 16091: int isset = 0; 16092: 16093: ht = Z_ARRVAL_PP(container); 16094: 16095: switch (Z_TYPE_P(offset)) { 16096: case IS_DOUBLE: 16097: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 16098: goto num_index_prop; 16099: case IS_RESOURCE: 16100: case IS_BOOL: 16101: case IS_LONG: 16102: hval = Z_LVAL_P(offset); 16103: num_index_prop: 16104: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 16105: isset = 1; 16106: } 16107: break; 16108: case IS_STRING: 16109: if (IS_TMP_VAR == IS_CONST) { 16110: hval = Z_HASH_P(offset); 16111: } else { 16112: if (!prop_dim) { 16113: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 16114: } 16115: if (IS_INTERNED(Z_STRVAL_P(offset))) { 16116: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 16117: } else { 16118: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 16119: } 16120: } 16121: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 16122: isset = 1; 16123: } 16124: break; 16125: case IS_NULL: 16126: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 16127: isset = 1; 16128: } 16129: break; 16130: default: 16131: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 16132: break; 16133: } 16134: 16135: if (opline->extended_value & ZEND_ISSET) { 16136: if (isset && Z_TYPE_PP(value) == IS_NULL) { 16137: result = 0; 16138: } else { 16139: result = isset; 16140: } 16141: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 16142: if (!isset || !i_zend_is_true(*value)) { 16143: result = 0; 16144: } else { 16145: result = 1; 16146: } 16147: } 16148: zval_dtor(free_op2.var); 16149: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 16150: if (1) { 16151: MAKE_REAL_ZVAL_PTR(offset); 16152: } 16153: if (prop_dim) { 16154: if (Z_OBJ_HT_P(*container)->has_property) { 16155: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16156: } else { 16157: zend_error(E_NOTICE, "Trying to check property of non-object"); 16158: result = 0; 16159: } 16160: } else { 16161: if (Z_OBJ_HT_P(*container)->has_dimension) { 16162: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 16163: } else { 16164: zend_error(E_NOTICE, "Trying to check element of non-array"); 16165: result = 0; 16166: } 16167: } 16168: if (1) { 16169: zval_ptr_dtor(&offset); 16170: } else { 16171: zval_dtor(free_op2.var); 16172: } 16173: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 16174: zval tmp; 16175: 16176: if (Z_TYPE_P(offset) != IS_LONG) { 16177: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 16178: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 16179: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 16180: ZVAL_COPY_VALUE(&tmp, offset); 16181: zval_copy_ctor(&tmp); 16182: convert_to_long(&tmp); 16183: offset = &tmp; 16184: } else { 16185: /* can not be converted to proper offset, return "not set" */ 16186: result = 0; 16187: } 16188: } 16189: if (Z_TYPE_P(offset) == IS_LONG) { 16190: if (opline->extended_value & ZEND_ISSET) { 16191: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 16192: result = 1; 16193: } 16194: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 16195: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 16196: result = 1; 16197: } 16198: } 16199: } 16200: zval_dtor(free_op2.var); 16201: } else { 16202: zval_dtor(free_op2.var); 16203: } 16204: 16205: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 16206: if (opline->extended_value & ZEND_ISSET) { 16207: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 16208: } else { 16209: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 16210: } 16211: 16212: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16213: 16214: CHECK_EXCEPTION(); 16215: ZEND_VM_NEXT_OPCODE(); 16216: } 16217: 16218: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16219: { 16220: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16221: } 16222: 16223: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16224: { 16225: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16226: } 16227: 16228: static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16229: { 16230: USE_OPLINE 16231: zend_free_op free_op1, free_op2; 16232: 16233: SAVE_OPLINE(); 16234: fast_add_function(&EX_T(opline->result.var).tmp_var, 16235: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16236: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16237: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16238: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16239: CHECK_EXCEPTION(); 16240: ZEND_VM_NEXT_OPCODE(); 16241: } 16242: 16243: static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16244: { 16245: USE_OPLINE 16246: zend_free_op free_op1, free_op2; 16247: 16248: SAVE_OPLINE(); 16249: fast_sub_function(&EX_T(opline->result.var).tmp_var, 16250: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16251: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16252: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16253: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16254: CHECK_EXCEPTION(); 16255: ZEND_VM_NEXT_OPCODE(); 16256: } 16257: 16258: static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16259: { 16260: USE_OPLINE 16261: zend_free_op free_op1, free_op2; 16262: 16263: SAVE_OPLINE(); 16264: fast_mul_function(&EX_T(opline->result.var).tmp_var, 16265: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16266: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16267: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16268: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16269: CHECK_EXCEPTION(); 16270: ZEND_VM_NEXT_OPCODE(); 16271: } 16272: 16273: static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16274: { 16275: USE_OPLINE 16276: zend_free_op free_op1, free_op2; 16277: 16278: SAVE_OPLINE(); 16279: fast_div_function(&EX_T(opline->result.var).tmp_var, 16280: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16281: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16282: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16283: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16284: CHECK_EXCEPTION(); 16285: ZEND_VM_NEXT_OPCODE(); 16286: } 16287: 16288: static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16289: { 16290: USE_OPLINE 16291: zend_free_op free_op1, free_op2; 16292: 16293: SAVE_OPLINE(); 16294: fast_mod_function(&EX_T(opline->result.var).tmp_var, 16295: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16296: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16297: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16298: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16299: CHECK_EXCEPTION(); 16300: ZEND_VM_NEXT_OPCODE(); 16301: } 16302: 16303: static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16304: { 16305: USE_OPLINE 16306: zend_free_op free_op1, free_op2; 16307: 16308: SAVE_OPLINE(); 16309: shift_left_function(&EX_T(opline->result.var).tmp_var, 16310: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16311: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16312: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16313: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16314: CHECK_EXCEPTION(); 16315: ZEND_VM_NEXT_OPCODE(); 16316: } 16317: 16318: static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16319: { 16320: USE_OPLINE 16321: zend_free_op free_op1, free_op2; 16322: 16323: SAVE_OPLINE(); 16324: shift_right_function(&EX_T(opline->result.var).tmp_var, 16325: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16326: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16327: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16328: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16329: CHECK_EXCEPTION(); 16330: ZEND_VM_NEXT_OPCODE(); 16331: } 16332: 16333: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16334: { 16335: USE_OPLINE 16336: zend_free_op free_op1, free_op2; 16337: 16338: SAVE_OPLINE(); 16339: concat_function(&EX_T(opline->result.var).tmp_var, 16340: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16341: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16342: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16343: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16344: CHECK_EXCEPTION(); 16345: ZEND_VM_NEXT_OPCODE(); 16346: } 16347: 16348: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16349: { 16350: USE_OPLINE 16351: zend_free_op free_op1, free_op2; 16352: 16353: SAVE_OPLINE(); 16354: is_identical_function(&EX_T(opline->result.var).tmp_var, 16355: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16356: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16357: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16358: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16359: CHECK_EXCEPTION(); 16360: ZEND_VM_NEXT_OPCODE(); 16361: } 16362: 16363: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16364: { 16365: USE_OPLINE 16366: zend_free_op free_op1, free_op2; 16367: zval *result = &EX_T(opline->result.var).tmp_var; 16368: 16369: SAVE_OPLINE(); 16370: is_identical_function(result, 16371: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16372: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16373: Z_LVAL_P(result) = !Z_LVAL_P(result); 16374: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16375: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16376: CHECK_EXCEPTION(); 16377: ZEND_VM_NEXT_OPCODE(); 16378: } 16379: 16380: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16381: { 16382: USE_OPLINE 16383: zend_free_op free_op1, free_op2; 16384: zval *result = &EX_T(opline->result.var).tmp_var; 16385: 16386: SAVE_OPLINE(); 16387: ZVAL_BOOL(result, fast_equal_function(result, 16388: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16389: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 16390: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16391: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16392: CHECK_EXCEPTION(); 16393: ZEND_VM_NEXT_OPCODE(); 16394: } 16395: 16396: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16397: { 16398: USE_OPLINE 16399: zend_free_op free_op1, free_op2; 16400: zval *result = &EX_T(opline->result.var).tmp_var; 16401: 16402: SAVE_OPLINE(); 16403: ZVAL_BOOL(result, fast_not_equal_function(result, 16404: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16405: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 16406: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16407: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16408: CHECK_EXCEPTION(); 16409: ZEND_VM_NEXT_OPCODE(); 16410: } 16411: 16412: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16413: { 16414: USE_OPLINE 16415: zend_free_op free_op1, free_op2; 16416: zval *result = &EX_T(opline->result.var).tmp_var; 16417: 16418: SAVE_OPLINE(); 16419: ZVAL_BOOL(result, fast_is_smaller_function(result, 16420: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16421: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 16422: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16423: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16424: CHECK_EXCEPTION(); 16425: ZEND_VM_NEXT_OPCODE(); 16426: } 16427: 16428: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16429: { 16430: USE_OPLINE 16431: zend_free_op free_op1, free_op2; 16432: zval *result = &EX_T(opline->result.var).tmp_var; 16433: 16434: SAVE_OPLINE(); 16435: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 16436: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16437: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 16438: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16439: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16440: CHECK_EXCEPTION(); 16441: ZEND_VM_NEXT_OPCODE(); 16442: } 16443: 16444: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16445: { 16446: USE_OPLINE 16447: zend_free_op free_op1, free_op2; 16448: 16449: SAVE_OPLINE(); 16450: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 16451: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16452: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16453: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16454: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16455: CHECK_EXCEPTION(); 16456: ZEND_VM_NEXT_OPCODE(); 16457: } 16458: 16459: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16460: { 16461: USE_OPLINE 16462: zend_free_op free_op1, free_op2; 16463: 16464: SAVE_OPLINE(); 16465: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 16466: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16467: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16468: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16469: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16470: CHECK_EXCEPTION(); 16471: ZEND_VM_NEXT_OPCODE(); 16472: } 16473: 16474: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16475: { 16476: USE_OPLINE 16477: zend_free_op free_op1, free_op2; 16478: 16479: SAVE_OPLINE(); 16480: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 16481: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16482: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16483: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16484: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16485: CHECK_EXCEPTION(); 16486: ZEND_VM_NEXT_OPCODE(); 16487: } 16488: 16489: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16490: { 16491: USE_OPLINE 16492: zend_free_op free_op1, free_op2; 16493: 16494: SAVE_OPLINE(); 16495: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 16496: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 16497: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 16498: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16499: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16500: CHECK_EXCEPTION(); 16501: ZEND_VM_NEXT_OPCODE(); 16502: } 16503: 16504: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 16505: { 16506: USE_OPLINE 16507: zend_free_op free_op1, free_op2, free_op_data1; 16508: zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16509: zval *object; 16510: zval *property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16511: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 16512: int have_get_ptr = 0; 16513: 16514: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 16515: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 16516: } 16517: 16518: make_real_object(object_ptr TSRMLS_CC); 16519: object = *object_ptr; 16520: 16521: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 16522: zend_error(E_WARNING, "Attempt to assign property of non-object"); 16523: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16524: FREE_OP(free_op_data1); 16525: 16526: if (RETURN_VALUE_USED(opline)) { 16527: PZVAL_LOCK(&EG(uninitialized_zval)); 16528: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 16529: EX_T(opline->result.var).var.ptr_ptr = NULL; 16530: } 16531: } else { 16532: /* here we are sure we are dealing with an object */ 16533: if (0) { 16534: MAKE_REAL_ZVAL_PTR(property); 16535: } 16536: 16537: /* here property is a string */ 16538: if (opline->extended_value == ZEND_ASSIGN_OBJ 16539: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 16540: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16541: if (zptr != NULL) { /* NULL means no success in getting PTR */ 16542: SEPARATE_ZVAL_IF_NOT_REF(zptr); 16543: 16544: have_get_ptr = 1; 16545: binary_op(*zptr, *zptr, value TSRMLS_CC); 16546: if (RETURN_VALUE_USED(opline)) { 16547: PZVAL_LOCK(*zptr); 16548: EX_T(opline->result.var).var.ptr = *zptr; 16549: EX_T(opline->result.var).var.ptr_ptr = NULL; 16550: } 16551: } 16552: } 16553: 16554: if (!have_get_ptr) { 16555: zval *z = NULL; 16556: 16557: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 16558: if (Z_OBJ_HT_P(object)->read_property) { 16559: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16560: } 16561: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 16562: if (Z_OBJ_HT_P(object)->read_dimension) { 16563: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 16564: } 16565: } 16566: if (z) { 16567: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 16568: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 16569: 16570: if (Z_REFCOUNT_P(z) == 0) { 16571: GC_REMOVE_ZVAL_FROM_BUFFER(z); 16572: zval_dtor(z); 16573: FREE_ZVAL(z); 16574: } 16575: z = value; 16576: } 16577: Z_ADDREF_P(z); 16578: SEPARATE_ZVAL_IF_NOT_REF(&z); 16579: binary_op(z, z, value TSRMLS_CC); 16580: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 16581: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16582: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 16583: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 16584: } 16585: if (RETURN_VALUE_USED(opline)) { 16586: PZVAL_LOCK(z); 16587: EX_T(opline->result.var).var.ptr = z; 16588: EX_T(opline->result.var).var.ptr_ptr = NULL; 16589: } 16590: zval_ptr_dtor(&z); 16591: } else { 16592: zend_error(E_WARNING, "Attempt to assign property of non-object"); 16593: if (RETURN_VALUE_USED(opline)) { 16594: PZVAL_LOCK(&EG(uninitialized_zval)); 16595: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 16596: EX_T(opline->result.var).var.ptr_ptr = NULL; 16597: } 16598: } 16599: } 16600: 16601: if (0) { 16602: zval_ptr_dtor(&property); 16603: } else { 16604: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16605: } 16606: FREE_OP(free_op_data1); 16607: } 16608: 16609: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16610: /* assign_obj has two opcodes! */ 16611: CHECK_EXCEPTION(); 16612: ZEND_VM_INC_OPCODE(); 16613: ZEND_VM_NEXT_OPCODE(); 16614: } 16615: 16616: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 16617: { 16618: USE_OPLINE 16619: zend_free_op free_op1, free_op2, free_op_data2, free_op_data1; 16620: zval **var_ptr; 16621: zval *value; 16622: 16623: SAVE_OPLINE(); 16624: switch (opline->extended_value) { 16625: case ZEND_ASSIGN_OBJ: 16626: return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16627: break; 16628: case ZEND_ASSIGN_DIM: { 16629: zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16630: 16631: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 16632: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 16633: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 16634: if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { 16635: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 16636: } 16637: return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16638: } else { 16639: zval *dim = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16640: 16641: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC); 16642: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 16643: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 16644: } 16645: } 16646: break; 16647: default: 16648: value = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16649: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16650: /* do nothing */ 16651: break; 16652: } 16653: 16654: if (UNEXPECTED(var_ptr == NULL)) { 16655: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 16656: } 16657: 16658: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 16659: if (RETURN_VALUE_USED(opline)) { 16660: PZVAL_LOCK(&EG(uninitialized_zval)); 16661: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 16662: } 16663: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16664: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16665: CHECK_EXCEPTION(); 16666: if (opline->extended_value == ZEND_ASSIGN_DIM) { 16667: ZEND_VM_INC_OPCODE(); 16668: } 16669: ZEND_VM_NEXT_OPCODE(); 16670: } 16671: 16672: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 16673: 16674: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 16675: && Z_OBJ_HANDLER_PP(var_ptr, get) 16676: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 16677: /* proxy object */ 16678: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 16679: Z_ADDREF_P(objval); 16680: binary_op(objval, objval, value TSRMLS_CC); 16681: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 16682: zval_ptr_dtor(&objval); 16683: } else { 16684: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 16685: } 16686: 16687: if (RETURN_VALUE_USED(opline)) { 16688: PZVAL_LOCK(*var_ptr); 16689: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 16690: } 16691: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16692: 16693: if (opline->extended_value == ZEND_ASSIGN_DIM) { 16694: FREE_OP(free_op_data1); 16695: FREE_OP_VAR_PTR(free_op_data2); 16696: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16697: CHECK_EXCEPTION(); 16698: ZEND_VM_INC_OPCODE(); 16699: } else { 16700: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16701: CHECK_EXCEPTION(); 16702: } 16703: ZEND_VM_NEXT_OPCODE(); 16704: } 16705: 16706: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16707: { 16708: return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16709: } 16710: 16711: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16712: { 16713: return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16714: } 16715: 16716: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16717: { 16718: return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16719: } 16720: 16721: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16722: { 16723: return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16724: } 16725: 16726: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16727: { 16728: return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16729: } 16730: 16731: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16732: { 16733: return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16734: } 16735: 16736: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16737: { 16738: return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16739: } 16740: 16741: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16742: { 16743: return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16744: } 16745: 16746: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16747: { 16748: return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16749: } 16750: 16751: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16752: { 16753: return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16754: } 16755: 16756: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16757: { 16758: return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16759: } 16760: 16761: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 16762: { 16763: USE_OPLINE 16764: zend_free_op free_op1, free_op2; 16765: zval **object_ptr; 16766: zval *object; 16767: zval *property; 16768: zval **retval; 16769: int have_get_ptr = 0; 16770: 16771: SAVE_OPLINE(); 16772: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16773: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16774: retval = &EX_T(opline->result.var).var.ptr; 16775: 16776: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 16777: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 16778: } 16779: 16780: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 16781: object = *object_ptr; 16782: 16783: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 16784: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 16785: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16786: if (RETURN_VALUE_USED(opline)) { 16787: PZVAL_LOCK(&EG(uninitialized_zval)); 16788: *retval = &EG(uninitialized_zval); 16789: } 16790: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16791: CHECK_EXCEPTION(); 16792: ZEND_VM_NEXT_OPCODE(); 16793: } 16794: 16795: /* here we are sure we are dealing with an object */ 16796: 16797: if (0) { 16798: MAKE_REAL_ZVAL_PTR(property); 16799: } 16800: 16801: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 16802: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16803: if (zptr != NULL) { /* NULL means no success in getting PTR */ 16804: SEPARATE_ZVAL_IF_NOT_REF(zptr); 16805: 16806: have_get_ptr = 1; 16807: incdec_op(*zptr); 16808: if (RETURN_VALUE_USED(opline)) { 16809: *retval = *zptr; 16810: PZVAL_LOCK(*retval); 16811: } 16812: } 16813: } 16814: 16815: if (!have_get_ptr) { 16816: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 16817: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16818: 16819: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 16820: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 16821: 16822: if (Z_REFCOUNT_P(z) == 0) { 16823: GC_REMOVE_ZVAL_FROM_BUFFER(z); 16824: zval_dtor(z); 16825: FREE_ZVAL(z); 16826: } 16827: z = value; 16828: } 16829: Z_ADDREF_P(z); 16830: SEPARATE_ZVAL_IF_NOT_REF(&z); 16831: incdec_op(z); 16832: *retval = z; 16833: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16834: SELECTIVE_PZVAL_LOCK(*retval, opline); 16835: zval_ptr_dtor(&z); 16836: } else { 16837: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 16838: if (RETURN_VALUE_USED(opline)) { 16839: PZVAL_LOCK(&EG(uninitialized_zval)); 16840: *retval = &EG(uninitialized_zval); 16841: } 16842: } 16843: } 16844: 16845: if (0) { 16846: zval_ptr_dtor(&property); 16847: } else { 16848: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16849: } 16850: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16851: CHECK_EXCEPTION(); 16852: ZEND_VM_NEXT_OPCODE(); 16853: } 16854: 16855: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16856: { 16857: return zend_pre_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16858: } 16859: 16860: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16861: { 16862: return zend_pre_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16863: } 16864: 16865: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 16866: { 16867: USE_OPLINE 16868: zend_free_op free_op1, free_op2; 16869: zval **object_ptr; 16870: zval *object; 16871: zval *property; 16872: zval *retval; 16873: int have_get_ptr = 0; 16874: 16875: SAVE_OPLINE(); 16876: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16877: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 16878: retval = &EX_T(opline->result.var).tmp_var; 16879: 16880: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 16881: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 16882: } 16883: 16884: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 16885: object = *object_ptr; 16886: 16887: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 16888: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 16889: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16890: ZVAL_NULL(retval); 16891: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16892: CHECK_EXCEPTION(); 16893: ZEND_VM_NEXT_OPCODE(); 16894: } 16895: 16896: /* here we are sure we are dealing with an object */ 16897: 16898: if (0) { 16899: MAKE_REAL_ZVAL_PTR(property); 16900: } 16901: 16902: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 16903: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16904: if (zptr != NULL) { /* NULL means no success in getting PTR */ 16905: have_get_ptr = 1; 16906: SEPARATE_ZVAL_IF_NOT_REF(zptr); 16907: 16908: ZVAL_COPY_VALUE(retval, *zptr); 16909: zendi_zval_copy_ctor(*retval); 16910: 16911: incdec_op(*zptr); 16912: 16913: } 16914: } 16915: 16916: if (!have_get_ptr) { 16917: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 16918: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16919: zval *z_copy; 16920: 16921: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 16922: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 16923: 16924: if (Z_REFCOUNT_P(z) == 0) { 16925: GC_REMOVE_ZVAL_FROM_BUFFER(z); 16926: zval_dtor(z); 16927: FREE_ZVAL(z); 16928: } 16929: z = value; 16930: } 16931: ZVAL_COPY_VALUE(retval, z); 16932: zendi_zval_copy_ctor(*retval); 16933: ALLOC_ZVAL(z_copy); 16934: INIT_PZVAL_COPY(z_copy, z); 16935: zendi_zval_copy_ctor(*z_copy); 16936: incdec_op(z_copy); 16937: Z_ADDREF_P(z); 16938: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 16939: zval_ptr_dtor(&z_copy); 16940: zval_ptr_dtor(&z); 16941: } else { 16942: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 16943: ZVAL_NULL(retval); 16944: } 16945: } 16946: 16947: if (0) { 16948: zval_ptr_dtor(&property); 16949: } else { 16950: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 16951: } 16952: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 16953: CHECK_EXCEPTION(); 16954: ZEND_VM_NEXT_OPCODE(); 16955: } 16956: 16957: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16958: { 16959: return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16960: } 16961: 16962: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 16963: { 16964: return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 16965: } 16966: 16967: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) 16968: { 16969: USE_OPLINE 16970: zend_free_op free_op1; 16971: zval *varname; 16972: zval **retval; 16973: zval tmp_varname; 16974: HashTable *target_symbol_table; 16975: ulong hash_value; 16976: 16977: SAVE_OPLINE(); 16978: varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 16979: 16980: if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 16981: ZVAL_COPY_VALUE(&tmp_varname, varname); 16982: zval_copy_ctor(&tmp_varname); 16983: Z_SET_REFCOUNT(tmp_varname, 1); 16984: Z_UNSET_ISREF(tmp_varname); 16985: convert_to_string(&tmp_varname); 16986: varname = &tmp_varname; 16987: } 16988: 16989: if (IS_VAR != IS_UNUSED) { 16990: zend_class_entry *ce; 16991: 16992: if (IS_VAR == IS_CONST) { 16993: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 16994: ce = CACHED_PTR(opline->op2.literal->cache_slot); 16995: } else { 16996: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 16997: if (UNEXPECTED(ce == NULL)) { 16998: if (IS_VAR != IS_CONST && varname == &tmp_varname) { 16999: zval_dtor(&tmp_varname); 17000: } 17001: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17002: CHECK_EXCEPTION(); 17003: ZEND_VM_NEXT_OPCODE(); 17004: } 17005: CACHE_PTR(opline->op2.literal->cache_slot, ce); 17006: } 17007: } else { 17008: ce = EX_T(opline->op2.var).class_entry; 17009: } 17010: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 17011: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17012: } else { 17013: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 17014: /* 17015: if (!target_symbol_table) { 17016: CHECK_EXCEPTION(); 17017: ZEND_VM_NEXT_OPCODE(); 17018: } 17019: */ 17020: if (IS_VAR == IS_CONST) { 17021: hash_value = Z_HASH_P(varname); 17022: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 17023: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 17024: } else { 17025: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 17026: } 17027: 17028: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 17029: switch (type) { 17030: case BP_VAR_R: 17031: case BP_VAR_UNSET: 17032: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 17033: /* break missing intentionally */ 17034: case BP_VAR_IS: 17035: retval = &EG(uninitialized_zval_ptr); 17036: break; 17037: case BP_VAR_RW: 17038: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 17039: /* break missing intentionally */ 17040: case BP_VAR_W: 17041: Z_ADDREF_P(&EG(uninitialized_zval)); 17042: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 17043: break; 17044: EMPTY_SWITCH_DEFAULT_CASE() 17045: } 17046: } 17047: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 17048: case ZEND_FETCH_GLOBAL: 17049: if (IS_VAR != IS_TMP_VAR) { 17050: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17051: } 17052: break; 17053: case ZEND_FETCH_LOCAL: 17054: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17055: break; 17056: case ZEND_FETCH_STATIC: 17057: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 17058: break; 17059: case ZEND_FETCH_GLOBAL_LOCK: 17060: if (IS_VAR == IS_VAR && !free_op1.var) { 17061: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 17062: } 17063: break; 17064: } 17065: } 17066: 17067: 17068: if (IS_VAR != IS_CONST && varname == &tmp_varname) { 17069: zval_dtor(&tmp_varname); 17070: } 17071: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 17072: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 17073: } 17074: PZVAL_LOCK(*retval); 17075: switch (type) { 17076: case BP_VAR_R: 17077: case BP_VAR_IS: 17078: AI_SET_PTR(&EX_T(opline->result.var), *retval); 17079: break; 17080: case BP_VAR_UNSET: { 17081: zend_free_op free_res; 17082: 17083: PZVAL_UNLOCK(*retval, &free_res); 17084: if (retval != &EG(uninitialized_zval_ptr)) { 17085: SEPARATE_ZVAL_IF_NOT_REF(retval); 17086: } 17087: PZVAL_LOCK(*retval); 17088: FREE_OP_VAR_PTR(free_res); 17089: } 17090: /* break missing intentionally */ 17091: default: 17092: EX_T(opline->result.var).var.ptr_ptr = retval; 17093: break; 17094: } 17095: CHECK_EXCEPTION(); 17096: ZEND_VM_NEXT_OPCODE(); 17097: } 17098: 17099: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17100: { 17101: return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17102: } 17103: 17104: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17105: { 17106: return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17107: } 17108: 17109: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17110: { 17111: return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17112: } 17113: 17114: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17115: { 17116: USE_OPLINE 17117: 17118: return zend_fetch_var_address_helper_SPEC_VAR_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17119: } 17120: 17121: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17122: { 17123: return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17124: } 17125: 17126: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17127: { 17128: return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17129: } 17130: 17131: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17132: { 17133: USE_OPLINE 17134: zend_free_op free_op1, free_op2; 17135: zval **container; 17136: 17137: SAVE_OPLINE(); 17138: 17139: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 17140: IS_VAR != IS_CV && 17141: EX_T(opline->op1.var).var.ptr_ptr) { 17142: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 17143: } 17144: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17145: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); 17146: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17147: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17148: CHECK_EXCEPTION(); 17149: ZEND_VM_NEXT_OPCODE(); 17150: } 17151: 17152: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17153: { 17154: USE_OPLINE 17155: zend_free_op free_op1, free_op2; 17156: zval **container; 17157: 17158: SAVE_OPLINE(); 17159: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17160: 17161: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17162: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 17163: } 17164: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); 17165: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17166: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17167: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17168: } 17169: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17170: 17171: /* We are going to assign the result by reference */ 17172: if (UNEXPECTED(opline->extended_value != 0)) { 17173: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 17174: 17175: if (retval_ptr) { 17176: Z_DELREF_PP(retval_ptr); 17177: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 17178: Z_ADDREF_PP(retval_ptr); 17179: } 17180: } 17181: 17182: CHECK_EXCEPTION(); 17183: ZEND_VM_NEXT_OPCODE(); 17184: } 17185: 17186: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17187: { 17188: USE_OPLINE 17189: zend_free_op free_op1, free_op2; 17190: zval **container; 17191: 17192: SAVE_OPLINE(); 17193: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17194: 17195: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17196: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 17197: } 17198: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC); 17199: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17200: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17201: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17202: } 17203: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17204: CHECK_EXCEPTION(); 17205: ZEND_VM_NEXT_OPCODE(); 17206: } 17207: 17208: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17209: { 17210: USE_OPLINE 17211: zend_free_op free_op1, free_op2; 17212: zval **container; 17213: 17214: SAVE_OPLINE(); 17215: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17216: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC); 17217: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17218: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17219: CHECK_EXCEPTION(); 17220: ZEND_VM_NEXT_OPCODE(); 17221: } 17222: 17223: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17224: { 17225: USE_OPLINE 17226: zend_free_op free_op1, free_op2; 17227: zval **container; 17228: 17229: SAVE_OPLINE(); 17230: 17231: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 17232: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17233: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17234: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 17235: } 17236: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); 17237: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17238: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17239: } 17240: } else { 17241: if (IS_VAR == IS_UNUSED) { 17242: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 17243: } 17244: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17245: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); 17246: } 17247: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17248: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17249: CHECK_EXCEPTION(); 17250: ZEND_VM_NEXT_OPCODE(); 17251: } 17252: 17253: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17254: { 17255: USE_OPLINE 17256: zend_free_op free_op1, free_op2; 17257: zval **container; 17258: 17259: SAVE_OPLINE(); 17260: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17261: 17262: if (IS_VAR == IS_CV) { 17263: if (container != &EG(uninitialized_zval_ptr)) { 17264: SEPARATE_ZVAL_IF_NOT_REF(container); 17265: } 17266: } 17267: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17268: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 17269: } 17270: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC); 17271: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17272: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17273: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17274: } 17275: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17276: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 17277: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 17278: } else { 17279: zend_free_op free_res; 17280: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 17281: 17282: PZVAL_UNLOCK(*retval_ptr, &free_res); 17283: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 17284: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 17285: } 17286: PZVAL_LOCK(*retval_ptr); 17287: FREE_OP_VAR_PTR(free_res); 17288: CHECK_EXCEPTION(); 17289: ZEND_VM_NEXT_OPCODE(); 17290: } 17291: } 17292: 17293: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS) 17294: { 17295: USE_OPLINE 17296: zend_free_op free_op1; 17297: zval *container; 17298: zend_free_op free_op2; 17299: zval *offset; 17300: 17301: SAVE_OPLINE(); 17302: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17303: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17304: 17305: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 17306: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 17307: zend_error(E_NOTICE, "Trying to get property of non-object"); 17308: PZVAL_LOCK(&EG(uninitialized_zval)); 17309: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 17310: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17311: } else { 17312: zval *retval; 17313: 17314: if (0) { 17315: MAKE_REAL_ZVAL_PTR(offset); 17316: } 17317: 17318: /* here we are sure we are dealing with an object */ 17319: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 17320: 17321: PZVAL_LOCK(retval); 17322: AI_SET_PTR(&EX_T(opline->result.var), retval); 17323: 17324: if (0) { 17325: zval_ptr_dtor(&offset); 17326: } else { 17327: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17328: } 17329: } 17330: 17331: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17332: CHECK_EXCEPTION(); 17333: ZEND_VM_NEXT_OPCODE(); 17334: } 17335: 17336: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17337: { 17338: return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17339: } 17340: 17341: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17342: { 17343: USE_OPLINE 17344: zend_free_op free_op1, free_op2; 17345: zval *property; 17346: zval **container; 17347: 17348: SAVE_OPLINE(); 17349: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17350: 17351: if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 17352: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 17353: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 17354: } 17355: 17356: if (0) { 17357: MAKE_REAL_ZVAL_PTR(property); 17358: } 17359: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17360: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17361: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 17362: } 17363: 17364: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 17365: if (0) { 17366: zval_ptr_dtor(&property); 17367: } else { 17368: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17369: } 17370: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17371: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17372: } 17373: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17374: 17375: /* We are going to assign the result by reference */ 17376: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 17377: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 17378: 17379: Z_DELREF_PP(retval_ptr); 17380: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 17381: Z_ADDREF_PP(retval_ptr); 17382: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 17383: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 17384: } 17385: 17386: CHECK_EXCEPTION(); 17387: ZEND_VM_NEXT_OPCODE(); 17388: } 17389: 17390: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17391: { 17392: USE_OPLINE 17393: zend_free_op free_op1, free_op2; 17394: zval *property; 17395: zval **container; 17396: 17397: SAVE_OPLINE(); 17398: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17399: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17400: 17401: if (0) { 17402: MAKE_REAL_ZVAL_PTR(property); 17403: } 17404: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17405: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 17406: } 17407: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 17408: if (0) { 17409: zval_ptr_dtor(&property); 17410: } else { 17411: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17412: } 17413: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17414: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17415: } 17416: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17417: CHECK_EXCEPTION(); 17418: ZEND_VM_NEXT_OPCODE(); 17419: } 17420: 17421: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17422: { 17423: USE_OPLINE 17424: zend_free_op free_op1; 17425: zval *container; 17426: zend_free_op free_op2; 17427: zval *offset; 17428: 17429: SAVE_OPLINE(); 17430: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17431: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17432: 17433: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 17434: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 17435: PZVAL_LOCK(&EG(uninitialized_zval)); 17436: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 17437: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17438: } else { 17439: zval *retval; 17440: 17441: if (0) { 17442: MAKE_REAL_ZVAL_PTR(offset); 17443: } 17444: 17445: /* here we are sure we are dealing with an object */ 17446: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 17447: 17448: PZVAL_LOCK(retval); 17449: AI_SET_PTR(&EX_T(opline->result.var), retval); 17450: 17451: if (0) { 17452: zval_ptr_dtor(&offset); 17453: } else { 17454: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17455: } 17456: } 17457: 17458: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17459: CHECK_EXCEPTION(); 17460: ZEND_VM_NEXT_OPCODE(); 17461: } 17462: 17463: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17464: { 17465: USE_OPLINE 17466: 17467: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 17468: /* Behave like FETCH_OBJ_W */ 17469: zend_free_op free_op1, free_op2; 17470: zval *property; 17471: zval **container; 17472: 17473: SAVE_OPLINE(); 17474: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17475: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17476: 17477: if (0) { 17478: MAKE_REAL_ZVAL_PTR(property); 17479: } 17480: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17481: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 17482: } 17483: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 17484: if (0) { 17485: zval_ptr_dtor(&property); 17486: } else { 17487: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17488: } 17489: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17490: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17491: } 17492: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17493: CHECK_EXCEPTION(); 17494: ZEND_VM_NEXT_OPCODE(); 17495: } else { 17496: return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17497: } 17498: } 17499: 17500: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17501: { 17502: USE_OPLINE 17503: zend_free_op free_op1, free_op2, free_res; 17504: zval **container; 17505: zval *property; 17506: 17507: SAVE_OPLINE(); 17508: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17509: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17510: 17511: if (IS_VAR == IS_CV) { 17512: if (container != &EG(uninitialized_zval_ptr)) { 17513: SEPARATE_ZVAL_IF_NOT_REF(container); 17514: } 17515: } 17516: if (0) { 17517: MAKE_REAL_ZVAL_PTR(property); 17518: } 17519: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 17520: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 17521: } 17522: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 17523: if (0) { 17524: zval_ptr_dtor(&property); 17525: } else { 17526: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17527: } 17528: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 17529: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 17530: } 17531: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17532: 17533: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 17534: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 17535: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 17536: } 17537: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 17538: FREE_OP_VAR_PTR(free_res); 17539: CHECK_EXCEPTION(); 17540: ZEND_VM_NEXT_OPCODE(); 17541: } 17542: 17543: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17544: { 17545: USE_OPLINE 17546: zend_free_op free_op1, free_op2; 17547: zval **object_ptr; 17548: zval *property_name; 17549: 17550: SAVE_OPLINE(); 17551: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17552: property_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17553: 17554: if (0) { 17555: MAKE_REAL_ZVAL_PTR(property_name); 17556: } 17557: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 17558: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 17559: } 17560: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 17561: if (0) { 17562: zval_ptr_dtor(&property_name); 17563: } else { 17564: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17565: } 17566: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17567: /* assign_obj has two opcodes! */ 17568: CHECK_EXCEPTION(); 17569: ZEND_VM_INC_OPCODE(); 17570: ZEND_VM_NEXT_OPCODE(); 17571: } 17572: 17573: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17574: { 17575: USE_OPLINE 17576: zend_free_op free_op1; 17577: zval **object_ptr; 17578: 17579: SAVE_OPLINE(); 17580: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17581: 17582: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 17583: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 17584: } 17585: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 17586: zend_free_op free_op2; 17587: zval *property_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17588: 17589: if (0) { 17590: MAKE_REAL_ZVAL_PTR(property_name); 17591: } 17592: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 17593: if (0) { 17594: zval_ptr_dtor(&property_name); 17595: } else { 17596: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17597: } 17598: } else { 17599: zend_free_op free_op2, free_op_data1, free_op_data2; 17600: zval *value; 17601: zval *dim = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17602: zval **variable_ptr_ptr; 17603: 17604: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC); 17605: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17606: 17607: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 17608: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 17609: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 17610: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 17611: if (RETURN_VALUE_USED(opline)) { 17612: zval *retval; 17613: 17614: ALLOC_ZVAL(retval); 17615: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 17616: INIT_PZVAL(retval); 17617: AI_SET_PTR(&EX_T(opline->result.var), retval); 17618: } 17619: } else if (RETURN_VALUE_USED(opline)) { 17620: PZVAL_LOCK(&EG(uninitialized_zval)); 17621: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 17622: } 17623: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 17624: if (IS_TMP_FREE(free_op_data1)) { 17625: zval_dtor(value); 17626: } 17627: if (RETURN_VALUE_USED(opline)) { 17628: PZVAL_LOCK(&EG(uninitialized_zval)); 17629: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 17630: } 17631: } else { 17632: if ((opline+1)->op1_type == IS_TMP_VAR) { 17633: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 17634: } else if ((opline+1)->op1_type == IS_CONST) { 17635: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 17636: } else { 17637: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 17638: } 17639: if (RETURN_VALUE_USED(opline)) { 17640: PZVAL_LOCK(value); 17641: AI_SET_PTR(&EX_T(opline->result.var), value); 17642: } 17643: } 17644: FREE_OP_VAR_PTR(free_op_data2); 17645: FREE_OP_IF_VAR(free_op_data1); 17646: } 17647: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17648: /* assign_dim has two opcodes! */ 17649: CHECK_EXCEPTION(); 17650: ZEND_VM_INC_OPCODE(); 17651: ZEND_VM_NEXT_OPCODE(); 17652: } 17653: 17654: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17655: { 17656: USE_OPLINE 17657: zend_free_op free_op1, free_op2; 17658: zval *value; 17659: zval **variable_ptr_ptr; 17660: 17661: SAVE_OPLINE(); 17662: value = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17663: variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17664: 17665: if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 17666: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) { 17667: if (RETURN_VALUE_USED(opline)) { 17668: zval *retval; 17669: 17670: ALLOC_ZVAL(retval); 17671: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 17672: INIT_PZVAL(retval); 17673: AI_SET_PTR(&EX_T(opline->result.var), retval); 17674: } 17675: } else if (RETURN_VALUE_USED(opline)) { 17676: PZVAL_LOCK(&EG(uninitialized_zval)); 17677: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 17678: } 17679: } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 17680: if (0) { 17681: zval_dtor(value); 17682: } 17683: if (RETURN_VALUE_USED(opline)) { 17684: PZVAL_LOCK(&EG(uninitialized_zval)); 17685: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 17686: } 17687: } else { 17688: if (IS_VAR == IS_TMP_VAR) { 17689: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 17690: } else if (IS_VAR == IS_CONST) { 17691: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 17692: } else { 17693: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 17694: } 17695: if (RETURN_VALUE_USED(opline)) { 17696: PZVAL_LOCK(value); 17697: AI_SET_PTR(&EX_T(opline->result.var), value); 17698: } 17699: } 17700: 17701: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17702: 17703: /* zend_assign_to_variable() always takes care of op2, never free it! */ 17704: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17705: 17706: CHECK_EXCEPTION(); 17707: ZEND_VM_NEXT_OPCODE(); 17708: } 17709: 17710: static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17711: { 17712: USE_OPLINE 17713: zend_free_op free_op1, free_op2; 17714: zval **variable_ptr_ptr; 17715: zval **value_ptr_ptr; 17716: 17717: SAVE_OPLINE(); 17718: value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17719: 17720: if (IS_VAR == IS_VAR && 17721: value_ptr_ptr && 17722: !Z_ISREF_PP(value_ptr_ptr) && 17723: opline->extended_value == ZEND_RETURNS_FUNCTION && 17724: !EX_T(opline->op2.var).var.fcall_returned_reference) { 17725: if (free_op2.var == NULL) { 17726: PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ 17727: } 17728: zend_error(E_STRICT, "Only variables should be assigned by reference"); 17729: if (UNEXPECTED(EG(exception) != NULL)) { 17730: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17731: HANDLE_EXCEPTION(); 17732: } 17733: return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 17734: } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 17735: PZVAL_LOCK(*value_ptr_ptr); 17736: } 17737: if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { 17738: zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); 17739: } 17740: 17741: variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17742: if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || 17743: (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { 17744: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); 17745: } 17746: zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); 17747: 17748: if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 17749: Z_DELREF_PP(variable_ptr_ptr); 17750: } 17751: 17752: if (RETURN_VALUE_USED(opline)) { 17753: PZVAL_LOCK(*variable_ptr_ptr); 17754: AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr); 17755: } 17756: 17757: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17758: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17759: 17760: CHECK_EXCEPTION(); 17761: ZEND_VM_NEXT_OPCODE(); 17762: } 17763: 17764: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17765: { 17766: USE_OPLINE 17767: zval *function_name; 17768: char *function_name_strval; 17769: int function_name_strlen; 17770: zend_free_op free_op1, free_op2; 17771: 17772: SAVE_OPLINE(); 17773: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 17774: 17775: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17776: 17777: if (IS_VAR != IS_CONST && 17778: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 17779: zend_error_noreturn(E_ERROR, "Method name must be a string"); 17780: } 17781: 17782: function_name_strval = Z_STRVAL_P(function_name); 17783: function_name_strlen = Z_STRLEN_P(function_name); 17784: 17785: EX(object) = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17786: 17787: if (EXPECTED(EX(object) != NULL) && 17788: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 17789: EX(called_scope) = Z_OBJCE_P(EX(object)); 17790: 17791: if (IS_VAR != IS_CONST || 17792: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 17793: zval *object = EX(object); 17794: 17795: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 17796: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 17797: } 17798: 17799: /* First, locate the function. */ 17800: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 17801: if (UNEXPECTED(EX(fbc) == NULL)) { 17802: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 17803: } 17804: if (IS_VAR == IS_CONST && 17805: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 17806: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 17807: EXPECTED(EX(object) == object)) { 17808: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 17809: } 17810: } 17811: } else { 17812: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 17813: } 17814: 17815: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 17816: EX(object) = NULL; 17817: } else { 17818: if (!PZVAL_IS_REF(EX(object))) { 17819: Z_ADDREF_P(EX(object)); /* For $this pointer */ 17820: } else { 17821: zval *this_ptr; 17822: ALLOC_ZVAL(this_ptr); 17823: INIT_PZVAL_COPY(this_ptr, EX(object)); 17824: zval_copy_ctor(this_ptr); 17825: EX(object) = this_ptr; 17826: } 17827: } 17828: 17829: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17830: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 17831: 17832: CHECK_EXCEPTION(); 17833: ZEND_VM_NEXT_OPCODE(); 17834: } 17835: 17836: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17837: { 17838: USE_OPLINE 17839: zval *function_name; 17840: zend_class_entry *ce; 17841: 17842: SAVE_OPLINE(); 17843: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 17844: 17845: if (IS_VAR == IS_CONST) { 17846: /* no function found. try a static method in class */ 17847: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 17848: ce = CACHED_PTR(opline->op1.literal->cache_slot); 17849: } else { 17850: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 17851: if (UNEXPECTED(EG(exception) != NULL)) { 17852: HANDLE_EXCEPTION(); 17853: } 17854: if (UNEXPECTED(ce == NULL)) { 17855: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 17856: } 17857: CACHE_PTR(opline->op1.literal->cache_slot, ce); 17858: } 17859: EX(called_scope) = ce; 17860: } else { 17861: ce = EX_T(opline->op1.var).class_entry; 17862: 17863: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 17864: EX(called_scope) = EG(called_scope); 17865: } else { 17866: EX(called_scope) = ce; 17867: } 17868: } 17869: 17870: if (IS_VAR == IS_CONST && 17871: IS_VAR == IS_CONST && 17872: CACHED_PTR(opline->op2.literal->cache_slot)) { 17873: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 17874: } else if (IS_VAR != IS_CONST && 17875: IS_VAR == IS_CONST && 17876: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 17877: /* do nothing */ 17878: } else if (IS_VAR != IS_UNUSED) { 17879: char *function_name_strval = NULL; 17880: int function_name_strlen = 0; 17881: zend_free_op free_op2; 17882: 17883: if (IS_VAR == IS_CONST) { 17884: function_name_strval = Z_STRVAL_P(opline->op2.zv); 17885: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 17886: } else { 17887: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 17888: 17889: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 17890: zend_error_noreturn(E_ERROR, "Function name must be a string"); 17891: } else { 17892: function_name_strval = Z_STRVAL_P(function_name); 17893: function_name_strlen = Z_STRLEN_P(function_name); 17894: } 17895: } 17896: 17897: if (function_name_strval) { 17898: if (ce->get_static_method) { 17899: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 17900: } else { 17901: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 17902: } 17903: if (UNEXPECTED(EX(fbc) == NULL)) { 17904: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 17905: } 17906: if (IS_VAR == IS_CONST && 17907: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 17908: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 17909: if (IS_VAR == IS_CONST) { 17910: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 17911: } else { 17912: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 17913: } 17914: } 17915: } 17916: if (IS_VAR != IS_CONST) { 17917: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17918: } 17919: } else { 17920: if (UNEXPECTED(ce->constructor == NULL)) { 17921: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 17922: } 17923: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 17924: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 17925: } 17926: EX(fbc) = ce->constructor; 17927: } 17928: 17929: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 17930: EX(object) = NULL; 17931: } else { 17932: if (EG(This) && 17933: Z_OBJ_HT_P(EG(This))->get_class_entry && 17934: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 17935: /* We are calling method of the other (incompatible) class, 17936: but passing $this. This is done for compatibility with php-4. */ 17937: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 17938: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 17939: } else { 17940: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 17941: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 17942: } 17943: } 17944: if ((EX(object) = EG(This))) { 17945: Z_ADDREF_P(EX(object)); 17946: EX(called_scope) = Z_OBJCE_P(EX(object)); 17947: } 17948: } 17949: 17950: CHECK_EXCEPTION(); 17951: ZEND_VM_NEXT_OPCODE(); 17952: } 17953: 17954: static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17955: { 17956: USE_OPLINE 17957: zend_free_op free_op1, free_op2; 17958: 17959: SAVE_OPLINE(); 17960: if (IS_VAR==IS_VAR) { 17961: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 17962: } 17963: is_equal_function(&EX_T(opline->result.var).tmp_var, 17964: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 17965: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 17966: 17967: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 17968: CHECK_EXCEPTION(); 17969: ZEND_VM_NEXT_OPCODE(); 17970: } 17971: 17972: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 17973: { 17974: USE_OPLINE 17975: zend_free_op free_op1; 17976: zval *expr_ptr; 17977: 17978: SAVE_OPLINE(); 17979: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 17980: zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17981: 17982: if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 17983: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 17984: } 17985: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 17986: expr_ptr = *expr_ptr_ptr; 17987: Z_ADDREF_P(expr_ptr); 17988: } else { 17989: expr_ptr=_get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 17990: if (0) { /* temporary variable */ 17991: zval *new_expr; 17992: 17993: ALLOC_ZVAL(new_expr); 17994: INIT_PZVAL_COPY(new_expr, expr_ptr); 17995: expr_ptr = new_expr; 17996: } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 17997: zval *new_expr; 17998: 17999: ALLOC_ZVAL(new_expr); 18000: INIT_PZVAL_COPY(new_expr, expr_ptr); 18001: expr_ptr = new_expr; 18002: zendi_zval_copy_ctor(*expr_ptr); 18003: } else { 18004: Z_ADDREF_P(expr_ptr); 18005: } 18006: } 18007: 18008: if (IS_VAR != IS_UNUSED) { 18009: zend_free_op free_op2; 18010: zval *offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 18011: ulong hval; 18012: 18013: switch (Z_TYPE_P(offset)) { 18014: case IS_DOUBLE: 18015: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 18016: goto num_index; 18017: case IS_LONG: 18018: case IS_BOOL: 18019: hval = Z_LVAL_P(offset); 18020: num_index: 18021: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 18022: break; 18023: case IS_STRING: 18024: if (IS_VAR == IS_CONST) { 18025: hval = Z_HASH_P(offset); 18026: } else { 18027: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 18028: if (IS_INTERNED(Z_STRVAL_P(offset))) { 18029: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 18030: } else { 18031: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 18032: } 18033: } 18034: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 18035: break; 18036: case IS_NULL: 18037: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 18038: break; 18039: default: 18040: zend_error(E_WARNING, "Illegal offset type"); 18041: zval_ptr_dtor(&expr_ptr); 18042: /* do nothing */ 18043: break; 18044: } 18045: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18046: } else { 18047: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 18048: } 18049: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 18050: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18051: } else { 18052: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18053: } 18054: CHECK_EXCEPTION(); 18055: ZEND_VM_NEXT_OPCODE(); 18056: } 18057: 18058: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18059: { 18060: USE_OPLINE 18061: 18062: array_init(&EX_T(opline->result.var).tmp_var); 18063: if (IS_VAR == IS_UNUSED) { 18064: ZEND_VM_NEXT_OPCODE(); 18065: #if 0 || IS_VAR != IS_UNUSED 18066: } else { 18067: return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18068: #endif 18069: } 18070: } 18071: 18072: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18073: { 18074: USE_OPLINE 18075: zval tmp, *varname; 18076: HashTable *target_symbol_table; 18077: zend_free_op free_op1; 18078: 18079: SAVE_OPLINE(); 18080: if (IS_VAR == IS_CV && 18081: IS_VAR == IS_UNUSED && 18082: (opline->extended_value & ZEND_QUICK_SET)) { 18083: if (EG(active_symbol_table)) { 18084: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 18085: 18086: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 18087: EX_CV(opline->op1.var) = NULL; 18088: } else if (EX_CV(opline->op1.var)) { 18089: zval_ptr_dtor(EX_CV(opline->op1.var)); 18090: EX_CV(opline->op1.var) = NULL; 18091: } 18092: CHECK_EXCEPTION(); 18093: ZEND_VM_NEXT_OPCODE(); 18094: } 18095: 18096: varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18097: 18098: if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 18099: ZVAL_COPY_VALUE(&tmp, varname); 18100: zval_copy_ctor(&tmp); 18101: convert_to_string(&tmp); 18102: varname = &tmp; 18103: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 18104: Z_ADDREF_P(varname); 18105: } 18106: 18107: if (IS_VAR != IS_UNUSED) { 18108: zend_class_entry *ce; 18109: 18110: if (IS_VAR == IS_CONST) { 18111: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 18112: ce = CACHED_PTR(opline->op2.literal->cache_slot); 18113: } else { 18114: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 18115: if (UNEXPECTED(EG(exception) != NULL)) { 18116: if (IS_VAR != IS_CONST && varname == &tmp) { 18117: zval_dtor(&tmp); 18118: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 18119: zval_ptr_dtor(&varname); 18120: } 18121: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18122: HANDLE_EXCEPTION(); 18123: } 18124: if (UNEXPECTED(ce == NULL)) { 18125: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 18126: } 18127: CACHE_PTR(opline->op2.literal->cache_slot, ce); 18128: } 18129: } else { 18130: ce = EX_T(opline->op2.var).class_entry; 18131: } 18132: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 18133: } else { 18134: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 18135: 18136: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 18137: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 18138: } 18139: 18140: if (IS_VAR != IS_CONST && varname == &tmp) { 18141: zval_dtor(&tmp); 18142: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 18143: zval_ptr_dtor(&varname); 18144: } 18145: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18146: CHECK_EXCEPTION(); 18147: ZEND_VM_NEXT_OPCODE(); 18148: } 18149: 18150: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18151: { 18152: USE_OPLINE 18153: zend_free_op free_op1, free_op2; 18154: zval **container; 18155: zval *offset; 18156: ulong hval; 18157: 18158: SAVE_OPLINE(); 18159: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18160: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 18161: SEPARATE_ZVAL_IF_NOT_REF(container); 18162: } 18163: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 18164: 18165: if (IS_VAR != IS_VAR || container) { 18166: switch (Z_TYPE_PP(container)) { 18167: case IS_ARRAY: { 18168: HashTable *ht = Z_ARRVAL_PP(container); 18169: 18170: switch (Z_TYPE_P(offset)) { 18171: case IS_DOUBLE: 18172: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 18173: zend_hash_index_del(ht, hval); 18174: break; 18175: case IS_RESOURCE: 18176: case IS_BOOL: 18177: case IS_LONG: 18178: hval = Z_LVAL_P(offset); 18179: zend_hash_index_del(ht, hval); 18180: break; 18181: case IS_STRING: 18182: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 18183: Z_ADDREF_P(offset); 18184: } 18185: if (IS_VAR == IS_CONST) { 18186: hval = Z_HASH_P(offset); 18187: } else { 18188: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 18189: if (IS_INTERNED(Z_STRVAL_P(offset))) { 18190: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 18191: } else { 18192: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 18193: } 18194: } 18195: if (ht == &EG(symbol_table)) { 18196: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 18197: } else { 18198: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 18199: } 18200: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 18201: zval_ptr_dtor(&offset); 18202: } 18203: break; 18204: num_index_dim: 18205: zend_hash_index_del(ht, hval); 18206: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 18207: zval_ptr_dtor(&offset); 18208: } 18209: break; 18210: case IS_NULL: 18211: zend_hash_del(ht, "", sizeof("")); 18212: break; 18213: default: 18214: zend_error(E_WARNING, "Illegal offset type in unset"); 18215: break; 18216: } 18217: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18218: break; 18219: } 18220: case IS_OBJECT: 18221: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 18222: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 18223: } 18224: if (0) { 18225: MAKE_REAL_ZVAL_PTR(offset); 18226: } 18227: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 18228: if (0) { 18229: zval_ptr_dtor(&offset); 18230: } else { 18231: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18232: } 18233: break; 18234: case IS_STRING: 18235: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 18236: ZEND_VM_CONTINUE(); /* bailed out before */ 18237: default: 18238: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18239: break; 18240: } 18241: } else { 18242: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18243: } 18244: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18245: 18246: CHECK_EXCEPTION(); 18247: ZEND_VM_NEXT_OPCODE(); 18248: } 18249: 18250: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18251: { 18252: USE_OPLINE 18253: zend_free_op free_op1, free_op2; 18254: zval **container; 18255: zval *offset; 18256: 18257: SAVE_OPLINE(); 18258: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18259: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 18260: 18261: if (IS_VAR != IS_VAR || container) { 18262: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 18263: SEPARATE_ZVAL_IF_NOT_REF(container); 18264: } 18265: if (Z_TYPE_PP(container) == IS_OBJECT) { 18266: if (0) { 18267: MAKE_REAL_ZVAL_PTR(offset); 18268: } 18269: if (Z_OBJ_HT_P(*container)->unset_property) { 18270: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 18271: } else { 18272: zend_error(E_NOTICE, "Trying to unset property of non-object"); 18273: } 18274: if (0) { 18275: zval_ptr_dtor(&offset); 18276: } else { 18277: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18278: } 18279: } else { 18280: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18281: } 18282: } else { 18283: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18284: } 18285: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18286: 18287: CHECK_EXCEPTION(); 18288: ZEND_VM_NEXT_OPCODE(); 18289: } 18290: 18291: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18292: { 18293: USE_OPLINE 18294: zval **value; 18295: zend_bool isset = 1; 18296: 18297: SAVE_OPLINE(); 18298: if (IS_VAR == IS_CV && 18299: IS_VAR == IS_UNUSED && 18300: (opline->extended_value & ZEND_QUICK_SET)) { 18301: if (EX_CV(opline->op1.var)) { 18302: value = EX_CV(opline->op1.var); 18303: } else if (EG(active_symbol_table)) { 18304: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 18305: 18306: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 18307: isset = 0; 18308: } 18309: } else { 18310: isset = 0; 18311: } 18312: } else { 18313: HashTable *target_symbol_table; 18314: zend_free_op free_op1; 18315: zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18316: 18317: if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 18318: ZVAL_COPY_VALUE(&tmp, varname); 18319: zval_copy_ctor(&tmp); 18320: convert_to_string(&tmp); 18321: varname = &tmp; 18322: } 18323: 18324: if (IS_VAR != IS_UNUSED) { 18325: zend_class_entry *ce; 18326: 18327: if (IS_VAR == IS_CONST) { 18328: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 18329: ce = CACHED_PTR(opline->op2.literal->cache_slot); 18330: } else { 18331: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 18332: if (UNEXPECTED(ce == NULL)) { 18333: CHECK_EXCEPTION(); 18334: ZEND_VM_NEXT_OPCODE(); 18335: } 18336: CACHE_PTR(opline->op2.literal->cache_slot, ce); 18337: } 18338: } else { 18339: ce = EX_T(opline->op2.var).class_entry; 18340: } 18341: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 18342: if (!value) { 18343: isset = 0; 18344: } 18345: } else { 18346: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 18347: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 18348: isset = 0; 18349: } 18350: } 18351: 18352: if (IS_VAR != IS_CONST && varname == &tmp) { 18353: zval_dtor(&tmp); 18354: } 18355: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18356: } 18357: 18358: if (opline->extended_value & ZEND_ISSET) { 18359: if (isset && Z_TYPE_PP(value) != IS_NULL) { 18360: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 18361: } else { 18362: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 18363: } 18364: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 18365: if (!isset || !i_zend_is_true(*value)) { 18366: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 18367: } else { 18368: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 18369: } 18370: } 18371: 18372: CHECK_EXCEPTION(); 18373: ZEND_VM_NEXT_OPCODE(); 18374: } 18375: 18376: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 18377: { 18378: USE_OPLINE 18379: zend_free_op free_op1, free_op2; 18380: zval **container; 18381: zval **value = NULL; 18382: int result = 0; 18383: ulong hval; 18384: zval *offset; 18385: 18386: SAVE_OPLINE(); 18387: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18388: 18389: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 18390: 18391: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 18392: HashTable *ht; 18393: int isset = 0; 18394: 18395: ht = Z_ARRVAL_PP(container); 18396: 18397: switch (Z_TYPE_P(offset)) { 18398: case IS_DOUBLE: 18399: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 18400: goto num_index_prop; 18401: case IS_RESOURCE: 18402: case IS_BOOL: 18403: case IS_LONG: 18404: hval = Z_LVAL_P(offset); 18405: num_index_prop: 18406: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 18407: isset = 1; 18408: } 18409: break; 18410: case IS_STRING: 18411: if (IS_VAR == IS_CONST) { 18412: hval = Z_HASH_P(offset); 18413: } else { 18414: if (!prop_dim) { 18415: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 18416: } 18417: if (IS_INTERNED(Z_STRVAL_P(offset))) { 18418: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 18419: } else { 18420: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 18421: } 18422: } 18423: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 18424: isset = 1; 18425: } 18426: break; 18427: case IS_NULL: 18428: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 18429: isset = 1; 18430: } 18431: break; 18432: default: 18433: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 18434: break; 18435: } 18436: 18437: if (opline->extended_value & ZEND_ISSET) { 18438: if (isset && Z_TYPE_PP(value) == IS_NULL) { 18439: result = 0; 18440: } else { 18441: result = isset; 18442: } 18443: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 18444: if (!isset || !i_zend_is_true(*value)) { 18445: result = 0; 18446: } else { 18447: result = 1; 18448: } 18449: } 18450: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18451: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 18452: if (0) { 18453: MAKE_REAL_ZVAL_PTR(offset); 18454: } 18455: if (prop_dim) { 18456: if (Z_OBJ_HT_P(*container)->has_property) { 18457: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 18458: } else { 18459: zend_error(E_NOTICE, "Trying to check property of non-object"); 18460: result = 0; 18461: } 18462: } else { 18463: if (Z_OBJ_HT_P(*container)->has_dimension) { 18464: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 18465: } else { 18466: zend_error(E_NOTICE, "Trying to check element of non-array"); 18467: result = 0; 18468: } 18469: } 18470: if (0) { 18471: zval_ptr_dtor(&offset); 18472: } else { 18473: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18474: } 18475: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 18476: zval tmp; 18477: 18478: if (Z_TYPE_P(offset) != IS_LONG) { 18479: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 18480: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 18481: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 18482: ZVAL_COPY_VALUE(&tmp, offset); 18483: zval_copy_ctor(&tmp); 18484: convert_to_long(&tmp); 18485: offset = &tmp; 18486: } else { 18487: /* can not be converted to proper offset, return "not set" */ 18488: result = 0; 18489: } 18490: } 18491: if (Z_TYPE_P(offset) == IS_LONG) { 18492: if (opline->extended_value & ZEND_ISSET) { 18493: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 18494: result = 1; 18495: } 18496: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 18497: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 18498: result = 1; 18499: } 18500: } 18501: } 18502: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18503: } else { 18504: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 18505: } 18506: 18507: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 18508: if (opline->extended_value & ZEND_ISSET) { 18509: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 18510: } else { 18511: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 18512: } 18513: 18514: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18515: 18516: CHECK_EXCEPTION(); 18517: ZEND_VM_NEXT_OPCODE(); 18518: } 18519: 18520: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18521: { 18522: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18523: } 18524: 18525: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18526: { 18527: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18528: } 18529: 18530: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 18531: { 18532: USE_OPLINE 18533: zend_free_op free_op1, free_op_data1; 18534: zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18535: zval *object; 18536: zval *property = NULL; 18537: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 18538: int have_get_ptr = 0; 18539: 18540: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 18541: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 18542: } 18543: 18544: make_real_object(object_ptr TSRMLS_CC); 18545: object = *object_ptr; 18546: 18547: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 18548: zend_error(E_WARNING, "Attempt to assign property of non-object"); 18549: 18550: FREE_OP(free_op_data1); 18551: 18552: if (RETURN_VALUE_USED(opline)) { 18553: PZVAL_LOCK(&EG(uninitialized_zval)); 18554: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 18555: EX_T(opline->result.var).var.ptr_ptr = NULL; 18556: } 18557: } else { 18558: /* here we are sure we are dealing with an object */ 18559: if (0) { 18560: MAKE_REAL_ZVAL_PTR(property); 18561: } 18562: 18563: /* here property is a string */ 18564: if (opline->extended_value == ZEND_ASSIGN_OBJ 18565: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 18566: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 18567: if (zptr != NULL) { /* NULL means no success in getting PTR */ 18568: SEPARATE_ZVAL_IF_NOT_REF(zptr); 18569: 18570: have_get_ptr = 1; 18571: binary_op(*zptr, *zptr, value TSRMLS_CC); 18572: if (RETURN_VALUE_USED(opline)) { 18573: PZVAL_LOCK(*zptr); 18574: EX_T(opline->result.var).var.ptr = *zptr; 18575: EX_T(opline->result.var).var.ptr_ptr = NULL; 18576: } 18577: } 18578: } 18579: 18580: if (!have_get_ptr) { 18581: zval *z = NULL; 18582: 18583: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 18584: if (Z_OBJ_HT_P(object)->read_property) { 18585: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 18586: } 18587: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 18588: if (Z_OBJ_HT_P(object)->read_dimension) { 18589: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 18590: } 18591: } 18592: if (z) { 18593: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 18594: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 18595: 18596: if (Z_REFCOUNT_P(z) == 0) { 18597: GC_REMOVE_ZVAL_FROM_BUFFER(z); 18598: zval_dtor(z); 18599: FREE_ZVAL(z); 18600: } 18601: z = value; 18602: } 18603: Z_ADDREF_P(z); 18604: SEPARATE_ZVAL_IF_NOT_REF(&z); 18605: binary_op(z, z, value TSRMLS_CC); 18606: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 18607: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 18608: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 18609: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 18610: } 18611: if (RETURN_VALUE_USED(opline)) { 18612: PZVAL_LOCK(z); 18613: EX_T(opline->result.var).var.ptr = z; 18614: EX_T(opline->result.var).var.ptr_ptr = NULL; 18615: } 18616: zval_ptr_dtor(&z); 18617: } else { 18618: zend_error(E_WARNING, "Attempt to assign property of non-object"); 18619: if (RETURN_VALUE_USED(opline)) { 18620: PZVAL_LOCK(&EG(uninitialized_zval)); 18621: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 18622: EX_T(opline->result.var).var.ptr_ptr = NULL; 18623: } 18624: } 18625: } 18626: 18627: if (0) { 18628: zval_ptr_dtor(&property); 18629: } else { 18630: 18631: } 18632: FREE_OP(free_op_data1); 18633: } 18634: 18635: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18636: /* assign_obj has two opcodes! */ 18637: CHECK_EXCEPTION(); 18638: ZEND_VM_INC_OPCODE(); 18639: ZEND_VM_NEXT_OPCODE(); 18640: } 18641: 18642: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 18643: { 18644: USE_OPLINE 18645: zend_free_op free_op1, free_op_data2, free_op_data1; 18646: zval **var_ptr; 18647: zval *value; 18648: 18649: SAVE_OPLINE(); 18650: switch (opline->extended_value) { 18651: case ZEND_ASSIGN_OBJ: 18652: return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18653: break; 18654: case ZEND_ASSIGN_DIM: { 18655: zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18656: 18657: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 18658: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 18659: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 18660: if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { 18661: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 18662: } 18663: return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18664: } else { 18665: zval *dim = NULL; 18666: 18667: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC); 18668: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 18669: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 18670: } 18671: } 18672: break; 18673: default: 18674: value = NULL; 18675: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18676: /* do nothing */ 18677: break; 18678: } 18679: 18680: if (UNEXPECTED(var_ptr == NULL)) { 18681: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 18682: } 18683: 18684: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 18685: if (RETURN_VALUE_USED(opline)) { 18686: PZVAL_LOCK(&EG(uninitialized_zval)); 18687: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 18688: } 18689: 18690: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18691: CHECK_EXCEPTION(); 18692: if (opline->extended_value == ZEND_ASSIGN_DIM) { 18693: ZEND_VM_INC_OPCODE(); 18694: } 18695: ZEND_VM_NEXT_OPCODE(); 18696: } 18697: 18698: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 18699: 18700: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 18701: && Z_OBJ_HANDLER_PP(var_ptr, get) 18702: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 18703: /* proxy object */ 18704: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 18705: Z_ADDREF_P(objval); 18706: binary_op(objval, objval, value TSRMLS_CC); 18707: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 18708: zval_ptr_dtor(&objval); 18709: } else { 18710: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 18711: } 18712: 18713: if (RETURN_VALUE_USED(opline)) { 18714: PZVAL_LOCK(*var_ptr); 18715: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 18716: } 18717: 18718: if (opline->extended_value == ZEND_ASSIGN_DIM) { 18719: FREE_OP(free_op_data1); 18720: FREE_OP_VAR_PTR(free_op_data2); 18721: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18722: CHECK_EXCEPTION(); 18723: ZEND_VM_INC_OPCODE(); 18724: } else { 18725: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18726: CHECK_EXCEPTION(); 18727: } 18728: ZEND_VM_NEXT_OPCODE(); 18729: } 18730: 18731: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18732: { 18733: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18734: } 18735: 18736: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18737: { 18738: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18739: } 18740: 18741: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18742: { 18743: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18744: } 18745: 18746: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18747: { 18748: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18749: } 18750: 18751: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18752: { 18753: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18754: } 18755: 18756: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18757: { 18758: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18759: } 18760: 18761: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18762: { 18763: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18764: } 18765: 18766: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18767: { 18768: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18769: } 18770: 18771: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18772: { 18773: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18774: } 18775: 18776: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18777: { 18778: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18779: } 18780: 18781: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18782: { 18783: return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18784: } 18785: 18786: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) 18787: { 18788: USE_OPLINE 18789: zend_free_op free_op1; 18790: zval *varname; 18791: zval **retval; 18792: zval tmp_varname; 18793: HashTable *target_symbol_table; 18794: ulong hash_value; 18795: 18796: SAVE_OPLINE(); 18797: varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18798: 18799: if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 18800: ZVAL_COPY_VALUE(&tmp_varname, varname); 18801: zval_copy_ctor(&tmp_varname); 18802: Z_SET_REFCOUNT(tmp_varname, 1); 18803: Z_UNSET_ISREF(tmp_varname); 18804: convert_to_string(&tmp_varname); 18805: varname = &tmp_varname; 18806: } 18807: 18808: if (IS_UNUSED != IS_UNUSED) { 18809: zend_class_entry *ce; 18810: 18811: if (IS_UNUSED == IS_CONST) { 18812: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 18813: ce = CACHED_PTR(opline->op2.literal->cache_slot); 18814: } else { 18815: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 18816: if (UNEXPECTED(ce == NULL)) { 18817: if (IS_VAR != IS_CONST && varname == &tmp_varname) { 18818: zval_dtor(&tmp_varname); 18819: } 18820: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18821: CHECK_EXCEPTION(); 18822: ZEND_VM_NEXT_OPCODE(); 18823: } 18824: CACHE_PTR(opline->op2.literal->cache_slot, ce); 18825: } 18826: } else { 18827: ce = EX_T(opline->op2.var).class_entry; 18828: } 18829: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 18830: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18831: } else { 18832: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 18833: /* 18834: if (!target_symbol_table) { 18835: CHECK_EXCEPTION(); 18836: ZEND_VM_NEXT_OPCODE(); 18837: } 18838: */ 18839: if (IS_VAR == IS_CONST) { 18840: hash_value = Z_HASH_P(varname); 18841: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 18842: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 18843: } else { 18844: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 18845: } 18846: 18847: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 18848: switch (type) { 18849: case BP_VAR_R: 18850: case BP_VAR_UNSET: 18851: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 18852: /* break missing intentionally */ 18853: case BP_VAR_IS: 18854: retval = &EG(uninitialized_zval_ptr); 18855: break; 18856: case BP_VAR_RW: 18857: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 18858: /* break missing intentionally */ 18859: case BP_VAR_W: 18860: Z_ADDREF_P(&EG(uninitialized_zval)); 18861: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 18862: break; 18863: EMPTY_SWITCH_DEFAULT_CASE() 18864: } 18865: } 18866: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 18867: case ZEND_FETCH_GLOBAL: 18868: if (IS_VAR != IS_TMP_VAR) { 18869: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18870: } 18871: break; 18872: case ZEND_FETCH_LOCAL: 18873: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18874: break; 18875: case ZEND_FETCH_STATIC: 18876: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 18877: break; 18878: case ZEND_FETCH_GLOBAL_LOCK: 18879: if (IS_VAR == IS_VAR && !free_op1.var) { 18880: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 18881: } 18882: break; 18883: } 18884: } 18885: 18886: 18887: if (IS_VAR != IS_CONST && varname == &tmp_varname) { 18888: zval_dtor(&tmp_varname); 18889: } 18890: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 18891: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 18892: } 18893: PZVAL_LOCK(*retval); 18894: switch (type) { 18895: case BP_VAR_R: 18896: case BP_VAR_IS: 18897: AI_SET_PTR(&EX_T(opline->result.var), *retval); 18898: break; 18899: case BP_VAR_UNSET: { 18900: zend_free_op free_res; 18901: 18902: PZVAL_UNLOCK(*retval, &free_res); 18903: if (retval != &EG(uninitialized_zval_ptr)) { 18904: SEPARATE_ZVAL_IF_NOT_REF(retval); 18905: } 18906: PZVAL_LOCK(*retval); 18907: FREE_OP_VAR_PTR(free_res); 18908: } 18909: /* break missing intentionally */ 18910: default: 18911: EX_T(opline->result.var).var.ptr_ptr = retval; 18912: break; 18913: } 18914: CHECK_EXCEPTION(); 18915: ZEND_VM_NEXT_OPCODE(); 18916: } 18917: 18918: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18919: { 18920: return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18921: } 18922: 18923: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18924: { 18925: return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18926: } 18927: 18928: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18929: { 18930: return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18931: } 18932: 18933: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18934: { 18935: USE_OPLINE 18936: 18937: return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18938: } 18939: 18940: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18941: { 18942: return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18943: } 18944: 18945: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18946: { 18947: return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 18948: } 18949: 18950: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18951: { 18952: USE_OPLINE 18953: zend_free_op free_op1; 18954: zval **container; 18955: 18956: SAVE_OPLINE(); 18957: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18958: 18959: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 18960: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 18961: } 18962: zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); 18963: 18964: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 18965: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 18966: } 18967: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 18968: 18969: /* We are going to assign the result by reference */ 18970: if (UNEXPECTED(opline->extended_value != 0)) { 18971: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 18972: 18973: if (retval_ptr) { 18974: Z_DELREF_PP(retval_ptr); 18975: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 18976: Z_ADDREF_PP(retval_ptr); 18977: } 18978: } 18979: 18980: CHECK_EXCEPTION(); 18981: ZEND_VM_NEXT_OPCODE(); 18982: } 18983: 18984: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 18985: { 18986: USE_OPLINE 18987: zend_free_op free_op1; 18988: zval **container; 18989: 18990: SAVE_OPLINE(); 18991: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 18992: 18993: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 18994: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 18995: } 18996: zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC); 18997: 18998: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 18999: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 19000: } 19001: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19002: CHECK_EXCEPTION(); 19003: ZEND_VM_NEXT_OPCODE(); 19004: } 19005: 19006: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19007: { 19008: USE_OPLINE 19009: zend_free_op free_op1; 19010: zval **container; 19011: 19012: SAVE_OPLINE(); 19013: 19014: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 19015: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19016: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 19017: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 19018: } 19019: zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); 19020: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 19021: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 19022: } 19023: } else { 19024: if (IS_UNUSED == IS_UNUSED) { 19025: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 19026: } 19027: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19028: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC); 19029: } 19030: 19031: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19032: CHECK_EXCEPTION(); 19033: ZEND_VM_NEXT_OPCODE(); 19034: } 19035: 19036: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19037: { 19038: USE_OPLINE 19039: zend_free_op free_op1; 19040: zval **object_ptr; 19041: 19042: SAVE_OPLINE(); 19043: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19044: 19045: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 19046: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 19047: } 19048: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 19049: 19050: zval *property_name = NULL; 19051: 19052: if (0) { 19053: MAKE_REAL_ZVAL_PTR(property_name); 19054: } 19055: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 19056: if (0) { 19057: zval_ptr_dtor(&property_name); 19058: } else { 19059: 19060: } 19061: } else { 19062: zend_free_op free_op_data1, free_op_data2; 19063: zval *value; 19064: zval *dim = NULL; 19065: zval **variable_ptr_ptr; 19066: 19067: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC); 19068: 19069: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 19070: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 19071: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 19072: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 19073: if (RETURN_VALUE_USED(opline)) { 19074: zval *retval; 19075: 19076: ALLOC_ZVAL(retval); 19077: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 19078: INIT_PZVAL(retval); 19079: AI_SET_PTR(&EX_T(opline->result.var), retval); 19080: } 19081: } else if (RETURN_VALUE_USED(opline)) { 19082: PZVAL_LOCK(&EG(uninitialized_zval)); 19083: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 19084: } 19085: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 19086: if (IS_TMP_FREE(free_op_data1)) { 19087: zval_dtor(value); 19088: } 19089: if (RETURN_VALUE_USED(opline)) { 19090: PZVAL_LOCK(&EG(uninitialized_zval)); 19091: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 19092: } 19093: } else { 19094: if ((opline+1)->op1_type == IS_TMP_VAR) { 19095: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 19096: } else if ((opline+1)->op1_type == IS_CONST) { 19097: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 19098: } else { 19099: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 19100: } 19101: if (RETURN_VALUE_USED(opline)) { 19102: PZVAL_LOCK(value); 19103: AI_SET_PTR(&EX_T(opline->result.var), value); 19104: } 19105: } 19106: FREE_OP_VAR_PTR(free_op_data2); 19107: FREE_OP_IF_VAR(free_op_data1); 19108: } 19109: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19110: /* assign_dim has two opcodes! */ 19111: CHECK_EXCEPTION(); 19112: ZEND_VM_INC_OPCODE(); 19113: ZEND_VM_NEXT_OPCODE(); 19114: } 19115: 19116: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19117: { 19118: USE_OPLINE 19119: zval *function_name; 19120: zend_class_entry *ce; 19121: 19122: SAVE_OPLINE(); 19123: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 19124: 19125: if (IS_VAR == IS_CONST) { 19126: /* no function found. try a static method in class */ 19127: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 19128: ce = CACHED_PTR(opline->op1.literal->cache_slot); 19129: } else { 19130: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 19131: if (UNEXPECTED(EG(exception) != NULL)) { 19132: HANDLE_EXCEPTION(); 19133: } 19134: if (UNEXPECTED(ce == NULL)) { 19135: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 19136: } 19137: CACHE_PTR(opline->op1.literal->cache_slot, ce); 19138: } 19139: EX(called_scope) = ce; 19140: } else { 19141: ce = EX_T(opline->op1.var).class_entry; 19142: 19143: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 19144: EX(called_scope) = EG(called_scope); 19145: } else { 19146: EX(called_scope) = ce; 19147: } 19148: } 19149: 19150: if (IS_VAR == IS_CONST && 19151: IS_UNUSED == IS_CONST && 19152: CACHED_PTR(opline->op2.literal->cache_slot)) { 19153: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 19154: } else if (IS_VAR != IS_CONST && 19155: IS_UNUSED == IS_CONST && 19156: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 19157: /* do nothing */ 19158: } else if (IS_UNUSED != IS_UNUSED) { 19159: char *function_name_strval = NULL; 19160: int function_name_strlen = 0; 19161: 19162: 19163: if (IS_UNUSED == IS_CONST) { 19164: function_name_strval = Z_STRVAL_P(opline->op2.zv); 19165: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 19166: } else { 19167: function_name = NULL; 19168: 19169: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 19170: zend_error_noreturn(E_ERROR, "Function name must be a string"); 19171: } else { 19172: function_name_strval = Z_STRVAL_P(function_name); 19173: function_name_strlen = Z_STRLEN_P(function_name); 19174: } 19175: } 19176: 19177: if (function_name_strval) { 19178: if (ce->get_static_method) { 19179: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 19180: } else { 19181: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 19182: } 19183: if (UNEXPECTED(EX(fbc) == NULL)) { 19184: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 19185: } 19186: if (IS_UNUSED == IS_CONST && 19187: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 19188: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 19189: if (IS_VAR == IS_CONST) { 19190: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 19191: } else { 19192: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 19193: } 19194: } 19195: } 19196: if (IS_UNUSED != IS_CONST) { 19197: 19198: } 19199: } else { 19200: if (UNEXPECTED(ce->constructor == NULL)) { 19201: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 19202: } 19203: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 19204: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 19205: } 19206: EX(fbc) = ce->constructor; 19207: } 19208: 19209: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 19210: EX(object) = NULL; 19211: } else { 19212: if (EG(This) && 19213: Z_OBJ_HT_P(EG(This))->get_class_entry && 19214: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 19215: /* We are calling method of the other (incompatible) class, 19216: but passing $this. This is done for compatibility with php-4. */ 19217: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 19218: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 19219: } else { 19220: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 19221: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 19222: } 19223: } 19224: if ((EX(object) = EG(This))) { 19225: Z_ADDREF_P(EX(object)); 19226: EX(called_scope) = Z_OBJCE_P(EX(object)); 19227: } 19228: } 19229: 19230: CHECK_EXCEPTION(); 19231: ZEND_VM_NEXT_OPCODE(); 19232: } 19233: 19234: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19235: { 19236: USE_OPLINE 19237: zend_free_op free_op1; 19238: zval *expr_ptr; 19239: 19240: SAVE_OPLINE(); 19241: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 19242: zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19243: 19244: if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 19245: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 19246: } 19247: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 19248: expr_ptr = *expr_ptr_ptr; 19249: Z_ADDREF_P(expr_ptr); 19250: } else { 19251: expr_ptr=_get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19252: if (0) { /* temporary variable */ 19253: zval *new_expr; 19254: 19255: ALLOC_ZVAL(new_expr); 19256: INIT_PZVAL_COPY(new_expr, expr_ptr); 19257: expr_ptr = new_expr; 19258: } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 19259: zval *new_expr; 19260: 19261: ALLOC_ZVAL(new_expr); 19262: INIT_PZVAL_COPY(new_expr, expr_ptr); 19263: expr_ptr = new_expr; 19264: zendi_zval_copy_ctor(*expr_ptr); 19265: } else { 19266: Z_ADDREF_P(expr_ptr); 19267: } 19268: } 19269: 19270: if (IS_UNUSED != IS_UNUSED) { 19271: 19272: zval *offset = NULL; 19273: ulong hval; 19274: 19275: switch (Z_TYPE_P(offset)) { 19276: case IS_DOUBLE: 19277: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 19278: goto num_index; 19279: case IS_LONG: 19280: case IS_BOOL: 19281: hval = Z_LVAL_P(offset); 19282: num_index: 19283: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 19284: break; 19285: case IS_STRING: 19286: if (IS_UNUSED == IS_CONST) { 19287: hval = Z_HASH_P(offset); 19288: } else { 19289: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 19290: if (IS_INTERNED(Z_STRVAL_P(offset))) { 19291: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 19292: } else { 19293: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 19294: } 19295: } 19296: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 19297: break; 19298: case IS_NULL: 19299: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 19300: break; 19301: default: 19302: zend_error(E_WARNING, "Illegal offset type"); 19303: zval_ptr_dtor(&expr_ptr); 19304: /* do nothing */ 19305: break; 19306: } 19307: 19308: } else { 19309: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 19310: } 19311: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 19312: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19313: } else { 19314: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19315: } 19316: CHECK_EXCEPTION(); 19317: ZEND_VM_NEXT_OPCODE(); 19318: } 19319: 19320: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19321: { 19322: USE_OPLINE 19323: 19324: array_init(&EX_T(opline->result.var).tmp_var); 19325: if (IS_VAR == IS_UNUSED) { 19326: ZEND_VM_NEXT_OPCODE(); 19327: #if 0 || IS_VAR != IS_UNUSED 19328: } else { 19329: return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 19330: #endif 19331: } 19332: } 19333: 19334: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19335: { 19336: USE_OPLINE 19337: zval tmp, *varname; 19338: HashTable *target_symbol_table; 19339: zend_free_op free_op1; 19340: 19341: SAVE_OPLINE(); 19342: if (IS_VAR == IS_CV && 19343: IS_UNUSED == IS_UNUSED && 19344: (opline->extended_value & ZEND_QUICK_SET)) { 19345: if (EG(active_symbol_table)) { 19346: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 19347: 19348: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 19349: EX_CV(opline->op1.var) = NULL; 19350: } else if (EX_CV(opline->op1.var)) { 19351: zval_ptr_dtor(EX_CV(opline->op1.var)); 19352: EX_CV(opline->op1.var) = NULL; 19353: } 19354: CHECK_EXCEPTION(); 19355: ZEND_VM_NEXT_OPCODE(); 19356: } 19357: 19358: varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19359: 19360: if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 19361: ZVAL_COPY_VALUE(&tmp, varname); 19362: zval_copy_ctor(&tmp); 19363: convert_to_string(&tmp); 19364: varname = &tmp; 19365: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 19366: Z_ADDREF_P(varname); 19367: } 19368: 19369: if (IS_UNUSED != IS_UNUSED) { 19370: zend_class_entry *ce; 19371: 19372: if (IS_UNUSED == IS_CONST) { 19373: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 19374: ce = CACHED_PTR(opline->op2.literal->cache_slot); 19375: } else { 19376: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 19377: if (UNEXPECTED(EG(exception) != NULL)) { 19378: if (IS_VAR != IS_CONST && varname == &tmp) { 19379: zval_dtor(&tmp); 19380: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 19381: zval_ptr_dtor(&varname); 19382: } 19383: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19384: HANDLE_EXCEPTION(); 19385: } 19386: if (UNEXPECTED(ce == NULL)) { 19387: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 19388: } 19389: CACHE_PTR(opline->op2.literal->cache_slot, ce); 19390: } 19391: } else { 19392: ce = EX_T(opline->op2.var).class_entry; 19393: } 19394: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 19395: } else { 19396: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 19397: 19398: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 19399: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 19400: } 19401: 19402: if (IS_VAR != IS_CONST && varname == &tmp) { 19403: zval_dtor(&tmp); 19404: } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { 19405: zval_ptr_dtor(&varname); 19406: } 19407: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19408: CHECK_EXCEPTION(); 19409: ZEND_VM_NEXT_OPCODE(); 19410: } 19411: 19412: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19413: { 19414: USE_OPLINE 19415: zval **value; 19416: zend_bool isset = 1; 19417: 19418: SAVE_OPLINE(); 19419: if (IS_VAR == IS_CV && 19420: IS_UNUSED == IS_UNUSED && 19421: (opline->extended_value & ZEND_QUICK_SET)) { 19422: if (EX_CV(opline->op1.var)) { 19423: value = EX_CV(opline->op1.var); 19424: } else if (EG(active_symbol_table)) { 19425: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 19426: 19427: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 19428: isset = 0; 19429: } 19430: } else { 19431: isset = 0; 19432: } 19433: } else { 19434: HashTable *target_symbol_table; 19435: zend_free_op free_op1; 19436: zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19437: 19438: if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 19439: ZVAL_COPY_VALUE(&tmp, varname); 19440: zval_copy_ctor(&tmp); 19441: convert_to_string(&tmp); 19442: varname = &tmp; 19443: } 19444: 19445: if (IS_UNUSED != IS_UNUSED) { 19446: zend_class_entry *ce; 19447: 19448: if (IS_UNUSED == IS_CONST) { 19449: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 19450: ce = CACHED_PTR(opline->op2.literal->cache_slot); 19451: } else { 19452: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 19453: if (UNEXPECTED(ce == NULL)) { 19454: CHECK_EXCEPTION(); 19455: ZEND_VM_NEXT_OPCODE(); 19456: } 19457: CACHE_PTR(opline->op2.literal->cache_slot, ce); 19458: } 19459: } else { 19460: ce = EX_T(opline->op2.var).class_entry; 19461: } 19462: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 19463: if (!value) { 19464: isset = 0; 19465: } 19466: } else { 19467: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 19468: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 19469: isset = 0; 19470: } 19471: } 19472: 19473: if (IS_VAR != IS_CONST && varname == &tmp) { 19474: zval_dtor(&tmp); 19475: } 19476: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19477: } 19478: 19479: if (opline->extended_value & ZEND_ISSET) { 19480: if (isset && Z_TYPE_PP(value) != IS_NULL) { 19481: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 19482: } else { 19483: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 19484: } 19485: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 19486: if (!isset || !i_zend_is_true(*value)) { 19487: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 19488: } else { 19489: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 19490: } 19491: } 19492: 19493: CHECK_EXCEPTION(); 19494: ZEND_VM_NEXT_OPCODE(); 19495: } 19496: 19497: static int ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19498: { 19499: USE_OPLINE 19500: zval *var_ptr, *new_zv; 19501: 19502: SAVE_OPLINE(); 19503: var_ptr = EX_T(opline->op1.var).var.ptr; 19504: if (Z_TYPE_P(var_ptr) != IS_OBJECT && 19505: !PZVAL_IS_REF(var_ptr) && 19506: Z_REFCOUNT_P(var_ptr) > 1) { 19507: 19508: Z_DELREF_P(var_ptr); 19509: ALLOC_ZVAL(new_zv); 19510: INIT_PZVAL_COPY(new_zv, var_ptr); 19511: var_ptr = new_zv; 19512: zval_copy_ctor(var_ptr); 19513: EX_T(opline->op1.var).var.ptr = var_ptr; 19514: } 19515: ZEND_VM_NEXT_OPCODE(); 19516: } 19517: 19518: static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19519: { 19520: USE_OPLINE 19521: zend_free_op free_op1; 19522: 19523: SAVE_OPLINE(); 19524: fast_add_function(&EX_T(opline->result.var).tmp_var, 19525: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19526: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19527: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19528: 19529: CHECK_EXCEPTION(); 19530: ZEND_VM_NEXT_OPCODE(); 19531: } 19532: 19533: static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19534: { 19535: USE_OPLINE 19536: zend_free_op free_op1; 19537: 19538: SAVE_OPLINE(); 19539: fast_sub_function(&EX_T(opline->result.var).tmp_var, 19540: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19541: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19542: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19543: 19544: CHECK_EXCEPTION(); 19545: ZEND_VM_NEXT_OPCODE(); 19546: } 19547: 19548: static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19549: { 19550: USE_OPLINE 19551: zend_free_op free_op1; 19552: 19553: SAVE_OPLINE(); 19554: fast_mul_function(&EX_T(opline->result.var).tmp_var, 19555: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19556: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19557: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19558: 19559: CHECK_EXCEPTION(); 19560: ZEND_VM_NEXT_OPCODE(); 19561: } 19562: 19563: static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19564: { 19565: USE_OPLINE 19566: zend_free_op free_op1; 19567: 19568: SAVE_OPLINE(); 19569: fast_div_function(&EX_T(opline->result.var).tmp_var, 19570: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19571: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19572: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19573: 19574: CHECK_EXCEPTION(); 19575: ZEND_VM_NEXT_OPCODE(); 19576: } 19577: 19578: static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19579: { 19580: USE_OPLINE 19581: zend_free_op free_op1; 19582: 19583: SAVE_OPLINE(); 19584: fast_mod_function(&EX_T(opline->result.var).tmp_var, 19585: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19586: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19587: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19588: 19589: CHECK_EXCEPTION(); 19590: ZEND_VM_NEXT_OPCODE(); 19591: } 19592: 19593: static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19594: { 19595: USE_OPLINE 19596: zend_free_op free_op1; 19597: 19598: SAVE_OPLINE(); 19599: shift_left_function(&EX_T(opline->result.var).tmp_var, 19600: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19601: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19602: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19603: 19604: CHECK_EXCEPTION(); 19605: ZEND_VM_NEXT_OPCODE(); 19606: } 19607: 19608: static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19609: { 19610: USE_OPLINE 19611: zend_free_op free_op1; 19612: 19613: SAVE_OPLINE(); 19614: shift_right_function(&EX_T(opline->result.var).tmp_var, 19615: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19616: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19617: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19618: 19619: CHECK_EXCEPTION(); 19620: ZEND_VM_NEXT_OPCODE(); 19621: } 19622: 19623: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19624: { 19625: USE_OPLINE 19626: zend_free_op free_op1; 19627: 19628: SAVE_OPLINE(); 19629: concat_function(&EX_T(opline->result.var).tmp_var, 19630: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19631: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19632: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19633: 19634: CHECK_EXCEPTION(); 19635: ZEND_VM_NEXT_OPCODE(); 19636: } 19637: 19638: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19639: { 19640: USE_OPLINE 19641: zend_free_op free_op1; 19642: 19643: SAVE_OPLINE(); 19644: is_identical_function(&EX_T(opline->result.var).tmp_var, 19645: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19646: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19647: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19648: 19649: CHECK_EXCEPTION(); 19650: ZEND_VM_NEXT_OPCODE(); 19651: } 19652: 19653: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19654: { 19655: USE_OPLINE 19656: zend_free_op free_op1; 19657: zval *result = &EX_T(opline->result.var).tmp_var; 19658: 19659: SAVE_OPLINE(); 19660: is_identical_function(result, 19661: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19662: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19663: Z_LVAL_P(result) = !Z_LVAL_P(result); 19664: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19665: 19666: CHECK_EXCEPTION(); 19667: ZEND_VM_NEXT_OPCODE(); 19668: } 19669: 19670: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19671: { 19672: USE_OPLINE 19673: zend_free_op free_op1; 19674: zval *result = &EX_T(opline->result.var).tmp_var; 19675: 19676: SAVE_OPLINE(); 19677: ZVAL_BOOL(result, fast_equal_function(result, 19678: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19679: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 19680: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19681: 19682: CHECK_EXCEPTION(); 19683: ZEND_VM_NEXT_OPCODE(); 19684: } 19685: 19686: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19687: { 19688: USE_OPLINE 19689: zend_free_op free_op1; 19690: zval *result = &EX_T(opline->result.var).tmp_var; 19691: 19692: SAVE_OPLINE(); 19693: ZVAL_BOOL(result, fast_not_equal_function(result, 19694: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19695: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 19696: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19697: 19698: CHECK_EXCEPTION(); 19699: ZEND_VM_NEXT_OPCODE(); 19700: } 19701: 19702: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19703: { 19704: USE_OPLINE 19705: zend_free_op free_op1; 19706: zval *result = &EX_T(opline->result.var).tmp_var; 19707: 19708: SAVE_OPLINE(); 19709: ZVAL_BOOL(result, fast_is_smaller_function(result, 19710: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19711: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 19712: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19713: 19714: CHECK_EXCEPTION(); 19715: ZEND_VM_NEXT_OPCODE(); 19716: } 19717: 19718: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19719: { 19720: USE_OPLINE 19721: zend_free_op free_op1; 19722: zval *result = &EX_T(opline->result.var).tmp_var; 19723: 19724: SAVE_OPLINE(); 19725: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 19726: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19727: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 19728: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19729: 19730: CHECK_EXCEPTION(); 19731: ZEND_VM_NEXT_OPCODE(); 19732: } 19733: 19734: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19735: { 19736: USE_OPLINE 19737: zend_free_op free_op1; 19738: 19739: SAVE_OPLINE(); 19740: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 19741: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19742: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19743: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19744: 19745: CHECK_EXCEPTION(); 19746: ZEND_VM_NEXT_OPCODE(); 19747: } 19748: 19749: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19750: { 19751: USE_OPLINE 19752: zend_free_op free_op1; 19753: 19754: SAVE_OPLINE(); 19755: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 19756: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19757: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19758: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19759: 19760: CHECK_EXCEPTION(); 19761: ZEND_VM_NEXT_OPCODE(); 19762: } 19763: 19764: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19765: { 19766: USE_OPLINE 19767: zend_free_op free_op1; 19768: 19769: SAVE_OPLINE(); 19770: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 19771: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19772: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19773: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19774: 19775: CHECK_EXCEPTION(); 19776: ZEND_VM_NEXT_OPCODE(); 19777: } 19778: 19779: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19780: { 19781: USE_OPLINE 19782: zend_free_op free_op1; 19783: 19784: SAVE_OPLINE(); 19785: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 19786: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 19787: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 19788: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19789: 19790: CHECK_EXCEPTION(); 19791: ZEND_VM_NEXT_OPCODE(); 19792: } 19793: 19794: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 19795: { 19796: USE_OPLINE 19797: zend_free_op free_op1, free_op_data1; 19798: zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19799: zval *object; 19800: zval *property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 19801: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 19802: int have_get_ptr = 0; 19803: 19804: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 19805: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 19806: } 19807: 19808: make_real_object(object_ptr TSRMLS_CC); 19809: object = *object_ptr; 19810: 19811: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 19812: zend_error(E_WARNING, "Attempt to assign property of non-object"); 19813: 19814: FREE_OP(free_op_data1); 19815: 19816: if (RETURN_VALUE_USED(opline)) { 19817: PZVAL_LOCK(&EG(uninitialized_zval)); 19818: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 19819: EX_T(opline->result.var).var.ptr_ptr = NULL; 19820: } 19821: } else { 19822: /* here we are sure we are dealing with an object */ 19823: if (0) { 19824: MAKE_REAL_ZVAL_PTR(property); 19825: } 19826: 19827: /* here property is a string */ 19828: if (opline->extended_value == ZEND_ASSIGN_OBJ 19829: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 19830: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 19831: if (zptr != NULL) { /* NULL means no success in getting PTR */ 19832: SEPARATE_ZVAL_IF_NOT_REF(zptr); 19833: 19834: have_get_ptr = 1; 19835: binary_op(*zptr, *zptr, value TSRMLS_CC); 19836: if (RETURN_VALUE_USED(opline)) { 19837: PZVAL_LOCK(*zptr); 19838: EX_T(opline->result.var).var.ptr = *zptr; 19839: EX_T(opline->result.var).var.ptr_ptr = NULL; 19840: } 19841: } 19842: } 19843: 19844: if (!have_get_ptr) { 19845: zval *z = NULL; 19846: 19847: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 19848: if (Z_OBJ_HT_P(object)->read_property) { 19849: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 19850: } 19851: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 19852: if (Z_OBJ_HT_P(object)->read_dimension) { 19853: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 19854: } 19855: } 19856: if (z) { 19857: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 19858: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 19859: 19860: if (Z_REFCOUNT_P(z) == 0) { 19861: GC_REMOVE_ZVAL_FROM_BUFFER(z); 19862: zval_dtor(z); 19863: FREE_ZVAL(z); 19864: } 19865: z = value; 19866: } 19867: Z_ADDREF_P(z); 19868: SEPARATE_ZVAL_IF_NOT_REF(&z); 19869: binary_op(z, z, value TSRMLS_CC); 19870: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 19871: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 19872: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 19873: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 19874: } 19875: if (RETURN_VALUE_USED(opline)) { 19876: PZVAL_LOCK(z); 19877: EX_T(opline->result.var).var.ptr = z; 19878: EX_T(opline->result.var).var.ptr_ptr = NULL; 19879: } 19880: zval_ptr_dtor(&z); 19881: } else { 19882: zend_error(E_WARNING, "Attempt to assign property of non-object"); 19883: if (RETURN_VALUE_USED(opline)) { 19884: PZVAL_LOCK(&EG(uninitialized_zval)); 19885: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 19886: EX_T(opline->result.var).var.ptr_ptr = NULL; 19887: } 19888: } 19889: } 19890: 19891: if (0) { 19892: zval_ptr_dtor(&property); 19893: } else { 19894: 19895: } 19896: FREE_OP(free_op_data1); 19897: } 19898: 19899: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19900: /* assign_obj has two opcodes! */ 19901: CHECK_EXCEPTION(); 19902: ZEND_VM_INC_OPCODE(); 19903: ZEND_VM_NEXT_OPCODE(); 19904: } 19905: 19906: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 19907: { 19908: USE_OPLINE 19909: zend_free_op free_op1, free_op_data2, free_op_data1; 19910: zval **var_ptr; 19911: zval *value; 19912: 19913: SAVE_OPLINE(); 19914: switch (opline->extended_value) { 19915: case ZEND_ASSIGN_OBJ: 19916: return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 19917: break; 19918: case ZEND_ASSIGN_DIM: { 19919: zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19920: 19921: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 19922: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 19923: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 19924: if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { 19925: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 19926: } 19927: return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 19928: } else { 19929: zval *dim = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 19930: 19931: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC); 19932: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 19933: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 19934: } 19935: } 19936: break; 19937: default: 19938: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 19939: var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 19940: /* do nothing */ 19941: break; 19942: } 19943: 19944: if (UNEXPECTED(var_ptr == NULL)) { 19945: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 19946: } 19947: 19948: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 19949: if (RETURN_VALUE_USED(opline)) { 19950: PZVAL_LOCK(&EG(uninitialized_zval)); 19951: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 19952: } 19953: 19954: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19955: CHECK_EXCEPTION(); 19956: if (opline->extended_value == ZEND_ASSIGN_DIM) { 19957: ZEND_VM_INC_OPCODE(); 19958: } 19959: ZEND_VM_NEXT_OPCODE(); 19960: } 19961: 19962: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 19963: 19964: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 19965: && Z_OBJ_HANDLER_PP(var_ptr, get) 19966: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 19967: /* proxy object */ 19968: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 19969: Z_ADDREF_P(objval); 19970: binary_op(objval, objval, value TSRMLS_CC); 19971: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 19972: zval_ptr_dtor(&objval); 19973: } else { 19974: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 19975: } 19976: 19977: if (RETURN_VALUE_USED(opline)) { 19978: PZVAL_LOCK(*var_ptr); 19979: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 19980: } 19981: 19982: if (opline->extended_value == ZEND_ASSIGN_DIM) { 19983: FREE_OP(free_op_data1); 19984: FREE_OP_VAR_PTR(free_op_data2); 19985: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19986: CHECK_EXCEPTION(); 19987: ZEND_VM_INC_OPCODE(); 19988: } else { 19989: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 19990: CHECK_EXCEPTION(); 19991: } 19992: ZEND_VM_NEXT_OPCODE(); 19993: } 19994: 19995: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 19996: { 19997: return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 19998: } 19999: 20000: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20001: { 20002: return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20003: } 20004: 20005: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20006: { 20007: return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20008: } 20009: 20010: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20011: { 20012: return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20013: } 20014: 20015: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20016: { 20017: return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20018: } 20019: 20020: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20021: { 20022: return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20023: } 20024: 20025: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20026: { 20027: return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20028: } 20029: 20030: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20031: { 20032: return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20033: } 20034: 20035: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20036: { 20037: return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20038: } 20039: 20040: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20041: { 20042: return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20043: } 20044: 20045: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20046: { 20047: return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20048: } 20049: 20050: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 20051: { 20052: USE_OPLINE 20053: zend_free_op free_op1; 20054: zval **object_ptr; 20055: zval *object; 20056: zval *property; 20057: zval **retval; 20058: int have_get_ptr = 0; 20059: 20060: SAVE_OPLINE(); 20061: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20062: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20063: retval = &EX_T(opline->result.var).var.ptr; 20064: 20065: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 20066: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 20067: } 20068: 20069: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 20070: object = *object_ptr; 20071: 20072: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 20073: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 20074: 20075: if (RETURN_VALUE_USED(opline)) { 20076: PZVAL_LOCK(&EG(uninitialized_zval)); 20077: *retval = &EG(uninitialized_zval); 20078: } 20079: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20080: CHECK_EXCEPTION(); 20081: ZEND_VM_NEXT_OPCODE(); 20082: } 20083: 20084: /* here we are sure we are dealing with an object */ 20085: 20086: if (0) { 20087: MAKE_REAL_ZVAL_PTR(property); 20088: } 20089: 20090: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 20091: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20092: if (zptr != NULL) { /* NULL means no success in getting PTR */ 20093: SEPARATE_ZVAL_IF_NOT_REF(zptr); 20094: 20095: have_get_ptr = 1; 20096: incdec_op(*zptr); 20097: if (RETURN_VALUE_USED(opline)) { 20098: *retval = *zptr; 20099: PZVAL_LOCK(*retval); 20100: } 20101: } 20102: } 20103: 20104: if (!have_get_ptr) { 20105: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 20106: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20107: 20108: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 20109: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 20110: 20111: if (Z_REFCOUNT_P(z) == 0) { 20112: GC_REMOVE_ZVAL_FROM_BUFFER(z); 20113: zval_dtor(z); 20114: FREE_ZVAL(z); 20115: } 20116: z = value; 20117: } 20118: Z_ADDREF_P(z); 20119: SEPARATE_ZVAL_IF_NOT_REF(&z); 20120: incdec_op(z); 20121: *retval = z; 20122: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20123: SELECTIVE_PZVAL_LOCK(*retval, opline); 20124: zval_ptr_dtor(&z); 20125: } else { 20126: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 20127: if (RETURN_VALUE_USED(opline)) { 20128: PZVAL_LOCK(&EG(uninitialized_zval)); 20129: *retval = &EG(uninitialized_zval); 20130: } 20131: } 20132: } 20133: 20134: if (0) { 20135: zval_ptr_dtor(&property); 20136: } else { 20137: 20138: } 20139: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20140: CHECK_EXCEPTION(); 20141: ZEND_VM_NEXT_OPCODE(); 20142: } 20143: 20144: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20145: { 20146: return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20147: } 20148: 20149: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20150: { 20151: return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20152: } 20153: 20154: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 20155: { 20156: USE_OPLINE 20157: zend_free_op free_op1; 20158: zval **object_ptr; 20159: zval *object; 20160: zval *property; 20161: zval *retval; 20162: int have_get_ptr = 0; 20163: 20164: SAVE_OPLINE(); 20165: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20166: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20167: retval = &EX_T(opline->result.var).tmp_var; 20168: 20169: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 20170: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 20171: } 20172: 20173: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 20174: object = *object_ptr; 20175: 20176: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 20177: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 20178: 20179: ZVAL_NULL(retval); 20180: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20181: CHECK_EXCEPTION(); 20182: ZEND_VM_NEXT_OPCODE(); 20183: } 20184: 20185: /* here we are sure we are dealing with an object */ 20186: 20187: if (0) { 20188: MAKE_REAL_ZVAL_PTR(property); 20189: } 20190: 20191: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 20192: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20193: if (zptr != NULL) { /* NULL means no success in getting PTR */ 20194: have_get_ptr = 1; 20195: SEPARATE_ZVAL_IF_NOT_REF(zptr); 20196: 20197: ZVAL_COPY_VALUE(retval, *zptr); 20198: zendi_zval_copy_ctor(*retval); 20199: 20200: incdec_op(*zptr); 20201: 20202: } 20203: } 20204: 20205: if (!have_get_ptr) { 20206: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 20207: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20208: zval *z_copy; 20209: 20210: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 20211: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 20212: 20213: if (Z_REFCOUNT_P(z) == 0) { 20214: GC_REMOVE_ZVAL_FROM_BUFFER(z); 20215: zval_dtor(z); 20216: FREE_ZVAL(z); 20217: } 20218: z = value; 20219: } 20220: ZVAL_COPY_VALUE(retval, z); 20221: zendi_zval_copy_ctor(*retval); 20222: ALLOC_ZVAL(z_copy); 20223: INIT_PZVAL_COPY(z_copy, z); 20224: zendi_zval_copy_ctor(*z_copy); 20225: incdec_op(z_copy); 20226: Z_ADDREF_P(z); 20227: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20228: zval_ptr_dtor(&z_copy); 20229: zval_ptr_dtor(&z); 20230: } else { 20231: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 20232: ZVAL_NULL(retval); 20233: } 20234: } 20235: 20236: if (0) { 20237: zval_ptr_dtor(&property); 20238: } else { 20239: 20240: } 20241: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20242: CHECK_EXCEPTION(); 20243: ZEND_VM_NEXT_OPCODE(); 20244: } 20245: 20246: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20247: { 20248: return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20249: } 20250: 20251: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20252: { 20253: return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20254: } 20255: 20256: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20257: { 20258: USE_OPLINE 20259: zend_free_op free_op1; 20260: zval **container; 20261: 20262: SAVE_OPLINE(); 20263: 20264: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 20265: IS_VAR != IS_CV && 20266: EX_T(opline->op1.var).var.ptr_ptr) { 20267: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 20268: } 20269: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20270: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); 20271: 20272: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20273: CHECK_EXCEPTION(); 20274: ZEND_VM_NEXT_OPCODE(); 20275: } 20276: 20277: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20278: { 20279: USE_OPLINE 20280: zend_free_op free_op1; 20281: zval **container; 20282: 20283: SAVE_OPLINE(); 20284: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20285: 20286: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20287: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 20288: } 20289: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); 20290: 20291: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20292: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20293: } 20294: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20295: 20296: /* We are going to assign the result by reference */ 20297: if (UNEXPECTED(opline->extended_value != 0)) { 20298: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 20299: 20300: if (retval_ptr) { 20301: Z_DELREF_PP(retval_ptr); 20302: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 20303: Z_ADDREF_PP(retval_ptr); 20304: } 20305: } 20306: 20307: CHECK_EXCEPTION(); 20308: ZEND_VM_NEXT_OPCODE(); 20309: } 20310: 20311: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20312: { 20313: USE_OPLINE 20314: zend_free_op free_op1; 20315: zval **container; 20316: 20317: SAVE_OPLINE(); 20318: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20319: 20320: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20321: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 20322: } 20323: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC); 20324: 20325: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20326: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20327: } 20328: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20329: CHECK_EXCEPTION(); 20330: ZEND_VM_NEXT_OPCODE(); 20331: } 20332: 20333: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20334: { 20335: USE_OPLINE 20336: zend_free_op free_op1; 20337: zval **container; 20338: 20339: SAVE_OPLINE(); 20340: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20341: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC); 20342: 20343: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20344: CHECK_EXCEPTION(); 20345: ZEND_VM_NEXT_OPCODE(); 20346: } 20347: 20348: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20349: { 20350: USE_OPLINE 20351: zend_free_op free_op1; 20352: zval **container; 20353: 20354: SAVE_OPLINE(); 20355: 20356: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 20357: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20358: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20359: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 20360: } 20361: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); 20362: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20363: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20364: } 20365: } else { 20366: if (IS_CV == IS_UNUSED) { 20367: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 20368: } 20369: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20370: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); 20371: } 20372: 20373: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20374: CHECK_EXCEPTION(); 20375: ZEND_VM_NEXT_OPCODE(); 20376: } 20377: 20378: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20379: { 20380: USE_OPLINE 20381: zend_free_op free_op1; 20382: zval **container; 20383: 20384: SAVE_OPLINE(); 20385: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20386: 20387: if (IS_VAR == IS_CV) { 20388: if (container != &EG(uninitialized_zval_ptr)) { 20389: SEPARATE_ZVAL_IF_NOT_REF(container); 20390: } 20391: } 20392: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20393: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 20394: } 20395: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC); 20396: 20397: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20398: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20399: } 20400: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20401: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 20402: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 20403: } else { 20404: zend_free_op free_res; 20405: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 20406: 20407: PZVAL_UNLOCK(*retval_ptr, &free_res); 20408: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 20409: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 20410: } 20411: PZVAL_LOCK(*retval_ptr); 20412: FREE_OP_VAR_PTR(free_res); 20413: CHECK_EXCEPTION(); 20414: ZEND_VM_NEXT_OPCODE(); 20415: } 20416: } 20417: 20418: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS) 20419: { 20420: USE_OPLINE 20421: zend_free_op free_op1; 20422: zval *container; 20423: 20424: zval *offset; 20425: 20426: SAVE_OPLINE(); 20427: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20428: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20429: 20430: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 20431: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 20432: zend_error(E_NOTICE, "Trying to get property of non-object"); 20433: PZVAL_LOCK(&EG(uninitialized_zval)); 20434: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 20435: 20436: } else { 20437: zval *retval; 20438: 20439: if (0) { 20440: MAKE_REAL_ZVAL_PTR(offset); 20441: } 20442: 20443: /* here we are sure we are dealing with an object */ 20444: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20445: 20446: PZVAL_LOCK(retval); 20447: AI_SET_PTR(&EX_T(opline->result.var), retval); 20448: 20449: if (0) { 20450: zval_ptr_dtor(&offset); 20451: } else { 20452: 20453: } 20454: } 20455: 20456: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20457: CHECK_EXCEPTION(); 20458: ZEND_VM_NEXT_OPCODE(); 20459: } 20460: 20461: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20462: { 20463: return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20464: } 20465: 20466: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20467: { 20468: USE_OPLINE 20469: zend_free_op free_op1; 20470: zval *property; 20471: zval **container; 20472: 20473: SAVE_OPLINE(); 20474: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20475: 20476: if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 20477: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 20478: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 20479: } 20480: 20481: if (0) { 20482: MAKE_REAL_ZVAL_PTR(property); 20483: } 20484: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20485: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20486: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 20487: } 20488: 20489: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 20490: if (0) { 20491: zval_ptr_dtor(&property); 20492: } else { 20493: 20494: } 20495: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20496: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20497: } 20498: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20499: 20500: /* We are going to assign the result by reference */ 20501: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 20502: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 20503: 20504: Z_DELREF_PP(retval_ptr); 20505: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 20506: Z_ADDREF_PP(retval_ptr); 20507: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 20508: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 20509: } 20510: 20511: CHECK_EXCEPTION(); 20512: ZEND_VM_NEXT_OPCODE(); 20513: } 20514: 20515: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20516: { 20517: USE_OPLINE 20518: zend_free_op free_op1; 20519: zval *property; 20520: zval **container; 20521: 20522: SAVE_OPLINE(); 20523: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20524: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20525: 20526: if (0) { 20527: MAKE_REAL_ZVAL_PTR(property); 20528: } 20529: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20530: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 20531: } 20532: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 20533: if (0) { 20534: zval_ptr_dtor(&property); 20535: } else { 20536: 20537: } 20538: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20539: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20540: } 20541: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20542: CHECK_EXCEPTION(); 20543: ZEND_VM_NEXT_OPCODE(); 20544: } 20545: 20546: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20547: { 20548: USE_OPLINE 20549: zend_free_op free_op1; 20550: zval *container; 20551: 20552: zval *offset; 20553: 20554: SAVE_OPLINE(); 20555: container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20556: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20557: 20558: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 20559: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 20560: PZVAL_LOCK(&EG(uninitialized_zval)); 20561: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 20562: 20563: } else { 20564: zval *retval; 20565: 20566: if (0) { 20567: MAKE_REAL_ZVAL_PTR(offset); 20568: } 20569: 20570: /* here we are sure we are dealing with an object */ 20571: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20572: 20573: PZVAL_LOCK(retval); 20574: AI_SET_PTR(&EX_T(opline->result.var), retval); 20575: 20576: if (0) { 20577: zval_ptr_dtor(&offset); 20578: } else { 20579: 20580: } 20581: } 20582: 20583: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20584: CHECK_EXCEPTION(); 20585: ZEND_VM_NEXT_OPCODE(); 20586: } 20587: 20588: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20589: { 20590: USE_OPLINE 20591: 20592: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 20593: /* Behave like FETCH_OBJ_W */ 20594: zend_free_op free_op1; 20595: zval *property; 20596: zval **container; 20597: 20598: SAVE_OPLINE(); 20599: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20600: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20601: 20602: if (0) { 20603: MAKE_REAL_ZVAL_PTR(property); 20604: } 20605: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20606: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 20607: } 20608: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 20609: if (0) { 20610: zval_ptr_dtor(&property); 20611: } else { 20612: 20613: } 20614: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20615: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20616: } 20617: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20618: CHECK_EXCEPTION(); 20619: ZEND_VM_NEXT_OPCODE(); 20620: } else { 20621: return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20622: } 20623: } 20624: 20625: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20626: { 20627: USE_OPLINE 20628: zend_free_op free_op1, free_res; 20629: zval **container; 20630: zval *property; 20631: 20632: SAVE_OPLINE(); 20633: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20634: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20635: 20636: if (IS_VAR == IS_CV) { 20637: if (container != &EG(uninitialized_zval_ptr)) { 20638: SEPARATE_ZVAL_IF_NOT_REF(container); 20639: } 20640: } 20641: if (0) { 20642: MAKE_REAL_ZVAL_PTR(property); 20643: } 20644: if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { 20645: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 20646: } 20647: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 20648: if (0) { 20649: zval_ptr_dtor(&property); 20650: } else { 20651: 20652: } 20653: if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { 20654: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 20655: } 20656: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20657: 20658: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 20659: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 20660: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 20661: } 20662: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 20663: FREE_OP_VAR_PTR(free_res); 20664: CHECK_EXCEPTION(); 20665: ZEND_VM_NEXT_OPCODE(); 20666: } 20667: 20668: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20669: { 20670: USE_OPLINE 20671: zend_free_op free_op1; 20672: zval **object_ptr; 20673: zval *property_name; 20674: 20675: SAVE_OPLINE(); 20676: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20677: property_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20678: 20679: if (0) { 20680: MAKE_REAL_ZVAL_PTR(property_name); 20681: } 20682: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 20683: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 20684: } 20685: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20686: if (0) { 20687: zval_ptr_dtor(&property_name); 20688: } else { 20689: 20690: } 20691: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20692: /* assign_obj has two opcodes! */ 20693: CHECK_EXCEPTION(); 20694: ZEND_VM_INC_OPCODE(); 20695: ZEND_VM_NEXT_OPCODE(); 20696: } 20697: 20698: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20699: { 20700: USE_OPLINE 20701: zend_free_op free_op1; 20702: zval **object_ptr; 20703: 20704: SAVE_OPLINE(); 20705: object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20706: 20707: if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 20708: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 20709: } 20710: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 20711: 20712: zval *property_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20713: 20714: if (0) { 20715: MAKE_REAL_ZVAL_PTR(property_name); 20716: } 20717: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 20718: if (0) { 20719: zval_ptr_dtor(&property_name); 20720: } else { 20721: 20722: } 20723: } else { 20724: zend_free_op free_op_data1, free_op_data2; 20725: zval *value; 20726: zval *dim = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20727: zval **variable_ptr_ptr; 20728: 20729: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC); 20730: 20731: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 20732: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 20733: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 20734: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 20735: if (RETURN_VALUE_USED(opline)) { 20736: zval *retval; 20737: 20738: ALLOC_ZVAL(retval); 20739: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 20740: INIT_PZVAL(retval); 20741: AI_SET_PTR(&EX_T(opline->result.var), retval); 20742: } 20743: } else if (RETURN_VALUE_USED(opline)) { 20744: PZVAL_LOCK(&EG(uninitialized_zval)); 20745: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 20746: } 20747: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 20748: if (IS_TMP_FREE(free_op_data1)) { 20749: zval_dtor(value); 20750: } 20751: if (RETURN_VALUE_USED(opline)) { 20752: PZVAL_LOCK(&EG(uninitialized_zval)); 20753: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 20754: } 20755: } else { 20756: if ((opline+1)->op1_type == IS_TMP_VAR) { 20757: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 20758: } else if ((opline+1)->op1_type == IS_CONST) { 20759: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 20760: } else { 20761: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 20762: } 20763: if (RETURN_VALUE_USED(opline)) { 20764: PZVAL_LOCK(value); 20765: AI_SET_PTR(&EX_T(opline->result.var), value); 20766: } 20767: } 20768: FREE_OP_VAR_PTR(free_op_data2); 20769: FREE_OP_IF_VAR(free_op_data1); 20770: } 20771: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20772: /* assign_dim has two opcodes! */ 20773: CHECK_EXCEPTION(); 20774: ZEND_VM_INC_OPCODE(); 20775: ZEND_VM_NEXT_OPCODE(); 20776: } 20777: 20778: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20779: { 20780: USE_OPLINE 20781: zend_free_op free_op1; 20782: zval *value; 20783: zval **variable_ptr_ptr; 20784: 20785: SAVE_OPLINE(); 20786: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20787: variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20788: 20789: if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 20790: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) { 20791: if (RETURN_VALUE_USED(opline)) { 20792: zval *retval; 20793: 20794: ALLOC_ZVAL(retval); 20795: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 20796: INIT_PZVAL(retval); 20797: AI_SET_PTR(&EX_T(opline->result.var), retval); 20798: } 20799: } else if (RETURN_VALUE_USED(opline)) { 20800: PZVAL_LOCK(&EG(uninitialized_zval)); 20801: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 20802: } 20803: } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 20804: if (0) { 20805: zval_dtor(value); 20806: } 20807: if (RETURN_VALUE_USED(opline)) { 20808: PZVAL_LOCK(&EG(uninitialized_zval)); 20809: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 20810: } 20811: } else { 20812: if (IS_CV == IS_TMP_VAR) { 20813: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 20814: } else if (IS_CV == IS_CONST) { 20815: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 20816: } else { 20817: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 20818: } 20819: if (RETURN_VALUE_USED(opline)) { 20820: PZVAL_LOCK(value); 20821: AI_SET_PTR(&EX_T(opline->result.var), value); 20822: } 20823: } 20824: 20825: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20826: 20827: /* zend_assign_to_variable() always takes care of op2, never free it! */ 20828: 20829: CHECK_EXCEPTION(); 20830: ZEND_VM_NEXT_OPCODE(); 20831: } 20832: 20833: static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20834: { 20835: USE_OPLINE 20836: zend_free_op free_op1, free_op2; 20837: zval **variable_ptr_ptr; 20838: zval **value_ptr_ptr; 20839: 20840: SAVE_OPLINE(); 20841: value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op2.var TSRMLS_CC); 20842: 20843: if (IS_CV == IS_VAR && 20844: value_ptr_ptr && 20845: !Z_ISREF_PP(value_ptr_ptr) && 20846: opline->extended_value == ZEND_RETURNS_FUNCTION && 20847: !EX_T(opline->op2.var).var.fcall_returned_reference) { 20848: if (free_op2.var == NULL) { 20849: PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ 20850: } 20851: zend_error(E_STRICT, "Only variables should be assigned by reference"); 20852: if (UNEXPECTED(EG(exception) != NULL)) { 20853: 20854: HANDLE_EXCEPTION(); 20855: } 20856: return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 20857: } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 20858: PZVAL_LOCK(*value_ptr_ptr); 20859: } 20860: if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { 20861: zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); 20862: } 20863: 20864: variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20865: if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || 20866: (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { 20867: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); 20868: } 20869: zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); 20870: 20871: if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 20872: Z_DELREF_PP(variable_ptr_ptr); 20873: } 20874: 20875: if (RETURN_VALUE_USED(opline)) { 20876: PZVAL_LOCK(*variable_ptr_ptr); 20877: AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr); 20878: } 20879: 20880: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20881: 20882: CHECK_EXCEPTION(); 20883: ZEND_VM_NEXT_OPCODE(); 20884: } 20885: 20886: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20887: { 20888: USE_OPLINE 20889: zval *function_name; 20890: char *function_name_strval; 20891: int function_name_strlen; 20892: zend_free_op free_op1; 20893: 20894: SAVE_OPLINE(); 20895: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 20896: 20897: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 20898: 20899: if (IS_CV != IS_CONST && 20900: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 20901: zend_error_noreturn(E_ERROR, "Method name must be a string"); 20902: } 20903: 20904: function_name_strval = Z_STRVAL_P(function_name); 20905: function_name_strlen = Z_STRLEN_P(function_name); 20906: 20907: EX(object) = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 20908: 20909: if (EXPECTED(EX(object) != NULL) && 20910: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 20911: EX(called_scope) = Z_OBJCE_P(EX(object)); 20912: 20913: if (IS_CV != IS_CONST || 20914: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 20915: zval *object = EX(object); 20916: 20917: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 20918: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 20919: } 20920: 20921: /* First, locate the function. */ 20922: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 20923: if (UNEXPECTED(EX(fbc) == NULL)) { 20924: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 20925: } 20926: if (IS_CV == IS_CONST && 20927: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 20928: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 20929: EXPECTED(EX(object) == object)) { 20930: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 20931: } 20932: } 20933: } else { 20934: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 20935: } 20936: 20937: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 20938: EX(object) = NULL; 20939: } else { 20940: if (!PZVAL_IS_REF(EX(object))) { 20941: Z_ADDREF_P(EX(object)); /* For $this pointer */ 20942: } else { 20943: zval *this_ptr; 20944: ALLOC_ZVAL(this_ptr); 20945: INIT_PZVAL_COPY(this_ptr, EX(object)); 20946: zval_copy_ctor(this_ptr); 20947: EX(object) = this_ptr; 20948: } 20949: } 20950: 20951: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 20952: 20953: CHECK_EXCEPTION(); 20954: ZEND_VM_NEXT_OPCODE(); 20955: } 20956: 20957: static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 20958: { 20959: USE_OPLINE 20960: zval *function_name; 20961: zend_class_entry *ce; 20962: 20963: SAVE_OPLINE(); 20964: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 20965: 20966: if (IS_VAR == IS_CONST) { 20967: /* no function found. try a static method in class */ 20968: if (CACHED_PTR(opline->op1.literal->cache_slot)) { 20969: ce = CACHED_PTR(opline->op1.literal->cache_slot); 20970: } else { 20971: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 20972: if (UNEXPECTED(EG(exception) != NULL)) { 20973: HANDLE_EXCEPTION(); 20974: } 20975: if (UNEXPECTED(ce == NULL)) { 20976: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 20977: } 20978: CACHE_PTR(opline->op1.literal->cache_slot, ce); 20979: } 20980: EX(called_scope) = ce; 20981: } else { 20982: ce = EX_T(opline->op1.var).class_entry; 20983: 20984: if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { 20985: EX(called_scope) = EG(called_scope); 20986: } else { 20987: EX(called_scope) = ce; 20988: } 20989: } 20990: 20991: if (IS_VAR == IS_CONST && 20992: IS_CV == IS_CONST && 20993: CACHED_PTR(opline->op2.literal->cache_slot)) { 20994: EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); 20995: } else if (IS_VAR != IS_CONST && 20996: IS_CV == IS_CONST && 20997: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { 20998: /* do nothing */ 20999: } else if (IS_CV != IS_UNUSED) { 21000: char *function_name_strval = NULL; 21001: int function_name_strlen = 0; 21002: 21003: 21004: if (IS_CV == IS_CONST) { 21005: function_name_strval = Z_STRVAL_P(opline->op2.zv); 21006: function_name_strlen = Z_STRLEN_P(opline->op2.zv); 21007: } else { 21008: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 21009: 21010: if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 21011: zend_error_noreturn(E_ERROR, "Function name must be a string"); 21012: } else { 21013: function_name_strval = Z_STRVAL_P(function_name); 21014: function_name_strlen = Z_STRLEN_P(function_name); 21015: } 21016: } 21017: 21018: if (function_name_strval) { 21019: if (ce->get_static_method) { 21020: EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); 21021: } else { 21022: EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 21023: } 21024: if (UNEXPECTED(EX(fbc) == NULL)) { 21025: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); 21026: } 21027: if (IS_CV == IS_CONST && 21028: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 21029: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { 21030: if (IS_VAR == IS_CONST) { 21031: CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); 21032: } else { 21033: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); 21034: } 21035: } 21036: } 21037: if (IS_CV != IS_CONST) { 21038: 21039: } 21040: } else { 21041: if (UNEXPECTED(ce->constructor == NULL)) { 21042: zend_error_noreturn(E_ERROR, "Cannot call constructor"); 21043: } 21044: if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { 21045: zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); 21046: } 21047: EX(fbc) = ce->constructor; 21048: } 21049: 21050: if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { 21051: EX(object) = NULL; 21052: } else { 21053: if (EG(This) && 21054: Z_OBJ_HT_P(EG(This))->get_class_entry && 21055: !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { 21056: /* We are calling method of the other (incompatible) class, 21057: but passing $this. This is done for compatibility with php-4. */ 21058: if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { 21059: zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 21060: } else { 21061: /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ 21062: zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); 21063: } 21064: } 21065: if ((EX(object) = EG(This))) { 21066: Z_ADDREF_P(EX(object)); 21067: EX(called_scope) = Z_OBJCE_P(EX(object)); 21068: } 21069: } 21070: 21071: CHECK_EXCEPTION(); 21072: ZEND_VM_NEXT_OPCODE(); 21073: } 21074: 21075: static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21076: { 21077: USE_OPLINE 21078: zend_free_op free_op1; 21079: 21080: SAVE_OPLINE(); 21081: if (IS_VAR==IS_VAR) { 21082: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 21083: } 21084: is_equal_function(&EX_T(opline->result.var).tmp_var, 21085: _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC), 21086: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 21087: 21088: CHECK_EXCEPTION(); 21089: ZEND_VM_NEXT_OPCODE(); 21090: } 21091: 21092: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21093: { 21094: USE_OPLINE 21095: zend_free_op free_op1; 21096: zval *expr_ptr; 21097: 21098: SAVE_OPLINE(); 21099: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 21100: zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 21101: 21102: if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 21103: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 21104: } 21105: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 21106: expr_ptr = *expr_ptr_ptr; 21107: Z_ADDREF_P(expr_ptr); 21108: } else { 21109: expr_ptr=_get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 21110: if (0) { /* temporary variable */ 21111: zval *new_expr; 21112: 21113: ALLOC_ZVAL(new_expr); 21114: INIT_PZVAL_COPY(new_expr, expr_ptr); 21115: expr_ptr = new_expr; 21116: } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 21117: zval *new_expr; 21118: 21119: ALLOC_ZVAL(new_expr); 21120: INIT_PZVAL_COPY(new_expr, expr_ptr); 21121: expr_ptr = new_expr; 21122: zendi_zval_copy_ctor(*expr_ptr); 21123: } else { 21124: Z_ADDREF_P(expr_ptr); 21125: } 21126: } 21127: 21128: if (IS_CV != IS_UNUSED) { 21129: 21130: zval *offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 21131: ulong hval; 21132: 21133: switch (Z_TYPE_P(offset)) { 21134: case IS_DOUBLE: 21135: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 21136: goto num_index; 21137: case IS_LONG: 21138: case IS_BOOL: 21139: hval = Z_LVAL_P(offset); 21140: num_index: 21141: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 21142: break; 21143: case IS_STRING: 21144: if (IS_CV == IS_CONST) { 21145: hval = Z_HASH_P(offset); 21146: } else { 21147: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 21148: if (IS_INTERNED(Z_STRVAL_P(offset))) { 21149: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 21150: } else { 21151: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 21152: } 21153: } 21154: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 21155: break; 21156: case IS_NULL: 21157: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 21158: break; 21159: default: 21160: zend_error(E_WARNING, "Illegal offset type"); 21161: zval_ptr_dtor(&expr_ptr); 21162: /* do nothing */ 21163: break; 21164: } 21165: 21166: } else { 21167: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 21168: } 21169: if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { 21170: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 21171: } else { 21172: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 21173: } 21174: CHECK_EXCEPTION(); 21175: ZEND_VM_NEXT_OPCODE(); 21176: } 21177: 21178: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21179: { 21180: USE_OPLINE 21181: 21182: array_init(&EX_T(opline->result.var).tmp_var); 21183: if (IS_VAR == IS_UNUSED) { 21184: ZEND_VM_NEXT_OPCODE(); 21185: #if 0 || IS_VAR != IS_UNUSED 21186: } else { 21187: return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21188: #endif 21189: } 21190: } 21191: 21192: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21193: { 21194: USE_OPLINE 21195: zend_free_op free_op1; 21196: zval **container; 21197: zval *offset; 21198: ulong hval; 21199: 21200: SAVE_OPLINE(); 21201: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 21202: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 21203: SEPARATE_ZVAL_IF_NOT_REF(container); 21204: } 21205: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 21206: 21207: if (IS_VAR != IS_VAR || container) { 21208: switch (Z_TYPE_PP(container)) { 21209: case IS_ARRAY: { 21210: HashTable *ht = Z_ARRVAL_PP(container); 21211: 21212: switch (Z_TYPE_P(offset)) { 21213: case IS_DOUBLE: 21214: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 21215: zend_hash_index_del(ht, hval); 21216: break; 21217: case IS_RESOURCE: 21218: case IS_BOOL: 21219: case IS_LONG: 21220: hval = Z_LVAL_P(offset); 21221: zend_hash_index_del(ht, hval); 21222: break; 21223: case IS_STRING: 21224: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 21225: Z_ADDREF_P(offset); 21226: } 21227: if (IS_CV == IS_CONST) { 21228: hval = Z_HASH_P(offset); 21229: } else { 21230: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 21231: if (IS_INTERNED(Z_STRVAL_P(offset))) { 21232: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 21233: } else { 21234: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 21235: } 21236: } 21237: if (ht == &EG(symbol_table)) { 21238: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 21239: } else { 21240: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 21241: } 21242: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 21243: zval_ptr_dtor(&offset); 21244: } 21245: break; 21246: num_index_dim: 21247: zend_hash_index_del(ht, hval); 21248: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 21249: zval_ptr_dtor(&offset); 21250: } 21251: break; 21252: case IS_NULL: 21253: zend_hash_del(ht, "", sizeof("")); 21254: break; 21255: default: 21256: zend_error(E_WARNING, "Illegal offset type in unset"); 21257: break; 21258: } 21259: 21260: break; 21261: } 21262: case IS_OBJECT: 21263: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 21264: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 21265: } 21266: if (0) { 21267: MAKE_REAL_ZVAL_PTR(offset); 21268: } 21269: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 21270: if (0) { 21271: zval_ptr_dtor(&offset); 21272: } else { 21273: 21274: } 21275: break; 21276: case IS_STRING: 21277: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 21278: ZEND_VM_CONTINUE(); /* bailed out before */ 21279: default: 21280: 21281: break; 21282: } 21283: } else { 21284: 21285: } 21286: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 21287: 21288: CHECK_EXCEPTION(); 21289: ZEND_VM_NEXT_OPCODE(); 21290: } 21291: 21292: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21293: { 21294: USE_OPLINE 21295: zend_free_op free_op1; 21296: zval **container; 21297: zval *offset; 21298: 21299: SAVE_OPLINE(); 21300: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 21301: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 21302: 21303: if (IS_VAR != IS_VAR || container) { 21304: if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { 21305: SEPARATE_ZVAL_IF_NOT_REF(container); 21306: } 21307: if (Z_TYPE_PP(container) == IS_OBJECT) { 21308: if (0) { 21309: MAKE_REAL_ZVAL_PTR(offset); 21310: } 21311: if (Z_OBJ_HT_P(*container)->unset_property) { 21312: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21313: } else { 21314: zend_error(E_NOTICE, "Trying to unset property of non-object"); 21315: } 21316: if (0) { 21317: zval_ptr_dtor(&offset); 21318: } else { 21319: 21320: } 21321: } else { 21322: 21323: } 21324: } else { 21325: 21326: } 21327: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 21328: 21329: CHECK_EXCEPTION(); 21330: ZEND_VM_NEXT_OPCODE(); 21331: } 21332: 21333: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 21334: { 21335: USE_OPLINE 21336: zend_free_op free_op1; 21337: zval **container; 21338: zval **value = NULL; 21339: int result = 0; 21340: ulong hval; 21341: zval *offset; 21342: 21343: SAVE_OPLINE(); 21344: container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC); 21345: 21346: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 21347: 21348: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 21349: HashTable *ht; 21350: int isset = 0; 21351: 21352: ht = Z_ARRVAL_PP(container); 21353: 21354: switch (Z_TYPE_P(offset)) { 21355: case IS_DOUBLE: 21356: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 21357: goto num_index_prop; 21358: case IS_RESOURCE: 21359: case IS_BOOL: 21360: case IS_LONG: 21361: hval = Z_LVAL_P(offset); 21362: num_index_prop: 21363: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 21364: isset = 1; 21365: } 21366: break; 21367: case IS_STRING: 21368: if (IS_CV == IS_CONST) { 21369: hval = Z_HASH_P(offset); 21370: } else { 21371: if (!prop_dim) { 21372: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 21373: } 21374: if (IS_INTERNED(Z_STRVAL_P(offset))) { 21375: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 21376: } else { 21377: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 21378: } 21379: } 21380: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 21381: isset = 1; 21382: } 21383: break; 21384: case IS_NULL: 21385: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 21386: isset = 1; 21387: } 21388: break; 21389: default: 21390: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 21391: break; 21392: } 21393: 21394: if (opline->extended_value & ZEND_ISSET) { 21395: if (isset && Z_TYPE_PP(value) == IS_NULL) { 21396: result = 0; 21397: } else { 21398: result = isset; 21399: } 21400: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 21401: if (!isset || !i_zend_is_true(*value)) { 21402: result = 0; 21403: } else { 21404: result = 1; 21405: } 21406: } 21407: 21408: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 21409: if (0) { 21410: MAKE_REAL_ZVAL_PTR(offset); 21411: } 21412: if (prop_dim) { 21413: if (Z_OBJ_HT_P(*container)->has_property) { 21414: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21415: } else { 21416: zend_error(E_NOTICE, "Trying to check property of non-object"); 21417: result = 0; 21418: } 21419: } else { 21420: if (Z_OBJ_HT_P(*container)->has_dimension) { 21421: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 21422: } else { 21423: zend_error(E_NOTICE, "Trying to check element of non-array"); 21424: result = 0; 21425: } 21426: } 21427: if (0) { 21428: zval_ptr_dtor(&offset); 21429: } else { 21430: 21431: } 21432: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 21433: zval tmp; 21434: 21435: if (Z_TYPE_P(offset) != IS_LONG) { 21436: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 21437: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 21438: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 21439: ZVAL_COPY_VALUE(&tmp, offset); 21440: zval_copy_ctor(&tmp); 21441: convert_to_long(&tmp); 21442: offset = &tmp; 21443: } else { 21444: /* can not be converted to proper offset, return "not set" */ 21445: result = 0; 21446: } 21447: } 21448: if (Z_TYPE_P(offset) == IS_LONG) { 21449: if (opline->extended_value & ZEND_ISSET) { 21450: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 21451: result = 1; 21452: } 21453: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 21454: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 21455: result = 1; 21456: } 21457: } 21458: } 21459: 21460: } else { 21461: 21462: } 21463: 21464: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 21465: if (opline->extended_value & ZEND_ISSET) { 21466: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 21467: } else { 21468: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 21469: } 21470: 21471: if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; 21472: 21473: CHECK_EXCEPTION(); 21474: ZEND_VM_NEXT_OPCODE(); 21475: } 21476: 21477: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21478: { 21479: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21480: } 21481: 21482: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21483: { 21484: return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21485: } 21486: 21487: static int ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21488: { 21489: USE_OPLINE 21490: 21491: zval *obj; 21492: zend_class_entry *ce; 21493: zend_function *clone; 21494: zend_object_clone_obj_t clone_call; 21495: 21496: SAVE_OPLINE(); 21497: obj = _get_obj_zval_ptr_unused(TSRMLS_C); 21498: 21499: if (IS_UNUSED == IS_CONST || 21500: UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) { 21501: zend_error_noreturn(E_ERROR, "__clone method called on non-object"); 21502: } 21503: 21504: ce = Z_OBJCE_P(obj); 21505: clone = ce ? ce->clone : NULL; 21506: clone_call = Z_OBJ_HT_P(obj)->clone_obj; 21507: if (UNEXPECTED(clone_call == NULL)) { 21508: if (ce) { 21509: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); 21510: } else { 21511: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); 21512: } 21513: } 21514: 21515: if (ce && clone) { 21516: if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { 21517: /* Ensure that if we're calling a private function, we're allowed to do so. 21518: */ 21519: if (UNEXPECTED(ce != EG(scope))) { 21520: zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 21521: } 21522: } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { 21523: /* Ensure that if we're calling a protected function, we're allowed to do so. 21524: */ 21525: if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { 21526: zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 21527: } 21528: } 21529: } 21530: 21531: if (EXPECTED(EG(exception) == NULL)) { 21532: zval *retval; 21533: 21534: ALLOC_ZVAL(retval); 21535: Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); 21536: Z_TYPE_P(retval) = IS_OBJECT; 21537: Z_SET_REFCOUNT_P(retval, 1); 21538: Z_SET_ISREF_P(retval); 21539: if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { 21540: zval_ptr_dtor(&retval); 21541: } else { 21542: AI_SET_PTR(&EX_T(opline->result.var), retval); 21543: } 21544: } 21545: 21546: CHECK_EXCEPTION(); 21547: ZEND_VM_NEXT_OPCODE(); 21548: } 21549: 21550: static int ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21551: { 21552: #if 0 || (IS_UNUSED != IS_UNUSED) 21553: USE_OPLINE 21554: 21555: SAVE_OPLINE(); 21556: if (IS_UNUSED != IS_UNUSED) { 21557: 21558: zval *ptr = NULL; 21559: 21560: if (Z_TYPE_P(ptr) == IS_LONG) { 21561: EG(exit_status) = Z_LVAL_P(ptr); 21562: } else { 21563: zend_print_variable(ptr); 21564: } 21565: 21566: } 21567: #endif 21568: zend_bailout(); 21569: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 21570: } 21571: 21572: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 21573: { 21574: USE_OPLINE 21575: zend_free_op free_op_data1; 21576: zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 21577: zval *object; 21578: zval *property = opline->op2.zv; 21579: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 21580: int have_get_ptr = 0; 21581: 21582: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 21583: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 21584: } 21585: 21586: make_real_object(object_ptr TSRMLS_CC); 21587: object = *object_ptr; 21588: 21589: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 21590: zend_error(E_WARNING, "Attempt to assign property of non-object"); 21591: 21592: FREE_OP(free_op_data1); 21593: 21594: if (RETURN_VALUE_USED(opline)) { 21595: PZVAL_LOCK(&EG(uninitialized_zval)); 21596: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 21597: EX_T(opline->result.var).var.ptr_ptr = NULL; 21598: } 21599: } else { 21600: /* here we are sure we are dealing with an object */ 21601: if (0) { 21602: MAKE_REAL_ZVAL_PTR(property); 21603: } 21604: 21605: /* here property is a string */ 21606: if (opline->extended_value == ZEND_ASSIGN_OBJ 21607: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 21608: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21609: if (zptr != NULL) { /* NULL means no success in getting PTR */ 21610: SEPARATE_ZVAL_IF_NOT_REF(zptr); 21611: 21612: have_get_ptr = 1; 21613: binary_op(*zptr, *zptr, value TSRMLS_CC); 21614: if (RETURN_VALUE_USED(opline)) { 21615: PZVAL_LOCK(*zptr); 21616: EX_T(opline->result.var).var.ptr = *zptr; 21617: EX_T(opline->result.var).var.ptr_ptr = NULL; 21618: } 21619: } 21620: } 21621: 21622: if (!have_get_ptr) { 21623: zval *z = NULL; 21624: 21625: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 21626: if (Z_OBJ_HT_P(object)->read_property) { 21627: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21628: } 21629: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 21630: if (Z_OBJ_HT_P(object)->read_dimension) { 21631: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 21632: } 21633: } 21634: if (z) { 21635: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 21636: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 21637: 21638: if (Z_REFCOUNT_P(z) == 0) { 21639: GC_REMOVE_ZVAL_FROM_BUFFER(z); 21640: zval_dtor(z); 21641: FREE_ZVAL(z); 21642: } 21643: z = value; 21644: } 21645: Z_ADDREF_P(z); 21646: SEPARATE_ZVAL_IF_NOT_REF(&z); 21647: binary_op(z, z, value TSRMLS_CC); 21648: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 21649: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21650: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 21651: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 21652: } 21653: if (RETURN_VALUE_USED(opline)) { 21654: PZVAL_LOCK(z); 21655: EX_T(opline->result.var).var.ptr = z; 21656: EX_T(opline->result.var).var.ptr_ptr = NULL; 21657: } 21658: zval_ptr_dtor(&z); 21659: } else { 21660: zend_error(E_WARNING, "Attempt to assign property of non-object"); 21661: if (RETURN_VALUE_USED(opline)) { 21662: PZVAL_LOCK(&EG(uninitialized_zval)); 21663: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 21664: EX_T(opline->result.var).var.ptr_ptr = NULL; 21665: } 21666: } 21667: } 21668: 21669: if (0) { 21670: zval_ptr_dtor(&property); 21671: } else { 21672: 21673: } 21674: FREE_OP(free_op_data1); 21675: } 21676: 21677: /* assign_obj has two opcodes! */ 21678: CHECK_EXCEPTION(); 21679: ZEND_VM_INC_OPCODE(); 21680: ZEND_VM_NEXT_OPCODE(); 21681: } 21682: 21683: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 21684: { 21685: USE_OPLINE 21686: zend_free_op free_op_data2, free_op_data1; 21687: zval **var_ptr; 21688: zval *value; 21689: 21690: SAVE_OPLINE(); 21691: switch (opline->extended_value) { 21692: case ZEND_ASSIGN_OBJ: 21693: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21694: break; 21695: case ZEND_ASSIGN_DIM: { 21696: zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 21697: 21698: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 21699: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 21700: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 21701: if (IS_UNUSED == IS_VAR && !0) { 21702: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 21703: } 21704: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21705: } else { 21706: zval *dim = opline->op2.zv; 21707: 21708: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); 21709: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 21710: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 21711: } 21712: } 21713: break; 21714: default: 21715: value = opline->op2.zv; 21716: var_ptr = NULL; 21717: /* do nothing */ 21718: break; 21719: } 21720: 21721: if (UNEXPECTED(var_ptr == NULL)) { 21722: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 21723: } 21724: 21725: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 21726: if (RETURN_VALUE_USED(opline)) { 21727: PZVAL_LOCK(&EG(uninitialized_zval)); 21728: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 21729: } 21730: 21731: 21732: CHECK_EXCEPTION(); 21733: if (opline->extended_value == ZEND_ASSIGN_DIM) { 21734: ZEND_VM_INC_OPCODE(); 21735: } 21736: ZEND_VM_NEXT_OPCODE(); 21737: } 21738: 21739: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 21740: 21741: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 21742: && Z_OBJ_HANDLER_PP(var_ptr, get) 21743: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 21744: /* proxy object */ 21745: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 21746: Z_ADDREF_P(objval); 21747: binary_op(objval, objval, value TSRMLS_CC); 21748: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 21749: zval_ptr_dtor(&objval); 21750: } else { 21751: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 21752: } 21753: 21754: if (RETURN_VALUE_USED(opline)) { 21755: PZVAL_LOCK(*var_ptr); 21756: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 21757: } 21758: 21759: if (opline->extended_value == ZEND_ASSIGN_DIM) { 21760: FREE_OP(free_op_data1); 21761: FREE_OP_VAR_PTR(free_op_data2); 21762: 21763: CHECK_EXCEPTION(); 21764: ZEND_VM_INC_OPCODE(); 21765: } else { 21766: 21767: CHECK_EXCEPTION(); 21768: } 21769: ZEND_VM_NEXT_OPCODE(); 21770: } 21771: 21772: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21773: { 21774: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21775: } 21776: 21777: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21778: { 21779: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21780: } 21781: 21782: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21783: { 21784: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21785: } 21786: 21787: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21788: { 21789: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21790: } 21791: 21792: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21793: { 21794: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21795: } 21796: 21797: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21798: { 21799: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21800: } 21801: 21802: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21803: { 21804: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21805: } 21806: 21807: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21808: { 21809: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21810: } 21811: 21812: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21813: { 21814: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21815: } 21816: 21817: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21818: { 21819: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21820: } 21821: 21822: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21823: { 21824: return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21825: } 21826: 21827: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 21828: { 21829: USE_OPLINE 21830: 21831: zval **object_ptr; 21832: zval *object; 21833: zval *property; 21834: zval **retval; 21835: int have_get_ptr = 0; 21836: 21837: SAVE_OPLINE(); 21838: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 21839: property = opline->op2.zv; 21840: retval = &EX_T(opline->result.var).var.ptr; 21841: 21842: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 21843: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 21844: } 21845: 21846: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 21847: object = *object_ptr; 21848: 21849: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 21850: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 21851: 21852: if (RETURN_VALUE_USED(opline)) { 21853: PZVAL_LOCK(&EG(uninitialized_zval)); 21854: *retval = &EG(uninitialized_zval); 21855: } 21856: 21857: CHECK_EXCEPTION(); 21858: ZEND_VM_NEXT_OPCODE(); 21859: } 21860: 21861: /* here we are sure we are dealing with an object */ 21862: 21863: if (0) { 21864: MAKE_REAL_ZVAL_PTR(property); 21865: } 21866: 21867: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 21868: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21869: if (zptr != NULL) { /* NULL means no success in getting PTR */ 21870: SEPARATE_ZVAL_IF_NOT_REF(zptr); 21871: 21872: have_get_ptr = 1; 21873: incdec_op(*zptr); 21874: if (RETURN_VALUE_USED(opline)) { 21875: *retval = *zptr; 21876: PZVAL_LOCK(*retval); 21877: } 21878: } 21879: } 21880: 21881: if (!have_get_ptr) { 21882: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 21883: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21884: 21885: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 21886: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 21887: 21888: if (Z_REFCOUNT_P(z) == 0) { 21889: GC_REMOVE_ZVAL_FROM_BUFFER(z); 21890: zval_dtor(z); 21891: FREE_ZVAL(z); 21892: } 21893: z = value; 21894: } 21895: Z_ADDREF_P(z); 21896: SEPARATE_ZVAL_IF_NOT_REF(&z); 21897: incdec_op(z); 21898: *retval = z; 21899: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21900: SELECTIVE_PZVAL_LOCK(*retval, opline); 21901: zval_ptr_dtor(&z); 21902: } else { 21903: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 21904: if (RETURN_VALUE_USED(opline)) { 21905: PZVAL_LOCK(&EG(uninitialized_zval)); 21906: *retval = &EG(uninitialized_zval); 21907: } 21908: } 21909: } 21910: 21911: if (0) { 21912: zval_ptr_dtor(&property); 21913: } else { 21914: 21915: } 21916: 21917: CHECK_EXCEPTION(); 21918: ZEND_VM_NEXT_OPCODE(); 21919: } 21920: 21921: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21922: { 21923: return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21924: } 21925: 21926: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 21927: { 21928: return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 21929: } 21930: 21931: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 21932: { 21933: USE_OPLINE 21934: 21935: zval **object_ptr; 21936: zval *object; 21937: zval *property; 21938: zval *retval; 21939: int have_get_ptr = 0; 21940: 21941: SAVE_OPLINE(); 21942: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 21943: property = opline->op2.zv; 21944: retval = &EX_T(opline->result.var).tmp_var; 21945: 21946: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 21947: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 21948: } 21949: 21950: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 21951: object = *object_ptr; 21952: 21953: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 21954: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 21955: 21956: ZVAL_NULL(retval); 21957: 21958: CHECK_EXCEPTION(); 21959: ZEND_VM_NEXT_OPCODE(); 21960: } 21961: 21962: /* here we are sure we are dealing with an object */ 21963: 21964: if (0) { 21965: MAKE_REAL_ZVAL_PTR(property); 21966: } 21967: 21968: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 21969: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21970: if (zptr != NULL) { /* NULL means no success in getting PTR */ 21971: have_get_ptr = 1; 21972: SEPARATE_ZVAL_IF_NOT_REF(zptr); 21973: 21974: ZVAL_COPY_VALUE(retval, *zptr); 21975: zendi_zval_copy_ctor(*retval); 21976: 21977: incdec_op(*zptr); 21978: 21979: } 21980: } 21981: 21982: if (!have_get_ptr) { 21983: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 21984: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 21985: zval *z_copy; 21986: 21987: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 21988: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 21989: 21990: if (Z_REFCOUNT_P(z) == 0) { 21991: GC_REMOVE_ZVAL_FROM_BUFFER(z); 21992: zval_dtor(z); 21993: FREE_ZVAL(z); 21994: } 21995: z = value; 21996: } 21997: ZVAL_COPY_VALUE(retval, z); 21998: zendi_zval_copy_ctor(*retval); 21999: ALLOC_ZVAL(z_copy); 22000: INIT_PZVAL_COPY(z_copy, z); 22001: zendi_zval_copy_ctor(*z_copy); 22002: incdec_op(z_copy); 22003: Z_ADDREF_P(z); 22004: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22005: zval_ptr_dtor(&z_copy); 22006: zval_ptr_dtor(&z); 22007: } else { 22008: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 22009: ZVAL_NULL(retval); 22010: } 22011: } 22012: 22013: if (0) { 22014: zval_ptr_dtor(&property); 22015: } else { 22016: 22017: } 22018: 22019: CHECK_EXCEPTION(); 22020: ZEND_VM_NEXT_OPCODE(); 22021: } 22022: 22023: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22024: { 22025: return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22026: } 22027: 22028: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22029: { 22030: return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22031: } 22032: 22033: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS) 22034: { 22035: USE_OPLINE 22036: 22037: zval *container; 22038: 22039: zval *offset; 22040: 22041: SAVE_OPLINE(); 22042: container = _get_obj_zval_ptr_unused(TSRMLS_C); 22043: offset = opline->op2.zv; 22044: 22045: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 22046: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 22047: zend_error(E_NOTICE, "Trying to get property of non-object"); 22048: PZVAL_LOCK(&EG(uninitialized_zval)); 22049: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 22050: 22051: } else { 22052: zval *retval; 22053: 22054: if (0) { 22055: MAKE_REAL_ZVAL_PTR(offset); 22056: } 22057: 22058: /* here we are sure we are dealing with an object */ 22059: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22060: 22061: PZVAL_LOCK(retval); 22062: AI_SET_PTR(&EX_T(opline->result.var), retval); 22063: 22064: if (0) { 22065: zval_ptr_dtor(&offset); 22066: } else { 22067: 22068: } 22069: } 22070: 22071: CHECK_EXCEPTION(); 22072: ZEND_VM_NEXT_OPCODE(); 22073: } 22074: 22075: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22076: { 22077: return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22078: } 22079: 22080: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22081: { 22082: USE_OPLINE 22083: zend_free_op free_op1; 22084: zval *property; 22085: zval **container; 22086: 22087: SAVE_OPLINE(); 22088: property = opline->op2.zv; 22089: 22090: if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 22091: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 22092: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 22093: } 22094: 22095: if (0) { 22096: MAKE_REAL_ZVAL_PTR(property); 22097: } 22098: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22099: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 22100: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 22101: } 22102: 22103: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 22104: if (0) { 22105: zval_ptr_dtor(&property); 22106: } else { 22107: 22108: } 22109: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 22110: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 22111: } 22112: 22113: /* We are going to assign the result by reference */ 22114: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 22115: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 22116: 22117: Z_DELREF_PP(retval_ptr); 22118: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 22119: Z_ADDREF_PP(retval_ptr); 22120: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 22121: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 22122: } 22123: 22124: CHECK_EXCEPTION(); 22125: ZEND_VM_NEXT_OPCODE(); 22126: } 22127: 22128: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22129: { 22130: USE_OPLINE 22131: zend_free_op free_op1; 22132: zval *property; 22133: zval **container; 22134: 22135: SAVE_OPLINE(); 22136: property = opline->op2.zv; 22137: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22138: 22139: if (0) { 22140: MAKE_REAL_ZVAL_PTR(property); 22141: } 22142: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 22143: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 22144: } 22145: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 22146: if (0) { 22147: zval_ptr_dtor(&property); 22148: } else { 22149: 22150: } 22151: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 22152: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 22153: } 22154: 22155: CHECK_EXCEPTION(); 22156: ZEND_VM_NEXT_OPCODE(); 22157: } 22158: 22159: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22160: { 22161: USE_OPLINE 22162: 22163: zval *container; 22164: 22165: zval *offset; 22166: 22167: SAVE_OPLINE(); 22168: container = _get_obj_zval_ptr_unused(TSRMLS_C); 22169: offset = opline->op2.zv; 22170: 22171: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 22172: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 22173: PZVAL_LOCK(&EG(uninitialized_zval)); 22174: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 22175: 22176: } else { 22177: zval *retval; 22178: 22179: if (0) { 22180: MAKE_REAL_ZVAL_PTR(offset); 22181: } 22182: 22183: /* here we are sure we are dealing with an object */ 22184: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22185: 22186: PZVAL_LOCK(retval); 22187: AI_SET_PTR(&EX_T(opline->result.var), retval); 22188: 22189: if (0) { 22190: zval_ptr_dtor(&offset); 22191: } else { 22192: 22193: } 22194: } 22195: 22196: CHECK_EXCEPTION(); 22197: ZEND_VM_NEXT_OPCODE(); 22198: } 22199: 22200: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22201: { 22202: USE_OPLINE 22203: 22204: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 22205: /* Behave like FETCH_OBJ_W */ 22206: zend_free_op free_op1; 22207: zval *property; 22208: zval **container; 22209: 22210: SAVE_OPLINE(); 22211: property = opline->op2.zv; 22212: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22213: 22214: if (0) { 22215: MAKE_REAL_ZVAL_PTR(property); 22216: } 22217: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 22218: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 22219: } 22220: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 22221: if (0) { 22222: zval_ptr_dtor(&property); 22223: } else { 22224: 22225: } 22226: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 22227: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 22228: } 22229: 22230: CHECK_EXCEPTION(); 22231: ZEND_VM_NEXT_OPCODE(); 22232: } else { 22233: return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22234: } 22235: } 22236: 22237: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22238: { 22239: USE_OPLINE 22240: zend_free_op free_op1, free_res; 22241: zval **container; 22242: zval *property; 22243: 22244: SAVE_OPLINE(); 22245: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22246: property = opline->op2.zv; 22247: 22248: if (IS_UNUSED == IS_CV) { 22249: if (container != &EG(uninitialized_zval_ptr)) { 22250: SEPARATE_ZVAL_IF_NOT_REF(container); 22251: } 22252: } 22253: if (0) { 22254: MAKE_REAL_ZVAL_PTR(property); 22255: } 22256: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 22257: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 22258: } 22259: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 22260: if (0) { 22261: zval_ptr_dtor(&property); 22262: } else { 22263: 22264: } 22265: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 22266: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 22267: } 22268: 22269: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 22270: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 22271: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 22272: } 22273: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 22274: FREE_OP_VAR_PTR(free_res); 22275: CHECK_EXCEPTION(); 22276: ZEND_VM_NEXT_OPCODE(); 22277: } 22278: 22279: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22280: { 22281: USE_OPLINE 22282: 22283: zval **object_ptr; 22284: zval *property_name; 22285: 22286: SAVE_OPLINE(); 22287: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22288: property_name = opline->op2.zv; 22289: 22290: if (0) { 22291: MAKE_REAL_ZVAL_PTR(property_name); 22292: } 22293: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 22294: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 22295: } 22296: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22297: if (0) { 22298: zval_ptr_dtor(&property_name); 22299: } else { 22300: 22301: } 22302: 22303: /* assign_obj has two opcodes! */ 22304: CHECK_EXCEPTION(); 22305: ZEND_VM_INC_OPCODE(); 22306: ZEND_VM_NEXT_OPCODE(); 22307: } 22308: 22309: static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22310: { 22311: USE_OPLINE 22312: zval *str = &EX_T(opline->result.var).tmp_var; 22313: 22314: SAVE_OPLINE(); 22315: 22316: if (IS_UNUSED == IS_UNUSED) { 22317: /* Initialize for erealloc in add_char_to_string */ 22318: Z_STRVAL_P(str) = NULL; 22319: Z_STRLEN_P(str) = 0; 22320: Z_TYPE_P(str) = IS_STRING; 22321: 22322: INIT_PZVAL(str); 22323: } 22324: 22325: add_char_to_string(str, str, opline->op2.zv); 22326: 22327: /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ 22328: /*CHECK_EXCEPTION();*/ 22329: ZEND_VM_NEXT_OPCODE(); 22330: } 22331: 22332: static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22333: { 22334: USE_OPLINE 22335: zval *str = &EX_T(opline->result.var).tmp_var; 22336: 22337: SAVE_OPLINE(); 22338: 22339: if (IS_UNUSED == IS_UNUSED) { 22340: /* Initialize for erealloc in add_string_to_string */ 22341: Z_STRVAL_P(str) = NULL; 22342: Z_STRLEN_P(str) = 0; 22343: Z_TYPE_P(str) = IS_STRING; 22344: 22345: INIT_PZVAL(str); 22346: } 22347: 22348: add_string_to_string(str, str, opline->op2.zv); 22349: 22350: /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ 22351: /*CHECK_EXCEPTION();*/ 22352: ZEND_VM_NEXT_OPCODE(); 22353: } 22354: 22355: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22356: { 22357: USE_OPLINE 22358: zval *function_name; 22359: char *function_name_strval; 22360: int function_name_strlen; 22361: 22362: 22363: SAVE_OPLINE(); 22364: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 22365: 22366: function_name = opline->op2.zv; 22367: 22368: if (IS_CONST != IS_CONST && 22369: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 22370: zend_error_noreturn(E_ERROR, "Method name must be a string"); 22371: } 22372: 22373: function_name_strval = Z_STRVAL_P(function_name); 22374: function_name_strlen = Z_STRLEN_P(function_name); 22375: 22376: EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C); 22377: 22378: if (EXPECTED(EX(object) != NULL) && 22379: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 22380: EX(called_scope) = Z_OBJCE_P(EX(object)); 22381: 22382: if (IS_CONST != IS_CONST || 22383: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 22384: zval *object = EX(object); 22385: 22386: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 22387: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 22388: } 22389: 22390: /* First, locate the function. */ 22391: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 22392: if (UNEXPECTED(EX(fbc) == NULL)) { 22393: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 22394: } 22395: if (IS_CONST == IS_CONST && 22396: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 22397: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 22398: EXPECTED(EX(object) == object)) { 22399: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 22400: } 22401: } 22402: } else { 22403: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 22404: } 22405: 22406: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 22407: EX(object) = NULL; 22408: } else { 22409: if (!PZVAL_IS_REF(EX(object))) { 22410: Z_ADDREF_P(EX(object)); /* For $this pointer */ 22411: } else { 22412: zval *this_ptr; 22413: ALLOC_ZVAL(this_ptr); 22414: INIT_PZVAL_COPY(this_ptr, EX(object)); 22415: zval_copy_ctor(this_ptr); 22416: EX(object) = this_ptr; 22417: } 22418: } 22419: 22420: 22421: CHECK_EXCEPTION(); 22422: ZEND_VM_NEXT_OPCODE(); 22423: } 22424: 22425: static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22426: { 22427: USE_OPLINE 22428: 22429: SAVE_OPLINE(); 22430: if (IS_UNUSED == IS_UNUSED) { 22431: zend_constant *c; 22432: zval *retval; 22433: 22434: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 22435: c = CACHED_PTR(opline->op2.literal->cache_slot); 22436: } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) { 22437: if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { 22438: char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); 22439: if(!actual) { 22440: actual = Z_STRVAL_P(opline->op2.zv); 22441: } else { 22442: actual++; 22443: } 22444: /* non-qualified constant - allow text substitution */ 22445: zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); 22446: ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1); 22447: CHECK_EXCEPTION(); 22448: ZEND_VM_NEXT_OPCODE(); 22449: } else { 22450: zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); 22451: } 22452: } else { 22453: CACHE_PTR(opline->op2.literal->cache_slot, c); 22454: } 22455: retval = &EX_T(opline->result.var).tmp_var; 22456: ZVAL_COPY_VALUE(retval, &c->value); 22457: zval_copy_ctor(retval); 22458: CHECK_EXCEPTION(); 22459: ZEND_VM_NEXT_OPCODE(); 22460: } else { 22461: /* class constant */ 22462: zend_class_entry *ce; 22463: zval **value; 22464: 22465: if (IS_UNUSED == IS_CONST) { 22466: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 22467: value = CACHED_PTR(opline->op2.literal->cache_slot); 22468: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 22469: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 22470: CHECK_EXCEPTION(); 22471: ZEND_VM_NEXT_OPCODE(); 22472: } else if (CACHED_PTR(opline->op1.literal->cache_slot)) { 22473: ce = CACHED_PTR(opline->op1.literal->cache_slot); 22474: } else { 22475: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); 22476: if (UNEXPECTED(EG(exception) != NULL)) { 22477: HANDLE_EXCEPTION(); 22478: } 22479: if (UNEXPECTED(ce == NULL)) { 22480: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); 22481: } 22482: CACHE_PTR(opline->op1.literal->cache_slot, ce); 22483: } 22484: } else { 22485: ce = EX_T(opline->op1.var).class_entry; 22486: if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) { 22487: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 22488: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 22489: CHECK_EXCEPTION(); 22490: ZEND_VM_NEXT_OPCODE(); 22491: } 22492: } 22493: 22494: if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) { 22495: if (Z_TYPE_PP(value) == IS_CONSTANT_ARRAY || 22496: (Z_TYPE_PP(value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) { 22497: zend_class_entry *old_scope = EG(scope); 22498: 22499: EG(scope) = ce; 22500: zval_update_constant(value, (void *) 1 TSRMLS_CC); 22501: EG(scope) = old_scope; 22502: } 22503: if (IS_UNUSED == IS_CONST) { 22504: CACHE_PTR(opline->op2.literal->cache_slot, value); 22505: } else { 22506: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value); 22507: } 22508: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); 22509: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 22510: } else { 22511: zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); 22512: } 22513: 22514: CHECK_EXCEPTION(); 22515: ZEND_VM_NEXT_OPCODE(); 22516: } 22517: } 22518: 22519: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22520: { 22521: USE_OPLINE 22522: 22523: array_init(&EX_T(opline->result.var).tmp_var); 22524: if (IS_UNUSED == IS_UNUSED) { 22525: ZEND_VM_NEXT_OPCODE(); 22526: #if 0 || IS_UNUSED != IS_UNUSED 22527: } else { 22528: return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22529: #endif 22530: } 22531: } 22532: 22533: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22534: { 22535: USE_OPLINE 22536: 22537: zval **container; 22538: zval *offset; 22539: ulong hval; 22540: 22541: SAVE_OPLINE(); 22542: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22543: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 22544: SEPARATE_ZVAL_IF_NOT_REF(container); 22545: } 22546: offset = opline->op2.zv; 22547: 22548: if (IS_UNUSED != IS_VAR || container) { 22549: switch (Z_TYPE_PP(container)) { 22550: case IS_ARRAY: { 22551: HashTable *ht = Z_ARRVAL_PP(container); 22552: 22553: switch (Z_TYPE_P(offset)) { 22554: case IS_DOUBLE: 22555: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 22556: zend_hash_index_del(ht, hval); 22557: break; 22558: case IS_RESOURCE: 22559: case IS_BOOL: 22560: case IS_LONG: 22561: hval = Z_LVAL_P(offset); 22562: zend_hash_index_del(ht, hval); 22563: break; 22564: case IS_STRING: 22565: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 22566: Z_ADDREF_P(offset); 22567: } 22568: if (IS_CONST == IS_CONST) { 22569: hval = Z_HASH_P(offset); 22570: } else { 22571: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 22572: if (IS_INTERNED(Z_STRVAL_P(offset))) { 22573: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 22574: } else { 22575: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 22576: } 22577: } 22578: if (ht == &EG(symbol_table)) { 22579: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 22580: } else { 22581: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 22582: } 22583: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 22584: zval_ptr_dtor(&offset); 22585: } 22586: break; 22587: num_index_dim: 22588: zend_hash_index_del(ht, hval); 22589: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 22590: zval_ptr_dtor(&offset); 22591: } 22592: break; 22593: case IS_NULL: 22594: zend_hash_del(ht, "", sizeof("")); 22595: break; 22596: default: 22597: zend_error(E_WARNING, "Illegal offset type in unset"); 22598: break; 22599: } 22600: 22601: break; 22602: } 22603: case IS_OBJECT: 22604: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 22605: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 22606: } 22607: if (0) { 22608: MAKE_REAL_ZVAL_PTR(offset); 22609: } 22610: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 22611: if (0) { 22612: zval_ptr_dtor(&offset); 22613: } else { 22614: 22615: } 22616: break; 22617: case IS_STRING: 22618: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 22619: ZEND_VM_CONTINUE(); /* bailed out before */ 22620: default: 22621: 22622: break; 22623: } 22624: } else { 22625: 22626: } 22627: 22628: CHECK_EXCEPTION(); 22629: ZEND_VM_NEXT_OPCODE(); 22630: } 22631: 22632: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22633: { 22634: USE_OPLINE 22635: 22636: zval **container; 22637: zval *offset; 22638: 22639: SAVE_OPLINE(); 22640: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22641: offset = opline->op2.zv; 22642: 22643: if (IS_UNUSED != IS_VAR || container) { 22644: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 22645: SEPARATE_ZVAL_IF_NOT_REF(container); 22646: } 22647: if (Z_TYPE_PP(container) == IS_OBJECT) { 22648: if (0) { 22649: MAKE_REAL_ZVAL_PTR(offset); 22650: } 22651: if (Z_OBJ_HT_P(*container)->unset_property) { 22652: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22653: } else { 22654: zend_error(E_NOTICE, "Trying to unset property of non-object"); 22655: } 22656: if (0) { 22657: zval_ptr_dtor(&offset); 22658: } else { 22659: 22660: } 22661: } else { 22662: 22663: } 22664: } else { 22665: 22666: } 22667: 22668: CHECK_EXCEPTION(); 22669: ZEND_VM_NEXT_OPCODE(); 22670: } 22671: 22672: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 22673: { 22674: USE_OPLINE 22675: 22676: zval **container; 22677: zval **value = NULL; 22678: int result = 0; 22679: ulong hval; 22680: zval *offset; 22681: 22682: SAVE_OPLINE(); 22683: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22684: 22685: offset = opline->op2.zv; 22686: 22687: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 22688: HashTable *ht; 22689: int isset = 0; 22690: 22691: ht = Z_ARRVAL_PP(container); 22692: 22693: switch (Z_TYPE_P(offset)) { 22694: case IS_DOUBLE: 22695: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 22696: goto num_index_prop; 22697: case IS_RESOURCE: 22698: case IS_BOOL: 22699: case IS_LONG: 22700: hval = Z_LVAL_P(offset); 22701: num_index_prop: 22702: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 22703: isset = 1; 22704: } 22705: break; 22706: case IS_STRING: 22707: if (IS_CONST == IS_CONST) { 22708: hval = Z_HASH_P(offset); 22709: } else { 22710: if (!prop_dim) { 22711: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 22712: } 22713: if (IS_INTERNED(Z_STRVAL_P(offset))) { 22714: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 22715: } else { 22716: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 22717: } 22718: } 22719: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 22720: isset = 1; 22721: } 22722: break; 22723: case IS_NULL: 22724: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 22725: isset = 1; 22726: } 22727: break; 22728: default: 22729: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 22730: break; 22731: } 22732: 22733: if (opline->extended_value & ZEND_ISSET) { 22734: if (isset && Z_TYPE_PP(value) == IS_NULL) { 22735: result = 0; 22736: } else { 22737: result = isset; 22738: } 22739: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 22740: if (!isset || !i_zend_is_true(*value)) { 22741: result = 0; 22742: } else { 22743: result = 1; 22744: } 22745: } 22746: 22747: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 22748: if (0) { 22749: MAKE_REAL_ZVAL_PTR(offset); 22750: } 22751: if (prop_dim) { 22752: if (Z_OBJ_HT_P(*container)->has_property) { 22753: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22754: } else { 22755: zend_error(E_NOTICE, "Trying to check property of non-object"); 22756: result = 0; 22757: } 22758: } else { 22759: if (Z_OBJ_HT_P(*container)->has_dimension) { 22760: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 22761: } else { 22762: zend_error(E_NOTICE, "Trying to check element of non-array"); 22763: result = 0; 22764: } 22765: } 22766: if (0) { 22767: zval_ptr_dtor(&offset); 22768: } else { 22769: 22770: } 22771: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 22772: zval tmp; 22773: 22774: if (Z_TYPE_P(offset) != IS_LONG) { 22775: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 22776: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 22777: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 22778: ZVAL_COPY_VALUE(&tmp, offset); 22779: zval_copy_ctor(&tmp); 22780: convert_to_long(&tmp); 22781: offset = &tmp; 22782: } else { 22783: /* can not be converted to proper offset, return "not set" */ 22784: result = 0; 22785: } 22786: } 22787: if (Z_TYPE_P(offset) == IS_LONG) { 22788: if (opline->extended_value & ZEND_ISSET) { 22789: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 22790: result = 1; 22791: } 22792: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 22793: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 22794: result = 1; 22795: } 22796: } 22797: } 22798: 22799: } else { 22800: 22801: } 22802: 22803: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 22804: if (opline->extended_value & ZEND_ISSET) { 22805: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 22806: } else { 22807: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 22808: } 22809: 22810: CHECK_EXCEPTION(); 22811: ZEND_VM_NEXT_OPCODE(); 22812: } 22813: 22814: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22815: { 22816: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22817: } 22818: 22819: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 22820: { 22821: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22822: } 22823: 22824: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 22825: { 22826: USE_OPLINE 22827: zend_free_op free_op2, free_op_data1; 22828: zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22829: zval *object; 22830: zval *property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 22831: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 22832: int have_get_ptr = 0; 22833: 22834: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 22835: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 22836: } 22837: 22838: make_real_object(object_ptr TSRMLS_CC); 22839: object = *object_ptr; 22840: 22841: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 22842: zend_error(E_WARNING, "Attempt to assign property of non-object"); 22843: zval_dtor(free_op2.var); 22844: FREE_OP(free_op_data1); 22845: 22846: if (RETURN_VALUE_USED(opline)) { 22847: PZVAL_LOCK(&EG(uninitialized_zval)); 22848: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 22849: EX_T(opline->result.var).var.ptr_ptr = NULL; 22850: } 22851: } else { 22852: /* here we are sure we are dealing with an object */ 22853: if (1) { 22854: MAKE_REAL_ZVAL_PTR(property); 22855: } 22856: 22857: /* here property is a string */ 22858: if (opline->extended_value == ZEND_ASSIGN_OBJ 22859: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 22860: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22861: if (zptr != NULL) { /* NULL means no success in getting PTR */ 22862: SEPARATE_ZVAL_IF_NOT_REF(zptr); 22863: 22864: have_get_ptr = 1; 22865: binary_op(*zptr, *zptr, value TSRMLS_CC); 22866: if (RETURN_VALUE_USED(opline)) { 22867: PZVAL_LOCK(*zptr); 22868: EX_T(opline->result.var).var.ptr = *zptr; 22869: EX_T(opline->result.var).var.ptr_ptr = NULL; 22870: } 22871: } 22872: } 22873: 22874: if (!have_get_ptr) { 22875: zval *z = NULL; 22876: 22877: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 22878: if (Z_OBJ_HT_P(object)->read_property) { 22879: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22880: } 22881: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 22882: if (Z_OBJ_HT_P(object)->read_dimension) { 22883: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 22884: } 22885: } 22886: if (z) { 22887: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 22888: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 22889: 22890: if (Z_REFCOUNT_P(z) == 0) { 22891: GC_REMOVE_ZVAL_FROM_BUFFER(z); 22892: zval_dtor(z); 22893: FREE_ZVAL(z); 22894: } 22895: z = value; 22896: } 22897: Z_ADDREF_P(z); 22898: SEPARATE_ZVAL_IF_NOT_REF(&z); 22899: binary_op(z, z, value TSRMLS_CC); 22900: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 22901: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 22902: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 22903: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 22904: } 22905: if (RETURN_VALUE_USED(opline)) { 22906: PZVAL_LOCK(z); 22907: EX_T(opline->result.var).var.ptr = z; 22908: EX_T(opline->result.var).var.ptr_ptr = NULL; 22909: } 22910: zval_ptr_dtor(&z); 22911: } else { 22912: zend_error(E_WARNING, "Attempt to assign property of non-object"); 22913: if (RETURN_VALUE_USED(opline)) { 22914: PZVAL_LOCK(&EG(uninitialized_zval)); 22915: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 22916: EX_T(opline->result.var).var.ptr_ptr = NULL; 22917: } 22918: } 22919: } 22920: 22921: if (1) { 22922: zval_ptr_dtor(&property); 22923: } else { 22924: zval_dtor(free_op2.var); 22925: } 22926: FREE_OP(free_op_data1); 22927: } 22928: 22929: /* assign_obj has two opcodes! */ 22930: CHECK_EXCEPTION(); 22931: ZEND_VM_INC_OPCODE(); 22932: ZEND_VM_NEXT_OPCODE(); 22933: } 22934: 22935: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 22936: { 22937: USE_OPLINE 22938: zend_free_op free_op2, free_op_data2, free_op_data1; 22939: zval **var_ptr; 22940: zval *value; 22941: 22942: SAVE_OPLINE(); 22943: switch (opline->extended_value) { 22944: case ZEND_ASSIGN_OBJ: 22945: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22946: break; 22947: case ZEND_ASSIGN_DIM: { 22948: zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 22949: 22950: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 22951: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 22952: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 22953: if (IS_UNUSED == IS_VAR && !0) { 22954: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 22955: } 22956: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 22957: } else { 22958: zval *dim = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 22959: 22960: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); 22961: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 22962: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 22963: } 22964: } 22965: break; 22966: default: 22967: value = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 22968: var_ptr = NULL; 22969: /* do nothing */ 22970: break; 22971: } 22972: 22973: if (UNEXPECTED(var_ptr == NULL)) { 22974: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 22975: } 22976: 22977: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 22978: if (RETURN_VALUE_USED(opline)) { 22979: PZVAL_LOCK(&EG(uninitialized_zval)); 22980: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 22981: } 22982: zval_dtor(free_op2.var); 22983: 22984: CHECK_EXCEPTION(); 22985: if (opline->extended_value == ZEND_ASSIGN_DIM) { 22986: ZEND_VM_INC_OPCODE(); 22987: } 22988: ZEND_VM_NEXT_OPCODE(); 22989: } 22990: 22991: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 22992: 22993: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 22994: && Z_OBJ_HANDLER_PP(var_ptr, get) 22995: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 22996: /* proxy object */ 22997: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 22998: Z_ADDREF_P(objval); 22999: binary_op(objval, objval, value TSRMLS_CC); 23000: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 23001: zval_ptr_dtor(&objval); 23002: } else { 23003: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 23004: } 23005: 23006: if (RETURN_VALUE_USED(opline)) { 23007: PZVAL_LOCK(*var_ptr); 23008: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 23009: } 23010: zval_dtor(free_op2.var); 23011: 23012: if (opline->extended_value == ZEND_ASSIGN_DIM) { 23013: FREE_OP(free_op_data1); 23014: FREE_OP_VAR_PTR(free_op_data2); 23015: 23016: CHECK_EXCEPTION(); 23017: ZEND_VM_INC_OPCODE(); 23018: } else { 23019: 23020: CHECK_EXCEPTION(); 23021: } 23022: ZEND_VM_NEXT_OPCODE(); 23023: } 23024: 23025: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23026: { 23027: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23028: } 23029: 23030: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23031: { 23032: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23033: } 23034: 23035: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23036: { 23037: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23038: } 23039: 23040: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23041: { 23042: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23043: } 23044: 23045: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23046: { 23047: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23048: } 23049: 23050: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23051: { 23052: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23053: } 23054: 23055: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23056: { 23057: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23058: } 23059: 23060: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23061: { 23062: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23063: } 23064: 23065: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23066: { 23067: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23068: } 23069: 23070: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23071: { 23072: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23073: } 23074: 23075: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23076: { 23077: return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23078: } 23079: 23080: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 23081: { 23082: USE_OPLINE 23083: zend_free_op free_op2; 23084: zval **object_ptr; 23085: zval *object; 23086: zval *property; 23087: zval **retval; 23088: int have_get_ptr = 0; 23089: 23090: SAVE_OPLINE(); 23091: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23092: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23093: retval = &EX_T(opline->result.var).var.ptr; 23094: 23095: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 23096: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 23097: } 23098: 23099: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 23100: object = *object_ptr; 23101: 23102: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 23103: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 23104: zval_dtor(free_op2.var); 23105: if (RETURN_VALUE_USED(opline)) { 23106: PZVAL_LOCK(&EG(uninitialized_zval)); 23107: *retval = &EG(uninitialized_zval); 23108: } 23109: 23110: CHECK_EXCEPTION(); 23111: ZEND_VM_NEXT_OPCODE(); 23112: } 23113: 23114: /* here we are sure we are dealing with an object */ 23115: 23116: if (1) { 23117: MAKE_REAL_ZVAL_PTR(property); 23118: } 23119: 23120: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 23121: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23122: if (zptr != NULL) { /* NULL means no success in getting PTR */ 23123: SEPARATE_ZVAL_IF_NOT_REF(zptr); 23124: 23125: have_get_ptr = 1; 23126: incdec_op(*zptr); 23127: if (RETURN_VALUE_USED(opline)) { 23128: *retval = *zptr; 23129: PZVAL_LOCK(*retval); 23130: } 23131: } 23132: } 23133: 23134: if (!have_get_ptr) { 23135: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 23136: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23137: 23138: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 23139: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 23140: 23141: if (Z_REFCOUNT_P(z) == 0) { 23142: GC_REMOVE_ZVAL_FROM_BUFFER(z); 23143: zval_dtor(z); 23144: FREE_ZVAL(z); 23145: } 23146: z = value; 23147: } 23148: Z_ADDREF_P(z); 23149: SEPARATE_ZVAL_IF_NOT_REF(&z); 23150: incdec_op(z); 23151: *retval = z; 23152: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23153: SELECTIVE_PZVAL_LOCK(*retval, opline); 23154: zval_ptr_dtor(&z); 23155: } else { 23156: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 23157: if (RETURN_VALUE_USED(opline)) { 23158: PZVAL_LOCK(&EG(uninitialized_zval)); 23159: *retval = &EG(uninitialized_zval); 23160: } 23161: } 23162: } 23163: 23164: if (1) { 23165: zval_ptr_dtor(&property); 23166: } else { 23167: zval_dtor(free_op2.var); 23168: } 23169: 23170: CHECK_EXCEPTION(); 23171: ZEND_VM_NEXT_OPCODE(); 23172: } 23173: 23174: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23175: { 23176: return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23177: } 23178: 23179: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23180: { 23181: return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23182: } 23183: 23184: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 23185: { 23186: USE_OPLINE 23187: zend_free_op free_op2; 23188: zval **object_ptr; 23189: zval *object; 23190: zval *property; 23191: zval *retval; 23192: int have_get_ptr = 0; 23193: 23194: SAVE_OPLINE(); 23195: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23196: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23197: retval = &EX_T(opline->result.var).tmp_var; 23198: 23199: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 23200: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 23201: } 23202: 23203: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 23204: object = *object_ptr; 23205: 23206: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 23207: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 23208: zval_dtor(free_op2.var); 23209: ZVAL_NULL(retval); 23210: 23211: CHECK_EXCEPTION(); 23212: ZEND_VM_NEXT_OPCODE(); 23213: } 23214: 23215: /* here we are sure we are dealing with an object */ 23216: 23217: if (1) { 23218: MAKE_REAL_ZVAL_PTR(property); 23219: } 23220: 23221: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 23222: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23223: if (zptr != NULL) { /* NULL means no success in getting PTR */ 23224: have_get_ptr = 1; 23225: SEPARATE_ZVAL_IF_NOT_REF(zptr); 23226: 23227: ZVAL_COPY_VALUE(retval, *zptr); 23228: zendi_zval_copy_ctor(*retval); 23229: 23230: incdec_op(*zptr); 23231: 23232: } 23233: } 23234: 23235: if (!have_get_ptr) { 23236: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 23237: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23238: zval *z_copy; 23239: 23240: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 23241: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 23242: 23243: if (Z_REFCOUNT_P(z) == 0) { 23244: GC_REMOVE_ZVAL_FROM_BUFFER(z); 23245: zval_dtor(z); 23246: FREE_ZVAL(z); 23247: } 23248: z = value; 23249: } 23250: ZVAL_COPY_VALUE(retval, z); 23251: zendi_zval_copy_ctor(*retval); 23252: ALLOC_ZVAL(z_copy); 23253: INIT_PZVAL_COPY(z_copy, z); 23254: zendi_zval_copy_ctor(*z_copy); 23255: incdec_op(z_copy); 23256: Z_ADDREF_P(z); 23257: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23258: zval_ptr_dtor(&z_copy); 23259: zval_ptr_dtor(&z); 23260: } else { 23261: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 23262: ZVAL_NULL(retval); 23263: } 23264: } 23265: 23266: if (1) { 23267: zval_ptr_dtor(&property); 23268: } else { 23269: zval_dtor(free_op2.var); 23270: } 23271: 23272: CHECK_EXCEPTION(); 23273: ZEND_VM_NEXT_OPCODE(); 23274: } 23275: 23276: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23277: { 23278: return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23279: } 23280: 23281: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23282: { 23283: return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23284: } 23285: 23286: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS) 23287: { 23288: USE_OPLINE 23289: 23290: zval *container; 23291: zend_free_op free_op2; 23292: zval *offset; 23293: 23294: SAVE_OPLINE(); 23295: container = _get_obj_zval_ptr_unused(TSRMLS_C); 23296: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23297: 23298: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 23299: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 23300: zend_error(E_NOTICE, "Trying to get property of non-object"); 23301: PZVAL_LOCK(&EG(uninitialized_zval)); 23302: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 23303: zval_dtor(free_op2.var); 23304: } else { 23305: zval *retval; 23306: 23307: if (1) { 23308: MAKE_REAL_ZVAL_PTR(offset); 23309: } 23310: 23311: /* here we are sure we are dealing with an object */ 23312: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23313: 23314: PZVAL_LOCK(retval); 23315: AI_SET_PTR(&EX_T(opline->result.var), retval); 23316: 23317: if (1) { 23318: zval_ptr_dtor(&offset); 23319: } else { 23320: zval_dtor(free_op2.var); 23321: } 23322: } 23323: 23324: CHECK_EXCEPTION(); 23325: ZEND_VM_NEXT_OPCODE(); 23326: } 23327: 23328: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23329: { 23330: return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23331: } 23332: 23333: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23334: { 23335: USE_OPLINE 23336: zend_free_op free_op1, free_op2; 23337: zval *property; 23338: zval **container; 23339: 23340: SAVE_OPLINE(); 23341: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23342: 23343: if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 23344: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 23345: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 23346: } 23347: 23348: if (1) { 23349: MAKE_REAL_ZVAL_PTR(property); 23350: } 23351: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23352: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 23353: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 23354: } 23355: 23356: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 23357: if (1) { 23358: zval_ptr_dtor(&property); 23359: } else { 23360: zval_dtor(free_op2.var); 23361: } 23362: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 23363: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 23364: } 23365: 23366: /* We are going to assign the result by reference */ 23367: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 23368: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 23369: 23370: Z_DELREF_PP(retval_ptr); 23371: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 23372: Z_ADDREF_PP(retval_ptr); 23373: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 23374: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 23375: } 23376: 23377: CHECK_EXCEPTION(); 23378: ZEND_VM_NEXT_OPCODE(); 23379: } 23380: 23381: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23382: { 23383: USE_OPLINE 23384: zend_free_op free_op1, free_op2; 23385: zval *property; 23386: zval **container; 23387: 23388: SAVE_OPLINE(); 23389: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23390: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23391: 23392: if (1) { 23393: MAKE_REAL_ZVAL_PTR(property); 23394: } 23395: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 23396: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 23397: } 23398: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 23399: if (1) { 23400: zval_ptr_dtor(&property); 23401: } else { 23402: zval_dtor(free_op2.var); 23403: } 23404: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 23405: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 23406: } 23407: 23408: CHECK_EXCEPTION(); 23409: ZEND_VM_NEXT_OPCODE(); 23410: } 23411: 23412: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23413: { 23414: USE_OPLINE 23415: 23416: zval *container; 23417: zend_free_op free_op2; 23418: zval *offset; 23419: 23420: SAVE_OPLINE(); 23421: container = _get_obj_zval_ptr_unused(TSRMLS_C); 23422: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23423: 23424: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 23425: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 23426: PZVAL_LOCK(&EG(uninitialized_zval)); 23427: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 23428: zval_dtor(free_op2.var); 23429: } else { 23430: zval *retval; 23431: 23432: if (1) { 23433: MAKE_REAL_ZVAL_PTR(offset); 23434: } 23435: 23436: /* here we are sure we are dealing with an object */ 23437: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23438: 23439: PZVAL_LOCK(retval); 23440: AI_SET_PTR(&EX_T(opline->result.var), retval); 23441: 23442: if (1) { 23443: zval_ptr_dtor(&offset); 23444: } else { 23445: zval_dtor(free_op2.var); 23446: } 23447: } 23448: 23449: CHECK_EXCEPTION(); 23450: ZEND_VM_NEXT_OPCODE(); 23451: } 23452: 23453: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23454: { 23455: USE_OPLINE 23456: 23457: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 23458: /* Behave like FETCH_OBJ_W */ 23459: zend_free_op free_op1, free_op2; 23460: zval *property; 23461: zval **container; 23462: 23463: SAVE_OPLINE(); 23464: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23465: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23466: 23467: if (1) { 23468: MAKE_REAL_ZVAL_PTR(property); 23469: } 23470: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 23471: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 23472: } 23473: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 23474: if (1) { 23475: zval_ptr_dtor(&property); 23476: } else { 23477: zval_dtor(free_op2.var); 23478: } 23479: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 23480: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 23481: } 23482: 23483: CHECK_EXCEPTION(); 23484: ZEND_VM_NEXT_OPCODE(); 23485: } else { 23486: return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23487: } 23488: } 23489: 23490: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23491: { 23492: USE_OPLINE 23493: zend_free_op free_op1, free_op2, free_res; 23494: zval **container; 23495: zval *property; 23496: 23497: SAVE_OPLINE(); 23498: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23499: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23500: 23501: if (IS_UNUSED == IS_CV) { 23502: if (container != &EG(uninitialized_zval_ptr)) { 23503: SEPARATE_ZVAL_IF_NOT_REF(container); 23504: } 23505: } 23506: if (1) { 23507: MAKE_REAL_ZVAL_PTR(property); 23508: } 23509: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 23510: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 23511: } 23512: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 23513: if (1) { 23514: zval_ptr_dtor(&property); 23515: } else { 23516: zval_dtor(free_op2.var); 23517: } 23518: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 23519: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 23520: } 23521: 23522: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 23523: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 23524: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 23525: } 23526: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 23527: FREE_OP_VAR_PTR(free_res); 23528: CHECK_EXCEPTION(); 23529: ZEND_VM_NEXT_OPCODE(); 23530: } 23531: 23532: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23533: { 23534: USE_OPLINE 23535: zend_free_op free_op2; 23536: zval **object_ptr; 23537: zval *property_name; 23538: 23539: SAVE_OPLINE(); 23540: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23541: property_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23542: 23543: if (1) { 23544: MAKE_REAL_ZVAL_PTR(property_name); 23545: } 23546: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 23547: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 23548: } 23549: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23550: if (1) { 23551: zval_ptr_dtor(&property_name); 23552: } else { 23553: zval_dtor(free_op2.var); 23554: } 23555: 23556: /* assign_obj has two opcodes! */ 23557: CHECK_EXCEPTION(); 23558: ZEND_VM_INC_OPCODE(); 23559: ZEND_VM_NEXT_OPCODE(); 23560: } 23561: 23562: static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23563: { 23564: USE_OPLINE 23565: zend_free_op free_op2; 23566: zval *str = &EX_T(opline->result.var).tmp_var; 23567: zval *var; 23568: zval var_copy; 23569: int use_copy = 0; 23570: 23571: SAVE_OPLINE(); 23572: var = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23573: 23574: if (IS_UNUSED == IS_UNUSED) { 23575: /* Initialize for erealloc in add_string_to_string */ 23576: Z_STRVAL_P(str) = NULL; 23577: Z_STRLEN_P(str) = 0; 23578: Z_TYPE_P(str) = IS_STRING; 23579: 23580: INIT_PZVAL(str); 23581: } 23582: 23583: if (Z_TYPE_P(var) != IS_STRING) { 23584: zend_make_printable_zval(var, &var_copy, &use_copy); 23585: 23586: if (use_copy) { 23587: var = &var_copy; 23588: } 23589: } 23590: add_string_to_string(str, str, var); 23591: 23592: if (use_copy) { 23593: zval_dtor(var); 23594: } 23595: /* original comment, possibly problematic: 23596: * FREE_OP is missing intentionally here - we're always working on the same temporary variable 23597: * (Zeev): I don't think it's problematic, we only use variables 23598: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're 23599: * string offsets or overloaded objects 23600: */ 23601: zval_dtor(free_op2.var); 23602: 23603: CHECK_EXCEPTION(); 23604: ZEND_VM_NEXT_OPCODE(); 23605: } 23606: 23607: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23608: { 23609: USE_OPLINE 23610: zval *function_name; 23611: char *function_name_strval; 23612: int function_name_strlen; 23613: zend_free_op free_op2; 23614: 23615: SAVE_OPLINE(); 23616: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 23617: 23618: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23619: 23620: if (IS_TMP_VAR != IS_CONST && 23621: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 23622: zend_error_noreturn(E_ERROR, "Method name must be a string"); 23623: } 23624: 23625: function_name_strval = Z_STRVAL_P(function_name); 23626: function_name_strlen = Z_STRLEN_P(function_name); 23627: 23628: EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C); 23629: 23630: if (EXPECTED(EX(object) != NULL) && 23631: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 23632: EX(called_scope) = Z_OBJCE_P(EX(object)); 23633: 23634: if (IS_TMP_VAR != IS_CONST || 23635: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 23636: zval *object = EX(object); 23637: 23638: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 23639: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 23640: } 23641: 23642: /* First, locate the function. */ 23643: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 23644: if (UNEXPECTED(EX(fbc) == NULL)) { 23645: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 23646: } 23647: if (IS_TMP_VAR == IS_CONST && 23648: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 23649: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 23650: EXPECTED(EX(object) == object)) { 23651: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 23652: } 23653: } 23654: } else { 23655: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 23656: } 23657: 23658: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 23659: EX(object) = NULL; 23660: } else { 23661: if (!PZVAL_IS_REF(EX(object))) { 23662: Z_ADDREF_P(EX(object)); /* For $this pointer */ 23663: } else { 23664: zval *this_ptr; 23665: ALLOC_ZVAL(this_ptr); 23666: INIT_PZVAL_COPY(this_ptr, EX(object)); 23667: zval_copy_ctor(this_ptr); 23668: EX(object) = this_ptr; 23669: } 23670: } 23671: 23672: zval_dtor(free_op2.var); 23673: 23674: CHECK_EXCEPTION(); 23675: ZEND_VM_NEXT_OPCODE(); 23676: } 23677: 23678: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23679: { 23680: USE_OPLINE 23681: 23682: array_init(&EX_T(opline->result.var).tmp_var); 23683: if (IS_UNUSED == IS_UNUSED) { 23684: ZEND_VM_NEXT_OPCODE(); 23685: #if 0 || IS_UNUSED != IS_UNUSED 23686: } else { 23687: return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23688: #endif 23689: } 23690: } 23691: 23692: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23693: { 23694: USE_OPLINE 23695: zend_free_op free_op2; 23696: zval **container; 23697: zval *offset; 23698: ulong hval; 23699: 23700: SAVE_OPLINE(); 23701: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23702: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 23703: SEPARATE_ZVAL_IF_NOT_REF(container); 23704: } 23705: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23706: 23707: if (IS_UNUSED != IS_VAR || container) { 23708: switch (Z_TYPE_PP(container)) { 23709: case IS_ARRAY: { 23710: HashTable *ht = Z_ARRVAL_PP(container); 23711: 23712: switch (Z_TYPE_P(offset)) { 23713: case IS_DOUBLE: 23714: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 23715: zend_hash_index_del(ht, hval); 23716: break; 23717: case IS_RESOURCE: 23718: case IS_BOOL: 23719: case IS_LONG: 23720: hval = Z_LVAL_P(offset); 23721: zend_hash_index_del(ht, hval); 23722: break; 23723: case IS_STRING: 23724: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 23725: Z_ADDREF_P(offset); 23726: } 23727: if (IS_TMP_VAR == IS_CONST) { 23728: hval = Z_HASH_P(offset); 23729: } else { 23730: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 23731: if (IS_INTERNED(Z_STRVAL_P(offset))) { 23732: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 23733: } else { 23734: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 23735: } 23736: } 23737: if (ht == &EG(symbol_table)) { 23738: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 23739: } else { 23740: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 23741: } 23742: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 23743: zval_ptr_dtor(&offset); 23744: } 23745: break; 23746: num_index_dim: 23747: zend_hash_index_del(ht, hval); 23748: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 23749: zval_ptr_dtor(&offset); 23750: } 23751: break; 23752: case IS_NULL: 23753: zend_hash_del(ht, "", sizeof("")); 23754: break; 23755: default: 23756: zend_error(E_WARNING, "Illegal offset type in unset"); 23757: break; 23758: } 23759: zval_dtor(free_op2.var); 23760: break; 23761: } 23762: case IS_OBJECT: 23763: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 23764: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 23765: } 23766: if (1) { 23767: MAKE_REAL_ZVAL_PTR(offset); 23768: } 23769: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 23770: if (1) { 23771: zval_ptr_dtor(&offset); 23772: } else { 23773: zval_dtor(free_op2.var); 23774: } 23775: break; 23776: case IS_STRING: 23777: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 23778: ZEND_VM_CONTINUE(); /* bailed out before */ 23779: default: 23780: zval_dtor(free_op2.var); 23781: break; 23782: } 23783: } else { 23784: zval_dtor(free_op2.var); 23785: } 23786: 23787: CHECK_EXCEPTION(); 23788: ZEND_VM_NEXT_OPCODE(); 23789: } 23790: 23791: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23792: { 23793: USE_OPLINE 23794: zend_free_op free_op2; 23795: zval **container; 23796: zval *offset; 23797: 23798: SAVE_OPLINE(); 23799: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23800: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23801: 23802: if (IS_UNUSED != IS_VAR || container) { 23803: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 23804: SEPARATE_ZVAL_IF_NOT_REF(container); 23805: } 23806: if (Z_TYPE_PP(container) == IS_OBJECT) { 23807: if (1) { 23808: MAKE_REAL_ZVAL_PTR(offset); 23809: } 23810: if (Z_OBJ_HT_P(*container)->unset_property) { 23811: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23812: } else { 23813: zend_error(E_NOTICE, "Trying to unset property of non-object"); 23814: } 23815: if (1) { 23816: zval_ptr_dtor(&offset); 23817: } else { 23818: zval_dtor(free_op2.var); 23819: } 23820: } else { 23821: zval_dtor(free_op2.var); 23822: } 23823: } else { 23824: zval_dtor(free_op2.var); 23825: } 23826: 23827: CHECK_EXCEPTION(); 23828: ZEND_VM_NEXT_OPCODE(); 23829: } 23830: 23831: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 23832: { 23833: USE_OPLINE 23834: zend_free_op free_op2; 23835: zval **container; 23836: zval **value = NULL; 23837: int result = 0; 23838: ulong hval; 23839: zval *offset; 23840: 23841: SAVE_OPLINE(); 23842: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23843: 23844: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23845: 23846: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 23847: HashTable *ht; 23848: int isset = 0; 23849: 23850: ht = Z_ARRVAL_PP(container); 23851: 23852: switch (Z_TYPE_P(offset)) { 23853: case IS_DOUBLE: 23854: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 23855: goto num_index_prop; 23856: case IS_RESOURCE: 23857: case IS_BOOL: 23858: case IS_LONG: 23859: hval = Z_LVAL_P(offset); 23860: num_index_prop: 23861: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 23862: isset = 1; 23863: } 23864: break; 23865: case IS_STRING: 23866: if (IS_TMP_VAR == IS_CONST) { 23867: hval = Z_HASH_P(offset); 23868: } else { 23869: if (!prop_dim) { 23870: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 23871: } 23872: if (IS_INTERNED(Z_STRVAL_P(offset))) { 23873: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 23874: } else { 23875: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 23876: } 23877: } 23878: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 23879: isset = 1; 23880: } 23881: break; 23882: case IS_NULL: 23883: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 23884: isset = 1; 23885: } 23886: break; 23887: default: 23888: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 23889: break; 23890: } 23891: 23892: if (opline->extended_value & ZEND_ISSET) { 23893: if (isset && Z_TYPE_PP(value) == IS_NULL) { 23894: result = 0; 23895: } else { 23896: result = isset; 23897: } 23898: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 23899: if (!isset || !i_zend_is_true(*value)) { 23900: result = 0; 23901: } else { 23902: result = 1; 23903: } 23904: } 23905: zval_dtor(free_op2.var); 23906: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 23907: if (1) { 23908: MAKE_REAL_ZVAL_PTR(offset); 23909: } 23910: if (prop_dim) { 23911: if (Z_OBJ_HT_P(*container)->has_property) { 23912: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 23913: } else { 23914: zend_error(E_NOTICE, "Trying to check property of non-object"); 23915: result = 0; 23916: } 23917: } else { 23918: if (Z_OBJ_HT_P(*container)->has_dimension) { 23919: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 23920: } else { 23921: zend_error(E_NOTICE, "Trying to check element of non-array"); 23922: result = 0; 23923: } 23924: } 23925: if (1) { 23926: zval_ptr_dtor(&offset); 23927: } else { 23928: zval_dtor(free_op2.var); 23929: } 23930: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 23931: zval tmp; 23932: 23933: if (Z_TYPE_P(offset) != IS_LONG) { 23934: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 23935: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 23936: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 23937: ZVAL_COPY_VALUE(&tmp, offset); 23938: zval_copy_ctor(&tmp); 23939: convert_to_long(&tmp); 23940: offset = &tmp; 23941: } else { 23942: /* can not be converted to proper offset, return "not set" */ 23943: result = 0; 23944: } 23945: } 23946: if (Z_TYPE_P(offset) == IS_LONG) { 23947: if (opline->extended_value & ZEND_ISSET) { 23948: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 23949: result = 1; 23950: } 23951: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 23952: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 23953: result = 1; 23954: } 23955: } 23956: } 23957: zval_dtor(free_op2.var); 23958: } else { 23959: zval_dtor(free_op2.var); 23960: } 23961: 23962: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 23963: if (opline->extended_value & ZEND_ISSET) { 23964: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 23965: } else { 23966: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 23967: } 23968: 23969: CHECK_EXCEPTION(); 23970: ZEND_VM_NEXT_OPCODE(); 23971: } 23972: 23973: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23974: { 23975: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23976: } 23977: 23978: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 23979: { 23980: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 23981: } 23982: 23983: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 23984: { 23985: USE_OPLINE 23986: zend_free_op free_op2, free_op_data1; 23987: zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 23988: zval *object; 23989: zval *property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 23990: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 23991: int have_get_ptr = 0; 23992: 23993: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 23994: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 23995: } 23996: 23997: make_real_object(object_ptr TSRMLS_CC); 23998: object = *object_ptr; 23999: 24000: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 24001: zend_error(E_WARNING, "Attempt to assign property of non-object"); 24002: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24003: FREE_OP(free_op_data1); 24004: 24005: if (RETURN_VALUE_USED(opline)) { 24006: PZVAL_LOCK(&EG(uninitialized_zval)); 24007: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 24008: EX_T(opline->result.var).var.ptr_ptr = NULL; 24009: } 24010: } else { 24011: /* here we are sure we are dealing with an object */ 24012: if (0) { 24013: MAKE_REAL_ZVAL_PTR(property); 24014: } 24015: 24016: /* here property is a string */ 24017: if (opline->extended_value == ZEND_ASSIGN_OBJ 24018: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 24019: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24020: if (zptr != NULL) { /* NULL means no success in getting PTR */ 24021: SEPARATE_ZVAL_IF_NOT_REF(zptr); 24022: 24023: have_get_ptr = 1; 24024: binary_op(*zptr, *zptr, value TSRMLS_CC); 24025: if (RETURN_VALUE_USED(opline)) { 24026: PZVAL_LOCK(*zptr); 24027: EX_T(opline->result.var).var.ptr = *zptr; 24028: EX_T(opline->result.var).var.ptr_ptr = NULL; 24029: } 24030: } 24031: } 24032: 24033: if (!have_get_ptr) { 24034: zval *z = NULL; 24035: 24036: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 24037: if (Z_OBJ_HT_P(object)->read_property) { 24038: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24039: } 24040: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 24041: if (Z_OBJ_HT_P(object)->read_dimension) { 24042: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 24043: } 24044: } 24045: if (z) { 24046: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 24047: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 24048: 24049: if (Z_REFCOUNT_P(z) == 0) { 24050: GC_REMOVE_ZVAL_FROM_BUFFER(z); 24051: zval_dtor(z); 24052: FREE_ZVAL(z); 24053: } 24054: z = value; 24055: } 24056: Z_ADDREF_P(z); 24057: SEPARATE_ZVAL_IF_NOT_REF(&z); 24058: binary_op(z, z, value TSRMLS_CC); 24059: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 24060: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24061: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 24062: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 24063: } 24064: if (RETURN_VALUE_USED(opline)) { 24065: PZVAL_LOCK(z); 24066: EX_T(opline->result.var).var.ptr = z; 24067: EX_T(opline->result.var).var.ptr_ptr = NULL; 24068: } 24069: zval_ptr_dtor(&z); 24070: } else { 24071: zend_error(E_WARNING, "Attempt to assign property of non-object"); 24072: if (RETURN_VALUE_USED(opline)) { 24073: PZVAL_LOCK(&EG(uninitialized_zval)); 24074: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 24075: EX_T(opline->result.var).var.ptr_ptr = NULL; 24076: } 24077: } 24078: } 24079: 24080: if (0) { 24081: zval_ptr_dtor(&property); 24082: } else { 24083: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24084: } 24085: FREE_OP(free_op_data1); 24086: } 24087: 24088: /* assign_obj has two opcodes! */ 24089: CHECK_EXCEPTION(); 24090: ZEND_VM_INC_OPCODE(); 24091: ZEND_VM_NEXT_OPCODE(); 24092: } 24093: 24094: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 24095: { 24096: USE_OPLINE 24097: zend_free_op free_op2, free_op_data2, free_op_data1; 24098: zval **var_ptr; 24099: zval *value; 24100: 24101: SAVE_OPLINE(); 24102: switch (opline->extended_value) { 24103: case ZEND_ASSIGN_OBJ: 24104: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24105: break; 24106: case ZEND_ASSIGN_DIM: { 24107: zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24108: 24109: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 24110: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 24111: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 24112: if (IS_UNUSED == IS_VAR && !0) { 24113: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 24114: } 24115: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24116: } else { 24117: zval *dim = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24118: 24119: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC); 24120: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 24121: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 24122: } 24123: } 24124: break; 24125: default: 24126: value = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24127: var_ptr = NULL; 24128: /* do nothing */ 24129: break; 24130: } 24131: 24132: if (UNEXPECTED(var_ptr == NULL)) { 24133: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 24134: } 24135: 24136: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 24137: if (RETURN_VALUE_USED(opline)) { 24138: PZVAL_LOCK(&EG(uninitialized_zval)); 24139: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 24140: } 24141: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24142: 24143: CHECK_EXCEPTION(); 24144: if (opline->extended_value == ZEND_ASSIGN_DIM) { 24145: ZEND_VM_INC_OPCODE(); 24146: } 24147: ZEND_VM_NEXT_OPCODE(); 24148: } 24149: 24150: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 24151: 24152: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 24153: && Z_OBJ_HANDLER_PP(var_ptr, get) 24154: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 24155: /* proxy object */ 24156: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 24157: Z_ADDREF_P(objval); 24158: binary_op(objval, objval, value TSRMLS_CC); 24159: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 24160: zval_ptr_dtor(&objval); 24161: } else { 24162: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 24163: } 24164: 24165: if (RETURN_VALUE_USED(opline)) { 24166: PZVAL_LOCK(*var_ptr); 24167: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 24168: } 24169: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24170: 24171: if (opline->extended_value == ZEND_ASSIGN_DIM) { 24172: FREE_OP(free_op_data1); 24173: FREE_OP_VAR_PTR(free_op_data2); 24174: 24175: CHECK_EXCEPTION(); 24176: ZEND_VM_INC_OPCODE(); 24177: } else { 24178: 24179: CHECK_EXCEPTION(); 24180: } 24181: ZEND_VM_NEXT_OPCODE(); 24182: } 24183: 24184: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24185: { 24186: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24187: } 24188: 24189: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24190: { 24191: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24192: } 24193: 24194: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24195: { 24196: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24197: } 24198: 24199: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24200: { 24201: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24202: } 24203: 24204: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24205: { 24206: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24207: } 24208: 24209: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24210: { 24211: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24212: } 24213: 24214: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24215: { 24216: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24217: } 24218: 24219: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24220: { 24221: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24222: } 24223: 24224: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24225: { 24226: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24227: } 24228: 24229: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24230: { 24231: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24232: } 24233: 24234: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24235: { 24236: return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24237: } 24238: 24239: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 24240: { 24241: USE_OPLINE 24242: zend_free_op free_op2; 24243: zval **object_ptr; 24244: zval *object; 24245: zval *property; 24246: zval **retval; 24247: int have_get_ptr = 0; 24248: 24249: SAVE_OPLINE(); 24250: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24251: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24252: retval = &EX_T(opline->result.var).var.ptr; 24253: 24254: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 24255: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 24256: } 24257: 24258: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 24259: object = *object_ptr; 24260: 24261: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 24262: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 24263: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24264: if (RETURN_VALUE_USED(opline)) { 24265: PZVAL_LOCK(&EG(uninitialized_zval)); 24266: *retval = &EG(uninitialized_zval); 24267: } 24268: 24269: CHECK_EXCEPTION(); 24270: ZEND_VM_NEXT_OPCODE(); 24271: } 24272: 24273: /* here we are sure we are dealing with an object */ 24274: 24275: if (0) { 24276: MAKE_REAL_ZVAL_PTR(property); 24277: } 24278: 24279: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 24280: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24281: if (zptr != NULL) { /* NULL means no success in getting PTR */ 24282: SEPARATE_ZVAL_IF_NOT_REF(zptr); 24283: 24284: have_get_ptr = 1; 24285: incdec_op(*zptr); 24286: if (RETURN_VALUE_USED(opline)) { 24287: *retval = *zptr; 24288: PZVAL_LOCK(*retval); 24289: } 24290: } 24291: } 24292: 24293: if (!have_get_ptr) { 24294: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 24295: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24296: 24297: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 24298: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 24299: 24300: if (Z_REFCOUNT_P(z) == 0) { 24301: GC_REMOVE_ZVAL_FROM_BUFFER(z); 24302: zval_dtor(z); 24303: FREE_ZVAL(z); 24304: } 24305: z = value; 24306: } 24307: Z_ADDREF_P(z); 24308: SEPARATE_ZVAL_IF_NOT_REF(&z); 24309: incdec_op(z); 24310: *retval = z; 24311: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24312: SELECTIVE_PZVAL_LOCK(*retval, opline); 24313: zval_ptr_dtor(&z); 24314: } else { 24315: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 24316: if (RETURN_VALUE_USED(opline)) { 24317: PZVAL_LOCK(&EG(uninitialized_zval)); 24318: *retval = &EG(uninitialized_zval); 24319: } 24320: } 24321: } 24322: 24323: if (0) { 24324: zval_ptr_dtor(&property); 24325: } else { 24326: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24327: } 24328: 24329: CHECK_EXCEPTION(); 24330: ZEND_VM_NEXT_OPCODE(); 24331: } 24332: 24333: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24334: { 24335: return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24336: } 24337: 24338: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24339: { 24340: return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24341: } 24342: 24343: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 24344: { 24345: USE_OPLINE 24346: zend_free_op free_op2; 24347: zval **object_ptr; 24348: zval *object; 24349: zval *property; 24350: zval *retval; 24351: int have_get_ptr = 0; 24352: 24353: SAVE_OPLINE(); 24354: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24355: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24356: retval = &EX_T(opline->result.var).tmp_var; 24357: 24358: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 24359: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 24360: } 24361: 24362: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 24363: object = *object_ptr; 24364: 24365: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 24366: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 24367: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24368: ZVAL_NULL(retval); 24369: 24370: CHECK_EXCEPTION(); 24371: ZEND_VM_NEXT_OPCODE(); 24372: } 24373: 24374: /* here we are sure we are dealing with an object */ 24375: 24376: if (0) { 24377: MAKE_REAL_ZVAL_PTR(property); 24378: } 24379: 24380: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 24381: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24382: if (zptr != NULL) { /* NULL means no success in getting PTR */ 24383: have_get_ptr = 1; 24384: SEPARATE_ZVAL_IF_NOT_REF(zptr); 24385: 24386: ZVAL_COPY_VALUE(retval, *zptr); 24387: zendi_zval_copy_ctor(*retval); 24388: 24389: incdec_op(*zptr); 24390: 24391: } 24392: } 24393: 24394: if (!have_get_ptr) { 24395: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 24396: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24397: zval *z_copy; 24398: 24399: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 24400: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 24401: 24402: if (Z_REFCOUNT_P(z) == 0) { 24403: GC_REMOVE_ZVAL_FROM_BUFFER(z); 24404: zval_dtor(z); 24405: FREE_ZVAL(z); 24406: } 24407: z = value; 24408: } 24409: ZVAL_COPY_VALUE(retval, z); 24410: zendi_zval_copy_ctor(*retval); 24411: ALLOC_ZVAL(z_copy); 24412: INIT_PZVAL_COPY(z_copy, z); 24413: zendi_zval_copy_ctor(*z_copy); 24414: incdec_op(z_copy); 24415: Z_ADDREF_P(z); 24416: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24417: zval_ptr_dtor(&z_copy); 24418: zval_ptr_dtor(&z); 24419: } else { 24420: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 24421: ZVAL_NULL(retval); 24422: } 24423: } 24424: 24425: if (0) { 24426: zval_ptr_dtor(&property); 24427: } else { 24428: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24429: } 24430: 24431: CHECK_EXCEPTION(); 24432: ZEND_VM_NEXT_OPCODE(); 24433: } 24434: 24435: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24436: { 24437: return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24438: } 24439: 24440: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24441: { 24442: return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24443: } 24444: 24445: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS) 24446: { 24447: USE_OPLINE 24448: 24449: zval *container; 24450: zend_free_op free_op2; 24451: zval *offset; 24452: 24453: SAVE_OPLINE(); 24454: container = _get_obj_zval_ptr_unused(TSRMLS_C); 24455: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24456: 24457: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 24458: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 24459: zend_error(E_NOTICE, "Trying to get property of non-object"); 24460: PZVAL_LOCK(&EG(uninitialized_zval)); 24461: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 24462: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24463: } else { 24464: zval *retval; 24465: 24466: if (0) { 24467: MAKE_REAL_ZVAL_PTR(offset); 24468: } 24469: 24470: /* here we are sure we are dealing with an object */ 24471: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24472: 24473: PZVAL_LOCK(retval); 24474: AI_SET_PTR(&EX_T(opline->result.var), retval); 24475: 24476: if (0) { 24477: zval_ptr_dtor(&offset); 24478: } else { 24479: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24480: } 24481: } 24482: 24483: CHECK_EXCEPTION(); 24484: ZEND_VM_NEXT_OPCODE(); 24485: } 24486: 24487: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24488: { 24489: return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24490: } 24491: 24492: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24493: { 24494: USE_OPLINE 24495: zend_free_op free_op1, free_op2; 24496: zval *property; 24497: zval **container; 24498: 24499: SAVE_OPLINE(); 24500: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24501: 24502: if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 24503: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 24504: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 24505: } 24506: 24507: if (0) { 24508: MAKE_REAL_ZVAL_PTR(property); 24509: } 24510: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24511: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 24512: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 24513: } 24514: 24515: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 24516: if (0) { 24517: zval_ptr_dtor(&property); 24518: } else { 24519: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24520: } 24521: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 24522: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 24523: } 24524: 24525: /* We are going to assign the result by reference */ 24526: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 24527: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 24528: 24529: Z_DELREF_PP(retval_ptr); 24530: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 24531: Z_ADDREF_PP(retval_ptr); 24532: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 24533: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 24534: } 24535: 24536: CHECK_EXCEPTION(); 24537: ZEND_VM_NEXT_OPCODE(); 24538: } 24539: 24540: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24541: { 24542: USE_OPLINE 24543: zend_free_op free_op1, free_op2; 24544: zval *property; 24545: zval **container; 24546: 24547: SAVE_OPLINE(); 24548: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24549: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24550: 24551: if (0) { 24552: MAKE_REAL_ZVAL_PTR(property); 24553: } 24554: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 24555: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 24556: } 24557: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 24558: if (0) { 24559: zval_ptr_dtor(&property); 24560: } else { 24561: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24562: } 24563: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 24564: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 24565: } 24566: 24567: CHECK_EXCEPTION(); 24568: ZEND_VM_NEXT_OPCODE(); 24569: } 24570: 24571: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24572: { 24573: USE_OPLINE 24574: 24575: zval *container; 24576: zend_free_op free_op2; 24577: zval *offset; 24578: 24579: SAVE_OPLINE(); 24580: container = _get_obj_zval_ptr_unused(TSRMLS_C); 24581: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24582: 24583: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 24584: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 24585: PZVAL_LOCK(&EG(uninitialized_zval)); 24586: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 24587: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24588: } else { 24589: zval *retval; 24590: 24591: if (0) { 24592: MAKE_REAL_ZVAL_PTR(offset); 24593: } 24594: 24595: /* here we are sure we are dealing with an object */ 24596: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24597: 24598: PZVAL_LOCK(retval); 24599: AI_SET_PTR(&EX_T(opline->result.var), retval); 24600: 24601: if (0) { 24602: zval_ptr_dtor(&offset); 24603: } else { 24604: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24605: } 24606: } 24607: 24608: CHECK_EXCEPTION(); 24609: ZEND_VM_NEXT_OPCODE(); 24610: } 24611: 24612: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24613: { 24614: USE_OPLINE 24615: 24616: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 24617: /* Behave like FETCH_OBJ_W */ 24618: zend_free_op free_op1, free_op2; 24619: zval *property; 24620: zval **container; 24621: 24622: SAVE_OPLINE(); 24623: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24624: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24625: 24626: if (0) { 24627: MAKE_REAL_ZVAL_PTR(property); 24628: } 24629: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 24630: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 24631: } 24632: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 24633: if (0) { 24634: zval_ptr_dtor(&property); 24635: } else { 24636: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24637: } 24638: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 24639: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 24640: } 24641: 24642: CHECK_EXCEPTION(); 24643: ZEND_VM_NEXT_OPCODE(); 24644: } else { 24645: return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24646: } 24647: } 24648: 24649: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24650: { 24651: USE_OPLINE 24652: zend_free_op free_op1, free_op2, free_res; 24653: zval **container; 24654: zval *property; 24655: 24656: SAVE_OPLINE(); 24657: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24658: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24659: 24660: if (IS_UNUSED == IS_CV) { 24661: if (container != &EG(uninitialized_zval_ptr)) { 24662: SEPARATE_ZVAL_IF_NOT_REF(container); 24663: } 24664: } 24665: if (0) { 24666: MAKE_REAL_ZVAL_PTR(property); 24667: } 24668: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 24669: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 24670: } 24671: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 24672: if (0) { 24673: zval_ptr_dtor(&property); 24674: } else { 24675: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24676: } 24677: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 24678: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 24679: } 24680: 24681: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 24682: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 24683: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 24684: } 24685: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 24686: FREE_OP_VAR_PTR(free_res); 24687: CHECK_EXCEPTION(); 24688: ZEND_VM_NEXT_OPCODE(); 24689: } 24690: 24691: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24692: { 24693: USE_OPLINE 24694: zend_free_op free_op2; 24695: zval **object_ptr; 24696: zval *property_name; 24697: 24698: SAVE_OPLINE(); 24699: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24700: property_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24701: 24702: if (0) { 24703: MAKE_REAL_ZVAL_PTR(property_name); 24704: } 24705: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 24706: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 24707: } 24708: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24709: if (0) { 24710: zval_ptr_dtor(&property_name); 24711: } else { 24712: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24713: } 24714: 24715: /* assign_obj has two opcodes! */ 24716: CHECK_EXCEPTION(); 24717: ZEND_VM_INC_OPCODE(); 24718: ZEND_VM_NEXT_OPCODE(); 24719: } 24720: 24721: static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24722: { 24723: USE_OPLINE 24724: zend_free_op free_op2; 24725: zval *str = &EX_T(opline->result.var).tmp_var; 24726: zval *var; 24727: zval var_copy; 24728: int use_copy = 0; 24729: 24730: SAVE_OPLINE(); 24731: var = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24732: 24733: if (IS_UNUSED == IS_UNUSED) { 24734: /* Initialize for erealloc in add_string_to_string */ 24735: Z_STRVAL_P(str) = NULL; 24736: Z_STRLEN_P(str) = 0; 24737: Z_TYPE_P(str) = IS_STRING; 24738: 24739: INIT_PZVAL(str); 24740: } 24741: 24742: if (Z_TYPE_P(var) != IS_STRING) { 24743: zend_make_printable_zval(var, &var_copy, &use_copy); 24744: 24745: if (use_copy) { 24746: var = &var_copy; 24747: } 24748: } 24749: add_string_to_string(str, str, var); 24750: 24751: if (use_copy) { 24752: zval_dtor(var); 24753: } 24754: /* original comment, possibly problematic: 24755: * FREE_OP is missing intentionally here - we're always working on the same temporary variable 24756: * (Zeev): I don't think it's problematic, we only use variables 24757: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're 24758: * string offsets or overloaded objects 24759: */ 24760: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24761: 24762: CHECK_EXCEPTION(); 24763: ZEND_VM_NEXT_OPCODE(); 24764: } 24765: 24766: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24767: { 24768: USE_OPLINE 24769: zval *function_name; 24770: char *function_name_strval; 24771: int function_name_strlen; 24772: zend_free_op free_op2; 24773: 24774: SAVE_OPLINE(); 24775: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 24776: 24777: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24778: 24779: if (IS_VAR != IS_CONST && 24780: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 24781: zend_error_noreturn(E_ERROR, "Method name must be a string"); 24782: } 24783: 24784: function_name_strval = Z_STRVAL_P(function_name); 24785: function_name_strlen = Z_STRLEN_P(function_name); 24786: 24787: EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C); 24788: 24789: if (EXPECTED(EX(object) != NULL) && 24790: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 24791: EX(called_scope) = Z_OBJCE_P(EX(object)); 24792: 24793: if (IS_VAR != IS_CONST || 24794: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 24795: zval *object = EX(object); 24796: 24797: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 24798: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 24799: } 24800: 24801: /* First, locate the function. */ 24802: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 24803: if (UNEXPECTED(EX(fbc) == NULL)) { 24804: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 24805: } 24806: if (IS_VAR == IS_CONST && 24807: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 24808: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 24809: EXPECTED(EX(object) == object)) { 24810: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 24811: } 24812: } 24813: } else { 24814: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 24815: } 24816: 24817: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 24818: EX(object) = NULL; 24819: } else { 24820: if (!PZVAL_IS_REF(EX(object))) { 24821: Z_ADDREF_P(EX(object)); /* For $this pointer */ 24822: } else { 24823: zval *this_ptr; 24824: ALLOC_ZVAL(this_ptr); 24825: INIT_PZVAL_COPY(this_ptr, EX(object)); 24826: zval_copy_ctor(this_ptr); 24827: EX(object) = this_ptr; 24828: } 24829: } 24830: 24831: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24832: 24833: CHECK_EXCEPTION(); 24834: ZEND_VM_NEXT_OPCODE(); 24835: } 24836: 24837: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24838: { 24839: USE_OPLINE 24840: 24841: array_init(&EX_T(opline->result.var).tmp_var); 24842: if (IS_UNUSED == IS_UNUSED) { 24843: ZEND_VM_NEXT_OPCODE(); 24844: #if 0 || IS_UNUSED != IS_UNUSED 24845: } else { 24846: return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 24847: #endif 24848: } 24849: } 24850: 24851: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24852: { 24853: USE_OPLINE 24854: zend_free_op free_op2; 24855: zval **container; 24856: zval *offset; 24857: ulong hval; 24858: 24859: SAVE_OPLINE(); 24860: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24861: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 24862: SEPARATE_ZVAL_IF_NOT_REF(container); 24863: } 24864: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24865: 24866: if (IS_UNUSED != IS_VAR || container) { 24867: switch (Z_TYPE_PP(container)) { 24868: case IS_ARRAY: { 24869: HashTable *ht = Z_ARRVAL_PP(container); 24870: 24871: switch (Z_TYPE_P(offset)) { 24872: case IS_DOUBLE: 24873: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 24874: zend_hash_index_del(ht, hval); 24875: break; 24876: case IS_RESOURCE: 24877: case IS_BOOL: 24878: case IS_LONG: 24879: hval = Z_LVAL_P(offset); 24880: zend_hash_index_del(ht, hval); 24881: break; 24882: case IS_STRING: 24883: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 24884: Z_ADDREF_P(offset); 24885: } 24886: if (IS_VAR == IS_CONST) { 24887: hval = Z_HASH_P(offset); 24888: } else { 24889: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 24890: if (IS_INTERNED(Z_STRVAL_P(offset))) { 24891: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 24892: } else { 24893: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 24894: } 24895: } 24896: if (ht == &EG(symbol_table)) { 24897: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 24898: } else { 24899: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 24900: } 24901: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 24902: zval_ptr_dtor(&offset); 24903: } 24904: break; 24905: num_index_dim: 24906: zend_hash_index_del(ht, hval); 24907: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 24908: zval_ptr_dtor(&offset); 24909: } 24910: break; 24911: case IS_NULL: 24912: zend_hash_del(ht, "", sizeof("")); 24913: break; 24914: default: 24915: zend_error(E_WARNING, "Illegal offset type in unset"); 24916: break; 24917: } 24918: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24919: break; 24920: } 24921: case IS_OBJECT: 24922: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 24923: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 24924: } 24925: if (0) { 24926: MAKE_REAL_ZVAL_PTR(offset); 24927: } 24928: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 24929: if (0) { 24930: zval_ptr_dtor(&offset); 24931: } else { 24932: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24933: } 24934: break; 24935: case IS_STRING: 24936: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 24937: ZEND_VM_CONTINUE(); /* bailed out before */ 24938: default: 24939: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24940: break; 24941: } 24942: } else { 24943: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24944: } 24945: 24946: CHECK_EXCEPTION(); 24947: ZEND_VM_NEXT_OPCODE(); 24948: } 24949: 24950: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 24951: { 24952: USE_OPLINE 24953: zend_free_op free_op2; 24954: zval **container; 24955: zval *offset; 24956: 24957: SAVE_OPLINE(); 24958: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 24959: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 24960: 24961: if (IS_UNUSED != IS_VAR || container) { 24962: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 24963: SEPARATE_ZVAL_IF_NOT_REF(container); 24964: } 24965: if (Z_TYPE_PP(container) == IS_OBJECT) { 24966: if (0) { 24967: MAKE_REAL_ZVAL_PTR(offset); 24968: } 24969: if (Z_OBJ_HT_P(*container)->unset_property) { 24970: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 24971: } else { 24972: zend_error(E_NOTICE, "Trying to unset property of non-object"); 24973: } 24974: if (0) { 24975: zval_ptr_dtor(&offset); 24976: } else { 24977: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24978: } 24979: } else { 24980: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24981: } 24982: } else { 24983: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 24984: } 24985: 24986: CHECK_EXCEPTION(); 24987: ZEND_VM_NEXT_OPCODE(); 24988: } 24989: 24990: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 24991: { 24992: USE_OPLINE 24993: zend_free_op free_op2; 24994: zval **container; 24995: zval **value = NULL; 24996: int result = 0; 24997: ulong hval; 24998: zval *offset; 24999: 25000: SAVE_OPLINE(); 25001: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25002: 25003: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 25004: 25005: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 25006: HashTable *ht; 25007: int isset = 0; 25008: 25009: ht = Z_ARRVAL_PP(container); 25010: 25011: switch (Z_TYPE_P(offset)) { 25012: case IS_DOUBLE: 25013: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 25014: goto num_index_prop; 25015: case IS_RESOURCE: 25016: case IS_BOOL: 25017: case IS_LONG: 25018: hval = Z_LVAL_P(offset); 25019: num_index_prop: 25020: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 25021: isset = 1; 25022: } 25023: break; 25024: case IS_STRING: 25025: if (IS_VAR == IS_CONST) { 25026: hval = Z_HASH_P(offset); 25027: } else { 25028: if (!prop_dim) { 25029: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 25030: } 25031: if (IS_INTERNED(Z_STRVAL_P(offset))) { 25032: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 25033: } else { 25034: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 25035: } 25036: } 25037: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 25038: isset = 1; 25039: } 25040: break; 25041: case IS_NULL: 25042: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 25043: isset = 1; 25044: } 25045: break; 25046: default: 25047: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 25048: break; 25049: } 25050: 25051: if (opline->extended_value & ZEND_ISSET) { 25052: if (isset && Z_TYPE_PP(value) == IS_NULL) { 25053: result = 0; 25054: } else { 25055: result = isset; 25056: } 25057: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 25058: if (!isset || !i_zend_is_true(*value)) { 25059: result = 0; 25060: } else { 25061: result = 1; 25062: } 25063: } 25064: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 25065: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 25066: if (0) { 25067: MAKE_REAL_ZVAL_PTR(offset); 25068: } 25069: if (prop_dim) { 25070: if (Z_OBJ_HT_P(*container)->has_property) { 25071: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25072: } else { 25073: zend_error(E_NOTICE, "Trying to check property of non-object"); 25074: result = 0; 25075: } 25076: } else { 25077: if (Z_OBJ_HT_P(*container)->has_dimension) { 25078: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 25079: } else { 25080: zend_error(E_NOTICE, "Trying to check element of non-array"); 25081: result = 0; 25082: } 25083: } 25084: if (0) { 25085: zval_ptr_dtor(&offset); 25086: } else { 25087: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 25088: } 25089: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 25090: zval tmp; 25091: 25092: if (Z_TYPE_P(offset) != IS_LONG) { 25093: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 25094: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 25095: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 25096: ZVAL_COPY_VALUE(&tmp, offset); 25097: zval_copy_ctor(&tmp); 25098: convert_to_long(&tmp); 25099: offset = &tmp; 25100: } else { 25101: /* can not be converted to proper offset, return "not set" */ 25102: result = 0; 25103: } 25104: } 25105: if (Z_TYPE_P(offset) == IS_LONG) { 25106: if (opline->extended_value & ZEND_ISSET) { 25107: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 25108: result = 1; 25109: } 25110: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 25111: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 25112: result = 1; 25113: } 25114: } 25115: } 25116: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 25117: } else { 25118: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 25119: } 25120: 25121: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 25122: if (opline->extended_value & ZEND_ISSET) { 25123: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 25124: } else { 25125: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 25126: } 25127: 25128: CHECK_EXCEPTION(); 25129: ZEND_VM_NEXT_OPCODE(); 25130: } 25131: 25132: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25133: { 25134: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25135: } 25136: 25137: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25138: { 25139: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25140: } 25141: 25142: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 25143: { 25144: USE_OPLINE 25145: zend_free_op free_op_data1; 25146: zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25147: zval *object; 25148: zval *property = NULL; 25149: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 25150: int have_get_ptr = 0; 25151: 25152: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 25153: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 25154: } 25155: 25156: make_real_object(object_ptr TSRMLS_CC); 25157: object = *object_ptr; 25158: 25159: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 25160: zend_error(E_WARNING, "Attempt to assign property of non-object"); 25161: 25162: FREE_OP(free_op_data1); 25163: 25164: if (RETURN_VALUE_USED(opline)) { 25165: PZVAL_LOCK(&EG(uninitialized_zval)); 25166: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 25167: EX_T(opline->result.var).var.ptr_ptr = NULL; 25168: } 25169: } else { 25170: /* here we are sure we are dealing with an object */ 25171: if (0) { 25172: MAKE_REAL_ZVAL_PTR(property); 25173: } 25174: 25175: /* here property is a string */ 25176: if (opline->extended_value == ZEND_ASSIGN_OBJ 25177: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 25178: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25179: if (zptr != NULL) { /* NULL means no success in getting PTR */ 25180: SEPARATE_ZVAL_IF_NOT_REF(zptr); 25181: 25182: have_get_ptr = 1; 25183: binary_op(*zptr, *zptr, value TSRMLS_CC); 25184: if (RETURN_VALUE_USED(opline)) { 25185: PZVAL_LOCK(*zptr); 25186: EX_T(opline->result.var).var.ptr = *zptr; 25187: EX_T(opline->result.var).var.ptr_ptr = NULL; 25188: } 25189: } 25190: } 25191: 25192: if (!have_get_ptr) { 25193: zval *z = NULL; 25194: 25195: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 25196: if (Z_OBJ_HT_P(object)->read_property) { 25197: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25198: } 25199: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 25200: if (Z_OBJ_HT_P(object)->read_dimension) { 25201: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 25202: } 25203: } 25204: if (z) { 25205: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 25206: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 25207: 25208: if (Z_REFCOUNT_P(z) == 0) { 25209: GC_REMOVE_ZVAL_FROM_BUFFER(z); 25210: zval_dtor(z); 25211: FREE_ZVAL(z); 25212: } 25213: z = value; 25214: } 25215: Z_ADDREF_P(z); 25216: SEPARATE_ZVAL_IF_NOT_REF(&z); 25217: binary_op(z, z, value TSRMLS_CC); 25218: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 25219: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25220: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 25221: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 25222: } 25223: if (RETURN_VALUE_USED(opline)) { 25224: PZVAL_LOCK(z); 25225: EX_T(opline->result.var).var.ptr = z; 25226: EX_T(opline->result.var).var.ptr_ptr = NULL; 25227: } 25228: zval_ptr_dtor(&z); 25229: } else { 25230: zend_error(E_WARNING, "Attempt to assign property of non-object"); 25231: if (RETURN_VALUE_USED(opline)) { 25232: PZVAL_LOCK(&EG(uninitialized_zval)); 25233: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 25234: EX_T(opline->result.var).var.ptr_ptr = NULL; 25235: } 25236: } 25237: } 25238: 25239: if (0) { 25240: zval_ptr_dtor(&property); 25241: } else { 25242: 25243: } 25244: FREE_OP(free_op_data1); 25245: } 25246: 25247: /* assign_obj has two opcodes! */ 25248: CHECK_EXCEPTION(); 25249: ZEND_VM_INC_OPCODE(); 25250: ZEND_VM_NEXT_OPCODE(); 25251: } 25252: 25253: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 25254: { 25255: USE_OPLINE 25256: zend_free_op free_op_data2, free_op_data1; 25257: zval **var_ptr; 25258: zval *value; 25259: 25260: SAVE_OPLINE(); 25261: switch (opline->extended_value) { 25262: case ZEND_ASSIGN_OBJ: 25263: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25264: break; 25265: case ZEND_ASSIGN_DIM: { 25266: zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25267: 25268: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 25269: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 25270: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 25271: if (IS_UNUSED == IS_VAR && !0) { 25272: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 25273: } 25274: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25275: } else { 25276: zval *dim = NULL; 25277: 25278: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC); 25279: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 25280: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 25281: } 25282: } 25283: break; 25284: default: 25285: value = NULL; 25286: var_ptr = NULL; 25287: /* do nothing */ 25288: break; 25289: } 25290: 25291: if (UNEXPECTED(var_ptr == NULL)) { 25292: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 25293: } 25294: 25295: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 25296: if (RETURN_VALUE_USED(opline)) { 25297: PZVAL_LOCK(&EG(uninitialized_zval)); 25298: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 25299: } 25300: 25301: 25302: CHECK_EXCEPTION(); 25303: if (opline->extended_value == ZEND_ASSIGN_DIM) { 25304: ZEND_VM_INC_OPCODE(); 25305: } 25306: ZEND_VM_NEXT_OPCODE(); 25307: } 25308: 25309: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 25310: 25311: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 25312: && Z_OBJ_HANDLER_PP(var_ptr, get) 25313: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 25314: /* proxy object */ 25315: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 25316: Z_ADDREF_P(objval); 25317: binary_op(objval, objval, value TSRMLS_CC); 25318: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 25319: zval_ptr_dtor(&objval); 25320: } else { 25321: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 25322: } 25323: 25324: if (RETURN_VALUE_USED(opline)) { 25325: PZVAL_LOCK(*var_ptr); 25326: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 25327: } 25328: 25329: if (opline->extended_value == ZEND_ASSIGN_DIM) { 25330: FREE_OP(free_op_data1); 25331: FREE_OP_VAR_PTR(free_op_data2); 25332: 25333: CHECK_EXCEPTION(); 25334: ZEND_VM_INC_OPCODE(); 25335: } else { 25336: 25337: CHECK_EXCEPTION(); 25338: } 25339: ZEND_VM_NEXT_OPCODE(); 25340: } 25341: 25342: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25343: { 25344: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25345: } 25346: 25347: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25348: { 25349: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25350: } 25351: 25352: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25353: { 25354: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25355: } 25356: 25357: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25358: { 25359: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25360: } 25361: 25362: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25363: { 25364: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25365: } 25366: 25367: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25368: { 25369: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25370: } 25371: 25372: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25373: { 25374: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25375: } 25376: 25377: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25378: { 25379: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25380: } 25381: 25382: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25383: { 25384: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25385: } 25386: 25387: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25388: { 25389: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25390: } 25391: 25392: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25393: { 25394: return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25395: } 25396: 25397: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25398: { 25399: USE_OPLINE 25400: 25401: array_init(&EX_T(opline->result.var).tmp_var); 25402: if (IS_UNUSED == IS_UNUSED) { 25403: ZEND_VM_NEXT_OPCODE(); 25404: #if 0 || IS_UNUSED != IS_UNUSED 25405: } else { 25406: return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25407: #endif 25408: } 25409: } 25410: 25411: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 25412: { 25413: USE_OPLINE 25414: zend_free_op free_op_data1; 25415: zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25416: zval *object; 25417: zval *property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25418: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 25419: int have_get_ptr = 0; 25420: 25421: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 25422: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 25423: } 25424: 25425: make_real_object(object_ptr TSRMLS_CC); 25426: object = *object_ptr; 25427: 25428: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 25429: zend_error(E_WARNING, "Attempt to assign property of non-object"); 25430: 25431: FREE_OP(free_op_data1); 25432: 25433: if (RETURN_VALUE_USED(opline)) { 25434: PZVAL_LOCK(&EG(uninitialized_zval)); 25435: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 25436: EX_T(opline->result.var).var.ptr_ptr = NULL; 25437: } 25438: } else { 25439: /* here we are sure we are dealing with an object */ 25440: if (0) { 25441: MAKE_REAL_ZVAL_PTR(property); 25442: } 25443: 25444: /* here property is a string */ 25445: if (opline->extended_value == ZEND_ASSIGN_OBJ 25446: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 25447: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25448: if (zptr != NULL) { /* NULL means no success in getting PTR */ 25449: SEPARATE_ZVAL_IF_NOT_REF(zptr); 25450: 25451: have_get_ptr = 1; 25452: binary_op(*zptr, *zptr, value TSRMLS_CC); 25453: if (RETURN_VALUE_USED(opline)) { 25454: PZVAL_LOCK(*zptr); 25455: EX_T(opline->result.var).var.ptr = *zptr; 25456: EX_T(opline->result.var).var.ptr_ptr = NULL; 25457: } 25458: } 25459: } 25460: 25461: if (!have_get_ptr) { 25462: zval *z = NULL; 25463: 25464: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 25465: if (Z_OBJ_HT_P(object)->read_property) { 25466: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25467: } 25468: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 25469: if (Z_OBJ_HT_P(object)->read_dimension) { 25470: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 25471: } 25472: } 25473: if (z) { 25474: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 25475: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 25476: 25477: if (Z_REFCOUNT_P(z) == 0) { 25478: GC_REMOVE_ZVAL_FROM_BUFFER(z); 25479: zval_dtor(z); 25480: FREE_ZVAL(z); 25481: } 25482: z = value; 25483: } 25484: Z_ADDREF_P(z); 25485: SEPARATE_ZVAL_IF_NOT_REF(&z); 25486: binary_op(z, z, value TSRMLS_CC); 25487: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 25488: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25489: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 25490: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 25491: } 25492: if (RETURN_VALUE_USED(opline)) { 25493: PZVAL_LOCK(z); 25494: EX_T(opline->result.var).var.ptr = z; 25495: EX_T(opline->result.var).var.ptr_ptr = NULL; 25496: } 25497: zval_ptr_dtor(&z); 25498: } else { 25499: zend_error(E_WARNING, "Attempt to assign property of non-object"); 25500: if (RETURN_VALUE_USED(opline)) { 25501: PZVAL_LOCK(&EG(uninitialized_zval)); 25502: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 25503: EX_T(opline->result.var).var.ptr_ptr = NULL; 25504: } 25505: } 25506: } 25507: 25508: if (0) { 25509: zval_ptr_dtor(&property); 25510: } else { 25511: 25512: } 25513: FREE_OP(free_op_data1); 25514: } 25515: 25516: /* assign_obj has two opcodes! */ 25517: CHECK_EXCEPTION(); 25518: ZEND_VM_INC_OPCODE(); 25519: ZEND_VM_NEXT_OPCODE(); 25520: } 25521: 25522: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 25523: { 25524: USE_OPLINE 25525: zend_free_op free_op_data2, free_op_data1; 25526: zval **var_ptr; 25527: zval *value; 25528: 25529: SAVE_OPLINE(); 25530: switch (opline->extended_value) { 25531: case ZEND_ASSIGN_OBJ: 25532: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25533: break; 25534: case ZEND_ASSIGN_DIM: { 25535: zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25536: 25537: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 25538: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 25539: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 25540: if (IS_UNUSED == IS_VAR && !0) { 25541: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 25542: } 25543: return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25544: } else { 25545: zval *dim = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25546: 25547: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC); 25548: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 25549: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 25550: } 25551: } 25552: break; 25553: default: 25554: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25555: var_ptr = NULL; 25556: /* do nothing */ 25557: break; 25558: } 25559: 25560: if (UNEXPECTED(var_ptr == NULL)) { 25561: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 25562: } 25563: 25564: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 25565: if (RETURN_VALUE_USED(opline)) { 25566: PZVAL_LOCK(&EG(uninitialized_zval)); 25567: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 25568: } 25569: 25570: 25571: CHECK_EXCEPTION(); 25572: if (opline->extended_value == ZEND_ASSIGN_DIM) { 25573: ZEND_VM_INC_OPCODE(); 25574: } 25575: ZEND_VM_NEXT_OPCODE(); 25576: } 25577: 25578: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 25579: 25580: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 25581: && Z_OBJ_HANDLER_PP(var_ptr, get) 25582: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 25583: /* proxy object */ 25584: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 25585: Z_ADDREF_P(objval); 25586: binary_op(objval, objval, value TSRMLS_CC); 25587: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 25588: zval_ptr_dtor(&objval); 25589: } else { 25590: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 25591: } 25592: 25593: if (RETURN_VALUE_USED(opline)) { 25594: PZVAL_LOCK(*var_ptr); 25595: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 25596: } 25597: 25598: if (opline->extended_value == ZEND_ASSIGN_DIM) { 25599: FREE_OP(free_op_data1); 25600: FREE_OP_VAR_PTR(free_op_data2); 25601: 25602: CHECK_EXCEPTION(); 25603: ZEND_VM_INC_OPCODE(); 25604: } else { 25605: 25606: CHECK_EXCEPTION(); 25607: } 25608: ZEND_VM_NEXT_OPCODE(); 25609: } 25610: 25611: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25612: { 25613: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25614: } 25615: 25616: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25617: { 25618: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25619: } 25620: 25621: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25622: { 25623: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25624: } 25625: 25626: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25627: { 25628: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25629: } 25630: 25631: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25632: { 25633: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25634: } 25635: 25636: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25637: { 25638: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25639: } 25640: 25641: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25642: { 25643: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25644: } 25645: 25646: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25647: { 25648: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25649: } 25650: 25651: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25652: { 25653: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25654: } 25655: 25656: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25657: { 25658: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25659: } 25660: 25661: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25662: { 25663: return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25664: } 25665: 25666: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 25667: { 25668: USE_OPLINE 25669: 25670: zval **object_ptr; 25671: zval *object; 25672: zval *property; 25673: zval **retval; 25674: int have_get_ptr = 0; 25675: 25676: SAVE_OPLINE(); 25677: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25678: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25679: retval = &EX_T(opline->result.var).var.ptr; 25680: 25681: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 25682: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 25683: } 25684: 25685: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 25686: object = *object_ptr; 25687: 25688: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 25689: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 25690: 25691: if (RETURN_VALUE_USED(opline)) { 25692: PZVAL_LOCK(&EG(uninitialized_zval)); 25693: *retval = &EG(uninitialized_zval); 25694: } 25695: 25696: CHECK_EXCEPTION(); 25697: ZEND_VM_NEXT_OPCODE(); 25698: } 25699: 25700: /* here we are sure we are dealing with an object */ 25701: 25702: if (0) { 25703: MAKE_REAL_ZVAL_PTR(property); 25704: } 25705: 25706: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 25707: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25708: if (zptr != NULL) { /* NULL means no success in getting PTR */ 25709: SEPARATE_ZVAL_IF_NOT_REF(zptr); 25710: 25711: have_get_ptr = 1; 25712: incdec_op(*zptr); 25713: if (RETURN_VALUE_USED(opline)) { 25714: *retval = *zptr; 25715: PZVAL_LOCK(*retval); 25716: } 25717: } 25718: } 25719: 25720: if (!have_get_ptr) { 25721: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 25722: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25723: 25724: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 25725: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 25726: 25727: if (Z_REFCOUNT_P(z) == 0) { 25728: GC_REMOVE_ZVAL_FROM_BUFFER(z); 25729: zval_dtor(z); 25730: FREE_ZVAL(z); 25731: } 25732: z = value; 25733: } 25734: Z_ADDREF_P(z); 25735: SEPARATE_ZVAL_IF_NOT_REF(&z); 25736: incdec_op(z); 25737: *retval = z; 25738: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25739: SELECTIVE_PZVAL_LOCK(*retval, opline); 25740: zval_ptr_dtor(&z); 25741: } else { 25742: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 25743: if (RETURN_VALUE_USED(opline)) { 25744: PZVAL_LOCK(&EG(uninitialized_zval)); 25745: *retval = &EG(uninitialized_zval); 25746: } 25747: } 25748: } 25749: 25750: if (0) { 25751: zval_ptr_dtor(&property); 25752: } else { 25753: 25754: } 25755: 25756: CHECK_EXCEPTION(); 25757: ZEND_VM_NEXT_OPCODE(); 25758: } 25759: 25760: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25761: { 25762: return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25763: } 25764: 25765: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25766: { 25767: return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25768: } 25769: 25770: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 25771: { 25772: USE_OPLINE 25773: 25774: zval **object_ptr; 25775: zval *object; 25776: zval *property; 25777: zval *retval; 25778: int have_get_ptr = 0; 25779: 25780: SAVE_OPLINE(); 25781: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25782: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25783: retval = &EX_T(opline->result.var).tmp_var; 25784: 25785: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 25786: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 25787: } 25788: 25789: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 25790: object = *object_ptr; 25791: 25792: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 25793: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 25794: 25795: ZVAL_NULL(retval); 25796: 25797: CHECK_EXCEPTION(); 25798: ZEND_VM_NEXT_OPCODE(); 25799: } 25800: 25801: /* here we are sure we are dealing with an object */ 25802: 25803: if (0) { 25804: MAKE_REAL_ZVAL_PTR(property); 25805: } 25806: 25807: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 25808: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25809: if (zptr != NULL) { /* NULL means no success in getting PTR */ 25810: have_get_ptr = 1; 25811: SEPARATE_ZVAL_IF_NOT_REF(zptr); 25812: 25813: ZVAL_COPY_VALUE(retval, *zptr); 25814: zendi_zval_copy_ctor(*retval); 25815: 25816: incdec_op(*zptr); 25817: 25818: } 25819: } 25820: 25821: if (!have_get_ptr) { 25822: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 25823: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25824: zval *z_copy; 25825: 25826: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 25827: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 25828: 25829: if (Z_REFCOUNT_P(z) == 0) { 25830: GC_REMOVE_ZVAL_FROM_BUFFER(z); 25831: zval_dtor(z); 25832: FREE_ZVAL(z); 25833: } 25834: z = value; 25835: } 25836: ZVAL_COPY_VALUE(retval, z); 25837: zendi_zval_copy_ctor(*retval); 25838: ALLOC_ZVAL(z_copy); 25839: INIT_PZVAL_COPY(z_copy, z); 25840: zendi_zval_copy_ctor(*z_copy); 25841: incdec_op(z_copy); 25842: Z_ADDREF_P(z); 25843: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25844: zval_ptr_dtor(&z_copy); 25845: zval_ptr_dtor(&z); 25846: } else { 25847: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 25848: ZVAL_NULL(retval); 25849: } 25850: } 25851: 25852: if (0) { 25853: zval_ptr_dtor(&property); 25854: } else { 25855: 25856: } 25857: 25858: CHECK_EXCEPTION(); 25859: ZEND_VM_NEXT_OPCODE(); 25860: } 25861: 25862: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25863: { 25864: return zend_post_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25865: } 25866: 25867: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25868: { 25869: return zend_post_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25870: } 25871: 25872: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS) 25873: { 25874: USE_OPLINE 25875: 25876: zval *container; 25877: 25878: zval *offset; 25879: 25880: SAVE_OPLINE(); 25881: container = _get_obj_zval_ptr_unused(TSRMLS_C); 25882: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25883: 25884: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 25885: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 25886: zend_error(E_NOTICE, "Trying to get property of non-object"); 25887: PZVAL_LOCK(&EG(uninitialized_zval)); 25888: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 25889: 25890: } else { 25891: zval *retval; 25892: 25893: if (0) { 25894: MAKE_REAL_ZVAL_PTR(offset); 25895: } 25896: 25897: /* here we are sure we are dealing with an object */ 25898: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 25899: 25900: PZVAL_LOCK(retval); 25901: AI_SET_PTR(&EX_T(opline->result.var), retval); 25902: 25903: if (0) { 25904: zval_ptr_dtor(&offset); 25905: } else { 25906: 25907: } 25908: } 25909: 25910: CHECK_EXCEPTION(); 25911: ZEND_VM_NEXT_OPCODE(); 25912: } 25913: 25914: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25915: { 25916: return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 25917: } 25918: 25919: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25920: { 25921: USE_OPLINE 25922: zend_free_op free_op1; 25923: zval *property; 25924: zval **container; 25925: 25926: SAVE_OPLINE(); 25927: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25928: 25929: if (IS_UNUSED == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 25930: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 25931: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 25932: } 25933: 25934: if (0) { 25935: MAKE_REAL_ZVAL_PTR(property); 25936: } 25937: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25938: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 25939: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 25940: } 25941: 25942: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 25943: if (0) { 25944: zval_ptr_dtor(&property); 25945: } else { 25946: 25947: } 25948: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 25949: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 25950: } 25951: 25952: /* We are going to assign the result by reference */ 25953: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 25954: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 25955: 25956: Z_DELREF_PP(retval_ptr); 25957: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 25958: Z_ADDREF_PP(retval_ptr); 25959: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 25960: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 25961: } 25962: 25963: CHECK_EXCEPTION(); 25964: ZEND_VM_NEXT_OPCODE(); 25965: } 25966: 25967: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25968: { 25969: USE_OPLINE 25970: zend_free_op free_op1; 25971: zval *property; 25972: zval **container; 25973: 25974: SAVE_OPLINE(); 25975: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 25976: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 25977: 25978: if (0) { 25979: MAKE_REAL_ZVAL_PTR(property); 25980: } 25981: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 25982: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 25983: } 25984: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 25985: if (0) { 25986: zval_ptr_dtor(&property); 25987: } else { 25988: 25989: } 25990: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 25991: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 25992: } 25993: 25994: CHECK_EXCEPTION(); 25995: ZEND_VM_NEXT_OPCODE(); 25996: } 25997: 25998: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 25999: { 26000: USE_OPLINE 26001: 26002: zval *container; 26003: 26004: zval *offset; 26005: 26006: SAVE_OPLINE(); 26007: container = _get_obj_zval_ptr_unused(TSRMLS_C); 26008: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26009: 26010: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 26011: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 26012: PZVAL_LOCK(&EG(uninitialized_zval)); 26013: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 26014: 26015: } else { 26016: zval *retval; 26017: 26018: if (0) { 26019: MAKE_REAL_ZVAL_PTR(offset); 26020: } 26021: 26022: /* here we are sure we are dealing with an object */ 26023: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 26024: 26025: PZVAL_LOCK(retval); 26026: AI_SET_PTR(&EX_T(opline->result.var), retval); 26027: 26028: if (0) { 26029: zval_ptr_dtor(&offset); 26030: } else { 26031: 26032: } 26033: } 26034: 26035: CHECK_EXCEPTION(); 26036: ZEND_VM_NEXT_OPCODE(); 26037: } 26038: 26039: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26040: { 26041: USE_OPLINE 26042: 26043: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 26044: /* Behave like FETCH_OBJ_W */ 26045: zend_free_op free_op1; 26046: zval *property; 26047: zval **container; 26048: 26049: SAVE_OPLINE(); 26050: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26051: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 26052: 26053: if (0) { 26054: MAKE_REAL_ZVAL_PTR(property); 26055: } 26056: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 26057: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 26058: } 26059: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 26060: if (0) { 26061: zval_ptr_dtor(&property); 26062: } else { 26063: 26064: } 26065: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 26066: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 26067: } 26068: 26069: CHECK_EXCEPTION(); 26070: ZEND_VM_NEXT_OPCODE(); 26071: } else { 26072: return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 26073: } 26074: } 26075: 26076: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26077: { 26078: USE_OPLINE 26079: zend_free_op free_op1, free_res; 26080: zval **container; 26081: zval *property; 26082: 26083: SAVE_OPLINE(); 26084: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 26085: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26086: 26087: if (IS_UNUSED == IS_CV) { 26088: if (container != &EG(uninitialized_zval_ptr)) { 26089: SEPARATE_ZVAL_IF_NOT_REF(container); 26090: } 26091: } 26092: if (0) { 26093: MAKE_REAL_ZVAL_PTR(property); 26094: } 26095: if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { 26096: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 26097: } 26098: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 26099: if (0) { 26100: zval_ptr_dtor(&property); 26101: } else { 26102: 26103: } 26104: if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 26105: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 26106: } 26107: 26108: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 26109: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 26110: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 26111: } 26112: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 26113: FREE_OP_VAR_PTR(free_res); 26114: CHECK_EXCEPTION(); 26115: ZEND_VM_NEXT_OPCODE(); 26116: } 26117: 26118: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26119: { 26120: USE_OPLINE 26121: 26122: zval **object_ptr; 26123: zval *property_name; 26124: 26125: SAVE_OPLINE(); 26126: object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 26127: property_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26128: 26129: if (0) { 26130: MAKE_REAL_ZVAL_PTR(property_name); 26131: } 26132: if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 26133: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 26134: } 26135: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 26136: if (0) { 26137: zval_ptr_dtor(&property_name); 26138: } else { 26139: 26140: } 26141: 26142: /* assign_obj has two opcodes! */ 26143: CHECK_EXCEPTION(); 26144: ZEND_VM_INC_OPCODE(); 26145: ZEND_VM_NEXT_OPCODE(); 26146: } 26147: 26148: static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26149: { 26150: USE_OPLINE 26151: 26152: zval *str = &EX_T(opline->result.var).tmp_var; 26153: zval *var; 26154: zval var_copy; 26155: int use_copy = 0; 26156: 26157: SAVE_OPLINE(); 26158: var = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26159: 26160: if (IS_UNUSED == IS_UNUSED) { 26161: /* Initialize for erealloc in add_string_to_string */ 26162: Z_STRVAL_P(str) = NULL; 26163: Z_STRLEN_P(str) = 0; 26164: Z_TYPE_P(str) = IS_STRING; 26165: 26166: INIT_PZVAL(str); 26167: } 26168: 26169: if (Z_TYPE_P(var) != IS_STRING) { 26170: zend_make_printable_zval(var, &var_copy, &use_copy); 26171: 26172: if (use_copy) { 26173: var = &var_copy; 26174: } 26175: } 26176: add_string_to_string(str, str, var); 26177: 26178: if (use_copy) { 26179: zval_dtor(var); 26180: } 26181: /* original comment, possibly problematic: 26182: * FREE_OP is missing intentionally here - we're always working on the same temporary variable 26183: * (Zeev): I don't think it's problematic, we only use variables 26184: * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're 26185: * string offsets or overloaded objects 26186: */ 26187: 26188: CHECK_EXCEPTION(); 26189: ZEND_VM_NEXT_OPCODE(); 26190: } 26191: 26192: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26193: { 26194: USE_OPLINE 26195: zval *function_name; 26196: char *function_name_strval; 26197: int function_name_strlen; 26198: 26199: 26200: SAVE_OPLINE(); 26201: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 26202: 26203: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26204: 26205: if (IS_CV != IS_CONST && 26206: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 26207: zend_error_noreturn(E_ERROR, "Method name must be a string"); 26208: } 26209: 26210: function_name_strval = Z_STRVAL_P(function_name); 26211: function_name_strlen = Z_STRLEN_P(function_name); 26212: 26213: EX(object) = _get_obj_zval_ptr_unused(TSRMLS_C); 26214: 26215: if (EXPECTED(EX(object) != NULL) && 26216: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 26217: EX(called_scope) = Z_OBJCE_P(EX(object)); 26218: 26219: if (IS_CV != IS_CONST || 26220: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 26221: zval *object = EX(object); 26222: 26223: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 26224: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 26225: } 26226: 26227: /* First, locate the function. */ 26228: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 26229: if (UNEXPECTED(EX(fbc) == NULL)) { 26230: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 26231: } 26232: if (IS_CV == IS_CONST && 26233: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 26234: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 26235: EXPECTED(EX(object) == object)) { 26236: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 26237: } 26238: } 26239: } else { 26240: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 26241: } 26242: 26243: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 26244: EX(object) = NULL; 26245: } else { 26246: if (!PZVAL_IS_REF(EX(object))) { 26247: Z_ADDREF_P(EX(object)); /* For $this pointer */ 26248: } else { 26249: zval *this_ptr; 26250: ALLOC_ZVAL(this_ptr); 26251: INIT_PZVAL_COPY(this_ptr, EX(object)); 26252: zval_copy_ctor(this_ptr); 26253: EX(object) = this_ptr; 26254: } 26255: } 26256: 26257: 26258: CHECK_EXCEPTION(); 26259: ZEND_VM_NEXT_OPCODE(); 26260: } 26261: 26262: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26263: { 26264: USE_OPLINE 26265: 26266: array_init(&EX_T(opline->result.var).tmp_var); 26267: if (IS_UNUSED == IS_UNUSED) { 26268: ZEND_VM_NEXT_OPCODE(); 26269: #if 0 || IS_UNUSED != IS_UNUSED 26270: } else { 26271: return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 26272: #endif 26273: } 26274: } 26275: 26276: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26277: { 26278: USE_OPLINE 26279: 26280: zval **container; 26281: zval *offset; 26282: ulong hval; 26283: 26284: SAVE_OPLINE(); 26285: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 26286: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 26287: SEPARATE_ZVAL_IF_NOT_REF(container); 26288: } 26289: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26290: 26291: if (IS_UNUSED != IS_VAR || container) { 26292: switch (Z_TYPE_PP(container)) { 26293: case IS_ARRAY: { 26294: HashTable *ht = Z_ARRVAL_PP(container); 26295: 26296: switch (Z_TYPE_P(offset)) { 26297: case IS_DOUBLE: 26298: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 26299: zend_hash_index_del(ht, hval); 26300: break; 26301: case IS_RESOURCE: 26302: case IS_BOOL: 26303: case IS_LONG: 26304: hval = Z_LVAL_P(offset); 26305: zend_hash_index_del(ht, hval); 26306: break; 26307: case IS_STRING: 26308: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 26309: Z_ADDREF_P(offset); 26310: } 26311: if (IS_CV == IS_CONST) { 26312: hval = Z_HASH_P(offset); 26313: } else { 26314: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 26315: if (IS_INTERNED(Z_STRVAL_P(offset))) { 26316: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 26317: } else { 26318: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 26319: } 26320: } 26321: if (ht == &EG(symbol_table)) { 26322: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 26323: } else { 26324: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 26325: } 26326: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 26327: zval_ptr_dtor(&offset); 26328: } 26329: break; 26330: num_index_dim: 26331: zend_hash_index_del(ht, hval); 26332: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 26333: zval_ptr_dtor(&offset); 26334: } 26335: break; 26336: case IS_NULL: 26337: zend_hash_del(ht, "", sizeof("")); 26338: break; 26339: default: 26340: zend_error(E_WARNING, "Illegal offset type in unset"); 26341: break; 26342: } 26343: 26344: break; 26345: } 26346: case IS_OBJECT: 26347: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 26348: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 26349: } 26350: if (0) { 26351: MAKE_REAL_ZVAL_PTR(offset); 26352: } 26353: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 26354: if (0) { 26355: zval_ptr_dtor(&offset); 26356: } else { 26357: 26358: } 26359: break; 26360: case IS_STRING: 26361: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 26362: ZEND_VM_CONTINUE(); /* bailed out before */ 26363: default: 26364: 26365: break; 26366: } 26367: } else { 26368: 26369: } 26370: 26371: CHECK_EXCEPTION(); 26372: ZEND_VM_NEXT_OPCODE(); 26373: } 26374: 26375: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26376: { 26377: USE_OPLINE 26378: 26379: zval **container; 26380: zval *offset; 26381: 26382: SAVE_OPLINE(); 26383: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 26384: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26385: 26386: if (IS_UNUSED != IS_VAR || container) { 26387: if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { 26388: SEPARATE_ZVAL_IF_NOT_REF(container); 26389: } 26390: if (Z_TYPE_PP(container) == IS_OBJECT) { 26391: if (0) { 26392: MAKE_REAL_ZVAL_PTR(offset); 26393: } 26394: if (Z_OBJ_HT_P(*container)->unset_property) { 26395: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 26396: } else { 26397: zend_error(E_NOTICE, "Trying to unset property of non-object"); 26398: } 26399: if (0) { 26400: zval_ptr_dtor(&offset); 26401: } else { 26402: 26403: } 26404: } else { 26405: 26406: } 26407: } else { 26408: 26409: } 26410: 26411: CHECK_EXCEPTION(); 26412: ZEND_VM_NEXT_OPCODE(); 26413: } 26414: 26415: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 26416: { 26417: USE_OPLINE 26418: 26419: zval **container; 26420: zval **value = NULL; 26421: int result = 0; 26422: ulong hval; 26423: zval *offset; 26424: 26425: SAVE_OPLINE(); 26426: container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); 26427: 26428: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 26429: 26430: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 26431: HashTable *ht; 26432: int isset = 0; 26433: 26434: ht = Z_ARRVAL_PP(container); 26435: 26436: switch (Z_TYPE_P(offset)) { 26437: case IS_DOUBLE: 26438: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 26439: goto num_index_prop; 26440: case IS_RESOURCE: 26441: case IS_BOOL: 26442: case IS_LONG: 26443: hval = Z_LVAL_P(offset); 26444: num_index_prop: 26445: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 26446: isset = 1; 26447: } 26448: break; 26449: case IS_STRING: 26450: if (IS_CV == IS_CONST) { 26451: hval = Z_HASH_P(offset); 26452: } else { 26453: if (!prop_dim) { 26454: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 26455: } 26456: if (IS_INTERNED(Z_STRVAL_P(offset))) { 26457: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 26458: } else { 26459: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 26460: } 26461: } 26462: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 26463: isset = 1; 26464: } 26465: break; 26466: case IS_NULL: 26467: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 26468: isset = 1; 26469: } 26470: break; 26471: default: 26472: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 26473: break; 26474: } 26475: 26476: if (opline->extended_value & ZEND_ISSET) { 26477: if (isset && Z_TYPE_PP(value) == IS_NULL) { 26478: result = 0; 26479: } else { 26480: result = isset; 26481: } 26482: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 26483: if (!isset || !i_zend_is_true(*value)) { 26484: result = 0; 26485: } else { 26486: result = 1; 26487: } 26488: } 26489: 26490: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 26491: if (0) { 26492: MAKE_REAL_ZVAL_PTR(offset); 26493: } 26494: if (prop_dim) { 26495: if (Z_OBJ_HT_P(*container)->has_property) { 26496: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 26497: } else { 26498: zend_error(E_NOTICE, "Trying to check property of non-object"); 26499: result = 0; 26500: } 26501: } else { 26502: if (Z_OBJ_HT_P(*container)->has_dimension) { 26503: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 26504: } else { 26505: zend_error(E_NOTICE, "Trying to check element of non-array"); 26506: result = 0; 26507: } 26508: } 26509: if (0) { 26510: zval_ptr_dtor(&offset); 26511: } else { 26512: 26513: } 26514: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 26515: zval tmp; 26516: 26517: if (Z_TYPE_P(offset) != IS_LONG) { 26518: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 26519: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 26520: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 26521: ZVAL_COPY_VALUE(&tmp, offset); 26522: zval_copy_ctor(&tmp); 26523: convert_to_long(&tmp); 26524: offset = &tmp; 26525: } else { 26526: /* can not be converted to proper offset, return "not set" */ 26527: result = 0; 26528: } 26529: } 26530: if (Z_TYPE_P(offset) == IS_LONG) { 26531: if (opline->extended_value & ZEND_ISSET) { 26532: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 26533: result = 1; 26534: } 26535: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 26536: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 26537: result = 1; 26538: } 26539: } 26540: } 26541: 26542: } else { 26543: 26544: } 26545: 26546: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 26547: if (opline->extended_value & ZEND_ISSET) { 26548: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 26549: } else { 26550: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 26551: } 26552: 26553: CHECK_EXCEPTION(); 26554: ZEND_VM_NEXT_OPCODE(); 26555: } 26556: 26557: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26558: { 26559: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 26560: } 26561: 26562: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26563: { 26564: return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 26565: } 26566: 26567: static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26568: { 26569: USE_OPLINE 26570: 26571: 26572: SAVE_OPLINE(); 26573: bitwise_not_function(&EX_T(opline->result.var).tmp_var, 26574: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC) TSRMLS_CC); 26575: 26576: CHECK_EXCEPTION(); 26577: ZEND_VM_NEXT_OPCODE(); 26578: } 26579: 26580: static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26581: { 26582: USE_OPLINE 26583: 26584: 26585: SAVE_OPLINE(); 26586: boolean_not_function(&EX_T(opline->result.var).tmp_var, 26587: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC) TSRMLS_CC); 26588: 26589: CHECK_EXCEPTION(); 26590: ZEND_VM_NEXT_OPCODE(); 26591: } 26592: 26593: static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26594: { 26595: USE_OPLINE 26596: 26597: zval **var_ptr; 26598: 26599: SAVE_OPLINE(); 26600: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 26601: 26602: if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 26603: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 26604: } 26605: if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 26606: if (RETURN_VALUE_USED(opline)) { 26607: PZVAL_LOCK(&EG(uninitialized_zval)); 26608: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 26609: } 26610: 26611: CHECK_EXCEPTION(); 26612: ZEND_VM_NEXT_OPCODE(); 26613: } 26614: 26615: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 26616: 26617: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 26618: && Z_OBJ_HANDLER_PP(var_ptr, get) 26619: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 26620: /* proxy object */ 26621: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 26622: Z_ADDREF_P(val); 26623: fast_increment_function(val); 26624: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 26625: zval_ptr_dtor(&val); 26626: } else { 26627: fast_increment_function(*var_ptr); 26628: } 26629: 26630: if (RETURN_VALUE_USED(opline)) { 26631: PZVAL_LOCK(*var_ptr); 26632: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 26633: } 26634: 26635: CHECK_EXCEPTION(); 26636: ZEND_VM_NEXT_OPCODE(); 26637: } 26638: 26639: static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26640: { 26641: USE_OPLINE 26642: 26643: zval **var_ptr; 26644: 26645: SAVE_OPLINE(); 26646: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 26647: 26648: if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 26649: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 26650: } 26651: if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 26652: if (RETURN_VALUE_USED(opline)) { 26653: PZVAL_LOCK(&EG(uninitialized_zval)); 26654: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 26655: } 26656: 26657: CHECK_EXCEPTION(); 26658: ZEND_VM_NEXT_OPCODE(); 26659: } 26660: 26661: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 26662: 26663: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 26664: && Z_OBJ_HANDLER_PP(var_ptr, get) 26665: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 26666: /* proxy object */ 26667: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 26668: Z_ADDREF_P(val); 26669: fast_decrement_function(val); 26670: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 26671: zval_ptr_dtor(&val); 26672: } else { 26673: fast_decrement_function(*var_ptr); 26674: } 26675: 26676: if (RETURN_VALUE_USED(opline)) { 26677: PZVAL_LOCK(*var_ptr); 26678: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 26679: } 26680: 26681: CHECK_EXCEPTION(); 26682: ZEND_VM_NEXT_OPCODE(); 26683: } 26684: 26685: static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26686: { 26687: USE_OPLINE 26688: 26689: zval **var_ptr, *retval; 26690: 26691: SAVE_OPLINE(); 26692: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 26693: 26694: if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 26695: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 26696: } 26697: if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 26698: ZVAL_NULL(&EX_T(opline->result.var).tmp_var); 26699: 26700: CHECK_EXCEPTION(); 26701: ZEND_VM_NEXT_OPCODE(); 26702: } 26703: 26704: retval = &EX_T(opline->result.var).tmp_var; 26705: ZVAL_COPY_VALUE(retval, *var_ptr); 26706: zendi_zval_copy_ctor(*retval); 26707: 26708: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 26709: 26710: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 26711: && Z_OBJ_HANDLER_PP(var_ptr, get) 26712: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 26713: /* proxy object */ 26714: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 26715: Z_ADDREF_P(val); 26716: fast_increment_function(val); 26717: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 26718: zval_ptr_dtor(&val); 26719: } else { 26720: fast_increment_function(*var_ptr); 26721: } 26722: 26723: CHECK_EXCEPTION(); 26724: ZEND_VM_NEXT_OPCODE(); 26725: } 26726: 26727: static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26728: { 26729: USE_OPLINE 26730: 26731: zval **var_ptr, *retval; 26732: 26733: SAVE_OPLINE(); 26734: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 26735: 26736: if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { 26737: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 26738: } 26739: if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { 26740: ZVAL_NULL(&EX_T(opline->result.var).tmp_var); 26741: 26742: CHECK_EXCEPTION(); 26743: ZEND_VM_NEXT_OPCODE(); 26744: } 26745: 26746: retval = &EX_T(opline->result.var).tmp_var; 26747: ZVAL_COPY_VALUE(retval, *var_ptr); 26748: zendi_zval_copy_ctor(*retval); 26749: 26750: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 26751: 26752: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 26753: && Z_OBJ_HANDLER_PP(var_ptr, get) 26754: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 26755: /* proxy object */ 26756: zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 26757: Z_ADDREF_P(val); 26758: fast_decrement_function(val); 26759: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); 26760: zval_ptr_dtor(&val); 26761: } else { 26762: fast_decrement_function(*var_ptr); 26763: } 26764: 26765: CHECK_EXCEPTION(); 26766: ZEND_VM_NEXT_OPCODE(); 26767: } 26768: 26769: static int ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26770: { 26771: USE_OPLINE 26772: 26773: zval *z; 26774: 26775: SAVE_OPLINE(); 26776: z = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26777: 26778: if (IS_CV == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { 26779: INIT_PZVAL(z); 26780: } 26781: zend_print_variable(z); 26782: 26783: CHECK_EXCEPTION(); 26784: ZEND_VM_NEXT_OPCODE(); 26785: } 26786: 26787: static int ZEND_FASTCALL ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26788: { 26789: USE_OPLINE 26790: 26791: ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); 26792: return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 26793: } 26794: 26795: static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26796: { 26797: USE_OPLINE 26798: 26799: zval *val; 26800: int ret; 26801: 26802: SAVE_OPLINE(); 26803: val = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26804: 26805: if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 26806: ret = Z_LVAL_P(val); 26807: } else { 26808: ret = i_zend_is_true(val); 26809: 26810: if (UNEXPECTED(EG(exception) != NULL)) { 26811: HANDLE_EXCEPTION(); 26812: } 26813: } 26814: if (!ret) { 26815: #if DEBUG_ZEND>=2 26816: printf("Conditional jmp to %d\n", opline->op2.opline_num); 26817: #endif 26818: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 26819: ZEND_VM_CONTINUE(); 26820: } 26821: 26822: ZEND_VM_NEXT_OPCODE(); 26823: } 26824: 26825: static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26826: { 26827: USE_OPLINE 26828: 26829: zval *val; 26830: int ret; 26831: 26832: SAVE_OPLINE(); 26833: val = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26834: 26835: if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 26836: ret = Z_LVAL_P(val); 26837: } else { 26838: ret = i_zend_is_true(val); 26839: 26840: if (UNEXPECTED(EG(exception) != NULL)) { 26841: HANDLE_EXCEPTION(); 26842: } 26843: } 26844: if (ret) { 26845: #if DEBUG_ZEND>=2 26846: printf("Conditional jmp to %d\n", opline->op2.opline_num); 26847: #endif 26848: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 26849: ZEND_VM_CONTINUE(); 26850: } 26851: 26852: ZEND_VM_NEXT_OPCODE(); 26853: } 26854: 26855: static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26856: { 26857: USE_OPLINE 26858: 26859: zval *val; 26860: int retval; 26861: 26862: SAVE_OPLINE(); 26863: val = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26864: 26865: if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 26866: retval = Z_LVAL_P(val); 26867: } else { 26868: retval = i_zend_is_true(val); 26869: 26870: if (UNEXPECTED(EG(exception) != NULL)) { 26871: HANDLE_EXCEPTION(); 26872: } 26873: } 26874: if (EXPECTED(retval != 0)) { 26875: #if DEBUG_ZEND>=2 26876: printf("Conditional jmp on true to %d\n", opline->extended_value); 26877: #endif 26878: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); 26879: ZEND_VM_CONTINUE(); /* CHECK_ME */ 26880: } else { 26881: #if DEBUG_ZEND>=2 26882: printf("Conditional jmp on false to %d\n", opline->op2.opline_num); 26883: #endif 26884: ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); 26885: ZEND_VM_CONTINUE(); /* CHECK_ME */ 26886: } 26887: } 26888: 26889: static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26890: { 26891: USE_OPLINE 26892: 26893: zval *val; 26894: int retval; 26895: 26896: SAVE_OPLINE(); 26897: val = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26898: 26899: if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 26900: retval = Z_LVAL_P(val); 26901: } else { 26902: retval = i_zend_is_true(val); 26903: 26904: if (UNEXPECTED(EG(exception) != NULL)) { 26905: HANDLE_EXCEPTION(); 26906: } 26907: } 26908: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 26909: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 26910: if (!retval) { 26911: #if DEBUG_ZEND>=2 26912: printf("Conditional jmp to %d\n", opline->op2.opline_num); 26913: #endif 26914: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 26915: ZEND_VM_CONTINUE(); 26916: } 26917: ZEND_VM_NEXT_OPCODE(); 26918: } 26919: 26920: static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26921: { 26922: USE_OPLINE 26923: 26924: zval *val; 26925: int retval; 26926: 26927: SAVE_OPLINE(); 26928: val = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26929: 26930: if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { 26931: retval = Z_LVAL_P(val); 26932: } else { 26933: retval = i_zend_is_true(val); 26934: 26935: if (UNEXPECTED(EG(exception) != NULL)) { 26936: HANDLE_EXCEPTION(); 26937: } 26938: } 26939: Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; 26940: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 26941: if (retval) { 26942: #if DEBUG_ZEND>=2 26943: printf("Conditional jmp to %d\n", opline->op2.opline_num); 26944: #endif 26945: ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); 26946: ZEND_VM_CONTINUE(); 26947: } 26948: ZEND_VM_NEXT_OPCODE(); 26949: } 26950: 26951: static int ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26952: { 26953: USE_OPLINE 26954: zval *retval_ptr; 26955: 26956: 26957: SAVE_OPLINE(); 26958: retval_ptr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 26959: 26960: if (!EG(return_value_ptr_ptr)) { 26961: if (IS_CV == IS_TMP_VAR) { 26962: 26963: } 26964: } else if (!0) { /* Not a temp var */ 26965: if (IS_CV == IS_CONST || 26966: (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) { 26967: zval *ret; 26968: 26969: ALLOC_ZVAL(ret); 26970: INIT_PZVAL_COPY(ret, retval_ptr); 26971: zval_copy_ctor(ret); 26972: *EG(return_value_ptr_ptr) = ret; 26973: } else if ((IS_CV == IS_CV || IS_CV == IS_VAR) && 26974: retval_ptr == &EG(uninitialized_zval)) { 26975: zval *ret; 26976: 26977: ALLOC_INIT_ZVAL(ret); 26978: *EG(return_value_ptr_ptr) = ret; 26979: } else { 26980: *EG(return_value_ptr_ptr) = retval_ptr; 26981: Z_ADDREF_P(retval_ptr); 26982: } 26983: } else { 26984: zval *ret; 26985: 26986: ALLOC_ZVAL(ret); 26987: INIT_PZVAL_COPY(ret, retval_ptr); 26988: *EG(return_value_ptr_ptr) = ret; 26989: } 26990: 26991: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 26992: } 26993: 26994: static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 26995: { 26996: USE_OPLINE 26997: zval *retval_ptr; 26998: zval **retval_ptr_ptr; 26999: 27000: 27001: SAVE_OPLINE(); 27002: 27003: do { 27004: if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { 27005: /* Not supposed to happen, but we'll allow it */ 27006: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 27007: 27008: retval_ptr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27009: if (!EG(return_value_ptr_ptr)) { 27010: if (IS_CV == IS_TMP_VAR) { 27011: 27012: } 27013: } else if (!0) { /* Not a temp var */ 27014: zval *ret; 27015: 27016: ALLOC_ZVAL(ret); 27017: INIT_PZVAL_COPY(ret, retval_ptr); 27018: zval_copy_ctor(ret); 27019: *EG(return_value_ptr_ptr) = ret; 27020: } else { 27021: zval *ret; 27022: 27023: ALLOC_ZVAL(ret); 27024: INIT_PZVAL_COPY(ret, retval_ptr); 27025: *EG(return_value_ptr_ptr) = ret; 27026: } 27027: break; 27028: } 27029: 27030: retval_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 27031: 27032: if (IS_CV == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { 27033: zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); 27034: } 27035: 27036: if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { 27037: if (opline->extended_value == ZEND_RETURNS_FUNCTION && 27038: EX_T(opline->op1.var).var.fcall_returned_reference) { 27039: } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { 27040: zend_error(E_NOTICE, "Only variable references should be returned by reference"); 27041: if (EG(return_value_ptr_ptr)) { 27042: zval *ret; 27043: 27044: ALLOC_ZVAL(ret); 27045: INIT_PZVAL_COPY(ret, *retval_ptr_ptr); 27046: zval_copy_ctor(ret); 27047: *EG(return_value_ptr_ptr) = ret; 27048: } 27049: break; 27050: } 27051: } 27052: 27053: if (EG(return_value_ptr_ptr)) { 27054: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); 27055: Z_ADDREF_PP(retval_ptr_ptr); 27056: 27057: *EG(return_value_ptr_ptr) = *retval_ptr_ptr; 27058: } 27059: } while (0); 27060: 27061: return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 27062: } 27063: 27064: static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27065: { 27066: USE_OPLINE 27067: zval *value; 27068: zval *exception; 27069: 27070: 27071: SAVE_OPLINE(); 27072: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27073: 27074: if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { 27075: zend_error_noreturn(E_ERROR, "Can only throw objects"); 27076: } 27077: zend_exception_save(TSRMLS_C); 27078: /* Not sure if a complete copy is what we want here */ 27079: ALLOC_ZVAL(exception); 27080: INIT_PZVAL_COPY(exception, value); 27081: if (!0) { 27082: zval_copy_ctor(exception); 27083: } 27084: 27085: zend_throw_exception_object(exception TSRMLS_CC); 27086: zend_exception_restore(TSRMLS_C); 27087: 27088: HANDLE_EXCEPTION(); 27089: } 27090: 27091: static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS) 27092: { 27093: USE_OPLINE 27094: zval *varptr; 27095: 27096: varptr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27097: 27098: if (varptr == &EG(uninitialized_zval)) { 27099: ALLOC_ZVAL(varptr); 27100: INIT_ZVAL(*varptr); 27101: Z_SET_REFCOUNT_P(varptr, 0); 27102: } else if (PZVAL_IS_REF(varptr)) { 27103: zval *original_var = varptr; 27104: 27105: ALLOC_ZVAL(varptr); 27106: ZVAL_COPY_VALUE(varptr, original_var); 27107: Z_UNSET_ISREF_P(varptr); 27108: Z_SET_REFCOUNT_P(varptr, 0); 27109: zval_copy_ctor(varptr); 27110: } 27111: Z_ADDREF_P(varptr); 27112: zend_vm_stack_push(varptr TSRMLS_CC); 27113: ; /* for string offsets */ 27114: 27115: CHECK_EXCEPTION(); 27116: ZEND_VM_NEXT_OPCODE(); 27117: } 27118: 27119: static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27120: { 27121: USE_OPLINE 27122: zend_free_op free_op1; 27123: zval *varptr; 27124: 27125: SAVE_OPLINE(); 27126: if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */ 27127: if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) { 27128: return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 27129: } 27130: } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 27131: return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 27132: } 27133: 27134: if (IS_CV == IS_VAR && 27135: (opline->extended_value & ZEND_ARG_SEND_FUNCTION) && 27136: EX_T(opline->op1.var).var.fcall_returned_reference && 27137: EX_T(opline->op1.var).var.ptr) { 27138: varptr = EX_T(opline->op1.var).var.ptr; 27139: PZVAL_UNLOCK_EX(varptr, &free_op1, 0); 27140: } else { 27141: varptr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27142: } 27143: if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) || 27144: EX_T(opline->op1.var).var.fcall_returned_reference) && 27145: varptr != &EG(uninitialized_zval) && 27146: (PZVAL_IS_REF(varptr) || 27147: (Z_REFCOUNT_P(varptr) == 1 && (IS_CV == IS_CV || free_op1.var)))) { 27148: Z_SET_ISREF_P(varptr); 27149: Z_ADDREF_P(varptr); 27150: zend_vm_stack_push(varptr TSRMLS_CC); 27151: } else { 27152: zval *valptr; 27153: 27154: if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? 27155: !(opline->extended_value & ZEND_ARG_SEND_SILENT) : 27156: !ARG_MAY_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 27157: zend_error(E_STRICT, "Only variables should be passed by reference"); 27158: } 27159: ALLOC_ZVAL(valptr); 27160: INIT_PZVAL_COPY(valptr, varptr); 27161: if (!0) { 27162: zval_copy_ctor(valptr); 27163: } 27164: zend_vm_stack_push(valptr TSRMLS_CC); 27165: } 27166: 27167: CHECK_EXCEPTION(); 27168: ZEND_VM_NEXT_OPCODE(); 27169: } 27170: 27171: static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27172: { 27173: USE_OPLINE 27174: 27175: zval **varptr_ptr; 27176: zval *varptr; 27177: 27178: SAVE_OPLINE(); 27179: varptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 27180: 27181: if (IS_CV == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) { 27182: zend_error_noreturn(E_ERROR, "Only variables can be passed by reference"); 27183: } 27184: 27185: if (IS_CV == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) { 27186: ALLOC_INIT_ZVAL(varptr); 27187: zend_vm_stack_push(varptr TSRMLS_CC); 27188: CHECK_EXCEPTION(); 27189: ZEND_VM_NEXT_OPCODE(); 27190: } 27191: 27192: if (opline->extended_value == ZEND_DO_FCALL_BY_NAME && 27193: EX(function_state).function->type == ZEND_INTERNAL_FUNCTION && 27194: !ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 27195: return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 27196: } 27197: 27198: SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr); 27199: varptr = *varptr_ptr; 27200: Z_ADDREF_P(varptr); 27201: zend_vm_stack_push(varptr TSRMLS_CC); 27202: 27203: CHECK_EXCEPTION(); 27204: ZEND_VM_NEXT_OPCODE(); 27205: } 27206: 27207: static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27208: { 27209: USE_OPLINE 27210: 27211: if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME) 27212: && ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.opline_num)) { 27213: return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 27214: } 27215: SAVE_OPLINE(); 27216: return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 27217: } 27218: 27219: static int ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27220: { 27221: USE_OPLINE 27222: 27223: zval *retval = &EX_T(opline->result.var).tmp_var; 27224: 27225: SAVE_OPLINE(); 27226: /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ 27227: ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC))); 27228: 27229: CHECK_EXCEPTION(); 27230: ZEND_VM_NEXT_OPCODE(); 27231: } 27232: 27233: static int ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27234: { 27235: USE_OPLINE 27236: 27237: zval *obj; 27238: zend_class_entry *ce; 27239: zend_function *clone; 27240: zend_object_clone_obj_t clone_call; 27241: 27242: SAVE_OPLINE(); 27243: obj = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27244: 27245: if (IS_CV == IS_CONST || 27246: UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) { 27247: zend_error_noreturn(E_ERROR, "__clone method called on non-object"); 27248: } 27249: 27250: ce = Z_OBJCE_P(obj); 27251: clone = ce ? ce->clone : NULL; 27252: clone_call = Z_OBJ_HT_P(obj)->clone_obj; 27253: if (UNEXPECTED(clone_call == NULL)) { 27254: if (ce) { 27255: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); 27256: } else { 27257: zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); 27258: } 27259: } 27260: 27261: if (ce && clone) { 27262: if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) { 27263: /* Ensure that if we're calling a private function, we're allowed to do so. 27264: */ 27265: if (UNEXPECTED(ce != EG(scope))) { 27266: zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 27267: } 27268: } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { 27269: /* Ensure that if we're calling a protected function, we're allowed to do so. 27270: */ 27271: if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { 27272: zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); 27273: } 27274: } 27275: } 27276: 27277: if (EXPECTED(EG(exception) == NULL)) { 27278: zval *retval; 27279: 27280: ALLOC_ZVAL(retval); 27281: Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); 27282: Z_TYPE_P(retval) = IS_OBJECT; 27283: Z_SET_REFCOUNT_P(retval, 1); 27284: Z_SET_ISREF_P(retval); 27285: if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { 27286: zval_ptr_dtor(&retval); 27287: } else { 27288: AI_SET_PTR(&EX_T(opline->result.var), retval); 27289: } 27290: } 27291: 27292: CHECK_EXCEPTION(); 27293: ZEND_VM_NEXT_OPCODE(); 27294: } 27295: 27296: static int ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27297: { 27298: USE_OPLINE 27299: 27300: zval *expr; 27301: zval *result = &EX_T(opline->result.var).tmp_var; 27302: 27303: SAVE_OPLINE(); 27304: expr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27305: 27306: if (opline->extended_value != IS_STRING) { 27307: ZVAL_COPY_VALUE(result, expr); 27308: if (!0) { 27309: zendi_zval_copy_ctor(*result); 27310: } 27311: } 27312: switch (opline->extended_value) { 27313: case IS_NULL: 27314: convert_to_null(result); 27315: break; 27316: case IS_BOOL: 27317: convert_to_boolean(result); 27318: break; 27319: case IS_LONG: 27320: convert_to_long(result); 27321: break; 27322: case IS_DOUBLE: 27323: convert_to_double(result); 27324: break; 27325: case IS_STRING: { 27326: zval var_copy; 27327: int use_copy; 27328: 27329: zend_make_printable_zval(expr, &var_copy, &use_copy); 27330: if (use_copy) { 27331: ZVAL_COPY_VALUE(result, &var_copy); 27332: if (0) { 27333: 27334: } 27335: } else { 27336: ZVAL_COPY_VALUE(result, expr); 27337: if (!0) { 27338: zendi_zval_copy_ctor(*result); 27339: } 27340: } 27341: break; 27342: } 27343: case IS_ARRAY: 27344: convert_to_array(result); 27345: break; 27346: case IS_OBJECT: 27347: convert_to_object(result); 27348: break; 27349: } 27350: 27351: CHECK_EXCEPTION(); 27352: ZEND_VM_NEXT_OPCODE(); 27353: } 27354: 27355: static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27356: { 27357: USE_OPLINE 27358: zend_op_array *new_op_array=NULL; 27359: 27360: zval *inc_filename; 27361: zval *tmp_inc_filename = NULL; 27362: zend_bool failure_retval=0; 27363: 27364: SAVE_OPLINE(); 27365: inc_filename = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27366: 27367: if (inc_filename->type!=IS_STRING) { 27368: MAKE_STD_ZVAL(tmp_inc_filename); 27369: ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); 27370: zval_copy_ctor(tmp_inc_filename); 27371: convert_to_string(tmp_inc_filename); 27372: inc_filename = tmp_inc_filename; 27373: } 27374: 27375: if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { 27376: if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { 27377: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 27378: } else { 27379: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 27380: } 27381: } else { 27382: switch (opline->extended_value) { 27383: case ZEND_INCLUDE_ONCE: 27384: case ZEND_REQUIRE_ONCE: { 27385: zend_file_handle file_handle; 27386: char *resolved_path; 27387: 27388: resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); 27389: if (resolved_path) { 27390: failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); 27391: } else { 27392: resolved_path = Z_STRVAL_P(inc_filename); 27393: } 27394: 27395: if (failure_retval) { 27396: /* do nothing, file already included */ 27397: } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) { 27398: 27399: if (!file_handle.opened_path) { 27400: file_handle.opened_path = estrdup(resolved_path); 27401: } 27402: 27403: if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { 27404: new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); 27405: zend_destroy_file_handle(&file_handle TSRMLS_CC); 27406: } else { 27407: zend_file_handle_dtor(&file_handle TSRMLS_CC); 27408: failure_retval=1; 27409: } 27410: } else { 27411: if (opline->extended_value == ZEND_INCLUDE_ONCE) { 27412: zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 27413: } else { 27414: zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); 27415: } 27416: } 27417: if (resolved_path != Z_STRVAL_P(inc_filename)) { 27418: efree(resolved_path); 27419: } 27420: } 27421: break; 27422: case ZEND_INCLUDE: 27423: case ZEND_REQUIRE: 27424: new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC); 27425: break; 27426: case ZEND_EVAL: { 27427: char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC); 27428: 27429: new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC); 27430: efree(eval_desc); 27431: } 27432: break; 27433: EMPTY_SWITCH_DEFAULT_CASE() 27434: } 27435: } 27436: if (tmp_inc_filename) { 27437: zval_ptr_dtor(&tmp_inc_filename); 27438: } 27439: 27440: if (UNEXPECTED(EG(exception) != NULL)) { 27441: HANDLE_EXCEPTION(); 27442: } else if (EXPECTED(new_op_array != NULL)) { 27443: EX(original_return_value) = EG(return_value_ptr_ptr); 27444: EG(active_op_array) = new_op_array; 27445: if (RETURN_VALUE_USED(opline)) { 27446: EX_T(opline->result.var).var.ptr = NULL; 27447: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 27448: EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; 27449: } else { 27450: EG(return_value_ptr_ptr) = NULL; 27451: } 27452: 27453: EX(current_object) = EX(object); 27454: 27455: EX(function_state).function = (zend_function *) new_op_array; 27456: EX(object) = NULL; 27457: 27458: if (!EG(active_symbol_table)) { 27459: zend_rebuild_symbol_table(TSRMLS_C); 27460: } 27461: 27462: if (EXPECTED(zend_execute == execute)) { 27463: ZEND_VM_ENTER(); 27464: } else { 27465: zend_execute(new_op_array TSRMLS_CC); 27466: } 27467: 27468: EX(function_state).function = (zend_function *) EX(op_array); 27469: EX(object) = EX(current_object); 27470: 27471: EG(opline_ptr) = &EX(opline); 27472: EG(active_op_array) = EX(op_array); 27473: EG(return_value_ptr_ptr) = EX(original_return_value); 27474: destroy_op_array(new_op_array TSRMLS_CC); 27475: efree(new_op_array); 27476: if (UNEXPECTED(EG(exception) != NULL)) { 27477: zend_throw_exception_internal(NULL TSRMLS_CC); 27478: HANDLE_EXCEPTION(); 27479: } else if (RETURN_VALUE_USED(opline)) { 27480: if (!EX_T(opline->result.var).var.ptr) { /* there was no return statement */ 27481: zval *retval; 27482: 27483: ALLOC_ZVAL(retval); 27484: ZVAL_BOOL(retval, 1); 27485: INIT_PZVAL(retval); 27486: EX_T(opline->result.var).var.ptr = retval; 27487: } 27488: } 27489: 27490: } else if (RETURN_VALUE_USED(opline)) { 27491: zval *retval; 27492: 27493: ALLOC_ZVAL(retval); 27494: ZVAL_BOOL(retval, failure_retval); 27495: INIT_PZVAL(retval); 27496: AI_SET_PTR(&EX_T(opline->result.var), retval); 27497: } 27498: ZEND_VM_NEXT_OPCODE(); 27499: } 27500: 27501: static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27502: { 27503: USE_OPLINE 27504: 27505: zval *array_ptr, **array_ptr_ptr; 27506: HashTable *fe_ht; 27507: zend_object_iterator *iter = NULL; 27508: zend_class_entry *ce = NULL; 27509: zend_bool is_empty = 0; 27510: 27511: SAVE_OPLINE(); 27512: 27513: if ((IS_CV == IS_CV || IS_CV == IS_VAR) && 27514: (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { 27515: array_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27516: if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { 27517: MAKE_STD_ZVAL(array_ptr); 27518: ZVAL_NULL(array_ptr); 27519: } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { 27520: if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { 27521: zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); 27522: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 27523: } 27524: 27525: ce = Z_OBJCE_PP(array_ptr_ptr); 27526: if (!ce || ce->get_iterator == NULL) { 27527: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 27528: Z_ADDREF_PP(array_ptr_ptr); 27529: } 27530: array_ptr = *array_ptr_ptr; 27531: } else { 27532: if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { 27533: SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); 27534: if (opline->extended_value & ZEND_FE_FETCH_BYREF) { 27535: Z_SET_ISREF_PP(array_ptr_ptr); 27536: } 27537: } 27538: array_ptr = *array_ptr_ptr; 27539: Z_ADDREF_P(array_ptr); 27540: } 27541: } else { 27542: array_ptr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27543: if (0) { /* IS_TMP_VAR */ 27544: zval *tmp; 27545: 27546: ALLOC_ZVAL(tmp); 27547: INIT_PZVAL_COPY(tmp, array_ptr); 27548: array_ptr = tmp; 27549: if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 27550: ce = Z_OBJCE_P(array_ptr); 27551: if (ce && ce->get_iterator) { 27552: Z_DELREF_P(array_ptr); 27553: } 27554: } 27555: } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { 27556: ce = Z_OBJCE_P(array_ptr); 27557: if (!ce || !ce->get_iterator) { 27558: Z_ADDREF_P(array_ptr); 27559: } 27560: } else if (IS_CV == IS_CONST || 27561: ((IS_CV == IS_CV || IS_CV == IS_VAR) && 27562: !Z_ISREF_P(array_ptr) && 27563: Z_REFCOUNT_P(array_ptr) > 1)) { 27564: zval *tmp; 27565: 27566: ALLOC_ZVAL(tmp); 27567: INIT_PZVAL_COPY(tmp, array_ptr); 27568: zval_copy_ctor(tmp); 27569: array_ptr = tmp; 27570: } else { 27571: Z_ADDREF_P(array_ptr); 27572: } 27573: } 27574: 27575: if (ce && ce->get_iterator) { 27576: iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC); 27577: 27578: if (iter && EXPECTED(EG(exception) == NULL)) { 27579: array_ptr = zend_iterator_wrap(iter TSRMLS_CC); 27580: } else { 27581: 27582: if (!EG(exception)) { 27583: zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); 27584: } 27585: zend_throw_exception_internal(NULL TSRMLS_CC); 27586: HANDLE_EXCEPTION(); 27587: } 27588: } 27589: 27590: EX_T(opline->result.var).fe.ptr = array_ptr; 27591: 27592: if (iter) { 27593: iter->index = 0; 27594: if (iter->funcs->rewind) { 27595: iter->funcs->rewind(iter TSRMLS_CC); 27596: if (UNEXPECTED(EG(exception) != NULL)) { 27597: zval_ptr_dtor(&array_ptr); 27598: 27599: HANDLE_EXCEPTION(); 27600: } 27601: } 27602: is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; 27603: if (UNEXPECTED(EG(exception) != NULL)) { 27604: zval_ptr_dtor(&array_ptr); 27605: 27606: HANDLE_EXCEPTION(); 27607: } 27608: iter->index = -1; /* will be set to 0 before using next handler */ 27609: } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { 27610: zend_hash_internal_pointer_reset(fe_ht); 27611: if (ce) { 27612: zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); 27613: while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { 27614: char *str_key; 27615: uint str_key_len; 27616: ulong int_key; 27617: zend_uchar key_type; 27618: 27619: key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); 27620: if (key_type != HASH_KEY_NON_EXISTANT && 27621: (key_type == HASH_KEY_IS_LONG || 27622: zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { 27623: break; 27624: } 27625: zend_hash_move_forward(fe_ht); 27626: } 27627: } 27628: is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; 27629: zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); 27630: } else { 27631: zend_error(E_WARNING, "Invalid argument supplied for foreach()"); 27632: is_empty = 1; 27633: } 27634: 27635: if (is_empty) { 27636: ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); 27637: } else { 27638: CHECK_EXCEPTION(); 27639: ZEND_VM_NEXT_OPCODE(); 27640: } 27641: } 27642: 27643: static int ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27644: { 27645: #if 0 || (IS_CV != IS_UNUSED) 27646: USE_OPLINE 27647: 27648: SAVE_OPLINE(); 27649: if (IS_CV != IS_UNUSED) { 27650: 27651: zval *ptr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27652: 27653: if (Z_TYPE_P(ptr) == IS_LONG) { 27654: EG(exit_status) = Z_LVAL_P(ptr); 27655: } else { 27656: zend_print_variable(ptr); 27657: } 27658: 27659: } 27660: #endif 27661: zend_bailout(); 27662: ZEND_VM_NEXT_OPCODE(); /* Never reached */ 27663: } 27664: 27665: static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27666: { 27667: USE_OPLINE 27668: 27669: zval *value; 27670: 27671: SAVE_OPLINE(); 27672: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27673: 27674: if (i_zend_is_true(value)) { 27675: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 27676: if (!0) { 27677: zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); 27678: } 27679: 27680: #if DEBUG_ZEND>=2 27681: printf("Conditional jmp to %d\n", opline->op2.opline_num); 27682: #endif 27683: ZEND_VM_JMP(opline->op2.jmp_addr); 27684: } 27685: 27686: CHECK_EXCEPTION(); 27687: ZEND_VM_NEXT_OPCODE(); 27688: } 27689: 27690: static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27691: { 27692: USE_OPLINE 27693: 27694: zval *value, *ret; 27695: 27696: SAVE_OPLINE(); 27697: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27698: 27699: if (i_zend_is_true(value)) { 27700: if (IS_CV == IS_VAR || IS_CV == IS_CV) { 27701: Z_ADDREF_P(value); 27702: EX_T(opline->result.var).var.ptr = value; 27703: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 27704: } else { 27705: ALLOC_ZVAL(ret); 27706: INIT_PZVAL_COPY(ret, value); 27707: EX_T(opline->result.var).var.ptr = ret; 27708: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 27709: if (!0) { 27710: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 27711: } 27712: } 27713: 27714: #if DEBUG_ZEND>=2 27715: printf("Conditional jmp to %d\n", opline->op2.opline_num); 27716: #endif 27717: ZEND_VM_JMP(opline->op2.jmp_addr); 27718: } 27719: 27720: CHECK_EXCEPTION(); 27721: ZEND_VM_NEXT_OPCODE(); 27722: } 27723: 27724: static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27725: { 27726: USE_OPLINE 27727: 27728: zval *value; 27729: 27730: SAVE_OPLINE(); 27731: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27732: 27733: ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); 27734: if (!0) { 27735: zval_copy_ctor(&EX_T(opline->result.var).tmp_var); 27736: } 27737: 27738: CHECK_EXCEPTION(); 27739: ZEND_VM_NEXT_OPCODE(); 27740: } 27741: 27742: static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27743: { 27744: USE_OPLINE 27745: 27746: zval *value, *ret; 27747: 27748: SAVE_OPLINE(); 27749: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27750: 27751: if (IS_CV == IS_VAR || IS_CV == IS_CV) { 27752: Z_ADDREF_P(value); 27753: EX_T(opline->result.var).var.ptr = value; 27754: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 27755: } else { 27756: ALLOC_ZVAL(ret); 27757: INIT_PZVAL_COPY(ret, value); 27758: EX_T(opline->result.var).var.ptr = ret; 27759: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 27760: if (!0) { 27761: zval_copy_ctor(EX_T(opline->result.var).var.ptr); 27762: } 27763: } 27764: 27765: CHECK_EXCEPTION(); 27766: ZEND_VM_NEXT_OPCODE(); 27767: } 27768: 27769: static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27770: { 27771: USE_OPLINE 27772: 27773: zval *expr; 27774: zend_bool result; 27775: 27776: SAVE_OPLINE(); 27777: expr = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 27778: 27779: if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { 27780: result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); 27781: } else { 27782: result = 0; 27783: } 27784: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); 27785: 27786: CHECK_EXCEPTION(); 27787: ZEND_VM_NEXT_OPCODE(); 27788: } 27789: 27790: static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27791: { 27792: USE_OPLINE 27793: 27794: 27795: SAVE_OPLINE(); 27796: fast_add_function(&EX_T(opline->result.var).tmp_var, 27797: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27798: opline->op2.zv TSRMLS_CC); 27799: 27800: 27801: CHECK_EXCEPTION(); 27802: ZEND_VM_NEXT_OPCODE(); 27803: } 27804: 27805: static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27806: { 27807: USE_OPLINE 27808: 27809: 27810: SAVE_OPLINE(); 27811: fast_sub_function(&EX_T(opline->result.var).tmp_var, 27812: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27813: opline->op2.zv TSRMLS_CC); 27814: 27815: 27816: CHECK_EXCEPTION(); 27817: ZEND_VM_NEXT_OPCODE(); 27818: } 27819: 27820: static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27821: { 27822: USE_OPLINE 27823: 27824: 27825: SAVE_OPLINE(); 27826: fast_mul_function(&EX_T(opline->result.var).tmp_var, 27827: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27828: opline->op2.zv TSRMLS_CC); 27829: 27830: 27831: CHECK_EXCEPTION(); 27832: ZEND_VM_NEXT_OPCODE(); 27833: } 27834: 27835: static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27836: { 27837: USE_OPLINE 27838: 27839: 27840: SAVE_OPLINE(); 27841: fast_div_function(&EX_T(opline->result.var).tmp_var, 27842: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27843: opline->op2.zv TSRMLS_CC); 27844: 27845: 27846: CHECK_EXCEPTION(); 27847: ZEND_VM_NEXT_OPCODE(); 27848: } 27849: 27850: static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27851: { 27852: USE_OPLINE 27853: 27854: 27855: SAVE_OPLINE(); 27856: fast_mod_function(&EX_T(opline->result.var).tmp_var, 27857: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27858: opline->op2.zv TSRMLS_CC); 27859: 27860: 27861: CHECK_EXCEPTION(); 27862: ZEND_VM_NEXT_OPCODE(); 27863: } 27864: 27865: static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27866: { 27867: USE_OPLINE 27868: 27869: 27870: SAVE_OPLINE(); 27871: shift_left_function(&EX_T(opline->result.var).tmp_var, 27872: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27873: opline->op2.zv TSRMLS_CC); 27874: 27875: 27876: CHECK_EXCEPTION(); 27877: ZEND_VM_NEXT_OPCODE(); 27878: } 27879: 27880: static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27881: { 27882: USE_OPLINE 27883: 27884: 27885: SAVE_OPLINE(); 27886: shift_right_function(&EX_T(opline->result.var).tmp_var, 27887: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27888: opline->op2.zv TSRMLS_CC); 27889: 27890: 27891: CHECK_EXCEPTION(); 27892: ZEND_VM_NEXT_OPCODE(); 27893: } 27894: 27895: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27896: { 27897: USE_OPLINE 27898: 27899: 27900: SAVE_OPLINE(); 27901: concat_function(&EX_T(opline->result.var).tmp_var, 27902: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27903: opline->op2.zv TSRMLS_CC); 27904: 27905: 27906: CHECK_EXCEPTION(); 27907: ZEND_VM_NEXT_OPCODE(); 27908: } 27909: 27910: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27911: { 27912: USE_OPLINE 27913: 27914: 27915: SAVE_OPLINE(); 27916: is_identical_function(&EX_T(opline->result.var).tmp_var, 27917: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27918: opline->op2.zv TSRMLS_CC); 27919: 27920: 27921: CHECK_EXCEPTION(); 27922: ZEND_VM_NEXT_OPCODE(); 27923: } 27924: 27925: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27926: { 27927: USE_OPLINE 27928: 27929: zval *result = &EX_T(opline->result.var).tmp_var; 27930: 27931: SAVE_OPLINE(); 27932: is_identical_function(result, 27933: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27934: opline->op2.zv TSRMLS_CC); 27935: Z_LVAL_P(result) = !Z_LVAL_P(result); 27936: 27937: 27938: CHECK_EXCEPTION(); 27939: ZEND_VM_NEXT_OPCODE(); 27940: } 27941: 27942: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27943: { 27944: USE_OPLINE 27945: 27946: zval *result = &EX_T(opline->result.var).tmp_var; 27947: 27948: SAVE_OPLINE(); 27949: ZVAL_BOOL(result, fast_equal_function(result, 27950: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27951: opline->op2.zv TSRMLS_CC)); 27952: 27953: 27954: CHECK_EXCEPTION(); 27955: ZEND_VM_NEXT_OPCODE(); 27956: } 27957: 27958: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27959: { 27960: USE_OPLINE 27961: 27962: zval *result = &EX_T(opline->result.var).tmp_var; 27963: 27964: SAVE_OPLINE(); 27965: ZVAL_BOOL(result, fast_not_equal_function(result, 27966: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27967: opline->op2.zv TSRMLS_CC)); 27968: 27969: 27970: CHECK_EXCEPTION(); 27971: ZEND_VM_NEXT_OPCODE(); 27972: } 27973: 27974: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27975: { 27976: USE_OPLINE 27977: 27978: zval *result = &EX_T(opline->result.var).tmp_var; 27979: 27980: SAVE_OPLINE(); 27981: ZVAL_BOOL(result, fast_is_smaller_function(result, 27982: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27983: opline->op2.zv TSRMLS_CC)); 27984: 27985: 27986: CHECK_EXCEPTION(); 27987: ZEND_VM_NEXT_OPCODE(); 27988: } 27989: 27990: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 27991: { 27992: USE_OPLINE 27993: 27994: zval *result = &EX_T(opline->result.var).tmp_var; 27995: 27996: SAVE_OPLINE(); 27997: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 27998: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 27999: opline->op2.zv TSRMLS_CC)); 28000: 28001: 28002: CHECK_EXCEPTION(); 28003: ZEND_VM_NEXT_OPCODE(); 28004: } 28005: 28006: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28007: { 28008: USE_OPLINE 28009: 28010: 28011: SAVE_OPLINE(); 28012: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 28013: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 28014: opline->op2.zv TSRMLS_CC); 28015: 28016: 28017: CHECK_EXCEPTION(); 28018: ZEND_VM_NEXT_OPCODE(); 28019: } 28020: 28021: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28022: { 28023: USE_OPLINE 28024: 28025: 28026: SAVE_OPLINE(); 28027: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 28028: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 28029: opline->op2.zv TSRMLS_CC); 28030: 28031: 28032: CHECK_EXCEPTION(); 28033: ZEND_VM_NEXT_OPCODE(); 28034: } 28035: 28036: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28037: { 28038: USE_OPLINE 28039: 28040: 28041: SAVE_OPLINE(); 28042: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 28043: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 28044: opline->op2.zv TSRMLS_CC); 28045: 28046: 28047: CHECK_EXCEPTION(); 28048: ZEND_VM_NEXT_OPCODE(); 28049: } 28050: 28051: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28052: { 28053: USE_OPLINE 28054: 28055: 28056: SAVE_OPLINE(); 28057: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 28058: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 28059: opline->op2.zv TSRMLS_CC); 28060: 28061: 28062: CHECK_EXCEPTION(); 28063: ZEND_VM_NEXT_OPCODE(); 28064: } 28065: 28066: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 28067: { 28068: USE_OPLINE 28069: zend_free_op free_op_data1; 28070: zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28071: zval *object; 28072: zval *property = opline->op2.zv; 28073: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 28074: int have_get_ptr = 0; 28075: 28076: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 28077: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 28078: } 28079: 28080: make_real_object(object_ptr TSRMLS_CC); 28081: object = *object_ptr; 28082: 28083: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 28084: zend_error(E_WARNING, "Attempt to assign property of non-object"); 28085: 28086: FREE_OP(free_op_data1); 28087: 28088: if (RETURN_VALUE_USED(opline)) { 28089: PZVAL_LOCK(&EG(uninitialized_zval)); 28090: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 28091: EX_T(opline->result.var).var.ptr_ptr = NULL; 28092: } 28093: } else { 28094: /* here we are sure we are dealing with an object */ 28095: if (0) { 28096: MAKE_REAL_ZVAL_PTR(property); 28097: } 28098: 28099: /* here property is a string */ 28100: if (opline->extended_value == ZEND_ASSIGN_OBJ 28101: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 28102: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28103: if (zptr != NULL) { /* NULL means no success in getting PTR */ 28104: SEPARATE_ZVAL_IF_NOT_REF(zptr); 28105: 28106: have_get_ptr = 1; 28107: binary_op(*zptr, *zptr, value TSRMLS_CC); 28108: if (RETURN_VALUE_USED(opline)) { 28109: PZVAL_LOCK(*zptr); 28110: EX_T(opline->result.var).var.ptr = *zptr; 28111: EX_T(opline->result.var).var.ptr_ptr = NULL; 28112: } 28113: } 28114: } 28115: 28116: if (!have_get_ptr) { 28117: zval *z = NULL; 28118: 28119: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 28120: if (Z_OBJ_HT_P(object)->read_property) { 28121: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28122: } 28123: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 28124: if (Z_OBJ_HT_P(object)->read_dimension) { 28125: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 28126: } 28127: } 28128: if (z) { 28129: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 28130: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 28131: 28132: if (Z_REFCOUNT_P(z) == 0) { 28133: GC_REMOVE_ZVAL_FROM_BUFFER(z); 28134: zval_dtor(z); 28135: FREE_ZVAL(z); 28136: } 28137: z = value; 28138: } 28139: Z_ADDREF_P(z); 28140: SEPARATE_ZVAL_IF_NOT_REF(&z); 28141: binary_op(z, z, value TSRMLS_CC); 28142: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 28143: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28144: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 28145: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 28146: } 28147: if (RETURN_VALUE_USED(opline)) { 28148: PZVAL_LOCK(z); 28149: EX_T(opline->result.var).var.ptr = z; 28150: EX_T(opline->result.var).var.ptr_ptr = NULL; 28151: } 28152: zval_ptr_dtor(&z); 28153: } else { 28154: zend_error(E_WARNING, "Attempt to assign property of non-object"); 28155: if (RETURN_VALUE_USED(opline)) { 28156: PZVAL_LOCK(&EG(uninitialized_zval)); 28157: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 28158: EX_T(opline->result.var).var.ptr_ptr = NULL; 28159: } 28160: } 28161: } 28162: 28163: if (0) { 28164: zval_ptr_dtor(&property); 28165: } else { 28166: 28167: } 28168: FREE_OP(free_op_data1); 28169: } 28170: 28171: /* assign_obj has two opcodes! */ 28172: CHECK_EXCEPTION(); 28173: ZEND_VM_INC_OPCODE(); 28174: ZEND_VM_NEXT_OPCODE(); 28175: } 28176: 28177: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 28178: { 28179: USE_OPLINE 28180: zend_free_op free_op_data2, free_op_data1; 28181: zval **var_ptr; 28182: zval *value; 28183: 28184: SAVE_OPLINE(); 28185: switch (opline->extended_value) { 28186: case ZEND_ASSIGN_OBJ: 28187: return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28188: break; 28189: case ZEND_ASSIGN_DIM: { 28190: zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28191: 28192: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28193: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 28194: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 28195: if (IS_CV == IS_VAR && !0) { 28196: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 28197: } 28198: return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28199: } else { 28200: zval *dim = opline->op2.zv; 28201: 28202: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); 28203: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 28204: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 28205: } 28206: } 28207: break; 28208: default: 28209: value = opline->op2.zv; 28210: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28211: /* do nothing */ 28212: break; 28213: } 28214: 28215: if (UNEXPECTED(var_ptr == NULL)) { 28216: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 28217: } 28218: 28219: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 28220: if (RETURN_VALUE_USED(opline)) { 28221: PZVAL_LOCK(&EG(uninitialized_zval)); 28222: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 28223: } 28224: 28225: 28226: CHECK_EXCEPTION(); 28227: if (opline->extended_value == ZEND_ASSIGN_DIM) { 28228: ZEND_VM_INC_OPCODE(); 28229: } 28230: ZEND_VM_NEXT_OPCODE(); 28231: } 28232: 28233: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 28234: 28235: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 28236: && Z_OBJ_HANDLER_PP(var_ptr, get) 28237: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 28238: /* proxy object */ 28239: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 28240: Z_ADDREF_P(objval); 28241: binary_op(objval, objval, value TSRMLS_CC); 28242: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 28243: zval_ptr_dtor(&objval); 28244: } else { 28245: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 28246: } 28247: 28248: if (RETURN_VALUE_USED(opline)) { 28249: PZVAL_LOCK(*var_ptr); 28250: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 28251: } 28252: 28253: if (opline->extended_value == ZEND_ASSIGN_DIM) { 28254: FREE_OP(free_op_data1); 28255: FREE_OP_VAR_PTR(free_op_data2); 28256: 28257: CHECK_EXCEPTION(); 28258: ZEND_VM_INC_OPCODE(); 28259: } else { 28260: 28261: CHECK_EXCEPTION(); 28262: } 28263: ZEND_VM_NEXT_OPCODE(); 28264: } 28265: 28266: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28267: { 28268: return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28269: } 28270: 28271: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28272: { 28273: return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28274: } 28275: 28276: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28277: { 28278: return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28279: } 28280: 28281: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28282: { 28283: return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28284: } 28285: 28286: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28287: { 28288: return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28289: } 28290: 28291: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28292: { 28293: return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28294: } 28295: 28296: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28297: { 28298: return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28299: } 28300: 28301: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28302: { 28303: return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28304: } 28305: 28306: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28307: { 28308: return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28309: } 28310: 28311: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28312: { 28313: return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28314: } 28315: 28316: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28317: { 28318: return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28319: } 28320: 28321: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 28322: { 28323: USE_OPLINE 28324: 28325: zval **object_ptr; 28326: zval *object; 28327: zval *property; 28328: zval **retval; 28329: int have_get_ptr = 0; 28330: 28331: SAVE_OPLINE(); 28332: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28333: property = opline->op2.zv; 28334: retval = &EX_T(opline->result.var).var.ptr; 28335: 28336: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 28337: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 28338: } 28339: 28340: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 28341: object = *object_ptr; 28342: 28343: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 28344: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 28345: 28346: if (RETURN_VALUE_USED(opline)) { 28347: PZVAL_LOCK(&EG(uninitialized_zval)); 28348: *retval = &EG(uninitialized_zval); 28349: } 28350: 28351: CHECK_EXCEPTION(); 28352: ZEND_VM_NEXT_OPCODE(); 28353: } 28354: 28355: /* here we are sure we are dealing with an object */ 28356: 28357: if (0) { 28358: MAKE_REAL_ZVAL_PTR(property); 28359: } 28360: 28361: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 28362: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28363: if (zptr != NULL) { /* NULL means no success in getting PTR */ 28364: SEPARATE_ZVAL_IF_NOT_REF(zptr); 28365: 28366: have_get_ptr = 1; 28367: incdec_op(*zptr); 28368: if (RETURN_VALUE_USED(opline)) { 28369: *retval = *zptr; 28370: PZVAL_LOCK(*retval); 28371: } 28372: } 28373: } 28374: 28375: if (!have_get_ptr) { 28376: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 28377: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28378: 28379: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 28380: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 28381: 28382: if (Z_REFCOUNT_P(z) == 0) { 28383: GC_REMOVE_ZVAL_FROM_BUFFER(z); 28384: zval_dtor(z); 28385: FREE_ZVAL(z); 28386: } 28387: z = value; 28388: } 28389: Z_ADDREF_P(z); 28390: SEPARATE_ZVAL_IF_NOT_REF(&z); 28391: incdec_op(z); 28392: *retval = z; 28393: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28394: SELECTIVE_PZVAL_LOCK(*retval, opline); 28395: zval_ptr_dtor(&z); 28396: } else { 28397: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 28398: if (RETURN_VALUE_USED(opline)) { 28399: PZVAL_LOCK(&EG(uninitialized_zval)); 28400: *retval = &EG(uninitialized_zval); 28401: } 28402: } 28403: } 28404: 28405: if (0) { 28406: zval_ptr_dtor(&property); 28407: } else { 28408: 28409: } 28410: 28411: CHECK_EXCEPTION(); 28412: ZEND_VM_NEXT_OPCODE(); 28413: } 28414: 28415: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28416: { 28417: return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28418: } 28419: 28420: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28421: { 28422: return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28423: } 28424: 28425: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 28426: { 28427: USE_OPLINE 28428: 28429: zval **object_ptr; 28430: zval *object; 28431: zval *property; 28432: zval *retval; 28433: int have_get_ptr = 0; 28434: 28435: SAVE_OPLINE(); 28436: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28437: property = opline->op2.zv; 28438: retval = &EX_T(opline->result.var).tmp_var; 28439: 28440: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 28441: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 28442: } 28443: 28444: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 28445: object = *object_ptr; 28446: 28447: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 28448: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 28449: 28450: ZVAL_NULL(retval); 28451: 28452: CHECK_EXCEPTION(); 28453: ZEND_VM_NEXT_OPCODE(); 28454: } 28455: 28456: /* here we are sure we are dealing with an object */ 28457: 28458: if (0) { 28459: MAKE_REAL_ZVAL_PTR(property); 28460: } 28461: 28462: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 28463: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28464: if (zptr != NULL) { /* NULL means no success in getting PTR */ 28465: have_get_ptr = 1; 28466: SEPARATE_ZVAL_IF_NOT_REF(zptr); 28467: 28468: ZVAL_COPY_VALUE(retval, *zptr); 28469: zendi_zval_copy_ctor(*retval); 28470: 28471: incdec_op(*zptr); 28472: 28473: } 28474: } 28475: 28476: if (!have_get_ptr) { 28477: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 28478: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28479: zval *z_copy; 28480: 28481: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 28482: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 28483: 28484: if (Z_REFCOUNT_P(z) == 0) { 28485: GC_REMOVE_ZVAL_FROM_BUFFER(z); 28486: zval_dtor(z); 28487: FREE_ZVAL(z); 28488: } 28489: z = value; 28490: } 28491: ZVAL_COPY_VALUE(retval, z); 28492: zendi_zval_copy_ctor(*retval); 28493: ALLOC_ZVAL(z_copy); 28494: INIT_PZVAL_COPY(z_copy, z); 28495: zendi_zval_copy_ctor(*z_copy); 28496: incdec_op(z_copy); 28497: Z_ADDREF_P(z); 28498: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28499: zval_ptr_dtor(&z_copy); 28500: zval_ptr_dtor(&z); 28501: } else { 28502: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 28503: ZVAL_NULL(retval); 28504: } 28505: } 28506: 28507: if (0) { 28508: zval_ptr_dtor(&property); 28509: } else { 28510: 28511: } 28512: 28513: CHECK_EXCEPTION(); 28514: ZEND_VM_NEXT_OPCODE(); 28515: } 28516: 28517: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28518: { 28519: return zend_post_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28520: } 28521: 28522: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28523: { 28524: return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28525: } 28526: 28527: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) 28528: { 28529: USE_OPLINE 28530: zend_free_op free_op1; 28531: zval *varname; 28532: zval **retval; 28533: zval tmp_varname; 28534: HashTable *target_symbol_table; 28535: ulong hash_value; 28536: 28537: SAVE_OPLINE(); 28538: varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 28539: 28540: if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 28541: ZVAL_COPY_VALUE(&tmp_varname, varname); 28542: zval_copy_ctor(&tmp_varname); 28543: Z_SET_REFCOUNT(tmp_varname, 1); 28544: Z_UNSET_ISREF(tmp_varname); 28545: convert_to_string(&tmp_varname); 28546: varname = &tmp_varname; 28547: } 28548: 28549: if (IS_CONST != IS_UNUSED) { 28550: zend_class_entry *ce; 28551: 28552: if (IS_CONST == IS_CONST) { 28553: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 28554: ce = CACHED_PTR(opline->op2.literal->cache_slot); 28555: } else { 28556: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 28557: if (UNEXPECTED(ce == NULL)) { 28558: if (IS_CV != IS_CONST && varname == &tmp_varname) { 28559: zval_dtor(&tmp_varname); 28560: } 28561: 28562: CHECK_EXCEPTION(); 28563: ZEND_VM_NEXT_OPCODE(); 28564: } 28565: CACHE_PTR(opline->op2.literal->cache_slot, ce); 28566: } 28567: } else { 28568: ce = EX_T(opline->op2.var).class_entry; 28569: } 28570: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 28571: 28572: } else { 28573: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 28574: /* 28575: if (!target_symbol_table) { 28576: CHECK_EXCEPTION(); 28577: ZEND_VM_NEXT_OPCODE(); 28578: } 28579: */ 28580: if (IS_CV == IS_CONST) { 28581: hash_value = Z_HASH_P(varname); 28582: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 28583: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 28584: } else { 28585: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 28586: } 28587: 28588: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 28589: switch (type) { 28590: case BP_VAR_R: 28591: case BP_VAR_UNSET: 28592: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 28593: /* break missing intentionally */ 28594: case BP_VAR_IS: 28595: retval = &EG(uninitialized_zval_ptr); 28596: break; 28597: case BP_VAR_RW: 28598: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 28599: /* break missing intentionally */ 28600: case BP_VAR_W: 28601: Z_ADDREF_P(&EG(uninitialized_zval)); 28602: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 28603: break; 28604: EMPTY_SWITCH_DEFAULT_CASE() 28605: } 28606: } 28607: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 28608: case ZEND_FETCH_GLOBAL: 28609: if (IS_CV != IS_TMP_VAR) { 28610: 28611: } 28612: break; 28613: case ZEND_FETCH_LOCAL: 28614: 28615: break; 28616: case ZEND_FETCH_STATIC: 28617: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 28618: break; 28619: case ZEND_FETCH_GLOBAL_LOCK: 28620: if (IS_CV == IS_VAR && !free_op1.var) { 28621: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 28622: } 28623: break; 28624: } 28625: } 28626: 28627: 28628: if (IS_CV != IS_CONST && varname == &tmp_varname) { 28629: zval_dtor(&tmp_varname); 28630: } 28631: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 28632: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 28633: } 28634: PZVAL_LOCK(*retval); 28635: switch (type) { 28636: case BP_VAR_R: 28637: case BP_VAR_IS: 28638: AI_SET_PTR(&EX_T(opline->result.var), *retval); 28639: break; 28640: case BP_VAR_UNSET: { 28641: zend_free_op free_res; 28642: 28643: PZVAL_UNLOCK(*retval, &free_res); 28644: if (retval != &EG(uninitialized_zval_ptr)) { 28645: SEPARATE_ZVAL_IF_NOT_REF(retval); 28646: } 28647: PZVAL_LOCK(*retval); 28648: FREE_OP_VAR_PTR(free_res); 28649: } 28650: /* break missing intentionally */ 28651: default: 28652: EX_T(opline->result.var).var.ptr_ptr = retval; 28653: break; 28654: } 28655: CHECK_EXCEPTION(); 28656: ZEND_VM_NEXT_OPCODE(); 28657: } 28658: 28659: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28660: { 28661: return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28662: } 28663: 28664: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28665: { 28666: return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28667: } 28668: 28669: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28670: { 28671: return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28672: } 28673: 28674: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28675: { 28676: USE_OPLINE 28677: 28678: return zend_fetch_var_address_helper_SPEC_CV_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28679: } 28680: 28681: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28682: { 28683: return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28684: } 28685: 28686: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28687: { 28688: return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28689: } 28690: 28691: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28692: { 28693: USE_OPLINE 28694: 28695: zval **container; 28696: 28697: SAVE_OPLINE(); 28698: 28699: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 28700: IS_CV != IS_CV && 28701: EX_T(opline->op1.var).var.ptr_ptr) { 28702: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 28703: } 28704: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 28705: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); 28706: 28707: 28708: CHECK_EXCEPTION(); 28709: ZEND_VM_NEXT_OPCODE(); 28710: } 28711: 28712: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28713: { 28714: USE_OPLINE 28715: zend_free_op free_op1; 28716: zval **container; 28717: 28718: SAVE_OPLINE(); 28719: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 28720: 28721: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28722: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 28723: } 28724: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); 28725: 28726: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 28727: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 28728: } 28729: 28730: /* We are going to assign the result by reference */ 28731: if (UNEXPECTED(opline->extended_value != 0)) { 28732: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 28733: 28734: if (retval_ptr) { 28735: Z_DELREF_PP(retval_ptr); 28736: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 28737: Z_ADDREF_PP(retval_ptr); 28738: } 28739: } 28740: 28741: CHECK_EXCEPTION(); 28742: ZEND_VM_NEXT_OPCODE(); 28743: } 28744: 28745: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28746: { 28747: USE_OPLINE 28748: zend_free_op free_op1; 28749: zval **container; 28750: 28751: SAVE_OPLINE(); 28752: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28753: 28754: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28755: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 28756: } 28757: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC); 28758: 28759: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 28760: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 28761: } 28762: 28763: CHECK_EXCEPTION(); 28764: ZEND_VM_NEXT_OPCODE(); 28765: } 28766: 28767: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28768: { 28769: USE_OPLINE 28770: 28771: zval **container; 28772: 28773: SAVE_OPLINE(); 28774: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 28775: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC); 28776: 28777: 28778: CHECK_EXCEPTION(); 28779: ZEND_VM_NEXT_OPCODE(); 28780: } 28781: 28782: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28783: { 28784: USE_OPLINE 28785: zend_free_op free_op1; 28786: zval **container; 28787: 28788: SAVE_OPLINE(); 28789: 28790: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 28791: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 28792: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28793: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 28794: } 28795: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); 28796: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 28797: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 28798: } 28799: } else { 28800: if (IS_CONST == IS_UNUSED) { 28801: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 28802: } 28803: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 28804: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); 28805: } 28806: 28807: 28808: CHECK_EXCEPTION(); 28809: ZEND_VM_NEXT_OPCODE(); 28810: } 28811: 28812: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28813: { 28814: USE_OPLINE 28815: zend_free_op free_op1; 28816: zval **container; 28817: 28818: SAVE_OPLINE(); 28819: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 28820: 28821: if (IS_CV == IS_CV) { 28822: if (container != &EG(uninitialized_zval_ptr)) { 28823: SEPARATE_ZVAL_IF_NOT_REF(container); 28824: } 28825: } 28826: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28827: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 28828: } 28829: zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC); 28830: 28831: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 28832: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 28833: } 28834: 28835: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 28836: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 28837: } else { 28838: zend_free_op free_res; 28839: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 28840: 28841: PZVAL_UNLOCK(*retval_ptr, &free_res); 28842: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 28843: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 28844: } 28845: PZVAL_LOCK(*retval_ptr); 28846: FREE_OP_VAR_PTR(free_res); 28847: CHECK_EXCEPTION(); 28848: ZEND_VM_NEXT_OPCODE(); 28849: } 28850: } 28851: 28852: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS) 28853: { 28854: USE_OPLINE 28855: 28856: zval *container; 28857: 28858: zval *offset; 28859: 28860: SAVE_OPLINE(); 28861: container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 28862: offset = opline->op2.zv; 28863: 28864: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 28865: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 28866: zend_error(E_NOTICE, "Trying to get property of non-object"); 28867: PZVAL_LOCK(&EG(uninitialized_zval)); 28868: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 28869: 28870: } else { 28871: zval *retval; 28872: 28873: if (0) { 28874: MAKE_REAL_ZVAL_PTR(offset); 28875: } 28876: 28877: /* here we are sure we are dealing with an object */ 28878: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 28879: 28880: PZVAL_LOCK(retval); 28881: AI_SET_PTR(&EX_T(opline->result.var), retval); 28882: 28883: if (0) { 28884: zval_ptr_dtor(&offset); 28885: } else { 28886: 28887: } 28888: } 28889: 28890: CHECK_EXCEPTION(); 28891: ZEND_VM_NEXT_OPCODE(); 28892: } 28893: 28894: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28895: { 28896: return zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 28897: } 28898: 28899: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28900: { 28901: USE_OPLINE 28902: zend_free_op free_op1; 28903: zval *property; 28904: zval **container; 28905: 28906: SAVE_OPLINE(); 28907: property = opline->op2.zv; 28908: 28909: if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 28910: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 28911: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 28912: } 28913: 28914: if (0) { 28915: MAKE_REAL_ZVAL_PTR(property); 28916: } 28917: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 28918: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28919: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 28920: } 28921: 28922: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 28923: if (0) { 28924: zval_ptr_dtor(&property); 28925: } else { 28926: 28927: } 28928: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 28929: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 28930: } 28931: 28932: /* We are going to assign the result by reference */ 28933: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 28934: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 28935: 28936: Z_DELREF_PP(retval_ptr); 28937: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 28938: Z_ADDREF_PP(retval_ptr); 28939: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 28940: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 28941: } 28942: 28943: CHECK_EXCEPTION(); 28944: ZEND_VM_NEXT_OPCODE(); 28945: } 28946: 28947: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28948: { 28949: USE_OPLINE 28950: zend_free_op free_op1; 28951: zval *property; 28952: zval **container; 28953: 28954: SAVE_OPLINE(); 28955: property = opline->op2.zv; 28956: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 28957: 28958: if (0) { 28959: MAKE_REAL_ZVAL_PTR(property); 28960: } 28961: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 28962: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 28963: } 28964: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 28965: if (0) { 28966: zval_ptr_dtor(&property); 28967: } else { 28968: 28969: } 28970: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 28971: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 28972: } 28973: 28974: CHECK_EXCEPTION(); 28975: ZEND_VM_NEXT_OPCODE(); 28976: } 28977: 28978: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 28979: { 28980: USE_OPLINE 28981: 28982: zval *container; 28983: 28984: zval *offset; 28985: 28986: SAVE_OPLINE(); 28987: container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 28988: offset = opline->op2.zv; 28989: 28990: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 28991: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 28992: PZVAL_LOCK(&EG(uninitialized_zval)); 28993: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 28994: 28995: } else { 28996: zval *retval; 28997: 28998: if (0) { 28999: MAKE_REAL_ZVAL_PTR(offset); 29000: } 29001: 29002: /* here we are sure we are dealing with an object */ 29003: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 29004: 29005: PZVAL_LOCK(retval); 29006: AI_SET_PTR(&EX_T(opline->result.var), retval); 29007: 29008: if (0) { 29009: zval_ptr_dtor(&offset); 29010: } else { 29011: 29012: } 29013: } 29014: 29015: CHECK_EXCEPTION(); 29016: ZEND_VM_NEXT_OPCODE(); 29017: } 29018: 29019: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29020: { 29021: USE_OPLINE 29022: 29023: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 29024: /* Behave like FETCH_OBJ_W */ 29025: zend_free_op free_op1; 29026: zval *property; 29027: zval **container; 29028: 29029: SAVE_OPLINE(); 29030: property = opline->op2.zv; 29031: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 29032: 29033: if (0) { 29034: MAKE_REAL_ZVAL_PTR(property); 29035: } 29036: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 29037: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 29038: } 29039: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 29040: if (0) { 29041: zval_ptr_dtor(&property); 29042: } else { 29043: 29044: } 29045: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 29046: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 29047: } 29048: 29049: CHECK_EXCEPTION(); 29050: ZEND_VM_NEXT_OPCODE(); 29051: } else { 29052: return zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 29053: } 29054: } 29055: 29056: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29057: { 29058: USE_OPLINE 29059: zend_free_op free_op1, free_res; 29060: zval **container; 29061: zval *property; 29062: 29063: SAVE_OPLINE(); 29064: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 29065: property = opline->op2.zv; 29066: 29067: if (IS_CV == IS_CV) { 29068: if (container != &EG(uninitialized_zval_ptr)) { 29069: SEPARATE_ZVAL_IF_NOT_REF(container); 29070: } 29071: } 29072: if (0) { 29073: MAKE_REAL_ZVAL_PTR(property); 29074: } 29075: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 29076: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 29077: } 29078: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 29079: if (0) { 29080: zval_ptr_dtor(&property); 29081: } else { 29082: 29083: } 29084: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 29085: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 29086: } 29087: 29088: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 29089: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 29090: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 29091: } 29092: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 29093: FREE_OP_VAR_PTR(free_res); 29094: CHECK_EXCEPTION(); 29095: ZEND_VM_NEXT_OPCODE(); 29096: } 29097: 29098: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29099: { 29100: USE_OPLINE 29101: 29102: zval **object_ptr; 29103: zval *property_name; 29104: 29105: SAVE_OPLINE(); 29106: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 29107: property_name = opline->op2.zv; 29108: 29109: if (0) { 29110: MAKE_REAL_ZVAL_PTR(property_name); 29111: } 29112: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 29113: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 29114: } 29115: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 29116: if (0) { 29117: zval_ptr_dtor(&property_name); 29118: } else { 29119: 29120: } 29121: 29122: /* assign_obj has two opcodes! */ 29123: CHECK_EXCEPTION(); 29124: ZEND_VM_INC_OPCODE(); 29125: ZEND_VM_NEXT_OPCODE(); 29126: } 29127: 29128: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29129: { 29130: USE_OPLINE 29131: 29132: zval **object_ptr; 29133: 29134: SAVE_OPLINE(); 29135: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 29136: 29137: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 29138: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 29139: } 29140: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 29141: 29142: zval *property_name = opline->op2.zv; 29143: 29144: if (0) { 29145: MAKE_REAL_ZVAL_PTR(property_name); 29146: } 29147: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 29148: if (0) { 29149: zval_ptr_dtor(&property_name); 29150: } else { 29151: 29152: } 29153: } else { 29154: zend_free_op free_op_data1, free_op_data2; 29155: zval *value; 29156: zval *dim = opline->op2.zv; 29157: zval **variable_ptr_ptr; 29158: 29159: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC); 29160: 29161: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 29162: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 29163: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 29164: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 29165: if (RETURN_VALUE_USED(opline)) { 29166: zval *retval; 29167: 29168: ALLOC_ZVAL(retval); 29169: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 29170: INIT_PZVAL(retval); 29171: AI_SET_PTR(&EX_T(opline->result.var), retval); 29172: } 29173: } else if (RETURN_VALUE_USED(opline)) { 29174: PZVAL_LOCK(&EG(uninitialized_zval)); 29175: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 29176: } 29177: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 29178: if (IS_TMP_FREE(free_op_data1)) { 29179: zval_dtor(value); 29180: } 29181: if (RETURN_VALUE_USED(opline)) { 29182: PZVAL_LOCK(&EG(uninitialized_zval)); 29183: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 29184: } 29185: } else { 29186: if ((opline+1)->op1_type == IS_TMP_VAR) { 29187: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 29188: } else if ((opline+1)->op1_type == IS_CONST) { 29189: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 29190: } else { 29191: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 29192: } 29193: if (RETURN_VALUE_USED(opline)) { 29194: PZVAL_LOCK(value); 29195: AI_SET_PTR(&EX_T(opline->result.var), value); 29196: } 29197: } 29198: FREE_OP_VAR_PTR(free_op_data2); 29199: FREE_OP_IF_VAR(free_op_data1); 29200: } 29201: 29202: /* assign_dim has two opcodes! */ 29203: CHECK_EXCEPTION(); 29204: ZEND_VM_INC_OPCODE(); 29205: ZEND_VM_NEXT_OPCODE(); 29206: } 29207: 29208: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29209: { 29210: USE_OPLINE 29211: 29212: zval *value; 29213: zval **variable_ptr_ptr; 29214: 29215: SAVE_OPLINE(); 29216: value = opline->op2.zv; 29217: variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 29218: 29219: if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 29220: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) { 29221: if (RETURN_VALUE_USED(opline)) { 29222: zval *retval; 29223: 29224: ALLOC_ZVAL(retval); 29225: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 29226: INIT_PZVAL(retval); 29227: AI_SET_PTR(&EX_T(opline->result.var), retval); 29228: } 29229: } else if (RETURN_VALUE_USED(opline)) { 29230: PZVAL_LOCK(&EG(uninitialized_zval)); 29231: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 29232: } 29233: } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 29234: if (0) { 29235: zval_dtor(value); 29236: } 29237: if (RETURN_VALUE_USED(opline)) { 29238: PZVAL_LOCK(&EG(uninitialized_zval)); 29239: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 29240: } 29241: } else { 29242: if (IS_CONST == IS_TMP_VAR) { 29243: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 29244: } else if (IS_CONST == IS_CONST) { 29245: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 29246: } else { 29247: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 29248: } 29249: if (RETURN_VALUE_USED(opline)) { 29250: PZVAL_LOCK(value); 29251: AI_SET_PTR(&EX_T(opline->result.var), value); 29252: } 29253: } 29254: 29255: /* zend_assign_to_variable() always takes care of op2, never free it! */ 29256: 29257: CHECK_EXCEPTION(); 29258: ZEND_VM_NEXT_OPCODE(); 29259: } 29260: 29261: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29262: { 29263: USE_OPLINE 29264: zval *function_name; 29265: char *function_name_strval; 29266: int function_name_strlen; 29267: 29268: 29269: SAVE_OPLINE(); 29270: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 29271: 29272: function_name = opline->op2.zv; 29273: 29274: if (IS_CONST != IS_CONST && 29275: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 29276: zend_error_noreturn(E_ERROR, "Method name must be a string"); 29277: } 29278: 29279: function_name_strval = Z_STRVAL_P(function_name); 29280: function_name_strlen = Z_STRLEN_P(function_name); 29281: 29282: EX(object) = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 29283: 29284: if (EXPECTED(EX(object) != NULL) && 29285: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 29286: EX(called_scope) = Z_OBJCE_P(EX(object)); 29287: 29288: if (IS_CONST != IS_CONST || 29289: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 29290: zval *object = EX(object); 29291: 29292: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 29293: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 29294: } 29295: 29296: /* First, locate the function. */ 29297: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 29298: if (UNEXPECTED(EX(fbc) == NULL)) { 29299: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 29300: } 29301: if (IS_CONST == IS_CONST && 29302: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 29303: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 29304: EXPECTED(EX(object) == object)) { 29305: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 29306: } 29307: } 29308: } else { 29309: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 29310: } 29311: 29312: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 29313: EX(object) = NULL; 29314: } else { 29315: if (!PZVAL_IS_REF(EX(object))) { 29316: Z_ADDREF_P(EX(object)); /* For $this pointer */ 29317: } else { 29318: zval *this_ptr; 29319: ALLOC_ZVAL(this_ptr); 29320: INIT_PZVAL_COPY(this_ptr, EX(object)); 29321: zval_copy_ctor(this_ptr); 29322: EX(object) = this_ptr; 29323: } 29324: } 29325: 29326: 29327: CHECK_EXCEPTION(); 29328: ZEND_VM_NEXT_OPCODE(); 29329: } 29330: 29331: static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29332: { 29333: USE_OPLINE 29334: 29335: 29336: SAVE_OPLINE(); 29337: if (IS_CV==IS_VAR) { 29338: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 29339: } 29340: is_equal_function(&EX_T(opline->result.var).tmp_var, 29341: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29342: opline->op2.zv TSRMLS_CC); 29343: 29344: CHECK_EXCEPTION(); 29345: ZEND_VM_NEXT_OPCODE(); 29346: } 29347: 29348: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29349: { 29350: USE_OPLINE 29351: 29352: zval *expr_ptr; 29353: 29354: SAVE_OPLINE(); 29355: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 29356: zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 29357: 29358: if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 29359: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 29360: } 29361: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 29362: expr_ptr = *expr_ptr_ptr; 29363: Z_ADDREF_P(expr_ptr); 29364: } else { 29365: expr_ptr=_get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 29366: if (0) { /* temporary variable */ 29367: zval *new_expr; 29368: 29369: ALLOC_ZVAL(new_expr); 29370: INIT_PZVAL_COPY(new_expr, expr_ptr); 29371: expr_ptr = new_expr; 29372: } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 29373: zval *new_expr; 29374: 29375: ALLOC_ZVAL(new_expr); 29376: INIT_PZVAL_COPY(new_expr, expr_ptr); 29377: expr_ptr = new_expr; 29378: zendi_zval_copy_ctor(*expr_ptr); 29379: } else { 29380: Z_ADDREF_P(expr_ptr); 29381: } 29382: } 29383: 29384: if (IS_CONST != IS_UNUSED) { 29385: 29386: zval *offset = opline->op2.zv; 29387: ulong hval; 29388: 29389: switch (Z_TYPE_P(offset)) { 29390: case IS_DOUBLE: 29391: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 29392: goto num_index; 29393: case IS_LONG: 29394: case IS_BOOL: 29395: hval = Z_LVAL_P(offset); 29396: num_index: 29397: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 29398: break; 29399: case IS_STRING: 29400: if (IS_CONST == IS_CONST) { 29401: hval = Z_HASH_P(offset); 29402: } else { 29403: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 29404: if (IS_INTERNED(Z_STRVAL_P(offset))) { 29405: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 29406: } else { 29407: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 29408: } 29409: } 29410: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 29411: break; 29412: case IS_NULL: 29413: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 29414: break; 29415: default: 29416: zend_error(E_WARNING, "Illegal offset type"); 29417: zval_ptr_dtor(&expr_ptr); 29418: /* do nothing */ 29419: break; 29420: } 29421: 29422: } else { 29423: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 29424: } 29425: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 29426: 29427: } else { 29428: 29429: } 29430: CHECK_EXCEPTION(); 29431: ZEND_VM_NEXT_OPCODE(); 29432: } 29433: 29434: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29435: { 29436: USE_OPLINE 29437: 29438: array_init(&EX_T(opline->result.var).tmp_var); 29439: if (IS_CV == IS_UNUSED) { 29440: ZEND_VM_NEXT_OPCODE(); 29441: #if 0 || IS_CV != IS_UNUSED 29442: } else { 29443: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 29444: #endif 29445: } 29446: } 29447: 29448: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29449: { 29450: USE_OPLINE 29451: zval tmp, *varname; 29452: HashTable *target_symbol_table; 29453: 29454: 29455: SAVE_OPLINE(); 29456: if (IS_CV == IS_CV && 29457: IS_CONST == IS_UNUSED && 29458: (opline->extended_value & ZEND_QUICK_SET)) { 29459: if (EG(active_symbol_table)) { 29460: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 29461: 29462: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 29463: EX_CV(opline->op1.var) = NULL; 29464: } else if (EX_CV(opline->op1.var)) { 29465: zval_ptr_dtor(EX_CV(opline->op1.var)); 29466: EX_CV(opline->op1.var) = NULL; 29467: } 29468: CHECK_EXCEPTION(); 29469: ZEND_VM_NEXT_OPCODE(); 29470: } 29471: 29472: varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 29473: 29474: if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 29475: ZVAL_COPY_VALUE(&tmp, varname); 29476: zval_copy_ctor(&tmp); 29477: convert_to_string(&tmp); 29478: varname = &tmp; 29479: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 29480: Z_ADDREF_P(varname); 29481: } 29482: 29483: if (IS_CONST != IS_UNUSED) { 29484: zend_class_entry *ce; 29485: 29486: if (IS_CONST == IS_CONST) { 29487: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 29488: ce = CACHED_PTR(opline->op2.literal->cache_slot); 29489: } else { 29490: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 29491: if (UNEXPECTED(EG(exception) != NULL)) { 29492: if (IS_CV != IS_CONST && varname == &tmp) { 29493: zval_dtor(&tmp); 29494: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 29495: zval_ptr_dtor(&varname); 29496: } 29497: 29498: HANDLE_EXCEPTION(); 29499: } 29500: if (UNEXPECTED(ce == NULL)) { 29501: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 29502: } 29503: CACHE_PTR(opline->op2.literal->cache_slot, ce); 29504: } 29505: } else { 29506: ce = EX_T(opline->op2.var).class_entry; 29507: } 29508: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 29509: } else { 29510: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 29511: 29512: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 29513: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 29514: } 29515: 29516: if (IS_CV != IS_CONST && varname == &tmp) { 29517: zval_dtor(&tmp); 29518: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 29519: zval_ptr_dtor(&varname); 29520: } 29521: 29522: CHECK_EXCEPTION(); 29523: ZEND_VM_NEXT_OPCODE(); 29524: } 29525: 29526: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29527: { 29528: USE_OPLINE 29529: 29530: zval **container; 29531: zval *offset; 29532: ulong hval; 29533: 29534: SAVE_OPLINE(); 29535: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 29536: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 29537: SEPARATE_ZVAL_IF_NOT_REF(container); 29538: } 29539: offset = opline->op2.zv; 29540: 29541: if (IS_CV != IS_VAR || container) { 29542: switch (Z_TYPE_PP(container)) { 29543: case IS_ARRAY: { 29544: HashTable *ht = Z_ARRVAL_PP(container); 29545: 29546: switch (Z_TYPE_P(offset)) { 29547: case IS_DOUBLE: 29548: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 29549: zend_hash_index_del(ht, hval); 29550: break; 29551: case IS_RESOURCE: 29552: case IS_BOOL: 29553: case IS_LONG: 29554: hval = Z_LVAL_P(offset); 29555: zend_hash_index_del(ht, hval); 29556: break; 29557: case IS_STRING: 29558: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 29559: Z_ADDREF_P(offset); 29560: } 29561: if (IS_CONST == IS_CONST) { 29562: hval = Z_HASH_P(offset); 29563: } else { 29564: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 29565: if (IS_INTERNED(Z_STRVAL_P(offset))) { 29566: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 29567: } else { 29568: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 29569: } 29570: } 29571: if (ht == &EG(symbol_table)) { 29572: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 29573: } else { 29574: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 29575: } 29576: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 29577: zval_ptr_dtor(&offset); 29578: } 29579: break; 29580: num_index_dim: 29581: zend_hash_index_del(ht, hval); 29582: if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { 29583: zval_ptr_dtor(&offset); 29584: } 29585: break; 29586: case IS_NULL: 29587: zend_hash_del(ht, "", sizeof("")); 29588: break; 29589: default: 29590: zend_error(E_WARNING, "Illegal offset type in unset"); 29591: break; 29592: } 29593: 29594: break; 29595: } 29596: case IS_OBJECT: 29597: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 29598: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 29599: } 29600: if (0) { 29601: MAKE_REAL_ZVAL_PTR(offset); 29602: } 29603: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 29604: if (0) { 29605: zval_ptr_dtor(&offset); 29606: } else { 29607: 29608: } 29609: break; 29610: case IS_STRING: 29611: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 29612: ZEND_VM_CONTINUE(); /* bailed out before */ 29613: default: 29614: 29615: break; 29616: } 29617: } else { 29618: 29619: } 29620: 29621: CHECK_EXCEPTION(); 29622: ZEND_VM_NEXT_OPCODE(); 29623: } 29624: 29625: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29626: { 29627: USE_OPLINE 29628: 29629: zval **container; 29630: zval *offset; 29631: 29632: SAVE_OPLINE(); 29633: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 29634: offset = opline->op2.zv; 29635: 29636: if (IS_CV != IS_VAR || container) { 29637: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 29638: SEPARATE_ZVAL_IF_NOT_REF(container); 29639: } 29640: if (Z_TYPE_PP(container) == IS_OBJECT) { 29641: if (0) { 29642: MAKE_REAL_ZVAL_PTR(offset); 29643: } 29644: if (Z_OBJ_HT_P(*container)->unset_property) { 29645: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 29646: } else { 29647: zend_error(E_NOTICE, "Trying to unset property of non-object"); 29648: } 29649: if (0) { 29650: zval_ptr_dtor(&offset); 29651: } else { 29652: 29653: } 29654: } else { 29655: 29656: } 29657: } else { 29658: 29659: } 29660: 29661: CHECK_EXCEPTION(); 29662: ZEND_VM_NEXT_OPCODE(); 29663: } 29664: 29665: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29666: { 29667: USE_OPLINE 29668: zval **value; 29669: zend_bool isset = 1; 29670: 29671: SAVE_OPLINE(); 29672: if (IS_CV == IS_CV && 29673: IS_CONST == IS_UNUSED && 29674: (opline->extended_value & ZEND_QUICK_SET)) { 29675: if (EX_CV(opline->op1.var)) { 29676: value = EX_CV(opline->op1.var); 29677: } else if (EG(active_symbol_table)) { 29678: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 29679: 29680: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 29681: isset = 0; 29682: } 29683: } else { 29684: isset = 0; 29685: } 29686: } else { 29687: HashTable *target_symbol_table; 29688: 29689: zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 29690: 29691: if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 29692: ZVAL_COPY_VALUE(&tmp, varname); 29693: zval_copy_ctor(&tmp); 29694: convert_to_string(&tmp); 29695: varname = &tmp; 29696: } 29697: 29698: if (IS_CONST != IS_UNUSED) { 29699: zend_class_entry *ce; 29700: 29701: if (IS_CONST == IS_CONST) { 29702: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 29703: ce = CACHED_PTR(opline->op2.literal->cache_slot); 29704: } else { 29705: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 29706: if (UNEXPECTED(ce == NULL)) { 29707: CHECK_EXCEPTION(); 29708: ZEND_VM_NEXT_OPCODE(); 29709: } 29710: CACHE_PTR(opline->op2.literal->cache_slot, ce); 29711: } 29712: } else { 29713: ce = EX_T(opline->op2.var).class_entry; 29714: } 29715: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 29716: if (!value) { 29717: isset = 0; 29718: } 29719: } else { 29720: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 29721: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 29722: isset = 0; 29723: } 29724: } 29725: 29726: if (IS_CV != IS_CONST && varname == &tmp) { 29727: zval_dtor(&tmp); 29728: } 29729: 29730: } 29731: 29732: if (opline->extended_value & ZEND_ISSET) { 29733: if (isset && Z_TYPE_PP(value) != IS_NULL) { 29734: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 29735: } else { 29736: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 29737: } 29738: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 29739: if (!isset || !i_zend_is_true(*value)) { 29740: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 29741: } else { 29742: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 29743: } 29744: } 29745: 29746: CHECK_EXCEPTION(); 29747: ZEND_VM_NEXT_OPCODE(); 29748: } 29749: 29750: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 29751: { 29752: USE_OPLINE 29753: 29754: zval **container; 29755: zval **value = NULL; 29756: int result = 0; 29757: ulong hval; 29758: zval *offset; 29759: 29760: SAVE_OPLINE(); 29761: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 29762: 29763: offset = opline->op2.zv; 29764: 29765: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 29766: HashTable *ht; 29767: int isset = 0; 29768: 29769: ht = Z_ARRVAL_PP(container); 29770: 29771: switch (Z_TYPE_P(offset)) { 29772: case IS_DOUBLE: 29773: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 29774: goto num_index_prop; 29775: case IS_RESOURCE: 29776: case IS_BOOL: 29777: case IS_LONG: 29778: hval = Z_LVAL_P(offset); 29779: num_index_prop: 29780: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 29781: isset = 1; 29782: } 29783: break; 29784: case IS_STRING: 29785: if (IS_CONST == IS_CONST) { 29786: hval = Z_HASH_P(offset); 29787: } else { 29788: if (!prop_dim) { 29789: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 29790: } 29791: if (IS_INTERNED(Z_STRVAL_P(offset))) { 29792: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 29793: } else { 29794: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 29795: } 29796: } 29797: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 29798: isset = 1; 29799: } 29800: break; 29801: case IS_NULL: 29802: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 29803: isset = 1; 29804: } 29805: break; 29806: default: 29807: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 29808: break; 29809: } 29810: 29811: if (opline->extended_value & ZEND_ISSET) { 29812: if (isset && Z_TYPE_PP(value) == IS_NULL) { 29813: result = 0; 29814: } else { 29815: result = isset; 29816: } 29817: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 29818: if (!isset || !i_zend_is_true(*value)) { 29819: result = 0; 29820: } else { 29821: result = 1; 29822: } 29823: } 29824: 29825: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 29826: if (0) { 29827: MAKE_REAL_ZVAL_PTR(offset); 29828: } 29829: if (prop_dim) { 29830: if (Z_OBJ_HT_P(*container)->has_property) { 29831: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 29832: } else { 29833: zend_error(E_NOTICE, "Trying to check property of non-object"); 29834: result = 0; 29835: } 29836: } else { 29837: if (Z_OBJ_HT_P(*container)->has_dimension) { 29838: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 29839: } else { 29840: zend_error(E_NOTICE, "Trying to check element of non-array"); 29841: result = 0; 29842: } 29843: } 29844: if (0) { 29845: zval_ptr_dtor(&offset); 29846: } else { 29847: 29848: } 29849: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 29850: zval tmp; 29851: 29852: if (Z_TYPE_P(offset) != IS_LONG) { 29853: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 29854: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 29855: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 29856: ZVAL_COPY_VALUE(&tmp, offset); 29857: zval_copy_ctor(&tmp); 29858: convert_to_long(&tmp); 29859: offset = &tmp; 29860: } else { 29861: /* can not be converted to proper offset, return "not set" */ 29862: result = 0; 29863: } 29864: } 29865: if (Z_TYPE_P(offset) == IS_LONG) { 29866: if (opline->extended_value & ZEND_ISSET) { 29867: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 29868: result = 1; 29869: } 29870: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 29871: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 29872: result = 1; 29873: } 29874: } 29875: } 29876: 29877: } else { 29878: 29879: } 29880: 29881: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 29882: if (opline->extended_value & ZEND_ISSET) { 29883: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 29884: } else { 29885: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 29886: } 29887: 29888: CHECK_EXCEPTION(); 29889: ZEND_VM_NEXT_OPCODE(); 29890: } 29891: 29892: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29893: { 29894: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 29895: } 29896: 29897: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29898: { 29899: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 29900: } 29901: 29902: static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29903: { 29904: USE_OPLINE 29905: zend_free_op free_op2; 29906: 29907: SAVE_OPLINE(); 29908: fast_add_function(&EX_T(opline->result.var).tmp_var, 29909: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29910: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 29911: 29912: zval_dtor(free_op2.var); 29913: CHECK_EXCEPTION(); 29914: ZEND_VM_NEXT_OPCODE(); 29915: } 29916: 29917: static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29918: { 29919: USE_OPLINE 29920: zend_free_op free_op2; 29921: 29922: SAVE_OPLINE(); 29923: fast_sub_function(&EX_T(opline->result.var).tmp_var, 29924: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29925: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 29926: 29927: zval_dtor(free_op2.var); 29928: CHECK_EXCEPTION(); 29929: ZEND_VM_NEXT_OPCODE(); 29930: } 29931: 29932: static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29933: { 29934: USE_OPLINE 29935: zend_free_op free_op2; 29936: 29937: SAVE_OPLINE(); 29938: fast_mul_function(&EX_T(opline->result.var).tmp_var, 29939: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29940: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 29941: 29942: zval_dtor(free_op2.var); 29943: CHECK_EXCEPTION(); 29944: ZEND_VM_NEXT_OPCODE(); 29945: } 29946: 29947: static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29948: { 29949: USE_OPLINE 29950: zend_free_op free_op2; 29951: 29952: SAVE_OPLINE(); 29953: fast_div_function(&EX_T(opline->result.var).tmp_var, 29954: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29955: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 29956: 29957: zval_dtor(free_op2.var); 29958: CHECK_EXCEPTION(); 29959: ZEND_VM_NEXT_OPCODE(); 29960: } 29961: 29962: static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29963: { 29964: USE_OPLINE 29965: zend_free_op free_op2; 29966: 29967: SAVE_OPLINE(); 29968: fast_mod_function(&EX_T(opline->result.var).tmp_var, 29969: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29970: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 29971: 29972: zval_dtor(free_op2.var); 29973: CHECK_EXCEPTION(); 29974: ZEND_VM_NEXT_OPCODE(); 29975: } 29976: 29977: static int ZEND_FASTCALL ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29978: { 29979: USE_OPLINE 29980: zend_free_op free_op2; 29981: 29982: SAVE_OPLINE(); 29983: shift_left_function(&EX_T(opline->result.var).tmp_var, 29984: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 29985: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 29986: 29987: zval_dtor(free_op2.var); 29988: CHECK_EXCEPTION(); 29989: ZEND_VM_NEXT_OPCODE(); 29990: } 29991: 29992: static int ZEND_FASTCALL ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 29993: { 29994: USE_OPLINE 29995: zend_free_op free_op2; 29996: 29997: SAVE_OPLINE(); 29998: shift_right_function(&EX_T(opline->result.var).tmp_var, 29999: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30000: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30001: 30002: zval_dtor(free_op2.var); 30003: CHECK_EXCEPTION(); 30004: ZEND_VM_NEXT_OPCODE(); 30005: } 30006: 30007: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30008: { 30009: USE_OPLINE 30010: zend_free_op free_op2; 30011: 30012: SAVE_OPLINE(); 30013: concat_function(&EX_T(opline->result.var).tmp_var, 30014: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30015: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30016: 30017: zval_dtor(free_op2.var); 30018: CHECK_EXCEPTION(); 30019: ZEND_VM_NEXT_OPCODE(); 30020: } 30021: 30022: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30023: { 30024: USE_OPLINE 30025: zend_free_op free_op2; 30026: 30027: SAVE_OPLINE(); 30028: is_identical_function(&EX_T(opline->result.var).tmp_var, 30029: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30030: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30031: 30032: zval_dtor(free_op2.var); 30033: CHECK_EXCEPTION(); 30034: ZEND_VM_NEXT_OPCODE(); 30035: } 30036: 30037: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30038: { 30039: USE_OPLINE 30040: zend_free_op free_op2; 30041: zval *result = &EX_T(opline->result.var).tmp_var; 30042: 30043: SAVE_OPLINE(); 30044: is_identical_function(result, 30045: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30046: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30047: Z_LVAL_P(result) = !Z_LVAL_P(result); 30048: 30049: zval_dtor(free_op2.var); 30050: CHECK_EXCEPTION(); 30051: ZEND_VM_NEXT_OPCODE(); 30052: } 30053: 30054: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30055: { 30056: USE_OPLINE 30057: zend_free_op free_op2; 30058: zval *result = &EX_T(opline->result.var).tmp_var; 30059: 30060: SAVE_OPLINE(); 30061: ZVAL_BOOL(result, fast_equal_function(result, 30062: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30063: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 30064: 30065: zval_dtor(free_op2.var); 30066: CHECK_EXCEPTION(); 30067: ZEND_VM_NEXT_OPCODE(); 30068: } 30069: 30070: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30071: { 30072: USE_OPLINE 30073: zend_free_op free_op2; 30074: zval *result = &EX_T(opline->result.var).tmp_var; 30075: 30076: SAVE_OPLINE(); 30077: ZVAL_BOOL(result, fast_not_equal_function(result, 30078: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30079: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 30080: 30081: zval_dtor(free_op2.var); 30082: CHECK_EXCEPTION(); 30083: ZEND_VM_NEXT_OPCODE(); 30084: } 30085: 30086: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30087: { 30088: USE_OPLINE 30089: zend_free_op free_op2; 30090: zval *result = &EX_T(opline->result.var).tmp_var; 30091: 30092: SAVE_OPLINE(); 30093: ZVAL_BOOL(result, fast_is_smaller_function(result, 30094: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30095: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 30096: 30097: zval_dtor(free_op2.var); 30098: CHECK_EXCEPTION(); 30099: ZEND_VM_NEXT_OPCODE(); 30100: } 30101: 30102: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30103: { 30104: USE_OPLINE 30105: zend_free_op free_op2; 30106: zval *result = &EX_T(opline->result.var).tmp_var; 30107: 30108: SAVE_OPLINE(); 30109: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 30110: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30111: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 30112: 30113: zval_dtor(free_op2.var); 30114: CHECK_EXCEPTION(); 30115: ZEND_VM_NEXT_OPCODE(); 30116: } 30117: 30118: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30119: { 30120: USE_OPLINE 30121: zend_free_op free_op2; 30122: 30123: SAVE_OPLINE(); 30124: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 30125: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30126: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30127: 30128: zval_dtor(free_op2.var); 30129: CHECK_EXCEPTION(); 30130: ZEND_VM_NEXT_OPCODE(); 30131: } 30132: 30133: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30134: { 30135: USE_OPLINE 30136: zend_free_op free_op2; 30137: 30138: SAVE_OPLINE(); 30139: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 30140: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30141: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30142: 30143: zval_dtor(free_op2.var); 30144: CHECK_EXCEPTION(); 30145: ZEND_VM_NEXT_OPCODE(); 30146: } 30147: 30148: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30149: { 30150: USE_OPLINE 30151: zend_free_op free_op2; 30152: 30153: SAVE_OPLINE(); 30154: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 30155: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30156: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30157: 30158: zval_dtor(free_op2.var); 30159: CHECK_EXCEPTION(); 30160: ZEND_VM_NEXT_OPCODE(); 30161: } 30162: 30163: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30164: { 30165: USE_OPLINE 30166: zend_free_op free_op2; 30167: 30168: SAVE_OPLINE(); 30169: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 30170: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 30171: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 30172: 30173: zval_dtor(free_op2.var); 30174: CHECK_EXCEPTION(); 30175: ZEND_VM_NEXT_OPCODE(); 30176: } 30177: 30178: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 30179: { 30180: USE_OPLINE 30181: zend_free_op free_op2, free_op_data1; 30182: zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30183: zval *object; 30184: zval *property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30185: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 30186: int have_get_ptr = 0; 30187: 30188: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 30189: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 30190: } 30191: 30192: make_real_object(object_ptr TSRMLS_CC); 30193: object = *object_ptr; 30194: 30195: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 30196: zend_error(E_WARNING, "Attempt to assign property of non-object"); 30197: zval_dtor(free_op2.var); 30198: FREE_OP(free_op_data1); 30199: 30200: if (RETURN_VALUE_USED(opline)) { 30201: PZVAL_LOCK(&EG(uninitialized_zval)); 30202: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 30203: EX_T(opline->result.var).var.ptr_ptr = NULL; 30204: } 30205: } else { 30206: /* here we are sure we are dealing with an object */ 30207: if (1) { 30208: MAKE_REAL_ZVAL_PTR(property); 30209: } 30210: 30211: /* here property is a string */ 30212: if (opline->extended_value == ZEND_ASSIGN_OBJ 30213: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 30214: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30215: if (zptr != NULL) { /* NULL means no success in getting PTR */ 30216: SEPARATE_ZVAL_IF_NOT_REF(zptr); 30217: 30218: have_get_ptr = 1; 30219: binary_op(*zptr, *zptr, value TSRMLS_CC); 30220: if (RETURN_VALUE_USED(opline)) { 30221: PZVAL_LOCK(*zptr); 30222: EX_T(opline->result.var).var.ptr = *zptr; 30223: EX_T(opline->result.var).var.ptr_ptr = NULL; 30224: } 30225: } 30226: } 30227: 30228: if (!have_get_ptr) { 30229: zval *z = NULL; 30230: 30231: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 30232: if (Z_OBJ_HT_P(object)->read_property) { 30233: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30234: } 30235: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 30236: if (Z_OBJ_HT_P(object)->read_dimension) { 30237: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 30238: } 30239: } 30240: if (z) { 30241: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 30242: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 30243: 30244: if (Z_REFCOUNT_P(z) == 0) { 30245: GC_REMOVE_ZVAL_FROM_BUFFER(z); 30246: zval_dtor(z); 30247: FREE_ZVAL(z); 30248: } 30249: z = value; 30250: } 30251: Z_ADDREF_P(z); 30252: SEPARATE_ZVAL_IF_NOT_REF(&z); 30253: binary_op(z, z, value TSRMLS_CC); 30254: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 30255: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30256: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 30257: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 30258: } 30259: if (RETURN_VALUE_USED(opline)) { 30260: PZVAL_LOCK(z); 30261: EX_T(opline->result.var).var.ptr = z; 30262: EX_T(opline->result.var).var.ptr_ptr = NULL; 30263: } 30264: zval_ptr_dtor(&z); 30265: } else { 30266: zend_error(E_WARNING, "Attempt to assign property of non-object"); 30267: if (RETURN_VALUE_USED(opline)) { 30268: PZVAL_LOCK(&EG(uninitialized_zval)); 30269: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 30270: EX_T(opline->result.var).var.ptr_ptr = NULL; 30271: } 30272: } 30273: } 30274: 30275: if (1) { 30276: zval_ptr_dtor(&property); 30277: } else { 30278: zval_dtor(free_op2.var); 30279: } 30280: FREE_OP(free_op_data1); 30281: } 30282: 30283: /* assign_obj has two opcodes! */ 30284: CHECK_EXCEPTION(); 30285: ZEND_VM_INC_OPCODE(); 30286: ZEND_VM_NEXT_OPCODE(); 30287: } 30288: 30289: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 30290: { 30291: USE_OPLINE 30292: zend_free_op free_op2, free_op_data2, free_op_data1; 30293: zval **var_ptr; 30294: zval *value; 30295: 30296: SAVE_OPLINE(); 30297: switch (opline->extended_value) { 30298: case ZEND_ASSIGN_OBJ: 30299: return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30300: break; 30301: case ZEND_ASSIGN_DIM: { 30302: zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30303: 30304: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30305: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 30306: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 30307: if (IS_CV == IS_VAR && !0) { 30308: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 30309: } 30310: return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30311: } else { 30312: zval *dim = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30313: 30314: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); 30315: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 30316: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 30317: } 30318: } 30319: break; 30320: default: 30321: value = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30322: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30323: /* do nothing */ 30324: break; 30325: } 30326: 30327: if (UNEXPECTED(var_ptr == NULL)) { 30328: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 30329: } 30330: 30331: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 30332: if (RETURN_VALUE_USED(opline)) { 30333: PZVAL_LOCK(&EG(uninitialized_zval)); 30334: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 30335: } 30336: zval_dtor(free_op2.var); 30337: 30338: CHECK_EXCEPTION(); 30339: if (opline->extended_value == ZEND_ASSIGN_DIM) { 30340: ZEND_VM_INC_OPCODE(); 30341: } 30342: ZEND_VM_NEXT_OPCODE(); 30343: } 30344: 30345: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 30346: 30347: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 30348: && Z_OBJ_HANDLER_PP(var_ptr, get) 30349: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 30350: /* proxy object */ 30351: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 30352: Z_ADDREF_P(objval); 30353: binary_op(objval, objval, value TSRMLS_CC); 30354: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 30355: zval_ptr_dtor(&objval); 30356: } else { 30357: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 30358: } 30359: 30360: if (RETURN_VALUE_USED(opline)) { 30361: PZVAL_LOCK(*var_ptr); 30362: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 30363: } 30364: zval_dtor(free_op2.var); 30365: 30366: if (opline->extended_value == ZEND_ASSIGN_DIM) { 30367: FREE_OP(free_op_data1); 30368: FREE_OP_VAR_PTR(free_op_data2); 30369: 30370: CHECK_EXCEPTION(); 30371: ZEND_VM_INC_OPCODE(); 30372: } else { 30373: 30374: CHECK_EXCEPTION(); 30375: } 30376: ZEND_VM_NEXT_OPCODE(); 30377: } 30378: 30379: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30380: { 30381: return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30382: } 30383: 30384: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30385: { 30386: return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30387: } 30388: 30389: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30390: { 30391: return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30392: } 30393: 30394: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30395: { 30396: return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30397: } 30398: 30399: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30400: { 30401: return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30402: } 30403: 30404: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30405: { 30406: return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30407: } 30408: 30409: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30410: { 30411: return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30412: } 30413: 30414: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30415: { 30416: return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30417: } 30418: 30419: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30420: { 30421: return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30422: } 30423: 30424: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30425: { 30426: return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30427: } 30428: 30429: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30430: { 30431: return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30432: } 30433: 30434: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 30435: { 30436: USE_OPLINE 30437: zend_free_op free_op2; 30438: zval **object_ptr; 30439: zval *object; 30440: zval *property; 30441: zval **retval; 30442: int have_get_ptr = 0; 30443: 30444: SAVE_OPLINE(); 30445: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30446: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30447: retval = &EX_T(opline->result.var).var.ptr; 30448: 30449: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 30450: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 30451: } 30452: 30453: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 30454: object = *object_ptr; 30455: 30456: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 30457: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 30458: zval_dtor(free_op2.var); 30459: if (RETURN_VALUE_USED(opline)) { 30460: PZVAL_LOCK(&EG(uninitialized_zval)); 30461: *retval = &EG(uninitialized_zval); 30462: } 30463: 30464: CHECK_EXCEPTION(); 30465: ZEND_VM_NEXT_OPCODE(); 30466: } 30467: 30468: /* here we are sure we are dealing with an object */ 30469: 30470: if (1) { 30471: MAKE_REAL_ZVAL_PTR(property); 30472: } 30473: 30474: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 30475: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30476: if (zptr != NULL) { /* NULL means no success in getting PTR */ 30477: SEPARATE_ZVAL_IF_NOT_REF(zptr); 30478: 30479: have_get_ptr = 1; 30480: incdec_op(*zptr); 30481: if (RETURN_VALUE_USED(opline)) { 30482: *retval = *zptr; 30483: PZVAL_LOCK(*retval); 30484: } 30485: } 30486: } 30487: 30488: if (!have_get_ptr) { 30489: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 30490: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30491: 30492: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 30493: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 30494: 30495: if (Z_REFCOUNT_P(z) == 0) { 30496: GC_REMOVE_ZVAL_FROM_BUFFER(z); 30497: zval_dtor(z); 30498: FREE_ZVAL(z); 30499: } 30500: z = value; 30501: } 30502: Z_ADDREF_P(z); 30503: SEPARATE_ZVAL_IF_NOT_REF(&z); 30504: incdec_op(z); 30505: *retval = z; 30506: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30507: SELECTIVE_PZVAL_LOCK(*retval, opline); 30508: zval_ptr_dtor(&z); 30509: } else { 30510: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 30511: if (RETURN_VALUE_USED(opline)) { 30512: PZVAL_LOCK(&EG(uninitialized_zval)); 30513: *retval = &EG(uninitialized_zval); 30514: } 30515: } 30516: } 30517: 30518: if (1) { 30519: zval_ptr_dtor(&property); 30520: } else { 30521: zval_dtor(free_op2.var); 30522: } 30523: 30524: CHECK_EXCEPTION(); 30525: ZEND_VM_NEXT_OPCODE(); 30526: } 30527: 30528: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30529: { 30530: return zend_pre_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30531: } 30532: 30533: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30534: { 30535: return zend_pre_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30536: } 30537: 30538: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 30539: { 30540: USE_OPLINE 30541: zend_free_op free_op2; 30542: zval **object_ptr; 30543: zval *object; 30544: zval *property; 30545: zval *retval; 30546: int have_get_ptr = 0; 30547: 30548: SAVE_OPLINE(); 30549: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30550: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30551: retval = &EX_T(opline->result.var).tmp_var; 30552: 30553: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 30554: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 30555: } 30556: 30557: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 30558: object = *object_ptr; 30559: 30560: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 30561: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 30562: zval_dtor(free_op2.var); 30563: ZVAL_NULL(retval); 30564: 30565: CHECK_EXCEPTION(); 30566: ZEND_VM_NEXT_OPCODE(); 30567: } 30568: 30569: /* here we are sure we are dealing with an object */ 30570: 30571: if (1) { 30572: MAKE_REAL_ZVAL_PTR(property); 30573: } 30574: 30575: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 30576: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30577: if (zptr != NULL) { /* NULL means no success in getting PTR */ 30578: have_get_ptr = 1; 30579: SEPARATE_ZVAL_IF_NOT_REF(zptr); 30580: 30581: ZVAL_COPY_VALUE(retval, *zptr); 30582: zendi_zval_copy_ctor(*retval); 30583: 30584: incdec_op(*zptr); 30585: 30586: } 30587: } 30588: 30589: if (!have_get_ptr) { 30590: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 30591: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30592: zval *z_copy; 30593: 30594: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 30595: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 30596: 30597: if (Z_REFCOUNT_P(z) == 0) { 30598: GC_REMOVE_ZVAL_FROM_BUFFER(z); 30599: zval_dtor(z); 30600: FREE_ZVAL(z); 30601: } 30602: z = value; 30603: } 30604: ZVAL_COPY_VALUE(retval, z); 30605: zendi_zval_copy_ctor(*retval); 30606: ALLOC_ZVAL(z_copy); 30607: INIT_PZVAL_COPY(z_copy, z); 30608: zendi_zval_copy_ctor(*z_copy); 30609: incdec_op(z_copy); 30610: Z_ADDREF_P(z); 30611: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30612: zval_ptr_dtor(&z_copy); 30613: zval_ptr_dtor(&z); 30614: } else { 30615: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 30616: ZVAL_NULL(retval); 30617: } 30618: } 30619: 30620: if (1) { 30621: zval_ptr_dtor(&property); 30622: } else { 30623: zval_dtor(free_op2.var); 30624: } 30625: 30626: CHECK_EXCEPTION(); 30627: ZEND_VM_NEXT_OPCODE(); 30628: } 30629: 30630: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30631: { 30632: return zend_post_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30633: } 30634: 30635: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30636: { 30637: return zend_post_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30638: } 30639: 30640: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30641: { 30642: USE_OPLINE 30643: zend_free_op free_op2; 30644: zval **container; 30645: 30646: SAVE_OPLINE(); 30647: 30648: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 30649: IS_CV != IS_CV && 30650: EX_T(opline->op1.var).var.ptr_ptr) { 30651: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 30652: } 30653: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 30654: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); 30655: zval_dtor(free_op2.var); 30656: 30657: CHECK_EXCEPTION(); 30658: ZEND_VM_NEXT_OPCODE(); 30659: } 30660: 30661: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30662: { 30663: USE_OPLINE 30664: zend_free_op free_op1, free_op2; 30665: zval **container; 30666: 30667: SAVE_OPLINE(); 30668: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 30669: 30670: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30671: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 30672: } 30673: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); 30674: zval_dtor(free_op2.var); 30675: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30676: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30677: } 30678: 30679: /* We are going to assign the result by reference */ 30680: if (UNEXPECTED(opline->extended_value != 0)) { 30681: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 30682: 30683: if (retval_ptr) { 30684: Z_DELREF_PP(retval_ptr); 30685: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 30686: Z_ADDREF_PP(retval_ptr); 30687: } 30688: } 30689: 30690: CHECK_EXCEPTION(); 30691: ZEND_VM_NEXT_OPCODE(); 30692: } 30693: 30694: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30695: { 30696: USE_OPLINE 30697: zend_free_op free_op1, free_op2; 30698: zval **container; 30699: 30700: SAVE_OPLINE(); 30701: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30702: 30703: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30704: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 30705: } 30706: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); 30707: zval_dtor(free_op2.var); 30708: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30709: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30710: } 30711: 30712: CHECK_EXCEPTION(); 30713: ZEND_VM_NEXT_OPCODE(); 30714: } 30715: 30716: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30717: { 30718: USE_OPLINE 30719: zend_free_op free_op2; 30720: zval **container; 30721: 30722: SAVE_OPLINE(); 30723: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 30724: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC); 30725: zval_dtor(free_op2.var); 30726: 30727: CHECK_EXCEPTION(); 30728: ZEND_VM_NEXT_OPCODE(); 30729: } 30730: 30731: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30732: { 30733: USE_OPLINE 30734: zend_free_op free_op1, free_op2; 30735: zval **container; 30736: 30737: SAVE_OPLINE(); 30738: 30739: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 30740: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 30741: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30742: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 30743: } 30744: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); 30745: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30746: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30747: } 30748: } else { 30749: if (IS_TMP_VAR == IS_UNUSED) { 30750: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 30751: } 30752: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 30753: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); 30754: } 30755: zval_dtor(free_op2.var); 30756: 30757: CHECK_EXCEPTION(); 30758: ZEND_VM_NEXT_OPCODE(); 30759: } 30760: 30761: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30762: { 30763: USE_OPLINE 30764: zend_free_op free_op1, free_op2; 30765: zval **container; 30766: 30767: SAVE_OPLINE(); 30768: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 30769: 30770: if (IS_CV == IS_CV) { 30771: if (container != &EG(uninitialized_zval_ptr)) { 30772: SEPARATE_ZVAL_IF_NOT_REF(container); 30773: } 30774: } 30775: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30776: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 30777: } 30778: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC); 30779: zval_dtor(free_op2.var); 30780: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30781: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30782: } 30783: 30784: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 30785: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 30786: } else { 30787: zend_free_op free_res; 30788: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 30789: 30790: PZVAL_UNLOCK(*retval_ptr, &free_res); 30791: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 30792: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 30793: } 30794: PZVAL_LOCK(*retval_ptr); 30795: FREE_OP_VAR_PTR(free_res); 30796: CHECK_EXCEPTION(); 30797: ZEND_VM_NEXT_OPCODE(); 30798: } 30799: } 30800: 30801: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS) 30802: { 30803: USE_OPLINE 30804: 30805: zval *container; 30806: zend_free_op free_op2; 30807: zval *offset; 30808: 30809: SAVE_OPLINE(); 30810: container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 30811: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30812: 30813: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 30814: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 30815: zend_error(E_NOTICE, "Trying to get property of non-object"); 30816: PZVAL_LOCK(&EG(uninitialized_zval)); 30817: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 30818: zval_dtor(free_op2.var); 30819: } else { 30820: zval *retval; 30821: 30822: if (1) { 30823: MAKE_REAL_ZVAL_PTR(offset); 30824: } 30825: 30826: /* here we are sure we are dealing with an object */ 30827: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30828: 30829: PZVAL_LOCK(retval); 30830: AI_SET_PTR(&EX_T(opline->result.var), retval); 30831: 30832: if (1) { 30833: zval_ptr_dtor(&offset); 30834: } else { 30835: zval_dtor(free_op2.var); 30836: } 30837: } 30838: 30839: CHECK_EXCEPTION(); 30840: ZEND_VM_NEXT_OPCODE(); 30841: } 30842: 30843: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30844: { 30845: return zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 30846: } 30847: 30848: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30849: { 30850: USE_OPLINE 30851: zend_free_op free_op1, free_op2; 30852: zval *property; 30853: zval **container; 30854: 30855: SAVE_OPLINE(); 30856: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30857: 30858: if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 30859: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 30860: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 30861: } 30862: 30863: if (1) { 30864: MAKE_REAL_ZVAL_PTR(property); 30865: } 30866: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 30867: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30868: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 30869: } 30870: 30871: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 30872: if (1) { 30873: zval_ptr_dtor(&property); 30874: } else { 30875: zval_dtor(free_op2.var); 30876: } 30877: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30878: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30879: } 30880: 30881: /* We are going to assign the result by reference */ 30882: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 30883: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 30884: 30885: Z_DELREF_PP(retval_ptr); 30886: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 30887: Z_ADDREF_PP(retval_ptr); 30888: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 30889: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 30890: } 30891: 30892: CHECK_EXCEPTION(); 30893: ZEND_VM_NEXT_OPCODE(); 30894: } 30895: 30896: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30897: { 30898: USE_OPLINE 30899: zend_free_op free_op1, free_op2; 30900: zval *property; 30901: zval **container; 30902: 30903: SAVE_OPLINE(); 30904: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30905: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 30906: 30907: if (1) { 30908: MAKE_REAL_ZVAL_PTR(property); 30909: } 30910: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30911: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 30912: } 30913: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 30914: if (1) { 30915: zval_ptr_dtor(&property); 30916: } else { 30917: zval_dtor(free_op2.var); 30918: } 30919: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30920: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30921: } 30922: 30923: CHECK_EXCEPTION(); 30924: ZEND_VM_NEXT_OPCODE(); 30925: } 30926: 30927: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30928: { 30929: USE_OPLINE 30930: 30931: zval *container; 30932: zend_free_op free_op2; 30933: zval *offset; 30934: 30935: SAVE_OPLINE(); 30936: container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 30937: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30938: 30939: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 30940: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 30941: PZVAL_LOCK(&EG(uninitialized_zval)); 30942: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 30943: zval_dtor(free_op2.var); 30944: } else { 30945: zval *retval; 30946: 30947: if (1) { 30948: MAKE_REAL_ZVAL_PTR(offset); 30949: } 30950: 30951: /* here we are sure we are dealing with an object */ 30952: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 30953: 30954: PZVAL_LOCK(retval); 30955: AI_SET_PTR(&EX_T(opline->result.var), retval); 30956: 30957: if (1) { 30958: zval_ptr_dtor(&offset); 30959: } else { 30960: zval_dtor(free_op2.var); 30961: } 30962: } 30963: 30964: CHECK_EXCEPTION(); 30965: ZEND_VM_NEXT_OPCODE(); 30966: } 30967: 30968: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 30969: { 30970: USE_OPLINE 30971: 30972: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 30973: /* Behave like FETCH_OBJ_W */ 30974: zend_free_op free_op1, free_op2; 30975: zval *property; 30976: zval **container; 30977: 30978: SAVE_OPLINE(); 30979: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 30980: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 30981: 30982: if (1) { 30983: MAKE_REAL_ZVAL_PTR(property); 30984: } 30985: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 30986: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 30987: } 30988: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 30989: if (1) { 30990: zval_ptr_dtor(&property); 30991: } else { 30992: zval_dtor(free_op2.var); 30993: } 30994: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 30995: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 30996: } 30997: 30998: CHECK_EXCEPTION(); 30999: ZEND_VM_NEXT_OPCODE(); 31000: } else { 31001: return zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 31002: } 31003: } 31004: 31005: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31006: { 31007: USE_OPLINE 31008: zend_free_op free_op1, free_op2, free_res; 31009: zval **container; 31010: zval *property; 31011: 31012: SAVE_OPLINE(); 31013: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 31014: property = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31015: 31016: if (IS_CV == IS_CV) { 31017: if (container != &EG(uninitialized_zval_ptr)) { 31018: SEPARATE_ZVAL_IF_NOT_REF(container); 31019: } 31020: } 31021: if (1) { 31022: MAKE_REAL_ZVAL_PTR(property); 31023: } 31024: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 31025: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 31026: } 31027: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 31028: if (1) { 31029: zval_ptr_dtor(&property); 31030: } else { 31031: zval_dtor(free_op2.var); 31032: } 31033: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 31034: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 31035: } 31036: 31037: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 31038: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 31039: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 31040: } 31041: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 31042: FREE_OP_VAR_PTR(free_res); 31043: CHECK_EXCEPTION(); 31044: ZEND_VM_NEXT_OPCODE(); 31045: } 31046: 31047: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31048: { 31049: USE_OPLINE 31050: zend_free_op free_op2; 31051: zval **object_ptr; 31052: zval *property_name; 31053: 31054: SAVE_OPLINE(); 31055: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 31056: property_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31057: 31058: if (1) { 31059: MAKE_REAL_ZVAL_PTR(property_name); 31060: } 31061: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 31062: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 31063: } 31064: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 31065: if (1) { 31066: zval_ptr_dtor(&property_name); 31067: } else { 31068: zval_dtor(free_op2.var); 31069: } 31070: 31071: /* assign_obj has two opcodes! */ 31072: CHECK_EXCEPTION(); 31073: ZEND_VM_INC_OPCODE(); 31074: ZEND_VM_NEXT_OPCODE(); 31075: } 31076: 31077: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31078: { 31079: USE_OPLINE 31080: 31081: zval **object_ptr; 31082: 31083: SAVE_OPLINE(); 31084: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 31085: 31086: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 31087: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 31088: } 31089: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 31090: zend_free_op free_op2; 31091: zval *property_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31092: 31093: if (1) { 31094: MAKE_REAL_ZVAL_PTR(property_name); 31095: } 31096: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 31097: if (1) { 31098: zval_ptr_dtor(&property_name); 31099: } else { 31100: zval_dtor(free_op2.var); 31101: } 31102: } else { 31103: zend_free_op free_op2, free_op_data1, free_op_data2; 31104: zval *value; 31105: zval *dim = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31106: zval **variable_ptr_ptr; 31107: 31108: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC); 31109: zval_dtor(free_op2.var); 31110: 31111: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 31112: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 31113: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 31114: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 31115: if (RETURN_VALUE_USED(opline)) { 31116: zval *retval; 31117: 31118: ALLOC_ZVAL(retval); 31119: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 31120: INIT_PZVAL(retval); 31121: AI_SET_PTR(&EX_T(opline->result.var), retval); 31122: } 31123: } else if (RETURN_VALUE_USED(opline)) { 31124: PZVAL_LOCK(&EG(uninitialized_zval)); 31125: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 31126: } 31127: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 31128: if (IS_TMP_FREE(free_op_data1)) { 31129: zval_dtor(value); 31130: } 31131: if (RETURN_VALUE_USED(opline)) { 31132: PZVAL_LOCK(&EG(uninitialized_zval)); 31133: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 31134: } 31135: } else { 31136: if ((opline+1)->op1_type == IS_TMP_VAR) { 31137: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 31138: } else if ((opline+1)->op1_type == IS_CONST) { 31139: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 31140: } else { 31141: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 31142: } 31143: if (RETURN_VALUE_USED(opline)) { 31144: PZVAL_LOCK(value); 31145: AI_SET_PTR(&EX_T(opline->result.var), value); 31146: } 31147: } 31148: FREE_OP_VAR_PTR(free_op_data2); 31149: FREE_OP_IF_VAR(free_op_data1); 31150: } 31151: 31152: /* assign_dim has two opcodes! */ 31153: CHECK_EXCEPTION(); 31154: ZEND_VM_INC_OPCODE(); 31155: ZEND_VM_NEXT_OPCODE(); 31156: } 31157: 31158: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31159: { 31160: USE_OPLINE 31161: zend_free_op free_op2; 31162: zval *value; 31163: zval **variable_ptr_ptr; 31164: 31165: SAVE_OPLINE(); 31166: value = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31167: variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 31168: 31169: if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 31170: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) { 31171: if (RETURN_VALUE_USED(opline)) { 31172: zval *retval; 31173: 31174: ALLOC_ZVAL(retval); 31175: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 31176: INIT_PZVAL(retval); 31177: AI_SET_PTR(&EX_T(opline->result.var), retval); 31178: } 31179: } else if (RETURN_VALUE_USED(opline)) { 31180: PZVAL_LOCK(&EG(uninitialized_zval)); 31181: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 31182: } 31183: } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 31184: if (1) { 31185: zval_dtor(value); 31186: } 31187: if (RETURN_VALUE_USED(opline)) { 31188: PZVAL_LOCK(&EG(uninitialized_zval)); 31189: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 31190: } 31191: } else { 31192: if (IS_TMP_VAR == IS_TMP_VAR) { 31193: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 31194: } else if (IS_TMP_VAR == IS_CONST) { 31195: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 31196: } else { 31197: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 31198: } 31199: if (RETURN_VALUE_USED(opline)) { 31200: PZVAL_LOCK(value); 31201: AI_SET_PTR(&EX_T(opline->result.var), value); 31202: } 31203: } 31204: 31205: /* zend_assign_to_variable() always takes care of op2, never free it! */ 31206: 31207: CHECK_EXCEPTION(); 31208: ZEND_VM_NEXT_OPCODE(); 31209: } 31210: 31211: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31212: { 31213: USE_OPLINE 31214: zval *function_name; 31215: char *function_name_strval; 31216: int function_name_strlen; 31217: zend_free_op free_op2; 31218: 31219: SAVE_OPLINE(); 31220: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 31221: 31222: function_name = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31223: 31224: if (IS_TMP_VAR != IS_CONST && 31225: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 31226: zend_error_noreturn(E_ERROR, "Method name must be a string"); 31227: } 31228: 31229: function_name_strval = Z_STRVAL_P(function_name); 31230: function_name_strlen = Z_STRLEN_P(function_name); 31231: 31232: EX(object) = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 31233: 31234: if (EXPECTED(EX(object) != NULL) && 31235: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 31236: EX(called_scope) = Z_OBJCE_P(EX(object)); 31237: 31238: if (IS_TMP_VAR != IS_CONST || 31239: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 31240: zval *object = EX(object); 31241: 31242: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 31243: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 31244: } 31245: 31246: /* First, locate the function. */ 31247: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 31248: if (UNEXPECTED(EX(fbc) == NULL)) { 31249: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 31250: } 31251: if (IS_TMP_VAR == IS_CONST && 31252: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 31253: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 31254: EXPECTED(EX(object) == object)) { 31255: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 31256: } 31257: } 31258: } else { 31259: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 31260: } 31261: 31262: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 31263: EX(object) = NULL; 31264: } else { 31265: if (!PZVAL_IS_REF(EX(object))) { 31266: Z_ADDREF_P(EX(object)); /* For $this pointer */ 31267: } else { 31268: zval *this_ptr; 31269: ALLOC_ZVAL(this_ptr); 31270: INIT_PZVAL_COPY(this_ptr, EX(object)); 31271: zval_copy_ctor(this_ptr); 31272: EX(object) = this_ptr; 31273: } 31274: } 31275: 31276: zval_dtor(free_op2.var); 31277: 31278: CHECK_EXCEPTION(); 31279: ZEND_VM_NEXT_OPCODE(); 31280: } 31281: 31282: static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31283: { 31284: USE_OPLINE 31285: zend_free_op free_op2; 31286: 31287: SAVE_OPLINE(); 31288: if (IS_CV==IS_VAR) { 31289: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 31290: } 31291: is_equal_function(&EX_T(opline->result.var).tmp_var, 31292: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31293: _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31294: 31295: zval_dtor(free_op2.var); 31296: CHECK_EXCEPTION(); 31297: ZEND_VM_NEXT_OPCODE(); 31298: } 31299: 31300: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31301: { 31302: USE_OPLINE 31303: 31304: zval *expr_ptr; 31305: 31306: SAVE_OPLINE(); 31307: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 31308: zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 31309: 31310: if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 31311: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 31312: } 31313: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 31314: expr_ptr = *expr_ptr_ptr; 31315: Z_ADDREF_P(expr_ptr); 31316: } else { 31317: expr_ptr=_get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 31318: if (0) { /* temporary variable */ 31319: zval *new_expr; 31320: 31321: ALLOC_ZVAL(new_expr); 31322: INIT_PZVAL_COPY(new_expr, expr_ptr); 31323: expr_ptr = new_expr; 31324: } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 31325: zval *new_expr; 31326: 31327: ALLOC_ZVAL(new_expr); 31328: INIT_PZVAL_COPY(new_expr, expr_ptr); 31329: expr_ptr = new_expr; 31330: zendi_zval_copy_ctor(*expr_ptr); 31331: } else { 31332: Z_ADDREF_P(expr_ptr); 31333: } 31334: } 31335: 31336: if (IS_TMP_VAR != IS_UNUSED) { 31337: zend_free_op free_op2; 31338: zval *offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31339: ulong hval; 31340: 31341: switch (Z_TYPE_P(offset)) { 31342: case IS_DOUBLE: 31343: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 31344: goto num_index; 31345: case IS_LONG: 31346: case IS_BOOL: 31347: hval = Z_LVAL_P(offset); 31348: num_index: 31349: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 31350: break; 31351: case IS_STRING: 31352: if (IS_TMP_VAR == IS_CONST) { 31353: hval = Z_HASH_P(offset); 31354: } else { 31355: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 31356: if (IS_INTERNED(Z_STRVAL_P(offset))) { 31357: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 31358: } else { 31359: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 31360: } 31361: } 31362: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 31363: break; 31364: case IS_NULL: 31365: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 31366: break; 31367: default: 31368: zend_error(E_WARNING, "Illegal offset type"); 31369: zval_ptr_dtor(&expr_ptr); 31370: /* do nothing */ 31371: break; 31372: } 31373: zval_dtor(free_op2.var); 31374: } else { 31375: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 31376: } 31377: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 31378: 31379: } else { 31380: 31381: } 31382: CHECK_EXCEPTION(); 31383: ZEND_VM_NEXT_OPCODE(); 31384: } 31385: 31386: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31387: { 31388: USE_OPLINE 31389: 31390: array_init(&EX_T(opline->result.var).tmp_var); 31391: if (IS_CV == IS_UNUSED) { 31392: ZEND_VM_NEXT_OPCODE(); 31393: #if 0 || IS_CV != IS_UNUSED 31394: } else { 31395: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 31396: #endif 31397: } 31398: } 31399: 31400: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31401: { 31402: USE_OPLINE 31403: zend_free_op free_op2; 31404: zval **container; 31405: zval *offset; 31406: ulong hval; 31407: 31408: SAVE_OPLINE(); 31409: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 31410: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 31411: SEPARATE_ZVAL_IF_NOT_REF(container); 31412: } 31413: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31414: 31415: if (IS_CV != IS_VAR || container) { 31416: switch (Z_TYPE_PP(container)) { 31417: case IS_ARRAY: { 31418: HashTable *ht = Z_ARRVAL_PP(container); 31419: 31420: switch (Z_TYPE_P(offset)) { 31421: case IS_DOUBLE: 31422: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 31423: zend_hash_index_del(ht, hval); 31424: break; 31425: case IS_RESOURCE: 31426: case IS_BOOL: 31427: case IS_LONG: 31428: hval = Z_LVAL_P(offset); 31429: zend_hash_index_del(ht, hval); 31430: break; 31431: case IS_STRING: 31432: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 31433: Z_ADDREF_P(offset); 31434: } 31435: if (IS_TMP_VAR == IS_CONST) { 31436: hval = Z_HASH_P(offset); 31437: } else { 31438: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 31439: if (IS_INTERNED(Z_STRVAL_P(offset))) { 31440: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 31441: } else { 31442: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 31443: } 31444: } 31445: if (ht == &EG(symbol_table)) { 31446: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 31447: } else { 31448: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 31449: } 31450: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 31451: zval_ptr_dtor(&offset); 31452: } 31453: break; 31454: num_index_dim: 31455: zend_hash_index_del(ht, hval); 31456: if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { 31457: zval_ptr_dtor(&offset); 31458: } 31459: break; 31460: case IS_NULL: 31461: zend_hash_del(ht, "", sizeof("")); 31462: break; 31463: default: 31464: zend_error(E_WARNING, "Illegal offset type in unset"); 31465: break; 31466: } 31467: zval_dtor(free_op2.var); 31468: break; 31469: } 31470: case IS_OBJECT: 31471: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 31472: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 31473: } 31474: if (1) { 31475: MAKE_REAL_ZVAL_PTR(offset); 31476: } 31477: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 31478: if (1) { 31479: zval_ptr_dtor(&offset); 31480: } else { 31481: zval_dtor(free_op2.var); 31482: } 31483: break; 31484: case IS_STRING: 31485: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 31486: ZEND_VM_CONTINUE(); /* bailed out before */ 31487: default: 31488: zval_dtor(free_op2.var); 31489: break; 31490: } 31491: } else { 31492: zval_dtor(free_op2.var); 31493: } 31494: 31495: CHECK_EXCEPTION(); 31496: ZEND_VM_NEXT_OPCODE(); 31497: } 31498: 31499: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31500: { 31501: USE_OPLINE 31502: zend_free_op free_op2; 31503: zval **container; 31504: zval *offset; 31505: 31506: SAVE_OPLINE(); 31507: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 31508: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31509: 31510: if (IS_CV != IS_VAR || container) { 31511: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 31512: SEPARATE_ZVAL_IF_NOT_REF(container); 31513: } 31514: if (Z_TYPE_PP(container) == IS_OBJECT) { 31515: if (1) { 31516: MAKE_REAL_ZVAL_PTR(offset); 31517: } 31518: if (Z_OBJ_HT_P(*container)->unset_property) { 31519: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 31520: } else { 31521: zend_error(E_NOTICE, "Trying to unset property of non-object"); 31522: } 31523: if (1) { 31524: zval_ptr_dtor(&offset); 31525: } else { 31526: zval_dtor(free_op2.var); 31527: } 31528: } else { 31529: zval_dtor(free_op2.var); 31530: } 31531: } else { 31532: zval_dtor(free_op2.var); 31533: } 31534: 31535: CHECK_EXCEPTION(); 31536: ZEND_VM_NEXT_OPCODE(); 31537: } 31538: 31539: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 31540: { 31541: USE_OPLINE 31542: zend_free_op free_op2; 31543: zval **container; 31544: zval **value = NULL; 31545: int result = 0; 31546: ulong hval; 31547: zval *offset; 31548: 31549: SAVE_OPLINE(); 31550: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 31551: 31552: offset = _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31553: 31554: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 31555: HashTable *ht; 31556: int isset = 0; 31557: 31558: ht = Z_ARRVAL_PP(container); 31559: 31560: switch (Z_TYPE_P(offset)) { 31561: case IS_DOUBLE: 31562: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 31563: goto num_index_prop; 31564: case IS_RESOURCE: 31565: case IS_BOOL: 31566: case IS_LONG: 31567: hval = Z_LVAL_P(offset); 31568: num_index_prop: 31569: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 31570: isset = 1; 31571: } 31572: break; 31573: case IS_STRING: 31574: if (IS_TMP_VAR == IS_CONST) { 31575: hval = Z_HASH_P(offset); 31576: } else { 31577: if (!prop_dim) { 31578: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 31579: } 31580: if (IS_INTERNED(Z_STRVAL_P(offset))) { 31581: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 31582: } else { 31583: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 31584: } 31585: } 31586: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 31587: isset = 1; 31588: } 31589: break; 31590: case IS_NULL: 31591: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 31592: isset = 1; 31593: } 31594: break; 31595: default: 31596: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 31597: break; 31598: } 31599: 31600: if (opline->extended_value & ZEND_ISSET) { 31601: if (isset && Z_TYPE_PP(value) == IS_NULL) { 31602: result = 0; 31603: } else { 31604: result = isset; 31605: } 31606: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 31607: if (!isset || !i_zend_is_true(*value)) { 31608: result = 0; 31609: } else { 31610: result = 1; 31611: } 31612: } 31613: zval_dtor(free_op2.var); 31614: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 31615: if (1) { 31616: MAKE_REAL_ZVAL_PTR(offset); 31617: } 31618: if (prop_dim) { 31619: if (Z_OBJ_HT_P(*container)->has_property) { 31620: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 31621: } else { 31622: zend_error(E_NOTICE, "Trying to check property of non-object"); 31623: result = 0; 31624: } 31625: } else { 31626: if (Z_OBJ_HT_P(*container)->has_dimension) { 31627: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 31628: } else { 31629: zend_error(E_NOTICE, "Trying to check element of non-array"); 31630: result = 0; 31631: } 31632: } 31633: if (1) { 31634: zval_ptr_dtor(&offset); 31635: } else { 31636: zval_dtor(free_op2.var); 31637: } 31638: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 31639: zval tmp; 31640: 31641: if (Z_TYPE_P(offset) != IS_LONG) { 31642: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 31643: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 31644: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 31645: ZVAL_COPY_VALUE(&tmp, offset); 31646: zval_copy_ctor(&tmp); 31647: convert_to_long(&tmp); 31648: offset = &tmp; 31649: } else { 31650: /* can not be converted to proper offset, return "not set" */ 31651: result = 0; 31652: } 31653: } 31654: if (Z_TYPE_P(offset) == IS_LONG) { 31655: if (opline->extended_value & ZEND_ISSET) { 31656: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 31657: result = 1; 31658: } 31659: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 31660: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 31661: result = 1; 31662: } 31663: } 31664: } 31665: zval_dtor(free_op2.var); 31666: } else { 31667: zval_dtor(free_op2.var); 31668: } 31669: 31670: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 31671: if (opline->extended_value & ZEND_ISSET) { 31672: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 31673: } else { 31674: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 31675: } 31676: 31677: CHECK_EXCEPTION(); 31678: ZEND_VM_NEXT_OPCODE(); 31679: } 31680: 31681: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31682: { 31683: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 31684: } 31685: 31686: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31687: { 31688: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 31689: } 31690: 31691: static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31692: { 31693: USE_OPLINE 31694: zend_free_op free_op2; 31695: 31696: SAVE_OPLINE(); 31697: fast_add_function(&EX_T(opline->result.var).tmp_var, 31698: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31699: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31700: 31701: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31702: CHECK_EXCEPTION(); 31703: ZEND_VM_NEXT_OPCODE(); 31704: } 31705: 31706: static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31707: { 31708: USE_OPLINE 31709: zend_free_op free_op2; 31710: 31711: SAVE_OPLINE(); 31712: fast_sub_function(&EX_T(opline->result.var).tmp_var, 31713: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31714: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31715: 31716: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31717: CHECK_EXCEPTION(); 31718: ZEND_VM_NEXT_OPCODE(); 31719: } 31720: 31721: static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31722: { 31723: USE_OPLINE 31724: zend_free_op free_op2; 31725: 31726: SAVE_OPLINE(); 31727: fast_mul_function(&EX_T(opline->result.var).tmp_var, 31728: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31729: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31730: 31731: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31732: CHECK_EXCEPTION(); 31733: ZEND_VM_NEXT_OPCODE(); 31734: } 31735: 31736: static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31737: { 31738: USE_OPLINE 31739: zend_free_op free_op2; 31740: 31741: SAVE_OPLINE(); 31742: fast_div_function(&EX_T(opline->result.var).tmp_var, 31743: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31744: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31745: 31746: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31747: CHECK_EXCEPTION(); 31748: ZEND_VM_NEXT_OPCODE(); 31749: } 31750: 31751: static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31752: { 31753: USE_OPLINE 31754: zend_free_op free_op2; 31755: 31756: SAVE_OPLINE(); 31757: fast_mod_function(&EX_T(opline->result.var).tmp_var, 31758: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31759: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31760: 31761: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31762: CHECK_EXCEPTION(); 31763: ZEND_VM_NEXT_OPCODE(); 31764: } 31765: 31766: static int ZEND_FASTCALL ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31767: { 31768: USE_OPLINE 31769: zend_free_op free_op2; 31770: 31771: SAVE_OPLINE(); 31772: shift_left_function(&EX_T(opline->result.var).tmp_var, 31773: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31774: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31775: 31776: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31777: CHECK_EXCEPTION(); 31778: ZEND_VM_NEXT_OPCODE(); 31779: } 31780: 31781: static int ZEND_FASTCALL ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31782: { 31783: USE_OPLINE 31784: zend_free_op free_op2; 31785: 31786: SAVE_OPLINE(); 31787: shift_right_function(&EX_T(opline->result.var).tmp_var, 31788: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31789: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31790: 31791: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31792: CHECK_EXCEPTION(); 31793: ZEND_VM_NEXT_OPCODE(); 31794: } 31795: 31796: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31797: { 31798: USE_OPLINE 31799: zend_free_op free_op2; 31800: 31801: SAVE_OPLINE(); 31802: concat_function(&EX_T(opline->result.var).tmp_var, 31803: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31804: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31805: 31806: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31807: CHECK_EXCEPTION(); 31808: ZEND_VM_NEXT_OPCODE(); 31809: } 31810: 31811: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31812: { 31813: USE_OPLINE 31814: zend_free_op free_op2; 31815: 31816: SAVE_OPLINE(); 31817: is_identical_function(&EX_T(opline->result.var).tmp_var, 31818: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31819: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31820: 31821: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31822: CHECK_EXCEPTION(); 31823: ZEND_VM_NEXT_OPCODE(); 31824: } 31825: 31826: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31827: { 31828: USE_OPLINE 31829: zend_free_op free_op2; 31830: zval *result = &EX_T(opline->result.var).tmp_var; 31831: 31832: SAVE_OPLINE(); 31833: is_identical_function(result, 31834: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31835: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31836: Z_LVAL_P(result) = !Z_LVAL_P(result); 31837: 31838: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31839: CHECK_EXCEPTION(); 31840: ZEND_VM_NEXT_OPCODE(); 31841: } 31842: 31843: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31844: { 31845: USE_OPLINE 31846: zend_free_op free_op2; 31847: zval *result = &EX_T(opline->result.var).tmp_var; 31848: 31849: SAVE_OPLINE(); 31850: ZVAL_BOOL(result, fast_equal_function(result, 31851: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31852: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 31853: 31854: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31855: CHECK_EXCEPTION(); 31856: ZEND_VM_NEXT_OPCODE(); 31857: } 31858: 31859: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31860: { 31861: USE_OPLINE 31862: zend_free_op free_op2; 31863: zval *result = &EX_T(opline->result.var).tmp_var; 31864: 31865: SAVE_OPLINE(); 31866: ZVAL_BOOL(result, fast_not_equal_function(result, 31867: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31868: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 31869: 31870: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31871: CHECK_EXCEPTION(); 31872: ZEND_VM_NEXT_OPCODE(); 31873: } 31874: 31875: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31876: { 31877: USE_OPLINE 31878: zend_free_op free_op2; 31879: zval *result = &EX_T(opline->result.var).tmp_var; 31880: 31881: SAVE_OPLINE(); 31882: ZVAL_BOOL(result, fast_is_smaller_function(result, 31883: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31884: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 31885: 31886: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31887: CHECK_EXCEPTION(); 31888: ZEND_VM_NEXT_OPCODE(); 31889: } 31890: 31891: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31892: { 31893: USE_OPLINE 31894: zend_free_op free_op2; 31895: zval *result = &EX_T(opline->result.var).tmp_var; 31896: 31897: SAVE_OPLINE(); 31898: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 31899: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31900: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC)); 31901: 31902: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31903: CHECK_EXCEPTION(); 31904: ZEND_VM_NEXT_OPCODE(); 31905: } 31906: 31907: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31908: { 31909: USE_OPLINE 31910: zend_free_op free_op2; 31911: 31912: SAVE_OPLINE(); 31913: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 31914: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31915: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31916: 31917: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31918: CHECK_EXCEPTION(); 31919: ZEND_VM_NEXT_OPCODE(); 31920: } 31921: 31922: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31923: { 31924: USE_OPLINE 31925: zend_free_op free_op2; 31926: 31927: SAVE_OPLINE(); 31928: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 31929: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31930: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31931: 31932: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31933: CHECK_EXCEPTION(); 31934: ZEND_VM_NEXT_OPCODE(); 31935: } 31936: 31937: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31938: { 31939: USE_OPLINE 31940: zend_free_op free_op2; 31941: 31942: SAVE_OPLINE(); 31943: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 31944: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31945: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31946: 31947: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31948: CHECK_EXCEPTION(); 31949: ZEND_VM_NEXT_OPCODE(); 31950: } 31951: 31952: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 31953: { 31954: USE_OPLINE 31955: zend_free_op free_op2; 31956: 31957: SAVE_OPLINE(); 31958: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 31959: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 31960: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 31961: 31962: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31963: CHECK_EXCEPTION(); 31964: ZEND_VM_NEXT_OPCODE(); 31965: } 31966: 31967: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 31968: { 31969: USE_OPLINE 31970: zend_free_op free_op2, free_op_data1; 31971: zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 31972: zval *object; 31973: zval *property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 31974: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 31975: int have_get_ptr = 0; 31976: 31977: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 31978: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 31979: } 31980: 31981: make_real_object(object_ptr TSRMLS_CC); 31982: object = *object_ptr; 31983: 31984: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 31985: zend_error(E_WARNING, "Attempt to assign property of non-object"); 31986: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 31987: FREE_OP(free_op_data1); 31988: 31989: if (RETURN_VALUE_USED(opline)) { 31990: PZVAL_LOCK(&EG(uninitialized_zval)); 31991: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 31992: EX_T(opline->result.var).var.ptr_ptr = NULL; 31993: } 31994: } else { 31995: /* here we are sure we are dealing with an object */ 31996: if (0) { 31997: MAKE_REAL_ZVAL_PTR(property); 31998: } 31999: 32000: /* here property is a string */ 32001: if (opline->extended_value == ZEND_ASSIGN_OBJ 32002: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 32003: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32004: if (zptr != NULL) { /* NULL means no success in getting PTR */ 32005: SEPARATE_ZVAL_IF_NOT_REF(zptr); 32006: 32007: have_get_ptr = 1; 32008: binary_op(*zptr, *zptr, value TSRMLS_CC); 32009: if (RETURN_VALUE_USED(opline)) { 32010: PZVAL_LOCK(*zptr); 32011: EX_T(opline->result.var).var.ptr = *zptr; 32012: EX_T(opline->result.var).var.ptr_ptr = NULL; 32013: } 32014: } 32015: } 32016: 32017: if (!have_get_ptr) { 32018: zval *z = NULL; 32019: 32020: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 32021: if (Z_OBJ_HT_P(object)->read_property) { 32022: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32023: } 32024: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 32025: if (Z_OBJ_HT_P(object)->read_dimension) { 32026: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 32027: } 32028: } 32029: if (z) { 32030: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 32031: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 32032: 32033: if (Z_REFCOUNT_P(z) == 0) { 32034: GC_REMOVE_ZVAL_FROM_BUFFER(z); 32035: zval_dtor(z); 32036: FREE_ZVAL(z); 32037: } 32038: z = value; 32039: } 32040: Z_ADDREF_P(z); 32041: SEPARATE_ZVAL_IF_NOT_REF(&z); 32042: binary_op(z, z, value TSRMLS_CC); 32043: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 32044: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32045: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 32046: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 32047: } 32048: if (RETURN_VALUE_USED(opline)) { 32049: PZVAL_LOCK(z); 32050: EX_T(opline->result.var).var.ptr = z; 32051: EX_T(opline->result.var).var.ptr_ptr = NULL; 32052: } 32053: zval_ptr_dtor(&z); 32054: } else { 32055: zend_error(E_WARNING, "Attempt to assign property of non-object"); 32056: if (RETURN_VALUE_USED(opline)) { 32057: PZVAL_LOCK(&EG(uninitialized_zval)); 32058: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 32059: EX_T(opline->result.var).var.ptr_ptr = NULL; 32060: } 32061: } 32062: } 32063: 32064: if (0) { 32065: zval_ptr_dtor(&property); 32066: } else { 32067: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32068: } 32069: FREE_OP(free_op_data1); 32070: } 32071: 32072: /* assign_obj has two opcodes! */ 32073: CHECK_EXCEPTION(); 32074: ZEND_VM_INC_OPCODE(); 32075: ZEND_VM_NEXT_OPCODE(); 32076: } 32077: 32078: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 32079: { 32080: USE_OPLINE 32081: zend_free_op free_op2, free_op_data2, free_op_data1; 32082: zval **var_ptr; 32083: zval *value; 32084: 32085: SAVE_OPLINE(); 32086: switch (opline->extended_value) { 32087: case ZEND_ASSIGN_OBJ: 32088: return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32089: break; 32090: case ZEND_ASSIGN_DIM: { 32091: zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 32092: 32093: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32094: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 32095: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 32096: if (IS_CV == IS_VAR && !0) { 32097: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 32098: } 32099: return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32100: } else { 32101: zval *dim = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32102: 32103: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC); 32104: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 32105: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 32106: } 32107: } 32108: break; 32109: default: 32110: value = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32111: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 32112: /* do nothing */ 32113: break; 32114: } 32115: 32116: if (UNEXPECTED(var_ptr == NULL)) { 32117: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 32118: } 32119: 32120: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 32121: if (RETURN_VALUE_USED(opline)) { 32122: PZVAL_LOCK(&EG(uninitialized_zval)); 32123: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 32124: } 32125: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32126: 32127: CHECK_EXCEPTION(); 32128: if (opline->extended_value == ZEND_ASSIGN_DIM) { 32129: ZEND_VM_INC_OPCODE(); 32130: } 32131: ZEND_VM_NEXT_OPCODE(); 32132: } 32133: 32134: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 32135: 32136: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 32137: && Z_OBJ_HANDLER_PP(var_ptr, get) 32138: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 32139: /* proxy object */ 32140: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 32141: Z_ADDREF_P(objval); 32142: binary_op(objval, objval, value TSRMLS_CC); 32143: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 32144: zval_ptr_dtor(&objval); 32145: } else { 32146: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 32147: } 32148: 32149: if (RETURN_VALUE_USED(opline)) { 32150: PZVAL_LOCK(*var_ptr); 32151: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 32152: } 32153: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32154: 32155: if (opline->extended_value == ZEND_ASSIGN_DIM) { 32156: FREE_OP(free_op_data1); 32157: FREE_OP_VAR_PTR(free_op_data2); 32158: 32159: CHECK_EXCEPTION(); 32160: ZEND_VM_INC_OPCODE(); 32161: } else { 32162: 32163: CHECK_EXCEPTION(); 32164: } 32165: ZEND_VM_NEXT_OPCODE(); 32166: } 32167: 32168: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32169: { 32170: return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32171: } 32172: 32173: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32174: { 32175: return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32176: } 32177: 32178: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32179: { 32180: return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32181: } 32182: 32183: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32184: { 32185: return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32186: } 32187: 32188: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32189: { 32190: return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32191: } 32192: 32193: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32194: { 32195: return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32196: } 32197: 32198: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32199: { 32200: return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32201: } 32202: 32203: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32204: { 32205: return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32206: } 32207: 32208: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32209: { 32210: return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32211: } 32212: 32213: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32214: { 32215: return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32216: } 32217: 32218: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32219: { 32220: return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32221: } 32222: 32223: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 32224: { 32225: USE_OPLINE 32226: zend_free_op free_op2; 32227: zval **object_ptr; 32228: zval *object; 32229: zval *property; 32230: zval **retval; 32231: int have_get_ptr = 0; 32232: 32233: SAVE_OPLINE(); 32234: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 32235: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32236: retval = &EX_T(opline->result.var).var.ptr; 32237: 32238: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 32239: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 32240: } 32241: 32242: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 32243: object = *object_ptr; 32244: 32245: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 32246: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 32247: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32248: if (RETURN_VALUE_USED(opline)) { 32249: PZVAL_LOCK(&EG(uninitialized_zval)); 32250: *retval = &EG(uninitialized_zval); 32251: } 32252: 32253: CHECK_EXCEPTION(); 32254: ZEND_VM_NEXT_OPCODE(); 32255: } 32256: 32257: /* here we are sure we are dealing with an object */ 32258: 32259: if (0) { 32260: MAKE_REAL_ZVAL_PTR(property); 32261: } 32262: 32263: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 32264: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32265: if (zptr != NULL) { /* NULL means no success in getting PTR */ 32266: SEPARATE_ZVAL_IF_NOT_REF(zptr); 32267: 32268: have_get_ptr = 1; 32269: incdec_op(*zptr); 32270: if (RETURN_VALUE_USED(opline)) { 32271: *retval = *zptr; 32272: PZVAL_LOCK(*retval); 32273: } 32274: } 32275: } 32276: 32277: if (!have_get_ptr) { 32278: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 32279: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32280: 32281: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 32282: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 32283: 32284: if (Z_REFCOUNT_P(z) == 0) { 32285: GC_REMOVE_ZVAL_FROM_BUFFER(z); 32286: zval_dtor(z); 32287: FREE_ZVAL(z); 32288: } 32289: z = value; 32290: } 32291: Z_ADDREF_P(z); 32292: SEPARATE_ZVAL_IF_NOT_REF(&z); 32293: incdec_op(z); 32294: *retval = z; 32295: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32296: SELECTIVE_PZVAL_LOCK(*retval, opline); 32297: zval_ptr_dtor(&z); 32298: } else { 32299: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 32300: if (RETURN_VALUE_USED(opline)) { 32301: PZVAL_LOCK(&EG(uninitialized_zval)); 32302: *retval = &EG(uninitialized_zval); 32303: } 32304: } 32305: } 32306: 32307: if (0) { 32308: zval_ptr_dtor(&property); 32309: } else { 32310: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32311: } 32312: 32313: CHECK_EXCEPTION(); 32314: ZEND_VM_NEXT_OPCODE(); 32315: } 32316: 32317: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32318: { 32319: return zend_pre_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32320: } 32321: 32322: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32323: { 32324: return zend_pre_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32325: } 32326: 32327: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 32328: { 32329: USE_OPLINE 32330: zend_free_op free_op2; 32331: zval **object_ptr; 32332: zval *object; 32333: zval *property; 32334: zval *retval; 32335: int have_get_ptr = 0; 32336: 32337: SAVE_OPLINE(); 32338: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 32339: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32340: retval = &EX_T(opline->result.var).tmp_var; 32341: 32342: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 32343: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 32344: } 32345: 32346: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 32347: object = *object_ptr; 32348: 32349: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 32350: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 32351: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32352: ZVAL_NULL(retval); 32353: 32354: CHECK_EXCEPTION(); 32355: ZEND_VM_NEXT_OPCODE(); 32356: } 32357: 32358: /* here we are sure we are dealing with an object */ 32359: 32360: if (0) { 32361: MAKE_REAL_ZVAL_PTR(property); 32362: } 32363: 32364: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 32365: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32366: if (zptr != NULL) { /* NULL means no success in getting PTR */ 32367: have_get_ptr = 1; 32368: SEPARATE_ZVAL_IF_NOT_REF(zptr); 32369: 32370: ZVAL_COPY_VALUE(retval, *zptr); 32371: zendi_zval_copy_ctor(*retval); 32372: 32373: incdec_op(*zptr); 32374: 32375: } 32376: } 32377: 32378: if (!have_get_ptr) { 32379: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 32380: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32381: zval *z_copy; 32382: 32383: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 32384: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 32385: 32386: if (Z_REFCOUNT_P(z) == 0) { 32387: GC_REMOVE_ZVAL_FROM_BUFFER(z); 32388: zval_dtor(z); 32389: FREE_ZVAL(z); 32390: } 32391: z = value; 32392: } 32393: ZVAL_COPY_VALUE(retval, z); 32394: zendi_zval_copy_ctor(*retval); 32395: ALLOC_ZVAL(z_copy); 32396: INIT_PZVAL_COPY(z_copy, z); 32397: zendi_zval_copy_ctor(*z_copy); 32398: incdec_op(z_copy); 32399: Z_ADDREF_P(z); 32400: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32401: zval_ptr_dtor(&z_copy); 32402: zval_ptr_dtor(&z); 32403: } else { 32404: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 32405: ZVAL_NULL(retval); 32406: } 32407: } 32408: 32409: if (0) { 32410: zval_ptr_dtor(&property); 32411: } else { 32412: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32413: } 32414: 32415: CHECK_EXCEPTION(); 32416: ZEND_VM_NEXT_OPCODE(); 32417: } 32418: 32419: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32420: { 32421: return zend_post_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32422: } 32423: 32424: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32425: { 32426: return zend_post_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32427: } 32428: 32429: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) 32430: { 32431: USE_OPLINE 32432: zend_free_op free_op1; 32433: zval *varname; 32434: zval **retval; 32435: zval tmp_varname; 32436: HashTable *target_symbol_table; 32437: ulong hash_value; 32438: 32439: SAVE_OPLINE(); 32440: varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 32441: 32442: if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 32443: ZVAL_COPY_VALUE(&tmp_varname, varname); 32444: zval_copy_ctor(&tmp_varname); 32445: Z_SET_REFCOUNT(tmp_varname, 1); 32446: Z_UNSET_ISREF(tmp_varname); 32447: convert_to_string(&tmp_varname); 32448: varname = &tmp_varname; 32449: } 32450: 32451: if (IS_VAR != IS_UNUSED) { 32452: zend_class_entry *ce; 32453: 32454: if (IS_VAR == IS_CONST) { 32455: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 32456: ce = CACHED_PTR(opline->op2.literal->cache_slot); 32457: } else { 32458: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 32459: if (UNEXPECTED(ce == NULL)) { 32460: if (IS_CV != IS_CONST && varname == &tmp_varname) { 32461: zval_dtor(&tmp_varname); 32462: } 32463: 32464: CHECK_EXCEPTION(); 32465: ZEND_VM_NEXT_OPCODE(); 32466: } 32467: CACHE_PTR(opline->op2.literal->cache_slot, ce); 32468: } 32469: } else { 32470: ce = EX_T(opline->op2.var).class_entry; 32471: } 32472: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 32473: 32474: } else { 32475: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 32476: /* 32477: if (!target_symbol_table) { 32478: CHECK_EXCEPTION(); 32479: ZEND_VM_NEXT_OPCODE(); 32480: } 32481: */ 32482: if (IS_CV == IS_CONST) { 32483: hash_value = Z_HASH_P(varname); 32484: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 32485: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 32486: } else { 32487: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 32488: } 32489: 32490: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 32491: switch (type) { 32492: case BP_VAR_R: 32493: case BP_VAR_UNSET: 32494: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 32495: /* break missing intentionally */ 32496: case BP_VAR_IS: 32497: retval = &EG(uninitialized_zval_ptr); 32498: break; 32499: case BP_VAR_RW: 32500: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 32501: /* break missing intentionally */ 32502: case BP_VAR_W: 32503: Z_ADDREF_P(&EG(uninitialized_zval)); 32504: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 32505: break; 32506: EMPTY_SWITCH_DEFAULT_CASE() 32507: } 32508: } 32509: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 32510: case ZEND_FETCH_GLOBAL: 32511: if (IS_CV != IS_TMP_VAR) { 32512: 32513: } 32514: break; 32515: case ZEND_FETCH_LOCAL: 32516: 32517: break; 32518: case ZEND_FETCH_STATIC: 32519: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 32520: break; 32521: case ZEND_FETCH_GLOBAL_LOCK: 32522: if (IS_CV == IS_VAR && !free_op1.var) { 32523: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 32524: } 32525: break; 32526: } 32527: } 32528: 32529: 32530: if (IS_CV != IS_CONST && varname == &tmp_varname) { 32531: zval_dtor(&tmp_varname); 32532: } 32533: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 32534: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 32535: } 32536: PZVAL_LOCK(*retval); 32537: switch (type) { 32538: case BP_VAR_R: 32539: case BP_VAR_IS: 32540: AI_SET_PTR(&EX_T(opline->result.var), *retval); 32541: break; 32542: case BP_VAR_UNSET: { 32543: zend_free_op free_res; 32544: 32545: PZVAL_UNLOCK(*retval, &free_res); 32546: if (retval != &EG(uninitialized_zval_ptr)) { 32547: SEPARATE_ZVAL_IF_NOT_REF(retval); 32548: } 32549: PZVAL_LOCK(*retval); 32550: FREE_OP_VAR_PTR(free_res); 32551: } 32552: /* break missing intentionally */ 32553: default: 32554: EX_T(opline->result.var).var.ptr_ptr = retval; 32555: break; 32556: } 32557: CHECK_EXCEPTION(); 32558: ZEND_VM_NEXT_OPCODE(); 32559: } 32560: 32561: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32562: { 32563: return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32564: } 32565: 32566: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32567: { 32568: return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32569: } 32570: 32571: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32572: { 32573: return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32574: } 32575: 32576: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32577: { 32578: USE_OPLINE 32579: 32580: return zend_fetch_var_address_helper_SPEC_CV_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32581: } 32582: 32583: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32584: { 32585: return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32586: } 32587: 32588: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32589: { 32590: return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32591: } 32592: 32593: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32594: { 32595: USE_OPLINE 32596: zend_free_op free_op2; 32597: zval **container; 32598: 32599: SAVE_OPLINE(); 32600: 32601: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 32602: IS_CV != IS_CV && 32603: EX_T(opline->op1.var).var.ptr_ptr) { 32604: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 32605: } 32606: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 32607: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); 32608: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32609: 32610: CHECK_EXCEPTION(); 32611: ZEND_VM_NEXT_OPCODE(); 32612: } 32613: 32614: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32615: { 32616: USE_OPLINE 32617: zend_free_op free_op1, free_op2; 32618: zval **container; 32619: 32620: SAVE_OPLINE(); 32621: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 32622: 32623: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32624: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 32625: } 32626: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); 32627: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32628: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32629: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32630: } 32631: 32632: /* We are going to assign the result by reference */ 32633: if (UNEXPECTED(opline->extended_value != 0)) { 32634: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 32635: 32636: if (retval_ptr) { 32637: Z_DELREF_PP(retval_ptr); 32638: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 32639: Z_ADDREF_PP(retval_ptr); 32640: } 32641: } 32642: 32643: CHECK_EXCEPTION(); 32644: ZEND_VM_NEXT_OPCODE(); 32645: } 32646: 32647: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32648: { 32649: USE_OPLINE 32650: zend_free_op free_op1, free_op2; 32651: zval **container; 32652: 32653: SAVE_OPLINE(); 32654: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 32655: 32656: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32657: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 32658: } 32659: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC); 32660: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32661: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32662: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32663: } 32664: 32665: CHECK_EXCEPTION(); 32666: ZEND_VM_NEXT_OPCODE(); 32667: } 32668: 32669: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32670: { 32671: USE_OPLINE 32672: zend_free_op free_op2; 32673: zval **container; 32674: 32675: SAVE_OPLINE(); 32676: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 32677: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC); 32678: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32679: 32680: CHECK_EXCEPTION(); 32681: ZEND_VM_NEXT_OPCODE(); 32682: } 32683: 32684: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32685: { 32686: USE_OPLINE 32687: zend_free_op free_op1, free_op2; 32688: zval **container; 32689: 32690: SAVE_OPLINE(); 32691: 32692: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 32693: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 32694: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32695: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 32696: } 32697: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); 32698: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32699: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32700: } 32701: } else { 32702: if (IS_VAR == IS_UNUSED) { 32703: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 32704: } 32705: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 32706: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); 32707: } 32708: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32709: 32710: CHECK_EXCEPTION(); 32711: ZEND_VM_NEXT_OPCODE(); 32712: } 32713: 32714: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32715: { 32716: USE_OPLINE 32717: zend_free_op free_op1, free_op2; 32718: zval **container; 32719: 32720: SAVE_OPLINE(); 32721: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 32722: 32723: if (IS_CV == IS_CV) { 32724: if (container != &EG(uninitialized_zval_ptr)) { 32725: SEPARATE_ZVAL_IF_NOT_REF(container); 32726: } 32727: } 32728: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32729: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 32730: } 32731: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC); 32732: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32733: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32734: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32735: } 32736: 32737: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 32738: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 32739: } else { 32740: zend_free_op free_res; 32741: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 32742: 32743: PZVAL_UNLOCK(*retval_ptr, &free_res); 32744: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 32745: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 32746: } 32747: PZVAL_LOCK(*retval_ptr); 32748: FREE_OP_VAR_PTR(free_res); 32749: CHECK_EXCEPTION(); 32750: ZEND_VM_NEXT_OPCODE(); 32751: } 32752: } 32753: 32754: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS) 32755: { 32756: USE_OPLINE 32757: 32758: zval *container; 32759: zend_free_op free_op2; 32760: zval *offset; 32761: 32762: SAVE_OPLINE(); 32763: container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 32764: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32765: 32766: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 32767: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 32768: zend_error(E_NOTICE, "Trying to get property of non-object"); 32769: PZVAL_LOCK(&EG(uninitialized_zval)); 32770: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 32771: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32772: } else { 32773: zval *retval; 32774: 32775: if (0) { 32776: MAKE_REAL_ZVAL_PTR(offset); 32777: } 32778: 32779: /* here we are sure we are dealing with an object */ 32780: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32781: 32782: PZVAL_LOCK(retval); 32783: AI_SET_PTR(&EX_T(opline->result.var), retval); 32784: 32785: if (0) { 32786: zval_ptr_dtor(&offset); 32787: } else { 32788: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32789: } 32790: } 32791: 32792: CHECK_EXCEPTION(); 32793: ZEND_VM_NEXT_OPCODE(); 32794: } 32795: 32796: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32797: { 32798: return zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32799: } 32800: 32801: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32802: { 32803: USE_OPLINE 32804: zend_free_op free_op1, free_op2; 32805: zval *property; 32806: zval **container; 32807: 32808: SAVE_OPLINE(); 32809: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32810: 32811: if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 32812: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 32813: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 32814: } 32815: 32816: if (0) { 32817: MAKE_REAL_ZVAL_PTR(property); 32818: } 32819: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 32820: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32821: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 32822: } 32823: 32824: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 32825: if (0) { 32826: zval_ptr_dtor(&property); 32827: } else { 32828: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32829: } 32830: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32831: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32832: } 32833: 32834: /* We are going to assign the result by reference */ 32835: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 32836: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 32837: 32838: Z_DELREF_PP(retval_ptr); 32839: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 32840: Z_ADDREF_PP(retval_ptr); 32841: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 32842: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 32843: } 32844: 32845: CHECK_EXCEPTION(); 32846: ZEND_VM_NEXT_OPCODE(); 32847: } 32848: 32849: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32850: { 32851: USE_OPLINE 32852: zend_free_op free_op1, free_op2; 32853: zval *property; 32854: zval **container; 32855: 32856: SAVE_OPLINE(); 32857: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32858: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 32859: 32860: if (0) { 32861: MAKE_REAL_ZVAL_PTR(property); 32862: } 32863: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32864: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 32865: } 32866: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 32867: if (0) { 32868: zval_ptr_dtor(&property); 32869: } else { 32870: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32871: } 32872: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32873: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32874: } 32875: 32876: CHECK_EXCEPTION(); 32877: ZEND_VM_NEXT_OPCODE(); 32878: } 32879: 32880: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32881: { 32882: USE_OPLINE 32883: 32884: zval *container; 32885: zend_free_op free_op2; 32886: zval *offset; 32887: 32888: SAVE_OPLINE(); 32889: container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 32890: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32891: 32892: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 32893: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 32894: PZVAL_LOCK(&EG(uninitialized_zval)); 32895: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 32896: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32897: } else { 32898: zval *retval; 32899: 32900: if (0) { 32901: MAKE_REAL_ZVAL_PTR(offset); 32902: } 32903: 32904: /* here we are sure we are dealing with an object */ 32905: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 32906: 32907: PZVAL_LOCK(retval); 32908: AI_SET_PTR(&EX_T(opline->result.var), retval); 32909: 32910: if (0) { 32911: zval_ptr_dtor(&offset); 32912: } else { 32913: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32914: } 32915: } 32916: 32917: CHECK_EXCEPTION(); 32918: ZEND_VM_NEXT_OPCODE(); 32919: } 32920: 32921: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32922: { 32923: USE_OPLINE 32924: 32925: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 32926: /* Behave like FETCH_OBJ_W */ 32927: zend_free_op free_op1, free_op2; 32928: zval *property; 32929: zval **container; 32930: 32931: SAVE_OPLINE(); 32932: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32933: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 32934: 32935: if (0) { 32936: MAKE_REAL_ZVAL_PTR(property); 32937: } 32938: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32939: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 32940: } 32941: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 32942: if (0) { 32943: zval_ptr_dtor(&property); 32944: } else { 32945: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32946: } 32947: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32948: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32949: } 32950: 32951: CHECK_EXCEPTION(); 32952: ZEND_VM_NEXT_OPCODE(); 32953: } else { 32954: return zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 32955: } 32956: } 32957: 32958: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 32959: { 32960: USE_OPLINE 32961: zend_free_op free_op1, free_op2, free_res; 32962: zval **container; 32963: zval *property; 32964: 32965: SAVE_OPLINE(); 32966: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 32967: property = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 32968: 32969: if (IS_CV == IS_CV) { 32970: if (container != &EG(uninitialized_zval_ptr)) { 32971: SEPARATE_ZVAL_IF_NOT_REF(container); 32972: } 32973: } 32974: if (0) { 32975: MAKE_REAL_ZVAL_PTR(property); 32976: } 32977: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 32978: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 32979: } 32980: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 32981: if (0) { 32982: zval_ptr_dtor(&property); 32983: } else { 32984: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 32985: } 32986: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 32987: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 32988: } 32989: 32990: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 32991: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 32992: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 32993: } 32994: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 32995: FREE_OP_VAR_PTR(free_res); 32996: CHECK_EXCEPTION(); 32997: ZEND_VM_NEXT_OPCODE(); 32998: } 32999: 33000: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33001: { 33002: USE_OPLINE 33003: zend_free_op free_op2; 33004: zval **object_ptr; 33005: zval *property_name; 33006: 33007: SAVE_OPLINE(); 33008: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 33009: property_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33010: 33011: if (0) { 33012: MAKE_REAL_ZVAL_PTR(property_name); 33013: } 33014: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 33015: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 33016: } 33017: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33018: if (0) { 33019: zval_ptr_dtor(&property_name); 33020: } else { 33021: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33022: } 33023: 33024: /* assign_obj has two opcodes! */ 33025: CHECK_EXCEPTION(); 33026: ZEND_VM_INC_OPCODE(); 33027: ZEND_VM_NEXT_OPCODE(); 33028: } 33029: 33030: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33031: { 33032: USE_OPLINE 33033: 33034: zval **object_ptr; 33035: 33036: SAVE_OPLINE(); 33037: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 33038: 33039: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 33040: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 33041: } 33042: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 33043: zend_free_op free_op2; 33044: zval *property_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33045: 33046: if (0) { 33047: MAKE_REAL_ZVAL_PTR(property_name); 33048: } 33049: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33050: if (0) { 33051: zval_ptr_dtor(&property_name); 33052: } else { 33053: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33054: } 33055: } else { 33056: zend_free_op free_op2, free_op_data1, free_op_data2; 33057: zval *value; 33058: zval *dim = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33059: zval **variable_ptr_ptr; 33060: 33061: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC); 33062: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33063: 33064: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 33065: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 33066: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 33067: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 33068: if (RETURN_VALUE_USED(opline)) { 33069: zval *retval; 33070: 33071: ALLOC_ZVAL(retval); 33072: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 33073: INIT_PZVAL(retval); 33074: AI_SET_PTR(&EX_T(opline->result.var), retval); 33075: } 33076: } else if (RETURN_VALUE_USED(opline)) { 33077: PZVAL_LOCK(&EG(uninitialized_zval)); 33078: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 33079: } 33080: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 33081: if (IS_TMP_FREE(free_op_data1)) { 33082: zval_dtor(value); 33083: } 33084: if (RETURN_VALUE_USED(opline)) { 33085: PZVAL_LOCK(&EG(uninitialized_zval)); 33086: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 33087: } 33088: } else { 33089: if ((opline+1)->op1_type == IS_TMP_VAR) { 33090: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 33091: } else if ((opline+1)->op1_type == IS_CONST) { 33092: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 33093: } else { 33094: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 33095: } 33096: if (RETURN_VALUE_USED(opline)) { 33097: PZVAL_LOCK(value); 33098: AI_SET_PTR(&EX_T(opline->result.var), value); 33099: } 33100: } 33101: FREE_OP_VAR_PTR(free_op_data2); 33102: FREE_OP_IF_VAR(free_op_data1); 33103: } 33104: 33105: /* assign_dim has two opcodes! */ 33106: CHECK_EXCEPTION(); 33107: ZEND_VM_INC_OPCODE(); 33108: ZEND_VM_NEXT_OPCODE(); 33109: } 33110: 33111: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33112: { 33113: USE_OPLINE 33114: zend_free_op free_op2; 33115: zval *value; 33116: zval **variable_ptr_ptr; 33117: 33118: SAVE_OPLINE(); 33119: value = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33120: variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 33121: 33122: if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 33123: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) { 33124: if (RETURN_VALUE_USED(opline)) { 33125: zval *retval; 33126: 33127: ALLOC_ZVAL(retval); 33128: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 33129: INIT_PZVAL(retval); 33130: AI_SET_PTR(&EX_T(opline->result.var), retval); 33131: } 33132: } else if (RETURN_VALUE_USED(opline)) { 33133: PZVAL_LOCK(&EG(uninitialized_zval)); 33134: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 33135: } 33136: } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 33137: if (0) { 33138: zval_dtor(value); 33139: } 33140: if (RETURN_VALUE_USED(opline)) { 33141: PZVAL_LOCK(&EG(uninitialized_zval)); 33142: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 33143: } 33144: } else { 33145: if (IS_VAR == IS_TMP_VAR) { 33146: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 33147: } else if (IS_VAR == IS_CONST) { 33148: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 33149: } else { 33150: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 33151: } 33152: if (RETURN_VALUE_USED(opline)) { 33153: PZVAL_LOCK(value); 33154: AI_SET_PTR(&EX_T(opline->result.var), value); 33155: } 33156: } 33157: 33158: /* zend_assign_to_variable() always takes care of op2, never free it! */ 33159: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33160: 33161: CHECK_EXCEPTION(); 33162: ZEND_VM_NEXT_OPCODE(); 33163: } 33164: 33165: static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33166: { 33167: USE_OPLINE 33168: zend_free_op free_op2; 33169: zval **variable_ptr_ptr; 33170: zval **value_ptr_ptr; 33171: 33172: SAVE_OPLINE(); 33173: value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33174: 33175: if (IS_VAR == IS_VAR && 33176: value_ptr_ptr && 33177: !Z_ISREF_PP(value_ptr_ptr) && 33178: opline->extended_value == ZEND_RETURNS_FUNCTION && 33179: !EX_T(opline->op2.var).var.fcall_returned_reference) { 33180: if (free_op2.var == NULL) { 33181: PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ 33182: } 33183: zend_error(E_STRICT, "Only variables should be assigned by reference"); 33184: if (UNEXPECTED(EG(exception) != NULL)) { 33185: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33186: HANDLE_EXCEPTION(); 33187: } 33188: return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 33189: } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 33190: PZVAL_LOCK(*value_ptr_ptr); 33191: } 33192: if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { 33193: zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); 33194: } 33195: 33196: variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 33197: if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || 33198: (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { 33199: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); 33200: } 33201: zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); 33202: 33203: if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 33204: Z_DELREF_PP(variable_ptr_ptr); 33205: } 33206: 33207: if (RETURN_VALUE_USED(opline)) { 33208: PZVAL_LOCK(*variable_ptr_ptr); 33209: AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr); 33210: } 33211: 33212: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33213: 33214: CHECK_EXCEPTION(); 33215: ZEND_VM_NEXT_OPCODE(); 33216: } 33217: 33218: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33219: { 33220: USE_OPLINE 33221: zval *function_name; 33222: char *function_name_strval; 33223: int function_name_strlen; 33224: zend_free_op free_op2; 33225: 33226: SAVE_OPLINE(); 33227: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 33228: 33229: function_name = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33230: 33231: if (IS_VAR != IS_CONST && 33232: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 33233: zend_error_noreturn(E_ERROR, "Method name must be a string"); 33234: } 33235: 33236: function_name_strval = Z_STRVAL_P(function_name); 33237: function_name_strlen = Z_STRLEN_P(function_name); 33238: 33239: EX(object) = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 33240: 33241: if (EXPECTED(EX(object) != NULL) && 33242: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 33243: EX(called_scope) = Z_OBJCE_P(EX(object)); 33244: 33245: if (IS_VAR != IS_CONST || 33246: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 33247: zval *object = EX(object); 33248: 33249: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 33250: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 33251: } 33252: 33253: /* First, locate the function. */ 33254: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 33255: if (UNEXPECTED(EX(fbc) == NULL)) { 33256: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 33257: } 33258: if (IS_VAR == IS_CONST && 33259: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 33260: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 33261: EXPECTED(EX(object) == object)) { 33262: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 33263: } 33264: } 33265: } else { 33266: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 33267: } 33268: 33269: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 33270: EX(object) = NULL; 33271: } else { 33272: if (!PZVAL_IS_REF(EX(object))) { 33273: Z_ADDREF_P(EX(object)); /* For $this pointer */ 33274: } else { 33275: zval *this_ptr; 33276: ALLOC_ZVAL(this_ptr); 33277: INIT_PZVAL_COPY(this_ptr, EX(object)); 33278: zval_copy_ctor(this_ptr); 33279: EX(object) = this_ptr; 33280: } 33281: } 33282: 33283: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33284: 33285: CHECK_EXCEPTION(); 33286: ZEND_VM_NEXT_OPCODE(); 33287: } 33288: 33289: static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33290: { 33291: USE_OPLINE 33292: zend_free_op free_op2; 33293: 33294: SAVE_OPLINE(); 33295: if (IS_CV==IS_VAR) { 33296: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 33297: } 33298: is_equal_function(&EX_T(opline->result.var).tmp_var, 33299: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 33300: _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC) TSRMLS_CC); 33301: 33302: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33303: CHECK_EXCEPTION(); 33304: ZEND_VM_NEXT_OPCODE(); 33305: } 33306: 33307: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33308: { 33309: USE_OPLINE 33310: 33311: zval *expr_ptr; 33312: 33313: SAVE_OPLINE(); 33314: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 33315: zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 33316: 33317: if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 33318: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 33319: } 33320: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 33321: expr_ptr = *expr_ptr_ptr; 33322: Z_ADDREF_P(expr_ptr); 33323: } else { 33324: expr_ptr=_get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 33325: if (0) { /* temporary variable */ 33326: zval *new_expr; 33327: 33328: ALLOC_ZVAL(new_expr); 33329: INIT_PZVAL_COPY(new_expr, expr_ptr); 33330: expr_ptr = new_expr; 33331: } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 33332: zval *new_expr; 33333: 33334: ALLOC_ZVAL(new_expr); 33335: INIT_PZVAL_COPY(new_expr, expr_ptr); 33336: expr_ptr = new_expr; 33337: zendi_zval_copy_ctor(*expr_ptr); 33338: } else { 33339: Z_ADDREF_P(expr_ptr); 33340: } 33341: } 33342: 33343: if (IS_VAR != IS_UNUSED) { 33344: zend_free_op free_op2; 33345: zval *offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33346: ulong hval; 33347: 33348: switch (Z_TYPE_P(offset)) { 33349: case IS_DOUBLE: 33350: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 33351: goto num_index; 33352: case IS_LONG: 33353: case IS_BOOL: 33354: hval = Z_LVAL_P(offset); 33355: num_index: 33356: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 33357: break; 33358: case IS_STRING: 33359: if (IS_VAR == IS_CONST) { 33360: hval = Z_HASH_P(offset); 33361: } else { 33362: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 33363: if (IS_INTERNED(Z_STRVAL_P(offset))) { 33364: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 33365: } else { 33366: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 33367: } 33368: } 33369: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 33370: break; 33371: case IS_NULL: 33372: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 33373: break; 33374: default: 33375: zend_error(E_WARNING, "Illegal offset type"); 33376: zval_ptr_dtor(&expr_ptr); 33377: /* do nothing */ 33378: break; 33379: } 33380: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33381: } else { 33382: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 33383: } 33384: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 33385: 33386: } else { 33387: 33388: } 33389: CHECK_EXCEPTION(); 33390: ZEND_VM_NEXT_OPCODE(); 33391: } 33392: 33393: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33394: { 33395: USE_OPLINE 33396: 33397: array_init(&EX_T(opline->result.var).tmp_var); 33398: if (IS_CV == IS_UNUSED) { 33399: ZEND_VM_NEXT_OPCODE(); 33400: #if 0 || IS_CV != IS_UNUSED 33401: } else { 33402: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 33403: #endif 33404: } 33405: } 33406: 33407: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33408: { 33409: USE_OPLINE 33410: zval tmp, *varname; 33411: HashTable *target_symbol_table; 33412: 33413: 33414: SAVE_OPLINE(); 33415: if (IS_CV == IS_CV && 33416: IS_VAR == IS_UNUSED && 33417: (opline->extended_value & ZEND_QUICK_SET)) { 33418: if (EG(active_symbol_table)) { 33419: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 33420: 33421: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 33422: EX_CV(opline->op1.var) = NULL; 33423: } else if (EX_CV(opline->op1.var)) { 33424: zval_ptr_dtor(EX_CV(opline->op1.var)); 33425: EX_CV(opline->op1.var) = NULL; 33426: } 33427: CHECK_EXCEPTION(); 33428: ZEND_VM_NEXT_OPCODE(); 33429: } 33430: 33431: varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 33432: 33433: if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 33434: ZVAL_COPY_VALUE(&tmp, varname); 33435: zval_copy_ctor(&tmp); 33436: convert_to_string(&tmp); 33437: varname = &tmp; 33438: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 33439: Z_ADDREF_P(varname); 33440: } 33441: 33442: if (IS_VAR != IS_UNUSED) { 33443: zend_class_entry *ce; 33444: 33445: if (IS_VAR == IS_CONST) { 33446: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 33447: ce = CACHED_PTR(opline->op2.literal->cache_slot); 33448: } else { 33449: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 33450: if (UNEXPECTED(EG(exception) != NULL)) { 33451: if (IS_CV != IS_CONST && varname == &tmp) { 33452: zval_dtor(&tmp); 33453: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 33454: zval_ptr_dtor(&varname); 33455: } 33456: 33457: HANDLE_EXCEPTION(); 33458: } 33459: if (UNEXPECTED(ce == NULL)) { 33460: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 33461: } 33462: CACHE_PTR(opline->op2.literal->cache_slot, ce); 33463: } 33464: } else { 33465: ce = EX_T(opline->op2.var).class_entry; 33466: } 33467: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 33468: } else { 33469: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 33470: 33471: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 33472: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 33473: } 33474: 33475: if (IS_CV != IS_CONST && varname == &tmp) { 33476: zval_dtor(&tmp); 33477: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 33478: zval_ptr_dtor(&varname); 33479: } 33480: 33481: CHECK_EXCEPTION(); 33482: ZEND_VM_NEXT_OPCODE(); 33483: } 33484: 33485: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33486: { 33487: USE_OPLINE 33488: zend_free_op free_op2; 33489: zval **container; 33490: zval *offset; 33491: ulong hval; 33492: 33493: SAVE_OPLINE(); 33494: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 33495: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 33496: SEPARATE_ZVAL_IF_NOT_REF(container); 33497: } 33498: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33499: 33500: if (IS_CV != IS_VAR || container) { 33501: switch (Z_TYPE_PP(container)) { 33502: case IS_ARRAY: { 33503: HashTable *ht = Z_ARRVAL_PP(container); 33504: 33505: switch (Z_TYPE_P(offset)) { 33506: case IS_DOUBLE: 33507: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 33508: zend_hash_index_del(ht, hval); 33509: break; 33510: case IS_RESOURCE: 33511: case IS_BOOL: 33512: case IS_LONG: 33513: hval = Z_LVAL_P(offset); 33514: zend_hash_index_del(ht, hval); 33515: break; 33516: case IS_STRING: 33517: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 33518: Z_ADDREF_P(offset); 33519: } 33520: if (IS_VAR == IS_CONST) { 33521: hval = Z_HASH_P(offset); 33522: } else { 33523: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 33524: if (IS_INTERNED(Z_STRVAL_P(offset))) { 33525: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 33526: } else { 33527: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 33528: } 33529: } 33530: if (ht == &EG(symbol_table)) { 33531: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 33532: } else { 33533: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 33534: } 33535: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 33536: zval_ptr_dtor(&offset); 33537: } 33538: break; 33539: num_index_dim: 33540: zend_hash_index_del(ht, hval); 33541: if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { 33542: zval_ptr_dtor(&offset); 33543: } 33544: break; 33545: case IS_NULL: 33546: zend_hash_del(ht, "", sizeof("")); 33547: break; 33548: default: 33549: zend_error(E_WARNING, "Illegal offset type in unset"); 33550: break; 33551: } 33552: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33553: break; 33554: } 33555: case IS_OBJECT: 33556: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 33557: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 33558: } 33559: if (0) { 33560: MAKE_REAL_ZVAL_PTR(offset); 33561: } 33562: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 33563: if (0) { 33564: zval_ptr_dtor(&offset); 33565: } else { 33566: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33567: } 33568: break; 33569: case IS_STRING: 33570: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 33571: ZEND_VM_CONTINUE(); /* bailed out before */ 33572: default: 33573: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33574: break; 33575: } 33576: } else { 33577: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33578: } 33579: 33580: CHECK_EXCEPTION(); 33581: ZEND_VM_NEXT_OPCODE(); 33582: } 33583: 33584: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33585: { 33586: USE_OPLINE 33587: zend_free_op free_op2; 33588: zval **container; 33589: zval *offset; 33590: 33591: SAVE_OPLINE(); 33592: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 33593: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33594: 33595: if (IS_CV != IS_VAR || container) { 33596: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 33597: SEPARATE_ZVAL_IF_NOT_REF(container); 33598: } 33599: if (Z_TYPE_PP(container) == IS_OBJECT) { 33600: if (0) { 33601: MAKE_REAL_ZVAL_PTR(offset); 33602: } 33603: if (Z_OBJ_HT_P(*container)->unset_property) { 33604: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33605: } else { 33606: zend_error(E_NOTICE, "Trying to unset property of non-object"); 33607: } 33608: if (0) { 33609: zval_ptr_dtor(&offset); 33610: } else { 33611: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33612: } 33613: } else { 33614: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33615: } 33616: } else { 33617: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33618: } 33619: 33620: CHECK_EXCEPTION(); 33621: ZEND_VM_NEXT_OPCODE(); 33622: } 33623: 33624: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33625: { 33626: USE_OPLINE 33627: zval **value; 33628: zend_bool isset = 1; 33629: 33630: SAVE_OPLINE(); 33631: if (IS_CV == IS_CV && 33632: IS_VAR == IS_UNUSED && 33633: (opline->extended_value & ZEND_QUICK_SET)) { 33634: if (EX_CV(opline->op1.var)) { 33635: value = EX_CV(opline->op1.var); 33636: } else if (EG(active_symbol_table)) { 33637: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 33638: 33639: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 33640: isset = 0; 33641: } 33642: } else { 33643: isset = 0; 33644: } 33645: } else { 33646: HashTable *target_symbol_table; 33647: 33648: zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 33649: 33650: if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 33651: ZVAL_COPY_VALUE(&tmp, varname); 33652: zval_copy_ctor(&tmp); 33653: convert_to_string(&tmp); 33654: varname = &tmp; 33655: } 33656: 33657: if (IS_VAR != IS_UNUSED) { 33658: zend_class_entry *ce; 33659: 33660: if (IS_VAR == IS_CONST) { 33661: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 33662: ce = CACHED_PTR(opline->op2.literal->cache_slot); 33663: } else { 33664: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 33665: if (UNEXPECTED(ce == NULL)) { 33666: CHECK_EXCEPTION(); 33667: ZEND_VM_NEXT_OPCODE(); 33668: } 33669: CACHE_PTR(opline->op2.literal->cache_slot, ce); 33670: } 33671: } else { 33672: ce = EX_T(opline->op2.var).class_entry; 33673: } 33674: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 33675: if (!value) { 33676: isset = 0; 33677: } 33678: } else { 33679: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 33680: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 33681: isset = 0; 33682: } 33683: } 33684: 33685: if (IS_CV != IS_CONST && varname == &tmp) { 33686: zval_dtor(&tmp); 33687: } 33688: 33689: } 33690: 33691: if (opline->extended_value & ZEND_ISSET) { 33692: if (isset && Z_TYPE_PP(value) != IS_NULL) { 33693: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 33694: } else { 33695: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 33696: } 33697: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 33698: if (!isset || !i_zend_is_true(*value)) { 33699: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 33700: } else { 33701: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 33702: } 33703: } 33704: 33705: CHECK_EXCEPTION(); 33706: ZEND_VM_NEXT_OPCODE(); 33707: } 33708: 33709: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 33710: { 33711: USE_OPLINE 33712: zend_free_op free_op2; 33713: zval **container; 33714: zval **value = NULL; 33715: int result = 0; 33716: ulong hval; 33717: zval *offset; 33718: 33719: SAVE_OPLINE(); 33720: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 33721: 33722: offset = _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC); 33723: 33724: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 33725: HashTable *ht; 33726: int isset = 0; 33727: 33728: ht = Z_ARRVAL_PP(container); 33729: 33730: switch (Z_TYPE_P(offset)) { 33731: case IS_DOUBLE: 33732: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 33733: goto num_index_prop; 33734: case IS_RESOURCE: 33735: case IS_BOOL: 33736: case IS_LONG: 33737: hval = Z_LVAL_P(offset); 33738: num_index_prop: 33739: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 33740: isset = 1; 33741: } 33742: break; 33743: case IS_STRING: 33744: if (IS_VAR == IS_CONST) { 33745: hval = Z_HASH_P(offset); 33746: } else { 33747: if (!prop_dim) { 33748: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 33749: } 33750: if (IS_INTERNED(Z_STRVAL_P(offset))) { 33751: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 33752: } else { 33753: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 33754: } 33755: } 33756: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 33757: isset = 1; 33758: } 33759: break; 33760: case IS_NULL: 33761: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 33762: isset = 1; 33763: } 33764: break; 33765: default: 33766: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 33767: break; 33768: } 33769: 33770: if (opline->extended_value & ZEND_ISSET) { 33771: if (isset && Z_TYPE_PP(value) == IS_NULL) { 33772: result = 0; 33773: } else { 33774: result = isset; 33775: } 33776: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 33777: if (!isset || !i_zend_is_true(*value)) { 33778: result = 0; 33779: } else { 33780: result = 1; 33781: } 33782: } 33783: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33784: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 33785: if (0) { 33786: MAKE_REAL_ZVAL_PTR(offset); 33787: } 33788: if (prop_dim) { 33789: if (Z_OBJ_HT_P(*container)->has_property) { 33790: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33791: } else { 33792: zend_error(E_NOTICE, "Trying to check property of non-object"); 33793: result = 0; 33794: } 33795: } else { 33796: if (Z_OBJ_HT_P(*container)->has_dimension) { 33797: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 33798: } else { 33799: zend_error(E_NOTICE, "Trying to check element of non-array"); 33800: result = 0; 33801: } 33802: } 33803: if (0) { 33804: zval_ptr_dtor(&offset); 33805: } else { 33806: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33807: } 33808: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 33809: zval tmp; 33810: 33811: if (Z_TYPE_P(offset) != IS_LONG) { 33812: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 33813: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 33814: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 33815: ZVAL_COPY_VALUE(&tmp, offset); 33816: zval_copy_ctor(&tmp); 33817: convert_to_long(&tmp); 33818: offset = &tmp; 33819: } else { 33820: /* can not be converted to proper offset, return "not set" */ 33821: result = 0; 33822: } 33823: } 33824: if (Z_TYPE_P(offset) == IS_LONG) { 33825: if (opline->extended_value & ZEND_ISSET) { 33826: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 33827: result = 1; 33828: } 33829: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 33830: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 33831: result = 1; 33832: } 33833: } 33834: } 33835: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33836: } else { 33837: if (free_op2.var) {zval_ptr_dtor(&free_op2.var);}; 33838: } 33839: 33840: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 33841: if (opline->extended_value & ZEND_ISSET) { 33842: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 33843: } else { 33844: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 33845: } 33846: 33847: CHECK_EXCEPTION(); 33848: ZEND_VM_NEXT_OPCODE(); 33849: } 33850: 33851: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33852: { 33853: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 33854: } 33855: 33856: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 33857: { 33858: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 33859: } 33860: 33861: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 33862: { 33863: USE_OPLINE 33864: zend_free_op free_op_data1; 33865: zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 33866: zval *object; 33867: zval *property = NULL; 33868: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 33869: int have_get_ptr = 0; 33870: 33871: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 33872: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 33873: } 33874: 33875: make_real_object(object_ptr TSRMLS_CC); 33876: object = *object_ptr; 33877: 33878: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 33879: zend_error(E_WARNING, "Attempt to assign property of non-object"); 33880: 33881: FREE_OP(free_op_data1); 33882: 33883: if (RETURN_VALUE_USED(opline)) { 33884: PZVAL_LOCK(&EG(uninitialized_zval)); 33885: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 33886: EX_T(opline->result.var).var.ptr_ptr = NULL; 33887: } 33888: } else { 33889: /* here we are sure we are dealing with an object */ 33890: if (0) { 33891: MAKE_REAL_ZVAL_PTR(property); 33892: } 33893: 33894: /* here property is a string */ 33895: if (opline->extended_value == ZEND_ASSIGN_OBJ 33896: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 33897: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33898: if (zptr != NULL) { /* NULL means no success in getting PTR */ 33899: SEPARATE_ZVAL_IF_NOT_REF(zptr); 33900: 33901: have_get_ptr = 1; 33902: binary_op(*zptr, *zptr, value TSRMLS_CC); 33903: if (RETURN_VALUE_USED(opline)) { 33904: PZVAL_LOCK(*zptr); 33905: EX_T(opline->result.var).var.ptr = *zptr; 33906: EX_T(opline->result.var).var.ptr_ptr = NULL; 33907: } 33908: } 33909: } 33910: 33911: if (!have_get_ptr) { 33912: zval *z = NULL; 33913: 33914: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 33915: if (Z_OBJ_HT_P(object)->read_property) { 33916: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33917: } 33918: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 33919: if (Z_OBJ_HT_P(object)->read_dimension) { 33920: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 33921: } 33922: } 33923: if (z) { 33924: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 33925: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 33926: 33927: if (Z_REFCOUNT_P(z) == 0) { 33928: GC_REMOVE_ZVAL_FROM_BUFFER(z); 33929: zval_dtor(z); 33930: FREE_ZVAL(z); 33931: } 33932: z = value; 33933: } 33934: Z_ADDREF_P(z); 33935: SEPARATE_ZVAL_IF_NOT_REF(&z); 33936: binary_op(z, z, value TSRMLS_CC); 33937: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 33938: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 33939: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 33940: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 33941: } 33942: if (RETURN_VALUE_USED(opline)) { 33943: PZVAL_LOCK(z); 33944: EX_T(opline->result.var).var.ptr = z; 33945: EX_T(opline->result.var).var.ptr_ptr = NULL; 33946: } 33947: zval_ptr_dtor(&z); 33948: } else { 33949: zend_error(E_WARNING, "Attempt to assign property of non-object"); 33950: if (RETURN_VALUE_USED(opline)) { 33951: PZVAL_LOCK(&EG(uninitialized_zval)); 33952: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 33953: EX_T(opline->result.var).var.ptr_ptr = NULL; 33954: } 33955: } 33956: } 33957: 33958: if (0) { 33959: zval_ptr_dtor(&property); 33960: } else { 33961: 33962: } 33963: FREE_OP(free_op_data1); 33964: } 33965: 33966: /* assign_obj has two opcodes! */ 33967: CHECK_EXCEPTION(); 33968: ZEND_VM_INC_OPCODE(); 33969: ZEND_VM_NEXT_OPCODE(); 33970: } 33971: 33972: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 33973: { 33974: USE_OPLINE 33975: zend_free_op free_op_data2, free_op_data1; 33976: zval **var_ptr; 33977: zval *value; 33978: 33979: SAVE_OPLINE(); 33980: switch (opline->extended_value) { 33981: case ZEND_ASSIGN_OBJ: 33982: return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 33983: break; 33984: case ZEND_ASSIGN_DIM: { 33985: zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 33986: 33987: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 33988: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 33989: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 33990: if (IS_CV == IS_VAR && !0) { 33991: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 33992: } 33993: return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 33994: } else { 33995: zval *dim = NULL; 33996: 33997: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC); 33998: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 33999: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 34000: } 34001: } 34002: break; 34003: default: 34004: value = NULL; 34005: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 34006: /* do nothing */ 34007: break; 34008: } 34009: 34010: if (UNEXPECTED(var_ptr == NULL)) { 34011: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 34012: } 34013: 34014: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 34015: if (RETURN_VALUE_USED(opline)) { 34016: PZVAL_LOCK(&EG(uninitialized_zval)); 34017: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 34018: } 34019: 34020: 34021: CHECK_EXCEPTION(); 34022: if (opline->extended_value == ZEND_ASSIGN_DIM) { 34023: ZEND_VM_INC_OPCODE(); 34024: } 34025: ZEND_VM_NEXT_OPCODE(); 34026: } 34027: 34028: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 34029: 34030: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 34031: && Z_OBJ_HANDLER_PP(var_ptr, get) 34032: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 34033: /* proxy object */ 34034: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 34035: Z_ADDREF_P(objval); 34036: binary_op(objval, objval, value TSRMLS_CC); 34037: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 34038: zval_ptr_dtor(&objval); 34039: } else { 34040: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 34041: } 34042: 34043: if (RETURN_VALUE_USED(opline)) { 34044: PZVAL_LOCK(*var_ptr); 34045: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 34046: } 34047: 34048: if (opline->extended_value == ZEND_ASSIGN_DIM) { 34049: FREE_OP(free_op_data1); 34050: FREE_OP_VAR_PTR(free_op_data2); 34051: 34052: CHECK_EXCEPTION(); 34053: ZEND_VM_INC_OPCODE(); 34054: } else { 34055: 34056: CHECK_EXCEPTION(); 34057: } 34058: ZEND_VM_NEXT_OPCODE(); 34059: } 34060: 34061: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34062: { 34063: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34064: } 34065: 34066: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34067: { 34068: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34069: } 34070: 34071: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34072: { 34073: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34074: } 34075: 34076: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34077: { 34078: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34079: } 34080: 34081: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34082: { 34083: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34084: } 34085: 34086: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34087: { 34088: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34089: } 34090: 34091: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34092: { 34093: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34094: } 34095: 34096: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34097: { 34098: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34099: } 34100: 34101: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34102: { 34103: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34104: } 34105: 34106: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34107: { 34108: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34109: } 34110: 34111: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34112: { 34113: return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34114: } 34115: 34116: static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) 34117: { 34118: USE_OPLINE 34119: zend_free_op free_op1; 34120: zval *varname; 34121: zval **retval; 34122: zval tmp_varname; 34123: HashTable *target_symbol_table; 34124: ulong hash_value; 34125: 34126: SAVE_OPLINE(); 34127: varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 34128: 34129: if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { 34130: ZVAL_COPY_VALUE(&tmp_varname, varname); 34131: zval_copy_ctor(&tmp_varname); 34132: Z_SET_REFCOUNT(tmp_varname, 1); 34133: Z_UNSET_ISREF(tmp_varname); 34134: convert_to_string(&tmp_varname); 34135: varname = &tmp_varname; 34136: } 34137: 34138: if (IS_UNUSED != IS_UNUSED) { 34139: zend_class_entry *ce; 34140: 34141: if (IS_UNUSED == IS_CONST) { 34142: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 34143: ce = CACHED_PTR(opline->op2.literal->cache_slot); 34144: } else { 34145: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 34146: if (UNEXPECTED(ce == NULL)) { 34147: if (IS_CV != IS_CONST && varname == &tmp_varname) { 34148: zval_dtor(&tmp_varname); 34149: } 34150: 34151: CHECK_EXCEPTION(); 34152: ZEND_VM_NEXT_OPCODE(); 34153: } 34154: CACHE_PTR(opline->op2.literal->cache_slot, ce); 34155: } 34156: } else { 34157: ce = EX_T(opline->op2.var).class_entry; 34158: } 34159: retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 34160: 34161: } else { 34162: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 34163: /* 34164: if (!target_symbol_table) { 34165: CHECK_EXCEPTION(); 34166: ZEND_VM_NEXT_OPCODE(); 34167: } 34168: */ 34169: if (IS_CV == IS_CONST) { 34170: hash_value = Z_HASH_P(varname); 34171: } else if (IS_INTERNED(Z_STRVAL_P(varname))) { 34172: hash_value = INTERNED_HASH(Z_STRVAL_P(varname)); 34173: } else { 34174: hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1); 34175: } 34176: 34177: if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { 34178: switch (type) { 34179: case BP_VAR_R: 34180: case BP_VAR_UNSET: 34181: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 34182: /* break missing intentionally */ 34183: case BP_VAR_IS: 34184: retval = &EG(uninitialized_zval_ptr); 34185: break; 34186: case BP_VAR_RW: 34187: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); 34188: /* break missing intentionally */ 34189: case BP_VAR_W: 34190: Z_ADDREF_P(&EG(uninitialized_zval)); 34191: zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); 34192: break; 34193: EMPTY_SWITCH_DEFAULT_CASE() 34194: } 34195: } 34196: switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { 34197: case ZEND_FETCH_GLOBAL: 34198: if (IS_CV != IS_TMP_VAR) { 34199: 34200: } 34201: break; 34202: case ZEND_FETCH_LOCAL: 34203: 34204: break; 34205: case ZEND_FETCH_STATIC: 34206: zval_update_constant(retval, (void*) 1 TSRMLS_CC); 34207: break; 34208: case ZEND_FETCH_GLOBAL_LOCK: 34209: if (IS_CV == IS_VAR && !free_op1.var) { 34210: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 34211: } 34212: break; 34213: } 34214: } 34215: 34216: 34217: if (IS_CV != IS_CONST && varname == &tmp_varname) { 34218: zval_dtor(&tmp_varname); 34219: } 34220: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 34221: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); 34222: } 34223: PZVAL_LOCK(*retval); 34224: switch (type) { 34225: case BP_VAR_R: 34226: case BP_VAR_IS: 34227: AI_SET_PTR(&EX_T(opline->result.var), *retval); 34228: break; 34229: case BP_VAR_UNSET: { 34230: zend_free_op free_res; 34231: 34232: PZVAL_UNLOCK(*retval, &free_res); 34233: if (retval != &EG(uninitialized_zval_ptr)) { 34234: SEPARATE_ZVAL_IF_NOT_REF(retval); 34235: } 34236: PZVAL_LOCK(*retval); 34237: FREE_OP_VAR_PTR(free_res); 34238: } 34239: /* break missing intentionally */ 34240: default: 34241: EX_T(opline->result.var).var.ptr_ptr = retval; 34242: break; 34243: } 34244: CHECK_EXCEPTION(); 34245: ZEND_VM_NEXT_OPCODE(); 34246: } 34247: 34248: static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34249: { 34250: return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34251: } 34252: 34253: static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34254: { 34255: return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34256: } 34257: 34258: static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34259: { 34260: return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34261: } 34262: 34263: static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34264: { 34265: USE_OPLINE 34266: 34267: return zend_fetch_var_address_helper_SPEC_CV_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34268: } 34269: 34270: static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34271: { 34272: return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34273: } 34274: 34275: static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34276: { 34277: return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34278: } 34279: 34280: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34281: { 34282: USE_OPLINE 34283: zend_free_op free_op1; 34284: zval **container; 34285: 34286: SAVE_OPLINE(); 34287: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 34288: 34289: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 34290: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 34291: } 34292: zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); 34293: 34294: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 34295: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 34296: } 34297: 34298: /* We are going to assign the result by reference */ 34299: if (UNEXPECTED(opline->extended_value != 0)) { 34300: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 34301: 34302: if (retval_ptr) { 34303: Z_DELREF_PP(retval_ptr); 34304: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 34305: Z_ADDREF_PP(retval_ptr); 34306: } 34307: } 34308: 34309: CHECK_EXCEPTION(); 34310: ZEND_VM_NEXT_OPCODE(); 34311: } 34312: 34313: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34314: { 34315: USE_OPLINE 34316: zend_free_op free_op1; 34317: zval **container; 34318: 34319: SAVE_OPLINE(); 34320: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 34321: 34322: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 34323: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 34324: } 34325: zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC); 34326: 34327: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 34328: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 34329: } 34330: 34331: CHECK_EXCEPTION(); 34332: ZEND_VM_NEXT_OPCODE(); 34333: } 34334: 34335: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34336: { 34337: USE_OPLINE 34338: zend_free_op free_op1; 34339: zval **container; 34340: 34341: SAVE_OPLINE(); 34342: 34343: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 34344: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 34345: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 34346: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 34347: } 34348: zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); 34349: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 34350: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 34351: } 34352: } else { 34353: if (IS_UNUSED == IS_UNUSED) { 34354: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 34355: } 34356: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 34357: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC); 34358: } 34359: 34360: 34361: CHECK_EXCEPTION(); 34362: ZEND_VM_NEXT_OPCODE(); 34363: } 34364: 34365: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34366: { 34367: USE_OPLINE 34368: 34369: zval **object_ptr; 34370: 34371: SAVE_OPLINE(); 34372: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 34373: 34374: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 34375: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 34376: } 34377: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 34378: 34379: zval *property_name = NULL; 34380: 34381: if (0) { 34382: MAKE_REAL_ZVAL_PTR(property_name); 34383: } 34384: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 34385: if (0) { 34386: zval_ptr_dtor(&property_name); 34387: } else { 34388: 34389: } 34390: } else { 34391: zend_free_op free_op_data1, free_op_data2; 34392: zval *value; 34393: zval *dim = NULL; 34394: zval **variable_ptr_ptr; 34395: 34396: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC); 34397: 34398: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 34399: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 34400: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 34401: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 34402: if (RETURN_VALUE_USED(opline)) { 34403: zval *retval; 34404: 34405: ALLOC_ZVAL(retval); 34406: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 34407: INIT_PZVAL(retval); 34408: AI_SET_PTR(&EX_T(opline->result.var), retval); 34409: } 34410: } else if (RETURN_VALUE_USED(opline)) { 34411: PZVAL_LOCK(&EG(uninitialized_zval)); 34412: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 34413: } 34414: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 34415: if (IS_TMP_FREE(free_op_data1)) { 34416: zval_dtor(value); 34417: } 34418: if (RETURN_VALUE_USED(opline)) { 34419: PZVAL_LOCK(&EG(uninitialized_zval)); 34420: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 34421: } 34422: } else { 34423: if ((opline+1)->op1_type == IS_TMP_VAR) { 34424: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 34425: } else if ((opline+1)->op1_type == IS_CONST) { 34426: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 34427: } else { 34428: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 34429: } 34430: if (RETURN_VALUE_USED(opline)) { 34431: PZVAL_LOCK(value); 34432: AI_SET_PTR(&EX_T(opline->result.var), value); 34433: } 34434: } 34435: FREE_OP_VAR_PTR(free_op_data2); 34436: FREE_OP_IF_VAR(free_op_data1); 34437: } 34438: 34439: /* assign_dim has two opcodes! */ 34440: CHECK_EXCEPTION(); 34441: ZEND_VM_INC_OPCODE(); 34442: ZEND_VM_NEXT_OPCODE(); 34443: } 34444: 34445: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34446: { 34447: USE_OPLINE 34448: 34449: zval *expr_ptr; 34450: 34451: SAVE_OPLINE(); 34452: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 34453: zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 34454: 34455: if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 34456: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 34457: } 34458: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 34459: expr_ptr = *expr_ptr_ptr; 34460: Z_ADDREF_P(expr_ptr); 34461: } else { 34462: expr_ptr=_get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 34463: if (0) { /* temporary variable */ 34464: zval *new_expr; 34465: 34466: ALLOC_ZVAL(new_expr); 34467: INIT_PZVAL_COPY(new_expr, expr_ptr); 34468: expr_ptr = new_expr; 34469: } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 34470: zval *new_expr; 34471: 34472: ALLOC_ZVAL(new_expr); 34473: INIT_PZVAL_COPY(new_expr, expr_ptr); 34474: expr_ptr = new_expr; 34475: zendi_zval_copy_ctor(*expr_ptr); 34476: } else { 34477: Z_ADDREF_P(expr_ptr); 34478: } 34479: } 34480: 34481: if (IS_UNUSED != IS_UNUSED) { 34482: 34483: zval *offset = NULL; 34484: ulong hval; 34485: 34486: switch (Z_TYPE_P(offset)) { 34487: case IS_DOUBLE: 34488: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 34489: goto num_index; 34490: case IS_LONG: 34491: case IS_BOOL: 34492: hval = Z_LVAL_P(offset); 34493: num_index: 34494: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 34495: break; 34496: case IS_STRING: 34497: if (IS_UNUSED == IS_CONST) { 34498: hval = Z_HASH_P(offset); 34499: } else { 34500: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 34501: if (IS_INTERNED(Z_STRVAL_P(offset))) { 34502: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 34503: } else { 34504: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 34505: } 34506: } 34507: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 34508: break; 34509: case IS_NULL: 34510: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 34511: break; 34512: default: 34513: zend_error(E_WARNING, "Illegal offset type"); 34514: zval_ptr_dtor(&expr_ptr); 34515: /* do nothing */ 34516: break; 34517: } 34518: 34519: } else { 34520: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 34521: } 34522: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 34523: 34524: } else { 34525: 34526: } 34527: CHECK_EXCEPTION(); 34528: ZEND_VM_NEXT_OPCODE(); 34529: } 34530: 34531: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34532: { 34533: USE_OPLINE 34534: 34535: array_init(&EX_T(opline->result.var).tmp_var); 34536: if (IS_CV == IS_UNUSED) { 34537: ZEND_VM_NEXT_OPCODE(); 34538: #if 0 || IS_CV != IS_UNUSED 34539: } else { 34540: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 34541: #endif 34542: } 34543: } 34544: 34545: static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34546: { 34547: USE_OPLINE 34548: zval tmp, *varname; 34549: HashTable *target_symbol_table; 34550: 34551: 34552: SAVE_OPLINE(); 34553: if (IS_CV == IS_CV && 34554: IS_UNUSED == IS_UNUSED && 34555: (opline->extended_value & ZEND_QUICK_SET)) { 34556: if (EG(active_symbol_table)) { 34557: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 34558: 34559: zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); 34560: EX_CV(opline->op1.var) = NULL; 34561: } else if (EX_CV(opline->op1.var)) { 34562: zval_ptr_dtor(EX_CV(opline->op1.var)); 34563: EX_CV(opline->op1.var) = NULL; 34564: } 34565: CHECK_EXCEPTION(); 34566: ZEND_VM_NEXT_OPCODE(); 34567: } 34568: 34569: varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 34570: 34571: if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 34572: ZVAL_COPY_VALUE(&tmp, varname); 34573: zval_copy_ctor(&tmp); 34574: convert_to_string(&tmp); 34575: varname = &tmp; 34576: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 34577: Z_ADDREF_P(varname); 34578: } 34579: 34580: if (IS_UNUSED != IS_UNUSED) { 34581: zend_class_entry *ce; 34582: 34583: if (IS_UNUSED == IS_CONST) { 34584: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 34585: ce = CACHED_PTR(opline->op2.literal->cache_slot); 34586: } else { 34587: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 34588: if (UNEXPECTED(EG(exception) != NULL)) { 34589: if (IS_CV != IS_CONST && varname == &tmp) { 34590: zval_dtor(&tmp); 34591: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 34592: zval_ptr_dtor(&varname); 34593: } 34594: 34595: HANDLE_EXCEPTION(); 34596: } 34597: if (UNEXPECTED(ce == NULL)) { 34598: zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); 34599: } 34600: CACHE_PTR(opline->op2.literal->cache_slot, ce); 34601: } 34602: } else { 34603: ce = EX_T(opline->op2.var).class_entry; 34604: } 34605: zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 34606: } else { 34607: ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); 34608: 34609: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 34610: zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); 34611: } 34612: 34613: if (IS_CV != IS_CONST && varname == &tmp) { 34614: zval_dtor(&tmp); 34615: } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { 34616: zval_ptr_dtor(&varname); 34617: } 34618: 34619: CHECK_EXCEPTION(); 34620: ZEND_VM_NEXT_OPCODE(); 34621: } 34622: 34623: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34624: { 34625: USE_OPLINE 34626: zval **value; 34627: zend_bool isset = 1; 34628: 34629: SAVE_OPLINE(); 34630: if (IS_CV == IS_CV && 34631: IS_UNUSED == IS_UNUSED && 34632: (opline->extended_value & ZEND_QUICK_SET)) { 34633: if (EX_CV(opline->op1.var)) { 34634: value = EX_CV(opline->op1.var); 34635: } else if (EG(active_symbol_table)) { 34636: zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); 34637: 34638: if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { 34639: isset = 0; 34640: } 34641: } else { 34642: isset = 0; 34643: } 34644: } else { 34645: HashTable *target_symbol_table; 34646: 34647: zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 34648: 34649: if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { 34650: ZVAL_COPY_VALUE(&tmp, varname); 34651: zval_copy_ctor(&tmp); 34652: convert_to_string(&tmp); 34653: varname = &tmp; 34654: } 34655: 34656: if (IS_UNUSED != IS_UNUSED) { 34657: zend_class_entry *ce; 34658: 34659: if (IS_UNUSED == IS_CONST) { 34660: if (CACHED_PTR(opline->op2.literal->cache_slot)) { 34661: ce = CACHED_PTR(opline->op2.literal->cache_slot); 34662: } else { 34663: ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); 34664: if (UNEXPECTED(ce == NULL)) { 34665: CHECK_EXCEPTION(); 34666: ZEND_VM_NEXT_OPCODE(); 34667: } 34668: CACHE_PTR(opline->op2.literal->cache_slot, ce); 34669: } 34670: } else { 34671: ce = EX_T(opline->op2.var).class_entry; 34672: } 34673: value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); 34674: if (!value) { 34675: isset = 0; 34676: } 34677: } else { 34678: target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); 34679: if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { 34680: isset = 0; 34681: } 34682: } 34683: 34684: if (IS_CV != IS_CONST && varname == &tmp) { 34685: zval_dtor(&tmp); 34686: } 34687: 34688: } 34689: 34690: if (opline->extended_value & ZEND_ISSET) { 34691: if (isset && Z_TYPE_PP(value) != IS_NULL) { 34692: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 34693: } else { 34694: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 34695: } 34696: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 34697: if (!isset || !i_zend_is_true(*value)) { 34698: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); 34699: } else { 34700: ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); 34701: } 34702: } 34703: 34704: CHECK_EXCEPTION(); 34705: ZEND_VM_NEXT_OPCODE(); 34706: } 34707: 34708: static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34709: { 34710: USE_OPLINE 34711: 34712: 34713: SAVE_OPLINE(); 34714: fast_add_function(&EX_T(opline->result.var).tmp_var, 34715: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34716: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34717: 34718: 34719: CHECK_EXCEPTION(); 34720: ZEND_VM_NEXT_OPCODE(); 34721: } 34722: 34723: static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34724: { 34725: USE_OPLINE 34726: 34727: 34728: SAVE_OPLINE(); 34729: fast_sub_function(&EX_T(opline->result.var).tmp_var, 34730: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34731: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34732: 34733: 34734: CHECK_EXCEPTION(); 34735: ZEND_VM_NEXT_OPCODE(); 34736: } 34737: 34738: static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34739: { 34740: USE_OPLINE 34741: 34742: 34743: SAVE_OPLINE(); 34744: fast_mul_function(&EX_T(opline->result.var).tmp_var, 34745: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34746: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34747: 34748: 34749: CHECK_EXCEPTION(); 34750: ZEND_VM_NEXT_OPCODE(); 34751: } 34752: 34753: static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34754: { 34755: USE_OPLINE 34756: 34757: 34758: SAVE_OPLINE(); 34759: fast_div_function(&EX_T(opline->result.var).tmp_var, 34760: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34761: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34762: 34763: 34764: CHECK_EXCEPTION(); 34765: ZEND_VM_NEXT_OPCODE(); 34766: } 34767: 34768: static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34769: { 34770: USE_OPLINE 34771: 34772: 34773: SAVE_OPLINE(); 34774: fast_mod_function(&EX_T(opline->result.var).tmp_var, 34775: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34776: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34777: 34778: 34779: CHECK_EXCEPTION(); 34780: ZEND_VM_NEXT_OPCODE(); 34781: } 34782: 34783: static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34784: { 34785: USE_OPLINE 34786: 34787: 34788: SAVE_OPLINE(); 34789: shift_left_function(&EX_T(opline->result.var).tmp_var, 34790: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34791: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34792: 34793: 34794: CHECK_EXCEPTION(); 34795: ZEND_VM_NEXT_OPCODE(); 34796: } 34797: 34798: static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34799: { 34800: USE_OPLINE 34801: 34802: 34803: SAVE_OPLINE(); 34804: shift_right_function(&EX_T(opline->result.var).tmp_var, 34805: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34806: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34807: 34808: 34809: CHECK_EXCEPTION(); 34810: ZEND_VM_NEXT_OPCODE(); 34811: } 34812: 34813: static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34814: { 34815: USE_OPLINE 34816: 34817: 34818: SAVE_OPLINE(); 34819: concat_function(&EX_T(opline->result.var).tmp_var, 34820: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34821: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34822: 34823: 34824: CHECK_EXCEPTION(); 34825: ZEND_VM_NEXT_OPCODE(); 34826: } 34827: 34828: static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34829: { 34830: USE_OPLINE 34831: 34832: 34833: SAVE_OPLINE(); 34834: is_identical_function(&EX_T(opline->result.var).tmp_var, 34835: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34836: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34837: 34838: 34839: CHECK_EXCEPTION(); 34840: ZEND_VM_NEXT_OPCODE(); 34841: } 34842: 34843: static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34844: { 34845: USE_OPLINE 34846: 34847: zval *result = &EX_T(opline->result.var).tmp_var; 34848: 34849: SAVE_OPLINE(); 34850: is_identical_function(result, 34851: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34852: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34853: Z_LVAL_P(result) = !Z_LVAL_P(result); 34854: 34855: 34856: CHECK_EXCEPTION(); 34857: ZEND_VM_NEXT_OPCODE(); 34858: } 34859: 34860: static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34861: { 34862: USE_OPLINE 34863: 34864: zval *result = &EX_T(opline->result.var).tmp_var; 34865: 34866: SAVE_OPLINE(); 34867: ZVAL_BOOL(result, fast_equal_function(result, 34868: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34869: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 34870: 34871: 34872: CHECK_EXCEPTION(); 34873: ZEND_VM_NEXT_OPCODE(); 34874: } 34875: 34876: static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34877: { 34878: USE_OPLINE 34879: 34880: zval *result = &EX_T(opline->result.var).tmp_var; 34881: 34882: SAVE_OPLINE(); 34883: ZVAL_BOOL(result, fast_not_equal_function(result, 34884: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34885: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 34886: 34887: 34888: CHECK_EXCEPTION(); 34889: ZEND_VM_NEXT_OPCODE(); 34890: } 34891: 34892: static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34893: { 34894: USE_OPLINE 34895: 34896: zval *result = &EX_T(opline->result.var).tmp_var; 34897: 34898: SAVE_OPLINE(); 34899: ZVAL_BOOL(result, fast_is_smaller_function(result, 34900: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34901: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 34902: 34903: 34904: CHECK_EXCEPTION(); 34905: ZEND_VM_NEXT_OPCODE(); 34906: } 34907: 34908: static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34909: { 34910: USE_OPLINE 34911: 34912: zval *result = &EX_T(opline->result.var).tmp_var; 34913: 34914: SAVE_OPLINE(); 34915: ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, 34916: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34917: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC)); 34918: 34919: 34920: CHECK_EXCEPTION(); 34921: ZEND_VM_NEXT_OPCODE(); 34922: } 34923: 34924: static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34925: { 34926: USE_OPLINE 34927: 34928: 34929: SAVE_OPLINE(); 34930: bitwise_or_function(&EX_T(opline->result.var).tmp_var, 34931: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34932: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34933: 34934: 34935: CHECK_EXCEPTION(); 34936: ZEND_VM_NEXT_OPCODE(); 34937: } 34938: 34939: static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34940: { 34941: USE_OPLINE 34942: 34943: 34944: SAVE_OPLINE(); 34945: bitwise_and_function(&EX_T(opline->result.var).tmp_var, 34946: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34947: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34948: 34949: 34950: CHECK_EXCEPTION(); 34951: ZEND_VM_NEXT_OPCODE(); 34952: } 34953: 34954: static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34955: { 34956: USE_OPLINE 34957: 34958: 34959: SAVE_OPLINE(); 34960: bitwise_xor_function(&EX_T(opline->result.var).tmp_var, 34961: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34962: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34963: 34964: 34965: CHECK_EXCEPTION(); 34966: ZEND_VM_NEXT_OPCODE(); 34967: } 34968: 34969: static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 34970: { 34971: USE_OPLINE 34972: 34973: 34974: SAVE_OPLINE(); 34975: boolean_xor_function(&EX_T(opline->result.var).tmp_var, 34976: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 34977: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 34978: 34979: 34980: CHECK_EXCEPTION(); 34981: ZEND_VM_NEXT_OPCODE(); 34982: } 34983: 34984: static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 34985: { 34986: USE_OPLINE 34987: zend_free_op free_op_data1; 34988: zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 34989: zval *object; 34990: zval *property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 34991: zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 34992: int have_get_ptr = 0; 34993: 34994: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 34995: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 34996: } 34997: 34998: make_real_object(object_ptr TSRMLS_CC); 34999: object = *object_ptr; 35000: 35001: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 35002: zend_error(E_WARNING, "Attempt to assign property of non-object"); 35003: 35004: FREE_OP(free_op_data1); 35005: 35006: if (RETURN_VALUE_USED(opline)) { 35007: PZVAL_LOCK(&EG(uninitialized_zval)); 35008: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 35009: EX_T(opline->result.var).var.ptr_ptr = NULL; 35010: } 35011: } else { 35012: /* here we are sure we are dealing with an object */ 35013: if (0) { 35014: MAKE_REAL_ZVAL_PTR(property); 35015: } 35016: 35017: /* here property is a string */ 35018: if (opline->extended_value == ZEND_ASSIGN_OBJ 35019: && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 35020: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35021: if (zptr != NULL) { /* NULL means no success in getting PTR */ 35022: SEPARATE_ZVAL_IF_NOT_REF(zptr); 35023: 35024: have_get_ptr = 1; 35025: binary_op(*zptr, *zptr, value TSRMLS_CC); 35026: if (RETURN_VALUE_USED(opline)) { 35027: PZVAL_LOCK(*zptr); 35028: EX_T(opline->result.var).var.ptr = *zptr; 35029: EX_T(opline->result.var).var.ptr_ptr = NULL; 35030: } 35031: } 35032: } 35033: 35034: if (!have_get_ptr) { 35035: zval *z = NULL; 35036: 35037: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 35038: if (Z_OBJ_HT_P(object)->read_property) { 35039: z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35040: } 35041: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 35042: if (Z_OBJ_HT_P(object)->read_dimension) { 35043: z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); 35044: } 35045: } 35046: if (z) { 35047: if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { 35048: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 35049: 35050: if (Z_REFCOUNT_P(z) == 0) { 35051: GC_REMOVE_ZVAL_FROM_BUFFER(z); 35052: zval_dtor(z); 35053: FREE_ZVAL(z); 35054: } 35055: z = value; 35056: } 35057: Z_ADDREF_P(z); 35058: SEPARATE_ZVAL_IF_NOT_REF(&z); 35059: binary_op(z, z, value TSRMLS_CC); 35060: if (opline->extended_value == ZEND_ASSIGN_OBJ) { 35061: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35062: } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { 35063: Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); 35064: } 35065: if (RETURN_VALUE_USED(opline)) { 35066: PZVAL_LOCK(z); 35067: EX_T(opline->result.var).var.ptr = z; 35068: EX_T(opline->result.var).var.ptr_ptr = NULL; 35069: } 35070: zval_ptr_dtor(&z); 35071: } else { 35072: zend_error(E_WARNING, "Attempt to assign property of non-object"); 35073: if (RETURN_VALUE_USED(opline)) { 35074: PZVAL_LOCK(&EG(uninitialized_zval)); 35075: EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); 35076: EX_T(opline->result.var).var.ptr_ptr = NULL; 35077: } 35078: } 35079: } 35080: 35081: if (0) { 35082: zval_ptr_dtor(&property); 35083: } else { 35084: 35085: } 35086: FREE_OP(free_op_data1); 35087: } 35088: 35089: /* assign_obj has two opcodes! */ 35090: CHECK_EXCEPTION(); 35091: ZEND_VM_INC_OPCODE(); 35092: ZEND_VM_NEXT_OPCODE(); 35093: } 35094: 35095: static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) 35096: { 35097: USE_OPLINE 35098: zend_free_op free_op_data2, free_op_data1; 35099: zval **var_ptr; 35100: zval *value; 35101: 35102: SAVE_OPLINE(); 35103: switch (opline->extended_value) { 35104: case ZEND_ASSIGN_OBJ: 35105: return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35106: break; 35107: case ZEND_ASSIGN_DIM: { 35108: zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 35109: 35110: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35111: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35112: } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { 35113: if (IS_CV == IS_VAR && !0) { 35114: Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ 35115: } 35116: return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35117: } else { 35118: zval *dim = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35119: 35120: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC); 35121: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 35122: var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 35123: } 35124: } 35125: break; 35126: default: 35127: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35128: var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 35129: /* do nothing */ 35130: break; 35131: } 35132: 35133: if (UNEXPECTED(var_ptr == NULL)) { 35134: zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); 35135: } 35136: 35137: if (UNEXPECTED(*var_ptr == &EG(error_zval))) { 35138: if (RETURN_VALUE_USED(opline)) { 35139: PZVAL_LOCK(&EG(uninitialized_zval)); 35140: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35141: } 35142: 35143: 35144: CHECK_EXCEPTION(); 35145: if (opline->extended_value == ZEND_ASSIGN_DIM) { 35146: ZEND_VM_INC_OPCODE(); 35147: } 35148: ZEND_VM_NEXT_OPCODE(); 35149: } 35150: 35151: SEPARATE_ZVAL_IF_NOT_REF(var_ptr); 35152: 35153: if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) 35154: && Z_OBJ_HANDLER_PP(var_ptr, get) 35155: && Z_OBJ_HANDLER_PP(var_ptr, set)) { 35156: /* proxy object */ 35157: zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); 35158: Z_ADDREF_P(objval); 35159: binary_op(objval, objval, value TSRMLS_CC); 35160: Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); 35161: zval_ptr_dtor(&objval); 35162: } else { 35163: binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); 35164: } 35165: 35166: if (RETURN_VALUE_USED(opline)) { 35167: PZVAL_LOCK(*var_ptr); 35168: AI_SET_PTR(&EX_T(opline->result.var), *var_ptr); 35169: } 35170: 35171: if (opline->extended_value == ZEND_ASSIGN_DIM) { 35172: FREE_OP(free_op_data1); 35173: FREE_OP_VAR_PTR(free_op_data2); 35174: 35175: CHECK_EXCEPTION(); 35176: ZEND_VM_INC_OPCODE(); 35177: } else { 35178: 35179: CHECK_EXCEPTION(); 35180: } 35181: ZEND_VM_NEXT_OPCODE(); 35182: } 35183: 35184: static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35185: { 35186: return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35187: } 35188: 35189: static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35190: { 35191: return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35192: } 35193: 35194: static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35195: { 35196: return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35197: } 35198: 35199: static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35200: { 35201: return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35202: } 35203: 35204: static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35205: { 35206: return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35207: } 35208: 35209: static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35210: { 35211: return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35212: } 35213: 35214: static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35215: { 35216: return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35217: } 35218: 35219: static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35220: { 35221: return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35222: } 35223: 35224: static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35225: { 35226: return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35227: } 35228: 35229: static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35230: { 35231: return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35232: } 35233: 35234: static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35235: { 35236: return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35237: } 35238: 35239: static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 35240: { 35241: USE_OPLINE 35242: 35243: zval **object_ptr; 35244: zval *object; 35245: zval *property; 35246: zval **retval; 35247: int have_get_ptr = 0; 35248: 35249: SAVE_OPLINE(); 35250: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 35251: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35252: retval = &EX_T(opline->result.var).var.ptr; 35253: 35254: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 35255: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 35256: } 35257: 35258: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 35259: object = *object_ptr; 35260: 35261: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 35262: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 35263: 35264: if (RETURN_VALUE_USED(opline)) { 35265: PZVAL_LOCK(&EG(uninitialized_zval)); 35266: *retval = &EG(uninitialized_zval); 35267: } 35268: 35269: CHECK_EXCEPTION(); 35270: ZEND_VM_NEXT_OPCODE(); 35271: } 35272: 35273: /* here we are sure we are dealing with an object */ 35274: 35275: if (0) { 35276: MAKE_REAL_ZVAL_PTR(property); 35277: } 35278: 35279: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 35280: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35281: if (zptr != NULL) { /* NULL means no success in getting PTR */ 35282: SEPARATE_ZVAL_IF_NOT_REF(zptr); 35283: 35284: have_get_ptr = 1; 35285: incdec_op(*zptr); 35286: if (RETURN_VALUE_USED(opline)) { 35287: *retval = *zptr; 35288: PZVAL_LOCK(*retval); 35289: } 35290: } 35291: } 35292: 35293: if (!have_get_ptr) { 35294: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 35295: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35296: 35297: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 35298: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 35299: 35300: if (Z_REFCOUNT_P(z) == 0) { 35301: GC_REMOVE_ZVAL_FROM_BUFFER(z); 35302: zval_dtor(z); 35303: FREE_ZVAL(z); 35304: } 35305: z = value; 35306: } 35307: Z_ADDREF_P(z); 35308: SEPARATE_ZVAL_IF_NOT_REF(&z); 35309: incdec_op(z); 35310: *retval = z; 35311: Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35312: SELECTIVE_PZVAL_LOCK(*retval, opline); 35313: zval_ptr_dtor(&z); 35314: } else { 35315: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 35316: if (RETURN_VALUE_USED(opline)) { 35317: PZVAL_LOCK(&EG(uninitialized_zval)); 35318: *retval = &EG(uninitialized_zval); 35319: } 35320: } 35321: } 35322: 35323: if (0) { 35324: zval_ptr_dtor(&property); 35325: } else { 35326: 35327: } 35328: 35329: CHECK_EXCEPTION(); 35330: ZEND_VM_NEXT_OPCODE(); 35331: } 35332: 35333: static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35334: { 35335: return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35336: } 35337: 35338: static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35339: { 35340: return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35341: } 35342: 35343: static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) 35344: { 35345: USE_OPLINE 35346: 35347: zval **object_ptr; 35348: zval *object; 35349: zval *property; 35350: zval *retval; 35351: int have_get_ptr = 0; 35352: 35353: SAVE_OPLINE(); 35354: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 35355: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35356: retval = &EX_T(opline->result.var).tmp_var; 35357: 35358: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 35359: zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); 35360: } 35361: 35362: make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ 35363: object = *object_ptr; 35364: 35365: if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { 35366: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 35367: 35368: ZVAL_NULL(retval); 35369: 35370: CHECK_EXCEPTION(); 35371: ZEND_VM_NEXT_OPCODE(); 35372: } 35373: 35374: /* here we are sure we are dealing with an object */ 35375: 35376: if (0) { 35377: MAKE_REAL_ZVAL_PTR(property); 35378: } 35379: 35380: if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { 35381: zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35382: if (zptr != NULL) { /* NULL means no success in getting PTR */ 35383: have_get_ptr = 1; 35384: SEPARATE_ZVAL_IF_NOT_REF(zptr); 35385: 35386: ZVAL_COPY_VALUE(retval, *zptr); 35387: zendi_zval_copy_ctor(*retval); 35388: 35389: incdec_op(*zptr); 35390: 35391: } 35392: } 35393: 35394: if (!have_get_ptr) { 35395: if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { 35396: zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35397: zval *z_copy; 35398: 35399: if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { 35400: zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); 35401: 35402: if (Z_REFCOUNT_P(z) == 0) { 35403: GC_REMOVE_ZVAL_FROM_BUFFER(z); 35404: zval_dtor(z); 35405: FREE_ZVAL(z); 35406: } 35407: z = value; 35408: } 35409: ZVAL_COPY_VALUE(retval, z); 35410: zendi_zval_copy_ctor(*retval); 35411: ALLOC_ZVAL(z_copy); 35412: INIT_PZVAL_COPY(z_copy, z); 35413: zendi_zval_copy_ctor(*z_copy); 35414: incdec_op(z_copy); 35415: Z_ADDREF_P(z); 35416: Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35417: zval_ptr_dtor(&z_copy); 35418: zval_ptr_dtor(&z); 35419: } else { 35420: zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); 35421: ZVAL_NULL(retval); 35422: } 35423: } 35424: 35425: if (0) { 35426: zval_ptr_dtor(&property); 35427: } else { 35428: 35429: } 35430: 35431: CHECK_EXCEPTION(); 35432: ZEND_VM_NEXT_OPCODE(); 35433: } 35434: 35435: static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35436: { 35437: return zend_post_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35438: } 35439: 35440: static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35441: { 35442: return zend_post_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35443: } 35444: 35445: static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35446: { 35447: USE_OPLINE 35448: 35449: zval **container; 35450: 35451: SAVE_OPLINE(); 35452: 35453: if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) && 35454: IS_CV != IS_CV && 35455: EX_T(opline->op1.var).var.ptr_ptr) { 35456: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 35457: } 35458: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 35459: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); 35460: 35461: 35462: CHECK_EXCEPTION(); 35463: ZEND_VM_NEXT_OPCODE(); 35464: } 35465: 35466: static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35467: { 35468: USE_OPLINE 35469: zend_free_op free_op1; 35470: zval **container; 35471: 35472: SAVE_OPLINE(); 35473: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35474: 35475: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35476: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35477: } 35478: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); 35479: 35480: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35481: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35482: } 35483: 35484: /* We are going to assign the result by reference */ 35485: if (UNEXPECTED(opline->extended_value != 0)) { 35486: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 35487: 35488: if (retval_ptr) { 35489: Z_DELREF_PP(retval_ptr); 35490: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 35491: Z_ADDREF_PP(retval_ptr); 35492: } 35493: } 35494: 35495: CHECK_EXCEPTION(); 35496: ZEND_VM_NEXT_OPCODE(); 35497: } 35498: 35499: static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35500: { 35501: USE_OPLINE 35502: zend_free_op free_op1; 35503: zval **container; 35504: 35505: SAVE_OPLINE(); 35506: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 35507: 35508: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35509: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35510: } 35511: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC); 35512: 35513: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35514: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35515: } 35516: 35517: CHECK_EXCEPTION(); 35518: ZEND_VM_NEXT_OPCODE(); 35519: } 35520: 35521: static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35522: { 35523: USE_OPLINE 35524: 35525: zval **container; 35526: 35527: SAVE_OPLINE(); 35528: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 35529: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC); 35530: 35531: 35532: CHECK_EXCEPTION(); 35533: ZEND_VM_NEXT_OPCODE(); 35534: } 35535: 35536: static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35537: { 35538: USE_OPLINE 35539: zend_free_op free_op1; 35540: zval **container; 35541: 35542: SAVE_OPLINE(); 35543: 35544: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 35545: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35546: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35547: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35548: } 35549: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); 35550: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35551: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35552: } 35553: } else { 35554: if (IS_CV == IS_UNUSED) { 35555: zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); 35556: } 35557: container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 35558: zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); 35559: } 35560: 35561: 35562: CHECK_EXCEPTION(); 35563: ZEND_VM_NEXT_OPCODE(); 35564: } 35565: 35566: static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35567: { 35568: USE_OPLINE 35569: zend_free_op free_op1; 35570: zval **container; 35571: 35572: SAVE_OPLINE(); 35573: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 35574: 35575: if (IS_CV == IS_CV) { 35576: if (container != &EG(uninitialized_zval_ptr)) { 35577: SEPARATE_ZVAL_IF_NOT_REF(container); 35578: } 35579: } 35580: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35581: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35582: } 35583: zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC); 35584: 35585: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35586: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35587: } 35588: 35589: if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { 35590: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 35591: } else { 35592: zend_free_op free_res; 35593: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 35594: 35595: PZVAL_UNLOCK(*retval_ptr, &free_res); 35596: if (retval_ptr != &EG(uninitialized_zval_ptr)) { 35597: SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); 35598: } 35599: PZVAL_LOCK(*retval_ptr); 35600: FREE_OP_VAR_PTR(free_res); 35601: CHECK_EXCEPTION(); 35602: ZEND_VM_NEXT_OPCODE(); 35603: } 35604: } 35605: 35606: static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS) 35607: { 35608: USE_OPLINE 35609: 35610: zval *container; 35611: 35612: zval *offset; 35613: 35614: SAVE_OPLINE(); 35615: container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 35616: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35617: 35618: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 35619: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 35620: zend_error(E_NOTICE, "Trying to get property of non-object"); 35621: PZVAL_LOCK(&EG(uninitialized_zval)); 35622: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35623: 35624: } else { 35625: zval *retval; 35626: 35627: if (0) { 35628: MAKE_REAL_ZVAL_PTR(offset); 35629: } 35630: 35631: /* here we are sure we are dealing with an object */ 35632: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35633: 35634: PZVAL_LOCK(retval); 35635: AI_SET_PTR(&EX_T(opline->result.var), retval); 35636: 35637: if (0) { 35638: zval_ptr_dtor(&offset); 35639: } else { 35640: 35641: } 35642: } 35643: 35644: CHECK_EXCEPTION(); 35645: ZEND_VM_NEXT_OPCODE(); 35646: } 35647: 35648: static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35649: { 35650: return zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35651: } 35652: 35653: static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35654: { 35655: USE_OPLINE 35656: zend_free_op free_op1; 35657: zval *property; 35658: zval **container; 35659: 35660: SAVE_OPLINE(); 35661: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35662: 35663: if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) { 35664: PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); 35665: EX_T(opline->op1.var).var.ptr = *EX_T(opline->op1.var).var.ptr_ptr; 35666: } 35667: 35668: if (0) { 35669: MAKE_REAL_ZVAL_PTR(property); 35670: } 35671: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35672: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35673: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 35674: } 35675: 35676: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 35677: if (0) { 35678: zval_ptr_dtor(&property); 35679: } else { 35680: 35681: } 35682: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35683: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35684: } 35685: 35686: /* We are going to assign the result by reference */ 35687: if (opline->extended_value & ZEND_FETCH_MAKE_REF) { 35688: zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; 35689: 35690: Z_DELREF_PP(retval_ptr); 35691: SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); 35692: Z_ADDREF_PP(retval_ptr); 35693: EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; 35694: EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; 35695: } 35696: 35697: CHECK_EXCEPTION(); 35698: ZEND_VM_NEXT_OPCODE(); 35699: } 35700: 35701: static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35702: { 35703: USE_OPLINE 35704: zend_free_op free_op1; 35705: zval *property; 35706: zval **container; 35707: 35708: SAVE_OPLINE(); 35709: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35710: container = _get_zval_ptr_ptr_cv_BP_VAR_RW(EX_CVs(), opline->op1.var TSRMLS_CC); 35711: 35712: if (0) { 35713: MAKE_REAL_ZVAL_PTR(property); 35714: } 35715: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35716: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 35717: } 35718: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); 35719: if (0) { 35720: zval_ptr_dtor(&property); 35721: } else { 35722: 35723: } 35724: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35725: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35726: } 35727: 35728: CHECK_EXCEPTION(); 35729: ZEND_VM_NEXT_OPCODE(); 35730: } 35731: 35732: static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35733: { 35734: USE_OPLINE 35735: 35736: zval *container; 35737: 35738: zval *offset; 35739: 35740: SAVE_OPLINE(); 35741: container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 35742: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35743: 35744: if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || 35745: UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { 35746: PZVAL_LOCK(&EG(uninitialized_zval)); 35747: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35748: 35749: } else { 35750: zval *retval; 35751: 35752: if (0) { 35753: MAKE_REAL_ZVAL_PTR(offset); 35754: } 35755: 35756: /* here we are sure we are dealing with an object */ 35757: retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35758: 35759: PZVAL_LOCK(retval); 35760: AI_SET_PTR(&EX_T(opline->result.var), retval); 35761: 35762: if (0) { 35763: zval_ptr_dtor(&offset); 35764: } else { 35765: 35766: } 35767: } 35768: 35769: CHECK_EXCEPTION(); 35770: ZEND_VM_NEXT_OPCODE(); 35771: } 35772: 35773: static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35774: { 35775: USE_OPLINE 35776: 35777: if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) { 35778: /* Behave like FETCH_OBJ_W */ 35779: zend_free_op free_op1; 35780: zval *property; 35781: zval **container; 35782: 35783: SAVE_OPLINE(); 35784: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35785: container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35786: 35787: if (0) { 35788: MAKE_REAL_ZVAL_PTR(property); 35789: } 35790: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35791: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 35792: } 35793: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); 35794: if (0) { 35795: zval_ptr_dtor(&property); 35796: } else { 35797: 35798: } 35799: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35800: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35801: } 35802: 35803: CHECK_EXCEPTION(); 35804: ZEND_VM_NEXT_OPCODE(); 35805: } else { 35806: return zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 35807: } 35808: } 35809: 35810: static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35811: { 35812: USE_OPLINE 35813: zend_free_op free_op1, free_res; 35814: zval **container; 35815: zval *property; 35816: 35817: SAVE_OPLINE(); 35818: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 35819: property = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35820: 35821: if (IS_CV == IS_CV) { 35822: if (container != &EG(uninitialized_zval_ptr)) { 35823: SEPARATE_ZVAL_IF_NOT_REF(container); 35824: } 35825: } 35826: if (0) { 35827: MAKE_REAL_ZVAL_PTR(property); 35828: } 35829: if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { 35830: zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); 35831: } 35832: zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); 35833: if (0) { 35834: zval_ptr_dtor(&property); 35835: } else { 35836: 35837: } 35838: if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { 35839: EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); 35840: } 35841: 35842: PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); 35843: if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { 35844: SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); 35845: } 35846: PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); 35847: FREE_OP_VAR_PTR(free_res); 35848: CHECK_EXCEPTION(); 35849: ZEND_VM_NEXT_OPCODE(); 35850: } 35851: 35852: static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35853: { 35854: USE_OPLINE 35855: 35856: zval **object_ptr; 35857: zval *property_name; 35858: 35859: SAVE_OPLINE(); 35860: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35861: property_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35862: 35863: if (0) { 35864: MAKE_REAL_ZVAL_PTR(property_name); 35865: } 35866: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 35867: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35868: } 35869: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35870: if (0) { 35871: zval_ptr_dtor(&property_name); 35872: } else { 35873: 35874: } 35875: 35876: /* assign_obj has two opcodes! */ 35877: CHECK_EXCEPTION(); 35878: ZEND_VM_INC_OPCODE(); 35879: ZEND_VM_NEXT_OPCODE(); 35880: } 35881: 35882: static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35883: { 35884: USE_OPLINE 35885: 35886: zval **object_ptr; 35887: 35888: SAVE_OPLINE(); 35889: object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35890: 35891: if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { 35892: zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); 35893: } 35894: if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { 35895: 35896: zval *property_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35897: 35898: if (0) { 35899: MAKE_REAL_ZVAL_PTR(property_name); 35900: } 35901: zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 35902: if (0) { 35903: zval_ptr_dtor(&property_name); 35904: } else { 35905: 35906: } 35907: } else { 35908: zend_free_op free_op_data1, free_op_data2; 35909: zval *value; 35910: zval *dim = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35911: zval **variable_ptr_ptr; 35912: 35913: zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC); 35914: 35915: value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, EX_Ts(), &free_op_data1, BP_VAR_R); 35916: variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, EX_Ts(), &free_op_data2 TSRMLS_CC); 35917: if (UNEXPECTED(variable_ptr_ptr == NULL)) { 35918: if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { 35919: if (RETURN_VALUE_USED(opline)) { 35920: zval *retval; 35921: 35922: ALLOC_ZVAL(retval); 35923: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); 35924: INIT_PZVAL(retval); 35925: AI_SET_PTR(&EX_T(opline->result.var), retval); 35926: } 35927: } else if (RETURN_VALUE_USED(opline)) { 35928: PZVAL_LOCK(&EG(uninitialized_zval)); 35929: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35930: } 35931: } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 35932: if (IS_TMP_FREE(free_op_data1)) { 35933: zval_dtor(value); 35934: } 35935: if (RETURN_VALUE_USED(opline)) { 35936: PZVAL_LOCK(&EG(uninitialized_zval)); 35937: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35938: } 35939: } else { 35940: if ((opline+1)->op1_type == IS_TMP_VAR) { 35941: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 35942: } else if ((opline+1)->op1_type == IS_CONST) { 35943: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 35944: } else { 35945: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 35946: } 35947: if (RETURN_VALUE_USED(opline)) { 35948: PZVAL_LOCK(value); 35949: AI_SET_PTR(&EX_T(opline->result.var), value); 35950: } 35951: } 35952: FREE_OP_VAR_PTR(free_op_data2); 35953: FREE_OP_IF_VAR(free_op_data1); 35954: } 35955: 35956: /* assign_dim has two opcodes! */ 35957: CHECK_EXCEPTION(); 35958: ZEND_VM_INC_OPCODE(); 35959: ZEND_VM_NEXT_OPCODE(); 35960: } 35961: 35962: static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 35963: { 35964: USE_OPLINE 35965: 35966: zval *value; 35967: zval **variable_ptr_ptr; 35968: 35969: SAVE_OPLINE(); 35970: value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 35971: variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 35972: 35973: if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { 35974: if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) { 35975: if (RETURN_VALUE_USED(opline)) { 35976: zval *retval; 35977: 35978: ALLOC_ZVAL(retval); 35979: ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); 35980: INIT_PZVAL(retval); 35981: AI_SET_PTR(&EX_T(opline->result.var), retval); 35982: } 35983: } else if (RETURN_VALUE_USED(opline)) { 35984: PZVAL_LOCK(&EG(uninitialized_zval)); 35985: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35986: } 35987: } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { 35988: if (0) { 35989: zval_dtor(value); 35990: } 35991: if (RETURN_VALUE_USED(opline)) { 35992: PZVAL_LOCK(&EG(uninitialized_zval)); 35993: AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval)); 35994: } 35995: } else { 35996: if (IS_CV == IS_TMP_VAR) { 35997: value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); 35998: } else if (IS_CV == IS_CONST) { 35999: value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); 36000: } else { 36001: value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); 36002: } 36003: if (RETURN_VALUE_USED(opline)) { 36004: PZVAL_LOCK(value); 36005: AI_SET_PTR(&EX_T(opline->result.var), value); 36006: } 36007: } 36008: 36009: /* zend_assign_to_variable() always takes care of op2, never free it! */ 36010: 36011: CHECK_EXCEPTION(); 36012: ZEND_VM_NEXT_OPCODE(); 36013: } 36014: 36015: static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36016: { 36017: USE_OPLINE 36018: zend_free_op free_op2; 36019: zval **variable_ptr_ptr; 36020: zval **value_ptr_ptr; 36021: 36022: SAVE_OPLINE(); 36023: value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op2.var TSRMLS_CC); 36024: 36025: if (IS_CV == IS_VAR && 36026: value_ptr_ptr && 36027: !Z_ISREF_PP(value_ptr_ptr) && 36028: opline->extended_value == ZEND_RETURNS_FUNCTION && 36029: !EX_T(opline->op2.var).var.fcall_returned_reference) { 36030: if (free_op2.var == NULL) { 36031: PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ 36032: } 36033: zend_error(E_STRICT, "Only variables should be assigned by reference"); 36034: if (UNEXPECTED(EG(exception) != NULL)) { 36035: 36036: HANDLE_EXCEPTION(); 36037: } 36038: return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 36039: } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 36040: PZVAL_LOCK(*value_ptr_ptr); 36041: } 36042: if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { 36043: zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); 36044: } 36045: 36046: variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 36047: if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || 36048: (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { 36049: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); 36050: } 36051: zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); 36052: 36053: if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { 36054: Z_DELREF_PP(variable_ptr_ptr); 36055: } 36056: 36057: if (RETURN_VALUE_USED(opline)) { 36058: PZVAL_LOCK(*variable_ptr_ptr); 36059: AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr); 36060: } 36061: 36062: 36063: CHECK_EXCEPTION(); 36064: ZEND_VM_NEXT_OPCODE(); 36065: } 36066: 36067: static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36068: { 36069: USE_OPLINE 36070: zval *function_name; 36071: char *function_name_strval; 36072: int function_name_strlen; 36073: 36074: 36075: SAVE_OPLINE(); 36076: zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); 36077: 36078: function_name = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 36079: 36080: if (IS_CV != IS_CONST && 36081: UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { 36082: zend_error_noreturn(E_ERROR, "Method name must be a string"); 36083: } 36084: 36085: function_name_strval = Z_STRVAL_P(function_name); 36086: function_name_strlen = Z_STRLEN_P(function_name); 36087: 36088: EX(object) = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 36089: 36090: if (EXPECTED(EX(object) != NULL) && 36091: EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { 36092: EX(called_scope) = Z_OBJCE_P(EX(object)); 36093: 36094: if (IS_CV != IS_CONST || 36095: (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { 36096: zval *object = EX(object); 36097: 36098: if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { 36099: zend_error_noreturn(E_ERROR, "Object does not support method calls"); 36100: } 36101: 36102: /* First, locate the function. */ 36103: EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); 36104: if (UNEXPECTED(EX(fbc) == NULL)) { 36105: zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); 36106: } 36107: if (IS_CV == IS_CONST && 36108: EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && 36109: EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && 36110: EXPECTED(EX(object) == object)) { 36111: CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); 36112: } 36113: } 36114: } else { 36115: zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); 36116: } 36117: 36118: if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { 36119: EX(object) = NULL; 36120: } else { 36121: if (!PZVAL_IS_REF(EX(object))) { 36122: Z_ADDREF_P(EX(object)); /* For $this pointer */ 36123: } else { 36124: zval *this_ptr; 36125: ALLOC_ZVAL(this_ptr); 36126: INIT_PZVAL_COPY(this_ptr, EX(object)); 36127: zval_copy_ctor(this_ptr); 36128: EX(object) = this_ptr; 36129: } 36130: } 36131: 36132: 36133: CHECK_EXCEPTION(); 36134: ZEND_VM_NEXT_OPCODE(); 36135: } 36136: 36137: static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36138: { 36139: USE_OPLINE 36140: 36141: 36142: SAVE_OPLINE(); 36143: if (IS_CV==IS_VAR) { 36144: PZVAL_LOCK(EX_T(opline->op1.var).var.ptr); 36145: } 36146: is_equal_function(&EX_T(opline->result.var).tmp_var, 36147: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC), 36148: _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC) TSRMLS_CC); 36149: 36150: CHECK_EXCEPTION(); 36151: ZEND_VM_NEXT_OPCODE(); 36152: } 36153: 36154: static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36155: { 36156: USE_OPLINE 36157: 36158: zval *expr_ptr; 36159: 36160: SAVE_OPLINE(); 36161: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 36162: zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC); 36163: 36164: if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { 36165: zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); 36166: } 36167: SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); 36168: expr_ptr = *expr_ptr_ptr; 36169: Z_ADDREF_P(expr_ptr); 36170: } else { 36171: expr_ptr=_get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC); 36172: if (0) { /* temporary variable */ 36173: zval *new_expr; 36174: 36175: ALLOC_ZVAL(new_expr); 36176: INIT_PZVAL_COPY(new_expr, expr_ptr); 36177: expr_ptr = new_expr; 36178: } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { 36179: zval *new_expr; 36180: 36181: ALLOC_ZVAL(new_expr); 36182: INIT_PZVAL_COPY(new_expr, expr_ptr); 36183: expr_ptr = new_expr; 36184: zendi_zval_copy_ctor(*expr_ptr); 36185: } else { 36186: Z_ADDREF_P(expr_ptr); 36187: } 36188: } 36189: 36190: if (IS_CV != IS_UNUSED) { 36191: 36192: zval *offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 36193: ulong hval; 36194: 36195: switch (Z_TYPE_P(offset)) { 36196: case IS_DOUBLE: 36197: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 36198: goto num_index; 36199: case IS_LONG: 36200: case IS_BOOL: 36201: hval = Z_LVAL_P(offset); 36202: num_index: 36203: zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); 36204: break; 36205: case IS_STRING: 36206: if (IS_CV == IS_CONST) { 36207: hval = Z_HASH_P(offset); 36208: } else { 36209: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); 36210: if (IS_INTERNED(Z_STRVAL_P(offset))) { 36211: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 36212: } else { 36213: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 36214: } 36215: } 36216: zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); 36217: break; 36218: case IS_NULL: 36219: zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); 36220: break; 36221: default: 36222: zend_error(E_WARNING, "Illegal offset type"); 36223: zval_ptr_dtor(&expr_ptr); 36224: /* do nothing */ 36225: break; 36226: } 36227: 36228: } else { 36229: zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); 36230: } 36231: if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { 36232: 36233: } else { 36234: 36235: } 36236: CHECK_EXCEPTION(); 36237: ZEND_VM_NEXT_OPCODE(); 36238: } 36239: 36240: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36241: { 36242: USE_OPLINE 36243: 36244: array_init(&EX_T(opline->result.var).tmp_var); 36245: if (IS_CV == IS_UNUSED) { 36246: ZEND_VM_NEXT_OPCODE(); 36247: #if 0 || IS_CV != IS_UNUSED 36248: } else { 36249: return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 36250: #endif 36251: } 36252: } 36253: 36254: static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36255: { 36256: USE_OPLINE 36257: 36258: zval **container; 36259: zval *offset; 36260: ulong hval; 36261: 36262: SAVE_OPLINE(); 36263: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 36264: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 36265: SEPARATE_ZVAL_IF_NOT_REF(container); 36266: } 36267: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 36268: 36269: if (IS_CV != IS_VAR || container) { 36270: switch (Z_TYPE_PP(container)) { 36271: case IS_ARRAY: { 36272: HashTable *ht = Z_ARRVAL_PP(container); 36273: 36274: switch (Z_TYPE_P(offset)) { 36275: case IS_DOUBLE: 36276: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 36277: zend_hash_index_del(ht, hval); 36278: break; 36279: case IS_RESOURCE: 36280: case IS_BOOL: 36281: case IS_LONG: 36282: hval = Z_LVAL_P(offset); 36283: zend_hash_index_del(ht, hval); 36284: break; 36285: case IS_STRING: 36286: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 36287: Z_ADDREF_P(offset); 36288: } 36289: if (IS_CV == IS_CONST) { 36290: hval = Z_HASH_P(offset); 36291: } else { 36292: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); 36293: if (IS_INTERNED(Z_STRVAL_P(offset))) { 36294: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 36295: } else { 36296: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 36297: } 36298: } 36299: if (ht == &EG(symbol_table)) { 36300: zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); 36301: } else { 36302: zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); 36303: } 36304: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 36305: zval_ptr_dtor(&offset); 36306: } 36307: break; 36308: num_index_dim: 36309: zend_hash_index_del(ht, hval); 36310: if (IS_CV == IS_CV || IS_CV == IS_VAR) { 36311: zval_ptr_dtor(&offset); 36312: } 36313: break; 36314: case IS_NULL: 36315: zend_hash_del(ht, "", sizeof("")); 36316: break; 36317: default: 36318: zend_error(E_WARNING, "Illegal offset type in unset"); 36319: break; 36320: } 36321: 36322: break; 36323: } 36324: case IS_OBJECT: 36325: if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { 36326: zend_error_noreturn(E_ERROR, "Cannot use object as array"); 36327: } 36328: if (0) { 36329: MAKE_REAL_ZVAL_PTR(offset); 36330: } 36331: Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); 36332: if (0) { 36333: zval_ptr_dtor(&offset); 36334: } else { 36335: 36336: } 36337: break; 36338: case IS_STRING: 36339: zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); 36340: ZEND_VM_CONTINUE(); /* bailed out before */ 36341: default: 36342: 36343: break; 36344: } 36345: } else { 36346: 36347: } 36348: 36349: CHECK_EXCEPTION(); 36350: ZEND_VM_NEXT_OPCODE(); 36351: } 36352: 36353: static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36354: { 36355: USE_OPLINE 36356: 36357: zval **container; 36358: zval *offset; 36359: 36360: SAVE_OPLINE(); 36361: container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(EX_CVs(), opline->op1.var TSRMLS_CC); 36362: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 36363: 36364: if (IS_CV != IS_VAR || container) { 36365: if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { 36366: SEPARATE_ZVAL_IF_NOT_REF(container); 36367: } 36368: if (Z_TYPE_PP(container) == IS_OBJECT) { 36369: if (0) { 36370: MAKE_REAL_ZVAL_PTR(offset); 36371: } 36372: if (Z_OBJ_HT_P(*container)->unset_property) { 36373: Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 36374: } else { 36375: zend_error(E_NOTICE, "Trying to unset property of non-object"); 36376: } 36377: if (0) { 36378: zval_ptr_dtor(&offset); 36379: } else { 36380: 36381: } 36382: } else { 36383: 36384: } 36385: } else { 36386: 36387: } 36388: 36389: CHECK_EXCEPTION(); 36390: ZEND_VM_NEXT_OPCODE(); 36391: } 36392: 36393: static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) 36394: { 36395: USE_OPLINE 36396: 36397: zval **container; 36398: zval **value = NULL; 36399: int result = 0; 36400: ulong hval; 36401: zval *offset; 36402: 36403: SAVE_OPLINE(); 36404: container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC); 36405: 36406: offset = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC); 36407: 36408: if (Z_TYPE_PP(container) == IS_ARRAY && !prop_dim) { 36409: HashTable *ht; 36410: int isset = 0; 36411: 36412: ht = Z_ARRVAL_PP(container); 36413: 36414: switch (Z_TYPE_P(offset)) { 36415: case IS_DOUBLE: 36416: hval = zend_dval_to_lval(Z_DVAL_P(offset)); 36417: goto num_index_prop; 36418: case IS_RESOURCE: 36419: case IS_BOOL: 36420: case IS_LONG: 36421: hval = Z_LVAL_P(offset); 36422: num_index_prop: 36423: if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { 36424: isset = 1; 36425: } 36426: break; 36427: case IS_STRING: 36428: if (IS_CV == IS_CONST) { 36429: hval = Z_HASH_P(offset); 36430: } else { 36431: if (!prop_dim) { 36432: ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); 36433: } 36434: if (IS_INTERNED(Z_STRVAL_P(offset))) { 36435: hval = INTERNED_HASH(Z_STRVAL_P(offset)); 36436: } else { 36437: hval = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); 36438: } 36439: } 36440: if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { 36441: isset = 1; 36442: } 36443: break; 36444: case IS_NULL: 36445: if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { 36446: isset = 1; 36447: } 36448: break; 36449: default: 36450: zend_error(E_WARNING, "Illegal offset type in isset or empty"); 36451: break; 36452: } 36453: 36454: if (opline->extended_value & ZEND_ISSET) { 36455: if (isset && Z_TYPE_PP(value) == IS_NULL) { 36456: result = 0; 36457: } else { 36458: result = isset; 36459: } 36460: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 36461: if (!isset || !i_zend_is_true(*value)) { 36462: result = 0; 36463: } else { 36464: result = 1; 36465: } 36466: } 36467: 36468: } else if (Z_TYPE_PP(container) == IS_OBJECT) { 36469: if (0) { 36470: MAKE_REAL_ZVAL_PTR(offset); 36471: } 36472: if (prop_dim) { 36473: if (Z_OBJ_HT_P(*container)->has_property) { 36474: result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); 36475: } else { 36476: zend_error(E_NOTICE, "Trying to check property of non-object"); 36477: result = 0; 36478: } 36479: } else { 36480: if (Z_OBJ_HT_P(*container)->has_dimension) { 36481: result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); 36482: } else { 36483: zend_error(E_NOTICE, "Trying to check element of non-array"); 36484: result = 0; 36485: } 36486: } 36487: if (0) { 36488: zval_ptr_dtor(&offset); 36489: } else { 36490: 36491: } 36492: } else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */ 36493: zval tmp; 36494: 36495: if (Z_TYPE_P(offset) != IS_LONG) { 36496: if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ 36497: || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ 36498: && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { 36499: ZVAL_COPY_VALUE(&tmp, offset); 36500: zval_copy_ctor(&tmp); 36501: convert_to_long(&tmp); 36502: offset = &tmp; 36503: } else { 36504: /* can not be converted to proper offset, return "not set" */ 36505: result = 0; 36506: } 36507: } 36508: if (Z_TYPE_P(offset) == IS_LONG) { 36509: if (opline->extended_value & ZEND_ISSET) { 36510: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container)) { 36511: result = 1; 36512: } 36513: } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { 36514: if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_PP(container) && Z_STRVAL_PP(container)[offset->value.lval] != '0') { 36515: result = 1; 36516: } 36517: } 36518: } 36519: 36520: } else { 36521: 36522: } 36523: 36524: Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; 36525: if (opline->extended_value & ZEND_ISSET) { 36526: Z_LVAL(EX_T(opline->result.var).tmp_var) = result; 36527: } else { 36528: Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; 36529: } 36530: 36531: CHECK_EXCEPTION(); 36532: ZEND_VM_NEXT_OPCODE(); 36533: } 36534: 36535: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36536: { 36537: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 36538: } 36539: 36540: static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36541: { 36542: return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 36543: } 36544: 36545: static int ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) 36546: { 36547: zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type); 36548: } 36549: 36550: 36551: void zend_init_opcodes_handlers(void) 36552: { 36553: static const opcode_handler_t labels[] = { 36554: ZEND_NOP_SPEC_HANDLER, 36555: ZEND_NOP_SPEC_HANDLER, 36556: ZEND_NOP_SPEC_HANDLER, 36557: ZEND_NOP_SPEC_HANDLER, 36558: ZEND_NOP_SPEC_HANDLER, 36559: ZEND_NOP_SPEC_HANDLER, 36560: ZEND_NOP_SPEC_HANDLER, 36561: ZEND_NOP_SPEC_HANDLER, 36562: ZEND_NOP_SPEC_HANDLER, 36563: ZEND_NOP_SPEC_HANDLER, 36564: ZEND_NOP_SPEC_HANDLER, 36565: ZEND_NOP_SPEC_HANDLER, 36566: ZEND_NOP_SPEC_HANDLER, 36567: ZEND_NOP_SPEC_HANDLER, 36568: ZEND_NOP_SPEC_HANDLER, 36569: ZEND_NOP_SPEC_HANDLER, 36570: ZEND_NOP_SPEC_HANDLER, 36571: ZEND_NOP_SPEC_HANDLER, 36572: ZEND_NOP_SPEC_HANDLER, 36573: ZEND_NOP_SPEC_HANDLER, 36574: ZEND_NOP_SPEC_HANDLER, 36575: ZEND_NOP_SPEC_HANDLER, 36576: ZEND_NOP_SPEC_HANDLER, 36577: ZEND_NOP_SPEC_HANDLER, 36578: ZEND_NOP_SPEC_HANDLER, 36579: ZEND_ADD_SPEC_CONST_CONST_HANDLER, 36580: ZEND_ADD_SPEC_CONST_TMP_HANDLER, 36581: ZEND_ADD_SPEC_CONST_VAR_HANDLER, 36582: ZEND_NULL_HANDLER, 36583: ZEND_ADD_SPEC_CONST_CV_HANDLER, 36584: ZEND_ADD_SPEC_TMP_CONST_HANDLER, 36585: ZEND_ADD_SPEC_TMP_TMP_HANDLER, 36586: ZEND_ADD_SPEC_TMP_VAR_HANDLER, 36587: ZEND_NULL_HANDLER, 36588: ZEND_ADD_SPEC_TMP_CV_HANDLER, 36589: ZEND_ADD_SPEC_VAR_CONST_HANDLER, 36590: ZEND_ADD_SPEC_VAR_TMP_HANDLER, 36591: ZEND_ADD_SPEC_VAR_VAR_HANDLER, 36592: ZEND_NULL_HANDLER, 36593: ZEND_ADD_SPEC_VAR_CV_HANDLER, 36594: ZEND_NULL_HANDLER, 36595: ZEND_NULL_HANDLER, 36596: ZEND_NULL_HANDLER, 36597: ZEND_NULL_HANDLER, 36598: ZEND_NULL_HANDLER, 36599: ZEND_ADD_SPEC_CV_CONST_HANDLER, 36600: ZEND_ADD_SPEC_CV_TMP_HANDLER, 36601: ZEND_ADD_SPEC_CV_VAR_HANDLER, 36602: ZEND_NULL_HANDLER, 36603: ZEND_ADD_SPEC_CV_CV_HANDLER, 36604: ZEND_SUB_SPEC_CONST_CONST_HANDLER, 36605: ZEND_SUB_SPEC_CONST_TMP_HANDLER, 36606: ZEND_SUB_SPEC_CONST_VAR_HANDLER, 36607: ZEND_NULL_HANDLER, 36608: ZEND_SUB_SPEC_CONST_CV_HANDLER, 36609: ZEND_SUB_SPEC_TMP_CONST_HANDLER, 36610: ZEND_SUB_SPEC_TMP_TMP_HANDLER, 36611: ZEND_SUB_SPEC_TMP_VAR_HANDLER, 36612: ZEND_NULL_HANDLER, 36613: ZEND_SUB_SPEC_TMP_CV_HANDLER, 36614: ZEND_SUB_SPEC_VAR_CONST_HANDLER, 36615: ZEND_SUB_SPEC_VAR_TMP_HANDLER, 36616: ZEND_SUB_SPEC_VAR_VAR_HANDLER, 36617: ZEND_NULL_HANDLER, 36618: ZEND_SUB_SPEC_VAR_CV_HANDLER, 36619: ZEND_NULL_HANDLER, 36620: ZEND_NULL_HANDLER, 36621: ZEND_NULL_HANDLER, 36622: ZEND_NULL_HANDLER, 36623: ZEND_NULL_HANDLER, 36624: ZEND_SUB_SPEC_CV_CONST_HANDLER, 36625: ZEND_SUB_SPEC_CV_TMP_HANDLER, 36626: ZEND_SUB_SPEC_CV_VAR_HANDLER, 36627: ZEND_NULL_HANDLER, 36628: ZEND_SUB_SPEC_CV_CV_HANDLER, 36629: ZEND_MUL_SPEC_CONST_CONST_HANDLER, 36630: ZEND_MUL_SPEC_CONST_TMP_HANDLER, 36631: ZEND_MUL_SPEC_CONST_VAR_HANDLER, 36632: ZEND_NULL_HANDLER, 36633: ZEND_MUL_SPEC_CONST_CV_HANDLER, 36634: ZEND_MUL_SPEC_TMP_CONST_HANDLER, 36635: ZEND_MUL_SPEC_TMP_TMP_HANDLER, 36636: ZEND_MUL_SPEC_TMP_VAR_HANDLER, 36637: ZEND_NULL_HANDLER, 36638: ZEND_MUL_SPEC_TMP_CV_HANDLER, 36639: ZEND_MUL_SPEC_VAR_CONST_HANDLER, 36640: ZEND_MUL_SPEC_VAR_TMP_HANDLER, 36641: ZEND_MUL_SPEC_VAR_VAR_HANDLER, 36642: ZEND_NULL_HANDLER, 36643: ZEND_MUL_SPEC_VAR_CV_HANDLER, 36644: ZEND_NULL_HANDLER, 36645: ZEND_NULL_HANDLER, 36646: ZEND_NULL_HANDLER, 36647: ZEND_NULL_HANDLER, 36648: ZEND_NULL_HANDLER, 36649: ZEND_MUL_SPEC_CV_CONST_HANDLER, 36650: ZEND_MUL_SPEC_CV_TMP_HANDLER, 36651: ZEND_MUL_SPEC_CV_VAR_HANDLER, 36652: ZEND_NULL_HANDLER, 36653: ZEND_MUL_SPEC_CV_CV_HANDLER, 36654: ZEND_DIV_SPEC_CONST_CONST_HANDLER, 36655: ZEND_DIV_SPEC_CONST_TMP_HANDLER, 36656: ZEND_DIV_SPEC_CONST_VAR_HANDLER, 36657: ZEND_NULL_HANDLER, 36658: ZEND_DIV_SPEC_CONST_CV_HANDLER, 36659: ZEND_DIV_SPEC_TMP_CONST_HANDLER, 36660: ZEND_DIV_SPEC_TMP_TMP_HANDLER, 36661: ZEND_DIV_SPEC_TMP_VAR_HANDLER, 36662: ZEND_NULL_HANDLER, 36663: ZEND_DIV_SPEC_TMP_CV_HANDLER, 36664: ZEND_DIV_SPEC_VAR_CONST_HANDLER, 36665: ZEND_DIV_SPEC_VAR_TMP_HANDLER, 36666: ZEND_DIV_SPEC_VAR_VAR_HANDLER, 36667: ZEND_NULL_HANDLER, 36668: ZEND_DIV_SPEC_VAR_CV_HANDLER, 36669: ZEND_NULL_HANDLER, 36670: ZEND_NULL_HANDLER, 36671: ZEND_NULL_HANDLER, 36672: ZEND_NULL_HANDLER, 36673: ZEND_NULL_HANDLER, 36674: ZEND_DIV_SPEC_CV_CONST_HANDLER, 36675: ZEND_DIV_SPEC_CV_TMP_HANDLER, 36676: ZEND_DIV_SPEC_CV_VAR_HANDLER, 36677: ZEND_NULL_HANDLER, 36678: ZEND_DIV_SPEC_CV_CV_HANDLER, 36679: ZEND_MOD_SPEC_CONST_CONST_HANDLER, 36680: ZEND_MOD_SPEC_CONST_TMP_HANDLER, 36681: ZEND_MOD_SPEC_CONST_VAR_HANDLER, 36682: ZEND_NULL_HANDLER, 36683: ZEND_MOD_SPEC_CONST_CV_HANDLER, 36684: ZEND_MOD_SPEC_TMP_CONST_HANDLER, 36685: ZEND_MOD_SPEC_TMP_TMP_HANDLER, 36686: ZEND_MOD_SPEC_TMP_VAR_HANDLER, 36687: ZEND_NULL_HANDLER, 36688: ZEND_MOD_SPEC_TMP_CV_HANDLER, 36689: ZEND_MOD_SPEC_VAR_CONST_HANDLER, 36690: ZEND_MOD_SPEC_VAR_TMP_HANDLER, 36691: ZEND_MOD_SPEC_VAR_VAR_HANDLER, 36692: ZEND_NULL_HANDLER, 36693: ZEND_MOD_SPEC_VAR_CV_HANDLER, 36694: ZEND_NULL_HANDLER, 36695: ZEND_NULL_HANDLER, 36696: ZEND_NULL_HANDLER, 36697: ZEND_NULL_HANDLER, 36698: ZEND_NULL_HANDLER, 36699: ZEND_MOD_SPEC_CV_CONST_HANDLER, 36700: ZEND_MOD_SPEC_CV_TMP_HANDLER, 36701: ZEND_MOD_SPEC_CV_VAR_HANDLER, 36702: ZEND_NULL_HANDLER, 36703: ZEND_MOD_SPEC_CV_CV_HANDLER, 36704: ZEND_SL_SPEC_CONST_CONST_HANDLER, 36705: ZEND_SL_SPEC_CONST_TMP_HANDLER, 36706: ZEND_SL_SPEC_CONST_VAR_HANDLER, 36707: ZEND_NULL_HANDLER, 36708: ZEND_SL_SPEC_CONST_CV_HANDLER, 36709: ZEND_SL_SPEC_TMP_CONST_HANDLER, 36710: ZEND_SL_SPEC_TMP_TMP_HANDLER, 36711: ZEND_SL_SPEC_TMP_VAR_HANDLER, 36712: ZEND_NULL_HANDLER, 36713: ZEND_SL_SPEC_TMP_CV_HANDLER, 36714: ZEND_SL_SPEC_VAR_CONST_HANDLER, 36715: ZEND_SL_SPEC_VAR_TMP_HANDLER, 36716: ZEND_SL_SPEC_VAR_VAR_HANDLER, 36717: ZEND_NULL_HANDLER, 36718: ZEND_SL_SPEC_VAR_CV_HANDLER, 36719: ZEND_NULL_HANDLER, 36720: ZEND_NULL_HANDLER, 36721: ZEND_NULL_HANDLER, 36722: ZEND_NULL_HANDLER, 36723: ZEND_NULL_HANDLER, 36724: ZEND_SL_SPEC_CV_CONST_HANDLER, 36725: ZEND_SL_SPEC_CV_TMP_HANDLER, 36726: ZEND_SL_SPEC_CV_VAR_HANDLER, 36727: ZEND_NULL_HANDLER, 36728: ZEND_SL_SPEC_CV_CV_HANDLER, 36729: ZEND_SR_SPEC_CONST_CONST_HANDLER, 36730: ZEND_SR_SPEC_CONST_TMP_HANDLER, 36731: ZEND_SR_SPEC_CONST_VAR_HANDLER, 36732: ZEND_NULL_HANDLER, 36733: ZEND_SR_SPEC_CONST_CV_HANDLER, 36734: ZEND_SR_SPEC_TMP_CONST_HANDLER, 36735: ZEND_SR_SPEC_TMP_TMP_HANDLER, 36736: ZEND_SR_SPEC_TMP_VAR_HANDLER, 36737: ZEND_NULL_HANDLER, 36738: ZEND_SR_SPEC_TMP_CV_HANDLER, 36739: ZEND_SR_SPEC_VAR_CONST_HANDLER, 36740: ZEND_SR_SPEC_VAR_TMP_HANDLER, 36741: ZEND_SR_SPEC_VAR_VAR_HANDLER, 36742: ZEND_NULL_HANDLER, 36743: ZEND_SR_SPEC_VAR_CV_HANDLER, 36744: ZEND_NULL_HANDLER, 36745: ZEND_NULL_HANDLER, 36746: ZEND_NULL_HANDLER, 36747: ZEND_NULL_HANDLER, 36748: ZEND_NULL_HANDLER, 36749: ZEND_SR_SPEC_CV_CONST_HANDLER, 36750: ZEND_SR_SPEC_CV_TMP_HANDLER, 36751: ZEND_SR_SPEC_CV_VAR_HANDLER, 36752: ZEND_NULL_HANDLER, 36753: ZEND_SR_SPEC_CV_CV_HANDLER, 36754: ZEND_CONCAT_SPEC_CONST_CONST_HANDLER, 36755: ZEND_CONCAT_SPEC_CONST_TMP_HANDLER, 36756: ZEND_CONCAT_SPEC_CONST_VAR_HANDLER, 36757: ZEND_NULL_HANDLER, 36758: ZEND_CONCAT_SPEC_CONST_CV_HANDLER, 36759: ZEND_CONCAT_SPEC_TMP_CONST_HANDLER, 36760: ZEND_CONCAT_SPEC_TMP_TMP_HANDLER, 36761: ZEND_CONCAT_SPEC_TMP_VAR_HANDLER, 36762: ZEND_NULL_HANDLER, 36763: ZEND_CONCAT_SPEC_TMP_CV_HANDLER, 36764: ZEND_CONCAT_SPEC_VAR_CONST_HANDLER, 36765: ZEND_CONCAT_SPEC_VAR_TMP_HANDLER, 36766: ZEND_CONCAT_SPEC_VAR_VAR_HANDLER, 36767: ZEND_NULL_HANDLER, 36768: ZEND_CONCAT_SPEC_VAR_CV_HANDLER, 36769: ZEND_NULL_HANDLER, 36770: ZEND_NULL_HANDLER, 36771: ZEND_NULL_HANDLER, 36772: ZEND_NULL_HANDLER, 36773: ZEND_NULL_HANDLER, 36774: ZEND_CONCAT_SPEC_CV_CONST_HANDLER, 36775: ZEND_CONCAT_SPEC_CV_TMP_HANDLER, 36776: ZEND_CONCAT_SPEC_CV_VAR_HANDLER, 36777: ZEND_NULL_HANDLER, 36778: ZEND_CONCAT_SPEC_CV_CV_HANDLER, 36779: ZEND_BW_OR_SPEC_CONST_CONST_HANDLER, 36780: ZEND_BW_OR_SPEC_CONST_TMP_HANDLER, 36781: ZEND_BW_OR_SPEC_CONST_VAR_HANDLER, 36782: ZEND_NULL_HANDLER, 36783: ZEND_BW_OR_SPEC_CONST_CV_HANDLER, 36784: ZEND_BW_OR_SPEC_TMP_CONST_HANDLER, 36785: ZEND_BW_OR_SPEC_TMP_TMP_HANDLER, 36786: ZEND_BW_OR_SPEC_TMP_VAR_HANDLER, 36787: ZEND_NULL_HANDLER, 36788: ZEND_BW_OR_SPEC_TMP_CV_HANDLER, 36789: ZEND_BW_OR_SPEC_VAR_CONST_HANDLER, 36790: ZEND_BW_OR_SPEC_VAR_TMP_HANDLER, 36791: ZEND_BW_OR_SPEC_VAR_VAR_HANDLER, 36792: ZEND_NULL_HANDLER, 36793: ZEND_BW_OR_SPEC_VAR_CV_HANDLER, 36794: ZEND_NULL_HANDLER, 36795: ZEND_NULL_HANDLER, 36796: ZEND_NULL_HANDLER, 36797: ZEND_NULL_HANDLER, 36798: ZEND_NULL_HANDLER, 36799: ZEND_BW_OR_SPEC_CV_CONST_HANDLER, 36800: ZEND_BW_OR_SPEC_CV_TMP_HANDLER, 36801: ZEND_BW_OR_SPEC_CV_VAR_HANDLER, 36802: ZEND_NULL_HANDLER, 36803: ZEND_BW_OR_SPEC_CV_CV_HANDLER, 36804: ZEND_BW_AND_SPEC_CONST_CONST_HANDLER, 36805: ZEND_BW_AND_SPEC_CONST_TMP_HANDLER, 36806: ZEND_BW_AND_SPEC_CONST_VAR_HANDLER, 36807: ZEND_NULL_HANDLER, 36808: ZEND_BW_AND_SPEC_CONST_CV_HANDLER, 36809: ZEND_BW_AND_SPEC_TMP_CONST_HANDLER, 36810: ZEND_BW_AND_SPEC_TMP_TMP_HANDLER, 36811: ZEND_BW_AND_SPEC_TMP_VAR_HANDLER, 36812: ZEND_NULL_HANDLER, 36813: ZEND_BW_AND_SPEC_TMP_CV_HANDLER, 36814: ZEND_BW_AND_SPEC_VAR_CONST_HANDLER, 36815: ZEND_BW_AND_SPEC_VAR_TMP_HANDLER, 36816: ZEND_BW_AND_SPEC_VAR_VAR_HANDLER, 36817: ZEND_NULL_HANDLER, 36818: ZEND_BW_AND_SPEC_VAR_CV_HANDLER, 36819: ZEND_NULL_HANDLER, 36820: ZEND_NULL_HANDLER, 36821: ZEND_NULL_HANDLER, 36822: ZEND_NULL_HANDLER, 36823: ZEND_NULL_HANDLER, 36824: ZEND_BW_AND_SPEC_CV_CONST_HANDLER, 36825: ZEND_BW_AND_SPEC_CV_TMP_HANDLER, 36826: ZEND_BW_AND_SPEC_CV_VAR_HANDLER, 36827: ZEND_NULL_HANDLER, 36828: ZEND_BW_AND_SPEC_CV_CV_HANDLER, 36829: ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER, 36830: ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER, 36831: ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER, 36832: ZEND_NULL_HANDLER, 36833: ZEND_BW_XOR_SPEC_CONST_CV_HANDLER, 36834: ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER, 36835: ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER, 36836: ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER, 36837: ZEND_NULL_HANDLER, 36838: ZEND_BW_XOR_SPEC_TMP_CV_HANDLER, 36839: ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER, 36840: ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER, 36841: ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER, 36842: ZEND_NULL_HANDLER, 36843: ZEND_BW_XOR_SPEC_VAR_CV_HANDLER, 36844: ZEND_NULL_HANDLER, 36845: ZEND_NULL_HANDLER, 36846: ZEND_NULL_HANDLER, 36847: ZEND_NULL_HANDLER, 36848: ZEND_NULL_HANDLER, 36849: ZEND_BW_XOR_SPEC_CV_CONST_HANDLER, 36850: ZEND_BW_XOR_SPEC_CV_TMP_HANDLER, 36851: ZEND_BW_XOR_SPEC_CV_VAR_HANDLER, 36852: ZEND_NULL_HANDLER, 36853: ZEND_BW_XOR_SPEC_CV_CV_HANDLER, 36854: ZEND_BW_NOT_SPEC_CONST_HANDLER, 36855: ZEND_BW_NOT_SPEC_CONST_HANDLER, 36856: ZEND_BW_NOT_SPEC_CONST_HANDLER, 36857: ZEND_BW_NOT_SPEC_CONST_HANDLER, 36858: ZEND_BW_NOT_SPEC_CONST_HANDLER, 36859: ZEND_BW_NOT_SPEC_TMP_HANDLER, 36860: ZEND_BW_NOT_SPEC_TMP_HANDLER, 36861: ZEND_BW_NOT_SPEC_TMP_HANDLER, 36862: ZEND_BW_NOT_SPEC_TMP_HANDLER, 36863: ZEND_BW_NOT_SPEC_TMP_HANDLER, 36864: ZEND_BW_NOT_SPEC_VAR_HANDLER, 36865: ZEND_BW_NOT_SPEC_VAR_HANDLER, 36866: ZEND_BW_NOT_SPEC_VAR_HANDLER, 36867: ZEND_BW_NOT_SPEC_VAR_HANDLER, 36868: ZEND_BW_NOT_SPEC_VAR_HANDLER, 36869: ZEND_NULL_HANDLER, 36870: ZEND_NULL_HANDLER, 36871: ZEND_NULL_HANDLER, 36872: ZEND_NULL_HANDLER, 36873: ZEND_NULL_HANDLER, 36874: ZEND_BW_NOT_SPEC_CV_HANDLER, 36875: ZEND_BW_NOT_SPEC_CV_HANDLER, 36876: ZEND_BW_NOT_SPEC_CV_HANDLER, 36877: ZEND_BW_NOT_SPEC_CV_HANDLER, 36878: ZEND_BW_NOT_SPEC_CV_HANDLER, 36879: ZEND_BOOL_NOT_SPEC_CONST_HANDLER, 36880: ZEND_BOOL_NOT_SPEC_CONST_HANDLER, 36881: ZEND_BOOL_NOT_SPEC_CONST_HANDLER, 36882: ZEND_BOOL_NOT_SPEC_CONST_HANDLER, 36883: ZEND_BOOL_NOT_SPEC_CONST_HANDLER, 36884: ZEND_BOOL_NOT_SPEC_TMP_HANDLER, 36885: ZEND_BOOL_NOT_SPEC_TMP_HANDLER, 36886: ZEND_BOOL_NOT_SPEC_TMP_HANDLER, 36887: ZEND_BOOL_NOT_SPEC_TMP_HANDLER, 36888: ZEND_BOOL_NOT_SPEC_TMP_HANDLER, 36889: ZEND_BOOL_NOT_SPEC_VAR_HANDLER, 36890: ZEND_BOOL_NOT_SPEC_VAR_HANDLER, 36891: ZEND_BOOL_NOT_SPEC_VAR_HANDLER, 36892: ZEND_BOOL_NOT_SPEC_VAR_HANDLER, 36893: ZEND_BOOL_NOT_SPEC_VAR_HANDLER, 36894: ZEND_NULL_HANDLER, 36895: ZEND_NULL_HANDLER, 36896: ZEND_NULL_HANDLER, 36897: ZEND_NULL_HANDLER, 36898: ZEND_NULL_HANDLER, 36899: ZEND_BOOL_NOT_SPEC_CV_HANDLER, 36900: ZEND_BOOL_NOT_SPEC_CV_HANDLER, 36901: ZEND_BOOL_NOT_SPEC_CV_HANDLER, 36902: ZEND_BOOL_NOT_SPEC_CV_HANDLER, 36903: ZEND_BOOL_NOT_SPEC_CV_HANDLER, 36904: ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER, 36905: ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER, 36906: ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER, 36907: ZEND_NULL_HANDLER, 36908: ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER, 36909: ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER, 36910: ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER, 36911: ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER, 36912: ZEND_NULL_HANDLER, 36913: ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER, 36914: ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER, 36915: ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER, 36916: ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER, 36917: ZEND_NULL_HANDLER, 36918: ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER, 36919: ZEND_NULL_HANDLER, 36920: ZEND_NULL_HANDLER, 36921: ZEND_NULL_HANDLER, 36922: ZEND_NULL_HANDLER, 36923: ZEND_NULL_HANDLER, 36924: ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER, 36925: ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER, 36926: ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER, 36927: ZEND_NULL_HANDLER, 36928: ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER, 36929: ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER, 36930: ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER, 36931: ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER, 36932: ZEND_NULL_HANDLER, 36933: ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER, 36934: ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER, 36935: ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER, 36936: ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER, 36937: ZEND_NULL_HANDLER, 36938: ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER, 36939: ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER, 36940: ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER, 36941: ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER, 36942: ZEND_NULL_HANDLER, 36943: ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER, 36944: ZEND_NULL_HANDLER, 36945: ZEND_NULL_HANDLER, 36946: ZEND_NULL_HANDLER, 36947: ZEND_NULL_HANDLER, 36948: ZEND_NULL_HANDLER, 36949: ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER, 36950: ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER, 36951: ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER, 36952: ZEND_NULL_HANDLER, 36953: ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER, 36954: ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER, 36955: ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER, 36956: ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER, 36957: ZEND_NULL_HANDLER, 36958: ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER, 36959: ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER, 36960: ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER, 36961: ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER, 36962: ZEND_NULL_HANDLER, 36963: ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER, 36964: ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER, 36965: ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER, 36966: ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER, 36967: ZEND_NULL_HANDLER, 36968: ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER, 36969: ZEND_NULL_HANDLER, 36970: ZEND_NULL_HANDLER, 36971: ZEND_NULL_HANDLER, 36972: ZEND_NULL_HANDLER, 36973: ZEND_NULL_HANDLER, 36974: ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER, 36975: ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER, 36976: ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER, 36977: ZEND_NULL_HANDLER, 36978: ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER, 36979: ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER, 36980: ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER, 36981: ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER, 36982: ZEND_NULL_HANDLER, 36983: ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER, 36984: ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER, 36985: ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER, 36986: ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER, 36987: ZEND_NULL_HANDLER, 36988: ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER, 36989: ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER, 36990: ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER, 36991: ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER, 36992: ZEND_NULL_HANDLER, 36993: ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER, 36994: ZEND_NULL_HANDLER, 36995: ZEND_NULL_HANDLER, 36996: ZEND_NULL_HANDLER, 36997: ZEND_NULL_HANDLER, 36998: ZEND_NULL_HANDLER, 36999: ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER, 37000: ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER, 37001: ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER, 37002: ZEND_NULL_HANDLER, 37003: ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER, 37004: ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER, 37005: ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER, 37006: ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER, 37007: ZEND_NULL_HANDLER, 37008: ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER, 37009: ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER, 37010: ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER, 37011: ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER, 37012: ZEND_NULL_HANDLER, 37013: ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER, 37014: ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER, 37015: ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER, 37016: ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER, 37017: ZEND_NULL_HANDLER, 37018: ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER, 37019: ZEND_NULL_HANDLER, 37020: ZEND_NULL_HANDLER, 37021: ZEND_NULL_HANDLER, 37022: ZEND_NULL_HANDLER, 37023: ZEND_NULL_HANDLER, 37024: ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER, 37025: ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER, 37026: ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER, 37027: ZEND_NULL_HANDLER, 37028: ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER, 37029: ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER, 37030: ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER, 37031: ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER, 37032: ZEND_NULL_HANDLER, 37033: ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER, 37034: ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER, 37035: ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER, 37036: ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER, 37037: ZEND_NULL_HANDLER, 37038: ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER, 37039: ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER, 37040: ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER, 37041: ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER, 37042: ZEND_NULL_HANDLER, 37043: ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER, 37044: ZEND_NULL_HANDLER, 37045: ZEND_NULL_HANDLER, 37046: ZEND_NULL_HANDLER, 37047: ZEND_NULL_HANDLER, 37048: ZEND_NULL_HANDLER, 37049: ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER, 37050: ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER, 37051: ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER, 37052: ZEND_NULL_HANDLER, 37053: ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER, 37054: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER, 37055: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER, 37056: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER, 37057: ZEND_NULL_HANDLER, 37058: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER, 37059: ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER, 37060: ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER, 37061: ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER, 37062: ZEND_NULL_HANDLER, 37063: ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER, 37064: ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER, 37065: ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER, 37066: ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER, 37067: ZEND_NULL_HANDLER, 37068: ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER, 37069: ZEND_NULL_HANDLER, 37070: ZEND_NULL_HANDLER, 37071: ZEND_NULL_HANDLER, 37072: ZEND_NULL_HANDLER, 37073: ZEND_NULL_HANDLER, 37074: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER, 37075: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER, 37076: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER, 37077: ZEND_NULL_HANDLER, 37078: ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER, 37079: ZEND_CAST_SPEC_CONST_HANDLER, 37080: ZEND_CAST_SPEC_CONST_HANDLER, 37081: ZEND_CAST_SPEC_CONST_HANDLER, 37082: ZEND_CAST_SPEC_CONST_HANDLER, 37083: ZEND_CAST_SPEC_CONST_HANDLER, 37084: ZEND_CAST_SPEC_TMP_HANDLER, 37085: ZEND_CAST_SPEC_TMP_HANDLER, 37086: ZEND_CAST_SPEC_TMP_HANDLER, 37087: ZEND_CAST_SPEC_TMP_HANDLER, 37088: ZEND_CAST_SPEC_TMP_HANDLER, 37089: ZEND_CAST_SPEC_VAR_HANDLER, 37090: ZEND_CAST_SPEC_VAR_HANDLER, 37091: ZEND_CAST_SPEC_VAR_HANDLER, 37092: ZEND_CAST_SPEC_VAR_HANDLER, 37093: ZEND_CAST_SPEC_VAR_HANDLER, 37094: ZEND_NULL_HANDLER, 37095: ZEND_NULL_HANDLER, 37096: ZEND_NULL_HANDLER, 37097: ZEND_NULL_HANDLER, 37098: ZEND_NULL_HANDLER, 37099: ZEND_CAST_SPEC_CV_HANDLER, 37100: ZEND_CAST_SPEC_CV_HANDLER, 37101: ZEND_CAST_SPEC_CV_HANDLER, 37102: ZEND_CAST_SPEC_CV_HANDLER, 37103: ZEND_CAST_SPEC_CV_HANDLER, 37104: ZEND_QM_ASSIGN_SPEC_CONST_HANDLER, 37105: ZEND_QM_ASSIGN_SPEC_CONST_HANDLER, 37106: ZEND_QM_ASSIGN_SPEC_CONST_HANDLER, 37107: ZEND_QM_ASSIGN_SPEC_CONST_HANDLER, 37108: ZEND_QM_ASSIGN_SPEC_CONST_HANDLER, 37109: ZEND_QM_ASSIGN_SPEC_TMP_HANDLER, 37110: ZEND_QM_ASSIGN_SPEC_TMP_HANDLER, 37111: ZEND_QM_ASSIGN_SPEC_TMP_HANDLER, 37112: ZEND_QM_ASSIGN_SPEC_TMP_HANDLER, 37113: ZEND_QM_ASSIGN_SPEC_TMP_HANDLER, 37114: ZEND_QM_ASSIGN_SPEC_VAR_HANDLER, 37115: ZEND_QM_ASSIGN_SPEC_VAR_HANDLER, 37116: ZEND_QM_ASSIGN_SPEC_VAR_HANDLER, 37117: ZEND_QM_ASSIGN_SPEC_VAR_HANDLER, 37118: ZEND_QM_ASSIGN_SPEC_VAR_HANDLER, 37119: ZEND_NULL_HANDLER, 37120: ZEND_NULL_HANDLER, 37121: ZEND_NULL_HANDLER, 37122: ZEND_NULL_HANDLER, 37123: ZEND_NULL_HANDLER, 37124: ZEND_QM_ASSIGN_SPEC_CV_HANDLER, 37125: ZEND_QM_ASSIGN_SPEC_CV_HANDLER, 37126: ZEND_QM_ASSIGN_SPEC_CV_HANDLER, 37127: ZEND_QM_ASSIGN_SPEC_CV_HANDLER, 37128: ZEND_QM_ASSIGN_SPEC_CV_HANDLER, 37129: ZEND_NULL_HANDLER, 37130: ZEND_NULL_HANDLER, 37131: ZEND_NULL_HANDLER, 37132: ZEND_NULL_HANDLER, 37133: ZEND_NULL_HANDLER, 37134: ZEND_NULL_HANDLER, 37135: ZEND_NULL_HANDLER, 37136: ZEND_NULL_HANDLER, 37137: ZEND_NULL_HANDLER, 37138: ZEND_NULL_HANDLER, 37139: ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER, 37140: ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER, 37141: ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER, 37142: ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER, 37143: ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER, 37144: ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER, 37145: ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER, 37146: ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER, 37147: ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER, 37148: ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER, 37149: ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER, 37150: ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER, 37151: ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER, 37152: ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER, 37153: ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER, 37154: ZEND_NULL_HANDLER, 37155: ZEND_NULL_HANDLER, 37156: ZEND_NULL_HANDLER, 37157: ZEND_NULL_HANDLER, 37158: ZEND_NULL_HANDLER, 37159: ZEND_NULL_HANDLER, 37160: ZEND_NULL_HANDLER, 37161: ZEND_NULL_HANDLER, 37162: ZEND_NULL_HANDLER, 37163: ZEND_NULL_HANDLER, 37164: ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER, 37165: ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER, 37166: ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER, 37167: ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER, 37168: ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER, 37169: ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER, 37170: ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER, 37171: ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER, 37172: ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER, 37173: ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER, 37174: ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER, 37175: ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER, 37176: ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER, 37177: ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER, 37178: ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER, 37179: ZEND_NULL_HANDLER, 37180: ZEND_NULL_HANDLER, 37181: ZEND_NULL_HANDLER, 37182: ZEND_NULL_HANDLER, 37183: ZEND_NULL_HANDLER, 37184: ZEND_NULL_HANDLER, 37185: ZEND_NULL_HANDLER, 37186: ZEND_NULL_HANDLER, 37187: ZEND_NULL_HANDLER, 37188: ZEND_NULL_HANDLER, 37189: ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER, 37190: ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER, 37191: ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER, 37192: ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER, 37193: ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER, 37194: ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER, 37195: ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER, 37196: ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER, 37197: ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER, 37198: ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER, 37199: ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER, 37200: ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER, 37201: ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER, 37202: ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER, 37203: ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER, 37204: ZEND_NULL_HANDLER, 37205: ZEND_NULL_HANDLER, 37206: ZEND_NULL_HANDLER, 37207: ZEND_NULL_HANDLER, 37208: ZEND_NULL_HANDLER, 37209: ZEND_NULL_HANDLER, 37210: ZEND_NULL_HANDLER, 37211: ZEND_NULL_HANDLER, 37212: ZEND_NULL_HANDLER, 37213: ZEND_NULL_HANDLER, 37214: ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER, 37215: ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER, 37216: ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER, 37217: ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER, 37218: ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER, 37219: ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER, 37220: ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER, 37221: ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER, 37222: ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER, 37223: ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER, 37224: ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER, 37225: ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER, 37226: ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER, 37227: ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER, 37228: ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER, 37229: ZEND_NULL_HANDLER, 37230: ZEND_NULL_HANDLER, 37231: ZEND_NULL_HANDLER, 37232: ZEND_NULL_HANDLER, 37233: ZEND_NULL_HANDLER, 37234: ZEND_NULL_HANDLER, 37235: ZEND_NULL_HANDLER, 37236: ZEND_NULL_HANDLER, 37237: ZEND_NULL_HANDLER, 37238: ZEND_NULL_HANDLER, 37239: ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER, 37240: ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER, 37241: ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER, 37242: ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER, 37243: ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER, 37244: ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER, 37245: ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER, 37246: ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER, 37247: ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER, 37248: ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER, 37249: ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER, 37250: ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER, 37251: ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER, 37252: ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER, 37253: ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER, 37254: ZEND_NULL_HANDLER, 37255: ZEND_NULL_HANDLER, 37256: ZEND_NULL_HANDLER, 37257: ZEND_NULL_HANDLER, 37258: ZEND_NULL_HANDLER, 37259: ZEND_NULL_HANDLER, 37260: ZEND_NULL_HANDLER, 37261: ZEND_NULL_HANDLER, 37262: ZEND_NULL_HANDLER, 37263: ZEND_NULL_HANDLER, 37264: ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER, 37265: ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER, 37266: ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER, 37267: ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER, 37268: ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER, 37269: ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER, 37270: ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER, 37271: ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER, 37272: ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER, 37273: ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER, 37274: ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER, 37275: ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER, 37276: ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER, 37277: ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER, 37278: ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER, 37279: ZEND_NULL_HANDLER, 37280: ZEND_NULL_HANDLER, 37281: ZEND_NULL_HANDLER, 37282: ZEND_NULL_HANDLER, 37283: ZEND_NULL_HANDLER, 37284: ZEND_NULL_HANDLER, 37285: ZEND_NULL_HANDLER, 37286: ZEND_NULL_HANDLER, 37287: ZEND_NULL_HANDLER, 37288: ZEND_NULL_HANDLER, 37289: ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER, 37290: ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER, 37291: ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER, 37292: ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER, 37293: ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER, 37294: ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER, 37295: ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER, 37296: ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER, 37297: ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER, 37298: ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER, 37299: ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER, 37300: ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER, 37301: ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER, 37302: ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER, 37303: ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER, 37304: ZEND_NULL_HANDLER, 37305: ZEND_NULL_HANDLER, 37306: ZEND_NULL_HANDLER, 37307: ZEND_NULL_HANDLER, 37308: ZEND_NULL_HANDLER, 37309: ZEND_NULL_HANDLER, 37310: ZEND_NULL_HANDLER, 37311: ZEND_NULL_HANDLER, 37312: ZEND_NULL_HANDLER, 37313: ZEND_NULL_HANDLER, 37314: ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER, 37315: ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER, 37316: ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER, 37317: ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER, 37318: ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER, 37319: ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER, 37320: ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER, 37321: ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER, 37322: ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER, 37323: ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER, 37324: ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER, 37325: ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER, 37326: ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER, 37327: ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER, 37328: ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER, 37329: ZEND_NULL_HANDLER, 37330: ZEND_NULL_HANDLER, 37331: ZEND_NULL_HANDLER, 37332: ZEND_NULL_HANDLER, 37333: ZEND_NULL_HANDLER, 37334: ZEND_NULL_HANDLER, 37335: ZEND_NULL_HANDLER, 37336: ZEND_NULL_HANDLER, 37337: ZEND_NULL_HANDLER, 37338: ZEND_NULL_HANDLER, 37339: ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER, 37340: ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER, 37341: ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER, 37342: ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER, 37343: ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER, 37344: ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER, 37345: ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER, 37346: ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER, 37347: ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER, 37348: ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER, 37349: ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER, 37350: ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER, 37351: ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER, 37352: ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER, 37353: ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER, 37354: ZEND_NULL_HANDLER, 37355: ZEND_NULL_HANDLER, 37356: ZEND_NULL_HANDLER, 37357: ZEND_NULL_HANDLER, 37358: ZEND_NULL_HANDLER, 37359: ZEND_NULL_HANDLER, 37360: ZEND_NULL_HANDLER, 37361: ZEND_NULL_HANDLER, 37362: ZEND_NULL_HANDLER, 37363: ZEND_NULL_HANDLER, 37364: ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER, 37365: ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER, 37366: ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER, 37367: ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER, 37368: ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER, 37369: ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER, 37370: ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER, 37371: ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER, 37372: ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER, 37373: ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER, 37374: ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER, 37375: ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER, 37376: ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER, 37377: ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER, 37378: ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER, 37379: ZEND_NULL_HANDLER, 37380: ZEND_NULL_HANDLER, 37381: ZEND_NULL_HANDLER, 37382: ZEND_NULL_HANDLER, 37383: ZEND_NULL_HANDLER, 37384: ZEND_NULL_HANDLER, 37385: ZEND_NULL_HANDLER, 37386: ZEND_NULL_HANDLER, 37387: ZEND_NULL_HANDLER, 37388: ZEND_NULL_HANDLER, 37389: ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER, 37390: ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER, 37391: ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER, 37392: ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER, 37393: ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER, 37394: ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER, 37395: ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER, 37396: ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER, 37397: ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER, 37398: ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER, 37399: ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER, 37400: ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER, 37401: ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER, 37402: ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER, 37403: ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER, 37404: ZEND_NULL_HANDLER, 37405: ZEND_NULL_HANDLER, 37406: ZEND_NULL_HANDLER, 37407: ZEND_NULL_HANDLER, 37408: ZEND_NULL_HANDLER, 37409: ZEND_NULL_HANDLER, 37410: ZEND_NULL_HANDLER, 37411: ZEND_NULL_HANDLER, 37412: ZEND_NULL_HANDLER, 37413: ZEND_NULL_HANDLER, 37414: ZEND_PRE_INC_SPEC_VAR_HANDLER, 37415: ZEND_PRE_INC_SPEC_VAR_HANDLER, 37416: ZEND_PRE_INC_SPEC_VAR_HANDLER, 37417: ZEND_PRE_INC_SPEC_VAR_HANDLER, 37418: ZEND_PRE_INC_SPEC_VAR_HANDLER, 37419: ZEND_NULL_HANDLER, 37420: ZEND_NULL_HANDLER, 37421: ZEND_NULL_HANDLER, 37422: ZEND_NULL_HANDLER, 37423: ZEND_NULL_HANDLER, 37424: ZEND_PRE_INC_SPEC_CV_HANDLER, 37425: ZEND_PRE_INC_SPEC_CV_HANDLER, 37426: ZEND_PRE_INC_SPEC_CV_HANDLER, 37427: ZEND_PRE_INC_SPEC_CV_HANDLER, 37428: ZEND_PRE_INC_SPEC_CV_HANDLER, 37429: ZEND_NULL_HANDLER, 37430: ZEND_NULL_HANDLER, 37431: ZEND_NULL_HANDLER, 37432: ZEND_NULL_HANDLER, 37433: ZEND_NULL_HANDLER, 37434: ZEND_NULL_HANDLER, 37435: ZEND_NULL_HANDLER, 37436: ZEND_NULL_HANDLER, 37437: ZEND_NULL_HANDLER, 37438: ZEND_NULL_HANDLER, 37439: ZEND_PRE_DEC_SPEC_VAR_HANDLER, 37440: ZEND_PRE_DEC_SPEC_VAR_HANDLER, 37441: ZEND_PRE_DEC_SPEC_VAR_HANDLER, 37442: ZEND_PRE_DEC_SPEC_VAR_HANDLER, 37443: ZEND_PRE_DEC_SPEC_VAR_HANDLER, 37444: ZEND_NULL_HANDLER, 37445: ZEND_NULL_HANDLER, 37446: ZEND_NULL_HANDLER, 37447: ZEND_NULL_HANDLER, 37448: ZEND_NULL_HANDLER, 37449: ZEND_PRE_DEC_SPEC_CV_HANDLER, 37450: ZEND_PRE_DEC_SPEC_CV_HANDLER, 37451: ZEND_PRE_DEC_SPEC_CV_HANDLER, 37452: ZEND_PRE_DEC_SPEC_CV_HANDLER, 37453: ZEND_PRE_DEC_SPEC_CV_HANDLER, 37454: ZEND_NULL_HANDLER, 37455: ZEND_NULL_HANDLER, 37456: ZEND_NULL_HANDLER, 37457: ZEND_NULL_HANDLER, 37458: ZEND_NULL_HANDLER, 37459: ZEND_NULL_HANDLER, 37460: ZEND_NULL_HANDLER, 37461: ZEND_NULL_HANDLER, 37462: ZEND_NULL_HANDLER, 37463: ZEND_NULL_HANDLER, 37464: ZEND_POST_INC_SPEC_VAR_HANDLER, 37465: ZEND_POST_INC_SPEC_VAR_HANDLER, 37466: ZEND_POST_INC_SPEC_VAR_HANDLER, 37467: ZEND_POST_INC_SPEC_VAR_HANDLER, 37468: ZEND_POST_INC_SPEC_VAR_HANDLER, 37469: ZEND_NULL_HANDLER, 37470: ZEND_NULL_HANDLER, 37471: ZEND_NULL_HANDLER, 37472: ZEND_NULL_HANDLER, 37473: ZEND_NULL_HANDLER, 37474: ZEND_POST_INC_SPEC_CV_HANDLER, 37475: ZEND_POST_INC_SPEC_CV_HANDLER, 37476: ZEND_POST_INC_SPEC_CV_HANDLER, 37477: ZEND_POST_INC_SPEC_CV_HANDLER, 37478: ZEND_POST_INC_SPEC_CV_HANDLER, 37479: ZEND_NULL_HANDLER, 37480: ZEND_NULL_HANDLER, 37481: ZEND_NULL_HANDLER, 37482: ZEND_NULL_HANDLER, 37483: ZEND_NULL_HANDLER, 37484: ZEND_NULL_HANDLER, 37485: ZEND_NULL_HANDLER, 37486: ZEND_NULL_HANDLER, 37487: ZEND_NULL_HANDLER, 37488: ZEND_NULL_HANDLER, 37489: ZEND_POST_DEC_SPEC_VAR_HANDLER, 37490: ZEND_POST_DEC_SPEC_VAR_HANDLER, 37491: ZEND_POST_DEC_SPEC_VAR_HANDLER, 37492: ZEND_POST_DEC_SPEC_VAR_HANDLER, 37493: ZEND_POST_DEC_SPEC_VAR_HANDLER, 37494: ZEND_NULL_HANDLER, 37495: ZEND_NULL_HANDLER, 37496: ZEND_NULL_HANDLER, 37497: ZEND_NULL_HANDLER, 37498: ZEND_NULL_HANDLER, 37499: ZEND_POST_DEC_SPEC_CV_HANDLER, 37500: ZEND_POST_DEC_SPEC_CV_HANDLER, 37501: ZEND_POST_DEC_SPEC_CV_HANDLER, 37502: ZEND_POST_DEC_SPEC_CV_HANDLER, 37503: ZEND_POST_DEC_SPEC_CV_HANDLER, 37504: ZEND_NULL_HANDLER, 37505: ZEND_NULL_HANDLER, 37506: ZEND_NULL_HANDLER, 37507: ZEND_NULL_HANDLER, 37508: ZEND_NULL_HANDLER, 37509: ZEND_NULL_HANDLER, 37510: ZEND_NULL_HANDLER, 37511: ZEND_NULL_HANDLER, 37512: ZEND_NULL_HANDLER, 37513: ZEND_NULL_HANDLER, 37514: ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER, 37515: ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER, 37516: ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER, 37517: ZEND_NULL_HANDLER, 37518: ZEND_ASSIGN_SPEC_VAR_CV_HANDLER, 37519: ZEND_NULL_HANDLER, 37520: ZEND_NULL_HANDLER, 37521: ZEND_NULL_HANDLER, 37522: ZEND_NULL_HANDLER, 37523: ZEND_NULL_HANDLER, 37524: ZEND_ASSIGN_SPEC_CV_CONST_HANDLER, 37525: ZEND_ASSIGN_SPEC_CV_TMP_HANDLER, 37526: ZEND_ASSIGN_SPEC_CV_VAR_HANDLER, 37527: ZEND_NULL_HANDLER, 37528: ZEND_ASSIGN_SPEC_CV_CV_HANDLER, 37529: ZEND_NULL_HANDLER, 37530: ZEND_NULL_HANDLER, 37531: ZEND_NULL_HANDLER, 37532: ZEND_NULL_HANDLER, 37533: ZEND_NULL_HANDLER, 37534: ZEND_NULL_HANDLER, 37535: ZEND_NULL_HANDLER, 37536: ZEND_NULL_HANDLER, 37537: ZEND_NULL_HANDLER, 37538: ZEND_NULL_HANDLER, 37539: ZEND_NULL_HANDLER, 37540: ZEND_NULL_HANDLER, 37541: ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER, 37542: ZEND_NULL_HANDLER, 37543: ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER, 37544: ZEND_NULL_HANDLER, 37545: ZEND_NULL_HANDLER, 37546: ZEND_NULL_HANDLER, 37547: ZEND_NULL_HANDLER, 37548: ZEND_NULL_HANDLER, 37549: ZEND_NULL_HANDLER, 37550: ZEND_NULL_HANDLER, 37551: ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER, 37552: ZEND_NULL_HANDLER, 37553: ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER, 37554: ZEND_ECHO_SPEC_CONST_HANDLER, 37555: ZEND_ECHO_SPEC_CONST_HANDLER, 37556: ZEND_ECHO_SPEC_CONST_HANDLER, 37557: ZEND_ECHO_SPEC_CONST_HANDLER, 37558: ZEND_ECHO_SPEC_CONST_HANDLER, 37559: ZEND_ECHO_SPEC_TMP_HANDLER, 37560: ZEND_ECHO_SPEC_TMP_HANDLER, 37561: ZEND_ECHO_SPEC_TMP_HANDLER, 37562: ZEND_ECHO_SPEC_TMP_HANDLER, 37563: ZEND_ECHO_SPEC_TMP_HANDLER, 37564: ZEND_ECHO_SPEC_VAR_HANDLER, 37565: ZEND_ECHO_SPEC_VAR_HANDLER, 37566: ZEND_ECHO_SPEC_VAR_HANDLER, 37567: ZEND_ECHO_SPEC_VAR_HANDLER, 37568: ZEND_ECHO_SPEC_VAR_HANDLER, 37569: ZEND_NULL_HANDLER, 37570: ZEND_NULL_HANDLER, 37571: ZEND_NULL_HANDLER, 37572: ZEND_NULL_HANDLER, 37573: ZEND_NULL_HANDLER, 37574: ZEND_ECHO_SPEC_CV_HANDLER, 37575: ZEND_ECHO_SPEC_CV_HANDLER, 37576: ZEND_ECHO_SPEC_CV_HANDLER, 37577: ZEND_ECHO_SPEC_CV_HANDLER, 37578: ZEND_ECHO_SPEC_CV_HANDLER, 37579: ZEND_PRINT_SPEC_CONST_HANDLER, 37580: ZEND_PRINT_SPEC_CONST_HANDLER, 37581: ZEND_PRINT_SPEC_CONST_HANDLER, 37582: ZEND_PRINT_SPEC_CONST_HANDLER, 37583: ZEND_PRINT_SPEC_CONST_HANDLER, 37584: ZEND_PRINT_SPEC_TMP_HANDLER, 37585: ZEND_PRINT_SPEC_TMP_HANDLER, 37586: ZEND_PRINT_SPEC_TMP_HANDLER, 37587: ZEND_PRINT_SPEC_TMP_HANDLER, 37588: ZEND_PRINT_SPEC_TMP_HANDLER, 37589: ZEND_PRINT_SPEC_VAR_HANDLER, 37590: ZEND_PRINT_SPEC_VAR_HANDLER, 37591: ZEND_PRINT_SPEC_VAR_HANDLER, 37592: ZEND_PRINT_SPEC_VAR_HANDLER, 37593: ZEND_PRINT_SPEC_VAR_HANDLER, 37594: ZEND_NULL_HANDLER, 37595: ZEND_NULL_HANDLER, 37596: ZEND_NULL_HANDLER, 37597: ZEND_NULL_HANDLER, 37598: ZEND_NULL_HANDLER, 37599: ZEND_PRINT_SPEC_CV_HANDLER, 37600: ZEND_PRINT_SPEC_CV_HANDLER, 37601: ZEND_PRINT_SPEC_CV_HANDLER, 37602: ZEND_PRINT_SPEC_CV_HANDLER, 37603: ZEND_PRINT_SPEC_CV_HANDLER, 37604: ZEND_JMP_SPEC_HANDLER, 37605: ZEND_JMP_SPEC_HANDLER, 37606: ZEND_JMP_SPEC_HANDLER, 37607: ZEND_JMP_SPEC_HANDLER, 37608: ZEND_JMP_SPEC_HANDLER, 37609: ZEND_JMP_SPEC_HANDLER, 37610: ZEND_JMP_SPEC_HANDLER, 37611: ZEND_JMP_SPEC_HANDLER, 37612: ZEND_JMP_SPEC_HANDLER, 37613: ZEND_JMP_SPEC_HANDLER, 37614: ZEND_JMP_SPEC_HANDLER, 37615: ZEND_JMP_SPEC_HANDLER, 37616: ZEND_JMP_SPEC_HANDLER, 37617: ZEND_JMP_SPEC_HANDLER, 37618: ZEND_JMP_SPEC_HANDLER, 37619: ZEND_JMP_SPEC_HANDLER, 37620: ZEND_JMP_SPEC_HANDLER, 37621: ZEND_JMP_SPEC_HANDLER, 37622: ZEND_JMP_SPEC_HANDLER, 37623: ZEND_JMP_SPEC_HANDLER, 37624: ZEND_JMP_SPEC_HANDLER, 37625: ZEND_JMP_SPEC_HANDLER, 37626: ZEND_JMP_SPEC_HANDLER, 37627: ZEND_JMP_SPEC_HANDLER, 37628: ZEND_JMP_SPEC_HANDLER, 37629: ZEND_JMPZ_SPEC_CONST_HANDLER, 37630: ZEND_JMPZ_SPEC_CONST_HANDLER, 37631: ZEND_JMPZ_SPEC_CONST_HANDLER, 37632: ZEND_JMPZ_SPEC_CONST_HANDLER, 37633: ZEND_JMPZ_SPEC_CONST_HANDLER, 37634: ZEND_JMPZ_SPEC_TMP_HANDLER, 37635: ZEND_JMPZ_SPEC_TMP_HANDLER, 37636: ZEND_JMPZ_SPEC_TMP_HANDLER, 37637: ZEND_JMPZ_SPEC_TMP_HANDLER, 37638: ZEND_JMPZ_SPEC_TMP_HANDLER, 37639: ZEND_JMPZ_SPEC_VAR_HANDLER, 37640: ZEND_JMPZ_SPEC_VAR_HANDLER, 37641: ZEND_JMPZ_SPEC_VAR_HANDLER, 37642: ZEND_JMPZ_SPEC_VAR_HANDLER, 37643: ZEND_JMPZ_SPEC_VAR_HANDLER, 37644: ZEND_NULL_HANDLER, 37645: ZEND_NULL_HANDLER, 37646: ZEND_NULL_HANDLER, 37647: ZEND_NULL_HANDLER, 37648: ZEND_NULL_HANDLER, 37649: ZEND_JMPZ_SPEC_CV_HANDLER, 37650: ZEND_JMPZ_SPEC_CV_HANDLER, 37651: ZEND_JMPZ_SPEC_CV_HANDLER, 37652: ZEND_JMPZ_SPEC_CV_HANDLER, 37653: ZEND_JMPZ_SPEC_CV_HANDLER, 37654: ZEND_JMPNZ_SPEC_CONST_HANDLER, 37655: ZEND_JMPNZ_SPEC_CONST_HANDLER, 37656: ZEND_JMPNZ_SPEC_CONST_HANDLER, 37657: ZEND_JMPNZ_SPEC_CONST_HANDLER, 37658: ZEND_JMPNZ_SPEC_CONST_HANDLER, 37659: ZEND_JMPNZ_SPEC_TMP_HANDLER, 37660: ZEND_JMPNZ_SPEC_TMP_HANDLER, 37661: ZEND_JMPNZ_SPEC_TMP_HANDLER, 37662: ZEND_JMPNZ_SPEC_TMP_HANDLER, 37663: ZEND_JMPNZ_SPEC_TMP_HANDLER, 37664: ZEND_JMPNZ_SPEC_VAR_HANDLER, 37665: ZEND_JMPNZ_SPEC_VAR_HANDLER, 37666: ZEND_JMPNZ_SPEC_VAR_HANDLER, 37667: ZEND_JMPNZ_SPEC_VAR_HANDLER, 37668: ZEND_JMPNZ_SPEC_VAR_HANDLER, 37669: ZEND_NULL_HANDLER, 37670: ZEND_NULL_HANDLER, 37671: ZEND_NULL_HANDLER, 37672: ZEND_NULL_HANDLER, 37673: ZEND_NULL_HANDLER, 37674: ZEND_JMPNZ_SPEC_CV_HANDLER, 37675: ZEND_JMPNZ_SPEC_CV_HANDLER, 37676: ZEND_JMPNZ_SPEC_CV_HANDLER, 37677: ZEND_JMPNZ_SPEC_CV_HANDLER, 37678: ZEND_JMPNZ_SPEC_CV_HANDLER, 37679: ZEND_JMPZNZ_SPEC_CONST_HANDLER, 37680: ZEND_JMPZNZ_SPEC_CONST_HANDLER, 37681: ZEND_JMPZNZ_SPEC_CONST_HANDLER, 37682: ZEND_JMPZNZ_SPEC_CONST_HANDLER, 37683: ZEND_JMPZNZ_SPEC_CONST_HANDLER, 37684: ZEND_JMPZNZ_SPEC_TMP_HANDLER, 37685: ZEND_JMPZNZ_SPEC_TMP_HANDLER, 37686: ZEND_JMPZNZ_SPEC_TMP_HANDLER, 37687: ZEND_JMPZNZ_SPEC_TMP_HANDLER, 37688: ZEND_JMPZNZ_SPEC_TMP_HANDLER, 37689: ZEND_JMPZNZ_SPEC_VAR_HANDLER, 37690: ZEND_JMPZNZ_SPEC_VAR_HANDLER, 37691: ZEND_JMPZNZ_SPEC_VAR_HANDLER, 37692: ZEND_JMPZNZ_SPEC_VAR_HANDLER, 37693: ZEND_JMPZNZ_SPEC_VAR_HANDLER, 37694: ZEND_NULL_HANDLER, 37695: ZEND_NULL_HANDLER, 37696: ZEND_NULL_HANDLER, 37697: ZEND_NULL_HANDLER, 37698: ZEND_NULL_HANDLER, 37699: ZEND_JMPZNZ_SPEC_CV_HANDLER, 37700: ZEND_JMPZNZ_SPEC_CV_HANDLER, 37701: ZEND_JMPZNZ_SPEC_CV_HANDLER, 37702: ZEND_JMPZNZ_SPEC_CV_HANDLER, 37703: ZEND_JMPZNZ_SPEC_CV_HANDLER, 37704: ZEND_JMPZ_EX_SPEC_CONST_HANDLER, 37705: ZEND_JMPZ_EX_SPEC_CONST_HANDLER, 37706: ZEND_JMPZ_EX_SPEC_CONST_HANDLER, 37707: ZEND_JMPZ_EX_SPEC_CONST_HANDLER, 37708: ZEND_JMPZ_EX_SPEC_CONST_HANDLER, 37709: ZEND_JMPZ_EX_SPEC_TMP_HANDLER, 37710: ZEND_JMPZ_EX_SPEC_TMP_HANDLER, 37711: ZEND_JMPZ_EX_SPEC_TMP_HANDLER, 37712: ZEND_JMPZ_EX_SPEC_TMP_HANDLER, 37713: ZEND_JMPZ_EX_SPEC_TMP_HANDLER, 37714: ZEND_JMPZ_EX_SPEC_VAR_HANDLER, 37715: ZEND_JMPZ_EX_SPEC_VAR_HANDLER, 37716: ZEND_JMPZ_EX_SPEC_VAR_HANDLER, 37717: ZEND_JMPZ_EX_SPEC_VAR_HANDLER, 37718: ZEND_JMPZ_EX_SPEC_VAR_HANDLER, 37719: ZEND_NULL_HANDLER, 37720: ZEND_NULL_HANDLER, 37721: ZEND_NULL_HANDLER, 37722: ZEND_NULL_HANDLER, 37723: ZEND_NULL_HANDLER, 37724: ZEND_JMPZ_EX_SPEC_CV_HANDLER, 37725: ZEND_JMPZ_EX_SPEC_CV_HANDLER, 37726: ZEND_JMPZ_EX_SPEC_CV_HANDLER, 37727: ZEND_JMPZ_EX_SPEC_CV_HANDLER, 37728: ZEND_JMPZ_EX_SPEC_CV_HANDLER, 37729: ZEND_JMPNZ_EX_SPEC_CONST_HANDLER, 37730: ZEND_JMPNZ_EX_SPEC_CONST_HANDLER, 37731: ZEND_JMPNZ_EX_SPEC_CONST_HANDLER, 37732: ZEND_JMPNZ_EX_SPEC_CONST_HANDLER, 37733: ZEND_JMPNZ_EX_SPEC_CONST_HANDLER, 37734: ZEND_JMPNZ_EX_SPEC_TMP_HANDLER, 37735: ZEND_JMPNZ_EX_SPEC_TMP_HANDLER, 37736: ZEND_JMPNZ_EX_SPEC_TMP_HANDLER, 37737: ZEND_JMPNZ_EX_SPEC_TMP_HANDLER, 37738: ZEND_JMPNZ_EX_SPEC_TMP_HANDLER, 37739: ZEND_JMPNZ_EX_SPEC_VAR_HANDLER, 37740: ZEND_JMPNZ_EX_SPEC_VAR_HANDLER, 37741: ZEND_JMPNZ_EX_SPEC_VAR_HANDLER, 37742: ZEND_JMPNZ_EX_SPEC_VAR_HANDLER, 37743: ZEND_JMPNZ_EX_SPEC_VAR_HANDLER, 37744: ZEND_NULL_HANDLER, 37745: ZEND_NULL_HANDLER, 37746: ZEND_NULL_HANDLER, 37747: ZEND_NULL_HANDLER, 37748: ZEND_NULL_HANDLER, 37749: ZEND_JMPNZ_EX_SPEC_CV_HANDLER, 37750: ZEND_JMPNZ_EX_SPEC_CV_HANDLER, 37751: ZEND_JMPNZ_EX_SPEC_CV_HANDLER, 37752: ZEND_JMPNZ_EX_SPEC_CV_HANDLER, 37753: ZEND_JMPNZ_EX_SPEC_CV_HANDLER, 37754: ZEND_CASE_SPEC_CONST_CONST_HANDLER, 37755: ZEND_CASE_SPEC_CONST_TMP_HANDLER, 37756: ZEND_CASE_SPEC_CONST_VAR_HANDLER, 37757: ZEND_NULL_HANDLER, 37758: ZEND_CASE_SPEC_CONST_CV_HANDLER, 37759: ZEND_CASE_SPEC_TMP_CONST_HANDLER, 37760: ZEND_CASE_SPEC_TMP_TMP_HANDLER, 37761: ZEND_CASE_SPEC_TMP_VAR_HANDLER, 37762: ZEND_NULL_HANDLER, 37763: ZEND_CASE_SPEC_TMP_CV_HANDLER, 37764: ZEND_CASE_SPEC_VAR_CONST_HANDLER, 37765: ZEND_CASE_SPEC_VAR_TMP_HANDLER, 37766: ZEND_CASE_SPEC_VAR_VAR_HANDLER, 37767: ZEND_NULL_HANDLER, 37768: ZEND_CASE_SPEC_VAR_CV_HANDLER, 37769: ZEND_NULL_HANDLER, 37770: ZEND_NULL_HANDLER, 37771: ZEND_NULL_HANDLER, 37772: ZEND_NULL_HANDLER, 37773: ZEND_NULL_HANDLER, 37774: ZEND_CASE_SPEC_CV_CONST_HANDLER, 37775: ZEND_CASE_SPEC_CV_TMP_HANDLER, 37776: ZEND_CASE_SPEC_CV_VAR_HANDLER, 37777: ZEND_NULL_HANDLER, 37778: ZEND_CASE_SPEC_CV_CV_HANDLER, 37779: ZEND_NULL_HANDLER, 37780: ZEND_NULL_HANDLER, 37781: ZEND_NULL_HANDLER, 37782: ZEND_NULL_HANDLER, 37783: ZEND_NULL_HANDLER, 37784: ZEND_NULL_HANDLER, 37785: ZEND_NULL_HANDLER, 37786: ZEND_NULL_HANDLER, 37787: ZEND_NULL_HANDLER, 37788: ZEND_NULL_HANDLER, 37789: ZEND_SWITCH_FREE_SPEC_VAR_HANDLER, 37790: ZEND_SWITCH_FREE_SPEC_VAR_HANDLER, 37791: ZEND_SWITCH_FREE_SPEC_VAR_HANDLER, 37792: ZEND_SWITCH_FREE_SPEC_VAR_HANDLER, 37793: ZEND_SWITCH_FREE_SPEC_VAR_HANDLER, 37794: ZEND_NULL_HANDLER, 37795: ZEND_NULL_HANDLER, 37796: ZEND_NULL_HANDLER, 37797: ZEND_NULL_HANDLER, 37798: ZEND_NULL_HANDLER, 37799: ZEND_NULL_HANDLER, 37800: ZEND_NULL_HANDLER, 37801: ZEND_NULL_HANDLER, 37802: ZEND_NULL_HANDLER, 37803: ZEND_NULL_HANDLER, 37804: ZEND_BRK_SPEC_CONST_HANDLER, 37805: ZEND_NULL_HANDLER, 37806: ZEND_NULL_HANDLER, 37807: ZEND_NULL_HANDLER, 37808: ZEND_NULL_HANDLER, 37809: ZEND_BRK_SPEC_CONST_HANDLER, 37810: ZEND_NULL_HANDLER, 37811: ZEND_NULL_HANDLER, 37812: ZEND_NULL_HANDLER, 37813: ZEND_NULL_HANDLER, 37814: ZEND_BRK_SPEC_CONST_HANDLER, 37815: ZEND_NULL_HANDLER, 37816: ZEND_NULL_HANDLER, 37817: ZEND_NULL_HANDLER, 37818: ZEND_NULL_HANDLER, 37819: ZEND_BRK_SPEC_CONST_HANDLER, 37820: ZEND_NULL_HANDLER, 37821: ZEND_NULL_HANDLER, 37822: ZEND_NULL_HANDLER, 37823: ZEND_NULL_HANDLER, 37824: ZEND_BRK_SPEC_CONST_HANDLER, 37825: ZEND_NULL_HANDLER, 37826: ZEND_NULL_HANDLER, 37827: ZEND_NULL_HANDLER, 37828: ZEND_NULL_HANDLER, 37829: ZEND_CONT_SPEC_CONST_HANDLER, 37830: ZEND_NULL_HANDLER, 37831: ZEND_NULL_HANDLER, 37832: ZEND_NULL_HANDLER, 37833: ZEND_NULL_HANDLER, 37834: ZEND_CONT_SPEC_CONST_HANDLER, 37835: ZEND_NULL_HANDLER, 37836: ZEND_NULL_HANDLER, 37837: ZEND_NULL_HANDLER, 37838: ZEND_NULL_HANDLER, 37839: ZEND_CONT_SPEC_CONST_HANDLER, 37840: ZEND_NULL_HANDLER, 37841: ZEND_NULL_HANDLER, 37842: ZEND_NULL_HANDLER, 37843: ZEND_NULL_HANDLER, 37844: ZEND_CONT_SPEC_CONST_HANDLER, 37845: ZEND_NULL_HANDLER, 37846: ZEND_NULL_HANDLER, 37847: ZEND_NULL_HANDLER, 37848: ZEND_NULL_HANDLER, 37849: ZEND_CONT_SPEC_CONST_HANDLER, 37850: ZEND_NULL_HANDLER, 37851: ZEND_NULL_HANDLER, 37852: ZEND_NULL_HANDLER, 37853: ZEND_NULL_HANDLER, 37854: ZEND_BOOL_SPEC_CONST_HANDLER, 37855: ZEND_BOOL_SPEC_CONST_HANDLER, 37856: ZEND_BOOL_SPEC_CONST_HANDLER, 37857: ZEND_BOOL_SPEC_CONST_HANDLER, 37858: ZEND_BOOL_SPEC_CONST_HANDLER, 37859: ZEND_BOOL_SPEC_TMP_HANDLER, 37860: ZEND_BOOL_SPEC_TMP_HANDLER, 37861: ZEND_BOOL_SPEC_TMP_HANDLER, 37862: ZEND_BOOL_SPEC_TMP_HANDLER, 37863: ZEND_BOOL_SPEC_TMP_HANDLER, 37864: ZEND_BOOL_SPEC_VAR_HANDLER, 37865: ZEND_BOOL_SPEC_VAR_HANDLER, 37866: ZEND_BOOL_SPEC_VAR_HANDLER, 37867: ZEND_BOOL_SPEC_VAR_HANDLER, 37868: ZEND_BOOL_SPEC_VAR_HANDLER, 37869: ZEND_NULL_HANDLER, 37870: ZEND_NULL_HANDLER, 37871: ZEND_NULL_HANDLER, 37872: ZEND_NULL_HANDLER, 37873: ZEND_NULL_HANDLER, 37874: ZEND_BOOL_SPEC_CV_HANDLER, 37875: ZEND_BOOL_SPEC_CV_HANDLER, 37876: ZEND_BOOL_SPEC_CV_HANDLER, 37877: ZEND_BOOL_SPEC_CV_HANDLER, 37878: ZEND_BOOL_SPEC_CV_HANDLER, 37879: ZEND_INIT_STRING_SPEC_HANDLER, 37880: ZEND_INIT_STRING_SPEC_HANDLER, 37881: ZEND_INIT_STRING_SPEC_HANDLER, 37882: ZEND_INIT_STRING_SPEC_HANDLER, 37883: ZEND_INIT_STRING_SPEC_HANDLER, 37884: ZEND_INIT_STRING_SPEC_HANDLER, 37885: ZEND_INIT_STRING_SPEC_HANDLER, 37886: ZEND_INIT_STRING_SPEC_HANDLER, 37887: ZEND_INIT_STRING_SPEC_HANDLER, 37888: ZEND_INIT_STRING_SPEC_HANDLER, 37889: ZEND_INIT_STRING_SPEC_HANDLER, 37890: ZEND_INIT_STRING_SPEC_HANDLER, 37891: ZEND_INIT_STRING_SPEC_HANDLER, 37892: ZEND_INIT_STRING_SPEC_HANDLER, 37893: ZEND_INIT_STRING_SPEC_HANDLER, 37894: ZEND_INIT_STRING_SPEC_HANDLER, 37895: ZEND_INIT_STRING_SPEC_HANDLER, 37896: ZEND_INIT_STRING_SPEC_HANDLER, 37897: ZEND_INIT_STRING_SPEC_HANDLER, 37898: ZEND_INIT_STRING_SPEC_HANDLER, 37899: ZEND_INIT_STRING_SPEC_HANDLER, 37900: ZEND_INIT_STRING_SPEC_HANDLER, 37901: ZEND_INIT_STRING_SPEC_HANDLER, 37902: ZEND_INIT_STRING_SPEC_HANDLER, 37903: ZEND_INIT_STRING_SPEC_HANDLER, 37904: ZEND_NULL_HANDLER, 37905: ZEND_NULL_HANDLER, 37906: ZEND_NULL_HANDLER, 37907: ZEND_NULL_HANDLER, 37908: ZEND_NULL_HANDLER, 37909: ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER, 37910: ZEND_NULL_HANDLER, 37911: ZEND_NULL_HANDLER, 37912: ZEND_NULL_HANDLER, 37913: ZEND_NULL_HANDLER, 37914: ZEND_NULL_HANDLER, 37915: ZEND_NULL_HANDLER, 37916: ZEND_NULL_HANDLER, 37917: ZEND_NULL_HANDLER, 37918: ZEND_NULL_HANDLER, 37919: ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER, 37920: ZEND_NULL_HANDLER, 37921: ZEND_NULL_HANDLER, 37922: ZEND_NULL_HANDLER, 37923: ZEND_NULL_HANDLER, 37924: ZEND_NULL_HANDLER, 37925: ZEND_NULL_HANDLER, 37926: ZEND_NULL_HANDLER, 37927: ZEND_NULL_HANDLER, 37928: ZEND_NULL_HANDLER, 37929: ZEND_NULL_HANDLER, 37930: ZEND_NULL_HANDLER, 37931: ZEND_NULL_HANDLER, 37932: ZEND_NULL_HANDLER, 37933: ZEND_NULL_HANDLER, 37934: ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER, 37935: ZEND_NULL_HANDLER, 37936: ZEND_NULL_HANDLER, 37937: ZEND_NULL_HANDLER, 37938: ZEND_NULL_HANDLER, 37939: ZEND_NULL_HANDLER, 37940: ZEND_NULL_HANDLER, 37941: ZEND_NULL_HANDLER, 37942: ZEND_NULL_HANDLER, 37943: ZEND_NULL_HANDLER, 37944: ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER, 37945: ZEND_NULL_HANDLER, 37946: ZEND_NULL_HANDLER, 37947: ZEND_NULL_HANDLER, 37948: ZEND_NULL_HANDLER, 37949: ZEND_NULL_HANDLER, 37950: ZEND_NULL_HANDLER, 37951: ZEND_NULL_HANDLER, 37952: ZEND_NULL_HANDLER, 37953: ZEND_NULL_HANDLER, 37954: ZEND_NULL_HANDLER, 37955: ZEND_NULL_HANDLER, 37956: ZEND_NULL_HANDLER, 37957: ZEND_NULL_HANDLER, 37958: ZEND_NULL_HANDLER, 37959: ZEND_NULL_HANDLER, 37960: ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER, 37961: ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER, 37962: ZEND_NULL_HANDLER, 37963: ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER, 37964: ZEND_NULL_HANDLER, 37965: ZEND_NULL_HANDLER, 37966: ZEND_NULL_HANDLER, 37967: ZEND_NULL_HANDLER, 37968: ZEND_NULL_HANDLER, 37969: ZEND_NULL_HANDLER, 37970: ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER, 37971: ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER, 37972: ZEND_NULL_HANDLER, 37973: ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER, 37974: ZEND_NULL_HANDLER, 37975: ZEND_NULL_HANDLER, 37976: ZEND_NULL_HANDLER, 37977: ZEND_NULL_HANDLER, 37978: ZEND_NULL_HANDLER, 37979: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37980: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37981: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37982: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37983: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37984: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37985: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37986: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37987: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37988: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37989: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37990: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37991: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37992: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37993: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37994: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37995: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37996: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37997: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37998: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 37999: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 38000: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 38001: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 38002: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 38003: ZEND_BEGIN_SILENCE_SPEC_HANDLER, 38004: ZEND_NULL_HANDLER, 38005: ZEND_NULL_HANDLER, 38006: ZEND_NULL_HANDLER, 38007: ZEND_NULL_HANDLER, 38008: ZEND_NULL_HANDLER, 38009: ZEND_END_SILENCE_SPEC_TMP_HANDLER, 38010: ZEND_END_SILENCE_SPEC_TMP_HANDLER, 38011: ZEND_END_SILENCE_SPEC_TMP_HANDLER, 38012: ZEND_END_SILENCE_SPEC_TMP_HANDLER, 38013: ZEND_END_SILENCE_SPEC_TMP_HANDLER, 38014: ZEND_NULL_HANDLER, 38015: ZEND_NULL_HANDLER, 38016: ZEND_NULL_HANDLER, 38017: ZEND_NULL_HANDLER, 38018: ZEND_NULL_HANDLER, 38019: ZEND_NULL_HANDLER, 38020: ZEND_NULL_HANDLER, 38021: ZEND_NULL_HANDLER, 38022: ZEND_NULL_HANDLER, 38023: ZEND_NULL_HANDLER, 38024: ZEND_NULL_HANDLER, 38025: ZEND_NULL_HANDLER, 38026: ZEND_NULL_HANDLER, 38027: ZEND_NULL_HANDLER, 38028: ZEND_NULL_HANDLER, 38029: ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38030: ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER, 38031: ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER, 38032: ZEND_NULL_HANDLER, 38033: ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER, 38034: ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38035: ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER, 38036: ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER, 38037: ZEND_NULL_HANDLER, 38038: ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER, 38039: ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38040: ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER, 38041: ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER, 38042: ZEND_NULL_HANDLER, 38043: ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER, 38044: ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38045: ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER, 38046: ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER, 38047: ZEND_NULL_HANDLER, 38048: ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER, 38049: ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38050: ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER, 38051: ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER, 38052: ZEND_NULL_HANDLER, 38053: ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER, 38054: ZEND_DO_FCALL_SPEC_CONST_HANDLER, 38055: ZEND_DO_FCALL_SPEC_CONST_HANDLER, 38056: ZEND_DO_FCALL_SPEC_CONST_HANDLER, 38057: ZEND_DO_FCALL_SPEC_CONST_HANDLER, 38058: ZEND_DO_FCALL_SPEC_CONST_HANDLER, 38059: ZEND_NULL_HANDLER, 38060: ZEND_NULL_HANDLER, 38061: ZEND_NULL_HANDLER, 38062: ZEND_NULL_HANDLER, 38063: ZEND_NULL_HANDLER, 38064: ZEND_NULL_HANDLER, 38065: ZEND_NULL_HANDLER, 38066: ZEND_NULL_HANDLER, 38067: ZEND_NULL_HANDLER, 38068: ZEND_NULL_HANDLER, 38069: ZEND_NULL_HANDLER, 38070: ZEND_NULL_HANDLER, 38071: ZEND_NULL_HANDLER, 38072: ZEND_NULL_HANDLER, 38073: ZEND_NULL_HANDLER, 38074: ZEND_NULL_HANDLER, 38075: ZEND_NULL_HANDLER, 38076: ZEND_NULL_HANDLER, 38077: ZEND_NULL_HANDLER, 38078: ZEND_NULL_HANDLER, 38079: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38080: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38081: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38082: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38083: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38084: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38085: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38086: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38087: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38088: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38089: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38090: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38091: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38092: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38093: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38094: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38095: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38096: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38097: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38098: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38099: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38100: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38101: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38102: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38103: ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER, 38104: ZEND_RETURN_SPEC_CONST_HANDLER, 38105: ZEND_RETURN_SPEC_CONST_HANDLER, 38106: ZEND_RETURN_SPEC_CONST_HANDLER, 38107: ZEND_RETURN_SPEC_CONST_HANDLER, 38108: ZEND_RETURN_SPEC_CONST_HANDLER, 38109: ZEND_RETURN_SPEC_TMP_HANDLER, 38110: ZEND_RETURN_SPEC_TMP_HANDLER, 38111: ZEND_RETURN_SPEC_TMP_HANDLER, 38112: ZEND_RETURN_SPEC_TMP_HANDLER, 38113: ZEND_RETURN_SPEC_TMP_HANDLER, 38114: ZEND_RETURN_SPEC_VAR_HANDLER, 38115: ZEND_RETURN_SPEC_VAR_HANDLER, 38116: ZEND_RETURN_SPEC_VAR_HANDLER, 38117: ZEND_RETURN_SPEC_VAR_HANDLER, 38118: ZEND_RETURN_SPEC_VAR_HANDLER, 38119: ZEND_NULL_HANDLER, 38120: ZEND_NULL_HANDLER, 38121: ZEND_NULL_HANDLER, 38122: ZEND_NULL_HANDLER, 38123: ZEND_NULL_HANDLER, 38124: ZEND_RETURN_SPEC_CV_HANDLER, 38125: ZEND_RETURN_SPEC_CV_HANDLER, 38126: ZEND_RETURN_SPEC_CV_HANDLER, 38127: ZEND_RETURN_SPEC_CV_HANDLER, 38128: ZEND_RETURN_SPEC_CV_HANDLER, 38129: ZEND_RECV_SPEC_HANDLER, 38130: ZEND_RECV_SPEC_HANDLER, 38131: ZEND_RECV_SPEC_HANDLER, 38132: ZEND_RECV_SPEC_HANDLER, 38133: ZEND_RECV_SPEC_HANDLER, 38134: ZEND_RECV_SPEC_HANDLER, 38135: ZEND_RECV_SPEC_HANDLER, 38136: ZEND_RECV_SPEC_HANDLER, 38137: ZEND_RECV_SPEC_HANDLER, 38138: ZEND_RECV_SPEC_HANDLER, 38139: ZEND_RECV_SPEC_HANDLER, 38140: ZEND_RECV_SPEC_HANDLER, 38141: ZEND_RECV_SPEC_HANDLER, 38142: ZEND_RECV_SPEC_HANDLER, 38143: ZEND_RECV_SPEC_HANDLER, 38144: ZEND_RECV_SPEC_HANDLER, 38145: ZEND_RECV_SPEC_HANDLER, 38146: ZEND_RECV_SPEC_HANDLER, 38147: ZEND_RECV_SPEC_HANDLER, 38148: ZEND_RECV_SPEC_HANDLER, 38149: ZEND_RECV_SPEC_HANDLER, 38150: ZEND_RECV_SPEC_HANDLER, 38151: ZEND_RECV_SPEC_HANDLER, 38152: ZEND_RECV_SPEC_HANDLER, 38153: ZEND_RECV_SPEC_HANDLER, 38154: ZEND_RECV_INIT_SPEC_CONST_HANDLER, 38155: ZEND_NULL_HANDLER, 38156: ZEND_NULL_HANDLER, 38157: ZEND_NULL_HANDLER, 38158: ZEND_NULL_HANDLER, 38159: ZEND_RECV_INIT_SPEC_CONST_HANDLER, 38160: ZEND_NULL_HANDLER, 38161: ZEND_NULL_HANDLER, 38162: ZEND_NULL_HANDLER, 38163: ZEND_NULL_HANDLER, 38164: ZEND_RECV_INIT_SPEC_CONST_HANDLER, 38165: ZEND_NULL_HANDLER, 38166: ZEND_NULL_HANDLER, 38167: ZEND_NULL_HANDLER, 38168: ZEND_NULL_HANDLER, 38169: ZEND_RECV_INIT_SPEC_CONST_HANDLER, 38170: ZEND_NULL_HANDLER, 38171: ZEND_NULL_HANDLER, 38172: ZEND_NULL_HANDLER, 38173: ZEND_NULL_HANDLER, 38174: ZEND_RECV_INIT_SPEC_CONST_HANDLER, 38175: ZEND_NULL_HANDLER, 38176: ZEND_NULL_HANDLER, 38177: ZEND_NULL_HANDLER, 38178: ZEND_NULL_HANDLER, 38179: ZEND_SEND_VAL_SPEC_CONST_HANDLER, 38180: ZEND_SEND_VAL_SPEC_CONST_HANDLER, 38181: ZEND_SEND_VAL_SPEC_CONST_HANDLER, 38182: ZEND_SEND_VAL_SPEC_CONST_HANDLER, 38183: ZEND_SEND_VAL_SPEC_CONST_HANDLER, 38184: ZEND_SEND_VAL_SPEC_TMP_HANDLER, 38185: ZEND_SEND_VAL_SPEC_TMP_HANDLER, 38186: ZEND_SEND_VAL_SPEC_TMP_HANDLER, 38187: ZEND_SEND_VAL_SPEC_TMP_HANDLER, 38188: ZEND_SEND_VAL_SPEC_TMP_HANDLER, 38189: ZEND_NULL_HANDLER, 38190: ZEND_NULL_HANDLER, 38191: ZEND_NULL_HANDLER, 38192: ZEND_NULL_HANDLER, 38193: ZEND_NULL_HANDLER, 38194: ZEND_NULL_HANDLER, 38195: ZEND_NULL_HANDLER, 38196: ZEND_NULL_HANDLER, 38197: ZEND_NULL_HANDLER, 38198: ZEND_NULL_HANDLER, 38199: ZEND_NULL_HANDLER, 38200: ZEND_NULL_HANDLER, 38201: ZEND_NULL_HANDLER, 38202: ZEND_NULL_HANDLER, 38203: ZEND_NULL_HANDLER, 38204: ZEND_NULL_HANDLER, 38205: ZEND_NULL_HANDLER, 38206: ZEND_NULL_HANDLER, 38207: ZEND_NULL_HANDLER, 38208: ZEND_NULL_HANDLER, 38209: ZEND_NULL_HANDLER, 38210: ZEND_NULL_HANDLER, 38211: ZEND_NULL_HANDLER, 38212: ZEND_NULL_HANDLER, 38213: ZEND_NULL_HANDLER, 38214: ZEND_SEND_VAR_SPEC_VAR_HANDLER, 38215: ZEND_SEND_VAR_SPEC_VAR_HANDLER, 38216: ZEND_SEND_VAR_SPEC_VAR_HANDLER, 38217: ZEND_SEND_VAR_SPEC_VAR_HANDLER, 38218: ZEND_SEND_VAR_SPEC_VAR_HANDLER, 38219: ZEND_NULL_HANDLER, 38220: ZEND_NULL_HANDLER, 38221: ZEND_NULL_HANDLER, 38222: ZEND_NULL_HANDLER, 38223: ZEND_NULL_HANDLER, 38224: ZEND_SEND_VAR_SPEC_CV_HANDLER, 38225: ZEND_SEND_VAR_SPEC_CV_HANDLER, 38226: ZEND_SEND_VAR_SPEC_CV_HANDLER, 38227: ZEND_SEND_VAR_SPEC_CV_HANDLER, 38228: ZEND_SEND_VAR_SPEC_CV_HANDLER, 38229: ZEND_NULL_HANDLER, 38230: ZEND_NULL_HANDLER, 38231: ZEND_NULL_HANDLER, 38232: ZEND_NULL_HANDLER, 38233: ZEND_NULL_HANDLER, 38234: ZEND_NULL_HANDLER, 38235: ZEND_NULL_HANDLER, 38236: ZEND_NULL_HANDLER, 38237: ZEND_NULL_HANDLER, 38238: ZEND_NULL_HANDLER, 38239: ZEND_SEND_REF_SPEC_VAR_HANDLER, 38240: ZEND_SEND_REF_SPEC_VAR_HANDLER, 38241: ZEND_SEND_REF_SPEC_VAR_HANDLER, 38242: ZEND_SEND_REF_SPEC_VAR_HANDLER, 38243: ZEND_SEND_REF_SPEC_VAR_HANDLER, 38244: ZEND_NULL_HANDLER, 38245: ZEND_NULL_HANDLER, 38246: ZEND_NULL_HANDLER, 38247: ZEND_NULL_HANDLER, 38248: ZEND_NULL_HANDLER, 38249: ZEND_SEND_REF_SPEC_CV_HANDLER, 38250: ZEND_SEND_REF_SPEC_CV_HANDLER, 38251: ZEND_SEND_REF_SPEC_CV_HANDLER, 38252: ZEND_SEND_REF_SPEC_CV_HANDLER, 38253: ZEND_SEND_REF_SPEC_CV_HANDLER, 38254: ZEND_NEW_SPEC_HANDLER, 38255: ZEND_NEW_SPEC_HANDLER, 38256: ZEND_NEW_SPEC_HANDLER, 38257: ZEND_NEW_SPEC_HANDLER, 38258: ZEND_NEW_SPEC_HANDLER, 38259: ZEND_NEW_SPEC_HANDLER, 38260: ZEND_NEW_SPEC_HANDLER, 38261: ZEND_NEW_SPEC_HANDLER, 38262: ZEND_NEW_SPEC_HANDLER, 38263: ZEND_NEW_SPEC_HANDLER, 38264: ZEND_NEW_SPEC_HANDLER, 38265: ZEND_NEW_SPEC_HANDLER, 38266: ZEND_NEW_SPEC_HANDLER, 38267: ZEND_NEW_SPEC_HANDLER, 38268: ZEND_NEW_SPEC_HANDLER, 38269: ZEND_NEW_SPEC_HANDLER, 38270: ZEND_NEW_SPEC_HANDLER, 38271: ZEND_NEW_SPEC_HANDLER, 38272: ZEND_NEW_SPEC_HANDLER, 38273: ZEND_NEW_SPEC_HANDLER, 38274: ZEND_NEW_SPEC_HANDLER, 38275: ZEND_NEW_SPEC_HANDLER, 38276: ZEND_NEW_SPEC_HANDLER, 38277: ZEND_NEW_SPEC_HANDLER, 38278: ZEND_NEW_SPEC_HANDLER, 38279: ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38280: ZEND_NULL_HANDLER, 38281: ZEND_NULL_HANDLER, 38282: ZEND_NULL_HANDLER, 38283: ZEND_NULL_HANDLER, 38284: ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38285: ZEND_NULL_HANDLER, 38286: ZEND_NULL_HANDLER, 38287: ZEND_NULL_HANDLER, 38288: ZEND_NULL_HANDLER, 38289: ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38290: ZEND_NULL_HANDLER, 38291: ZEND_NULL_HANDLER, 38292: ZEND_NULL_HANDLER, 38293: ZEND_NULL_HANDLER, 38294: ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38295: ZEND_NULL_HANDLER, 38296: ZEND_NULL_HANDLER, 38297: ZEND_NULL_HANDLER, 38298: ZEND_NULL_HANDLER, 38299: ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, 38300: ZEND_NULL_HANDLER, 38301: ZEND_NULL_HANDLER, 38302: ZEND_NULL_HANDLER, 38303: ZEND_NULL_HANDLER, 38304: ZEND_NULL_HANDLER, 38305: ZEND_NULL_HANDLER, 38306: ZEND_NULL_HANDLER, 38307: ZEND_NULL_HANDLER, 38308: ZEND_NULL_HANDLER, 38309: ZEND_FREE_SPEC_TMP_HANDLER, 38310: ZEND_FREE_SPEC_TMP_HANDLER, 38311: ZEND_FREE_SPEC_TMP_HANDLER, 38312: ZEND_FREE_SPEC_TMP_HANDLER, 38313: ZEND_FREE_SPEC_TMP_HANDLER, 38314: ZEND_FREE_SPEC_VAR_HANDLER, 38315: ZEND_FREE_SPEC_VAR_HANDLER, 38316: ZEND_FREE_SPEC_VAR_HANDLER, 38317: ZEND_FREE_SPEC_VAR_HANDLER, 38318: ZEND_FREE_SPEC_VAR_HANDLER, 38319: ZEND_NULL_HANDLER, 38320: ZEND_NULL_HANDLER, 38321: ZEND_NULL_HANDLER, 38322: ZEND_NULL_HANDLER, 38323: ZEND_NULL_HANDLER, 38324: ZEND_NULL_HANDLER, 38325: ZEND_NULL_HANDLER, 38326: ZEND_NULL_HANDLER, 38327: ZEND_NULL_HANDLER, 38328: ZEND_NULL_HANDLER, 38329: ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER, 38330: ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER, 38331: ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER, 38332: ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER, 38333: ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER, 38334: ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER, 38335: ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER, 38336: ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER, 38337: ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER, 38338: ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER, 38339: ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER, 38340: ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER, 38341: ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER, 38342: ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER, 38343: ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER, 38344: ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER, 38345: ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER, 38346: ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER, 38347: ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER, 38348: ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER, 38349: ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER, 38350: ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER, 38351: ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER, 38352: ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER, 38353: ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER, 38354: ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER, 38355: ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER, 38356: ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER, 38357: ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER, 38358: ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER, 38359: ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER, 38360: ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER, 38361: ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER, 38362: ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER, 38363: ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER, 38364: ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER, 38365: ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER, 38366: ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER, 38367: ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER, 38368: ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER, 38369: ZEND_NULL_HANDLER, 38370: ZEND_NULL_HANDLER, 38371: ZEND_NULL_HANDLER, 38372: ZEND_NULL_HANDLER, 38373: ZEND_NULL_HANDLER, 38374: ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER, 38375: ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER, 38376: ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER, 38377: ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER, 38378: ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER, 38379: ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, 38380: ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, 38381: ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, 38382: ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, 38383: ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, 38384: ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER, 38385: ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER, 38386: ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER, 38387: ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER, 38388: ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER, 38389: ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER, 38390: ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER, 38391: ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER, 38392: ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER, 38393: ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER, 38394: ZEND_NULL_HANDLER, 38395: ZEND_NULL_HANDLER, 38396: ZEND_NULL_HANDLER, 38397: ZEND_NULL_HANDLER, 38398: ZEND_NULL_HANDLER, 38399: ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, 38400: ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, 38401: ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, 38402: ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, 38403: ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, 38404: ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER, 38405: ZEND_NULL_HANDLER, 38406: ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER, 38407: ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER, 38408: ZEND_NULL_HANDLER, 38409: ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER, 38410: ZEND_NULL_HANDLER, 38411: ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER, 38412: ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER, 38413: ZEND_NULL_HANDLER, 38414: ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER, 38415: ZEND_NULL_HANDLER, 38416: ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER, 38417: ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER, 38418: ZEND_NULL_HANDLER, 38419: ZEND_NULL_HANDLER, 38420: ZEND_NULL_HANDLER, 38421: ZEND_NULL_HANDLER, 38422: ZEND_NULL_HANDLER, 38423: ZEND_NULL_HANDLER, 38424: ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER, 38425: ZEND_NULL_HANDLER, 38426: ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER, 38427: ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER, 38428: ZEND_NULL_HANDLER, 38429: ZEND_NULL_HANDLER, 38430: ZEND_NULL_HANDLER, 38431: ZEND_NULL_HANDLER, 38432: ZEND_NULL_HANDLER, 38433: ZEND_NULL_HANDLER, 38434: ZEND_NULL_HANDLER, 38435: ZEND_NULL_HANDLER, 38436: ZEND_NULL_HANDLER, 38437: ZEND_NULL_HANDLER, 38438: ZEND_NULL_HANDLER, 38439: ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER, 38440: ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER, 38441: ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER, 38442: ZEND_NULL_HANDLER, 38443: ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER, 38444: ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER, 38445: ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER, 38446: ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER, 38447: ZEND_NULL_HANDLER, 38448: ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER, 38449: ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER, 38450: ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER, 38451: ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER, 38452: ZEND_NULL_HANDLER, 38453: ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER, 38454: ZEND_NULL_HANDLER, 38455: ZEND_NULL_HANDLER, 38456: ZEND_NULL_HANDLER, 38457: ZEND_NULL_HANDLER, 38458: ZEND_NULL_HANDLER, 38459: ZEND_NULL_HANDLER, 38460: ZEND_NULL_HANDLER, 38461: ZEND_NULL_HANDLER, 38462: ZEND_NULL_HANDLER, 38463: ZEND_NULL_HANDLER, 38464: ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER, 38465: ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER, 38466: ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER, 38467: ZEND_NULL_HANDLER, 38468: ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER, 38469: ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER, 38470: ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER, 38471: ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER, 38472: ZEND_NULL_HANDLER, 38473: ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER, 38474: ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER, 38475: ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER, 38476: ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER, 38477: ZEND_NULL_HANDLER, 38478: ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER, 38479: ZEND_FE_RESET_SPEC_CONST_HANDLER, 38480: ZEND_FE_RESET_SPEC_CONST_HANDLER, 38481: ZEND_FE_RESET_SPEC_CONST_HANDLER, 38482: ZEND_FE_RESET_SPEC_CONST_HANDLER, 38483: ZEND_FE_RESET_SPEC_CONST_HANDLER, 38484: ZEND_FE_RESET_SPEC_TMP_HANDLER, 38485: ZEND_FE_RESET_SPEC_TMP_HANDLER, 38486: ZEND_FE_RESET_SPEC_TMP_HANDLER, 38487: ZEND_FE_RESET_SPEC_TMP_HANDLER, 38488: ZEND_FE_RESET_SPEC_TMP_HANDLER, 38489: ZEND_FE_RESET_SPEC_VAR_HANDLER, 38490: ZEND_FE_RESET_SPEC_VAR_HANDLER, 38491: ZEND_FE_RESET_SPEC_VAR_HANDLER, 38492: ZEND_FE_RESET_SPEC_VAR_HANDLER, 38493: ZEND_FE_RESET_SPEC_VAR_HANDLER, 38494: ZEND_NULL_HANDLER, 38495: ZEND_NULL_HANDLER, 38496: ZEND_NULL_HANDLER, 38497: ZEND_NULL_HANDLER, 38498: ZEND_NULL_HANDLER, 38499: ZEND_FE_RESET_SPEC_CV_HANDLER, 38500: ZEND_FE_RESET_SPEC_CV_HANDLER, 38501: ZEND_FE_RESET_SPEC_CV_HANDLER, 38502: ZEND_FE_RESET_SPEC_CV_HANDLER, 38503: ZEND_FE_RESET_SPEC_CV_HANDLER, 38504: ZEND_NULL_HANDLER, 38505: ZEND_NULL_HANDLER, 38506: ZEND_NULL_HANDLER, 38507: ZEND_NULL_HANDLER, 38508: ZEND_NULL_HANDLER, 38509: ZEND_NULL_HANDLER, 38510: ZEND_NULL_HANDLER, 38511: ZEND_NULL_HANDLER, 38512: ZEND_NULL_HANDLER, 38513: ZEND_NULL_HANDLER, 38514: ZEND_FE_FETCH_SPEC_VAR_HANDLER, 38515: ZEND_FE_FETCH_SPEC_VAR_HANDLER, 38516: ZEND_FE_FETCH_SPEC_VAR_HANDLER, 38517: ZEND_FE_FETCH_SPEC_VAR_HANDLER, 38518: ZEND_FE_FETCH_SPEC_VAR_HANDLER, 38519: ZEND_NULL_HANDLER, 38520: ZEND_NULL_HANDLER, 38521: ZEND_NULL_HANDLER, 38522: ZEND_NULL_HANDLER, 38523: ZEND_NULL_HANDLER, 38524: ZEND_NULL_HANDLER, 38525: ZEND_NULL_HANDLER, 38526: ZEND_NULL_HANDLER, 38527: ZEND_NULL_HANDLER, 38528: ZEND_NULL_HANDLER, 38529: ZEND_EXIT_SPEC_CONST_HANDLER, 38530: ZEND_EXIT_SPEC_CONST_HANDLER, 38531: ZEND_EXIT_SPEC_CONST_HANDLER, 38532: ZEND_EXIT_SPEC_CONST_HANDLER, 38533: ZEND_EXIT_SPEC_CONST_HANDLER, 38534: ZEND_EXIT_SPEC_TMP_HANDLER, 38535: ZEND_EXIT_SPEC_TMP_HANDLER, 38536: ZEND_EXIT_SPEC_TMP_HANDLER, 38537: ZEND_EXIT_SPEC_TMP_HANDLER, 38538: ZEND_EXIT_SPEC_TMP_HANDLER, 38539: ZEND_EXIT_SPEC_VAR_HANDLER, 38540: ZEND_EXIT_SPEC_VAR_HANDLER, 38541: ZEND_EXIT_SPEC_VAR_HANDLER, 38542: ZEND_EXIT_SPEC_VAR_HANDLER, 38543: ZEND_EXIT_SPEC_VAR_HANDLER, 38544: ZEND_EXIT_SPEC_UNUSED_HANDLER, 38545: ZEND_EXIT_SPEC_UNUSED_HANDLER, 38546: ZEND_EXIT_SPEC_UNUSED_HANDLER, 38547: ZEND_EXIT_SPEC_UNUSED_HANDLER, 38548: ZEND_EXIT_SPEC_UNUSED_HANDLER, 38549: ZEND_EXIT_SPEC_CV_HANDLER, 38550: ZEND_EXIT_SPEC_CV_HANDLER, 38551: ZEND_EXIT_SPEC_CV_HANDLER, 38552: ZEND_EXIT_SPEC_CV_HANDLER, 38553: ZEND_EXIT_SPEC_CV_HANDLER, 38554: ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER, 38555: ZEND_NULL_HANDLER, 38556: ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER, 38557: ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER, 38558: ZEND_NULL_HANDLER, 38559: ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER, 38560: ZEND_NULL_HANDLER, 38561: ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER, 38562: ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER, 38563: ZEND_NULL_HANDLER, 38564: ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER, 38565: ZEND_NULL_HANDLER, 38566: ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER, 38567: ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER, 38568: ZEND_NULL_HANDLER, 38569: ZEND_NULL_HANDLER, 38570: ZEND_NULL_HANDLER, 38571: ZEND_NULL_HANDLER, 38572: ZEND_NULL_HANDLER, 38573: ZEND_NULL_HANDLER, 38574: ZEND_FETCH_R_SPEC_CV_CONST_HANDLER, 38575: ZEND_NULL_HANDLER, 38576: ZEND_FETCH_R_SPEC_CV_VAR_HANDLER, 38577: ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER, 38578: ZEND_NULL_HANDLER, 38579: ZEND_NULL_HANDLER, 38580: ZEND_NULL_HANDLER, 38581: ZEND_NULL_HANDLER, 38582: ZEND_NULL_HANDLER, 38583: ZEND_NULL_HANDLER, 38584: ZEND_NULL_HANDLER, 38585: ZEND_NULL_HANDLER, 38586: ZEND_NULL_HANDLER, 38587: ZEND_NULL_HANDLER, 38588: ZEND_NULL_HANDLER, 38589: ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER, 38590: ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER, 38591: ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER, 38592: ZEND_NULL_HANDLER, 38593: ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER, 38594: ZEND_NULL_HANDLER, 38595: ZEND_NULL_HANDLER, 38596: ZEND_NULL_HANDLER, 38597: ZEND_NULL_HANDLER, 38598: ZEND_NULL_HANDLER, 38599: ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER, 38600: ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER, 38601: ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER, 38602: ZEND_NULL_HANDLER, 38603: ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER, 38604: ZEND_NULL_HANDLER, 38605: ZEND_NULL_HANDLER, 38606: ZEND_NULL_HANDLER, 38607: ZEND_NULL_HANDLER, 38608: ZEND_NULL_HANDLER, 38609: ZEND_NULL_HANDLER, 38610: ZEND_NULL_HANDLER, 38611: ZEND_NULL_HANDLER, 38612: ZEND_NULL_HANDLER, 38613: ZEND_NULL_HANDLER, 38614: ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER, 38615: ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER, 38616: ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER, 38617: ZEND_NULL_HANDLER, 38618: ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER, 38619: ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER, 38620: ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER, 38621: ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER, 38622: ZEND_NULL_HANDLER, 38623: ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER, 38624: ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER, 38625: ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER, 38626: ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER, 38627: ZEND_NULL_HANDLER, 38628: ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER, 38629: ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER, 38630: ZEND_NULL_HANDLER, 38631: ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER, 38632: ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER, 38633: ZEND_NULL_HANDLER, 38634: ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER, 38635: ZEND_NULL_HANDLER, 38636: ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER, 38637: ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER, 38638: ZEND_NULL_HANDLER, 38639: ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER, 38640: ZEND_NULL_HANDLER, 38641: ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER, 38642: ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER, 38643: ZEND_NULL_HANDLER, 38644: ZEND_NULL_HANDLER, 38645: ZEND_NULL_HANDLER, 38646: ZEND_NULL_HANDLER, 38647: ZEND_NULL_HANDLER, 38648: ZEND_NULL_HANDLER, 38649: ZEND_FETCH_W_SPEC_CV_CONST_HANDLER, 38650: ZEND_NULL_HANDLER, 38651: ZEND_FETCH_W_SPEC_CV_VAR_HANDLER, 38652: ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER, 38653: ZEND_NULL_HANDLER, 38654: ZEND_NULL_HANDLER, 38655: ZEND_NULL_HANDLER, 38656: ZEND_NULL_HANDLER, 38657: ZEND_NULL_HANDLER, 38658: ZEND_NULL_HANDLER, 38659: ZEND_NULL_HANDLER, 38660: ZEND_NULL_HANDLER, 38661: ZEND_NULL_HANDLER, 38662: ZEND_NULL_HANDLER, 38663: ZEND_NULL_HANDLER, 38664: ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER, 38665: ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER, 38666: ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER, 38667: ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER, 38668: ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER, 38669: ZEND_NULL_HANDLER, 38670: ZEND_NULL_HANDLER, 38671: ZEND_NULL_HANDLER, 38672: ZEND_NULL_HANDLER, 38673: ZEND_NULL_HANDLER, 38674: ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER, 38675: ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER, 38676: ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER, 38677: ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER, 38678: ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER, 38679: ZEND_NULL_HANDLER, 38680: ZEND_NULL_HANDLER, 38681: ZEND_NULL_HANDLER, 38682: ZEND_NULL_HANDLER, 38683: ZEND_NULL_HANDLER, 38684: ZEND_NULL_HANDLER, 38685: ZEND_NULL_HANDLER, 38686: ZEND_NULL_HANDLER, 38687: ZEND_NULL_HANDLER, 38688: ZEND_NULL_HANDLER, 38689: ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER, 38690: ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER, 38691: ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER, 38692: ZEND_NULL_HANDLER, 38693: ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER, 38694: ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER, 38695: ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER, 38696: ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER, 38697: ZEND_NULL_HANDLER, 38698: ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER, 38699: ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER, 38700: ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER, 38701: ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER, 38702: ZEND_NULL_HANDLER, 38703: ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER, 38704: ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER, 38705: ZEND_NULL_HANDLER, 38706: ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER, 38707: ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER, 38708: ZEND_NULL_HANDLER, 38709: ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER, 38710: ZEND_NULL_HANDLER, 38711: ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER, 38712: ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER, 38713: ZEND_NULL_HANDLER, 38714: ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER, 38715: ZEND_NULL_HANDLER, 38716: ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER, 38717: ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER, 38718: ZEND_NULL_HANDLER, 38719: ZEND_NULL_HANDLER, 38720: ZEND_NULL_HANDLER, 38721: ZEND_NULL_HANDLER, 38722: ZEND_NULL_HANDLER, 38723: ZEND_NULL_HANDLER, 38724: ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER, 38725: ZEND_NULL_HANDLER, 38726: ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER, 38727: ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER, 38728: ZEND_NULL_HANDLER, 38729: ZEND_NULL_HANDLER, 38730: ZEND_NULL_HANDLER, 38731: ZEND_NULL_HANDLER, 38732: ZEND_NULL_HANDLER, 38733: ZEND_NULL_HANDLER, 38734: ZEND_NULL_HANDLER, 38735: ZEND_NULL_HANDLER, 38736: ZEND_NULL_HANDLER, 38737: ZEND_NULL_HANDLER, 38738: ZEND_NULL_HANDLER, 38739: ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER, 38740: ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER, 38741: ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER, 38742: ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER, 38743: ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER, 38744: ZEND_NULL_HANDLER, 38745: ZEND_NULL_HANDLER, 38746: ZEND_NULL_HANDLER, 38747: ZEND_NULL_HANDLER, 38748: ZEND_NULL_HANDLER, 38749: ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER, 38750: ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER, 38751: ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER, 38752: ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER, 38753: ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER, 38754: ZEND_NULL_HANDLER, 38755: ZEND_NULL_HANDLER, 38756: ZEND_NULL_HANDLER, 38757: ZEND_NULL_HANDLER, 38758: ZEND_NULL_HANDLER, 38759: ZEND_NULL_HANDLER, 38760: ZEND_NULL_HANDLER, 38761: ZEND_NULL_HANDLER, 38762: ZEND_NULL_HANDLER, 38763: ZEND_NULL_HANDLER, 38764: ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER, 38765: ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER, 38766: ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER, 38767: ZEND_NULL_HANDLER, 38768: ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER, 38769: ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER, 38770: ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER, 38771: ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER, 38772: ZEND_NULL_HANDLER, 38773: ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER, 38774: ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER, 38775: ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER, 38776: ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER, 38777: ZEND_NULL_HANDLER, 38778: ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER, 38779: ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER, 38780: ZEND_NULL_HANDLER, 38781: ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER, 38782: ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER, 38783: ZEND_NULL_HANDLER, 38784: ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER, 38785: ZEND_NULL_HANDLER, 38786: ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER, 38787: ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER, 38788: ZEND_NULL_HANDLER, 38789: ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER, 38790: ZEND_NULL_HANDLER, 38791: ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER, 38792: ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER, 38793: ZEND_NULL_HANDLER, 38794: ZEND_NULL_HANDLER, 38795: ZEND_NULL_HANDLER, 38796: ZEND_NULL_HANDLER, 38797: ZEND_NULL_HANDLER, 38798: ZEND_NULL_HANDLER, 38799: ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER, 38800: ZEND_NULL_HANDLER, 38801: ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER, 38802: ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER, 38803: ZEND_NULL_HANDLER, 38804: ZEND_NULL_HANDLER, 38805: ZEND_NULL_HANDLER, 38806: ZEND_NULL_HANDLER, 38807: ZEND_NULL_HANDLER, 38808: ZEND_NULL_HANDLER, 38809: ZEND_NULL_HANDLER, 38810: ZEND_NULL_HANDLER, 38811: ZEND_NULL_HANDLER, 38812: ZEND_NULL_HANDLER, 38813: ZEND_NULL_HANDLER, 38814: ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER, 38815: ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER, 38816: ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER, 38817: ZEND_NULL_HANDLER, 38818: ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER, 38819: ZEND_NULL_HANDLER, 38820: ZEND_NULL_HANDLER, 38821: ZEND_NULL_HANDLER, 38822: ZEND_NULL_HANDLER, 38823: ZEND_NULL_HANDLER, 38824: ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER, 38825: ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER, 38826: ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER, 38827: ZEND_NULL_HANDLER, 38828: ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER, 38829: ZEND_NULL_HANDLER, 38830: ZEND_NULL_HANDLER, 38831: ZEND_NULL_HANDLER, 38832: ZEND_NULL_HANDLER, 38833: ZEND_NULL_HANDLER, 38834: ZEND_NULL_HANDLER, 38835: ZEND_NULL_HANDLER, 38836: ZEND_NULL_HANDLER, 38837: ZEND_NULL_HANDLER, 38838: ZEND_NULL_HANDLER, 38839: ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER, 38840: ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER, 38841: ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER, 38842: ZEND_NULL_HANDLER, 38843: ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER, 38844: ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER, 38845: ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER, 38846: ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER, 38847: ZEND_NULL_HANDLER, 38848: ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER, 38849: ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER, 38850: ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER, 38851: ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER, 38852: ZEND_NULL_HANDLER, 38853: ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER, 38854: ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER, 38855: ZEND_NULL_HANDLER, 38856: ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER, 38857: ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER, 38858: ZEND_NULL_HANDLER, 38859: ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER, 38860: ZEND_NULL_HANDLER, 38861: ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER, 38862: ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER, 38863: ZEND_NULL_HANDLER, 38864: ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER, 38865: ZEND_NULL_HANDLER, 38866: ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER, 38867: ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER, 38868: ZEND_NULL_HANDLER, 38869: ZEND_NULL_HANDLER, 38870: ZEND_NULL_HANDLER, 38871: ZEND_NULL_HANDLER, 38872: ZEND_NULL_HANDLER, 38873: ZEND_NULL_HANDLER, 38874: ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER, 38875: ZEND_NULL_HANDLER, 38876: ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER, 38877: ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER, 38878: ZEND_NULL_HANDLER, 38879: ZEND_NULL_HANDLER, 38880: ZEND_NULL_HANDLER, 38881: ZEND_NULL_HANDLER, 38882: ZEND_NULL_HANDLER, 38883: ZEND_NULL_HANDLER, 38884: ZEND_NULL_HANDLER, 38885: ZEND_NULL_HANDLER, 38886: ZEND_NULL_HANDLER, 38887: ZEND_NULL_HANDLER, 38888: ZEND_NULL_HANDLER, 38889: ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER, 38890: ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER, 38891: ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER, 38892: ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER, 38893: ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER, 38894: ZEND_NULL_HANDLER, 38895: ZEND_NULL_HANDLER, 38896: ZEND_NULL_HANDLER, 38897: ZEND_NULL_HANDLER, 38898: ZEND_NULL_HANDLER, 38899: ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER, 38900: ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER, 38901: ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER, 38902: ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER, 38903: ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER, 38904: ZEND_NULL_HANDLER, 38905: ZEND_NULL_HANDLER, 38906: ZEND_NULL_HANDLER, 38907: ZEND_NULL_HANDLER, 38908: ZEND_NULL_HANDLER, 38909: ZEND_NULL_HANDLER, 38910: ZEND_NULL_HANDLER, 38911: ZEND_NULL_HANDLER, 38912: ZEND_NULL_HANDLER, 38913: ZEND_NULL_HANDLER, 38914: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER, 38915: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER, 38916: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER, 38917: ZEND_NULL_HANDLER, 38918: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER, 38919: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER, 38920: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER, 38921: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER, 38922: ZEND_NULL_HANDLER, 38923: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER, 38924: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER, 38925: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER, 38926: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER, 38927: ZEND_NULL_HANDLER, 38928: ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER, 38929: ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER, 38930: ZEND_NULL_HANDLER, 38931: ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER, 38932: ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER, 38933: ZEND_NULL_HANDLER, 38934: ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER, 38935: ZEND_NULL_HANDLER, 38936: ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER, 38937: ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER, 38938: ZEND_NULL_HANDLER, 38939: ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER, 38940: ZEND_NULL_HANDLER, 38941: ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER, 38942: ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER, 38943: ZEND_NULL_HANDLER, 38944: ZEND_NULL_HANDLER, 38945: ZEND_NULL_HANDLER, 38946: ZEND_NULL_HANDLER, 38947: ZEND_NULL_HANDLER, 38948: ZEND_NULL_HANDLER, 38949: ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER, 38950: ZEND_NULL_HANDLER, 38951: ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER, 38952: ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER, 38953: ZEND_NULL_HANDLER, 38954: ZEND_NULL_HANDLER, 38955: ZEND_NULL_HANDLER, 38956: ZEND_NULL_HANDLER, 38957: ZEND_NULL_HANDLER, 38958: ZEND_NULL_HANDLER, 38959: ZEND_NULL_HANDLER, 38960: ZEND_NULL_HANDLER, 38961: ZEND_NULL_HANDLER, 38962: ZEND_NULL_HANDLER, 38963: ZEND_NULL_HANDLER, 38964: ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER, 38965: ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER, 38966: ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER, 38967: ZEND_NULL_HANDLER, 38968: ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER, 38969: ZEND_NULL_HANDLER, 38970: ZEND_NULL_HANDLER, 38971: ZEND_NULL_HANDLER, 38972: ZEND_NULL_HANDLER, 38973: ZEND_NULL_HANDLER, 38974: ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER, 38975: ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER, 38976: ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER, 38977: ZEND_NULL_HANDLER, 38978: ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER, 38979: ZEND_NULL_HANDLER, 38980: ZEND_NULL_HANDLER, 38981: ZEND_NULL_HANDLER, 38982: ZEND_NULL_HANDLER, 38983: ZEND_NULL_HANDLER, 38984: ZEND_NULL_HANDLER, 38985: ZEND_NULL_HANDLER, 38986: ZEND_NULL_HANDLER, 38987: ZEND_NULL_HANDLER, 38988: ZEND_NULL_HANDLER, 38989: ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER, 38990: ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER, 38991: ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER, 38992: ZEND_NULL_HANDLER, 38993: ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER, 38994: ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER, 38995: ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER, 38996: ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER, 38997: ZEND_NULL_HANDLER, 38998: ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER, 38999: ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER, 39000: ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER, 39001: ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER, 39002: ZEND_NULL_HANDLER, 39003: ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER, 39004: ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER, 39005: ZEND_NULL_HANDLER, 39006: ZEND_NULL_HANDLER, 39007: ZEND_NULL_HANDLER, 39008: ZEND_NULL_HANDLER, 39009: ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER, 39010: ZEND_NULL_HANDLER, 39011: ZEND_NULL_HANDLER, 39012: ZEND_NULL_HANDLER, 39013: ZEND_NULL_HANDLER, 39014: ZEND_NULL_HANDLER, 39015: ZEND_NULL_HANDLER, 39016: ZEND_NULL_HANDLER, 39017: ZEND_NULL_HANDLER, 39018: ZEND_NULL_HANDLER, 39019: ZEND_NULL_HANDLER, 39020: ZEND_NULL_HANDLER, 39021: ZEND_NULL_HANDLER, 39022: ZEND_NULL_HANDLER, 39023: ZEND_NULL_HANDLER, 39024: ZEND_NULL_HANDLER, 39025: ZEND_NULL_HANDLER, 39026: ZEND_NULL_HANDLER, 39027: ZEND_NULL_HANDLER, 39028: ZEND_NULL_HANDLER, 39029: ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER, 39030: ZEND_NULL_HANDLER, 39031: ZEND_NULL_HANDLER, 39032: ZEND_NULL_HANDLER, 39033: ZEND_NULL_HANDLER, 39034: ZEND_NULL_HANDLER, 39035: ZEND_NULL_HANDLER, 39036: ZEND_NULL_HANDLER, 39037: ZEND_NULL_HANDLER, 39038: ZEND_NULL_HANDLER, 39039: ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER, 39040: ZEND_NULL_HANDLER, 39041: ZEND_NULL_HANDLER, 39042: ZEND_NULL_HANDLER, 39043: ZEND_NULL_HANDLER, 39044: ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER, 39045: ZEND_NULL_HANDLER, 39046: ZEND_NULL_HANDLER, 39047: ZEND_NULL_HANDLER, 39048: ZEND_NULL_HANDLER, 39049: ZEND_NULL_HANDLER, 39050: ZEND_NULL_HANDLER, 39051: ZEND_NULL_HANDLER, 39052: ZEND_NULL_HANDLER, 39053: ZEND_NULL_HANDLER, 39054: ZEND_GOTO_SPEC_CONST_HANDLER, 39055: ZEND_NULL_HANDLER, 39056: ZEND_NULL_HANDLER, 39057: ZEND_NULL_HANDLER, 39058: ZEND_NULL_HANDLER, 39059: ZEND_GOTO_SPEC_CONST_HANDLER, 39060: ZEND_NULL_HANDLER, 39061: ZEND_NULL_HANDLER, 39062: ZEND_NULL_HANDLER, 39063: ZEND_NULL_HANDLER, 39064: ZEND_GOTO_SPEC_CONST_HANDLER, 39065: ZEND_NULL_HANDLER, 39066: ZEND_NULL_HANDLER, 39067: ZEND_NULL_HANDLER, 39068: ZEND_NULL_HANDLER, 39069: ZEND_GOTO_SPEC_CONST_HANDLER, 39070: ZEND_NULL_HANDLER, 39071: ZEND_NULL_HANDLER, 39072: ZEND_NULL_HANDLER, 39073: ZEND_NULL_HANDLER, 39074: ZEND_GOTO_SPEC_CONST_HANDLER, 39075: ZEND_NULL_HANDLER, 39076: ZEND_NULL_HANDLER, 39077: ZEND_NULL_HANDLER, 39078: ZEND_NULL_HANDLER, 39079: ZEND_EXT_STMT_SPEC_HANDLER, 39080: ZEND_EXT_STMT_SPEC_HANDLER, 39081: ZEND_EXT_STMT_SPEC_HANDLER, 39082: ZEND_EXT_STMT_SPEC_HANDLER, 39083: ZEND_EXT_STMT_SPEC_HANDLER, 39084: ZEND_EXT_STMT_SPEC_HANDLER, 39085: ZEND_EXT_STMT_SPEC_HANDLER, 39086: ZEND_EXT_STMT_SPEC_HANDLER, 39087: ZEND_EXT_STMT_SPEC_HANDLER, 39088: ZEND_EXT_STMT_SPEC_HANDLER, 39089: ZEND_EXT_STMT_SPEC_HANDLER, 39090: ZEND_EXT_STMT_SPEC_HANDLER, 39091: ZEND_EXT_STMT_SPEC_HANDLER, 39092: ZEND_EXT_STMT_SPEC_HANDLER, 39093: ZEND_EXT_STMT_SPEC_HANDLER, 39094: ZEND_EXT_STMT_SPEC_HANDLER, 39095: ZEND_EXT_STMT_SPEC_HANDLER, 39096: ZEND_EXT_STMT_SPEC_HANDLER, 39097: ZEND_EXT_STMT_SPEC_HANDLER, 39098: ZEND_EXT_STMT_SPEC_HANDLER, 39099: ZEND_EXT_STMT_SPEC_HANDLER, 39100: ZEND_EXT_STMT_SPEC_HANDLER, 39101: ZEND_EXT_STMT_SPEC_HANDLER, 39102: ZEND_EXT_STMT_SPEC_HANDLER, 39103: ZEND_EXT_STMT_SPEC_HANDLER, 39104: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39105: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39106: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39107: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39108: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39109: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39110: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39111: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39112: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39113: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39114: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39115: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39116: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39117: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39118: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39119: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39120: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39121: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39122: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39123: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39124: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39125: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39126: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39127: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39128: ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, 39129: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39130: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39131: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39132: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39133: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39134: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39135: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39136: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39137: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39138: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39139: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39140: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39141: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39142: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39143: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39144: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39145: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39146: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39147: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39148: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39149: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39150: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39151: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39152: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39153: ZEND_EXT_FCALL_END_SPEC_HANDLER, 39154: ZEND_EXT_NOP_SPEC_HANDLER, 39155: ZEND_EXT_NOP_SPEC_HANDLER, 39156: ZEND_EXT_NOP_SPEC_HANDLER, 39157: ZEND_EXT_NOP_SPEC_HANDLER, 39158: ZEND_EXT_NOP_SPEC_HANDLER, 39159: ZEND_EXT_NOP_SPEC_HANDLER, 39160: ZEND_EXT_NOP_SPEC_HANDLER, 39161: ZEND_EXT_NOP_SPEC_HANDLER, 39162: ZEND_EXT_NOP_SPEC_HANDLER, 39163: ZEND_EXT_NOP_SPEC_HANDLER, 39164: ZEND_EXT_NOP_SPEC_HANDLER, 39165: ZEND_EXT_NOP_SPEC_HANDLER, 39166: ZEND_EXT_NOP_SPEC_HANDLER, 39167: ZEND_EXT_NOP_SPEC_HANDLER, 39168: ZEND_EXT_NOP_SPEC_HANDLER, 39169: ZEND_EXT_NOP_SPEC_HANDLER, 39170: ZEND_EXT_NOP_SPEC_HANDLER, 39171: ZEND_EXT_NOP_SPEC_HANDLER, 39172: ZEND_EXT_NOP_SPEC_HANDLER, 39173: ZEND_EXT_NOP_SPEC_HANDLER, 39174: ZEND_EXT_NOP_SPEC_HANDLER, 39175: ZEND_EXT_NOP_SPEC_HANDLER, 39176: ZEND_EXT_NOP_SPEC_HANDLER, 39177: ZEND_EXT_NOP_SPEC_HANDLER, 39178: ZEND_EXT_NOP_SPEC_HANDLER, 39179: ZEND_TICKS_SPEC_HANDLER, 39180: ZEND_TICKS_SPEC_HANDLER, 39181: ZEND_TICKS_SPEC_HANDLER, 39182: ZEND_TICKS_SPEC_HANDLER, 39183: ZEND_TICKS_SPEC_HANDLER, 39184: ZEND_TICKS_SPEC_HANDLER, 39185: ZEND_TICKS_SPEC_HANDLER, 39186: ZEND_TICKS_SPEC_HANDLER, 39187: ZEND_TICKS_SPEC_HANDLER, 39188: ZEND_TICKS_SPEC_HANDLER, 39189: ZEND_TICKS_SPEC_HANDLER, 39190: ZEND_TICKS_SPEC_HANDLER, 39191: ZEND_TICKS_SPEC_HANDLER, 39192: ZEND_TICKS_SPEC_HANDLER, 39193: ZEND_TICKS_SPEC_HANDLER, 39194: ZEND_TICKS_SPEC_HANDLER, 39195: ZEND_TICKS_SPEC_HANDLER, 39196: ZEND_TICKS_SPEC_HANDLER, 39197: ZEND_TICKS_SPEC_HANDLER, 39198: ZEND_TICKS_SPEC_HANDLER, 39199: ZEND_TICKS_SPEC_HANDLER, 39200: ZEND_TICKS_SPEC_HANDLER, 39201: ZEND_TICKS_SPEC_HANDLER, 39202: ZEND_TICKS_SPEC_HANDLER, 39203: ZEND_TICKS_SPEC_HANDLER, 39204: ZEND_NULL_HANDLER, 39205: ZEND_NULL_HANDLER, 39206: ZEND_NULL_HANDLER, 39207: ZEND_NULL_HANDLER, 39208: ZEND_NULL_HANDLER, 39209: ZEND_NULL_HANDLER, 39210: ZEND_NULL_HANDLER, 39211: ZEND_NULL_HANDLER, 39212: ZEND_NULL_HANDLER, 39213: ZEND_NULL_HANDLER, 39214: ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER, 39215: ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER, 39216: ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER, 39217: ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER, 39218: ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER, 39219: ZEND_NULL_HANDLER, 39220: ZEND_NULL_HANDLER, 39221: ZEND_NULL_HANDLER, 39222: ZEND_NULL_HANDLER, 39223: ZEND_NULL_HANDLER, 39224: ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER, 39225: ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER, 39226: ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER, 39227: ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER, 39228: ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER, 39229: ZEND_NULL_HANDLER, 39230: ZEND_NULL_HANDLER, 39231: ZEND_NULL_HANDLER, 39232: ZEND_NULL_HANDLER, 39233: ZEND_CATCH_SPEC_CONST_CV_HANDLER, 39234: ZEND_NULL_HANDLER, 39235: ZEND_NULL_HANDLER, 39236: ZEND_NULL_HANDLER, 39237: ZEND_NULL_HANDLER, 39238: ZEND_NULL_HANDLER, 39239: ZEND_NULL_HANDLER, 39240: ZEND_NULL_HANDLER, 39241: ZEND_NULL_HANDLER, 39242: ZEND_NULL_HANDLER, 39243: ZEND_NULL_HANDLER, 39244: ZEND_NULL_HANDLER, 39245: ZEND_NULL_HANDLER, 39246: ZEND_NULL_HANDLER, 39247: ZEND_NULL_HANDLER, 39248: ZEND_NULL_HANDLER, 39249: ZEND_NULL_HANDLER, 39250: ZEND_NULL_HANDLER, 39251: ZEND_NULL_HANDLER, 39252: ZEND_NULL_HANDLER, 39253: ZEND_NULL_HANDLER, 39254: ZEND_THROW_SPEC_CONST_HANDLER, 39255: ZEND_THROW_SPEC_CONST_HANDLER, 39256: ZEND_THROW_SPEC_CONST_HANDLER, 39257: ZEND_THROW_SPEC_CONST_HANDLER, 39258: ZEND_THROW_SPEC_CONST_HANDLER, 39259: ZEND_THROW_SPEC_TMP_HANDLER, 39260: ZEND_THROW_SPEC_TMP_HANDLER, 39261: ZEND_THROW_SPEC_TMP_HANDLER, 39262: ZEND_THROW_SPEC_TMP_HANDLER, 39263: ZEND_THROW_SPEC_TMP_HANDLER, 39264: ZEND_THROW_SPEC_VAR_HANDLER, 39265: ZEND_THROW_SPEC_VAR_HANDLER, 39266: ZEND_THROW_SPEC_VAR_HANDLER, 39267: ZEND_THROW_SPEC_VAR_HANDLER, 39268: ZEND_THROW_SPEC_VAR_HANDLER, 39269: ZEND_NULL_HANDLER, 39270: ZEND_NULL_HANDLER, 39271: ZEND_NULL_HANDLER, 39272: ZEND_NULL_HANDLER, 39273: ZEND_NULL_HANDLER, 39274: ZEND_THROW_SPEC_CV_HANDLER, 39275: ZEND_THROW_SPEC_CV_HANDLER, 39276: ZEND_THROW_SPEC_CV_HANDLER, 39277: ZEND_THROW_SPEC_CV_HANDLER, 39278: ZEND_THROW_SPEC_CV_HANDLER, 39279: ZEND_FETCH_CLASS_SPEC_CONST_HANDLER, 39280: ZEND_FETCH_CLASS_SPEC_TMP_HANDLER, 39281: ZEND_FETCH_CLASS_SPEC_VAR_HANDLER, 39282: ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER, 39283: ZEND_FETCH_CLASS_SPEC_CV_HANDLER, 39284: ZEND_FETCH_CLASS_SPEC_CONST_HANDLER, 39285: ZEND_FETCH_CLASS_SPEC_TMP_HANDLER, 39286: ZEND_FETCH_CLASS_SPEC_VAR_HANDLER, 39287: ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER, 39288: ZEND_FETCH_CLASS_SPEC_CV_HANDLER, 39289: ZEND_FETCH_CLASS_SPEC_CONST_HANDLER, 39290: ZEND_FETCH_CLASS_SPEC_TMP_HANDLER, 39291: ZEND_FETCH_CLASS_SPEC_VAR_HANDLER, 39292: ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER, 39293: ZEND_FETCH_CLASS_SPEC_CV_HANDLER, 39294: ZEND_FETCH_CLASS_SPEC_CONST_HANDLER, 39295: ZEND_FETCH_CLASS_SPEC_TMP_HANDLER, 39296: ZEND_FETCH_CLASS_SPEC_VAR_HANDLER, 39297: ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER, 39298: ZEND_FETCH_CLASS_SPEC_CV_HANDLER, 39299: ZEND_FETCH_CLASS_SPEC_CONST_HANDLER, 39300: ZEND_FETCH_CLASS_SPEC_TMP_HANDLER, 39301: ZEND_FETCH_CLASS_SPEC_VAR_HANDLER, 39302: ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER, 39303: ZEND_FETCH_CLASS_SPEC_CV_HANDLER, 39304: ZEND_CLONE_SPEC_CONST_HANDLER, 39305: ZEND_CLONE_SPEC_CONST_HANDLER, 39306: ZEND_CLONE_SPEC_CONST_HANDLER, 39307: ZEND_CLONE_SPEC_CONST_HANDLER, 39308: ZEND_CLONE_SPEC_CONST_HANDLER, 39309: ZEND_CLONE_SPEC_TMP_HANDLER, 39310: ZEND_CLONE_SPEC_TMP_HANDLER, 39311: ZEND_CLONE_SPEC_TMP_HANDLER, 39312: ZEND_CLONE_SPEC_TMP_HANDLER, 39313: ZEND_CLONE_SPEC_TMP_HANDLER, 39314: ZEND_CLONE_SPEC_VAR_HANDLER, 39315: ZEND_CLONE_SPEC_VAR_HANDLER, 39316: ZEND_CLONE_SPEC_VAR_HANDLER, 39317: ZEND_CLONE_SPEC_VAR_HANDLER, 39318: ZEND_CLONE_SPEC_VAR_HANDLER, 39319: ZEND_CLONE_SPEC_UNUSED_HANDLER, 39320: ZEND_CLONE_SPEC_UNUSED_HANDLER, 39321: ZEND_CLONE_SPEC_UNUSED_HANDLER, 39322: ZEND_CLONE_SPEC_UNUSED_HANDLER, 39323: ZEND_CLONE_SPEC_UNUSED_HANDLER, 39324: ZEND_CLONE_SPEC_CV_HANDLER, 39325: ZEND_CLONE_SPEC_CV_HANDLER, 39326: ZEND_CLONE_SPEC_CV_HANDLER, 39327: ZEND_CLONE_SPEC_CV_HANDLER, 39328: ZEND_CLONE_SPEC_CV_HANDLER, 39329: ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, 39330: ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, 39331: ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, 39332: ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, 39333: ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, 39334: ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER, 39335: ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER, 39336: ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER, 39337: ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER, 39338: ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER, 39339: ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER, 39340: ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER, 39341: ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER, 39342: ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER, 39343: ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER, 39344: ZEND_NULL_HANDLER, 39345: ZEND_NULL_HANDLER, 39346: ZEND_NULL_HANDLER, 39347: ZEND_NULL_HANDLER, 39348: ZEND_NULL_HANDLER, 39349: ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, 39350: ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, 39351: ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, 39352: ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, 39353: ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, 39354: ZEND_NULL_HANDLER, 39355: ZEND_NULL_HANDLER, 39356: ZEND_NULL_HANDLER, 39357: ZEND_NULL_HANDLER, 39358: ZEND_NULL_HANDLER, 39359: ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER, 39360: ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER, 39361: ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER, 39362: ZEND_NULL_HANDLER, 39363: ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER, 39364: ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER, 39365: ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER, 39366: ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER, 39367: ZEND_NULL_HANDLER, 39368: ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER, 39369: ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, 39370: ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER, 39371: ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER, 39372: ZEND_NULL_HANDLER, 39373: ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, 39374: ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER, 39375: ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER, 39376: ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER, 39377: ZEND_NULL_HANDLER, 39378: ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER, 39379: ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER, 39380: ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER, 39381: ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER, 39382: ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER, 39383: ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER, 39384: ZEND_NULL_HANDLER, 39385: ZEND_NULL_HANDLER, 39386: ZEND_NULL_HANDLER, 39387: ZEND_NULL_HANDLER, 39388: ZEND_NULL_HANDLER, 39389: ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER, 39390: ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER, 39391: ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER, 39392: ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER, 39393: ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER, 39394: ZEND_NULL_HANDLER, 39395: ZEND_NULL_HANDLER, 39396: ZEND_NULL_HANDLER, 39397: ZEND_NULL_HANDLER, 39398: ZEND_NULL_HANDLER, 39399: ZEND_NULL_HANDLER, 39400: ZEND_NULL_HANDLER, 39401: ZEND_NULL_HANDLER, 39402: ZEND_NULL_HANDLER, 39403: ZEND_NULL_HANDLER, 39404: ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER, 39405: ZEND_NULL_HANDLER, 39406: ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER, 39407: ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER, 39408: ZEND_NULL_HANDLER, 39409: ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER, 39410: ZEND_NULL_HANDLER, 39411: ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER, 39412: ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER, 39413: ZEND_NULL_HANDLER, 39414: ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER, 39415: ZEND_NULL_HANDLER, 39416: ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER, 39417: ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER, 39418: ZEND_NULL_HANDLER, 39419: ZEND_NULL_HANDLER, 39420: ZEND_NULL_HANDLER, 39421: ZEND_NULL_HANDLER, 39422: ZEND_NULL_HANDLER, 39423: ZEND_NULL_HANDLER, 39424: ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER, 39425: ZEND_NULL_HANDLER, 39426: ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER, 39427: ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER, 39428: ZEND_NULL_HANDLER, 39429: ZEND_NULL_HANDLER, 39430: ZEND_NULL_HANDLER, 39431: ZEND_NULL_HANDLER, 39432: ZEND_NULL_HANDLER, 39433: ZEND_NULL_HANDLER, 39434: ZEND_NULL_HANDLER, 39435: ZEND_NULL_HANDLER, 39436: ZEND_NULL_HANDLER, 39437: ZEND_NULL_HANDLER, 39438: ZEND_NULL_HANDLER, 39439: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER, 39440: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER, 39441: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER, 39442: ZEND_NULL_HANDLER, 39443: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER, 39444: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER, 39445: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER, 39446: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER, 39447: ZEND_NULL_HANDLER, 39448: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER, 39449: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER, 39450: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER, 39451: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER, 39452: ZEND_NULL_HANDLER, 39453: ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER, 39454: ZEND_NULL_HANDLER, 39455: ZEND_NULL_HANDLER, 39456: ZEND_NULL_HANDLER, 39457: ZEND_NULL_HANDLER, 39458: ZEND_NULL_HANDLER, 39459: ZEND_NULL_HANDLER, 39460: ZEND_NULL_HANDLER, 39461: ZEND_NULL_HANDLER, 39462: ZEND_NULL_HANDLER, 39463: ZEND_NULL_HANDLER, 39464: ZEND_NULL_HANDLER, 39465: ZEND_NULL_HANDLER, 39466: ZEND_NULL_HANDLER, 39467: ZEND_NULL_HANDLER, 39468: ZEND_NULL_HANDLER, 39469: ZEND_NULL_HANDLER, 39470: ZEND_NULL_HANDLER, 39471: ZEND_NULL_HANDLER, 39472: ZEND_NULL_HANDLER, 39473: ZEND_NULL_HANDLER, 39474: ZEND_NULL_HANDLER, 39475: ZEND_NULL_HANDLER, 39476: ZEND_NULL_HANDLER, 39477: ZEND_NULL_HANDLER, 39478: ZEND_NULL_HANDLER, 39479: ZEND_NULL_HANDLER, 39480: ZEND_NULL_HANDLER, 39481: ZEND_NULL_HANDLER, 39482: ZEND_NULL_HANDLER, 39483: ZEND_NULL_HANDLER, 39484: ZEND_NULL_HANDLER, 39485: ZEND_NULL_HANDLER, 39486: ZEND_NULL_HANDLER, 39487: ZEND_NULL_HANDLER, 39488: ZEND_NULL_HANDLER, 39489: ZEND_NULL_HANDLER, 39490: ZEND_NULL_HANDLER, 39491: ZEND_NULL_HANDLER, 39492: ZEND_NULL_HANDLER, 39493: ZEND_NULL_HANDLER, 39494: ZEND_NULL_HANDLER, 39495: ZEND_NULL_HANDLER, 39496: ZEND_NULL_HANDLER, 39497: ZEND_NULL_HANDLER, 39498: ZEND_NULL_HANDLER, 39499: ZEND_NULL_HANDLER, 39500: ZEND_NULL_HANDLER, 39501: ZEND_NULL_HANDLER, 39502: ZEND_NULL_HANDLER, 39503: ZEND_NULL_HANDLER, 39504: ZEND_NULL_HANDLER, 39505: ZEND_NULL_HANDLER, 39506: ZEND_NULL_HANDLER, 39507: ZEND_NULL_HANDLER, 39508: ZEND_NULL_HANDLER, 39509: ZEND_NULL_HANDLER, 39510: ZEND_NULL_HANDLER, 39511: ZEND_NULL_HANDLER, 39512: ZEND_NULL_HANDLER, 39513: ZEND_NULL_HANDLER, 39514: ZEND_NULL_HANDLER, 39515: ZEND_NULL_HANDLER, 39516: ZEND_NULL_HANDLER, 39517: ZEND_NULL_HANDLER, 39518: ZEND_NULL_HANDLER, 39519: ZEND_NULL_HANDLER, 39520: ZEND_NULL_HANDLER, 39521: ZEND_NULL_HANDLER, 39522: ZEND_NULL_HANDLER, 39523: ZEND_NULL_HANDLER, 39524: ZEND_NULL_HANDLER, 39525: ZEND_NULL_HANDLER, 39526: ZEND_NULL_HANDLER, 39527: ZEND_NULL_HANDLER, 39528: ZEND_NULL_HANDLER, 39529: ZEND_NULL_HANDLER, 39530: ZEND_NULL_HANDLER, 39531: ZEND_NULL_HANDLER, 39532: ZEND_NULL_HANDLER, 39533: ZEND_NULL_HANDLER, 39534: ZEND_NULL_HANDLER, 39535: ZEND_NULL_HANDLER, 39536: ZEND_NULL_HANDLER, 39537: ZEND_NULL_HANDLER, 39538: ZEND_NULL_HANDLER, 39539: ZEND_NULL_HANDLER, 39540: ZEND_NULL_HANDLER, 39541: ZEND_NULL_HANDLER, 39542: ZEND_NULL_HANDLER, 39543: ZEND_NULL_HANDLER, 39544: ZEND_NULL_HANDLER, 39545: ZEND_NULL_HANDLER, 39546: ZEND_NULL_HANDLER, 39547: ZEND_NULL_HANDLER, 39548: ZEND_NULL_HANDLER, 39549: ZEND_NULL_HANDLER, 39550: ZEND_NULL_HANDLER, 39551: ZEND_NULL_HANDLER, 39552: ZEND_NULL_HANDLER, 39553: ZEND_NULL_HANDLER, 39554: ZEND_NULL_HANDLER, 39555: ZEND_NULL_HANDLER, 39556: ZEND_NULL_HANDLER, 39557: ZEND_NULL_HANDLER, 39558: ZEND_NULL_HANDLER, 39559: ZEND_NULL_HANDLER, 39560: ZEND_NULL_HANDLER, 39561: ZEND_NULL_HANDLER, 39562: ZEND_NULL_HANDLER, 39563: ZEND_NULL_HANDLER, 39564: ZEND_NULL_HANDLER, 39565: ZEND_NULL_HANDLER, 39566: ZEND_NULL_HANDLER, 39567: ZEND_NULL_HANDLER, 39568: ZEND_NULL_HANDLER, 39569: ZEND_NULL_HANDLER, 39570: ZEND_NULL_HANDLER, 39571: ZEND_NULL_HANDLER, 39572: ZEND_NULL_HANDLER, 39573: ZEND_NULL_HANDLER, 39574: ZEND_NULL_HANDLER, 39575: ZEND_NULL_HANDLER, 39576: ZEND_NULL_HANDLER, 39577: ZEND_NULL_HANDLER, 39578: ZEND_NULL_HANDLER, 39579: ZEND_NULL_HANDLER, 39580: ZEND_NULL_HANDLER, 39581: ZEND_NULL_HANDLER, 39582: ZEND_NULL_HANDLER, 39583: ZEND_NULL_HANDLER, 39584: ZEND_NULL_HANDLER, 39585: ZEND_NULL_HANDLER, 39586: ZEND_NULL_HANDLER, 39587: ZEND_NULL_HANDLER, 39588: ZEND_NULL_HANDLER, 39589: ZEND_NULL_HANDLER, 39590: ZEND_NULL_HANDLER, 39591: ZEND_NULL_HANDLER, 39592: ZEND_NULL_HANDLER, 39593: ZEND_NULL_HANDLER, 39594: ZEND_NULL_HANDLER, 39595: ZEND_NULL_HANDLER, 39596: ZEND_NULL_HANDLER, 39597: ZEND_NULL_HANDLER, 39598: ZEND_NULL_HANDLER, 39599: ZEND_NULL_HANDLER, 39600: ZEND_NULL_HANDLER, 39601: ZEND_NULL_HANDLER, 39602: ZEND_NULL_HANDLER, 39603: ZEND_NULL_HANDLER, 39604: ZEND_NULL_HANDLER, 39605: ZEND_NULL_HANDLER, 39606: ZEND_NULL_HANDLER, 39607: ZEND_NULL_HANDLER, 39608: ZEND_NULL_HANDLER, 39609: ZEND_NULL_HANDLER, 39610: ZEND_NULL_HANDLER, 39611: ZEND_NULL_HANDLER, 39612: ZEND_NULL_HANDLER, 39613: ZEND_NULL_HANDLER, 39614: ZEND_NULL_HANDLER, 39615: ZEND_NULL_HANDLER, 39616: ZEND_NULL_HANDLER, 39617: ZEND_NULL_HANDLER, 39618: ZEND_NULL_HANDLER, 39619: ZEND_NULL_HANDLER, 39620: ZEND_NULL_HANDLER, 39621: ZEND_NULL_HANDLER, 39622: ZEND_NULL_HANDLER, 39623: ZEND_NULL_HANDLER, 39624: ZEND_NULL_HANDLER, 39625: ZEND_NULL_HANDLER, 39626: ZEND_NULL_HANDLER, 39627: ZEND_NULL_HANDLER, 39628: ZEND_NULL_HANDLER, 39629: ZEND_NULL_HANDLER, 39630: ZEND_NULL_HANDLER, 39631: ZEND_NULL_HANDLER, 39632: ZEND_NULL_HANDLER, 39633: ZEND_NULL_HANDLER, 39634: ZEND_NULL_HANDLER, 39635: ZEND_NULL_HANDLER, 39636: ZEND_NULL_HANDLER, 39637: ZEND_NULL_HANDLER, 39638: ZEND_NULL_HANDLER, 39639: ZEND_NULL_HANDLER, 39640: ZEND_NULL_HANDLER, 39641: ZEND_NULL_HANDLER, 39642: ZEND_NULL_HANDLER, 39643: ZEND_NULL_HANDLER, 39644: ZEND_NULL_HANDLER, 39645: ZEND_NULL_HANDLER, 39646: ZEND_NULL_HANDLER, 39647: ZEND_NULL_HANDLER, 39648: ZEND_NULL_HANDLER, 39649: ZEND_NULL_HANDLER, 39650: ZEND_NULL_HANDLER, 39651: ZEND_NULL_HANDLER, 39652: ZEND_NULL_HANDLER, 39653: ZEND_NULL_HANDLER, 39654: ZEND_NULL_HANDLER, 39655: ZEND_NULL_HANDLER, 39656: ZEND_NULL_HANDLER, 39657: ZEND_NULL_HANDLER, 39658: ZEND_NULL_HANDLER, 39659: ZEND_NULL_HANDLER, 39660: ZEND_NULL_HANDLER, 39661: ZEND_NULL_HANDLER, 39662: ZEND_NULL_HANDLER, 39663: ZEND_NULL_HANDLER, 39664: ZEND_NULL_HANDLER, 39665: ZEND_NULL_HANDLER, 39666: ZEND_NULL_HANDLER, 39667: ZEND_NULL_HANDLER, 39668: ZEND_NULL_HANDLER, 39669: ZEND_NULL_HANDLER, 39670: ZEND_NULL_HANDLER, 39671: ZEND_NULL_HANDLER, 39672: ZEND_NULL_HANDLER, 39673: ZEND_NULL_HANDLER, 39674: ZEND_NULL_HANDLER, 39675: ZEND_NULL_HANDLER, 39676: ZEND_NULL_HANDLER, 39677: ZEND_NULL_HANDLER, 39678: ZEND_NULL_HANDLER, 39679: ZEND_NULL_HANDLER, 39680: ZEND_NULL_HANDLER, 39681: ZEND_NULL_HANDLER, 39682: ZEND_NULL_HANDLER, 39683: ZEND_NULL_HANDLER, 39684: ZEND_NULL_HANDLER, 39685: ZEND_NULL_HANDLER, 39686: ZEND_NULL_HANDLER, 39687: ZEND_NULL_HANDLER, 39688: ZEND_NULL_HANDLER, 39689: ZEND_NULL_HANDLER, 39690: ZEND_NULL_HANDLER, 39691: ZEND_NULL_HANDLER, 39692: ZEND_NULL_HANDLER, 39693: ZEND_NULL_HANDLER, 39694: ZEND_NULL_HANDLER, 39695: ZEND_NULL_HANDLER, 39696: ZEND_NULL_HANDLER, 39697: ZEND_NULL_HANDLER, 39698: ZEND_NULL_HANDLER, 39699: ZEND_NULL_HANDLER, 39700: ZEND_NULL_HANDLER, 39701: ZEND_NULL_HANDLER, 39702: ZEND_NULL_HANDLER, 39703: ZEND_NULL_HANDLER, 39704: ZEND_NULL_HANDLER, 39705: ZEND_NULL_HANDLER, 39706: ZEND_NULL_HANDLER, 39707: ZEND_NULL_HANDLER, 39708: ZEND_NULL_HANDLER, 39709: ZEND_NULL_HANDLER, 39710: ZEND_NULL_HANDLER, 39711: ZEND_NULL_HANDLER, 39712: ZEND_NULL_HANDLER, 39713: ZEND_NULL_HANDLER, 39714: ZEND_NULL_HANDLER, 39715: ZEND_NULL_HANDLER, 39716: ZEND_NULL_HANDLER, 39717: ZEND_NULL_HANDLER, 39718: ZEND_NULL_HANDLER, 39719: ZEND_NULL_HANDLER, 39720: ZEND_NULL_HANDLER, 39721: ZEND_NULL_HANDLER, 39722: ZEND_NULL_HANDLER, 39723: ZEND_NULL_HANDLER, 39724: ZEND_NULL_HANDLER, 39725: ZEND_NULL_HANDLER, 39726: ZEND_NULL_HANDLER, 39727: ZEND_NULL_HANDLER, 39728: ZEND_NULL_HANDLER, 39729: ZEND_NULL_HANDLER, 39730: ZEND_NULL_HANDLER, 39731: ZEND_NULL_HANDLER, 39732: ZEND_NULL_HANDLER, 39733: ZEND_NULL_HANDLER, 39734: ZEND_NULL_HANDLER, 39735: ZEND_NULL_HANDLER, 39736: ZEND_NULL_HANDLER, 39737: ZEND_NULL_HANDLER, 39738: ZEND_NULL_HANDLER, 39739: ZEND_NULL_HANDLER, 39740: ZEND_NULL_HANDLER, 39741: ZEND_NULL_HANDLER, 39742: ZEND_NULL_HANDLER, 39743: ZEND_NULL_HANDLER, 39744: ZEND_NULL_HANDLER, 39745: ZEND_NULL_HANDLER, 39746: ZEND_NULL_HANDLER, 39747: ZEND_NULL_HANDLER, 39748: ZEND_NULL_HANDLER, 39749: ZEND_NULL_HANDLER, 39750: ZEND_NULL_HANDLER, 39751: ZEND_NULL_HANDLER, 39752: ZEND_NULL_HANDLER, 39753: ZEND_NULL_HANDLER, 39754: ZEND_NULL_HANDLER, 39755: ZEND_NULL_HANDLER, 39756: ZEND_NULL_HANDLER, 39757: ZEND_NULL_HANDLER, 39758: ZEND_NULL_HANDLER, 39759: ZEND_NULL_HANDLER, 39760: ZEND_NULL_HANDLER, 39761: ZEND_NULL_HANDLER, 39762: ZEND_NULL_HANDLER, 39763: ZEND_NULL_HANDLER, 39764: ZEND_NULL_HANDLER, 39765: ZEND_NULL_HANDLER, 39766: ZEND_NULL_HANDLER, 39767: ZEND_NULL_HANDLER, 39768: ZEND_NULL_HANDLER, 39769: ZEND_NULL_HANDLER, 39770: ZEND_NULL_HANDLER, 39771: ZEND_NULL_HANDLER, 39772: ZEND_NULL_HANDLER, 39773: ZEND_NULL_HANDLER, 39774: ZEND_NULL_HANDLER, 39775: ZEND_NULL_HANDLER, 39776: ZEND_NULL_HANDLER, 39777: ZEND_NULL_HANDLER, 39778: ZEND_NULL_HANDLER, 39779: ZEND_NULL_HANDLER, 39780: ZEND_NULL_HANDLER, 39781: ZEND_NULL_HANDLER, 39782: ZEND_NULL_HANDLER, 39783: ZEND_NULL_HANDLER, 39784: ZEND_NULL_HANDLER, 39785: ZEND_NULL_HANDLER, 39786: ZEND_NULL_HANDLER, 39787: ZEND_NULL_HANDLER, 39788: ZEND_NULL_HANDLER, 39789: ZEND_NULL_HANDLER, 39790: ZEND_NULL_HANDLER, 39791: ZEND_NULL_HANDLER, 39792: ZEND_NULL_HANDLER, 39793: ZEND_NULL_HANDLER, 39794: ZEND_NULL_HANDLER, 39795: ZEND_NULL_HANDLER, 39796: ZEND_NULL_HANDLER, 39797: ZEND_NULL_HANDLER, 39798: ZEND_NULL_HANDLER, 39799: ZEND_NULL_HANDLER, 39800: ZEND_NULL_HANDLER, 39801: ZEND_NULL_HANDLER, 39802: ZEND_NULL_HANDLER, 39803: ZEND_NULL_HANDLER, 39804: ZEND_NULL_HANDLER, 39805: ZEND_NULL_HANDLER, 39806: ZEND_NULL_HANDLER, 39807: ZEND_NULL_HANDLER, 39808: ZEND_NULL_HANDLER, 39809: ZEND_NULL_HANDLER, 39810: ZEND_NULL_HANDLER, 39811: ZEND_NULL_HANDLER, 39812: ZEND_NULL_HANDLER, 39813: ZEND_NULL_HANDLER, 39814: ZEND_NULL_HANDLER, 39815: ZEND_NULL_HANDLER, 39816: ZEND_NULL_HANDLER, 39817: ZEND_NULL_HANDLER, 39818: ZEND_NULL_HANDLER, 39819: ZEND_NULL_HANDLER, 39820: ZEND_NULL_HANDLER, 39821: ZEND_NULL_HANDLER, 39822: ZEND_NULL_HANDLER, 39823: ZEND_NULL_HANDLER, 39824: ZEND_NULL_HANDLER, 39825: ZEND_NULL_HANDLER, 39826: ZEND_NULL_HANDLER, 39827: ZEND_NULL_HANDLER, 39828: ZEND_NULL_HANDLER, 39829: ZEND_NULL_HANDLER, 39830: ZEND_NULL_HANDLER, 39831: ZEND_NULL_HANDLER, 39832: ZEND_NULL_HANDLER, 39833: ZEND_NULL_HANDLER, 39834: ZEND_NULL_HANDLER, 39835: ZEND_NULL_HANDLER, 39836: ZEND_NULL_HANDLER, 39837: ZEND_NULL_HANDLER, 39838: ZEND_NULL_HANDLER, 39839: ZEND_NULL_HANDLER, 39840: ZEND_NULL_HANDLER, 39841: ZEND_NULL_HANDLER, 39842: ZEND_NULL_HANDLER, 39843: ZEND_NULL_HANDLER, 39844: ZEND_NULL_HANDLER, 39845: ZEND_NULL_HANDLER, 39846: ZEND_NULL_HANDLER, 39847: ZEND_NULL_HANDLER, 39848: ZEND_NULL_HANDLER, 39849: ZEND_NULL_HANDLER, 39850: ZEND_NULL_HANDLER, 39851: ZEND_NULL_HANDLER, 39852: ZEND_NULL_HANDLER, 39853: ZEND_NULL_HANDLER, 39854: ZEND_NULL_HANDLER, 39855: ZEND_NULL_HANDLER, 39856: ZEND_NULL_HANDLER, 39857: ZEND_NULL_HANDLER, 39858: ZEND_NULL_HANDLER, 39859: ZEND_NULL_HANDLER, 39860: ZEND_NULL_HANDLER, 39861: ZEND_NULL_HANDLER, 39862: ZEND_NULL_HANDLER, 39863: ZEND_NULL_HANDLER, 39864: ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER, 39865: ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER, 39866: ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER, 39867: ZEND_NULL_HANDLER, 39868: ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER, 39869: ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER, 39870: ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER, 39871: ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER, 39872: ZEND_NULL_HANDLER, 39873: ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER, 39874: ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER, 39875: ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER, 39876: ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER, 39877: ZEND_NULL_HANDLER, 39878: ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER, 39879: ZEND_NULL_HANDLER, 39880: ZEND_NULL_HANDLER, 39881: ZEND_NULL_HANDLER, 39882: ZEND_NULL_HANDLER, 39883: ZEND_NULL_HANDLER, 39884: ZEND_NULL_HANDLER, 39885: ZEND_NULL_HANDLER, 39886: ZEND_NULL_HANDLER, 39887: ZEND_NULL_HANDLER, 39888: ZEND_NULL_HANDLER, 39889: ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER, 39890: ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER, 39891: ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER, 39892: ZEND_NULL_HANDLER, 39893: ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER, 39894: ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER, 39895: ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER, 39896: ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER, 39897: ZEND_NULL_HANDLER, 39898: ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER, 39899: ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER, 39900: ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER, 39901: ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER, 39902: ZEND_NULL_HANDLER, 39903: ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER, 39904: ZEND_NULL_HANDLER, 39905: ZEND_NULL_HANDLER, 39906: ZEND_NULL_HANDLER, 39907: ZEND_NULL_HANDLER, 39908: ZEND_NULL_HANDLER, 39909: ZEND_NULL_HANDLER, 39910: ZEND_NULL_HANDLER, 39911: ZEND_NULL_HANDLER, 39912: ZEND_NULL_HANDLER, 39913: ZEND_NULL_HANDLER, 39914: ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER, 39915: ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER, 39916: ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER, 39917: ZEND_NULL_HANDLER, 39918: ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER, 39919: ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER, 39920: ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER, 39921: ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER, 39922: ZEND_NULL_HANDLER, 39923: ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER, 39924: ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER, 39925: ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER, 39926: ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER, 39927: ZEND_NULL_HANDLER, 39928: ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER, 39929: ZEND_NULL_HANDLER, 39930: ZEND_NULL_HANDLER, 39931: ZEND_NULL_HANDLER, 39932: ZEND_NULL_HANDLER, 39933: ZEND_NULL_HANDLER, 39934: ZEND_NULL_HANDLER, 39935: ZEND_NULL_HANDLER, 39936: ZEND_NULL_HANDLER, 39937: ZEND_NULL_HANDLER, 39938: ZEND_NULL_HANDLER, 39939: ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER, 39940: ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER, 39941: ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER, 39942: ZEND_NULL_HANDLER, 39943: ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER, 39944: ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER, 39945: ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER, 39946: ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER, 39947: ZEND_NULL_HANDLER, 39948: ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER, 39949: ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER, 39950: ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER, 39951: ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER, 39952: ZEND_NULL_HANDLER, 39953: ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER, 39954: ZEND_NULL_HANDLER, 39955: ZEND_NULL_HANDLER, 39956: ZEND_NULL_HANDLER, 39957: ZEND_NULL_HANDLER, 39958: ZEND_NULL_HANDLER, 39959: ZEND_NULL_HANDLER, 39960: ZEND_NULL_HANDLER, 39961: ZEND_NULL_HANDLER, 39962: ZEND_NULL_HANDLER, 39963: ZEND_NULL_HANDLER, 39964: ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER, 39965: ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER, 39966: ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER, 39967: ZEND_NULL_HANDLER, 39968: ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER, 39969: ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER, 39970: ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER, 39971: ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER, 39972: ZEND_NULL_HANDLER, 39973: ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER, 39974: ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER, 39975: ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER, 39976: ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER, 39977: ZEND_NULL_HANDLER, 39978: ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER, 39979: ZEND_NULL_HANDLER, 39980: ZEND_NULL_HANDLER, 39981: ZEND_NULL_HANDLER, 39982: ZEND_NULL_HANDLER, 39983: ZEND_NULL_HANDLER, 39984: ZEND_NULL_HANDLER, 39985: ZEND_NULL_HANDLER, 39986: ZEND_NULL_HANDLER, 39987: ZEND_NULL_HANDLER, 39988: ZEND_NULL_HANDLER, 39989: ZEND_NULL_HANDLER, 39990: ZEND_NULL_HANDLER, 39991: ZEND_NULL_HANDLER, 39992: ZEND_NULL_HANDLER, 39993: ZEND_NULL_HANDLER, 39994: ZEND_NULL_HANDLER, 39995: ZEND_NULL_HANDLER, 39996: ZEND_NULL_HANDLER, 39997: ZEND_NULL_HANDLER, 39998: ZEND_NULL_HANDLER, 39999: ZEND_NULL_HANDLER, 40000: ZEND_NULL_HANDLER, 40001: ZEND_NULL_HANDLER, 40002: ZEND_NULL_HANDLER, 40003: ZEND_NULL_HANDLER, 40004: ZEND_NULL_HANDLER, 40005: ZEND_NULL_HANDLER, 40006: ZEND_NULL_HANDLER, 40007: ZEND_NULL_HANDLER, 40008: ZEND_NULL_HANDLER, 40009: ZEND_INSTANCEOF_SPEC_TMP_HANDLER, 40010: ZEND_INSTANCEOF_SPEC_TMP_HANDLER, 40011: ZEND_INSTANCEOF_SPEC_TMP_HANDLER, 40012: ZEND_INSTANCEOF_SPEC_TMP_HANDLER, 40013: ZEND_INSTANCEOF_SPEC_TMP_HANDLER, 40014: ZEND_INSTANCEOF_SPEC_VAR_HANDLER, 40015: ZEND_INSTANCEOF_SPEC_VAR_HANDLER, 40016: ZEND_INSTANCEOF_SPEC_VAR_HANDLER, 40017: ZEND_INSTANCEOF_SPEC_VAR_HANDLER, 40018: ZEND_INSTANCEOF_SPEC_VAR_HANDLER, 40019: ZEND_NULL_HANDLER, 40020: ZEND_NULL_HANDLER, 40021: ZEND_NULL_HANDLER, 40022: ZEND_NULL_HANDLER, 40023: ZEND_NULL_HANDLER, 40024: ZEND_INSTANCEOF_SPEC_CV_HANDLER, 40025: ZEND_INSTANCEOF_SPEC_CV_HANDLER, 40026: ZEND_INSTANCEOF_SPEC_CV_HANDLER, 40027: ZEND_INSTANCEOF_SPEC_CV_HANDLER, 40028: ZEND_INSTANCEOF_SPEC_CV_HANDLER, 40029: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40030: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40031: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40032: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40033: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40034: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40035: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40036: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40037: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40038: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40039: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40040: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40041: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40042: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40043: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40044: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40045: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40046: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40047: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40048: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40049: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40050: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40051: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40052: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40053: ZEND_DECLARE_CLASS_SPEC_HANDLER, 40054: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40055: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40056: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40057: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40058: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40059: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40060: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40061: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40062: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40063: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40064: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40065: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40066: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40067: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40068: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40069: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40070: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40071: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40072: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40073: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40074: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40075: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40076: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40077: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40078: ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER, 40079: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40080: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40081: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40082: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40083: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40084: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40085: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40086: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40087: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40088: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40089: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40090: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40091: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40092: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40093: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40094: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40095: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40096: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40097: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40098: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40099: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40100: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40101: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40102: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40103: ZEND_DECLARE_FUNCTION_SPEC_HANDLER, 40104: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40105: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40106: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40107: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40108: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40109: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40110: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40111: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40112: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40113: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40114: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40115: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40116: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40117: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40118: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40119: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40120: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40121: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40122: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40123: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40124: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40125: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40126: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40127: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40128: ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER, 40129: ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER, 40130: ZEND_NULL_HANDLER, 40131: ZEND_NULL_HANDLER, 40132: ZEND_NULL_HANDLER, 40133: ZEND_NULL_HANDLER, 40134: ZEND_NULL_HANDLER, 40135: ZEND_NULL_HANDLER, 40136: ZEND_NULL_HANDLER, 40137: ZEND_NULL_HANDLER, 40138: ZEND_NULL_HANDLER, 40139: ZEND_NULL_HANDLER, 40140: ZEND_NULL_HANDLER, 40141: ZEND_NULL_HANDLER, 40142: ZEND_NULL_HANDLER, 40143: ZEND_NULL_HANDLER, 40144: ZEND_NULL_HANDLER, 40145: ZEND_NULL_HANDLER, 40146: ZEND_NULL_HANDLER, 40147: ZEND_NULL_HANDLER, 40148: ZEND_NULL_HANDLER, 40149: ZEND_NULL_HANDLER, 40150: ZEND_NULL_HANDLER, 40151: ZEND_NULL_HANDLER, 40152: ZEND_NULL_HANDLER, 40153: ZEND_NULL_HANDLER, 40154: ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER, 40155: ZEND_NULL_HANDLER, 40156: ZEND_NULL_HANDLER, 40157: ZEND_NULL_HANDLER, 40158: ZEND_NULL_HANDLER, 40159: ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER, 40160: ZEND_NULL_HANDLER, 40161: ZEND_NULL_HANDLER, 40162: ZEND_NULL_HANDLER, 40163: ZEND_NULL_HANDLER, 40164: ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER, 40165: ZEND_NULL_HANDLER, 40166: ZEND_NULL_HANDLER, 40167: ZEND_NULL_HANDLER, 40168: ZEND_NULL_HANDLER, 40169: ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER, 40170: ZEND_NULL_HANDLER, 40171: ZEND_NULL_HANDLER, 40172: ZEND_NULL_HANDLER, 40173: ZEND_NULL_HANDLER, 40174: ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER, 40175: ZEND_NULL_HANDLER, 40176: ZEND_NULL_HANDLER, 40177: ZEND_NULL_HANDLER, 40178: ZEND_NULL_HANDLER, 40179: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40180: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40181: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40182: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40183: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40184: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40185: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40186: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40187: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40188: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40189: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40190: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40191: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40192: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40193: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40194: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40195: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40196: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40197: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40198: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40199: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40200: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40201: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40202: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40203: ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER, 40204: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40205: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40206: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40207: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40208: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40209: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40210: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40211: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40212: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40213: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40214: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40215: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40216: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40217: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40218: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40219: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40220: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40221: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40222: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40223: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40224: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40225: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40226: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40227: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40228: ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, 40229: ZEND_NULL_HANDLER, 40230: ZEND_NULL_HANDLER, 40231: ZEND_NULL_HANDLER, 40232: ZEND_NULL_HANDLER, 40233: ZEND_NULL_HANDLER, 40234: ZEND_NULL_HANDLER, 40235: ZEND_NULL_HANDLER, 40236: ZEND_NULL_HANDLER, 40237: ZEND_NULL_HANDLER, 40238: ZEND_NULL_HANDLER, 40239: ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER, 40240: ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER, 40241: ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER, 40242: ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER, 40243: ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER, 40244: ZEND_NULL_HANDLER, 40245: ZEND_NULL_HANDLER, 40246: ZEND_NULL_HANDLER, 40247: ZEND_NULL_HANDLER, 40248: ZEND_NULL_HANDLER, 40249: ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER, 40250: ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER, 40251: ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER, 40252: ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER, 40253: ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER, 40254: ZEND_NULL_HANDLER, 40255: ZEND_NULL_HANDLER, 40256: ZEND_NULL_HANDLER, 40257: ZEND_NULL_HANDLER, 40258: ZEND_NULL_HANDLER, 40259: ZEND_NULL_HANDLER, 40260: ZEND_NULL_HANDLER, 40261: ZEND_NULL_HANDLER, 40262: ZEND_NULL_HANDLER, 40263: ZEND_NULL_HANDLER, 40264: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER, 40265: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER, 40266: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER, 40267: ZEND_NULL_HANDLER, 40268: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER, 40269: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER, 40270: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER, 40271: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER, 40272: ZEND_NULL_HANDLER, 40273: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER, 40274: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER, 40275: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER, 40276: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER, 40277: ZEND_NULL_HANDLER, 40278: ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER, 40279: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40280: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40281: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40282: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40283: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40284: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40285: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40286: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40287: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40288: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40289: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40290: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40291: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40292: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40293: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40294: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40295: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40296: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40297: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40298: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40299: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40300: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40301: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40302: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40303: ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, 40304: ZEND_USER_OPCODE_SPEC_HANDLER, 40305: ZEND_USER_OPCODE_SPEC_HANDLER, 40306: ZEND_USER_OPCODE_SPEC_HANDLER, 40307: ZEND_USER_OPCODE_SPEC_HANDLER, 40308: ZEND_USER_OPCODE_SPEC_HANDLER, 40309: ZEND_USER_OPCODE_SPEC_HANDLER, 40310: ZEND_USER_OPCODE_SPEC_HANDLER, 40311: ZEND_USER_OPCODE_SPEC_HANDLER, 40312: ZEND_USER_OPCODE_SPEC_HANDLER, 40313: ZEND_USER_OPCODE_SPEC_HANDLER, 40314: ZEND_USER_OPCODE_SPEC_HANDLER, 40315: ZEND_USER_OPCODE_SPEC_HANDLER, 40316: ZEND_USER_OPCODE_SPEC_HANDLER, 40317: ZEND_USER_OPCODE_SPEC_HANDLER, 40318: ZEND_USER_OPCODE_SPEC_HANDLER, 40319: ZEND_USER_OPCODE_SPEC_HANDLER, 40320: ZEND_USER_OPCODE_SPEC_HANDLER, 40321: ZEND_USER_OPCODE_SPEC_HANDLER, 40322: ZEND_USER_OPCODE_SPEC_HANDLER, 40323: ZEND_USER_OPCODE_SPEC_HANDLER, 40324: ZEND_USER_OPCODE_SPEC_HANDLER, 40325: ZEND_USER_OPCODE_SPEC_HANDLER, 40326: ZEND_USER_OPCODE_SPEC_HANDLER, 40327: ZEND_USER_OPCODE_SPEC_HANDLER, 40328: ZEND_USER_OPCODE_SPEC_HANDLER, 40329: ZEND_NULL_HANDLER, 40330: ZEND_NULL_HANDLER, 40331: ZEND_NULL_HANDLER, 40332: ZEND_NULL_HANDLER, 40333: ZEND_NULL_HANDLER, 40334: ZEND_NULL_HANDLER, 40335: ZEND_NULL_HANDLER, 40336: ZEND_NULL_HANDLER, 40337: ZEND_NULL_HANDLER, 40338: ZEND_NULL_HANDLER, 40339: ZEND_NULL_HANDLER, 40340: ZEND_NULL_HANDLER, 40341: ZEND_NULL_HANDLER, 40342: ZEND_NULL_HANDLER, 40343: ZEND_NULL_HANDLER, 40344: ZEND_NULL_HANDLER, 40345: ZEND_NULL_HANDLER, 40346: ZEND_NULL_HANDLER, 40347: ZEND_NULL_HANDLER, 40348: ZEND_NULL_HANDLER, 40349: ZEND_NULL_HANDLER, 40350: ZEND_NULL_HANDLER, 40351: ZEND_NULL_HANDLER, 40352: ZEND_NULL_HANDLER, 40353: ZEND_NULL_HANDLER, 40354: ZEND_JMP_SET_SPEC_CONST_HANDLER, 40355: ZEND_JMP_SET_SPEC_CONST_HANDLER, 40356: ZEND_JMP_SET_SPEC_CONST_HANDLER, 40357: ZEND_JMP_SET_SPEC_CONST_HANDLER, 40358: ZEND_JMP_SET_SPEC_CONST_HANDLER, 40359: ZEND_JMP_SET_SPEC_TMP_HANDLER, 40360: ZEND_JMP_SET_SPEC_TMP_HANDLER, 40361: ZEND_JMP_SET_SPEC_TMP_HANDLER, 40362: ZEND_JMP_SET_SPEC_TMP_HANDLER, 40363: ZEND_JMP_SET_SPEC_TMP_HANDLER, 40364: ZEND_JMP_SET_SPEC_VAR_HANDLER, 40365: ZEND_JMP_SET_SPEC_VAR_HANDLER, 40366: ZEND_JMP_SET_SPEC_VAR_HANDLER, 40367: ZEND_JMP_SET_SPEC_VAR_HANDLER, 40368: ZEND_JMP_SET_SPEC_VAR_HANDLER, 40369: ZEND_NULL_HANDLER, 40370: ZEND_NULL_HANDLER, 40371: ZEND_NULL_HANDLER, 40372: ZEND_NULL_HANDLER, 40373: ZEND_NULL_HANDLER, 40374: ZEND_JMP_SET_SPEC_CV_HANDLER, 40375: ZEND_JMP_SET_SPEC_CV_HANDLER, 40376: ZEND_JMP_SET_SPEC_CV_HANDLER, 40377: ZEND_JMP_SET_SPEC_CV_HANDLER, 40378: ZEND_JMP_SET_SPEC_CV_HANDLER, 40379: ZEND_NULL_HANDLER, 40380: ZEND_NULL_HANDLER, 40381: ZEND_NULL_HANDLER, 40382: ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER, 40383: ZEND_NULL_HANDLER, 40384: ZEND_NULL_HANDLER, 40385: ZEND_NULL_HANDLER, 40386: ZEND_NULL_HANDLER, 40387: ZEND_NULL_HANDLER, 40388: ZEND_NULL_HANDLER, 40389: ZEND_NULL_HANDLER, 40390: ZEND_NULL_HANDLER, 40391: ZEND_NULL_HANDLER, 40392: ZEND_NULL_HANDLER, 40393: ZEND_NULL_HANDLER, 40394: ZEND_NULL_HANDLER, 40395: ZEND_NULL_HANDLER, 40396: ZEND_NULL_HANDLER, 40397: ZEND_NULL_HANDLER, 40398: ZEND_NULL_HANDLER, 40399: ZEND_NULL_HANDLER, 40400: ZEND_NULL_HANDLER, 40401: ZEND_NULL_HANDLER, 40402: ZEND_NULL_HANDLER, 40403: ZEND_NULL_HANDLER, 40404: ZEND_ADD_TRAIT_SPEC_HANDLER, 40405: ZEND_ADD_TRAIT_SPEC_HANDLER, 40406: ZEND_ADD_TRAIT_SPEC_HANDLER, 40407: ZEND_ADD_TRAIT_SPEC_HANDLER, 40408: ZEND_ADD_TRAIT_SPEC_HANDLER, 40409: ZEND_ADD_TRAIT_SPEC_HANDLER, 40410: ZEND_ADD_TRAIT_SPEC_HANDLER, 40411: ZEND_ADD_TRAIT_SPEC_HANDLER, 40412: ZEND_ADD_TRAIT_SPEC_HANDLER, 40413: ZEND_ADD_TRAIT_SPEC_HANDLER, 40414: ZEND_ADD_TRAIT_SPEC_HANDLER, 40415: ZEND_ADD_TRAIT_SPEC_HANDLER, 40416: ZEND_ADD_TRAIT_SPEC_HANDLER, 40417: ZEND_ADD_TRAIT_SPEC_HANDLER, 40418: ZEND_ADD_TRAIT_SPEC_HANDLER, 40419: ZEND_ADD_TRAIT_SPEC_HANDLER, 40420: ZEND_ADD_TRAIT_SPEC_HANDLER, 40421: ZEND_ADD_TRAIT_SPEC_HANDLER, 40422: ZEND_ADD_TRAIT_SPEC_HANDLER, 40423: ZEND_ADD_TRAIT_SPEC_HANDLER, 40424: ZEND_ADD_TRAIT_SPEC_HANDLER, 40425: ZEND_ADD_TRAIT_SPEC_HANDLER, 40426: ZEND_ADD_TRAIT_SPEC_HANDLER, 40427: ZEND_ADD_TRAIT_SPEC_HANDLER, 40428: ZEND_ADD_TRAIT_SPEC_HANDLER, 40429: ZEND_BIND_TRAITS_SPEC_HANDLER, 40430: ZEND_BIND_TRAITS_SPEC_HANDLER, 40431: ZEND_BIND_TRAITS_SPEC_HANDLER, 40432: ZEND_BIND_TRAITS_SPEC_HANDLER, 40433: ZEND_BIND_TRAITS_SPEC_HANDLER, 40434: ZEND_BIND_TRAITS_SPEC_HANDLER, 40435: ZEND_BIND_TRAITS_SPEC_HANDLER, 40436: ZEND_BIND_TRAITS_SPEC_HANDLER, 40437: ZEND_BIND_TRAITS_SPEC_HANDLER, 40438: ZEND_BIND_TRAITS_SPEC_HANDLER, 40439: ZEND_BIND_TRAITS_SPEC_HANDLER, 40440: ZEND_BIND_TRAITS_SPEC_HANDLER, 40441: ZEND_BIND_TRAITS_SPEC_HANDLER, 40442: ZEND_BIND_TRAITS_SPEC_HANDLER, 40443: ZEND_BIND_TRAITS_SPEC_HANDLER, 40444: ZEND_BIND_TRAITS_SPEC_HANDLER, 40445: ZEND_BIND_TRAITS_SPEC_HANDLER, 40446: ZEND_BIND_TRAITS_SPEC_HANDLER, 40447: ZEND_BIND_TRAITS_SPEC_HANDLER, 40448: ZEND_BIND_TRAITS_SPEC_HANDLER, 40449: ZEND_BIND_TRAITS_SPEC_HANDLER, 40450: ZEND_BIND_TRAITS_SPEC_HANDLER, 40451: ZEND_BIND_TRAITS_SPEC_HANDLER, 40452: ZEND_BIND_TRAITS_SPEC_HANDLER, 40453: ZEND_BIND_TRAITS_SPEC_HANDLER, 40454: ZEND_NULL_HANDLER, 40455: ZEND_NULL_HANDLER, 40456: ZEND_NULL_HANDLER, 40457: ZEND_NULL_HANDLER, 40458: ZEND_NULL_HANDLER, 40459: ZEND_NULL_HANDLER, 40460: ZEND_NULL_HANDLER, 40461: ZEND_NULL_HANDLER, 40462: ZEND_NULL_HANDLER, 40463: ZEND_NULL_HANDLER, 40464: ZEND_NULL_HANDLER, 40465: ZEND_NULL_HANDLER, 40466: ZEND_NULL_HANDLER, 40467: ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER, 40468: ZEND_NULL_HANDLER, 40469: ZEND_NULL_HANDLER, 40470: ZEND_NULL_HANDLER, 40471: ZEND_NULL_HANDLER, 40472: ZEND_NULL_HANDLER, 40473: ZEND_NULL_HANDLER, 40474: ZEND_NULL_HANDLER, 40475: ZEND_NULL_HANDLER, 40476: ZEND_NULL_HANDLER, 40477: ZEND_NULL_HANDLER, 40478: ZEND_NULL_HANDLER, 40479: ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER, 40480: ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER, 40481: ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER, 40482: ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER, 40483: ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER, 40484: ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER, 40485: ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER, 40486: ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER, 40487: ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER, 40488: ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER, 40489: ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER, 40490: ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER, 40491: ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER, 40492: ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER, 40493: ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER, 40494: ZEND_NULL_HANDLER, 40495: ZEND_NULL_HANDLER, 40496: ZEND_NULL_HANDLER, 40497: ZEND_NULL_HANDLER, 40498: ZEND_NULL_HANDLER, 40499: ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER, 40500: ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER, 40501: ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER, 40502: ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER, 40503: ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER, 40504: ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER, 40505: ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER, 40506: ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER, 40507: ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER, 40508: ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER, 40509: ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER, 40510: ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER, 40511: ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER, 40512: ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER, 40513: ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER, 40514: ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER, 40515: ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER, 40516: ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER, 40517: ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER, 40518: ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER, 40519: ZEND_NULL_HANDLER, 40520: ZEND_NULL_HANDLER, 40521: ZEND_NULL_HANDLER, 40522: ZEND_NULL_HANDLER, 40523: ZEND_NULL_HANDLER, 40524: ZEND_JMP_SET_VAR_SPEC_CV_HANDLER, 40525: ZEND_JMP_SET_VAR_SPEC_CV_HANDLER, 40526: ZEND_JMP_SET_VAR_SPEC_CV_HANDLER, 40527: ZEND_JMP_SET_VAR_SPEC_CV_HANDLER, 40528: ZEND_JMP_SET_VAR_SPEC_CV_HANDLER, 40529: ZEND_NULL_HANDLER 40530: }; 40531: zend_opcode_handlers = (opcode_handler_t*)labels; 40532: } 40533: static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op) 40534: { 40535: static const int zend_vm_decode[] = { 40536: _UNUSED_CODE, /* 0 */ 40537: _CONST_CODE, /* 1 = IS_CONST */ 40538: _TMP_CODE, /* 2 = IS_TMP_VAR */ 40539: _UNUSED_CODE, /* 3 */ 40540: _VAR_CODE, /* 4 = IS_VAR */ 40541: _UNUSED_CODE, /* 5 */ 40542: _UNUSED_CODE, /* 6 */ 40543: _UNUSED_CODE, /* 7 */ 40544: _UNUSED_CODE, /* 8 = IS_UNUSED */ 40545: _UNUSED_CODE, /* 9 */ 40546: _UNUSED_CODE, /* 10 */ 40547: _UNUSED_CODE, /* 11 */ 40548: _UNUSED_CODE, /* 12 */ 40549: _UNUSED_CODE, /* 13 */ 40550: _UNUSED_CODE, /* 14 */ 40551: _UNUSED_CODE, /* 15 */ 40552: _CV_CODE /* 16 = IS_CV */ 40553: }; 40554: return zend_opcode_handlers[opcode * 25 + zend_vm_decode[op->op1_type] * 5 + zend_vm_decode[op->op2_type]]; 40555: } 40556: 40557: ZEND_API void zend_vm_set_opcode_handler(zend_op* op) 40558: { 40559: op->handler = zend_vm_get_opcode_handler(zend_user_opcodes[op->opcode], op); 40560: } 40561: 40562: ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS) 40563: { 40564: return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); 40565: } 40566: