![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to var.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 / ext / standard|
Return to var.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
1.1.1.3 ! misho 5: | Copyright (c) 1997-2013 The PHP Group |
1.1 misho 6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP 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.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
1.1.1.2 misho 15: | Authors: Jani Lehtimäki <jkl@njet.net> |
1.1 misho 16: | Thies C. Arntzen <thies@thieso.net> |
17: | Sascha Schumann <sascha@schumann.cx> |
18: +----------------------------------------------------------------------+
19: */
20:
1.1.1.2 misho 21: /* $Id$ */
1.1 misho 22:
23: /* {{{ includes
24: */
25: #include <stdio.h>
26: #include <stdlib.h>
27: #include <errno.h>
28: #include "php.h"
29: #include "php_string.h"
30: #include "php_var.h"
31: #include "php_smart_str.h"
32: #include "basic_functions.h"
33: #include "php_incomplete_class.h"
34:
35: #define COMMON (Z_ISREF_PP(struc) ? "&" : "")
36: /* }}} */
37:
38: static int php_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
39: {
40: int level;
41:
42: level = va_arg(args, int);
43:
44: if (hash_key->nKeyLength == 0) { /* numeric key */
45: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
46: } else { /* string key */
47: php_printf("%*c[\"", level + 1, ' ');
48: PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
49: php_printf("\"]=>\n");
50: }
51: php_var_dump(zv, level + 2 TSRMLS_CC);
52: return 0;
53: }
54: /* }}} */
55:
56: static int php_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
57: {
58: int level;
1.1.1.2 misho 59: const char *prop_name, *class_name;
1.1 misho 60:
61: level = va_arg(args, int);
62:
63: if (hash_key->nKeyLength == 0) { /* numeric key */
64: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
65: } else { /* string key */
66: int unmangle = zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
67: php_printf("%*c[", level + 1, ' ');
68:
69: if (class_name && unmangle == SUCCESS) {
70: if (class_name[0] == '*') {
71: php_printf("\"%s\":protected", prop_name);
72: } else {
73: php_printf("\"%s\":\"%s\":private", prop_name, class_name);
74: }
75: } else {
76: php_printf("\"");
77: PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
78: php_printf("\"");
79: }
80: ZEND_PUTS("]=>\n");
81: }
82: php_var_dump(zv, level + 2 TSRMLS_CC);
83: return 0;
84: }
85: /* }}} */
86:
87: PHPAPI void php_var_dump(zval **struc, int level TSRMLS_DC) /* {{{ */
88: {
89: HashTable *myht;
1.1.1.2 misho 90: const char *class_name;
1.1 misho 91: zend_uint class_name_len;
92: int (*php_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
93: int is_temp;
94:
95: if (level > 1) {
96: php_printf("%*c", level - 1, ' ');
97: }
98:
99: switch (Z_TYPE_PP(struc)) {
100: case IS_BOOL:
101: php_printf("%sbool(%s)\n", COMMON, Z_LVAL_PP(struc) ? "true" : "false");
102: break;
103: case IS_NULL:
104: php_printf("%sNULL\n", COMMON);
105: break;
106: case IS_LONG:
107: php_printf("%sint(%ld)\n", COMMON, Z_LVAL_PP(struc));
108: break;
109: case IS_DOUBLE:
110: php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc));
111: break;
112: case IS_STRING:
113: php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
114: PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
115: PUTS("\"\n");
116: break;
117: case IS_ARRAY:
118: myht = Z_ARRVAL_PP(struc);
119: if (++myht->nApplyCount > 1) {
120: PUTS("*RECURSION*\n");
121: --myht->nApplyCount;
122: return;
123: }
124: php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht));
125: php_element_dump_func = php_array_element_dump;
126: is_temp = 0;
127: goto head_done;
128: case IS_OBJECT:
129: myht = Z_OBJDEBUG_PP(struc, is_temp);
130: if (myht && ++myht->nApplyCount > 1) {
131: PUTS("*RECURSION*\n");
132: --myht->nApplyCount;
133: return;
134: }
135:
1.1.1.2 misho 136: if (Z_OBJ_HANDLER(**struc, get_class_name)) {
137: Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
138: php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0);
139: efree((char*)class_name);
140: } else {
141: php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0);
142: }
1.1 misho 143: php_element_dump_func = php_object_property_dump;
144: head_done:
145: if (myht) {
146: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level);
147: --myht->nApplyCount;
148: if (is_temp) {
149: zend_hash_destroy(myht);
150: efree(myht);
151: }
152: }
153: if (level > 1) {
154: php_printf("%*c", level-1, ' ');
155: }
156: PUTS("}\n");
157: break;
158: case IS_RESOURCE: {
1.1.1.2 misho 159: const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
1.1 misho 160: php_printf("%sresource(%ld) of type (%s)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown");
161: break;
162: }
163: default:
164: php_printf("%sUNKNOWN:0\n", COMMON);
165: break;
166: }
167: }
168: /* }}} */
169:
170: /* {{{ proto void var_dump(mixed var)
171: Dumps a string representation of variable to output */
172: PHP_FUNCTION(var_dump)
173: {
174: zval ***args;
175: int argc;
176: int i;
177:
178: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
179: return;
180: }
181:
182: for (i = 0; i < argc; i++) {
183: php_var_dump(args[i], 1 TSRMLS_CC);
184: }
185: efree(args);
186: }
187: /* }}} */
188:
189: static int zval_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
190: {
191: int level;
192:
193: level = va_arg(args, int);
194:
195: if (hash_key->nKeyLength == 0) { /* numeric key */
196: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
197: } else { /* string key */
198: /* XXX: perphaps when we are inside the class we should permit access to
199: * private & protected values
200: */
201: if (va_arg(args, int) && hash_key->arKey[0] == '\0') {
202: return 0;
203: }
204: php_printf("%*c[\"", level + 1, ' ');
205: PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
206: php_printf("\"]=>\n");
207: }
208: php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
209: return 0;
210: }
211: /* }}} */
212:
213: static int zval_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
214: {
215: int level;
1.1.1.2 misho 216: const char *prop_name, *class_name;
1.1 misho 217:
218: level = va_arg(args, int);
219:
220: if (hash_key->nKeyLength == 0) { /* numeric key */
221: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
222: } else { /* string key */
223: zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
224: php_printf("%*c[", level + 1, ' ');
225:
226: if (class_name) {
227: if (class_name[0] == '*') {
228: php_printf("\"%s\":protected", prop_name);
229: } else {
230: php_printf("\"%s\":\"%s\":private", prop_name, class_name);
231: }
232: } else {
233: php_printf("\"%s\"", prop_name);
234: }
235: ZEND_PUTS("]=>\n");
236: }
237: php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
238: return 0;
239: }
240: /* }}} */
241:
242: PHPAPI void php_debug_zval_dump(zval **struc, int level TSRMLS_DC) /* {{{ */
243: {
244: HashTable *myht = NULL;
1.1.1.2 misho 245: const char *class_name;
1.1 misho 246: zend_uint class_name_len;
247: int (*zval_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
248: int is_temp = 0;
249:
250: if (level > 1) {
251: php_printf("%*c", level - 1, ' ');
252: }
253:
254: switch (Z_TYPE_PP(struc)) {
255: case IS_BOOL:
256: php_printf("%sbool(%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc)?"true":"false", Z_REFCOUNT_PP(struc));
257: break;
258: case IS_NULL:
259: php_printf("%sNULL refcount(%u)\n", COMMON, Z_REFCOUNT_PP(struc));
260: break;
261: case IS_LONG:
262: php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc));
263: break;
264: case IS_DOUBLE:
265: php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc), Z_REFCOUNT_PP(struc));
266: break;
267: case IS_STRING:
268: php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
269: PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
270: php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc));
271: break;
272: case IS_ARRAY:
273: myht = Z_ARRVAL_PP(struc);
274: if (myht->nApplyCount > 1) {
275: PUTS("*RECURSION*\n");
276: return;
277: }
278: php_printf("%sarray(%d) refcount(%u){\n", COMMON, zend_hash_num_elements(myht), Z_REFCOUNT_PP(struc));
279: zval_element_dump_func = zval_array_element_dump;
280: goto head_done;
281: case IS_OBJECT:
282: myht = Z_OBJDEBUG_PP(struc, is_temp);
283: if (myht && myht->nApplyCount > 1) {
284: PUTS("*RECURSION*\n");
285: return;
286: }
1.1.1.2 misho 287: Z_OBJ_HANDLER_PP(struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
288: php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_PP(struc));
289: efree((char*)class_name);
1.1 misho 290: zval_element_dump_func = zval_object_property_dump;
291: head_done:
292: if (myht) {
293: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) zval_element_dump_func, 1, level, (Z_TYPE_PP(struc) == IS_ARRAY ? 0 : 1));
294: if (is_temp) {
295: zend_hash_destroy(myht);
296: efree(myht);
297: }
298: }
299: if (level > 1) {
300: php_printf("%*c", level - 1, ' ');
301: }
302: PUTS("}\n");
303: break;
304: case IS_RESOURCE: {
1.1.1.2 misho 305: const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
1.1 misho 306: php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown", Z_REFCOUNT_PP(struc));
307: break;
308: }
309: default:
310: php_printf("%sUNKNOWN:0\n", COMMON);
311: break;
312: }
313: }
314: /* }}} */
315:
316: /* {{{ proto void debug_zval_dump(mixed var)
317: Dumps a string representation of an internal zend value to output. */
318: PHP_FUNCTION(debug_zval_dump)
319: {
320: zval ***args;
321: int argc;
322: int i;
323:
324: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
325: return;
326: }
327:
328: for (i = 0; i < argc; i++) {
329: php_debug_zval_dump(args[i], 1 TSRMLS_CC);
330: }
331: efree(args);
332: }
333: /* }}} */
334:
335: #define buffer_append_spaces(buf, num_spaces) \
336: do { \
337: char *tmp_spaces; \
338: int tmp_spaces_len; \
339: tmp_spaces_len = spprintf(&tmp_spaces, 0,"%*c", num_spaces, ' '); \
340: smart_str_appendl(buf, tmp_spaces, tmp_spaces_len); \
341: efree(tmp_spaces); \
342: } while(0);
343:
344: static int php_array_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
345: {
346: int level;
347: smart_str *buf;
348:
349: level = va_arg(args, int);
350: buf = va_arg(args, smart_str *);
351:
352: if (hash_key->nKeyLength == 0) { /* numeric key */
353: buffer_append_spaces(buf, level+1);
354: smart_str_append_long(buf, (long) hash_key->h);
355: smart_str_appendl(buf, " => ", 4);
1.1.1.2 misho 356:
1.1 misho 357: } else { /* string key */
358: char *key, *tmp_str;
359: int key_len, tmp_len;
360: key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
361: tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
362:
363: buffer_append_spaces(buf, level + 1);
364:
365: smart_str_appendc(buf, '\'');
366: smart_str_appendl(buf, tmp_str, tmp_len);
367: smart_str_appendl(buf, "' => ", 5);
368:
369: efree(key);
370: efree(tmp_str);
371: }
372: php_var_export_ex(zv, level + 2, buf TSRMLS_CC);
373:
374: smart_str_appendc(buf, ',');
375: smart_str_appendc(buf, '\n');
1.1.1.2 misho 376:
1.1 misho 377: return 0;
378: }
379: /* }}} */
380:
381: static int php_object_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
382: {
383: int level;
384: smart_str *buf;
385:
386: level = va_arg(args, int);
387: buf = va_arg(args, smart_str *);
388:
389: buffer_append_spaces(buf, level + 2);
390: if (hash_key->nKeyLength != 0) {
1.1.1.2 misho 391: const char *class_name; /* ignored, but must be passed to unmangle */
392: const char *pname;
393: char *pname_esc;
1.1 misho 394: int pname_esc_len;
395:
396: zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1,
397: &class_name, &pname);
398: pname_esc = php_addcslashes(pname, strlen(pname), &pname_esc_len, 0,
399: "'\\", 2 TSRMLS_CC);
400:
401: smart_str_appendc(buf, '\'');
402: smart_str_appendl(buf, pname_esc, pname_esc_len);
403: smart_str_appendc(buf, '\'');
404: efree(pname_esc);
405: } else {
1.1.1.2 misho 406: smart_str_append_long(buf, (long) hash_key->h);
1.1 misho 407: }
408: smart_str_appendl(buf, " => ", 4);
409: php_var_export_ex(zv, level + 2, buf TSRMLS_CC);
410: smart_str_appendc(buf, ',');
411: smart_str_appendc(buf, '\n');
412: return 0;
413: }
414: /* }}} */
415:
416: PHPAPI void php_var_export_ex(zval **struc, int level, smart_str *buf TSRMLS_DC) /* {{{ */
417: {
418: HashTable *myht;
419: char *tmp_str, *tmp_str2;
420: int tmp_len, tmp_len2;
1.1.1.2 misho 421: const char *class_name;
1.1 misho 422: zend_uint class_name_len;
423:
424: switch (Z_TYPE_PP(struc)) {
425: case IS_BOOL:
1.1.1.2 misho 426: if (Z_LVAL_PP(struc)) {
427: smart_str_appendl(buf, "true", 4);
428: } else {
429: smart_str_appendl(buf, "false", 5);
430: }
1.1 misho 431: break;
432: case IS_NULL:
433: smart_str_appendl(buf, "NULL", 4);
434: break;
435: case IS_LONG:
436: smart_str_append_long(buf, Z_LVAL_PP(struc));
437: break;
438: case IS_DOUBLE:
439: tmp_len = spprintf(&tmp_str, 0,"%.*H", (int) EG(precision), Z_DVAL_PP(struc));
440: smart_str_appendl(buf, tmp_str, tmp_len);
441: efree(tmp_str);
442: break;
443: case IS_STRING:
444: tmp_str = php_addcslashes(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc), &tmp_len, 0, "'\\", 2 TSRMLS_CC);
445: tmp_str2 = php_str_to_str_ex(tmp_str, tmp_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len2, 0, NULL);
446:
447: smart_str_appendc(buf, '\'');
448: smart_str_appendl(buf, tmp_str2, tmp_len2);
449: smart_str_appendc(buf, '\'');
450:
451: efree(tmp_str2);
452: efree(tmp_str);
453: break;
454: case IS_ARRAY:
455: myht = Z_ARRVAL_PP(struc);
1.1.1.3 ! misho 456: if(myht && myht->nApplyCount > 0){
! 457: smart_str_appendl(buf, "NULL", 4);
! 458: zend_error(E_WARNING, "var_export does not handle circular references");
! 459: return;
! 460: }
1.1 misho 461: if (level > 1) {
462: smart_str_appendc(buf, '\n');
463: buffer_append_spaces(buf, level - 1);
464: }
465: smart_str_appendl(buf, "array (\n", 8);
466: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_array_element_export, 2, level, buf);
467:
468: if (level > 1) {
469: buffer_append_spaces(buf, level - 1);
470: }
471: smart_str_appendc(buf, ')');
1.1.1.2 misho 472:
1.1 misho 473: break;
1.1.1.2 misho 474:
1.1 misho 475: case IS_OBJECT:
476: myht = Z_OBJPROP_PP(struc);
1.1.1.3 ! misho 477: if(myht && myht->nApplyCount > 0){
! 478: smart_str_appendl(buf, "NULL", 4);
! 479: zend_error(E_WARNING, "var_export does not handle circular references");
! 480: return;
! 481: }
1.1 misho 482: if (level > 1) {
483: smart_str_appendc(buf, '\n');
484: buffer_append_spaces(buf, level - 1);
485: }
486: Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
487:
488: smart_str_appendl(buf, class_name, class_name_len);
489: smart_str_appendl(buf, "::__set_state(array(\n", 21);
490:
1.1.1.2 misho 491: efree((char*)class_name);
1.1 misho 492: if (myht) {
1.1.1.2 misho 493: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_object_element_export, 1, level, buf);
1.1 misho 494: }
495: if (level > 1) {
496: buffer_append_spaces(buf, level - 1);
497: }
498: smart_str_appendl(buf, "))", 2);
499:
500: break;
501: default:
502: smart_str_appendl(buf, "NULL", 4);
503: break;
504: }
505: }
506: /* }}} */
507:
508: /* FOR BC reasons, this will always perform and then print */
509: PHPAPI void php_var_export(zval **struc, int level TSRMLS_DC) /* {{{ */
510: {
511: smart_str buf = {0};
512: php_var_export_ex(struc, level, &buf TSRMLS_CC);
513: smart_str_0 (&buf);
514: PHPWRITE(buf.c, buf.len);
515: smart_str_free(&buf);
516: }
517: /* }}} */
518:
1.1.1.2 misho 519:
1.1 misho 520: /* {{{ proto mixed var_export(mixed var [, bool return])
521: Outputs or returns a string representation of a variable */
522: PHP_FUNCTION(var_export)
523: {
524: zval *var;
525: zend_bool return_output = 0;
526: smart_str buf = {0};
527:
528: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &var, &return_output) == FAILURE) {
529: return;
530: }
531:
532: php_var_export_ex(&var, 1, &buf TSRMLS_CC);
533: smart_str_0 (&buf);
534:
535: if (return_output) {
536: RETVAL_STRINGL(buf.c, buf.len, 1);
537: } else {
538: PHPWRITE(buf.c, buf.len);
539: }
540: smart_str_free(&buf);
541: }
542: /* }}} */
543:
544: static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC);
545:
546: static inline int php_add_var_hash(HashTable *var_hash, zval *var, void *var_old TSRMLS_DC) /* {{{ */
547: {
548: ulong var_no;
549: char id[32], *p;
550: register int len;
551:
552: /* relies on "(long)" being a perfect hash function for data pointers,
553: * however the actual identity of an object has had to be determined
1.1.1.3 ! misho 554: * by its object handle since 5.0. */
1.1 misho 555: if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry) {
1.1.1.3 ! misho 556: p = smart_str_print_long(id + sizeof(id) - 1, (long) Z_OBJ_HANDLE_P(var));
1.1 misho 557: *(--p) = 'O';
558: len = id + sizeof(id) - 1 - p;
559: } else {
560: p = smart_str_print_long(id + sizeof(id) - 1, (long) var);
561: len = id + sizeof(id) - 1 - p;
562: }
563:
564: if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) {
565: if (!Z_ISREF_P(var)) {
566: /* we still need to bump up the counter, since non-refs will
567: * be counted separately by unserializer */
568: var_no = -1;
569: zend_hash_next_index_insert(var_hash, &var_no, sizeof(var_no), NULL);
570: }
1.1.1.2 misho 571: #if 0
572: fprintf(stderr, "- had var (%d): %lu\n", Z_TYPE_P(var), **(ulong**)var_old);
573: #endif
1.1 misho 574: return FAILURE;
575: }
576:
577: /* +1 because otherwise hash will think we are trying to store NULL pointer */
578: var_no = zend_hash_num_elements(var_hash) + 1;
579: zend_hash_add(var_hash, p, len, &var_no, sizeof(var_no), NULL);
1.1.1.2 misho 580: #if 0
581: fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), var_no);
582: #endif
1.1 misho 583: return SUCCESS;
584: }
585: /* }}} */
586:
587: static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */
588: {
589: smart_str_appendl(buf, "i:", 2);
590: smart_str_append_long(buf, val);
591: smart_str_appendc(buf, ';');
592: }
593: /* }}} */
594:
595: static inline void php_var_serialize_string(smart_str *buf, char *str, int len) /* {{{ */
596: {
597: smart_str_appendl(buf, "s:", 2);
598: smart_str_append_long(buf, len);
599: smart_str_appendl(buf, ":\"", 2);
600: smart_str_appendl(buf, str, len);
601: smart_str_appendl(buf, "\";", 2);
602: }
603: /* }}} */
604:
605: static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc TSRMLS_DC) /* {{{ */
606: {
607: PHP_CLASS_ATTRIBUTES;
608:
609: PHP_SET_CLASS_ATTRIBUTES(struc);
610: smart_str_appendl(buf, "O:", 2);
611: smart_str_append_long(buf, (int)name_len);
612: smart_str_appendl(buf, ":\"", 2);
613: smart_str_appendl(buf, class_name, name_len);
614: smart_str_appendl(buf, "\":", 2);
615: PHP_CLEANUP_CLASS_ATTRIBUTES();
616: return incomplete_class;
617: }
618: /* }}} */
619:
620: static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_ptr, HashTable *var_hash TSRMLS_DC) /* {{{ */
621: {
622: int count;
623: zend_bool incomplete_class;
624:
625: incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC);
626: /* count after serializing name, since php_var_serialize_class_name
627: * changes the count if the variable is incomplete class */
628: count = zend_hash_num_elements(HASH_OF(retval_ptr));
629: if (incomplete_class) {
630: --count;
631: }
632: smart_str_append_long(buf, count);
633: smart_str_appendl(buf, ":{", 2);
634:
635: if (count > 0) {
636: char *key;
637: zval **d, **name;
638: ulong index;
639: HashPosition pos;
640: int i;
641: zval nval, *nvalp;
1.1.1.3 ! misho 642: HashTable *propers;
1.1 misho 643:
644: ZVAL_NULL(&nval);
645: nvalp = &nval;
646:
647: zend_hash_internal_pointer_reset_ex(HASH_OF(retval_ptr), &pos);
648:
649: for (;; zend_hash_move_forward_ex(HASH_OF(retval_ptr), &pos)) {
650: i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos);
651:
652: if (i == HASH_KEY_NON_EXISTANT) {
653: break;
654: }
655:
656: if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
657: continue;
658: }
659: zend_hash_get_current_data_ex(HASH_OF(retval_ptr), (void **) &name, &pos);
660:
661: if (Z_TYPE_PP(name) != IS_STRING) {
662: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize.");
663: /* we should still add element even if it's not OK,
664: * since we already wrote the length of the array before */
665: smart_str_appendl(buf,"N;", 2);
666: continue;
667: }
1.1.1.3 ! misho 668: propers = Z_OBJPROP_P(struc);
! 669: if (zend_hash_find(propers, Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void *) &d) == SUCCESS) {
1.1 misho 670: php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
671: php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
672: } else {
673: zend_class_entry *ce;
674: ce = zend_get_class_entry(struc TSRMLS_CC);
675: if (ce) {
676: char *prot_name, *priv_name;
677: int prop_name_length;
678:
679: do {
680: zend_mangle_property_name(&priv_name, &prop_name_length, ce->name, ce->name_length, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
1.1.1.3 ! misho 681: if (zend_hash_find(propers, priv_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
1.1 misho 682: php_var_serialize_string(buf, priv_name, prop_name_length);
683: pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
684: php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
685: break;
686: }
687: pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
688: zend_mangle_property_name(&prot_name, &prop_name_length, "*", 1, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
1.1.1.3 ! misho 689: if (zend_hash_find(propers, prot_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
1.1 misho 690: php_var_serialize_string(buf, prot_name, prop_name_length);
691: pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
692: php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
693: break;
694: }
695: pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
696: php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
697: php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
698: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_PP(name));
699: } while (0);
700: } else {
701: php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
702: php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
703: }
704: }
705: }
706: }
707: smart_str_appendc(buf, '}');
708: }
709: /* }}} */
710:
711: static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC) /* {{{ */
712: {
713: int i;
714: ulong *var_already;
715: HashTable *myht;
716:
1.1.1.3 ! misho 717: if (EG(exception)) {
! 718: return;
! 719: }
! 720:
1.1 misho 721: if (var_hash && php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) {
722: if (Z_ISREF_P(struc)) {
723: smart_str_appendl(buf, "R:", 2);
724: smart_str_append_long(buf, (long)*var_already);
725: smart_str_appendc(buf, ';');
726: return;
727: } else if (Z_TYPE_P(struc) == IS_OBJECT) {
728: smart_str_appendl(buf, "r:", 2);
729: smart_str_append_long(buf, (long)*var_already);
730: smart_str_appendc(buf, ';');
731: return;
732: }
733: }
734:
735: switch (Z_TYPE_P(struc)) {
736: case IS_BOOL:
737: smart_str_appendl(buf, "b:", 2);
738: smart_str_append_long(buf, Z_LVAL_P(struc));
739: smart_str_appendc(buf, ';');
740: return;
741:
742: case IS_NULL:
743: smart_str_appendl(buf, "N;", 2);
744: return;
745:
746: case IS_LONG:
747: php_var_serialize_long(buf, Z_LVAL_P(struc));
748: return;
749:
750: case IS_DOUBLE: {
751: char *s;
752:
753: smart_str_appendl(buf, "d:", 2);
754: s = (char *) safe_emalloc(PG(serialize_precision), 1, MAX_LENGTH_OF_DOUBLE + 1);
755: php_gcvt(Z_DVAL_P(struc), PG(serialize_precision), '.', 'E', s);
756: smart_str_appends(buf, s);
757: smart_str_appendc(buf, ';');
758: efree(s);
759: return;
760: }
761:
762: case IS_STRING:
763: php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc));
764: return;
765:
766: case IS_OBJECT: {
767: zval *retval_ptr = NULL;
768: zval fname;
769: int res;
770: zend_class_entry *ce = NULL;
771:
772: if (Z_OBJ_HT_P(struc)->get_class_entry) {
773: ce = Z_OBJCE_P(struc);
774: }
775:
776: if (ce && ce->serialize != NULL) {
777: /* has custom handler */
778: unsigned char *serialized_data = NULL;
779: zend_uint serialized_length;
780:
781: if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) {
782: smart_str_appendl(buf, "C:", 2);
783: smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name_length);
784: smart_str_appendl(buf, ":\"", 2);
785: smart_str_appendl(buf, Z_OBJCE_P(struc)->name, Z_OBJCE_P(struc)->name_length);
786: smart_str_appendl(buf, "\":", 2);
787:
788: smart_str_append_long(buf, (int)serialized_length);
789: smart_str_appendl(buf, ":{", 2);
790: smart_str_appendl(buf, serialized_data, serialized_length);
791: smart_str_appendc(buf, '}');
792: } else {
793: smart_str_appendl(buf, "N;", 2);
794: }
795: if (serialized_data) {
796: efree(serialized_data);
797: }
798: return;
799: }
800:
801: if (ce && ce != PHP_IC_ENTRY && zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep"))) {
802: INIT_PZVAL(&fname);
803: ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0);
1.1.1.2 misho 804: BG(serialize_lock)++;
1.1 misho 805: res = call_user_function_ex(CG(function_table), &struc, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
1.1.1.2 misho 806: BG(serialize_lock)--;
1.1.1.3 ! misho 807:
! 808: if (EG(exception)) {
! 809: if (retval_ptr) {
! 810: zval_ptr_dtor(&retval_ptr);
! 811: }
! 812: return;
! 813: }
1.1 misho 814:
1.1.1.3 ! misho 815: if (res == SUCCESS) {
1.1 misho 816: if (retval_ptr) {
817: if (HASH_OF(retval_ptr)) {
818: php_var_serialize_class(buf, struc, retval_ptr, var_hash TSRMLS_CC);
819: } else {
820: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize");
821: /* we should still add element even if it's not OK,
822: * since we already wrote the length of the array before */
823: smart_str_appendl(buf,"N;", 2);
824: }
825: zval_ptr_dtor(&retval_ptr);
826: }
827: return;
828: }
829: }
830:
831: if (retval_ptr) {
832: zval_ptr_dtor(&retval_ptr);
833: }
834: /* fall-through */
835: }
836: case IS_ARRAY: {
837: zend_bool incomplete_class = 0;
838: if (Z_TYPE_P(struc) == IS_ARRAY) {
839: smart_str_appendl(buf, "a:", 2);
840: myht = HASH_OF(struc);
841: } else {
842: incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC);
843: myht = Z_OBJPROP_P(struc);
844: }
845: /* count after serializing name, since php_var_serialize_class_name
846: * changes the count if the variable is incomplete class */
847: i = myht ? zend_hash_num_elements(myht) : 0;
848: if (i > 0 && incomplete_class) {
849: --i;
850: }
851: smart_str_append_long(buf, i);
852: smart_str_appendl(buf, ":{", 2);
853: if (i > 0) {
854: char *key;
855: zval **data;
856: ulong index;
857: uint key_len;
858: HashPosition pos;
859:
860: zend_hash_internal_pointer_reset_ex(myht, &pos);
861: for (;; zend_hash_move_forward_ex(myht, &pos)) {
862: i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
863: if (i == HASH_KEY_NON_EXISTANT) {
864: break;
865: }
866: if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
867: continue;
868: }
869:
870: switch (i) {
871: case HASH_KEY_IS_LONG:
872: php_var_serialize_long(buf, index);
873: break;
874: case HASH_KEY_IS_STRING:
875: php_var_serialize_string(buf, key, key_len - 1);
876: break;
877: }
878:
879: /* we should still add element even if it's not OK,
880: * since we already wrote the length of the array before */
881: if (zend_hash_get_current_data_ex(myht, (void **) &data, &pos) != SUCCESS
882: || !data
883: || data == &struc
884: || (Z_TYPE_PP(data) == IS_ARRAY && Z_ARRVAL_PP(data)->nApplyCount > 1)
885: ) {
886: smart_str_appendl(buf, "N;", 2);
887: } else {
888: if (Z_TYPE_PP(data) == IS_ARRAY) {
889: Z_ARRVAL_PP(data)->nApplyCount++;
890: }
891: php_var_serialize_intern(buf, *data, var_hash TSRMLS_CC);
892: if (Z_TYPE_PP(data) == IS_ARRAY) {
893: Z_ARRVAL_PP(data)->nApplyCount--;
894: }
895: }
896: }
897: }
898: smart_str_appendc(buf, '}');
899: return;
900: }
901: default:
902: smart_str_appendl(buf, "i:0;", 4);
903: return;
904: }
905: }
906: /* }}} */
907:
1.1.1.2 misho 908: PHPAPI void php_var_serialize(smart_str *buf, zval **struc, php_serialize_data_t *var_hash TSRMLS_DC) /* {{{ */
1.1 misho 909: {
1.1.1.2 misho 910: php_var_serialize_intern(buf, *struc, *var_hash TSRMLS_CC);
1.1 misho 911: smart_str_0(buf);
912: }
913: /* }}} */
914:
915: /* {{{ proto string serialize(mixed variable)
916: Returns a string representation of variable (which can later be unserialized) */
917: PHP_FUNCTION(serialize)
918: {
919: zval **struc;
920: php_serialize_data_t var_hash;
921: smart_str buf = {0};
922:
923: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &struc) == FAILURE) {
924: return;
925: }
926:
927: Z_TYPE_P(return_value) = IS_STRING;
928: Z_STRVAL_P(return_value) = NULL;
929: Z_STRLEN_P(return_value) = 0;
930:
931: PHP_VAR_SERIALIZE_INIT(var_hash);
932: php_var_serialize(&buf, struc, &var_hash TSRMLS_CC);
933: PHP_VAR_SERIALIZE_DESTROY(var_hash);
934:
1.1.1.3 ! misho 935: if (EG(exception)) {
! 936: smart_str_free(&buf);
! 937: RETURN_FALSE;
! 938: }
! 939:
1.1 misho 940: if (buf.c) {
941: RETURN_STRINGL(buf.c, buf.len, 0);
942: } else {
943: RETURN_NULL();
944: }
945: }
946: /* }}} */
947:
948: /* {{{ proto mixed unserialize(string variable_representation)
949: Takes a string representation of variable and recreates it */
950: PHP_FUNCTION(unserialize)
951: {
952: char *buf = NULL;
953: int buf_len;
954: const unsigned char *p;
955: php_unserialize_data_t var_hash;
956:
957: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
958: RETURN_FALSE;
959: }
960:
961: if (buf_len == 0) {
962: RETURN_FALSE;
963: }
964:
965: p = (const unsigned char*) buf;
966: PHP_VAR_UNSERIALIZE_INIT(var_hash);
967: if (!php_var_unserialize(&return_value, &p, p + buf_len, &var_hash TSRMLS_CC)) {
968: PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
969: zval_dtor(return_value);
1.1.1.3 ! misho 970: if (!EG(exception)) {
! 971: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len);
! 972: }
1.1 misho 973: RETURN_FALSE;
974: }
975: PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
976: }
977: /* }}} */
978:
979: /* {{{ proto int memory_get_usage([real_usage])
980: Returns the allocated by PHP memory */
981: PHP_FUNCTION(memory_get_usage) {
982: zend_bool real_usage = 0;
983:
984: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) {
985: RETURN_FALSE;
986: }
987:
988: RETURN_LONG(zend_memory_usage(real_usage TSRMLS_CC));
989: }
990: /* }}} */
991:
992: /* {{{ proto int memory_get_peak_usage([real_usage])
993: Returns the peak allocated by PHP memory */
994: PHP_FUNCTION(memory_get_peak_usage) {
995: zend_bool real_usage = 0;
996:
997: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) {
998: RETURN_FALSE;
999: }
1000:
1001: RETURN_LONG(zend_memory_peak_usage(real_usage TSRMLS_CC));
1002: }
1003: /* }}} */
1004:
1005: /*
1006: * Local variables:
1007: * tab-width: 4
1008: * c-basic-offset: 4
1009: * End:
1010: * vim600: sw=4 ts=4 fdm=marker
1011: * vim<600: sw=4 ts=4
1012: */