PageRenderTime 54ms CodeModel.GetById 11ms RepoModel.GetById 0ms app.codeStats 1ms

/Zend/zend_compile.c

http://github.com/infusion/PHP
C | 5454 lines | 4294 code | 754 blank | 406 comment | 1094 complexity | 79b2bba80d4838380d8d3483804f6547 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.    +----------------------------------------------------------------------+
    3. 

  3.    | Zend Engine                                                          |
    4. 

  4.    +----------------------------------------------------------------------+
    5. 

  5.    | Copyright (c) 1998-2011 Zend Technologies Ltd. (http://www.zend.com) |
    6. 

  6.    +----------------------------------------------------------------------+
    7. 

  7.    | This source file is subject to version 2.00 of the Zend license,     |
    8. 

  8.    | that is bundled with this package in the file LICENSE, and is        | 
    9. 

  9.    | available through the world-wide-web at the following url:           |
    10. 

  10.    | http://www.zend.com/license/2_00.txt.                                |
    11. 

  11.    | If you did not receive a copy of the Zend license and are unable to  |
    12. 

  12.    | obtain it through the world-wide-web, please send a note to          |
    13. 

  13.    | license@zend.com so we can mail you a copy immediately.              |
    14. 

  14.    +----------------------------------------------------------------------+
    15. 

  15.    | Authors: Andi Gutmans <andi@zend.com>                                |
    16. 

  16.    |          Zeev Suraski <zeev@zend.com>                                |
    17. 

  17.    +----------------------------------------------------------------------+
    18. 

  18. */
    19. 

  19. 

  20. /* $Id: zend_compile.c 308443 2011-02-17 23:24:50Z felipe $ */
    21. 

  21. 

  22. #include <zend_language_parser.h>
    23. 

  23. #include "zend.h"
    24. 

  24. #include "zend_compile.h"
    25. 

  25. #include "zend_constants.h"
    26. 

  26. #include "zend_llist.h"
    27. 

  27. #include "zend_API.h"
    28. 

  28. #include "zend_exceptions.h"
    29. 

  29. #include "tsrm_virtual_cwd.h"
    30. 

  30. 

  31. #ifdef ZEND_MULTIBYTE
    32. 

  32. #include "zend_multibyte.h"
    33. 

  33. #endif /* ZEND_MULTIBYTE */
    34. 

  34. 

  35. ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
    36. 

  36. ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
    37. 

  37. 

  38. #ifndef ZTS
    39. 

  39. ZEND_API zend_compiler_globals compiler_globals;
    40. 

  40. ZEND_API zend_executor_globals executor_globals;
    41. 

  41. #endif
    42. 

  42. 

  43. static void zend_duplicate_property_info(zend_property_info *property_info) /* {{{ */
    44. 

  44. {
    45. 

  45. 	property_info->name = estrndup(property_info->name, property_info->name_length);
    46. 

  46. 	if (property_info->doc_comment) {
    47. 

  47. 		property_info->doc_comment = estrndup(property_info->doc_comment, property_info->doc_comment_len);
    48. 

  48. 	}
    49. 

  49. }
    50. 

  50. /* }}} */
    51. 

  51. 

  52. 

  53. static void zend_duplicate_property_info_internal(zend_property_info *property_info) /* {{{ */
    54. 

  54. {
    55. 

  55. 	property_info->name = zend_strndup(property_info->name, property_info->name_length);
    56. 

  56. }
    57. 

  57. /* }}} */
    58. 

  58. 

  59. 

  60. static void zend_destroy_property_info(zend_property_info *property_info) /* {{{ */
    61. 

  61. {
    62. 

  62. 	efree(property_info->name);
    63. 

  63. 	if (property_info->doc_comment) {
    64. 

  64. 		efree(property_info->doc_comment);
    65. 

  65. 	}
    66. 

  66. }
    67. 

  67. /* }}} */
    68. 

  68. 

  69. 

  70. static void zend_destroy_property_info_internal(zend_property_info *property_info) /* {{{ */
    71. 

  71. {
    72. 

  72. 	free(property_info->name);
    73. 

  73. }
    74. 

  74. /* }}} */
    75. 

  75. 

  76. static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */
    77. 

  77. {
    78. 

  78. 	char char_pos_buf[32];
    79. 

  79. 	uint char_pos_len;
    80. 

  80. 	char *filename;
    81. 

  81. 

  82. 	char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text));
    83. 

  83. 	if (CG(active_op_array)->filename) {
    84. 

  84. 		filename = CG(active_op_array)->filename;
    85. 

  85. 	} else {
    86. 

  86. 		filename = "-";
    87. 

  87. 	}
    88. 

  88. 

  89. 	/* NULL, name length, filename length, last accepting char position length */
    90. 

  90. 	result->value.str.len = 1+name_length+strlen(filename)+char_pos_len;
    91. 

  91. #ifdef ZEND_MULTIBYTE
    92. 

  92.  	/* must be binary safe */
    93. 

  93.  	result->value.str.val = (char *) safe_emalloc(result->value.str.len, 1, 1);
    94. 

  94.  	result->value.str.val[0] = '\0';
    95. 

  95.  	sprintf(result->value.str.val+1, "%s%s%s", name, filename, char_pos_buf);
    96. 

  96. #else
    97. 

  97. 	zend_spprintf(&result->value.str.val, 0, "%c%s%s%s", '\0', name, filename, char_pos_buf);
    98. 

  98. #endif /* ZEND_MULTIBYTE */
    99. 

  99. 	result->type = IS_STRING;
    100. 

  100. 	Z_SET_REFCOUNT_P(result, 1);
    101. 

  101. }
    102. 

  102. /* }}} */
    103. 

  103. 

  104. 

  105. int zend_auto_global_arm(zend_auto_global *auto_global TSRMLS_DC) /* {{{ */
    106. 

  106. {
    107. 

  107. 	auto_global->armed = (auto_global->auto_global_callback ? 1 : 0);
    108. 

  108. 	return 0;
    109. 

  109. }
    110. 

  110. /* }}} */
    111. 

  111. 

  112. 

  113. ZEND_API int zend_auto_global_disable_jit(const char *varname, zend_uint varname_length TSRMLS_DC) /* {{{ */
    114. 

  114. {
    115. 

  115. 	zend_auto_global *auto_global;
    116. 

  116. 

  117. 	if (zend_hash_find(CG(auto_globals), varname, varname_length+1, (void **) &auto_global)==FAILURE) {
    118. 

  118. 		return FAILURE;
    119. 

  119. 	}
    120. 

  120. 	auto_global->armed = 0;
    121. 

  121. 	return SUCCESS;
    122. 

  122. }
    123. 

  123. /* }}} */
    124. 

  124. 

  125. 

  126. static void init_compiler_declarables(TSRMLS_D) /* {{{ */
    127. 

  127. {
    128. 

  128. 	Z_TYPE(CG(declarables).ticks) = IS_LONG;
    129. 

  129. 	Z_LVAL(CG(declarables).ticks) = 0;
    130. 

  130. }
    131. 

  131. /* }}} */
    132. 

  132. 

  133. 

  134. void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
    135. 

  135. {
    136. 

  136. 	zend_stack_init(&CG(bp_stack));
    137. 

  137. 	zend_stack_init(&CG(function_call_stack));
    138. 

  138. 	zend_stack_init(&CG(switch_cond_stack));
    139. 

  139. 	zend_stack_init(&CG(foreach_copy_stack));
    140. 

  140. 	zend_stack_init(&CG(object_stack));
    141. 

  141. 	zend_stack_init(&CG(declare_stack));
    142. 

  142. 	CG(active_class_entry) = NULL;
    143. 

  143. 	zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
    144. 

  144. 	zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
    145. 

  145. 	zend_stack_init(&CG(list_stack));
    146. 

  146. 	CG(in_compilation) = 0;
    147. 

  147. 	CG(start_lineno) = 0;
    148. 

  148. 	CG(current_namespace) = NULL;
    149. 

  149. 	CG(in_namespace) = 0;
    150. 

  150. 	CG(has_bracketed_namespaces) = 0;
    151. 

  151. 	CG(current_import) = NULL;
    152. 

  152. 	init_compiler_declarables(TSRMLS_C);
    153. 

  153. 	zend_hash_apply(CG(auto_globals), (apply_func_t) zend_auto_global_arm TSRMLS_CC);
    154. 

  154. 	zend_stack_init(&CG(labels_stack));
    155. 

  155. 	CG(labels) = NULL;
    156. 

  156. 

  157. #ifdef ZEND_MULTIBYTE
    158. 

  158. 	CG(script_encoding_list) = NULL;
    159. 

  159. 	CG(script_encoding_list_size) = 0;
    160. 

  160. 	CG(internal_encoding) = NULL;
    161. 

  161. 	CG(encoding_detector) = NULL;
    162. 

  162. 	CG(encoding_converter) = NULL;
    163. 

  163. 	CG(encoding_oddlen) = NULL;
    164. 

  164. 	CG(encoding_declared) = 0;
    165. 

  165. #endif /* ZEND_MULTIBYTE */
    166. 

  166. }
    167. 

  167. /* }}} */
    168. 

  168. 

  169. 

  170. ZEND_API void file_handle_dtor(zend_file_handle *fh) /* {{{ */
    171. 

  171. {
    172. 

  172. 	TSRMLS_FETCH();
    173. 

  173. 

  174. 	zend_file_handle_dtor(fh TSRMLS_CC);
    175. 

  175. }
    176. 

  176. /* }}} */
    177. 

  177. 

  178. 

  179. void init_compiler(TSRMLS_D) /* {{{ */
    180. 

  180. {
    181. 

  181. 	CG(active_op_array) = NULL;
    182. 

  182. 	zend_init_compiler_data_structures(TSRMLS_C);
    183. 

  183. 	zend_init_rsrc_list(TSRMLS_C);
    184. 

  184. 	zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0);
    185. 

  185. 	zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0);
    186. 

  186. 	CG(unclean_shutdown) = 0;
    187. 

  187. }
    188. 

  188. /* }}} */
    189. 

  189. 

  190. 

  191. void shutdown_compiler(TSRMLS_D) /* {{{ */
    192. 

  192. {
    193. 

  193. 	zend_stack_destroy(&CG(bp_stack));
    194. 

  194. 	zend_stack_destroy(&CG(function_call_stack));
    195. 

  195. 	zend_stack_destroy(&CG(switch_cond_stack));
    196. 

  196. 	zend_stack_destroy(&CG(foreach_copy_stack));
    197. 

  197. 	zend_stack_destroy(&CG(object_stack));
    198. 

  198. 	zend_stack_destroy(&CG(declare_stack));
    199. 

  199. 	zend_stack_destroy(&CG(list_stack));
    200. 

  200. 	zend_hash_destroy(&CG(filenames_table));
    201. 

  201. 	zend_llist_destroy(&CG(open_files));
    202. 

  202. 	zend_stack_destroy(&CG(labels_stack));
    203. 

  203. 

  204. #ifdef ZEND_MULTIBYTE
    205. 

  205. 	if (CG(script_encoding_list)) {
    206. 

  206. 		efree(CG(script_encoding_list));
    207. 

  207. 	}
    208. 

  208. #endif /* ZEND_MULTIBYTE */
    209. 

  209. }
    210. 

  210. /* }}} */
    211. 

  211. 

  212. 

  213. ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC) /* {{{ */
    214. 

  214. {
    215. 

  215. 	char **pp, *p;
    216. 

  216. 	int length = strlen(new_compiled_filename);
    217. 

  217. 

  218. 	if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp) == SUCCESS) {
    219. 

  219. 		CG(compiled_filename) = *pp;
    220. 

  220. 		return *pp;
    221. 

  221. 	}
    222. 

  222. 	p = estrndup(new_compiled_filename, length);
    223. 

  223. 	zend_hash_update(&CG(filenames_table), new_compiled_filename, length+1, &p, sizeof(char *), (void **) &pp);
    224. 

  224. 	CG(compiled_filename) = p;
    225. 

  225. 	return p;
    226. 

  226. }
    227. 

  227. /* }}} */
    228. 

  228. 

  229. 

  230. ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC) /* {{{ */
    231. 

  231. {
    232. 

  232. 	CG(compiled_filename) = original_compiled_filename;
    233. 

  233. }
    234. 

  234. /* }}} */
    235. 

  235. 

  236. 

  237. ZEND_API char *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
    238. 

  238. {
    239. 

  239. 	return CG(compiled_filename);
    240. 

  240. }
    241. 

  241. /* }}} */
    242. 

  242. 

  243. 

  244. ZEND_API int zend_get_compiled_lineno(TSRMLS_D) /* {{{ */
    245. 

  245. {
    246. 

  246. 	return CG(zend_lineno);
    247. 

  247. }
    248. 

  248. /* }}} */
    249. 

  249. 

  250. 

  251. ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */
    252. 

  252. {
    253. 

  253. 	return CG(in_compilation);
    254. 

  254. }
    255. 

  255. /* }}} */
    256. 

  256. 

  257. 

  258. static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */
    259. 

  259. {
    260. 

  260. 	return (op_array->T)++ * ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable));
    261. 

  261. }
    262. 

  262. /* }}} */
    263. 

  263. 

  264. static int lookup_cv(zend_op_array *op_array, char* name, int name_len) /* {{{ */
    265. 

  265. {
    266. 

  266. 	int i = 0;
    267. 

  267. 	ulong hash_value = zend_inline_hash_func(name, name_len+1);
    268. 

  268. 

  269. 	while (i < op_array->last_var) {
    270. 

  270. 		if (op_array->vars[i].hash_value == hash_value &&
    271. 

  271. 		    op_array->vars[i].name_len == name_len &&
    272. 

  272. 		    strcmp(op_array->vars[i].name, name) == 0) {
    273. 

  273. 		  efree(name);
    274. 

  274. 		  return i;
    275. 

  275. 		}
    276. 

  276. 		i++;
    277. 

  277. 	}
    278. 

  278. 	i = op_array->last_var;
    279. 

  279. 	op_array->last_var++;
    280. 

  280. 	if (op_array->last_var > op_array->size_var) {
    281. 

  281. 		op_array->size_var += 16; /* FIXME */
    282. 

  282. 		op_array->vars = erealloc(op_array->vars, op_array->size_var*sizeof(zend_compiled_variable));
    283. 

  283. 	}
    284. 

  284. 	op_array->vars[i].name = name; /* estrndup(name, name_len); */
    285. 

  285. 	op_array->vars[i].name_len = name_len;
    286. 

  286. 	op_array->vars[i].hash_value = hash_value;
    287. 

  287. 	return i;
    288. 

  288. }
    289. 

  289. /* }}} */
    290. 

  290. 

  291. 

  292. void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
    293. 

  293. {
    294. 

  294. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    295. 

  295. 

  296. 	opline->opcode = op;
    297. 

  297. 	opline->result.op_type = IS_TMP_VAR;
    298. 

  298. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    299. 

  299. 	opline->op1 = *op1;
    300. 

  300. 	opline->op2 = *op2;
    301. 

  301. 	*result = opline->result;
    302. 

  302. }
    303. 

  303. /* }}} */
    304. 

  304. 

  305. void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
    306. 

  306. {
    307. 

  307. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    308. 

  308. 

  309. 	opline->opcode = op;
    310. 

  310. 	opline->result.op_type = IS_TMP_VAR;
    311. 

  311. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    312. 

  312. 	opline->op1 = *op1;
    313. 

  313. 	*result = opline->result;
    314. 

  314. 	SET_UNUSED(opline->op2);
    315. 

  315. }
    316. 

  316. /* }}} */
    317. 

  317. 

  318. #define MAKE_NOP(opline)	{ opline->opcode = ZEND_NOP;  memset(&opline->result,0,sizeof(znode)); memset(&opline->op1,0,sizeof(znode)); memset(&opline->op2,0,sizeof(znode)); opline->result.op_type=opline->op1.op_type=opline->op2.op_type=IS_UNUSED;  }
    319. 

  319. 

  320. 

  321. static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {{{ */
    322. 

  322. {
    323. 

  323. 	data_op->opcode = ZEND_OP_DATA;
    324. 

  324. 	data_op->op1 = *value;
    325. 

  325. 	SET_UNUSED(data_op->op2);
    326. 

  326. }
    327. 

  327. /* }}} */
    328. 

  328. 

  329. void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
    330. 

  330. {
    331. 

  331. 	int last_op_number = get_next_op_number(CG(active_op_array));
    332. 

  332. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    333. 

  333. 

  334. 	if (last_op_number > 0) {
    335. 

  335. 		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
    336. 

  336. 

  337. 		switch (last_op->opcode) {
    338. 

  338. 			case ZEND_FETCH_OBJ_RW:
    339. 

  339. 				last_op->opcode = op;
    340. 

  340. 				last_op->extended_value = ZEND_ASSIGN_OBJ;
    341. 

  341. 

  342. 				zend_do_op_data(opline, op2 TSRMLS_CC);
    343. 

  343. 				SET_UNUSED(opline->result);
    344. 

  344. 				*result = last_op->result;
    345. 

  345. 				return;
    346. 

  346. 			case ZEND_FETCH_DIM_RW:
    347. 

  347. 				last_op->opcode = op;
    348. 

  348. 				last_op->extended_value = ZEND_ASSIGN_DIM;
    349. 

  349. 

  350. 				zend_do_op_data(opline, op2 TSRMLS_CC);
    351. 

  351. 				opline->op2.u.var = get_temporary_variable(CG(active_op_array));
    352. 

  352. 				opline->op2.u.EA.type = 0;
    353. 

  353. 				opline->op2.op_type = IS_VAR;
    354. 

  354. 				SET_UNUSED(opline->result);
    355. 

  355. 				*result = last_op->result;
    356. 

  356. 				return;
    357. 

  357. 			default:
    358. 

  358. 				break;
    359. 

  359. 		}
    360. 

  360. 	}
    361. 

  361. 

  362. 	opline->opcode = op;
    363. 

  363. 	opline->op1 = *op1;
    364. 

  364. 	opline->op2 = *op2;
    365. 

  365. 	opline->result.op_type = IS_VAR;
    366. 

  366. 	opline->result.u.EA.type = 0;
    367. 

  367. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    368. 

  368. 	*result = opline->result;
    369. 

  369. }
    370. 

  370. /* }}} */
    371. 

  371. 

  372. void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */
    373. 

  373. {
    374. 

  374. 	zend_op opline;
    375. 

  375. 	zend_op *opline_ptr;
    376. 

  376. 	zend_llist *fetch_list_ptr;
    377. 

  377. 

  378. 	if (varname->op_type == IS_CONST) {
    379. 

  379. 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
    380. 

  380. 			convert_to_string(&varname->u.constant);
    381. 

  381. 		}
    382. 

  382. 		if (!zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC) &&
    383. 

  383. 		    !(varname->u.constant.value.str.len == (sizeof("this")-1) &&
    384. 

  384. 		      !memcmp(varname->u.constant.value.str.val, "this", sizeof("this"))) &&
    385. 

  385. 		    (CG(active_op_array)->last == 0 ||
    386. 

  386. 		     CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
    387. 

  387. 			result->op_type = IS_CV;
    388. 

  388. 			result->u.var = lookup_cv(CG(active_op_array), varname->u.constant.value.str.val, varname->u.constant.value.str.len);
    389. 

  389. 			result->u.EA.type = 0;
    390. 

  390. 			varname->u.constant.value.str.val = CG(active_op_array)->vars[result->u.var].name;
    391. 

  391. 			return;
    392. 

  392. 		}
    393. 

  393. 	}
    394. 

  394. 

  395. 	if (bp) {
    396. 

  396. 		opline_ptr = &opline;
    397. 

  397. 		init_op(opline_ptr TSRMLS_CC);
    398. 

  398. 	} else {
    399. 

  399. 		opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
    400. 

  400. 	}
    401. 

  401. 

  402. 	opline_ptr->opcode = op;
    403. 

  403. 	opline_ptr->result.op_type = IS_VAR;
    404. 

  404. 	opline_ptr->result.u.EA.type = 0;
    405. 

  405. 	opline_ptr->result.u.var = get_temporary_variable(CG(active_op_array));
    406. 

  406. 	opline_ptr->op1 = *varname;
    407. 

  407. 	*result = opline_ptr->result;
    408. 

  408. 	SET_UNUSED(opline_ptr->op2);
    409. 

  409. 

  410. 	opline_ptr->op2.u.EA.type = ZEND_FETCH_LOCAL;
    411. 

  411. 	if (varname->op_type == IS_CONST && varname->u.constant.type == IS_STRING) {
    412. 

  412. 		if (zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC)) {
    413. 

  413. 			opline_ptr->op2.u.EA.type = ZEND_FETCH_GLOBAL;
    414. 

  414. 		}
    415. 

  415. 	}
    416. 

  416. 

  417. 	if (bp) {
    418. 

  418. 		zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
    419. 

  419. 		zend_llist_add_element(fetch_list_ptr, opline_ptr);
    420. 

  420. 	}
    421. 

  421. }
    422. 

  422. /* }}} */
    423. 

  423. 

  424. void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */
    425. 

  425. {
    426. 

  426. 	/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
    427. 

  427. 	fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
    428. 

  428. }
    429. 

  429. /* }}} */
    430. 

  430. 

  431. void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
    432. 

  432. {
    433. 

  433. 	znode class_node;
    434. 

  434. 	zend_llist *fetch_list_ptr;
    435. 

  435. 	zend_llist_element *le;
    436. 

  436. 	zend_op *opline_ptr;
    437. 

  437. 	zend_op opline;
    438. 

  438. 

  439. 	zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
    440. 

  440. 	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
    441. 

  441. 	if (result->op_type == IS_CV) {
    442. 

  442. 		init_op(&opline TSRMLS_CC);
    443. 

  443. 

  444. 		opline.opcode = ZEND_FETCH_W;
    445. 

  445. 		opline.result.op_type = IS_VAR;
    446. 

  446. 		opline.result.u.EA.type = 0;
    447. 

  447. 		opline.result.u.var = get_temporary_variable(CG(active_op_array));
    448. 

  448. 		opline.op1.op_type = IS_CONST;
    449. 

  449. 		opline.op1.u.constant.type = IS_STRING;
    450. 

  450. 		opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[result->u.var].name);
    451. 

  451. 		opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[result->u.var].name_len;
    452. 

  452. 		SET_UNUSED(opline.op2);
    453. 

  453. 		opline.op2 = class_node;
    454. 

  454. 		opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
    455. 

  455. 		*result = opline.result;
    456. 

  456. 

  457. 		zend_llist_add_element(fetch_list_ptr, &opline);
    458. 

  458. 	} else {
    459. 

  459. 		le = fetch_list_ptr->head;
    460. 

  460. 

  461. 		opline_ptr = (zend_op *)le->data;
    462. 

  462. 		if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1.op_type == IS_CV) {
    463. 

  463. 			init_op(&opline TSRMLS_CC);
    464. 

  464. 			opline.opcode = ZEND_FETCH_W;
    465. 

  465. 			opline.result.op_type = IS_VAR;
    466. 

  466. 			opline.result.u.EA.type = 0;
    467. 

  467. 			opline.result.u.var = get_temporary_variable(CG(active_op_array));
    468. 

  468. 			opline.op1.op_type = IS_CONST;
    469. 

  469. 			opline.op1.u.constant.type = IS_STRING;
    470. 

  470. 			opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[opline_ptr->op1.u.var].name);
    471. 

  471. 			opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[opline_ptr->op1.u.var].name_len;
    472. 

  472. 			SET_UNUSED(opline.op2);
    473. 

  473. 			opline.op2 = class_node;
    474. 

  474. 			opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
    475. 

  475. 			opline_ptr->op1 = opline.result;
    476. 

  476. 

  477. 			zend_llist_prepend_element(fetch_list_ptr, &opline);
    478. 

  478. 		} else {
    479. 

  479. 			opline_ptr->op2 = class_node;
    480. 

  480. 			opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
    481. 

  481. 		}
    482. 

  482. 	}
    483. 

  483. }
    484. 

  484. /* }}} */
    485. 

  485. 

  486. void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */
    487. 

  487. {
    488. 

  488. 	fetch_simple_variable(result, varname, 1 TSRMLS_CC);
    489. 

  489. 

  490. 	fetch_array_dim(result, result, first_dim TSRMLS_CC);
    491. 

  491. }
    492. 

  492. /* }}} */
    493. 

  493. 

  494. void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC) /* {{{ */
    495. 

  495. {
    496. 

  496. 	zend_op opline;
    497. 

  497. 	zend_llist *fetch_list_ptr;
    498. 

  498. 

  499. 	init_op(&opline TSRMLS_CC);
    500. 

  500. 	opline.opcode = ZEND_FETCH_DIM_W;	/* the backpatching routine assumes W */
    501. 

  501. 	opline.result.op_type = IS_VAR;
    502. 

  502. 	opline.result.u.EA.type = 0;
    503. 

  503. 	opline.result.u.var = get_temporary_variable(CG(active_op_array));
    504. 

  504. 	opline.op1 = *parent;
    505. 

  505. 	opline.op2 = *dim;
    506. 

  506. 	opline.extended_value = ZEND_FETCH_STANDARD;
    507. 

  507. 	*result = opline.result;
    508. 

  508. 

  509. 	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
    510. 

  510. 	zend_llist_add_element(fetch_list_ptr, &opline);
    511. 

  511. }
    512. 

  512. /* }}} */
    513. 

  513. 

  514. void fetch_string_offset(znode *result, const znode *parent, const znode *offset TSRMLS_DC) /* {{{ */
    515. 

  515. {
    516. 

  516. 	fetch_array_dim(result, parent, offset TSRMLS_CC);
    517. 

  517. }
    518. 

  518. /* }}} */
    519. 

  519. 

  520. void zend_do_print(znode *result, const znode *arg TSRMLS_DC) /* {{{ */
    521. 

  521. {
    522. 

  522. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    523. 

  523. 

  524. 	opline->result.op_type = IS_TMP_VAR;
    525. 

  525. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    526. 

  526. 	opline->opcode = ZEND_PRINT;
    527. 

  527. 	opline->op1 = *arg;
    528. 

  528. 	SET_UNUSED(opline->op2);
    529. 

  529. 	*result = opline->result;
    530. 

  530. }
    531. 

  531. /* }}} */
    532. 

  532. 

  533. void zend_do_echo(const znode *arg TSRMLS_DC) /* {{{ */
    534. 

  534. {
    535. 

  535. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    536. 

  536. 

  537. 	opline->opcode = ZEND_ECHO;
    538. 

  538. 	opline->op1 = *arg;
    539. 

  539. 	SET_UNUSED(opline->op2);
    540. 

  540. }
    541. 

  541. /* }}} */
    542. 

  542. 

  543. void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */
    544. 

  544. {
    545. 

  545. 	char *method_type;
    546. 

  546. 

  547. 	if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
    548. 

  548. 		Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
    549. 

  549. 		method_type = "Interface";
    550. 

  550. 	} else {
    551. 

  551. 		method_type = "Abstract";
    552. 

  552. 	}
    553. 

  553. 

  554. 	if (modifiers->u.constant.value.lval & ZEND_ACC_ABSTRACT) {
    555. 

  555. 		if(modifiers->u.constant.value.lval & ZEND_ACC_PRIVATE) {
    556. 

  556. 			zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, function_name->u.constant.value.str.val);
    557. 

  557. 		}
    558. 

  558. 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
    559. 

  559. 			zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    560. 

  560. 

  561. 			opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
    562. 

  562. 			SET_UNUSED(opline->op1);
    563. 

  563. 			SET_UNUSED(opline->op2);
    564. 

  564. 		} else {
    565. 

  565. 			/* we had code in the function body */
    566. 

  566. 			zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, function_name->u.constant.value.str.val);
    567. 

  567. 		}
    568. 

  568. 	} else {
    569. 

  569. 		if (body->u.constant.value.lval == ZEND_ACC_ABSTRACT) {
    570. 

  570. 			zend_error(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, function_name->u.constant.value.str.val);
    571. 

  571. 		}
    572. 

  572. 	}
    573. 

  573. }
    574. 

  574. /* }}} */
    575. 

  575. 

  576. static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */
    577. 

  577. {
    578. 

  578. 	if ((opline->opcode == ZEND_FETCH_W) && (opline->op1.op_type == IS_CONST)
    579. 

  579. 		&& (opline->op1.u.constant.type == IS_STRING)
    580. 

  580. 		&& (opline->op1.u.constant.value.str.len == (sizeof("this")-1))
    581. 

  581. 		&& !memcmp(opline->op1.u.constant.value.str.val, "this", sizeof("this"))) {
    582. 

  582. 		return 1;
    583. 

  583. 	} else {
    584. 

  584. 		return 0;
    585. 

  585. 	}
    586. 

  586. }
    587. 

  587. /* }}} */
    588. 

  588. 

  589. void zend_do_assign(znode *result, znode *variable, const znode *value TSRMLS_DC) /* {{{ */
    590. 

  590. {
    591. 

  591. 	int last_op_number;
    592. 

  592. 	zend_op *opline;
    593. 

  593. 

  594. 	if (value->op_type == IS_CV) {
    595. 

  595. 		zend_llist *fetch_list_ptr;
    596. 

  596. 

  597. 		zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
    598. 

  598. 		if (fetch_list_ptr && fetch_list_ptr->head) {
    599. 

  599. 			opline = (zend_op *)fetch_list_ptr->head->data;
    600. 

  600. 

  601. 			if (opline->opcode == ZEND_FETCH_DIM_W &&
    602. 

  602. 			    opline->op1.op_type == IS_CV &&
    603. 

  603. 			    opline->op1.u.var == value->u.var) {
    604. 

  604. 

  605. 				opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    606. 

  606. 				opline->opcode = ZEND_FETCH_R;
    607. 

  607. 				opline->result.op_type = IS_VAR;
    608. 

  608. 				opline->result.u.EA.type = 0;
    609. 

  609. 				opline->result.u.var = get_temporary_variable(CG(active_op_array));
    610. 

  610. 				opline->op1.op_type = IS_CONST;
    611. 

  611. 				ZVAL_STRINGL(&opline->op1.u.constant,
    612. 

  612. 					CG(active_op_array)->vars[value->u.var].name, 
    613. 

  613. 					CG(active_op_array)->vars[value->u.var].name_len, 1);
    614. 

  614. 				SET_UNUSED(opline->op2);
    615. 

  615. 				opline->op2.u.EA.type = ZEND_FETCH_LOCAL;
    616. 

  616. 				value = &opline->result;
    617. 

  617. 			}
    618. 

  618. 		}
    619. 

  619. 	}
    620. 

  620. 

  621. 	zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC);
    622. 

  622. 

  623. 	last_op_number = get_next_op_number(CG(active_op_array));
    624. 

  624. 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    625. 

  625. 

  626. 	if (variable->op_type == IS_CV) {
    627. 

  627. 		if (variable->u.var == CG(active_op_array)->this_var) {
    628. 

  628. 			zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
    629. 

  629. 		}
    630. 

  630. 	} else if (variable->op_type == IS_VAR) {
    631. 

  631. 		int n = 0;
    632. 

  632. 

  633. 		while (last_op_number - n > 0) {
    634. 

  634. 			zend_op *last_op;
    635. 

  635. 

  636. 			last_op = &CG(active_op_array)->opcodes[last_op_number-n-1];
    637. 

  637. 

  638. 			if (last_op->result.op_type == IS_VAR &&
    639. 

  639. 			    last_op->result.u.var == variable->u.var) {
    640. 

  640. 				if (last_op->opcode == ZEND_FETCH_OBJ_W) {
    641. 

  641. 					if (n > 0) {
    642. 

  642. 						int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
    643. 

  643. 						*opline = *last_op;
    644. 

  644. 						MAKE_NOP(last_op);
    645. 

  645. 						/* last_op = opline; */
    646. 

  646. 						opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    647. 

  647. 						/* get_next_op can realloc, we need to move last_op */
    648. 

  648. 						last_op = &CG(active_op_array)->opcodes[opline_no];
    649. 

  649. 					}
    650. 

  650. 					last_op->opcode = ZEND_ASSIGN_OBJ;
    651. 

  651. 					zend_do_op_data(opline, value TSRMLS_CC);
    652. 

  652. 					SET_UNUSED(opline->result);
    653. 

  653. 					*result = last_op->result;
    654. 

  654. 					return;
    655. 

  655. 				} else if (last_op->opcode == ZEND_FETCH_DIM_W) {
    656. 

  656. 					if (n > 0) {
    657. 

  657. 						int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
    658. 

  658. 						*opline = *last_op;
    659. 

  659. 						MAKE_NOP(last_op);
    660. 

  660. 						/* last_op = opline; */
    661. 

  661. 						/* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */
    662. 

  662. 						opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    663. 

  663. 						/* get_next_op can realloc, we need to move last_op */
    664. 

  664. 						last_op = &CG(active_op_array)->opcodes[opline_no];
    665. 

  665. 					}
    666. 

  666. 					last_op->opcode = ZEND_ASSIGN_DIM;
    667. 

  667. 					zend_do_op_data(opline, value TSRMLS_CC);
    668. 

  668. 					opline->op2.u.var = get_temporary_variable(CG(active_op_array));
    669. 

  669. 					opline->op2.u.EA.type = 0;
    670. 

  670. 					opline->op2.op_type = IS_VAR;
    671. 

  671. 					SET_UNUSED(opline->result);
    672. 

  672. 					*result = last_op->result;
    673. 

  673. 					return;
    674. 

  674. 				} else if (opline_is_fetch_this(last_op TSRMLS_CC)) {
    675. 

  675. 					zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
    676. 

  676. 				} else {
    677. 

  677. 					break;
    678. 

  678. 				}
    679. 

  679. 			}
    680. 

  680. 			n++;
    681. 

  681. 		}
    682. 

  682. 	}
    683. 

  683. 

  684. 	opline->opcode = ZEND_ASSIGN;
    685. 

  685. 	opline->op1 = *variable;
    686. 

  686. 	opline->op2 = *value;
    687. 

  687. 	opline->result.op_type = IS_VAR;
    688. 

  688. 	opline->result.u.EA.type = 0;
    689. 

  689. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    690. 

  690. 	*result = opline->result;
    691. 

  691. }
    692. 

  692. /* }}} */
    693. 

  693. 

  694. static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */
    695. 

  695. {
    696. 

  696. 	zend_uint type = variable->u.EA.type;
    697. 

  697. 

  698. 	return  ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL));
    699. 

  699. }
    700. 

  700. /* }}} */
    701. 

  701. 

  702. void zend_do_assign_ref(znode *result, const znode *lvar, const znode *rvar TSRMLS_DC) /* {{{ */
    703. 

  703. {
    704. 

  704. 	zend_op *opline;
    705. 

  705. 

  706. 	if (lvar->op_type == IS_CV) {
    707. 

  707. 		if (lvar->u.var == CG(active_op_array)->this_var) {
    708. 

  708.  			zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
    709. 

  709. 		}
    710. 

  710. 	} else if (lvar->op_type == IS_VAR) {
    711. 

  711. 		int last_op_number = get_next_op_number(CG(active_op_array));
    712. 

  712. 

  713. 		if (last_op_number > 0) {
    714. 

  714. 			opline = &CG(active_op_array)->opcodes[last_op_number-1];
    715. 

  715. 			if (opline_is_fetch_this(opline TSRMLS_CC)) {
    716. 

  716. 	 			zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
    717. 

  717. 			}
    718. 

  718.  		}
    719. 

  719.  	}
    720. 

  720. 

  721. 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    722. 

  722. 	opline->opcode = ZEND_ASSIGN_REF;
    723. 

  723. 	if (zend_is_function_or_method_call(rvar)) {
    724. 

  724. 		opline->extended_value = ZEND_RETURNS_FUNCTION;
    725. 

  725. 	} else if (rvar->u.EA.type & ZEND_PARSED_NEW) {
    726. 

  726. 		opline->extended_value = ZEND_RETURNS_NEW;
    727. 

  727. 	} else {
    728. 

  728. 		opline->extended_value = 0;
    729. 

  729. 	}
    730. 

  730. 	if (result) {
    731. 

  731. 		opline->result.op_type = IS_VAR;
    732. 

  732. 		opline->result.u.EA.type = 0;
    733. 

  733. 		opline->result.u.var = get_temporary_variable(CG(active_op_array));
    734. 

  734. 		*result = opline->result;
    735. 

  735. 	} else {
    736. 

  736. 		/* SET_UNUSED(opline->result); */
    737. 

  737. 		opline->result.u.EA.type |= EXT_TYPE_UNUSED;
    738. 

  738. 	}
    739. 

  739. 	opline->op1 = *lvar;
    740. 

  740. 	opline->op2 = *rvar;
    741. 

  741. }
    742. 

  742. /* }}} */
    743. 

  743. 

  744. static inline void do_begin_loop(TSRMLS_D) /* {{{ */
    745. 

  745. {
    746. 

  746. 	zend_brk_cont_element *brk_cont_element;
    747. 

  747. 	int parent;
    748. 

  748. 

  749. 	parent = CG(active_op_array)->current_brk_cont;
    750. 

  750. 	CG(active_op_array)->current_brk_cont = CG(active_op_array)->last_brk_cont;
    751. 

  751. 	brk_cont_element = get_next_brk_cont_element(CG(active_op_array));
    752. 

  752. 	brk_cont_element->start = get_next_op_number(CG(active_op_array));
    753. 

  753. 	brk_cont_element->parent = parent;
    754. 

  754. }
    755. 

  755. /* }}} */
    756. 

  756. 

  757. static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
    758. 

  758. {
    759. 

  759. 	if (!has_loop_var) {
    760. 

  760. 		/* The start fileld is used to free temporary variables in case of exceptions.
    761. 

  761. 		 * We won't try to free something of we don't have loop variable.
    762. 

  762. 		 */
    763. 

  763. 		CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].start = -1;
    764. 

  764. 	}
    765. 

  765. 	CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].cont = cont_addr;
    766. 

  766. 	CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].brk = get_next_op_number(CG(active_op_array));
    767. 

  767. 	CG(active_op_array)->current_brk_cont = CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].parent;
    768. 

  768. }
    769. 

  769. /* }}} */
    770. 

  770. 

  771. void zend_do_while_cond(const znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
    772. 

  772. {
    773. 

  773. 	int while_cond_op_number = get_next_op_number(CG(active_op_array));
    774. 

  774. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    775. 

  775. 

  776. 	opline->opcode = ZEND_JMPZ;
    777. 

  777. 	opline->op1 = *expr;
    778. 

  778. 	close_bracket_token->u.opline_num = while_cond_op_number;
    779. 

  779. 	SET_UNUSED(opline->op2);
    780. 

  780. 

  781. 	do_begin_loop(TSRMLS_C);
    782. 

  782. 	INC_BPC(CG(active_op_array));
    783. 

  783. }
    784. 

  784. /* }}} */
    785. 

  785. 

  786. void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */
    787. 

  787. {
    788. 

  788. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    789. 

  789. 

  790. 	/* add unconditional jump */
    791. 

  791. 	opline->opcode = ZEND_JMP;
    792. 

  792. 	opline->op1.u.opline_num = while_token->u.opline_num;
    793. 

  793. 	SET_UNUSED(opline->op1);
    794. 

  794. 	SET_UNUSED(opline->op2);
    795. 

  795. 

  796. 	/* update while's conditional jmp */
    797. 

  797. 	CG(active_op_array)->opcodes[close_bracket_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
    798. 

  798. 

  799. 	do_end_loop(while_token->u.opline_num, 0 TSRMLS_CC);
    800. 

  800. 

  801. 	DEC_BPC(CG(active_op_array));
    802. 

  802. }
    803. 

  803. /* }}} */
    804. 

  804. 

  805. void zend_do_for_cond(const znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
    806. 

  806. {
    807. 

  807. 	int for_cond_op_number = get_next_op_number(CG(active_op_array));
    808. 

  808. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    809. 

  809. 

  810. 	opline->opcode = ZEND_JMPZNZ;
    811. 

  811. 	opline->op1 = *expr;  /* the conditional expression */
    812. 

  812. 	second_semicolon_token->u.opline_num = for_cond_op_number;
    813. 

  813. 	SET_UNUSED(opline->op2);
    814. 

  814. }
    815. 

  815. /* }}} */
    816. 

  816. 

  817. void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
    818. 

  818. {
    819. 

  819. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    820. 

  820. 

  821. 	opline->opcode = ZEND_JMP;
    822. 

  822. 	opline->op1.u.opline_num = cond_start->u.opline_num;
    823. 

  823. 	CG(active_op_array)->opcodes[second_semicolon_token->u.opline_num].extended_value = get_next_op_number(CG(active_op_array));
    824. 

  824. 	SET_UNUSED(opline->op1);
    825. 

  825. 	SET_UNUSED(opline->op2);
    826. 

  826. 

  827. 	do_begin_loop(TSRMLS_C);
    828. 

  828. 

  829. 	INC_BPC(CG(active_op_array));
    830. 

  830. }
    831. 

  831. /* }}} */
    832. 

  832. 

  833. void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
    834. 

  834. {
    835. 

  835. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    836. 

  836. 

  837. 	opline->opcode = ZEND_JMP;
    838. 

  838. 	opline->op1.u.opline_num = second_semicolon_token->u.opline_num+1;
    839. 

  839. 	CG(active_op_array)->opcodes[second_semicolon_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
    840. 

  840. 	SET_UNUSED(opline->op1);
    841. 

  841. 	SET_UNUSED(opline->op2);
    842. 

  842. 

  843. 	do_end_loop(second_semicolon_token->u.opline_num+1, 0 TSRMLS_CC);
    844. 

  844. 

  845. 	DEC_BPC(CG(active_op_array));
    846. 

  846. }
    847. 

  847. /* }}} */
    848. 

  848. 

  849. void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
    850. 

  850. {
    851. 

  851. 	int last_op_number = get_next_op_number(CG(active_op_array));
    852. 

  852. 	zend_op *opline;
    853. 

  853. 

  854. 	if (last_op_number > 0) {
    855. 

  855. 		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
    856. 

  856. 

  857. 		if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
    858. 

  858. 			last_op->opcode = (op==ZEND_PRE_INC)?ZEND_PRE_INC_OBJ:ZEND_PRE_DEC_OBJ;
    859. 

  859. 			last_op->result.op_type = IS_VAR;
    860. 

  860. 			last_op->result.u.EA.type = 0;
    861. 

  861. 			last_op->result.u.var = get_temporary_variable(CG(active_op_array));
    862. 

  862. 			*result = last_op->result;
    863. 

  863. 			return;
    864. 

  864. 		}
    865. 

  865. 	}
    866. 

  866. 

  867. 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    868. 

  868. 	opline->opcode = op;
    869. 

  869. 	opline->op1 = *op1;
    870. 

  870. 	SET_UNUSED(opline->op2);
    871. 

  871. 	opline->result.op_type = IS_VAR;
    872. 

  872. 	opline->result.u.EA.type = 0;
    873. 

  873. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    874. 

  874. 	*result = opline->result;
    875. 

  875. }
    876. 

  876. /* }}} */
    877. 

  877. 

  878. void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
    879. 

  879. {
    880. 

  880. 	int last_op_number = get_next_op_number(CG(active_op_array));
    881. 

  881. 	zend_op *opline;
    882. 

  882. 

  883. 	if (last_op_number > 0) {
    884. 

  884. 		zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
    885. 

  885. 

  886. 		if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
    887. 

  887. 			last_op->opcode = (op==ZEND_POST_INC)?ZEND_POST_INC_OBJ:ZEND_POST_DEC_OBJ;
    888. 

  888. 			last_op->result.op_type = IS_TMP_VAR;
    889. 

  889. 			last_op->result.u.var = get_temporary_variable(CG(active_op_array));
    890. 

  890. 			*result = last_op->result;
    891. 

  891. 			return;
    892. 

  892. 		}
    893. 

  893. 	}
    894. 

  894. 

  895. 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    896. 

  896. 	opline->opcode = op;
    897. 

  897. 	opline->op1 = *op1;
    898. 

  898. 	SET_UNUSED(opline->op2);
    899. 

  899. 	opline->result.op_type = IS_TMP_VAR;
    900. 

  900. 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
    901. 

  901. 	*result = opline->result;
    902. 

  902. }
    903. 

  903. /* }}} */
    904. 

  904. 

  905. void zend_do_if_cond(const znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */
    906. 

  906. {
    907. 

  907. 	int if_cond_op_number = get_next_op_number(CG(active_op_array));
    908. 

  908. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    909. 

  909. 

  910. 	opline->opcode = ZEND_JMPZ;
    911. 

  911. 	opline->op1 = *cond;
    912. 

  912. 	closing_bracket_token->u.opline_num = if_cond_op_number;
    913. 

  913. 	SET_UNUSED(opline->op2);
    914. 

  914. 	INC_BPC(CG(active_op_array));
    915. 

  915. }
    916. 

  916. /* }}} */
    917. 

  917. 

  918. void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC) /* {{{ */
    919. 

  919. {
    920. 

  920. 	int if_end_op_number = get_next_op_number(CG(active_op_array));
    921. 

  921. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    922. 

  922. 	zend_llist *jmp_list_ptr;
    923. 

  923. 

  924. 	opline->opcode = ZEND_JMP;
    925. 

  925. 	/* save for backpatching */
    926. 

  926. 	if (initialize) {
    927. 

  927. 		zend_llist jmp_list;
    928. 

  928. 

  929. 		zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
    930. 

  930. 		zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist));
    931. 

  931. 	}
    932. 

  932. 	zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
    933. 

  933. 	zend_llist_add_element(jmp_list_ptr, &if_end_op_number);
    934. 

  934. 

  935. 	CG(active_op_array)->opcodes[closing_bracket_token->u.opline_num].op2.u.opline_num = if_end_op_number+1;
    936. 

  936. 	SET_UNUSED(opline->op1);
    937. 

  937. 	SET_UNUSED(opline->op2);
    938. 

  938. }
    939. 

  939. /* }}} */
    940. 

  940. 

  941. void zend_do_if_end(TSRMLS_D) /* {{{ */
    942. 

  942. {
    943. 

  943. 	int next_op_number = get_next_op_number(CG(active_op_array));
    944. 

  944. 	zend_llist *jmp_list_ptr;
    945. 

  945. 	zend_llist_element *le;
    946. 

  946. 

  947. 	zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
    948. 

  948. 	for (le=jmp_list_ptr->head; le; le = le->next) {
    949. 

  949. 		CG(active_op_array)->opcodes[*((int *) le->data)].op1.u.opline_num = next_op_number;
    950. 

  950. 	}
    951. 

  951. 	zend_llist_destroy(jmp_list_ptr);
    952. 

  952. 	zend_stack_del_top(&CG(bp_stack));
    953. 

  953. 	DEC_BPC(CG(active_op_array));
    954. 

  954. }
    955. 

  955. /* }}} */
    956. 

  956. 

  957. void zend_check_writable_variable(const znode *variable) /* {{{ */
    958. 

  958. {
    959. 

  959. 	zend_uint type = variable->u.EA.type;
    960. 

  960. 

  961. 	if (type & ZEND_PARSED_METHOD_CALL) {
    962. 

  962. 		zend_error(E_COMPILE_ERROR, "Can't use method return value in write context");
    963. 

  963. 	}
    964. 

  964. 	if (type == ZEND_PARSED_FUNCTION_CALL) {
    965. 

  965. 		zend_error(E_COMPILE_ERROR, "Can't use function return value in write context");
    966. 

  966. 	}
    967. 

  967. }
    968. 

  968. /* }}} */
    969. 

  969. 

  970. void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */
    971. 

  971. {
    972. 

  972. 	zend_llist fetch_list;
    973. 

  973. 

  974. 	zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0);
    975. 

  975. 	zend_stack_push(&CG(bp_stack), (void *) &fetch_list, sizeof(zend_llist));
    976. 

  976. }
    977. 

  977. /* }}} */
    978. 

  978. 

  979. void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */
    980. 

  980. {
    981. 

  981. 	zend_llist *fetch_list_ptr;
    982. 

  982. 	zend_llist_element *le;
    983. 

  983. 	zend_op *opline = NULL;
    984. 

  984. 	zend_op *opline_ptr;
    985. 

  985. 	zend_uint this_var = -1;
    986. 

  986. 

  987. 	zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
    988. 

  988. 

  989. 	le = fetch_list_ptr->head;
    990. 

  990. 

  991. 	/* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */
    992. 

  992. 

  993. 	if (le) {
    994. 

  994. 		opline_ptr = (zend_op *)le->data;
    995. 

  995. 		if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
    996. 

  996. 			/* convert to FETCH_?(this) into IS_CV */
    997. 

  997. 			if (CG(active_op_array)->last == 0 ||
    998. 

  998. 			    CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) {
    999. 

  999. 

  1000. 				this_var = opline_ptr->result.u.var;
    1001. 

  1001. 				if (CG(active_op_array)->this_var == -1) {
    1002. 

  1002. 					CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STRVAL(opline_ptr->op1.u.constant), Z_STRLEN(opline_ptr->op1.u.constant));
    1003. 

  1003. 				} else {
    1004. 

  1004. 					efree(Z_STRVAL(opline_ptr->op1.u.constant));
    1005. 

  1005. 				}
    1006. 

  1006. 				le = le->next;
    1007. 

  1007. 				if (variable->op_type == IS_VAR &&
    1008. 

  1008. 				    variable->u.var == this_var) {
    1009. 

  1009. 					variable->op_type = IS_CV;
    1010. 

  1010. 					variable->u.var = CG(active_op_array)->this_var;
    1011. 

  1011. 				}
    1012. 

  1012. 			} else if (CG(active_op_array)->this_var == -1) {
    1013. 

  1013. 				CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1);
    1014. 

  1014. 			}
    1015. 

  1015. 		}
    1016. 

  1016. 

  1017. 		while (le) {
    1018. 

  1018. 			opline_ptr = (zend_op *)le->data;
    1019. 

  1019. 			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1020. 

  1020. 			memcpy(opline, opline_ptr, sizeof(zend_op));
    1021. 

  1021. 			if (opline->op1.op_type == IS_VAR &&
    1022. 

  1022. 			    opline->op1.u.var == this_var) {
    1023. 

  1023. 				opline->op1.op_type = IS_CV;
    1024. 

  1024. 				opline->op1.u.var = CG(active_op_array)->this_var;
    1025. 

  1025. 			}
    1026. 

  1026. 			switch (type) {
    1027. 

  1027. 				case BP_VAR_R:
    1028. 

  1028. 					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2.op_type == IS_UNUSED) {
    1029. 

  1029. 						zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
    1030. 

  1030. 					}
    1031. 

  1031. 					opline->opcode -= 3;
    1032. 

  1032. 					break;
    1033. 

  1033. 				case BP_VAR_W:
    1034. 

  1034. 					break;
    1035. 

  1035. 				case BP_VAR_RW:
    1036. 

  1036. 					opline->opcode += 3;
    1037. 

  1037. 					break;
    1038. 

  1038. 				case BP_VAR_IS:
    1039. 

  1039. 					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2.op_type == IS_UNUSED) {
    1040. 

  1040. 						zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
    1041. 

  1041. 					}
    1042. 

  1042. 					opline->opcode += 6; /* 3+3 */
    1043. 

  1043. 					break;
    1044. 

  1044. 				case BP_VAR_FUNC_ARG:
    1045. 

  1045. 					opline->opcode += 9; /* 3+3+3 */
    1046. 

  1046. 					opline->extended_value = arg_offset;
    1047. 

  1047. 					break;
    1048. 

  1048. 				case BP_VAR_UNSET:
    1049. 

  1049. 					if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2.op_type == IS_UNUSED) {
    1050. 

  1050. 						zend_error(E_COMPILE_ERROR, "Cannot use [] for unsetting");
    1051. 

  1051. 					}
    1052. 

  1052. 					opline->opcode += 12; /* 3+3+3+3 */
    1053. 

  1053. 					break;
    1054. 

  1054. 			}
    1055. 

  1055. 			le = le->next;
    1056. 

  1056. 		}
    1057. 

  1057. 		if (opline && type == BP_VAR_W && arg_offset) {
    1058. 

  1058. 			opline->extended_value = ZEND_FETCH_MAKE_REF;
    1059. 

  1059. 		}
    1060. 

  1060. 	}
    1061. 

  1061. 	zend_llist_destroy(fetch_list_ptr);
    1062. 

  1062. 	zend_stack_del_top(&CG(bp_stack));
    1063. 

  1063. }
    1064. 

  1064. /* }}} */
    1065. 

  1065. 

  1066. void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
    1067. 

  1067. {
    1068. 

  1068. 	zend_op *opline;
    1069. 

  1069. 

  1070. 	if (Z_STRLEN(op2->u.constant) > 1) {
    1071. 

  1071. 		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1072. 

  1072. 		opline->opcode = ZEND_ADD_STRING;
    1073. 

  1073. 	} else if (Z_STRLEN(op2->u.constant) == 1) {
    1074. 

  1074. 		int ch = *Z_STRVAL(op2->u.constant);
    1075. 

  1075. 

  1076. 		/* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */
    1077. 

  1077. 		efree(Z_STRVAL(op2->u.constant));
    1078. 

  1078. 		ZVAL_LONG(&op2->u.constant, ch);
    1079. 

  1079. 		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1080. 

  1080. 		opline->opcode = ZEND_ADD_CHAR;
    1081. 

  1081. 	} else { /* String can be empty after a variable at the end of a heredoc */
    1082. 

  1082. 		efree(Z_STRVAL(op2->u.constant));
    1083. 

  1083. 		return;
    1084. 

  1084. 	}
    1085. 

  1085. 

  1086. 	if (op1) {
    1087. 

  1087. 		opline->op1 = *op1;
    1088. 

  1088. 		opline->result = *op1;
    1089. 

  1089. 	} else {
    1090. 

  1090. 		SET_UNUSED(opline->op1);
    1091. 

  1091. 		opline->result.op_type = IS_TMP_VAR;
    1092. 

  1092. 		opline->result.u.var = get_temporary_variable(CG(active_op_array));
    1093. 

  1093. 	}
    1094. 

  1094. 	opline->op2 = *op2;
    1095. 

  1095. 	*result = opline->result;
    1096. 

  1096. }
    1097. 

  1097. /* }}} */
    1098. 

  1098. 

  1099. void zend_do_add_variable(znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
    1100. 

  1100. {
    1101. 

  1101. 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1102. 

  1102. 

  1103. 	opline->opcode = ZEND_ADD_VAR;
    1104. 

  1104. 

  1105. 	if (op1) {
    1106. 

  1106. 		opline->op1 = *op1;
    1107. 

  1107. 		opline->result = *op1;
    1108. 

  1108. 	} else {
    1109. 

  1109. 		SET_UNUSED(opline->op1);
    1110. 

  1110. 		opline->result.op_type = IS_TMP_VAR;
    1111. 

  1111. 		opline->result.u.var = get_temporary_variable(CG(active_op_array));
    1112. 

  1112. 	}
    1113. 

  1113. 	opline->op2 = *op2;
    1114. 

  1114. 	*result = opline->result;
    1115. 

  1115. }
    1116. 

  1116. /* }}} */
    1117. 

  1117. 

  1118. void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
    1119. 

  1119. {
    1120. 

  1120. 	if (op1->op_type==IS_TMP_VAR) {
    1121. 

  1121. 		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1122. 

  1122. 

  1123. 		opline->opcode = ZEND_FREE;
    1124. 

  1124. 		opline->op1 = *op1;
    1125. 

  1125. 		SET_UNUSED(opline->op2);
    1126. 

  1126. 	} else if (op1->op_type==IS_VAR) {
    1127. 

  1127. 		zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
    1128. 

  1128. 

  1129. 		while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
    1130. 

  1130. 			opline--;
    1131. 

  1131. 		}
    1132. 

  1132. 		if (opline->result.op_type == IS_VAR
    1133. 

  1133. 			&& opline->result.u.var == op1->u.var) {
    1134. 

  1134. 			opline->result.u.EA.type |= EXT_TYPE_UNUSED;
    1135. 

  1135. 		} else {
    1136. 

  1136. 			while (opline>CG(active_op_array)->opcodes) {
    1137. 

  1137. 				if (opline->opcode == ZEND_FETCH_DIM_R
    1138. 

  1138. 				    && opline->op1.op_type == IS_VAR
    1139. 

  1139. 				    && opline->op1.u.var == op1->u.var) {
    1140. 

  1140. 					/* This should the end of a list() construct
    1141. 

  1141. 					 * Mark its result as unused
    1142. 

  1142. 					 */
    1143. 

  1143. 					opline->extended_value = ZEND_FETCH_STANDARD;
    1144. 

  1144. 					break;
    1145. 

  1145. 				} else if (opline->result.op_type==IS_VAR
    1146. 

  1146. 					&& opline->result.u.var == op1->u.var) {
    1147. 

  1147. 					if (opline->opcode == ZEND_NEW) {
    1148. 

  1148. 						opline->result.u.EA.type |= EXT_TYPE_UNUSED;
    1149. 

  1149. 					}
    1150. 

  1150. 					break;
    1151. 

  1151. 				}
    1152. 

  1152. 				opline--;
    1153. 

  1153. 			}
    1154. 

  1154. 		}
    1155. 

  1155. 	} else if (op1->op_type == IS_CONST) {
    1156. 

  1156. 		zval_dtor(&op1->u.constant);
    1157. 

  1157. 	}
    1158. 

  1158. }
    1159. 

  1159. /* }}} */
    1160. 

  1160. 

  1161. int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */
    1162. 

  1162. {
    1163. 

  1163. 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
    1164. 

  1164. 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
    1165. 

  1165. 		zend_error(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
    1166. 

  1166. 	}
    1167. 

  1167. 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
    1168. 

  1168. 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
    1169. 

  1169. 		zend_error(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
    1170. 

  1170. 	}
    1171. 

  1171. 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
    1172. 

  1172. 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
    1173. 

  1173. 		zend_error(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
    1174. 

  1174. 	}
    1175. 

  1175. 	if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
    1176. 

  1176. 		&& (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
    1177. 

  1177. 		zend_error(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
    1178. 

  1178. 	}
    1179. 

  1179. 	if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
    1180. 

  1180. 		zend_error(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
    1181. 

  1181. 	}
    1182. 

  1182. 	return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
    1183. 

  1183. }
    1184. 

  1184. /* }}} */
    1185. 

  1185. 

  1186. void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
    1187. 

  1187. {
    1188. 

  1188. 	zend_op_array op_array;
    1189. 

  1189. 	char *name = function_name->u.constant.value.str.val;
    1190. 

  1190. 	int name_len = function_name->u.constant.value.str.len;
    1191. 

  1191. 	int function_begin_line = function_token->u.opline_num;
    1192. 

  1192. 	zend_uint fn_flags;
    1193. 

  1193. 	char *lcname;
    1194. 

  1194. 	zend_bool orig_interactive;
    1195. 

  1195. 	ALLOCA_FLAG(use_heap)
    1196. 

  1196. 

  1197. 	if (is_method) {
    1198. 

  1198. 		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
    1199. 

  1199. 			if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
    1200. 

  1200. 				zend_error(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, function_name->u.constant.value.str.val);
    1201. 

  1201. 			}
    1202. 

  1202. 			Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
    1203. 

  1203. 		}
    1204. 

  1204. 		fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
    1205. 

  1205. 	} else {
    1206. 

  1206. 		fn_flags = 0;
    1207. 

  1207. 	}
    1208. 

  1208. 	if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
    1209. 

  1209. 		zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
    1210. 

  1210. 	}
    1211. 

  1211. 

  1212. 	function_token->u.op_array = CG(active_op_array);
    1213. 

  1213. 	lcname = zend_str_tolower_dup(name, name_len);
    1214. 

  1214. 

  1215. 	orig_interactive = CG(interactive);
    1216. 

  1216. 	CG(interactive) = 0;
    1217. 

  1217. 	init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
    1218. 

  1218. 	CG(interactive) = orig_interactive;
    1219. 

  1219. 

  1220. 	op_array.function_name = name;
    1221. 

  1221. 	op_array.return_reference = return_reference;
    1222. 

  1222. 	op_array.fn_flags |= fn_flags;
    1223. 

  1223. 	op_array.pass_rest_by_reference = 0;
    1224. 

  1224. 

  1225. 	op_array.scope = is_method?CG(active_class_entry):NULL;
    1226. 

  1226. 	op_array.prototype = NULL;
    1227. 

  1227. 

  1228. 	op_array.line_start = zend_get_compiled_lineno(TSRMLS_C);
    1229. 

  1229. 

  1230. 	if (is_method) {
    1231. 

  1231. 		if (zend_hash_add(&CG(active_class_entry)->function_table, lcname, name_len+1, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)) == FAILURE) {
    1232. 

  1232. 			zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name, name);
    1233. 

  1233. 		}
    1234. 

  1234. 

  1235. 		if (fn_flags & ZEND_ACC_ABSTRACT) {
    1236. 

  1236. 			CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
    1237. 

  1237. 		}
    1238. 

  1238. 

  1239. 		if (!(fn_flags & ZEND_ACC_PPP_MASK)) {
    1240. 

  1240. 			fn_flags |= ZEND_ACC_PUBLIC;
    1241. 

  1241. 		}
    1242. 

  1242. 

  1243. 		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
    1244. 

  1244. 			if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
    1245. 

  1245. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1246. 

  1246. 					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
    1247. 

  1247. 				}
    1248. 

  1248. 			} else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
    1249. 

  1249. 				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
    1250. 

  1250. 					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
    1251. 

  1251. 				}
    1252. 

  1252. 			} else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
    1253. 

  1253. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1254. 

  1254. 					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
    1255. 

  1255. 				}
    1256. 

  1256. 			} else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
    1257. 

  1257. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1258. 

  1258. 					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
    1259. 

  1259. 				}
    1260. 

  1260. 			} else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
    1261. 

  1261. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1262. 

  1262. 					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
    1263. 

  1263. 				}
    1264. 

  1264. 			} else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
    1265. 

  1265. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1266. 

  1266. 					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
    1267. 

  1267. 				}
    1268. 

  1268. 			} else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
    1269. 

  1269. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1270. 

  1270. 					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
    1271. 

  1271. 				}
    1272. 

  1272. 			}
    1273. 

  1273. 		} else {
    1274. 

  1274. 			char *class_lcname;
    1275. 

  1275. 			
    1276. 

  1276. 			class_lcname = do_alloca(CG(active_class_entry)->name_length + 1, use_heap);
    1277. 

  1277. 			zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name, CG(active_class_entry)->name_length);
    1278. 

  1278. 			/* Improve after RC: cache the lowercase class name */
    1279. 

  1279. 

  1280. 			if ((CG(active_class_entry)->name_length == name_len) && (!memcmp(class_lcname, lcname, name_len))) {
    1281. 

  1281. 				if (!CG(active_class_entry)->constructor) {
    1282. 

  1282. 					CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
    1283. 

  1283. 				}
    1284. 

  1284. 			} else if ((name_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)))) {
    1285. 

  1285. 				if (CG(active_class_entry)->constructor) {
    1286. 

  1286. 					zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name);
    1287. 

  1287. 				}
    1288. 

  1288. 				CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
    1289. 

  1289. 			} else if ((name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
    1290. 

  1290. 				CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array);
    1291. 

  1291. 			} else if ((name_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
    1292. 

  1292. 				CG(active_class_entry)->clone = (zend_function *) CG(active_op_array);
    1293. 

  1293. 			} else if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
    1294. 

  1294. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1295. 

  1295. 					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
    1296. 

  1296. 				}
    1297. 

  1297. 				CG(active_class_entry)->__call = (zend_function *) CG(active_op_array);
    1298. 

  1298. 			} else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
    1299. 

  1299. 				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
    1300. 

  1300. 					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
    1301. 

  1301. 				}
    1302. 

  1302. 				CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array);
    1303. 

  1303. 			} else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
    1304. 

  1304. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1305. 

  1305. 					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
    1306. 

  1306. 				}
    1307. 

  1307. 				CG(active_class_entry)->__get = (zend_function *) CG(active_op_array);
    1308. 

  1308. 			} else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
    1309. 

  1309. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1310. 

  1310. 					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
    1311. 

  1311. 				}
    1312. 

  1312. 				CG(active_class_entry)->__set = (zend_function *) CG(active_op_array);
    1313. 

  1313. 			} else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
    1314. 

  1314. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1315. 

  1315. 					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
    1316. 

  1316. 				}
    1317. 

  1317. 				CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array);
    1318. 

  1318. 			} else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
    1319. 

  1319. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1320. 

  1320. 					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
    1321. 

  1321. 				}
    1322. 

  1322. 				CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array);
    1323. 

  1323. 			} else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
    1324. 

  1324. 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
    1325. 

  1325. 					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
    1326. 

  1326. 				}				
    1327. 

  1327. 				CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array);
    1328. 

  1328. 			} else if (!(fn_flags & ZEND_ACC_STATIC)) {
    1329. 

  1329. 				CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC;
    1330. 

  1330. 			}
    1331. 

  1331. 			free_alloca(class_lcname, use_heap);
    1332. 

  1332. 		}
    1333. 

  1333. 

  1334. 		efree(lcname);
    1335. 

  1335. 	} else {
    1336. 

  1336. 		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1337. 

  1337. 

  1338. 		if (CG(current_namespace)) {
    1339. 

  1339. 			/* Prefix function name with current namespcae name */
    1340. 

  1340. 			znode tmp;
    1341. 

  1341. 

  1342. 			tmp.u.constant = *CG(current_namespace);
    1343. 

  1343. 			zval_copy_ctor(&tmp.u.constant);
    1344. 

  1344. 			zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
    1345. 

  1345. 			op_array.function_name = Z_STRVAL(tmp.u.constant);
    1346. 

  1346. 			efree(lcname);
    1347. 

  1347. 			name_len = Z_STRLEN(tmp.u.constant);
    1348. 

  1348. 			lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len);
    1349. 

  1349. 		}
    1350. 

  1350. 

  1351. 		opline->opcode = ZEND_DECLARE_FUNCTION;
    1352. 

  1352. 		opline->op1.op_type = IS_CONST;
    1353. 

  1353. 		build_runtime_defined_function_key(&opline->op1.u.constant, lcname, name_len TSRMLS_CC);
    1354. 

  1354. 		opline->op2.op_type = IS_CONST;
    1355. 

  1355. 		opline->op2.u.constant.type = IS_STRING;
    1356. 

  1356. 		opline->op2.u.constant.value.str.val = lcname;
    1357. 

  1357. 		opline->op2.u.constant.value.str.len = name_len;
    1358. 

  1358. 		Z_SET_REFCOUNT(opline->op2.u.constant, 1);
    1359. 

  1359. 		opline->extended_value = ZEND_DECLARE_FUNCTION;
    1360. 

  1360. 		zend_hash_update(CG(function_table), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
    1361. 

  1361. 	}
    1362. 

  1362. 

  1363. 	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
    1364. 

  1364. 		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
    1365. 

  1365. 

  1366. 		opline->opcode = ZEND_EXT_NOP;
    1367. 

  1367. 		opline->lineno = function_begin_line;
    1368. 

  1368. 		SET_UNUSED(opline->op1);
    1369. 

  1369. 		SET_UNUSED(opline->op2);
    1370. 

  1370. 	}
    1371. 

  1371. 

  1372. 	{
    1373. 

  1373. 		/* Push a seperator to the switch and foreach stacks */
    1374. 

  1374. 		zend_switch_entry switch_entry;
    1375. 

  1375. 

  1376. 		switch_entry.cond.op_type = IS_UNUSED;
    1377. 

  1377. 		switch_entry.default_case = 0;
    1378. 

  1378. 		switch_entry.control_var = 0;
    1379. 

  1379. 

  1380. 		zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
    1381. 

  1381. 

  1382. 		{
    1383. 

  1383. 			/* Foreach stack separator */
    1384. 

  1384. 			zend_op dummy_opline;
    1385. 

  1385. 

  1386. 			dummy_opline.result.op_type = IS_UNUSED;
    1387. 

  1387. 			dummy_opline.op1.op_type = IS_UNUSED;
    1388. 

  1388. 

  1389. 			zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
    1390. 

  1390. 		}
    1391. 

  1391. 	}
    1392. 

  1392. 

  1393. 	if (CG(doc_comment)) {
    1394. 

  1394. 		CG(active_op_array)->doc_comment = CG(doc_comment);
    1395. 

  1395. 		CG(active_op_array)->doc_comment_len = CG(doc_comment_len);
    1396. 

  1396. 		CG(doc_comment) = NULL;
    1397. 

  1397. 		CG(doc_comment_len) = 0;
    1398. 

  1398. 	}
    1399. 

  1399. 

  1400. 	zend_stack_push(&CG(labels_stack), (void *) &CG(labels), sizeof(HashTable*));
    1401. 

  1401. 	CG(labels) = NULL;
    1402. 

  1402. }
    1403. 

  1403. /* }}} */
    1404. 

  1404. 

  1405. void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference TSRMLS_DC) /* {{{ */
    1406. 

  1406. {
    1407. 

  1407. 	znode          function_name;
    1408. 

  1408. 	zend_op_array *current_op_array = CG(active_op_array);
    1409. 

  1409. 	int            current_op_number = get_next_op_number(CG(active_op_array));
    1410. 

  1410. 	zend_op       *current_op;
    1411. 

  1411. 

  1412. 	function_name.op_type = IS_CONST;
    1413. 

  1413. 	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1);
    1414. 

  1414. 

  1415. 	zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC);
    1416. 

  1416. 

  1417. 	result->op_type = IS_TMP_VAR;
    1418. 

  1418. 	result->u.var = get_temporary_variable(current_op_array);
    1419. 

  1419. 

  1420. 	current_op = &current_op_array->opcodes[current_op_number];
    1421. 

  1421. 	current_op->opcode = ZEND_DECLARE_LAMBDA_FUNCTION;
    1422. 

  1422. 	zval_dtor(&current_op->op2.u.constant);
    1423. 

  1423. 	ZVAL_LONG(&current_op->op2.u.constant, zend_hash_func(Z_STRVAL(current_op->op1.u.constant), Z_STRLEN(current_op->op1.u.constant)));
    1424. 

  1424. 	current_op->result = *result;
    1425. 

  1425. 	CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE;
    1426. 

  1426. }
    1427. 

  1427. /* }}} */
    1428. 

  1428. 

  1429. void zend_d…
    1430.

Large files files are truncated, but you can click here to view the full file