1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 7 |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | http://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Authors: Sara Golemon <pollita@php.net> |
14 +----------------------------------------------------------------------+
15 */
16
17 #include "converter.h"
18 #include "zend_exceptions.h"
19
20 #include <unicode/utypes.h>
21 #include <unicode/ucnv.h>
22 #include <unicode/ustring.h>
23
24 #include "../intl_error.h"
25 #include "../intl_common.h"
26
27 typedef struct _php_converter_object {
28 UConverter *src, *dest;
29 zend_fcall_info to_cb, from_cb;
30 zend_fcall_info_cache to_cache, from_cache;
31 intl_error error;
32 zend_object obj;
33 } php_converter_object;
34
35
php_converter_fetch_object(zend_object * obj)36 static inline php_converter_object *php_converter_fetch_object(zend_object *obj) {
37 return (php_converter_object *)((char*)(obj) - XtOffsetOf(php_converter_object, obj));
38 }
39 #define Z_INTL_CONVERTER_P(zv) php_converter_fetch_object(Z_OBJ_P(zv))
40
41 static zend_class_entry *php_converter_ce;
42 static zend_object_handlers php_converter_object_handlers;
43
44 #define CONV_GET(pzv) (Z_INTL_CONVERTER_P((pzv)))
45 #define THROW_UFAILURE(obj, fname, error) php_converter_throw_failure(obj, error, \
46 fname "() returned error " ZEND_LONG_FMT ": %s", (zend_long)error, u_errorName(error))
47
48 /* {{{ php_converter_throw_failure */
php_converter_throw_failure(php_converter_object * objval,UErrorCode error,const char * format,...)49 static inline void php_converter_throw_failure(php_converter_object *objval, UErrorCode error, const char *format, ...) {
50 intl_error *err = objval ? &(objval->error) : NULL;
51 char message[1024];
52 va_list vargs;
53
54 va_start(vargs, format);
55 vsnprintf(message, sizeof(message), format, vargs);
56 va_end(vargs);
57
58 intl_errors_set(err, error, message, 1);
59 }
60 /* }}} */
61
62 /* {{{ php_converter_default_callback */
php_converter_default_callback(zval * return_value,zval * zobj,zend_long reason,zval * error)63 static void php_converter_default_callback(zval *return_value, zval *zobj, zend_long reason, zval *error) {
64 ZVAL_DEREF(error);
65 zval_ptr_dtor(error);
66 ZVAL_LONG(error, U_ZERO_ERROR);
67 /* Basic functionality so children can call parent::toUCallback() */
68 switch (reason) {
69 case UCNV_UNASSIGNED:
70 case UCNV_ILLEGAL:
71 case UCNV_IRREGULAR:
72 {
73 php_converter_object *objval = (php_converter_object*)CONV_GET(zobj);
74 char chars[127];
75 int8_t chars_len = sizeof(chars);
76 UErrorCode uerror = U_ZERO_ERROR;
77 if(!objval->src) {
78 php_converter_throw_failure(objval, U_INVALID_STATE_ERROR, "Source Converter has not been initialized yet");
79 chars[0] = 0x1A;
80 chars[1] = 0;
81 chars_len = 1;
82 ZVAL_LONG(error, U_INVALID_STATE_ERROR);
83 RETVAL_STRINGL(chars, chars_len);
84 return;
85 }
86
87 /* Yes, this is fairly wasteful at first glance,
88 * but considering that the alternative is to store
89 * what's sent into setSubstChars() and the fact
90 * that this is an extremely unlikely codepath
91 * I'd rather take the CPU hit here, than waste time
92 * storing a value I'm unlikely to use.
93 */
94 ucnv_getSubstChars(objval->src, chars, &chars_len, &uerror);
95 if (U_FAILURE(uerror)) {
96 THROW_UFAILURE(objval, "ucnv_getSubstChars", uerror);
97 chars[0] = 0x1A;
98 chars[1] = 0;
99 chars_len = 1;
100 ZVAL_LONG(error, uerror);
101 }
102 RETVAL_STRINGL(chars, chars_len);
103 }
104 }
105 }
106 /* }}} */
107
108 /* {{{ proto void UConverter::toUCallback(long $reason,
109 string $source, string $codeUnits,
110 long &$error) */
111 ZEND_BEGIN_ARG_INFO_EX(php_converter_toUCallback_arginfo, 0, ZEND_RETURN_VALUE, 4)
112 ZEND_ARG_INFO(0, reason)
113 ZEND_ARG_INFO(0, source)
114 ZEND_ARG_INFO(0, codeUnits)
115 ZEND_ARG_INFO(1, error)
116 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,toUCallback)117 static PHP_METHOD(UConverter, toUCallback) {
118 zend_long reason;
119 zval *source, *codeUnits, *error;
120
121 if (zend_parse_parameters(ZEND_NUM_ARGS(), "lzzz",
122 &reason, &source, &codeUnits, &error) == FAILURE) {
123 return;
124 }
125
126 php_converter_default_callback(return_value, getThis(), reason, error);
127 }
128 /* }}} */
129
130 /* {{{ proto void UConverter::fromUCallback(long $reason,
131 Array $source, long $codePoint,
132 long &$error) */
133 ZEND_BEGIN_ARG_INFO_EX(php_converter_fromUCallback_arginfo, 0, ZEND_RETURN_VALUE, 4)
134 ZEND_ARG_INFO(0, reason)
135 ZEND_ARG_INFO(0, source)
136 ZEND_ARG_INFO(0, codePoint)
137 ZEND_ARG_INFO(1, error)
138 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,fromUCallback)139 static PHP_METHOD(UConverter, fromUCallback) {
140 zend_long reason;
141 zval *source, *codePoint, *error;
142
143 if (zend_parse_parameters(ZEND_NUM_ARGS(), "lzzz",
144 &reason, &source, &codePoint, &error) == FAILURE) {
145 return;
146 }
147
148 php_converter_default_callback(return_value, getThis(), reason, error);
149 }
150 /* }}} */
151
152 /* {{{ php_converter_check_limits */
php_converter_check_limits(php_converter_object * objval,zend_long available,zend_long needed)153 static inline zend_bool php_converter_check_limits(php_converter_object *objval, zend_long available, zend_long needed) {
154 if (available < needed) {
155 php_converter_throw_failure(objval, U_BUFFER_OVERFLOW_ERROR, "Buffer overrun " ZEND_LONG_FMT " bytes needed, " ZEND_LONG_FMT " available", needed, available);
156 return 0;
157 }
158 return 1;
159 }
160 /* }}} */
161
162 #define TARGET_CHECK(cnvargs, needed) php_converter_check_limits(objval, cnvargs->targetLimit - cnvargs->target, needed)
163
164 /* {{{ php_converter_append_toUnicode_target */
php_converter_append_toUnicode_target(zval * val,UConverterToUnicodeArgs * args,php_converter_object * objval)165 static void php_converter_append_toUnicode_target(zval *val, UConverterToUnicodeArgs *args, php_converter_object *objval) {
166 switch (Z_TYPE_P(val)) {
167 case IS_NULL:
168 /* Code unit is being skipped */
169 return;
170 case IS_LONG:
171 {
172 zend_long lval = Z_LVAL_P(val);
173 if ((lval < 0) || (lval > 0x10FFFF)) {
174 php_converter_throw_failure(objval, U_ILLEGAL_ARGUMENT_ERROR, "Invalid codepoint U+%04lx", lval);
175 return;
176 }
177 if (lval > 0xFFFF) {
178 /* Supplemental planes U+010000 - U+10FFFF */
179 if (TARGET_CHECK(args, 2)) {
180 /* TODO: Find the ICU call which does this properly */
181 *(args->target++) = (UChar)(((lval - 0x10000) >> 10) | 0xD800);
182 *(args->target++) = (UChar)(((lval - 0x10000) & 0x3FF) | 0xDC00);
183 }
184 return;
185 }
186 /* Non-suggogate BMP codepoint */
187 if (TARGET_CHECK(args, 1)) {
188 *(args->target++) = (UChar)lval;
189 }
190 return;
191 }
192 case IS_STRING:
193 {
194 const char *strval = Z_STRVAL_P(val);
195 int i = 0, strlen = Z_STRLEN_P(val);
196
197 while((i != strlen) && TARGET_CHECK(args, 1)) {
198 UChar c;
199 U8_NEXT(strval, i, strlen, c);
200 *(args->target++) = c;
201 }
202 return;
203 }
204 case IS_ARRAY:
205 {
206 HashTable *ht = Z_ARRVAL_P(val);
207 zval *tmpzval;
208
209 ZEND_HASH_FOREACH_VAL(ht, tmpzval) {
210 php_converter_append_toUnicode_target(tmpzval, args, objval);
211 } ZEND_HASH_FOREACH_END();
212 return;
213 }
214 default:
215 php_converter_throw_failure(objval, U_ILLEGAL_ARGUMENT_ERROR,
216 "toUCallback() specified illegal type for substitution character");
217 }
218 }
219 /* }}} */
220
221 /* {{{ php_converter_to_u_callback */
php_converter_to_u_callback(const void * context,UConverterToUnicodeArgs * args,const char * codeUnits,int32_t length,UConverterCallbackReason reason,UErrorCode * pErrorCode)222 static void php_converter_to_u_callback(const void *context,
223 UConverterToUnicodeArgs *args,
224 const char *codeUnits, int32_t length,
225 UConverterCallbackReason reason,
226 UErrorCode *pErrorCode) {
227 php_converter_object *objval = (php_converter_object*)context;
228 zval retval;
229 zval zargs[4];
230
231 ZVAL_LONG(&zargs[0], reason);
232 ZVAL_STRINGL(&zargs[1], args->source, args->sourceLimit - args->source);
233 ZVAL_STRINGL(&zargs[2], codeUnits, length);
234 ZVAL_LONG(&zargs[3], *pErrorCode);
235
236 objval->to_cb.param_count = 4;
237 objval->to_cb.params = zargs;
238 objval->to_cb.retval = &retval;
239 objval->to_cb.no_separation = 0;
240 if (zend_call_function(&(objval->to_cb), &(objval->to_cache)) == FAILURE) {
241 /* Unlikely */
242 php_converter_throw_failure(objval, U_INTERNAL_PROGRAM_ERROR, "Unexpected failure calling toUCallback()");
243 } else if (!Z_ISUNDEF(retval)) {
244 php_converter_append_toUnicode_target(&retval, args, objval);
245 zval_ptr_dtor(&retval);
246 }
247
248 if (Z_TYPE(zargs[3]) == IS_LONG) {
249 *pErrorCode = Z_LVAL(zargs[3]);
250 } else if (Z_ISREF(zargs[3]) && Z_TYPE_P(Z_REFVAL(zargs[3])) == IS_LONG) {
251 *pErrorCode = Z_LVAL_P(Z_REFVAL(zargs[3]));
252 }
253
254 zval_ptr_dtor(&zargs[0]);
255 zval_ptr_dtor(&zargs[1]);
256 zval_ptr_dtor(&zargs[2]);
257 zval_ptr_dtor(&zargs[3]);
258 }
259 /* }}} */
260
261 /* {{{ php_converter_append_fromUnicode_target */
php_converter_append_fromUnicode_target(zval * val,UConverterFromUnicodeArgs * args,php_converter_object * objval)262 static void php_converter_append_fromUnicode_target(zval *val, UConverterFromUnicodeArgs *args, php_converter_object *objval) {
263 switch (Z_TYPE_P(val)) {
264 case IS_NULL:
265 /* Ignore */
266 return;
267 case IS_LONG:
268 if (TARGET_CHECK(args, 1)) {
269 *(args->target++) = Z_LVAL_P(val);
270 }
271 return;
272 case IS_STRING:
273 {
274 size_t vallen = Z_STRLEN_P(val);
275 if (TARGET_CHECK(args, vallen)) {
276 memcpy(args->target, Z_STRVAL_P(val), vallen);
277 args->target += vallen;
278 }
279 return;
280 }
281 case IS_ARRAY:
282 {
283 HashTable *ht = Z_ARRVAL_P(val);
284 zval *tmpzval;
285 ZEND_HASH_FOREACH_VAL(ht, tmpzval) {
286 php_converter_append_fromUnicode_target(tmpzval, args, objval);
287 } ZEND_HASH_FOREACH_END();
288 return;
289 }
290 default:
291 php_converter_throw_failure(objval, U_ILLEGAL_ARGUMENT_ERROR, "fromUCallback() specified illegal type for substitution character");
292 }
293 }
294 /* }}} */
295
296 /* {{{ php_converter_from_u_callback */
php_converter_from_u_callback(const void * context,UConverterFromUnicodeArgs * args,const UChar * codeUnits,int32_t length,UChar32 codePoint,UConverterCallbackReason reason,UErrorCode * pErrorCode)297 static void php_converter_from_u_callback(const void *context,
298 UConverterFromUnicodeArgs *args,
299 const UChar *codeUnits, int32_t length, UChar32 codePoint,
300 UConverterCallbackReason reason,
301 UErrorCode *pErrorCode) {
302 php_converter_object *objval = (php_converter_object*)context;
303 zval retval;
304 zval zargs[4];
305 int i;
306
307 ZVAL_LONG(&zargs[0], reason);
308 array_init(&zargs[1]);
309 i = 0;
310 while (i < length) {
311 UChar32 c;
312 U16_NEXT(codeUnits, i, length, c);
313 add_next_index_long(&zargs[1], c);
314 }
315 ZVAL_LONG(&zargs[2], codePoint);
316 ZVAL_LONG(&zargs[3], *pErrorCode);
317
318 objval->from_cb.param_count = 4;
319 objval->from_cb.params = zargs;
320 objval->from_cb.retval = &retval;
321 objval->from_cb.no_separation = 0;
322 if (zend_call_function(&(objval->from_cb), &(objval->from_cache)) == FAILURE) {
323 /* Unlikely */
324 php_converter_throw_failure(objval, U_INTERNAL_PROGRAM_ERROR, "Unexpected failure calling fromUCallback()");
325 } else if (!Z_ISUNDEF(retval)) {
326 php_converter_append_fromUnicode_target(&retval, args, objval);
327 zval_ptr_dtor(&retval);
328 }
329
330 if (Z_TYPE(zargs[3]) == IS_LONG) {
331 *pErrorCode = Z_LVAL(zargs[3]);
332 } else if (Z_ISREF(zargs[3]) && Z_TYPE_P(Z_REFVAL(zargs[3])) == IS_LONG) {
333 *pErrorCode = Z_LVAL_P(Z_REFVAL(zargs[3]));
334 }
335
336 zval_ptr_dtor(&zargs[0]);
337 zval_ptr_dtor(&zargs[1]);
338 zval_ptr_dtor(&zargs[2]);
339 zval_ptr_dtor(&zargs[3]);
340 }
341 /* }}} */
342
343 /* {{{ php_converter_set_callbacks */
php_converter_set_callbacks(php_converter_object * objval,UConverter * cnv)344 static inline zend_bool php_converter_set_callbacks(php_converter_object *objval, UConverter *cnv) {
345 zend_bool ret = 1;
346 UErrorCode error = U_ZERO_ERROR;
347
348 if (objval->obj.ce == php_converter_ce) {
349 /* Short-circuit having to go through method calls and data marshalling
350 * when we're using default behavior
351 */
352 return 1;
353 }
354
355 ucnv_setToUCallBack(cnv, (UConverterToUCallback)php_converter_to_u_callback, (const void*)objval,
356 NULL, NULL, &error);
357 if (U_FAILURE(error)) {
358 THROW_UFAILURE(objval, "ucnv_setToUCallBack", error);
359 ret = 0;
360 }
361
362 error = U_ZERO_ERROR;
363 ucnv_setFromUCallBack(cnv, (UConverterFromUCallback)php_converter_from_u_callback, (const void*)objval,
364 NULL, NULL, &error);
365 if (U_FAILURE(error)) {
366 THROW_UFAILURE(objval, "ucnv_setFromUCallBack", error);
367 ret = 0;
368 }
369 return ret;
370 }
371 /* }}} */
372
373 /* {{{ php_converter_set_encoding */
php_converter_set_encoding(php_converter_object * objval,UConverter ** pcnv,const char * enc,size_t enc_len)374 static zend_bool php_converter_set_encoding(php_converter_object *objval,
375 UConverter **pcnv,
376 const char *enc, size_t enc_len
377 ) {
378 UErrorCode error = U_ZERO_ERROR;
379 UConverter *cnv = ucnv_open(enc, &error);
380
381 if (error == U_AMBIGUOUS_ALIAS_WARNING) {
382 UErrorCode getname_error = U_ZERO_ERROR;
383 const char *actual_encoding = ucnv_getName(cnv, &getname_error);
384 if (U_FAILURE(getname_error)) {
385 /* Should never happen */
386 actual_encoding = "(unknown)";
387 }
388 php_error_docref(NULL, E_WARNING, "Ambiguous encoding specified, using %s", actual_encoding);
389 } else if (U_FAILURE(error)) {
390 if (objval) {
391 THROW_UFAILURE(objval, "ucnv_open", error);
392 } else {
393 php_error_docref(NULL, E_WARNING, "Error setting encoding: %d - %s", (int)error, u_errorName(error));
394 }
395 return 0;
396 }
397
398 if (objval && !php_converter_set_callbacks(objval, cnv)) {
399 return 0;
400 }
401
402 if (*pcnv) {
403 ucnv_close(*pcnv);
404 }
405 *pcnv = cnv;
406 return 1;
407 }
408 /* }}} */
409
410 /* {{{ php_converter_do_set_encoding */
411 ZEND_BEGIN_ARG_INFO_EX(php_converter_set_encoding_arginfo, 0, ZEND_RETURN_VALUE, 1)
412 ZEND_ARG_INFO(0, encoding)
413 ZEND_END_ARG_INFO();
php_converter_do_set_encoding(UConverter ** pcnv,INTERNAL_FUNCTION_PARAMETERS)414 static void php_converter_do_set_encoding(UConverter **pcnv, INTERNAL_FUNCTION_PARAMETERS) {
415 php_converter_object *objval = CONV_GET(getThis());
416 char *enc;
417 size_t enc_len;
418
419 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &enc, &enc_len) == FAILURE) {
420 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "Bad arguments, "
421 "expected one string argument", 0);
422 RETURN_FALSE;
423 }
424 intl_errors_reset(&objval->error);
425
426 RETURN_BOOL(php_converter_set_encoding(objval, pcnv, enc, enc_len));
427 }
428 /* }}} */
429
430 /* {{{ proto bool UConverter::setSourceEncoding(string encoding) */
PHP_METHOD(UConverter,setSourceEncoding)431 static PHP_METHOD(UConverter, setSourceEncoding) {
432 php_converter_object *objval = CONV_GET(getThis());
433 php_converter_do_set_encoding(&(objval->src), INTERNAL_FUNCTION_PARAM_PASSTHRU);
434 }
435 /* }}} */
436
437 /* {{{ proto bool UConverter::setDestinationEncoding(string encoding) */
PHP_METHOD(UConverter,setDestinationEncoding)438 static PHP_METHOD(UConverter, setDestinationEncoding) {
439 php_converter_object *objval = CONV_GET(getThis());
440 php_converter_do_set_encoding(&(objval->dest), INTERNAL_FUNCTION_PARAM_PASSTHRU);
441 }
442 /* }}} */
443
444 /* {{{ php_converter_do_get_encoding */
445 ZEND_BEGIN_ARG_INFO_EX(php_converter_get_encoding_arginfo, 0, ZEND_RETURN_VALUE, 0)
446 ZEND_END_ARG_INFO();
php_converter_do_get_encoding(php_converter_object * objval,UConverter * cnv,INTERNAL_FUNCTION_PARAMETERS)447 static void php_converter_do_get_encoding(php_converter_object *objval, UConverter *cnv, INTERNAL_FUNCTION_PARAMETERS) {
448 const char *name;
449
450 if (zend_parse_parameters_none() == FAILURE) {
451 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "Expected no arguments", 0);
452 RETURN_FALSE;
453 }
454
455 intl_errors_reset(&objval->error);
456
457 if (!cnv) {
458 RETURN_NULL();
459 }
460
461 name = ucnv_getName(cnv, &objval->error.code);
462 if (U_FAILURE(objval->error.code)) {
463 THROW_UFAILURE(objval, "ucnv_getName()", objval->error.code);
464 RETURN_FALSE;
465 }
466
467 RETURN_STRING(name);
468 }
469 /* }}} */
470
471 /* {{{ proto string UConverter::getSourceEncoding() */
PHP_METHOD(UConverter,getSourceEncoding)472 static PHP_METHOD(UConverter, getSourceEncoding) {
473 php_converter_object *objval = CONV_GET(getThis());
474 php_converter_do_get_encoding(objval, objval->src, INTERNAL_FUNCTION_PARAM_PASSTHRU);
475 }
476 /* }}} */
477
478 /* {{{ proto string UConverter::getDestinationEncoding() */
PHP_METHOD(UConverter,getDestinationEncoding)479 static PHP_METHOD(UConverter, getDestinationEncoding) {
480 php_converter_object *objval = CONV_GET(getThis());
481 php_converter_do_get_encoding(objval, objval->dest, INTERNAL_FUNCTION_PARAM_PASSTHRU);
482 }
483 /* }}} */
484
485 /* {{{ php_converter_do_get_type */
486 ZEND_BEGIN_ARG_INFO_EX(php_converter_get_type_arginfo, 0, ZEND_RETURN_VALUE, 0)
487 ZEND_END_ARG_INFO();
php_converter_do_get_type(php_converter_object * objval,UConverter * cnv,INTERNAL_FUNCTION_PARAMETERS)488 static void php_converter_do_get_type(php_converter_object *objval, UConverter *cnv, INTERNAL_FUNCTION_PARAMETERS) {
489 UConverterType t;
490
491 if (zend_parse_parameters_none() == FAILURE) {
492 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "Expected no arguments", 0);
493 RETURN_FALSE;
494 }
495 intl_errors_reset(&objval->error);
496
497 if (!cnv) {
498 RETURN_NULL();
499 }
500
501 t = ucnv_getType(cnv);
502 if (U_FAILURE(objval->error.code)) {
503 THROW_UFAILURE(objval, "ucnv_getType", objval->error.code);
504 RETURN_FALSE;
505 }
506
507 RETURN_LONG(t);
508 }
509 /* }}} */
510
511 /* {{{ proto long UConverter::getSourceType() */
PHP_METHOD(UConverter,getSourceType)512 static PHP_METHOD(UConverter, getSourceType) {
513 php_converter_object *objval = CONV_GET(getThis());
514 php_converter_do_get_type(objval, objval->src, INTERNAL_FUNCTION_PARAM_PASSTHRU);
515 }
516 /* }}} */
517
518 /* {{{ proto long UConverter::getDestinationType() */
PHP_METHOD(UConverter,getDestinationType)519 static PHP_METHOD(UConverter, getDestinationType) {
520 php_converter_object *objval = CONV_GET(getThis());
521 php_converter_do_get_type(objval, objval->dest, INTERNAL_FUNCTION_PARAM_PASSTHRU);
522 }
523 /* }}} */
524
525 /* {{{ php_converter_resolve_callback */
php_converter_resolve_callback(zval * zobj,php_converter_object * objval,const char * callback_name,zend_fcall_info * finfo,zend_fcall_info_cache * fcache)526 static void php_converter_resolve_callback(zval *zobj,
527 php_converter_object *objval,
528 const char *callback_name,
529 zend_fcall_info *finfo,
530 zend_fcall_info_cache *fcache) {
531 char *errstr = NULL;
532 zval caller;
533
534 array_init(&caller);
535 Z_ADDREF_P(zobj);
536 add_index_zval(&caller, 0, zobj);
537 add_index_string(&caller, 1, callback_name);
538 if (zend_fcall_info_init(&caller, 0, finfo, fcache, NULL, &errstr) == FAILURE) {
539 php_converter_throw_failure(objval, U_INTERNAL_PROGRAM_ERROR, "Error setting converter callback: %s", errstr);
540 }
541 zval_dtor(&caller);
542 if (errstr) {
543 efree(errstr);
544 }
545 }
546 /* }}} */
547
548 /* {{{ proto void UConverter::__construct([string dest = 'utf-8',[string src = 'utf-8']]) */
549 ZEND_BEGIN_ARG_INFO_EX(php_converter_arginfo, 0, ZEND_RETURN_VALUE, 0)
550 ZEND_ARG_INFO(0, destination_encoding)
551 ZEND_ARG_INFO(0, source_encoding)
552 ZEND_END_ARG_INFO();
553
PHP_METHOD(UConverter,__construct)554 static PHP_METHOD(UConverter, __construct) {
555 php_converter_object *objval = CONV_GET(getThis());
556 char *src = "utf-8";
557 size_t src_len = sizeof("utf-8") - 1;
558 char *dest = src;
559 size_t dest_len = src_len;
560
561 intl_error_reset(NULL);
562
563 if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "|s!s!", &dest, &dest_len, &src, &src_len) == FAILURE) {
564 return;
565 }
566
567 php_converter_set_encoding(objval, &(objval->src), src, src_len );
568 php_converter_set_encoding(objval, &(objval->dest), dest, dest_len);
569 php_converter_resolve_callback(getThis(), objval, "toUCallback", &(objval->to_cb), &(objval->to_cache));
570 php_converter_resolve_callback(getThis(), objval, "fromUCallback", &(objval->from_cb), &(objval->from_cache));
571 }
572 /* }}} */
573
574 /* {{{ proto bool UConverter::setSubstChars(string $chars) */
575 ZEND_BEGIN_ARG_INFO_EX(php_converter_setSubstChars_arginfo, 0, ZEND_RETURN_VALUE, 1)
576 ZEND_ARG_INFO(0, chars)
577 ZEND_END_ARG_INFO();
578
PHP_METHOD(UConverter,setSubstChars)579 static PHP_METHOD(UConverter, setSubstChars) {
580 php_converter_object *objval = CONV_GET(getThis());
581 char *chars;
582 size_t chars_len;
583 int ret = 1;
584
585 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &chars, &chars_len) == FAILURE) {
586 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
587 "UConverter::setSubstChars(): bad arguments", 0);
588 RETURN_FALSE;
589 }
590 intl_errors_reset(&objval->error);
591
592 if (objval->src) {
593 UErrorCode error = U_ZERO_ERROR;
594 ucnv_setSubstChars(objval->src, chars, chars_len, &error);
595 if (U_FAILURE(error)) {
596 THROW_UFAILURE(objval, "ucnv_setSubstChars", error);
597 ret = 0;
598 }
599 } else {
600 php_converter_throw_failure(objval, U_INVALID_STATE_ERROR, "Source Converter has not been initialized yet");
601 ret = 0;
602 }
603
604 if (objval->dest) {
605 UErrorCode error = U_ZERO_ERROR;
606 ucnv_setSubstChars(objval->dest, chars, chars_len, &error);
607 if (U_FAILURE(error)) {
608 THROW_UFAILURE(objval, "ucnv_setSubstChars", error);
609 ret = 0;
610 }
611 } else {
612 php_converter_throw_failure(objval, U_INVALID_STATE_ERROR, "Destination Converter has not been initialized yet");
613 ret = 0;
614 }
615
616 RETURN_BOOL(ret);
617 }
618 /* }}} */
619
620 /* {{{ proto string UConverter::getSubstChars() */
621 ZEND_BEGIN_ARG_INFO_EX(php_converter_getSubstChars_arginfo, 0, ZEND_RETURN_VALUE, 0)
622 ZEND_END_ARG_INFO();
623
PHP_METHOD(UConverter,getSubstChars)624 static PHP_METHOD(UConverter, getSubstChars) {
625 php_converter_object *objval = CONV_GET(getThis());
626 char chars[127];
627 int8_t chars_len = sizeof(chars);
628 UErrorCode error = U_ZERO_ERROR;
629
630 if (zend_parse_parameters_none() == FAILURE) {
631 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
632 "UConverter::getSubstChars(): expected no arguments", 0);
633 RETURN_FALSE;
634 }
635 intl_errors_reset(&objval->error);
636
637 if (!objval->src) {
638 RETURN_NULL();
639 }
640
641 /* src and dest get the same subst chars set,
642 * so it doesn't really matter which one we read from
643 */
644 ucnv_getSubstChars(objval->src, chars, &chars_len, &error);
645 if (U_FAILURE(error)) {
646 THROW_UFAILURE(objval, "ucnv_getSubstChars", error);
647 RETURN_FALSE;
648 }
649
650 RETURN_STRINGL(chars, chars_len);
651 }
652 /* }}} */
653
654 /* {{{ php_converter_do_convert */
php_converter_do_convert(UConverter * dest_cnv,UConverter * src_cnv,const char * src,int32_t src_len,php_converter_object * objval)655 static zend_string* php_converter_do_convert(UConverter *dest_cnv,
656 UConverter *src_cnv, const char *src, int32_t src_len,
657 php_converter_object *objval
658 ) {
659 UErrorCode error = U_ZERO_ERROR;
660 int32_t temp_len, ret_len;
661 zend_string *ret;
662 UChar *temp;
663
664 if (!src_cnv || !dest_cnv) {
665 php_converter_throw_failure(objval, U_INVALID_STATE_ERROR,
666 "Internal converters not initialized");
667 return NULL;
668 }
669
670 /* Get necessary buffer size first */
671 temp_len = 1 + ucnv_toUChars(src_cnv, NULL, 0, src, src_len, &error);
672 if (U_FAILURE(error) && error != U_BUFFER_OVERFLOW_ERROR) {
673 THROW_UFAILURE(objval, "ucnv_toUChars", error);
674 return NULL;
675 }
676 temp = safe_emalloc(sizeof(UChar), temp_len, sizeof(UChar));
677
678 /* Convert to intermediate UChar* array */
679 error = U_ZERO_ERROR;
680 temp_len = ucnv_toUChars(src_cnv, temp, temp_len, src, src_len, &error);
681 if (U_FAILURE(error)) {
682 THROW_UFAILURE(objval, "ucnv_toUChars", error);
683 efree(temp);
684 return NULL;
685 }
686 temp[temp_len] = 0;
687
688 /* Get necessary output buffer size */
689 ret_len = ucnv_fromUChars(dest_cnv, NULL, 0, temp, temp_len, &error);
690 if (U_FAILURE(error) && error != U_BUFFER_OVERFLOW_ERROR) {
691 THROW_UFAILURE(objval, "ucnv_fromUChars", error);
692 efree(temp);
693 return NULL;
694 }
695
696 ret = zend_string_alloc(ret_len, 0);
697
698 /* Convert to final encoding */
699 error = U_ZERO_ERROR;
700 ZSTR_LEN(ret) = ucnv_fromUChars(dest_cnv, ZSTR_VAL(ret), ret_len+1, temp, temp_len, &error);
701 efree(temp);
702 if (U_FAILURE(error)) {
703 THROW_UFAILURE(objval, "ucnv_fromUChars", error);
704 zend_string_free(ret);
705 return NULL;
706 }
707
708 return ret;
709 }
710 /* }}} */
711
712 /* {{{ proto string UConverter::reasonText(long reason) */
713 #define UCNV_REASON_CASE(v) case (UCNV_ ## v) : RETURN_STRINGL( "REASON_" #v , sizeof( "REASON_" #v ) - 1);
714 ZEND_BEGIN_ARG_INFO_EX(php_converter_reasontext_arginfo, 0, ZEND_RETURN_VALUE, 0)
715 ZEND_ARG_INFO(0, reason)
716 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,reasonText)717 static PHP_METHOD(UConverter, reasonText) {
718 zend_long reason;
719
720 if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &reason) == FAILURE) {
721 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
722 "UConverter::reasonText(): bad arguments", 0);
723 RETURN_FALSE;
724 }
725 intl_error_reset(NULL);
726
727 switch (reason) {
728 UCNV_REASON_CASE(UNASSIGNED)
729 UCNV_REASON_CASE(ILLEGAL)
730 UCNV_REASON_CASE(IRREGULAR)
731 UCNV_REASON_CASE(RESET)
732 UCNV_REASON_CASE(CLOSE)
733 UCNV_REASON_CASE(CLONE)
734 default:
735 php_error_docref(NULL, E_WARNING, "Unknown UConverterCallbackReason: " ZEND_LONG_FMT, reason);
736 RETURN_FALSE;
737 }
738 }
739 /* }}} */
740
741 /* {{{ proto string UConverter::convert(string str[, bool reverse]) */
742 ZEND_BEGIN_ARG_INFO_EX(php_converter_convert_arginfo, 0, ZEND_RETURN_VALUE, 1)
743 ZEND_ARG_INFO(0, str)
744 ZEND_ARG_INFO(0, reverse)
745 ZEND_END_ARG_INFO();
746
PHP_METHOD(UConverter,convert)747 static PHP_METHOD(UConverter, convert) {
748 php_converter_object *objval = CONV_GET(getThis());
749 char *str;
750 size_t str_len;
751 zend_string *ret;
752 zend_bool reverse = 0;
753
754 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b",
755 &str, &str_len, &reverse) == FAILURE) {
756 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
757 "UConverter::convert(): bad arguments", 0);
758 RETURN_FALSE;
759 }
760 intl_errors_reset(&objval->error);
761
762 ret = php_converter_do_convert(reverse ? objval->src : objval->dest,
763 reverse ? objval->dest : objval->src,
764 str, str_len,
765 objval);
766 if (ret) {
767 RETURN_NEW_STR(ret);
768 } else {
769 RETURN_FALSE;
770 }
771 }
772 /* }}} */
773
774 /* {{{ proto string UConverter::transcode(string $str, string $toEncoding, string $fromEncoding[, Array $options = array()]) */
775 ZEND_BEGIN_ARG_INFO_EX(php_converter_transcode_arginfo, 0, ZEND_RETURN_VALUE, 3)
776 ZEND_ARG_INFO(0, str)
777 ZEND_ARG_INFO(0, toEncoding)
778 ZEND_ARG_INFO(0, fromEncoding)
779 ZEND_ARG_ARRAY_INFO(0, options, 1)
780 ZEND_END_ARG_INFO();
781
PHP_METHOD(UConverter,transcode)782 static PHP_METHOD(UConverter, transcode) {
783 char *str, *src, *dest;
784 size_t str_len, src_len, dest_len;
785 zval *options = NULL;
786 UConverter *src_cnv = NULL, *dest_cnv = NULL;
787
788 if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss|a!",
789 &str, &str_len, &dest, &dest_len, &src, &src_len, &options) == FAILURE) {
790 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
791 "UConverter::transcode(): bad arguments", 0);
792 RETURN_FALSE;
793 }
794 intl_error_reset(NULL);
795
796 if (php_converter_set_encoding(NULL, &src_cnv, src, src_len) &&
797 php_converter_set_encoding(NULL, &dest_cnv, dest, dest_len)) {
798 zend_string *ret;
799 UErrorCode error = U_ZERO_ERROR;
800
801 if (options && zend_hash_num_elements(Z_ARRVAL_P(options))) {
802 zval *tmpzval;
803
804 if (U_SUCCESS(error) &&
805 (tmpzval = zend_hash_str_find(Z_ARRVAL_P(options), "from_subst", sizeof("from_subst") - 1)) != NULL &&
806 Z_TYPE_P(tmpzval) == IS_STRING) {
807 error = U_ZERO_ERROR;
808 ucnv_setSubstChars(src_cnv, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval) & 0x7F, &error);
809 }
810 if (U_SUCCESS(error) &&
811 (tmpzval = zend_hash_str_find(Z_ARRVAL_P(options), "to_subst", sizeof("to_subst") - 1)) != NULL &&
812 Z_TYPE_P(tmpzval) == IS_STRING) {
813 error = U_ZERO_ERROR;
814 ucnv_setSubstChars(dest_cnv, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval) & 0x7F, &error);
815 }
816 }
817
818 if (U_SUCCESS(error) &&
819 (ret = php_converter_do_convert(dest_cnv, src_cnv, str, str_len, NULL)) != NULL) {
820 RETURN_NEW_STR(ret);
821 }
822
823 if (U_FAILURE(error)) {
824 THROW_UFAILURE(NULL, "transcode", error);
825 RETVAL_FALSE;
826 }
827 } else {
828 RETVAL_FALSE;
829 }
830
831 if (src_cnv) {
832 ucnv_close(src_cnv);
833 }
834 if (dest_cnv) {
835 ucnv_close(dest_cnv);
836 }
837 }
838 /* }}} */
839
840 /* {{{ proto int UConverter::getErrorCode() */
841 ZEND_BEGIN_ARG_INFO_EX(php_converter_geterrorcode_arginfo, 0, ZEND_RETURN_VALUE, 0)
842 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,getErrorCode)843 static PHP_METHOD(UConverter, getErrorCode) {
844 php_converter_object *objval = CONV_GET(getThis());
845
846 if (zend_parse_parameters_none() == FAILURE) {
847 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
848 "UConverter::getErrorCode(): expected no arguments", 0);
849 RETURN_FALSE;
850 }
851
852 RETURN_LONG(intl_error_get_code(&(objval->error)));
853 }
854 /* }}} */
855
856 /* {{{ proto string UConverter::getErrorMessage() */
857 ZEND_BEGIN_ARG_INFO_EX(php_converter_geterrormsg_arginfo, 0, ZEND_RETURN_VALUE, 0)
858 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,getErrorMessage)859 static PHP_METHOD(UConverter, getErrorMessage) {
860 php_converter_object *objval = CONV_GET(getThis());
861 zend_string *message = intl_error_get_message(&(objval->error));
862
863 if (zend_parse_parameters_none() == FAILURE) {
864 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
865 "UConverter::getErrorMessage(): expected no arguments", 0);
866 RETURN_FALSE;
867 }
868
869 if (message) {
870 RETURN_STR(message);
871 } else {
872 RETURN_NULL();
873 }
874 }
875 /* }}} */
876
877 /* {{{ proto array UConverter::getAvailable() */
878 ZEND_BEGIN_ARG_INFO_EX(php_converter_getavailable_arginfo, 0, ZEND_RETURN_VALUE, 0)
879 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,getAvailable)880 static PHP_METHOD(UConverter, getAvailable) {
881 int32_t i,
882 count = ucnv_countAvailable();
883
884 if (zend_parse_parameters_none() == FAILURE) {
885 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
886 "UConverter::getErrorMessage(): expected no arguments", 0);
887 RETURN_FALSE;
888 }
889 intl_error_reset(NULL);
890
891 array_init(return_value);
892 for(i = 0; i < count; i++) {
893 const char *name = ucnv_getAvailableName(i);
894 add_next_index_string(return_value, name);
895 }
896 }
897 /* }}} */
898
899 /* {{{ proto array UConverter::getAliases(string name) */
900 ZEND_BEGIN_ARG_INFO_EX(php_converter_getaliases_arginfo, 0, ZEND_RETURN_VALUE, 1)
901 ZEND_ARG_INFO(0, name)
902 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,getAliases)903 static PHP_METHOD(UConverter, getAliases) {
904 char *name;
905 size_t name_len;
906 UErrorCode error = U_ZERO_ERROR;
907 uint16_t i, count;
908
909 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name, &name_len) == FAILURE) {
910 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
911 "UConverter::getAliases(): bad arguments", 0);
912 RETURN_FALSE;
913 }
914 intl_error_reset(NULL);
915
916 count = ucnv_countAliases(name, &error);
917 if (U_FAILURE(error)) {
918 THROW_UFAILURE(NULL, "ucnv_countAliases", error);
919 RETURN_FALSE;
920 }
921
922 array_init(return_value);
923 for(i = 0; i < count; i++) {
924 const char *alias;
925
926 error = U_ZERO_ERROR;
927 alias = ucnv_getAlias(name, i, &error);
928 if (U_FAILURE(error)) {
929 THROW_UFAILURE(NULL, "ucnv_getAlias", error);
930 zval_dtor(return_value);
931 RETURN_NULL();
932 }
933 add_next_index_string(return_value, alias);
934 }
935 }
936 /* }}} */
937
938 /* {{{ proto array UConverter::getStandards() */
939 ZEND_BEGIN_ARG_INFO_EX(php_converter_getstandards_arginfo, 0, ZEND_RETURN_VALUE, 0)
940 ZEND_END_ARG_INFO();
PHP_METHOD(UConverter,getStandards)941 static PHP_METHOD(UConverter, getStandards) {
942 uint16_t i, count;
943
944 if (zend_parse_parameters_none() == FAILURE) {
945 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
946 "UConverter::getStandards(): expected no arguments", 0);
947 RETURN_FALSE;
948 }
949 intl_error_reset(NULL);
950
951 array_init(return_value);
952 count = ucnv_countStandards();
953 for(i = 0; i < count; i++) {
954 UErrorCode error = U_ZERO_ERROR;
955 const char *name = ucnv_getStandard(i, &error);
956 if (U_FAILURE(error)) {
957 THROW_UFAILURE(NULL, "ucnv_getStandard", error);
958 zval_dtor(return_value);
959 RETURN_NULL();
960 }
961 add_next_index_string(return_value, name);
962 }
963 }
964 /* }}} */
965
966 static zend_function_entry php_converter_methods[] = {
967 PHP_ME(UConverter, __construct, php_converter_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
968
969 /* Encoding selection */
970 PHP_ME(UConverter, setSourceEncoding, php_converter_set_encoding_arginfo, ZEND_ACC_PUBLIC)
971 PHP_ME(UConverter, setDestinationEncoding, php_converter_set_encoding_arginfo, ZEND_ACC_PUBLIC)
972 PHP_ME(UConverter, getSourceEncoding, php_converter_get_encoding_arginfo, ZEND_ACC_PUBLIC)
973 PHP_ME(UConverter, getDestinationEncoding, php_converter_get_encoding_arginfo, ZEND_ACC_PUBLIC)
974
975 /* Introspection for algorithmic converters */
976 PHP_ME(UConverter, getSourceType, php_converter_get_type_arginfo, ZEND_ACC_PUBLIC)
977 PHP_ME(UConverter, getDestinationType, php_converter_get_type_arginfo, ZEND_ACC_PUBLIC)
978
979 /* Basic codeunit error handling */
980 PHP_ME(UConverter, getSubstChars, php_converter_getSubstChars_arginfo, ZEND_ACC_PUBLIC)
981 PHP_ME(UConverter, setSubstChars, php_converter_setSubstChars_arginfo, ZEND_ACC_PUBLIC)
982
983 /* Default callback handlers */
984 PHP_ME(UConverter, toUCallback, php_converter_toUCallback_arginfo, ZEND_ACC_PUBLIC)
985 PHP_ME(UConverter, fromUCallback, php_converter_fromUCallback_arginfo, ZEND_ACC_PUBLIC)
986
987 /* Core conversion workhorses */
988 PHP_ME(UConverter, convert, php_converter_convert_arginfo, ZEND_ACC_PUBLIC)
989 PHP_ME(UConverter, transcode, php_converter_transcode_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
990
991 /* Error inspection */
992 PHP_ME(UConverter, getErrorCode, php_converter_geterrorcode_arginfo, ZEND_ACC_PUBLIC)
993 PHP_ME(UConverter, getErrorMessage, php_converter_geterrormsg_arginfo, ZEND_ACC_PUBLIC)
994
995 /* Ennumeration and lookup */
996 PHP_ME(UConverter, reasonText, php_converter_reasontext_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
997 PHP_ME(UConverter, getAvailable, php_converter_getavailable_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
998 PHP_ME(UConverter, getAliases, php_converter_getaliases_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
999 PHP_ME(UConverter, getStandards, php_converter_getstandards_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
1000 PHP_FE_END
1001 };
1002
1003 /* {{{ Converter create/clone/destroy */
php_converter_dtor_object(zend_object * obj)1004 static void php_converter_dtor_object(zend_object *obj) {
1005 php_converter_object *objval = php_converter_fetch_object(obj);
1006
1007 if (objval->src) {
1008 ucnv_close(objval->src);
1009 }
1010
1011 if (objval->dest) {
1012 ucnv_close(objval->dest);
1013 }
1014
1015 intl_error_reset(&(objval->error));
1016 }
1017
php_converter_object_ctor(zend_class_entry * ce,php_converter_object ** pobjval)1018 static zend_object *php_converter_object_ctor(zend_class_entry *ce, php_converter_object **pobjval) {
1019 php_converter_object *objval;
1020
1021 objval = ecalloc(1, sizeof(php_converter_object) + zend_object_properties_size(ce));
1022
1023 zend_object_std_init(&objval->obj, ce );
1024 intl_error_init(&(objval->error));
1025
1026 objval->obj.handlers = &php_converter_object_handlers;
1027 *pobjval = objval;
1028
1029 return &objval->obj;
1030 }
1031
php_converter_create_object(zend_class_entry * ce)1032 static zend_object *php_converter_create_object(zend_class_entry *ce) {
1033 php_converter_object *objval = NULL;
1034 zend_object *retval = php_converter_object_ctor(ce, &objval);
1035
1036 object_properties_init(&(objval->obj), ce);
1037
1038 return retval;
1039 }
1040
php_converter_clone_object(zval * object)1041 static zend_object *php_converter_clone_object(zval *object) {
1042 php_converter_object *objval, *oldobj = Z_INTL_CONVERTER_P(object);
1043 zend_object *retval = php_converter_object_ctor(Z_OBJCE_P(object), &objval);
1044 UErrorCode error = U_ZERO_ERROR;
1045
1046 intl_errors_reset(&oldobj->error);
1047
1048 objval->src = ucnv_safeClone(oldobj->src, NULL, NULL, &error);
1049 if (U_SUCCESS(error)) {
1050 error = U_ZERO_ERROR;
1051 objval->dest = ucnv_safeClone(oldobj->dest, NULL, NULL, &error);
1052 }
1053 if (U_FAILURE(error)) {
1054 zend_string *err_msg;
1055 THROW_UFAILURE(oldobj, "ucnv_safeClone", error);
1056
1057 err_msg = intl_error_get_message(&oldobj->error);
1058 zend_throw_exception(NULL, ZSTR_VAL(err_msg), 0);
1059 zend_string_release(err_msg);
1060
1061 return retval;
1062 }
1063
1064 /* Update contexts for converter error handlers */
1065 php_converter_set_callbacks(objval, objval->src );
1066 php_converter_set_callbacks(objval, objval->dest);
1067
1068 zend_objects_clone_members(&(objval->obj), &(oldobj->obj));
1069
1070 /* Newly cloned object deliberately does not inherit error state from original object */
1071
1072 return retval;
1073 }
1074 /* }}} */
1075
1076 #define CONV_REASON_CONST(v) zend_declare_class_constant_long(php_converter_ce, "REASON_" #v, sizeof("REASON_" #v) - 1, UCNV_ ## v)
1077 #define CONV_TYPE_CONST(v) zend_declare_class_constant_long(php_converter_ce, #v , sizeof(#v) - 1, UCNV_ ## v)
1078
1079 /* {{{ php_converter_minit */
php_converter_minit(INIT_FUNC_ARGS)1080 int php_converter_minit(INIT_FUNC_ARGS) {
1081 zend_class_entry ce;
1082
1083 INIT_CLASS_ENTRY(ce, "UConverter", php_converter_methods);
1084 php_converter_ce = zend_register_internal_class(&ce);
1085 php_converter_ce->create_object = php_converter_create_object;
1086 memcpy(&php_converter_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1087 php_converter_object_handlers.offset = XtOffsetOf(php_converter_object, obj);
1088 php_converter_object_handlers.clone_obj = php_converter_clone_object;
1089 php_converter_object_handlers.dtor_obj = php_converter_dtor_object;
1090
1091 /* enum UConverterCallbackReason */
1092 CONV_REASON_CONST(UNASSIGNED);
1093 CONV_REASON_CONST(ILLEGAL);
1094 CONV_REASON_CONST(IRREGULAR);
1095 CONV_REASON_CONST(RESET);
1096 CONV_REASON_CONST(CLOSE);
1097 CONV_REASON_CONST(CLONE);
1098
1099 /* enum UConverterType */
1100 CONV_TYPE_CONST(UNSUPPORTED_CONVERTER);
1101 CONV_TYPE_CONST(SBCS);
1102 CONV_TYPE_CONST(DBCS);
1103 CONV_TYPE_CONST(MBCS);
1104 CONV_TYPE_CONST(LATIN_1);
1105 CONV_TYPE_CONST(UTF8);
1106 CONV_TYPE_CONST(UTF16_BigEndian);
1107 CONV_TYPE_CONST(UTF16_LittleEndian);
1108 CONV_TYPE_CONST(UTF32_BigEndian);
1109 CONV_TYPE_CONST(UTF32_LittleEndian);
1110 CONV_TYPE_CONST(EBCDIC_STATEFUL);
1111 CONV_TYPE_CONST(ISO_2022);
1112 CONV_TYPE_CONST(LMBCS_1);
1113 CONV_TYPE_CONST(LMBCS_2);
1114 CONV_TYPE_CONST(LMBCS_3);
1115 CONV_TYPE_CONST(LMBCS_4);
1116 CONV_TYPE_CONST(LMBCS_5);
1117 CONV_TYPE_CONST(LMBCS_6);
1118 CONV_TYPE_CONST(LMBCS_8);
1119 CONV_TYPE_CONST(LMBCS_11);
1120 CONV_TYPE_CONST(LMBCS_16);
1121 CONV_TYPE_CONST(LMBCS_17);
1122 CONV_TYPE_CONST(LMBCS_18);
1123 CONV_TYPE_CONST(LMBCS_19);
1124 CONV_TYPE_CONST(LMBCS_LAST);
1125 CONV_TYPE_CONST(HZ);
1126 CONV_TYPE_CONST(SCSU);
1127 CONV_TYPE_CONST(ISCII);
1128 CONV_TYPE_CONST(US_ASCII);
1129 CONV_TYPE_CONST(UTF7);
1130 CONV_TYPE_CONST(BOCU1);
1131 CONV_TYPE_CONST(UTF16);
1132 CONV_TYPE_CONST(UTF32);
1133 CONV_TYPE_CONST(CESU8);
1134 CONV_TYPE_CONST(IMAP_MAILBOX);
1135
1136 return SUCCESS;
1137 }
1138 /* }}} */
1139
1140 /*
1141 * Local variables:
1142 * tab-width: 4
1143 * c-basic-offset: 4
1144 * End:
1145 * vim600: noet sw=4 ts=4 fdm=marker
1146 * vim<600: noet sw=4 ts=4
1147 */
1148
