release/src/router/php/Zend/zend_multibyte.c

   1 /*
   2    +----------------------------------------------------------------------+
   3    | Zend Engine                                                          |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 1998-2013 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 static const zend_encoding *dummy_encoding_fetcher(const char *encoding_name TSRMLS_DC)
  29 {
  30         return NULL;
  31 }
  32
  33 static const char *dummy_encoding_name_getter(const zend_encoding *encoding)
  34 {
  35         return (const char*)encoding;
  36 }
  37
  38 static int dummy_encoding_lexer_compatibility_checker(const zend_encoding *encoding)
  39 {
  40         return 0;
  41 }
  42
  43 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         return NULL;
  46 }
  47
  48 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         return (size_t)-1;
  51 }
  52
  53 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         *return_list = pemalloc(0, persistent);
  56         return_size = 0;
  57         return SUCCESS;
  58 }
  59
  60 static const zend_encoding *dummy_internal_encoding_getter(TSRMLS_D)
  61 {
  62         return NULL;
  63 }
  64
  65 static int dummy_internal_encoding_setter(const zend_encoding *encoding TSRMLS_DC)
  66 {
  67         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 ZEND_API int zend_multibyte_set_functions(const zend_multibyte_functions *functions TSRMLS_DC)
  89 {
  90         zend_multibyte_encoding_utf32be = functions->encoding_fetcher("UTF-32BE" TSRMLS_CC);
  91         if (!zend_multibyte_encoding_utf32be) {
  92                 return FAILURE;
  93         }
  94         zend_multibyte_encoding_utf32le = functions->encoding_fetcher("UTF-32LE" TSRMLS_CC);
  95         if (!zend_multibyte_encoding_utf32le) {
  96                 return FAILURE;
  97         }
  98         zend_multibyte_encoding_utf16be = functions->encoding_fetcher("UTF-16BE" TSRMLS_CC);
  99         if (!zend_multibyte_encoding_utf16be) {
 100                 return FAILURE;
 101         }
 102         zend_multibyte_encoding_utf16le = functions->encoding_fetcher("UTF-16LE" TSRMLS_CC);
 103         if (!zend_multibyte_encoding_utf16le) {
 104                 return FAILURE;
 105         }
 106         zend_multibyte_encoding_utf8 = functions->encoding_fetcher("UTF-8" TSRMLS_CC);
 107         if (!zend_multibyte_encoding_utf8) {
 108                 return FAILURE;
 109         }
 110
 111         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                 const char *value = zend_ini_string("zend.script_encoding", sizeof("zend.script_encoding"), 0);
 118                 zend_multibyte_set_script_encoding_by_string(value, strlen(value) TSRMLS_CC);
 119         }
 120         return SUCCESS;
 121 }
 122
 123 ZEND_API const zend_multibyte_functions *zend_multibyte_get_functions(TSRMLS_D)
 124 {
 125         return multibyte_functions.provider_name ? &multibyte_functions: NULL;
 126 }
 127
 128 ZEND_API const zend_encoding *zend_multibyte_fetch_encoding(const char *name TSRMLS_DC)
 129 {
 130         return multibyte_functions.encoding_fetcher(name TSRMLS_CC);
 131 }
 132
 133 ZEND_API const char *zend_multibyte_get_encoding_name(const zend_encoding *encoding)
 134 {
 135         return multibyte_functions.encoding_name_getter(encoding);
 136 }
 137
 138 ZEND_API int zend_multibyte_check_lexer_compatibility(const zend_encoding *encoding)
 139 {
 140         return multibyte_functions.lexer_compatibility_checker(encoding);
 141 }
 142
 143 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         return multibyte_functions.encoding_detector(string, length, list, list_size TSRMLS_CC);
 146 }
 147
 148 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         return multibyte_functions.encoding_converter(to, to_length, from, from_length, encoding_to, encoding_from TSRMLS_CC);
 151 }
 152
 153 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         return multibyte_functions.encoding_list_parser(encoding_list, encoding_list_len, return_list, return_size, persistent TSRMLS_CC);
 156 }
 157
 158 ZEND_API const zend_encoding *zend_multibyte_get_internal_encoding(TSRMLS_D)
 159 {
 160         return multibyte_functions.internal_encoding_getter(TSRMLS_C);
 161 }
 162
 163 ZEND_API const zend_encoding *zend_multibyte_get_script_encoding(TSRMLS_D)
 164 {
 165         return LANG_SCNG(script_encoding);
 166 }
 167
 168 ZEND_API int zend_multibyte_set_script_encoding(const zend_encoding **encoding_list, size_t encoding_list_size TSRMLS_DC)
 169 {
 170         if (CG(script_encoding_list)) {
 171                 free(CG(script_encoding_list));
 172         }
 173         CG(script_encoding_list) = encoding_list;
 174         CG(script_encoding_list_size) = encoding_list_size;
 175         return SUCCESS;
 176 }
 177
 178 ZEND_API int zend_multibyte_set_internal_encoding(const zend_encoding *encoding TSRMLS_DC)
 179 {
 180         return multibyte_functions.internal_encoding_setter(encoding TSRMLS_CC);
 181 }
 182
 183 ZEND_API int zend_multibyte_set_script_encoding_by_string(const char *new_value, size_t new_value_length TSRMLS_DC)
 184 {
 185         const zend_encoding **list = 0;
 186         size_t size = 0;
 187
 188         if (!new_value) {
 189                 zend_multibyte_set_script_encoding(NULL, 0 TSRMLS_CC);
 190                 return SUCCESS;
 191         }
 192
 193         if (FAILURE == zend_multibyte_parse_encoding_list(new_value, new_value_length, &list, &size, 1 TSRMLS_CC)) {
 194                 return FAILURE;
 195         }
 196
 197         if (size == 0) {
 198                 pefree(list, 1);
 199                 return FAILURE;
 200         }
 201
 202         if (FAILURE == zend_multibyte_set_script_encoding(list, size TSRMLS_CC)) {
 203                 return FAILURE;
 204         }
 205
 206         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  */