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