diff options
66 files changed, 1280 insertions, 1280 deletions
diff --git a/Zend/zend_API.c b/Zend/zend_API.c index 91d2e40e7b..e94d49eabc 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -426,7 +426,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons double d; int type; - if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), p, &d, -1)) == 0) { + if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), p, &d, -1)) == 0) { return "long"; } else if (type == IS_DOUBLE) { if (c == 'L') { @@ -439,7 +439,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons } } - *p = zend_dval_to_lval(d); + *p = zend_dval_to_ival(d); } } break; @@ -457,7 +457,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons case IS_NULL: case IS_FALSE: case IS_TRUE: - case IS_LONG: + case IS_INT: convert_to_int_ex(arg); *p = Z_IVAL_P(arg); break; @@ -472,7 +472,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons break; case 'i': - case 'i': + case 'I': { zend_int_t *p = va_arg(*va, zend_int_t *); @@ -490,7 +490,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), p, &d, -1)) == 0) { return "long"; } else if (type == IS_DOUBLE) { - if (c == 'L') { + if (c == 'I') { if (d > ZEND_INT_MAX) { *p = ZEND_INT_MAX; break; @@ -506,7 +506,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons break; case IS_DOUBLE: - if (c == 'L') { + if (c == 'I') { if (Z_DVAL_P(arg) > ZEND_INT_MAX) { *p = ZEND_INT_MAX; break; diff --git a/ext/date/php_date.c b/ext/date/php_date.c index 6cea2af048..168fe9c920 100644 --- a/ext/date/php_date.c +++ b/ext/date/php_date.c @@ -860,9 +860,9 @@ PHP_MINIT_FUNCTION(date) REGISTER_STRING_CONSTANT("DATE_RSS", DATE_FORMAT_RFC1123, CONST_CS | CONST_PERSISTENT); REGISTER_STRING_CONSTANT("DATE_W3C", DATE_FORMAT_RFC3339, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SUNFUNCS_RET_TIMESTAMP", SUNFUNCS_RET_TIMESTAMP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SUNFUNCS_RET_STRING", SUNFUNCS_RET_STRING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SUNFUNCS_RET_DOUBLE", SUNFUNCS_RET_DOUBLE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SUNFUNCS_RET_TIMESTAMP", SUNFUNCS_RET_TIMESTAMP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SUNFUNCS_RET_STRING", SUNFUNCS_RET_STRING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SUNFUNCS_RET_DOUBLE", SUNFUNCS_RET_DOUBLE, CONST_CS | CONST_PERSISTENT); php_date_global_timezone_db = NULL; php_date_global_timezone_db_enabled = 0; @@ -962,7 +962,7 @@ static char* guess_timezone(const timelib_tzdb *tzdb TSRMLS_DC) zval ztz; if (SUCCESS == zend_get_configuration_directive("date.timezone", sizeof("date.timezone"), &ztz) - && Z_TYPE(ztz) == IS_STRING && Z_STRLEN(ztz) > 0 && timelib_timezone_id_is_valid(Z_STRVAL(ztz), tzdb)) { + && Z_TYPE(ztz) == IS_STRING && Z_STRSIZE(ztz) > 0 && timelib_timezone_id_is_valid(Z_STRVAL(ztz), tzdb)) { return Z_STRVAL(ztz); } } else if (*DATEG(default_timezone)) { @@ -1394,7 +1394,7 @@ PHP_FUNCTION(idate) php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unrecognized date format token."); RETURN_FALSE; } - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ @@ -1490,7 +1490,7 @@ PHP_FUNCTION(strtotime) if (error1 || error2) { RETURN_FALSE; } else { - RETURN_LONG(ts); + RETURN_INT(ts); } } /* }}} */ @@ -1582,7 +1582,7 @@ PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt) if (error) { RETURN_FALSE; } else { - RETURN_LONG(ts); + RETURN_INT(ts); } } /* }}} */ @@ -1737,7 +1737,7 @@ PHP_FUNCTION(gmstrftime) Return current UNIX timestamp */ PHP_FUNCTION(time) { - RETURN_LONG((long)time(NULL)); + RETURN_INT((long)time(NULL)); } /* }}} */ @@ -1763,25 +1763,25 @@ PHP_FUNCTION(localtime) array_init(return_value); if (associative) { - add_assoc_long(return_value, "tm_sec", ts->s); - add_assoc_long(return_value, "tm_min", ts->i); - add_assoc_long(return_value, "tm_hour", ts->h); - add_assoc_long(return_value, "tm_mday", ts->d); - add_assoc_long(return_value, "tm_mon", ts->m - 1); - add_assoc_long(return_value, "tm_year", ts->y - 1900); - add_assoc_long(return_value, "tm_wday", timelib_day_of_week(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "tm_yday", timelib_day_of_year(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "tm_isdst", ts->dst); + add_assoc_int(return_value, "tm_sec", ts->s); + add_assoc_int(return_value, "tm_min", ts->i); + add_assoc_int(return_value, "tm_hour", ts->h); + add_assoc_int(return_value, "tm_mday", ts->d); + add_assoc_int(return_value, "tm_mon", ts->m - 1); + add_assoc_int(return_value, "tm_year", ts->y - 1900); + add_assoc_int(return_value, "tm_wday", timelib_day_of_week(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "tm_yday", timelib_day_of_year(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "tm_isdst", ts->dst); } else { - add_next_index_long(return_value, ts->s); - add_next_index_long(return_value, ts->i); - add_next_index_long(return_value, ts->h); - add_next_index_long(return_value, ts->d); - add_next_index_long(return_value, ts->m - 1); - add_next_index_long(return_value, ts->y- 1900); - add_next_index_long(return_value, timelib_day_of_week(ts->y, ts->m, ts->d)); - add_next_index_long(return_value, timelib_day_of_year(ts->y, ts->m, ts->d)); - add_next_index_long(return_value, ts->dst); + add_next_index_int(return_value, ts->s); + add_next_index_int(return_value, ts->i); + add_next_index_int(return_value, ts->h); + add_next_index_int(return_value, ts->d); + add_next_index_int(return_value, ts->m - 1); + add_next_index_int(return_value, ts->y- 1900); + add_next_index_int(return_value, timelib_day_of_week(ts->y, ts->m, ts->d)); + add_next_index_int(return_value, timelib_day_of_year(ts->y, ts->m, ts->d)); + add_next_index_int(return_value, ts->dst); } timelib_time_dtor(ts); @@ -1808,17 +1808,17 @@ PHP_FUNCTION(getdate) array_init(return_value); - add_assoc_long(return_value, "seconds", ts->s); - add_assoc_long(return_value, "minutes", ts->i); - add_assoc_long(return_value, "hours", ts->h); - add_assoc_long(return_value, "mday", ts->d); - add_assoc_long(return_value, "wday", timelib_day_of_week(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "mon", ts->m); - add_assoc_long(return_value, "year", ts->y); - add_assoc_long(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "seconds", ts->s); + add_assoc_int(return_value, "minutes", ts->i); + add_assoc_int(return_value, "hours", ts->h); + add_assoc_int(return_value, "mday", ts->d); + add_assoc_int(return_value, "wday", timelib_day_of_week(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "mon", ts->m); + add_assoc_int(return_value, "year", ts->y); + add_assoc_int(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d)); add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d)); add_assoc_string(return_value, "month", mon_full_names[ts->m - 1]); - add_index_long(return_value, 0, timestamp); + add_index_int(return_value, 0, timestamp); timelib_time_dtor(ts); } @@ -1925,7 +1925,7 @@ static zval *date_period_it_current_data(zend_object_iterator *iter TSRMLS_DC) static void date_period_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) { date_period_it *iterator = (date_period_it *)iter; - ZVAL_LONG(key, iterator->current_index); + ZVAL_INT(key, iterator->current_index); } /* }}} */ @@ -2049,7 +2049,7 @@ static void date_register_classes(TSRMLS_D) /* {{{ */ date_object_handlers_timezone.get_gc = date_object_get_gc_timezone; #define REGISTER_TIMEZONE_CLASS_CONST_STRING(const_name, value) \ - zend_declare_class_constant_long(date_ce_timezone, const_name, sizeof(const_name)-1, value TSRMLS_CC); + zend_declare_class_constant_int(date_ce_timezone, const_name, sizeof(const_name)-1, value TSRMLS_CC); REGISTER_TIMEZONE_CLASS_CONST_STRING("AFRICA", PHP_DATE_TIMEZONE_GROUP_AFRICA); REGISTER_TIMEZONE_CLASS_CONST_STRING("AMERICA", PHP_DATE_TIMEZONE_GROUP_AMERICA); @@ -2096,7 +2096,7 @@ static void date_register_classes(TSRMLS_D) /* {{{ */ date_object_handlers_period.write_property = date_period_write_property; #define REGISTER_PERIOD_CLASS_CONST_STRING(const_name, value) \ - zend_declare_class_constant_long(date_ce_period, const_name, sizeof(const_name)-1, value TSRMLS_CC); + zend_declare_class_constant_int(date_ce_period, const_name, sizeof(const_name)-1, value TSRMLS_CC); REGISTER_PERIOD_CLASS_CONST_STRING("EXCLUDE_START_DATE", PHP_DATE_PERIOD_EXCLUDE_START_DATE); } /* }}} */ @@ -2203,7 +2203,7 @@ static HashTable *date_object_get_properties(zval *object TSRMLS_DC) /* {{{ */ /* then we add the timezone name (or similar) */ if (dateobj->time->is_localtime) { - ZVAL_LONG(&zv, dateobj->time->zone_type); + ZVAL_INT(&zv, dateobj->time->zone_type); zend_hash_str_update(props, "timezone_type", sizeof("timezone_type")-1, &zv); switch (dateobj->time->zone_type) { @@ -2296,7 +2296,7 @@ static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC) /* return props; } - ZVAL_LONG(&zv, tzobj->type); + ZVAL_INT(&zv, tzobj->type); zend_hash_str_update(props, "timezone_type", sizeof("timezone_type")-1, &zv); switch (tzobj->type) { @@ -2377,7 +2377,7 @@ static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC) /* } #define PHP_DATE_INTERVAL_ADD_PROPERTY(n,f) \ - ZVAL_LONG(&zv, (long)intervalobj->diff->f); \ + ZVAL_INT(&zv, (long)intervalobj->diff->f); \ zend_hash_str_update(props, n, sizeof(n)-1, &zv); PHP_DATE_INTERVAL_ADD_PROPERTY("y", y); @@ -2760,18 +2760,18 @@ static int php_date_initialize_from_hash(php_date_obj **dateobj, HashTable *myht convert_to_string(z_date); z_timezone_type = zend_hash_str_find(myht, "timezone_type", sizeof("timezone_type")-1); if (z_timezone_type) { - convert_to_long(z_timezone_type); + convert_to_int(z_timezone_type); z_timezone = zend_hash_str_find(myht, "timezone", sizeof("timezone")-1); if (z_timezone) { convert_to_string(z_timezone); - switch (Z_LVAL_P(z_timezone_type)) { + switch (Z_IVAL_P(z_timezone_type)) { case TIMELIB_ZONETYPE_OFFSET: case TIMELIB_ZONETYPE_ABBR: { - char *tmp = emalloc(Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 2); + char *tmp = emalloc(Z_STRSIZE_P(z_date) + Z_STRSIZE_P(z_timezone) + 2); int ret; - snprintf(tmp, Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 2, "%s %s", Z_STRVAL_P(z_date), Z_STRVAL_P(z_timezone)); - ret = php_date_initialize(*dateobj, tmp, Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 1, NULL, NULL, 0 TSRMLS_CC); + snprintf(tmp, Z_STRSIZE_P(z_date) + Z_STRSIZE_P(z_timezone) + 2, "%s %s", Z_STRVAL_P(z_date), Z_STRVAL_P(z_timezone)); + ret = php_date_initialize(*dateobj, tmp, Z_STRSIZE_P(z_date) + Z_STRSIZE_P(z_timezone) + 1, NULL, NULL, 0 TSRMLS_CC); efree(tmp); return 1 == ret; } @@ -2791,7 +2791,7 @@ static int php_date_initialize_from_hash(php_date_obj **dateobj, HashTable *myht tzobj->tzi.tz = tzi; tzobj->initialized = 1; - ret = php_date_initialize(*dateobj, Z_STRVAL_P(z_date), Z_STRLEN_P(z_date), NULL, &tmp_obj, 0 TSRMLS_CC); + ret = php_date_initialize(*dateobj, Z_STRVAL_P(z_date), Z_STRSIZE_P(z_date), NULL, &tmp_obj, 0 TSRMLS_CC); zval_ptr_dtor(&tmp_obj); return 1 == ret; } @@ -2870,14 +2870,14 @@ static void zval_from_error_container(zval *z, timelib_error_container *error) / int i; zval element; - add_assoc_long(z, "warning_count", error->warning_count); + add_assoc_int(z, "warning_count", error->warning_count); array_init(&element); for (i = 0; i < error->warning_count; i++) { add_index_string(&element, error->warning_messages[i].position, error->warning_messages[i].message); } add_assoc_zval(z, "warnings", &element); - add_assoc_long(z, "error_count", error->error_count); + add_assoc_int(z, "error_count", error->error_count); array_init(&element); for (i = 0; i < error->error_count; i++) { add_index_string(&element, error->error_messages[i].position, error->error_messages[i].message); @@ -2908,7 +2908,7 @@ void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time * if (parsed_time->elem == -99999) { \ add_assoc_bool(return_value, #name, 0); \ } else { \ - add_assoc_long(return_value, #name, parsed_time->elem); \ + add_assoc_int(return_value, #name, parsed_time->elem); \ } PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(year, y); PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(month, m); @@ -2953,17 +2953,17 @@ void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time * } if (parsed_time->have_relative) { array_init(&element); - add_assoc_long(&element, "year", parsed_time->relative.y); - add_assoc_long(&element, "month", parsed_time->relative.m); - add_assoc_long(&element, "day", parsed_time->relative.d); - add_assoc_long(&element, "hour", parsed_time->relative.h); - add_assoc_long(&element, "minute", parsed_time->relative.i); - add_assoc_long(&element, "second", parsed_time->relative.s); + add_assoc_int(&element, "year", parsed_time->relative.y); + add_assoc_int(&element, "month", parsed_time->relative.m); + add_assoc_int(&element, "day", parsed_time->relative.d); + add_assoc_int(&element, "hour", parsed_time->relative.h); + add_assoc_int(&element, "minute", parsed_time->relative.i); + add_assoc_int(&element, "second", parsed_time->relative.s); if (parsed_time->relative.have_weekday_relative) { - add_assoc_long(&element, "weekday", parsed_time->relative.weekday); + add_assoc_int(&element, "weekday", parsed_time->relative.weekday); } if (parsed_time->relative.have_special_relative && (parsed_time->relative.special.type == TIMELIB_SPECIAL_WEEKDAY)) { - add_assoc_long(&element, "weekdays", parsed_time->relative.special.amount); + add_assoc_int(&element, "weekdays", parsed_time->relative.special.amount); } if (parsed_time->relative.first_last_day_of) { add_assoc_bool(&element, parsed_time->relative.first_last_day_of == 1 ? "first_day_of_month" : "last_day_of_month", 1); @@ -3360,19 +3360,19 @@ PHP_FUNCTION(date_offset_get) switch (dateobj->time->zone_type) { case TIMELIB_ZONETYPE_ID: offset = timelib_get_time_zone_info(dateobj->time->sse, dateobj->time->tz_info); - RETVAL_LONG(offset->offset); + RETVAL_INT(offset->offset); timelib_time_offset_dtor(offset); break; case TIMELIB_ZONETYPE_OFFSET: - RETVAL_LONG(dateobj->time->z * -60); + RETVAL_INT(dateobj->time->z * -60); break; case TIMELIB_ZONETYPE_ABBR: - RETVAL_LONG((dateobj->time->z - (60 * dateobj->time->dst)) * -60); + RETVAL_INT((dateobj->time->z - (60 * dateobj->time->dst)) * -60); break; } return; } else { - RETURN_LONG(0); + RETURN_INT(0); } } /* }}} */ @@ -3592,7 +3592,7 @@ PHP_FUNCTION(date_timestamp_get) if (error) { RETURN_FALSE; } else { - RETVAL_LONG(timestamp); + RETVAL_INT(timestamp); } } /* }}} */ @@ -3692,7 +3692,7 @@ static int php_date_timezone_initialize_from_hash(zval **return_value, php_timez if ((z_timezone_type = zend_hash_str_find(myht, "timezone_type", sizeof("timezone_type")-1)) != NULL) { if ((z_timezone = zend_hash_str_find(myht, "timezone", sizeof("timezone")-1)) != NULL) { - convert_to_long(z_timezone_type); + convert_to_int(z_timezone_type); if (SUCCESS == timezone_initialize(*tzobj, Z_STRVAL_P(z_timezone) TSRMLS_CC)) { return SUCCESS; } @@ -3819,14 +3819,14 @@ PHP_FUNCTION(timezone_offset_get) switch (tzobj->type) { case TIMELIB_ZONETYPE_ID: offset = timelib_get_time_zone_info(dateobj->time->sse, tzobj->tzi.tz); - RETVAL_LONG(offset->offset); + RETVAL_INT(offset->offset); timelib_time_offset_dtor(offset); break; case TIMELIB_ZONETYPE_OFFSET: - RETURN_LONG(tzobj->tzi.utc_offset * -60); + RETURN_INT(tzobj->tzi.utc_offset * -60); break; case TIMELIB_ZONETYPE_ABBR: - RETURN_LONG((tzobj->tzi.z.utc_offset - (tzobj->tzi.z.dst*60)) * -60); + RETURN_INT((tzobj->tzi.z.utc_offset - (tzobj->tzi.z.dst*60)) * -60); break; } } @@ -3853,18 +3853,18 @@ PHP_FUNCTION(timezone_transitions_get) #define add_nominal() \ array_init(&element); \ - add_assoc_long(&element, "ts", timestamp_begin); \ + add_assoc_int(&element, "ts", timestamp_begin); \ add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, timestamp_begin, 0 TSRMLS_CC)); \ - add_assoc_long(&element, "offset", tzobj->tzi.tz->type[0].offset); \ + add_assoc_int(&element, "offset", tzobj->tzi.tz->type[0].offset); \ add_assoc_bool(&element, "isdst", tzobj->tzi.tz->type[0].isdst); \ add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx]); \ add_next_index_zval(return_value, &element); #define add(i,ts) \ array_init(&element); \ - add_assoc_long(&element, "ts", ts); \ + add_assoc_int(&element, "ts", ts); \ add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, ts, 0 TSRMLS_CC)); \ - add_assoc_long(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \ + add_assoc_int(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \ add_assoc_bool(&element, "isdst", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].isdst); \ add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx]); \ add_next_index_zval(return_value, &element); @@ -4023,7 +4023,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, void **c retval = rv; if (value != -99999) { - ZVAL_LONG(retval, value); + ZVAL_INT(retval, value); } else { ZVAL_FALSE(retval); } @@ -4496,7 +4496,7 @@ PHP_FUNCTION(timezone_abbreviations_list) do { array_init(&element); add_assoc_bool(&element, "dst", entry->type); - add_assoc_long(&element, "offset", entry->gmtoffset); + add_assoc_int(&element, "offset", entry->gmtoffset); if (entry->full_tz_name) { add_assoc_string(&element, "timezone_id", entry->full_tz_name); } else { @@ -4617,7 +4617,7 @@ static void php_do_date_sunrise_sunset(INTERNAL_FUNCTION_PARAMETERS, int calc_su } if (retformat == SUNFUNCS_RET_TIMESTAMP) { - RETURN_LONG(calc_sunset ? set : rise); + RETURN_INT(calc_sunset ? set : rise); } N = (calc_sunset ? h_set : h_rise) + gmt_offset; @@ -4693,12 +4693,12 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "sunrise", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "sunrise", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "sunset", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "sunset", timelib_date_to_int(t2, &dummy)); } t2->sse = transit; - add_assoc_long(return_value, "transit", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "transit", timelib_date_to_int(t2, &dummy)); /* Get civil twilight */ rs = timelib_astro_rise_set_altitude(t, longitude, latitude, -6.0, 0, &ddummy, &ddummy, &rise, &set, &transit); @@ -4713,9 +4713,9 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "civil_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "civil_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "civil_twilight_end", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "civil_twilight_end", timelib_date_to_int(t2, &dummy)); } /* Get nautical twilight */ @@ -4731,9 +4731,9 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "nautical_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "nautical_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "nautical_twilight_end", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "nautical_twilight_end", timelib_date_to_int(t2, &dummy)); } /* Get astronomical twilight */ @@ -4749,9 +4749,9 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "astronomical_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "astronomical_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "astronomical_twilight_end", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "astronomical_twilight_end", timelib_date_to_int(t2, &dummy)); } timelib_time_dtor(t); timelib_time_dtor(t2); @@ -4821,7 +4821,7 @@ static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC) /* { zend_hash_str_update(props, "interval", sizeof("interval")-1, &zv); /* converted to larger type (int->long); must check when unserializing */ - ZVAL_LONG(&zv, (long) period_obj->recurrences); + ZVAL_INT(&zv, (long) period_obj->recurrences); zend_hash_str_update(props, "recurrences", sizeof("recurrences")-1, &zv); ZVAL_BOOL(&zv, period_obj->include_start_date); @@ -4891,8 +4891,8 @@ static int php_date_period_initialize_from_hash(php_period_obj *period_obj, Hash ht_entry = zend_hash_str_find(myht, "recurrences", sizeof("recurrences")-1); if (ht_entry && - Z_TYPE_P(ht_entry) == IS_LONG && Z_LVAL_P(ht_entry) >= 0 && Z_LVAL_P(ht_entry) <= INT_MAX) { - period_obj->recurrences = Z_LVAL_P(ht_entry); + Z_TYPE_P(ht_entry) == IS_INT && Z_IVAL_P(ht_entry) >= 0 && Z_IVAL_P(ht_entry) <= INT_MAX) { + period_obj->recurrences = Z_IVAL_P(ht_entry); } else { return 0; } diff --git a/ext/ereg/ereg.c b/ext/ereg/ereg.c index 79bee9b79f..280b54a43d 100644 --- a/ext/ereg/ereg.c +++ b/ext/ereg/ereg.c @@ -323,7 +323,7 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase) } else { /* we convert numbers to integers and treat them as a string */ if (Z_TYPE_P(regex) == IS_DOUBLE) { - convert_to_long_ex(regex); /* get rid of decimal places */ + convert_to_int_ex(regex); /* get rid of decimal places */ } convert_to_string_ex(regex); /* don't bother doing an extended regex with just a number */ @@ -379,7 +379,7 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase) } else { if (match_len == 0) match_len = 1; - RETVAL_LONG(match_len); + RETVAL_INT(match_len); } regfree(&re); } @@ -564,28 +564,28 @@ static void php_do_ereg_replace(INTERNAL_FUNCTION_PARAMETERS, int icase) } if (Z_TYPE_P(arg_pattern) == IS_STRING) { - if (Z_STRVAL_P(arg_pattern) && Z_STRLEN_P(arg_pattern)) { + if (Z_STRVAL_P(arg_pattern) && Z_STRSIZE_P(arg_pattern)) { pattern = STR_COPY(Z_STR_P(arg_pattern)); } else { pattern = STR_EMPTY_ALLOC(); } } else { - convert_to_long_ex(arg_pattern); + convert_to_int_ex(arg_pattern); pattern = STR_ALLOC(1, 0); - pattern->val[0] = (char) Z_LVAL_P(arg_pattern); + pattern->val[0] = (char) Z_IVAL_P(arg_pattern); pattern->val[1] = '\0'; } if (Z_TYPE_P(arg_replace) == IS_STRING) { - if (Z_STRVAL_P(arg_replace) && Z_STRLEN_P(arg_replace)) { + if (Z_STRVAL_P(arg_replace) && Z_STRSIZE_P(arg_replace)) { replace = STR_COPY(Z_STR_P(arg_replace)); } else { replace = STR_EMPTY_ALLOC(); } } else { - convert_to_long_ex(arg_replace); + convert_to_int_ex(arg_replace); replace = STR_ALLOC(1, 0); - replace->val[0] = (char) Z_LVAL_P(arg_replace); + replace->val[0] = (char) Z_IVAL_P(arg_replace); replace->val[1] = '\0'; } diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c index 4731db21fb..ddfccc3763 100644 --- a/ext/pcre/php_pcre.c +++ b/ext/pcre/php_pcre.c @@ -143,20 +143,20 @@ static PHP_MINIT_FUNCTION(pcre) { REGISTER_INI_ENTRIES(); - REGISTER_LONG_CONSTANT("PREG_PATTERN_ORDER", PREG_PATTERN_ORDER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SET_ORDER", PREG_SET_ORDER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_OFFSET_CAPTURE", PREG_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SPLIT_NO_EMPTY", PREG_SPLIT_NO_EMPTY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SPLIT_DELIM_CAPTURE", PREG_SPLIT_DELIM_CAPTURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SPLIT_OFFSET_CAPTURE", PREG_SPLIT_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_GREP_INVERT", PREG_GREP_INVERT, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("PREG_NO_ERROR", PHP_PCRE_NO_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_INTERNAL_ERROR", PHP_PCRE_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_BACKTRACK_LIMIT_ERROR", PHP_PCRE_BACKTRACK_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_RECURSION_LIMIT_ERROR", PHP_PCRE_RECURSION_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_ERROR", PHP_PCRE_BAD_UTF8_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_OFFSET_ERROR", PHP_PCRE_BAD_UTF8_OFFSET_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_PATTERN_ORDER", PREG_PATTERN_ORDER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SET_ORDER", PREG_SET_ORDER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_OFFSET_CAPTURE", PREG_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SPLIT_NO_EMPTY", PREG_SPLIT_NO_EMPTY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SPLIT_DELIM_CAPTURE", PREG_SPLIT_DELIM_CAPTURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SPLIT_OFFSET_CAPTURE", PREG_SPLIT_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_GREP_INVERT", PREG_GREP_INVERT, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("PREG_NO_ERROR", PHP_PCRE_NO_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_INTERNAL_ERROR", PHP_PCRE_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_BACKTRACK_LIMIT_ERROR", PHP_PCRE_BACKTRACK_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_RECURSION_LIMIT_ERROR", PHP_PCRE_RECURSION_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_BAD_UTF8_ERROR", PHP_PCRE_BAD_UTF8_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_BAD_UTF8_OFFSET_ERROR", PHP_PCRE_BAD_UTF8_OFFSET_ERROR, CONST_CS | CONST_PERSISTENT); REGISTER_STRING_CONSTANT("PCRE_VERSION", (char *)pcre_version(), CONST_CS | CONST_PERSISTENT); return SUCCESS; @@ -527,7 +527,7 @@ static inline void add_offset_pair(zval *result, char *str, int len, int offset, /* Add (match, offset) to the return value */ add_next_index_stringl(&match_pair, str, len); - add_next_index_long(&match_pair, offset); + add_next_index_int(&match_pair, offset); if (name) { zval_add_ref(&match_pair); @@ -888,7 +888,7 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec /* Did we encounter an error? */ if (PCRE_G(error_code) == PHP_PCRE_NO_ERROR) { - RETVAL_LONG(matched); + RETVAL_INT(matched); } else { RETVAL_FALSE; } @@ -1142,7 +1142,7 @@ PHPAPI zend_string *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, } } else { replace = Z_STRVAL_P(replace_val); - replace_len = Z_STRLEN_P(replace_val); + replace_len = Z_STRSIZE_P(replace_val); replace_end = replace + replace_len; } @@ -1519,7 +1519,7 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_repl } if (ZEND_NUM_ARGS() > 4) { zval_dtor(zcount); - ZVAL_LONG(zcount, replace_count); + ZVAL_INT(zcount, replace_count); } } @@ -1988,7 +1988,7 @@ static PHP_FUNCTION(preg_last_error) ZEND_PARSE_PARAMETERS_END(); #endif - RETURN_LONG(PCRE_G(error_code)); + RETURN_INT(PCRE_G(error_code)); } /* }}} */ diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 4248de834d..639016179f 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -110,8 +110,8 @@ ZEND_DECLARE_MODULE_GLOBALS(reflection) target = intern->ptr; \ /* Class constants */ -#define REGISTER_REFLECTION_CLASS_CONST_LONG(class_name, const_name, value) \ - zend_declare_class_constant_long(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); +#define REGISTER_REFLECTION_CLASS_CONST_INT(class_name, const_name, value) \ + zend_declare_class_constant_int(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); /* {{{ Smart string functions */ typedef struct _string { @@ -738,8 +738,8 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg string_write(str, "NULL", sizeof("NULL")-1); } else if (Z_TYPE(zv) == IS_STRING) { string_write(str, "'", sizeof("'")-1); - string_write(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15)); - if (Z_STRLEN(zv) > 15) { + string_write(str, Z_STRVAL(zv), MIN(Z_STRSIZE(zv), 15)); + if (Z_STRSIZE(zv) > 15) { string_write(str, "...", sizeof("...")-1); } string_write(str, "'", sizeof("'")-1); @@ -1817,7 +1817,7 @@ ZEND_METHOD(reflection_function, getStartLine) } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { - RETURN_LONG(fptr->op_array.line_start); + RETURN_INT(fptr->op_array.line_start); } RETURN_FALSE; } @@ -1835,7 +1835,7 @@ ZEND_METHOD(reflection_function, getEndLine) } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { - RETURN_LONG(fptr->op_array.line_end); + RETURN_INT(fptr->op_array.line_end); } RETURN_FALSE; } @@ -2018,7 +2018,7 @@ ZEND_METHOD(reflection_function, getNumberOfParameters) METHOD_NOTSTATIC(reflection_function_abstract_ptr); GET_REFLECTION_OBJECT_PTR(fptr); - RETURN_LONG(fptr->common.num_args); + RETURN_INT(fptr->common.num_args); } /* }}} */ @@ -2032,7 +2032,7 @@ ZEND_METHOD(reflection_function, getNumberOfRequiredParameters) METHOD_NOTSTATIC(reflection_function_abstract_ptr); GET_REFLECTION_OBJECT_PTR(fptr); - RETURN_LONG(fptr->common.required_num_args); + RETURN_INT(fptr->common.required_num_args); } /* }}} */ @@ -2149,7 +2149,7 @@ ZEND_METHOD(reflection_parameter, __construct) unsigned int lcname_len; char *lcname; - lcname_len = Z_STRLEN_P(reference); + lcname_len = Z_STRSIZE_P(reference); lcname = zend_str_tolower_dup(Z_STRVAL_P(reference), lcname_len); if ((fptr = zend_hash_str_find_ptr(EG(function_table), lcname, lcname_len)) == NULL) { efree(lcname); @@ -2187,7 +2187,7 @@ ZEND_METHOD(reflection_parameter, __construct) } convert_to_string_ex(method); - lcname_len = Z_STRLEN_P(method); + lcname_len = Z_STRSIZE_P(method); lcname = zend_str_tolower_dup(Z_STRVAL_P(method), lcname_len); if (ce == zend_ce_closure && Z_TYPE_P(classref) == IS_OBJECT && (lcname_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) @@ -2228,8 +2228,8 @@ ZEND_METHOD(reflection_parameter, __construct) /* Now, search for the parameter */ arg_info = fptr->common.arg_info; - if (Z_TYPE_P(parameter) == IS_LONG) { - position= Z_LVAL_P(parameter); + if (Z_TYPE_P(parameter) == IS_INT) { + position= Z_IVAL_P(parameter); if (position < 0 || (zend_uint)position >= fptr->common.num_args) { if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) { if (fptr->type != ZEND_OVERLOADED_FUNCTION) { @@ -2512,7 +2512,7 @@ ZEND_METHOD(reflection_parameter, getPosition) } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_LONG(param->offset); + RETVAL_INT(param->offset); } /* }}} */ @@ -3112,7 +3112,7 @@ ZEND_METHOD(reflection_function, inNamespace) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_TRUE; @@ -3135,7 +3135,7 @@ ZEND_METHOD(reflection_function, getNamespaceName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_STRINGL(Z_STRVAL_P(name), backslash - Z_STRVAL_P(name)); @@ -3158,10 +3158,10 @@ ZEND_METHOD(reflection_function, getShortName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { - RETURN_STRINGL(backslash + 1, Z_STRLEN_P(name) - (backslash - Z_STRVAL_P(name) + 1)); + RETURN_STRINGL(backslash + 1, Z_STRSIZE_P(name) - (backslash - Z_STRVAL_P(name) + 1)); } RETURN_ZVAL(name, 1, 0); } @@ -3212,7 +3212,7 @@ ZEND_METHOD(reflection_method, getModifiers) } GET_REFLECTION_OBJECT_PTR(mptr); - RETURN_LONG(mptr->common.fn_flags); + RETURN_INT(mptr->common.fn_flags); } /* }}} */ @@ -3575,7 +3575,7 @@ ZEND_METHOD(reflection_class, getStartLine) } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_FUNCTION) { - RETURN_LONG(ce->info.user.line_start); + RETURN_INT(ce->info.user.line_start); } RETURN_FALSE; } @@ -3593,7 +3593,7 @@ ZEND_METHOD(reflection_class, getEndLine) } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_CLASS) { - RETURN_LONG(ce->info.user.line_end); + RETURN_INT(ce->info.user.line_end); } RETURN_FALSE; } @@ -4146,7 +4146,7 @@ ZEND_METHOD(reflection_class, getModifiers) } GET_REFLECTION_OBJECT_PTR(ce); - RETURN_LONG(ce->ce_flags & ~ZEND_ACC_CONSTANTS_UPDATED); + RETURN_INT(ce->ce_flags & ~ZEND_ACC_CONSTANTS_UPDATED); } /* }}} */ @@ -4657,7 +4657,7 @@ ZEND_METHOD(reflection_class, inNamespace) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_TRUE; @@ -4680,7 +4680,7 @@ ZEND_METHOD(reflection_class, getNamespaceName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_STRINGL(Z_STRVAL_P(name), backslash - Z_STRVAL_P(name)); @@ -4703,10 +4703,10 @@ ZEND_METHOD(reflection_class, getShortName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { - RETURN_STRINGL(backslash + 1, Z_STRLEN_P(name) - (backslash - Z_STRVAL_P(name) + 1)); + RETURN_STRINGL(backslash + 1, Z_STRSIZE_P(name) - (backslash - Z_STRVAL_P(name) + 1)); } RETURN_ZVAL(name, 1, 0); } @@ -4926,7 +4926,7 @@ ZEND_METHOD(reflection_property, getModifiers) } GET_REFLECTION_OBJECT_PTR(ref); - RETURN_LONG(ref->prop.flags); + RETURN_INT(ref->prop.flags); } /* }}} */ @@ -6058,8 +6058,8 @@ static void _reflection_write_property(zval *object, zval *member, zval *value, { if ((Z_TYPE_P(member) == IS_STRING) && zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member)) - && ((Z_STRLEN_P(member) == sizeof("name") - 1 && !memcmp(Z_STRVAL_P(member), "name", sizeof("name"))) - || (Z_STRLEN_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class"))))) + && ((Z_STRSIZE_P(member) == sizeof("name") - 1 && !memcmp(Z_STRVAL_P(member), "name", sizeof("name"))) + || (Z_STRSIZE_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class"))))) { zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Cannot set read-only property %s::$%s", Z_OBJCE_P(object)->name->val, Z_STRVAL_P(member)); @@ -6102,7 +6102,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ reflection_function_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr TSRMLS_CC); zend_declare_property_string(reflection_function_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED); + REGISTER_REFLECTION_CLASS_CONST_INT(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionParameter", reflection_parameter_functions); _reflection_entry.create_object = reflection_objects_new; @@ -6116,12 +6116,12 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ zend_declare_property_string(reflection_method_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); zend_declare_property_string(reflection_method_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_STATIC", ZEND_ACC_STATIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PUBLIC", ZEND_ACC_PUBLIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PROTECTED", ZEND_ACC_PROTECTED); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PRIVATE", ZEND_ACC_PRIVATE); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_ABSTRACT", ZEND_ACC_ABSTRACT); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_FINAL", ZEND_ACC_FINAL); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_STATIC", ZEND_ACC_STATIC); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_PUBLIC", ZEND_ACC_PUBLIC); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_PROTECTED", ZEND_ACC_PROTECTED); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_PRIVATE", ZEND_ACC_PRIVATE); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_ABSTRACT", ZEND_ACC_ABSTRACT); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_FINAL", ZEND_ACC_FINAL); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClass", reflection_class_functions); _reflection_entry.create_object = reflection_objects_new; @@ -6129,9 +6129,9 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ reflection_register_implement(reflection_class_ptr, reflector_ptr TSRMLS_CC); zend_declare_property_string(reflection_class_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_IMPLICIT_ABSTRACT", ZEND_ACC_IMPLICIT_ABSTRACT_CLASS); - REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_EXPLICIT_ABSTRACT", ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); - REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_FINAL", ZEND_ACC_FINAL_CLASS); + REGISTER_REFLECTION_CLASS_CONST_INT(class, "IS_IMPLICIT_ABSTRACT", ZEND_ACC_IMPLICIT_ABSTRACT_CLASS); + REGISTER_REFLECTION_CLASS_CONST_INT(class, "IS_EXPLICIT_ABSTRACT", ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + REGISTER_REFLECTION_CLASS_CONST_INT(class, "IS_FINAL", ZEND_ACC_FINAL_CLASS); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionObject", reflection_object_functions); _reflection_entry.create_object = reflection_objects_new; @@ -6144,10 +6144,10 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ zend_declare_property_string(reflection_property_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); zend_declare_property_string(reflection_property_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_STATIC", ZEND_ACC_STATIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PUBLIC", ZEND_ACC_PUBLIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PROTECTED", ZEND_ACC_PROTECTED); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PRIVATE", ZEND_ACC_PRIVATE); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_STATIC", ZEND_ACC_STATIC); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_PUBLIC", ZEND_ACC_PUBLIC); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_PROTECTED", ZEND_ACC_PROTECTED); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_PRIVATE", ZEND_ACC_PRIVATE); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionExtension", reflection_extension_functions); _reflection_entry.create_object = reflection_objects_new; diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c index 62cf6ae144..530a0c80ee 100644 --- a/ext/spl/php_spl.c +++ b/ext/spl/php_spl.c @@ -417,8 +417,8 @@ PHP_FUNCTION(spl_autoload_call) if (SPL_G(autoload_functions)) { int l_autoload_running = SPL_G(autoload_running); SPL_G(autoload_running) = 1; - lc_name = STR_ALLOC(Z_STRLEN_P(class_name), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name)); + lc_name = STR_ALLOC(Z_STRSIZE_P(class_name), 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(class_name), Z_STRSIZE_P(class_name)); ZEND_HASH_FOREACH_STR_KEY_PTR(SPL_G(autoload_functions), func_name, alfi) { zend_call_method(Z_ISUNDEF(alfi->obj)? NULL : &alfi->obj, alfi->ce, &alfi->func_ptr, func_name->val, func_name->len, retval, 1, class_name, NULL TSRMLS_CC); zend_exception_save(TSRMLS_C); diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 720a704e92..c7d9a951b8 100644 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -372,8 +372,8 @@ fetch_dim_string: case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: if ((retval = zend_hash_index_find(ht, index)) == NULL) { switch (type) { @@ -504,8 +504,8 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (ht->u.v.nApplyCount > 0) { @@ -596,8 +596,8 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (ht->u.v.nApplyCount > 0) { @@ -675,8 +675,8 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: if ((tmp = zend_hash_index_find(ht, index)) != NULL) { if (check_empty == 2) { @@ -957,7 +957,7 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ ht2 = spl_array_get_hash_table(intern2, 0 TSRMLS_CC); zend_compare_symbol_tables(&temp_zv, ht1, ht2 TSRMLS_CC); - result = (int)Z_LVAL(temp_zv); + result = (int)Z_IVAL(temp_zv); /* if we just compared std.properties, don't do it again */ if (result == 0 && !(ht1 == intern1->std.properties && ht2 == intern2->std.properties)) { @@ -1302,7 +1302,7 @@ SPL_METHOD(Array, getFlags) return; } - RETURN_LONG(intern->ar_flags & ~SPL_ARRAY_INT_MASK); + RETURN_INT(intern->ar_flags & ~SPL_ARRAY_INT_MASK); } /* }}} */ @@ -1449,8 +1449,8 @@ int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ if (Z_TYPE(rv) != IS_UNDEF) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long)Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (long)Z_IVAL(intern->retval); return SUCCESS; } *count = 0; @@ -1473,7 +1473,7 @@ SPL_METHOD(Array, count) spl_array_object_count_elements_helper(intern, &count TSRMLS_CC); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ static void spl_array_method(INTERNAL_FUNCTION_PARAMETERS, char *fname, int fname_len, int use_arg) /* {{{ */ @@ -1706,7 +1706,7 @@ SPL_METHOD(Array, getChildren) } } - ZVAL_LONG(&flags, SPL_ARRAY_USE_OTHER | intern->ar_flags); + ZVAL_INT(&flags, SPL_ARRAY_USE_OTHER | intern->ar_flags); spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, entry, &flags TSRMLS_CC); } /* }}} */ @@ -1733,7 +1733,7 @@ SPL_METHOD(Array, serialize) PHP_VAR_SERIALIZE_INIT(var_hash); - ZVAL_LONG(&flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK)); + ZVAL_INT(&flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK)); /* storage */ smart_str_appendl(&buf, "x:", 2); @@ -1806,12 +1806,12 @@ SPL_METHOD(Array, unserialize) } ++p; - if (!php_var_unserialize(&zflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE(zflags) != IS_LONG) { + if (!php_var_unserialize(&zflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE(zflags) != IS_INT) { goto outexcept; } --p; /* for ';' */ - flags = Z_LVAL(zflags); + flags = Z_IVAL(zflags); /* flags needs to be verified and we also need to verify whether the next * thing we get is ';'. After that we require an 'm' or somethign else * where 'm' stands for members and anything else should be an array. If @@ -2018,13 +2018,13 @@ PHP_MINIT_FUNCTION(spl_array) REGISTER_SPL_IMPLEMENTS(RecursiveArrayIterator, RecursiveIterator); spl_ce_RecursiveArrayIterator->get_iterator = spl_array_get_iterator; - REGISTER_SPL_CLASS_CONST_LONG(ArrayObject, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); - REGISTER_SPL_CLASS_CONST_LONG(ArrayObject, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); + REGISTER_SPL_CLASS_CONST_INT(ArrayObject, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); + REGISTER_SPL_CLASS_CONST_INT(ArrayObject, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); - REGISTER_SPL_CLASS_CONST_LONG(ArrayIterator, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); - REGISTER_SPL_CLASS_CONST_LONG(ArrayIterator, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); + REGISTER_SPL_CLASS_CONST_INT(ArrayIterator, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); + REGISTER_SPL_CLASS_CONST_INT(ArrayIterator, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveArrayIterator, "CHILD_ARRAYS_ONLY", SPL_ARRAY_CHILD_ARRAYS_ONLY); + REGISTER_SPL_CLASS_CONST_INT(RecursiveArrayIterator, "CHILD_ARRAYS_ONLY", SPL_ARRAY_CHILD_ARRAYS_ONLY); return SUCCESS; } diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index f9fe83e26d..f0c377bd33 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -767,7 +767,7 @@ SPL_METHOD(DirectoryIterator, key) } if (intern->u.dir.dirp) { - RETURN_LONG(intern->u.dir.index); + RETURN_INT(intern->u.dir.index); } else { RETURN_FALSE; } @@ -1445,7 +1445,7 @@ SPL_METHOD(FilesystemIterator, getFlags) return; } - RETURN_LONG(intern->flags & (SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK)); + RETURN_INT(intern->flags & (SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK)); } /* }}} */ /* {{{ proto void FilesystemIterator::setFlags(long $flags) @@ -1506,7 +1506,7 @@ SPL_METHOD(RecursiveDirectoryIterator, getChildren) if (SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) { RETURN_STRINGL(intern->file_name, intern->file_name_len); } else { - ZVAL_LONG(&zflags, intern->flags); + ZVAL_INT(&zflags, intern->flags); ZVAL_STRINGL(&zpath, intern->file_name, intern->file_name_len); spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, &zpath, &zflags TSRMLS_CC); zval_ptr_dtor(&zpath); @@ -1597,7 +1597,7 @@ SPL_METHOD(GlobIterator, count) } if (intern->u.dir.dirp && php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) { - RETURN_LONG(php_glob_stream_get_count(intern->u.dir.dirp, NULL)); + RETURN_INT(php_glob_stream_get_count(intern->u.dir.dirp, NULL)); } else { /* should not happen */ php_error_docref(NULL TSRMLS_CC, E_ERROR, "GlobIterator lost glob state"); @@ -1686,7 +1686,7 @@ static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval * { spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC); - ZVAL_LONG(key, object->u.dir.index); + ZVAL_INT(key, object->u.dir.index); } /* }}} */ @@ -2177,8 +2177,8 @@ static int spl_filesystem_file_read_line_ex(zval * this_ptr, spl_filesystem_obje } spl_filesystem_file_free_line(intern TSRMLS_CC); if (Z_TYPE(retval) == IS_STRING) { - intern->u.file.current_line = estrndup(Z_STRVAL(retval), Z_STRLEN(retval)); - intern->u.file.current_line_len = Z_STRLEN(retval); + intern->u.file.current_line = estrndup(Z_STRVAL(retval), Z_STRSIZE(retval)); + intern->u.file.current_line_len = Z_STRSIZE(retval); } else { ZVAL_ZVAL(&intern->u.file.current_zval, &retval, 1, 0); } @@ -2199,7 +2199,7 @@ static int spl_filesystem_file_is_empty_line(spl_filesystem_object *intern TSRML } else if (!Z_ISUNDEF(intern->u.file.current_zval)) { switch(Z_TYPE(intern->u.file.current_zval)) { case IS_STRING: - return Z_STRLEN(intern->u.file.current_zval) == 0; + return Z_STRSIZE(intern->u.file.current_zval) == 0; case IS_ARRAY: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) && zend_hash_num_elements(Z_ARRVAL(intern->u.file.current_zval)) == 1) { @@ -2210,7 +2210,7 @@ static int spl_filesystem_file_is_empty_line(spl_filesystem_object *intern TSRML idx++; } first = &Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val; - return Z_TYPE_P(first) == IS_STRING && Z_STRLEN_P(first) == 0; + return Z_TYPE_P(first) == IS_STRING && Z_STRSIZE_P(first) == 0; } return zend_hash_num_elements(Z_ARRVAL(intern->u.file.current_zval)) == 0; case IS_NULL: @@ -2463,7 +2463,7 @@ SPL_METHOD(SplFileObject, key) if (!intern->current_line) { spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC); } */ - RETURN_LONG(intern->u.file.current_line_num); + RETURN_INT(intern->u.file.current_line_num); } /* }}} */ /* {{{ proto void SplFileObject::next() @@ -2504,7 +2504,7 @@ SPL_METHOD(SplFileObject, getFlags) return; } - RETURN_LONG(intern->flags & SPL_FILE_OBJECT_MASK); + RETURN_INT(intern->flags & SPL_FILE_OBJECT_MASK); } /* }}} */ /* {{{ proto void SplFileObject::setMaxLineLen(int max_len) @@ -2537,7 +2537,7 @@ SPL_METHOD(SplFileObject, getMaxLineLen) return; } - RETURN_LONG((long)intern->u.file.max_line_len); + RETURN_INT((long)intern->u.file.max_line_len); } /* }}} */ /* {{{ proto bool SplFileObject::hasChildren() @@ -2649,7 +2649,7 @@ SPL_METHOD(SplFileObject, fputcsv) break; } ret = php_fputcsv(intern->u.file.stream, fields, delimiter, enclosure, escape TSRMLS_CC); - RETURN_LONG(ret); + RETURN_INT(ret); } } /* }}} */ @@ -2752,7 +2752,7 @@ SPL_METHOD(SplFileObject, ftell) if (ret == -1) { RETURN_FALSE; } else { - RETURN_LONG(ret); + RETURN_INT(ret); } } /* }}} */ @@ -2773,7 +2773,7 @@ SPL_METHOD(SplFileObject, fseek) } spl_filesystem_file_free_line(intern TSRMLS_CC); - RETURN_LONG(php_stream_seek(intern->u.file.stream, pos, whence)); + RETURN_INT(php_stream_seek(intern->u.file.stream, pos, whence)); } /* }}} */ /* {{{ proto int SplFileObject::fgetc() @@ -2819,9 +2819,9 @@ SPL_METHOD(SplFileObject, fgetss) } if (intern->u.file.max_line_len > 0) { - ZVAL_LONG(&arg2, intern->u.file.max_line_len); + ZVAL_INT(&arg2, intern->u.file.max_line_len); } else { - ZVAL_LONG(&arg2, 1024); + ZVAL_INT(&arg2, 1024); } spl_filesystem_file_free_line(intern TSRMLS_CC); @@ -2841,7 +2841,7 @@ SPL_METHOD(SplFileObject, fpassthru) return; } - RETURN_LONG(php_stream_passthru(intern->u.file.stream)); + RETURN_INT(php_stream_passthru(intern->u.file.stream)); } /* }}} */ /* {{{ proto bool SplFileObject::fscanf(string format [, string ...]) @@ -2884,10 +2884,10 @@ SPL_METHOD(SplFileObject, fwrite) str_len = MAX(0, MIN(length, str_len)); } if (!str_len) { - RETURN_LONG(0); + RETURN_INT(0); } - RETURN_LONG(php_stream_write(intern->u.file.stream, str, str_len)); + RETURN_INT(php_stream_write(intern->u.file.stream, str, str_len)); } /* }}} */ SPL_METHOD(SplFileObject, fread) @@ -2910,10 +2910,10 @@ SPL_METHOD(SplFileObject, fread) } ZVAL_STR(return_value, STR_ALLOC(length, 0)); - Z_STRLEN_P(return_value) = php_stream_read(intern->u.file.stream, Z_STRVAL_P(return_value), length); + Z_STRSIZE_P(return_value) = php_stream_read(intern->u.file.stream, Z_STRVAL_P(return_value), length); /* needed because recv/read/gzread doesnt put a null at the end*/ - Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0; + Z_STRVAL_P(return_value)[Z_STRSIZE_P(return_value)] = 0; } /* {{{ proto bool SplFileObject::fstat() @@ -3110,18 +3110,18 @@ PHP_MINIT_FUNCTION(spl_directory) REGISTER_SPL_SUB_CLASS_EX(FilesystemIterator, DirectoryIterator, spl_filesystem_object_new, spl_FilesystemIterator_functions); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_MODE_MASK", SPL_FILE_DIR_CURRENT_MODE_MASK); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_PATHNAME", SPL_FILE_DIR_CURRENT_AS_PATHNAME); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_FILEINFO", SPL_FILE_DIR_CURRENT_AS_FILEINFO); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_SELF", SPL_FILE_DIR_CURRENT_AS_SELF); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_MODE_MASK", SPL_FILE_DIR_KEY_MODE_MASK); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_AS_PATHNAME", SPL_FILE_DIR_KEY_AS_PATHNAME); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "FOLLOW_SYMLINKS", SPL_FILE_DIR_FOLLOW_SYMLINKS); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_AS_FILENAME", SPL_FILE_DIR_KEY_AS_FILENAME); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "NEW_CURRENT_AND_KEY", SPL_FILE_DIR_KEY_AS_FILENAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "OTHER_MODE_MASK", SPL_FILE_DIR_OTHERS_MASK); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "SKIP_DOTS", SPL_FILE_DIR_SKIPDOTS); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "UNIX_PATHS", SPL_FILE_DIR_UNIXPATHS); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_MODE_MASK", SPL_FILE_DIR_CURRENT_MODE_MASK); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_AS_PATHNAME", SPL_FILE_DIR_CURRENT_AS_PATHNAME); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_AS_FILEINFO", SPL_FILE_DIR_CURRENT_AS_FILEINFO); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_AS_SELF", SPL_FILE_DIR_CURRENT_AS_SELF); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "KEY_MODE_MASK", SPL_FILE_DIR_KEY_MODE_MASK); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "KEY_AS_PATHNAME", SPL_FILE_DIR_KEY_AS_PATHNAME); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "FOLLOW_SYMLINKS", SPL_FILE_DIR_FOLLOW_SYMLINKS); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "KEY_AS_FILENAME", SPL_FILE_DIR_KEY_AS_FILENAME); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "NEW_CURRENT_AND_KEY", SPL_FILE_DIR_KEY_AS_FILENAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "OTHER_MODE_MASK", SPL_FILE_DIR_OTHERS_MASK); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "SKIP_DOTS", SPL_FILE_DIR_SKIPDOTS); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "UNIX_PATHS", SPL_FILE_DIR_UNIXPATHS); spl_ce_FilesystemIterator->get_iterator = spl_filesystem_tree_get_iterator; @@ -3140,10 +3140,10 @@ PHP_MINIT_FUNCTION(spl_directory) REGISTER_SPL_IMPLEMENTS(SplFileObject, RecursiveIterator); REGISTER_SPL_IMPLEMENTS(SplFileObject, SeekableIterator); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "DROP_NEW_LINE", SPL_FILE_OBJECT_DROP_NEW_LINE); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_AHEAD", SPL_FILE_OBJECT_READ_AHEAD); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "SKIP_EMPTY", SPL_FILE_OBJECT_SKIP_EMPTY); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_CSV", SPL_FILE_OBJECT_READ_CSV); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "DROP_NEW_LINE", SPL_FILE_OBJECT_DROP_NEW_LINE); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "READ_AHEAD", SPL_FILE_OBJECT_READ_AHEAD); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "SKIP_EMPTY", SPL_FILE_OBJECT_SKIP_EMPTY); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "READ_CSV", SPL_FILE_OBJECT_READ_CSV); REGISTER_SPL_SUB_CLASS_EX(SplTempFileObject, SplFileObject, spl_filesystem_object_new_check, spl_SplTempFileObject_functions); return SUCCESS; diff --git a/ext/spl/spl_dllist.c b/ext/spl/spl_dllist.c index 09d874645d..e6dcc53691 100644 --- a/ext/spl/spl_dllist.c +++ b/ext/spl/spl_dllist.c @@ -484,8 +484,8 @@ static int spl_dllist_object_count_elements(zval *object, long *count TSRMLS_DC) if (!Z_ISUNDEF(rv)) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long) Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (long) Z_IVAL(intern->retval); return SUCCESS; } *count = 0; @@ -520,7 +520,7 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "flags", sizeof("flags")-1 TSRMLS_CC); - ZVAL_LONG(&tmp, intern->flags); + ZVAL_INT(&tmp, intern->flags); zend_hash_add(intern->debug_info, pnstr, &tmp); STR_RELEASE(pnstr); @@ -681,7 +681,7 @@ SPL_METHOD(SplDoublyLinkedList, count) } count = spl_ptr_llist_count(intern->llist); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -721,7 +721,7 @@ SPL_METHOD(SplDoublyLinkedList, setIteratorMode) intern->flags = value & SPL_DLLIST_IT_MASK; - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -737,7 +737,7 @@ SPL_METHOD(SplDoublyLinkedList, getIteratorMode) intern = Z_SPLDLLIST_P(getThis()); - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -754,7 +754,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetExists) } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); RETURN_BOOL(index >= 0 && index < intern->llist->count); } /* }}} */ @@ -773,7 +773,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetGet) } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); if (index < 0 || index >= intern->llist->count) { zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid or out of range", 0 TSRMLS_CC); @@ -811,7 +811,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetSet) long index; spl_ptr_llist_element *element; - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); if (index < 0 || index >= intern->llist->count) { zval_ptr_dtor(value); @@ -859,7 +859,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetUnset) } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); llist = intern->llist; if (index < 0 || index >= intern->llist->count) { @@ -1006,7 +1006,7 @@ static void spl_dllist_it_get_current_key(zend_object_iterator *iter, zval *key { spl_dllist_it *iterator = (spl_dllist_it *)iter; - ZVAL_LONG(key, iterator->traverse_position); + ZVAL_INT(key, iterator->traverse_position); } /* }}} */ @@ -1031,7 +1031,7 @@ SPL_METHOD(SplDoublyLinkedList, key) return; } - RETURN_LONG(intern->traverse_position); + RETURN_INT(intern->traverse_position); } /* }}} */ @@ -1127,7 +1127,7 @@ SPL_METHOD(SplDoublyLinkedList, serialize) PHP_VAR_SERIALIZE_INIT(var_hash); /* flags */ - ZVAL_LONG(&flags, intern->flags); + ZVAL_INT(&flags, intern->flags); php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC); zval_ptr_dtor(&flags); @@ -1181,12 +1181,12 @@ SPL_METHOD(SplDoublyLinkedList, unserialize) goto error; } - if (Z_TYPE(flags) != IS_LONG) { + if (Z_TYPE(flags) != IS_INT) { zval_ptr_dtor(&flags); goto error; } - intern->flags = Z_LVAL(flags); + intern->flags = Z_IVAL(flags); zval_ptr_dtor(&flags); /* elements */ @@ -1228,7 +1228,7 @@ SPL_METHOD(SplDoublyLinkedList, add) } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); if (index < 0 || index > intern->llist->count) { zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid or out of range", 0 TSRMLS_CC); @@ -1385,10 +1385,10 @@ PHP_MINIT_FUNCTION(spl_dllist) /* {{{ */ spl_handler_SplDoublyLinkedList.dtor_obj = zend_objects_destroy_object; spl_handler_SplDoublyLinkedList.free_obj = spl_dllist_object_free_storage; - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_LIFO", SPL_DLLIST_IT_LIFO); - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_FIFO", 0); - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_DELETE",SPL_DLLIST_IT_DELETE); - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_KEEP", 0); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_LIFO", SPL_DLLIST_IT_LIFO); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_FIFO", 0); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_DELETE",SPL_DLLIST_IT_DELETE); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_KEEP", 0); REGISTER_SPL_IMPLEMENTS(SplDoublyLinkedList, Iterator); REGISTER_SPL_IMPLEMENTS(SplDoublyLinkedList, Countable); diff --git a/ext/spl/spl_engine.c b/ext/spl/spl_engine.c index 0cfcb8ee18..0cd63dba78 100644 --- a/ext/spl/spl_engine.c +++ b/ext/spl/spl_engine.c @@ -40,7 +40,7 @@ PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC) } /* }}} */ -PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC) /* {{{ */ +PHPAPI long spl_offset_convert_to_int(zval *offset TSRMLS_DC) /* {{{ */ { ulong idx; @@ -52,8 +52,8 @@ PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC) /* {{{ */ break; case IS_DOUBLE: return (long)Z_DVAL_P(offset); - case IS_LONG: - return Z_LVAL_P(offset); + case IS_INT: + return Z_IVAL_P(offset); case IS_FALSE: return 0; case IS_TRUE: diff --git a/ext/spl/spl_engine.h b/ext/spl/spl_engine.h index 8c72ca9691..1ddf6bcff3 100644 --- a/ext/spl/spl_engine.h +++ b/ext/spl/spl_engine.h @@ -27,7 +27,7 @@ PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC); -PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC); +PHPAPI long spl_offset_convert_to_int(zval *offset TSRMLS_DC); /* {{{ spl_instantiate_arg_ex1 */ static inline int spl_instantiate_arg_ex1(zend_class_entry *pce, zval *retval, zval *arg1 TSRMLS_DC) diff --git a/ext/spl/spl_fixedarray.c b/ext/spl/spl_fixedarray.c index 62aaffbc3c..8b3486d627 100644 --- a/ext/spl/spl_fixedarray.c +++ b/ext/spl/spl_fixedarray.c @@ -337,10 +337,10 @@ static inline zval *spl_fixedarray_object_read_dimension_helper(spl_fixedarray_o return NULL; } - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -392,10 +392,10 @@ static inline void spl_fixedarray_object_write_dimension_helper(spl_fixedarray_o return; } - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -440,10 +440,10 @@ static inline void spl_fixedarray_object_unset_dimension_helper(spl_fixedarray_o { long index; - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -479,10 +479,10 @@ static inline int spl_fixedarray_object_has_dimension_helper(spl_fixedarray_obje long index; int retval; - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -539,8 +539,8 @@ static int spl_fixedarray_object_count_elements(zval *object, long *count TSRMLS if (!Z_ISUNDEF(rv)) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long) Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (long) Z_IVAL(intern->retval); return SUCCESS; } } else if (intern->array) { @@ -629,9 +629,9 @@ SPL_METHOD(SplFixedArray, count) intern = Z_SPLFIXEDARRAY_P(object); if (intern->array) { - RETURN_LONG(intern->array->size); + RETURN_INT(intern->array->size); } - RETURN_LONG(0); + RETURN_INT(0); } /* }}} */ @@ -747,9 +747,9 @@ SPL_METHOD(SplFixedArray, getSize) intern = Z_SPLFIXEDARRAY_P(object); if (intern->array) { - RETURN_LONG(intern->array->size); + RETURN_INT(intern->array->size); } - RETURN_LONG(0); + RETURN_INT(0); } /* }}} */ @@ -895,7 +895,7 @@ static zval *spl_fixedarray_it_get_current_data(zend_object_iterator *iter TSRML } else { zval *data; - ZVAL_LONG(&zindex, object->current); + ZVAL_INT(&zindex, object->current); data = spl_fixedarray_object_read_dimension_helper(object, &zindex TSRMLS_CC); zval_ptr_dtor(&zindex); @@ -915,7 +915,7 @@ static void spl_fixedarray_it_get_current_key(zend_object_iterator *iter, zval * if (object->flags & SPL_FIXEDARRAY_OVERLOADED_KEY) { zend_user_it_get_current_key(iter, key TSRMLS_CC); } else { - ZVAL_LONG(key, object->current); + ZVAL_INT(key, object->current); } } /* }}} */ @@ -943,7 +943,7 @@ SPL_METHOD(SplFixedArray, key) return; } - RETURN_LONG(intern->current); + RETURN_INT(intern->current); } /* }}} */ @@ -1000,7 +1000,7 @@ SPL_METHOD(SplFixedArray, current) return; } - ZVAL_LONG(&zindex, intern->current); + ZVAL_INT(&zindex, intern->current); value = spl_fixedarray_object_read_dimension_helper(intern, &zindex TSRMLS_CC); diff --git a/ext/spl/spl_functions.h b/ext/spl/spl_functions.h index 1d116ff783..568984f928 100644 --- a/ext/spl/spl_functions.h +++ b/ext/spl/spl_functions.h @@ -46,8 +46,8 @@ typedef zend_object* (*create_object_func_t)(zend_class_entry *class_type TSRMLS #define REGISTER_SPL_PROPERTY(class_name, prop_name, prop_flags) \ spl_register_property(spl_ce_ ## class_name, prop_name, sizeof(prop_name)-1, prop_flags TSRMLS_CC); -#define REGISTER_SPL_CLASS_CONST_LONG(class_name, const_name, value) \ - zend_declare_class_constant_long(spl_ce_ ## class_name, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); +#define REGISTER_SPL_CLASS_CONST_INT(class_name, const_name, value) \ + zend_declare_class_constant_int(spl_ce_ ## class_name, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); void spl_register_std_class(zend_class_entry ** ppce, char * class_name, create_object_func_t ctor, const zend_function_entry * function_list TSRMLS_DC); void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry * parent_ce, char * class_name, create_object_func_t ctor, const zend_function_entry * function_list TSRMLS_DC); diff --git a/ext/spl/spl_heap.c b/ext/spl/spl_heap.c index 90d78db6ee..90fa9af9ed 100644 --- a/ext/spl/spl_heap.c +++ b/ext/spl/spl_heap.c @@ -114,8 +114,8 @@ static int spl_ptr_heap_cmp_cb_helper(zval *object, spl_heap_object *heap_object return FAILURE; } - convert_to_long(&zresult); - *result = Z_LVAL(zresult); + convert_to_int(&zresult); + *result = Z_IVAL(zresult); zval_ptr_dtor(&zresult); @@ -165,7 +165,7 @@ static int spl_ptr_heap_zval_max_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { } compare_function(&result, a, b TSRMLS_CC); - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -189,7 +189,7 @@ static int spl_ptr_heap_zval_min_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { } compare_function(&result, b, a TSRMLS_CC); - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -220,7 +220,7 @@ static int spl_ptr_pqueue_zval_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { / } compare_function(&result, a_priority_p, b_priority_p TSRMLS_CC); - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -493,8 +493,8 @@ static int spl_heap_object_count_elements(zval *object, long *count TSRMLS_DC) / if (!Z_ISUNDEF(rv)) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long) Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (long) Z_IVAL(intern->retval); return SUCCESS; } *count = 0; @@ -529,7 +529,7 @@ static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zv zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); pnstr = spl_gen_private_prop_name(ce, "flags", sizeof("flags")-1 TSRMLS_CC); - ZVAL_LONG(&tmp, intern->flags); + ZVAL_INT(&tmp, intern->flags); zend_hash_update(intern->debug_info, pnstr, &tmp); STR_RELEASE(pnstr); @@ -580,7 +580,7 @@ SPL_METHOD(SplHeap, count) } count = spl_ptr_heap_count(intern->heap); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -776,7 +776,7 @@ SPL_METHOD(SplPriorityQueue, setExtractFlags) intern->flags = value & SPL_PQUEUE_EXTR_MASK; - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -808,7 +808,7 @@ SPL_METHOD(SplPriorityQueue, compare) return; } - RETURN_LONG(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); + RETURN_INT(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); } /* }}} */ @@ -851,7 +851,7 @@ SPL_METHOD(SplMinHeap, compare) return; } - RETURN_LONG(spl_ptr_heap_zval_min_cmp(a, b, NULL TSRMLS_CC)); + RETURN_INT(spl_ptr_heap_zval_min_cmp(a, b, NULL TSRMLS_CC)); } /* }}} */ @@ -865,7 +865,7 @@ SPL_METHOD(SplMaxHeap, compare) return; } - RETURN_LONG(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); + RETURN_INT(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); } /* }}} */ @@ -934,7 +934,7 @@ static void spl_heap_it_get_current_key(zend_object_iterator *iter, zval *key TS { spl_heap_object *object = Z_SPLHEAP_P(&iter->data); - ZVAL_LONG(key, object->heap->count - 1); + ZVAL_INT(key, object->heap->count - 1); } /* }}} */ @@ -966,7 +966,7 @@ SPL_METHOD(SplHeap, key) return; } - RETURN_LONG(intern->heap->count - 1); + RETURN_INT(intern->heap->count - 1); } /* }}} */ @@ -1226,9 +1226,9 @@ PHP_MINIT_FUNCTION(spl_heap) /* {{{ */ spl_ce_SplPriorityQueue->get_iterator = spl_pqueue_get_iterator; - REGISTER_SPL_CLASS_CONST_LONG(SplPriorityQueue, "EXTR_BOTH", SPL_PQUEUE_EXTR_BOTH); - REGISTER_SPL_CLASS_CONST_LONG(SplPriorityQueue, "EXTR_PRIORITY", SPL_PQUEUE_EXTR_PRIORITY); - REGISTER_SPL_CLASS_CONST_LONG(SplPriorityQueue, "EXTR_DATA", SPL_PQUEUE_EXTR_DATA); + REGISTER_SPL_CLASS_CONST_INT(SplPriorityQueue, "EXTR_BOTH", SPL_PQUEUE_EXTR_BOTH); + REGISTER_SPL_CLASS_CONST_INT(SplPriorityQueue, "EXTR_PRIORITY", SPL_PQUEUE_EXTR_PRIORITY); + REGISTER_SPL_CLASS_CONST_INT(SplPriorityQueue, "EXTR_DATA", SPL_PQUEUE_EXTR_DATA); return SUCCESS; } diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c index e503f9b581..1c8c942753 100644 --- a/ext/spl/spl_iterators.c +++ b/ext/spl/spl_iterators.c @@ -228,7 +228,7 @@ static void spl_recursive_it_get_current_key(zend_object_iterator *iter, zval *k if (sub_iter->funcs->get_current_key) { sub_iter->funcs->get_current_key(sub_iter, key TSRMLS_CC); } else { - ZVAL_LONG(key, iter->index); + ZVAL_INT(key, iter->index); } } @@ -496,7 +496,7 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla if (user_caching_it_flags) { ZVAL_ZVAL(&caching_it_flags, user_caching_it_flags, 1, 0); } else { - ZVAL_LONG(&caching_it_flags, CIT_CATCH_GET_CHILD); + ZVAL_INT(&caching_it_flags, CIT_CATCH_GET_CHILD); } spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &caching_it, iterator, &caching_it_flags TSRMLS_CC); zval_ptr_dtor(&caching_it_flags); @@ -695,7 +695,7 @@ SPL_METHOD(RecursiveIteratorIterator, getDepth) return; } - RETURN_LONG(object->level); + RETURN_INT(object->level); } /* }}} */ /* {{{ proto RecursiveIterator RecursiveIteratorIterator::getSubIterator([int level]) @@ -871,7 +871,7 @@ SPL_METHOD(RecursiveIteratorIterator, getMaxDepth) if (object->max_depth == -1) { RETURN_FALSE; } else { - RETURN_LONG(object->max_depth); + RETURN_INT(object->max_depth); } } /* }}} */ @@ -1222,15 +1222,15 @@ SPL_METHOD(RecursiveTreeIterator, current) } spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC); - str = STR_ALLOC(Z_STRLEN(prefix) + Z_STRLEN(entry) + Z_STRLEN(postfix), 0); + str = STR_ALLOC(Z_STRSIZE(prefix) + Z_STRSIZE(entry) + Z_STRSIZE(postfix), 0); ptr = str->val; - memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix)); - ptr += Z_STRLEN(prefix); - memcpy(ptr, Z_STRVAL(entry), Z_STRLEN(entry)); - ptr += Z_STRLEN(entry); - memcpy(ptr, Z_STRVAL(postfix), Z_STRLEN(postfix)); - ptr += Z_STRLEN(postfix); + memcpy(ptr, Z_STRVAL(prefix), Z_STRSIZE(prefix)); + ptr += Z_STRSIZE(prefix); + memcpy(ptr, Z_STRVAL(entry), Z_STRSIZE(entry)); + ptr += Z_STRSIZE(entry); + memcpy(ptr, Z_STRVAL(postfix), Z_STRSIZE(postfix)); + ptr += Z_STRSIZE(postfix); *ptr = 0; zval_ptr_dtor(&prefix); @@ -1278,15 +1278,15 @@ SPL_METHOD(RecursiveTreeIterator, key) spl_recursive_tree_iterator_get_prefix(object, &prefix TSRMLS_CC); spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC); - str = STR_ALLOC(Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix), 0); + str = STR_ALLOC(Z_STRSIZE(prefix) + Z_STRSIZE(key) + Z_STRSIZE(postfix), 0); ptr = str->val; - memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix)); - ptr += Z_STRLEN(prefix); - memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key)); - ptr += Z_STRLEN(key); - memcpy(ptr, Z_STRVAL(postfix), Z_STRLEN(postfix)); - ptr += Z_STRLEN(postfix); + memcpy(ptr, Z_STRVAL(prefix), Z_STRSIZE(prefix)); + ptr += Z_STRSIZE(prefix); + memcpy(ptr, Z_STRVAL(key), Z_STRSIZE(key)); + ptr += Z_STRSIZE(key); + memcpy(ptr, Z_STRVAL(postfix), Z_STRSIZE(postfix)); + ptr += Z_STRSIZE(postfix); *ptr = 0; zval_ptr_dtor(&prefix); @@ -1709,7 +1709,7 @@ static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more T ZVAL_UNDEF(&intern->current.key); } } else { - ZVAL_LONG(&intern->current.key, intern->current.pos); + ZVAL_INT(&intern->current.key, intern->current.pos); } return EG(exception) ? FAILURE : SUCCESS; } @@ -2049,10 +2049,10 @@ SPL_METHOD(RegexIterator, accept) use_copy = zend_make_printable_zval(subject_ptr, &subject_copy TSRMLS_CC); if (use_copy) { subject = Z_STRVAL(subject_copy); - subject_len = Z_STRLEN(subject_copy); + subject_len = Z_STRSIZE(subject_copy); } else { subject = Z_STRVAL_P(subject_ptr); - subject_len = Z_STRLEN_P(subject_ptr); + subject_len = Z_STRSIZE_P(subject_ptr); } use_copy = 0; @@ -2151,7 +2151,7 @@ SPL_METHOD(RegexIterator, getMode) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->u.regex.mode); + RETURN_INT(intern->u.regex.mode); } /* }}} */ /* {{{ proto bool RegexIterator::setMode(int new_mode) @@ -2187,7 +2187,7 @@ SPL_METHOD(RegexIterator, getFlags) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->u.regex.flags); + RETURN_INT(intern->u.regex.flags); } /* }}} */ /* {{{ proto bool RegexIterator::setFlags(int new_flags) @@ -2219,7 +2219,7 @@ SPL_METHOD(RegexIterator, getPregFlags) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); if (intern->u.regex.use_flags) { - RETURN_LONG(intern->u.regex.preg_flags); + RETURN_INT(intern->u.regex.preg_flags); } else { return; } @@ -2486,7 +2486,7 @@ static inline void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS return; } if (pos != intern->current.pos && instanceof_function(intern->inner.ce, spl_ce_SeekableIterator TSRMLS_CC)) { - ZVAL_LONG(&zpos, pos); + ZVAL_INT(&zpos, pos); spl_dual_it_free(intern TSRMLS_CC); zend_call_method_with_1_params(&intern->inner.zobject, intern->inner.ce, NULL, "seek", NULL, &zpos); zval_ptr_dtor(&zpos); @@ -2568,7 +2568,7 @@ SPL_METHOD(LimitIterator, seek) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); spl_limit_it_seek(intern, pos TSRMLS_CC); - RETURN_LONG(intern->current.pos); + RETURN_INT(intern->current.pos); } /* }}} */ /* {{{ proto int LimitIterator::getPosition() @@ -2577,7 +2577,7 @@ SPL_METHOD(LimitIterator, getPosition) { spl_dual_it_object *intern; SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->current.pos); + RETURN_INT(intern->current.pos); } /* }}} */ ZEND_BEGIN_ARG_INFO(arginfo_seekable_it_seek, 0) @@ -2660,7 +2660,7 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC) return; } } else { - ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC); + ZVAL_INT(&zflags, intern->u.caching.flags & CIT_PUBLIC); spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, &zchildren, &zflags TSRMLS_CC); zval_ptr_dtor(&zchildren); } @@ -2929,7 +2929,7 @@ SPL_METHOD(CachingIterator, getFlags) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->u.caching.flags); + RETURN_INT(intern->u.caching.flags); } /* }}} */ @@ -2983,7 +2983,7 @@ SPL_METHOD(CachingIterator, count) return; } - RETURN_LONG(zend_hash_num_elements(HASH_OF(&intern->u.caching.zcache))); + RETURN_INT(zend_hash_num_elements(HASH_OF(&intern->u.caching.zcache))); } /* }}} */ @@ -3591,7 +3591,7 @@ PHP_FUNCTION(iterator_count) } if (spl_iterator_apply(obj, spl_iterator_count_apply, (void*)&count TSRMLS_CC) == SUCCESS) { - RETURN_LONG(count); + RETURN_INT(count); } } /* }}} */ @@ -3636,7 +3636,7 @@ PHP_FUNCTION(iterator_apply) apply_info.count = 0; zend_fcall_info_args(&apply_info.fci, apply_info.args TSRMLS_CC); if (spl_iterator_apply(apply_info.obj, spl_iterator_func_apply, (void*)&apply_info TSRMLS_CC) == SUCCESS) { - RETVAL_LONG(apply_info.count); + RETVAL_INT(apply_info.count); } else { RETVAL_FALSE; } @@ -3682,10 +3682,10 @@ PHP_MINIT_FUNCTION(spl_iterators) spl_ce_RecursiveIteratorIterator->get_iterator = spl_recursive_it_get_iterator; spl_ce_RecursiveIteratorIterator->iterator_funcs.funcs = &spl_recursive_it_iterator_funcs; - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "LEAVES_ONLY", RIT_LEAVES_ONLY); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "SELF_FIRST", RIT_SELF_FIRST); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "CHILD_FIRST", RIT_CHILD_FIRST); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "CATCH_GET_CHILD", RIT_CATCH_GET_CHILD); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "LEAVES_ONLY", RIT_LEAVES_ONLY); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "SELF_FIRST", RIT_SELF_FIRST); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "CHILD_FIRST", RIT_CHILD_FIRST); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "CATCH_GET_CHILD", RIT_CATCH_GET_CHILD); REGISTER_SPL_INTERFACE(OuterIterator); REGISTER_SPL_ITERATOR(OuterIterator); @@ -3718,12 +3718,12 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_IMPLEMENTS(CachingIterator, ArrayAccess); REGISTER_SPL_IMPLEMENTS(CachingIterator, Countable); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CALL_TOSTRING", CIT_CALL_TOSTRING); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CATCH_GET_CHILD", CIT_CATCH_GET_CHILD); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_KEY", CIT_TOSTRING_USE_KEY); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_CURRENT", CIT_TOSTRING_USE_CURRENT); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "CALL_TOSTRING", CIT_CALL_TOSTRING); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "CATCH_GET_CHILD", CIT_CATCH_GET_CHILD); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "TOSTRING_USE_KEY", CIT_TOSTRING_USE_KEY); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "TOSTRING_USE_CURRENT", CIT_TOSTRING_USE_CURRENT); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE); REGISTER_SPL_SUB_CLASS_EX(RecursiveCachingIterator, CachingIterator, spl_dual_it_new, spl_funcs_RecursiveCachingIterator); REGISTER_SPL_IMPLEMENTS(RecursiveCachingIterator, RecursiveIterator); @@ -3737,13 +3737,13 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_SUB_CLASS_EX(InfiniteIterator, IteratorIterator, spl_dual_it_new, spl_funcs_InfiniteIterator); #if HAVE_PCRE || HAVE_BUNDLED_PCRE REGISTER_SPL_SUB_CLASS_EX(RegexIterator, FilterIterator, spl_dual_it_new, spl_funcs_RegexIterator); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "USE_KEY", REGIT_USE_KEY); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "INVERT_MATCH",REGIT_INVERTED); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "MATCH", REGIT_MODE_MATCH); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "GET_MATCH", REGIT_MODE_GET_MATCH); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "ALL_MATCHES", REGIT_MODE_ALL_MATCHES); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "SPLIT", REGIT_MODE_SPLIT); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "REPLACE", REGIT_MODE_REPLACE); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "USE_KEY", REGIT_USE_KEY); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "INVERT_MATCH",REGIT_INVERTED); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "MATCH", REGIT_MODE_MATCH); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "GET_MATCH", REGIT_MODE_GET_MATCH); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "ALL_MATCHES", REGIT_MODE_ALL_MATCHES); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "SPLIT", REGIT_MODE_SPLIT); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "REPLACE", REGIT_MODE_REPLACE); REGISTER_SPL_PROPERTY(RegexIterator, "replacement", 0); REGISTER_SPL_SUB_CLASS_EX(RecursiveRegexIterator, RegexIterator, spl_dual_it_new, spl_funcs_RecursiveRegexIterator); REGISTER_SPL_IMPLEMENTS(RecursiveRegexIterator, RecursiveIterator); @@ -3756,14 +3756,14 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_ITERATOR(EmptyIterator); REGISTER_SPL_SUB_CLASS_EX(RecursiveTreeIterator, RecursiveIteratorIterator, spl_RecursiveTreeIterator_new, spl_funcs_RecursiveTreeIterator); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_CURRENT", RTIT_BYPASS_CURRENT); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_KEY", RTIT_BYPASS_KEY); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_LEFT", 0); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_MID_HAS_NEXT", 1); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_MID_LAST", 2); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_END_HAS_NEXT", 3); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_END_LAST", 4); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_RIGHT", 5); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "BYPASS_CURRENT", RTIT_BYPASS_CURRENT); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "BYPASS_KEY", RTIT_BYPASS_KEY); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_LEFT", 0); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_MID_HAS_NEXT", 1); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_MID_LAST", 2); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_END_HAS_NEXT", 3); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_END_LAST", 4); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_RIGHT", 5); return SUCCESS; } diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c index bdfff35506..fcc6af387c 100644 --- a/ext/spl/spl_observer.c +++ b/ext/spl/spl_observer.c @@ -397,7 +397,7 @@ static int spl_object_storage_compare_info(zval *e1, zval *e2 TSRMLS_DC) /* {{{ return 1; } - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -526,7 +526,7 @@ SPL_METHOD(SplObjectStorage, addAll) spl_object_storage_addall(intern, getThis(), other TSRMLS_CC); - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ /* {{{ proto bool SplObjectStorage::removeAll(SplObjectStorage $os) @@ -554,7 +554,7 @@ SPL_METHOD(SplObjectStorage, removeAll) zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos); intern->index = 0; - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ /* {{{ proto bool SplObjectStorage::removeAllExcept(SplObjectStorage $os) @@ -581,7 +581,7 @@ SPL_METHOD(SplObjectStorage, removeAllExcept) zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos); intern->index = 0; - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ @@ -617,11 +617,11 @@ SPL_METHOD(SplObjectStorage, count) ret += php_count_recursive(element, mode TSRMLS_CC); } ZEND_HASH_FOREACH_END(); - RETURN_LONG(ret); + RETURN_INT(ret); return; } - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ /* {{{ proto void SplObjectStorage::rewind() @@ -661,7 +661,7 @@ SPL_METHOD(SplObjectStorage, key) return; } - RETURN_LONG(intern->index); + RETURN_INT(intern->index); } /* }}} */ /* {{{ proto mixed SplObjectStorage::current() @@ -751,7 +751,7 @@ SPL_METHOD(SplObjectStorage, serialize) /* storage */ smart_str_appendl(&buf, "x:", 2); - ZVAL_LONG(&flags, zend_hash_num_elements(&intern->storage)); + ZVAL_INT(&flags, zend_hash_num_elements(&intern->storage)); php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC); zval_ptr_dtor(&flags); @@ -822,13 +822,13 @@ SPL_METHOD(SplObjectStorage, unserialize) if (!php_var_unserialize(&pcount, &p, s + buf_len, &var_hash TSRMLS_CC)) { goto outexcept; } - if (Z_TYPE(pcount) != IS_LONG) { + if (Z_TYPE(pcount) != IS_INT) { zval_ptr_dtor(&pcount); goto outexcept; } --p; /* for ';' */ - count = Z_LVAL(pcount); + count = Z_IVAL(pcount); while (count-- > 0) { spl_SplObjectStorageElement *pelement; @@ -1011,7 +1011,7 @@ SPL_METHOD(MultipleIterator, getFlags) if (zend_parse_parameters_none() == FAILURE) { return; } - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -1045,7 +1045,7 @@ SPL_METHOD(MultipleIterator, attachIterator) spl_SplObjectStorageElement *element; zval compare_result; - if (Z_TYPE_P(info) != IS_LONG && Z_TYPE_P(info) != IS_STRING) { + if (Z_TYPE_P(info) != IS_INT && Z_TYPE_P(info) != IS_STRING) { zend_throw_exception(spl_ce_InvalidArgumentException, "Info must be NULL, integer or string", 0 TSRMLS_CC); return; } @@ -1203,8 +1203,8 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_ if (intern->flags & MIT_KEYS_ASSOC) { switch (Z_TYPE(element->inf)) { - case IS_LONG: - add_index_zval(return_value, Z_LVAL(element->inf), &retval); + case IS_INT: + add_index_zval(return_value, Z_IVAL(element->inf), &retval); break; case IS_STRING: zend_hash_update(Z_ARRVAL_P(return_value), Z_STR(element->inf), &retval); @@ -1312,10 +1312,10 @@ PHP_MINIT_FUNCTION(spl_observer) REGISTER_SPL_STD_CLASS_EX(MultipleIterator, spl_SplObjectStorage_new, spl_funcs_MultipleIterator); REGISTER_SPL_ITERATOR(MultipleIterator); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ANY", MIT_NEED_ANY); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ALL", MIT_NEED_ALL); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_KEYS_NUMERIC", MIT_KEYS_NUMERIC); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_KEYS_ASSOC", MIT_KEYS_ASSOC); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_NEED_ANY", MIT_NEED_ANY); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_NEED_ALL", MIT_NEED_ALL); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_KEYS_NUMERIC", MIT_KEYS_NUMERIC); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_KEYS_ASSOC", MIT_KEYS_ASSOC); return SUCCESS; } diff --git a/ext/standard/array.c b/ext/standard/array.c index a177ee7e0f..1675562a50 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -99,33 +99,33 @@ PHP_MINIT_FUNCTION(array) /* {{{ */ { ZEND_INIT_MODULE_GLOBALS(array, php_array_init_globals, NULL); - REGISTER_LONG_CONSTANT("EXTR_OVERWRITE", EXTR_OVERWRITE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_SKIP", EXTR_SKIP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_SAME", EXTR_PREFIX_SAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_ALL", EXTR_PREFIX_ALL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_INVALID", EXTR_PREFIX_INVALID, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_IF_EXISTS", EXTR_PREFIX_IF_EXISTS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_IF_EXISTS", EXTR_IF_EXISTS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_REFS", EXTR_REFS, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("SORT_ASC", PHP_SORT_ASC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_DESC", PHP_SORT_DESC, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("SORT_REGULAR", PHP_SORT_REGULAR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_NUMERIC", PHP_SORT_NUMERIC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_STRING", PHP_SORT_STRING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_LOCALE_STRING", PHP_SORT_LOCALE_STRING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_NATURAL", PHP_SORT_NATURAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_FLAG_CASE", PHP_SORT_FLAG_CASE, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("CASE_LOWER", CASE_LOWER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CASE_UPPER", CASE_UPPER, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("COUNT_NORMAL", COUNT_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("COUNT_RECURSIVE", COUNT_RECURSIVE, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("ARRAY_FILTER_USE_BOTH", ARRAY_FILTER_USE_BOTH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ARRAY_FILTER_USE_KEY", ARRAY_FILTER_USE_KEY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_OVERWRITE", EXTR_OVERWRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_SKIP", EXTR_SKIP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_SAME", EXTR_PREFIX_SAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_ALL", EXTR_PREFIX_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_INVALID", EXTR_PREFIX_INVALID, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_IF_EXISTS", EXTR_PREFIX_IF_EXISTS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_IF_EXISTS", EXTR_IF_EXISTS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_REFS", EXTR_REFS, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("SORT_ASC", PHP_SORT_ASC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_DESC", PHP_SORT_DESC, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("SORT_REGULAR", PHP_SORT_REGULAR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_NUMERIC", PHP_SORT_NUMERIC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_STRING", PHP_SORT_STRING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_LOCALE_STRING", PHP_SORT_LOCALE_STRING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_NATURAL", PHP_SORT_NATURAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_FLAG_CASE", PHP_SORT_FLAG_CASE, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("CASE_LOWER", CASE_LOWER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CASE_UPPER", CASE_UPPER, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("COUNT_NORMAL", COUNT_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("COUNT_RECURSIVE", COUNT_RECURSIVE, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("ARRAY_FILTER_USE_BOTH", ARRAY_FILTER_USE_BOTH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ARRAY_FILTER_USE_KEY", ARRAY_FILTER_USE_KEY, CONST_CS | CONST_PERSISTENT); return SUCCESS; } @@ -182,13 +182,13 @@ static int php_array_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ s = (Bucket *) b; if (f->key == NULL) { - ZVAL_LONG(&first, f->h); + ZVAL_INT(&first, f->h); } else { ZVAL_STR(&first, f->key); } if (s->key == 0) { - ZVAL_LONG(&second, s->h); + ZVAL_INT(&second, s->h); } else { ZVAL_STR(&second, s->key); } @@ -197,8 +197,8 @@ static int php_array_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ return 0; } - if (EXPECTED(Z_TYPE(result) == IS_LONG)) { - return ZEND_NORMALIZE_BOOL(Z_LVAL(result)); + if (EXPECTED(Z_TYPE(result) == IS_INT)) { + return ZEND_NORMALIZE_BOOL(Z_IVAL(result)); } else if (Z_TYPE(result) == IS_DOUBLE) { return ZEND_NORMALIZE_BOOL(Z_DVAL(result)); } @@ -306,7 +306,7 @@ PHP_FUNCTION(count) switch (Z_TYPE_P(array)) { case IS_NULL: - RETURN_LONG(0); + RETURN_INT(0); break; case IS_ARRAY: cnt = zend_hash_num_elements(Z_ARRVAL_P(array)); @@ -316,7 +316,7 @@ PHP_FUNCTION(count) cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC); } ZEND_HASH_FOREACH_END(); } - RETURN_LONG(cnt); + RETURN_INT(cnt); break; case IS_OBJECT: { #ifdef HAVE_SPL @@ -324,8 +324,8 @@ PHP_FUNCTION(count) #endif /* first, we check if the handler is defined */ if (Z_OBJ_HT_P(array)->count_elements) { - RETVAL_LONG(1); - if (SUCCESS == Z_OBJ_HT(*array)->count_elements(array, &Z_LVAL_P(return_value) TSRMLS_CC)) { + RETVAL_INT(1); + if (SUCCESS == Z_OBJ_HT(*array)->count_elements(array, &Z_IVAL_P(return_value) TSRMLS_CC)) { return; } } @@ -334,7 +334,7 @@ PHP_FUNCTION(count) if (Z_OBJ_HT_P(array)->get_class_entry && instanceof_function(Z_OBJCE_P(array), spl_ce_Countable TSRMLS_CC)) { zend_call_method_with_0_params(array, NULL, NULL, "count", &retval); if (Z_TYPE(retval) != IS_UNDEF) { - RETVAL_LONG(zval_get_long(&retval)); + RETVAL_INT(zval_get_long(&retval)); zval_ptr_dtor(&retval); } return; @@ -342,7 +342,7 @@ PHP_FUNCTION(count) #endif } default: - RETURN_LONG(1); + RETURN_INT(1); break; } } @@ -378,8 +378,8 @@ static int php_array_data_compare(const void *a, const void *b TSRMLS_DC) /* {{{ return 0; } - if (EXPECTED(Z_TYPE(result) == IS_LONG)) { - return ZEND_NORMALIZE_BOOL(Z_LVAL(result)); + if (EXPECTED(Z_TYPE(result) == IS_INT)) { + return ZEND_NORMALIZE_BOOL(Z_IVAL(result)); } else if (Z_TYPE(result) == IS_DOUBLE) { return ZEND_NORMALIZE_BOOL(Z_DVAL(result)); } @@ -704,12 +704,12 @@ static int php_array_user_key_compare(const void *a, const void *b TSRMLS_DC) /* s = (Bucket *) b; if (f->key == NULL) { - ZVAL_LONG(&args[0], f->h); + ZVAL_INT(&args[0], f->h); } else { ZVAL_STR(&args[0], STR_COPY(f->key)); } if (s->key == NULL) { - ZVAL_LONG(&args[1], s->h); + ZVAL_INT(&args[1], s->h); } else { ZVAL_STR(&args[1], STR_COPY(s->key)); } @@ -1258,7 +1258,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ if (str_idx) { RETVAL_STR(STR_COPY(str_idx)); } else { - RETVAL_LONG(num_idx); + RETVAL_INT(num_idx); } return; } @@ -1273,7 +1273,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ if (str_idx) { RETVAL_STR(STR_COPY(str_idx)); } else { - RETVAL_LONG(num_idx); + RETVAL_INT(num_idx); } return; } @@ -1339,14 +1339,14 @@ static int php_valid_var_name(char *var_name, int var_name_len) /* {{{ */ PHPAPI int php_prefix_varname(zval *result, zval *prefix, char *var_name, int var_name_len, zend_bool add_underscore TSRMLS_DC) /* {{{ */ { - ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0)); - memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRLEN_P(prefix)); + ZVAL_NEW_STR(result, STR_ALLOC(Z_STRSIZE_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0)); + memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRSIZE_P(prefix)); if (add_underscore) { - Z_STRVAL_P(result)[Z_STRLEN_P(prefix)] = '_'; + Z_STRVAL_P(result)[Z_STRSIZE_P(prefix)] = '_'; } - memcpy(Z_STRVAL_P(result) + Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0), var_name, var_name_len + 1); + memcpy(Z_STRVAL_P(result) + Z_STRSIZE_P(prefix) + (add_underscore ? 1 : 0), var_name, var_name_len + 1); return SUCCESS; } @@ -1384,7 +1384,7 @@ PHP_FUNCTION(extract) if (prefix) { convert_to_string(prefix); - if (Z_STRLEN_P(prefix) && !php_valid_var_name(Z_STRVAL_P(prefix), Z_STRLEN_P(prefix))) { + if (Z_STRSIZE_P(prefix) && !php_valid_var_name(Z_STRVAL_P(prefix), Z_STRSIZE_P(prefix))) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "prefix is not a valid identifier"); return; } @@ -1403,9 +1403,9 @@ PHP_FUNCTION(extract) } else if (extract_type == EXTR_PREFIX_ALL || extract_type == EXTR_PREFIX_INVALID) { zval num; - ZVAL_LONG(&num, num_key); + ZVAL_INT(&num, num_key); convert_to_string(&num); - php_prefix_varname(&final_name, prefix, Z_STRVAL(num), Z_STRLEN(num), 1 TSRMLS_CC); + php_prefix_varname(&final_name, prefix, Z_STRVAL(num), Z_STRSIZE(num), 1 TSRMLS_CC); zval_dtor(&num); } else { continue; @@ -1462,7 +1462,7 @@ PHP_FUNCTION(extract) break; } - if (Z_TYPE(final_name) != IS_NULL && php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) { + if (Z_TYPE(final_name) != IS_NULL && php_valid_var_name(Z_STRVAL(final_name), Z_STRSIZE(final_name))) { if (extract_refs) { zval *orig_var; @@ -1487,7 +1487,7 @@ PHP_FUNCTION(extract) zval_dtor(&final_name); } ZEND_HASH_FOREACH_END(); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -1603,9 +1603,9 @@ PHP_FUNCTION(array_fill_keys) ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(keys), entry) { ZVAL_DEREF(entry); - if (Z_TYPE_P(entry) == IS_LONG) { + if (Z_TYPE_P(entry) == IS_INT) { zval_add_ref(val); - zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), val); + zend_hash_index_update(Z_ARRVAL_P(return_value), Z_IVAL_P(entry), val); } else { zend_string *key = zval_get_string(entry); @@ -1632,7 +1632,7 @@ PHP_FUNCTION(range) if (zstep) { if (Z_TYPE_P(zstep) == IS_DOUBLE || - (Z_TYPE_P(zstep) == IS_STRING && is_numeric_string(Z_STRVAL_P(zstep), Z_STRLEN_P(zstep), NULL, NULL, 0) == IS_DOUBLE) + (Z_TYPE_P(zstep) == IS_STRING && is_numeric_string(Z_STRVAL_P(zstep), Z_STRSIZE_P(zstep), NULL, NULL, 0) == IS_DOUBLE) ) { is_step_double = 1; } @@ -1649,17 +1649,17 @@ PHP_FUNCTION(range) array_init(return_value); /* If the range is given as strings, generate an array of characters. */ - if (Z_TYPE_P(zlow) == IS_STRING && Z_TYPE_P(zhigh) == IS_STRING && Z_STRLEN_P(zlow) >= 1 && Z_STRLEN_P(zhigh) >= 1) { + if (Z_TYPE_P(zlow) == IS_STRING && Z_TYPE_P(zhigh) == IS_STRING && Z_STRSIZE_P(zlow) >= 1 && Z_STRSIZE_P(zhigh) >= 1) { int type1, type2; unsigned char low, high; long lstep = (long) step; - type1 = is_numeric_string(Z_STRVAL_P(zlow), Z_STRLEN_P(zlow), NULL, NULL, 0); - type2 = is_numeric_string(Z_STRVAL_P(zhigh), Z_STRLEN_P(zhigh), NULL, NULL, 0); + type1 = is_numeric_string(Z_STRVAL_P(zlow), Z_STRSIZE_P(zlow), NULL, NULL, 0); + type2 = is_numeric_string(Z_STRVAL_P(zhigh), Z_STRSIZE_P(zhigh), NULL, NULL, 0); if (type1 == IS_DOUBLE || type2 == IS_DOUBLE || is_step_double) { goto double_str; - } else if (type1 == IS_LONG || type2 == IS_LONG) { + } else if (type1 == IS_INT || type2 == IS_INT) { goto long_str; } @@ -1748,14 +1748,14 @@ long_str: high = zval_get_double(zhigh); lstep = (long) step; - Z_TYPE_INFO(tmp) = IS_LONG; + Z_TYPE_INFO(tmp) = IS_INT; if (low > high) { /* Negative steps */ if (low - high < lstep || lstep <= 0) { err = 1; goto err; } for (; low >= high; low -= lstep) { - Z_LVAL(tmp) = (long)low; + Z_IVAL(tmp) = (long)low; zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp); } } else if (high > low) { /* Positive steps */ @@ -1764,11 +1764,11 @@ long_str: goto err; } for (; low <= high; low += lstep) { - Z_LVAL(tmp) = (long)low; + Z_IVAL(tmp) = (long)low; zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp); } } else { - Z_LVAL(tmp) = (long)low; + Z_IVAL(tmp) = (long)low; zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp); } } @@ -1985,7 +1985,7 @@ PHP_FUNCTION(array_push) } /* Clean up and return the number of values in the stack */ - RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack))); + RETVAL_INT(zend_hash_num_elements(Z_ARRVAL_P(stack))); } /* }}} */ @@ -2129,7 +2129,7 @@ PHP_FUNCTION(array_unshift) zend_hash_destroy(&old_hash); /* Clean up and return the number of elements in the stack */ - RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack))); + RETVAL_INT(zend_hash_num_elements(Z_ARRVAL_P(stack))); } /* }}} */ @@ -2604,7 +2604,7 @@ PHP_FUNCTION(array_keys) if (str_idx) { ZVAL_STR(&new_val, STR_COPY(str_idx)); } else { - ZVAL_LONG(&new_val, num_idx); + ZVAL_INT(&new_val, num_idx); } zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &new_val); } @@ -2653,21 +2653,21 @@ PHP_FUNCTION(array_count_values) /* Go through input array and add values to the return array */ myht = Z_ARRVAL_P(input); ZEND_HASH_FOREACH_VAL(myht, entry) { - if (Z_TYPE_P(entry) == IS_LONG) { - if ((tmp = zend_hash_index_find(Z_ARRVAL_P(return_value), Z_LVAL_P(entry))) == NULL) { + if (Z_TYPE_P(entry) == IS_INT) { + if ((tmp = zend_hash_index_find(Z_ARRVAL_P(return_value), Z_IVAL_P(entry))) == NULL) { zval data; - ZVAL_LONG(&data, 1); - zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data); + ZVAL_INT(&data, 1); + zend_hash_index_update(Z_ARRVAL_P(return_value), Z_IVAL_P(entry), &data); } else { - Z_LVAL_P(tmp)++; + Z_IVAL_P(tmp)++; } } else if (Z_TYPE_P(entry) == IS_STRING) { if ((tmp = zend_symtable_find(Z_ARRVAL_P(return_value), Z_STR_P(entry))) == NULL) { zval data; - ZVAL_LONG(&data, 1); + ZVAL_INT(&data, 1); zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data); } else { - Z_LVAL_P(tmp)++; + Z_IVAL_P(tmp)++; } } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only count STRING and INTEGER values!"); @@ -2684,9 +2684,9 @@ zend_bool array_column_param_helper(zval *param, const char *name TSRMLS_DC) { switch (Z_TYPE_P(param)) { case IS_DOUBLE: - convert_to_long_ex(param); + convert_to_int_ex(param); /* fallthrough */ - case IS_LONG: + case IS_INT: return 1; case IS_OBJECT: @@ -2736,8 +2736,8 @@ PHP_FUNCTION(array_column) } else if ((Z_TYPE_P(zcolumn) == IS_STRING) && ((zcolval = zend_hash_find(ht, Z_STR_P(zcolumn))) == NULL)) { continue; - } else if ((Z_TYPE_P(zcolumn) == IS_LONG) && - ((zcolval = zend_hash_index_find(ht, Z_LVAL_P(zcolumn))) == NULL)) { + } else if ((Z_TYPE_P(zcolumn) == IS_INT) && + ((zcolval = zend_hash_index_find(ht, Z_IVAL_P(zcolumn))) == NULL)) { continue; } @@ -2746,8 +2746,8 @@ PHP_FUNCTION(array_column) */ if (zkey && (Z_TYPE_P(zkey) == IS_STRING)) { zkeyval = zend_hash_find(ht, Z_STR_P(zkey)); - } else if (zkey && (Z_TYPE_P(zkey) == IS_LONG)) { - zkeyval = zend_hash_index_find(ht, Z_LVAL_P(zkey)); + } else if (zkey && (Z_TYPE_P(zkey) == IS_INT)) { + zkeyval = zend_hash_index_find(ht, Z_IVAL_P(zkey)); } if (Z_REFCOUNTED_P(zcolval)) { @@ -2755,8 +2755,8 @@ PHP_FUNCTION(array_column) } if (zkeyval && Z_TYPE_P(zkeyval) == IS_STRING) { zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(zkeyval), zcolval); - } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_LONG) { - add_index_zval(return_value, Z_LVAL_P(zkeyval), zcolval); + } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_INT) { + add_index_zval(return_value, Z_IVAL_P(zkeyval), zcolval); } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_OBJECT) { SEPARATE_ZVAL(zkeyval); convert_to_string(zkeyval); @@ -2884,18 +2884,18 @@ PHP_FUNCTION(array_flip) array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array))); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) { - if (Z_TYPE_P(entry) == IS_LONG) { + if (Z_TYPE_P(entry) == IS_INT) { if (str_idx) { ZVAL_STR(&data, STR_COPY(str_idx)); } else { - ZVAL_LONG(&data, num_idx); + ZVAL_INT(&data, num_idx); } - zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data); + zend_hash_index_update(Z_ARRVAL_P(return_value), Z_IVAL_P(entry), &data); } else if (Z_TYPE_P(entry) == IS_STRING) { if (str_idx) { ZVAL_STR(&data, STR_COPY(str_idx)); } else { - ZVAL_LONG(&data, num_idx); + ZVAL_INT(&data, num_idx); } zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data); } else { @@ -3035,8 +3035,8 @@ static int zval_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */ return ZEND_NORMALIZE_BOOL(Z_DVAL(result)); } - convert_to_long(&result); - return ZEND_NORMALIZE_BOOL(Z_LVAL(result)); + convert_to_int(&result); + return ZEND_NORMALIZE_BOOL(Z_IVAL(result)); } /* }}} */ @@ -3935,7 +3935,7 @@ PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC) /* {{{ php_set_compare_func(ARRAYG(multisort_flags)[MULTISORT_TYPE][r] TSRMLS_CC); ARRAYG(compare_func)(&temp, &ab[r].val, &bb[r].val TSRMLS_CC); - result = ARRAYG(multisort_flags)[MULTISORT_ORDER][r] * Z_LVAL(temp); + result = ARRAYG(multisort_flags)[MULTISORT_ORDER][r] * Z_IVAL(temp); if (result != 0) { return result; } @@ -4008,14 +4008,14 @@ PHP_FUNCTION(array_multisort) for (k = 0; k < MULTISORT_LAST; k++) { parse_state[k] = 1; } - } else if (Z_TYPE_P(arg) == IS_LONG) { - switch (Z_LVAL_P(arg) & ~PHP_SORT_FLAG_CASE) { + } else if (Z_TYPE_P(arg) == IS_INT) { + switch (Z_IVAL_P(arg) & ~PHP_SORT_FLAG_CASE) { case PHP_SORT_ASC: case PHP_SORT_DESC: /* flag allowed here */ if (parse_state[MULTISORT_ORDER] == 1) { /* Save the flag and make sure then next arg is not the current flag. */ - sort_order = Z_LVAL(args[i]) == PHP_SORT_DESC ? -1 : 1; + sort_order = Z_IVAL(args[i]) == PHP_SORT_DESC ? -1 : 1; parse_state[MULTISORT_ORDER] = 0; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1); @@ -4033,7 +4033,7 @@ PHP_FUNCTION(array_multisort) /* flag allowed here */ if (parse_state[MULTISORT_TYPE] == 1) { /* Save the flag and make sure then next arg is not the current flag. */ - sort_type = Z_LVAL(args[i]); + sort_type = Z_IVAL(args[i]); parse_state[MULTISORT_TYPE] = 0; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1); @@ -4178,14 +4178,14 @@ PHP_FUNCTION(array_rand) if (string_key) { RETURN_STR(STR_COPY(string_key)); } else { - RETURN_LONG(num_key); + RETURN_INT(num_key); } } else { /* Append the result to the return value. */ if (string_key) { add_next_index_str(return_value, STR_COPY(string_key)); } else { - add_next_index_long(return_value, num_key); + add_next_index_int(return_value, num_key); } } num_req--; @@ -4207,7 +4207,7 @@ PHP_FUNCTION(array_sum) return; } - ZVAL_LONG(return_value, 0); + ZVAL_INT(return_value, 0); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), entry) { if (Z_TYPE_P(entry) == IS_ARRAY || Z_TYPE_P(entry) == IS_OBJECT) { @@ -4233,7 +4233,7 @@ PHP_FUNCTION(array_product) return; } - ZVAL_LONG(return_value, 1); + ZVAL_INT(return_value, 1); if (!zend_hash_num_elements(Z_ARRVAL_P(input))) { return; } @@ -4245,10 +4245,10 @@ PHP_FUNCTION(array_product) ZVAL_DUP(&entry_n, entry); convert_scalar_to_number(&entry_n TSRMLS_CC); - if (Z_TYPE(entry_n) == IS_LONG && Z_TYPE_P(return_value) == IS_LONG) { - dval = (double)Z_LVAL_P(return_value) * (double)Z_LVAL(entry_n); + if (Z_TYPE(entry_n) == IS_INT && Z_TYPE_P(return_value) == IS_INT) { + dval = (double)Z_IVAL_P(return_value) * (double)Z_IVAL(entry_n); if ( (double)LONG_MIN <= dval && dval <= (double)LONG_MAX ) { - Z_LVAL_P(return_value) *= Z_LVAL(entry_n); + Z_IVAL_P(return_value) *= Z_IVAL(entry_n); continue; } } @@ -4353,9 +4353,9 @@ PHP_FUNCTION(array_filter) if (!string_key) { if (use_type == ARRAY_FILTER_USE_BOTH) { fci.param_count = 2; - ZVAL_LONG(&args[1], num_key); + ZVAL_INT(&args[1], num_key); } else if (use_type == ARRAY_FILTER_USE_KEY) { - ZVAL_LONG(&args[0], num_key); + ZVAL_INT(&args[0], num_key); } } else { if (use_type == ARRAY_FILTER_USE_BOTH) { @@ -4597,8 +4597,8 @@ PHP_FUNCTION(array_key_exists) RETURN_TRUE; } RETURN_FALSE; - case IS_LONG: - if (zend_hash_index_exists(array, Z_LVAL_P(key))) { + case IS_INT: + if (zend_hash_index_exists(array, Z_IVAL_P(key))) { RETURN_TRUE; } RETURN_FALSE; @@ -4714,9 +4714,9 @@ PHP_FUNCTION(array_combine) break; } else if (Z_TYPE(Z_ARRVAL_P(values)->arData[pos_values].val) != IS_UNDEF) { entry_values = &Z_ARRVAL_P(values)->arData[pos_values].val; - if (Z_TYPE_P(entry_keys) == IS_LONG) { + if (Z_TYPE_P(entry_keys) == IS_INT) { zval_add_ref(entry_values); - add_index_zval(return_value, Z_LVAL_P(entry_keys), entry_values); + add_index_zval(return_value, Z_IVAL_P(entry_keys), entry_values); } else { zend_string *key = zval_get_string(entry_keys); diff --git a/ext/standard/assert.c b/ext/standard/assert.c index e64e2e1ecb..062b15f8b6 100644 --- a/ext/standard/assert.c +++ b/ext/standard/assert.c @@ -98,11 +98,11 @@ PHP_MINIT_FUNCTION(assert) /* {{{ */ REGISTER_INI_ENTRIES(); - REGISTER_LONG_CONSTANT("ASSERT_ACTIVE", ASSERT_ACTIVE, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_CALLBACK", ASSERT_CALLBACK, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_BAIL", ASSERT_BAIL, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_WARNING", ASSERT_WARNING, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_QUIET_EVAL", ASSERT_QUIET_EVAL, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_ACTIVE", ASSERT_ACTIVE, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_CALLBACK", ASSERT_CALLBACK, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_BAIL", ASSERT_BAIL, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_WARNING", ASSERT_WARNING, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_QUIET_EVAL", ASSERT_QUIET_EVAL, CONST_CS|CONST_PERSISTENT); return SUCCESS; } @@ -164,7 +164,7 @@ PHP_FUNCTION(assert) } compiled_string_description = zend_make_compiled_string_description("assert code" TSRMLS_CC); - if (zend_eval_stringl(myeval, Z_STRLEN_P(assertion), &retval, compiled_string_description TSRMLS_CC) == FAILURE) { + if (zend_eval_stringl(myeval, Z_STRSIZE_P(assertion), &retval, compiled_string_description TSRMLS_CC) == FAILURE) { efree(compiled_string_description); if (description_len == 0) { php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Failure evaluating code: %s%s", PHP_EOL, myeval); @@ -205,7 +205,7 @@ PHP_FUNCTION(assert) const char *filename = zend_get_executed_filename(TSRMLS_C); ZVAL_STRING(&args[0], SAFE_STRING(filename)); - ZVAL_LONG (&args[1], lineno); + ZVAL_INT (&args[1], lineno); ZVAL_STRING(&args[2], SAFE_STRING(myeval)); ZVAL_FALSE(&retval); @@ -275,7 +275,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_BAIL: @@ -287,7 +287,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_QUIET_EVAL: @@ -299,7 +299,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_WARNING: @@ -311,7 +311,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_CALLBACK: diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index 17bdae5719..f2f358b3f3 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -3545,28 +3545,28 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */ BG(incomplete_class) = incomplete_class_entry = php_create_incomplete_class(TSRMLS_C); - REGISTER_LONG_CONSTANT("CONNECTION_ABORTED", PHP_CONNECTION_ABORTED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CONNECTION_NORMAL", PHP_CONNECTION_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CONNECTION_TIMEOUT", PHP_CONNECTION_TIMEOUT, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("INI_USER", ZEND_INI_USER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_PERDIR", ZEND_INI_PERDIR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_SYSTEM", ZEND_INI_SYSTEM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_ALL", ZEND_INI_ALL, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("INI_SCANNER_NORMAL", ZEND_INI_SCANNER_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_SCANNER_RAW", ZEND_INI_SCANNER_RAW, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("PHP_URL_SCHEME", PHP_URL_SCHEME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_HOST", PHP_URL_HOST, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_PORT", PHP_URL_PORT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_USER", PHP_URL_USER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_PASS", PHP_URL_PASS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_PATH", PHP_URL_PATH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_QUERY", PHP_URL_QUERY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_FRAGMENT", PHP_URL_FRAGMENT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_QUERY_RFC1738", PHP_QUERY_RFC1738, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_QUERY_RFC3986", PHP_QUERY_RFC3986, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CONNECTION_ABORTED", PHP_CONNECTION_ABORTED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CONNECTION_NORMAL", PHP_CONNECTION_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CONNECTION_TIMEOUT", PHP_CONNECTION_TIMEOUT, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("INI_USER", ZEND_INI_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_PERDIR", ZEND_INI_PERDIR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_SYSTEM", ZEND_INI_SYSTEM, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_ALL", ZEND_INI_ALL, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("INI_SCANNER_NORMAL", ZEND_INI_SCANNER_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_SCANNER_RAW", ZEND_INI_SCANNER_RAW, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("PHP_URL_SCHEME", PHP_URL_SCHEME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_HOST", PHP_URL_HOST, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_PORT", PHP_URL_PORT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_USER", PHP_URL_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_PASS", PHP_URL_PASS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_PATH", PHP_URL_PATH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_QUERY", PHP_URL_QUERY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_FRAGMENT", PHP_URL_FRAGMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_QUERY_RFC1738", PHP_QUERY_RFC1738, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_QUERY_RFC3986", PHP_QUERY_RFC3986, CONST_CS | CONST_PERSISTENT); #define REGISTER_MATH_CONSTANT(x) REGISTER_DOUBLE_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) REGISTER_MATH_CONSTANT(M_E); @@ -3589,10 +3589,10 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */ REGISTER_DOUBLE_CONSTANT("INF", php_get_inf(), CONST_CS | CONST_PERSISTENT); REGISTER_DOUBLE_CONSTANT("NAN", php_get_nan(), CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_UP", PHP_ROUND_HALF_UP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_DOWN", PHP_ROUND_HALF_DOWN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_EVEN", PHP_ROUND_HALF_EVEN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_ODD", PHP_ROUND_HALF_ODD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_UP", PHP_ROUND_HALF_UP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_DOWN", PHP_ROUND_HALF_DOWN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_EVEN", PHP_ROUND_HALF_EVEN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_ODD", PHP_ROUND_HALF_ODD, CONST_CS | CONST_PERSISTENT); #if ENABLE_TEST_CLASS test_class_startup(); @@ -3925,7 +3925,7 @@ PHP_FUNCTION(ip2long) if (addr_len == 0 || inet_pton(AF_INET, addr, &ip) != 1) { RETURN_FALSE; } - RETURN_LONG(ntohl(ip.s_addr)); + RETURN_INT(ntohl(ip.s_addr)); #else if (addr_len == 0 || (ip = inet_addr(addr)) == INADDR_NONE) { /* The only special case when we should return -1 ourselves, @@ -3934,11 +3934,11 @@ PHP_FUNCTION(ip2long) if (addr_len == sizeof("255.255.255.255") - 1 && !memcmp(addr, "255.255.255.255", sizeof("255.255.255.255") - 1) ) { - RETURN_LONG(0xFFFFFFFF); + RETURN_INT(0xFFFFFFFF); } RETURN_FALSE; } - RETURN_LONG(ntohl(ip)); + RETURN_INT(ntohl(ip)); #endif } /* }}} */ @@ -4342,7 +4342,7 @@ PHP_FUNCTION(getopt) /* Add this option / argument pair to the result hash. */ optname_len = strlen(optname); - if (!(optname_len > 1 && optname[0] == '0') && is_numeric_string(optname, optname_len, NULL, NULL, 0) == IS_LONG) { + if (!(optname_len > 1 && optname[0] == '0') && is_numeric_string(optname, optname_len, NULL, NULL, 0) == IS_INT) { /* numeric string */ int optname_int = atoi(optname); if ((args = zend_hash_index_find(HASH_OF(return_value), optname_int)) != NULL) { @@ -4396,7 +4396,7 @@ PHP_FUNCTION(sleep) RETURN_FALSE; } #ifdef PHP_SLEEP_NON_VOID - RETURN_LONG(php_sleep(num)); + RETURN_INT(php_sleep(num)); #else php_sleep(num); #endif @@ -4450,8 +4450,8 @@ PHP_FUNCTION(time_nanosleep) RETURN_TRUE; } else if (errno == EINTR) { array_init(return_value); - add_assoc_long_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec); - add_assoc_long_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec); + add_assoc_int_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec); + add_assoc_int_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec); return; } else if (errno == EINVAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "nanoseconds was not in the range 0 to 999 999 999 or seconds was negative"); @@ -4703,10 +4703,10 @@ PHP_FUNCTION(error_get_last) if (PG(last_error_message)) { array_init(return_value); - add_assoc_long_ex(return_value, "type", sizeof("type")-1, PG(last_error_type)); + add_assoc_int_ex(return_value, "type", sizeof("type")-1, PG(last_error_type)); add_assoc_string_ex(return_value, "message", sizeof("message")-1, PG(last_error_message)); add_assoc_string_ex(return_value, "file", sizeof("file")-1, PG(last_error_file)?PG(last_error_file):"-"); - add_assoc_long_ex(return_value, "line", sizeof("line")-1, PG(last_error_lineno)); + add_assoc_int_ex(return_value, "line", sizeof("line")-1, PG(last_error_lineno)); } } /* }}} */ @@ -4937,11 +4937,11 @@ static int user_tick_function_compare(user_tick_function_entry * tick_fe1, user_ } else if (Z_TYPE_P(func1) == IS_ARRAY && Z_TYPE_P(func2) == IS_ARRAY) { zval result; zend_compare_arrays(&result, func1, func2 TSRMLS_CC); - ret = (Z_LVAL(result) == 0); + ret = (Z_IVAL(result) == 0); } else if (Z_TYPE_P(func1) == IS_OBJECT && Z_TYPE_P(func2) == IS_OBJECT) { zval result; zend_compare_objects(&result, func1, func2 TSRMLS_CC); - ret = (Z_LVAL(result) == 0); + ret = (Z_IVAL(result) == 0); } else { ret = 0; } @@ -5242,7 +5242,7 @@ static int php_ini_get_option(zval *zv TSRMLS_DC, int num_args, va_list args, ze add_assoc_null(&option, "local_value"); } - add_assoc_long(&option, "access", ini_entry->modifiable); + add_assoc_int(&option, "access", ini_entry->modifiable); add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, &option); } else { @@ -5450,7 +5450,7 @@ PHP_FUNCTION(print_r) Returns true if client disconnected */ PHP_FUNCTION(connection_aborted) { - RETURN_LONG(PG(connection_status) & PHP_CONNECTION_ABORTED); + RETURN_INT(PG(connection_status) & PHP_CONNECTION_ABORTED); } /* }}} */ @@ -5458,7 +5458,7 @@ PHP_FUNCTION(connection_aborted) Returns the connection status bitfield */ PHP_FUNCTION(connection_status) { - RETURN_LONG(PG(connection_status)); + RETURN_INT(PG(connection_status)); } /* }}} */ @@ -5482,7 +5482,7 @@ PHP_FUNCTION(ignore_user_abort) STR_RELEASE(key); } - RETURN_LONG(old_setting); + RETURN_INT(old_setting); } /* }}} */ @@ -5514,7 +5514,7 @@ PHP_FUNCTION(getservbyname) RETURN_FALSE; } - RETURN_LONG(ntohs(serv->s_port)); + RETURN_INT(ntohs(serv->s_port)); } /* }}} */ #endif @@ -5563,7 +5563,7 @@ PHP_FUNCTION(getprotobyname) RETURN_FALSE; } - RETURN_LONG(ent->p_proto); + RETURN_INT(ent->p_proto); } /* }}} */ #endif @@ -5777,8 +5777,8 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal break; } - if (!(Z_STRLEN_P(arg1) > 1 && Z_STRVAL_P(arg1)[0] == '0') && is_numeric_string(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), NULL, NULL, 0) == IS_LONG) { - ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1)); + if (!(Z_STRSIZE_P(arg1) > 1 && Z_STRVAL_P(arg1)[0] == '0') && is_numeric_string(Z_STRVAL_P(arg1), Z_STRSIZE_P(arg1), NULL, NULL, 0) == IS_INT) { + ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRSIZE_P(arg1)); if ((find_hash = zend_hash_index_find(Z_ARRVAL_P(arr), key)) == NULL) { array_init(&hash); find_hash = zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash); @@ -5797,7 +5797,7 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal ZVAL_DUP(&element, arg2); - if (arg3 && Z_STRLEN_P(arg3) > 0) { + if (arg3 && Z_STRSIZE_P(arg3) > 0) { zend_symtable_update(Z_ARRVAL_P(find_hash), Z_STR_P(arg3), &element); } else { add_next_index_zval(find_hash, &element); diff --git a/ext/standard/browscap.c b/ext/standard/browscap.c index f494cc86b1..c5a4b47744 100644 --- a/ext/standard/browscap.c +++ b/ext/standard/browscap.c @@ -83,15 +83,15 @@ static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */ zend_string *res; char *lc_pattern; - res = STR_SAFE_ALLOC(Z_STRLEN_P(pattern), 2, 4, persistent); + res = STR_SAFE_ALLOC(Z_STRSIZE_P(pattern), 2, 4, persistent); t = res->val; - lc_pattern = zend_str_tolower_dup(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern)); + lc_pattern = zend_str_tolower_dup(Z_STRVAL_P(pattern), Z_STRSIZE_P(pattern)); t[j++] = '\xA7'; /* section sign */ t[j++] = '^'; - for (i=0; i<Z_STRLEN_P(pattern); i++, j++) { + for (i=0; i<Z_STRSIZE_P(pattern); i++, j++) { switch (lc_pattern[i]) { case '?': t[j] = '.'; @@ -163,16 +163,16 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb } /* Set proper value for true/false settings */ - if ((Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "on", sizeof("on") - 1)) || - (Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) || - (Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1)) + if ((Z_STRSIZE_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "on", sizeof("on") - 1)) || + (Z_STRSIZE_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) || + (Z_STRSIZE_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1)) ) { ZVAL_NEW_STR(&new_property, STR_INIT("1", sizeof("1")-1, persistent)); } else if ( - (Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) || - (Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) || - (Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) || - (Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1)) + (Z_STRSIZE_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) || + (Z_STRSIZE_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) || + (Z_STRSIZE_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) || + (Z_STRSIZE_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1)) ) { // TODO: USE STR_EMPTY_ALLOC()? ZVAL_NEW_STR(&new_property, STR_INIT("", sizeof("")-1, persistent)); @@ -203,7 +203,7 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb pefree(bdata->current_section_name, persistent); } bdata->current_section_name = pestrndup(Z_STRVAL_P(arg1), - Z_STRLEN_P(arg1), persistent); + Z_STRSIZE_P(arg1), persistent); zend_hash_update(bdata->htab, Z_STR_P(arg1), &bdata->current_section); @@ -388,7 +388,7 @@ static int browser_reg_compare(zval *browser TSRMLS_DC, int num_args, va_list ar ua_len = lookup_browser_length; - for (i = 0; i < Z_STRLEN_P(previous_match); i++) { + for (i = 0; i < Z_STRSIZE_P(previous_match); i++) { switch (Z_STRVAL_P(previous_match)[i]) { case '?': case '*': @@ -400,7 +400,7 @@ static int browser_reg_compare(zval *browser TSRMLS_DC, int num_args, va_list ar } } - for (i = 0; i < Z_STRLEN_P(current_match); i++) { + for (i = 0; i < Z_STRSIZE_P(current_match); i++) { switch (Z_STRVAL_P(current_match)[i]) { case '?': case '*': @@ -475,7 +475,7 @@ PHP_FUNCTION(get_browser) RETURN_FALSE; } agent_name = Z_STRVAL_P(http_user_agent); - agent_name_len = Z_STRLEN_P(http_user_agent); + agent_name_len = Z_STRSIZE_P(http_user_agent); } lookup_browser_name = estrndup(agent_name, agent_name_len); diff --git a/ext/standard/crc32.c b/ext/standard/crc32.c index e9176e84da..6ff40d57c8 100644 --- a/ext/standard/crc32.c +++ b/ext/standard/crc32.c @@ -39,7 +39,7 @@ PHP_NAMED_FUNCTION(php_if_crc32) for (; nr--; ++p) { crc = ((crc >> 8) & 0x00FFFFFF) ^ crc32tab[(crc ^ (*p)) & 0xFF ]; } - RETVAL_LONG(crc^0xFFFFFFFF); + RETVAL_INT(crc^0xFFFFFFFF); } /* }}} */ diff --git a/ext/standard/crypt.c b/ext/standard/crypt.c index 2a2304be20..86ae9bee13 100644 --- a/ext/standard/crypt.c +++ b/ext/standard/crypt.c @@ -102,18 +102,18 @@ PHP_MINIT_FUNCTION(crypt) /* {{{ */ { - REGISTER_LONG_CONSTANT("CRYPT_SALT_LENGTH", PHP_MAX_SALT_LEN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_STD_DES", PHP_STD_DES_CRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_EXT_DES", PHP_EXT_DES_CRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_MD5", PHP_MD5_CRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_BLOWFISH", PHP_BLOWFISH_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_SALT_LENGTH", PHP_MAX_SALT_LEN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_STD_DES", PHP_STD_DES_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_EXT_DES", PHP_EXT_DES_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_MD5", PHP_MD5_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_BLOWFISH", PHP_BLOWFISH_CRYPT, CONST_CS | CONST_PERSISTENT); #ifdef PHP_SHA256_CRYPT - REGISTER_LONG_CONSTANT("CRYPT_SHA256", PHP_SHA256_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_SHA256", PHP_SHA256_CRYPT, CONST_CS | CONST_PERSISTENT); #endif #ifdef PHP_SHA512_CRYPT - REGISTER_LONG_CONSTANT("CRYPT_SHA512", PHP_SHA512_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_SHA512", PHP_SHA512_CRYPT, CONST_CS | CONST_PERSISTENT); #endif #if PHP_USE_PHP_CRYPT_R diff --git a/ext/standard/datetime.c b/ext/standard/datetime.c index 80a34a4548..8743708ad9 100644 --- a/ext/standard/datetime.c +++ b/ext/standard/datetime.c @@ -104,14 +104,14 @@ PHP_FUNCTION(strptime) } array_init(return_value); - add_assoc_long(return_value, "tm_sec", parsed_time.tm_sec); - add_assoc_long(return_value, "tm_min", parsed_time.tm_min); - add_assoc_long(return_value, "tm_hour", parsed_time.tm_hour); - add_assoc_long(return_value, "tm_mday", parsed_time.tm_mday); - add_assoc_long(return_value, "tm_mon", parsed_time.tm_mon); - add_assoc_long(return_value, "tm_year", parsed_time.tm_year); - add_assoc_long(return_value, "tm_wday", parsed_time.tm_wday); - add_assoc_long(return_value, "tm_yday", parsed_time.tm_yday); + add_assoc_int(return_value, "tm_sec", parsed_time.tm_sec); + add_assoc_int(return_value, "tm_min", parsed_time.tm_min); + add_assoc_int(return_value, "tm_hour", parsed_time.tm_hour); + add_assoc_int(return_value, "tm_mday", parsed_time.tm_mday); + add_assoc_int(return_value, "tm_mon", parsed_time.tm_mon); + add_assoc_int(return_value, "tm_year", parsed_time.tm_year); + add_assoc_int(return_value, "tm_wday", parsed_time.tm_wday); + add_assoc_int(return_value, "tm_yday", parsed_time.tm_yday); add_assoc_string(return_value, "unparsed", unparsed_part); } /* }}} */ diff --git a/ext/standard/dir.c b/ext/standard/dir.c index 16cc8db054..e721de9774 100644 --- a/ext/standard/dir.c +++ b/ext/standard/dir.c @@ -148,44 +148,44 @@ PHP_MINIT_FUNCTION(dir) pathsep_str[1] = '\0'; REGISTER_STRING_CONSTANT("PATH_SEPARATOR", pathsep_str, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SCANDIR_SORT_ASCENDING", PHP_SCANDIR_SORT_ASCENDING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SCANDIR_SORT_DESCENDING", PHP_SCANDIR_SORT_DESCENDING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SCANDIR_SORT_NONE", PHP_SCANDIR_SORT_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SCANDIR_SORT_ASCENDING", PHP_SCANDIR_SORT_ASCENDING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SCANDIR_SORT_DESCENDING", PHP_SCANDIR_SORT_DESCENDING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SCANDIR_SORT_NONE", PHP_SCANDIR_SORT_NONE, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_GLOB #ifdef GLOB_BRACE - REGISTER_LONG_CONSTANT("GLOB_BRACE", GLOB_BRACE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_BRACE", GLOB_BRACE, CONST_CS | CONST_PERSISTENT); #else # define GLOB_BRACE 0 #endif #ifdef GLOB_MARK - REGISTER_LONG_CONSTANT("GLOB_MARK", GLOB_MARK, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_MARK", GLOB_MARK, CONST_CS | CONST_PERSISTENT); #else # define GLOB_MARK 0 #endif #ifdef GLOB_NOSORT - REGISTER_LONG_CONSTANT("GLOB_NOSORT", GLOB_NOSORT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_NOSORT", GLOB_NOSORT, CONST_CS | CONST_PERSISTENT); #else # define GLOB_NOSORT 0 #endif #ifdef GLOB_NOCHECK - REGISTER_LONG_CONSTANT("GLOB_NOCHECK", GLOB_NOCHECK, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_NOCHECK", GLOB_NOCHECK, CONST_CS | CONST_PERSISTENT); #else # define GLOB_NOCHECK 0 #endif #ifdef GLOB_NOESCAPE - REGISTER_LONG_CONSTANT("GLOB_NOESCAPE", GLOB_NOESCAPE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_NOESCAPE", GLOB_NOESCAPE, CONST_CS | CONST_PERSISTENT); #else # define GLOB_NOESCAPE 0 #endif #ifdef GLOB_ERR - REGISTER_LONG_CONSTANT("GLOB_ERR", GLOB_ERR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_ERR", GLOB_ERR, CONST_CS | CONST_PERSISTENT); #else # define GLOB_ERR 0 #endif @@ -201,8 +201,8 @@ PHP_MINIT_FUNCTION(dir) /* This is used for checking validity of passed flags (passing invalid flags causes segfault in glob()!! */ #define GLOB_AVAILABLE_FLAGS (0 | GLOB_BRACE | GLOB_MARK | GLOB_NOSORT | GLOB_NOCHECK | GLOB_NOESCAPE | GLOB_ERR | GLOB_ONLYDIR) - REGISTER_LONG_CONSTANT("GLOB_ONLYDIR", GLOB_ONLYDIR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("GLOB_AVAILABLE_FLAGS", GLOB_AVAILABLE_FLAGS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_ONLYDIR", GLOB_ONLYDIR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_AVAILABLE_FLAGS", GLOB_AVAILABLE_FLAGS, CONST_CS | CONST_PERSISTENT); #endif /* HAVE_GLOB */ diff --git a/ext/standard/dl.c b/ext/standard/dl.c index 19573d8e42..2f92c82d2c 100644 --- a/ext/standard/dl.c +++ b/ext/standard/dl.c @@ -83,7 +83,7 @@ PHPAPI PHP_FUNCTION(dl) } php_dl(filename, MODULE_TEMPORARY, return_value, 0 TSRMLS_CC); - if (Z_LVAL_P(return_value) == 1) { + if (Z_IVAL_P(return_value) == 1) { EG(full_tables_cleanup) = 1; } } diff --git a/ext/standard/dns.c b/ext/standard/dns.c index cabe3d72f1..c760fc0713 100644 --- a/ext/standard/dns.c +++ b/ext/standard/dns.c @@ -448,10 +448,10 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int add_assoc_string(subarray, "host", name); add_assoc_string(subarray, "class", "IN"); - add_assoc_long(subarray, "ttl", ttl); + add_assoc_int(subarray, "ttl", ttl); if (raw) { - add_assoc_long(subarray, "type", type); + add_assoc_int(subarray, "type", type); add_assoc_stringl(subarray, "data", (char*) cp, (uint) dlen); cp += dlen; return cp; @@ -467,7 +467,7 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int case DNS_T_MX: add_assoc_string(subarray, "type", "MX"); GETSHORT(n, cp); - add_assoc_long(subarray, "pri", n); + add_assoc_int(subarray, "pri", n); /* no break; */ case DNS_T_CNAME: if (type == DNS_T_CNAME) { @@ -546,15 +546,15 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int cp += n; add_assoc_string(subarray, "rname", name); GETLONG(n, cp); - add_assoc_long(subarray, "serial", n); + add_assoc_int(subarray, "serial", n); GETLONG(n, cp); - add_assoc_long(subarray, "refresh", n); + add_assoc_int(subarray, "refresh", n); GETLONG(n, cp); - add_assoc_long(subarray, "retry", n); + add_assoc_int(subarray, "retry", n); GETLONG(n, cp); - add_assoc_long(subarray, "expire", n); + add_assoc_int(subarray, "expire", n); GETLONG(n, cp); - add_assoc_long(subarray, "minimum-ttl", n); + add_assoc_int(subarray, "minimum-ttl", n); break; case DNS_T_AAAA: tp = (u_char*)name; @@ -594,7 +594,7 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int add_assoc_string(subarray, "type", "A6"); n = ((int)cp[0]) & 0xFF; cp++; - add_assoc_long(subarray, "masklen", n); + add_assoc_int(subarray, "masklen", n); tp = (u_char*)name; if (n > 15) { have_v6_break = 1; @@ -667,11 +667,11 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int case DNS_T_SRV: add_assoc_string(subarray, "type", "SRV"); GETSHORT(n, cp); - add_assoc_long(subarray, "pri", n); + add_assoc_int(subarray, "pri", n); GETSHORT(n, cp); - add_assoc_long(subarray, "weight", n); + add_assoc_int(subarray, "weight", n); GETSHORT(n, cp); - add_assoc_long(subarray, "port", n); + add_assoc_int(subarray, "port", n); n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2); if (n < 0) { return NULL; @@ -682,9 +682,9 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int case DNS_T_NAPTR: add_assoc_string(subarray, "type", "NAPTR"); GETSHORT(n, cp); - add_assoc_long(subarray, "order", n); + add_assoc_int(subarray, "order", n); GETSHORT(n, cp); - add_assoc_long(subarray, "pref", n); + add_assoc_int(subarray, "pref", n); n = (cp[0] & 0xFF); add_assoc_stringl(subarray, "flags", (char*)++cp, n); cp += n; @@ -1011,7 +1011,7 @@ PHP_FUNCTION(dns_get_mx) cp += i; add_next_index_string(mx_list, buf); if (weight_list) { - add_next_index_long(weight_list, weight); + add_next_index_int(weight_list, weight); } } php_dns_free_handle(handle); @@ -1023,20 +1023,20 @@ PHP_FUNCTION(dns_get_mx) #if HAVE_FULL_DNS_FUNCS || defined(PHP_WIN32) PHP_MINIT_FUNCTION(dns) { - REGISTER_LONG_CONSTANT("DNS_A", PHP_DNS_A, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_NS", PHP_DNS_NS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_CNAME", PHP_DNS_CNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_SOA", PHP_DNS_SOA, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_PTR", PHP_DNS_PTR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_HINFO", PHP_DNS_HINFO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_MX", PHP_DNS_MX, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_TXT", PHP_DNS_TXT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_SRV", PHP_DNS_SRV, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_NAPTR", PHP_DNS_NAPTR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_AAAA", PHP_DNS_AAAA, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_A6", PHP_DNS_A6, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_ANY", PHP_DNS_ANY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_ALL", PHP_DNS_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_A", PHP_DNS_A, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_NS", PHP_DNS_NS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_CNAME", PHP_DNS_CNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_SOA", PHP_DNS_SOA, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_PTR", PHP_DNS_PTR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_HINFO", PHP_DNS_HINFO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_MX", PHP_DNS_MX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_TXT", PHP_DNS_TXT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_SRV", PHP_DNS_SRV, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_NAPTR", PHP_DNS_NAPTR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_AAAA", PHP_DNS_AAAA, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_A6", PHP_DNS_A6, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_ANY", PHP_DNS_ANY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_ALL", PHP_DNS_ALL, CONST_CS | CONST_PERSISTENT); return SUCCESS; } #endif /* HAVE_FULL_DNS_FUNCS */ diff --git a/ext/standard/dns_win32.c b/ext/standard/dns_win32.c index f255ebba63..7ef53dd0e7 100644 --- a/ext/standard/dns_win32.c +++ b/ext/standard/dns_win32.c @@ -77,7 +77,7 @@ PHP_FUNCTION(dns_get_mx) /* {{{ */ add_next_index_string(mx_list, pRec->Data.MX.pNameExchange); if (weight_list) { - add_next_index_long(weight_list, srv->wPriority); + add_next_index_int(weight_list, srv->wPriority); } } @@ -158,10 +158,10 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, add_assoc_string(subarray, "host", pRec->pName); add_assoc_string(subarray, "class", "IN"); - add_assoc_long(subarray, "ttl", ttl); + add_assoc_int(subarray, "ttl", ttl); if (raw) { - add_assoc_long(subarray, "type", type); + add_assoc_int(subarray, "type", type); add_assoc_stringl(subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength); return; } @@ -177,7 +177,7 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, case DNS_TYPE_MX: add_assoc_string(subarray, "type", "MX"); - add_assoc_long(subarray, "pri", pRec->Data.Srv.wPriority); + add_assoc_int(subarray, "pri", pRec->Data.Srv.wPriority); /* no break; */ case DNS_TYPE_CNAME: @@ -241,11 +241,11 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, add_assoc_string(subarray, "mname", data_soa->pNamePrimaryServer); add_assoc_string(subarray, "rname", data_soa->pNameAdministrator); - add_assoc_long(subarray, "serial", data_soa->dwSerialNo); - add_assoc_long(subarray, "refresh", data_soa->dwRefresh); - add_assoc_long(subarray, "retry", data_soa->dwRetry); - add_assoc_long(subarray, "expire", data_soa->dwExpire); - add_assoc_long(subarray, "minimum-ttl", data_soa->dwDefaultTtl); + add_assoc_int(subarray, "serial", data_soa->dwSerialNo); + add_assoc_int(subarray, "refresh", data_soa->dwRefresh); + add_assoc_int(subarray, "retry", data_soa->dwRetry); + add_assoc_int(subarray, "expire", data_soa->dwExpire); + add_assoc_int(subarray, "minimum-ttl", data_soa->dwDefaultTtl); } break; @@ -309,9 +309,9 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, DNS_SRV_DATA *data_srv = &pRec->Data.Srv; add_assoc_string(subarray, "type", "SRV"); - add_assoc_long(subarray, "pri", data_srv->wPriority); - add_assoc_long(subarray, "weight", data_srv->wWeight); - add_assoc_long(subarray, "port", data_srv->wPort); + add_assoc_int(subarray, "pri", data_srv->wPriority); + add_assoc_int(subarray, "weight", data_srv->wWeight); + add_assoc_int(subarray, "port", data_srv->wPort); add_assoc_string(subarray, "target", data_srv->pNameTarget); } break; @@ -322,8 +322,8 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, DNS_NAPTR_DATA * data_naptr = &pRec->Data.Naptr; add_assoc_string(subarray, "type", "NAPTR"); - add_assoc_long(subarray, "order", data_naptr->wOrder); - add_assoc_long(subarray, "pref", data_naptr->wPreference); + add_assoc_int(subarray, "order", data_naptr->wOrder); + add_assoc_int(subarray, "pref", data_naptr->wPreference); add_assoc_string(subarray, "flags", data_naptr->pFlags); add_assoc_string(subarray, "services", data_naptr->pService); add_assoc_string(subarray, "regex", data_naptr->pRegularExpression); diff --git a/ext/standard/exec.c b/ext/standard/exec.c index 6720231089..87e73ee4f2 100644 --- a/ext/standard/exec.c +++ b/ext/standard/exec.c @@ -200,7 +200,7 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */ } if (ret_code) { zval_dtor(ret_code); - ZVAL_LONG(ret_code, ret); + ZVAL_INT(ret_code, ret); } } /* }}} */ diff --git a/ext/standard/file.c b/ext/standard/file.c index 4551bef8cf..5b0237ba4e 100644 --- a/ext/standard/file.c +++ b/ext/standard/file.c @@ -188,135 +188,135 @@ PHP_MINIT_FUNCTION(file) REGISTER_INI_ENTRIES(); - REGISTER_LONG_CONSTANT("SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_SH", PHP_LOCK_SH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_EX", PHP_LOCK_EX, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_UN", PHP_LOCK_UN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_NB", PHP_LOCK_NB, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_CONNECT", PHP_STREAM_NOTIFY_CONNECT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_AUTH_REQUIRED", PHP_STREAM_NOTIFY_AUTH_REQUIRED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_AUTH_RESULT", PHP_STREAM_NOTIFY_AUTH_RESULT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_MIME_TYPE_IS", PHP_STREAM_NOTIFY_MIME_TYPE_IS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_FILE_SIZE_IS", PHP_STREAM_NOTIFY_FILE_SIZE_IS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_REDIRECTED", PHP_STREAM_NOTIFY_REDIRECTED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_PROGRESS", PHP_STREAM_NOTIFY_PROGRESS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_FAILURE", PHP_STREAM_NOTIFY_FAILURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_COMPLETED", PHP_STREAM_NOTIFY_COMPLETED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_RESOLVE", PHP_STREAM_NOTIFY_RESOLVE, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_INFO", PHP_STREAM_NOTIFY_SEVERITY_INFO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_WARN", PHP_STREAM_NOTIFY_SEVERITY_WARN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_ERR", PHP_STREAM_NOTIFY_SEVERITY_ERR, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_FILTER_READ", PHP_STREAM_FILTER_READ, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_FILTER_WRITE", PHP_STREAM_FILTER_WRITE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_FILTER_ALL", PHP_STREAM_FILTER_ALL, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_CLIENT_PERSISTENT", PHP_STREAM_CLIENT_PERSISTENT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CLIENT_ASYNC_CONNECT", PHP_STREAM_CLIENT_ASYNC_CONNECT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CLIENT_CONNECT", PHP_STREAM_CLIENT_CONNECT, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_ANY_CLIENT", STREAM_CRYPTO_METHOD_ANY_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_CLIENT", STREAM_CRYPTO_METHOD_SSLv2_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_CLIENT", STREAM_CRYPTO_METHOD_SSLv3_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_CLIENT", STREAM_CRYPTO_METHOD_SSLv23_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLS_CLIENT", STREAM_CRYPTO_METHOD_TLS_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_ANY_SERVER", STREAM_CRYPTO_METHOD_ANY_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_SERVER", STREAM_CRYPTO_METHOD_SSLv2_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_SERVER", STREAM_CRYPTO_METHOD_SSLv3_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_SERVER", STREAM_CRYPTO_METHOD_SSLv23_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLS_SERVER", STREAM_CRYPTO_METHOD_TLS_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_SERVER", STREAM_CRYPTO_METHOD_TLSv1_0_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_SERVER", STREAM_CRYPTO_METHOD_TLSv1_1_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_SERVER", STREAM_CRYPTO_METHOD_TLSv1_2_SERVER, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_SHUT_RD", STREAM_SHUT_RD, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SHUT_WR", STREAM_SHUT_WR, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SHUT_RDWR", STREAM_SHUT_RDWR, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_SH", PHP_LOCK_SH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_EX", PHP_LOCK_EX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_UN", PHP_LOCK_UN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_NB", PHP_LOCK_NB, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_NOTIFY_CONNECT", PHP_STREAM_NOTIFY_CONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_AUTH_REQUIRED", PHP_STREAM_NOTIFY_AUTH_REQUIRED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_AUTH_RESULT", PHP_STREAM_NOTIFY_AUTH_RESULT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_MIME_TYPE_IS", PHP_STREAM_NOTIFY_MIME_TYPE_IS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_FILE_SIZE_IS", PHP_STREAM_NOTIFY_FILE_SIZE_IS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_REDIRECTED", PHP_STREAM_NOTIFY_REDIRECTED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_PROGRESS", PHP_STREAM_NOTIFY_PROGRESS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_FAILURE", PHP_STREAM_NOTIFY_FAILURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_COMPLETED", PHP_STREAM_NOTIFY_COMPLETED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_RESOLVE", PHP_STREAM_NOTIFY_RESOLVE, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_NOTIFY_SEVERITY_INFO", PHP_STREAM_NOTIFY_SEVERITY_INFO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_SEVERITY_WARN", PHP_STREAM_NOTIFY_SEVERITY_WARN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_SEVERITY_ERR", PHP_STREAM_NOTIFY_SEVERITY_ERR, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_FILTER_READ", PHP_STREAM_FILTER_READ, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_FILTER_WRITE", PHP_STREAM_FILTER_WRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_FILTER_ALL", PHP_STREAM_FILTER_ALL, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_CLIENT_PERSISTENT", PHP_STREAM_CLIENT_PERSISTENT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CLIENT_ASYNC_CONNECT", PHP_STREAM_CLIENT_ASYNC_CONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CLIENT_CONNECT", PHP_STREAM_CLIENT_CONNECT, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_ANY_CLIENT", STREAM_CRYPTO_METHOD_ANY_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_CLIENT", STREAM_CRYPTO_METHOD_SSLv2_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_CLIENT", STREAM_CRYPTO_METHOD_SSLv3_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_CLIENT", STREAM_CRYPTO_METHOD_SSLv23_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLS_CLIENT", STREAM_CRYPTO_METHOD_TLS_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_ANY_SERVER", STREAM_CRYPTO_METHOD_ANY_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_SERVER", STREAM_CRYPTO_METHOD_SSLv2_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_SERVER", STREAM_CRYPTO_METHOD_SSLv3_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_SERVER", STREAM_CRYPTO_METHOD_SSLv23_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLS_SERVER", STREAM_CRYPTO_METHOD_TLS_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_SERVER", STREAM_CRYPTO_METHOD_TLSv1_0_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_SERVER", STREAM_CRYPTO_METHOD_TLSv1_1_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_SERVER", STREAM_CRYPTO_METHOD_TLSv1_2_SERVER, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_SHUT_RD", STREAM_SHUT_RD, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SHUT_WR", STREAM_SHUT_WR, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SHUT_RDWR", STREAM_SHUT_RDWR, CONST_CS|CONST_PERSISTENT); #ifdef PF_INET - REGISTER_LONG_CONSTANT("STREAM_PF_INET", PF_INET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET", PF_INET, CONST_CS|CONST_PERSISTENT); #elif defined(AF_INET) - REGISTER_LONG_CONSTANT("STREAM_PF_INET", AF_INET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET", AF_INET, CONST_CS|CONST_PERSISTENT); #endif #if HAVE_IPV6 # ifdef PF_INET6 - REGISTER_LONG_CONSTANT("STREAM_PF_INET6", PF_INET6, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET6", PF_INET6, CONST_CS|CONST_PERSISTENT); # elif defined(AF_INET6) - REGISTER_LONG_CONSTANT("STREAM_PF_INET6", AF_INET6, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET6", AF_INET6, CONST_CS|CONST_PERSISTENT); # endif #endif #ifdef PF_UNIX - REGISTER_LONG_CONSTANT("STREAM_PF_UNIX", PF_UNIX, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_UNIX", PF_UNIX, CONST_CS|CONST_PERSISTENT); #elif defined(AF_UNIX) - REGISTER_LONG_CONSTANT("STREAM_PF_UNIX", AF_UNIX, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_UNIX", AF_UNIX, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_IP /* most people will use this one when calling socket() or socketpair() */ - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_IP", IPPROTO_IP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_IP", IPPROTO_IP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_TCP - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_TCP", IPPROTO_TCP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_TCP", IPPROTO_TCP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_UDP - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_UDP", IPPROTO_UDP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_UDP", IPPROTO_UDP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_ICMP - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_ICMP", IPPROTO_ICMP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_ICMP", IPPROTO_ICMP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_RAW - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_RAW", IPPROTO_RAW, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_RAW", IPPROTO_RAW, CONST_CS|CONST_PERSISTENT); #endif - REGISTER_LONG_CONSTANT("STREAM_SOCK_STREAM", SOCK_STREAM, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SOCK_DGRAM", SOCK_DGRAM, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_STREAM", SOCK_STREAM, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_DGRAM", SOCK_DGRAM, CONST_CS|CONST_PERSISTENT); #ifdef SOCK_RAW - REGISTER_LONG_CONSTANT("STREAM_SOCK_RAW", SOCK_RAW, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_RAW", SOCK_RAW, CONST_CS|CONST_PERSISTENT); #endif #ifdef SOCK_SEQPACKET - REGISTER_LONG_CONSTANT("STREAM_SOCK_SEQPACKET", SOCK_SEQPACKET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_SEQPACKET", SOCK_SEQPACKET, CONST_CS|CONST_PERSISTENT); #endif #ifdef SOCK_RDM - REGISTER_LONG_CONSTANT("STREAM_SOCK_RDM", SOCK_RDM, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_RDM", SOCK_RDM, CONST_CS|CONST_PERSISTENT); #endif - REGISTER_LONG_CONSTANT("STREAM_PEEK", STREAM_PEEK, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_OOB", STREAM_OOB, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PEEK", STREAM_PEEK, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_OOB", STREAM_OOB, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SERVER_BIND", STREAM_XPORT_BIND, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SERVER_LISTEN", STREAM_XPORT_LISTEN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SERVER_BIND", STREAM_XPORT_BIND, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SERVER_LISTEN", STREAM_XPORT_LISTEN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_USE_INCLUDE_PATH", PHP_FILE_USE_INCLUDE_PATH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_IGNORE_NEW_LINES", PHP_FILE_IGNORE_NEW_LINES, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_SKIP_EMPTY_LINES", PHP_FILE_SKIP_EMPTY_LINES, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_APPEND", PHP_FILE_APPEND, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_NO_DEFAULT_CONTEXT", PHP_FILE_NO_DEFAULT_CONTEXT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_USE_INCLUDE_PATH", PHP_FILE_USE_INCLUDE_PATH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_IGNORE_NEW_LINES", PHP_FILE_IGNORE_NEW_LINES, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_SKIP_EMPTY_LINES", PHP_FILE_SKIP_EMPTY_LINES, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_APPEND", PHP_FILE_APPEND, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_NO_DEFAULT_CONTEXT", PHP_FILE_NO_DEFAULT_CONTEXT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_TEXT", 0, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_BINARY", 0, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_TEXT", 0, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_BINARY", 0, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_FNMATCH - REGISTER_LONG_CONSTANT("FNM_NOESCAPE", FNM_NOESCAPE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FNM_PATHNAME", FNM_PATHNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FNM_PERIOD", FNM_PERIOD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_NOESCAPE", FNM_NOESCAPE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_PATHNAME", FNM_PATHNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_PERIOD", FNM_PERIOD, CONST_CS | CONST_PERSISTENT); # ifdef FNM_CASEFOLD /* a GNU extension */ /* TODO emulate if not available */ - REGISTER_LONG_CONSTANT("FNM_CASEFOLD", FNM_CASEFOLD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_CASEFOLD", FNM_CASEFOLD, CONST_CS | CONST_PERSISTENT); # endif #endif @@ -358,14 +358,14 @@ PHP_FUNCTION(flock) if (arg3) { zval_dtor(arg3); - ZVAL_LONG(arg3, 0); + ZVAL_INT(arg3, 0); } /* flock_values contains all possible actions if (operation & 4) we won't block on the lock */ act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0); if (php_stream_lock(stream, act)) { if (operation && errno == EWOULDBLOCK && arg3) { - ZVAL_LONG(arg3, 1); + ZVAL_INT(arg3, 1); } RETURN_FALSE; } @@ -640,17 +640,17 @@ PHP_FUNCTION(file_put_contents) break; } case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: convert_to_string_ex(data); case IS_STRING: - if (Z_STRLEN_P(data)) { - numbytes = php_stream_write(stream, Z_STRVAL_P(data), Z_STRLEN_P(data)); - if (numbytes != Z_STRLEN_P(data)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %d bytes written, possibly out of free disk space", numbytes, Z_STRLEN_P(data)); + if (Z_STRSIZE_P(data)) { + numbytes = php_stream_write(stream, Z_STRVAL_P(data), Z_STRSIZE_P(data)); + if (numbytes != Z_STRSIZE_P(data)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %d bytes written, possibly out of free disk space", numbytes, Z_STRSIZE_P(data)); numbytes = -1; } } @@ -687,9 +687,9 @@ PHP_FUNCTION(file_put_contents) zval out; if (zend_std_cast_object_tostring(data, &out, IS_STRING TSRMLS_CC) == SUCCESS) { - numbytes = php_stream_write(stream, Z_STRVAL(out), Z_STRLEN(out)); - if (numbytes != Z_STRLEN(out)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %d bytes written, possibly out of free disk space", numbytes, Z_STRLEN(out)); + numbytes = php_stream_write(stream, Z_STRVAL(out), Z_STRSIZE(out)); + if (numbytes != Z_STRSIZE(out)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %d bytes written, possibly out of free disk space", numbytes, Z_STRSIZE(out)); numbytes = -1; } zval_dtor(&out); @@ -706,7 +706,7 @@ PHP_FUNCTION(file_put_contents) RETURN_FALSE; } - RETURN_LONG(numbytes); + RETURN_INT(numbytes); } /* }}} */ @@ -980,7 +980,7 @@ PHP_FUNCTION(pclose) FG(pclose_wait) = 1; zend_list_close(stream->res); FG(pclose_wait) = 0; - RETURN_LONG(FG(pclose_ret)); + RETURN_INT(FG(pclose_ret)); } /* }}} */ @@ -1215,7 +1215,7 @@ PHPAPI PHP_FUNCTION(fwrite) } if (!num_bytes) { - RETURN_LONG(0); + RETURN_INT(0); } PHP_STREAM_TO_ZVAL(stream, arg1); @@ -1225,7 +1225,7 @@ PHPAPI PHP_FUNCTION(fwrite) efree(buffer); } - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ @@ -1289,7 +1289,7 @@ PHPAPI PHP_FUNCTION(ftell) if (ret == -1) { RETURN_FALSE; } - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ @@ -1307,7 +1307,7 @@ PHPAPI PHP_FUNCTION(fseek) PHP_STREAM_TO_ZVAL(stream, arg1); - RETURN_LONG(php_stream_seek(stream, arg2, whence)); + RETURN_INT(php_stream_seek(stream, arg2, whence)); } /* }}} */ @@ -1398,7 +1398,7 @@ PHP_FUNCTION(readfile) if (stream) { size = php_stream_passthru(stream); php_stream_close(stream); - RETURN_LONG(size); + RETURN_INT(size); } RETURN_FALSE; @@ -1428,7 +1428,7 @@ PHP_FUNCTION(umask) umask(arg1); } - RETURN_LONG(oldumask); + RETURN_INT(oldumask); } /* }}} */ @@ -1447,7 +1447,7 @@ PHPAPI PHP_FUNCTION(fpassthru) PHP_STREAM_TO_ZVAL(stream, arg1); size = php_stream_passthru(stream); - RETURN_LONG(size); + RETURN_INT(size); } /* }}} */ @@ -1568,30 +1568,30 @@ PHP_NAMED_FUNCTION(php_if_fstat) array_init(return_value); - ZVAL_LONG(&stat_dev, stat_ssb.sb.st_dev); - ZVAL_LONG(&stat_ino, stat_ssb.sb.st_ino); - ZVAL_LONG(&stat_mode, stat_ssb.sb.st_mode); - ZVAL_LONG(&stat_nlink, stat_ssb.sb.st_nlink); - ZVAL_LONG(&stat_uid, stat_ssb.sb.st_uid); - ZVAL_LONG(&stat_gid, stat_ssb.sb.st_gid); + ZVAL_INT(&stat_dev, stat_ssb.sb.st_dev); + ZVAL_INT(&stat_ino, stat_ssb.sb.st_ino); + ZVAL_INT(&stat_mode, stat_ssb.sb.st_mode); + ZVAL_INT(&stat_nlink, stat_ssb.sb.st_nlink); + ZVAL_INT(&stat_uid, stat_ssb.sb.st_uid); + ZVAL_INT(&stat_gid, stat_ssb.sb.st_gid); #ifdef HAVE_ST_RDEV - ZVAL_LONG(&stat_rdev, stat_ssb.sb.st_rdev); + ZVAL_INT(&stat_rdev, stat_ssb.sb.st_rdev); #else - ZVAL_LONG(&stat_rdev, -1); + ZVAL_INT(&stat_rdev, -1); #endif - ZVAL_LONG(&stat_size, stat_ssb.sb.st_size); - ZVAL_LONG(&stat_atime, stat_ssb.sb.st_atime); - ZVAL_LONG(&stat_mtime, stat_ssb.sb.st_mtime); - ZVAL_LONG(&stat_ctime, stat_ssb.sb.st_ctime); + ZVAL_INT(&stat_size, stat_ssb.sb.st_size); + ZVAL_INT(&stat_atime, stat_ssb.sb.st_atime); + ZVAL_INT(&stat_mtime, stat_ssb.sb.st_mtime); + ZVAL_INT(&stat_ctime, stat_ssb.sb.st_ctime); #ifdef HAVE_ST_BLKSIZE - ZVAL_LONG(&stat_blksize, stat_ssb.sb.st_blksize); + ZVAL_INT(&stat_blksize, stat_ssb.sb.st_blksize); #else - ZVAL_LONG(&stat_blksize,-1); + ZVAL_INT(&stat_blksize,-1); #endif #ifdef HAVE_ST_BLOCKS - ZVAL_LONG(&stat_blocks, stat_ssb.sb.st_blocks); + ZVAL_INT(&stat_blocks, stat_ssb.sb.st_blocks); #else - ZVAL_LONG(&stat_blocks,-1); + ZVAL_INT(&stat_blocks,-1); #endif /* Store numeric indexes in propper order */ zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev); @@ -1782,10 +1782,10 @@ PHPAPI PHP_FUNCTION(fread) } ZVAL_NEW_STR(return_value, STR_ALLOC(len, 0)); - Z_STRLEN_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len); + Z_STRSIZE_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len); /* needed because recv/read/gzread doesnt put a null at the end*/ - Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0; + Z_STRVAL_P(return_value)[Z_STRSIZE_P(return_value)] = 0; } /* }}} */ @@ -1887,7 +1887,7 @@ PHP_FUNCTION(fputcsv) PHP_STREAM_TO_ZVAL(stream, fp); ret = php_fputcsv(stream, fields, delimiter, enclosure, escape_char TSRMLS_CC); - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c index 9fb35ef344..b1b7e5933a 100644 --- a/ext/standard/filestat.c +++ b/ext/standard/filestat.c @@ -437,9 +437,9 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */ if(wrapper && wrapper->wops->stream_metadata) { int option; void *value; - if (Z_TYPE_P(group) == IS_LONG) { + if (Z_TYPE_P(group) == IS_INT) { option = PHP_STREAM_META_GROUP; - value = &Z_LVAL_P(group); + value = &Z_IVAL_P(group); } else if (Z_TYPE_P(group) == IS_STRING) { option = PHP_STREAM_META_GROUP_NAME; value = Z_STRVAL_P(group); @@ -465,8 +465,8 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */ /* We have no native chgrp on Windows, nothing left to do if stream doesn't have own implementation */ RETURN_FALSE; #else - if (Z_TYPE_P(group) == IS_LONG) { - gid = (gid_t)Z_LVAL_P(group); + if (Z_TYPE_P(group) == IS_INT) { + gid = (gid_t)Z_IVAL_P(group); } else if (Z_TYPE_P(group) == IS_STRING) { if(php_get_gid_by_name(Z_STRVAL_P(group), &gid TSRMLS_CC) != SUCCESS) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find gid for %s", Z_STRVAL_P(group)); @@ -574,9 +574,9 @@ static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown) /* {{{ */ if(wrapper && wrapper->wops->stream_metadata) { int option; void *value; - if (Z_TYPE_P(user) == IS_LONG) { + if (Z_TYPE_P(user) == IS_INT) { option = PHP_STREAM_META_OWNER; - value = &Z_LVAL_P(user); + value = &Z_IVAL_P(user); } else if (Z_TYPE_P(user) == IS_STRING) { option = PHP_STREAM_META_OWNER_NAME; value = Z_STRVAL_P(user); @@ -603,8 +603,8 @@ static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown) /* {{{ */ RETURN_FALSE; #else - if (Z_TYPE_P(user) == IS_LONG) { - uid = (uid_t)Z_LVAL_P(user); + if (Z_TYPE_P(user) == IS_INT) { + uid = (uid_t)Z_IVAL_P(user); } else if (Z_TYPE_P(user) == IS_STRING) { if(php_get_uid_by_name(Z_STRVAL_P(user), &uid TSRMLS_CC) != SUCCESS) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find uid for %s", Z_STRVAL_P(user)); @@ -962,21 +962,21 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ switch (type) { case FS_PERMS: - RETURN_LONG((long)ssb.sb.st_mode); + RETURN_INT((long)ssb.sb.st_mode); case FS_INODE: - RETURN_LONG((long)ssb.sb.st_ino); + RETURN_INT((long)ssb.sb.st_ino); case FS_SIZE: - RETURN_LONG((long)ssb.sb.st_size); + RETURN_INT((long)ssb.sb.st_size); case FS_OWNER: - RETURN_LONG((long)ssb.sb.st_uid); + RETURN_INT((long)ssb.sb.st_uid); case FS_GROUP: - RETURN_LONG((long)ssb.sb.st_gid); + RETURN_INT((long)ssb.sb.st_gid); case FS_ATIME: - RETURN_LONG((long)ssb.sb.st_atime); + RETURN_INT((long)ssb.sb.st_atime); case FS_MTIME: - RETURN_LONG((long)ssb.sb.st_mtime); + RETURN_INT((long)ssb.sb.st_mtime); case FS_CTIME: - RETURN_LONG((long)ssb.sb.st_ctime); + RETURN_INT((long)ssb.sb.st_ctime); case FS_TYPE: if (S_ISLNK(ssb.sb.st_mode)) { RETURN_STRING("link"); @@ -1012,30 +1012,30 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ case FS_STAT: array_init(return_value); - ZVAL_LONG(&stat_dev, stat_sb->st_dev); - ZVAL_LONG(&stat_ino, stat_sb->st_ino); - ZVAL_LONG(&stat_mode, stat_sb->st_mode); - ZVAL_LONG(&stat_nlink, stat_sb->st_nlink); - ZVAL_LONG(&stat_uid, stat_sb->st_uid); - ZVAL_LONG(&stat_gid, stat_sb->st_gid); + ZVAL_INT(&stat_dev, stat_sb->st_dev); + ZVAL_INT(&stat_ino, stat_sb->st_ino); + ZVAL_INT(&stat_mode, stat_sb->st_mode); + ZVAL_INT(&stat_nlink, stat_sb->st_nlink); + ZVAL_INT(&stat_uid, stat_sb->st_uid); + ZVAL_INT(&stat_gid, stat_sb->st_gid); #ifdef HAVE_ST_RDEV - ZVAL_LONG(&stat_rdev, stat_sb->st_rdev); + ZVAL_INT(&stat_rdev, stat_sb->st_rdev); #else - ZVAL_LONG(&stat_rdev, -1); + ZVAL_INT(&stat_rdev, -1); #endif - ZVAL_LONG(&stat_size, stat_sb->st_size); - ZVAL_LONG(&stat_atime, stat_sb->st_atime); - ZVAL_LONG(&stat_mtime, stat_sb->st_mtime); - ZVAL_LONG(&stat_ctime, stat_sb->st_ctime); + ZVAL_INT(&stat_size, stat_sb->st_size); + ZVAL_INT(&stat_atime, stat_sb->st_atime); + ZVAL_INT(&stat_mtime, stat_sb->st_mtime); + ZVAL_INT(&stat_ctime, stat_sb->st_ctime); #ifdef HAVE_ST_BLKSIZE - ZVAL_LONG(&stat_blksize, stat_sb->st_blksize); + ZVAL_INT(&stat_blksize, stat_sb->st_blksize); #else - ZVAL_LONG(&stat_blksize,-1); + ZVAL_INT(&stat_blksize,-1); #endif #ifdef HAVE_ST_BLOCKS - ZVAL_LONG(&stat_blocks, stat_sb->st_blocks); + ZVAL_INT(&stat_blocks, stat_sb->st_blocks); #else - ZVAL_LONG(&stat_blocks,-1); + ZVAL_INT(&stat_blocks,-1); #endif /* Store numeric indexes in propper order */ zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev); @@ -1201,7 +1201,7 @@ PHP_FUNCTION(realpath_cache_size) if (zend_parse_parameters_none() == FAILURE) { return; } - RETURN_LONG(realpath_cache_size(TSRMLS_C)); + RETURN_INT(realpath_cache_size(TSRMLS_C)); } /* {{{ proto bool realpath_cache_get() @@ -1224,13 +1224,13 @@ PHP_FUNCTION(realpath_cache_get) /* bucket->key is unsigned long */ if (LONG_MAX >= bucket->key) { - add_assoc_long(&entry, "key", bucket->key); + add_assoc_int(&entry, "key", bucket->key); } else { add_assoc_double(&entry, "key", (double)bucket->key); } add_assoc_bool(&entry, "is_dir", bucket->is_dir); add_assoc_stringl(&entry, "realpath", bucket->realpath, bucket->realpath_len); - add_assoc_long(&entry, "expires", bucket->expires); + add_assoc_int(&entry, "expires", bucket->expires); #ifdef PHP_WIN32 add_assoc_bool(&entry, "is_rvalid", bucket->is_rvalid); add_assoc_bool(&entry, "is_wvalid", bucket->is_wvalid); diff --git a/ext/standard/filters.c b/ext/standard/filters.c index d40321f959..b595252cc5 100644 --- a/ext/standard/filters.c +++ b/ext/standard/filters.c @@ -263,14 +263,14 @@ static php_stream_filter *strfilter_strip_tags_create(const char *filtername, zv ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(filterparams), tmp) { convert_to_string_ex(tmp); smart_str_appendc(&tags_ss, '<'); - smart_str_appendl(&tags_ss, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)); + smart_str_appendl(&tags_ss, Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); smart_str_appendc(&tags_ss, '>'); } ZEND_HASH_FOREACH_END(); smart_str_0(&tags_ss); } else { /* FIXME: convert_to_* may clutter zvals and lead it into segfault ? */ convert_to_string_ex(filterparams); - smart_str_setl(&tags_ss, Z_STRVAL_P(filterparams), Z_STRLEN_P(filterparams)); + smart_str_setl(&tags_ss, Z_STRVAL_P(filterparams), Z_STRSIZE_P(filterparams)); } } @@ -1241,13 +1241,13 @@ static php_conv_err_t php_conv_get_long_prop_ex(const HashTable *ht, long *pretv if (zend_hash_find((HashTable *)ht, field_name, field_name_len, (void **)&tmpval) == SUCCESS) { zval tmp, *ztval = *tmpval; - if (Z_TYPE_PP(tmpval) != IS_LONG) { + if (Z_TYPE_PP(tmpval) != IS_INT) { tmp = *ztval; zval_copy_ctor(&tmp); - convert_to_long(&tmp); + convert_to_int(&tmp); ztval = &tmp; } - *pretval = Z_LVAL_P(ztval); + *pretval = Z_IVAL_P(ztval); } else { return PHP_CONV_ERR_NOT_FOUND; } @@ -1264,15 +1264,15 @@ static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, unsigned l if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) { zval tmp; - if (Z_TYPE_P(tmpval) != IS_LONG) { + if (Z_TYPE_P(tmpval) != IS_INT) { ZVAL_DUP(&tmp, tmpval);; - convert_to_long(&tmp); + convert_to_int(&tmp); tmpval = &tmp; } - if (Z_LVAL_P(tmpval) < 0) { + if (Z_IVAL_P(tmpval) < 0) { *pretval = 0; } else { - *pretval = Z_LVAL_P(tmpval); + *pretval = Z_IVAL_P(tmpval); } } else { return PHP_CONV_ERR_NOT_FOUND; diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c index edd704b068..4725f46386 100644 --- a/ext/standard/formatted_print.c +++ b/ext/standard/formatted_print.c @@ -416,12 +416,12 @@ php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC) } format = Z_STRVAL(args[format_offset]); - format_len = Z_STRLEN(args[format_offset]); + format_len = Z_STRSIZE(args[format_offset]); result = STR_ALLOC(size, 0); currarg = 1; - while (inpos < Z_STRLEN(args[format_offset])) { + while (inpos < Z_STRSIZE(args[format_offset])) { int expprec = 0; zval *tmp; @@ -687,7 +687,7 @@ PHP_FUNCTION(user_printf) } rlen = PHPWRITE(result->val, result->len); STR_FREE(result); - RETURN_LONG(rlen); + RETURN_INT(rlen); } /* }}} */ @@ -703,7 +703,7 @@ PHP_FUNCTION(vprintf) } rlen = PHPWRITE(result->val, result->len); STR_FREE(result); - RETURN_LONG(rlen); + RETURN_INT(rlen); } /* }}} */ @@ -731,7 +731,7 @@ PHP_FUNCTION(fprintf) php_stream_write(stream, result->val, result->len); - RETVAL_LONG(result->len); + RETVAL_INT(result->len); STR_FREE(result); } /* }}} */ @@ -760,7 +760,7 @@ PHP_FUNCTION(vfprintf) php_stream_write(stream, result->val, result->len); - RETVAL_LONG(result->len); + RETVAL_INT(result->len); STR_FREE(result); } /* }}} */ diff --git a/ext/standard/fsock.c b/ext/standard/fsock.c index 300df8c1c0..f47331f6af 100644 --- a/ext/standard/fsock.c +++ b/ext/standard/fsock.c @@ -69,7 +69,7 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent) if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, 0); + ZVAL_INT(zerrno, 0); } if (zerrstr) { zval_dtor(zerrstr); @@ -93,7 +93,7 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent) if (stream == NULL) { if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, err); + ZVAL_INT(zerrno, err); } if (zerrstr && errstr) { /* no need to dup; we need to efree buf anyway */ diff --git a/ext/standard/ftok.c b/ext/standard/ftok.c index 4833bddc01..709d90840b 100644 --- a/ext/standard/ftok.c +++ b/ext/standard/ftok.c @@ -41,16 +41,16 @@ PHP_FUNCTION(ftok) if (pathname_len == 0){ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Pathname is invalid"); - RETURN_LONG(-1); + RETURN_INT(-1); } if (proj_len != 1){ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Project identifier is invalid"); - RETURN_LONG(-1); + RETURN_INT(-1); } if (php_check_open_basedir(pathname TSRMLS_CC)) { - RETURN_LONG(-1); + RETURN_INT(-1); } k = ftok(pathname, proj[0]); @@ -58,7 +58,7 @@ PHP_FUNCTION(ftok) php_error_docref(NULL TSRMLS_CC, E_WARNING, "ftok() failed - %s", strerror(errno)); } - RETURN_LONG(k); + RETURN_INT(k); } /* }}} */ #endif diff --git a/ext/standard/ftp_fopen_wrapper.c b/ext/standard/ftp_fopen_wrapper.c index 31b96fb68c..ae7f28b7da 100644 --- a/ext/standard/ftp_fopen_wrapper.c +++ b/ext/standard/ftp_fopen_wrapper.c @@ -498,7 +498,7 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa } else if (read_write == 2) { /* when writing file (but not appending), it must NOT exist, unless a context option exists which allows it */ if (context && (tmpzval = php_stream_context_get_option(context, "ftp", "overwrite")) != NULL) { - allow_overwrite = Z_LVAL_P(tmpzval); + allow_overwrite = Z_IVAL_P(tmpzval); } if (result <= 299 && result >= 200) { if (allow_overwrite) { @@ -529,12 +529,12 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa /* set resume position if applicable */ if (context && (tmpzval = php_stream_context_get_option(context, "ftp", "resume_pos")) != NULL && - Z_TYPE_P(tmpzval) == IS_LONG && - Z_LVAL_P(tmpzval) > 0) { - php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_LVAL_P(tmpzval)); + Z_TYPE_P(tmpzval) == IS_INT && + Z_IVAL_P(tmpzval) > 0) { + php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_IVAL_P(tmpzval)); result = GET_FTP_RESULT(stream); if (result < 300 || result > 399) { - php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_LVAL_P(tmpzval)); + php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_IVAL_P(tmpzval)); goto errexit; } } diff --git a/ext/standard/head.c b/ext/standard/head.c index ad82b9fbbf..ec792bee2c 100644 --- a/ext/standard/head.c +++ b/ext/standard/head.c @@ -239,7 +239,7 @@ PHP_FUNCTION(headers_sent) switch(ZEND_NUM_ARGS()) { case 2: zval_dtor(arg2); - ZVAL_LONG(arg2, line); + ZVAL_INT(arg2, line); case 1: zval_dtor(arg1); if (file) { @@ -303,7 +303,7 @@ PHP_FUNCTION(http_response_code) SG(sapi_headers).http_response_code = response_code; if (old_response_code) { - RETURN_LONG(old_response_code); + RETURN_INT(old_response_code); } RETURN_TRUE; @@ -313,7 +313,7 @@ PHP_FUNCTION(http_response_code) RETURN_FALSE; } - RETURN_LONG(SG(sapi_headers).http_response_code); + RETURN_INT(SG(sapi_headers).http_response_code); } /* }}} */ diff --git a/ext/standard/html.c b/ext/standard/html.c index 360639ea76..e072abd3a4 100644 --- a/ext/standard/html.c +++ b/ext/standard/html.c @@ -1477,18 +1477,18 @@ static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all) */ void register_html_constants(INIT_FUNC_ARGS) { - REGISTER_LONG_CONSTANT("HTML_SPECIALCHARS", HTML_SPECIALCHARS, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("HTML_ENTITIES", HTML_ENTITIES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_COMPAT", ENT_COMPAT, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_QUOTES", ENT_QUOTES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_NOQUOTES", ENT_NOQUOTES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_IGNORE", ENT_IGNORE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_SUBSTITUTE", ENT_SUBSTITUTE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_DISALLOWED", ENT_DISALLOWED, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_HTML401", ENT_HTML401, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_XML1", ENT_XML1, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_XHTML", ENT_XHTML, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_HTML5", ENT_HTML5, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("HTML_SPECIALCHARS", HTML_SPECIALCHARS, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("HTML_ENTITIES", HTML_ENTITIES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_COMPAT", ENT_COMPAT, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_QUOTES", ENT_QUOTES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_NOQUOTES", ENT_NOQUOTES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_IGNORE", ENT_IGNORE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_SUBSTITUTE", ENT_SUBSTITUTE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_DISALLOWED", ENT_DISALLOWED, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_HTML401", ENT_HTML401, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_XML1", ENT_XML1, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_XHTML", ENT_XHTML, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_HTML5", ENT_HTML5, CONST_PERSISTENT|CONST_CS); } /* }}} */ diff --git a/ext/standard/http.c b/ext/standard/http.c index 34b8e79389..a3eb8246d3 100644 --- a/ext/standard/http.c +++ b/ext/standard/http.c @@ -178,19 +178,19 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, case IS_STRING: { zend_string *ekey; if (enc_type == PHP_QUERY_RFC3986) { - ekey = php_raw_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)); + ekey = php_raw_url_encode(Z_STRVAL_P(zdata), Z_STRSIZE_P(zdata)); } else { - ekey = php_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)); + ekey = php_url_encode(Z_STRVAL_P(zdata), Z_STRSIZE_P(zdata)); } smart_str_appendl(formstr, ekey->val, ekey->len); STR_FREE(ekey); } break; - case IS_LONG: + case IS_INT: { char *ekey; int ekey_len; - ekey_len = spprintf(&ekey, 0, "%ld", Z_LVAL_P(zdata)); + ekey_len = spprintf(&ekey, 0, "%ld", Z_IVAL_P(zdata)); smart_str_appendl(formstr, ekey, ekey_len); efree(ekey); } @@ -217,9 +217,9 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, ZVAL_DUP(©zval, zdata); convert_to_string_ex(©zval); if (enc_type == PHP_QUERY_RFC3986) { - ekey = php_raw_url_encode(Z_STRVAL(copyzval), Z_STRLEN(copyzval)); + ekey = php_raw_url_encode(Z_STRVAL(copyzval), Z_STRSIZE(copyzval)); } else { - ekey = php_url_encode(Z_STRVAL(copyzval), Z_STRLEN(copyzval)); + ekey = php_url_encode(Z_STRVAL(copyzval), Z_STRSIZE(copyzval)); } smart_str_appendl(formstr, ekey->val, ekey->len); zval_ptr_dtor(©zval); diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c index 73952dda31..ffec818037 100644 --- a/ext/standard/http_fopen_wrapper.c +++ b/ext/standard/http_fopen_wrapper.c @@ -160,7 +160,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, if (!context || (tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "proxy")) == NULL || Z_TYPE_P(tmpzval) != IS_STRING || - Z_STRLEN_P(tmpzval) <= 0) { + Z_STRSIZE_P(tmpzval) <= 0) { php_url_free(resource); return php_stream_open_wrapper_ex(path, mode, REPORT_ERRORS, NULL, context); } @@ -169,8 +169,8 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, use_ssl = 0; use_proxy = 1; - transport_len = Z_STRLEN_P(tmpzval); - transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval)); + transport_len = Z_STRSIZE_P(tmpzval); + transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval)); } else { /* Normal http request (possibly with proxy) */ @@ -190,10 +190,10 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, if (context && (tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "proxy")) != NULL && Z_TYPE_P(tmpzval) == IS_STRING && - Z_STRLEN_P(tmpzval) > 0) { + Z_STRSIZE_P(tmpzval) > 0) { use_proxy = 1; - transport_len = Z_STRLEN_P(tmpzval); - transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval)); + transport_len = Z_STRSIZE_P(tmpzval); + transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval)); } else { transport_len = spprintf(&transport_string, 0, "%s://%s:%d", use_ssl ? "ssl" : "tcp", resource->host, resource->port); } @@ -271,7 +271,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, } while (*s != 0); } } ZEND_HASH_FOREACH_END(); - } else if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval)) { + } else if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval)) { s = Z_STRVAL_P(tmpzval); do { while (*s == ' ' || *s == '\t') s++; @@ -350,16 +350,16 @@ finish: } if (context && (tmpzval = php_stream_context_get_option(context, "http", "method")) != NULL) { - if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0) { + if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval) > 0) { /* As per the RFC, automatically redirected requests MUST NOT use other methods than * GET and HEAD unless it can be confirmed by the user */ if (!redirected - || (Z_STRLEN_P(tmpzval) == 3 && memcmp("GET", Z_STRVAL_P(tmpzval), 3) == 0) - || (Z_STRLEN_P(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_P(tmpzval), 4) == 0) + || (Z_STRSIZE_P(tmpzval) == 3 && memcmp("GET", Z_STRVAL_P(tmpzval), 3) == 0) + || (Z_STRSIZE_P(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_P(tmpzval), 4) == 0) ) { - scratch_len = strlen(path) + 29 + Z_STRLEN_P(tmpzval); + scratch_len = strlen(path) + 29 + Z_STRSIZE_P(tmpzval); scratch = emalloc(scratch_len); - strlcpy(scratch, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval) + 1); + strlcpy(scratch, Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval) + 1); strncat(scratch, " ", 1); } } @@ -422,7 +422,7 @@ finish: ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmpzval), tmpheader) { if (Z_TYPE_P(tmpheader) == IS_STRING) { - smart_str_appendl(&tmpstr, Z_STRVAL_P(tmpheader), Z_STRLEN_P(tmpheader)); + smart_str_appendl(&tmpstr, Z_STRVAL_P(tmpheader), Z_STRSIZE_P(tmpheader)); smart_str_appendl(&tmpstr, "\r\n", sizeof("\r\n") - 1); } } ZEND_HASH_FOREACH_END(); @@ -433,9 +433,9 @@ finish: smart_str_free(&tmpstr); } } - if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval)) { + if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval)) { /* Remove newlines and spaces from start and end php_trim will estrndup() */ - tmp = php_trim(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC); + tmp = php_trim(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC); } if (tmp && strlen(tmp) > 0) { char *s; @@ -609,9 +609,9 @@ finish: context && !(have_header & HTTP_HEADER_CONTENT_LENGTH) && (tmpzval = php_stream_context_get_option(context, "http", "content")) != NULL && - Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0 + Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval) > 0 ) { - scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_P(tmpzval)); + scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRSIZE_P(tmpzval)); php_stream_write(stream, scratch, scratch_len); have_header |= HTTP_HEADER_CONTENT_LENGTH; } @@ -624,9 +624,9 @@ finish: /* Request content, such as for POST requests */ if (header_init && context && (tmpzval = php_stream_context_get_option(context, "http", "content")) != NULL && - Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0) { + Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval) > 0) { if (!(have_header & HTTP_HEADER_CONTENT_LENGTH)) { - scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_P(tmpzval)); + scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRSIZE_P(tmpzval)); php_stream_write(stream, scratch, scratch_len); } if (!(have_header & HTTP_HEADER_TYPE)) { @@ -635,7 +635,7 @@ finish: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Content-type not specified assuming application/x-www-form-urlencoded"); } php_stream_write(stream, "\r\n", sizeof("\r\n")-1); - php_stream_write(stream, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval)); + php_stream_write(stream, Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval)); } else { php_stream_write(stream, "\r\n", sizeof("\r\n")-1); } diff --git a/ext/standard/image.c b/ext/standard/image.c index 0ec4cd3885..87ab458800 100644 --- a/ext/standard/image.c +++ b/ext/standard/image.c @@ -72,28 +72,28 @@ struct gfxinfo { * Register IMAGETYPE_<xxx> constants used by GetImageSize(), image_type_to_mime_type, ext/exif */ PHP_MINIT_FUNCTION(imagetypes) { - REGISTER_LONG_CONSTANT("IMAGETYPE_GIF", IMAGE_FILETYPE_GIF, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPEG", IMAGE_FILETYPE_JPEG, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_PNG", IMAGE_FILETYPE_PNG, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_SWF", IMAGE_FILETYPE_SWF, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_PSD", IMAGE_FILETYPE_PSD, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_BMP", IMAGE_FILETYPE_BMP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_TIFF_II", IMAGE_FILETYPE_TIFF_II, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_TIFF_MM", IMAGE_FILETYPE_TIFF_MM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPC", IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JP2", IMAGE_FILETYPE_JP2, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPX", IMAGE_FILETYPE_JPX, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JB2", IMAGE_FILETYPE_JB2, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_GIF", IMAGE_FILETYPE_GIF, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPEG", IMAGE_FILETYPE_JPEG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_PNG", IMAGE_FILETYPE_PNG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_SWF", IMAGE_FILETYPE_SWF, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_PSD", IMAGE_FILETYPE_PSD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_BMP", IMAGE_FILETYPE_BMP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_TIFF_II", IMAGE_FILETYPE_TIFF_II, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_TIFF_MM", IMAGE_FILETYPE_TIFF_MM, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPC", IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JP2", IMAGE_FILETYPE_JP2, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPX", IMAGE_FILETYPE_JPX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JB2", IMAGE_FILETYPE_JB2, CONST_CS | CONST_PERSISTENT); #if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB) - REGISTER_LONG_CONSTANT("IMAGETYPE_SWC", IMAGE_FILETYPE_SWC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_SWC", IMAGE_FILETYPE_SWC, CONST_CS | CONST_PERSISTENT); #endif - REGISTER_LONG_CONSTANT("IMAGETYPE_IFF", IMAGE_FILETYPE_IFF, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_WBMP", IMAGE_FILETYPE_WBMP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPEG2000",IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); /* keep alias */ - REGISTER_LONG_CONSTANT("IMAGETYPE_XBM", IMAGE_FILETYPE_XBM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_ICO", IMAGE_FILETYPE_ICO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_UNKNOWN", IMAGE_FILETYPE_UNKNOWN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_COUNT", IMAGE_FILETYPE_COUNT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_IFF", IMAGE_FILETYPE_IFF, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_WBMP", IMAGE_FILETYPE_WBMP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPEG2000",IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); /* keep alias */ + REGISTER_INT_CONSTANT("IMAGETYPE_XBM", IMAGE_FILETYPE_XBM, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_ICO", IMAGE_FILETYPE_ICO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_UNKNOWN", IMAGE_FILETYPE_UNKNOWN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_COUNT", IMAGE_FILETYPE_COUNT, CONST_CS | CONST_PERSISTENT); return SUCCESS; } /* }}} */ @@ -1364,19 +1364,19 @@ static void php_getimagesize_from_stream(php_stream *stream, zval *info, INTERNA } if (result) { - char temp[MAX_LENGTH_OF_LONG * 2 + sizeof("width=\"\" height=\"\"")]; + char temp[MAX_LENGTH_OF_ZEND_INT * 2 + sizeof("width=\"\" height=\"\"")]; array_init(return_value); - add_index_long(return_value, 0, result->width); - add_index_long(return_value, 1, result->height); - add_index_long(return_value, 2, itype); + add_index_int(return_value, 0, result->width); + add_index_int(return_value, 1, result->height); + add_index_int(return_value, 2, itype); snprintf(temp, sizeof(temp), "width=\"%d\" height=\"%d\"", result->width, result->height); add_index_string(return_value, 3, temp); if (result->bits != 0) { - add_assoc_long(return_value, "bits", result->bits); + add_assoc_int(return_value, "bits", result->bits); } if (result->channels != 0) { - add_assoc_long(return_value, "channels", result->channels); + add_assoc_int(return_value, "channels", result->channels); } add_assoc_string(return_value, "mime", (char*)php_image_type_to_mime_type(itype)); efree(result); diff --git a/ext/standard/info.c b/ext/standard/info.c index 47249466b0..15ecd0433a 100644 --- a/ext/standard/info.c +++ b/ext/standard/info.c @@ -244,10 +244,10 @@ static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC) } if (!sapi_module.phpinfo_as_text) { - if (Z_STRLEN(tmp2) == 0) { + if (Z_STRSIZE(tmp2) == 0) { php_info_print("<i>no value</i>"); } else { - php_info_print_html_esc(Z_STRVAL(tmp2), Z_STRLEN(tmp2)); + php_info_print_html_esc(Z_STRVAL(tmp2), Z_STRSIZE(tmp2)); } } else { php_info_print(Z_STRVAL(tmp2)); @@ -1143,22 +1143,22 @@ PHPAPI void php_info_print_table_row_ex(int num_cols, const char *value_class, */ void register_phpinfo_constants(INIT_FUNC_ARGS) { - REGISTER_LONG_CONSTANT("INFO_GENERAL", PHP_INFO_GENERAL, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_CREDITS", PHP_INFO_CREDITS, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_CONFIGURATION", PHP_INFO_CONFIGURATION, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_MODULES", PHP_INFO_MODULES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_ENVIRONMENT", PHP_INFO_ENVIRONMENT, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_VARIABLES", PHP_INFO_VARIABLES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_LICENSE", PHP_INFO_LICENSE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_ALL", PHP_INFO_ALL, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_GROUP", PHP_CREDITS_GROUP, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_GENERAL", PHP_CREDITS_GENERAL, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_SAPI", PHP_CREDITS_SAPI, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_MODULES", PHP_CREDITS_MODULES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_DOCS", PHP_CREDITS_DOCS, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_FULLPAGE", PHP_CREDITS_FULLPAGE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_QA", PHP_CREDITS_QA, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_ALL", PHP_CREDITS_ALL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_GENERAL", PHP_INFO_GENERAL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_CREDITS", PHP_INFO_CREDITS, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_CONFIGURATION", PHP_INFO_CONFIGURATION, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_MODULES", PHP_INFO_MODULES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_ENVIRONMENT", PHP_INFO_ENVIRONMENT, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_VARIABLES", PHP_INFO_VARIABLES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_LICENSE", PHP_INFO_LICENSE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_ALL", PHP_INFO_ALL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_GROUP", PHP_CREDITS_GROUP, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_GENERAL", PHP_CREDITS_GENERAL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_SAPI", PHP_CREDITS_SAPI, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_MODULES", PHP_CREDITS_MODULES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_DOCS", PHP_CREDITS_DOCS, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_FULLPAGE", PHP_CREDITS_FULLPAGE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_QA", PHP_CREDITS_QA, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_ALL", PHP_CREDITS_ALL, CONST_PERSISTENT|CONST_CS); } /* }}} */ diff --git a/ext/standard/levenshtein.c b/ext/standard/levenshtein.c index 786ca052d7..86ce0f2fbe 100644 --- a/ext/standard/levenshtein.c +++ b/ext/standard/levenshtein.c @@ -128,7 +128,7 @@ PHP_FUNCTION(levenshtein) php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument string(s) too long"); } - RETURN_LONG(distance); + RETURN_INT(distance); } /* }}} */ diff --git a/ext/standard/link.c b/ext/standard/link.c index 0f889a9e6a..4265823616 100644 --- a/ext/standard/link.c +++ b/ext/standard/link.c @@ -106,11 +106,11 @@ PHP_FUNCTION(linkinfo) if (ret == -1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno)); efree(dirname); - RETURN_LONG(-1L); + RETURN_INT(-1L); } efree(dirname); - RETURN_LONG((long) sb.st_dev); + RETURN_INT((long) sb.st_dev); } /* }}} */ diff --git a/ext/standard/link_win32.c b/ext/standard/link_win32.c index 41ce9d20df..60556c1fe2 100644 --- a/ext/standard/link_win32.c +++ b/ext/standard/link_win32.c @@ -98,10 +98,10 @@ PHP_FUNCTION(linkinfo) ret = VCWD_STAT(link, &sb); if (ret == -1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno)); - RETURN_LONG(-1L); + RETURN_INT(-1L); } - RETURN_LONG((long) sb.st_dev); + RETURN_INT((long) sb.st_dev); } /* }}} */ diff --git a/ext/standard/mail.c b/ext/standard/mail.c index 815f83118f..b08c4858e8 100644 --- a/ext/standard/mail.c +++ b/ext/standard/mail.c @@ -92,7 +92,7 @@ PHP_FUNCTION(ezmlm_hash) h = (h % 53); - RETURN_LONG((int) h); + RETURN_INT((int) h); } /* }}} */ diff --git a/ext/standard/math.c b/ext/standard/math.c index a392eb607c..a5387458f4 100644 --- a/ext/standard/math.c +++ b/ext/standard/math.c @@ -285,11 +285,11 @@ PHP_FUNCTION(abs) if (Z_TYPE_P(value) == IS_DOUBLE) { RETURN_DOUBLE(fabs(Z_DVAL_P(value))); - } else if (Z_TYPE_P(value) == IS_LONG) { - if (Z_LVAL_P(value) == LONG_MIN) { + } else if (Z_TYPE_P(value) == IS_INT) { + if (Z_IVAL_P(value) == LONG_MIN) { RETURN_DOUBLE(-(double)LONG_MIN); } else { - RETURN_LONG(Z_LVAL_P(value) < 0 ? -Z_LVAL_P(value) : Z_LVAL_P(value)); + RETURN_INT(Z_IVAL_P(value) < 0 ? -Z_IVAL_P(value) : Z_IVAL_P(value)); } } RETURN_FALSE; @@ -309,7 +309,7 @@ PHP_FUNCTION(ceil) if (Z_TYPE_P(value) == IS_DOUBLE) { RETURN_DOUBLE(ceil(Z_DVAL_P(value))); - } else if (Z_TYPE_P(value) == IS_LONG) { + } else if (Z_TYPE_P(value) == IS_INT) { RETURN_DOUBLE(zval_get_double(value)); } RETURN_FALSE; @@ -329,7 +329,7 @@ PHP_FUNCTION(floor) if (Z_TYPE_P(value) == IS_DOUBLE) { RETURN_DOUBLE(floor(Z_DVAL_P(value))); - } else if (Z_TYPE_P(value) == IS_LONG) { + } else if (Z_TYPE_P(value) == IS_INT) { RETURN_DOUBLE(zval_get_double(value)); } RETURN_FALSE; @@ -356,15 +356,15 @@ PHP_FUNCTION(round) convert_scalar_to_number_ex(value); switch (Z_TYPE_P(value)) { - case IS_LONG: + case IS_INT: /* Simple case - long that doesn't need to be rounded. */ if (places >= 0) { - RETURN_DOUBLE((double) Z_LVAL_P(value)); + RETURN_DOUBLE((double) Z_IVAL_P(value)); } /* break omitted intentionally */ case IS_DOUBLE: - return_val = (Z_TYPE_P(value) == IS_LONG) ? (double)Z_LVAL_P(value) : Z_DVAL_P(value); + return_val = (Z_TYPE_P(value) == IS_INT) ? (double)Z_IVAL_P(value) : Z_DVAL_P(value); return_val = _php_math_round(return_val, places, mode); RETURN_DOUBLE(return_val); break; @@ -938,7 +938,7 @@ PHPAPI long _php_math_basetolong(zval *arg, int base) s = Z_STRVAL_P(arg); - for (i = Z_STRLEN_P(arg); i > 0; i--) { + for (i = Z_STRSIZE_P(arg); i > 0; i--) { c = *s++; digit = (c >= '0' && c <= '9') ? c - '0' @@ -990,7 +990,7 @@ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret) cutoff = LONG_MAX / base; cutlim = LONG_MAX % base; - for (i = Z_STRLEN_P(arg); i > 0; i--) { + for (i = Z_STRSIZE_P(arg); i > 0; i--) { c = *s++; /* might not work for EBCDIC */ @@ -1024,7 +1024,7 @@ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret) if (mode == 1) { ZVAL_DOUBLE(ret, fnum); } else { - ZVAL_LONG(ret, num); + ZVAL_INT(ret, num); } return SUCCESS; } @@ -1042,11 +1042,11 @@ PHPAPI zend_string * _php_math_longtobase(zval *arg, int base TSRMLS_DC) char *ptr, *end; unsigned long value; - if (Z_TYPE_P(arg) != IS_LONG || base < 2 || base > 36) { + if (Z_TYPE_P(arg) != IS_INT || base < 2 || base > 36) { return STR_EMPTY_ALLOC(); } - value = Z_LVAL_P(arg); + value = Z_IVAL_P(arg); end = ptr = buf + sizeof(buf) - 1; *ptr = '\0'; @@ -1069,7 +1069,7 @@ PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC) { static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; - if ((Z_TYPE_P(arg) != IS_LONG && Z_TYPE_P(arg) != IS_DOUBLE) || base < 2 || base > 36) { + if ((Z_TYPE_P(arg) != IS_INT && Z_TYPE_P(arg) != IS_DOUBLE) || base < 2 || base > 36) { return STR_EMPTY_ALLOC(); } @@ -1157,7 +1157,7 @@ PHP_FUNCTION(decbin) if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { return; } - convert_to_long_ex(arg); + convert_to_int_ex(arg); result = _php_math_longtobase(arg, 2 TSRMLS_CC); RETURN_STR(result); } @@ -1173,7 +1173,7 @@ PHP_FUNCTION(decoct) if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { return; } - convert_to_long_ex(arg); + convert_to_int_ex(arg); result = _php_math_longtobase(arg, 8 TSRMLS_CC); RETURN_STR(result); } @@ -1189,7 +1189,7 @@ PHP_FUNCTION(dechex) if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { return; } - convert_to_long_ex(arg); + convert_to_int_ex(arg); result = _php_math_longtobase(arg, 16 TSRMLS_CC); RETURN_STR(result); } @@ -1434,10 +1434,10 @@ PHP_FUNCTION(intdiv) } else if (divisor == -1 && numerator == LONG_MIN) { /* Prevent overflow error/crash We don't return a float here as that violates function contract */ - RETURN_LONG(0); + RETURN_INT(0); } - RETURN_LONG(numerator/divisor); + RETURN_INT(numerator/divisor); } /* }}} */ diff --git a/ext/standard/microtime.c b/ext/standard/microtime.c index f8e19c74ca..3cadf729cc 100644 --- a/ext/standard/microtime.c +++ b/ext/standard/microtime.c @@ -73,11 +73,11 @@ static void _php_gettimeofday(INTERNAL_FUNCTION_PARAMETERS, int mode) offset = timelib_get_time_zone_info(tp.tv_sec, get_timezone_info(TSRMLS_C)); array_init(return_value); - add_assoc_long(return_value, "sec", tp.tv_sec); - add_assoc_long(return_value, "usec", tp.tv_usec); + add_assoc_int(return_value, "sec", tp.tv_sec); + add_assoc_int(return_value, "usec", tp.tv_usec); - add_assoc_long(return_value, "minuteswest", -offset->offset / SEC_IN_MIN); - add_assoc_long(return_value, "dsttime", offset->is_dst); + add_assoc_int(return_value, "minuteswest", -offset->offset / SEC_IN_MIN); + add_assoc_int(return_value, "dsttime", offset->is_dst); timelib_time_offset_dtor(offset); } else { @@ -130,7 +130,7 @@ PHP_FUNCTION(getrusage) array_init(return_value); #define PHP_RUSAGE_PARA(a) \ - add_assoc_long(return_value, #a, usg.a) + add_assoc_int(return_value, #a, usg.a) #if !defined( _OSD_POSIX) && !defined(__BEOS__) /* BS2000 has only a few fields in the rusage struct */ PHP_RUSAGE_PARA(ru_oublock); PHP_RUSAGE_PARA(ru_inblock); diff --git a/ext/standard/pack.c b/ext/standard/pack.c index c77a1a40c6..90fef0f855 100644 --- a/ext/standard/pack.c +++ b/ext/standard/pack.c @@ -89,8 +89,8 @@ static void php_pack(zval *val, int size, int *map, char *output) int i; char *v; - convert_to_long_ex(val); - v = (char *) &Z_LVAL_P(val); + convert_to_int_ex(val); + v = (char *) &Z_IVAL_P(val); for (i = 0; i < size; i++) { *output++ = v[map[i]]; @@ -126,7 +126,7 @@ PHP_FUNCTION(pack) convert_to_string_ex(&argv[0]); format = Z_STRVAL(argv[0]); - formatlen = Z_STRLEN(argv[0]); + formatlen = Z_STRSIZE(argv[0]); /* We have a maximum of <formatlen> format codes to deal with */ formatcodes = safe_emalloc(formatlen, sizeof(*formatcodes), 0); @@ -185,7 +185,7 @@ PHP_FUNCTION(pack) SEPARATE_ZVAL(&argv[currentarg]); } convert_to_string_ex(&argv[currentarg]); - arg = Z_STRLEN(argv[currentarg]); + arg = Z_STRSIZE(argv[currentarg]); if (code == 'Z') { /* add one because Z is always NUL-terminated: * pack("Z*", "aa") === "aa\0" @@ -771,7 +771,7 @@ PHP_FUNCTION(unpack) case 'C': { int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0; long v = php_unpack(&input[inputpos], 1, issigned, byte_map); - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } @@ -792,7 +792,7 @@ PHP_FUNCTION(unpack) } v = php_unpack(&input[inputpos], 2, issigned, map); - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } @@ -806,7 +806,7 @@ PHP_FUNCTION(unpack) } v = php_unpack(&input[inputpos], sizeof(int), issigned, int_map); - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } @@ -840,7 +840,7 @@ PHP_FUNCTION(unpack) v = (unsigned int) v; } } - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } @@ -948,8 +948,8 @@ PHP_MINIT_FUNCTION(pack) } else { zval val; - int size = sizeof(Z_LVAL(val)); - Z_LVAL(val)=0; /*silence a warning*/ + int size = sizeof(Z_IVAL(val)); + Z_IVAL(val)=0; /*silence a warning*/ /* Where to get hi to lo bytes from */ byte_map[0] = size - 1; diff --git a/ext/standard/pageinfo.c b/ext/standard/pageinfo.c index a9a4e58de0..9f7cab6edf 100644 --- a/ext/standard/pageinfo.c +++ b/ext/standard/pageinfo.c @@ -106,7 +106,7 @@ PHP_FUNCTION(getmyuid) if (uid < 0) { RETURN_FALSE; } else { - RETURN_LONG(uid); + RETURN_INT(uid); } } /* }}} */ @@ -125,7 +125,7 @@ PHP_FUNCTION(getmygid) if (gid < 0) { RETURN_FALSE; } else { - RETURN_LONG(gid); + RETURN_INT(gid); } } /* }}} */ @@ -144,7 +144,7 @@ PHP_FUNCTION(getmypid) if (pid < 0) { RETURN_FALSE; } else { - RETURN_LONG((long) pid); + RETURN_INT((long) pid); } } /* }}} */ @@ -161,7 +161,7 @@ PHP_FUNCTION(getmyinode) if (BG(page_inode) < 0) { RETURN_FALSE; } else { - RETURN_LONG(BG(page_inode)); + RETURN_INT(BG(page_inode)); } } /* }}} */ @@ -186,7 +186,7 @@ PHP_FUNCTION(getlastmod) if (lm < 0) { RETURN_FALSE; } else { - RETURN_LONG(lm); + RETURN_INT(lm); } } /* }}} */ diff --git a/ext/standard/password.c b/ext/standard/password.c index aa50ab1f00..d001e475f0 100644 --- a/ext/standard/password.c +++ b/ext/standard/password.c @@ -37,10 +37,10 @@ PHP_MINIT_FUNCTION(password) /* {{{ */ { - REGISTER_LONG_CONSTANT("PASSWORD_DEFAULT", PHP_PASSWORD_DEFAULT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PASSWORD_BCRYPT", PHP_PASSWORD_BCRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PASSWORD_DEFAULT", PHP_PASSWORD_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PASSWORD_BCRYPT", PHP_PASSWORD_BCRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PASSWORD_BCRYPT_DEFAULT_COST", PHP_PASSWORD_BCRYPT_COST, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PASSWORD_BCRYPT_DEFAULT_COST", PHP_PASSWORD_BCRYPT_COST, CONST_CS | CONST_PERSISTENT); return SUCCESS; } @@ -197,7 +197,7 @@ PHP_FUNCTION(password_get_info) { long cost = PHP_PASSWORD_BCRYPT_COST; sscanf(hash, "$2y$%ld$", &cost); - add_assoc_long(&options, "cost", cost); + add_assoc_int(&options, "cost", cost); } break; case PHP_PASSWORD_UNKNOWN: @@ -207,7 +207,7 @@ PHP_FUNCTION(password_get_info) array_init(return_value); - add_assoc_long(return_value, "algo", algo); + add_assoc_int(return_value, "algo", algo); add_assoc_string(return_value, "algoName", algo_name); add_assoc_zval(return_value, "options", &options); } @@ -242,14 +242,14 @@ PHP_FUNCTION(password_needs_rehash) long new_cost = PHP_PASSWORD_BCRYPT_COST, cost = 0; if (options && (option_buffer = zend_symtable_str_find(options, "cost", sizeof("cost")-1)) != NULL) { - if (Z_TYPE_P(option_buffer) != IS_LONG) { + if (Z_TYPE_P(option_buffer) != IS_INT) { zval cast_option_buffer; ZVAL_DUP(&cast_option_buffer, option_buffer); - convert_to_long(&cast_option_buffer); - new_cost = Z_LVAL(cast_option_buffer); + convert_to_int(&cast_option_buffer); + new_cost = Z_IVAL(cast_option_buffer); zval_dtor(&cast_option_buffer); } else { - new_cost = Z_LVAL_P(option_buffer); + new_cost = Z_IVAL_P(option_buffer); } } @@ -324,14 +324,14 @@ PHP_FUNCTION(password_hash) long cost = PHP_PASSWORD_BCRYPT_COST; if (options && (option_buffer = zend_symtable_str_find(options, "cost", sizeof("cost")-1)) != NULL) { - if (Z_TYPE_P(option_buffer) != IS_LONG) { + if (Z_TYPE_P(option_buffer) != IS_INT) { zval cast_option_buffer; ZVAL_DUP(&cast_option_buffer, option_buffer); - convert_to_long(&cast_option_buffer); - cost = Z_LVAL(cast_option_buffer); + convert_to_int(&cast_option_buffer); + cost = Z_IVAL(cast_option_buffer); zval_dtor(&cast_option_buffer); } else { - cost = Z_LVAL_P(option_buffer); + cost = Z_IVAL_P(option_buffer); } } @@ -358,10 +358,10 @@ PHP_FUNCTION(password_hash) size_t buffer_len; switch (Z_TYPE_P(option_buffer)) { case IS_STRING: - buffer = estrndup(Z_STRVAL_P(option_buffer), Z_STRLEN_P(option_buffer)); - buffer_len_int = Z_STRLEN_P(option_buffer); + buffer = estrndup(Z_STRVAL_P(option_buffer), Z_STRSIZE_P(option_buffer)); + buffer_len_int = Z_STRSIZE_P(option_buffer); break; - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_OBJECT: { zval cast_option_buffer; @@ -369,8 +369,8 @@ PHP_FUNCTION(password_hash) ZVAL_DUP(&cast_option_buffer, option_buffer); convert_to_string(&cast_option_buffer); if (Z_TYPE(cast_option_buffer) == IS_STRING) { - buffer = estrndup(Z_STRVAL(cast_option_buffer), Z_STRLEN(cast_option_buffer)); - buffer_len_int = Z_STRLEN(cast_option_buffer); + buffer = estrndup(Z_STRVAL(cast_option_buffer), Z_STRSIZE(cast_option_buffer)); + buffer_len_int = Z_STRSIZE(cast_option_buffer); zval_dtor(&cast_option_buffer); break; } diff --git a/ext/standard/php_smart_str.h b/ext/standard/php_smart_str.h index 71bcf0b223..2c8c966540 100644 --- a/ext/standard/php_smart_str.h +++ b/ext/standard/php_smart_str.h @@ -91,8 +91,8 @@ smart_str_appendl_ex((dest), (src), (len), 0) #define smart_str_append(dest, src) \ smart_str_append_ex((dest), (src), 0) -#define smart_str_append_long(dest, val) \ - smart_str_append_long_ex((dest), (val), 0) +#define smart_str_append_int(dest, val) \ + smart_str_append_int_ex((dest), (val), 0) #define smart_str_append_off_t(dest, val) \ smart_str_append_off_t_ex((dest), (val), 0) #define smart_str_append_unsigned(dest, val) \ @@ -152,7 +152,7 @@ static inline char *smart_str_print_unsigned(char *buf, long num) { #define smart_str_append_unsigned_ex(dest, num, type) \ smart_str_append_generic_ex((dest), (num), (type), unsigned long, _unsigned) -#define smart_str_append_long_ex(dest, num, type) \ +#define smart_str_append_int_ex(dest, num, type) \ smart_str_append_generic_ex((dest), (num), (type), unsigned long, _signed) #define smart_str_append_off_t_ex(dest, num, type) \ diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c index dea8c16c07..84986c2e03 100644 --- a/ext/standard/proc_open.c +++ b/ext/standard/proc_open.c @@ -300,7 +300,7 @@ PHP_FUNCTION(proc_close) FG(pclose_wait) = 1; zend_list_close(Z_RES_P(zproc)); FG(pclose_wait) = 0; - RETURN_LONG(FG(pclose_ret)); + RETURN_INT(FG(pclose_ret)); } /* }}} */ @@ -328,7 +328,7 @@ PHP_FUNCTION(proc_get_status) array_init(return_value); add_assoc_string(return_value, "command", proc->command); - add_assoc_long(return_value, "pid", (long) proc->child); + add_assoc_int(return_value, "pid", (long) proc->child); #ifdef PHP_WIN32 @@ -368,9 +368,9 @@ PHP_FUNCTION(proc_get_status) add_assoc_bool(return_value, "running", running); add_assoc_bool(return_value, "signaled", signaled); add_assoc_bool(return_value, "stopped", stopped); - add_assoc_long(return_value, "exitcode", exitcode); - add_assoc_long(return_value, "termsig", termsig); - add_assoc_long(return_value, "stopsig", stopsig); + add_assoc_int(return_value, "exitcode", exitcode); + add_assoc_int(return_value, "termsig", termsig); + add_assoc_int(return_value, "stopsig", stopsig); } /* }}} */ @@ -471,14 +471,14 @@ PHP_FUNCTION(proc_open) if (other_options) { zval *item = zend_hash_str_find(Z_ARRVAL_P(other_options), "suppress_errors", sizeof("suppress_errors") - 1); if (item != NULL) { - if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_LONG) && Z_LVAL_P(item))) { + if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_INT) && Z_IVAL_P(item))) { suppress_errors = 1; } } item = zend_hash_str_find(Z_ARRVAL_P(other_options), "bypass_shell", sizeof("bypass_shell") - 1); if (item != NULL) { - if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_LONG) && Z_LVAL_P(item))) { + if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_INT) && Z_IVAL_P(item))) { bypass_shell = 1; } } @@ -584,7 +584,7 @@ PHP_FUNCTION(proc_open) #endif descriptors[ndesc].mode_flags = descriptors[ndesc].mode & DESC_PARENT_MODE_WRITE ? O_WRONLY : O_RDONLY; #ifdef PHP_WIN32 - if (Z_STRLEN_P(zmode) >= 2 && Z_STRVAL_P(zmode)[1] == 'b') + if (Z_STRSIZE_P(zmode) >= 2 && Z_STRVAL_P(zmode)[1] == 'b') descriptors[ndesc].mode_flags |= O_BINARY; #endif diff --git a/ext/standard/rand.c b/ext/standard/rand.c index 702fec2311..3029ed28bc 100644 --- a/ext/standard/rand.c +++ b/ext/standard/rand.c @@ -301,7 +301,7 @@ PHP_FUNCTION(rand) RAND_RANGE(number, min, max, PHP_RAND_MAX); } - RETURN_LONG(number); + RETURN_INT(number); } /* }}} */ @@ -340,7 +340,7 @@ PHP_FUNCTION(mt_rand) RAND_RANGE(number, min, max, PHP_MT_RAND_MAX); } - RETURN_LONG(number); + RETURN_INT(number); } /* }}} */ @@ -352,7 +352,7 @@ PHP_FUNCTION(getrandmax) return; } - RETURN_LONG(PHP_RAND_MAX); + RETURN_INT(PHP_RAND_MAX); } /* }}} */ @@ -368,7 +368,7 @@ PHP_FUNCTION(mt_getrandmax) * Melo: it could be 2^^32 but we only use 2^^31 to maintain * compatibility with the previous php_rand */ - RETURN_LONG(PHP_MT_RAND_MAX); /* 2^^31 */ + RETURN_INT(PHP_MT_RAND_MAX); /* 2^^31 */ } /* }}} */ diff --git a/ext/standard/scanf.c b/ext/standard/scanf.c index f5f97161f2..bf7d461b8b 100644 --- a/ext/standard/scanf.c +++ b/ext/standard/scanf.c @@ -744,9 +744,9 @@ literal: } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); - ZVAL_LONG(current, (long)(string - baseString) ); + ZVAL_INT(current, (long)(string - baseString) ); } else { - add_index_long(return_value, objIndex++, string - baseString); + add_index_int(return_value, objIndex++, string - baseString); } } nconversions++; @@ -1068,9 +1068,9 @@ addToInt: } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); - ZVAL_LONG(current, value); + ZVAL_INT(current, value); } else { - add_index_long(return_value, objIndex++, value); + add_index_int(return_value, objIndex++, value); } } } @@ -1190,8 +1190,8 @@ done: scan_set_error_return( numVars, return_value ); result = SCAN_ERROR_EOF; } else if (numVars) { - convert_to_long(return_value ); - Z_LVAL_P(return_value) = nconversions; + convert_to_int(return_value ); + Z_IVAL_P(return_value) = nconversions; } else if (nconversions < totalVars) { /* TODO: not all elements converted. we need to prune the list - cc */ } @@ -1203,7 +1203,7 @@ done: static inline void scan_set_error_return(int numVars, zval *return_value) /* {{{ */ { if (numVars) { - ZVAL_LONG(return_value, SCAN_ERROR_EOF); /* EOF marker */ + ZVAL_INT(return_value, SCAN_ERROR_EOF); /* EOF marker */ } else { /* convert_to_null calls destructor */ convert_to_null(return_value); diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c index 652512ce07..88c16469a1 100644 --- a/ext/standard/streamsfuncs.c +++ b/ext/standard/streamsfuncs.c @@ -123,7 +123,7 @@ PHP_FUNCTION(stream_socket_client) #endif if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, 0); + ZVAL_INT(zerrno, 0); } if (zerrstr) { zval_dtor(zerrstr); @@ -151,7 +151,7 @@ PHP_FUNCTION(stream_socket_client) if (stream == NULL) { if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, err); + ZVAL_INT(zerrno, err); } if (zerrstr && errstr) { zval_dtor(zerrstr); @@ -198,7 +198,7 @@ PHP_FUNCTION(stream_socket_server) if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, 0); + ZVAL_INT(zerrno, 0); } if (zerrstr) { zval_dtor(zerrstr); @@ -216,7 +216,7 @@ PHP_FUNCTION(stream_socket_server) if (stream == NULL) { if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, err); + ZVAL_INT(zerrno, err); } if (zerrstr && errstr) { zval_dtor(zerrstr); @@ -340,7 +340,7 @@ PHP_FUNCTION(stream_socket_sendto) } } - RETURN_LONG(php_stream_xport_sendto(stream, data, datalen, flags, target_addr ? &sa : NULL, sl TSRMLS_CC)); + RETURN_INT(php_stream_xport_sendto(stream, data, datalen, flags, target_addr ? &sa : NULL, sl TSRMLS_CC)); } /* }}} */ @@ -467,7 +467,7 @@ PHP_FUNCTION(stream_copy_to_stream) if (ret != SUCCESS) { RETURN_FALSE; } - RETURN_LONG(len); + RETURN_INT(len); } /* }}} */ @@ -511,7 +511,7 @@ PHP_FUNCTION(stream_get_meta_data) } #endif - add_assoc_long(return_value, "unread_bytes", stream->writepos - stream->readpos); + add_assoc_int(return_value, "unread_bytes", stream->writepos - stream->readpos); add_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0); if (stream->orig_path) { @@ -763,9 +763,9 @@ PHP_FUNCTION(stream_select) /* If seconds is not set to null, build the timeval, else we wait indefinitely */ if (sec != NULL) { - convert_to_long_ex(sec); + convert_to_int_ex(sec); - if (Z_LVAL_P(sec) < 0) { + if (Z_IVAL_P(sec) < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "The seconds parameter must be greater than 0"); RETURN_FALSE; } else if (usec < 0) { @@ -775,10 +775,10 @@ PHP_FUNCTION(stream_select) /* Solaris + BSD do not like microsecond values which are >= 1 sec */ if (usec > 999999) { - tv.tv_sec = Z_LVAL_P(sec) + (usec / 1000000); + tv.tv_sec = Z_IVAL_P(sec) + (usec / 1000000); tv.tv_usec = usec % 1000000; } else { - tv.tv_sec = Z_LVAL_P(sec); + tv.tv_sec = Z_IVAL_P(sec); tv.tv_usec = usec; } @@ -798,7 +798,7 @@ PHP_FUNCTION(stream_select) if (e_array != NULL) { zend_hash_clean(Z_ARRVAL_P(e_array)); } - RETURN_LONG(retval); + RETURN_INT(retval); } } @@ -814,7 +814,7 @@ PHP_FUNCTION(stream_select) if (w_array != NULL) stream_array_from_fd_set(w_array, &wfds TSRMLS_CC); if (e_array != NULL) stream_array_from_fd_set(e_array, &efds TSRMLS_CC); - RETURN_LONG(retval); + RETURN_INT(retval); } /* }}} */ @@ -827,16 +827,16 @@ static void user_space_stream_notifier(php_stream_context *context, int notifyco zval zvs[6]; int i; - ZVAL_LONG(&zvs[0], notifycode); - ZVAL_LONG(&zvs[1], severity); + ZVAL_INT(&zvs[0], notifycode); + ZVAL_INT(&zvs[1], severity); if (xmsg) { ZVAL_STRING(&zvs[2], xmsg); } else { ZVAL_NULL(&zvs[2]); } - ZVAL_LONG(&zvs[3], xcode); - ZVAL_LONG(&zvs[4], bytes_sofar); - ZVAL_LONG(&zvs[5], bytes_max); + ZVAL_INT(&zvs[3], xcode); + ZVAL_INT(&zvs[4], bytes_sofar); + ZVAL_INT(&zvs[5], bytes_max); if (FAILURE == call_user_function_ex(EG(function_table), NULL, callback, &retval, 6, zvs, 0, NULL TSRMLS_CC)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call user notifier"); @@ -1356,7 +1356,7 @@ PHP_FUNCTION(stream_set_write_buffer) ret = php_stream_set_option(stream, PHP_STREAM_OPTION_WRITE_BUFFER, PHP_STREAM_BUFFER_FULL, &buff); } - RETURN_LONG(ret == 0 ? 0 : EOF); + RETURN_INT(ret == 0 ? 0 : EOF); } /* }}} */ @@ -1390,7 +1390,7 @@ PHP_FUNCTION(stream_set_chunk_size) ret = php_stream_set_option(stream, PHP_STREAM_OPTION_SET_CHUNK_SIZE, (int)csize, NULL); - RETURN_LONG(ret > 0 ? (long)ret : (long)EOF); + RETURN_INT(ret > 0 ? (long)ret : (long)EOF); } /* }}} */ @@ -1419,7 +1419,7 @@ PHP_FUNCTION(stream_set_read_buffer) ret = php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER, PHP_STREAM_BUFFER_FULL, &buff); } - RETURN_LONG(ret == 0 ? 0 : EOF); + RETURN_INT(ret == 0 ? 0 : EOF); } /* }}} */ @@ -1448,7 +1448,7 @@ PHP_FUNCTION(stream_socket_enable_crypto) RETURN_FALSE; } - cryptokind = Z_LVAL_P(val); + cryptokind = Z_IVAL_P(val); } if (zsessstream) { @@ -1466,7 +1466,7 @@ PHP_FUNCTION(stream_socket_enable_crypto) RETURN_FALSE; case 0: - RETURN_LONG(0); + RETURN_INT(0); default: RETURN_TRUE; diff --git a/ext/standard/string.c b/ext/standard/string.c index 82b98eb094..7a9bca8adc 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -81,13 +81,13 @@ */ void register_string_constants(INIT_FUNC_ARGS) { - REGISTER_LONG_CONSTANT("STR_PAD_LEFT", STR_PAD_LEFT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STR_PAD_RIGHT", STR_PAD_RIGHT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STR_PAD_BOTH", STR_PAD_BOTH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_DIRNAME", PHP_PATHINFO_DIRNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_BASENAME", PHP_PATHINFO_BASENAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_EXTENSION", PHP_PATHINFO_EXTENSION, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STR_PAD_LEFT", STR_PAD_LEFT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STR_PAD_RIGHT", STR_PAD_RIGHT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STR_PAD_BOTH", STR_PAD_BOTH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_DIRNAME", PHP_PATHINFO_DIRNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_BASENAME", PHP_PATHINFO_BASENAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_EXTENSION", PHP_PATHINFO_EXTENSION, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_LOCALECONV /* If last members of struct lconv equal CHAR_MAX, no grouping is done */ @@ -97,18 +97,18 @@ void register_string_constants(INIT_FUNC_ARGS) # define CHAR_MAX 127 # endif - REGISTER_LONG_CONSTANT("CHAR_MAX", CHAR_MAX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CHAR_MAX", CHAR_MAX, CONST_CS | CONST_PERSISTENT); #endif #ifdef HAVE_LOCALE_H - REGISTER_LONG_CONSTANT("LC_CTYPE", LC_CTYPE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_NUMERIC", LC_NUMERIC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_TIME", LC_TIME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_COLLATE", LC_COLLATE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_MONETARY", LC_MONETARY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_ALL", LC_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_CTYPE", LC_CTYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_NUMERIC", LC_NUMERIC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_TIME", LC_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_COLLATE", LC_COLLATE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_MONETARY", LC_MONETARY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_ALL", LC_ALL, CONST_CS | CONST_PERSISTENT); # ifdef LC_MESSAGES - REGISTER_LONG_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS | CONST_PERSISTENT); # endif #endif @@ -318,16 +318,16 @@ static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) / } if(len == 0) { - RETURN_LONG(0); + RETURN_INT(0); } if (behavior == STR_STRSPN) { - RETURN_LONG(php_strspn(s11 + start /*str1_start*/, + RETURN_INT(php_strspn(s11 + start /*str1_start*/, s22 /*str2_start*/, s11 + start + len /*str1_end*/, s22 + len2 /*str2_end*/)); } else if (behavior == STR_STRCSPN) { - RETURN_LONG(php_strcspn(s11 + start /*str1_start*/, + RETURN_INT(php_strcspn(s11 + start /*str1_start*/, s22 /*str2_start*/, s11 + start + len /*str1_end*/, s22 + len2 /*str2_end*/)); @@ -356,7 +356,7 @@ PHP_FUNCTION(strcspn) #if HAVE_NL_LANGINFO PHP_MINIT_FUNCTION(nl_langinfo) { -#define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_LONG_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) +#define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_INT_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) #ifdef ABDAY_1 REGISTER_NL_LANGINFO_CONSTANT(ABDAY_1); REGISTER_NL_LANGINFO_CONSTANT(ABDAY_2); @@ -721,7 +721,7 @@ PHP_FUNCTION(strcoll) return; } - RETURN_LONG(strcoll((const char *) s1, + RETURN_INT(strcoll((const char *) s1, (const char *) s2)); } /* }}} */ @@ -1017,18 +1017,18 @@ PHPAPI void php_explode(zval *delim, zval *str, zval *return_value, long limit) { char *p1, *p2, *endp; - endp = Z_STRVAL_P(str) + Z_STRLEN_P(str); + endp = Z_STRVAL_P(str) + Z_STRSIZE_P(str); p1 = Z_STRVAL_P(str); - p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp); + p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp); if (p2 == NULL) { - add_next_index_stringl(return_value, p1, Z_STRLEN_P(str)); + add_next_index_stringl(return_value, p1, Z_STRSIZE_P(str)); } else { do { add_next_index_stringl(return_value, p1, p2 - p1); - p1 = p2 + Z_STRLEN_P(delim); - } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL && + p1 = p2 + Z_STRSIZE_P(delim); + } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp)) != NULL && --limit > 1); if (p1 <= endp) @@ -1044,10 +1044,10 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu #define EXPLODE_ALLOC_STEP 64 char *p1, *p2, *endp; - endp = Z_STRVAL_P(str) + Z_STRLEN_P(str); + endp = Z_STRVAL_P(str) + Z_STRSIZE_P(str); p1 = Z_STRVAL_P(str); - p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp); + p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp); if (p2 == NULL) { /* @@ -1065,14 +1065,14 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu allocated = found + EXPLODE_ALLOC_STEP;/* make sure we have enough memory */ positions = erealloc(positions, allocated*sizeof(char *)); } - positions[found++] = p1 = p2 + Z_STRLEN_P(delim); - } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL); + positions[found++] = p1 = p2 + Z_STRSIZE_P(delim); + } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp)) != NULL); to_return = limit + found; /* limit is at least -1 therefore no need of bounds checking : i will be always less than found */ for (i = 0;i < to_return;i++) { /* this checks also for to_return > 0 */ add_next_index_stringl(return_value, positions[i], - (positions[i+1] - Z_STRLEN_P(delim)) - positions[i]); + (positions[i+1] - Z_STRSIZE_P(delim)) - positions[i]); } efree(positions); } @@ -1150,11 +1150,11 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC) again: switch (Z_TYPE_P(tmp)) { case IS_STRING: - smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)); + smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); break; - case IS_LONG: - smart_str_append_long(&implstr, Z_LVAL_P(tmp)); + case IS_INT: + smart_str_append_int(&implstr, Z_IVAL_P(tmp)); break; case IS_TRUE: @@ -1186,7 +1186,7 @@ again: } if (++i != numelems) { - smart_str_appendl(&implstr, Z_STRVAL_P(delim), Z_STRLEN_P(delim)); + smart_str_appendl(&implstr, Z_STRVAL_P(delim), Z_STRSIZE_P(delim)); } } ZEND_HASH_FOREACH_END(); @@ -1661,8 +1661,8 @@ PHPAPI size_t php_strcspn(char *s1, char *s2, char *s1_end, char *s2_end) static int php_needle_char(zval *needle, char *target TSRMLS_DC) { switch (Z_TYPE_P(needle)) { - case IS_LONG: - *target = (char)Z_LVAL_P(needle); + case IS_INT: + *target = (char)Z_IVAL_P(needle); return SUCCESS; case IS_NULL: case IS_FALSE: @@ -1678,11 +1678,11 @@ static int php_needle_char(zval *needle, char *target TSRMLS_DC) { zval holder = *needle; zval_copy_ctor(&(holder)); - convert_to_long(&(holder)); - if(Z_TYPE(holder) != IS_LONG) { + convert_to_int(&(holder)); + if(Z_TYPE(holder) != IS_INT) { return FAILURE; } - *target = (char)Z_LVAL(holder); + *target = (char)Z_IVAL(holder); return SUCCESS; } default: { @@ -1714,13 +1714,13 @@ PHP_FUNCTION(stristr) if (Z_TYPE_P(needle) == IS_STRING) { char *orig_needle; - if (!Z_STRLEN_P(needle)) { + if (!Z_STRSIZE_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); efree(haystack_dup); RETURN_FALSE; } - orig_needle = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle)); - found = php_stristr(haystack_dup, orig_needle, haystack_len, Z_STRLEN_P(needle)); + orig_needle = estrndup(Z_STRVAL_P(needle), Z_STRSIZE_P(needle)); + found = php_stristr(haystack_dup, orig_needle, haystack_len, Z_STRSIZE_P(needle)); efree(orig_needle); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { @@ -1764,12 +1764,12 @@ PHP_FUNCTION(strstr) } if (Z_TYPE_P(needle) == IS_STRING) { - if (!Z_STRLEN_P(needle)) { + if (!Z_STRSIZE_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); RETURN_FALSE; } - found = (char*)php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack + haystack_len); + found = (char*)php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRSIZE_P(needle), haystack + haystack_len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -1825,14 +1825,14 @@ PHP_FUNCTION(strpos) } if (Z_TYPE_P(needle) == IS_STRING) { - if (!Z_STRLEN_P(needle)) { + if (!Z_STRSIZE_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); RETURN_FALSE; } found = (char*)php_memnstr(haystack + offset, Z_STRVAL_P(needle), - Z_STRLEN_P(needle), + Z_STRSIZE_P(needle), haystack + haystack_len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { @@ -1847,7 +1847,7 @@ PHP_FUNCTION(strpos) } if (found) { - RETURN_LONG(found - haystack); + RETURN_INT(found - haystack); } else { RETURN_FALSE; } @@ -1883,14 +1883,14 @@ PHP_FUNCTION(stripos) php_strtolower(haystack_dup, haystack_len); if (Z_TYPE_P(needle) == IS_STRING) { - if (Z_STRLEN_P(needle) == 0 || Z_STRLEN_P(needle) > haystack_len) { + if (Z_STRSIZE_P(needle) == 0 || Z_STRSIZE_P(needle) > haystack_len) { efree(haystack_dup); RETURN_FALSE; } - needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle)); - php_strtolower(needle_dup, Z_STRLEN_P(needle)); - found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack_len); + needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRSIZE_P(needle)); + php_strtolower(needle_dup, Z_STRSIZE_P(needle)); + found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRSIZE_P(needle), haystack_dup + haystack_len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { efree(haystack_dup); @@ -1910,7 +1910,7 @@ PHP_FUNCTION(stripos) } if (found) { - RETURN_LONG(found - haystack_dup); + RETURN_INT(found - haystack_dup); } else { RETURN_FALSE; } @@ -1942,7 +1942,7 @@ PHP_FUNCTION(strrpos) if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); - needle_len = Z_STRLEN_P(zneedle); + needle_len = Z_STRSIZE_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -1981,7 +1981,7 @@ PHP_FUNCTION(strrpos) /* Single character search can shortcut memcmps */ while (e >= p) { if (*e == *needle) { - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -1990,7 +1990,7 @@ PHP_FUNCTION(strrpos) while (e >= p) { if (memcmp(e, needle, needle_len) == 0) { - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2016,7 +2016,7 @@ PHP_FUNCTION(strripos) if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); - needle_len = Z_STRLEN_P(zneedle); + needle_len = Z_STRSIZE_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -2052,7 +2052,7 @@ PHP_FUNCTION(strripos) *ord_needle = tolower(*needle); while (e >= p) { if (tolower(*e) == *ord_needle) { - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2092,7 +2092,7 @@ PHP_FUNCTION(strripos) if (memcmp(e, needle_dup, needle_len) == 0) { efree(haystack_dup); efree(needle_dup); - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2331,7 +2331,7 @@ PHP_FUNCTION(substr_replace) convert_to_string_ex(repl); } if (Z_TYPE_P(from) != IS_ARRAY) { - convert_to_long_ex(from); + convert_to_int_ex(from); } if (argc > 3) { @@ -2340,7 +2340,7 @@ PHP_FUNCTION(substr_replace) } } else { if (Z_TYPE_P(str) != IS_ARRAY) { - l = Z_STRLEN_P(str); + l = Z_STRSIZE_P(str); } } @@ -2364,55 +2364,55 @@ PHP_FUNCTION(substr_replace) if (Z_TYPE_P(from) != IS_ARRAY) { int repl_len = 0; - f = Z_LVAL_P(from); + f = Z_IVAL_P(from); /* if "from" position is negative, count start position from the end * of the string */ if (f < 0) { - f = Z_STRLEN_P(str) + f; + f = Z_STRSIZE_P(str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRLEN_P(str)) { - f = Z_STRLEN_P(str); + } else if (f > Z_STRSIZE_P(str)) { + f = Z_STRSIZE_P(str); } /* if "length" position is negative, set it to the length * needed to stop that many chars from the end of the string */ if (l < 0) { - l = (Z_STRLEN_P(str) - f) + l; + l = (Z_STRSIZE_P(str) - f) + l; if (l < 0) { l = 0; } } - if (f > Z_STRLEN_P(str) || (f < 0 && -f > Z_STRLEN_P(str))) { + if (f > Z_STRSIZE_P(str) || (f < 0 && -f > Z_STRSIZE_P(str))) { RETURN_FALSE; - } else if (l > Z_STRLEN_P(str) || (l < 0 && -l > Z_STRLEN_P(str))) { - l = Z_STRLEN_P(str); + } else if (l > Z_STRSIZE_P(str) || (l < 0 && -l > Z_STRSIZE_P(str))) { + l = Z_STRSIZE_P(str); } - if ((f + l) > Z_STRLEN_P(str)) { - l = Z_STRLEN_P(str) - f; + if ((f + l) > Z_STRSIZE_P(str)) { + l = Z_STRSIZE_P(str) - f; } if (Z_TYPE_P(repl) == IS_ARRAY) { zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl); if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) { convert_to_string_ex(tmp_repl); - repl_len = Z_STRLEN_P(tmp_repl); + repl_len = Z_STRSIZE_P(tmp_repl); } } else { - repl_len = Z_STRLEN_P(repl); + repl_len = Z_STRSIZE_P(repl); } - result = STR_ALLOC(Z_STRLEN_P(str) - l + repl_len, 0); + result = STR_ALLOC(Z_STRSIZE_P(str) - l + repl_len, 0); memcpy(result->val, Z_STRVAL_P(str), f); if (repl_len) { memcpy((result->val + f), (Z_TYPE_P(repl) == IS_ARRAY ? Z_STRVAL_P(tmp_repl) : Z_STRVAL_P(repl)), repl_len); } - memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l); + memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRSIZE_P(str) - f - l); result->val[result->len] = '\0'; RETURN_NEW_STR(result); } else { @@ -2464,26 +2464,26 @@ PHP_FUNCTION(substr_replace) f = zval_get_long(tmp_from); if (f < 0) { - f = Z_STRLEN_P(orig_str) + f; + f = Z_STRSIZE_P(orig_str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRLEN_P(orig_str)) { - f = Z_STRLEN_P(orig_str); + } else if (f > Z_STRSIZE_P(orig_str)) { + f = Z_STRSIZE_P(orig_str); } zend_hash_move_forward_ex(Z_ARRVAL_P(from), &pos_from); } else { f = 0; } } else { - f = Z_LVAL_P(from); + f = Z_IVAL_P(from); if (f < 0) { - f = Z_STRLEN_P(orig_str) + f; + f = Z_STRSIZE_P(orig_str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRLEN_P(orig_str)) { - f = Z_STRLEN_P(orig_str); + } else if (f > Z_STRSIZE_P(orig_str)) { + f = Z_STRSIZE_P(orig_str); } } @@ -2492,26 +2492,26 @@ PHP_FUNCTION(substr_replace) l = zval_get_long(tmp_len); zend_hash_move_forward_ex(Z_ARRVAL_P(len), &pos_len); } else { - l = Z_STRLEN_P(orig_str); + l = Z_STRSIZE_P(orig_str); } } else if (argc > 3) { - l = Z_LVAL_P(len); + l = Z_IVAL_P(len); } else { - l = Z_STRLEN_P(orig_str); + l = Z_STRSIZE_P(orig_str); } if (l < 0) { - l = (Z_STRLEN_P(orig_str) - f) + l; + l = (Z_STRSIZE_P(orig_str) - f) + l; if (l < 0) { l = 0; } } - if ((f + l) > Z_STRLEN_P(orig_str)) { - l = Z_STRLEN_P(orig_str) - f; + if ((f + l) > Z_STRSIZE_P(orig_str)) { + l = Z_STRSIZE_P(orig_str) - f; } - result_len = Z_STRLEN_P(orig_str) - l; + result_len = Z_STRSIZE_P(orig_str) - l; if (Z_TYPE_P(repl) == IS_ARRAY) { if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) { @@ -2536,13 +2536,13 @@ PHP_FUNCTION(substr_replace) } */ - result_len += Z_STRLEN_P(repl_str); + result_len += Z_STRSIZE_P(repl_str); zend_hash_move_forward_ex(Z_ARRVAL_P(repl), &pos_repl); result = STR_ALLOC(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRLEN_P(repl_str)); - memcpy((result->val + f + Z_STRLEN_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRSIZE_P(repl_str)); + memcpy((result->val + f + Z_STRSIZE_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); if(Z_TYPE_P(tmp_repl) != IS_STRING) { zval_dtor(repl_str); } @@ -2550,16 +2550,16 @@ PHP_FUNCTION(substr_replace) result = STR_ALLOC(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); } } else { - result_len += Z_STRLEN_P(repl); + result_len += Z_STRSIZE_P(repl); result = STR_ALLOC(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRLEN_P(repl)); - memcpy((result->val + f + Z_STRLEN_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRSIZE_P(repl)); + memcpy((result->val + f + Z_STRSIZE_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); } result->val[result->len] = '\0'; @@ -2650,7 +2650,7 @@ PHP_FUNCTION(ord) ZEND_PARSE_PARAMETERS_END(); #endif - RETURN_LONG((unsigned char) str[0]); + RETURN_INT((unsigned char) str[0]); } /* }}} */ @@ -2773,7 +2773,7 @@ PHP_FUNCTION(ucwords) r = Z_STRVAL_P(return_value); *r = toupper((unsigned char) *r); - for (r_end = r + Z_STRLEN_P(return_value) - 1; r < r_end; ) { + for (r_end = r + Z_STRSIZE_P(return_value) - 1; r < r_end; ) { if (mask[(unsigned char)*r++]) { *r = toupper((unsigned char) *r); } @@ -2861,7 +2861,7 @@ static void php_strtr_array(zval *return_value, char *str, int slen, HashTable * zend_hash_init(&str_hash, zend_hash_num_elements(pats), NULL, NULL, 0); ZEND_HASH_FOREACH_KEY_VAL(pats, num_key, str_key, entry) { if (UNEXPECTED(!str_key)) { - ZVAL_LONG(&tmp, num_key); + ZVAL_INT(&tmp, num_key); convert_to_string(&tmp); str_key = Z_STR(tmp); len = str_key->len; @@ -3005,10 +3005,10 @@ PHP_FUNCTION(strtr) ZVAL_STRINGL(return_value, str, str_len); php_strtr(Z_STRVAL_P(return_value), - Z_STRLEN_P(return_value), + Z_STRSIZE_P(return_value), Z_STRVAL_P(from), to, - MIN(Z_STRLEN_P(from), + MIN(Z_STRSIZE_P(from), to_len)); } } @@ -3111,7 +3111,7 @@ PHP_FUNCTION(similar_text) Z_DVAL_P(percent) = 0; } - RETURN_LONG(0); + RETURN_INT(0); } sim = php_similar_char(t1, t1_len, t2, t2_len); @@ -3120,7 +3120,7 @@ PHP_FUNCTION(similar_text) Z_DVAL_P(percent) = sim * 200.0 / (t1_len + t2_len); } - RETURN_LONG(sim); + RETURN_INT(sim); } /* }}} */ @@ -3227,7 +3227,7 @@ PHP_FUNCTION(stripcslashes) } ZVAL_STRINGL(return_value, str, str_len); - php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value)); + php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRSIZE_P(return_value)); } /* }}} */ @@ -3243,7 +3243,7 @@ PHP_FUNCTION(stripslashes) } ZVAL_STRINGL(return_value, str, str_len); - php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC); + php_stripslashes(Z_STRVAL_P(return_value), &Z_STRSIZE_P(return_value) TSRMLS_CC); } /* }}} */ @@ -3708,7 +3708,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec convert_to_string_ex(&tmp_subject); subject = &tmp_subject; } - if (Z_STRLEN_P(subject) == 0) { + if (Z_STRSIZE_P(subject) == 0) { zval_ptr_dtor(&tmp_subject); ZVAL_EMPTY_STRING(result); return; @@ -3725,7 +3725,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec } else { /* Set replacement value to the passed one */ replace_value = Z_STRVAL_P(replace); - replace_len = Z_STRLEN_P(replace); + replace_len = Z_STRSIZE_P(replace); } /* For each entry in the search array, get the entry */ @@ -3733,7 +3733,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec /* Make sure we're dealing with strings. */ SEPARATE_ZVAL(search_entry); convert_to_string(search_entry); - if (Z_STRLEN_P(search_entry) == 0) { + if (Z_STRSIZE_P(search_entry) == 0) { if (Z_TYPE_P(replace) == IS_ARRAY) { zend_hash_move_forward_ex(Z_ARRVAL_P(replace), &pos); } @@ -3749,7 +3749,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec /* Set replacement value to the one we got from array */ replace_value = Z_STRVAL_P(replace_entry); - replace_len = Z_STRLEN_P(replace_entry); + replace_len = Z_STRSIZE_P(replace_entry); zend_hash_move_forward_ex(Z_ARRVAL_P(replace), &pos); } else { @@ -3759,18 +3759,18 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec } } - if (Z_STRLEN_P(search_entry) == 1) { + if (Z_STRSIZE_P(search_entry) == 1) { php_char_to_str_ex(Z_STRVAL_P(result), - Z_STRLEN_P(result), + Z_STRSIZE_P(result), Z_STRVAL_P(search_entry)[0], replace_value, replace_len, &temp_result, case_sensitivity, replace_count); - } else if (Z_STRLEN_P(search_entry) > 1) { - ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result), - Z_STRVAL_P(search_entry), Z_STRLEN_P(search_entry), + } else if (Z_STRSIZE_P(search_entry) > 1) { + ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRSIZE_P(result), + Z_STRVAL_P(search_entry), Z_STRSIZE_P(search_entry), replace_value, replace_len, case_sensitivity, replace_count)); } @@ -3778,25 +3778,25 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec Z_STR_P(result) = Z_STR(temp_result); Z_TYPE_INFO_P(result) = Z_TYPE_INFO(temp_result); - if (Z_STRLEN_P(result) == 0) { + if (Z_STRSIZE_P(result) == 0) { zval_ptr_dtor(&tmp_subject); return; } } ZEND_HASH_FOREACH_END(); } else { - if (Z_STRLEN_P(search) == 1) { + if (Z_STRSIZE_P(search) == 1) { php_char_to_str_ex(Z_STRVAL_P(subject), - Z_STRLEN_P(subject), + Z_STRSIZE_P(subject), Z_STRVAL_P(search)[0], Z_STRVAL_P(replace), - Z_STRLEN_P(replace), + Z_STRSIZE_P(replace), result, case_sensitivity, replace_count); - } else if (Z_STRLEN_P(search) > 1) { - ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRLEN_P(subject), - Z_STRVAL_P(search), Z_STRLEN_P(search), - Z_STRVAL_P(replace), Z_STRLEN_P(replace), case_sensitivity, replace_count)); + } else if (Z_STRSIZE_P(search) > 1) { + ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRSIZE_P(subject), + Z_STRVAL_P(search), Z_STRSIZE_P(search), + Z_STRVAL_P(replace), Z_STRSIZE_P(replace), case_sensitivity, replace_count)); } else { ZVAL_DUP(result, subject); } @@ -3867,7 +3867,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit } if (argc > 3) { zval_dtor(zcount); - ZVAL_LONG(zcount, count); + ZVAL_INT(zcount, count); } } /* }}} */ @@ -4176,11 +4176,11 @@ PHP_FUNCTION(strip_tags) convert_to_string_ex(allow); // TODO: reimplement to avoid reallocation ??? if (IS_INTERNED(Z_STR_P(allow))) { - allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRLEN_P(allow)); - allowed_tags_len = Z_STRLEN_P(allow); + allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRSIZE_P(allow)); + allowed_tags_len = Z_STRSIZE_P(allow); } else { allowed_tags = Z_STRVAL_P(allow); - allowed_tags_len = Z_STRLEN_P(allow); + allowed_tags_len = Z_STRSIZE_P(allow); } } @@ -4210,8 +4210,8 @@ PHP_FUNCTION(setlocale) } #ifdef HAVE_SETLOCALE - if (Z_TYPE_P(pcategory) == IS_LONG) { - cat = Z_LVAL_P(pcategory); + if (Z_TYPE_P(pcategory) == IS_INT) { + cat = Z_IVAL_P(pcategory); } else { /* FIXME: The following behaviour should be removed. */ char *category; @@ -4272,7 +4272,7 @@ PHP_FUNCTION(setlocale) loc = NULL; } else { loc = Z_STRVAL(tmp); - if (Z_STRLEN(tmp) >= 255) { + if (Z_STRSIZE(tmp) >= 255) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified locale name is too long"); zval_dtor(&tmp); break; @@ -4817,16 +4817,16 @@ PHP_FUNCTION(count_chars) for (inx = 0; inx < 256; inx++) { switch (mymode) { case 0: - add_index_long(return_value, inx, chars[inx]); + add_index_int(return_value, inx, chars[inx]); break; case 1: if (chars[inx] != 0) { - add_index_long(return_value, inx, chars[inx]); + add_index_int(return_value, inx, chars[inx]); } break; case 2: if (chars[inx] == 0) { - add_index_long(return_value, inx, chars[inx]); + add_index_int(return_value, inx, chars[inx]); } break; case 3: @@ -4859,7 +4859,7 @@ static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS, int fold_case) return; } - RETURN_LONG(strnatcmp_ex(s1, s1_len, + RETURN_INT(strnatcmp_ex(s1, s1_len, s2, s2_len, fold_case)); } @@ -4870,7 +4870,7 @@ PHPAPI int string_natural_compare_function_ex(zval *result, zval *op1, zval *op2 zend_string *str1 = zval_get_string(op1); zend_string *str2 = zval_get_string(op2); - ZVAL_LONG(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); + ZVAL_INT(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); STR_RELEASE(str1); STR_RELEASE(str2); @@ -4924,14 +4924,14 @@ PHP_FUNCTION(localeconv) len = strlen(currlocdata.grouping); for (i = 0; i < len; i++) { - add_index_long(&grouping, i, currlocdata.grouping[i]); + add_index_int(&grouping, i, currlocdata.grouping[i]); } /* Grab the monetary grouping data out of the array */ len = strlen(currlocdata.mon_grouping); for (i = 0; i < len; i++) { - add_index_long(&mon_grouping, i, currlocdata.mon_grouping[i]); + add_index_int(&mon_grouping, i, currlocdata.mon_grouping[i]); } add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point); @@ -4942,21 +4942,21 @@ PHP_FUNCTION(localeconv) add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep); add_assoc_string(return_value, "positive_sign", currlocdata.positive_sign); add_assoc_string(return_value, "negative_sign", currlocdata.negative_sign); - add_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits); - add_assoc_long( return_value, "frac_digits", currlocdata.frac_digits); - add_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes); - add_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space); - add_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes); - add_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space); - add_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn); - add_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn); + add_assoc_int( return_value, "int_frac_digits", currlocdata.int_frac_digits); + add_assoc_int( return_value, "frac_digits", currlocdata.frac_digits); + add_assoc_int( return_value, "p_cs_precedes", currlocdata.p_cs_precedes); + add_assoc_int( return_value, "p_sep_by_space", currlocdata.p_sep_by_space); + add_assoc_int( return_value, "n_cs_precedes", currlocdata.n_cs_precedes); + add_assoc_int( return_value, "n_sep_by_space", currlocdata.n_sep_by_space); + add_assoc_int( return_value, "p_sign_posn", currlocdata.p_sign_posn); + add_assoc_int( return_value, "n_sign_posn", currlocdata.n_sign_posn); } #else /* Ok, it doesn't look like we have locale info floating around, so I guess it wouldn't hurt to just go ahead and return the POSIX locale information? */ - add_index_long(&grouping, 0, -1); - add_index_long(&mon_grouping, 0, -1); + add_index_int(&grouping, 0, -1); + add_index_int(&mon_grouping, 0, -1); add_assoc_string(return_value, "decimal_point", "\x2E"); add_assoc_string(return_value, "thousands_sep", ""); @@ -4966,14 +4966,14 @@ PHP_FUNCTION(localeconv) add_assoc_string(return_value, "mon_thousands_sep", ""); add_assoc_string(return_value, "positive_sign", ""); add_assoc_string(return_value, "negative_sign", ""); - add_assoc_long( return_value, "int_frac_digits", CHAR_MAX); - add_assoc_long( return_value, "frac_digits", CHAR_MAX); - add_assoc_long( return_value, "p_cs_precedes", CHAR_MAX); - add_assoc_long( return_value, "p_sep_by_space", CHAR_MAX); - add_assoc_long( return_value, "n_cs_precedes", CHAR_MAX); - add_assoc_long( return_value, "n_sep_by_space", CHAR_MAX); - add_assoc_long( return_value, "p_sign_posn", CHAR_MAX); - add_assoc_long( return_value, "n_sign_posn", CHAR_MAX); + add_assoc_int( return_value, "int_frac_digits", CHAR_MAX); + add_assoc_int( return_value, "frac_digits", CHAR_MAX); + add_assoc_int( return_value, "p_cs_precedes", CHAR_MAX); + add_assoc_int( return_value, "p_sep_by_space", CHAR_MAX); + add_assoc_int( return_value, "n_cs_precedes", CHAR_MAX); + add_assoc_int( return_value, "n_sep_by_space", CHAR_MAX); + add_assoc_int( return_value, "p_sign_posn", CHAR_MAX); + add_assoc_int( return_value, "n_sign_posn", CHAR_MAX); #endif zend_hash_str_update(Z_ARRVAL_P(return_value), "grouping", sizeof("grouping")-1, &grouping); @@ -5050,7 +5050,7 @@ PHP_FUNCTION(substr_count) } } - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -5174,7 +5174,7 @@ PHP_FUNCTION(str_rot13) RETVAL_STRINGL(arg, arglen); - php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), rot13_from, rot13_to, 52); + php_strtr(Z_STRVAL_P(return_value), Z_STRSIZE_P(return_value), rot13_from, rot13_to, 52); } /* }}} */ @@ -5216,8 +5216,8 @@ PHP_FUNCTION(str_shuffle) } RETVAL_STRINGL(arg, arglen); - if (Z_STRLEN_P(return_value) > 1) { - php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC); + if (Z_STRSIZE_P(return_value) > 1) { + php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRSIZE_P(return_value) TSRMLS_CC); } } /* }}} */ @@ -5253,7 +5253,7 @@ PHP_FUNCTION(str_word_count) break; case 0: if (!str_len) { - RETURN_LONG(0); + RETURN_INT(0); } /* nothing to be done */ break; @@ -5301,7 +5301,7 @@ PHP_FUNCTION(str_word_count) } if (!type) { - RETURN_LONG(word_count); + RETURN_INT(word_count); } } @@ -5433,7 +5433,7 @@ PHP_FUNCTION(substr_compare) if (ZEND_NUM_ARGS() >= 4 && len <= 0) { if (len == 0) { - RETURN_LONG(0L); + RETURN_INT(0L); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "The length must be greater than or equal to zero"); RETURN_FALSE; @@ -5453,9 +5453,9 @@ PHP_FUNCTION(substr_compare) cmp_len = (uint) (len ? len : MAX(s2_len, (s1_len - offset))); if (!cs) { - RETURN_LONG(zend_binary_strncmp(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); + RETURN_INT(zend_binary_strncmp(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); } else { - RETURN_LONG(zend_binary_strncasecmp_l(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); + RETURN_INT(zend_binary_strncasecmp_l(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); } } /* }}} */ diff --git a/ext/standard/syslog.c b/ext/standard/syslog.c index acbffe49ad..05c443988e 100644 --- a/ext/standard/syslog.c +++ b/ext/standard/syslog.c @@ -41,59 +41,59 @@ PHP_MINIT_FUNCTION(syslog) { /* error levels */ - REGISTER_LONG_CONSTANT("LOG_EMERG", LOG_EMERG, CONST_CS | CONST_PERSISTENT); /* system unusable */ - REGISTER_LONG_CONSTANT("LOG_ALERT", LOG_ALERT, CONST_CS | CONST_PERSISTENT); /* immediate action required */ - REGISTER_LONG_CONSTANT("LOG_CRIT", LOG_CRIT, CONST_CS | CONST_PERSISTENT); /* critical conditions */ - REGISTER_LONG_CONSTANT("LOG_ERR", LOG_ERR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_WARNING", LOG_WARNING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_NOTICE", LOG_NOTICE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_INFO", LOG_INFO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_DEBUG", LOG_DEBUG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_EMERG", LOG_EMERG, CONST_CS | CONST_PERSISTENT); /* system unusable */ + REGISTER_INT_CONSTANT("LOG_ALERT", LOG_ALERT, CONST_CS | CONST_PERSISTENT); /* immediate action required */ + REGISTER_INT_CONSTANT("LOG_CRIT", LOG_CRIT, CONST_CS | CONST_PERSISTENT); /* critical conditions */ + REGISTER_INT_CONSTANT("LOG_ERR", LOG_ERR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_WARNING", LOG_WARNING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_NOTICE", LOG_NOTICE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_INFO", LOG_INFO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_DEBUG", LOG_DEBUG, CONST_CS | CONST_PERSISTENT); /* facility: type of program logging the message */ - REGISTER_LONG_CONSTANT("LOG_KERN", LOG_KERN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_USER", LOG_USER, CONST_CS | CONST_PERSISTENT); /* generic user level */ - REGISTER_LONG_CONSTANT("LOG_MAIL", LOG_MAIL, CONST_CS | CONST_PERSISTENT); /* log to email */ - REGISTER_LONG_CONSTANT("LOG_DAEMON", LOG_DAEMON, CONST_CS | CONST_PERSISTENT); /* other system daemons */ - REGISTER_LONG_CONSTANT("LOG_AUTH", LOG_AUTH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_SYSLOG", LOG_SYSLOG, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LPR", LOG_LPR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_KERN", LOG_KERN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_USER", LOG_USER, CONST_CS | CONST_PERSISTENT); /* generic user level */ + REGISTER_INT_CONSTANT("LOG_MAIL", LOG_MAIL, CONST_CS | CONST_PERSISTENT); /* log to email */ + REGISTER_INT_CONSTANT("LOG_DAEMON", LOG_DAEMON, CONST_CS | CONST_PERSISTENT); /* other system daemons */ + REGISTER_INT_CONSTANT("LOG_AUTH", LOG_AUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_SYSLOG", LOG_SYSLOG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LPR", LOG_LPR, CONST_CS | CONST_PERSISTENT); #ifdef LOG_NEWS /* No LOG_NEWS on HP-UX */ - REGISTER_LONG_CONSTANT("LOG_NEWS", LOG_NEWS, CONST_CS | CONST_PERSISTENT); /* usenet new */ + REGISTER_INT_CONSTANT("LOG_NEWS", LOG_NEWS, CONST_CS | CONST_PERSISTENT); /* usenet new */ #endif #ifdef LOG_UUCP /* No LOG_UUCP on HP-UX */ - REGISTER_LONG_CONSTANT("LOG_UUCP", LOG_UUCP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_UUCP", LOG_UUCP, CONST_CS | CONST_PERSISTENT); #endif #ifdef LOG_CRON /* apparently some systems don't have this one */ - REGISTER_LONG_CONSTANT("LOG_CRON", LOG_CRON, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_CRON", LOG_CRON, CONST_CS | CONST_PERSISTENT); #endif #ifdef LOG_AUTHPRIV /* AIX doesn't have LOG_AUTHPRIV */ - REGISTER_LONG_CONSTANT("LOG_AUTHPRIV", LOG_AUTHPRIV, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_AUTHPRIV", LOG_AUTHPRIV, CONST_CS | CONST_PERSISTENT); #endif #ifndef PHP_WIN32 - REGISTER_LONG_CONSTANT("LOG_LOCAL0", LOG_LOCAL0, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL1", LOG_LOCAL1, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL2", LOG_LOCAL2, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL3", LOG_LOCAL3, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL4", LOG_LOCAL4, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL5", LOG_LOCAL5, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL6", LOG_LOCAL6, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL7", LOG_LOCAL7, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL0", LOG_LOCAL0, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL1", LOG_LOCAL1, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL2", LOG_LOCAL2, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL3", LOG_LOCAL3, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL4", LOG_LOCAL4, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL5", LOG_LOCAL5, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL6", LOG_LOCAL6, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL7", LOG_LOCAL7, CONST_CS | CONST_PERSISTENT); #endif /* options */ - REGISTER_LONG_CONSTANT("LOG_PID", LOG_PID, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_CONS", LOG_CONS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_ODELAY", LOG_ODELAY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_NDELAY", LOG_NDELAY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_PID", LOG_PID, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_CONS", LOG_CONS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_ODELAY", LOG_ODELAY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_NDELAY", LOG_NDELAY, CONST_CS | CONST_PERSISTENT); #ifdef LOG_NOWAIT - REGISTER_LONG_CONSTANT("LOG_NOWAIT", LOG_NOWAIT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_NOWAIT", LOG_NOWAIT, CONST_CS | CONST_PERSISTENT); #endif #ifdef LOG_PERROR /* AIX doesn't have LOG_PERROR */ - REGISTER_LONG_CONSTANT("LOG_PERROR", LOG_PERROR, CONST_CS | CONST_PERSISTENT); /*log to stderr*/ + REGISTER_INT_CONSTANT("LOG_PERROR", LOG_PERROR, CONST_CS | CONST_PERSISTENT); /*log to stderr*/ #endif BG(syslog_device)=NULL; diff --git a/ext/standard/type.c b/ext/standard/type.c index 2a2988dee5..1aac60dfc2 100644 --- a/ext/standard/type.c +++ b/ext/standard/type.c @@ -41,7 +41,7 @@ PHP_FUNCTION(gettype) RETVAL_STRING("boolean"); break; - case IS_LONG: + case IS_INT: RETVAL_STRING("integer"); break; @@ -103,9 +103,9 @@ PHP_FUNCTION(settype) ZVAL_DEREF(var); SEPARATE_ZVAL_NOREF(var); if (!strcasecmp(type, "integer")) { - convert_to_long(var); + convert_to_int(var); } else if (!strcasecmp(type, "int")) { - convert_to_long(var); + convert_to_int(var); } else if (!strcasecmp(type, "float")) { convert_to_double(var); } else if (!strcasecmp(type, "double")) { /* deprecated */ @@ -156,7 +156,7 @@ PHP_FUNCTION(intval) #endif RETVAL_ZVAL(num, 1, 0); - convert_to_long_base(return_value, base); + convert_to_int_base(return_value, base); } /* }}} */ @@ -277,7 +277,7 @@ PHP_FUNCTION(is_bool) Returns true if variable is a long (integer) */ PHP_FUNCTION(is_long) { - php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_LONG); + php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_INT); } /* }}} */ @@ -324,13 +324,13 @@ PHP_FUNCTION(is_numeric) } switch (Z_TYPE_P(arg)) { - case IS_LONG: + case IS_INT: case IS_DOUBLE: RETURN_TRUE; break; case IS_STRING: - if (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), NULL, NULL, 0)) { + if (is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), NULL, NULL, 0)) { RETURN_TRUE; } else { RETURN_FALSE; @@ -364,7 +364,7 @@ PHP_FUNCTION(is_scalar) case IS_FALSE: case IS_TRUE: case IS_DOUBLE: - case IS_LONG: + case IS_INT: case IS_STRING: RETURN_TRUE; break; diff --git a/ext/standard/url.c b/ext/standard/url.c index 7e848fecfe..714d334cfe 100644 --- a/ext/standard/url.c +++ b/ext/standard/url.c @@ -398,7 +398,7 @@ PHP_FUNCTION(parse_url) if (resource->host != NULL) RETVAL_STRING(resource->host); break; case PHP_URL_PORT: - if (resource->port != 0) RETVAL_LONG(resource->port); + if (resource->port != 0) RETVAL_INT(resource->port); break; case PHP_URL_USER: if (resource->user != NULL) RETVAL_STRING(resource->user); @@ -431,7 +431,7 @@ PHP_FUNCTION(parse_url) if (resource->host != NULL) add_assoc_string(return_value, "host", resource->host); if (resource->port != 0) - add_assoc_long(return_value, "port", resource->port); + add_assoc_int(return_value, "port", resource->port); if (resource->user != NULL) add_assoc_string(return_value, "user", resource->user); if (resource->pass != NULL) @@ -769,10 +769,10 @@ no_name_header: } if ((prev_val = zend_hash_str_find(HASH_OF(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) { - add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr)))); + add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRSIZE_P(hdr) - (s - Z_STRVAL_P(hdr)))); } else { /* some headers may occur more then once, therefor we need to remake the string into an array */ convert_to_array(prev_val); - add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr)))); + add_next_index_stringl(prev_val, s, (Z_STRSIZE_P(hdr) - (s - Z_STRVAL_P(hdr)))); } *p = c; diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c index 7dce126ac3..f9c94186f1 100644 --- a/ext/standard/user_filters.c +++ b/ext/standard/user_filters.c @@ -113,13 +113,13 @@ PHP_MINIT_FUNCTION(user_filters) return FAILURE; } - REGISTER_LONG_CONSTANT("PSFS_PASS_ON", PSFS_PASS_ON, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FEED_ME", PSFS_FEED_ME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_ERR_FATAL", PSFS_ERR_FATAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_PASS_ON", PSFS_PASS_ON, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FEED_ME", PSFS_FEED_ME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_ERR_FATAL", PSFS_ERR_FATAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FLAG_NORMAL", PSFS_FLAG_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_INC", PSFS_FLAG_FLUSH_INC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_CLOSE", PSFS_FLAG_FLUSH_CLOSE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FLAG_NORMAL", PSFS_FLAG_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FLAG_FLUSH_INC", PSFS_FLAG_FLUSH_INC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FLAG_FLUSH_CLOSE", PSFS_FLAG_FLUSH_CLOSE, CONST_CS | CONST_PERSISTENT); return SUCCESS; } @@ -203,7 +203,7 @@ php_stream_filter_status_t userfilter_filter( ZEND_REGISTER_RESOURCE(&args[1], buckets_out, le_bucket_brigade); if (bytes_consumed) { - ZVAL_LONG(&args[2], *bytes_consumed); + ZVAL_INT(&args[2], *bytes_consumed); } else { ZVAL_NULL(&args[2]); } @@ -220,14 +220,14 @@ php_stream_filter_status_t userfilter_filter( zval_ptr_dtor(&func_name); if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { - convert_to_long(&retval); - ret = Z_LVAL(retval); + convert_to_int(&retval); + ret = Z_IVAL(retval); } else if (call_result == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call filter function"); } if (bytes_consumed) { - *bytes_consumed = Z_LVAL_P(&args[2]); + *bytes_consumed = Z_IVAL_P(&args[2]); } if (buckets_in->head) { @@ -424,7 +424,7 @@ PHP_FUNCTION(stream_bucket_make_writeable) /* add_property_zval increments the refcount which is unwanted here */ zval_ptr_dtor(&zbucket); add_property_stringl(return_value, "data", bucket->buf, bucket->buflen); - add_property_long(return_value, "datalen", bucket->buflen); + add_property_int(return_value, "datalen", bucket->buflen); } } /* }}} */ @@ -453,9 +453,9 @@ static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS) if (!bucket->own_buf) { bucket = php_stream_bucket_make_writeable(bucket TSRMLS_CC); } - if ((int)bucket->buflen != Z_STRLEN_P(pzdata)) { - bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent); - bucket->buflen = Z_STRLEN_P(pzdata); + if ((int)bucket->buflen != Z_STRSIZE_P(pzdata)) { + bucket->buf = perealloc(bucket->buf, Z_STRSIZE_P(pzdata), bucket->is_persistent); + bucket->buflen = Z_STRSIZE_P(pzdata); } memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen); } @@ -525,7 +525,7 @@ PHP_FUNCTION(stream_bucket_new) /* add_property_zval increments the refcount which is unwanted here */ zval_ptr_dtor(&zbucket); add_property_stringl(return_value, "data", bucket->buf, bucket->buflen); - add_property_long(return_value, "datalen", bucket->buflen); + add_property_int(return_value, "datalen", bucket->buflen); } /* }}} */ diff --git a/ext/standard/var.c b/ext/standard/var.c index 96b1ee40ec..1f86b1331b 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -119,15 +119,15 @@ again: case IS_NULL: php_printf("%sNULL\n", COMMON); break; - case IS_LONG: - php_printf("%sint(%ld)\n", COMMON, Z_LVAL_P(struc)); + case IS_INT: + php_printf("%sint(%ld)\n", COMMON, Z_IVAL_P(struc)); break; case IS_DOUBLE: php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc)); break; case IS_STRING: - php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc)); - PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + php_printf("%sstring(%d) \"", COMMON, Z_STRSIZE_P(struc)); + PHPWRITE(Z_STRVAL_P(struc), Z_STRSIZE_P(struc)); PUTS("\"\n"); break; case IS_ARRAY: @@ -290,15 +290,15 @@ again: case IS_NULL: php_printf("%sNULL\n", COMMON); break; - case IS_LONG: - php_printf("%slong(%ld)\n", COMMON, Z_LVAL_P(struc)); + case IS_INT: + php_printf("%slong(%ld)\n", COMMON, Z_IVAL_P(struc)); break; case IS_DOUBLE: php_printf("%sdouble(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc)); break; case IS_STRING: - php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc)); - PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + php_printf("%sstring(%d) \"", COMMON, Z_STRSIZE_P(struc)); + PHPWRITE(Z_STRVAL_P(struc), Z_STRSIZE_P(struc)); php_printf("\" refcount(%u)\n", IS_INTERNED(Z_STR_P(struc)) ? 1 : Z_REFCOUNT_P(struc)); break; case IS_ARRAY: @@ -402,7 +402,7 @@ static void php_array_element_export(zval *zv, ulong index, zend_string *key, in { if (key == NULL) { /* numeric key */ buffer_append_spaces(buf, level+1); - smart_str_append_long(buf, (long) index); + smart_str_append_int(buf, (long) index); smart_str_appendl(buf, " => ", 4); } else { /* string key */ @@ -443,7 +443,7 @@ static void php_object_element_export(zval *zv, ulong index, zend_string *key, i smart_str_appendc(buf, '\''); STR_RELEASE(pname_esc); } else { - smart_str_append_long(buf, (long) index); + smart_str_append_int(buf, (long) index); } smart_str_appendl(buf, " => ", 4); php_var_export_ex(zv, level + 2, buf TSRMLS_CC); @@ -474,8 +474,8 @@ again: case IS_NULL: smart_str_appendl(buf, "NULL", 4); break; - case IS_LONG: - smart_str_append_long(buf, Z_LVAL_P(struc)); + case IS_INT: + smart_str_append_int(buf, Z_IVAL_P(struc)); break; case IS_DOUBLE: tmp_len = spprintf(&tmp_str, 0,"%.*H", PG(serialize_precision), Z_DVAL_P(struc)); @@ -483,7 +483,7 @@ again: efree(tmp_str); break; case IS_STRING: - ztmp = php_addcslashes(Z_STRVAL_P(struc), Z_STRLEN_P(struc), 0, "'\\", 2 TSRMLS_CC); + ztmp = php_addcslashes(Z_STRVAL_P(struc), Z_STRSIZE_P(struc), 0, "'\\", 2 TSRMLS_CC); ztmp2 = php_str_to_str_ex(ztmp->val, ztmp->len, "\0", 1, "' . \"\\0\" . '", 12, 0, NULL); smart_str_appendc(buf, '\''); @@ -631,7 +631,7 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var_ptr, zval *var if (var == var_ptr) { /* we still need to bump up the counter, since non-refs will * be counted separately by unserializer */ - ZVAL_LONG(&var_no, -1); + ZVAL_INT(&var_no, -1); zend_hash_next_index_insert(var_hash, &var_no); } #if 0 @@ -641,10 +641,10 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var_ptr, zval *var } /* +1 because otherwise hash will think we are trying to store NULL pointer */ - ZVAL_LONG(&var_no, zend_hash_num_elements(var_hash) + 1); + ZVAL_INT(&var_no, zend_hash_num_elements(var_hash) + 1); zend_hash_str_add(var_hash, p, len, &var_no); #if 0 - fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), Z_LVAL(var_no)); + fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), Z_IVAL(var_no)); #endif return SUCCESS; } @@ -653,7 +653,7 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var_ptr, zval *var static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */ { smart_str_appendl(buf, "i:", 2); - smart_str_append_long(buf, val); + smart_str_append_int(buf, val); smart_str_appendc(buf, ';'); } /* }}} */ @@ -661,7 +661,7 @@ static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */ static inline void php_var_serialize_string(smart_str *buf, char *str, int len) /* {{{ */ { smart_str_appendl(buf, "s:", 2); - smart_str_append_long(buf, len); + smart_str_append_int(buf, len); smart_str_appendl(buf, ":\"", 2); smart_str_appendl(buf, str, len); smart_str_appendl(buf, "\";", 2); @@ -674,7 +674,7 @@ static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc PHP_SET_CLASS_ATTRIBUTES(struc); smart_str_appendl(buf, "O:", 2); - smart_str_append_long(buf, (int)class_name->len); + smart_str_append_int(buf, (int)class_name->len); smart_str_appendl(buf, ":\"", 2); smart_str_appendl(buf, class_name->val, class_name->len); smart_str_appendl(buf, "\":", 2); @@ -695,7 +695,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt if (incomplete_class) { --count; } - smart_str_append_long(buf, count); + smart_str_append_int(buf, count); smart_str_appendl(buf, ":{", 2); if (count > 0) { @@ -728,7 +728,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt continue; } } - php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); + php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRSIZE_P(name)); php_var_serialize_intern(buf, d, var_hash TSRMLS_CC); } else { zend_class_entry *ce; @@ -737,7 +737,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt zend_string *prot_name, *priv_name; do { - priv_name = zend_mangle_property_name(ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); + priv_name = zend_mangle_property_name(ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRSIZE_P(name), ce->type & ZEND_INTERNAL_CLASS); if ((d = zend_hash_find(propers, priv_name)) != NULL) { if (Z_TYPE_P(d) == IS_INDIRECT) { d = Z_INDIRECT_P(d); @@ -751,7 +751,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt break; } STR_FREE(priv_name); - prot_name = zend_mangle_property_name("*", 1, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); + prot_name = zend_mangle_property_name("*", 1, Z_STRVAL_P(name), Z_STRSIZE_P(name), ce->type & ZEND_INTERNAL_CLASS); if ((d = zend_hash_find(propers, prot_name)) != NULL) { if (Z_TYPE_P(d) == IS_INDIRECT) { d = Z_INDIRECT_P(d); @@ -766,12 +766,12 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt break; } STR_FREE(prot_name); - php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); + php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRSIZE_P(name)); php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_P(name)); } while (0); } else { - php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); + php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRSIZE_P(name)); php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); } } @@ -797,12 +797,12 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var php_add_var_hash(var_hash, struc, &var_already TSRMLS_CC) == FAILURE) { if (Z_ISREF_P(struc)) { smart_str_appendl(buf, "R:", 2); - smart_str_append_long(buf, Z_LVAL(var_already)); + smart_str_append_int(buf, Z_IVAL(var_already)); smart_str_appendc(buf, ';'); return; } else if (Z_TYPE_P(struc) == IS_OBJECT) { smart_str_appendl(buf, "r:", 2); - smart_str_append_long(buf, Z_LVAL(var_already)); + smart_str_append_int(buf, Z_IVAL(var_already)); smart_str_appendc(buf, ';'); return; } @@ -822,8 +822,8 @@ again: smart_str_appendl(buf, "N;", 2); return; - case IS_LONG: - php_var_serialize_long(buf, Z_LVAL_P(struc)); + case IS_INT: + php_var_serialize_long(buf, Z_IVAL_P(struc)); return; case IS_DOUBLE: { @@ -839,7 +839,7 @@ again: } case IS_STRING: - php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRSIZE_P(struc)); return; case IS_OBJECT: { @@ -859,12 +859,12 @@ again: if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) { smart_str_appendl(buf, "C:", 2); - smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name->len); + smart_str_append_int(buf, (int)Z_OBJCE_P(struc)->name->len); smart_str_appendl(buf, ":\"", 2); smart_str_appendl(buf, Z_OBJCE_P(struc)->name->val, Z_OBJCE_P(struc)->name->len); smart_str_appendl(buf, "\":", 2); - smart_str_append_long(buf, (int)serialized_length); + smart_str_append_int(buf, (int)serialized_length); smart_str_appendl(buf, ":{", 2); smart_str_appendl(buf, serialized_data, serialized_length); smart_str_appendc(buf, '}'); @@ -923,7 +923,7 @@ again: if (i > 0 && incomplete_class) { --i; } - smart_str_append_long(buf, i); + smart_str_append_int(buf, i); smart_str_appendl(buf, ":{", 2); if (i > 0) { zend_string *key; @@ -1048,7 +1048,7 @@ PHP_FUNCTION(memory_get_usage) { RETURN_FALSE; } - RETURN_LONG(zend_memory_usage(real_usage TSRMLS_CC)); + RETURN_INT(zend_memory_usage(real_usage TSRMLS_CC)); } /* }}} */ @@ -1061,7 +1061,7 @@ PHP_FUNCTION(memory_get_peak_usage) { RETURN_FALSE; } - RETURN_LONG(zend_memory_peak_usage(real_usage TSRMLS_CC)); + RETURN_INT(zend_memory_peak_usage(real_usage TSRMLS_CC)); } /* }}} */ diff --git a/ext/standard/var_unserializer.c b/ext/standard/var_unserializer.c index b6fcd79c2d..968598aa18 100644 --- a/ext/standard/var_unserializer.c +++ b/ext/standard/var_unserializer.c @@ -307,7 +307,7 @@ static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long return 0; } - if (Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING) { + if (Z_TYPE(key) != IS_INT && Z_TYPE(key) != IS_STRING) { zval_dtor(&key); return 0; } @@ -317,12 +317,12 @@ static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long if (!objprops) { switch (Z_TYPE(key)) { - case IS_LONG: - if ((old_data = zend_hash_index_find(ht, Z_LVAL(key))) != NULL) { + case IS_INT: + if ((old_data = zend_hash_index_find(ht, Z_IVAL(key))) != NULL) { //??? update hash var_push_dtor(var_hash, old_data); } - data = zend_hash_index_update(ht, Z_LVAL(key), &d); + data = zend_hash_index_update(ht, Z_IVAL(key), &d); break; case IS_STRING: if ((old_data = zend_symtable_find(ht, Z_STR(key))) != NULL) { @@ -1142,9 +1142,9 @@ yy79: } /* Use double for large long values that were serialized on a 64-bit system */ - if (digits >= MAX_LENGTH_OF_LONG - 1) { - if (digits == MAX_LENGTH_OF_LONG - 1) { - int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1); + if (digits >= MAX_LENGTH_OF_ZEND_INT - 1) { + if (digits == MAX_LENGTH_OF_ZEND_INT - 1) { + int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_ZEND_INT, int_min_digits, MAX_LENGTH_OF_ZEND_INT - 1); if (!(cmp < 0 || (cmp == 0 && start[2] == '-'))) { goto use_double; @@ -1155,7 +1155,7 @@ yy79: } #endif *p = YYCURSOR; - ZVAL_LONG(rval, parse_iv(start + 2)); + ZVAL_INT(rval, parse_iv(start + 2)); return 1; } #line 1162 "ext/standard/var_unserializer.c" diff --git a/ext/standard/versioning.c b/ext/standard/versioning.c index 9eb3829a08..85085b0b97 100644 --- a/ext/standard/versioning.c +++ b/ext/standard/versioning.c @@ -221,7 +221,7 @@ PHP_FUNCTION(version_compare) } compare = php_version_compare(v1, v2); if (argc == 2) { - RETURN_LONG(compare); + RETURN_INT(compare); } if (!strncmp(op, "<", op_len) || !strncmp(op, "lt", op_len)) { RETURN_BOOL(compare == -1); diff --git a/sapi/cli/cli.h b/sapi/cli/cli.h index dc85893a0b..8840ac01cc 100644 --- a/sapi/cli/cli.h +++ b/sapi/cli/cli.h @@ -30,11 +30,11 @@ #endif -extern PHP_CLI_API size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS_DC); +extern PHP_CLI_API size_t sapi_cli_single_write(const char *str, php_size_t str_length TSRMLS_DC); typedef struct { - size_t (*cli_shell_write)(const char *str, uint str_length TSRMLS_DC); - int (*cli_shell_ub_write)(const char *str, uint str_length TSRMLS_DC); + php_size_t (*cli_shell_write)(const char *str, php_size_t str_length TSRMLS_DC); + php_size_t (*cli_shell_ub_write)(const char *str, php_size_t str_length TSRMLS_DC); int (*cli_shell_run)(TSRMLS_D); } cli_shell_callbacks_t; diff --git a/sapi/cli/php_cli.c b/sapi/cli/php_cli.c index ec76f37715..92ec58b25f 100644 --- a/sapi/cli/php_cli.c +++ b/sapi/cli/php_cli.c @@ -252,16 +252,16 @@ static inline int sapi_cli_select(int fd TSRMLS_DC) return ret != -1; } -PHP_CLI_API size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */ +PHP_CLI_API php_size_t sapi_cli_single_write(const char *str, php_size_t str_length TSRMLS_DC) /* {{{ */ { #ifdef PHP_WRITE_STDOUT long ret; #else - size_t ret; + php_size_t ret; #endif if (cli_shell_callbacks.cli_shell_write) { - size_t shell_wrote; + php_size_t shell_wrote; shell_wrote = cli_shell_callbacks.cli_shell_write(str, str_length TSRMLS_CC); if (shell_wrote > -1) { return shell_wrote; @@ -285,10 +285,10 @@ PHP_CLI_API size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS } /* }}} */ -static int sapi_cli_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */ +static php_size_t sapi_cli_ub_write(const char *str, php_size_t str_length TSRMLS_DC) /* {{{ */ { const char *ptr = str; - uint remaining = str_length; + php_size_t remaining = str_length; size_t ret; if (!str_length) { @@ -296,7 +296,7 @@ static int sapi_cli_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ } if (cli_shell_callbacks.cli_shell_ub_write) { - int ub_wrote; + php_size_t ub_wrote; ub_wrote = cli_shell_callbacks.cli_shell_ub_write(str, str_length TSRMLS_CC); if (ub_wrote > -1) { return ub_wrote; @@ -338,7 +338,7 @@ static char *script_filename = ""; static void sapi_cli_register_variables(zval *track_vars_array TSRMLS_DC) /* {{{ */ { - unsigned int len; + php_size_t len; char *docroot = ""; /* In CGI mode, we consider the environment to be a part of the server @@ -1033,7 +1033,7 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */ if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) { exit_status=254; } - ZVAL_LONG(&argi, index); + ZVAL_INT(&argi, index); zend_hash_str_update(&EG(symbol_table).ht, "argi", sizeof("argi")-1, &argi); while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) { len = strlen(input); @@ -1042,7 +1042,7 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */ } ZVAL_STRINGL(&argn, input, len); zend_hash_str_update(&EG(symbol_table).ht, "argn", sizeof("argn")-1, &argn); - Z_LVAL(argi) = ++index; + Z_IVAL(argi) = ++index; if (exec_run) { if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) { exit_status=254; diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c index 09cfd02ec9..f381e4ba2b 100644 --- a/sapi/cli/php_cli_server.c +++ b/sapi/cli/php_cli_server.c @@ -139,7 +139,7 @@ typedef struct php_cli_server_request { size_t content_len; const char *ext; size_t ext_len; - struct stat sb; + php_stat_t sb; } php_cli_server_request; typedef struct php_cli_server_chunk { @@ -436,7 +436,7 @@ PHP_FUNCTION(apache_request_headers) /* {{{ */ static void add_response_header(sapi_header_struct *h, zval *return_value TSRMLS_DC) /* {{{ */ { char *s, *p; - int len; + ptrdiff_t len; ALLOCA_FLAG(use_heap) if (h->header_len > 0) { @@ -539,7 +539,7 @@ static int sapi_cli_server_startup(sapi_module_struct *sapi_module) /* {{{ */ return SUCCESS; } /* }}} */ -static int sapi_cli_server_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */ +static php_size_t sapi_cli_server_ub_write(const char *str, php_size_t str_length TSRMLS_DC) /* {{{ */ { php_cli_server_client *client = SG(server_context); if (!client) { @@ -619,7 +619,7 @@ static char *sapi_cli_server_read_cookies(TSRMLS_D) /* {{{ */ return val; } /* }}} */ -static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* {{{ */ +static php_size_t sapi_cli_server_read_post(char *buf, php_size_t count_bytes TSRMLS_DC) /* {{{ */ { php_cli_server_client *client = SG(server_context); if (client->request.content) { @@ -635,7 +635,7 @@ static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* { static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val TSRMLS_DC) /* {{{ */ { char *new_val = (char *)val; - uint new_val_len; + php_size_t new_val_len; if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len TSRMLS_CC)) { php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array TSRMLS_CC); } @@ -789,7 +789,7 @@ static int php_cli_server_poller_ctor(php_cli_server_poller *poller) /* {{{ */ return SUCCESS; } /* }}} */ -static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, int fd) /* {{{ */ +static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */ { if (mode & POLLIN) { PHP_SAFE_FD_SET(fd, &poller->rfds); @@ -802,7 +802,7 @@ static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, i } } /* }}} */ -static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, int fd) /* {{{ */ +static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */ { if (mode & POLLIN) { PHP_SAFE_FD_CLR(fd, &poller->rfds); @@ -830,7 +830,7 @@ static int php_cli_server_poller_poll(php_cli_server_poller *poller, struct time return php_select(poller->max_fd + 1, &poller->active.rfds, &poller->active.wfds, NULL, tv); } /* }}} */ -static int php_cli_server_poller_iter_on_active(php_cli_server_poller *poller, void *opaque, int(*callback)(void *, int fd, int events)) /* {{{ */ +static int php_cli_server_poller_iter_on_active(php_cli_server_poller *poller, void *opaque, int(*callback)(void *, php_socket_t fd, int events)) /* {{{ */ { int retval = SUCCESS; #ifdef PHP_WIN32 @@ -1209,7 +1209,7 @@ static void php_cli_server_logf(const char *format TSRMLS_DC, ...) /* {{{ */ static int php_network_listen_socket(const char *host, int *port, int socktype, int *af, socklen_t *socklen, zend_string **errstr TSRMLS_DC) /* {{{ */ { - int retval = SOCK_ERR; + php_socket_t retval = SOCK_ERR; int err = 0; struct sockaddr *sa = NULL, **p, **sal; @@ -1377,7 +1377,7 @@ static void php_cli_server_request_dtor(php_cli_server_request *req) /* {{{ */ static void php_cli_server_request_translate_vpath(php_cli_server_request *request, const char *document_root, size_t document_root_len) /* {{{ */ { - struct stat sb; + php_stat_t sb; static const char *index_files[] = { "index.php", "index.html", NULL }; char *buf = safe_pemalloc(1, request->vpath_len, 1 + document_root_len + 1 + sizeof("index.html"), 1); char *p = buf, *prev_path = NULL, *q, *vpath; @@ -1414,7 +1414,7 @@ static void php_cli_server_request_translate_vpath(php_cli_server_request *reque *p = '\0'; q = p; while (q > buf) { - if (!stat(buf, &sb)) { + if (!php_stat_fn(buf, &sb)) { if (sb.st_mode & S_IFDIR) { const char **file = index_files; if (q[-1] != DEFAULT_SLASH) { @@ -1423,7 +1423,7 @@ static void php_cli_server_request_translate_vpath(php_cli_server_request *reque while (*file) { size_t l = strlen(*file); memmove(q, *file, l + 1); - if (!stat(buf, &sb) && (sb.st_mode & S_IFREG)) { + if (!php_stat_fn(buf, &sb) && (sb.st_mode & S_IFREG)) { q += l; break; } @@ -1785,7 +1785,7 @@ static void destroy_request_info(sapi_request_info *request_info) /* {{{ */ { } /* }}} */ -static int php_cli_server_client_ctor(php_cli_server_client *client, php_cli_server *server, int client_sock, struct sockaddr *addr, socklen_t addr_len TSRMLS_DC) /* {{{ */ +static int php_cli_server_client_ctor(php_cli_server_client *client, php_cli_server *server, php_socket_t client_sock, struct sockaddr *addr, socklen_t addr_len TSRMLS_DC) /* {{{ */ { client->server = server; client->sock = client_sock; @@ -2361,7 +2361,7 @@ typedef struct php_cli_server_do_event_for_each_fd_callback_params { int(*whandler)(php_cli_server*, php_cli_server_client* TSRMLS_DC); } php_cli_server_do_event_for_each_fd_callback_params; -static int php_cli_server_do_event_for_each_fd_callback(void *_params, int fd, int event) /* {{{ */ +static int php_cli_server_do_event_for_each_fd_callback(void *_params, php_socket_t fd, int event) /* {{{ */ { php_cli_server_do_event_for_each_fd_callback_params *params = _params; #ifdef ZTS @@ -2487,9 +2487,9 @@ int do_cli_server(int argc, char **argv TSRMLS_DC) /* {{{ */ } if (document_root) { - struct stat sb; + php_stat_t sb; - if (stat(document_root, &sb)) { + if (php_stat_fn(document_root, &sb)) { fprintf(stderr, "Directory %s does not exist.\n", document_root); return 1; } |