Annotation of embedaddon/php/Zend/zend_compile.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | Zend Engine |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 2.00 of the Zend license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.zend.com/license/2_00.txt. |
11: | If you did not receive a copy of the Zend license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@zend.com so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Andi Gutmans <andi@zend.com> |
16: | Zeev Suraski <zeev@zend.com> |
17: +----------------------------------------------------------------------+
18: */
19:
20: /* $Id: zend_compile.c 321634 2012-01-01 13:15:04Z felipe $ */
21:
22: #include <zend_language_parser.h>
23: #include "zend.h"
24: #include "zend_compile.h"
25: #include "zend_constants.h"
26: #include "zend_llist.h"
27: #include "zend_API.h"
28: #include "zend_exceptions.h"
29: #include "tsrm_virtual_cwd.h"
30:
31: #ifdef ZEND_MULTIBYTE
32: #include "zend_multibyte.h"
33: #endif /* ZEND_MULTIBYTE */
34:
35: ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
36: ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
37:
38: #ifndef ZTS
39: ZEND_API zend_compiler_globals compiler_globals;
40: ZEND_API zend_executor_globals executor_globals;
41: #endif
42:
43: static void zend_duplicate_property_info(zend_property_info *property_info) /* {{{ */
44: {
45: property_info->name = estrndup(property_info->name, property_info->name_length);
46: if (property_info->doc_comment) {
47: property_info->doc_comment = estrndup(property_info->doc_comment, property_info->doc_comment_len);
48: }
49: }
50: /* }}} */
51:
52:
53: static void zend_duplicate_property_info_internal(zend_property_info *property_info) /* {{{ */
54: {
55: property_info->name = zend_strndup(property_info->name, property_info->name_length);
56: }
57: /* }}} */
58:
59:
60: static void zend_destroy_property_info(zend_property_info *property_info) /* {{{ */
61: {
62: efree(property_info->name);
63: if (property_info->doc_comment) {
64: efree(property_info->doc_comment);
65: }
66: }
67: /* }}} */
68:
69:
70: static void zend_destroy_property_info_internal(zend_property_info *property_info) /* {{{ */
71: {
72: free(property_info->name);
73: }
74: /* }}} */
75:
76: #if SUHOSIN_PATCH
77: void *suhosin_zend_destroy_property_info_internal = zend_destroy_property_info_internal;
78: void *suhosin_zend_destroy_property_info = zend_destroy_property_info;
79: #endif
80:
81: static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */
82: {
83: char char_pos_buf[32];
84: uint char_pos_len;
85: char *filename;
86:
87: char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text));
88: if (CG(active_op_array)->filename) {
89: filename = CG(active_op_array)->filename;
90: } else {
91: filename = "-";
92: }
93:
94: /* NULL, name length, filename length, last accepting char position length */
95: result->value.str.len = 1+name_length+strlen(filename)+char_pos_len;
96: #ifdef ZEND_MULTIBYTE
97: /* must be binary safe */
98: result->value.str.val = (char *) safe_emalloc(result->value.str.len, 1, 1);
99: result->value.str.val[0] = '\0';
100: sprintf(result->value.str.val+1, "%s%s%s", name, filename, char_pos_buf);
101: #else
102: zend_spprintf(&result->value.str.val, 0, "%c%s%s%s", '\0', name, filename, char_pos_buf);
103: #endif /* ZEND_MULTIBYTE */
104: result->type = IS_STRING;
105: Z_SET_REFCOUNT_P(result, 1);
106: }
107: /* }}} */
108:
109:
110: int zend_auto_global_arm(zend_auto_global *auto_global TSRMLS_DC) /* {{{ */
111: {
112: auto_global->armed = (auto_global->auto_global_callback ? 1 : 0);
113: return 0;
114: }
115: /* }}} */
116:
117:
118: ZEND_API int zend_auto_global_disable_jit(const char *varname, zend_uint varname_length TSRMLS_DC) /* {{{ */
119: {
120: zend_auto_global *auto_global;
121:
122: if (zend_hash_find(CG(auto_globals), varname, varname_length+1, (void **) &auto_global)==FAILURE) {
123: return FAILURE;
124: }
125: auto_global->armed = 0;
126: return SUCCESS;
127: }
128: /* }}} */
129:
130:
131: static void init_compiler_declarables(TSRMLS_D) /* {{{ */
132: {
133: Z_TYPE(CG(declarables).ticks) = IS_LONG;
134: Z_LVAL(CG(declarables).ticks) = 0;
135: }
136: /* }}} */
137:
138:
139: void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
140: {
141: zend_stack_init(&CG(bp_stack));
142: zend_stack_init(&CG(function_call_stack));
143: zend_stack_init(&CG(switch_cond_stack));
144: zend_stack_init(&CG(foreach_copy_stack));
145: zend_stack_init(&CG(object_stack));
146: zend_stack_init(&CG(declare_stack));
147: CG(active_class_entry) = NULL;
148: zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
149: zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
150: zend_stack_init(&CG(list_stack));
151: CG(in_compilation) = 0;
152: CG(start_lineno) = 0;
153: CG(current_namespace) = NULL;
154: CG(in_namespace) = 0;
155: CG(has_bracketed_namespaces) = 0;
156: CG(current_import) = NULL;
157: init_compiler_declarables(TSRMLS_C);
158: zend_hash_apply(CG(auto_globals), (apply_func_t) zend_auto_global_arm TSRMLS_CC);
159: zend_stack_init(&CG(labels_stack));
160: CG(labels) = NULL;
161:
162: #ifdef ZEND_MULTIBYTE
163: CG(script_encoding_list) = NULL;
164: CG(script_encoding_list_size) = 0;
165: CG(internal_encoding) = NULL;
166: CG(encoding_detector) = NULL;
167: CG(encoding_converter) = NULL;
168: CG(encoding_oddlen) = NULL;
169: CG(encoding_declared) = 0;
170: #endif /* ZEND_MULTIBYTE */
171: }
172: /* }}} */
173:
174:
175: ZEND_API void file_handle_dtor(zend_file_handle *fh) /* {{{ */
176: {
177: TSRMLS_FETCH();
178:
179: zend_file_handle_dtor(fh TSRMLS_CC);
180: }
181: /* }}} */
182:
183:
184: void init_compiler(TSRMLS_D) /* {{{ */
185: {
186: CG(active_op_array) = NULL;
187: zend_init_compiler_data_structures(TSRMLS_C);
188: zend_init_rsrc_list(TSRMLS_C);
189: zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0);
190: zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0);
191: CG(unclean_shutdown) = 0;
192: }
193: /* }}} */
194:
195:
196: void shutdown_compiler(TSRMLS_D) /* {{{ */
197: {
198: zend_stack_destroy(&CG(bp_stack));
199: zend_stack_destroy(&CG(function_call_stack));
200: zend_stack_destroy(&CG(switch_cond_stack));
201: zend_stack_destroy(&CG(foreach_copy_stack));
202: zend_stack_destroy(&CG(object_stack));
203: zend_stack_destroy(&CG(declare_stack));
204: zend_stack_destroy(&CG(list_stack));
205: zend_hash_destroy(&CG(filenames_table));
206: zend_llist_destroy(&CG(open_files));
207: zend_stack_destroy(&CG(labels_stack));
208:
209: #ifdef ZEND_MULTIBYTE
210: if (CG(script_encoding_list)) {
211: efree(CG(script_encoding_list));
212: }
213: #endif /* ZEND_MULTIBYTE */
214: }
215: /* }}} */
216:
217:
218: ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC) /* {{{ */
219: {
220: char **pp, *p;
221: int length = strlen(new_compiled_filename);
222:
223: if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp) == SUCCESS) {
224: CG(compiled_filename) = *pp;
225: return *pp;
226: }
227: p = estrndup(new_compiled_filename, length);
228: zend_hash_update(&CG(filenames_table), new_compiled_filename, length+1, &p, sizeof(char *), (void **) &pp);
229: CG(compiled_filename) = p;
230: return p;
231: }
232: /* }}} */
233:
234:
235: ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC) /* {{{ */
236: {
237: CG(compiled_filename) = original_compiled_filename;
238: }
239: /* }}} */
240:
241:
242: ZEND_API char *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
243: {
244: return CG(compiled_filename);
245: }
246: /* }}} */
247:
248:
249: ZEND_API int zend_get_compiled_lineno(TSRMLS_D) /* {{{ */
250: {
251: return CG(zend_lineno);
252: }
253: /* }}} */
254:
255:
256: ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */
257: {
258: return CG(in_compilation);
259: }
260: /* }}} */
261:
262:
263: static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */
264: {
265: return (op_array->T)++ * ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable));
266: }
267: /* }}} */
268:
269: static int lookup_cv(zend_op_array *op_array, char* name, int name_len) /* {{{ */
270: {
271: int i = 0;
272: ulong hash_value = zend_inline_hash_func(name, name_len+1);
273:
274: while (i < op_array->last_var) {
275: if (op_array->vars[i].hash_value == hash_value &&
276: op_array->vars[i].name_len == name_len &&
277: strcmp(op_array->vars[i].name, name) == 0) {
278: efree(name);
279: return i;
280: }
281: i++;
282: }
283: i = op_array->last_var;
284: op_array->last_var++;
285: if (op_array->last_var > op_array->size_var) {
286: op_array->size_var += 16; /* FIXME */
287: op_array->vars = erealloc(op_array->vars, op_array->size_var*sizeof(zend_compiled_variable));
288: }
289: op_array->vars[i].name = name; /* estrndup(name, name_len); */
290: op_array->vars[i].name_len = name_len;
291: op_array->vars[i].hash_value = hash_value;
292: return i;
293: }
294: /* }}} */
295:
296:
297: void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
298: {
299: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
300:
301: opline->opcode = op;
302: opline->result.op_type = IS_TMP_VAR;
303: opline->result.u.var = get_temporary_variable(CG(active_op_array));
304: opline->op1 = *op1;
305: opline->op2 = *op2;
306: *result = opline->result;
307: }
308: /* }}} */
309:
310: void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
311: {
312: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
313:
314: opline->opcode = op;
315: opline->result.op_type = IS_TMP_VAR;
316: opline->result.u.var = get_temporary_variable(CG(active_op_array));
317: opline->op1 = *op1;
318: *result = opline->result;
319: SET_UNUSED(opline->op2);
320: }
321: /* }}} */
322:
323: #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; }
324:
325:
326: static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {{{ */
327: {
328: data_op->opcode = ZEND_OP_DATA;
329: data_op->op1 = *value;
330: SET_UNUSED(data_op->op2);
331: }
332: /* }}} */
333:
334: void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
335: {
336: int last_op_number = get_next_op_number(CG(active_op_array));
337: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
338:
339: if (last_op_number > 0) {
340: zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
341:
342: switch (last_op->opcode) {
343: case ZEND_FETCH_OBJ_RW:
344: last_op->opcode = op;
345: last_op->extended_value = ZEND_ASSIGN_OBJ;
346:
347: zend_do_op_data(opline, op2 TSRMLS_CC);
348: SET_UNUSED(opline->result);
349: *result = last_op->result;
350: return;
351: case ZEND_FETCH_DIM_RW:
352: last_op->opcode = op;
353: last_op->extended_value = ZEND_ASSIGN_DIM;
354:
355: zend_do_op_data(opline, op2 TSRMLS_CC);
356: opline->op2.u.var = get_temporary_variable(CG(active_op_array));
357: opline->op2.u.EA.type = 0;
358: opline->op2.op_type = IS_VAR;
359: SET_UNUSED(opline->result);
360: *result = last_op->result;
361: return;
362: default:
363: break;
364: }
365: }
366:
367: opline->opcode = op;
368: opline->op1 = *op1;
369: opline->op2 = *op2;
370: opline->result.op_type = IS_VAR;
371: opline->result.u.EA.type = 0;
372: opline->result.u.var = get_temporary_variable(CG(active_op_array));
373: *result = opline->result;
374: }
375: /* }}} */
376:
377: void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */
378: {
379: zend_op opline;
380: zend_op *opline_ptr;
381: zend_llist *fetch_list_ptr;
382:
383: if (varname->op_type == IS_CONST) {
384: if (Z_TYPE(varname->u.constant) != IS_STRING) {
385: convert_to_string(&varname->u.constant);
386: }
387: if (!zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC) &&
388: !(varname->u.constant.value.str.len == (sizeof("this")-1) &&
389: !memcmp(varname->u.constant.value.str.val, "this", sizeof("this"))) &&
390: (CG(active_op_array)->last == 0 ||
391: CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
392: result->op_type = IS_CV;
393: result->u.var = lookup_cv(CG(active_op_array), varname->u.constant.value.str.val, varname->u.constant.value.str.len);
394: result->u.EA.type = 0;
395: varname->u.constant.value.str.val = CG(active_op_array)->vars[result->u.var].name;
396: return;
397: }
398: }
399:
400: if (bp) {
401: opline_ptr = &opline;
402: init_op(opline_ptr TSRMLS_CC);
403: } else {
404: opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
405: }
406:
407: opline_ptr->opcode = op;
408: opline_ptr->result.op_type = IS_VAR;
409: opline_ptr->result.u.EA.type = 0;
410: opline_ptr->result.u.var = get_temporary_variable(CG(active_op_array));
411: opline_ptr->op1 = *varname;
412: *result = opline_ptr->result;
413: SET_UNUSED(opline_ptr->op2);
414:
415: opline_ptr->op2.u.EA.type = ZEND_FETCH_LOCAL;
416: if (varname->op_type == IS_CONST && varname->u.constant.type == IS_STRING) {
417: if (zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC)) {
418: opline_ptr->op2.u.EA.type = ZEND_FETCH_GLOBAL;
419: }
420: }
421:
422: if (bp) {
423: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
424: zend_llist_add_element(fetch_list_ptr, opline_ptr);
425: }
426: }
427: /* }}} */
428:
429: void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */
430: {
431: /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
432: fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
433: }
434: /* }}} */
435:
436: void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
437: {
438: znode class_node;
439: zend_llist *fetch_list_ptr;
440: zend_llist_element *le;
441: zend_op *opline_ptr;
442: zend_op opline;
443:
444: zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
445: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
446: if (result->op_type == IS_CV) {
447: init_op(&opline TSRMLS_CC);
448:
449: opline.opcode = ZEND_FETCH_W;
450: opline.result.op_type = IS_VAR;
451: opline.result.u.EA.type = 0;
452: opline.result.u.var = get_temporary_variable(CG(active_op_array));
453: opline.op1.op_type = IS_CONST;
454: opline.op1.u.constant.type = IS_STRING;
455: opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[result->u.var].name);
456: opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[result->u.var].name_len;
457: SET_UNUSED(opline.op2);
458: opline.op2 = class_node;
459: opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
460: *result = opline.result;
461:
462: zend_llist_add_element(fetch_list_ptr, &opline);
463: } else {
464: le = fetch_list_ptr->head;
465:
466: opline_ptr = (zend_op *)le->data;
467: if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1.op_type == IS_CV) {
468: init_op(&opline TSRMLS_CC);
469: opline.opcode = ZEND_FETCH_W;
470: opline.result.op_type = IS_VAR;
471: opline.result.u.EA.type = 0;
472: opline.result.u.var = get_temporary_variable(CG(active_op_array));
473: opline.op1.op_type = IS_CONST;
474: opline.op1.u.constant.type = IS_STRING;
475: opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[opline_ptr->op1.u.var].name);
476: opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[opline_ptr->op1.u.var].name_len;
477: SET_UNUSED(opline.op2);
478: opline.op2 = class_node;
479: opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
480: opline_ptr->op1 = opline.result;
481:
482: zend_llist_prepend_element(fetch_list_ptr, &opline);
483: } else {
484: opline_ptr->op2 = class_node;
485: opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
486: }
487: }
488: }
489: /* }}} */
490:
491: void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */
492: {
493: fetch_simple_variable(result, varname, 1 TSRMLS_CC);
494:
495: fetch_array_dim(result, result, first_dim TSRMLS_CC);
496: }
497: /* }}} */
498:
499: void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC) /* {{{ */
500: {
501: zend_op opline;
502: zend_llist *fetch_list_ptr;
503:
504: init_op(&opline TSRMLS_CC);
505: opline.opcode = ZEND_FETCH_DIM_W; /* the backpatching routine assumes W */
506: opline.result.op_type = IS_VAR;
507: opline.result.u.EA.type = 0;
508: opline.result.u.var = get_temporary_variable(CG(active_op_array));
509: opline.op1 = *parent;
510: opline.op2 = *dim;
511: opline.extended_value = ZEND_FETCH_STANDARD;
512: *result = opline.result;
513:
514: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
515: zend_llist_add_element(fetch_list_ptr, &opline);
516: }
517: /* }}} */
518:
519: void fetch_string_offset(znode *result, const znode *parent, const znode *offset TSRMLS_DC) /* {{{ */
520: {
521: fetch_array_dim(result, parent, offset TSRMLS_CC);
522: }
523: /* }}} */
524:
525: void zend_do_print(znode *result, const znode *arg TSRMLS_DC) /* {{{ */
526: {
527: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
528:
529: opline->result.op_type = IS_TMP_VAR;
530: opline->result.u.var = get_temporary_variable(CG(active_op_array));
531: opline->opcode = ZEND_PRINT;
532: opline->op1 = *arg;
533: SET_UNUSED(opline->op2);
534: *result = opline->result;
535: }
536: /* }}} */
537:
538: void zend_do_echo(const znode *arg TSRMLS_DC) /* {{{ */
539: {
540: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
541:
542: opline->opcode = ZEND_ECHO;
543: opline->op1 = *arg;
544: SET_UNUSED(opline->op2);
545: }
546: /* }}} */
547:
548: void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */
549: {
550: char *method_type;
551:
552: if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
553: Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
554: method_type = "Interface";
555: } else {
556: method_type = "Abstract";
557: }
558:
559: if (modifiers->u.constant.value.lval & ZEND_ACC_ABSTRACT) {
560: if(modifiers->u.constant.value.lval & ZEND_ACC_PRIVATE) {
561: 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);
562: }
563: if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
564: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
565:
566: opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
567: SET_UNUSED(opline->op1);
568: SET_UNUSED(opline->op2);
569: } else {
570: /* we had code in the function body */
571: 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);
572: }
573: } else {
574: if (body->u.constant.value.lval == ZEND_ACC_ABSTRACT) {
575: 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);
576: }
577: }
578: }
579: /* }}} */
580:
581: static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */
582: {
583: if ((opline->opcode == ZEND_FETCH_W) && (opline->op1.op_type == IS_CONST)
584: && (opline->op1.u.constant.type == IS_STRING)
585: && (opline->op1.u.constant.value.str.len == (sizeof("this")-1))
586: && !memcmp(opline->op1.u.constant.value.str.val, "this", sizeof("this"))) {
587: return 1;
588: } else {
589: return 0;
590: }
591: }
592: /* }}} */
593:
594: void zend_do_assign(znode *result, znode *variable, const znode *value TSRMLS_DC) /* {{{ */
595: {
596: int last_op_number;
597: zend_op *opline;
598:
599: if (value->op_type == IS_CV) {
600: zend_llist *fetch_list_ptr;
601:
602: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
603: if (fetch_list_ptr && fetch_list_ptr->head) {
604: opline = (zend_op *)fetch_list_ptr->head->data;
605:
606: if (opline->opcode == ZEND_FETCH_DIM_W &&
607: opline->op1.op_type == IS_CV &&
608: opline->op1.u.var == value->u.var) {
609:
610: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
611: opline->opcode = ZEND_FETCH_R;
612: opline->result.op_type = IS_VAR;
613: opline->result.u.EA.type = 0;
614: opline->result.u.var = get_temporary_variable(CG(active_op_array));
615: opline->op1.op_type = IS_CONST;
616: ZVAL_STRINGL(&opline->op1.u.constant,
617: CG(active_op_array)->vars[value->u.var].name,
618: CG(active_op_array)->vars[value->u.var].name_len, 1);
619: SET_UNUSED(opline->op2);
620: opline->op2.u.EA.type = ZEND_FETCH_LOCAL;
621: value = &opline->result;
622: }
623: }
624: }
625:
626: zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC);
627:
628: last_op_number = get_next_op_number(CG(active_op_array));
629: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
630:
631: if (variable->op_type == IS_CV) {
632: if (variable->u.var == CG(active_op_array)->this_var) {
633: zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
634: }
635: } else if (variable->op_type == IS_VAR) {
636: int n = 0;
637:
638: while (last_op_number - n > 0) {
639: zend_op *last_op;
640:
641: last_op = &CG(active_op_array)->opcodes[last_op_number-n-1];
642:
643: if (last_op->result.op_type == IS_VAR &&
644: last_op->result.u.var == variable->u.var) {
645: if (last_op->opcode == ZEND_FETCH_OBJ_W) {
646: if (n > 0) {
647: int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
648: *opline = *last_op;
649: MAKE_NOP(last_op);
650: /* last_op = opline; */
651: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
652: /* get_next_op can realloc, we need to move last_op */
653: last_op = &CG(active_op_array)->opcodes[opline_no];
654: }
655: last_op->opcode = ZEND_ASSIGN_OBJ;
656: zend_do_op_data(opline, value TSRMLS_CC);
657: SET_UNUSED(opline->result);
658: *result = last_op->result;
659: return;
660: } else if (last_op->opcode == ZEND_FETCH_DIM_W) {
661: if (n > 0) {
662: int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
663: *opline = *last_op;
664: MAKE_NOP(last_op);
665: /* last_op = opline; */
666: /* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */
667: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
668: /* get_next_op can realloc, we need to move last_op */
669: last_op = &CG(active_op_array)->opcodes[opline_no];
670: }
671: last_op->opcode = ZEND_ASSIGN_DIM;
672: zend_do_op_data(opline, value TSRMLS_CC);
673: opline->op2.u.var = get_temporary_variable(CG(active_op_array));
674: opline->op2.u.EA.type = 0;
675: opline->op2.op_type = IS_VAR;
676: SET_UNUSED(opline->result);
677: *result = last_op->result;
678: return;
679: } else if (opline_is_fetch_this(last_op TSRMLS_CC)) {
680: zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
681: } else {
682: break;
683: }
684: }
685: n++;
686: }
687: }
688:
689: opline->opcode = ZEND_ASSIGN;
690: opline->op1 = *variable;
691: opline->op2 = *value;
692: opline->result.op_type = IS_VAR;
693: opline->result.u.EA.type = 0;
694: opline->result.u.var = get_temporary_variable(CG(active_op_array));
695: *result = opline->result;
696: }
697: /* }}} */
698:
699: static inline zend_bool zend_is_function_or_method_call(const znode *variable) /* {{{ */
700: {
701: zend_uint type = variable->u.EA.type;
702:
703: return ((type & ZEND_PARSED_METHOD_CALL) || (type == ZEND_PARSED_FUNCTION_CALL));
704: }
705: /* }}} */
706:
707: void zend_do_assign_ref(znode *result, const znode *lvar, const znode *rvar TSRMLS_DC) /* {{{ */
708: {
709: zend_op *opline;
710:
711: if (lvar->op_type == IS_CV) {
712: if (lvar->u.var == CG(active_op_array)->this_var) {
713: zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
714: }
715: } else if (lvar->op_type == IS_VAR) {
716: int last_op_number = get_next_op_number(CG(active_op_array));
717:
718: if (last_op_number > 0) {
719: opline = &CG(active_op_array)->opcodes[last_op_number-1];
720: if (opline_is_fetch_this(opline TSRMLS_CC)) {
721: zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
722: }
723: }
724: }
725:
726: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
727: opline->opcode = ZEND_ASSIGN_REF;
728: if (zend_is_function_or_method_call(rvar)) {
729: opline->extended_value = ZEND_RETURNS_FUNCTION;
730: } else if (rvar->u.EA.type & ZEND_PARSED_NEW) {
731: opline->extended_value = ZEND_RETURNS_NEW;
732: } else {
733: opline->extended_value = 0;
734: }
735: if (result) {
736: opline->result.op_type = IS_VAR;
737: opline->result.u.EA.type = 0;
738: opline->result.u.var = get_temporary_variable(CG(active_op_array));
739: *result = opline->result;
740: } else {
741: /* SET_UNUSED(opline->result); */
742: opline->result.u.EA.type |= EXT_TYPE_UNUSED;
743: }
744: opline->op1 = *lvar;
745: opline->op2 = *rvar;
746: }
747: /* }}} */
748:
749: static inline void do_begin_loop(TSRMLS_D) /* {{{ */
750: {
751: zend_brk_cont_element *brk_cont_element;
752: int parent;
753:
754: parent = CG(active_op_array)->current_brk_cont;
755: CG(active_op_array)->current_brk_cont = CG(active_op_array)->last_brk_cont;
756: brk_cont_element = get_next_brk_cont_element(CG(active_op_array));
757: brk_cont_element->start = get_next_op_number(CG(active_op_array));
758: brk_cont_element->parent = parent;
759: }
760: /* }}} */
761:
762: static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
763: {
764: if (!has_loop_var) {
765: /* The start fileld is used to free temporary variables in case of exceptions.
766: * We won't try to free something of we don't have loop variable.
767: */
768: CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].start = -1;
769: }
770: CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].cont = cont_addr;
771: CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].brk = get_next_op_number(CG(active_op_array));
772: CG(active_op_array)->current_brk_cont = CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].parent;
773: }
774: /* }}} */
775:
776: void zend_do_while_cond(const znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
777: {
778: int while_cond_op_number = get_next_op_number(CG(active_op_array));
779: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
780:
781: opline->opcode = ZEND_JMPZ;
782: opline->op1 = *expr;
783: close_bracket_token->u.opline_num = while_cond_op_number;
784: SET_UNUSED(opline->op2);
785:
786: do_begin_loop(TSRMLS_C);
787: INC_BPC(CG(active_op_array));
788: }
789: /* }}} */
790:
791: void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */
792: {
793: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
794:
795: /* add unconditional jump */
796: opline->opcode = ZEND_JMP;
797: opline->op1.u.opline_num = while_token->u.opline_num;
798: SET_UNUSED(opline->op1);
799: SET_UNUSED(opline->op2);
800:
801: /* update while's conditional jmp */
802: CG(active_op_array)->opcodes[close_bracket_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
803:
804: do_end_loop(while_token->u.opline_num, 0 TSRMLS_CC);
805:
806: DEC_BPC(CG(active_op_array));
807: }
808: /* }}} */
809:
810: void zend_do_for_cond(const znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
811: {
812: int for_cond_op_number = get_next_op_number(CG(active_op_array));
813: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
814:
815: opline->opcode = ZEND_JMPZNZ;
816: opline->op1 = *expr; /* the conditional expression */
817: second_semicolon_token->u.opline_num = for_cond_op_number;
818: SET_UNUSED(opline->op2);
819: }
820: /* }}} */
821:
822: void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
823: {
824: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
825:
826: opline->opcode = ZEND_JMP;
827: opline->op1.u.opline_num = cond_start->u.opline_num;
828: CG(active_op_array)->opcodes[second_semicolon_token->u.opline_num].extended_value = get_next_op_number(CG(active_op_array));
829: SET_UNUSED(opline->op1);
830: SET_UNUSED(opline->op2);
831:
832: do_begin_loop(TSRMLS_C);
833:
834: INC_BPC(CG(active_op_array));
835: }
836: /* }}} */
837:
838: void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
839: {
840: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
841:
842: opline->opcode = ZEND_JMP;
843: opline->op1.u.opline_num = second_semicolon_token->u.opline_num+1;
844: CG(active_op_array)->opcodes[second_semicolon_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
845: SET_UNUSED(opline->op1);
846: SET_UNUSED(opline->op2);
847:
848: do_end_loop(second_semicolon_token->u.opline_num+1, 0 TSRMLS_CC);
849:
850: DEC_BPC(CG(active_op_array));
851: }
852: /* }}} */
853:
854: void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
855: {
856: int last_op_number = get_next_op_number(CG(active_op_array));
857: zend_op *opline;
858:
859: if (last_op_number > 0) {
860: zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
861:
862: if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
863: last_op->opcode = (op==ZEND_PRE_INC)?ZEND_PRE_INC_OBJ:ZEND_PRE_DEC_OBJ;
864: last_op->result.op_type = IS_VAR;
865: last_op->result.u.EA.type = 0;
866: last_op->result.u.var = get_temporary_variable(CG(active_op_array));
867: *result = last_op->result;
868: return;
869: }
870: }
871:
872: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
873: opline->opcode = op;
874: opline->op1 = *op1;
875: SET_UNUSED(opline->op2);
876: opline->result.op_type = IS_VAR;
877: opline->result.u.EA.type = 0;
878: opline->result.u.var = get_temporary_variable(CG(active_op_array));
879: *result = opline->result;
880: }
881: /* }}} */
882:
883: void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
884: {
885: int last_op_number = get_next_op_number(CG(active_op_array));
886: zend_op *opline;
887:
888: if (last_op_number > 0) {
889: zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
890:
891: if (last_op->opcode == ZEND_FETCH_OBJ_RW) {
892: last_op->opcode = (op==ZEND_POST_INC)?ZEND_POST_INC_OBJ:ZEND_POST_DEC_OBJ;
893: last_op->result.op_type = IS_TMP_VAR;
894: last_op->result.u.var = get_temporary_variable(CG(active_op_array));
895: *result = last_op->result;
896: return;
897: }
898: }
899:
900: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
901: opline->opcode = op;
902: opline->op1 = *op1;
903: SET_UNUSED(opline->op2);
904: opline->result.op_type = IS_TMP_VAR;
905: opline->result.u.var = get_temporary_variable(CG(active_op_array));
906: *result = opline->result;
907: }
908: /* }}} */
909:
910: void zend_do_if_cond(const znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */
911: {
912: int if_cond_op_number = get_next_op_number(CG(active_op_array));
913: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
914:
915: opline->opcode = ZEND_JMPZ;
916: opline->op1 = *cond;
917: closing_bracket_token->u.opline_num = if_cond_op_number;
918: SET_UNUSED(opline->op2);
919: INC_BPC(CG(active_op_array));
920: }
921: /* }}} */
922:
923: void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC) /* {{{ */
924: {
925: int if_end_op_number = get_next_op_number(CG(active_op_array));
926: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
927: zend_llist *jmp_list_ptr;
928:
929: opline->opcode = ZEND_JMP;
930: /* save for backpatching */
931: if (initialize) {
932: zend_llist jmp_list;
933:
934: zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
935: zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist));
936: }
937: zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
938: zend_llist_add_element(jmp_list_ptr, &if_end_op_number);
939:
940: CG(active_op_array)->opcodes[closing_bracket_token->u.opline_num].op2.u.opline_num = if_end_op_number+1;
941: SET_UNUSED(opline->op1);
942: SET_UNUSED(opline->op2);
943: }
944: /* }}} */
945:
946: void zend_do_if_end(TSRMLS_D) /* {{{ */
947: {
948: int next_op_number = get_next_op_number(CG(active_op_array));
949: zend_llist *jmp_list_ptr;
950: zend_llist_element *le;
951:
952: zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
953: for (le=jmp_list_ptr->head; le; le = le->next) {
954: CG(active_op_array)->opcodes[*((int *) le->data)].op1.u.opline_num = next_op_number;
955: }
956: zend_llist_destroy(jmp_list_ptr);
957: zend_stack_del_top(&CG(bp_stack));
958: DEC_BPC(CG(active_op_array));
959: }
960: /* }}} */
961:
962: void zend_check_writable_variable(const znode *variable) /* {{{ */
963: {
964: zend_uint type = variable->u.EA.type;
965:
966: if (type & ZEND_PARSED_METHOD_CALL) {
967: zend_error(E_COMPILE_ERROR, "Can't use method return value in write context");
968: }
969: if (type == ZEND_PARSED_FUNCTION_CALL) {
970: zend_error(E_COMPILE_ERROR, "Can't use function return value in write context");
971: }
972: }
973: /* }}} */
974:
975: void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */
976: {
977: zend_llist fetch_list;
978:
979: zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0);
980: zend_stack_push(&CG(bp_stack), (void *) &fetch_list, sizeof(zend_llist));
981: }
982: /* }}} */
983:
984: void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */
985: {
986: zend_llist *fetch_list_ptr;
987: zend_llist_element *le;
988: zend_op *opline = NULL;
989: zend_op *opline_ptr;
990: zend_uint this_var = -1;
991:
992: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
993:
994: le = fetch_list_ptr->head;
995:
996: /* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */
997:
998: if (le) {
999: opline_ptr = (zend_op *)le->data;
1000: if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
1001: /* convert to FETCH_?(this) into IS_CV */
1002: if (CG(active_op_array)->last == 0 ||
1003: CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) {
1004:
1005: this_var = opline_ptr->result.u.var;
1006: if (CG(active_op_array)->this_var == -1) {
1007: 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));
1008: } else {
1009: efree(Z_STRVAL(opline_ptr->op1.u.constant));
1010: }
1011: le = le->next;
1012: if (variable->op_type == IS_VAR &&
1013: variable->u.var == this_var) {
1014: variable->op_type = IS_CV;
1015: variable->u.var = CG(active_op_array)->this_var;
1016: }
1017: } else if (CG(active_op_array)->this_var == -1) {
1018: CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1);
1019: }
1020: }
1021:
1022: while (le) {
1023: opline_ptr = (zend_op *)le->data;
1024: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1025: memcpy(opline, opline_ptr, sizeof(zend_op));
1026: if (opline->op1.op_type == IS_VAR &&
1027: opline->op1.u.var == this_var) {
1028: opline->op1.op_type = IS_CV;
1029: opline->op1.u.var = CG(active_op_array)->this_var;
1030: }
1031: switch (type) {
1032: case BP_VAR_R:
1033: if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2.op_type == IS_UNUSED) {
1034: zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
1035: }
1036: opline->opcode -= 3;
1037: break;
1038: case BP_VAR_W:
1039: break;
1040: case BP_VAR_RW:
1041: opline->opcode += 3;
1042: break;
1043: case BP_VAR_IS:
1044: if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2.op_type == IS_UNUSED) {
1045: zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
1046: }
1047: opline->opcode += 6; /* 3+3 */
1048: break;
1049: case BP_VAR_FUNC_ARG:
1050: opline->opcode += 9; /* 3+3+3 */
1051: opline->extended_value = arg_offset;
1052: break;
1053: case BP_VAR_UNSET:
1054: if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2.op_type == IS_UNUSED) {
1055: zend_error(E_COMPILE_ERROR, "Cannot use [] for unsetting");
1056: }
1057: opline->opcode += 12; /* 3+3+3+3 */
1058: break;
1059: }
1060: le = le->next;
1061: }
1062: if (opline && type == BP_VAR_W && arg_offset) {
1063: opline->extended_value = ZEND_FETCH_MAKE_REF;
1064: }
1065: }
1066: zend_llist_destroy(fetch_list_ptr);
1067: zend_stack_del_top(&CG(bp_stack));
1068: }
1069: /* }}} */
1070:
1071: void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
1072: {
1073: zend_op *opline;
1074:
1075: if (Z_STRLEN(op2->u.constant) > 1) {
1076: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1077: opline->opcode = ZEND_ADD_STRING;
1078: } else if (Z_STRLEN(op2->u.constant) == 1) {
1079: int ch = *Z_STRVAL(op2->u.constant);
1080:
1081: /* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */
1082: efree(Z_STRVAL(op2->u.constant));
1083: ZVAL_LONG(&op2->u.constant, ch);
1084: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1085: opline->opcode = ZEND_ADD_CHAR;
1086: } else { /* String can be empty after a variable at the end of a heredoc */
1087: efree(Z_STRVAL(op2->u.constant));
1088: return;
1089: }
1090:
1091: if (op1) {
1092: opline->op1 = *op1;
1093: opline->result = *op1;
1094: } else {
1095: SET_UNUSED(opline->op1);
1096: opline->result.op_type = IS_TMP_VAR;
1097: opline->result.u.var = get_temporary_variable(CG(active_op_array));
1098: }
1099: opline->op2 = *op2;
1100: *result = opline->result;
1101: }
1102: /* }}} */
1103:
1104: void zend_do_add_variable(znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
1105: {
1106: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1107:
1108: opline->opcode = ZEND_ADD_VAR;
1109:
1110: if (op1) {
1111: opline->op1 = *op1;
1112: opline->result = *op1;
1113: } else {
1114: SET_UNUSED(opline->op1);
1115: opline->result.op_type = IS_TMP_VAR;
1116: opline->result.u.var = get_temporary_variable(CG(active_op_array));
1117: }
1118: opline->op2 = *op2;
1119: *result = opline->result;
1120: }
1121: /* }}} */
1122:
1123: void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
1124: {
1125: if (op1->op_type==IS_TMP_VAR) {
1126: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1127:
1128: opline->opcode = ZEND_FREE;
1129: opline->op1 = *op1;
1130: SET_UNUSED(opline->op2);
1131: } else if (op1->op_type==IS_VAR) {
1132: zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
1133:
1134: while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
1135: opline--;
1136: }
1137: if (opline->result.op_type == IS_VAR
1138: && opline->result.u.var == op1->u.var) {
1139: opline->result.u.EA.type |= EXT_TYPE_UNUSED;
1140: } else {
1141: while (opline>CG(active_op_array)->opcodes) {
1142: if (opline->opcode == ZEND_FETCH_DIM_R
1143: && opline->op1.op_type == IS_VAR
1144: && opline->op1.u.var == op1->u.var) {
1145: /* This should the end of a list() construct
1146: * Mark its result as unused
1147: */
1148: opline->extended_value = ZEND_FETCH_STANDARD;
1149: break;
1150: } else if (opline->result.op_type==IS_VAR
1151: && opline->result.u.var == op1->u.var) {
1152: if (opline->opcode == ZEND_NEW) {
1153: opline->result.u.EA.type |= EXT_TYPE_UNUSED;
1154: }
1155: break;
1156: }
1157: opline--;
1158: }
1159: }
1160: } else if (op1->op_type == IS_CONST) {
1161: zval_dtor(&op1->u.constant);
1162: }
1163: }
1164: /* }}} */
1165:
1166: int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */
1167: {
1168: if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
1169: && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
1170: zend_error(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
1171: }
1172: if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
1173: && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
1174: zend_error(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
1175: }
1176: if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
1177: && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
1178: zend_error(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
1179: }
1180: if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
1181: && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
1182: zend_error(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
1183: }
1184: 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)) {
1185: zend_error(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
1186: }
1187: return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
1188: }
1189: /* }}} */
1190:
1191: void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
1192: {
1193: zend_op_array op_array;
1194: char *name = function_name->u.constant.value.str.val;
1195: int name_len = function_name->u.constant.value.str.len;
1196: int function_begin_line = function_token->u.opline_num;
1197: zend_uint fn_flags;
1198: char *lcname;
1199: zend_bool orig_interactive;
1200: ALLOCA_FLAG(use_heap)
1201:
1202: if (is_method) {
1203: if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
1204: if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
1205: 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);
1206: }
1207: Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
1208: }
1209: fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
1210: } else {
1211: fn_flags = 0;
1212: }
1213: if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
1214: 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));
1215: }
1216:
1217: function_token->u.op_array = CG(active_op_array);
1218: lcname = zend_str_tolower_dup(name, name_len);
1219:
1220: orig_interactive = CG(interactive);
1221: CG(interactive) = 0;
1222: init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
1223: CG(interactive) = orig_interactive;
1224:
1225: op_array.function_name = name;
1226: op_array.return_reference = return_reference;
1227: op_array.fn_flags |= fn_flags;
1228: op_array.pass_rest_by_reference = 0;
1229:
1230: op_array.scope = is_method?CG(active_class_entry):NULL;
1231: op_array.prototype = NULL;
1232:
1233: op_array.line_start = zend_get_compiled_lineno(TSRMLS_C);
1234:
1235: if (is_method) {
1236: 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) {
1237: zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name, name);
1238: }
1239:
1240: if (fn_flags & ZEND_ACC_ABSTRACT) {
1241: CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
1242: }
1243:
1244: if (!(fn_flags & ZEND_ACC_PPP_MASK)) {
1245: fn_flags |= ZEND_ACC_PUBLIC;
1246: }
1247:
1248: if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
1249: if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
1250: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1251: zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
1252: }
1253: } else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
1254: if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
1255: zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
1256: }
1257: } else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
1258: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1259: zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
1260: }
1261: } else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
1262: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1263: zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
1264: }
1265: } else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
1266: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1267: zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
1268: }
1269: } else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
1270: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1271: zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
1272: }
1273: } else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
1274: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1275: zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
1276: }
1277: }
1278: } else {
1279: char *class_lcname;
1280:
1281: class_lcname = do_alloca(CG(active_class_entry)->name_length + 1, use_heap);
1282: zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name, CG(active_class_entry)->name_length);
1283: /* Improve after RC: cache the lowercase class name */
1284:
1285: if ((CG(active_class_entry)->name_length == name_len) && (!memcmp(class_lcname, lcname, name_len))) {
1286: if (!CG(active_class_entry)->constructor) {
1287: CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
1288: }
1289: } else if ((name_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)))) {
1290: if (CG(active_class_entry)->constructor) {
1291: zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name);
1292: }
1293: CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
1294: } else if ((name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
1295: CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array);
1296: } else if ((name_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
1297: CG(active_class_entry)->clone = (zend_function *) CG(active_op_array);
1298: } else if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
1299: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1300: zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
1301: }
1302: CG(active_class_entry)->__call = (zend_function *) CG(active_op_array);
1303: } else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
1304: if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
1305: zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
1306: }
1307: CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array);
1308: } else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
1309: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1310: zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
1311: }
1312: CG(active_class_entry)->__get = (zend_function *) CG(active_op_array);
1313: } else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
1314: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1315: zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
1316: }
1317: CG(active_class_entry)->__set = (zend_function *) CG(active_op_array);
1318: } else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
1319: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1320: zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
1321: }
1322: CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array);
1323: } else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
1324: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1325: zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
1326: }
1327: CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array);
1328: } else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
1329: if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
1330: zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
1331: }
1332: CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array);
1333: } else if (!(fn_flags & ZEND_ACC_STATIC)) {
1334: CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC;
1335: }
1336: free_alloca(class_lcname, use_heap);
1337: }
1338:
1339: efree(lcname);
1340: } else {
1341: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1342:
1343: if (CG(current_namespace)) {
1344: /* Prefix function name with current namespcae name */
1345: znode tmp;
1346:
1347: tmp.u.constant = *CG(current_namespace);
1348: zval_copy_ctor(&tmp.u.constant);
1349: zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
1350: op_array.function_name = Z_STRVAL(tmp.u.constant);
1351: efree(lcname);
1352: name_len = Z_STRLEN(tmp.u.constant);
1353: lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len);
1354: }
1355:
1356: opline->opcode = ZEND_DECLARE_FUNCTION;
1357: opline->op1.op_type = IS_CONST;
1358: build_runtime_defined_function_key(&opline->op1.u.constant, lcname, name_len TSRMLS_CC);
1359: opline->op2.op_type = IS_CONST;
1360: opline->op2.u.constant.type = IS_STRING;
1361: opline->op2.u.constant.value.str.val = lcname;
1362: opline->op2.u.constant.value.str.len = name_len;
1363: Z_SET_REFCOUNT(opline->op2.u.constant, 1);
1364: opline->extended_value = ZEND_DECLARE_FUNCTION;
1365: 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));
1366: }
1367:
1368: if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
1369: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1370:
1371: opline->opcode = ZEND_EXT_NOP;
1372: opline->lineno = function_begin_line;
1373: SET_UNUSED(opline->op1);
1374: SET_UNUSED(opline->op2);
1375: }
1376:
1377: {
1378: /* Push a seperator to the switch and foreach stacks */
1379: zend_switch_entry switch_entry;
1380:
1381: switch_entry.cond.op_type = IS_UNUSED;
1382: switch_entry.default_case = 0;
1383: switch_entry.control_var = 0;
1384:
1385: zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
1386:
1387: {
1388: /* Foreach stack separator */
1389: zend_op dummy_opline;
1390:
1391: dummy_opline.result.op_type = IS_UNUSED;
1392: dummy_opline.op1.op_type = IS_UNUSED;
1393:
1394: zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
1395: }
1396: }
1397:
1398: if (CG(doc_comment)) {
1399: CG(active_op_array)->doc_comment = CG(doc_comment);
1400: CG(active_op_array)->doc_comment_len = CG(doc_comment_len);
1401: CG(doc_comment) = NULL;
1402: CG(doc_comment_len) = 0;
1403: }
1404:
1405: zend_stack_push(&CG(labels_stack), (void *) &CG(labels), sizeof(HashTable*));
1406: CG(labels) = NULL;
1407: }
1408: /* }}} */
1409:
1410: void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference TSRMLS_DC) /* {{{ */
1411: {
1412: znode function_name;
1413: zend_op_array *current_op_array = CG(active_op_array);
1414: int current_op_number = get_next_op_number(CG(active_op_array));
1415: zend_op *current_op;
1416:
1417: function_name.op_type = IS_CONST;
1418: ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1);
1419:
1420: zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC);
1421:
1422: result->op_type = IS_TMP_VAR;
1423: result->u.var = get_temporary_variable(current_op_array);
1424:
1425: current_op = ¤t_op_array->opcodes[current_op_number];
1426: current_op->opcode = ZEND_DECLARE_LAMBDA_FUNCTION;
1427: zval_dtor(¤t_op->op2.u.constant);
1428: ZVAL_LONG(¤t_op->op2.u.constant, zend_hash_func(Z_STRVAL(current_op->op1.u.constant), Z_STRLEN(current_op->op1.u.constant)));
1429: current_op->result = *result;
1430: CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE;
1431: }
1432: /* }}} */
1433:
1434: void zend_do_handle_exception(TSRMLS_D) /* {{{ */
1435: {
1436: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1437:
1438: opline->opcode = ZEND_HANDLE_EXCEPTION;
1439: SET_UNUSED(opline->op1);
1440: SET_UNUSED(opline->op2);
1441: }
1442: /* }}} */
1443:
1444: void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */
1445: {
1446: char lcname[16];
1447: int name_len;
1448:
1449: zend_do_extended_info(TSRMLS_C);
1450: zend_do_return(NULL, 0 TSRMLS_CC);
1451:
1452: pass_two(CG(active_op_array) TSRMLS_CC);
1453: zend_release_labels(TSRMLS_C);
1454:
1455: if (CG(active_class_entry)) {
1456: zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC);
1457: } else {
1458: /* we don't care if the function name is longer, in fact lowercasing only
1459: * the beginning of the name speeds up the check process */
1460: name_len = strlen(CG(active_op_array)->function_name);
1461: zend_str_tolower_copy(lcname, CG(active_op_array)->function_name, MIN(name_len, sizeof(lcname)-1));
1462: lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
1463: if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
1464: zend_error(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME);
1465: }
1466: }
1467:
1468: CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C);
1469: CG(active_op_array) = function_token->u.op_array;
1470:
1471:
1472: /* Pop the switch and foreach seperators */
1473: zend_stack_del_top(&CG(switch_cond_stack));
1474: zend_stack_del_top(&CG(foreach_copy_stack));
1475: }
1476: /* }}} */
1477:
1478: void zend_do_receive_arg(zend_uchar op, const znode *var, const znode *offset, const znode *initialization, znode *class_type, const znode *varname, zend_uchar pass_by_reference TSRMLS_DC) /* {{{ */
1479: {
1480: zend_op *opline;
1481: zend_arg_info *cur_arg_info;
1482:
1483: if (class_type->op_type == IS_CONST &&
1484: Z_TYPE(class_type->u.constant) == IS_STRING &&
1485: Z_STRLEN(class_type->u.constant) == 0) {
1486: /* Usage of namespace as class name not in namespace */
1487: zval_dtor(&class_type->u.constant);
1488: zend_error(E_COMPILE_ERROR, "Cannot use 'namespace' as a class name");
1489: return;
1490: }
1491:
1492: if (var->op_type == IS_CV &&
1493: var->u.var == CG(active_op_array)->this_var &&
1494: (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) {
1495: zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
1496: } else if (var->op_type == IS_VAR &&
1497: CG(active_op_array)->scope &&
1498: ((CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) &&
1499: (Z_TYPE(varname->u.constant) == IS_STRING) &&
1500: (Z_STRLEN(varname->u.constant) == sizeof("this")-1) &&
1501: (memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")) == 0)) {
1502: zend_error(E_COMPILE_ERROR, "Cannot re-assign $this");
1503: }
1504:
1505: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1506: CG(active_op_array)->num_args++;
1507: opline->opcode = op;
1508: opline->result = *var;
1509: opline->op1 = *offset;
1510: if (op == ZEND_RECV_INIT) {
1511: opline->op2 = *initialization;
1512: } else {
1513: CG(active_op_array)->required_num_args = CG(active_op_array)->num_args;
1514: SET_UNUSED(opline->op2);
1515: }
1516: CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
1517: cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
1518: cur_arg_info->name = estrndup(varname->u.constant.value.str.val, varname->u.constant.value.str.len);
1519: cur_arg_info->name_len = varname->u.constant.value.str.len;
1520: cur_arg_info->array_type_hint = 0;
1521: cur_arg_info->allow_null = 1;
1522: cur_arg_info->pass_by_reference = pass_by_reference;
1523: cur_arg_info->class_name = NULL;
1524: cur_arg_info->class_name_len = 0;
1525:
1526: if (class_type->op_type != IS_UNUSED) {
1527: cur_arg_info->allow_null = 0;
1528: if (class_type->u.constant.type == IS_STRING) {
1529: if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
1530: zend_resolve_class_name(class_type, &opline->extended_value, 1 TSRMLS_CC);
1531: }
1532: cur_arg_info->class_name = class_type->u.constant.value.str.val;
1533: cur_arg_info->class_name_len = class_type->u.constant.value.str.len;
1534: if (op == ZEND_RECV_INIT) {
1535: if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
1536: cur_arg_info->allow_null = 1;
1537: } else {
1538: zend_error(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL");
1539: }
1540: }
1541: } else {
1542: cur_arg_info->array_type_hint = 1;
1543: cur_arg_info->class_name = NULL;
1544: cur_arg_info->class_name_len = 0;
1545: if (op == ZEND_RECV_INIT) {
1546: if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
1547: cur_arg_info->allow_null = 1;
1548: } else if (Z_TYPE(initialization->u.constant) != IS_ARRAY && Z_TYPE(initialization->u.constant) != IS_CONSTANT_ARRAY) {
1549: zend_error(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL");
1550: }
1551: }
1552: }
1553: }
1554: opline->result.u.EA.type |= EXT_TYPE_UNUSED;
1555: }
1556: /* }}} */
1557:
1558: int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
1559: {
1560: zend_function *function;
1561: char *lcname;
1562: char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
1563:
1564: zend_resolve_non_class_name(function_name, check_namespace TSRMLS_CC);
1565:
1566: if (check_namespace && CG(current_namespace) && !is_compound) {
1567: /* We assume we call function from the current namespace
1568: if it is not prefixed. */
1569:
1570: /* In run-time PHP will check for function with full name and
1571: internal function with short name */
1572: zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC);
1573: return 1;
1574: }
1575:
1576: lcname = zend_str_tolower_dup(function_name->u.constant.value.str.val, function_name->u.constant.value.str.len);
1577: if ((zend_hash_find(CG(function_table), lcname, function_name->u.constant.value.str.len+1, (void **) &function)==FAILURE) ||
1578: ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
1579: (function->type == ZEND_INTERNAL_FUNCTION))) {
1580: zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
1581: efree(lcname);
1582: return 1; /* Dynamic */
1583: }
1584: efree(function_name->u.constant.value.str.val);
1585: function_name->u.constant.value.str.val = lcname;
1586:
1587: zend_stack_push(&CG(function_call_stack), (void *) &function, sizeof(zend_function *));
1588: zend_do_extended_fcall_begin(TSRMLS_C);
1589: return 0;
1590: }
1591: /* }}} */
1592:
1593: void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */
1594: {
1595: zend_op *last_op;
1596: int last_op_number;
1597: unsigned char *ptr = NULL;
1598:
1599: zend_do_end_variable_parse(left_bracket, BP_VAR_R, 0 TSRMLS_CC);
1600: zend_do_begin_variable_parse(TSRMLS_C);
1601:
1602: last_op_number = get_next_op_number(CG(active_op_array))-1;
1603: last_op = &CG(active_op_array)->opcodes[last_op_number];
1604:
1605: if ((last_op->op2.op_type == IS_CONST) && (last_op->op2.u.constant.type == IS_STRING) && (last_op->op2.u.constant.value.str.len == sizeof(ZEND_CLONE_FUNC_NAME)-1)
1606: && !zend_binary_strcasecmp(last_op->op2.u.constant.value.str.val, last_op->op2.u.constant.value.str.len, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) {
1607: zend_error(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead");
1608: }
1609:
1610: if (last_op->opcode == ZEND_FETCH_OBJ_R) {
1611: last_op->opcode = ZEND_INIT_METHOD_CALL;
1612: SET_UNUSED(last_op->result);
1613: Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
1614: } else {
1615: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1616: opline->opcode = ZEND_INIT_FCALL_BY_NAME;
1617: opline->op2 = *left_bracket;
1618: if (opline->op2.op_type == IS_CONST) {
1619: opline->op1.op_type = IS_CONST;
1620: Z_TYPE(opline->op1.u.constant) = IS_STRING;
1621: Z_STRVAL(opline->op1.u.constant) = zend_str_tolower_dup(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant));
1622: Z_STRLEN(opline->op1.u.constant) = Z_STRLEN(opline->op2.u.constant);
1623: opline->extended_value = zend_hash_func(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant) + 1);
1624: } else {
1625: opline->extended_value = 0;
1626: SET_UNUSED(opline->op1);
1627: }
1628: }
1629:
1630: zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
1631: zend_do_extended_fcall_begin(TSRMLS_C);
1632: }
1633: /* }}} */
1634:
1635: void zend_do_clone(znode *result, const znode *expr TSRMLS_DC) /* {{{ */
1636: {
1637: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1638:
1639: opline->opcode = ZEND_CLONE;
1640: opline->op1 = *expr;
1641: SET_UNUSED(opline->op2);
1642: opline->result.op_type = IS_VAR;
1643: opline->result.u.var = get_temporary_variable(CG(active_op_array));
1644: *result = opline->result;
1645: }
1646: /* }}} */
1647:
1648: void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */
1649: {
1650: unsigned char *ptr = NULL;
1651: zend_op *opline, *opline2;
1652:
1653: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1654: if (ns_call) {
1655: char *slash;
1656: int prefix_len, name_len;
1657: /* In run-time PHP will check for function with full name and
1658: internal function with short name */
1659: opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
1660: opline->op2 = *function_name;
1661: opline->extended_value = 0;
1662: opline->op1.op_type = IS_CONST;
1663: Z_TYPE(opline->op1.u.constant) = IS_STRING;
1664: Z_STRVAL(opline->op1.u.constant) = zend_str_tolower_dup(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant));
1665: Z_STRLEN(opline->op1.u.constant) = Z_STRLEN(opline->op2.u.constant);
1666: opline->extended_value = zend_hash_func(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant) + 1);
1667: slash = zend_memrchr(Z_STRVAL(opline->op1.u.constant), '\\', Z_STRLEN(opline->op1.u.constant));
1668: prefix_len = slash-Z_STRVAL(opline->op1.u.constant)+1;
1669: name_len = Z_STRLEN(opline->op1.u.constant)-prefix_len;
1670: opline2 = get_next_op(CG(active_op_array) TSRMLS_CC);
1671: opline2->opcode = ZEND_OP_DATA;
1672: opline2->op1.op_type = IS_CONST;
1673: Z_TYPE(opline2->op1.u.constant) = IS_LONG;
1674: if(!slash) {
1675: zend_error(E_CORE_ERROR, "Namespaced name %s should contain slash", Z_STRVAL(opline->op1.u.constant));
1676: }
1677: /* this is the length of namespace prefix */
1678: Z_LVAL(opline2->op1.u.constant) = prefix_len;
1679: /* this is the hash of the non-prefixed part, lowercased */
1680: opline2->extended_value = zend_hash_func(slash+1, name_len+1);
1681: SET_UNUSED(opline2->op2);
1682: } else {
1683: opline->opcode = ZEND_INIT_FCALL_BY_NAME;
1684: opline->op2 = *function_name;
1685: if (opline->op2.op_type == IS_CONST) {
1686: opline->op1.op_type = IS_CONST;
1687: Z_TYPE(opline->op1.u.constant) = IS_STRING;
1688: Z_STRVAL(opline->op1.u.constant) = zend_str_tolower_dup(Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant));
1689: Z_STRLEN(opline->op1.u.constant) = Z_STRLEN(opline->op2.u.constant);
1690: opline->extended_value = zend_hash_func(Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant) + 1);
1691: } else {
1692: opline->extended_value = 0;
1693: SET_UNUSED(opline->op1);
1694: }
1695: }
1696:
1697: zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
1698: zend_do_extended_fcall_begin(TSRMLS_C);
1699: }
1700: /* }}} */
1701:
1702: void zend_resolve_non_class_name(znode *element_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
1703: {
1704: znode tmp;
1705: int len;
1706: zval **ns;
1707: char *lcname, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
1708:
1709: if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
1710: /* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
1711: memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
1712: --Z_STRLEN(element_name->u.constant);
1713: return;
1714: }
1715:
1716: if(!check_namespace) {
1717: return;
1718: }
1719:
1720: if (compound && CG(current_import)) {
1721: len = compound - Z_STRVAL(element_name->u.constant);
1722: lcname = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
1723: /* Check if first part of compound name is an import name */
1724: if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) {
1725: /* Substitute import name */
1726: tmp.op_type = IS_CONST;
1727: tmp.u.constant = **ns;
1728: zval_copy_ctor(&tmp.u.constant);
1729: len += 1;
1730: Z_STRLEN(element_name->u.constant) -= len;
1731: memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
1732: zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC);
1733: *element_name = tmp;
1734: efree(lcname);
1735: return;
1736: }
1737: efree(lcname);
1738: }
1739:
1740: if (CG(current_namespace)) {
1741: tmp = *element_name;
1742: Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace));
1743: Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1);
1744: memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
1745: memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace))]), "\\", sizeof("\\")-1);
1746: memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
1747: STR_FREE(Z_STRVAL(element_name->u.constant));
1748: *element_name = tmp;
1749: }
1750: }
1751: /* }}} */
1752:
1753: void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_name TSRMLS_DC) /* {{{ */
1754: {
1755: char *compound;
1756: char *lcname;
1757: zval **ns;
1758: znode tmp;
1759: int len;
1760:
1761: compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant));
1762: if (compound) {
1763: /* This is a compound class name that contains namespace prefix */
1764: if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
1765: /* The STRING name has "\" prefix */
1766: Z_STRLEN(class_name->u.constant) -= 1;
1767: memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)+1);
1768: Z_STRVAL(class_name->u.constant) = erealloc(
1769: Z_STRVAL(class_name->u.constant),
1770: Z_STRLEN(class_name->u.constant) + 1);
1771:
1772: if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
1773: zend_error(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
1774: }
1775: } else {
1776: if (CG(current_import)) {
1777: len = compound - Z_STRVAL(class_name->u.constant);
1778: lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), len);
1779: /* Check if first part of compound name is an import name */
1780: if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) {
1781: /* Substitute import name */
1782: tmp.op_type = IS_CONST;
1783: tmp.u.constant = **ns;
1784: zval_copy_ctor(&tmp.u.constant);
1785: len += 1;
1786: Z_STRLEN(class_name->u.constant) -= len;
1787: memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
1788: zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
1789: *class_name = tmp;
1790: efree(lcname);
1791: return;
1792: }
1793: efree(lcname);
1794: }
1795: /* Here name is not prefixed with \ and not imported */
1796: if (CG(current_namespace)) {
1797: tmp.op_type = IS_CONST;
1798: tmp.u.constant = *CG(current_namespace);
1799: zval_copy_ctor(&tmp.u.constant);
1800: zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
1801: *class_name = tmp;
1802: }
1803: }
1804: } else if (CG(current_import) || CG(current_namespace)) {
1805: /* this is a plain name (without \) */
1806: lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
1807:
1808: if (CG(current_import) &&
1809: zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns) == SUCCESS) {
1810: /* The given name is an import name. Substitute it. */
1811: zval_dtor(&class_name->u.constant);
1812: class_name->u.constant = **ns;
1813: zval_copy_ctor(&class_name->u.constant);
1814: } else if (CG(current_namespace)) {
1815: /* plain name, no import - prepend current namespace to it */
1816: tmp.op_type = IS_CONST;
1817: tmp.u.constant = *CG(current_namespace);
1818: zval_copy_ctor(&tmp.u.constant);
1819: zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
1820: *class_name = tmp;
1821: }
1822: efree(lcname);
1823: }
1824: }
1825: /* }}} */
1826:
1827: void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
1828: {
1829: long fetch_class_op_number;
1830: zend_op *opline;
1831:
1832: if (class_name->op_type == IS_CONST &&
1833: Z_TYPE(class_name->u.constant) == IS_STRING &&
1834: Z_STRLEN(class_name->u.constant) == 0) {
1835: /* Usage of namespace as class name not in namespace */
1836: zval_dtor(&class_name->u.constant);
1837: zend_error(E_COMPILE_ERROR, "Cannot use 'namespace' as a class name");
1838: return;
1839: }
1840:
1841: fetch_class_op_number = get_next_op_number(CG(active_op_array));
1842: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1843:
1844: opline->opcode = ZEND_FETCH_CLASS;
1845: SET_UNUSED(opline->op1);
1846: opline->extended_value = ZEND_FETCH_CLASS_GLOBAL;
1847: CG(catch_begin) = fetch_class_op_number;
1848: if (class_name->op_type == IS_CONST) {
1849: int fetch_type;
1850:
1851: fetch_type = zend_get_class_fetch_type(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);
1852: switch (fetch_type) {
1853: case ZEND_FETCH_CLASS_SELF:
1854: case ZEND_FETCH_CLASS_PARENT:
1855: case ZEND_FETCH_CLASS_STATIC:
1856: SET_UNUSED(opline->op2);
1857: opline->extended_value = fetch_type;
1858: zval_dtor(&class_name->u.constant);
1859: break;
1860: default:
1861: zend_resolve_class_name(class_name, &opline->extended_value, 0 TSRMLS_CC);
1862: opline->op2 = *class_name;
1863: break;
1864: }
1865: } else {
1866: opline->op2 = *class_name;
1867: }
1868: opline->result.u.var = get_temporary_variable(CG(active_op_array));
1869: opline->result.u.EA.type = opline->extended_value;
1870: opline->result.op_type = IS_VAR; /* FIXME: Hack so that INIT_FCALL_BY_NAME still knows this is a class */
1871: *result = opline->result;
1872: }
1873: /* }}} */
1874:
1875: void zend_do_label(znode *label TSRMLS_DC) /* {{{ */
1876: {
1877: zend_op_array *oparray = CG(active_op_array);
1878: zend_label dest;
1879:
1880: if (!CG(labels)) {
1881: ALLOC_HASHTABLE(CG(labels));
1882: zend_hash_init(CG(labels), 4, NULL, NULL, 0);
1883: }
1884:
1885: dest.brk_cont = oparray->current_brk_cont;
1886: dest.opline_num = get_next_op_number(oparray);
1887:
1888: if (zend_hash_add(CG(labels), Z_STRVAL(label->u.constant), Z_STRLEN(label->u.constant) + 1, (void**)&dest, sizeof(zend_label), NULL) == FAILURE) {
1889: zend_error(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant));
1890: }
1891:
1892: /* Done with label now */
1893: zval_dtor(&label->u.constant);
1894: }
1895: /* }}} */
1896:
1897: void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
1898: {
1899: zend_label *dest;
1900: long current, distance;
1901:
1902: if (CG(labels) == NULL ||
1903: zend_hash_find(CG(labels), Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void**)&dest) == FAILURE) {
1904:
1905: if (pass2) {
1906: CG(in_compilation) = 1;
1907: CG(active_op_array) = op_array;
1908: CG(zend_lineno) = opline->lineno;
1909: zend_error(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL(opline->op2.u.constant));
1910: } else {
1911: /* Label is not defined. Delay to pass 2. */
1912: INC_BPC(op_array);
1913: return;
1914: }
1915: }
1916:
1917: opline->op1.u.opline_num = dest->opline_num;
1918: zval_dtor(&opline->op2.u.constant);
1919:
1920: /* Check that we are not moving into loop or switch */
1921: current = opline->extended_value;
1922: for (distance = 0; current != dest->brk_cont; distance++) {
1923: if (current == -1) {
1924: if (pass2) {
1925: CG(in_compilation) = 1;
1926: CG(active_op_array) = op_array;
1927: CG(zend_lineno) = opline->lineno;
1928: }
1929: zend_error(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed");
1930: }
1931: current = op_array->brk_cont_array[current].parent;
1932: }
1933:
1934: if (distance == 0) {
1935: /* Nothing to break out of, optimize to ZEND_JMP */
1936: opline->opcode = ZEND_JMP;
1937: opline->extended_value = 0;
1938: SET_UNUSED(opline->op2);
1939: } else {
1940: /* Set real break distance */
1941: ZVAL_LONG(&opline->op2.u.constant, distance);
1942: }
1943:
1944: if (pass2) {
1945: DEC_BPC(op_array);
1946: }
1947: }
1948: /* }}} */
1949:
1950: void zend_do_goto(const znode *label TSRMLS_DC) /* {{{ */
1951: {
1952: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1953:
1954: opline->opcode = ZEND_GOTO;
1955: opline->extended_value = CG(active_op_array)->current_brk_cont;
1956: SET_UNUSED(opline->op1);
1957: opline->op2 = *label;
1958: zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC);
1959: }
1960: /* }}} */
1961:
1962: void zend_release_labels(TSRMLS_D) /* {{{ */
1963: {
1964: if (CG(labels)) {
1965: zend_hash_destroy(CG(labels));
1966: FREE_HASHTABLE(CG(labels));
1967: }
1968: if (!zend_stack_is_empty(&CG(labels_stack))) {
1969: HashTable **pht;
1970:
1971: zend_stack_top(&CG(labels_stack), (void**)&pht);
1972: CG(labels) = *pht;
1973: zend_stack_del_top(&CG(labels_stack));
1974: } else {
1975: CG(labels) = NULL;
1976: }
1977: }
1978: /* }}} */
1979:
1980: void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC) /* {{{ */
1981: {
1982: zend_uint length;
1983:
1984: if (!result) {
1985: result = prefix;
1986: } else {
1987: *result = *prefix;
1988: }
1989:
1990: if (is_class_member) {
1991: length = sizeof("::")-1 + result->u.constant.value.str.len + name->u.constant.value.str.len;
1992: result->u.constant.value.str.val = erealloc(result->u.constant.value.str.val, length+1);
1993: memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len], "::", sizeof("::")-1);
1994: memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len + sizeof("::")-1], name->u.constant.value.str.val, name->u.constant.value.str.len+1);
1995: STR_FREE(name->u.constant.value.str.val);
1996: result->u.constant.value.str.len = length;
1997: } else {
1998: length = sizeof("\\")-1 + result->u.constant.value.str.len + name->u.constant.value.str.len;
1999: result->u.constant.value.str.val = erealloc(result->u.constant.value.str.val, length+1);
2000: memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len], "\\", sizeof("\\")-1);
2001: memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len + sizeof("\\")-1], name->u.constant.value.str.val, name->u.constant.value.str.len+1);
2002: STR_FREE(name->u.constant.value.str.val);
2003: result->u.constant.value.str.len = length;
2004: }
2005: }
2006: /* }}} */
2007:
2008: int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
2009: {
2010: znode class_node;
2011: unsigned char *ptr = NULL;
2012: zend_op *opline;
2013: ulong fetch_type = 0;
2014:
2015: if (method_name->op_type == IS_CONST) {
2016: char *lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
2017: if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
2018: memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) {
2019: zval_dtor(&method_name->u.constant);
2020: SET_UNUSED(*method_name);
2021: }
2022: efree(lcname);
2023: }
2024:
2025: if (class_name->op_type == IS_CONST &&
2026: ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
2027: fetch_type = ZEND_FETCH_CLASS_GLOBAL;
2028: zend_resolve_class_name(class_name, &fetch_type, 1 TSRMLS_CC);
2029: class_node = *class_name;
2030: } else {
2031: zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
2032: }
2033: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2034: opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
2035: opline->op1 = class_node;
2036: opline->op2 = *method_name;
2037:
2038: zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
2039: zend_do_extended_fcall_begin(TSRMLS_C);
2040: return 1; /* Dynamic */
2041: }
2042: /* }}} */
2043:
2044: void zend_do_end_function_call(znode *function_name, znode *result, const znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */
2045: {
2046: zend_op *opline;
2047:
2048: if (is_method && function_name && function_name->op_type == IS_UNUSED) {
2049: /* clone */
2050: if (Z_LVAL(argument_list->u.constant) != 0) {
2051: zend_error(E_WARNING, "Clone method does not require arguments");
2052: }
2053: opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
2054: } else {
2055: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2056: if (!is_method && !is_dynamic_fcall && function_name->op_type==IS_CONST) {
2057: opline->opcode = ZEND_DO_FCALL;
2058: opline->op1 = *function_name;
2059: ZVAL_LONG(&opline->op2.u.constant, zend_hash_func(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant) + 1));
2060: } else {
2061: opline->opcode = ZEND_DO_FCALL_BY_NAME;
2062: SET_UNUSED(opline->op1);
2063: }
2064: }
2065:
2066: opline->result.u.var = get_temporary_variable(CG(active_op_array));
2067: opline->result.op_type = IS_VAR;
2068: *result = opline->result;
2069: SET_UNUSED(opline->op2);
2070:
2071: zend_stack_del_top(&CG(function_call_stack));
2072: opline->extended_value = Z_LVAL(argument_list->u.constant);
2073: }
2074: /* }}} */
2075:
2076: void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC) /* {{{ */
2077: {
2078: zend_op *opline;
2079: int original_op=op;
2080: zend_function **function_ptr_ptr, *function_ptr;
2081: int send_by_reference;
2082: int send_function = 0;
2083:
2084: zend_stack_top(&CG(function_call_stack), (void **) &function_ptr_ptr);
2085: function_ptr = *function_ptr_ptr;
2086:
2087: if (original_op == ZEND_SEND_REF && !CG(allow_call_time_pass_reference)) {
2088: if (function_ptr &&
2089: function_ptr->common.function_name &&
2090: function_ptr->common.type == ZEND_USER_FUNCTION &&
2091: !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, (zend_uint) offset)) {
2092: zend_error(E_DEPRECATED,
2093: "Call-time pass-by-reference has been deprecated; "
2094: "If you would like to pass it by reference, modify the declaration of %s(). "
2095: "If you would like to enable call-time pass-by-reference, you can set "
2096: "allow_call_time_pass_reference to true in your INI file", function_ptr->common.function_name);
2097: } else {
2098: zend_error(E_DEPRECATED, "Call-time pass-by-reference has been deprecated");
2099: }
2100: }
2101:
2102: if (function_ptr) {
2103: if (ARG_MAY_BE_SENT_BY_REF(function_ptr, (zend_uint) offset)) {
2104: if (param->op_type & (IS_VAR|IS_CV)) {
2105: send_by_reference = 1;
2106: if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
2107: /* Method call */
2108: op = ZEND_SEND_VAR_NO_REF;
2109: send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT;
2110: }
2111: } else {
2112: op = ZEND_SEND_VAL;
2113: send_by_reference = 0;
2114: }
2115: } else {
2116: send_by_reference = ARG_SHOULD_BE_SENT_BY_REF(function_ptr, (zend_uint) offset) ? ZEND_ARG_SEND_BY_REF : 0;
2117: }
2118: } else {
2119: send_by_reference = 0;
2120: }
2121:
2122: if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
2123: /* Method call */
2124: op = ZEND_SEND_VAR_NO_REF;
2125: send_function = ZEND_ARG_SEND_FUNCTION;
2126: } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) {
2127: op = ZEND_SEND_VAR_NO_REF;
2128: }
2129:
2130: if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) {
2131: /* change to passing by reference */
2132: switch (param->op_type) {
2133: case IS_VAR:
2134: case IS_CV:
2135: op = ZEND_SEND_REF;
2136: break;
2137: default:
2138: zend_error(E_COMPILE_ERROR, "Only variables can be passed by reference");
2139: break;
2140: }
2141: }
2142:
2143: if (original_op == ZEND_SEND_VAR) {
2144: switch (op) {
2145: case ZEND_SEND_VAR_NO_REF:
2146: zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
2147: break;
2148: case ZEND_SEND_VAR:
2149: if (function_ptr) {
2150: zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
2151: } else {
2152: zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, offset TSRMLS_CC);
2153: }
2154: break;
2155: case ZEND_SEND_REF:
2156: zend_do_end_variable_parse(param, BP_VAR_W, 0 TSRMLS_CC);
2157: break;
2158: }
2159: }
2160:
2161: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2162:
2163: if (op == ZEND_SEND_VAR_NO_REF) {
2164: if (function_ptr) {
2165: opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function;
2166: } else {
2167: opline->extended_value = send_function;
2168: }
2169: } else {
2170: if (function_ptr) {
2171: opline->extended_value = ZEND_DO_FCALL;
2172: } else {
2173: opline->extended_value = ZEND_DO_FCALL_BY_NAME;
2174: }
2175: }
2176: opline->opcode = op;
2177: opline->op1 = *param;
2178: opline->op2.u.opline_num = offset;
2179: SET_UNUSED(opline->op2);
2180: }
2181: /* }}} */
2182:
2183: static int generate_free_switch_expr(const zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */
2184: {
2185: zend_op *opline;
2186:
2187: if (switch_entry->cond.op_type != IS_VAR && switch_entry->cond.op_type != IS_TMP_VAR) {
2188: return (switch_entry->cond.op_type == IS_UNUSED);
2189: }
2190:
2191: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2192:
2193: opline->opcode = (switch_entry->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
2194: opline->op1 = switch_entry->cond;
2195: SET_UNUSED(opline->op2);
2196: opline->extended_value = 0;
2197: return 0;
2198: }
2199: /* }}} */
2200:
2201: static int generate_free_foreach_copy(const zend_op *foreach_copy TSRMLS_DC) /* {{{ */
2202: {
2203: zend_op *opline;
2204:
2205: /* If we reach the seperator then stop applying the stack */
2206: if (foreach_copy->result.op_type == IS_UNUSED && foreach_copy->op1.op_type == IS_UNUSED) {
2207: return 1;
2208: }
2209:
2210: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2211:
2212: opline->opcode = (foreach_copy->result.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
2213: opline->op1 = foreach_copy->result;
2214: SET_UNUSED(opline->op2);
2215: opline->extended_value = 1;
2216:
2217: if (foreach_copy->op1.op_type != IS_UNUSED) {
2218: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2219:
2220: opline->opcode = (foreach_copy->op1.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
2221: opline->op1 = foreach_copy->op1;
2222: SET_UNUSED(opline->op2);
2223: opline->extended_value = 0;
2224: }
2225:
2226: return 0;
2227: }
2228: /* }}} */
2229:
2230: void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
2231: {
2232: zend_op *opline;
2233: int start_op_number, end_op_number;
2234:
2235: if (do_end_vparse) {
2236: if (CG(active_op_array)->return_reference && !zend_is_function_or_method_call(expr)) {
2237: zend_do_end_variable_parse(expr, BP_VAR_W, 0 TSRMLS_CC);
2238: } else {
2239: zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC);
2240: }
2241: }
2242:
2243: start_op_number = get_next_op_number(CG(active_op_array));
2244:
2245: #ifdef ZTS
2246: zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
2247: zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
2248: #else
2249: zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
2250: zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
2251: #endif
2252:
2253: end_op_number = get_next_op_number(CG(active_op_array));
2254: while (start_op_number < end_op_number) {
2255: CG(active_op_array)->opcodes[start_op_number].op1.u.EA.type = EXT_TYPE_FREE_ON_RETURN;
2256: start_op_number++;
2257: }
2258:
2259: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2260:
2261: opline->opcode = ZEND_RETURN;
2262:
2263: if (expr) {
2264: opline->op1 = *expr;
2265:
2266: if (do_end_vparse && zend_is_function_or_method_call(expr)) {
2267: opline->extended_value = ZEND_RETURNS_FUNCTION;
2268: }
2269: } else {
2270: opline->op1.op_type = IS_CONST;
2271: INIT_ZVAL(opline->op1.u.constant);
2272: }
2273:
2274: SET_UNUSED(opline->op2);
2275: }
2276: /* }}} */
2277:
2278: static int zend_add_try_element(zend_uint try_op TSRMLS_DC) /* {{{ */
2279: {
2280: int try_catch_offset = CG(active_op_array)->last_try_catch++;
2281:
2282: CG(active_op_array)->try_catch_array = erealloc(CG(active_op_array)->try_catch_array, sizeof(zend_try_catch_element)*CG(active_op_array)->last_try_catch);
2283: CG(active_op_array)->try_catch_array[try_catch_offset].try_op = try_op;
2284: return try_catch_offset;
2285: }
2286: /* }}} */
2287:
2288: static void zend_add_catch_element(int offset, zend_uint catch_op TSRMLS_DC) /* {{{ */
2289: {
2290: CG(active_op_array)->try_catch_array[offset].catch_op = catch_op;
2291: }
2292: /* }}} */
2293:
2294: void zend_do_first_catch(znode *open_parentheses TSRMLS_DC) /* {{{ */
2295: {
2296: open_parentheses->u.opline_num = get_next_op_number(CG(active_op_array));
2297: }
2298: /* }}} */
2299:
2300: void zend_initialize_try_catch_element(const znode *try_token TSRMLS_DC) /* {{{ */
2301: {
2302: int jmp_op_number = get_next_op_number(CG(active_op_array));
2303: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2304: zend_llist jmp_list;
2305: zend_llist *jmp_list_ptr;
2306:
2307: opline->opcode = ZEND_JMP;
2308: SET_UNUSED(opline->op1);
2309: SET_UNUSED(opline->op2);
2310: /* save for backpatching */
2311:
2312: zend_llist_init(&jmp_list, sizeof(int), NULL, 0);
2313: zend_stack_push(&CG(bp_stack), (void *) &jmp_list, sizeof(zend_llist));
2314: zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
2315: zend_llist_add_element(jmp_list_ptr, &jmp_op_number);
2316:
2317: zend_add_catch_element(try_token->u.opline_num, get_next_op_number(CG(active_op_array)) TSRMLS_CC);
2318: }
2319: /* }}} */
2320:
2321: void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additional_catch TSRMLS_DC) /* {{{ */
2322: {
2323: CG(active_op_array)->last--;
2324: zend_do_if_end(TSRMLS_C);
2325: if (last_additional_catch->u.opline_num == -1) {
2326: CG(active_op_array)->opcodes[first_catch->u.opline_num].op1.u.EA.type = 1;
2327: CG(active_op_array)->opcodes[first_catch->u.opline_num].extended_value = get_next_op_number(CG(active_op_array));
2328: } else {
2329: CG(active_op_array)->opcodes[last_additional_catch->u.opline_num].op1.u.EA.type = 1;
2330: CG(active_op_array)->opcodes[last_additional_catch->u.opline_num].extended_value = get_next_op_number(CG(active_op_array));
2331: }
2332: DEC_BPC(CG(active_op_array));
2333: }
2334: /* }}} */
2335:
2336: void zend_do_try(znode *try_token TSRMLS_DC) /* {{{ */
2337: {
2338: try_token->u.opline_num = zend_add_try_element(get_next_op_number(CG(active_op_array)) TSRMLS_CC);
2339: INC_BPC(CG(active_op_array));
2340: }
2341: /* }}} */
2342:
2343: void zend_do_begin_catch(znode *try_token, znode *class_name, const znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */
2344: {
2345: long catch_op_number;
2346: zend_op *opline;
2347: znode catch_class;
2348:
2349: zend_do_fetch_class(&catch_class, class_name TSRMLS_CC);
2350:
2351: catch_op_number = get_next_op_number(CG(active_op_array));
2352: if (catch_op_number > 0) {
2353: opline = &CG(active_op_array)->opcodes[catch_op_number-1];
2354: if (opline->opcode == ZEND_FETCH_CLASS) {
2355: opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
2356: }
2357: }
2358:
2359: if (first_catch) {
2360: first_catch->u.opline_num = catch_op_number;
2361: }
2362:
2363: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2364: opline->opcode = ZEND_CATCH;
2365: opline->op1 = catch_class;
2366: /* SET_UNUSED(opline->op1); */ /* FIXME: Define IS_CLASS or something like that */
2367: opline->op2.op_type = IS_CV;
2368: opline->op2.u.var = lookup_cv(CG(active_op_array), catch_var->u.constant.value.str.val, catch_var->u.constant.value.str.len);
2369: opline->op2.u.EA.type = 0;
2370: opline->op1.u.EA.type = 0; /* 1 means it's the last catch in the block */
2371:
2372: try_token->u.opline_num = catch_op_number;
2373: }
2374: /* }}} */
2375:
2376: void zend_do_end_catch(const znode *try_token TSRMLS_DC) /* {{{ */
2377: {
2378: int jmp_op_number = get_next_op_number(CG(active_op_array));
2379: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2380: zend_llist *jmp_list_ptr;
2381:
2382: opline->opcode = ZEND_JMP;
2383: SET_UNUSED(opline->op1);
2384: SET_UNUSED(opline->op2);
2385: /* save for backpatching */
2386:
2387: zend_stack_top(&CG(bp_stack), (void **) &jmp_list_ptr);
2388: zend_llist_add_element(jmp_list_ptr, &jmp_op_number);
2389:
2390: CG(active_op_array)->opcodes[try_token->u.opline_num].extended_value = get_next_op_number(CG(active_op_array));
2391: }
2392: /* }}} */
2393:
2394: void zend_do_throw(const znode *expr TSRMLS_DC) /* {{{ */
2395: {
2396: zend_op *opline;
2397:
2398: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2399: opline->opcode = ZEND_THROW;
2400: opline->op1 = *expr;
2401: SET_UNUSED(opline->op2);
2402: }
2403: /* }}} */
2404:
2405: ZEND_API void function_add_ref(zend_function *function) /* {{{ */
2406: {
2407: if (function->type == ZEND_USER_FUNCTION) {
2408: zend_op_array *op_array = &function->op_array;
2409:
2410: (*op_array->refcount)++;
2411: if (op_array->static_variables) {
2412: HashTable *static_variables = op_array->static_variables;
2413: zval *tmp_zval;
2414:
2415: ALLOC_HASHTABLE(op_array->static_variables);
2416: zend_hash_init(op_array->static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
2417: zend_hash_copy(op_array->static_variables, static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_zval, sizeof(zval *));
2418: }
2419: }
2420: }
2421: /* }}} */
2422:
2423: static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
2424: {
2425: zend_function *function;
2426:
2427: if (!ce->parent) {
2428: return;
2429: }
2430:
2431: /* You cannot change create_object */
2432: ce->create_object = ce->parent->create_object;
2433:
2434: /* Inherit special functions if needed */
2435: if (!ce->get_iterator) {
2436: ce->get_iterator = ce->parent->get_iterator;
2437: }
2438: if (!ce->iterator_funcs.funcs) {
2439: ce->iterator_funcs.funcs = ce->parent->iterator_funcs.funcs;
2440: }
2441: if (!ce->__get) {
2442: ce->__get = ce->parent->__get;
2443: }
2444: if (!ce->__set) {
2445: ce->__set = ce->parent->__set;
2446: }
2447: if (!ce->__unset) {
2448: ce->__unset = ce->parent->__unset;
2449: }
2450: if (!ce->__isset) {
2451: ce->__isset = ce->parent->__isset;
2452: }
2453: if (!ce->__call) {
2454: ce->__call = ce->parent->__call;
2455: }
2456: if (!ce->__callstatic) {
2457: ce->__callstatic = ce->parent->__callstatic;
2458: }
2459: if (!ce->__tostring) {
2460: ce->__tostring = ce->parent->__tostring;
2461: }
2462: if (!ce->clone) {
2463: ce->clone = ce->parent->clone;
2464: }
2465: if(!ce->serialize) {
2466: ce->serialize = ce->parent->serialize;
2467: }
2468: if(!ce->unserialize) {
2469: ce->unserialize = ce->parent->unserialize;
2470: }
2471: if (!ce->destructor) {
2472: ce->destructor = ce->parent->destructor;
2473: }
2474: if (ce->constructor) {
2475: if (ce->parent->constructor && ce->parent->constructor->common.fn_flags & ZEND_ACC_FINAL) {
2476: zend_error(E_ERROR, "Cannot override final %s::%s() with %s::%s()",
2477: ce->parent->name, ce->parent->constructor->common.function_name,
2478: ce->name, ce->constructor->common.function_name
2479: );
2480: }
2481: return;
2482: }
2483:
2484: if (zend_hash_find(&ce->parent->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), (void **)&function)==SUCCESS) {
2485: /* inherit parent's constructor */
2486: zend_hash_update(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), function, sizeof(zend_function), NULL);
2487: function_add_ref(function);
2488: } else {
2489: /* Don't inherit the old style constructor if we already have the new style constructor */
2490: char *lc_class_name;
2491: char *lc_parent_class_name;
2492:
2493: lc_class_name = zend_str_tolower_dup(ce->name, ce->name_length);
2494: if (!zend_hash_exists(&ce->function_table, lc_class_name, ce->name_length+1)) {
2495: lc_parent_class_name = zend_str_tolower_dup(ce->parent->name, ce->parent->name_length);
2496: if (!zend_hash_exists(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1) &&
2497: zend_hash_find(&ce->parent->function_table, lc_parent_class_name, ce->parent->name_length+1, (void **)&function)==SUCCESS) {
2498: if (function->common.fn_flags & ZEND_ACC_CTOR) {
2499: /* inherit parent's constructor */
2500: zend_hash_update(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1, function, sizeof(zend_function), NULL);
2501: function_add_ref(function);
2502: }
2503: }
2504: efree(lc_parent_class_name);
2505: }
2506: efree(lc_class_name);
2507: }
2508: ce->constructor = ce->parent->constructor;
2509: }
2510: /* }}} */
2511:
2512: char *zend_visibility_string(zend_uint fn_flags) /* {{{ */
2513: {
2514: if (fn_flags & ZEND_ACC_PRIVATE) {
2515: return "private";
2516: }
2517: if (fn_flags & ZEND_ACC_PROTECTED) {
2518: return "protected";
2519: }
2520: if (fn_flags & ZEND_ACC_PUBLIC) {
2521: return "public";
2522: }
2523: return "";
2524: }
2525: /* }}} */
2526:
2527: static void do_inherit_method(zend_function *function) /* {{{ */
2528: {
2529: /* The class entry of the derived function intentionally remains the same
2530: * as that of the parent class. That allows us to know in which context
2531: * we're running, and handle private method calls properly.
2532: */
2533: function_add_ref(function);
2534: }
2535: /* }}} */
2536:
2537: static zend_bool zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto TSRMLS_DC) /* {{{ */
2538: {
2539: zend_uint i;
2540:
2541: /* If it's a user function then arg_info == NULL means we don't have any parameters but
2542: * we still need to do the arg number checks. We are only willing to ignore this for internal
2543: * functions because extensions don't always define arg_info.
2544: */
2545: if (!proto || (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION)) {
2546: return 1;
2547: }
2548:
2549: /* Checks for constructors only if they are declared in an interface */
2550: if ((fe->common.fn_flags & ZEND_ACC_CTOR) && (proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0) {
2551: return 1;
2552: }
2553:
2554: /* check number of arguments */
2555: if (proto->common.required_num_args < fe->common.required_num_args
2556: || proto->common.num_args > fe->common.num_args) {
2557: return 0;
2558: }
2559:
2560: if (fe->common.type != ZEND_USER_FUNCTION
2561: && proto->common.pass_rest_by_reference
2562: && !fe->common.pass_rest_by_reference) {
2563: return 0;
2564: }
2565:
2566: /* by-ref constraints on return values are covariant */
2567: if (proto->common.return_reference && !fe->common.return_reference) {
2568: return 0;
2569: }
2570:
2571: for (i=0; i < proto->common.num_args; i++) {
2572: if (ZEND_LOG_XOR(fe->common.arg_info[i].class_name, proto->common.arg_info[i].class_name)) {
2573: /* Only one has a type hint and the other one doesn't */
2574: return 0;
2575: }
2576: if (fe->common.arg_info[i].class_name
2577: && strcasecmp(fe->common.arg_info[i].class_name, proto->common.arg_info[i].class_name)!=0) {
2578: char *colon;
2579:
2580: if (fe->common.type != ZEND_USER_FUNCTION) {
2581: return 0;
2582: } else if (strchr(proto->common.arg_info[i].class_name, '\\') != NULL ||
2583: (colon = zend_memrchr(fe->common.arg_info[i].class_name, '\\', fe->common.arg_info[i].class_name_len)) == NULL ||
2584: strcasecmp(colon+1, proto->common.arg_info[i].class_name) != 0) {
2585: zend_class_entry **fe_ce, **proto_ce;
2586: int found, found2;
2587:
2588: found = zend_lookup_class(fe->common.arg_info[i].class_name, fe->common.arg_info[i].class_name_len, &fe_ce TSRMLS_CC);
2589: found2 = zend_lookup_class(proto->common.arg_info[i].class_name, proto->common.arg_info[i].class_name_len, &proto_ce TSRMLS_CC);
2590:
2591: /* Check for class alias */
2592: if (found != SUCCESS || found2 != SUCCESS ||
2593: (*fe_ce)->type == ZEND_INTERNAL_CLASS ||
2594: (*proto_ce)->type == ZEND_INTERNAL_CLASS ||
2595: *fe_ce != *proto_ce) {
2596: return 0;
2597: }
2598: }
2599: }
2600: if (fe->common.arg_info[i].array_type_hint != proto->common.arg_info[i].array_type_hint) {
2601: /* Only one has an array type hint and the other one doesn't */
2602: return 0;
2603: }
2604:
2605: /* by-ref constraints on arguments are invariant */
2606: if (fe->common.arg_info[i].pass_by_reference != proto->common.arg_info[i].pass_by_reference) {
2607: return 0;
2608: }
2609: }
2610:
2611: if (proto->common.pass_rest_by_reference) {
2612: for (i=proto->common.num_args; i < fe->common.num_args; i++) {
2613: if (!fe->common.arg_info[i].pass_by_reference) {
2614: return 0;
2615: }
2616: }
2617: }
2618: return 1;
2619: }
2620: /* }}} */
2621:
2622: static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, const zend_hash_key *hash_key, zend_class_entry *child_ce) /* {{{ */
2623: {
2624: zend_uint child_flags;
2625: zend_uint parent_flags = parent->common.fn_flags;
2626: zend_function *child;
2627: TSRMLS_FETCH();
2628:
2629: if (zend_hash_quick_find(child_function_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child)==FAILURE) {
2630: if (parent_flags & (ZEND_ACC_ABSTRACT)) {
2631: child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
2632: }
2633: return 1; /* method doesn't exist in child, copy from parent */
2634: }
2635:
2636: if ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
2637: && parent->common.fn_flags & ZEND_ACC_ABSTRACT
2638: && parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope)
2639: && child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) {
2640: zend_error(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)",
2641: parent->common.scope->name,
2642: child->common.function_name,
2643: child->common.prototype ? child->common.prototype->common.scope->name : child->common.scope->name);
2644: }
2645:
2646: if (parent_flags & ZEND_ACC_FINAL) {
2647: zend_error(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name);
2648: }
2649:
2650: child_flags = child->common.fn_flags;
2651: /* You cannot change from static to non static and vice versa.
2652: */
2653: if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) {
2654: if (child->common.fn_flags & ZEND_ACC_STATIC) {
2655: zend_error(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
2656: } else {
2657: zend_error(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
2658: }
2659: }
2660:
2661: /* Disallow making an inherited method abstract. */
2662: if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
2663: zend_error(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
2664: }
2665:
2666: if (parent_flags & ZEND_ACC_CHANGED) {
2667: child->common.fn_flags |= ZEND_ACC_CHANGED;
2668: } else {
2669: /* Prevent derived classes from restricting access that was available in parent classes
2670: */
2671: if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
2672: zend_error(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
2673: } else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
2674: && ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
2675: child->common.fn_flags |= ZEND_ACC_CHANGED;
2676: }
2677: }
2678:
2679: if (parent_flags & ZEND_ACC_PRIVATE) {
2680: child->common.prototype = NULL;
2681: } else if (parent_flags & ZEND_ACC_ABSTRACT) {
2682: child->common.fn_flags |= ZEND_ACC_IMPLEMENTED_ABSTRACT;
2683: child->common.prototype = parent;
2684: } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) {
2685: /* ctors only have a prototype if it comes from an interface */
2686: child->common.prototype = parent->common.prototype ? parent->common.prototype : parent;
2687: }
2688:
2689: if (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) {
2690: if (!zend_do_perform_implementation_check(child, child->common.prototype TSRMLS_CC)) {
2691: zend_error(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with that of %s::%s()", ZEND_FN_SCOPE_NAME(child), child->common.function_name, ZEND_FN_SCOPE_NAME(child->common.prototype), child->common.prototype->common.function_name);
2692: }
2693: } else if (EG(error_reporting) & E_STRICT || EG(user_error_handler)) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
2694: if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) {
2695: zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with that of %s::%s()", ZEND_FN_SCOPE_NAME(child), child->common.function_name, ZEND_FN_SCOPE_NAME(parent), parent->common.function_name);
2696: }
2697: }
2698:
2699: return 0;
2700: }
2701: /* }}} */
2702:
2703: static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, const zend_hash_key *hash_key, zend_class_entry *ce) /* {{{ */
2704: {
2705: zend_property_info *child_info;
2706: zend_class_entry *parent_ce = ce->parent;
2707:
2708: if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) {
2709: if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
2710: child_info->flags |= ZEND_ACC_CHANGED;
2711: } else {
2712: zend_hash_quick_update(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, parent_info, sizeof(zend_property_info), (void **) &child_info);
2713: if(ce->type & ZEND_INTERNAL_CLASS) {
2714: zend_duplicate_property_info_internal(child_info);
2715: } else {
2716: zend_duplicate_property_info(child_info);
2717: }
2718: child_info->flags &= ~ZEND_ACC_PRIVATE; /* it's not private anymore */
2719: child_info->flags |= ZEND_ACC_SHADOW; /* but it's a shadow of private */
2720: }
2721: return 0; /* don't copy access information to child */
2722: }
2723:
2724: if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
2725: if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) {
2726: zend_error(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
2727: (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name, hash_key->arKey,
2728: (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name, hash_key->arKey);
2729:
2730: }
2731:
2732: if(parent_info->flags & ZEND_ACC_CHANGED) {
2733: child_info->flags |= ZEND_ACC_CHANGED;
2734: }
2735:
2736: if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) {
2737: zend_error(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name, hash_key->arKey, zend_visibility_string(parent_info->flags), parent_ce->name, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
2738: } else if (child_info->flags & ZEND_ACC_IMPLICIT_PUBLIC) {
2739: if (!(parent_info->flags & ZEND_ACC_IMPLICIT_PUBLIC)) {
2740: /* Explicitly copy the default value from the parent (if it has one) */
2741: zval **pvalue;
2742:
2743: if (zend_hash_quick_find(&parent_ce->default_properties, parent_info->name, parent_info->name_length+1, parent_info->h, (void **) &pvalue) == SUCCESS) {
2744: Z_ADDREF_PP(pvalue);
2745: zend_hash_quick_del(&ce->default_properties, child_info->name, child_info->name_length+1, parent_info->h);
2746: zend_hash_quick_update(&ce->default_properties, parent_info->name, parent_info->name_length+1, parent_info->h, pvalue, sizeof(zval *), NULL);
2747: }
2748: }
2749: return 1; /* Inherit from the parent */
2750: } else if ((child_info->flags & ZEND_ACC_PUBLIC) && (parent_info->flags & ZEND_ACC_PROTECTED)) {
2751: char *prot_name;
2752: int prot_name_length;
2753:
2754: zend_mangle_property_name(&prot_name, &prot_name_length, "*", 1, child_info->name, child_info->name_length, ce->type & ZEND_INTERNAL_CLASS);
2755: if (child_info->flags & ZEND_ACC_STATIC) {
2756: zval **prop;
2757: HashTable *ht;
2758:
2759: if (parent_ce->type != ce->type) {
2760: /* User class extends internal class */
2761: TSRMLS_FETCH();
2762:
2763: ht = CE_STATIC_MEMBERS(parent_ce);
2764: } else {
2765: ht = &parent_ce->default_static_members;
2766: }
2767: if (zend_hash_find(ht, prot_name, prot_name_length+1, (void**)&prop) == SUCCESS) {
2768: zend_hash_del(&ce->default_static_members, prot_name, prot_name_length+1);
2769: }
2770: } else {
2771: zend_hash_del(&ce->default_properties, prot_name, prot_name_length+1);
2772: }
2773: pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
2774: }
2775: return 0; /* Don't copy from parent */
2776: } else {
2777: return 1; /* Copy from parent */
2778: }
2779: }
2780: /* }}} */
2781:
2782: static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
2783: {
2784: if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce TSRMLS_CC) == FAILURE) {
2785: zend_error(E_CORE_ERROR, "Class %s could not implement interface %s", ce->name, iface->name);
2786: }
2787: if (ce == iface) {
2788: zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name);
2789: }
2790: }
2791: /* }}} */
2792:
2793: ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC) /* {{{ */
2794: {
2795: /* expects interface to be contained in ce's interface list already */
2796: zend_uint i, ce_num, if_num = iface->num_interfaces;
2797: zend_class_entry *entry;
2798:
2799: if (if_num==0) {
2800: return;
2801: }
2802: ce_num = ce->num_interfaces;
2803:
2804: if (ce->type == ZEND_INTERNAL_CLASS) {
2805: ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
2806: } else {
2807: ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
2808: }
2809:
2810: /* Inherit the interfaces, only if they're not already inherited by the class */
2811: while (if_num--) {
2812: entry = iface->interfaces[if_num];
2813: for (i = 0; i < ce_num; i++) {
2814: if (ce->interfaces[i] == entry) {
2815: break;
2816: }
2817: }
2818: if (i == ce_num) {
2819: ce->interfaces[ce->num_interfaces++] = entry;
2820: }
2821: }
2822:
2823: /* and now call the implementing handlers */
2824: while (ce_num < ce->num_interfaces) {
2825: do_implement_interface(ce, ce->interfaces[ce_num++] TSRMLS_CC);
2826: }
2827: }
2828: /* }}} */
2829:
2830: static int inherit_static_prop(zval **p TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */
2831: {
2832: HashTable *target = va_arg(args, HashTable*);
2833:
2834: if (!zend_hash_quick_exists(target, key->arKey, key->nKeyLength, key->h)) {
2835: SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
2836: if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, p, sizeof(zval*), NULL) == SUCCESS) {
2837: Z_ADDREF_PP(p);
2838: }
2839: }
2840: return ZEND_HASH_APPLY_KEEP;
2841: }
2842: /* }}} */
2843:
2844: #define zval_property_ctor(parent_ce, ce) \
2845: ((copy_ctor_func_t) (((parent_ce)->type != (ce)->type) ? zval_shared_property_ctor : zval_add_ref))
2846:
2847: ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
2848: {
2849: if ((ce->ce_flags & ZEND_ACC_INTERFACE)
2850: && !(parent_ce->ce_flags & ZEND_ACC_INTERFACE)) {
2851: zend_error(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name, parent_ce->name);
2852: }
2853: if (parent_ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
2854: zend_error(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name, parent_ce->name);
2855: }
2856:
2857: ce->parent = parent_ce;
2858: /* Copy serialize/unserialize callbacks */
2859: if (!ce->serialize) {
2860: ce->serialize = parent_ce->serialize;
2861: }
2862: if (!ce->unserialize) {
2863: ce->unserialize = parent_ce->unserialize;
2864: }
2865:
2866: /* Inherit interfaces */
2867: zend_do_inherit_interfaces(ce, parent_ce TSRMLS_CC);
2868:
2869: /* Inherit properties */
2870: zend_hash_merge(&ce->default_properties, &parent_ce->default_properties, zval_property_ctor(parent_ce, ce), NULL, sizeof(zval *), 0);
2871: if (parent_ce->type != ce->type) {
2872: /* User class extends internal class */
2873: zend_update_class_constants(parent_ce TSRMLS_CC);
2874: zend_hash_apply_with_arguments(CE_STATIC_MEMBERS(parent_ce) TSRMLS_CC, (apply_func_args_t)inherit_static_prop, 1, &ce->default_static_members);
2875: } else {
2876: zend_hash_apply_with_arguments(&parent_ce->default_static_members TSRMLS_CC, (apply_func_args_t)inherit_static_prop, 1, &ce->default_static_members);
2877: }
2878: zend_hash_merge_ex(&ce->properties_info, &parent_ce->properties_info, (copy_ctor_func_t) (ce->type & ZEND_INTERNAL_CLASS ? zend_duplicate_property_info_internal : zend_duplicate_property_info), sizeof(zend_property_info), (merge_checker_func_t) do_inherit_property_access_check, ce);
2879:
2880: zend_hash_merge(&ce->constants_table, &parent_ce->constants_table, zval_property_ctor(parent_ce, ce), NULL, sizeof(zval *), 0);
2881: zend_hash_merge_ex(&ce->function_table, &parent_ce->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);
2882: do_inherit_parent_constructor(ce);
2883:
2884: if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) {
2885: ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
2886: } else if (!(ce->ce_flags & ZEND_ACC_IMPLEMENT_INTERFACES)) {
2887: /* The verification will be done in runtime by ZEND_VERIFY_ABSTRACT_CLASS */
2888: zend_verify_abstract_class(ce TSRMLS_CC);
2889: }
2890: }
2891: /* }}} */
2892:
2893: static zend_bool do_inherit_constant_check(HashTable *child_constants_table, const zval **parent_constant, const zend_hash_key *hash_key, const zend_class_entry *iface) /* {{{ */
2894: {
2895: zval **old_constant;
2896:
2897: if (zend_hash_quick_find(child_constants_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void**)&old_constant) == SUCCESS) {
2898: if (*old_constant != *parent_constant) {
2899: zend_error(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", hash_key->arKey, iface->name);
2900: }
2901: return 0;
2902: }
2903: return 1;
2904: }
2905: /* }}} */
2906:
2907: static int do_interface_constant_check(zval **val TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */
2908: {
2909: zend_class_entry **iface = va_arg(args, zend_class_entry**);
2910:
2911: do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface);
2912:
2913: return ZEND_HASH_APPLY_KEEP;
2914: }
2915: /* }}} */
2916:
2917: ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
2918: {
2919: zend_uint i, ignore = 0;
2920: zend_uint current_iface_num = ce->num_interfaces;
2921: zend_uint parent_iface_num = ce->parent ? ce->parent->num_interfaces : 0;
2922:
2923: for (i = 0; i < ce->num_interfaces; i++) {
2924: if (ce->interfaces[i] == NULL) {
2925: memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i));
2926: i--;
2927: } else if (ce->interfaces[i] == iface) {
2928: if (i < parent_iface_num) {
2929: ignore = 1;
2930: } else {
2931: zend_error(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name, iface->name);
2932: }
2933: }
2934: }
2935: if (ignore) {
2936: /* Check for attempt to redeclare interface constants */
2937: zend_hash_apply_with_arguments(&ce->constants_table TSRMLS_CC, (apply_func_args_t) do_interface_constant_check, 1, &iface);
2938: } else {
2939: if (ce->num_interfaces >= current_iface_num) {
2940: if (ce->type == ZEND_INTERNAL_CLASS) {
2941: ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
2942: } else {
2943: ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
2944: }
2945: }
2946: ce->interfaces[ce->num_interfaces++] = iface;
2947:
2948: zend_hash_merge_ex(&ce->constants_table, &iface->constants_table, (copy_ctor_func_t) zval_add_ref, sizeof(zval *), (merge_checker_func_t) do_inherit_constant_check, iface);
2949: zend_hash_merge_ex(&ce->function_table, &iface->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);
2950:
2951: do_implement_interface(ce, iface TSRMLS_CC);
2952: zend_do_inherit_interfaces(ce, iface TSRMLS_CC);
2953: }
2954: }
2955: /* }}} */
2956:
2957: ZEND_API int do_bind_function(zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */
2958: {
2959: zend_function *function;
2960:
2961: zend_hash_find(function_table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, (void *) &function);
2962: if (zend_hash_add(function_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, function, sizeof(zend_function), NULL)==FAILURE) {
2963: int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
2964: zend_function *old_function;
2965:
2966: if (zend_hash_find(function_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void *) &old_function)==SUCCESS
2967: && old_function->type == ZEND_USER_FUNCTION
2968: && old_function->op_array.last > 0) {
2969: zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
2970: function->common.function_name,
2971: old_function->op_array.filename,
2972: old_function->op_array.opcodes[0].lineno);
2973: } else {
2974: zend_error(error_level, "Cannot redeclare %s()", function->common.function_name);
2975: }
2976: return FAILURE;
2977: } else {
2978: (*function->op_array.refcount)++;
2979: function->op_array.static_variables = NULL; /* NULL out the unbound function */
2980: return SUCCESS;
2981: }
2982: }
2983: /* }}} */
2984:
2985: ZEND_API zend_class_entry *do_bind_class(const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
2986: {
2987: zend_class_entry *ce, **pce;
2988:
2989: if (zend_hash_find(class_table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, (void **) &pce)==FAILURE) {
2990: zend_error(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", opline->op1.u.constant.value.str.val);
2991: return NULL;
2992: } else {
2993: ce = *pce;
2994: }
2995: ce->refcount++;
2996: if (zend_hash_add(class_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, &ce, sizeof(zend_class_entry *), NULL)==FAILURE) {
2997: ce->refcount--;
2998: if (!compile_time) {
2999: /* If we're in compile time, in practice, it's quite possible
3000: * that we'll never reach this class declaration at runtime,
3001: * so we shut up about it. This allows the if (!defined('FOO')) { return; }
3002: * approach to work.
3003: */
3004: zend_error(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name);
3005: }
3006: return NULL;
3007: } else {
3008: if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES))) {
3009: zend_verify_abstract_class(ce TSRMLS_CC);
3010: }
3011: return ce;
3012: }
3013: }
3014: /* }}} */
3015:
3016: ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
3017: {
3018: zend_class_entry *ce, **pce;
3019: int found_ce;
3020:
3021: found_ce = zend_hash_find(class_table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, (void **) &pce);
3022:
3023: if (found_ce == FAILURE) {
3024: if (!compile_time) {
3025: /* If we're in compile time, in practice, it's quite possible
3026: * that we'll never reach this class declaration at runtime,
3027: * so we shut up about it. This allows the if (!defined('FOO')) { return; }
3028: * approach to work.
3029: */
3030: zend_error(E_COMPILE_ERROR, "Cannot redeclare class %s", opline->op2.u.constant.value.str.val);
3031: }
3032: return NULL;
3033: } else {
3034: ce = *pce;
3035: }
3036:
3037: if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
3038: zend_error(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name, parent_ce->name);
3039: }
3040:
3041: zend_do_inheritance(ce, parent_ce TSRMLS_CC);
3042:
3043: ce->refcount++;
3044:
3045: /* Register the derived class */
3046: if (zend_hash_add(class_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, pce, sizeof(zend_class_entry *), NULL)==FAILURE) {
3047: zend_error(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name);
3048: }
3049: return ce;
3050: }
3051: /* }}} */
3052:
3053: void zend_do_early_binding(TSRMLS_D) /* {{{ */
3054: {
3055: zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
3056: HashTable *table;
3057:
3058: while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
3059: opline--;
3060: }
3061:
3062: switch (opline->opcode) {
3063: case ZEND_DECLARE_FUNCTION:
3064: if (do_bind_function(opline, CG(function_table), 1) == FAILURE) {
3065: return;
3066: }
3067: table = CG(function_table);
3068: break;
3069: case ZEND_DECLARE_CLASS:
3070: if (do_bind_class(opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
3071: return;
3072: }
3073: table = CG(class_table);
3074: break;
3075: case ZEND_DECLARE_INHERITED_CLASS:
3076: {
3077: zend_op *fetch_class_opline = opline-1;
3078: zval *parent_name = &fetch_class_opline->op2.u.constant;
3079: zend_class_entry **pce;
3080:
3081: if ((zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) ||
3082: ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
3083: ((*pce)->type == ZEND_INTERNAL_CLASS))) {
3084: if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
3085: zend_uint *opline_num = &CG(active_op_array)->early_binding;
3086:
3087: while (*opline_num != -1) {
3088: opline_num = &CG(active_op_array)->opcodes[*opline_num].result.u.opline_num;
3089: }
3090: *opline_num = opline - CG(active_op_array)->opcodes;
3091: opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
3092: opline->result.op_type = IS_UNUSED;
3093: opline->result.u.opline_num = -1;
3094: }
3095: return;
3096: }
3097: if (do_bind_inherited_class(opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
3098: return;
3099: }
3100: /* clear unnecessary ZEND_FETCH_CLASS opcode */
3101: zval_dtor(&fetch_class_opline->op2.u.constant);
3102: MAKE_NOP(fetch_class_opline);
3103:
3104: table = CG(class_table);
3105: break;
3106: }
3107: case ZEND_VERIFY_ABSTRACT_CLASS:
3108: case ZEND_ADD_INTERFACE:
3109: /* We currently don't early-bind classes that implement interfaces */
3110: return;
3111: default:
3112: zend_error(E_COMPILE_ERROR, "Invalid binding type");
3113: return;
3114: }
3115:
3116: zend_hash_del(table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len);
3117: zval_dtor(&opline->op1.u.constant);
3118: zval_dtor(&opline->op2.u.constant);
3119: MAKE_NOP(opline);
3120: }
3121: /* }}} */
3122:
3123: ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
3124: {
3125: if (op_array->early_binding != -1) {
3126: zend_bool orig_in_compilation = CG(in_compilation);
3127: zend_uint opline_num = op_array->early_binding;
3128: zend_class_entry **pce;
3129:
3130: CG(in_compilation) = 1;
3131: while (opline_num != -1) {
3132: if (zend_lookup_class(Z_STRVAL(op_array->opcodes[opline_num-1].op2.u.constant), Z_STRLEN(op_array->opcodes[opline_num-1].op2.u.constant), &pce TSRMLS_CC) == SUCCESS) {
3133: do_bind_inherited_class(&op_array->opcodes[opline_num], EG(class_table), *pce, 1 TSRMLS_CC);
3134: }
3135: opline_num = op_array->opcodes[opline_num].result.u.opline_num;
3136: }
3137: CG(in_compilation) = orig_in_compilation;
3138: }
3139: }
3140: /* }}} */
3141:
3142: void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
3143: {
3144: int next_op_number = get_next_op_number(CG(active_op_array));
3145: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3146:
3147: opline->opcode = ZEND_JMPNZ_EX;
3148: if (expr1->op_type == IS_TMP_VAR) {
3149: opline->result = *expr1;
3150: } else {
3151: opline->result.u.var = get_temporary_variable(CG(active_op_array));
3152: opline->result.op_type = IS_TMP_VAR;
3153: }
3154: opline->op1 = *expr1;
3155: SET_UNUSED(opline->op2);
3156:
3157: op_token->u.opline_num = next_op_number;
3158:
3159: *expr1 = opline->result;
3160: }
3161: /* }}} */
3162:
3163: void zend_do_boolean_or_end(znode *result, const znode *expr1, const znode *expr2, znode *op_token TSRMLS_DC) /* {{{ */
3164: {
3165: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3166:
3167: *result = *expr1; /* we saved the original result in expr1 */
3168: opline->opcode = ZEND_BOOL;
3169: opline->result = *result;
3170: opline->op1 = *expr2;
3171: SET_UNUSED(opline->op2);
3172:
3173: CG(active_op_array)->opcodes[op_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
3174: }
3175: /* }}} */
3176:
3177: void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
3178: {
3179: int next_op_number = get_next_op_number(CG(active_op_array));
3180: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3181:
3182: opline->opcode = ZEND_JMPZ_EX;
3183: if (expr1->op_type == IS_TMP_VAR) {
3184: opline->result = *expr1;
3185: } else {
3186: opline->result.u.var = get_temporary_variable(CG(active_op_array));
3187: opline->result.op_type = IS_TMP_VAR;
3188: }
3189: opline->op1 = *expr1;
3190: SET_UNUSED(opline->op2);
3191:
3192: op_token->u.opline_num = next_op_number;
3193:
3194: *expr1 = opline->result;
3195: }
3196: /* }}} */
3197:
3198: void zend_do_boolean_and_end(znode *result, const znode *expr1, const znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
3199: {
3200: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3201:
3202: *result = *expr1; /* we saved the original result in expr1 */
3203: opline->opcode = ZEND_BOOL;
3204: opline->result = *result;
3205: opline->op1 = *expr2;
3206: SET_UNUSED(opline->op2);
3207:
3208: CG(active_op_array)->opcodes[op_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
3209: }
3210: /* }}} */
3211:
3212: void zend_do_do_while_begin(TSRMLS_D) /* {{{ */
3213: {
3214: do_begin_loop(TSRMLS_C);
3215: INC_BPC(CG(active_op_array));
3216: }
3217: /* }}} */
3218:
3219: void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, const znode *expr TSRMLS_DC) /* {{{ */
3220: {
3221: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3222:
3223: opline->opcode = ZEND_JMPNZ;
3224: opline->op1 = *expr;
3225: opline->op2.u.opline_num = do_token->u.opline_num;
3226: SET_UNUSED(opline->op2);
3227:
3228: do_end_loop(expr_open_bracket->u.opline_num, 0 TSRMLS_CC);
3229:
3230: DEC_BPC(CG(active_op_array));
3231: }
3232: /* }}} */
3233:
3234: void zend_do_brk_cont(zend_uchar op, const znode *expr TSRMLS_DC) /* {{{ */
3235: {
3236: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3237:
3238: opline->opcode = op;
3239: opline->op1.u.opline_num = CG(active_op_array)->current_brk_cont;
3240: SET_UNUSED(opline->op1);
3241: if (expr) {
3242: opline->op2 = *expr;
3243: } else {
3244: Z_TYPE(opline->op2.u.constant) = IS_LONG;
3245: Z_LVAL(opline->op2.u.constant) = 1;
3246: INIT_PZVAL(&opline->op2.u.constant);
3247: opline->op2.op_type = IS_CONST;
3248: }
3249: }
3250: /* }}} */
3251:
3252: void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */
3253: {
3254: zend_switch_entry switch_entry;
3255:
3256: switch_entry.cond = *cond;
3257: switch_entry.default_case = -1;
3258: switch_entry.control_var = -1;
3259: zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
3260:
3261: do_begin_loop(TSRMLS_C);
3262:
3263: INC_BPC(CG(active_op_array));
3264: }
3265: /* }}} */
3266:
3267: void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */
3268: {
3269: zend_op *opline;
3270: zend_switch_entry *switch_entry_ptr;
3271:
3272: zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
3273:
3274: /* add code to jmp to default case */
3275: if (switch_entry_ptr->default_case != -1) {
3276: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3277: opline->opcode = ZEND_JMP;
3278: SET_UNUSED(opline->op1);
3279: SET_UNUSED(opline->op2);
3280: opline->op1.u.opline_num = switch_entry_ptr->default_case;
3281: }
3282:
3283: if (case_list->op_type != IS_UNUSED) { /* non-empty switch */
3284: int next_op_number = get_next_op_number(CG(active_op_array));
3285:
3286: CG(active_op_array)->opcodes[case_list->u.opline_num].op1.u.opline_num = next_op_number;
3287: }
3288:
3289: /* remember break/continue loop information */
3290: CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].cont = CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].brk = get_next_op_number(CG(active_op_array));
3291: CG(active_op_array)->current_brk_cont = CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].parent;
3292:
3293: if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) {
3294: /* emit free for the switch condition*/
3295: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3296: opline->opcode = (switch_entry_ptr->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
3297: opline->op1 = switch_entry_ptr->cond;
3298: SET_UNUSED(opline->op2);
3299: }
3300: if (switch_entry_ptr->cond.op_type == IS_CONST) {
3301: zval_dtor(&switch_entry_ptr->cond.u.constant);
3302: }
3303:
3304: zend_stack_del_top(&CG(switch_cond_stack));
3305:
3306: DEC_BPC(CG(active_op_array));
3307: }
3308: /* }}} */
3309:
3310: void zend_do_case_before_statement(const znode *case_list, znode *case_token, const znode *case_expr TSRMLS_DC) /* {{{ */
3311: {
3312: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3313: int next_op_number;
3314: zend_switch_entry *switch_entry_ptr;
3315: znode result;
3316:
3317: zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
3318:
3319: if (switch_entry_ptr->control_var == -1) {
3320: switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array));
3321: }
3322: opline->opcode = ZEND_CASE;
3323: opline->result.u.var = switch_entry_ptr->control_var;
3324: opline->result.op_type = IS_TMP_VAR;
3325: opline->op1 = switch_entry_ptr->cond;
3326: opline->op2 = *case_expr;
3327: if (opline->op1.op_type == IS_CONST) {
3328: zval_copy_ctor(&opline->op1.u.constant);
3329: }
3330: result = opline->result;
3331:
3332: next_op_number = get_next_op_number(CG(active_op_array));
3333: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3334: opline->opcode = ZEND_JMPZ;
3335: opline->op1 = result;
3336: SET_UNUSED(opline->op2);
3337: case_token->u.opline_num = next_op_number;
3338:
3339: if (case_list->op_type==IS_UNUSED) {
3340: return;
3341: }
3342: next_op_number = get_next_op_number(CG(active_op_array));
3343: CG(active_op_array)->opcodes[case_list->u.opline_num].op1.u.opline_num = next_op_number;
3344: }
3345: /* }}} */
3346:
3347: void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */
3348: {
3349: int next_op_number = get_next_op_number(CG(active_op_array));
3350: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3351:
3352: opline->opcode = ZEND_JMP;
3353: SET_UNUSED(opline->op1);
3354: SET_UNUSED(opline->op2);
3355: result->u.opline_num = next_op_number;
3356:
3357: switch (CG(active_op_array)->opcodes[case_token->u.opline_num].opcode) {
3358: case ZEND_JMP:
3359: CG(active_op_array)->opcodes[case_token->u.opline_num].op1.u.opline_num = get_next_op_number(CG(active_op_array));
3360: break;
3361: case ZEND_JMPZ:
3362: CG(active_op_array)->opcodes[case_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
3363: break;
3364: }
3365: }
3366: /* }}} */
3367:
3368: void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */
3369: {
3370: int next_op_number = get_next_op_number(CG(active_op_array));
3371: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3372: zend_switch_entry *switch_entry_ptr;
3373:
3374: zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
3375:
3376: opline->opcode = ZEND_JMP;
3377: SET_UNUSED(opline->op1);
3378: SET_UNUSED(opline->op2);
3379: default_token->u.opline_num = next_op_number;
3380:
3381: next_op_number = get_next_op_number(CG(active_op_array));
3382: switch_entry_ptr->default_case = next_op_number;
3383:
3384: if (case_list->op_type==IS_UNUSED) {
3385: return;
3386: }
3387: CG(active_op_array)->opcodes[case_list->u.opline_num].op1.u.opline_num = next_op_number;
3388: }
3389: /* }}} */
3390:
3391: void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */
3392: {
3393: zend_op *opline;
3394: int doing_inheritance = 0;
3395: zend_class_entry *new_class_entry;
3396: char *lcname;
3397: int error = 0;
3398: zval **ns_name;
3399:
3400: if (CG(active_class_entry)) {
3401: zend_error(E_COMPILE_ERROR, "Class declarations may not be nested");
3402: return;
3403: }
3404:
3405: lcname = zend_str_tolower_dup(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);
3406:
3407: if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) {
3408: efree(lcname);
3409: zend_error(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", class_name->u.constant.value.str.val);
3410: }
3411:
3412: /* Class name must not conflict with import names */
3413: if (CG(current_import) &&
3414: zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
3415: error = 1;
3416: }
3417:
3418: if (CG(current_namespace)) {
3419: /* Prefix class name with name of current namespace */
3420: znode tmp;
3421:
3422: tmp.u.constant = *CG(current_namespace);
3423: zval_copy_ctor(&tmp.u.constant);
3424: zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
3425: class_name = &tmp;
3426: efree(lcname);
3427: lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
3428: }
3429:
3430: if (error) {
3431: char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name));
3432:
3433: if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) ||
3434: memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) {
3435: zend_error(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
3436: }
3437: efree(tmp);
3438: }
3439:
3440: new_class_entry = emalloc(sizeof(zend_class_entry));
3441: new_class_entry->type = ZEND_USER_CLASS;
3442: new_class_entry->name = class_name->u.constant.value.str.val;
3443: new_class_entry->name_length = class_name->u.constant.value.str.len;
3444:
3445: zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC);
3446: new_class_entry->filename = zend_get_compiled_filename(TSRMLS_C);
3447: new_class_entry->line_start = class_token->u.opline_num;
3448: new_class_entry->ce_flags |= class_token->u.EA.type;
3449:
3450: if (parent_class_name && parent_class_name->op_type != IS_UNUSED) {
3451: switch (parent_class_name->u.EA.type) {
3452: case ZEND_FETCH_CLASS_SELF:
3453: zend_error(E_COMPILE_ERROR, "Cannot use 'self' as class name as it is reserved");
3454: break;
3455: case ZEND_FETCH_CLASS_PARENT:
3456: zend_error(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved");
3457: break;
3458: case ZEND_FETCH_CLASS_STATIC:
3459: zend_error(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved");
3460: break;
3461: default:
3462: break;
3463: }
3464: doing_inheritance = 1;
3465: }
3466:
3467: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3468: opline->op1.op_type = IS_CONST;
3469: build_runtime_defined_function_key(&opline->op1.u.constant, lcname, new_class_entry->name_length TSRMLS_CC);
3470:
3471: opline->op2.op_type = IS_CONST;
3472: opline->op2.u.constant.type = IS_STRING;
3473: Z_SET_REFCOUNT(opline->op2.u.constant, 1);
3474:
3475: if (doing_inheritance) {
3476: opline->extended_value = parent_class_name->u.var;
3477: opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
3478: } else {
3479: opline->opcode = ZEND_DECLARE_CLASS;
3480: }
3481:
3482: opline->op2.u.constant.value.str.val = lcname;
3483: opline->op2.u.constant.value.str.len = new_class_entry->name_length;
3484:
3485: zend_hash_update(CG(class_table), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, &new_class_entry, sizeof(zend_class_entry *), NULL);
3486: CG(active_class_entry) = new_class_entry;
3487:
3488: opline->result.u.var = get_temporary_variable(CG(active_op_array));
3489: opline->result.op_type = IS_VAR;
3490: CG(implementing_class) = opline->result;
3491:
3492: if (CG(doc_comment)) {
3493: CG(active_class_entry)->doc_comment = CG(doc_comment);
3494: CG(active_class_entry)->doc_comment_len = CG(doc_comment_len);
3495: CG(doc_comment) = NULL;
3496: CG(doc_comment_len) = 0;
3497: }
3498: }
3499: /* }}} */
3500:
3501: static void do_verify_abstract_class(TSRMLS_D) /* {{{ */
3502: {
3503: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3504:
3505: opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS;
3506: opline->op1 = CG(implementing_class);
3507: SET_UNUSED(opline->op2);
3508: }
3509: /* }}} */
3510:
3511: void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */
3512: {
3513: zend_class_entry *ce = CG(active_class_entry);
3514:
3515: if (ce->constructor) {
3516: ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
3517: if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
3518: zend_error(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name, ce->constructor->common.function_name);
3519: }
3520: }
3521: if (ce->destructor) {
3522: ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
3523: if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
3524: zend_error(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name, ce->destructor->common.function_name);
3525: }
3526: }
3527: if (ce->clone) {
3528: ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
3529: if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
3530: zend_error(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name, ce->clone->common.function_name);
3531: }
3532: }
3533:
3534: ce->line_end = zend_get_compiled_lineno(TSRMLS_C);
3535:
3536: if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
3537: && ((parent_token->op_type != IS_UNUSED) || (ce->num_interfaces > 0))) {
3538: zend_verify_abstract_class(ce TSRMLS_CC);
3539: if (ce->num_interfaces) {
3540: do_verify_abstract_class(TSRMLS_C);
3541: }
3542: }
3543: /* Inherit interfaces; reset number to zero, we need it for above check and
3544: * will restore it during actual implementation.
3545: * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
3546: * zend_verify_abstract_class() */
3547: if (ce->num_interfaces > 0) {
3548: ce->interfaces = NULL;
3549: ce->num_interfaces = 0;
3550: ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES;
3551: }
3552: CG(active_class_entry) = NULL;
3553: }
3554: /* }}} */
3555:
3556: void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */
3557: {
3558: zend_op *opline;
3559:
3560: switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
3561: case ZEND_FETCH_CLASS_SELF:
3562: case ZEND_FETCH_CLASS_PARENT:
3563: case ZEND_FETCH_CLASS_STATIC:
3564: zend_error(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant));
3565: break;
3566: default:
3567: break;
3568: }
3569:
3570: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3571: opline->opcode = ZEND_ADD_INTERFACE;
3572: opline->op1 = CG(implementing_class);
3573: zend_resolve_class_name(interface_name, &opline->extended_value, 0 TSRMLS_CC);
3574: opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE;
3575: opline->op2 = *interface_name;
3576: CG(active_class_entry)->num_interfaces++;
3577: }
3578: /* }}} */
3579:
3580: ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
3581: {
3582: char *prop_name;
3583: int prop_name_length;
3584:
3585: prop_name_length = 1 + src1_length + 1 + src2_length;
3586: prop_name = pemalloc(prop_name_length + 1, internal);
3587: prop_name[0] = '\0';
3588: memcpy(prop_name + 1, src1, src1_length+1);
3589: memcpy(prop_name + 1 + src1_length + 1, src2, src2_length+1);
3590:
3591: *dest = prop_name;
3592: *dest_length = prop_name_length;
3593: }
3594: /* }}} */
3595:
3596: static int zend_strnlen(const char* s, int maxlen) /* {{{ */
3597: {
3598: int len = 0;
3599: while (*s++ && maxlen--) len++;
3600: return len;
3601: }
3602: /* }}} */
3603:
3604: ZEND_API int zend_unmangle_property_name(char *mangled_property, int len, char **class_name, char **prop_name) /* {{{ */
3605: {
3606: int class_name_len;
3607:
3608: *class_name = NULL;
3609:
3610: if (mangled_property[0]!=0) {
3611: *prop_name = mangled_property;
3612: return SUCCESS;
3613: }
3614: if (len < 3 || mangled_property[1]==0) {
3615: zend_error(E_NOTICE, "Illegal member variable name");
3616: *prop_name = mangled_property;
3617: return FAILURE;
3618: }
3619:
3620: class_name_len = zend_strnlen(mangled_property+1, --len - 1) + 1;
3621: if (class_name_len >= len || mangled_property[class_name_len]!=0) {
3622: zend_error(E_NOTICE, "Corrupt member variable name");
3623: *prop_name = mangled_property;
3624: return FAILURE;
3625: }
3626: *class_name = mangled_property+1;
3627: *prop_name = (*class_name)+class_name_len;
3628: return SUCCESS;
3629: }
3630: /* }}} */
3631:
3632: void zend_do_declare_property(const znode *var_name, const znode *value, zend_uint access_type TSRMLS_DC) /* {{{ */
3633: {
3634: zval *property;
3635: zend_property_info *existing_property_info;
3636: char *comment = NULL;
3637: int comment_len = 0;
3638:
3639: if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
3640: zend_error(E_COMPILE_ERROR, "Interfaces may not include member variables");
3641: }
3642:
3643: if (access_type & ZEND_ACC_ABSTRACT) {
3644: zend_error(E_COMPILE_ERROR, "Properties cannot be declared abstract");
3645: }
3646:
3647: if (access_type & ZEND_ACC_FINAL) {
3648: zend_error(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",
3649: CG(active_class_entry)->name, var_name->u.constant.value.str.val);
3650: }
3651:
3652: if (zend_hash_find(&CG(active_class_entry)->properties_info, var_name->u.constant.value.str.val, var_name->u.constant.value.str.len+1, (void **) &existing_property_info)==SUCCESS) {
3653: if (!(existing_property_info->flags & ZEND_ACC_IMPLICIT_PUBLIC)) {
3654: zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, var_name->u.constant.value.str.val);
3655: }
3656: }
3657: ALLOC_ZVAL(property);
3658:
3659: if (value) {
3660: *property = value->u.constant;
3661: } else {
3662: INIT_PZVAL(property);
3663: Z_TYPE_P(property) = IS_NULL;
3664: }
3665:
3666: if (CG(doc_comment)) {
3667: comment = CG(doc_comment);
3668: comment_len = CG(doc_comment_len);
3669: CG(doc_comment) = NULL;
3670: CG(doc_comment_len) = 0;
3671: }
3672:
3673: zend_declare_property_ex(CG(active_class_entry), var_name->u.constant.value.str.val, var_name->u.constant.value.str.len, property, access_type, comment, comment_len TSRMLS_CC);
3674: efree(var_name->u.constant.value.str.val);
3675: }
3676: /* }}} */
3677:
3678: void zend_do_declare_class_constant(znode *var_name, const znode *value TSRMLS_DC) /* {{{ */
3679: {
3680: zval *property;
3681:
3682: if(Z_TYPE(value->u.constant) == IS_CONSTANT_ARRAY) {
3683: zend_error(E_COMPILE_ERROR, "Arrays are not allowed in class constants");
3684: }
3685:
3686: ALLOC_ZVAL(property);
3687: *property = value->u.constant;
3688:
3689: if (zend_hash_add(&CG(active_class_entry)->constants_table, var_name->u.constant.value.str.val, var_name->u.constant.value.str.len+1, &property, sizeof(zval *), NULL)==FAILURE) {
3690: FREE_ZVAL(property);
3691: zend_error(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, var_name->u.constant.value.str.val);
3692: }
3693: FREE_PNODE(var_name);
3694:
3695: if (CG(doc_comment)) {
3696: efree(CG(doc_comment));
3697: CG(doc_comment) = NULL;
3698: CG(doc_comment_len) = 0;
3699: }
3700: }
3701: /* }}} */
3702:
3703: void zend_do_fetch_property(znode *result, znode *object, const znode *property TSRMLS_DC) /* {{{ */
3704: {
3705: zend_op opline;
3706: zend_llist *fetch_list_ptr;
3707:
3708: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
3709:
3710: if (object->op_type == IS_CV) {
3711: if (object->u.var == CG(active_op_array)->this_var) {
3712: SET_UNUSED(*object); /* this means $this for objects */
3713: }
3714: } else if (fetch_list_ptr->count == 1) {
3715: zend_llist_element *le = fetch_list_ptr->head;
3716: zend_op *opline_ptr = (zend_op *) le->data;
3717:
3718: if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
3719: efree(Z_STRVAL(opline_ptr->op1.u.constant));
3720: SET_UNUSED(opline_ptr->op1); /* this means $this for objects */
3721: opline_ptr->op2 = *property;
3722: /* if it was usual fetch, we change it to object fetch */
3723: switch (opline_ptr->opcode) {
3724: case ZEND_FETCH_W:
3725: opline_ptr->opcode = ZEND_FETCH_OBJ_W;
3726: break;
3727: case ZEND_FETCH_R:
3728: opline_ptr->opcode = ZEND_FETCH_OBJ_R;
3729: break;
3730: case ZEND_FETCH_RW:
3731: opline_ptr->opcode = ZEND_FETCH_OBJ_RW;
3732: break;
3733: case ZEND_FETCH_IS:
3734: opline_ptr->opcode = ZEND_FETCH_OBJ_IS;
3735: break;
3736: case ZEND_FETCH_UNSET:
3737: opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET;
3738: break;
3739: case ZEND_FETCH_FUNC_ARG:
3740: opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG;
3741: break;
3742: }
3743: *result = opline_ptr->result;
3744: return;
3745: }
3746: }
3747:
3748: init_op(&opline TSRMLS_CC);
3749: opline.opcode = ZEND_FETCH_OBJ_W; /* the backpatching routine assumes W */
3750: opline.result.op_type = IS_VAR;
3751: opline.result.u.EA.type = 0;
3752: opline.result.u.var = get_temporary_variable(CG(active_op_array));
3753: opline.op1 = *object;
3754: opline.op2 = *property;
3755: *result = opline.result;
3756:
3757: zend_llist_add_element(fetch_list_ptr, &opline);
3758: }
3759: /* }}} */
3760:
3761: void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */
3762: {
3763: char *name, *cfilename;
3764: char haltoff[] = "__COMPILER_HALT_OFFSET__";
3765: int len, clen;
3766:
3767: if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
3768: zend_error(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope");
3769: }
3770:
3771: cfilename = zend_get_compiled_filename(TSRMLS_C);
3772: clen = strlen(cfilename);
3773: zend_mangle_property_name(&name, &len, haltoff, sizeof(haltoff) - 1, cfilename, clen, 0);
3774: zend_register_long_constant(name, len+1, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC);
3775: pefree(name, 0);
3776:
3777: if (CG(in_namespace)) {
3778: zend_do_end_namespace(TSRMLS_C);
3779: }
3780: }
3781: /* }}} */
3782:
3783: void zend_do_declare_implicit_property(TSRMLS_D) /* {{{ */
3784: {
3785: /* Fixes bug #26182. Not sure why we needed to do this in the first place.
3786: Has to be checked with Zeev.
3787: */
3788: #if ANDI_0
3789: zend_op *opline_ptr;
3790: zend_llist_element *le;
3791: zend_llist *fetch_list_ptr;
3792:
3793:
3794: zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
3795:
3796: if (fetch_list_ptr->count != 1) {
3797: return;
3798: }
3799:
3800: le = fetch_list_ptr->head;
3801: opline_ptr = (zend_op *) le->data;
3802:
3803: if (opline_ptr->op1.op_type == IS_UNUSED
3804: && CG(active_class_entry)
3805: && opline_ptr->op2.op_type == IS_CONST
3806: && !zend_hash_exists(&CG(active_class_entry)->properties_info, opline_ptr->op2.u.constant.value.str.val, opline_ptr->op2.u.constant.value.str.len+1)) {
3807: znode property;
3808:
3809: property = opline_ptr->op2;
3810: property.u.constant.value.str.val = estrndup(opline_ptr->op2.u.constant.value.str.val, opline_ptr->op2.u.constant.value.str.len);
3811: zend_do_declare_property(&property, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_IMPLICIT_PUBLIC TSRMLS_CC);
3812: }
3813: #endif
3814: }
3815: /* }}} */
3816:
3817: void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */
3818: {
3819: zend_stack_push(&CG(object_stack), object, sizeof(znode));
3820: }
3821: /* }}} */
3822:
3823: void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */
3824: {
3825: if (object) {
3826: znode *tmp;
3827:
3828: zend_stack_top(&CG(object_stack), (void **) &tmp);
3829: *object = *tmp;
3830: }
3831: zend_stack_del_top(&CG(object_stack));
3832: }
3833: /* }}} */
3834:
3835: void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */
3836: {
3837: zend_op *opline;
3838: unsigned char *ptr = NULL;
3839:
3840: new_token->u.opline_num = get_next_op_number(CG(active_op_array));
3841: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3842: opline->opcode = ZEND_NEW;
3843: opline->result.op_type = IS_VAR;
3844: opline->result.u.var = get_temporary_variable(CG(active_op_array));
3845: opline->op1 = *class_type;
3846: SET_UNUSED(opline->op2);
3847:
3848: zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(unsigned char *));
3849: }
3850: /* }}} */
3851:
3852: void zend_do_end_new_object(znode *result, const znode *new_token, const znode *argument_list TSRMLS_DC) /* {{{ */
3853: {
3854: znode ctor_result;
3855:
3856: zend_do_end_function_call(NULL, &ctor_result, argument_list, 1, 0 TSRMLS_CC);
3857: zend_do_free(&ctor_result TSRMLS_CC);
3858:
3859: CG(active_op_array)->opcodes[new_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
3860: *result = CG(active_op_array)->opcodes[new_token->u.opline_num].result;
3861: }
3862: /* }}} */
3863:
3864: static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
3865: {
3866: zend_constant *c = NULL;
3867:
3868: if (Z_STRVAL_P(const_name)[0] == '\\') {
3869: if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name), (void **) &c) == FAILURE) {
3870: char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
3871:
3872: if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name), (void **) &c)==SUCCESS) {
3873: if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
3874: efree(lookup_name);
3875: return c;
3876: }
3877: }
3878: efree(lookup_name);
3879: return NULL;
3880: }
3881: } else if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)+1, (void **) &c) == FAILURE) {
3882: char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
3883:
3884: if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)+1, (void **) &c)==SUCCESS) {
3885: if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
3886: efree(lookup_name);
3887: return c;
3888: }
3889: }
3890: efree(lookup_name);
3891: return NULL;
3892: }
3893: if (c->flags & CONST_CT_SUBST) {
3894: return c;
3895: }
3896: if (all_internal_constants_substitution &&
3897: (c->flags & CONST_PERSISTENT) &&
3898: !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
3899: Z_TYPE(c->value) != IS_CONSTANT &&
3900: Z_TYPE(c->value) != IS_CONSTANT_ARRAY) {
3901: return c;
3902: }
3903: return NULL;
3904: }
3905: /* }}} */
3906:
3907: static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
3908: {
3909: zend_constant *c = zend_get_ct_const(const_name, all_internal_constants_substitution TSRMLS_CC);
3910:
3911: if (c) {
3912: zval_dtor(const_name);
3913: result->op_type = IS_CONST;
3914: result->u.constant = c->value;
3915: zval_copy_ctor(&result->u.constant);
3916: INIT_PZVAL(&result->u.constant);
3917: return 1;
3918: }
3919: return 0;
3920: }
3921: /* }}} */
3922:
3923: void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */
3924: {
3925: znode tmp;
3926: zend_op *opline;
3927: int type;
3928: char *compound;
3929: ulong fetch_type = 0;
3930:
3931: if (constant_container) {
3932: switch (mode) {
3933: case ZEND_CT:
3934: /* this is a class constant */
3935: type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
3936:
3937: if (ZEND_FETCH_CLASS_STATIC == type) {
3938: zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants");
3939: } else if (ZEND_FETCH_CLASS_DEFAULT == type) {
3940: zend_resolve_class_name(constant_container, &fetch_type, 1 TSRMLS_CC);
3941: }
3942: zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
3943: *result = *constant_container;
3944: result->u.constant.type = IS_CONSTANT | fetch_type;
3945: break;
3946: case ZEND_RT:
3947: if (constant_container->op_type == IS_CONST &&
3948: ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) {
3949: zend_resolve_class_name(constant_container, &fetch_type, 1 TSRMLS_CC);
3950: } else {
3951: zend_do_fetch_class(&tmp, constant_container TSRMLS_CC);
3952: constant_container = &tmp;
3953: }
3954: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3955: opline->opcode = ZEND_FETCH_CONSTANT;
3956: opline->result.op_type = IS_TMP_VAR;
3957: opline->result.u.var = get_temporary_variable(CG(active_op_array));
3958: opline->op1 = *constant_container;
3959: opline->op2 = *constant_name;
3960: *result = opline->result;
3961: break;
3962: }
3963: return;
3964: }
3965: /* namespace constant */
3966: /* only one that did not contain \ from the start can be converted to string if unknown */
3967: switch (mode) {
3968: case ZEND_CT:
3969: compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
3970: /* this is a namespace constant, or an unprefixed constant */
3971:
3972: if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
3973: break;
3974: }
3975:
3976: zend_resolve_non_class_name(constant_name, check_namespace TSRMLS_CC);
3977:
3978: if(!compound) {
3979: fetch_type |= IS_CONSTANT_UNQUALIFIED;
3980: }
3981:
3982: *result = *constant_name;
3983: result->u.constant.type = IS_CONSTANT | fetch_type;
3984: break;
3985: case ZEND_RT:
3986: compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
3987:
3988: zend_resolve_non_class_name(constant_name, check_namespace TSRMLS_CC);
3989:
3990: if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
3991: break;
3992: }
3993:
3994: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3995: opline->opcode = ZEND_FETCH_CONSTANT;
3996: opline->result.op_type = IS_TMP_VAR;
3997: opline->result.u.var = get_temporary_variable(CG(active_op_array));
3998: *result = opline->result;
3999: SET_UNUSED(opline->op1);
4000: if(compound) {
4001: /* the name is unambiguous */
4002: opline->extended_value = 0;
4003: } else {
4004: opline->extended_value = IS_CONSTANT_UNQUALIFIED;
4005: }
4006: opline->op2 = *constant_name;
4007: break;
4008: }
4009: }
4010: /* }}} */
4011:
4012: void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC) /* {{{ */
4013: {
4014: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4015:
4016: switch (cmd->op_type) {
4017: case IS_CONST:
4018: case IS_TMP_VAR:
4019: opline->opcode = ZEND_SEND_VAL;
4020: break;
4021: default:
4022: opline->opcode = ZEND_SEND_VAR;
4023: break;
4024: }
4025: opline->op1 = *cmd;
4026: opline->op2.u.opline_num = 0;
4027: opline->extended_value = ZEND_DO_FCALL;
4028: SET_UNUSED(opline->op2);
4029:
4030: /* FIXME: exception support not added to this op2 */
4031: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4032: opline->opcode = ZEND_DO_FCALL;
4033: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4034: opline->result.op_type = IS_VAR;
4035: Z_STRVAL(opline->op1.u.constant) = estrndup("shell_exec", sizeof("shell_exec")-1);
4036: Z_STRLEN(opline->op1.u.constant) = sizeof("shell_exec")-1;
4037: INIT_PZVAL(&opline->op1.u.constant);
4038: Z_TYPE(opline->op1.u.constant) = IS_STRING;
4039: opline->op1.op_type = IS_CONST;
4040: opline->extended_value = 1;
4041: SET_UNUSED(opline->op2);
4042: ZVAL_LONG(&opline->op2.u.constant, zend_hash_func("shell_exec", sizeof("shell_exec")));
4043: *result = opline->result;
4044: }
4045: /* }}} */
4046:
4047: void zend_do_init_array(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
4048: {
4049: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4050:
4051: opline->opcode = ZEND_INIT_ARRAY;
4052: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4053: opline->result.op_type = IS_TMP_VAR;
4054: *result = opline->result;
4055: if (expr) {
4056: opline->op1 = *expr;
4057: if (offset) {
4058: opline->op2 = *offset;
4059: } else {
4060: SET_UNUSED(opline->op2);
4061: }
4062: } else {
4063: SET_UNUSED(opline->op1);
4064: SET_UNUSED(opline->op2);
4065: }
4066: opline->extended_value = is_ref;
4067: }
4068: /* }}} */
4069:
4070: void zend_do_add_array_element(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
4071: {
4072: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4073:
4074: opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
4075: opline->result = *result;
4076: opline->op1 = *expr;
4077: if (offset) {
4078: opline->op2 = *offset;
4079: } else {
4080: SET_UNUSED(opline->op2);
4081: }
4082: opline->extended_value = is_ref;
4083: }
4084: /* }}} */
4085:
4086: void zend_do_add_static_array_element(znode *result, znode *offset, const znode *expr) /* {{{ */
4087: {
4088: zval *element;
4089:
4090: ALLOC_ZVAL(element);
4091: *element = expr->u.constant;
4092: if (offset) {
4093: switch (offset->u.constant.type & IS_CONSTANT_TYPE_MASK) {
4094: case IS_CONSTANT:
4095: /* Ugly hack to denote that this value has a constant index */
4096: Z_TYPE_P(element) |= IS_CONSTANT_INDEX;
4097: Z_STRVAL(offset->u.constant) = erealloc(Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3);
4098: Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+1] = Z_TYPE(offset->u.constant);
4099: Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+2] = 0;
4100: zend_symtable_update(result->u.constant.value.ht, Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3, &element, sizeof(zval *), NULL);
4101: zval_dtor(&offset->u.constant);
4102: break;
4103: case IS_STRING:
4104: zend_symtable_update(result->u.constant.value.ht, offset->u.constant.value.str.val, offset->u.constant.value.str.len+1, &element, sizeof(zval *), NULL);
4105: zval_dtor(&offset->u.constant);
4106: break;
4107: case IS_NULL:
4108: zend_symtable_update(Z_ARRVAL(result->u.constant), "", 1, &element, sizeof(zval *), NULL);
4109: break;
4110: case IS_LONG:
4111: case IS_BOOL:
4112: zend_hash_index_update(Z_ARRVAL(result->u.constant), Z_LVAL(offset->u.constant), &element, sizeof(zval *), NULL);
4113: break;
4114: case IS_DOUBLE:
4115: zend_hash_index_update(Z_ARRVAL(result->u.constant), zend_dval_to_lval(Z_DVAL(offset->u.constant)), &element, sizeof(zval *), NULL);
4116: break;
4117: case IS_CONSTANT_ARRAY:
4118: zend_error(E_ERROR, "Illegal offset type");
4119: break;
4120: }
4121: } else {
4122: zend_hash_next_index_insert(Z_ARRVAL(result->u.constant), &element, sizeof(zval *), NULL);
4123: }
4124: }
4125: /* }}} */
4126:
4127: void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */
4128: {
4129: list_llist_element lle;
4130:
4131: if (element) {
4132: zend_check_writable_variable(element);
4133:
4134: lle.var = *element;
4135: zend_llist_copy(&lle.dimensions, &CG(dimension_llist));
4136: zend_llist_prepend_element(&CG(list_llist), &lle);
4137: }
4138: (*((int *)CG(dimension_llist).tail->data))++;
4139: }
4140: /* }}} */
4141:
4142: void zend_do_new_list_begin(TSRMLS_D) /* {{{ */
4143: {
4144: int current_dimension = 0;
4145: zend_llist_add_element(&CG(dimension_llist), ¤t_dimension);
4146: }
4147: /* }}} */
4148:
4149: void zend_do_new_list_end(TSRMLS_D) /* {{{ */
4150: {
4151: zend_llist_remove_tail(&CG(dimension_llist));
4152: (*((int *)CG(dimension_llist).tail->data))++;
4153: }
4154: /* }}} */
4155:
4156: void zend_do_list_init(TSRMLS_D) /* {{{ */
4157: {
4158: zend_stack_push(&CG(list_stack), &CG(list_llist), sizeof(zend_llist));
4159: zend_stack_push(&CG(list_stack), &CG(dimension_llist), sizeof(zend_llist));
4160: zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
4161: zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
4162: zend_do_new_list_begin(TSRMLS_C);
4163: }
4164: /* }}} */
4165:
4166: void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */
4167: {
4168: zend_llist_element *le;
4169: zend_llist_element *dimension;
4170: zend_op *opline;
4171: znode last_container;
4172:
4173: le = CG(list_llist).head;
4174: while (le) {
4175: zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions;
4176: dimension = tmp_dimension_llist->head;
4177: while (dimension) {
4178: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4179: if (dimension == tmp_dimension_llist->head) { /* first */
4180: last_container = *expr;
4181: switch (expr->op_type) {
4182: case IS_VAR:
4183: case IS_CV:
4184: opline->opcode = ZEND_FETCH_DIM_R;
4185: break;
4186: case IS_TMP_VAR:
4187: opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
4188: break;
4189: case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */
4190: zval_copy_ctor(&expr->u.constant);
4191: opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
4192: break;
4193: }
4194: opline->extended_value = ZEND_FETCH_ADD_LOCK;
4195: } else {
4196: opline->opcode = ZEND_FETCH_DIM_R;
4197: }
4198: opline->result.op_type = IS_VAR;
4199: opline->result.u.EA.type = 0;
4200: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4201: opline->op1 = last_container;
4202: opline->op2.op_type = IS_CONST;
4203: Z_TYPE(opline->op2.u.constant) = IS_LONG;
4204: Z_LVAL(opline->op2.u.constant) = *((int *) dimension->data);
4205: INIT_PZVAL(&opline->op2.u.constant);
4206: last_container = opline->result;
4207: dimension = dimension->next;
4208: }
4209: ((list_llist_element *) le->data)->value = last_container;
4210: zend_llist_destroy(&((list_llist_element *) le->data)->dimensions);
4211: zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC);
4212: zend_do_free(result TSRMLS_CC);
4213: le = le->next;
4214: }
4215: zend_llist_destroy(&CG(dimension_llist));
4216: zend_llist_destroy(&CG(list_llist));
4217: *result = *expr;
4218: {
4219: zend_llist *p;
4220:
4221: /* restore previous lists */
4222: zend_stack_top(&CG(list_stack), (void **) &p);
4223: CG(dimension_llist) = *p;
4224: zend_stack_del_top(&CG(list_stack));
4225: zend_stack_top(&CG(list_stack), (void **) &p);
4226: CG(list_llist) = *p;
4227: zend_stack_del_top(&CG(list_stack));
4228: }
4229: }
4230: /* }}} */
4231:
4232: void zend_do_fetch_static_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
4233: {
4234: zval *tmp;
4235: zend_op *opline;
4236: znode lval;
4237: znode result;
4238:
4239: ALLOC_ZVAL(tmp);
4240:
4241: if (static_assignment) {
4242: *tmp = static_assignment->u.constant;
4243: } else {
4244: INIT_ZVAL(*tmp);
4245: }
4246: if (!CG(active_op_array)->static_variables) {
4247: ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
4248: zend_hash_init(CG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0);
4249: }
4250: zend_hash_update(CG(active_op_array)->static_variables, varname->u.constant.value.str.val, varname->u.constant.value.str.len+1, &tmp, sizeof(zval *), NULL);
4251:
4252: if (varname->op_type == IS_CONST) {
4253: if (Z_TYPE(varname->u.constant) != IS_STRING) {
4254: convert_to_string(&varname->u.constant);
4255: }
4256: }
4257:
4258: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4259: opline->opcode = (fetch_type == ZEND_FETCH_LEXICAL) ? ZEND_FETCH_R : ZEND_FETCH_W; /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
4260: opline->result.op_type = IS_VAR;
4261: opline->result.u.EA.type = 0;
4262: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4263: opline->op1 = *varname;
4264: SET_UNUSED(opline->op2);
4265: opline->op2.u.EA.type = ZEND_FETCH_STATIC;
4266: result = opline->result;
4267:
4268: if (varname->op_type == IS_CONST) {
4269: zval_copy_ctor(&varname->u.constant);
4270: }
4271: fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
4272:
4273: if (fetch_type == ZEND_FETCH_LEXICAL) {
4274: znode dummy;
4275:
4276: zend_do_begin_variable_parse(TSRMLS_C);
4277: zend_do_assign(&dummy, &lval, &result TSRMLS_CC);
4278: zend_do_free(&dummy TSRMLS_CC);
4279: } else {
4280: zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
4281: }
4282: CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
4283:
4284: /* zval_dtor(&varname->u.constant); */
4285: }
4286: /* }}} */
4287:
4288: void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) /* {{{ */
4289: {
4290: znode value;
4291:
4292: if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 &&
4293: memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) {
4294: zend_error(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
4295: return;
4296: }
4297:
4298: value.op_type = IS_CONST;
4299: ZVAL_NULL(&value.u.constant);
4300: Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
4301: Z_SET_REFCOUNT_P(&value.u.constant, 1);
4302: Z_UNSET_ISREF_P(&value.u.constant);
4303:
4304: zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC);
4305: }
4306: /* }}} */
4307:
4308: void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
4309: {
4310: zend_op *opline;
4311: znode lval;
4312: znode result;
4313:
4314: if (varname->op_type == IS_CONST) {
4315: if (Z_TYPE(varname->u.constant) != IS_STRING) {
4316: convert_to_string(&varname->u.constant);
4317: }
4318: }
4319:
4320: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4321: opline->opcode = ZEND_FETCH_W; /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
4322: opline->result.op_type = IS_VAR;
4323: opline->result.u.EA.type = 0;
4324: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4325: opline->op1 = *varname;
4326: SET_UNUSED(opline->op2);
4327: opline->op2.u.EA.type = fetch_type;
4328: result = opline->result;
4329:
4330: if (varname->op_type == IS_CONST) {
4331: zval_copy_ctor(&varname->u.constant);
4332: }
4333: fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
4334:
4335: zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
4336: CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
4337: }
4338: /* }}} */
4339:
4340: void zend_do_cast(znode *result, const znode *expr, int type TSRMLS_DC) /* {{{ */
4341: {
4342: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4343:
4344: opline->opcode = ZEND_CAST;
4345: opline->result.op_type = IS_TMP_VAR;
4346: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4347: opline->op1 = *expr;
4348: SET_UNUSED(opline->op2);
4349: opline->extended_value = type;
4350: *result = opline->result;
4351: }
4352: /* }}} */
4353:
4354: void zend_do_include_or_eval(int type, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
4355: {
4356: zend_do_extended_fcall_begin(TSRMLS_C);
4357: {
4358: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4359:
4360: opline->opcode = ZEND_INCLUDE_OR_EVAL;
4361: opline->result.op_type = IS_VAR;
4362: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4363: opline->op1 = *op1;
4364: SET_UNUSED(opline->op2);
4365: Z_LVAL(opline->op2.u.constant) = type;
4366: *result = opline->result;
4367: }
4368: zend_do_extended_fcall_end(TSRMLS_C);
4369: }
4370: /* }}} */
4371:
4372: void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */
4373: {
4374: int i;
4375:
4376: zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC);
4377: for (i=1; i<num_references->u.constant.value.lval; i++) {
4378: fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
4379: *variable = *result;
4380: }
4381: zend_do_begin_variable_parse(TSRMLS_C);
4382: fetch_simple_variable(result, variable, 1 TSRMLS_CC);
4383: /* there is a chance someone is accessing $this */
4384: if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) {
4385: CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1);
4386: }
4387: }
4388: /* }}} */
4389:
4390: void zend_do_unset(const znode *variable TSRMLS_DC) /* {{{ */
4391: {
4392: zend_op *last_op;
4393:
4394: zend_check_writable_variable(variable);
4395:
4396: if (variable->op_type == IS_CV) {
4397: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4398: opline->opcode = ZEND_UNSET_VAR;
4399: opline->op1 = *variable;
4400: SET_UNUSED(opline->op2);
4401: opline->op2.u.EA.type = ZEND_FETCH_LOCAL;
4402: SET_UNUSED(opline->result);
4403: opline->extended_value = ZEND_QUICK_SET;
4404: } else {
4405: last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
4406:
4407: switch (last_op->opcode) {
4408: case ZEND_FETCH_UNSET:
4409: last_op->opcode = ZEND_UNSET_VAR;
4410: break;
4411: case ZEND_FETCH_DIM_UNSET:
4412: last_op->opcode = ZEND_UNSET_DIM;
4413: break;
4414: case ZEND_FETCH_OBJ_UNSET:
4415: last_op->opcode = ZEND_UNSET_OBJ;
4416: break;
4417:
4418: }
4419: }
4420: }
4421: /* }}} */
4422:
4423: void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */
4424: {
4425: zend_op *last_op;
4426:
4427: zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC);
4428:
4429: zend_check_writable_variable(variable);
4430:
4431: if (variable->op_type == IS_CV) {
4432: last_op = get_next_op(CG(active_op_array) TSRMLS_CC);
4433: last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
4434: last_op->op1 = *variable;
4435: SET_UNUSED(last_op->op2);
4436: last_op->op2.u.EA.type = ZEND_FETCH_LOCAL;
4437: last_op->result.u.var = get_temporary_variable(CG(active_op_array));
4438: last_op->extended_value = ZEND_QUICK_SET;
4439: } else {
4440: last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
4441:
4442: switch (last_op->opcode) {
4443: case ZEND_FETCH_IS:
4444: last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
4445: break;
4446: case ZEND_FETCH_DIM_IS:
4447: last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
4448: break;
4449: case ZEND_FETCH_OBJ_IS:
4450: last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
4451: break;
4452: }
4453: last_op->extended_value = 0;
4454: }
4455: last_op->result.op_type = IS_TMP_VAR;
4456: last_op->extended_value |= type;
4457:
4458: *result = last_op->result;
4459: }
4460: /* }}} */
4461:
4462: void zend_do_instanceof(znode *result, const znode *expr, const znode *class_znode, int type TSRMLS_DC) /* {{{ */
4463: {
4464: int last_op_number = get_next_op_number(CG(active_op_array));
4465: zend_op *opline;
4466:
4467: if (last_op_number > 0) {
4468: opline = &CG(active_op_array)->opcodes[last_op_number-1];
4469: if (opline->opcode == ZEND_FETCH_CLASS) {
4470: opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
4471: }
4472: }
4473:
4474: if (expr->op_type == IS_CONST) {
4475: zend_error(E_COMPILE_ERROR, "instanceof expects an object instance, constant given");
4476: }
4477:
4478: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4479: opline->opcode = ZEND_INSTANCEOF;
4480: opline->result.op_type = IS_TMP_VAR;
4481: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4482: opline->op1 = *expr;
4483:
4484: opline->op2 = *class_znode;
4485:
4486: *result = opline->result;
4487: }
4488: /* }}} */
4489:
4490: void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */
4491: {
4492: zend_op *opline;
4493: zend_bool is_variable;
4494: zend_bool push_container = 0;
4495: zend_op dummy_opline;
4496:
4497: if (variable) {
4498: if (zend_is_function_or_method_call(array)) {
4499: is_variable = 0;
4500: } else {
4501: is_variable = 1;
4502: }
4503: /* save the location of FETCH_W instruction(s) */
4504: open_brackets_token->u.opline_num = get_next_op_number(CG(active_op_array));
4505: zend_do_end_variable_parse(array, BP_VAR_W, 0 TSRMLS_CC);
4506: if (CG(active_op_array)->last > 0 &&
4507: CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode == ZEND_FETCH_OBJ_W) {
4508: /* Only lock the container if we are fetching from a real container and not $this */
4509: if (CG(active_op_array)->opcodes[CG(active_op_array)->last-1].op1.op_type == IS_VAR) {
4510: CG(active_op_array)->opcodes[CG(active_op_array)->last-1].extended_value |= ZEND_FETCH_ADD_LOCK;
4511: push_container = 1;
4512: }
4513: }
4514: } else {
4515: is_variable = 0;
4516: open_brackets_token->u.opline_num = get_next_op_number(CG(active_op_array));
4517: }
4518:
4519: /* save the location of FE_RESET */
4520: foreach_token->u.opline_num = get_next_op_number(CG(active_op_array));
4521:
4522: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4523:
4524: /* Preform array reset */
4525: opline->opcode = ZEND_FE_RESET;
4526: opline->result.op_type = IS_VAR;
4527: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4528: opline->op1 = *array;
4529: SET_UNUSED(opline->op2);
4530: opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0;
4531:
4532: dummy_opline.result = opline->result;
4533: if (push_container) {
4534: dummy_opline.op1 = CG(active_op_array)->opcodes[CG(active_op_array)->last-2].op1;
4535: } else {
4536: znode tmp;
4537:
4538: tmp.op_type = IS_UNUSED;
4539: dummy_opline.op1 = tmp;
4540: }
4541: zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline, sizeof(zend_op));
4542:
4543: /* save the location of FE_FETCH */
4544: as_token->u.opline_num = get_next_op_number(CG(active_op_array));
4545:
4546: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4547: opline->opcode = ZEND_FE_FETCH;
4548: opline->result.op_type = IS_VAR;
4549: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4550: opline->op1 = dummy_opline.result;
4551: opline->extended_value = 0;
4552: SET_UNUSED(opline->op2);
4553:
4554: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4555: opline->opcode = ZEND_OP_DATA;
4556: SET_UNUSED(opline->op1);
4557: SET_UNUSED(opline->op2);
4558: SET_UNUSED(opline->result);
4559: }
4560: /* }}} */
4561:
4562: void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */
4563: {
4564: zend_op *opline;
4565: znode dummy, value_node;
4566: zend_bool assign_by_ref=0;
4567:
4568: opline = &CG(active_op_array)->opcodes[as_token->u.opline_num];
4569: if (key->op_type != IS_UNUSED) {
4570: znode *tmp;
4571:
4572: /* switch between the key and value... */
4573: tmp = key;
4574: key = value;
4575: value = tmp;
4576:
4577: /* Mark extended_value in case both key and value are being used */
4578: opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
4579: }
4580:
4581: if ((key->op_type != IS_UNUSED) && (key->u.EA.type & ZEND_PARSED_REFERENCE_VARIABLE)) {
4582: zend_error(E_COMPILE_ERROR, "Key element cannot be a reference");
4583: }
4584:
4585: if (value->u.EA.type & ZEND_PARSED_REFERENCE_VARIABLE) {
4586: assign_by_ref = 1;
4587: if (!(opline-1)->extended_value) {
4588: zend_error(E_COMPILE_ERROR, "Cannot create references to elements of a temporary array expression");
4589: }
4590: /* Mark extended_value for assign-by-reference */
4591: opline->extended_value |= ZEND_FE_FETCH_BYREF;
4592: CG(active_op_array)->opcodes[foreach_token->u.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE;
4593: } else {
4594: zend_op *foreach_copy;
4595: zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.opline_num];
4596: zend_op *end = &CG(active_op_array)->opcodes[open_brackets_token->u.opline_num];
4597:
4598: /* Change "write context" into "read context" */
4599: fetch->extended_value = 0; /* reset ZEND_FE_RESET_VARIABLE */
4600: while (fetch != end) {
4601: --fetch;
4602: if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2.op_type == IS_UNUSED) {
4603: zend_error(E_COMPILE_ERROR, "Cannot use [] for reading");
4604: }
4605: fetch->opcode -= 3; /* FETCH_W -> FETCH_R */
4606: }
4607: /* prevent double SWITCH_FREE */
4608: zend_stack_top(&CG(foreach_copy_stack), (void **) &foreach_copy);
4609: foreach_copy->op1.op_type = IS_UNUSED;
4610: }
4611:
4612: value_node = opline->result;
4613:
4614: if (assign_by_ref) {
4615: zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC);
4616: /* Mark FE_FETCH as IS_VAR as it holds the data directly as a value */
4617: zend_do_assign_ref(NULL, value, &value_node TSRMLS_CC);
4618: } else {
4619: zend_do_assign(&dummy, value, &value_node TSRMLS_CC);
4620: zend_do_free(&dummy TSRMLS_CC);
4621: }
4622:
4623: if (key->op_type != IS_UNUSED) {
4624: znode key_node;
4625:
4626: opline = &CG(active_op_array)->opcodes[as_token->u.opline_num+1];
4627: opline->result.op_type = IS_TMP_VAR;
4628: opline->result.u.EA.type = 0;
4629: opline->result.u.opline_num = get_temporary_variable(CG(active_op_array));
4630: key_node = opline->result;
4631:
4632: zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
4633: zend_do_free(&dummy TSRMLS_CC);
4634: }
4635:
4636: do_begin_loop(TSRMLS_C);
4637: INC_BPC(CG(active_op_array));
4638: }
4639: /* }}} */
4640:
4641: void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */
4642: {
4643: zend_op *container_ptr;
4644: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4645:
4646: opline->opcode = ZEND_JMP;
4647: opline->op1.u.opline_num = as_token->u.opline_num;
4648: SET_UNUSED(opline->op1);
4649: SET_UNUSED(opline->op2);
4650:
4651: CG(active_op_array)->opcodes[foreach_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */
4652: CG(active_op_array)->opcodes[as_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */
4653:
4654: do_end_loop(as_token->u.opline_num, 1 TSRMLS_CC);
4655:
4656: zend_stack_top(&CG(foreach_copy_stack), (void **) &container_ptr);
4657: generate_free_foreach_copy(container_ptr TSRMLS_CC);
4658: zend_stack_del_top(&CG(foreach_copy_stack));
4659:
4660: DEC_BPC(CG(active_op_array));
4661: }
4662: /* }}} */
4663:
4664: void zend_do_declare_begin(TSRMLS_D) /* {{{ */
4665: {
4666: zend_stack_push(&CG(declare_stack), &CG(declarables), sizeof(zend_declarables));
4667: }
4668: /* }}} */
4669:
4670: void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
4671: {
4672: if (!zend_binary_strcasecmp(var->u.constant.value.str.val, var->u.constant.value.str.len, "ticks", sizeof("ticks")-1)) {
4673: convert_to_long(&val->u.constant);
4674: CG(declarables).ticks = val->u.constant;
4675: #ifdef ZEND_MULTIBYTE
4676: } else if (!zend_binary_strcasecmp(var->u.constant.value.str.val, var->u.constant.value.str.len, "encoding", sizeof("encoding")-1)) {
4677: zend_encoding *new_encoding, *old_encoding;
4678: zend_encoding_filter old_input_filter;
4679:
4680: if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
4681: zend_error(E_COMPILE_ERROR, "Cannot use constants as encoding");
4682: }
4683:
4684: /*
4685: * Check that the pragma comes before any opcodes. If the compilation
4686: * got as far as this, the previous portion of the script must have been
4687: * parseable according to the .ini script_encoding setting. We still
4688: * want to tell them to put declare() at the top.
4689: */
4690: {
4691: int num = CG(active_op_array)->last;
4692: /* ignore ZEND_EXT_STMT and ZEND_TICKS */
4693: while (num > 0 &&
4694: (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
4695: CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
4696: --num;
4697: }
4698:
4699: if (num > 0) {
4700: zend_error(E_COMPILE_ERROR, "Encoding declaration pragma must be the very first statement in the script");
4701: }
4702: }
4703: CG(encoding_declared) = 1;
4704:
4705: convert_to_string(&val->u.constant);
4706: new_encoding = zend_multibyte_fetch_encoding(val->u.constant.value.str.val);
4707: if (!new_encoding) {
4708: zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", val->u.constant.value.str.val);
4709: } else {
4710: old_input_filter = LANG_SCNG(input_filter);
4711: old_encoding = LANG_SCNG(script_encoding);
4712: zend_multibyte_set_filter(new_encoding TSRMLS_CC);
4713:
4714: /* need to re-scan if input filter changed */
4715: if (old_input_filter != LANG_SCNG(input_filter) ||
4716: ((old_input_filter == zend_multibyte_script_encoding_filter) &&
4717: (new_encoding != old_encoding))) {
4718: zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
4719: }
4720: }
4721: efree(val->u.constant.value.str.val);
4722: #else /* !ZEND_MULTIBYTE */
4723: } else if (!zend_binary_strcasecmp(var->u.constant.value.str.val, var->u.constant.value.str.len, "encoding", sizeof("encoding")-1)) {
4724: /* Do not generate any kind of warning for encoding declares */
4725: /* zend_error(E_COMPILE_WARNING, "Declare encoding [%s] not supported", val->u.constant.value.str.val); */
4726: zval_dtor(&val->u.constant);
4727: #endif /* ZEND_MULTIBYTE */
4728: } else {
4729: zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", var->u.constant.value.str.val);
4730: zval_dtor(&val->u.constant);
4731: }
4732: zval_dtor(&var->u.constant);
4733: }
4734: /* }}} */
4735:
4736: void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */
4737: {
4738: zend_declarables *declarables;
4739:
4740: zend_stack_top(&CG(declare_stack), (void **) &declarables);
4741: /* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */
4742: if ((get_next_op_number(CG(active_op_array)) - declare_token->u.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) {
4743: CG(declarables) = *declarables;
4744: }
4745: }
4746: /* }}} */
4747:
4748: void zend_do_exit(znode *result, const znode *message TSRMLS_DC) /* {{{ */
4749: {
4750: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4751:
4752: opline->opcode = ZEND_EXIT;
4753: opline->op1 = *message;
4754: SET_UNUSED(opline->op2);
4755:
4756: result->op_type = IS_CONST;
4757: Z_TYPE(result->u.constant) = IS_BOOL;
4758: Z_LVAL(result->u.constant) = 1;
4759: }
4760: /* }}} */
4761:
4762: void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
4763: {
4764: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4765:
4766: opline->opcode = ZEND_BEGIN_SILENCE;
4767: opline->result.op_type = IS_TMP_VAR;
4768: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4769: SET_UNUSED(opline->op1);
4770: SET_UNUSED(opline->op2);
4771: *strudel_token = opline->result;
4772: }
4773: /* }}} */
4774:
4775: void zend_do_end_silence(const znode *strudel_token TSRMLS_DC) /* {{{ */
4776: {
4777: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4778:
4779: opline->opcode = ZEND_END_SILENCE;
4780: opline->op1 = *strudel_token;
4781: SET_UNUSED(opline->op2);
4782: }
4783: /* }}} */
4784:
4785: void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
4786: {
4787: int op_number = get_next_op_number(CG(active_op_array));
4788: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4789:
4790: opline->opcode = ZEND_JMP_SET;
4791: opline->result.op_type = IS_TMP_VAR;
4792: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4793: opline->op1 = *value;
4794: SET_UNUSED(opline->op2);
4795:
4796: *colon_token = opline->result;
4797:
4798: jmp_token->u.opline_num = op_number;
4799:
4800: INC_BPC(CG(active_op_array));
4801: }
4802: /* }}} */
4803:
4804: void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *jmp_token, const znode *colon_token TSRMLS_DC) /* {{{ */
4805: {
4806: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4807:
4808: opline->opcode = ZEND_QM_ASSIGN;
4809: opline->extended_value = 0;
4810: opline->result = *colon_token;
4811: opline->op1 = *false_value;
4812: SET_UNUSED(opline->op2);
4813:
4814: *result = opline->result;
4815:
4816: CG(active_op_array)->opcodes[jmp_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
4817:
4818: DEC_BPC(CG(active_op_array));
4819: }
4820: /* }}} */
4821:
4822: void zend_do_begin_qm_op(const znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
4823: {
4824: int jmpz_op_number = get_next_op_number(CG(active_op_array));
4825: zend_op *opline;
4826:
4827: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4828:
4829: opline->opcode = ZEND_JMPZ;
4830: opline->op1 = *cond;
4831: SET_UNUSED(opline->op2);
4832: opline->op2.u.opline_num = jmpz_op_number;
4833: *qm_token = opline->op2;
4834:
4835: INC_BPC(CG(active_op_array));
4836: }
4837: /* }}} */
4838:
4839: void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */
4840: {
4841: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4842:
4843: CG(active_op_array)->opcodes[qm_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
4844:
4845: opline->opcode = ZEND_QM_ASSIGN;
4846: opline->result.op_type = IS_TMP_VAR;
4847: opline->result.u.var = get_temporary_variable(CG(active_op_array));
4848: opline->op1 = *true_value;
4849: SET_UNUSED(opline->op2);
4850:
4851: *qm_token = opline->result;
4852: colon_token->u.opline_num = get_next_op_number(CG(active_op_array));
4853:
4854: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4855: opline->opcode = ZEND_JMP;
4856: SET_UNUSED(opline->op1);
4857: SET_UNUSED(opline->op2);
4858: }
4859: /* }}} */
4860:
4861: void zend_do_qm_false(znode *result, const znode *false_value, const znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */
4862: {
4863: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4864:
4865: opline->opcode = ZEND_QM_ASSIGN;
4866: opline->result = *qm_token;
4867: opline->op1 = *false_value;
4868: SET_UNUSED(opline->op2);
4869:
4870: CG(active_op_array)->opcodes[colon_token->u.opline_num].op1.u.opline_num = get_next_op_number(CG(active_op_array));
4871:
4872: *result = opline->result;
4873:
4874: DEC_BPC(CG(active_op_array));
4875: }
4876: /* }}} */
4877:
4878: void zend_do_extended_info(TSRMLS_D) /* {{{ */
4879: {
4880: zend_op *opline;
4881:
4882: if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
4883: return;
4884: }
4885:
4886: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4887:
4888: opline->opcode = ZEND_EXT_STMT;
4889: SET_UNUSED(opline->op1);
4890: SET_UNUSED(opline->op2);
4891: }
4892: /* }}} */
4893:
4894: void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
4895: {
4896: zend_op *opline;
4897:
4898: if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
4899: return;
4900: }
4901:
4902: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4903:
4904: opline->opcode = ZEND_EXT_FCALL_BEGIN;
4905: SET_UNUSED(opline->op1);
4906: SET_UNUSED(opline->op2);
4907: }
4908: /* }}} */
4909:
4910: void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
4911: {
4912: zend_op *opline;
4913:
4914: if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
4915: return;
4916: }
4917:
4918: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4919:
4920: opline->opcode = ZEND_EXT_FCALL_END;
4921: SET_UNUSED(opline->op1);
4922: SET_UNUSED(opline->op2);
4923: }
4924: /* }}} */
4925:
4926: void zend_do_ticks(TSRMLS_D) /* {{{ */
4927: {
4928: zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4929:
4930: opline->opcode = ZEND_TICKS;
4931: opline->op1.u.constant = CG(declarables).ticks;
4932: opline->op1.op_type = IS_CONST;
4933: SET_UNUSED(opline->op2);
4934: }
4935: /* }}} */
4936:
4937: void zend_auto_global_dtor(zend_auto_global *auto_global) /* {{{ */
4938: {
4939: free(auto_global->name);
4940: }
4941: /* }}} */
4942:
4943: zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC) /* {{{ */
4944: {
4945: zend_auto_global *auto_global;
4946:
4947: if (zend_hash_find(CG(auto_globals), name, name_len+1, (void **) &auto_global)==SUCCESS) {
4948: if (auto_global->armed) {
4949: auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
4950: }
4951: return 1;
4952: }
4953: return 0;
4954: }
4955: /* }}} */
4956:
4957: int zend_register_auto_global(const char *name, uint name_len, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
4958: {
4959: zend_auto_global auto_global;
4960:
4961: auto_global.name = zend_strndup(name, name_len);
4962: auto_global.name_len = name_len;
4963: auto_global.auto_global_callback = auto_global_callback;
4964:
4965: return zend_hash_add(CG(auto_globals), name, name_len+1, &auto_global, sizeof(zend_auto_global), NULL);
4966: }
4967: /* }}} */
4968:
4969: int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
4970: {
4971: int retval;
4972:
4973: if (CG(increment_lineno)) {
4974: CG(zend_lineno)++;
4975: CG(increment_lineno) = 0;
4976: }
4977:
4978: again:
4979: Z_TYPE(zendlval->u.constant) = IS_LONG;
4980: retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
4981: switch (retval) {
4982: case T_COMMENT:
4983: case T_DOC_COMMENT:
4984: case T_OPEN_TAG:
4985: case T_WHITESPACE:
4986: goto again;
4987:
4988: case T_CLOSE_TAG:
4989: if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
4990: CG(increment_lineno) = 1;
4991: }
4992: if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
4993: goto again;
4994: }
4995: retval = ';'; /* implicit ; */
4996: break;
4997: case T_OPEN_TAG_WITH_ECHO:
4998: retval = T_ECHO;
4999: break;
5000: case T_END_HEREDOC:
5001: efree(Z_STRVAL(zendlval->u.constant));
5002: break;
5003: }
5004:
5005: INIT_PZVAL(&zendlval->u.constant);
5006: zendlval->op_type = IS_CONST;
5007: return retval;
5008: }
5009: /* }}} */
5010:
5011: ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
5012: {
5013: zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
5014: dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
5015:
5016: ce->refcount = 1;
5017: ce->constants_updated = 0;
5018: ce->ce_flags = 0;
5019:
5020: ce->doc_comment = NULL;
5021: ce->doc_comment_len = 0;
5022:
5023: zend_hash_init_ex(&ce->default_properties, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
5024: zend_hash_init_ex(&ce->properties_info, 0, NULL, (dtor_func_t) (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
5025: zend_hash_init_ex(&ce->default_static_members, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
5026: zend_hash_init_ex(&ce->constants_table, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
5027: zend_hash_init_ex(&ce->function_table, 0, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
5028:
5029: if (ce->type == ZEND_INTERNAL_CLASS) {
5030: #ifdef ZTS
5031: int n = zend_hash_num_elements(CG(class_table));
5032:
5033: if (CG(static_members) && n >= CG(last_static_member)) {
5034: /* Support for run-time declaration: dl() */
5035: CG(last_static_member) = n+1;
5036: CG(static_members) = realloc(CG(static_members), (n+1)*sizeof(HashTable*));
5037: CG(static_members)[n] = NULL;
5038: }
5039: ce->static_members = (HashTable*)(zend_intptr_t)n;
5040: #else
5041: ce->static_members = NULL;
5042: #endif
5043: } else {
5044: ce->static_members = &ce->default_static_members;
5045: }
5046:
5047: if (nullify_handlers) {
5048: ce->constructor = NULL;
5049: ce->destructor = NULL;
5050: ce->clone = NULL;
5051: ce->__get = NULL;
5052: ce->__set = NULL;
5053: ce->__unset = NULL;
5054: ce->__isset = NULL;
5055: ce->__call = NULL;
5056: ce->__callstatic = NULL;
5057: ce->__tostring = NULL;
5058: ce->create_object = NULL;
5059: ce->get_iterator = NULL;
5060: ce->iterator_funcs.funcs = NULL;
5061: ce->interface_gets_implemented = NULL;
5062: ce->get_static_method = NULL;
5063: ce->parent = NULL;
5064: ce->num_interfaces = 0;
5065: ce->interfaces = NULL;
5066: ce->module = NULL;
5067: ce->serialize = NULL;
5068: ce->unserialize = NULL;
5069: ce->serialize_func = NULL;
5070: ce->unserialize_func = NULL;
5071: ce->builtin_functions = NULL;
5072: }
5073: }
5074: /* }}} */
5075:
5076: int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{{ */
5077: {
5078: if ((class_name_len == sizeof("self")-1) &&
5079: !memcmp(class_name, "self", sizeof("self")-1)) {
5080: return ZEND_FETCH_CLASS_SELF;
5081: } else if ((class_name_len == sizeof("parent")-1) &&
5082: !memcmp(class_name, "parent", sizeof("parent")-1)) {
5083: return ZEND_FETCH_CLASS_PARENT;
5084: } else if ((class_name_len == sizeof("static")-1) &&
5085: !memcmp(class_name, "static", sizeof("static")-1)) {
5086: return ZEND_FETCH_CLASS_STATIC;
5087: } else {
5088: return ZEND_FETCH_CLASS_DEFAULT;
5089: }
5090: }
5091: /* }}} */
5092:
5093: ZEND_API char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len) /* {{{ */
5094: {
5095: if (name_len) {
5096: *name_len = op_array->vars[var].name_len;
5097: }
5098: return op_array->vars[var].name;
5099: }
5100: /* }}} */
5101:
5102: void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */
5103: {
5104: if (prefix) {
5105: *result = *prefix;
5106: if (Z_TYPE(result->u.constant) == IS_STRING &&
5107: Z_STRLEN(result->u.constant) == 0) {
5108: /* namespace\ */
5109: if (CG(current_namespace)) {
5110: znode tmp;
5111:
5112: zval_dtor(&result->u.constant);
5113: tmp.op_type = IS_CONST;
5114: tmp.u.constant = *CG(current_namespace);
5115: zval_copy_ctor(&tmp.u.constant);
5116: zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC);
5117: }
5118: }
5119: } else {
5120: result->op_type = IS_CONST;
5121: Z_TYPE(result->u.constant) = IS_STRING;
5122: Z_STRVAL(result->u.constant) = NULL;
5123: Z_STRLEN(result->u.constant) = 0;
5124: }
5125: /* prefix = result */
5126: zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC);
5127: }
5128: /* }}} */
5129:
5130: void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */
5131: {
5132: char *lcname;
5133:
5134: /* handle mixed syntax declaration or nested namespaces */
5135: if (!CG(has_bracketed_namespaces)) {
5136: if (CG(current_namespace)) {
5137: /* previous namespace declarations were unbracketed */
5138: if (with_bracket) {
5139: zend_error(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
5140: }
5141: }
5142: } else {
5143: /* previous namespace declarations were bracketed */
5144: if (!with_bracket) {
5145: zend_error(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
5146: } else if (CG(current_namespace) || CG(in_namespace)) {
5147: zend_error(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
5148: }
5149: }
5150:
5151: if (((!with_bracket && !CG(current_namespace)) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) {
5152: /* ignore ZEND_EXT_STMT and ZEND_TICKS */
5153: int num = CG(active_op_array)->last;
5154: while (num > 0 &&
5155: (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
5156: CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
5157: --num;
5158: }
5159: if (num > 0) {
5160: zend_error(E_COMPILE_ERROR, "Namespace declaration statement has to be the very first statement in the script");
5161: }
5162: }
5163:
5164: CG(in_namespace) = 1;
5165: if (with_bracket) {
5166: CG(has_bracketed_namespaces) = 1;
5167: }
5168:
5169: if (name) {
5170: lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
5171: if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
5172: !memcmp(lcname, "self", sizeof("self")-1)) ||
5173: ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
5174: !memcmp(lcname, "parent", sizeof("parent")-1))) {
5175: zend_error(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
5176: }
5177: efree(lcname);
5178:
5179: if (CG(current_namespace)) {
5180: zval_dtor(CG(current_namespace));
5181: } else {
5182: ALLOC_ZVAL(CG(current_namespace));
5183: }
5184: *CG(current_namespace) = name->u.constant;
5185: } else {
5186: if (CG(current_namespace)) {
5187: zval_dtor(CG(current_namespace));
5188: FREE_ZVAL(CG(current_namespace));
5189: CG(current_namespace) = NULL;
5190: }
5191: }
5192:
5193: if (CG(current_import)) {
5194: zend_hash_destroy(CG(current_import));
5195: efree(CG(current_import));
5196: CG(current_import) = NULL;
5197: }
5198:
5199: if (CG(doc_comment)) {
5200: efree(CG(doc_comment));
5201: CG(doc_comment) = NULL;
5202: CG(doc_comment_len) = 0;
5203: }
5204: }
5205: /* }}} */
5206:
5207: void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
5208: {
5209: char *lcname;
5210: zval *name, *ns, tmp;
5211: zend_bool warn = 0;
5212: zend_class_entry **pce;
5213:
5214: if (!CG(current_import)) {
5215: CG(current_import) = emalloc(sizeof(HashTable));
5216: zend_hash_init(CG(current_import), 0, NULL, ZVAL_PTR_DTOR, 0);
5217: }
5218:
5219: ALLOC_ZVAL(ns);
5220: *ns = ns_name->u.constant;
5221: if (new_name) {
5222: name = &new_name->u.constant;
5223: } else {
5224: char *p;
5225:
5226: /* The form "use A\B" is eqivalent to "use A\B as B".
5227: So we extract the last part of compound name to use as a new_name */
5228: name = &tmp;
5229: p = zend_memrchr(Z_STRVAL_P(ns), '\\', Z_STRLEN_P(ns));
5230: if (p) {
5231: ZVAL_STRING(name, p+1, 1);
5232: } else {
5233: *name = *ns;
5234: zval_copy_ctor(name);
5235: warn = !is_global && !CG(current_namespace);
5236: }
5237: }
5238:
5239: lcname = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name));
5240:
5241: if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
5242: !memcmp(lcname, "self", sizeof("self")-1)) ||
5243: ((Z_STRLEN_P(name) == sizeof("parent")-1) &&
5244: !memcmp(lcname, "parent", sizeof("parent")-1))) {
5245: zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL_P(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
5246: }
5247:
5248: if (CG(current_namespace)) {
5249: /* Prefix import name with current namespace name to avoid conflicts with classes */
5250: char *c_ns_name = emalloc(Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) + 1);
5251:
5252: zend_str_tolower_copy(c_ns_name, Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
5253: c_ns_name[Z_STRLEN_P(CG(current_namespace))] = '\\';
5254: memcpy(c_ns_name+Z_STRLEN_P(CG(current_namespace))+1, lcname, Z_STRLEN_P(name)+1);
5255: if (zend_hash_exists(CG(class_table), c_ns_name, Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name)+1)) {
5256: char *tmp2 = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
5257:
5258: if (Z_STRLEN_P(ns) != Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
5259: memcmp(tmp2, c_ns_name, Z_STRLEN_P(ns))) {
5260: zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
5261: }
5262: efree(tmp2);
5263: }
5264: efree(c_ns_name);
5265: } else if (zend_hash_find(CG(class_table), lcname, Z_STRLEN_P(name)+1, (void**)&pce) == SUCCESS &&
5266: (*pce)->type == ZEND_USER_CLASS &&
5267: (*pce)->filename == CG(compiled_filename)) {
5268: char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
5269:
5270: if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) ||
5271: memcmp(c_tmp, lcname, Z_STRLEN_P(ns))) {
5272: zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
5273: }
5274: efree(c_tmp);
5275: }
5276:
5277: if (zend_hash_add(CG(current_import), lcname, Z_STRLEN_P(name)+1, &ns, sizeof(zval*), NULL) != SUCCESS) {
5278: zend_error(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
5279: }
5280: if (warn) {
5281: zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name));
5282: }
5283: efree(lcname);
5284: zval_dtor(name);
5285: }
5286: /* }}} */
5287:
5288: void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
5289: {
5290: zend_op *opline;
5291:
5292: if(Z_TYPE(value->u.constant) == IS_CONSTANT_ARRAY) {
5293: zend_error(E_COMPILE_ERROR, "Arrays are not allowed as constants");
5294: }
5295:
5296: if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
5297: zend_error(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
5298: }
5299:
5300: if (CG(current_namespace)) {
5301: /* Prefix constant name with name of current namespace, lowercased */
5302: znode tmp;
5303:
5304: tmp.op_type = IS_CONST;
5305: tmp.u.constant = *CG(current_namespace);
5306: Z_STRVAL(tmp.u.constant) = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
5307: zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
5308: *name = tmp;
5309: }
5310:
5311: opline = get_next_op(CG(active_op_array) TSRMLS_CC);
5312: opline->opcode = ZEND_DECLARE_CONST;
5313: SET_UNUSED(opline->result);
5314: opline->op1 = *name;
5315: opline->op2 = *value;
5316: }
5317: /* }}} */
5318:
5319: void zend_verify_namespace(TSRMLS_D) /* {{{ */
5320: {
5321: if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
5322: zend_error(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
5323: }
5324: }
5325: /* }}} */
5326:
5327: void zend_do_end_namespace(TSRMLS_D) /* {{{ */
5328: {
5329: CG(in_namespace) = 0;
5330: if (CG(current_namespace)) {
5331: zval_dtor(CG(current_namespace));
5332: FREE_ZVAL(CG(current_namespace));
5333: CG(current_namespace) = NULL;
5334: }
5335: if (CG(current_import)) {
5336: zend_hash_destroy(CG(current_import));
5337: efree(CG(current_import));
5338: CG(current_import) = NULL;
5339: }
5340:
5341: if (CG(doc_comment)) {
5342: efree(CG(doc_comment));
5343: CG(doc_comment) = NULL;
5344: CG(doc_comment_len) = 0;
5345: }
5346: }
5347: /* }}} */
5348:
5349: void zend_do_end_compilation(TSRMLS_D) /* {{{ */
5350: {
5351: CG(has_bracketed_namespaces) = 0;
5352: zend_do_end_namespace(TSRMLS_C);
5353: }
5354: /* }}} */
5355:
5356: /* {{{ zend_dirname
5357: Returns directory name component of path */
5358: ZEND_API size_t zend_dirname(char *path, size_t len)
5359: {
5360: register char *end = path + len - 1;
5361: unsigned int len_adjust = 0;
5362:
5363: #ifdef PHP_WIN32
5364: /* Note that on Win32 CWD is per drive (heritage from CP/M).
5365: * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
5366: */
5367: if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
5368: /* Skip over the drive spec (if any) so as not to change */
5369: path += 2;
5370: len_adjust += 2;
5371: if (2 == len) {
5372: /* Return "c:" on Win32 for dirname("c:").
5373: * It would be more consistent to return "c:."
5374: * but that would require making the string *longer*.
5375: */
5376: return len;
5377: }
5378: }
5379: #elif defined(NETWARE)
5380: /*
5381: * Find the first occurence of : from the left
5382: * move the path pointer to the position just after :
5383: * increment the len_adjust to the length of path till colon character(inclusive)
5384: * If there is no character beyond : simple return len
5385: */
5386: char *colonpos = NULL;
5387: colonpos = strchr(path, ':');
5388: if (colonpos != NULL) {
5389: len_adjust = ((colonpos - path) + 1);
5390: path += len_adjust;
5391: if (len_adjust == len) {
5392: return len;
5393: }
5394: }
5395: #endif
5396:
5397: if (len == 0) {
5398: /* Illegal use of this function */
5399: return 0;
5400: }
5401:
5402: /* Strip trailing slashes */
5403: while (end >= path && IS_SLASH_P(end)) {
5404: end--;
5405: }
5406: if (end < path) {
5407: /* The path only contained slashes */
5408: path[0] = DEFAULT_SLASH;
5409: path[1] = '\0';
5410: return 1 + len_adjust;
5411: }
5412:
5413: /* Strip filename */
5414: while (end >= path && !IS_SLASH_P(end)) {
5415: end--;
5416: }
5417: if (end < path) {
5418: /* No slash found, therefore return '.' */
5419: #ifdef NETWARE
5420: if (len_adjust == 0) {
5421: path[0] = '.';
5422: path[1] = '\0';
5423: return 1; /* only one character */
5424: } else {
5425: path[0] = '\0';
5426: return len_adjust;
5427: }
5428: #else
5429: path[0] = '.';
5430: path[1] = '\0';
5431: return 1 + len_adjust;
5432: #endif
5433: }
5434:
5435: /* Strip slashes which came before the file name */
5436: while (end >= path && IS_SLASH_P(end)) {
5437: end--;
5438: }
5439: if (end < path) {
5440: path[0] = DEFAULT_SLASH;
5441: path[1] = '\0';
5442: return 1 + len_adjust;
5443: }
5444: *(end+1) = '\0';
5445:
5446: return (size_t)(end + 1 - path) + len_adjust;
5447: }
5448: /* }}} */
5449:
5450: /*
5451: * Local variables:
5452: * tab-width: 4
5453: * c-basic-offset: 4
5454: * indent-tabs-mode: t
5455: * End:
5456: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_compile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend