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++; } }