PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/json - json_encoder.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 207 213 97.2 %
Date: 2017-12-15 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 7                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2017 The PHP Group                                |
       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             :   +----------------------------------------------------------------------+
      15             :   | Author: Omar Kilani <omar@php.net>                                   |
      16             :   |         Jakub Zelenka <bukka@php.net>                                |
      17             :   +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : #ifdef HAVE_CONFIG_H
      21             : #include "config.h"
      22             : #endif
      23             : 
      24             : #include "php.h"
      25             : #include "php_ini.h"
      26             : #include "ext/standard/info.h"
      27             : #include "ext/standard/html.h"
      28             : #include "zend_smart_str.h"
      29             : #include "php_json.h"
      30             : #include "php_json_encoder.h"
      31             : #include <zend_exceptions.h>
      32             : 
      33             : static const char digits[] = "0123456789abcdef";
      34             : 
      35             : static int php_json_escape_string(
      36             :                 smart_str *buf, char *s, size_t len,
      37             :                 int options, php_json_encoder *encoder);
      38             : 
      39        1259 : static int php_json_determine_array_type(zval *val) /* {{{ */
      40             : {
      41             :         int i;
      42        1259 :         HashTable *myht = Z_ARRVAL_P(val);
      43             : 
      44        1259 :         i = myht ? zend_hash_num_elements(myht) : 0;
      45        1259 :         if (i > 0) {
      46             :                 zend_string *key;
      47             :                 zend_ulong index, idx;
      48             : 
      49        1239 :                 if (HT_IS_PACKED(myht) && HT_IS_WITHOUT_HOLES(myht)) {
      50        1214 :                         return PHP_JSON_OUTPUT_ARRAY;
      51             :                 }
      52             : 
      53          25 :                 idx = 0;
      54          54 :                 ZEND_HASH_FOREACH_KEY(myht, index, key) {
      55          26 :                         if (key) {
      56          22 :                                 return PHP_JSON_OUTPUT_OBJECT;
      57             :                         } else {
      58           4 :                                 if (index != idx) {
      59           3 :                                         return PHP_JSON_OUTPUT_OBJECT;
      60             :                                 }
      61             :                         }
      62           1 :                         idx++;
      63             :                 } ZEND_HASH_FOREACH_END();
      64             :         }
      65             : 
      66          20 :         return PHP_JSON_OUTPUT_ARRAY;
      67             : }
      68             : /* }}} */
      69             : 
      70             : /* {{{ Pretty printing support functions */
      71             : 
      72        2700 : static inline void php_json_pretty_print_char(smart_str *buf, int options, char c) /* {{{ */
      73             : {
      74        2700 :         if (options & PHP_JSON_PRETTY_PRINT) {
      75          32 :                 smart_str_appendc(buf, c);
      76             :         }
      77        2700 : }
      78             : /* }}} */
      79             : 
      80        2425 : static inline void php_json_pretty_print_indent(smart_str *buf, int options, php_json_encoder *encoder) /* {{{ */
      81             : {
      82             :         int i;
      83             : 
      84        2425 :         if (options & PHP_JSON_PRETTY_PRINT) {
      85          56 :                 for (i = 0; i < encoder->depth; ++i) {
      86             :                         smart_str_appendl(buf, "    ", 4);
      87             :                 }
      88             :         }
      89        2425 : }
      90             : /* }}} */
      91             : 
      92             : /* }}} */
      93             : 
      94          69 : static inline int php_json_is_valid_double(double d) /* {{{ */
      95             : {
      96          69 :         return !zend_isinf(d) && !zend_isnan(d);
      97             : }
      98             : /* }}} */
      99             : 
     100          60 : static inline void php_json_encode_double(smart_str *buf, double d, int options) /* {{{ */
     101             : {
     102             :         size_t len;
     103             :         char num[PHP_DOUBLE_MAX_LENGTH];
     104             : 
     105          60 :         php_gcvt(d, (int)PG(serialize_precision), '.', 'e', num);
     106          60 :         len = strlen(num);
     107          60 :         if (options & PHP_JSON_PRESERVE_ZERO_FRACTION && strchr(num, '.') == NULL && len < PHP_DOUBLE_MAX_LENGTH - 2) {
     108           9 :                 num[len++] = '.';
     109           9 :                 num[len++] = '0';
     110           9 :                 num[len] = '\0';
     111             :         }
     112             :         smart_str_appendl(buf, num, len);
     113          60 : }
     114             : /* }}} */
     115             : 
     116             : #define PHP_JSON_HASH_APPLY_PROTECTION_INC(_tmp_ht) \
     117             :         do { \
     118             :                 if (_tmp_ht && ZEND_HASH_APPLY_PROTECTION(_tmp_ht)) { \
     119             :                         ZEND_HASH_INC_APPLY_COUNT(_tmp_ht); \
     120             :                 } \
     121             :         } while (0)
     122             : 
     123             : #define PHP_JSON_HASH_APPLY_PROTECTION_DEC(_tmp_ht) \
     124             :         do { \
     125             :                 if (_tmp_ht && ZEND_HASH_APPLY_PROTECTION(_tmp_ht)) { \
     126             :                         ZEND_HASH_DEC_APPLY_COUNT(_tmp_ht); \
     127             :                 } \
     128             :         } while (0)
     129             : 
     130        1338 : static int php_json_encode_array(smart_str *buf, zval *val, int options, php_json_encoder *encoder) /* {{{ */
     131             : {
     132        1338 :         int i, r, need_comma = 0;
     133             :         HashTable *myht;
     134             : 
     135        1338 :         if (Z_TYPE_P(val) == IS_ARRAY) {
     136        1263 :                 myht = Z_ARRVAL_P(val);
     137        1263 :                 r = (options & PHP_JSON_FORCE_OBJECT) ? PHP_JSON_OUTPUT_OBJECT : php_json_determine_array_type(val);
     138             :         } else {
     139          75 :                 myht = Z_OBJPROP_P(val);
     140          75 :                 r = PHP_JSON_OUTPUT_OBJECT;
     141             :         }
     142             : 
     143        1338 :         if (myht && ZEND_HASH_GET_APPLY_COUNT(myht) > 0) {
     144           5 :                 encoder->error_code = PHP_JSON_ERROR_RECURSION;
     145             :                 smart_str_appendl(buf, "null", 4);
     146           5 :                 return FAILURE;
     147             :         }
     148             : 
     149        1333 :         PHP_JSON_HASH_APPLY_PROTECTION_INC(myht);
     150             : 
     151        1333 :         if (r == PHP_JSON_OUTPUT_ARRAY) {
     152             :                 smart_str_appendc(buf, '[');
     153             :         } else {
     154             :                 smart_str_appendc(buf, '{');
     155             :         }
     156             : 
     157        1333 :         ++encoder->depth;
     158             : 
     159        1333 :         i = myht ? zend_hash_num_elements(myht) : 0;
     160             : 
     161        1333 :         if (i > 0) {
     162             :                 zend_string *key;
     163             :                 zval *data;
     164             :                 zend_ulong index;
     165             : 
     166        5842 :                 ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) {
     167        1704 :                         if (r == PHP_JSON_OUTPUT_ARRAY) {
     168        1425 :                                 if (need_comma) {
     169             :                                         smart_str_appendc(buf, ',');
     170             :                                 } else {
     171        1212 :                                         need_comma = 1;
     172             :                                 }
     173             : 
     174        1425 :                                 php_json_pretty_print_char(buf, options, '\n');
     175        1425 :                                 php_json_pretty_print_indent(buf, options, encoder);
     176         279 :                         } else if (r == PHP_JSON_OUTPUT_OBJECT) {
     177         279 :                                 if (key) {
     178         270 :                                         if (ZSTR_VAL(key)[0] == '\0' && ZSTR_LEN(key) > 0 && Z_TYPE_P(val) == IS_OBJECT) {
     179             :                                                 /* Skip protected and private members. */
     180           4 :                                                 continue;
     181             :                                         }
     182             : 
     183         261 :                                         if (need_comma) {
     184             :                                                 smart_str_appendc(buf, ',');
     185             :                                         } else {
     186          64 :                                                 need_comma = 1;
     187             :                                         }
     188             : 
     189         261 :                                         php_json_pretty_print_char(buf, options, '\n');
     190         261 :                                         php_json_pretty_print_indent(buf, options, encoder);
     191             : 
     192         263 :                                         if (php_json_escape_string(buf, ZSTR_VAL(key), ZSTR_LEN(key),
     193         261 :                                                                 options & ~PHP_JSON_NUMERIC_CHECK, encoder) == FAILURE &&
     194           1 :                                                         (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) &&
     195           1 :                                                         buf->s) {
     196           1 :                                                 ZSTR_LEN(buf->s) -= 4;
     197             :                                                 smart_str_appendl(buf, "\"\"", 2);
     198             :                                         }
     199             :                                 } else {
     200          14 :                                         if (need_comma) {
     201             :                                                 smart_str_appendc(buf, ',');
     202             :                                         } else {
     203           6 :                                                 need_comma = 1;
     204             :                                         }
     205             : 
     206          14 :                                         php_json_pretty_print_char(buf, options, '\n');
     207          14 :                                         php_json_pretty_print_indent(buf, options, encoder);
     208             : 
     209             :                                         smart_str_appendc(buf, '"');
     210          14 :                                         smart_str_append_long(buf, (zend_long) index);
     211             :                                         smart_str_appendc(buf, '"');
     212             :                                 }
     213             : 
     214             :                                 smart_str_appendc(buf, ':');
     215         275 :                                 php_json_pretty_print_char(buf, options, ' ');
     216             :                         }
     217             : 
     218        2263 :                         if (php_json_encode_zval(buf, data, options, encoder) == FAILURE &&
     219         563 :                                         !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
     220         557 :                                 PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht);
     221         557 :                                 return FAILURE;
     222             :                         }
     223             :                 } ZEND_HASH_FOREACH_END();
     224             :         }
     225             : 
     226         776 :         PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht);
     227             : 
     228         776 :         if (encoder->depth > encoder->max_depth) {
     229           1 :                 encoder->error_code = PHP_JSON_ERROR_DEPTH;
     230           1 :                 if (!(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
     231           1 :                         return FAILURE;
     232             :                 }
     233             :         }
     234         775 :         --encoder->depth;
     235             : 
     236             :         /* Only keep closing bracket on same line for empty arrays/objects */
     237         775 :         if (need_comma) {
     238         725 :                 php_json_pretty_print_char(buf, options, '\n');
     239         725 :                 php_json_pretty_print_indent(buf, options, encoder);
     240             :         }
     241             : 
     242         775 :         if (r == PHP_JSON_OUTPUT_ARRAY) {
     243             :                 smart_str_appendc(buf, ']');
     244             :         } else {
     245             :                 smart_str_appendc(buf, '}');
     246             :         }
     247             : 
     248         775 :         return SUCCESS;
     249             : }
     250             : /* }}} */
     251             : 
     252         705 : static int php_json_escape_string(
     253             :                 smart_str *buf, char *s, size_t len,
     254             :                 int options, php_json_encoder *encoder) /* {{{ */
     255             : {
     256             :         int status;
     257             :         unsigned int us;
     258             :         size_t pos, checkpoint;
     259             : 
     260         705 :         if (len == 0) {
     261             :                 smart_str_appendl(buf, "\"\"", 2);
     262          33 :                 return SUCCESS;
     263             :         }
     264             : 
     265         672 :         if (options & PHP_JSON_NUMERIC_CHECK) {
     266             :                 double d;
     267             :                 int type;
     268             :                 zend_long p;
     269             : 
     270           6 :                 if ((type = is_numeric_string(s, len, &p, &d, 0)) != 0) {
     271           6 :                         if (type == IS_LONG) {
     272           3 :                                 smart_str_append_long(buf, p);
     273           3 :                                 return SUCCESS;
     274           3 :                         } else if (type == IS_DOUBLE && php_json_is_valid_double(d)) {
     275           2 :                                 php_json_encode_double(buf, d, options);
     276           2 :                                 return SUCCESS;
     277             :                         }
     278             :                 }
     279             : 
     280             :         }
     281         667 :         pos = 0;
     282         667 :         checkpoint = buf->s ? ZSTR_LEN(buf->s) : 0;
     283             : 
     284             :         /* pre-allocate for string length plus 2 quotes */
     285         667 :         smart_str_alloc(buf, len+2, 0);
     286             :         smart_str_appendc(buf, '"');
     287             : 
     288             :         do {
     289        4235 :                 us = (unsigned char)s[pos];
     290        4235 :                 if (us >= 0x80) {
     291         188 :                         int utf8_sub = 0;
     292         188 :                         size_t prev_pos = pos;
     293             : 
     294         188 :                         us = php_next_utf8_char((unsigned char *)s, len, &pos, &status);
     295             : 
     296             :                         /* check whether UTF8 character is correct */
     297         188 :                         if (status != SUCCESS) {
     298          25 :                                 if (options & PHP_JSON_INVALID_UTF8_IGNORE) {
     299             :                                         /* ignore invalid UTF8 character */
     300           2 :                                         continue;
     301          23 :                                 } else if (options & PHP_JSON_INVALID_UTF8_SUBSTITUTE) {
     302             :                                         /* Use Unicode character 'REPLACEMENT CHARACTER' (U+FFFD) */
     303           4 :                                         us = 0xfffd;
     304           4 :                                         utf8_sub = 1;
     305             :                                 } else {
     306          19 :                                         if (buf->s) {
     307          19 :                                                 ZSTR_LEN(buf->s) = checkpoint;
     308             :                                         }
     309          19 :                                         encoder->error_code = PHP_JSON_ERROR_UTF8;
     310          19 :                                         if (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) {
     311             :                                                 smart_str_appendl(buf, "null", 4);
     312             :                                         }
     313          19 :                                         return FAILURE;
     314             :                                 }
     315             :                         }
     316             : 
     317             :                         /* Escape U+2028/U+2029 line terminators, UNLESS both
     318             :                            JSON_UNESCAPED_UNICODE and
     319             :                            JSON_UNESCAPED_LINE_TERMINATORS were provided */
     320         189 :                         if ((options & PHP_JSON_UNESCAPED_UNICODE)
     321          22 :                             && ((options & PHP_JSON_UNESCAPED_LINE_TERMINATORS)
     322             :                                         || us < 0x2028 || us > 0x2029)) {
     323          20 :                                 if (utf8_sub) {
     324             :                                         smart_str_appendl(buf, "\xef\xbf\xbd", 3);
     325             :                                 } else {
     326          18 :                                         smart_str_appendl(buf, s + prev_pos, pos - prev_pos);
     327             :                                 }
     328          20 :                                 continue;
     329             :                         }
     330             :                         /* From http://en.wikipedia.org/wiki/UTF16 */
     331         147 :                         if (us >= 0x10000) {
     332             :                                 unsigned int next_us;
     333          18 :                                 us -= 0x10000;
     334          18 :                                 next_us = (unsigned short)((us & 0x3ff) | 0xdc00);
     335          18 :                                 us = (unsigned short)((us >> 10) | 0xd800);
     336             :                                 smart_str_appendl(buf, "\\u", 2);
     337          18 :                                 smart_str_appendc(buf, digits[(us & 0xf000) >> 12]);
     338          18 :                                 smart_str_appendc(buf, digits[(us & 0xf00)  >> 8]);
     339          18 :                                 smart_str_appendc(buf, digits[(us & 0xf0)   >> 4]);
     340          18 :                                 smart_str_appendc(buf, digits[(us & 0xf)]);
     341          18 :                                 us = next_us;
     342             :                         }
     343             :                         smart_str_appendl(buf, "\\u", 2);
     344         147 :                         smart_str_appendc(buf, digits[(us & 0xf000) >> 12]);
     345         147 :                         smart_str_appendc(buf, digits[(us & 0xf00)  >> 8]);
     346         147 :                         smart_str_appendc(buf, digits[(us & 0xf0)   >> 4]);
     347         147 :                         smart_str_appendc(buf, digits[(us & 0xf)]);
     348             :                 } else {
     349             :                         static const uint32_t charmap[4] = {
     350             :                                 0xffffffff, 0x500080c4, 0x10000000, 0x00000000};
     351             : 
     352        4047 :                         pos++;
     353        4047 :                         if (EXPECTED(!(charmap[us >> 5] & (1 << (us & 0x1f))))) {
     354        3763 :                                 smart_str_appendc(buf, (unsigned char) us);
     355             :                         } else {
     356         284 :                                 switch (us) {
     357             :                                         case '"':
     358          44 :                                                 if (options & PHP_JSON_HEX_QUOT) {
     359             :                                                         smart_str_appendl(buf, "\\u0022", 6);
     360             :                                                 } else {
     361             :                                                         smart_str_appendl(buf, "\\\"", 2);
     362             :                                                 }
     363          44 :                                                 break;
     364             : 
     365             :                                         case '\\':
     366             :                                                 smart_str_appendl(buf, "\\\\", 2);
     367          16 :                                                 break;
     368             : 
     369             :                                         case '/':
     370          52 :                                                 if (options & PHP_JSON_UNESCAPED_SLASHES) {
     371             :                                                         smart_str_appendc(buf, '/');
     372             :                                                 } else {
     373             :                                                         smart_str_appendl(buf, "\\/", 2);
     374             :                                                 }
     375          52 :                                                 break;
     376             : 
     377             :                                         case '\b':
     378             :                                                 smart_str_appendl(buf, "\\b", 2);
     379          10 :                                                 break;
     380             : 
     381             :                                         case '\f':
     382             :                                                 smart_str_appendl(buf, "\\f", 2);
     383           8 :                                                 break;
     384             : 
     385             :                                         case '\n':
     386             :                                                 smart_str_appendl(buf, "\\n", 2);
     387          25 :                                                 break;
     388             : 
     389             :                                         case '\r':
     390             :                                                 smart_str_appendl(buf, "\\r", 2);
     391           8 :                                                 break;
     392             : 
     393             :                                         case '\t':
     394             :                                                 smart_str_appendl(buf, "\\t", 2);
     395          10 :                                                 break;
     396             : 
     397             :                                         case '<':
     398          20 :                                                 if (options & PHP_JSON_HEX_TAG) {
     399             :                                                         smart_str_appendl(buf, "\\u003C", 6);
     400             :                                                 } else {
     401             :                                                         smart_str_appendc(buf, '<');
     402             :                                                 }
     403          20 :                                                 break;
     404             : 
     405             :                                         case '>':
     406          20 :                                                 if (options & PHP_JSON_HEX_TAG) {
     407             :                                                         smart_str_appendl(buf, "\\u003E", 6);
     408             :                                                 } else {
     409             :                                                         smart_str_appendc(buf, '>');
     410             :                                                 }
     411          20 :                                                 break;
     412             : 
     413             :                                         case '&':
     414          32 :                                                 if (options & PHP_JSON_HEX_AMP) {
     415             :                                                         smart_str_appendl(buf, "\\u0026", 6);
     416             :                                                 } else {
     417             :                                                         smart_str_appendc(buf, '&');
     418             :                                                 }
     419          32 :                                                 break;
     420             : 
     421             :                                         case '\'':
     422          20 :                                                 if (options & PHP_JSON_HEX_APOS) {
     423             :                                                         smart_str_appendl(buf, "\\u0027", 6);
     424             :                                                 } else {
     425             :                                                         smart_str_appendc(buf, '\'');
     426             :                                                 }
     427          20 :                                                 break;
     428             : 
     429             :                                         default:
     430             :                                                 ZEND_ASSERT(us < ' ');
     431             :                                                 smart_str_appendl(buf, "\\u00", sizeof("\\u00")-1);
     432          19 :                                                 smart_str_appendc(buf, digits[(us & 0xf0)   >> 4]);
     433          19 :                                                 smart_str_appendc(buf, digits[(us & 0xf)]);
     434             :                                                 break;
     435             :                                 }
     436             :                         }
     437             :                 }
     438        4216 :         } while (pos < len);
     439             : 
     440             :         smart_str_appendc(buf, '"');
     441             : 
     442         648 :         return SUCCESS;
     443             : }
     444             : /* }}} */
     445             : 
     446          18 : static int php_json_encode_serializable_object(smart_str *buf, zval *val, int options, php_json_encoder *encoder) /* {{{ */
     447             : {
     448          18 :         zend_class_entry *ce = Z_OBJCE_P(val);
     449          18 :         HashTable* myht = Z_OBJPROP_P(val);
     450             :         zval retval, fname;
     451             :         int return_code;
     452             : 
     453          18 :         if (myht && ZEND_HASH_GET_APPLY_COUNT(myht) > 0) {
     454           1 :                 encoder->error_code = PHP_JSON_ERROR_RECURSION;
     455           1 :                 if (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) {
     456             :                         smart_str_appendl(buf, "null", 4);
     457             :                 }
     458           1 :                 return FAILURE;
     459             :         }
     460             : 
     461          17 :         PHP_JSON_HASH_APPLY_PROTECTION_INC(myht);
     462             : 
     463          34 :         ZVAL_STRING(&fname, "jsonSerialize");
     464             : 
     465          34 :         if (FAILURE == call_user_function_ex(EG(function_table), val, &fname, &retval, 0, NULL, 1, NULL) || Z_TYPE(retval) == IS_UNDEF) {
     466           2 :                 if (!EG(exception)) {
     467           0 :                         zend_throw_exception_ex(NULL, 0, "Failed calling %s::jsonSerialize()", ZSTR_VAL(ce->name));
     468             :                 }
     469           2 :                 zval_ptr_dtor(&fname);
     470             : 
     471           2 :                 if (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) {
     472             :                         smart_str_appendl(buf, "null", 4);
     473             :                 }
     474           2 :                 PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht);
     475           2 :                 return FAILURE;
     476             :         }
     477             : 
     478          15 :         if (EG(exception)) {
     479             :                 /* Error already raised */
     480           0 :                 zval_ptr_dtor(&retval);
     481           0 :                 zval_ptr_dtor(&fname);
     482             : 
     483           0 :                 if (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) {
     484             :                         smart_str_appendl(buf, "null", 4);
     485             :                 }
     486           0 :                 PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht);
     487           0 :                 return FAILURE;
     488             :         }
     489             : 
     490          22 :         if ((Z_TYPE(retval) == IS_OBJECT) &&
     491           4 :                 (Z_OBJ(retval) == Z_OBJ_P(val))) {
     492             :                 /* Handle the case where jsonSerialize does: return $this; by going straight to encode array */
     493           3 :                 PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht);
     494           3 :                 return_code = php_json_encode_array(buf, &retval, options, encoder);
     495             :         } else {
     496             :                 /* All other types, encode as normal */
     497          12 :                 return_code = php_json_encode_zval(buf, &retval, options, encoder);
     498          12 :                 PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht);
     499             :         }
     500             : 
     501          15 :         zval_ptr_dtor(&retval);
     502          15 :         zval_ptr_dtor(&fname);
     503             : 
     504          15 :         return return_code;
     505             : }
     506             : /* }}} */
     507             : 
     508        2177 : int php_json_encode_zval(smart_str *buf, zval *val, int options, php_json_encoder *encoder) /* {{{ */
     509             : {
     510             : again:
     511        2177 :         switch (Z_TYPE_P(val))
     512             :         {
     513             :                 case IS_NULL:
     514             :                         smart_str_appendl(buf, "null", 4);
     515          30 :                         break;
     516             : 
     517             :                 case IS_TRUE:
     518             :                         smart_str_appendl(buf, "true", 4);
     519          12 :                         break;
     520             :                 case IS_FALSE:
     521             :                         smart_str_appendl(buf, "false", 5);
     522          84 :                         break;
     523             : 
     524             :                 case IS_LONG:
     525         182 :                         smart_str_append_long(buf, Z_LVAL_P(val));
     526         182 :                         break;
     527             : 
     528             :                 case IS_DOUBLE:
     529          66 :                         if (php_json_is_valid_double(Z_DVAL_P(val))) {
     530          58 :                                 php_json_encode_double(buf, Z_DVAL_P(val), options);
     531             :                         } else {
     532           8 :                                 encoder->error_code = PHP_JSON_ERROR_INF_OR_NAN;
     533             :                                 smart_str_appendc(buf, '0');
     534             :                         }
     535          66 :                         break;
     536             : 
     537             :                 case IS_STRING:
     538         444 :                         return php_json_escape_string(buf, Z_STRVAL_P(val), Z_STRLEN_P(val), options, encoder);
     539             : 
     540             :                 case IS_OBJECT:
     541          90 :                         if (instanceof_function(Z_OBJCE_P(val), php_json_serializable_ce)) {
     542          18 :                                 return php_json_encode_serializable_object(buf, val, options, encoder);
     543             :                         }
     544             :                         /* fallthrough -- Non-serializable object */
     545             :                 case IS_ARRAY:
     546        1335 :                         return php_json_encode_array(buf, val, options, encoder);
     547             : 
     548             :                 case IS_REFERENCE:
     549           2 :                         val = Z_REFVAL_P(val);
     550           2 :                         goto again;
     551             : 
     552             :                 default:
     553           4 :                         encoder->error_code = PHP_JSON_ERROR_UNSUPPORTED_TYPE;
     554           4 :                         if (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) {
     555             :                                 smart_str_appendl(buf, "null", 4);
     556             :                         }
     557           4 :                         return FAILURE;
     558             :         }
     559             : 
     560         374 :         return SUCCESS;
     561             : }
     562             : /* }}} */
     563             : 
     564             : /*
     565             :  * Local variables:
     566             :  * tab-width: 4
     567             :  * c-basic-offset: 4
     568             :  * End:
     569             :  * vim600: noet sw=4 ts=4 fdm=marker
     570             :  * vim<600: noet sw=4 ts=4
     571             :  */

Generated by: LCOV version 1.10

Generated at Fri, 15 Dec 2017 07:20:39 +0000 (2 days ago)

Copyright © 2005-2017 The PHP Group
All rights reserved.