* No need to do anything, the engine increments ->index */
const char *s = Z_STRVAL(bio->text);
- int32_t slen = Z_STRLEN(bio->text);
+ size_t slen = Z_STRLEN(bio->text);
zend_string *res;
if (next == BreakIterator::DONE) {
- next = slen;
+ next = (int32_t)slen;
}
assert(next <= slen && next >= cur);
res = zend_string_alloc(next - cur, 0);
{
zval *object = getThis();
char *rules;
- size_t rules_len;
+ size_t rules_len;
zend_bool compiled = 0;
UErrorCode status = U_ZERO_ERROR;
intl_error_reset(NULL);
BREAKITER_METHOD_FETCH_OBJECT;
char *str;
- int str_len;
+ size_t str_len;
const UnicodeString rules = fetch_rbbi(bio)->getRules();
if (intl_charFromString(rules, &str, &str_len, BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
UErrorCode* status )
{
const char* old_val;
- int old_val_len;
+ size_t old_val_len;
UChar* new_val = NULL;
- int new_val_len = 0;
- zval znew_val;
+ int32_t new_val_len = 0;
+ zval znew_val;
/* Process string values only. */
if( Z_TYPE_P( hashData ) != IS_STRING )
UErrorCode* status )
{
const char* old_val;
- int old_val_len;
- char* new_val = NULL;
- int new_val_len = 0;
- zval znew_val;
+ size_t old_val_len;
+ char* new_val = NULL;
+ size_t new_val_len = 0;
+ zval znew_val;
/* Process string values only. */
if( Z_TYPE_P( hashData ) != IS_STRING )
return;
/* Update current hash item with the converted value. */
- ZVAL_STRINGL( &znew_val, (char*)new_val, new_val_len);
+ ZVAL_STRINGL( &znew_val, new_val, new_val_len);
//???
efree(new_val);
{
zval* utf8_zval = NULL;
char* str = NULL;
- int str_len = 0;
+ size_t str_len = 0;
UErrorCode status = U_ZERO_ERROR;
/* Convert to utf8 then. */
{
zval* zstr = NULL;
UChar* ustr = NULL;
- int ustr_len = 0;
+ int32_t ustr_len = 0;
UErrorCode status = U_ZERO_ERROR;
/* Convert the string to UTF-16. */
zval* zstr = NULL;
UErrorCode status = U_ZERO_ERROR;
UChar* ustr = NULL;
- int ustr_len = 0;
+ int32_t ustr_len = 0;
/* Bail out if it's not an object. */
if( Z_TYPE_P( obj ) != IS_OBJECT )
static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
const char* locale;
- size_t locale_len = 0;
+ size_t locale_len = 0;
zval* object;
Collator_object* co;
/* {{{ collator_is_numeric]
* Taken from PHP6:is_numeric_unicode()
*/
-zend_uchar collator_is_numeric( UChar *str, int length, zend_long *lval, double *dval, int allow_errors )
+zend_uchar collator_is_numeric( UChar *str, int32_t length, zend_long *lval, double *dval, int allow_errors )
{
zend_long local_lval;
double local_dval;
#include <php.h>
#include <unicode/uchar.h>
-zend_uchar collator_is_numeric( UChar *str, int length, zend_long *lval, double *dval, int allow_errors );
+zend_uchar collator_is_numeric( UChar *str, int32_t length, zend_long *lval, double *dval, int allow_errors );
#endif // COLLATOR_IS_NUMERIC_H
PHP_FUNCTION( collator_get_sort_key )
{
char* str = NULL;
- size_t str_len = 0;
+ size_t str_len = 0;
UChar* ustr = NULL;
- int ustr_len = 0;
+ int32_t ustr_len = 0;
uint8_t* key = NULL;
int key_len = 0;
{
char *id = NULL,
offset_id[] = "GMT+00:00";
- int id_len = 0;
+ int32_t id_len = 0;
char *message;
TimeZone *timeZone;
return;
case IS_STRING:
{
- int vallen = Z_STRLEN_P(val);
+ size_t vallen = Z_STRLEN_P(val);
if (TARGET_CHECK(args, vallen)) {
memcpy(args->target, Z_STRVAL_P(val), vallen);
args->target += vallen;
/* {{{ php_converter_set_encoding */
static zend_bool php_converter_set_encoding(php_converter_object *objval,
UConverter **pcnv,
- const char *enc, int enc_len
+ const char *enc, size_t enc_len
) {
UErrorCode error = U_ZERO_ERROR;
UConverter *cnv = ucnv_open(enc, &error);
PHP_FUNCTION( datefmt_set_pattern )
{
char* value = NULL;
- size_t value_len = 0;
- int slength = 0;
+ size_t value_len = 0;
+ int32_t slength = 0;
UChar* svalue = NULL;
zend_bool is_pattern_localized =FALSE;
U_CFUNC PHP_FUNCTION(datefmt_get_timezone_id)
{
char *str;
- int str_len;
+ size_t str_len;
DATE_FORMAT_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
zval *object;
const char *locale_str;
- size_t locale_len = 0;
+ size_t locale_len = 0;
Locale locale;
- zend_long date_type = 0;
- zend_long time_type = 0;
+ zend_long date_type = 0;
+ zend_long time_type = 0;
zval *calendar_zv = NULL;
Calendar *calendar = NULL;
- zend_long calendar_type;
+ zend_long calendar_type;
bool calendar_owned;
zval *timezone_zv = NULL;
TimeZone *timezone = NULL;
bool explicit_tz;
char* pattern_str = NULL;
- size_t pattern_str_len = 0;
+ size_t pattern_str_len = 0;
UChar* svalue = NULL; /* UTF-16 pattern_str */
- int slength = 0;
+ int32_t slength = 0;
IntlDateFormatter_object* dfo;
intl_error_reset(NULL);
#include "intl_error.h"
typedef struct {
- // error hangling
+ // error handling
intl_error error;
// formatter handling
zval *object,
*format = NULL;
const char *locale_str = NULL;
- size_t locale_len;
+ size_t locale_len;
bool pattern = false;
UDate date;
TimeZone *timeZone = NULL;
{
char *ret_str;
- int ret_str_len;
+ size_t ret_str_len;
UnicodeString result = UnicodeString();
df->format(date, result);
* if set to 1 - store any error encountered in the parameter parse_error
* if set to 0 - no need to store any error encountered in the parameter parse_error
*/
-static void internal_parse_to_timestamp(IntlDateFormatter_object *dfo, char* text_to_parse, int32_t text_len, int32_t *parse_pos, zval *return_value)
+static void internal_parse_to_timestamp(IntlDateFormatter_object *dfo, char* text_to_parse, size_t text_len, int32_t *parse_pos, zval *return_value)
{
double result = 0;
UDate timestamp =0;
/* {{{
* Internal function which calls the udat_parseCalendar
*/
-static void internal_parse_to_localtime(IntlDateFormatter_object *dfo, char* text_to_parse, int32_t text_len, int32_t *parse_pos, zval *return_value)
+static void internal_parse_to_localtime(IntlDateFormatter_object *dfo, char* text_to_parse, size_t text_len, int32_t *parse_pos, zval *return_value)
{
UCalendar *parsed_calendar = NULL;
UChar* text_utf16 = NULL;
PHP_FUNCTION( numfmt_get_text_attribute )
{
zend_long attribute;
- UChar value_buf[64];
- int value_buf_size = USIZE( value_buf );
- UChar* value = value_buf;
- int length = 0;
+ UChar value_buf[64];
+ int32_t value_buf_size = USIZE( value_buf );
+ UChar* value = value_buf;
+ int32_t length = 0;
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
*/
PHP_FUNCTION( numfmt_set_text_attribute )
{
- int slength = 0;
+ int32_t slength = 0;
UChar *svalue = NULL;
zend_long attribute;
char *value;
zend_long symbol;
UChar value_buf[4];
UChar *value = value_buf;
- int length = USIZE(value_buf);
+ int32_t length = USIZE(value_buf);
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
*/
PHP_FUNCTION( numfmt_set_symbol )
{
- zend_long symbol;
+ zend_long symbol;
char* value = NULL;
- size_t value_len = 0;
+ size_t value_len = 0;
UChar* svalue = 0;
- int slength = 0;
+ int32_t slength = 0;
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
*/
PHP_FUNCTION( numfmt_get_pattern )
{
- UChar value_buf[64];
- int length = USIZE( value_buf );
- UChar* value = value_buf;
+ UChar value_buf[64];
+ int32_t length = USIZE( value_buf );
+ UChar* value = value_buf;
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
{
char* value = NULL;
size_t value_len = 0;
- int slength = 0;
+ int32_t slength = 0;
UChar* svalue = NULL;
FORMATTER_METHOD_INIT_VARS;
zend_long type = FORMAT_TYPE_DEFAULT;
UChar format_buf[32];
UChar* formatted = format_buf;
- int formatted_len = USIZE(format_buf);
+ int32_t formatted_len = USIZE(format_buf);
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
double number;
UChar format_buf[32];
UChar* formatted = format_buf;
- int formatted_len = USIZE(format_buf);
+ int32_t formatted_len = USIZE(format_buf);
char* currency = NULL;
- size_t currency_len = 0;
+ size_t currency_len = 0;
UChar* scurrency = NULL;
- int scurrency_len = 0;
+ int32_t scurrency_len = 0;
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
{
const char* locale;
char* pattern = NULL;
- size_t locale_len = 0, pattern_len = 0;
- zend_long style;
+ size_t locale_len = 0, pattern_len = 0;
+ zend_long style;
UChar* spattern = NULL;
- int spattern_len = 0;
+ int32_t spattern_len = 0;
FORMATTER_METHOD_INIT_VARS;
/* Parse parameters. */
{
zend_long type = FORMAT_TYPE_DOUBLE;
UChar* sstr = NULL;
- int sstr_len = 0;
+ int32_t sstr_len = 0;
char* str = NULL;
size_t str_len;
int32_t val32, position = 0;
double number;
UChar currency[5] = {0};
UChar* sstr = NULL;
- int sstr_len = 0;
+ int32_t sstr_len = 0;
char *currency_str = NULL;
- int currency_len = 0;
+ size_t currency_len = 0;
char *str;
size_t str_len;
int32_t* position_p = NULL;
Get number of graphemes in a string */
PHP_FUNCTION(grapheme_strlen)
{
- unsigned char* string;
+ char* string;
size_t string_len;
UChar* ustring = NULL;
int ustring_len = 0;
- int ret_len;
+ zend_long ret_len;
UErrorCode status;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", (char **)&string, &string_len) == FAILURE) {
-
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &string, &string_len) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_strlen: unable to parse input param", 0 );
-
RETURN_FALSE;
}
- ret_len = grapheme_ascii_check(string, string_len);
+ ret_len = grapheme_ascii_check((unsigned char *)string, string_len);
if ( ret_len >= 0 )
- RETURN_LONG(ret_len);
+ RETURN_LONG(string_len);
/* convert the string to UTF-16. */
status = U_ZERO_ERROR;
- intl_convert_utf8_to_utf16(&ustring, &ustring_len, (char*) string, string_len, &status );
+ intl_convert_utf8_to_utf16(&ustring, &ustring_len, string, string_len, &status );
if ( U_FAILURE( status ) ) {
/* Set global error code. */
Find position of first occurrence of a string within another */
PHP_FUNCTION(grapheme_strpos)
{
- unsigned char *haystack, *needle;
+ char *haystack, *needle;
size_t haystack_len, needle_len;
- unsigned char *found;
+ const char *found;
zend_long loffset = 0;
int32_t offset = 0;
- int ret_pos;
-
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
+ zend_long ret_pos;
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_strpos: unable to parse input param", 0 );
-
RETURN_FALSE;
}
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Offset not contained in string", 1 );
-
RETURN_FALSE;
}
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
if (needle_len == 0) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 );
-
RETURN_FALSE;
}
/* quick check to see if the string might be there
* I realize that 'offset' is 'grapheme count offset' but will work in spite of that
*/
- found = (unsigned char *)php_memnstr((char *)haystack + offset, (char *)needle, needle_len, (char *)haystack + haystack_len);
+ found = php_memnstr(haystack + offset, needle, needle_len, haystack + haystack_len);
/* if it isn't there the we are done */
if (!found) {
}
/* if it is there, and if the haystack is ascii, we are all done */
- if ( grapheme_ascii_check(haystack, haystack_len) >= 0 ) {
-
+ if ( grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0 ) {
RETURN_LONG(found - haystack);
}
Find position of first occurrence of a string within another, ignoring case differences */
PHP_FUNCTION(grapheme_stripos)
{
- unsigned char *haystack, *needle, *haystack_dup, *needle_dup;
+ char *haystack, *needle, *haystack_dup, *needle_dup;
size_t haystack_len, needle_len;
- unsigned char *found;
+ const char *found;
zend_long loffset = 0;
int32_t offset = 0;
- int ret_pos;
+ zend_long ret_pos;
int is_ascii;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
-
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_stripos: unable to parse input param", 0 );
-
RETURN_FALSE;
}
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_stripos: Offset not contained in string", 1 );
-
RETURN_FALSE;
}
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
if (needle_len == 0) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_stripos: Empty delimiter", 1 );
-
RETURN_FALSE;
}
- is_ascii = ( grapheme_ascii_check(haystack, haystack_len) >= 0 );
+ is_ascii = ( grapheme_ascii_check((unsigned char*)haystack, haystack_len) >= 0 );
if ( is_ascii ) {
- needle_dup = (unsigned char *)estrndup((char *)needle, needle_len);
- php_strtolower((char *)needle_dup, needle_len);
- haystack_dup = (unsigned char *)estrndup((char *)haystack, haystack_len);
- php_strtolower((char *)haystack_dup, haystack_len);
+ needle_dup = estrndup(needle, needle_len);
+ php_strtolower(needle_dup, needle_len);
+ haystack_dup = estrndup(haystack, haystack_len);
+ php_strtolower(haystack_dup, haystack_len);
- found = (unsigned char*) php_memnstr((char *)haystack_dup + offset, (char *)needle_dup, needle_len, (char *)haystack_dup + haystack_len);
+ found = php_memnstr(haystack_dup + offset, needle_dup, needle_len, haystack_dup + haystack_len);
efree(haystack_dup);
efree(needle_dup);
}
/* if needle was ascii too, we are all done, otherwise we need to try using Unicode to see what we get */
- if ( grapheme_ascii_check(needle, needle_len) >= 0 ) {
+ if ( grapheme_ascii_check((unsigned char *)needle, needle_len) >= 0 ) {
RETURN_FALSE;
}
}
Find position of last occurrence of a string within another */
PHP_FUNCTION(grapheme_strrpos)
{
- unsigned char *haystack, *needle;
+ char *haystack, *needle;
size_t haystack_len, needle_len;
zend_long loffset = 0;
int32_t offset = 0;
- int32_t ret_pos;
+ zend_long ret_pos;
int is_ascii;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
-
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_strrpos: unable to parse input param", 0 );
-
RETURN_FALSE;
}
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Offset not contained in string", 1 );
-
RETURN_FALSE;
}
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
if (needle_len == 0) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 );
-
RETURN_FALSE;
}
- is_ascii = grapheme_ascii_check(haystack, haystack_len) >= 0;
+ is_ascii = grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0;
if ( is_ascii ) {
ret_pos = grapheme_strrpos_ascii(haystack, haystack_len, needle, needle_len, offset);
-
if ( ret_pos >= 0 ) {
RETURN_LONG(ret_pos);
}
/* if the needle was ascii too, we are done */
- if ( grapheme_ascii_check(needle, needle_len) >= 0 ) {
+ if ( grapheme_ascii_check((unsigned char *)needle, needle_len) >= 0 ) {
RETURN_FALSE;
}
Find position of last occurrence of a string within another, ignoring case */
PHP_FUNCTION(grapheme_strripos)
{
- unsigned char *haystack, *needle;
+ char *haystack, *needle;
size_t haystack_len, needle_len;
zend_long loffset = 0;
int32_t offset = 0;
- int32_t ret_pos;
+ zend_long ret_pos;
int is_ascii;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
-
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_strrpos: unable to parse input param", 0 );
-
RETURN_FALSE;
}
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Offset not contained in string", 1 );
-
RETURN_FALSE;
}
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
if (needle_len == 0) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 );
-
RETURN_FALSE;
}
- is_ascii = grapheme_ascii_check(haystack, haystack_len) >= 0;
+ is_ascii = grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0;
if ( is_ascii ) {
- unsigned char *needle_dup, *haystack_dup;
+ char *needle_dup, *haystack_dup;
- needle_dup = (unsigned char *)estrndup((char *)needle, needle_len);
- php_strtolower((char *)needle_dup, needle_len);
- haystack_dup = (unsigned char *)estrndup((char *)haystack, haystack_len);
- php_strtolower((char *)haystack_dup, haystack_len);
+ needle_dup = estrndup(needle, needle_len);
+ php_strtolower(needle_dup, needle_len);
+ haystack_dup = estrndup(haystack, haystack_len);
+ php_strtolower(haystack_dup, haystack_len);
ret_pos = grapheme_strrpos_ascii(haystack_dup, haystack_len, needle_dup, needle_len, offset);
/* if the needle was ascii too, we are done */
- if ( grapheme_ascii_check(needle, needle_len) >= 0 ) {
+ if ( grapheme_ascii_check((unsigned char *)needle, needle_len) >= 0 ) {
RETURN_FALSE;
}
Returns part of a string */
PHP_FUNCTION(grapheme_substr)
{
- unsigned char *str, *sub_str;
+ char *str, *sub_str;
UChar *ustr;
size_t str_len;
int32_t ustr_len;
- int32_t sub_str_len;
+ size_t sub_str_len;
zend_long lstart = 0, length = 0;
int32_t start = 0;
int iter_val;
UBreakIterator* bi = NULL;
int sub_str_start_pos, sub_str_end_pos;
int32_t (*iter_func)(UBreakIterator *);
+ int no_length = 1;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l", (char **)&str, &str_len, &lstart, &length) == FAILURE) {
-
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!", (char **)&str, &str_len, &lstart, &length, &no_length) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_substr: unable to parse input param", 0 );
-
RETURN_FALSE;
}
- if ( OUTSIDE_STRING(lstart, str_len) ) {
-
+ if ( OUTSIDE_STRING(lstart, str_len)) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: start not contained in string", 1 );
-
RETURN_FALSE;
}
/* we checked that it will fit: */
start = (int32_t) lstart;
+ if(no_length) {
+ length = str_len;
+ }
+
+ if(length < INT32_MIN) {
+ length = INT32_MIN;
+ } else if(length > INT32_MAX) {
+ length = INT32_MAX;
+ }
+
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
- if ( grapheme_ascii_check(str, str_len) >= 0 ) {
- grapheme_substr_ascii((char *)str, str_len, start, length, ZEND_NUM_ARGS(), (char **) &sub_str, &sub_str_len);
+ if ( grapheme_ascii_check((unsigned char *)str, str_len) >= 0 ) {
+ int32_t asub_str_len;
+ grapheme_substr_ascii(str, str_len, start, (int32_t)length, &sub_str, &asub_str_len);
if ( NULL == sub_str ) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: invalid parameters", 1 );
RETURN_FALSE;
}
- RETURN_STRINGL(((char *)sub_str), sub_str_len);
+ RETURN_STRINGL(sub_str, asub_str_len);
}
ustr = NULL;
ustr_len = 0;
status = U_ZERO_ERROR;
- intl_convert_utf8_to_utf16(&ustr, &ustr_len, (char *)str, str_len, &status);
+ intl_convert_utf8_to_utf16(&ustr, &ustr_len, str, str_len, &status);
if ( U_FAILURE( status ) ) {
/* Set global error code. */
RETURN_FALSE;
}
- if (ZEND_NUM_ARGS() <= 2) {
+ /* OK to convert here since if str_len were big, convert above would fail */
+ if (length >= (int32_t)str_len) {
- /* no length supplied, return the rest of the string */
+ /* no length supplied or length is too big, return the rest of the string */
sub_str = NULL;
sub_str_len = 0;
status = U_ZERO_ERROR;
- intl_convert_utf16_to_utf8((char **)&sub_str, &sub_str_len, ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
+ intl_convert_utf16_to_utf8(&sub_str, &sub_str_len, ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
if (ustr) {
efree( ustr );
}
/* return the allocated string, not a duplicate */
- RETVAL_STRINGL(((char *)sub_str), sub_str_len);
+ RETVAL_STRINGL(sub_str, sub_str_len);
//???
efree(sub_str);
return;
sub_str = NULL;
status = U_ZERO_ERROR;
- intl_convert_utf16_to_utf8((char **)&sub_str, &sub_str_len, ustr + sub_str_start_pos, ( sub_str_end_pos - sub_str_start_pos ), &status);
+ intl_convert_utf16_to_utf8(&sub_str, &sub_str_len, ustr + sub_str_start_pos, ( sub_str_end_pos - sub_str_start_pos ), &status);
efree( ustr );
}
/* return the allocated string, not a duplicate */
- RETVAL_STRINGL(((char *)sub_str), sub_str_len);
+ RETVAL_STRINGL(sub_str, sub_str_len);
//????
efree(sub_str);
/* {{{ strstr_common_handler */
static void strstr_common_handler(INTERNAL_FUNCTION_PARAMETERS, int f_ignore_case)
{
- unsigned char *haystack, *needle, *found;
+ char *haystack, *needle;
+ const char *found;
size_t haystack_len, needle_len;
- int ret_pos, uchar_pos;
+ int32_t ret_pos, uchar_pos;
zend_bool part = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|b", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &part) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|b", &haystack, &haystack_len, &needle, &needle_len, &part) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_strstr: unable to parse input param", 0 );
/* ASCII optimization: quick check to see if the string might be there
* I realize that 'offset' is 'grapheme count offset' but will work in spite of that
*/
- found = (unsigned char *)php_memnstr((char *)haystack, (char *)needle, needle_len, (char *)haystack + haystack_len);
+ found = php_memnstr(haystack, needle, needle_len, haystack + haystack_len);
/* if it isn't there the we are done */
if ( !found ) {
}
/* if it is there, and if the haystack is ascii, we are all done */
- if ( grapheme_ascii_check(haystack, haystack_len) >= 0 ) {
+ if ( grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0 ) {
size_t found_offset = found - haystack;
if (part) {
- RETURN_STRINGL(((char *)haystack) , found_offset);
+ RETURN_STRINGL(haystack, found_offset);
} else {
- RETURN_STRINGL(((char *)found), haystack_len - found_offset);
+ RETURN_STRINGL(found, haystack_len - found_offset);
}
}
U8_FWD_N(haystack, ret_pos, haystack_len, uchar_pos);
if (part) {
- RETURN_STRINGL(((char *)haystack), ret_pos);
- }
- else {
- RETURN_STRINGL(((char *)haystack) + ret_pos, haystack_len - ret_pos);
+ RETURN_STRINGL(haystack, ret_pos);
+ } else {
+ RETURN_STRINGL(haystack + ret_pos, haystack_len - ret_pos);
}
}
Function to extract a sequence of default grapheme clusters */
PHP_FUNCTION(grapheme_extract)
{
- unsigned char *str, *pstr;
+ char *str, *pstr;
UChar *ustr;
size_t str_len;
int32_t ustr_len;
int ret_pos;
zval *next = NULL; /* return offset of next part of the string */
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|llz", (char **)&str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) {
-
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|llz", &str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_extract: unable to parse input param", 0 );
-
RETURN_FALSE;
}
if ( !Z_ISREF_P(next) ) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_extract: 'next' was not passed by reference", 0 );
-
RETURN_FALSE;
- }
- else {
+ } else {
ZVAL_DEREF(next);
/* initialize next */
SEPARATE_ZVAL(next);
}
if ( extract_type < GRAPHEME_EXTRACT_TYPE_MIN || extract_type > GRAPHEME_EXTRACT_TYPE_MAX ) {
-
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_extract: unknown extract type param", 0 );
-
RETURN_FALSE;
}
/* just in case pstr points in the middle of a character, move forward to the start of the next char */
if ( !UTF8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
- unsigned char *str_end = str + str_len;
+ char *str_end = str + str_len;
while ( !UTF8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
pstr++;
(size + 1 because the size-th character might be the beginning of a grapheme cluster)
*/
- if ( -1 != grapheme_ascii_check(pstr, size + 1 < str_len ? size + 1 : str_len ) ) {
- zend_long nsize = ( size < str_len ? size : str_len );
+ if ( -1 != grapheme_ascii_check((unsigned char *)pstr, MIN(size + 1, str_len)) ) {
+ size_t nsize = MIN(size, str_len);
if ( NULL != next ) {
ZVAL_LONG(next, start+nsize);
}
- RETURN_STRINGL(((char *)pstr), nsize);
+ RETURN_STRINGL(pstr, nsize);
}
/* convert the strings to UTF-16. */
ustr = NULL;
ustr_len = 0;
status = U_ZERO_ERROR;
- intl_convert_utf8_to_utf16(&ustr, &ustr_len, (char *)pstr, str_len, &status );
+ intl_convert_utf8_to_utf16(&ustr, &ustr_len, pstr, str_len, &status );
if ( U_FAILURE( status ) ) {
/* Set global error code. */
can't back up. So, we will not do anything. */
/* now we need to find the end of the chunk the user wants us to return */
-
- ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, pstr, str_len);
+ /* it's ok to convert str_len to in32_t since if it were too big intl_convert_utf8_to_utf16 above would fail */
+ ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, (unsigned char *)pstr, (int32_t)str_len);
if (ustr) {
efree(ustr);
/* }}} */
/* {{{ grapheme_substr_ascii f='from' - starting point, l='length' */
-void grapheme_substr_ascii(char *str, int str_len, int f, int l, int argc, char **sub_str, int *sub_str_len)
+void grapheme_substr_ascii(char *str, size_t str_len, int32_t f, int32_t l, char **sub_str, int32_t *sub_str_len)
{
+ int32_t str_len2 = (int32_t)str_len; /* in order to avoid signed/unsigned problems */
*sub_str = NULL;
- if (argc > 2) {
- if ((l < 0 && -l > str_len)) {
- return;
- } else if (l > str_len) {
- l = str_len;
- }
- } else {
- l = str_len;
+ if(str_len > INT32_MAX) {
+ /* We can not return long strings from ICU functions, so we won't here too */
+ return;
}
- if (f > str_len || (f < 0 && -f > str_len)) {
+ if ((l < 0 && -l > str_len2)) {
return;
+ } else if (l > 0 && l > str_len2) {
+ l = str_len2;
}
- if (l < 0 && (l + str_len - f) < 0) {
+ if (f > str_len2 || (f < 0 && -f > str_len2)) {
+ return;
+ }
+
+ if (l < 0 && str_len2 < f - l) {
return;
}
* of the string
*/
if (f < 0) {
- f = str_len + f;
+ f = str_len2 + f;
if (f < 0) {
f = 0;
}
* needed to stop that many chars from the end of the string
*/
if (l < 0) {
- l = (str_len - f) + l;
+ l = (str_len2 - f) + l;
if (l < 0) {
l = 0;
}
}
- if (f >= str_len) {
+ if (f >= str_len2) {
return;
}
- if ((f + l) > str_len) {
+ if ((f + l) > str_len2) {
l = str_len - f;
}
/* {{{ grapheme_strpos_utf16 - strrpos using utf16*/
-int grapheme_strpos_utf16(unsigned char *haystack, int32_t haystack_len, unsigned char*needle, int32_t needle_len, int32_t offset, int32_t *puchar_pos, int f_ignore_case, int last)
+int32_t grapheme_strpos_utf16(char *haystack, size_t haystack_len, char *needle, size_t needle_len, int32_t offset, int32_t *puchar_pos, int f_ignore_case, int last)
{
UChar *uhaystack = NULL, *uneedle = NULL;
int32_t uhaystack_len = 0, uneedle_len = 0, char_pos, ret_pos, offset_pos = 0;
/* convert the strings to UTF-16. */
status = U_ZERO_ERROR;
- intl_convert_utf8_to_utf16(&uhaystack, &uhaystack_len, (char *) haystack, haystack_len, &status );
+ intl_convert_utf8_to_utf16(&uhaystack, &uhaystack_len, haystack, haystack_len, &status );
STRPOS_CHECK_STATUS(status, "Error converting input string to UTF-16");
status = U_ZERO_ERROR;
- intl_convert_utf8_to_utf16(&uneedle, &uneedle_len, (char *) needle, needle_len, &status );
- STRPOS_CHECK_STATUS(status, "Error converting input string to UTF-16");
+ intl_convert_utf8_to_utf16(&uneedle, &uneedle_len, needle, needle_len, &status );
+ STRPOS_CHECK_STATUS(status, "Error converting needle string to UTF-16");
/* get a pointer to the haystack taking into account the offset */
status = U_ZERO_ERROR;
/* }}} */
/* {{{ grapheme_ascii_check: ASCII check */
-int grapheme_ascii_check(const unsigned char *day, int32_t len)
+zend_long grapheme_ascii_check(const unsigned char *day, size_t len)
{
int ret_len = len;
while ( len-- ) {
/* }}} */
/* {{{ grapheme_split_string: find and optionally return grapheme boundaries */
-int grapheme_split_string(const UChar *text, int32_t text_length, int boundary_array[], int boundary_array_len )
+int32_t grapheme_split_string(const UChar *text, int32_t text_length, int boundary_array[], int boundary_array_len )
{
unsigned char u_break_iterator_buffer[U_BRK_SAFECLONE_BUFFERSIZE];
UErrorCode status = U_ZERO_ERROR;
/* {{{ grapheme_get_haystack_offset - bump the haystack pointer based on the grapheme count offset */
-int grapheme_get_haystack_offset(UBreakIterator* bi, int32_t offset)
+int32_t grapheme_get_haystack_offset(UBreakIterator* bi, int32_t offset)
{
int32_t pos;
int32_t (*iter_op)(UBreakIterator* bi);
/* }}} */
/* {{{ grapheme_strrpos_ascii: borrowed from the php ext/standard/string.c */
- int32_t
-grapheme_strrpos_ascii(unsigned char *haystack, int32_t haystack_len, unsigned char *needle, int32_t needle_len, int32_t offset)
+ zend_long
+grapheme_strrpos_ascii(char *haystack, size_t haystack_len, char *needle, size_t needle_len, int32_t offset)
{
- unsigned char *p, *e;
+ char *p, *e;
if (offset >= 0) {
p = haystack + offset;
/* get_break_interator: get a break iterator from the global structure */
UBreakIterator* grapheme_get_break_iterator(void *stack_buffer, UErrorCode *status );
-void grapheme_substr_ascii(char *str, int32_t str_len, int32_t f, int32_t l, int argc, char **sub_str, int *sub_str_len);
+zend_long grapheme_ascii_check(const unsigned char *day, size_t len);
+void grapheme_substr_ascii(char *str, size_t str_len, int32_t f, int32_t l, char **sub_str, int32_t *sub_str_len);
+zend_long grapheme_strrpos_ascii(char *haystack, size_t haystack_len, char *needle, size_t needle_len, int32_t offset);
-int grapheme_strrpos_utf16(unsigned char *haystack, int32_t haystack_len, unsigned char*needle, int32_t needle_len, int32_t offset, int f_ignore_case);
+int32_t grapheme_strrpos_utf16(char *haystack, size_t haystack_len, char *needle, size_t needle_len, int32_t offset, int f_ignore_case);
+int32_t grapheme_strpos_utf16(char *haystack, size_t haystack_len, char *needle, size_t needle_len, int32_t offset, int *puchar_pos, int f_ignore_case, int last);
-int grapheme_strpos_utf16(unsigned char *haystack, int32_t haystack_len, unsigned char*needle, int32_t needle_len, int32_t offset, int *puchar_pos, int f_ignore_case, int last);
-
-int grapheme_ascii_check(const unsigned char *day, int32_t len);
-
-int grapheme_split_string(const UChar *text, int32_t text_length, int boundary_array[], int boundary_array_len );
+int32_t grapheme_split_string(const UChar *text, int32_t text_length, int boundary_array[], int boundary_array_len );
int32_t grapheme_count_graphemes(UBreakIterator *bi, UChar *string, int32_t string_len);
inline void *grapheme_memrchr_grapheme(const void *s, int c, int32_t n);
-int grapheme_get_haystack_offset(UBreakIterator* bi, int32_t offset);
-
-int32_t grapheme_strrpos_ascii(unsigned char *haystack, int32_t haystack_len, unsigned char *needle, int32_t needle_len, int32_t offset);
+int32_t grapheme_get_haystack_offset(UBreakIterator* bi, int32_t offset);
UBreakIterator* grapheme_get_break_iterator(void *stack_buffer, UErrorCode *status );
#ifdef HAVE_46_API
static void php_intl_idn_to_46(INTERNAL_FUNCTION_PARAMETERS,
- const char *domain, int domain_len, uint32_t option, int mode, zval *idna_info)
+ const char *domain, int32_t domain_len, uint32_t option, int mode, zval *idna_info)
{
UErrorCode status = U_ZERO_ERROR;
UIDNA *uts46;
}
if (mode == INTL_IDN_TO_ASCII) {
- len = uidna_nameToASCII_UTF8(uts46, domain, (int32_t)domain_len,
+ len = uidna_nameToASCII_UTF8(uts46, domain, domain_len,
buffer->val, buffer_capac, &info, &status);
} else {
- len = uidna_nameToUnicodeUTF8(uts46, domain, (int32_t)domain_len,
+ len = uidna_nameToUnicodeUTF8(uts46, domain, domain_len,
buffer->val, buffer_capac, &info, &status);
}
if (php_intl_idn_check_status(status, "failed to convert name",
#endif
static void php_intl_idn_to(INTERNAL_FUNCTION_PARAMETERS,
- const char *domain, int domain_len, uint32_t option, int mode)
+ const char *domain, int32_t domain_len, uint32_t option, int mode)
{
UChar* ustring = NULL;
int ustring_len = 0;
UErrorCode status;
char *converted_utf8;
- int32_t converted_utf8_len;
+ size_t converted_utf8_len;
UChar converted[MAXPATHLEN];
int32_t converted_ret_len;
}
/* return the allocated string, not a duplicate */
- RETVAL_STRINGL(((char *)converted_utf8), converted_utf8_len);
+ RETVAL_STRINGL(converted_utf8, converted_utf8_len);
//????
efree(converted_utf8);
}
if (variant == INTL_IDN_VARIANT_2003) {
php_intl_idn_to(INTERNAL_FUNCTION_PARAM_PASSTHRU,
- domain, domain_len, (uint32_t)option, mode);
+ domain, (int32_t)domain_len, (uint32_t)option, mode);
}
#ifdef HAVE_46_API
else {
- php_intl_idn_to_46(INTERNAL_FUNCTION_PARAM_PASSTHRU, domain, domain_len,
+ php_intl_idn_to_46(INTERNAL_FUNCTION_PARAM_PASSTHRU, domain, (int32_t)domain_len,
(uint32_t)option, mode, idna_info);
}
#endif
* In this case the buffer will be used to store the converted string to,
* and may be resized (made larger) if needed.
*
+ * Note that ICU uses int32_t as string length and PHP uses size_t. While
+ * it is not likely in practical situations to have strings longer than
+ * INT32_MAX, these are different types and need to be handled carefully.
+ *
* @param target Where to place the result.
* @param target_len Result length.
* @param source String to convert.
* @return void This function does not return anything.
*/
void intl_convert_utf8_to_utf16(
- UChar** target, int* target_len,
- const char* src, int src_len,
+ UChar** target, int32_t* target_len,
+ const char* src, size_t src_len,
UErrorCode* status )
{
UChar* dst_buf = NULL;
*/
*status = U_ZERO_ERROR;
- u_strFromUTF8( *target, *target_len, &dst_len, src, src_len, status );
+ if(src_len > INT32_MAX) {
+ /* we can not fit this string */
+ *status = U_BUFFER_OVERFLOW_ERROR;
+ return;
+ }
+
+ u_strFromUTF8( *target, *target_len, &dst_len, src, (int32_t)src_len, status );
if( *status == U_ZERO_ERROR )
{
* @return void This function does not return anything.
*/
void intl_convert_utf16_to_utf8(
- char** target, int* target_len,
- const UChar* src, int src_len,
+ char** target, size_t* target_len,
+ const UChar* src, int32_t src_len,
UErrorCode* status )
{
char* dst_buf = NULL;
dst_buf[dst_len] = 0;
*target = dst_buf;
- *target_len = dst_len;
+ *target_len = (size_t)dst_len;
}
/* }}} */
#include <unicode/ustring.h>
void intl_convert_utf8_to_utf16(
- UChar** target, int* target_len,
- const char* src, int src_len,
+ UChar** target, int32_t* target_len,
+ const char* src, size_t src_len,
UErrorCode* status );
void intl_convert_utf16_to_utf8(
- char** target, int* target_len,
- const UChar* src, int src_len,
+ char** target, size_t* target_len,
+ const UChar* src, int32_t src_len,
UErrorCode* status );
#endif // INTL_CONVERT_H
}
/* {{{ intl_stringFromChar */
-int intl_stringFromChar(UnicodeString &ret, char *str, int32_t str_len, UErrorCode *status)
+int intl_stringFromChar(UnicodeString &ret, char *str, size_t str_len, UErrorCode *status)
{
+ if(str_len > INT32_MAX) {
+ *status = U_BUFFER_OVERFLOW_ERROR;
+ ret.setToBogus();
+ return FAILURE;
+ }
//the number of UTF-16 code units is not larger than that of UTF-8 code
//units, + 1 for the terminator
- int32_t capacity = str_len + 1;
+ int32_t capacity = (int32_t)str_len + 1;
//no check necessary -- if NULL will fail ahead
UChar *utf16 = ret.getBuffer(capacity);
* faster than doing intl_convert_utf16_to_utf8(&res, &res_len,
* from.getBuffer(), from.length(), &status),
* but consumes more memory */
-int intl_charFromString(const UnicodeString &from, char **res, int *res_len, UErrorCode *status)
+int intl_charFromString(const UnicodeString &from, char **res, size_t *res_len, UErrorCode *status)
{
if (from.isBogus()) {
return FAILURE;
return FAILURE;
}
(*res)[actual_len] = '\0';
- *res_len = (int)actual_len;
+ *res_len = actual_len;
return SUCCESS;
}
#include <unicode/unistr.h>
-int intl_stringFromChar(UnicodeString &ret, char *str, int32_t str_len, UErrorCode *status);
+int intl_stringFromChar(UnicodeString &ret, char *str, size_t str_len, UErrorCode *status);
-int intl_charFromString(const UnicodeString &from, char **res, int *res_len, UErrorCode *status);
+int intl_charFromString(const UnicodeString &from, char **res, size_t *res_len, UErrorCode *status);
#endif /* INTL_CONVERTCPP_H */
#define INTL_METHOD_RETVAL_UTF8(obj, ustring, ulen, free_it) \
{ \
char *u8value; \
- int u8len; \
+ size_t u8len; \
intl_convert_utf16_to_utf8(&u8value, &u8len, ustring, ulen, &INTL_DATA_ERROR_CODE((obj))); \
if((free_it)) { \
efree(ustring); \
#define INTL_CHECK_LOCALE_LEN(locale_len) \
if((locale_len) > INTL_MAX_LOCALE_LEN) { \
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, \
- "Locale string too long, should be no longer than 80 characters", 0 ); \
+ "Locale string too long, should be no longer than 80 characters", 0 ); \
RETURN_NULL(); \
}
#define INTL_CHECK_LOCALE_LEN_OBJ(locale_len, object) \
if((locale_len) > INTL_MAX_LOCALE_LEN) { \
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, \
- "Locale string too long, should be no longer than 80 characters", 0 ); \
+ "Locale string too long, should be no longer than 80 characters", 0 ); \
zval_dtor(object); \
ZVAL_NULL(object); \
RETURN_NULL(); \
{
smart_str ret = {0};
char *buf;
- int u8len;
+ size_t u8len;
UErrorCode status;
int any = 0;
size_t loc_name_len = 0;
const char* disp_loc_name = NULL;
- size_t disp_loc_name_len = 0;
+ size_t disp_loc_name_len = 0;
int free_loc_name = 0;
UChar* disp_name = NULL;
UErrorCode status = U_ZERO_ERROR;
char* utf8value = NULL;
- int utf8value_len = 0;
+ size_t utf8value_len = 0;
char* msg = NULL;
int grOffset = 0;
{
const char* locale;
char* pattern;
- size_t locale_len = 0, pattern_len = 0;
+ size_t locale_len = 0, pattern_len = 0;
UChar* spattern = NULL;
int spattern_len = 0;
zval* object;
PHP_FUNCTION( msgfmt_set_pattern )
{
char* value = NULL;
- size_t value_len = 0;
- int spattern_len = 0;
+ size_t value_len = 0;
+ int32_t spattern_len = 0;
UChar* spattern = NULL;
MSG_FORMAT_METHOD_INIT_VARS;
{
int count;
UChar* formatted = NULL;
- int formatted_len = 0;
+ int32_t formatted_len = 0;
HashTable *args_copy;
count = zend_hash_num_elements(Z_ARRVAL_P(args));
UChar *spattern = NULL;
int spattern_len = 0;
char *pattern = NULL;
- size_t pattern_len = 0;
+ size_t pattern_len = 0;
const char *slocale = NULL;
- size_t slocale_len = 0;
+ size_t slocale_len = 0;
MessageFormatter_object mf = {0};
MessageFormatter_object *mfo = &mf;
U_CFUNC void umsg_format_helper(MessageFormatter_object *mfo,
HashTable *args,
UChar **formatted,
- int *formatted_len)
+ int32_t *formatted_len)
{
int arg_count = zend_hash_num_elements(args);
std::vector<Formattable> fargs;
// Key related variables
zend_string *str_index;
- zend_ulong num_index;
+ zend_ulong num_index;
ZEND_HASH_FOREACH_KEY_VAL(args, num_index, str_index, elem) {
Formattable& formattable = fargs[argNum];
double dd = intl_zval_to_millis(elem, &err, "msgfmt_format");
if (U_FAILURE(err.code)) {
char *message, *key_char;
- int key_len;
+ size_t key_len;
UErrorCode status = UErrorCode();
- if (intl_charFromString(key, &key_char, &key_len,
- &status) == SUCCESS) {
+ if (intl_charFromString(key, &key_char, &key_len, &status) == SUCCESS) {
spprintf(&message, 0, "The argument for key '%s' "
"cannot be used as a date or time", key_char);
intl_errors_set(&err, err.code, message, 1);
default:
{
char *message, *key_char;
- int key_len;
+ size_t key_len;
UErrorCode status = UErrorCode();
if (intl_charFromString(key, &key_char, &key_len,
&status) == SUCCESS) {
#define cleanup_zvals() for(int j=i;j>=0;j--) { zval_ptr_dtor((*args)+i); }
-U_CFUNC void umsg_parse_helper(UMessageFormat *fmt, int *count, zval **args, UChar *source, int source_len, UErrorCode *status)
+U_CFUNC void umsg_parse_helper(UMessageFormat *fmt, int *count, zval **args, UChar *source, int32_t source_len, UErrorCode *status)
{
UnicodeString srcString(source, source_len);
Formattable *fargs = ((const MessageFormat*)fmt)->parse(srcString, *count, *status);
double aDate;
UnicodeString temp;
char *stmp;
- int stmp_len;
+ size_t stmp_len;
switch(fargs[i].getType()) {
case Formattable::kDate:
UChar *spattern = NULL;
int spattern_len = 0;
char *pattern = NULL;
- size_t pattern_len = 0;
+ size_t pattern_len = 0;
const char *slocale = NULL;
- size_t slocale_len = 0;
+ size_t slocale_len = 0;
char *source = NULL;
- size_t src_len = 0;
+ size_t src_len = 0;
MessageFormatter_object mf = {0};
MessageFormatter_object *mfo = &mf;
{
char* input = NULL;
/* form is optional, defaults to FORM_C */
- zend_long form = NORMALIZER_DEFAULT;
+ zend_long form = NORMALIZER_DEFAULT;
size_t input_len = 0;
UChar* uinput = NULL;
- int uinput_len = 0;
- int expansion_factor = 1;
+ int32_t uinput_len = 0;
+ int expansion_factor = 1;
UErrorCode status = U_ZERO_ERROR;
UChar* uret_buf = NULL;
- int uret_len = 0;
+ int32_t uret_len = 0;
char* ret_buf = NULL;
- int32_t ret_len = 0;
+ size_t ret_len = 0;
int32_t size_needed;
const int32_t* vfield;
int32_t ilen;
int i;
- zend_long lfield;
+ zend_long lfield;
ResourceBundle_object* newrb;
restype = ures_getType( source->child );
/* {{{ ResourceBundle_ctor */
static void resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
- const char *bundlename;
- size_t bundlename_len = 0;
- const char *locale;
- size_t locale_len = 0;
+ const char *bundlename;
+ size_t bundlename_len = 0;
+ const char *locale;
+ size_t locale_len = 0;
zend_bool fallback = 1;
zval *object = return_value;
if(Z_TYPE_P(offset) == IS_LONG) {
is_numeric = 1;
- meindex = Z_LVAL_P(offset);
+ meindex = (int32_t)Z_LVAL_P(offset);
rb->child = ures_getByIndex( rb->me, meindex, rb->child, &INTL_DATA_ERROR_CODE(rb) );
} else if(Z_TYPE_P(offset) == IS_STRING) {
mekey = Z_STRVAL_P(offset);
zend_object_iterator intern;
ResourceBundle_object *subject;
zend_bool is_table;
- zend_long length;
+ zend_long length;
zval current;
char *currentkey;
- zend_long i;
+ zend_long i;
} ResourceBundle_iterator;
zend_object_iterator *resourcebundle_get_iterator( zend_class_entry *ce, zval *object, int byref );
}
SPOOFCHECKER_METHOD_FETCH_OBJECT;
-
- ret = uspoof_areConfusableUTF8(co->uspoof, s1, s1_len, s2, s2_len, SPOOFCHECKER_ERROR_CODE_P(co));
-
+ if(s1_len > INT32_MAX || s2_len > INT32_MAX) {
+ SPOOFCHECKER_ERROR_CODE(co) = U_BUFFER_OVERFLOW_ERROR;
+ } else {
+ ret = uspoof_areConfusableUTF8(co->uspoof, s1, (int32_t)s1_len, s2, (int32_t)s2_len, SPOOFCHECKER_ERROR_CODE_P(co));
+ }
if (U_FAILURE(SPOOFCHECKER_ERROR_CODE(co))) {
php_error_docref(NULL, E_WARNING, "(%d) %s", SPOOFCHECKER_ERROR_CODE(co), u_errorName(SPOOFCHECKER_ERROR_CODE(co)));
RETURN_TRUE;
tzobj->tzi.utc_offset = -1 * timeZone->getRawOffset() / (60 * 1000);
} else {
char *str;
- int str_len;
+ size_t str_len;
/* Call the constructor! */
if (intl_charFromString(id, &str, &str_len, &INTL_ERROR_CODE(*outside_error)) == FAILURE) {
spprintf(&message, 0, "%s: could not convert id to UTF-8", func);
const TimeZone *tz;
UnicodeString ustr;
char *str;
- int str_len;
+ size_t str_len;
HashTable *debug_info;
UErrorCode uec = U_ZERO_ERROR;
U_CFUNC PHP_FUNCTION(intltz_create_time_zone)
{
char *str_id;
- size_t str_id_len;
+ size_t str_id_len;
intl_error_reset(NULL);
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
- &str_id, &str_id_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str_id, &str_id_len) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_time_zone: bad arguments", 0);
RETURN_NULL();
U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids)
{
char *str_id;
- size_t str_id_len;
+ size_t str_id_len;
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
#if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
U_CFUNC PHP_FUNCTION(intltz_create_time_zone_id_enumeration)
{
- zend_long zoneType,
- offset_arg;
- char *region = NULL;
- size_t region_len = 0;
- int32_t offset,
- *offsetp = NULL;
+ zend_long zoneType,
+ offset_arg;
+ char *region = NULL;
+ size_t region_len = 0;
+ int32_t offset,
+ *offsetp = NULL;
zend_bool arg3isnull = 1;
intl_error_reset(NULL);
U_CFUNC PHP_FUNCTION(intltz_get_canonical_id)
{
char *str_id;
- size_t str_id_len;
+ size_t str_id_len;
zval *is_systemid = NULL;
intl_error_reset(NULL);
INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID");
char *str;
- int str_len;
+ size_t str_len;
intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status,
"intltz_get_canonical_id: could not convert time zone id to UTF-16");
U_CFUNC PHP_FUNCTION(intltz_get_region)
{
char *str_id;
- size_t str_id_len;
- char outbuf[3];
+ size_t str_id_len;
+ char outbuf[3];
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
{
- char *str_id;
+ char *str_id;
size_t str_id_len;
zend_long index;
intl_error_reset(NULL);
const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
char *str;
- int str_len;
+ size_t str_len;
intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
UnicodeString id_us;
to->utimezone->getID(id_us);
- char *id = NULL;
- int id_len = 0;
+ char *id = NULL;
+ size_t id_len = 0;
intl_convert_utf16_to_utf8(&id, &id_len,
id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
U_CFUNC PHP_FUNCTION(intltz_get_display_name)
{
zend_bool daylight = 0;
- zend_long display_type = TimeZone::LONG;
- const char *locale_str = NULL;
- size_t dummy = 0;
+ zend_long display_type = TimeZone::LONG;
+ const char *locale_str = NULL;
+ size_t dummy = 0;
TIMEZONE_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
Locale::createFromName(locale_str), result);
char *str;
- int str_len;
+ size_t str_len;
intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
"could not convert resulting time zone id to UTF-16");
const UChar *ustr_id;
int32_t ustr_id_len;
char *str_id;
- int str_id_len;
+ size_t str_id_len;
Transliterator_object *to;
TRANSLITERATOR_METHOD_FETCH_OBJECT_NO_CHECK;
#include <zend_exceptions.h>
-static int create_transliterator( char *str_id, int str_id_len, zend_long direction, zval *object )
+static int create_transliterator( char *str_id, size_t str_id_len, zend_long direction, zval *object )
{
Transliterator_object *to;
UChar *ustr_id = NULL;
*/
PHP_FUNCTION( transliterator_create )
{
- char *str_id;
- size_t str_id_len;
- zend_long direction = TRANSLITERATOR_FORWARD;
+ char *str_id;
+ size_t str_id_len;
+ zend_long direction = TRANSLITERATOR_FORWARD;
int res;
TRANSLITERATOR_METHOD_INIT_VARS;
PHP_FUNCTION( transliterator_create_from_rules )
{
char *str_rules;
- size_t str_rules_len;
+ size_t str_rules_len;
UChar *ustr_rules = NULL;
int32_t ustr_rules_len = 0;
- zend_long direction = TRANSLITERATOR_FORWARD;
+ zend_long direction = TRANSLITERATOR_FORWARD;
UParseError parse_error = {0, -1};
UTransliterator *utrans;
UChar id[] = {0x52, 0x75, 0x6C, 0x65, 0x73, 0x54, 0x72,
while( (elem = uenum_unext( en, &elem_len, &status )) )
{
char *el_char = NULL;
- int el_len = 0;
+ size_t el_len = 0;
intl_convert_utf16_to_utf8( &el_char, &el_len, elem, elem_len, &status );
char *str;
UChar *ustr = NULL,
*uresult = NULL;
- size_t str_len;
+ size_t str_len;
int32_t ustr_len = 0,
capacity,
uresult_len;
- zend_long start = 0,
+ zend_long start = 0,
limit = -1;
int success = 0;
zval tmp_object;
projects / php / commitdiff