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 - Zend - zend_multibyte.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 47 78 60.3 %
Date: 2014-08-04 Functions: 12 21 57.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 2.00 of the Zend license,     |
       8             :    | that is bundled with this package in the file LICENSE, and is        | 
       9             :    | available through the world-wide-web at                              |
      10             :    | http://www.zend.com/license/2_00.txt.                                |
      11             :    | If you did not receive a copy of the Zend license and are unable to  |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@zend.com so we can mail you a copy immediately.              |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Masaki Fujimoto <fujimoto@php.net>                          |
      16             :    |          Rui Hirokawa <hirokawa@php.net>                             |
      17             :    +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : /* $Id$ */
      21             : 
      22             : #include "zend.h"
      23             : #include "zend_compile.h"
      24             : #include "zend_operators.h"
      25             : #include "zend_multibyte.h"
      26             : #include "zend_ini.h"
      27             : 
      28           0 : static const zend_encoding *dummy_encoding_fetcher(const char *encoding_name TSRMLS_DC)
      29             : {
      30           0 :         return NULL;
      31             : }
      32             : 
      33           0 : static const char *dummy_encoding_name_getter(const zend_encoding *encoding)
      34             : {
      35           0 :         return (const char*)encoding;
      36             : }
      37             : 
      38           0 : static int dummy_encoding_lexer_compatibility_checker(const zend_encoding *encoding)
      39             : {
      40           0 :         return 0;
      41             : }
      42             : 
      43           0 : static const zend_encoding *dummy_encoding_detector(const unsigned char *string, size_t length, const zend_encoding **list, size_t list_size TSRMLS_DC)
      44             : {
      45           0 :         return NULL;
      46             : }
      47             : 
      48           0 : static size_t dummy_encoding_converter(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length, const zend_encoding *encoding_to, const zend_encoding *encoding_from TSRMLS_DC)
      49             : {
      50           0 :         return (size_t)-1;
      51             : }
      52             : 
      53           0 : static int dummy_encoding_list_parser(const char *encoding_list, size_t encoding_list_len, const zend_encoding ***return_list, size_t *return_size, int persistent TSRMLS_DC)
      54             : {
      55           0 :         *return_list = pemalloc(0, persistent);
      56           0 :         *return_size = 0;
      57           0 :         return SUCCESS;
      58             : }
      59             : 
      60           0 : static const zend_encoding *dummy_internal_encoding_getter(TSRMLS_D)
      61             : {
      62           0 :         return NULL;
      63             : }
      64             : 
      65           0 : static int dummy_internal_encoding_setter(const zend_encoding *encoding TSRMLS_DC)
      66             : {
      67           0 :         return FAILURE;
      68             : }
      69             : 
      70             : static zend_multibyte_functions multibyte_functions = {
      71             :         NULL,
      72             :         dummy_encoding_fetcher,
      73             :         dummy_encoding_name_getter,
      74             :         dummy_encoding_lexer_compatibility_checker,
      75             :         dummy_encoding_detector,
      76             :         dummy_encoding_converter,
      77             :         dummy_encoding_list_parser,
      78             :         dummy_internal_encoding_getter,
      79             :         dummy_internal_encoding_setter
      80             : };
      81             : 
      82             : ZEND_API const zend_encoding *zend_multibyte_encoding_utf32be = (const zend_encoding*)"UTF-32BE";
      83             : ZEND_API const zend_encoding *zend_multibyte_encoding_utf32le = (const zend_encoding*)"UTF-32LE";
      84             : ZEND_API const zend_encoding *zend_multibyte_encoding_utf16be = (const zend_encoding*)"UTF-16BE";
      85             : ZEND_API const zend_encoding *zend_multibyte_encoding_utf16le = (const zend_encoding*)"UTF-32LE";
      86             : ZEND_API const zend_encoding *zend_multibyte_encoding_utf8 = (const zend_encoding*)"UTF-8";
      87             : 
      88       21265 : ZEND_API int zend_multibyte_set_functions(const zend_multibyte_functions *functions TSRMLS_DC)
      89             : {
      90       21265 :         zend_multibyte_encoding_utf32be = functions->encoding_fetcher("UTF-32BE" TSRMLS_CC);
      91       21265 :         if (!zend_multibyte_encoding_utf32be) {
      92           0 :                 return FAILURE;
      93             :         }
      94       21265 :         zend_multibyte_encoding_utf32le = functions->encoding_fetcher("UTF-32LE" TSRMLS_CC);
      95       21265 :         if (!zend_multibyte_encoding_utf32le) {
      96           0 :                 return FAILURE;
      97             :         }
      98       21265 :         zend_multibyte_encoding_utf16be = functions->encoding_fetcher("UTF-16BE" TSRMLS_CC);
      99       21265 :         if (!zend_multibyte_encoding_utf16be) {
     100           0 :                 return FAILURE;
     101             :         }
     102       21265 :         zend_multibyte_encoding_utf16le = functions->encoding_fetcher("UTF-16LE" TSRMLS_CC);
     103       21265 :         if (!zend_multibyte_encoding_utf16le) {
     104           0 :                 return FAILURE;
     105             :         }
     106       21265 :         zend_multibyte_encoding_utf8 = functions->encoding_fetcher("UTF-8" TSRMLS_CC);
     107       21265 :         if (!zend_multibyte_encoding_utf8) {
     108           0 :                 return FAILURE;
     109             :         }
     110             : 
     111       21265 :         multibyte_functions = *functions;
     112             : 
     113             :         /* As zend_multibyte_set_functions() gets called after ini settings were
     114             :          * populated, we need to reinitialize script_encoding here.
     115             :          */
     116             :         {
     117       21265 :                 const char *value = zend_ini_string("zend.script_encoding", sizeof("zend.script_encoding"), 0);
     118       21265 :                 zend_multibyte_set_script_encoding_by_string(value, strlen(value) TSRMLS_CC);
     119             :         }
     120       21265 :         return SUCCESS;
     121             : }
     122             : 
     123         166 : ZEND_API const zend_multibyte_functions *zend_multibyte_get_functions(TSRMLS_D)
     124             : {
     125         166 :         return multibyte_functions.provider_name ? &multibyte_functions: NULL;
     126             : }
     127             : 
     128          31 : ZEND_API const zend_encoding *zend_multibyte_fetch_encoding(const char *name TSRMLS_DC)
     129             : {
     130          31 :         return multibyte_functions.encoding_fetcher(name TSRMLS_CC);
     131             : }
     132             : 
     133          18 : ZEND_API const char *zend_multibyte_get_encoding_name(const zend_encoding *encoding)
     134             : {
     135          18 :         return multibyte_functions.encoding_name_getter(encoding);
     136             : }
     137             : 
     138          52 : ZEND_API int zend_multibyte_check_lexer_compatibility(const zend_encoding *encoding)
     139             : {
     140          52 :         return multibyte_functions.lexer_compatibility_checker(encoding);
     141             : }
     142             : 
     143           3 : ZEND_API const zend_encoding *zend_multibyte_encoding_detector(const unsigned char *string, size_t length, const zend_encoding **list, size_t list_size TSRMLS_DC)
     144             : {
     145           3 :         return multibyte_functions.encoding_detector(string, length, list, list_size TSRMLS_CC);
     146             : }
     147             : 
     148          68 : ZEND_API size_t zend_multibyte_encoding_converter(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length, const zend_encoding *encoding_to, const zend_encoding *encoding_from TSRMLS_DC)
     149             : {
     150          68 :         return multibyte_functions.encoding_converter(to, to_length, from, from_length, encoding_to, encoding_from TSRMLS_CC);
     151             : }
     152             : 
     153      127590 : ZEND_API int zend_multibyte_parse_encoding_list(const char *encoding_list, size_t encoding_list_len, const zend_encoding ***return_list, size_t *return_size, int persistent TSRMLS_DC)
     154             : {
     155      127590 :         return multibyte_functions.encoding_list_parser(encoding_list, encoding_list_len, return_list, return_size, persistent TSRMLS_CC);
     156             : }
     157             : 
     158         120 : ZEND_API const zend_encoding *zend_multibyte_get_internal_encoding(TSRMLS_D)
     159             : {
     160         120 :         return multibyte_functions.internal_encoding_getter(TSRMLS_C);
     161             : }
     162             : 
     163           0 : ZEND_API const zend_encoding *zend_multibyte_get_script_encoding(TSRMLS_D)
     164             : {
     165           0 :         return LANG_SCNG(script_encoding);
     166             : }
     167             : 
     168          13 : ZEND_API int zend_multibyte_set_script_encoding(const zend_encoding **encoding_list, size_t encoding_list_size TSRMLS_DC)
     169             : {
     170          13 :         if (CG(script_encoding_list)) {
     171           0 :                 free(CG(script_encoding_list));
     172             :         }
     173          13 :         CG(script_encoding_list) = encoding_list;
     174          13 :         CG(script_encoding_list_size) = encoding_list_size;
     175          13 :         return SUCCESS;
     176             : }
     177             : 
     178       21222 : ZEND_API int zend_multibyte_set_internal_encoding(const zend_encoding *encoding TSRMLS_DC)
     179             : {
     180       21222 :         return multibyte_functions.internal_encoding_setter(encoding TSRMLS_CC);
     181             : }
     182             : 
     183       21265 : ZEND_API int zend_multibyte_set_script_encoding_by_string(const char *new_value, size_t new_value_length TSRMLS_DC)
     184             : {
     185       21265 :         const zend_encoding **list = 0;
     186       21265 :         size_t size = 0;
     187             : 
     188       21265 :         if (!new_value) {
     189           0 :                 zend_multibyte_set_script_encoding(NULL, 0 TSRMLS_CC);
     190           0 :                 return SUCCESS;
     191             :         }
     192             : 
     193       21265 :         if (FAILURE == zend_multibyte_parse_encoding_list(new_value, new_value_length, &list, &size, 1 TSRMLS_CC)) {
     194       21252 :                 return FAILURE;
     195             :         }
     196             : 
     197          13 :         if (size == 0) {
     198           0 :                 pefree(list, 1);
     199           0 :                 return FAILURE;
     200             :         }
     201             : 
     202          13 :         if (FAILURE == zend_multibyte_set_script_encoding(list, size TSRMLS_CC)) {
     203           0 :                 return FAILURE;
     204             :         }
     205             : 
     206          13 :         return SUCCESS;
     207             : }
     208             : 
     209             : /*
     210             :  * Local variables:
     211             :  * tab-width: 4
     212             :  * c-basic-offset: 4
     213             :  * End:
     214             :  * vim600: sw=4 ts=4 tw=78
     215             :  * vim<600: sw=4 ts=4 tw=78
     216             :  */

Generated by: LCOV version 1.10

Generated at Mon, 04 Aug 2014 15:49:00 +0000 (24 days ago)

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