/**
* 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;
}
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, 1, 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;
}
PHP_METHOD(Rows, offsetExists)
{
zval* offset;
cassandra_rows* self = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &offset) == FAILURE)
return;
if (Z_TYPE_P(offset) != IS_LONG || Z_LVAL_P(offset) < 0) {
INVALID_ARGUMENT(offset, "a positive integer");
}
self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC);
RETURN_BOOL(zend_hash_index_exists(Z_ARRVAL_P(self->rows), (ulong) Z_LVAL_P(offset)));
}
PHP_COUCHBASE_LOCAL
zval *pcbc_ht_ifind(zval *assoc, unsigned long idx)
{
zval *data;
ISARRAY_SANITY(assoc);
if (!zend_hash_index_exists(Z_ARRVAL_P(assoc), idx)) {
return NULL;
}
if (zend_hash_index_find(Z_ARRVAL_P(assoc),
idx, (void **)&data) != SUCCESS) {
return NULL;
}
return data;
}
/* {{{ proto void SolrInputDocument::__construct()
SolrInputDocument constructor */
PHP_METHOD(SolrInputDocument, __construct)
{
zval *objptr = getThis();
uint nSize = SOLR_INITIAL_HASH_TABLE_SIZE;
ulong document_index = SOLR_UNIQUE_DOCUMENT_INDEX();
auto solr_document_t solr_doc;
solr_document_t *doc_entry = NULL, *doc_ptr = NULL;
memset(&solr_doc, 0, sizeof(solr_document_t));
doc_entry = &solr_doc;
doc_entry->document_index = document_index;
doc_entry->field_count = 0L;
doc_entry->document_boost = 0.0f;
/* Allocated memory for the fields HashTable using fast cache for HashTables */
ALLOC_HASHTABLE(doc_entry->fields);
ALLOC_HASHTABLE(doc_entry->children);
/* Initializing the hash table used for storing fields in this SolrDocument */
zend_hash_init(doc_entry->fields, nSize, NULL, (dtor_func_t) solr_destroy_field_list, SOLR_DOCUMENT_FIELD_PERSISTENT);
zend_hash_init(doc_entry->children, nSize, NULL, ZVAL_PTR_DTOR, SOLR_DOCUMENT_FIELD_PERSISTENT);
/* Let's check one more time before insert into the HashTable */
if (zend_hash_index_exists(SOLR_GLOBAL(documents), document_index)) {
pefree(doc_entry->fields, SOLR_DOCUMENT_FIELD_PERSISTENT);
pefree(doc_entry->children, SOLR_DOCUMENT_FIELD_PERSISTENT);
return;
}
/* Add the document entry to the directory of documents */
zend_hash_index_update(SOLR_GLOBAL(documents), document_index, (void *) doc_entry, sizeof(solr_document_t), (void **) &doc_ptr);
/* Set the value of the internal id property */
zend_update_property_long(solr_ce_SolrInputDocument, objptr, SOLR_INDEX_PROPERTY_NAME, sizeof(SOLR_INDEX_PROPERTY_NAME) - 1, document_index TSRMLS_CC);
/* Keep track of how many SolrDocument instances we currently have */
SOLR_GLOBAL(document_count)++;
/* Overriding the default object handlers */
Z_OBJ_HT_P(objptr) = &solr_input_document_object_handlers;
}
/**
* @ret 父亲zval
* @name 父亲name
* @r 子zval
* @son_name 子name
*/
static void php_xml2array_add_val (zval *ret, const xmlChar *name, zval *r, char *son_key) {
zval **tmp = NULL;
char *key = (char *)name;//要插入的node 的key
int has_tmp = zend_symtable_find(Z_ARRVAL(*ret), key, strlen(key) + 1, (void**)&tmp);
if (has_tmp == SUCCESS && tmp != NULL && Z_TYPE_PP(tmp) == IS_ARRAY && son_key == NULL && Z_TYPE_P(r) == IS_STRING) {//avoid <xx></xx>,<xx></xx>
zval_ptr_dtor(&r);
return;
}
if(son_key != NULL && zend_symtable_find(Z_ARRVAL(*ret), key, strlen(key) + 1, (void**)&tmp) != FAILURE
&& Z_TYPE_PP(tmp) == IS_ARRAY) {
zval **son_val = NULL;
zend_symtable_find(Z_ARRVAL_P(r), son_key , strlen(son_key)+1, (void**)&son_val);
zval *son_val_copy;
MAKE_STD_ZVAL(son_val_copy);
MAKE_COPY_ZVAL(son_val, son_val_copy);
zval **tmp_val = NULL;
if (zend_symtable_find(Z_ARRVAL_P(*tmp), son_key , strlen(son_key)+1, (void**)&tmp_val) != FAILURE) {//已经包含同名子元素
if (Z_TYPE_PP(tmp_val) == IS_ARRAY && zend_hash_index_exists(Z_ARRVAL_PP(tmp_val), 0)) {
add_next_index_zval(*tmp_val, son_val_copy);
} else {
zval *son_arr = init_zval_array();
zval *copy;
MAKE_STD_ZVAL(copy);
MAKE_COPY_ZVAL(tmp_val, copy);
add_next_index_zval(son_arr, copy);
add_next_index_zval(son_arr, son_val_copy);
zend_symtable_update(Z_ARRVAL_PP(tmp), son_key, strlen(son_key)+1, (void *) &son_arr, sizeof(zval *), NULL);
}
} else {
add_assoc_zval(*tmp, son_key, son_val_copy);
}
zval_ptr_dtor(&r);//accept a zval** param
} else {
add_assoc_zval(ret, key, r);
}
}
int TWIG_ARRAY_KEY_EXISTS(zval *array, zval *key)
{
if (Z_TYPE_P(array) != IS_ARRAY) {
return 0;
}
switch (Z_TYPE_P(key)) {
case IS_NULL:
return zend_hash_exists(Z_ARRVAL_P(array), "", 1);
case IS_BOOL:
case IS_DOUBLE:
convert_to_long(key);
case IS_LONG:
return zend_hash_index_exists(Z_ARRVAL_P(array), Z_LVAL_P(key));
default:
convert_to_string(key);
return zend_symtable_exists(Z_ARRVAL_P(array), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1);
}
}
static zval *phannot_ret_zval_list(zval *list_left, zval *right_list)
{
zval *ret;
HashPosition pos;
HashTable *list;
MAKE_STD_ZVAL(ret);
array_init(ret);
if (list_left) {
list = Z_ARRVAL_P(list_left);
if (zend_hash_index_exists(list, 0)) {
zend_hash_internal_pointer_reset_ex(list, &pos);
for (;; zend_hash_move_forward_ex(list, &pos)) {
zval ** item;
if (zend_hash_get_current_data_ex(list, (void**) &item, &pos) == FAILURE) {
break;
}
Z_ADDREF_PP(item);
add_next_index_zval(ret, *item);
}
zval_ptr_dtor(&list_left);
} else {
add_next_index_zval(ret, list_left);
}
}
add_next_index_zval(ret, right_list);
return ret;
}
/* {{{ php_runkit_import_functions
*/
static int php_runkit_import_functions(HashTable *function_table, long flags TSRMLS_DC)
{
HashPosition pos;
int i, func_count = zend_hash_num_elements(function_table);
zend_hash_internal_pointer_reset_ex(function_table, &pos);
for(i = 0; i < func_count; i++) {
zend_function *fe = NULL;
char *key, *new_key;
int key_len, new_key_len, type;
long idx;
zend_bool add_function = 1;
zend_bool exists = 0;
zend_hash_get_current_data_ex(function_table, (void**)&fe, &pos);
new_key = fe->common.function_name;
new_key_len = strlen(new_key) + 1;
if (((type = zend_hash_get_current_key_ex(function_table, &key, &key_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT) &&
fe && fe->type == ZEND_USER_FUNCTION) {
if (type == HASH_KEY_IS_STRING) {
new_key = key;
new_key_len = key_len;
exists = zend_hash_exists(EG(function_table), new_key, new_key_len);
} else {
exists = zend_hash_index_exists(EG(function_table), idx);
}
if (exists) {
if (flags & PHP_RUNKIT_IMPORT_OVERRIDE) {
if (type == HASH_KEY_IS_STRING) {
if (zend_hash_del(EG(function_table), new_key, new_key_len) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment");
return FAILURE;
}
} else {
if (zend_hash_index_del(EG(function_table), idx) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment");
return FAILURE;
}
}
} else {
add_function = 0;
}
}
}
if (add_function) {
if (zend_hash_add(EG(function_table), new_key, new_key_len, fe, sizeof(zend_function), NULL) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failure importing %s()", fe->common.function_name);
#ifdef ZEND_ENGINE_2
destroy_zend_function(fe TSRMLS_CC);
#else
destroy_end_function(fe);
#endif
return FAILURE;
} else {
fe->op_array.static_variables = NULL;
(*fe->op_array.refcount)++;
}
}
zend_hash_move_forward_ex(function_table, &pos);
}
return SUCCESS;
}
zval *phalcon_replace_marker(int named, zval *paths, zval *replacements, unsigned long *position, char *cursor, char *marker){
zval **zv, **tmp;
int result = FAILURE;
unsigned int length, variable_length, ch;
char *item = NULL, *cursor_var, *variable = NULL;
int not_valid = 0, j;
if (named) {
length = cursor - marker - 1;
item = estrndup(marker + 1, length);
cursor_var = item;
marker = item;
for (j = 0; j < length; j++) {
ch = *cursor_var;
if (ch == '\0') {
not_valid = 1;
break;
}
if (j == 0 && !((ch >= 'a' && ch <='z') || (ch >= 'A' && ch <= 'Z'))){
not_valid = 1;
break;
}
if ((ch >= 'a' && ch <='z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '-' || ch == '_' || ch == ':') {
if (ch == ':') {
variable_length = cursor_var - marker;
variable = estrndup(marker, variable_length);
break;
}
} else {
not_valid = 1;
break;
}
cursor_var++;
}
}
if (!not_valid) {
if (zend_hash_index_exists(Z_ARRVAL_P(paths), *position)) {
if (named) {
if (variable) {
efree(item);
item = variable;
length = variable_length;
}
if (zend_hash_exists(Z_ARRVAL_P(replacements), item, length + 1)) {
if ((result = zend_hash_find(Z_ARRVAL_P(replacements), item, length + 1, (void**) &zv)) == SUCCESS) {
efree(item);
(*position)++;
return *zv;
}
}
} else {
if ((result = zend_hash_index_find(Z_ARRVAL_P(paths), *position, (void**) &zv)) == SUCCESS) {
if (Z_TYPE_PP(zv) == IS_STRING) {
if (zend_hash_exists(Z_ARRVAL_P(replacements), Z_STRVAL_PP(zv), Z_STRLEN_PP(zv) + 1)) {
if ((result = zend_hash_find(Z_ARRVAL_P(replacements), Z_STRVAL_PP(zv), Z_STRLEN_PP(zv) + 1, (void**) &tmp)) == SUCCESS) {
(*position)++;
return *tmp;
}
}
}
}
}
}
(*position)++;
}
if (item) {
efree(item);
}
return NULL;
}
/**
* Check if char index exists on an array zval
*/
int phalcon_array_isset_long(const zval *arr, ulong index){
if(Z_TYPE_P(arr)!=IS_ARRAY){
return 0;
}
return zend_hash_index_exists(Z_ARRVAL_P(arr), index);
}
static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,
enum pdo_param_event event_type)
{
pdo_pgsql_stmt *S = (pdo_pgsql_stmt*)stmt->driver_data;
if (stmt->supports_placeholders == PDO_PLACEHOLDER_NAMED && param->is_param) {
switch (event_type) {
case PDO_PARAM_EVT_FREE:
if (param->driver_data) {
efree(param->driver_data);
}
break;
case PDO_PARAM_EVT_NORMALIZE:
/* decode name from $1, $2 into 0, 1 etc. */
if (param->name) {
if (ZSTR_VAL(param->name)[0] == '$') {
ZEND_ATOL(param->paramno, ZSTR_VAL(param->name) + 1);
} else {
/* resolve parameter name to rewritten name */
char *namevar;
if (stmt->bound_param_map && (namevar = zend_hash_find_ptr(stmt->bound_param_map,
param->name)) != NULL) {
ZEND_ATOL(param->paramno, namevar + 1);
param->paramno--;
} else {
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", ZSTR_VAL(param->name));
return 0;
}
}
}
break;
case PDO_PARAM_EVT_ALLOC:
if (!zend_hash_index_exists(stmt->bound_param_map, param->paramno)) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined");
return 0;
}
case PDO_PARAM_EVT_EXEC_POST:
case PDO_PARAM_EVT_FETCH_PRE:
case PDO_PARAM_EVT_FETCH_POST:
/* work is handled by EVT_NORMALIZE */
return 1;
case PDO_PARAM_EVT_EXEC_PRE:
if (!stmt->bound_param_map) {
return 0;
}
if (!S->param_values) {
S->param_values = ecalloc(
zend_hash_num_elements(stmt->bound_param_map),
sizeof(char*));
S->param_lengths = ecalloc(
zend_hash_num_elements(stmt->bound_param_map),
sizeof(int));
S->param_formats = ecalloc(
zend_hash_num_elements(stmt->bound_param_map),
sizeof(int));
S->param_types = ecalloc(
zend_hash_num_elements(stmt->bound_param_map),
sizeof(Oid));
}
if (param->paramno >= 0) {
zval *parameter;
/*
if (param->paramno >= zend_hash_num_elements(stmt->bound_params)) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined");
return 0;
}
*/
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB &&
Z_TYPE_P(parameter) == IS_RESOURCE) {
php_stream *stm;
php_stream_from_zval_no_verify(stm, parameter);
if (stm) {
if (php_stream_is(stm, &pdo_pgsql_lob_stream_ops)) {
struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stm->abstract;
pdo_pgsql_bound_param *P = param->driver_data;
if (P == NULL) {
P = ecalloc(1, sizeof(*P));
param->driver_data = P;
}
P->oid = htonl(self->oid);
S->param_values[param->paramno] = (char*)&P->oid;
S->param_lengths[param->paramno] = sizeof(P->oid);
S->param_formats[param->paramno] = 1;
S->param_types[param->paramno] = OIDOID;
return 1;
} else {
zend_string *str = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
if (str != NULL) {
//??SEPARATE_ZVAL_IF_NOT_REF(¶m->parameter);
ZVAL_STR(parameter, str);
} else {
ZVAL_EMPTY_STRING(parameter);
}
}
} else {
/* expected a stream resource */
pdo_pgsql_error_stmt(stmt, PGRES_FATAL_ERROR, "HY105");
return 0;
}
}
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL ||
Z_TYPE_P(parameter) == IS_NULL) {
S->param_values[param->paramno] = NULL;
S->param_lengths[param->paramno] = 0;
} else if (Z_TYPE_P(parameter) == IS_FALSE || Z_TYPE_P(parameter) == IS_TRUE) {
S->param_values[param->paramno] = Z_TYPE_P(parameter) == IS_TRUE ? "t" : "f";
S->param_lengths[param->paramno] = 1;
S->param_formats[param->paramno] = 0;
} else {
//SEPARATE_ZVAL_IF_NOT_REF(¶m->parameter);
convert_to_string_ex(parameter);
S->param_values[param->paramno] = Z_STRVAL_P(parameter);
S->param_lengths[param->paramno] = Z_STRLEN_P(parameter);
S->param_formats[param->paramno] = 0;
}
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
S->param_types[param->paramno] = 0;
S->param_formats[param->paramno] = 1;
} else {
S->param_types[param->paramno] = 0;
}
}
break;
}
} else if (param->is_param) {
/* We need to manually convert to a pg native boolean value */
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_BOOL &&
((param->param_type & PDO_PARAM_INPUT_OUTPUT) != PDO_PARAM_INPUT_OUTPUT)) {
const char *s = zend_is_true(¶m->parameter) ? "t" : "f";
param->param_type = PDO_PARAM_STR;
zval_ptr_dtor(¶m->parameter);
ZVAL_STRINGL(¶m->parameter, s, 1);
}
}
return 1;
}
static zval *get_trace_detail(const jsonlite_decoder *self) {
HashTable *array = NULL;
HashPosition *pointer = NULL;
zval *traces = NULL;
zval *trace = NULL;
zval **val = NULL;
zval **msg = NULL;
zval **range_start = NULL;
zval **range_end = NULL;
zval *range = NULL;
char *str = NULL;
zval *chars = NULL;
zval **detail = NULL;
int start = 0;
int end = 0;
array = Z_ARRVAL_P(self->trace);
ALLOC_INIT_ZVAL(traces);
array_init(traces);
zend_hash_internal_pointer_reset_ex(array, pointer);
while (zend_hash_has_more_elements_ex(array, pointer) == SUCCESS) {
if (zend_hash_get_current_data_ex(array, (void **) &val, pointer) == SUCCESS) {
if (val && Z_TYPE_PP(val) == IS_ARRAY) {
zend_hash_index_find(Z_ARRVAL_PP(val), 0, (void **) &msg);
zend_hash_index_find(Z_ARRVAL_PP(val), 1, (void **) &range_start);
zend_hash_index_find(Z_ARRVAL_PP(val), 2, (void **) &range_end);
if (zend_hash_index_exists(Z_ARRVAL_PP(val), 3) == 1) {
zend_hash_index_find(Z_ARRVAL_PP(val), 3, (void **) &detail);
}
ALLOC_INIT_ZVAL(trace);
array_init(trace);
zval_add_ref(msg);
add_assoc_zval_ex(trace, ZEND_STRS("msg"), *msg);
ALLOC_INIT_ZVAL(range);
array_init(range);
zval_add_ref(range_start);
add_next_index_zval(range, *range_start);
zval_add_ref(range_end);
add_next_index_zval(range, *range_end);
add_assoc_zval_ex(trace, ZEND_STRS("range"), range);
start = Z_LVAL_PP(range_start);
if (start > 0) {
start--;
}
end = Z_LVAL_PP(range_end);
if (end < self->length) {
end++;
}
str = zend_strndup((self->jsonlite + start), end - start);
add_assoc_string_ex(trace, ZEND_STRS("chars"), str, 1);
free(str);
if (detail != NULL) {
zval_add_ref(detail);
add_assoc_zval_ex(trace, ZEND_STRS("detail"), *detail);
}
add_next_index_zval(traces, trace);
detail = NULL;
trace = NULL;
}
}
if (zend_hash_move_forward_ex(array, pointer) == FAILURE) {
break;
}
}
return traces;
}
