bool f_settype(VRefParam var, CStrRef type) {
if (type == "boolean") var = var.toBoolean();
else if (type == "bool" ) var = var.toBoolean();
else if (type == "integer") var = var.toInt64();
else if (type == "int" ) var = var.toInt64();
else if (type == "float" ) var = var.toDouble();
else if (type == "string" ) var = var.toString();
else if (type == "array" ) var = var.toArray();
else if (type == "object" ) var = var.toObject();
else if (type == "null" ) var = null;
else return false;
return true;
}
bool f_settype(VRefParam var, CStrRef type) {
if (type == s_boolean) var = var.toBoolean();
else if (type == s_bool ) var = var.toBoolean();
else if (type == s_integer) var = var.toInt64();
else if (type == s_int ) var = var.toInt64();
else if (type == s_float ) var = var.toDouble();
else if (type == s_string ) var = var.toString();
else if (type == s_array ) var = var.toArray();
else if (type == s_object ) var = var.toObject();
else if (type == s_null ) var = uninit_null();
else return false;
return true;
}
bool HHVM_FUNCTION(settype, VRefParam var, const String& type) {
if (type == s_boolean) var = var.toBoolean();
else if (type == s_bool ) var = var.toBoolean();
else if (type == s_integer) var = var.toInt64();
else if (type == s_int ) var = var.toInt64();
else if (type == s_float ) var = var.toDouble();
else if (type == s_string ) var = var.toString();
else if (type == s_array ) var = var.toArray();
else if (type == s_object ) var = var.toObject();
else if (type == s_null ) var = uninit_null();
else return false;
return true;
}
int64_t f_array_unshift(int _argc, VRefParam array, CVarRef var, CArrRef _argv /* = null_array */) {
if (array.toArray()->isVectorData()) {
if (!_argv.empty()) {
for (ssize_t pos = _argv->iter_end(); pos != ArrayData::invalid_index;
pos = _argv->iter_rewind(pos)) {
array.prepend(_argv->getValueRef(pos));
}
}
array.prepend(var);
} else {
{
Array newArray;
newArray.append(var);
if (!_argv.empty()) {
for (ssize_t pos = _argv->iter_begin();
pos != ArrayData::invalid_index;
pos = _argv->iter_advance(pos)) {
newArray.append(_argv->getValueRef(pos));
}
}
for (ArrayIter iter(array); iter; ++iter) {
Variant key(iter.first());
CVarRef value(iter.secondRef());
if (key.isInteger()) {
newArray.appendWithRef(value);
} else {
newArray.lvalAt(key, AccessFlags::Key).setWithRef(value);
}
}
array = newArray;
}
// Reset the array's internal pointer
if (array.is(KindOfArray)) {
array.array_iter_reset();
}
}
return array.toArray().size();
}
Variant f_socket_select(VRefParam read, VRefParam write, VRefParam except,
CVarRef vtv_sec, int tv_usec /* = 0 */) {
int count = 0;
if (!read.isNull()) {
count += read.toArray().size();
}
if (!write.isNull()) {
count += write.toArray().size();
}
if (!except.isNull()) {
count += except.toArray().size();
}
if (!count) {
return false;
}
struct pollfd *fds = (struct pollfd *)calloc(count, sizeof(struct pollfd));
count = 0;
if (!read.isNull()) {
sock_array_to_fd_set(read.toArray(), fds, count, POLLIN);
}
if (!write.isNull()) {
sock_array_to_fd_set(write.toArray(), fds, count, POLLOUT);
}
if (!except.isNull()) {
sock_array_to_fd_set(except.toArray(), fds, count, POLLPRI);
}
IOStatusHelper io("socket_select");
int timeout_ms = -1;
if (!vtv_sec.isNull()) {
timeout_ms = vtv_sec.toInt32() * 1000 + tv_usec / 1000;
}
int retval = poll(fds, count, timeout_ms);
if (retval == -1) {
raise_warning("unable to select [%d]: %s", errno,
Util::safe_strerror(errno).c_str());
free(fds);
return false;
}
count = 0;
int nfds = 0;
if (!read.isNull()) {
sock_array_from_fd_set(read, fds, nfds, count, POLLIN|POLLERR);
}
if (!write.isNull()) {
sock_array_from_fd_set(write, fds, nfds, count, POLLOUT|POLLERR);
}
if (!except.isNull()) {
sock_array_from_fd_set(except, fds, nfds, count, POLLPRI|POLLERR);
}
free(fds);
return count;
}
bool c_Collator::t_sortwithsortkeys(VRefParam arr) {
INSTANCE_METHOD_INJECTION_BUILTIN(Collator, Collator::sortwithsortkeys);
char* sortKeyBuf = NULL; /* buffer to store sort keys */
int32_t sortKeyBufSize = DEF_SORT_KEYS_BUF_SIZE; /* buffer size */
ptrdiff_t sortKeyBufOffset = 0; /* pos in buffer to store sort key */
int32_t sortKeyLen = 0; /* the length of currently processing key */
int32_t bufLeft = 0;
int32_t bufIncrement = 0;
/* buffer to store 'indexes' which will be passed to 'qsort' */
collator_sort_key_index_t* sortKeyIndxBuf = NULL;
int32_t sortKeyIndxBufSize = DEF_SORT_KEYS_INDX_BUF_SIZE;
int32_t sortKeyIndxSize = sizeof( collator_sort_key_index_t );
int32_t sortKeyCount = 0;
int32_t j = 0;
/* tmp buffer to hold current processing string in utf-16 */
UChar* utf16_buf = NULL;
/* the length of utf16_buf */
int utf16_buf_size = DEF_UTF16_BUF_SIZE;
/* length of converted string */
int utf16_len = 0;
m_errcode.clear();
s_intl_error->m_error.clear();
/*
* Sort specified array.
*/
if (!arr.isArray()) {
return true;
}
Array hash = arr.toArray();
if (hash.size() == 0) {
return true;
}
/* Create bufers */
sortKeyBuf = (char*)calloc(sortKeyBufSize, sizeof(char));
sortKeyIndxBuf = (collator_sort_key_index_t*)malloc(sortKeyIndxBufSize);
utf16_buf = (UChar*)malloc(utf16_buf_size);
/* Iterate through input hash and create a sort key for each value. */
for (ssize_t pos = hash->iter_begin(); pos != ArrayData::invalid_index;
pos = hash->iter_advance(pos)) {
/* Convert current hash item from UTF-8 to UTF-16LE and save the result
* to utf16_buf. */
utf16_len = utf16_buf_size;
/* Process string values only. */
Variant val(hash->getValue(pos));
if (val.isString()) {
String str = val.toString();
intl_convert_utf8_to_utf16(&utf16_buf, &utf16_len, str.data(),
str.size(), &(m_errcode.code));
if (U_FAILURE(m_errcode.code)) {
m_errcode.custom_error_message = "Sort with sort keys failed";
if (utf16_buf) {
free(utf16_buf);
}
free(sortKeyIndxBuf);
free(sortKeyBuf);
return false;
}
} else {
/* Set empty string */
utf16_len = 0;
utf16_buf[utf16_len] = 0;
}
if ((utf16_len + 1) > utf16_buf_size) {
utf16_buf_size = utf16_len + 1;
}
/* Get sort key, reallocating the buffer if needed. */
bufLeft = sortKeyBufSize - sortKeyBufOffset;
sortKeyLen = ucol_getSortKey(m_ucoll,
utf16_buf,
utf16_len,
(uint8_t*)sortKeyBuf + sortKeyBufOffset,
bufLeft);
/* check for sortKeyBuf overflow, increasing its size of the buffer if
needed */
if (sortKeyLen > bufLeft) {
bufIncrement = ( sortKeyLen > DEF_SORT_KEYS_BUF_INCREMENT ) ?
sortKeyLen : DEF_SORT_KEYS_BUF_INCREMENT;
sortKeyBufSize += bufIncrement;
bufLeft += bufIncrement;
sortKeyBuf = (char*)realloc(sortKeyBuf, sortKeyBufSize);
sortKeyLen = ucol_getSortKey(m_ucoll, utf16_buf, utf16_len,
(uint8_t*)sortKeyBuf + sortKeyBufOffset,
bufLeft);
}
/* check sortKeyIndxBuf overflow, increasing its size of the buffer if
needed */
if ((sortKeyCount + 1) * sortKeyIndxSize > sortKeyIndxBufSize) {
bufIncrement = (sortKeyIndxSize > DEF_SORT_KEYS_INDX_BUF_INCREMENT) ?
sortKeyIndxSize : DEF_SORT_KEYS_INDX_BUF_INCREMENT;
sortKeyIndxBufSize += bufIncrement;
sortKeyIndxBuf = (collator_sort_key_index_t*)realloc(sortKeyIndxBuf,
sortKeyIndxBufSize);
}
sortKeyIndxBuf[sortKeyCount].key = (char*)sortKeyBufOffset;
sortKeyIndxBuf[sortKeyCount].valPos = pos;
sortKeyBufOffset += sortKeyLen;
++sortKeyCount;
}
/* update ptrs to point to valid keys. */
for( j = 0; j < sortKeyCount; j++ )
sortKeyIndxBuf[j].key = sortKeyBuf + (ptrdiff_t)sortKeyIndxBuf[j].key;
/* sort it */
zend_qsort(sortKeyIndxBuf, sortKeyCount, sortKeyIndxSize,
collator_cmp_sort_keys, NULL);
/* for resulting hash we'll assign new hash keys rather then reordering */
Array sortedHash = Array::Create();
for (j = 0; j < sortKeyCount; j++) {
sortedHash.append(hash->getValue(sortKeyIndxBuf[j].valPos));
}
/* Save sorted hash into return variable. */
arr = sortedHash;
if (utf16_buf)
free(utf16_buf);
free(sortKeyIndxBuf);
free(sortKeyBuf);
return true;
}
Variant HHVM_FUNCTION(socket_select,
VRefParam read,
VRefParam write,
VRefParam except,
const Variant& vtv_sec,
int tv_usec /* = 0 */) {
int count = 0;
if (!read.isNull()) {
count += read.toArray().size();
}
if (!write.isNull()) {
count += write.toArray().size();
}
if (!except.isNull()) {
count += except.toArray().size();
}
if (!count) {
return false;
}
struct pollfd *fds = (struct pollfd *)calloc(count, sizeof(struct pollfd));
count = 0;
if (!read.isNull()) {
sock_array_to_fd_set(read.toArray(), fds, count, POLLIN);
}
if (!write.isNull()) {
sock_array_to_fd_set(write.toArray(), fds, count, POLLOUT);
}
if (!except.isNull()) {
sock_array_to_fd_set(except.toArray(), fds, count, POLLPRI);
}
if (!count) {
raise_warning("no resource arrays were passed to select");
free(fds);
return false;
}
IOStatusHelper io("socket_select");
int timeout_ms = -1;
if (!vtv_sec.isNull()) {
timeout_ms = vtv_sec.toInt32() * 1000 + tv_usec / 1000;
}
/* slight hack to support buffered data; if there is data sitting in the
* read buffer of any of the streams in the read array, let's pretend
* that we selected, but return only the readable sockets */
if (!read.isNull()) {
auto hasData = Array::Create();
for (ArrayIter iter(read.toArray()); iter; ++iter) {
auto file = cast<File>(iter.second());
if (file->bufferedLen() > 0) {
hasData.append(iter.second());
}
}
if (hasData.size() > 0) {
if (!write.isNull()) {
write = empty_array();
}
if (!except.isNull()) {
except = empty_array();
}
read = hasData;
free(fds);
return hasData.size();
}
}
int retval = poll(fds, count, timeout_ms);
if (retval == -1) {
raise_warning("unable to select [%d]: %s", errno,
folly::errnoStr(errno).c_str());
free(fds);
return false;
}
count = 0;
int nfds = 0;
if (!read.isNull()) {
sock_array_from_fd_set(read, fds, nfds, count, POLLIN|POLLERR|POLLHUP);
}
if (!write.isNull()) {
sock_array_from_fd_set(write, fds, nfds, count, POLLOUT|POLLERR);
}
if (!except.isNull()) {
sock_array_from_fd_set(except, fds, nfds, count, POLLPRI|POLLERR);
}
free(fds);
return count;
}
static bool HHVM_METHOD(Collator, sortWithSortKeys, VRefParam arr) {
FETCH_COL(data, this_, false);
data->clearError();
if (!arr.isArray()) {
return true;
}
Array hash = arr.toArray();
if (hash.size() == 0) {
return true;
}
// Preallocate sort keys buffer
size_t sortKeysOffset = 0;
size_t sortKeysLength = DEF_SORT_KEYS_BUF_SIZE;
char* sortKeys = (char*)smart_malloc(sortKeysLength);
if (!sortKeys) {
throw Exception("Out of memory");
}
SCOPE_EXIT{ smart_free(sortKeys); };
// Preallocate index buffer
size_t sortIndexPos = 0;
size_t sortIndexLength = DEF_SORT_KEYS_INDX_BUF_SIZE;
auto sortIndex = (collator_sort_key_index_t*)smart_malloc(
sortIndexLength * sizeof(collator_sort_key_index_t));
if (!sortIndex) {
throw Exception("Out of memory");
}
SCOPE_EXIT{ smart_free(sortIndex); };
// Translate input hash to sortable index
auto pos_limit = hash->iter_end();
for (ssize_t pos = hash->iter_begin(); pos != pos_limit;
pos = hash->iter_advance(pos)) {
Variant val(hash->getValue(pos));
// Convert to UTF16
icu::UnicodeString strval;
if (val.isString()) {
UErrorCode error = U_ZERO_ERROR;
strval = u16(val.toString(), error);
if (U_FAILURE(error)) {
return false;
}
}
// Generate sort key
int sortkey_len =
ucol_getSortKey(data->collator(),
strval.getBuffer(), strval.length(),
(uint8_t*)(sortKeys + sortKeysOffset),
sortKeysLength - sortKeysOffset);
// Check for key buffer overflow
if (sortkey_len > (sortKeysLength - sortKeysOffset)) {
int32_t inc = (sortkey_len > DEF_SORT_KEYS_BUF_INCREMENT)
? sortkey_len : DEF_SORT_KEYS_BUF_INCREMENT;
sortKeysLength += inc;
sortKeys = (char*)smart_realloc(sortKeys, sortKeysLength);
if (!sortKeys) {
throw Exception("Out of memory");
}
sortkey_len =
ucol_getSortKey(data->collator(),
strval.getBuffer(), strval.length(),
(uint8_t*)(sortKeys + sortKeysOffset),
sortKeysLength - sortKeysOffset);
assert(sortkey_len <= (sortKeysLength - sortKeysOffset));
}
// Check for index buffer overflow
if ((sortIndexPos + 1) > sortIndexLength) {
sortIndexLength += DEF_SORT_KEYS_INDX_BUF_INCREMENT;
sortIndex = (collator_sort_key_index_t*)smart_realloc(sortIndex,
sortIndexLength * sizeof(collator_sort_key_index_t));
if (!sortIndex) {
throw Exception("Out of memory");
}
}
// Initially store offset into buffer, update later to deal with reallocs
sortIndex[sortIndexPos].key = (char*)sortKeysOffset;
sortKeysOffset += sortkey_len;
sortIndex[sortIndexPos].valPos = pos;
++sortIndexPos;
}
// Update keys to location in realloc'd buffer
for (int i = 0; i < sortIndexPos; ++i) {
sortIndex[i].key = sortKeys + (ptrdiff_t)sortIndex[i].key;
}
zend_qsort(sortIndex, sortIndexPos,
sizeof(collator_sort_key_index_t),
collator_cmp_sort_keys, nullptr);
Array ret = Array::Create();
for (int i = 0; i < sortIndexPos; ++i) {
ret.append(hash->getValue(sortIndex[i].valPos));
}
arr = ret;
return true;
}
