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

Generated by: LCOV version 1.10

Generated at Fri, 13 Oct 2017 06:54:00 +0000 (10 days ago)

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