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.c,v 1.1.1.1 2012/02/21 23:47:52 misho Exp $ */
21:
22: #include "zend.h"
23: #include "zend_extensions.h"
24: #include "zend_modules.h"
25: #include "zend_constants.h"
26: #include "zend_list.h"
27: #include "zend_API.h"
28: #include "zend_exceptions.h"
29: #include "zend_builtin_functions.h"
30: #include "zend_ini.h"
31: #include "zend_vm.h"
32:
33: #ifdef ZTS
34: # define GLOBAL_FUNCTION_TABLE global_function_table
35: # define GLOBAL_CLASS_TABLE global_class_table
36: # define GLOBAL_CONSTANTS_TABLE global_constants_table
37: # define GLOBAL_AUTO_GLOBALS_TABLE global_auto_globals_table
38: #else
39: # define GLOBAL_FUNCTION_TABLE CG(function_table)
40: # define GLOBAL_CLASS_TABLE CG(class_table)
41: # define GLOBAL_AUTO_GLOBALS_TABLE CG(auto_globals)
42: # define GLOBAL_CONSTANTS_TABLE EG(zend_constants)
43: #endif
44:
45: #if defined(ZEND_WIN32) && ZEND_DEBUG
46: BOOL WINAPI IsDebuggerPresent(VOID);
47: #endif
48:
49: /* true multithread-shared globals */
50: ZEND_API zend_class_entry *zend_standard_class_def = NULL;
51: ZEND_API int (*zend_printf)(const char *format, ...);
52: ZEND_API zend_write_func_t zend_write;
53: ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path TSRMLS_DC);
54: ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
55: ZEND_API void (*zend_block_interruptions)(void);
56: ZEND_API void (*zend_unblock_interruptions)(void);
57: ZEND_API void (*zend_ticks_function)(int ticks);
58: ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
59: int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap);
60: ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC);
61: ZEND_API char *(*zend_resolve_path)(const char *filename, int filename_len TSRMLS_DC);
62:
63: #if SUHOSIN_PATCH
64: ZEND_API void (*zend_suhosin_log)(int loglevel, char *fmt, ...);
65: #endif
66:
67: void (*zend_on_timeout)(int seconds TSRMLS_DC);
68:
69: static void (*zend_message_dispatcher_p)(long message, void *data TSRMLS_DC);
70: static int (*zend_get_configuration_directive_p)(const char *name, uint name_length, zval *contents);
71:
72: static ZEND_INI_MH(OnUpdateErrorReporting) /* {{{ */
73: {
74: if (!new_value) {
75: EG(error_reporting) = E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED;
76: } else {
77: EG(error_reporting) = atoi(new_value);
78: }
79: return SUCCESS;
80: }
81: /* }}} */
82:
83: static ZEND_INI_MH(OnUpdateGCEnabled) /* {{{ */
84: {
85: OnUpdateBool(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
86:
87: if (GC_G(gc_enabled)) {
88: gc_init(TSRMLS_C);
89: }
90:
91: return SUCCESS;
92: }
93: /* }}} */
94:
95: #if SUHOSIN_PATCH
96: static ZEND_INI_MH(OnUpdateSuhosin_log_syslog)
97: {
98: if (!new_value) {
99: SPG(log_syslog) = S_ALL & ~S_SQL | S_MEMORY;
100: } else {
101: SPG(log_syslog) = atoi(new_value) | S_MEMORY;
102: }
103: return SUCCESS;
104: }
105: static ZEND_INI_MH(OnUpdateSuhosin_log_syslog_facility)
106: {
107: if (!new_value) {
108: SPG(log_syslog_facility) = LOG_USER;
109: } else {
110: SPG(log_syslog_facility) = atoi(new_value);
111: }
112: return SUCCESS;
113: }
114: static ZEND_INI_MH(OnUpdateSuhosin_log_syslog_priority)
115: {
116: if (!new_value) {
117: SPG(log_syslog_priority) = LOG_ALERT;
118: } else {
119: SPG(log_syslog_priority) = atoi(new_value);
120: }
121: return SUCCESS;
122: }
123: static ZEND_INI_MH(OnUpdateSuhosin_log_sapi)
124: {
125: if (!new_value) {
126: SPG(log_sapi) = S_ALL & ~S_SQL;
127: } else {
128: SPG(log_sapi) = atoi(new_value);
129: }
130: return SUCCESS;
131: }
132: static ZEND_INI_MH(OnUpdateSuhosin_log_script)
133: {
134: if (!new_value) {
135: SPG(log_script) = S_ALL & ~S_MEMORY;
136: } else {
137: SPG(log_script) = atoi(new_value) & (~S_MEMORY) & (~S_INTERNAL);
138: }
139: return SUCCESS;
140: }
141: static ZEND_INI_MH(OnUpdateSuhosin_log_scriptname)
142: {
143: if (SPG(log_scriptname)) {
144: pefree(SPG(log_scriptname),1);
145: }
146: SPG(log_scriptname) = NULL;
147: if (new_value) {
148: SPG(log_scriptname) = pestrdup(new_value,1);
149: }
150: return SUCCESS;
151: }
152: static ZEND_INI_MH(OnUpdateSuhosin_log_phpscript)
153: {
154: if (!new_value) {
155: SPG(log_phpscript) = S_ALL & ~S_MEMORY;
156: } else {
157: SPG(log_phpscript) = atoi(new_value) & (~S_MEMORY) & (~S_INTERNAL);
158: }
159: return SUCCESS;
160: }
161: #endif
162:
163: ZEND_INI_BEGIN()
164: ZEND_INI_ENTRY("error_reporting", NULL, ZEND_INI_ALL, OnUpdateErrorReporting)
165: STD_ZEND_INI_BOOLEAN("zend.enable_gc", "1", ZEND_INI_ALL, OnUpdateGCEnabled, gc_enabled, zend_gc_globals, gc_globals)
166: #ifdef ZEND_MULTIBYTE
167: STD_ZEND_INI_BOOLEAN("detect_unicode", "1", ZEND_INI_ALL, OnUpdateBool, detect_unicode, zend_compiler_globals, compiler_globals)
168: #endif
169: ZEND_INI_END()
170:
171:
172: #ifdef ZTS
173: ZEND_API int compiler_globals_id;
174: ZEND_API int executor_globals_id;
175: static HashTable *global_function_table = NULL;
176: static HashTable *global_class_table = NULL;
177: static HashTable *global_constants_table = NULL;
178: static HashTable *global_auto_globals_table = NULL;
179: static HashTable *global_persistent_list = NULL;
180: #endif
181:
182: ZEND_API zend_utility_values zend_uv;
183:
184: ZEND_API zval zval_used_for_init; /* True global variable */
185:
186: /* version information */
187: static char *zend_version_info;
188: static uint zend_version_info_length;
189: #define ZEND_CORE_VERSION_INFO "Zend Engine v" ZEND_VERSION ", Copyright (c) 1998-2012 Zend Technologies\n"
190: #define PRINT_ZVAL_INDENT 4
191:
192: static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent, zend_bool is_object TSRMLS_DC) /* {{{ */
193: {
194: zval **tmp;
195: char *string_key;
196: HashPosition iterator;
197: ulong num_key;
198: uint str_len;
199: int i;
200:
201: for (i = 0; i < indent; i++) {
202: ZEND_PUTS_EX(" ");
203: }
204: ZEND_PUTS_EX("(\n");
205: indent += PRINT_ZVAL_INDENT;
206: zend_hash_internal_pointer_reset_ex(ht, &iterator);
207: while (zend_hash_get_current_data_ex(ht, (void **) &tmp, &iterator) == SUCCESS) {
208: for (i = 0; i < indent; i++) {
209: ZEND_PUTS_EX(" ");
210: }
211: ZEND_PUTS_EX("[");
212: switch (zend_hash_get_current_key_ex(ht, &string_key, &str_len, &num_key, 0, &iterator)) {
213: case HASH_KEY_IS_STRING:
214: if (is_object) {
215: char *prop_name, *class_name;
216: int mangled = zend_unmangle_property_name(string_key, str_len - 1, &class_name, &prop_name);
217:
218: ZEND_PUTS_EX(prop_name);
219: if (class_name && mangled == SUCCESS) {
220: if (class_name[0]=='*') {
221: ZEND_PUTS_EX(":protected");
222: } else {
223: ZEND_PUTS_EX(":");
224: ZEND_PUTS_EX(class_name);
225: ZEND_PUTS_EX(":private");
226: }
227: }
228: } else {
229: ZEND_WRITE_EX(string_key, str_len-1);
230: }
231: break;
232: case HASH_KEY_IS_LONG:
233: {
234: char key[25];
235: snprintf(key, sizeof(key), "%ld", num_key);
236: ZEND_PUTS_EX(key);
237: }
238: break;
239: }
240: ZEND_PUTS_EX("] => ");
241: zend_print_zval_r_ex(write_func, *tmp, indent+PRINT_ZVAL_INDENT TSRMLS_CC);
242: ZEND_PUTS_EX("\n");
243: zend_hash_move_forward_ex(ht, &iterator);
244: }
245: indent -= PRINT_ZVAL_INDENT;
246: for (i = 0; i < indent; i++) {
247: ZEND_PUTS_EX(" ");
248: }
249: ZEND_PUTS_EX(")\n");
250: }
251: /* }}} */
252:
253: static void print_flat_hash(HashTable *ht TSRMLS_DC) /* {{{ */
254: {
255: zval **tmp;
256: char *string_key;
257: HashPosition iterator;
258: ulong num_key;
259: uint str_len;
260: int i = 0;
261:
262: zend_hash_internal_pointer_reset_ex(ht, &iterator);
263: while (zend_hash_get_current_data_ex(ht, (void **) &tmp, &iterator) == SUCCESS) {
264: if (i++ > 0) {
265: ZEND_PUTS(",");
266: }
267: ZEND_PUTS("[");
268: switch (zend_hash_get_current_key_ex(ht, &string_key, &str_len, &num_key, 0, &iterator)) {
269: case HASH_KEY_IS_STRING:
270: ZEND_PUTS(string_key);
271: break;
272: case HASH_KEY_IS_LONG:
273: zend_printf("%ld", num_key);
274: break;
275: }
276: ZEND_PUTS("] => ");
277: zend_print_flat_zval_r(*tmp TSRMLS_CC);
278: zend_hash_move_forward_ex(ht, &iterator);
279: }
280: }
281: /* }}} */
282:
283: ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy) /* {{{ */
284: {
285: if (Z_TYPE_P(expr)==IS_STRING) {
286: *use_copy = 0;
287: return;
288: }
289: switch (Z_TYPE_P(expr)) {
290: case IS_NULL:
291: Z_STRLEN_P(expr_copy) = 0;
292: Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
293: break;
294: case IS_BOOL:
295: if (Z_LVAL_P(expr)) {
296: Z_STRLEN_P(expr_copy) = 1;
297: Z_STRVAL_P(expr_copy) = estrndup("1", 1);
298: } else {
299: Z_STRLEN_P(expr_copy) = 0;
300: Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
301: }
302: break;
303: case IS_RESOURCE:
304: Z_STRVAL_P(expr_copy) = (char *) emalloc(sizeof("Resource id #") - 1 + MAX_LENGTH_OF_LONG);
305: Z_STRLEN_P(expr_copy) = sprintf(Z_STRVAL_P(expr_copy), "Resource id #%ld", Z_LVAL_P(expr));
306: break;
307: case IS_ARRAY:
308: Z_STRLEN_P(expr_copy) = sizeof("Array") - 1;
309: Z_STRVAL_P(expr_copy) = estrndup("Array", Z_STRLEN_P(expr_copy));
310: break;
311: case IS_OBJECT:
312: {
313: TSRMLS_FETCH();
314:
315: if (Z_OBJ_HANDLER_P(expr, cast_object) && Z_OBJ_HANDLER_P(expr, cast_object)(expr, expr_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
316: break;
317: }
318: /* Standard PHP objects */
319: if (Z_OBJ_HT_P(expr) == &std_object_handlers || !Z_OBJ_HANDLER_P(expr, cast_object)) {
320: if (zend_std_cast_object_tostring(expr, expr_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
321: break;
322: }
323: }
324: if (!Z_OBJ_HANDLER_P(expr, cast_object) && Z_OBJ_HANDLER_P(expr, get)) {
325: zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC);
326:
327: Z_ADDREF_P(z);
328: if (Z_TYPE_P(z) != IS_OBJECT) {
329: zend_make_printable_zval(z, expr_copy, use_copy);
330: if (*use_copy) {
331: zval_ptr_dtor(&z);
332: } else {
333: ZVAL_ZVAL(expr_copy, z, 0, 1);
334: *use_copy = 1;
335: }
336: return;
337: }
338: zval_ptr_dtor(&z);
339: }
340: zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(expr)->name);
341: Z_STRLEN_P(expr_copy) = 0;
342: Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
343: }
344: break;
345: case IS_DOUBLE:
346: *expr_copy = *expr;
347: zval_copy_ctor(expr_copy);
348: zend_locale_sprintf_double(expr_copy ZEND_FILE_LINE_CC);
349: break;
350: default:
351: *expr_copy = *expr;
352: zval_copy_ctor(expr_copy);
353: convert_to_string(expr_copy);
354: break;
355: }
356: Z_TYPE_P(expr_copy) = IS_STRING;
357: *use_copy = 1;
358: }
359: /* }}} */
360:
361: ZEND_API int zend_print_zval(zval *expr, int indent) /* {{{ */
362: {
363: return zend_print_zval_ex(zend_write, expr, indent);
364: }
365: /* }}} */
366:
367: ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent) /* {{{ */
368: {
369: zval expr_copy;
370: int use_copy;
371:
372: zend_make_printable_zval(expr, &expr_copy, &use_copy);
373: if (use_copy) {
374: expr = &expr_copy;
375: }
376: if (Z_STRLEN_P(expr) == 0) { /* optimize away empty strings */
377: if (use_copy) {
378: zval_dtor(expr);
379: }
380: return 0;
381: }
382: write_func(Z_STRVAL_P(expr), Z_STRLEN_P(expr));
383: if (use_copy) {
384: zval_dtor(expr);
385: }
386: return Z_STRLEN_P(expr);
387: }
388: /* }}} */
389:
390: ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC) /* {{{ */
391: {
392: switch (Z_TYPE_P(expr)) {
393: case IS_ARRAY:
394: ZEND_PUTS("Array (");
395: if (++Z_ARRVAL_P(expr)->nApplyCount>1) {
396: ZEND_PUTS(" *RECURSION*");
397: Z_ARRVAL_P(expr)->nApplyCount--;
398: return;
399: }
400: print_flat_hash(Z_ARRVAL_P(expr) TSRMLS_CC);
401: ZEND_PUTS(")");
402: Z_ARRVAL_P(expr)->nApplyCount--;
403: break;
404: case IS_OBJECT:
405: {
406: HashTable *properties = NULL;
407: char *class_name = NULL;
408: zend_uint clen;
409:
410: if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
411: Z_OBJ_HANDLER_P(expr, get_class_name)(expr, &class_name, &clen, 0 TSRMLS_CC);
412: }
413: if (class_name) {
414: zend_printf("%s Object (", class_name);
415: } else {
416: zend_printf("%s Object (", "Unknown Class");
417: }
418: if (class_name) {
419: efree(class_name);
420: }
421: if (Z_OBJ_HANDLER_P(expr, get_properties)) {
422: properties = Z_OBJPROP_P(expr);
423: }
424: if (properties) {
425: if (++properties->nApplyCount>1) {
426: ZEND_PUTS(" *RECURSION*");
427: properties->nApplyCount--;
428: return;
429: }
430: print_flat_hash(properties TSRMLS_CC);
431: properties->nApplyCount--;
432: }
433: ZEND_PUTS(")");
434: break;
435: }
436: default:
437: zend_print_variable(expr);
438: break;
439: }
440: }
441: /* }}} */
442:
443: ZEND_API void zend_print_zval_r(zval *expr, int indent TSRMLS_DC) /* {{{ */
444: {
445: zend_print_zval_r_ex(zend_write, expr, indent TSRMLS_CC);
446: }
447: /* }}} */
448:
449: ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC) /* {{{ */
450: {
451: switch (Z_TYPE_P(expr)) {
452: case IS_ARRAY:
453: ZEND_PUTS_EX("Array\n");
454: if (++Z_ARRVAL_P(expr)->nApplyCount>1) {
455: ZEND_PUTS_EX(" *RECURSION*");
456: Z_ARRVAL_P(expr)->nApplyCount--;
457: return;
458: }
459: print_hash(write_func, Z_ARRVAL_P(expr), indent, 0 TSRMLS_CC);
460: Z_ARRVAL_P(expr)->nApplyCount--;
461: break;
462: case IS_OBJECT:
463: {
464: HashTable *properties;
465: char *class_name = NULL;
466: zend_uint clen;
467: int is_temp;
468:
469: if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
470: Z_OBJ_HANDLER_P(expr, get_class_name)(expr, &class_name, &clen, 0 TSRMLS_CC);
471: }
472: if (class_name) {
473: ZEND_PUTS_EX(class_name);
474: } else {
475: ZEND_PUTS_EX("Unknown Class");
476: }
477: ZEND_PUTS_EX(" Object\n");
478: if (class_name) {
479: efree(class_name);
480: }
481: if ((properties = Z_OBJDEBUG_P(expr, is_temp)) == NULL) {
482: break;
483: }
484: if (++properties->nApplyCount>1) {
485: ZEND_PUTS_EX(" *RECURSION*");
486: properties->nApplyCount--;
487: return;
488: }
489: print_hash(write_func, properties, indent, 1 TSRMLS_CC);
490: properties->nApplyCount--;
491: if (is_temp) {
492: zend_hash_destroy(properties);
493: efree(properties);
494: }
495: break;
496: }
497: default:
498: zend_print_zval_ex(write_func, expr, indent);
499: break;
500: }
501: }
502: /* }}} */
503:
504: static FILE *zend_fopen_wrapper(const char *filename, char **opened_path TSRMLS_DC) /* {{{ */
505: {
506: if (opened_path) {
507: *opened_path = estrdup(filename);
508: }
509: return fopen(filename, "rb");
510: }
511: /* }}} */
512:
513: #ifdef ZTS
514: static zend_bool asp_tags_default = 0;
515: static zend_bool short_tags_default = 1;
516: static zend_bool ct_pass_ref_default = 1;
517: static zend_uint compiler_options_default = ZEND_COMPILE_DEFAULT;
518: #else
519: # define asp_tags_default 0
520: # define short_tags_default 1
521: # define ct_pass_ref_default 1
522: # define compiler_options_default ZEND_COMPILE_DEFAULT
523: #endif
524:
525: static void zend_set_default_compile_time_values(TSRMLS_D) /* {{{ */
526: {
527: /* default compile-time values */
528: CG(asp_tags) = asp_tags_default;
529: CG(short_tags) = short_tags_default;
530: CG(allow_call_time_pass_reference) = ct_pass_ref_default;
531: CG(compiler_options) = compiler_options_default;
532: }
533: /* }}} */
534:
535: static void zend_init_exception_op(TSRMLS_D) /* {{{ */
536: {
537: memset(EG(exception_op), 0, sizeof(EG(exception_op)));
538: EG(exception_op)[0].opcode = ZEND_HANDLE_EXCEPTION;
539: EG(exception_op)[0].op1.op_type = IS_UNUSED;
540: EG(exception_op)[0].op2.op_type = IS_UNUSED;
541: EG(exception_op)[0].result.op_type = IS_UNUSED;
542: ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op));
543: EG(exception_op)[1].opcode = ZEND_HANDLE_EXCEPTION;
544: EG(exception_op)[1].op1.op_type = IS_UNUSED;
545: EG(exception_op)[1].op2.op_type = IS_UNUSED;
546: EG(exception_op)[1].result.op_type = IS_UNUSED;
547: ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+1);
548: EG(exception_op)[2].opcode = ZEND_HANDLE_EXCEPTION;
549: EG(exception_op)[2].op1.op_type = IS_UNUSED;
550: EG(exception_op)[2].op2.op_type = IS_UNUSED;
551: EG(exception_op)[2].result.op_type = IS_UNUSED;
552: ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+2);
553: }
554: /* }}} */
555:
556: #ifdef ZTS
557: static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS_DC) /* {{{ */
558: {
559: zend_function tmp_func;
560: zend_class_entry *tmp_class;
561:
562: compiler_globals->compiled_filename = NULL;
563:
564: compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
565: zend_hash_init_ex(compiler_globals->function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
566: zend_hash_copy(compiler_globals->function_table, global_function_table, NULL, &tmp_func, sizeof(zend_function));
567:
568: compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable));
569: zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
570: zend_hash_copy(compiler_globals->class_table, global_class_table, (copy_ctor_func_t) zend_class_add_ref, &tmp_class, sizeof(zend_class_entry *));
571:
572: zend_set_default_compile_time_values(TSRMLS_C);
573:
574: CG(interactive) = 0;
575:
576: compiler_globals->auto_globals = (HashTable *) malloc(sizeof(HashTable));
577: zend_hash_init_ex(compiler_globals->auto_globals, 8, NULL, NULL, 1, 0);
578: zend_hash_copy(compiler_globals->auto_globals, global_auto_globals_table, NULL, NULL, sizeof(zend_auto_global) /* empty element */);
579:
580: compiler_globals->last_static_member = zend_hash_num_elements(compiler_globals->class_table);
581: if (compiler_globals->last_static_member) {
582: compiler_globals->static_members = (HashTable**)calloc(compiler_globals->last_static_member, sizeof(HashTable*));
583: } else {
584: compiler_globals->static_members = NULL;
585: }
586: }
587: /* }}} */
588:
589: static void compiler_globals_dtor(zend_compiler_globals *compiler_globals TSRMLS_DC) /* {{{ */
590: {
591: if (compiler_globals->function_table != GLOBAL_FUNCTION_TABLE) {
592: zend_hash_destroy(compiler_globals->function_table);
593: free(compiler_globals->function_table);
594: }
595: if (compiler_globals->class_table != GLOBAL_CLASS_TABLE) {
596: zend_hash_destroy(compiler_globals->class_table);
597: free(compiler_globals->class_table);
598: }
599: if (compiler_globals->auto_globals != GLOBAL_AUTO_GLOBALS_TABLE) {
600: zend_hash_destroy(compiler_globals->auto_globals);
601: free(compiler_globals->auto_globals);
602: }
603: if (compiler_globals->static_members) {
604: free(compiler_globals->static_members);
605: }
606: compiler_globals->last_static_member = 0;
607: }
608: /* }}} */
609:
610: static void executor_globals_ctor(zend_executor_globals *executor_globals TSRMLS_DC) /* {{{ */
611: {
612: zend_startup_constants(TSRMLS_C);
613: zend_copy_constants(EG(zend_constants), GLOBAL_CONSTANTS_TABLE);
614: zend_init_rsrc_plist(TSRMLS_C);
615: zend_init_exception_op(TSRMLS_C);
616: EG(lambda_count) = 0;
617: EG(user_error_handler) = NULL;
618: EG(user_exception_handler) = NULL;
619: EG(in_execution) = 0;
620: EG(in_autoload) = NULL;
621: EG(current_execute_data) = NULL;
622: EG(current_module) = NULL;
623: EG(exit_status) = 0;
624: EG(saved_fpu_cw) = NULL;
625: EG(active) = 0;
626: }
627: /* }}} */
628:
629: static void executor_globals_dtor(zend_executor_globals *executor_globals TSRMLS_DC) /* {{{ */
630: {
631: zend_ini_shutdown(TSRMLS_C);
632: if (&executor_globals->persistent_list != global_persistent_list) {
633: zend_destroy_rsrc_list(&executor_globals->persistent_list TSRMLS_CC);
634: }
635: if (executor_globals->zend_constants != GLOBAL_CONSTANTS_TABLE) {
636: zend_hash_destroy(executor_globals->zend_constants);
637: free(executor_globals->zend_constants);
638: }
639: }
640: /* }}} */
641:
642: static void zend_new_thread_end_handler(THREAD_T thread_id TSRMLS_DC) /* {{{ */
643: {
644: if (zend_copy_ini_directives(TSRMLS_C) == SUCCESS) {
645: zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP TSRMLS_CC);
646: }
647: }
648: /* }}} */
649: #endif
650:
651: #if defined(__FreeBSD__) || defined(__DragonFly__)
652: /* FreeBSD and DragonFly floating point precision fix */
653: #include <floatingpoint.h>
654: #endif
655:
656: static void ini_scanner_globals_ctor(zend_ini_scanner_globals *scanner_globals_p TSRMLS_DC) /* {{{ */
657: {
658: memset(scanner_globals_p, 0, sizeof(*scanner_globals_p));
659: }
660: /* }}} */
661:
662: static void php_scanner_globals_ctor(zend_php_scanner_globals *scanner_globals_p TSRMLS_DC) /* {{{ */
663: {
664: memset(scanner_globals_p, 0, sizeof(*scanner_globals_p));
665: }
666: /* }}} */
667:
668: void zend_init_opcodes_handlers(void);
669:
670: int zend_startup(zend_utility_functions *utility_functions, char **extensions TSRMLS_DC) /* {{{ */
671: {
672: #ifdef ZTS
673: zend_compiler_globals *compiler_globals;
674: zend_executor_globals *executor_globals;
675: extern ZEND_API ts_rsrc_id ini_scanner_globals_id;
676: extern ZEND_API ts_rsrc_id language_scanner_globals_id;
677: #else
678: extern zend_ini_scanner_globals ini_scanner_globals;
679: extern zend_php_scanner_globals language_scanner_globals;
680: #endif
681:
682: start_memory_manager(TSRMLS_C);
683:
684: #if defined(__FreeBSD__) || defined(__DragonFly__)
685: /* FreeBSD and DragonFly floating point precision fix */
686: fpsetmask(0);
687: #endif
688:
689: zend_startup_strtod();
690: zend_startup_extensions_mechanism();
691:
692: /* Set up utility functions and values */
693: zend_error_cb = utility_functions->error_function;
694: zend_printf = utility_functions->printf_function;
695: zend_write = (zend_write_func_t) utility_functions->write_function;
696: zend_fopen = utility_functions->fopen_function;
697: if (!zend_fopen) {
698: zend_fopen = zend_fopen_wrapper;
699: }
700: zend_stream_open_function = utility_functions->stream_open_function;
701: zend_message_dispatcher_p = utility_functions->message_handler;
702: zend_block_interruptions = utility_functions->block_interruptions;
703: zend_unblock_interruptions = utility_functions->unblock_interruptions;
704: zend_get_configuration_directive_p = utility_functions->get_configuration_directive;
705: zend_ticks_function = utility_functions->ticks_function;
706: zend_on_timeout = utility_functions->on_timeout;
707: zend_vspprintf = utility_functions->vspprintf_function;
708: zend_getenv = utility_functions->getenv_function;
709: zend_resolve_path = utility_functions->resolve_path_function;
710:
711: zend_compile_file = compile_file;
712: zend_compile_string = compile_string;
713: zend_execute = execute;
714: zend_execute_internal = NULL;
715: zend_throw_exception_hook = NULL;
716:
717: zend_init_opcodes_handlers();
718:
719: /* set up version */
720: zend_version_info = strdup(ZEND_CORE_VERSION_INFO);
721: zend_version_info_length = sizeof(ZEND_CORE_VERSION_INFO) - 1;
722:
723: GLOBAL_FUNCTION_TABLE = (HashTable *) malloc(sizeof(HashTable));
724: GLOBAL_CLASS_TABLE = (HashTable *) malloc(sizeof(HashTable));
725: GLOBAL_AUTO_GLOBALS_TABLE = (HashTable *) malloc(sizeof(HashTable));
726: GLOBAL_CONSTANTS_TABLE = (HashTable *) malloc(sizeof(HashTable));
727:
728: zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
729: zend_hash_init_ex(GLOBAL_CLASS_TABLE, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
730: zend_hash_init_ex(GLOBAL_AUTO_GLOBALS_TABLE, 8, NULL, (dtor_func_t) zend_auto_global_dtor, 1, 0);
731: zend_hash_init_ex(GLOBAL_CONSTANTS_TABLE, 20, NULL, ZEND_CONSTANT_DTOR, 1, 0);
732:
733: zend_hash_init_ex(&module_registry, 50, NULL, ZEND_MODULE_DTOR, 1, 0);
734: zend_init_rsrc_list_dtors();
735:
736: /* This zval can be used to initialize allocate zval's to an uninit'ed value */
737: Z_UNSET_ISREF(zval_used_for_init);
738: Z_SET_REFCOUNT(zval_used_for_init, 1);
739: Z_TYPE(zval_used_for_init) = IS_NULL;
740:
741: #ifdef ZTS
742: ts_allocate_id(&compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
743: ts_allocate_id(&executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
744: ts_allocate_id(&language_scanner_globals_id, sizeof(zend_php_scanner_globals), (ts_allocate_ctor) php_scanner_globals_ctor, NULL);
745: ts_allocate_id(&ini_scanner_globals_id, sizeof(zend_ini_scanner_globals), (ts_allocate_ctor) ini_scanner_globals_ctor, NULL);
746: compiler_globals = ts_resource(compiler_globals_id);
747: executor_globals = ts_resource(executor_globals_id);
748:
749: compiler_globals_dtor(compiler_globals TSRMLS_CC);
750: compiler_globals->in_compilation = 0;
751: compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
752: compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable));
753:
754: *compiler_globals->function_table = *GLOBAL_FUNCTION_TABLE;
755: *compiler_globals->class_table = *GLOBAL_CLASS_TABLE;
756: compiler_globals->auto_globals = GLOBAL_AUTO_GLOBALS_TABLE;
757:
758: zend_hash_destroy(executor_globals->zend_constants);
759: *executor_globals->zend_constants = *GLOBAL_CONSTANTS_TABLE;
760: #else
761: ini_scanner_globals_ctor(&ini_scanner_globals TSRMLS_CC);
762: php_scanner_globals_ctor(&language_scanner_globals TSRMLS_CC);
763: zend_set_default_compile_time_values(TSRMLS_C);
764: EG(user_error_handler) = NULL;
765: EG(user_exception_handler) = NULL;
766: #endif
767:
768: zend_startup_builtin_functions(TSRMLS_C);
769: zend_register_standard_constants(TSRMLS_C);
770: zend_register_auto_global("GLOBALS", sizeof("GLOBALS") - 1, NULL TSRMLS_CC);
771:
772: #ifndef ZTS
773: zend_init_rsrc_plist(TSRMLS_C);
774: zend_init_exception_op(TSRMLS_C);
775: #endif
776:
777: zend_ini_startup(TSRMLS_C);
778:
779: #ifdef ZTS
780: tsrm_set_new_thread_end_handler(zend_new_thread_end_handler);
781: #endif
782:
783: return SUCCESS;
784: }
785: /* }}} */
786:
787: void zend_register_standard_ini_entries(TSRMLS_D) /* {{{ */
788: {
789: int module_number = 0;
790:
791: REGISTER_INI_ENTRIES();
792: }
793: /* }}} */
794:
795: /* Unlink the global (r/o) copies of the class, function and constant tables,
796: * and use a fresh r/w copy for the startup thread
797: */
798: void zend_post_startup(TSRMLS_D) /* {{{ */
799: {
800: #ifdef ZTS
801: zend_compiler_globals *compiler_globals = ts_resource(compiler_globals_id);
802: zend_executor_globals *executor_globals = ts_resource(executor_globals_id);
803:
804: *GLOBAL_FUNCTION_TABLE = *compiler_globals->function_table;
805: *GLOBAL_CLASS_TABLE = *compiler_globals->class_table;
806: *GLOBAL_CONSTANTS_TABLE = *executor_globals->zend_constants;
807:
808: asp_tags_default = CG(asp_tags);
809: short_tags_default = CG(short_tags);
810: ct_pass_ref_default = CG(allow_call_time_pass_reference);
811: compiler_options_default = CG(compiler_options);
812:
813: zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC);
814: free(compiler_globals->function_table);
815: free(compiler_globals->class_table);
816: compiler_globals_ctor(compiler_globals, tsrm_ls);
817: free(EG(zend_constants));
818: executor_globals_ctor(executor_globals, tsrm_ls);
819: global_persistent_list = &EG(persistent_list);
820: zend_copy_ini_directives(TSRMLS_C);
821: #endif
822: }
823: /* }}} */
824:
825: void zend_shutdown(TSRMLS_D) /* {{{ */
826: {
827: #ifdef ZEND_WIN32
828: zend_shutdown_timeout_thread();
829: #endif
830: zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC);
831: zend_hash_graceful_reverse_destroy(&module_registry);
832:
833: zend_hash_destroy(GLOBAL_FUNCTION_TABLE);
834: zend_hash_destroy(GLOBAL_CLASS_TABLE);
835:
836: zend_hash_destroy(GLOBAL_AUTO_GLOBALS_TABLE);
837: free(GLOBAL_AUTO_GLOBALS_TABLE);
838:
839: zend_shutdown_extensions(TSRMLS_C);
840: free(zend_version_info);
841:
842: free(GLOBAL_FUNCTION_TABLE);
843: free(GLOBAL_CLASS_TABLE);
844:
845: zend_hash_destroy(GLOBAL_CONSTANTS_TABLE);
846: free(GLOBAL_CONSTANTS_TABLE);
847: zend_shutdown_strtod();
848:
849: #ifdef ZTS
850: GLOBAL_FUNCTION_TABLE = NULL;
851: GLOBAL_CLASS_TABLE = NULL;
852: GLOBAL_AUTO_GLOBALS_TABLE = NULL;
853: GLOBAL_CONSTANTS_TABLE = NULL;
854: #endif
855: zend_destroy_rsrc_list_dtors();
856: }
857: /* }}} */
858:
859: void zend_set_utility_values(zend_utility_values *utility_values) /* {{{ */
860: {
861: zend_uv = *utility_values;
862: zend_uv.import_use_extension_length = strlen(zend_uv.import_use_extension);
863: }
864: /* }}} */
865:
866: /* this should be compatible with the standard zenderror */
867: void zenderror(const char *error) /* {{{ */
868: {
869: zend_error(E_PARSE, "%s", error);
870: }
871: /* }}} */
872:
873: BEGIN_EXTERN_C()
874: ZEND_API void _zend_bailout(char *filename, uint lineno) /* {{{ */
875: {
876: TSRMLS_FETCH();
877:
878: if (!EG(bailout)) {
879: zend_output_debug_string(1, "%s(%d) : Bailed out without a bailout address!", filename, lineno);
880: exit(-1);
881: }
882: CG(unclean_shutdown) = 1;
883: CG(active_class_entry) = NULL;
884: CG(in_compilation) = EG(in_execution) = 0;
885: EG(current_execute_data) = NULL;
886: LONGJMP(*EG(bailout), FAILURE);
887: }
888: /* }}} */
889: END_EXTERN_C()
890:
891: void zend_append_version_info(const zend_extension *extension) /* {{{ */
892: {
893: char *new_info;
894: uint new_info_length;
895:
896: new_info_length = sizeof(" with v, , by \n")
897: + strlen(extension->name)
898: + strlen(extension->version)
899: + strlen(extension->copyright)
900: + strlen(extension->author);
901:
902: new_info = (char *) malloc(new_info_length + 1);
903:
904: snprintf(new_info, new_info_length, " with %s v%s, %s, by %s\n", extension->name, extension->version, extension->copyright, extension->author);
905:
906: zend_version_info = (char *) realloc(zend_version_info, zend_version_info_length+new_info_length + 1);
907: strncat(zend_version_info, new_info, new_info_length);
908: zend_version_info_length += new_info_length;
909: free(new_info);
910: }
911: /* }}} */
912:
913: ZEND_API char *get_zend_version(void) /* {{{ */
914: {
915: return zend_version_info;
916: }
917: /* }}} */
918:
919: void zend_activate(TSRMLS_D) /* {{{ */
920: {
921: gc_reset(TSRMLS_C);
922: init_compiler(TSRMLS_C);
923: init_executor(TSRMLS_C);
924: startup_scanner(TSRMLS_C);
925: }
926: /* }}} */
927:
928: void zend_activate_modules(TSRMLS_D) /* {{{ */
929: {
930: zend_hash_apply(&module_registry, (apply_func_t) module_registry_request_startup TSRMLS_CC);
931: }
932: /* }}} */
933:
934: void zend_deactivate_modules(TSRMLS_D) /* {{{ */
935: {
936: EG(opline_ptr) = NULL; /* we're no longer executing anything */
937:
938: zend_try {
939: zend_hash_reverse_apply(&module_registry, (apply_func_t) module_registry_cleanup TSRMLS_CC);
940: } zend_end_try();
941: }
942: /* }}} */
943:
944: void zend_call_destructors(TSRMLS_D) /* {{{ */
945: {
946: zend_try {
947: shutdown_destructors(TSRMLS_C);
948: } zend_end_try();
949: }
950: /* }}} */
951:
952: void zend_deactivate(TSRMLS_D) /* {{{ */
953: {
954: /* we're no longer executing anything */
955: EG(opline_ptr) = NULL;
956: EG(active_symbol_table) = NULL;
957:
958: zend_try {
959: shutdown_scanner(TSRMLS_C);
960: } zend_end_try();
961:
962: /* shutdown_executor() takes care of its own bailout handling */
963: shutdown_executor(TSRMLS_C);
964:
965: zend_try {
966: shutdown_compiler(TSRMLS_C);
967: } zend_end_try();
968:
969: zend_destroy_rsrc_list(&EG(regular_list) TSRMLS_CC);
970:
971: #ifdef ZEND_DEBUG
972: if (GC_G(gc_enabled) && !CG(unclean_shutdown)) {
973: gc_collect_cycles(TSRMLS_C);
974: }
975: #endif
976:
977: #if GC_BENCH
978: fprintf(stderr, "GC Statistics\n");
979: fprintf(stderr, "-------------\n");
980: fprintf(stderr, "Runs: %d\n", GC_G(gc_runs));
981: fprintf(stderr, "Collected: %d\n", GC_G(collected));
982: fprintf(stderr, "Root buffer length: %d\n", GC_G(root_buf_length));
983: fprintf(stderr, "Root buffer peak: %d\n\n", GC_G(root_buf_peak));
984: fprintf(stderr, " Possible Remove from Marked\n");
985: fprintf(stderr, " Root Buffered buffer grey\n");
986: fprintf(stderr, " -------- -------- ----------- ------\n");
987: fprintf(stderr, "ZVAL %8d %8d %9d %8d\n", GC_G(zval_possible_root), GC_G(zval_buffered), GC_G(zval_remove_from_buffer), GC_G(zval_marked_grey));
988: fprintf(stderr, "ZOBJ %8d %8d %9d %8d\n", GC_G(zobj_possible_root), GC_G(zobj_buffered), GC_G(zobj_remove_from_buffer), GC_G(zobj_marked_grey));
989: #endif
990:
991: zend_try {
992: zend_ini_deactivate(TSRMLS_C);
993: } zend_end_try();
994: }
995: /* }}} */
996:
997: static int exec_done_cb(zend_module_entry *module TSRMLS_DC) /* {{{ */
998: {
999: if (module->post_deactivate_func) {
1000: module->post_deactivate_func();
1001: }
1002: return 0;
1003: }
1004: /* }}} */
1005:
1006: void zend_post_deactivate_modules(TSRMLS_D) /* {{{ */
1007: {
1008: zend_hash_apply(&module_registry, (apply_func_t) exec_done_cb TSRMLS_CC);
1009: zend_hash_reverse_apply(&module_registry, (apply_func_t) module_registry_unload_temp TSRMLS_CC);
1010: }
1011: /* }}} */
1012:
1013: BEGIN_EXTERN_C()
1014: ZEND_API void zend_message_dispatcher(long message, void *data TSRMLS_DC) /* {{{ */
1015: {
1016: if (zend_message_dispatcher_p) {
1017: zend_message_dispatcher_p(message, data TSRMLS_CC);
1018: }
1019: }
1020: /* }}} */
1021: END_EXTERN_C()
1022:
1023: ZEND_API int zend_get_configuration_directive(const char *name, uint name_length, zval *contents) /* {{{ */
1024: {
1025: if (zend_get_configuration_directive_p) {
1026: return zend_get_configuration_directive_p(name, name_length, contents);
1027: } else {
1028: return FAILURE;
1029: }
1030: }
1031: /* }}} */
1032:
1033: #define SAVE_STACK(stack) do { \
1034: if (CG(stack).top) { \
1035: memcpy(&stack, &CG(stack), sizeof(zend_stack)); \
1036: CG(stack).top = CG(stack).max = 0; \
1037: CG(stack).elements = NULL; \
1038: } else { \
1039: stack.top = 0; \
1040: } \
1041: } while (0)
1042:
1043: #define RESTORE_STACK(stack) do { \
1044: if (stack.top) { \
1045: zend_stack_destroy(&CG(stack)); \
1046: memcpy(&CG(stack), &stack, sizeof(zend_stack)); \
1047: } \
1048: } while (0)
1049:
1050: ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
1051: {
1052: va_list args;
1053: va_list usr_copy;
1054: zval ***params;
1055: zval *retval;
1056: zval *z_error_type, *z_error_message, *z_error_filename, *z_error_lineno, *z_context;
1057: char *error_filename;
1058: uint error_lineno;
1059: zval *orig_user_error_handler;
1060: zend_bool in_compilation;
1061: zend_class_entry *saved_class_entry;
1062: zend_stack bp_stack;
1063: zend_stack function_call_stack;
1064: zend_stack switch_cond_stack;
1065: zend_stack foreach_copy_stack;
1066: zend_stack object_stack;
1067: zend_stack declare_stack;
1068: zend_stack list_stack;
1069: zend_stack labels_stack;
1070: TSRMLS_FETCH();
1071:
1072: /* Obtain relevant filename and lineno */
1073: switch (type) {
1074: case E_CORE_ERROR:
1075: case E_CORE_WARNING:
1076: error_filename = NULL;
1077: error_lineno = 0;
1078: break;
1079: case E_PARSE:
1080: case E_COMPILE_ERROR:
1081: case E_COMPILE_WARNING:
1082: case E_ERROR:
1083: case E_NOTICE:
1084: case E_STRICT:
1085: case E_DEPRECATED:
1086: case E_WARNING:
1087: case E_USER_ERROR:
1088: case E_USER_WARNING:
1089: case E_USER_NOTICE:
1090: case E_USER_DEPRECATED:
1091: case E_RECOVERABLE_ERROR:
1092: if (zend_is_compiling(TSRMLS_C)) {
1093: error_filename = zend_get_compiled_filename(TSRMLS_C);
1094: error_lineno = zend_get_compiled_lineno(TSRMLS_C);
1095: } else if (zend_is_executing(TSRMLS_C)) {
1096: error_filename = zend_get_executed_filename(TSRMLS_C);
1097: error_lineno = zend_get_executed_lineno(TSRMLS_C);
1098: } else {
1099: error_filename = NULL;
1100: error_lineno = 0;
1101: }
1102: break;
1103: default:
1104: error_filename = NULL;
1105: error_lineno = 0;
1106: break;
1107: }
1108: if (!error_filename) {
1109: error_filename = "Unknown";
1110: }
1111:
1112: va_start(args, format);
1113:
1114: /* if we don't have a user defined error handler */
1115: if (!EG(user_error_handler)
1116: || !(EG(user_error_handler_error_reporting) & type)
1117: || EG(error_handling) != EH_NORMAL) {
1118: zend_error_cb(type, error_filename, error_lineno, format, args);
1119: } else switch (type) {
1120: case E_ERROR:
1121: case E_PARSE:
1122: case E_CORE_ERROR:
1123: case E_CORE_WARNING:
1124: case E_COMPILE_ERROR:
1125: case E_COMPILE_WARNING:
1126: /* The error may not be safe to handle in user-space */
1127: zend_error_cb(type, error_filename, error_lineno, format, args);
1128: break;
1129: default:
1130: /* Handle the error in user space */
1131: ALLOC_INIT_ZVAL(z_error_message);
1132: ALLOC_INIT_ZVAL(z_error_type);
1133: ALLOC_INIT_ZVAL(z_error_filename);
1134: ALLOC_INIT_ZVAL(z_error_lineno);
1135: ALLOC_INIT_ZVAL(z_context);
1136:
1137: /* va_copy() is __va_copy() in old gcc versions.
1138: * According to the autoconf manual, using
1139: * memcpy(&dst, &src, sizeof(va_list))
1140: * gives maximum portability. */
1141: #ifndef va_copy
1142: # ifdef __va_copy
1143: # define va_copy(dest, src) __va_copy((dest), (src))
1144: # else
1145: # define va_copy(dest, src) memcpy(&(dest), &(src), sizeof(va_list))
1146: # endif
1147: #endif
1148: va_copy(usr_copy, args);
1149: Z_STRLEN_P(z_error_message) = zend_vspprintf(&Z_STRVAL_P(z_error_message), 0, format, usr_copy);
1150: #ifdef va_copy
1151: va_end(usr_copy);
1152: #endif
1153: Z_TYPE_P(z_error_message) = IS_STRING;
1154:
1155: Z_LVAL_P(z_error_type) = type;
1156: Z_TYPE_P(z_error_type) = IS_LONG;
1157:
1158: if (error_filename) {
1159: ZVAL_STRING(z_error_filename, error_filename, 1);
1160: }
1161:
1162: Z_LVAL_P(z_error_lineno) = error_lineno;
1163: Z_TYPE_P(z_error_lineno) = IS_LONG;
1164:
1165: if (!EG(active_symbol_table)) {
1166: zend_rebuild_symbol_table(TSRMLS_C);
1167: }
1168:
1169: /* during shutdown the symbol table table can be still null */
1170: if (!EG(active_symbol_table)) {
1171: Z_TYPE_P(z_context) = IS_NULL;
1172: } else {
1173: Z_ARRVAL_P(z_context) = EG(active_symbol_table);
1174: Z_TYPE_P(z_context) = IS_ARRAY;
1175: zval_copy_ctor(z_context);
1176: }
1177:
1178: params = (zval ***) emalloc(sizeof(zval **)*5);
1179: params[0] = &z_error_type;
1180: params[1] = &z_error_message;
1181: params[2] = &z_error_filename;
1182: params[3] = &z_error_lineno;
1183: params[4] = &z_context;
1184:
1185: orig_user_error_handler = EG(user_error_handler);
1186: EG(user_error_handler) = NULL;
1187:
1188: /* User error handler may include() additinal PHP files.
1189: * If an error was generated during comilation PHP will compile
1190: * such scripts recursivly, but some CG() variables may be
1191: * inconsistent. */
1192:
1193: in_compilation = zend_is_compiling(TSRMLS_C);
1194: if (in_compilation) {
1195: saved_class_entry = CG(active_class_entry);
1196: CG(active_class_entry) = NULL;
1197: SAVE_STACK(bp_stack);
1198: SAVE_STACK(function_call_stack);
1199: SAVE_STACK(switch_cond_stack);
1200: SAVE_STACK(foreach_copy_stack);
1201: SAVE_STACK(object_stack);
1202: SAVE_STACK(declare_stack);
1203: SAVE_STACK(list_stack);
1204: SAVE_STACK(labels_stack);
1205: }
1206:
1207: if (call_user_function_ex(CG(function_table), NULL, orig_user_error_handler, &retval, 5, params, 1, NULL TSRMLS_CC) == SUCCESS) {
1208: if (retval) {
1209: if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
1210: zend_error_cb(type, error_filename, error_lineno, format, args);
1211: }
1212: zval_ptr_dtor(&retval);
1213: }
1214: } else if (!EG(exception)) {
1215: /* The user error handler failed, use built-in error handler */
1216: zend_error_cb(type, error_filename, error_lineno, format, args);
1217: }
1218:
1219: if (in_compilation) {
1220: CG(active_class_entry) = saved_class_entry;
1221: RESTORE_STACK(bp_stack);
1222: RESTORE_STACK(function_call_stack);
1223: RESTORE_STACK(switch_cond_stack);
1224: RESTORE_STACK(foreach_copy_stack);
1225: RESTORE_STACK(object_stack);
1226: RESTORE_STACK(declare_stack);
1227: RESTORE_STACK(list_stack);
1228: RESTORE_STACK(labels_stack);
1229: }
1230:
1231: if (!EG(user_error_handler)) {
1232: EG(user_error_handler) = orig_user_error_handler;
1233: }
1234: else {
1235: zval_ptr_dtor(&orig_user_error_handler);
1236: }
1237:
1238: efree(params);
1239: zval_ptr_dtor(&z_error_message);
1240: zval_ptr_dtor(&z_error_type);
1241: zval_ptr_dtor(&z_error_filename);
1242: zval_ptr_dtor(&z_error_lineno);
1243: zval_ptr_dtor(&z_context);
1244: break;
1245: }
1246:
1247: va_end(args);
1248:
1249: if (type == E_PARSE) {
1250: EG(exit_status) = 255;
1251: zend_init_compiler_data_structures(TSRMLS_C);
1252: }
1253: }
1254: /* }}} */
1255:
1256: #if defined(__GNUC__) && __GNUC__ >= 3 && !defined(__INTEL_COMPILER) && !defined(DARWIN) && !defined(__hpux) && !defined(_AIX) && !defined(__osf__)
1257: void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((alias("zend_error"),noreturn));
1258: #endif
1259:
1260: ZEND_API void zend_output_debug_string(zend_bool trigger_break, const char *format, ...) /* {{{ */
1261: {
1262: #if ZEND_DEBUG
1263: va_list args;
1264:
1265: va_start(args, format);
1266: # ifdef ZEND_WIN32
1267: {
1268: char output_buf[1024];
1269:
1270: vsnprintf(output_buf, 1024, format, args);
1271: OutputDebugString(output_buf);
1272: OutputDebugString("\n");
1273: if (trigger_break && IsDebuggerPresent()) {
1274: DebugBreak();
1275: }
1276: }
1277: # else
1278: vfprintf(stderr, format, args);
1279: fprintf(stderr, "\n");
1280: # endif
1281: va_end(args);
1282: #endif
1283: }
1284: /* }}} */
1285:
1286: ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_count, ...) /* {{{ */
1287: {
1288: va_list files;
1289: int i;
1290: zend_file_handle *file_handle;
1291: zend_op_array *orig_op_array = EG(active_op_array);
1292: zval **orig_retval_ptr_ptr = EG(return_value_ptr_ptr);
1293:
1294: va_start(files, file_count);
1295: for (i = 0; i < file_count; i++) {
1296: file_handle = va_arg(files, zend_file_handle *);
1297: if (!file_handle) {
1298: continue;
1299: }
1300: EG(active_op_array) = zend_compile_file(file_handle, type TSRMLS_CC);
1301: if (file_handle->opened_path) {
1302: int dummy = 1;
1303: zend_hash_add(&EG(included_files), file_handle->opened_path, strlen(file_handle->opened_path) + 1, (void *)&dummy, sizeof(int), NULL);
1304: }
1305: zend_destroy_file_handle(file_handle TSRMLS_CC);
1306: if (EG(active_op_array)) {
1307: EG(return_value_ptr_ptr) = retval ? retval : NULL;
1308: zend_execute(EG(active_op_array) TSRMLS_CC);
1309: zend_exception_restore(TSRMLS_C);
1310: if (EG(exception)) {
1311: if (EG(user_exception_handler)) {
1312: zval *orig_user_exception_handler;
1313: zval **params[1], *retval2, *old_exception;
1314: old_exception = EG(exception);
1315: EG(exception) = NULL;
1316: params[0] = &old_exception;
1317: orig_user_exception_handler = EG(user_exception_handler);
1318: if (call_user_function_ex(CG(function_table), NULL, orig_user_exception_handler, &retval2, 1, params, 1, NULL TSRMLS_CC) == SUCCESS) {
1319: if (retval2 != NULL) {
1320: zval_ptr_dtor(&retval2);
1321: }
1322: if (EG(exception)) {
1323: zval_ptr_dtor(&EG(exception));
1324: EG(exception) = NULL;
1325: }
1326: zval_ptr_dtor(&old_exception);
1327: } else {
1328: EG(exception) = old_exception;
1329: zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
1330: }
1331: } else {
1332: zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
1333: }
1334: }
1335: destroy_op_array(EG(active_op_array) TSRMLS_CC);
1336: efree(EG(active_op_array));
1337: } else if (type==ZEND_REQUIRE) {
1338: va_end(files);
1339: EG(active_op_array) = orig_op_array;
1340: EG(return_value_ptr_ptr) = orig_retval_ptr_ptr;
1341: return FAILURE;
1342: }
1343: }
1344: va_end(files);
1345: EG(active_op_array) = orig_op_array;
1346: EG(return_value_ptr_ptr) = orig_retval_ptr_ptr;
1347:
1348: return SUCCESS;
1349: }
1350: /* }}} */
1351:
1352: #define COMPILED_STRING_DESCRIPTION_FORMAT "%s(%d) : %s"
1353:
1354: ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC) /* {{{ */
1355: {
1356: char *cur_filename;
1357: int cur_lineno;
1358: char *compiled_string_description;
1359:
1360: if (zend_is_compiling(TSRMLS_C)) {
1361: cur_filename = zend_get_compiled_filename(TSRMLS_C);
1362: cur_lineno = zend_get_compiled_lineno(TSRMLS_C);
1363: } else if (zend_is_executing(TSRMLS_C)) {
1364: cur_filename = zend_get_executed_filename(TSRMLS_C);
1365: cur_lineno = zend_get_executed_lineno(TSRMLS_C);
1366: } else {
1367: cur_filename = "Unknown";
1368: cur_lineno = 0;
1369: }
1370:
1371: zend_spprintf(&compiled_string_description, 0, COMPILED_STRING_DESCRIPTION_FORMAT, cur_filename, cur_lineno, name);
1372: return compiled_string_description;
1373: }
1374: /* }}} */
1375:
1376: void free_estring(char **str_p) /* {{{ */
1377: {
1378: efree(*str_p);
1379: }
1380: /* }}} */
1381:
1382: /*
1383: * Local variables:
1384: * tab-width: 4
1385: * c-basic-offset: 4
1386: * indent-tabs-mode: t
1387: * End:
1388: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend.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