bool tvCanBeCoercedToNumber(TypedValue* tv) {
switch (tv->m_type) {
case KindOfUninit:
case KindOfNull:
case KindOfBoolean:
case KindOfInt64:
case KindOfDouble:
return true;
case KindOfStaticString:
case KindOfString: {
StringData* s;
DataType type;
s = tv->m_data.pstr;
type = is_numeric_string(s->data(), s->size(), nullptr, nullptr);
return type == KindOfInt64 || type == KindOfDouble;
}
case KindOfArray:
case KindOfObject:
case KindOfResource:
return false;
case KindOfRef:
case KindOfClass:
break;
}
not_reached();
}
U_CFUNC PHP_FUNCTION(intltz_create_enumeration)
{
zval *arg = NULL;
StringEnumeration *se = NULL;
intl_error_reset(NULL);
/* double indirection to have the zend engine destroy the new zval that
* results from separation */
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &arg) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: bad arguments", 0);
RETURN_FALSE;
}
if (arg == NULL || Z_TYPE_P(arg) == IS_NULL) {
se = TimeZone::createEnumeration();
} else if (Z_TYPE_P(arg) == IS_LONG) {
int_offset:
if (Z_LVAL_P(arg) < (zend_long)INT32_MIN ||
Z_LVAL_P(arg) > (zend_long)INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: value is out of range", 0);
RETURN_FALSE;
} else {
se = TimeZone::createEnumeration((int32_t) Z_LVAL_P(arg));
}
} else if (Z_TYPE_P(arg) == IS_DOUBLE) {
double_offset:
convert_to_long_ex(arg);
goto int_offset;
} else if (Z_TYPE_P(arg) == IS_OBJECT || Z_TYPE_P(arg) == IS_STRING) {
zend_long lval;
double dval;
convert_to_string_ex(arg);
switch (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &lval, &dval, 0)) {
case IS_DOUBLE:
zval_ptr_dtor(arg);
ZVAL_DOUBLE(arg, dval);
goto double_offset;
case IS_LONG:
zval_ptr_dtor(arg);
ZVAL_LONG(arg, lval);
goto int_offset;
}
/* else call string version */
se = TimeZone::createEnumeration(Z_STRVAL_P(arg));
} else {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: invalid argument type", 0);
RETURN_FALSE;
}
if (se) {
IntlIterator_from_StringEnumeration(se, return_value);
} else {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: error obtaining enumeration", 0);
RETVAL_FALSE;
}
}
PHP_METHOD(jz_data, get) {
zval *ret, *pzval, *default_value = NULL;
zend_string *name = NULL;
uint32_t num_args = ZEND_NUM_ARGS();
if (zend_parse_parameters(num_args, "|Sz", &name, &default_value) == FAILURE) {
return;
}
if (!name) {
RETURN_ZVAL(getThis(), 1, 0);
} else {
zval *properties;
HashTable *hash;
zend_long lval;
double dval;
properties = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
hash = Z_ARRVAL_P(properties);
if (is_numeric_string(ZSTR_VAL(name), ZSTR_LEN(name), &lval, &dval, 0) != IS_LONG) {
if ((pzval = zend_hash_find(hash, name)) == NULL) {
goto GET_RETURN;
}
} else {
if ((pzval = zend_hash_index_find(hash, lval)) == NULL) {
goto GET_RETURN;
}
}
if (Z_TYPE_P(pzval) == IS_ARRAY) {
zval rv = {{0}};
if ((ret = jz_data_format(getThis(), pzval, &rv))) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
} else {
RETURN_ZVAL(pzval, 1, 0);
}
}
GET_RETURN: {
if (1 == num_args || Z_TYPE_P(default_value) == IS_NULL) {
RETURN_NULL();
} else {
if (Z_TYPE_P(default_value) == IS_ARRAY) {
zval rv = {{0}};
if ((ret = jz_data_format(getThis(), default_value, &rv))) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
}
RETURN_ZVAL(default_value, 1, 0);
}
}
}
DataType StringData::toNumeric(int64 &ival, double &dval) const {
int len = size();
if (len) {
DataType r = is_numeric_string(data(), len, &ival, &dval, 0);
if (r == KindOfInt64 || r == KindOfDouble) return r;
}
return KindOfString;
}
/* CONVERSIONS for integers */
static zend_long from_zval_integer_common(const zval *arr_value, ser_context *ctx)
{
zend_long ret = 0;
zval lzval;
ZVAL_NULL(&lzval);
if (Z_TYPE_P(arr_value) != IS_LONG) {
ZVAL_COPY(&lzval, (zval *)arr_value);
arr_value = &lzval;
}
switch (Z_TYPE_P(arr_value)) {
case IS_LONG:
long_case:
ret = Z_LVAL_P(arr_value);
break;
/* if not long we're operating on lzval */
case IS_DOUBLE:
double_case:
convert_to_long(&lzval);
goto long_case;
case IS_OBJECT:
case IS_STRING: {
zend_long lval;
double dval;
convert_to_string(&lzval);
switch (is_numeric_string(Z_STRVAL(lzval), Z_STRLEN(lzval), &lval, &dval, 0)) {
case IS_DOUBLE:
zval_dtor(&lzval);
ZVAL_DOUBLE(&lzval, dval);
goto double_case;
case IS_LONG:
zval_dtor(&lzval);
ZVAL_LONG(&lzval, lval);
goto long_case;
}
/* if we get here, we don't have a numeric string */
do_from_zval_err(ctx, "expected an integer, but got a non numeric "
"string (possibly from a converted object): '%s'", Z_STRVAL_P(arr_value));
break;
}
default:
do_from_zval_err(ctx, "%s", "expected an integer, either of a PHP "
"integer type or of a convertible type");
break;
}
zval_dtor(&lzval);
return ret;
}
void StringData::preCompute() {
auto s = slice();
m_hash = hash_string_unsafe(s.data(), s.size());
assert(m_hash >= 0);
if (s.size() > 0 &&
(is_numeric_string(s.data(), s.size(), nullptr, nullptr,
1, nullptr) == KindOfNull)) {
m_hash |= STRHASH_MSB;
}
}
void StringData::preCompute() {
StringSlice s = slice();
m_hash = hash_string_unsafe(s.ptr, s.len);
assert(m_hash >= 0);
if (s.len > 0 &&
(is_numeric_string(s.ptr, s.len, nullptr, nullptr,
1, nullptr) == KindOfNull)) {
m_hash |= STRHASH_MSB;
}
}
static PHP_INI_MH(OnUpdateIsMasterInterval)
{
long converted_val;
if (new_value && is_numeric_string(new_value, new_value_length, &converted_val, NULL, 0) == IS_LONG && converted_val > 0) {
MonGlo(manager)->ismaster_interval = converted_val;
return SUCCESS;
}
return FAILURE;
}
bool more(int64 v1, CStrRef v2) {
DataType ret = KindOfNull;
int64 lval; double dval;
ret = is_numeric_string(v2.data(), v2.size(), &lval, &dval, 1);
if (ret == KindOfInt64) {
return v1 > lval;
} else if (ret == KindOfDouble) {
return (double)v1 > dval;
} else {
return v1 > 0;
}
}
/**
* Check if index exists on an array zval
*/
int PHALCON_FASTCALL phalcon_array_isset(const zval *arr, zval *index) {
zval *copy;
int exists, type, copied = 0;
if (Z_TYPE_P(arr) != IS_ARRAY) {
return 0;
} else {
if (!zend_hash_num_elements(Z_ARRVAL_P(arr))) {
return 0;
}
}
if (Z_TYPE_P(index) == IS_NULL) {
ALLOC_INIT_ZVAL(copy);
ZVAL_ZVAL(copy, index, 1, 0);
convert_to_string(copy);
index = copy;
copied = 1;
} else {
if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) {
ALLOC_INIT_ZVAL(copy);
ZVAL_ZVAL(copy, index, 0, 0);
convert_to_long(copy);
index = copy;
copied = 1;
}
}
if (Z_TYPE_P(index) == IS_STRING) {
if((type = is_numeric_string(Z_STRVAL_P(index), Z_STRLEN_P(index), NULL, NULL, 0))){
if (type == IS_LONG) {
ALLOC_INIT_ZVAL(copy);
ZVAL_ZVAL(copy, index, 1, 0);
convert_to_long(copy);
index = copy;
copied = 1;
}
}
}
if (Z_TYPE_P(index) == IS_STRING) {
exists = zend_hash_exists(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index) + 1);
} else {
exists = zend_hash_index_exists(Z_ARRVAL_P(arr), Z_LVAL_P(index));
}
if (copied) {
zval_ptr_dtor(©);
}
return exists;
}
bool equal(int64 v1, const StringData *v2) {
DataType ret = KindOfNull;
int64 lval; double dval;
ret = is_numeric_string((v2 ? v2->data() : NULL),
(v2 ? v2->size() : 0), &lval, &dval, 1);
if (ret == KindOfInt64) {
return v1 == lval;
} else if (ret == KindOfDouble) {
return (double)v1 == dval;
} else {
return v1 == 0;
}
}
DataType StringData::isNumericWithVal(int64_t &lval, double &dval,
int allow_errors, int* overflow) const {
if (m_hash < 0) return KindOfNull;
DataType ret = KindOfNull;
StringSlice s = slice();
if (s.len) {
ret = is_numeric_string(s.ptr, s.len, &lval, &dval, allow_errors, overflow);
if (ret == KindOfNull && !isShared() && allow_errors) {
m_hash |= STRHASH_MSB;
}
}
return ret;
}
DataType StringData::isNumericWithVal(int64 &lval, double &dval,
int allow_errors) const {
if (m_hash < 0) return KindOfNull;
DataType ret = KindOfNull;
int len = size();
if (len) {
ret = is_numeric_string(data(), size(), &lval, &dval, allow_errors);
if (ret == KindOfNull && !isShared()) {
m_hash |= (1ull << 63);
}
}
return ret;
}
static PHP_INI_MH(OnUpdateNativeLong)
{
long converted_val;
if (new_value && is_numeric_string(new_value, new_value_length, &converted_val, NULL, 0) == IS_LONG) {
if (converted_val != 0) {
php_error_docref(NULL TSRMLS_CC, E_CORE_ERROR, "To prevent data corruption, you are not allowed to turn on the mongo.native_long setting on 32-bit platforms");
}
return SUCCESS;
}
return FAILURE;
}
DataType StringData::isNumericWithVal(int64 &lval, double &dval,
int allow_errors) const {
if (m_hash < 0) return KindOfNull;
DataType ret = KindOfNull;
StringSlice s = slice();
if (s.len) {
// Not involved in further string construction/mutation; no taint pickup
ret = is_numeric_string(s.ptr, s.len, &lval, &dval, allow_errors);
if (ret == KindOfNull && !isShared() && allow_errors) {
m_hash |= STRHASH_MSB;
}
}
return ret;
}
int StringData::numericCompare(const StringData *v2) const {
ASSERT(v2);
int64 lval1, lval2;
double dval1, dval2;
DataType ret1, ret2;
if ((ret1 = is_numeric_string(data(), size(),
&lval1, &dval1, 0)) == KindOfNull ||
(ret1 == KindOfDouble && !finite(dval1)) ||
(ret2 = is_numeric_string(v2->data(), v2->size(),
&lval2, &dval2, 0)) == KindOfNull ||
(ret2 == KindOfDouble && !finite(dval2))) {
return -2;
}
if (ret1 == KindOfInt64 && ret2 == KindOfInt64) {
if (lval1 > lval2) return 1;
if (lval1 == lval2) return 0;
return -1;
}
if (ret1 == KindOfDouble && ret2 == KindOfDouble) {
if (dval1 > dval2) return 1;
if (dval1 == dval2) return 0;
return -1;
}
if (ret1 == KindOfDouble) {
ASSERT(ret2 == KindOfInt64);
dval2 = (double)lval2;
} else {
ASSERT(ret1 == KindOfInt64);
ASSERT(ret2 == KindOfDouble);
dval1 = (double)lval1;
}
if (dval1 > dval2) return 1;
if (dval1 == dval2) return 0;
return -1;
}
bool StringData::isInteger() const {
int len = size();
if (len) {
int64 lval; double dval;
DataType ret = is_numeric_string(data(), len, &lval, &dval, 0);
switch (ret) {
case KindOfNull: return false;
case KindOfInt64: return true;
case KindOfDouble: return false;
default:
ASSERT(false);
break;
}
}
return false;
}
static void add_zval(zval* list, const char* id, zval* val)
{
if (list && val) {
if (id) {
int id_len = strlen(id);
if (!(id_len > 1 && id[0] == '0') && is_numeric_string((char *)id, id_len, NULL, NULL, 0) == IS_LONG) {
long index = strtol(id, NULL, 0);
zend_hash_index_update(Z_ARRVAL_P(list), index, val);
} else {
zend_hash_str_update(Z_ARRVAL_P(list), (char*)id, strlen(id), val);
}
} else {
zend_hash_next_index_insert(Z_ARRVAL_P(list), val);
}
}
}
/** {{{ proto public Yaf_Config_Simple::get(string $name = NULL)
*/
PHP_METHOD(yaf_config_simple, get) {
zval *ret, *pzval;
zend_string *name = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|S", &name) == FAILURE) {
return;
}
if (!name) {
RETURN_ZVAL(getThis(), 1, 0);
} else {
zval *properties;
HashTable *hash;
long lval;
double dval;
properties = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
hash = Z_ARRVAL_P(properties);
if (is_numeric_string(ZSTR_VAL(name), ZSTR_LEN(name), &lval, &dval, 0) != IS_LONG) {
if ((pzval = zend_hash_find(hash, name)) == NULL) {
RETURN_FALSE;
}
} else {
if ((pzval = zend_hash_index_find(hash, lval)) == NULL) {
RETURN_FALSE;
}
}
if (Z_TYPE_P(pzval) == IS_ARRAY) {
zval rv = {{0}};
if ((ret = yaf_config_simple_format(getThis(), pzval, &rv))) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
} else {
RETURN_ZVAL(pzval, 1, 0);
}
}
RETURN_FALSE;
}
DataType StringData::isNumericWithVal(int64_t &lval, double &dval,
int allow_errors, int* overflow) const {
if (m_hash < 0) return KindOfNull;
DataType ret = KindOfNull;
auto s = slice();
if (s.size()) {
ret = is_numeric_string(
s.data(),
s.size(),
&lval,
&dval,
allow_errors,
overflow
);
if (ret == KindOfNull && !isProxy() && allow_errors) {
m_hash |= STRHASH_MSB;
}
}
return ret;
}
bool tvCanBeCoercedToNumber(TypedValue* tv) {
switch (tv->m_type) {
case KindOfStaticString:
case KindOfString:
StringData* s;
DataType type;
s = tv->m_data.pstr;
type = is_numeric_string(s->data(), s->size(), nullptr, nullptr);
if (type != KindOfDouble && type != KindOfInt64) {
return false;
}
break;
case KindOfArray:
case KindOfObject:
return false;
default:
break;
}
return true;
}
ZEND_METHOD(Vedis, decrby)
{
char *key;
int key_len;
zval *zv;
VEDIS_ARGS_PARAM(DECRBY, 6, 2);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
&key, &key_len, &zv) == FAILURE) {
return;
}
VEDIS_SELF(intern);
VEDIS_ARGS_STRING(key, key_len);
switch (Z_TYPE_P(zv)) {
case IS_LONG:
VEDIS_ARGS_INT(Z_LVAL_P(zv));
break;
case IS_DOUBLE:
VEDIS_ARGS_DOUBLE(Z_DVAL_P(zv));
break;
case IS_STRING:
if (is_numeric_string(Z_STRVAL_P(zv), Z_STRLEN_P(zv),
NULL, NULL, 0)) {
VEDIS_ARGS_STRING(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
} else {
RETURN_FALSE;
}
break;
default:
RETURN_FALSE;
break;
}
VEDIS_ARGS_EXEC(RETURN_FALSE);
VEDIS_RETURN_LONG();
}
ZEND_API void convert_scalar_to_number(zval *op)
{
switch (op->type) {
case IS_STRING:
{
char *strval;
strval = op->value.str.val;
switch ((op->type=is_numeric_string(strval, op->value.str.len, &op->value.lval, &op->value.dval))) {
case IS_DOUBLE:
case IS_LONG:
break;
#if 0 && WITH_BCMATH
case FLAG_IS_BC:
op->type = IS_DOUBLE; /* may have lost significant digits */
break;
#endif
default:
op->value.lval = strtol(op->value.str.val, NULL, 10);
op->type = IS_LONG;
break;
}
STR_FREE(strval);
break;
}
case IS_BOOL:
op->type = IS_LONG;
break;
case IS_RESOURCE:
zend_list_delete(op->value.lval);
op->type = IS_LONG;
break;
case IS_NULL:
op->type = IS_LONG;
op->value.lval = 0;
break;
}
}
Variant ArrayUtil::FromHdf(const Hdf &hdf) {
if (hdf.firstChild().exists()) {
Array ret = Array::Create();
const char *value = hdf.get();
if (value) {
ret.set(s_default, String(value, CopyString));
}
for (Hdf child = hdf.firstChild(); child.exists(); child = child.next()) {
ret.set(String(child.getName()), FromHdf(child));
}
return ret;
}
const char *value = hdf.get("");
if (strcasecmp(value, "false") == 0 ||
strcasecmp(value, "no") == 0 ||
strcasecmp(value, "off") == 0) {
return false;
}
if (strcasecmp(value, "true") == 0 ||
strcasecmp(value, "yes") == 0 ||
strcasecmp(value, "on") == 0) {
return true;
}
int64_t lval; double dval;
int len = strlen(value);
DataType ret = is_numeric_string(value, len, &lval, &dval, 0);
switch (ret) {
case KindOfInt64: return lval;
case KindOfDouble: return dval;
default: break;
}
return String(value, len, CopyString);
}
static Array HHVM_FUNCTION(getopt, const String& options,
const Variant& longopts /*=null */) {
opt_struct *opts, *orig_opts;
int len = parse_opts(options.data(), options.size(), &opts);
if (!longopts.isNull()) {
Array arropts = longopts.toArray();
int count = arropts.size();
/* the first <len> slots are filled by the one short ops
* we now extend our array and jump to the new added structs */
opts = (opt_struct *)smart_realloc(
opts, sizeof(opt_struct) * (len + count + 1));
orig_opts = opts;
opts += len;
memset(opts, 0, count * sizeof(opt_struct));
for (ArrayIter iter(arropts); iter; ++iter) {
String entry = iter.second().toString();
opts->need_param = 0;
opts->opt_name = strdup(entry.data());
len = strlen(opts->opt_name);
if ((len > 0) && (opts->opt_name[len - 1] == ':')) {
opts->need_param++;
opts->opt_name[len - 1] = '\0';
if ((len > 1) && (opts->opt_name[len - 2] == ':')) {
opts->need_param++;
opts->opt_name[len - 2] = '\0';
}
}
opts->opt_char = 0;
opts++;
}
} else {
opts = (opt_struct*) smart_realloc(opts, sizeof(opt_struct) * (len + 1));
orig_opts = opts;
opts += len;
}
/* php_getopt want to identify the last param */
opts->opt_char = '-';
opts->need_param = 0;
opts->opt_name = NULL;
static const StaticString s_argv("argv");
Array vargv = php_global(s_argv).toArray();
int argc = vargv.size();
char **argv = (char **)smart_malloc((argc+1) * sizeof(char*));
std::vector<String> holders;
int index = 0;
for (ArrayIter iter(vargv); iter; ++iter) {
String arg = iter.second().toString();
holders.push_back(arg);
argv[index++] = (char*)arg.data();
}
argv[index] = NULL;
/* after our pointer arithmetic jump back to the first element */
opts = orig_opts;
int o;
char *php_optarg = NULL;
int php_optind = 1;
SCOPE_EXIT {
free_longopts(orig_opts);
smart_free(orig_opts);
smart_free(argv);
};
Array ret = Array::Create();
Variant val;
int optchr = 0;
int dash = 0; /* have already seen the - */
char opt[2] = { '\0' };
char *optname;
int optname_len = 0;
int php_optidx;
while ((o = php_getopt(argc, argv, opts, &php_optarg, &php_optind, 0, 1,
optchr, dash, php_optidx))
!= -1) {
/* Skip unknown arguments. */
if (o == '?') {
continue;
}
/* Prepare the option character and the argument string. */
if (o == 0) {
optname = opts[php_optidx].opt_name;
} else {
if (o == 1) {
o = '-';
}
opt[0] = o;
optname = opt;
}
if (php_optarg != NULL) {
/* keep the arg as binary, since the encoding is not known */
val = String(php_optarg, CopyString);
} else {
val = false;
}
/* 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) ==
KindOfInt64) {
/* numeric string */
int optname_int = atoi(optname);
if (ret.exists(optname_int)) {
Variant &e = ret.lvalAt(optname_int);
if (!e.isArray()) {
ret.set(optname_int, make_packed_array(e, val));
} else {
e.toArrRef().append(val);
}
} else {
ret.set(optname_int, val);
}
} else {
/* other strings */
String key(optname, strlen(optname), CopyString);
if (ret.exists(key)) {
Variant &e = ret.lvalAt(key);
if (!e.isArray()) {
ret.set(key, make_packed_array(e, val));
} else {
e.toArrRef().append(val);
}
} else {
ret.set(key, val);
}
}
php_optarg = NULL;
}
return ret;
}
static zend_bool parse_number(jsonlite_decoder *self, zval **ret, const char *boundary) {
zval *value = NULL;
zend_bool pass = 0;
int dotCount = 0;
char ch = 0;
smart_str value_buf = {NULL, 0, 0};
long long_val = 0;
double double_val = 0;
zend_uchar type = 0;
begin(self);
if (self->jsonlite[self->index] == '+') {
self->index++;
} else if (self->jsonlite[self->index] == '-') {
self->index++;
smart_str_appendc(&value_buf, '-');
}
for (; self->index < self->length; self->index++) {
ch = self->jsonlite[self->index];
if (ch == '.') {
dotCount++;
if (dotCount > 1) {
pass = 0;
break;
}
}
if (('0' <= ch && ch <= '9') || ch == '.') {
smart_str_appendc(&value_buf, ch);
pass = 1;
continue;
}
if ((boundary == NULL || strchr(boundary, ch) == NULL) && stack_last(self) != ch) {
/**
* string start with number
*/
pass = 0;
// trace string
}
self->index--;
break;
}
smart_str_0(&value_buf);
type = is_numeric_string(value_buf.c, value_buf.len, &long_val, &double_val, 0);
if (!type) {
pass = 0;
}
if (pass) {
do {
if (dotCount) {
type = IS_DOUBLE;
break;
}
/**
* 0 number
* 0.1 number
* 01 string
* 00 string
*/
if (strcasecmp(value_buf.c, "0") == 0 || strchr(value_buf.c, '0') == 0) {
type = IS_LONG;
break;
}
pass = 0;
} while (0);
}
if (!pass) {
rollback(self);
} else {
if (type == IS_LONG) {
ALLOC_INIT_ZVAL(value);
ZVAL_LONG(value, long_val)
} else if (type == IS_DOUBLE) {
/* Sets addr by hostname, or by ip in string form (AF_INET6) */
int php_set_inet6_addr(struct sockaddr_in6 *sin6, char *string, php_socket *php_sock) /* {{{ */
{
struct in6_addr tmp;
#if HAVE_GETADDRINFO
struct addrinfo hints;
struct addrinfo *addrinfo = NULL;
#endif
char *scope = strchr(string, '%');
if (inet_pton(AF_INET6, string, &tmp)) {
memcpy(&(sin6->sin6_addr.s6_addr), &(tmp.s6_addr), sizeof(struct in6_addr));
} else {
#if HAVE_GETADDRINFO
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_INET6;
#if HAVE_AI_V4MAPPED
hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG;
#else
hints.ai_flags = AI_ADDRCONFIG;
#endif
getaddrinfo(string, NULL, &hints, &addrinfo);
if (!addrinfo) {
#ifdef PHP_WIN32
PHP_SOCKET_ERROR(php_sock, "Host lookup failed", WSAGetLastError());
#else
PHP_SOCKET_ERROR(php_sock, "Host lookup failed", (-10000 - h_errno));
#endif
return 0;
}
if (addrinfo->ai_family != PF_INET6 || addrinfo->ai_addrlen != sizeof(struct sockaddr_in6)) {
php_error_docref(NULL, E_WARNING, "Host lookup failed: Non AF_INET6 domain returned on AF_INET6 socket");
freeaddrinfo(addrinfo);
return 0;
}
memcpy(&(sin6->sin6_addr.s6_addr), ((struct sockaddr_in6*)(addrinfo->ai_addr))->sin6_addr.s6_addr, sizeof(struct in6_addr));
freeaddrinfo(addrinfo);
#else
/* No IPv6 specific hostname resolution is available on this system? */
php_error_docref(NULL, E_WARNING, "Host lookup failed: getaddrinfo() not available on this system");
return 0;
#endif
}
if (scope++) {
zend_long lval = 0;
double dval = 0;
unsigned scope_id = 0;
if (IS_LONG == is_numeric_string(scope, strlen(scope), &lval, &dval, 0)) {
if (lval > 0 && lval <= UINT_MAX) {
scope_id = lval;
}
} else {
php_string_to_if_index(scope, &scope_id);
}
sin6->sin6_scope_id = scope_id;
}
return 1;
}
/**
* Reads an item from an array using a zval as index
*/
int phalcon_array_fetch(zval **return_value, zval *arr, zval *index, int silent TSRMLS_DC){
zval **zv;
int result = FAILURE, type;
if (Z_TYPE_P(index) == IS_ARRAY || Z_TYPE_P(index) == IS_OBJECT) {
ZVAL_NULL(*return_value);
if (silent == PH_NOISY) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type");
}
return FAILURE;
}
if (Z_TYPE_P(index) == IS_NULL) {
convert_to_string(index);
}
ZVAL_NULL(*return_value);
if (Z_TYPE_P(arr) == IS_NULL || Z_TYPE_P(arr) == IS_BOOL) {
return FAILURE;
}
if (Z_TYPE_P(index) != IS_STRING && Z_TYPE_P(index) != IS_LONG && Z_TYPE_P(index) != IS_DOUBLE) {
if (silent == PH_NOISY) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type");
}
return FAILURE;
}
if (Z_TYPE_P(index) == IS_STRING) {
if((type = is_numeric_string(Z_STRVAL_P(index), Z_STRLEN_P(index), NULL, NULL, 0))){
if (type == IS_LONG) {
convert_to_long(index);
}
}
} else {
if (Z_TYPE_P(index) == IS_DOUBLE) {
convert_to_long(index);
}
}
if (Z_TYPE_P(index) == IS_STRING) {
if((result = zend_hash_find(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1, (void**) &zv)) == SUCCESS){
zval_ptr_dtor(return_value);
*return_value = *zv;
Z_ADDREF_PP(return_value);
return SUCCESS;
}
}
if (Z_TYPE_P(index) == IS_LONG) {
if ((result = zend_hash_index_find(Z_ARRVAL_P(arr), Z_LVAL_P(index), (void**) &zv)) == SUCCESS) {
zval_ptr_dtor(return_value);
*return_value = *zv;
Z_ADDREF_PP(return_value);
return SUCCESS;
}
}
if (silent == PH_NOISY) {
if (Z_TYPE_P(index) == IS_LONG) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: %ld", Z_LVAL_P(index));
} else {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: %s", Z_STRVAL_P(index));
}
}
return FAILURE;
}
void VariableSerializer::write(const char *v, int len /* = -1 */,
bool isArrayKey /* = false */) {
switch (m_type) {
case PrintR: {
if (len < 0) len = strlen(v);
m_buf->append(v, len);
break;
}
case DebuggerDump:
case VarExport: {
if (len < 0) len = strlen(v);
m_buf->append('\'');
const char *p = v;
for (int i = 0; i < len; i++, p++) {
const char c = *p;
// adapted from Zend php_var_export and php_addcslashes
if (c == '\0') {
m_buf->append("' . \"\\0\" . '");
continue;
} else if (c == '\'' || c == '\\') {
m_buf->append('\\');
}
m_buf->append(c);
}
m_buf->append('\'');
break;
}
case VarDump:
case DebugDump: {
if (v == NULL) v = "";
if (len < 0) len = strlen(v);
indent();
m_buf->append("string(");
m_buf->append(len);
m_buf->append(") \"");
m_buf->append(v, len);
m_buf->append('"');
writeRefCount();
m_buf->append('\n');
break;
}
case Serialize:
case APCSerialize:
case DebuggerSerialize:
if (len < 0) len = strlen(v);
m_buf->append("s:");
m_buf->append(len);
m_buf->append(":\"");
m_buf->append(v, len);
m_buf->append("\";");
break;
case JSON:
{
if (len < 0) len = strlen(v);
if (m_option & k_JSON_NUMERIC_CHECK) {
int64 lval; double dval;
switch (is_numeric_string(v, len, &lval, &dval, 0)) {
case KindOfInt32:
case KindOfInt64:
write(lval);
return;
case KindOfDouble:
write(dval);
return;
default:
break;
}
}
m_buf->appendJsonEscape(v, len, m_option);
}
break;
default:
ASSERT(false);
break;
}
}
void zend_optimizer_pass2(zend_op_array *op_array)
{
zend_op *opline;
zend_op *end = op_array->opcodes + op_array->last;
opline = op_array->opcodes;
while (opline < end) {
switch (opline->opcode) {
case ZEND_ADD:
case ZEND_SUB:
case ZEND_MUL:
case ZEND_DIV:
case ZEND_POW:
if (opline->op1_type == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
/* don't optimise if it should produce a runtime numeric string error */
if (is_numeric_string(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), NULL, NULL, 0)) {
convert_scalar_to_number(&ZEND_OP1_LITERAL(opline));
}
}
}
/* break missing *intentionally* - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_ADD:
case ZEND_ASSIGN_SUB:
case ZEND_ASSIGN_MUL:
case ZEND_ASSIGN_DIV:
case ZEND_ASSIGN_POW:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
/* don't optimise if it should produce a runtime numeric string error */
if (is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0)) {
convert_scalar_to_number(&ZEND_OP2_LITERAL(opline));
}
}
}
break;
case ZEND_MOD:
case ZEND_SL:
case ZEND_SR:
if (opline->op1_type == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) {
/* don't optimise if it should produce a runtime numeric string error */
if (!(Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING
&& !is_numeric_string(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), NULL, NULL, 0))) {
convert_to_long(&ZEND_OP1_LITERAL(opline));
}
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_MOD:
case ZEND_ASSIGN_SL:
case ZEND_ASSIGN_SR:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
/* don't optimise if it should produce a runtime numeric string error */
if (!(Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING
&& !is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0))) {
convert_to_long(&ZEND_OP2_LITERAL(opline));
}
}
}
break;
case ZEND_CONCAT:
case ZEND_FAST_CONCAT:
if (opline->op1_type == IS_CONST) {
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP1_LITERAL(opline));
}
}
/* break missing *intentionally - the assign_op's may only optimize op2 */
case ZEND_ASSIGN_CONCAT:
if (opline->extended_value != 0) {
/* object tristate op - don't attempt to optimize it! */
break;
}
if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP2_LITERAL(opline));
}
}
break;
case ZEND_JMPZ_EX:
case ZEND_JMPNZ_EX:
/* convert Ti = JMPZ_EX(Ti, L) to JMPZ(Ti, L) */
#if 0
/* Disabled unsafe pattern: in conjunction with
* ZEND_VM_SMART_BRANCH() this may improperly eliminate
* assignment to Ti.
*/
if (opline->op1_type == IS_TMP_VAR &&
opline->result_type == IS_TMP_VAR &&
opline->op1.var == opline->result.var) {
opline->opcode -= 3;
SET_UNUSED(opline->result);
} else
#endif
/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
in case we know it wouldn't jump */
if (opline->op1_type == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ_EX) {
should_jmp = !should_jmp;
}
if (!should_jmp) {
opline->opcode = ZEND_QM_ASSIGN;
SET_UNUSED(opline->op2);
}
}
break;
case ZEND_JMPZ:
case ZEND_JMPNZ:
if (opline->op1_type == IS_CONST) {
int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ) {
should_jmp = !should_jmp;
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
opline->op1_type = IS_UNUSED;
if (should_jmp) {
opline->opcode = ZEND_JMP;
COPY_NODE(opline->op1, opline->op2);
} else {
MAKE_NOP(opline);
}
break;
}
if ((opline + 1)->opcode == ZEND_JMP) {
/* JMPZ(X, L1), JMP(L2) => JMPZNZ(X, L1, L2) */
/* JMPNZ(X, L1), JMP(L2) => JMPZNZ(X, L2, L1) */
if (ZEND_OP2_JMP_ADDR(opline) == ZEND_OP1_JMP_ADDR(opline + 1)) {
/* JMPZ(X, L1), JMP(L1) => NOP, JMP(L1) */
if (opline->op1_type == IS_CV) {
opline->opcode = ZEND_CHECK_VAR;
opline->op2.num = 0;
} else if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
opline->opcode = ZEND_FREE;
opline->op2.num = 0;
} else {
MAKE_NOP(opline);
}
} else {
if (opline->opcode == ZEND_JMPZ) {
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, ZEND_OP1_JMP_ADDR(opline + 1));
} else {
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, ZEND_OP2_JMP_ADDR(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP1_JMP_ADDR(opline + 1));
}
opline->opcode = ZEND_JMPZNZ;
}
}
break;
case ZEND_JMPZNZ:
if (opline->op1_type == IS_CONST) {
zend_op *target_opline;
if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
target_opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); /* JMPNZ */
} else {
target_opline = ZEND_OP2_JMP_ADDR(opline); /* JMPZ */
}
literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op1, target_opline);
opline->op1_type = IS_UNUSED;
opline->opcode = ZEND_JMP;
}
break;
}
opline++;
}
}
