/**
* $x[$a][$b][$c] = $v
*/
void phalcon_array_update_zval_zval_zval_multi_3(zval **arr, zval *index1, zval *index2, zval *index3, zval **value, int flags TSRMLS_DC){
zval *temp1 = NULL, *temp2 = NULL;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);
}
phalcon_array_fetch(&temp2, temp1, index2, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY TSRMLS_CC);
}
phalcon_array_update_zval(&temp2, index3, value, PH_COPY TSRMLS_CC);
}
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
if (temp2 != NULL) {
zval_ptr_dtor(&temp2);
}
}
/**
* $x[$a]["hello"][] = $v
*/
void phalcon_array_update_zval_string_append_multi_3(zval **arr, zval *index1, char *index2, uint index2_length, zval **value, int flags TSRMLS_DC){
zval *temp1 = NULL, *temp2 = NULL;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);
}
phalcon_array_fetch_string(&temp2, temp1, index2, index2_length, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_string(&temp1, index2, index2_length, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_string(&temp1, index2, index2_length, &temp2, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&temp2, *value, flags TSRMLS_CC);
}
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
if (temp2 != NULL) {
zval_ptr_dtor(&temp2);
}
}
/**
* $x[$a][$b]["str"] = $v
*/
void phalcon_array_update_string_zval_zval_multi_3(zval **arr, zval *index1, zval *index2, char *index3, uint index3_length, zval **value, int flags TSRMLS_DC){
zval *temp1, *temp2;
ALLOC_INIT_ZVAL(temp1);
ALLOC_INIT_ZVAL(temp2);
if (Z_TYPE_PP(arr) == IS_ARRAY) {
ALLOC_INIT_ZVAL(temp1);
phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(temp1) == IS_ARRAY) {
ALLOC_INIT_ZVAL(temp2);
phalcon_array_fetch(&temp2, temp1, index2, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY TSRMLS_CC);
}
phalcon_array_update_string(&temp2, index3, index3_length, value, PH_COPY TSRMLS_CC);
zval_ptr_dtor(&temp1);
zval_ptr_dtor(&temp2);
}
/**
* Assigns default values to generated tags by helpers
*
* <code>
* //Assigning "peter" to "name" component
* Phalcon\Tag::setDefault("name", "peter");
*
* //Later in the view
* echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
* </code>
*
* @param string $id
* @param string $value
*/
PHP_METHOD(Phalcon_Tag, setDefault){
zval *id, *value, *is_scalar;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &id, &value) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (zend_is_true(value)) {
PHALCON_INIT_VAR(is_scalar);
PHALCON_CALL_FUNC_PARAMS_1(is_scalar, "is_scalar", value);
if (PHALCON_IS_FALSE(is_scalar)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "Only scalar values can be assigned to UI components");
return;
}
}
PHALCON_OBSERVE_VAR(t0);
phalcon_read_static_property(&t0, SL("phalcon\\tag"), SL("_displayValues") TSRMLS_CC);
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
}
phalcon_array_update_zval(&t0, id, &value, PH_COPY TSRMLS_CC);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_displayValues"), t0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Assigns default values to generated tags by helpers
*
* <code>
* //Assigning "peter" to "name" component
* Phalcon\Tag::setDefault("name", "peter");
*
* //Later in the view
* echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
* </code>
*
* @param string $id
* @param string $value
*/
PHP_METHOD(Phalcon_Tag, setDefault){
zval *id, *value;
zval *t0 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &id, &value);
if (Z_TYPE_P(value) != IS_NULL) {
if (PHALCON_IS_SCALAR(value)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "Only scalar values can be assigned to UI components");
return;
}
}
PHALCON_OBSERVE_VAR(t0);
phalcon_read_static_property(&t0, SL("phalcon\\tag"), SL("_displayValues") TSRMLS_CC);
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
}
phalcon_array_update_zval(&t0, id, &value, PH_COPY TSRMLS_CC);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_displayValues"), t0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
VALUE zval_to_hash(zval *zv) {
HashTable *ht;
HashPosition pos;
zval **data;
VALUE ret;
convert_to_array(zv);
ht = Z_ARRVAL_P(zv);
ret = rb_hash_new();
zend_hash_internal_pointer_reset_ex(ht, &pos);
while (zend_hash_get_current_data_ex(ht, (void **)&data, &pos) == SUCCESS) {
char* key_str;
uint key_len;
ulong num_index;
VALUE key = Qnil;
VALUE val = new_php_embed_value(*data);
switch(zend_hash_get_current_key_ex(ht, &key_str, &key_len, &num_index, 0, &pos)) {
case HASH_KEY_IS_STRING:
//key = rb_str_new(key_str, key_len);
key = rb_str_new_cstr(key_str);
break;
case HASH_KEY_IS_LONG:
key = LONG2NUM(num_index);
break;
}
rb_hash_aset(ret, key, val);
zend_hash_move_forward_ex(ht, &pos);
}
return ret;
}
/**
* Phalcon_Model_MetaData_Session constructor
*
* @param Phalcon_Config|stdClass $options
*/
PHP_METHOD(Phalcon_Model_MetaData_Session, __construct){
zval *options = NULL, *adapter_options = NULL;
zval *t0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(options);
if (Z_TYPE_P(options) == IS_ARRAY) {
PHALCON_SEPARATE_PARAM(options);
convert_to_array(options);
PHALCON_CPY_WRT(adapter_options, options);
} else {
PHALCON_CPY_WRT(adapter_options, options);
}
eval_int = phalcon_isset_property(adapter_options, "suffix", strlen("suffix") TSRMLS_CC);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, adapter_options, "suffix", sizeof("suffix")-1, PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_suffix", strlen("_suffix"), t0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
static inline void phalcon_config_adapter_ini_update_zval_directive(zval **arr, zval *section, zval *directive, zval **value, int flags TSRMLS_DC) {
zval *temp1 = NULL, *temp2 = NULL, *index = NULL;
int i, n;
n = zend_hash_num_elements(Z_ARRVAL_P(directive));
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp1, *arr, section, PH_SILENT);
if (Z_REFCOUNT_P(temp1) > 1) {
phalcon_array_update_zval(arr, section, &temp1, PH_COPY | PH_CTOR);
}
if (Z_TYPE_P(temp1) != IS_ARRAY) {
convert_to_array(temp1);
phalcon_array_update_zval(arr, section, &temp1, PH_COPY);
}
for (i = 0; i < n - 1; i++) {
phalcon_array_fetch_long(&index, directive, i, PH_NOISY);
phalcon_array_fetch(&temp2, temp1, index, PH_SILENT);
if (Z_REFCOUNT_P(temp2) > 1) {
phalcon_array_update_zval(&temp1, index, &temp2, PH_COPY | PH_CTOR);
}
if (Z_TYPE_P(temp2) != IS_ARRAY) {
convert_to_array(temp2);
phalcon_array_update_zval(&temp1, index, &temp2, PH_COPY);
}
zval_ptr_dtor(&index);
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
temp1 = temp2;
temp2 = NULL;
}
phalcon_array_fetch_long(&index, directive, n - 1, PH_NOISY);
phalcon_array_update_zval(&temp1, index, value, PH_COPY);
zval_ptr_dtor(&index);
if (temp1 != NULL) {
zval_ptr_dtor(&temp1);
}
}
}
/**
* Appends a zval value to an array property
*/
int zephir_update_property_array_append(zval *object, char *property, unsigned int property_length, zval *value)
{
zval tmp;
int separated = 0;
ZVAL_UNDEF(&tmp);
if (Z_TYPE_P(object) != IS_OBJECT) {
return SUCCESS;
}
zephir_read_property(&tmp, object, property, property_length, PH_NOISY_CC);
Z_TRY_DELREF(tmp);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp)) {
if (Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
/** Convert the value to array if not is an array */
if (Z_TYPE(tmp) != IS_ARRAY) {
if (separated) {
convert_to_array(&tmp);
} else {
array_init(&tmp);
separated = 1;
}
Z_DELREF(tmp);
}
Z_TRY_ADDREF_P(value);
add_next_index_zval(&tmp, value);
if (separated) {
zephir_update_property_zval(object, property, property_length, &tmp);
}
return SUCCESS;
}
/**
* Updates an array property
*/
int zephir_update_property_array(zval *object, const char *property, zend_uint property_length, const zval *index, zval *value)
{
zval tmp;
int separated = 0;
if (Z_TYPE_P(object) == IS_OBJECT) {
zephir_read_property(&tmp, object, property, property_length, PH_NOISY | PH_READONLY);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp)) {
if (Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
/** Convert the value to array if not is an array */
if (Z_TYPE(tmp) != IS_ARRAY) {
if (separated) {
convert_to_array(&tmp);
} else {
array_init(&tmp);
separated = 1;
}
Z_DELREF(tmp);
}
Z_TRY_ADDREF_P(value);
if (Z_TYPE_P(index) == IS_STRING) {
zend_symtable_str_update(Z_ARRVAL(tmp), Z_STRVAL_P(index), Z_STRLEN_P(index), value);
} else if (Z_TYPE_P(index) == IS_LONG) {
zend_hash_index_update(Z_ARRVAL(tmp), Z_LVAL_P(index), value);
} else if (Z_TYPE_P(index) == IS_NULL) {
zend_hash_next_index_insert(Z_ARRVAL(tmp), value);
}
if (separated) {
zephir_update_property_zval(object, property, property_length, &tmp);
}
}
return SUCCESS;
}
/*
* Multiple array-offset update
*/
int zephir_update_static_property_array_multi_ce(zend_class_entry *ce, const char *property, zend_uint property_length, zval *value, const char *types, int types_length, int types_count, ...)
{
va_list ap;
zval tmp_arr;
int separated = 0;
ZVAL_UNDEF(&tmp_arr);
zephir_read_static_property_ce(&tmp_arr, ce, property, property_length, PH_NOISY | PH_READONLY);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp_arr)) {
if (Z_REFCOUNT(tmp_arr) > 1) {
if (!Z_ISREF(tmp_arr)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp_arr);
ZVAL_COPY_VALUE(&tmp_arr, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp_arr);
ZVAL_COPY_VALUE(&tmp_arr, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
/** Convert the value to array if not is an array */
if (Z_TYPE(tmp_arr) != IS_ARRAY) {
if (separated) {
convert_to_array(&tmp_arr);
} else {
array_init(&tmp_arr);
separated = 1;
}
Z_DELREF(tmp_arr);
}
va_start(ap, types_count);
SEPARATE_ZVAL_IF_NOT_REF(&tmp_arr);
zephir_array_update_multi_ex(&tmp_arr, value, types, types_length, types_count, ap);
va_end(ap);
if (separated) {
zephir_update_static_property_ce(ce, property, property_length, &tmp_arr);
}
return SUCCESS;
}
/**
* $x[$a][] = 1
*/
void phalcon_array_update_append_multi_2(zval **arr, zval *index1, zval *value, int flags TSRMLS_DC){
zval *temp;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch(&temp, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp) > 1) {
phalcon_array_update_zval(arr, index1, &temp, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp) != IS_ARRAY) {
convert_to_array(temp);
phalcon_array_update_zval(arr, index1, &temp, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&temp, value, flags TSRMLS_CC);
zval_ptr_dtor(&temp);
}
}
VALUE zval_to_array(zval *zv) {
HashTable *ht;
HashPosition pos;
zval **data;
VALUE ret;
convert_to_array(zv);
ht = Z_ARRVAL_P(zv);
ret = rb_ary_new2(zend_hash_num_elements(ht));
zend_hash_internal_pointer_reset_ex(ht, &pos);
while (SUCCESS == zend_hash_get_current_data_ex(ht, (void **)&data, &pos)) {
rb_ary_push(ret, new_php_embed_value(*data));
zend_hash_move_forward_ex(ht, &pos);
}
return ret;
}
/**
* Updates multi-dimensional arrays with one long index and other string
*
* $foo[10]["lol"] = $x
*/
void phalcon_array_update_long_string_multi_2(zval **arr, long index1, char *index2, uint index2_length, zval **value, int flags TSRMLS_DC){
zval *temp;
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch_long(&temp, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp) > 1) {
phalcon_array_update_long(arr, index1, &temp, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp) != IS_ARRAY) {
convert_to_array(temp);
phalcon_array_update_long(arr, index1, &temp, PH_COPY TSRMLS_CC);
}
phalcon_array_update_string(&temp, index2, index2_length, value, flags | PH_COPY TSRMLS_CC);
zval_ptr_dtor(&temp);
}
}
void c_array_to_php_array(void *c_array,int num,zval *php_array,int type)
{
zval *val;
HashTable *ht;
int i;
convert_to_array(php_array);
ht = Z_ARRVAL_P(php_array);
for(i = 0;i < num;i++)
{
MAKE_STD_ZVAL(val);
switch(type)
{
case C_INT_TO_PHP_LONG:
ZVAL_LONG(val,(int)((int*)c_array)[i]);
break;
case C_UINT_TO_PHP_LONG:
ZVAL_LONG(val,(unsigned int)((unsigned int*)c_array)[i]);
break;
case C_LONG_TO_PHP_LONG:
ZVAL_LONG(val,((long*)c_array)[i]);
break;
case C_FLOAT_TO_PHP_DOUBLE:
ZVAL_DOUBLE(val,(float)((float*)c_array)[i]);
break;
case C_DOUBLE_TO_PHP_DOUBLE:
ZVAL_DOUBLE(val,(double)((double*)c_array)[i]);
break;
case C_BOOLEAN_TO_PHP_BOOLEAN:
ZVAL_BOOL(val,(unsigned char)((unsigned char*)c_array)[i]);
break;
case C_CHAR_TO_PHP_LONG:
ZVAL_LONG(val,(char)((char*)c_array)[i]);
break;
case C_USHORT_TO_PHP_LONG:
ZVAL_LONG(val,(unsigned short)((unsigned short*)c_array)[i]);
break;
}
zend_hash_next_index_insert(ht,&val,sizeof(zval*),NULL);
}
}
/**
* Updates multi-dimensional arrays with two long indices
*
* $foo[10][4] = $x
*/
void phalcon_array_update_long_long_multi_2(zval **arr, long index1, long index2, zval **value, int flags TSRMLS_DC){
zval *temp;
ALLOC_INIT_ZVAL(temp);
if (Z_TYPE_PP(arr) == IS_ARRAY) {
phalcon_array_fetch_long(&temp, *arr, index1, PH_SILENT_CC);
if (Z_REFCOUNT_P(temp) > 1) {
phalcon_array_update_long(arr, index1, &temp, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(temp) != IS_ARRAY) {
convert_to_array(temp);
phalcon_array_update_long(arr, index1, &temp, PH_COPY TSRMLS_CC);
}
phalcon_array_update_long(&temp, index2, value, flags | PH_COPY TSRMLS_CC);
}
zval_ptr_dtor(&temp);
}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences){
zval *table = NULL, *schema = NULL, *dialect = NULL, *sql = NULL, *empty_arr = NULL, *references = NULL;
zval *fetch_assoc = NULL, *describe = NULL, *reference = NULL, *constraint_name = NULL, *constraint_id = NULL;
zval *referenced_schema = NULL, *referenced_table = NULL;
zval *reference_array = NULL, *column_name = NULL, *referenced_columns = NULL;
zval *reference_objects = NULL, *array_reference = NULL;
zval *name = NULL, *columns = NULL, *definition = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(empty_arr);
array_init(empty_arr);
PHALCON_INIT_VAR(references);
array_init(references);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(reference);
PHALCON_INIT_VAR(constraint_id);
PHALCON_INIT_VAR(constraint_name);
phalcon_array_fetch_string(&constraint_id, reference, SL("id"), PH_NOISY_CC);
PHALCON_CONCAT_SV(constraint_name, "foreign_key_", constraint_id);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(referenced_schema);
ZVAL_STRING(referenced_schema, "main", 1);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, reference, SL("table"), PH_NOISY_CC);
PHALCON_INIT_VAR(reference_array);
array_init(reference_array);
phalcon_array_update_string(&reference_array, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("columns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedColumns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&references, constraint_name, &reference_array, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, reference, SL("from"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t0);
phalcon_array_fetch(&t0, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t0) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t0, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
phalcon_array_update_zval(&references, constraint_name, &t0, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t0) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch_string(&t1, t0, SL("columns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update_string(&t0, SL("columns"), &t1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update_string(&t0, SL("columns"), &t1, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t1, column_name, 0 TSRMLS_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, reference, SL("to"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch(&t2, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_zval(&references, constraint_name, &t2, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t2) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch_string(&t3, t2, SL("referencedColumns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update_string(&t2, SL("referencedColumns"), &t3, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update_string(&t2, SL("referencedColumns"), &t3, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t3, referenced_columns, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(reference_objects);
array_init(reference_objects);
if (!phalcon_valid_foreach(references TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto ph_cycle_end_1;
}
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(array_reference);
PHALCON_INIT_VAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC);
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC);
PHALCON_INIT_VAR(definition);
array_init(definition);
phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference);
object_init_ex(reference, phalcon_db_reference_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition, PH_CHECK);
phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
RETURN_CTOR(reference_objects);}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon_Db_Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, describeReferences){
zval *table = NULL, *schema = NULL, *sql = NULL, *references = NULL, *describe = NULL;
zval *reference = NULL, *constraint_name = NULL, *reference_objects = NULL;
zval *array_reference = NULL, *name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL;
zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *i0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_INIT_VAR(schema);
ZVAL_NULL(schema);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db_dialect_mysql", "describereferences", table, schema);
PHALCON_CPY_WRT(sql, r0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(references, a0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(describe, r1);
if (phalcon_valid_foreach(describe TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_4:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_4;
}
PHALCON_INIT_VAR(reference);
ZVAL_ZVAL(reference, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
phalcon_array_fetch_string(&r2, reference, SL("CONSTRAINT_NAME"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(constraint_name, r2);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_INIT_VAR(r3);
phalcon_array_fetch_string(&r3, reference, SL("REFERENCED_TABLE_SCHEMA"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a1, SL("referencedSchema"), &r3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r4);
phalcon_array_fetch_string(&r4, reference, SL("REFERENCED_TABLE_NAME"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a1, SL("referencedTable"), &r4, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(a2);
array_init(a2);
phalcon_array_update_string(&a1, SL("columns"), &a2, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(a3);
array_init(a3);
phalcon_array_update_string(&a1, SL("referencedColumns"), &a3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update(&references, constraint_name, &a1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_string(&r5, reference, SL("COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch(&t1, references, constraint_name, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch_string(&t2, t1, SL("columns"), PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&t2, r5, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_array_fetch_string(&r6, reference, SL("REFERENCED_COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch(&t3, references, constraint_name, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) == IS_ARRAY) {
PHALCON_INIT_VAR(t4);
phalcon_array_fetch_string(&t4, t3, SL("referencedColumns"), PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t4) > 1) {
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t4) != IS_ARRAY) {
convert_to_array(t4);
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&t4, r6, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_4;
fee_321f_4:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(a4);
array_init(a4);
PHALCON_CPY_WRT(reference_objects, a4);
if (phalcon_valid_foreach(references TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_321f_5:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_321f_5;
} else {
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
}
PHALCON_INIT_VAR(array_reference);
ZVAL_ZVAL(array_reference, *hd, 1, 0);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_db_reference_ce);
PHALCON_INIT_VAR(a5);
array_init(a5);
PHALCON_INIT_VAR(r7);
phalcon_array_fetch_string(&r7, array_reference, SL("referencedSchema"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedSchema"), &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r8);
phalcon_array_fetch_string(&r8, array_reference, SL("referencedTable"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedTable"), &r8, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch_string(&r9, array_reference, SL("columns"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("columns"), &r9, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r10);
phalcon_array_fetch_string(&r10, array_reference, SL("referencedColumns"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedColumns"), &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", name, a5, PHALCON_CHECK);
phalcon_array_update(&reference_objects, name, &i0, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_321f_5;
fee_321f_5:
if(0){}
} else {
return;
}
RETURN_CTOR(reference_objects);
}
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport, zval** value, HashTable* fieldspec) {
// At this point the typeID (and field num, if applicable) should've already been written to the output so all we need to do is write the payload.
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return;
case T_STRUCT: {
TSRMLS_FETCH();
if (Z_TYPE_PP(value) != IS_OBJECT) {
throw_tprotocolexception("Attempt to send non-object type as a T_STRUCT", INVALID_DATA);
}
zval* spec = zend_read_static_property(zend_get_class_entry(*value TSRMLS_CC), "_TSPEC", 6, false TSRMLS_CC);
binary_serialize_spec(*value, transport, Z_ARRVAL_P(spec));
}
return;
case T_BOOL:
if (Z_TYPE_PP(value) != IS_BOOL) convert_to_boolean(*value);
transport.writeI8(Z_BVAL_PP(value) ? 1 : 0);
return;
case T_BYTE:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI8(Z_LVAL_PP(value));
return;
case T_I16:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI16(Z_LVAL_PP(value));
return;
case T_I32:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI32(Z_LVAL_PP(value));
return;
case T_I64:
case T_U64:
if (Z_TYPE_PP(value) != IS_LONG) convert_to_long(*value);
transport.writeI64(Z_LVAL_PP(value));
return;
case T_DOUBLE: {
union {
int64_t c;
double d;
} a;
if (Z_TYPE_PP(value) != IS_DOUBLE) convert_to_double(*value);
a.d = Z_DVAL_PP(value);
transport.writeI64(a.c);
}
return;
//case T_UTF7:
case T_UTF8:
case T_UTF16:
case T_STRING:
if (Z_TYPE_PP(value) != IS_STRING) convert_to_string(*value);
transport.writeString(Z_STRVAL_PP(value), Z_STRLEN_PP(value));
return;
case T_MAP: {
if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value);
if (Z_TYPE_PP(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_MAP)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_PP(value);
zval** val_ptr;
zend_hash_find(fieldspec, "ktype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t keytype = Z_LVAL_PP(val_ptr);
transport.writeI8(keytype);
zend_hash_find(fieldspec, "vtype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t valtype = Z_LVAL_PP(val_ptr);
transport.writeI8(valtype);
zend_hash_find(fieldspec, "val", 4, (void**)&val_ptr);
HashTable* valspec = Z_ARRVAL_PP(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
binary_serialize(valtype, transport, val_ptr, valspec);
}
}
return;
case T_LIST: {
if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value);
if (Z_TYPE_PP(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_LIST)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_PP(value);
zval** val_ptr;
zend_hash_find(fieldspec, "etype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t valtype = Z_LVAL_PP(val_ptr);
transport.writeI8(valtype);
zend_hash_find(fieldspec, "elem", 5, (void**)&val_ptr);
HashTable* valspec = Z_ARRVAL_PP(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize(valtype, transport, val_ptr, valspec);
}
}
return;
case T_SET: {
if (Z_TYPE_PP(value) != IS_ARRAY) convert_to_array(*value);
if (Z_TYPE_PP(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_SET)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_PP(value);
zval** val_ptr;
zend_hash_find(fieldspec, "etype", 6, (void**)&val_ptr);
if (Z_TYPE_PP(val_ptr) != IS_LONG) convert_to_long(*val_ptr);
uint8_t keytype = Z_LVAL_PP(val_ptr);
transport.writeI8(keytype);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr); zend_hash_get_current_data_ex(ht, (void**)&val_ptr, &key_ptr) == SUCCESS; zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
}
}
return;
};
char errbuf[128];
sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(errbuf, INVALID_DATA);
}
/**
* Phalcon_Config_Adapter_Ini constructor
*
* @param string $filePath
* @return Phalcon_Config_Adapter_Ini
*
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct){
zval *file_path = NULL, *config = NULL, *ini_config = NULL, *directives = NULL;
zval *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL;
zval *a0 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *i0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL;
zval *t0 = NULL, *t1 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &file_path) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(config, a0);
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 1);
PHALCON_INIT_VAR(ini_config);
PHALCON_CALL_FUNC_PARAMS_2(ini_config, "parse_ini_file", file_path, c0);
if (Z_TYPE_P(ini_config) == IS_BOOL && !Z_BVAL_P(ini_config)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_config_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "basename", file_path);
PHALCON_CONCAT_SVS(r0, "Configuration file ", r1, " can't be loaded");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r0, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
if (phalcon_valid_foreach(ini_config TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(ini_config);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_b840_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_b840_0;
} else {
PHALCON_INIT_VAR(section);
PHALCON_GET_FOREACH_KEY(section, ah0, hp0);
}
PHALCON_INIT_VAR(directives);
ZVAL_ZVAL(directives, *hd, 1, 0);
if (phalcon_valid_foreach(directives TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(directives);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_b840_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_b840_1;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah1, hp1);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, ".", 1);
PHALCON_INIT_VAR(r2);
phalcon_fast_strpos(r2, key, c1 TSRMLS_CC);
if (Z_TYPE_P(r2) != IS_BOOL || (Z_TYPE_P(r2) == IS_BOOL && Z_BVAL_P(r2))) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, ".", 1);
PHALCON_INIT_VAR(r3);
phalcon_fast_explode(r3, c2, key TSRMLS_CC);
PHALCON_CPY_WRT(directive_parts, r3);
if (Z_TYPE_P(config) == IS_ARRAY) {
PHALCON_INIT_VAR(t0);
phalcon_array_fetch(&t0, config, section, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t0) > 1) {
phalcon_array_update(&config, section, &t0, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t0) != IS_ARRAY) {
convert_to_array(t0);
phalcon_array_update(&config, section, &t0, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r4);
phalcon_array_fetch_long(&r4, directive_parts, 0, PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(t0) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch(&t1, t0, r4, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update(&t0, r4, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update(&t0, r4, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_long(&r5, directive_parts, 1, PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t1, r5, &value, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
phalcon_array_update_multi_2(&config, section, key, &value, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_b840_1;
fee_b840_1:
if(0){}
} else {
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_b840_0;
fee_b840_0:
if(0){}
} else {
return;
}
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon_Config_Adapter_Ini", "__construct", config);
PHALCON_MM_RESTORE();
}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeReferences){
zval *table = NULL, *schema = NULL, *dialect = NULL, *sql = NULL, *references = NULL;
zval *describe = NULL, *reference = NULL, *constraint_name = NULL;
zval *referenced_schema = NULL, *referenced_table = NULL;
zval *column_name = NULL, *referenced_columns = NULL, *reference_objects = NULL;
zval *array_reference = NULL, *name = NULL, *columns = NULL, *definition = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *a0 = NULL, *a1 = NULL, *a2 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(references);
array_init(references);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_get_class_constant(t0, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, t0, PH_NO_CHECK);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ecef_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ecef_3;
}
PHALCON_INIT_VAR(reference);
ZVAL_ZVAL(reference, *hd, 1, 0);
PHALCON_INIT_VAR(constraint_name);
phalcon_array_fetch_string(&constraint_name, reference, SL("constraint_name"), PH_NOISY_CC);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, reference, SL("referenced_table_schema"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, reference, SL("referenced_table_name"), PH_NOISY_CC);
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_update_string(&a0, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&a0, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(a1);
array_init(a1);
phalcon_array_update_string(&a0, SL("columns"), &a1, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(a2);
array_init(a2);
phalcon_array_update_string(&a0, SL("referencedColumns"), &a2, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&references, constraint_name, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, reference, SL("column_name"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch(&t1, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t1, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update_zval(&references, constraint_name, &t1, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t1) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch_string(&t2, t1, SL("columns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_string(&t1, SL("columns"), &t2, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_string(&t1, SL("columns"), &t2, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t2, column_name, 0 TSRMLS_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, reference, SL("referenced_column_name"), PH_NOISY_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch(&t3, references, constraint_name, PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update_zval(&references, constraint_name, &t3, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update_zval(&references, constraint_name, &t3, PH_COPY TSRMLS_CC);
}
if (Z_TYPE_P(t3) == IS_ARRAY) {
PHALCON_INIT_VAR(t4);
phalcon_array_fetch_string(&t4, t3, SL("referencedColumns"), PH_SILENT_CC);
}
if (Z_REFCOUNT_P(t4) > 1) {
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PH_COPY | PH_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t4) != IS_ARRAY) {
convert_to_array(t4);
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PH_COPY TSRMLS_CC);
}
phalcon_array_append(&t4, referenced_columns, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecef_3;
fee_ecef_3:
PHALCON_INIT_VAR(reference_objects);
array_init(reference_objects);
if (!phalcon_valid_foreach(references TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_ecef_4:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_ecef_4;
}
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_INIT_VAR(array_reference);
ZVAL_ZVAL(array_reference, *hd, 1, 0);
PHALCON_INIT_VAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC);
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC);
PHALCON_INIT_VAR(definition);
array_init(definition);
phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference);
object_init_ex(reference, phalcon_db_reference_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition, PH_CHECK);
phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_ecef_4;
fee_ecef_4:
RETURN_CTOR(reference_objects);
}
static
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport, zval* value, HashTable* fieldspec) {
// At this point the typeID (and field num, if applicable) should've already been written to the output so all we need to do is write the payload.
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return;
case T_STRUCT: {
if (Z_TYPE_P(value) != IS_OBJECT) {
throw_tprotocolexception("Attempt to send non-object type as a T_STRUCT", INVALID_DATA);
}
zval* spec = zend_read_static_property(Z_OBJCE_P(value), "_TSPEC", sizeof("_TSPEC")-1, false);
if (Z_TYPE_P(spec) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send non-Thrift object as a T_STRUCT", INVALID_DATA);
}
binary_serialize_spec(value, transport, Z_ARRVAL_P(spec));
} return;
case T_BOOL:
if (!zval_is_bool(value)) convert_to_boolean(value);
transport.writeI8(Z_TYPE_INFO_P(value) == IS_TRUE ? 1 : 0);
return;
case T_BYTE:
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
transport.writeI8(Z_LVAL_P(value));
return;
case T_I16:
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
transport.writeI16(Z_LVAL_P(value));
return;
case T_I32:
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
transport.writeI32(Z_LVAL_P(value));
return;
case T_I64:
case T_U64: {
int64_t l_data;
#if defined(_LP64) || defined(_WIN64)
if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value);
l_data = Z_LVAL_P(value);
#else
if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value);
l_data = (int64_t)Z_DVAL_P(value);
#endif
transport.writeI64(l_data);
} return;
case T_DOUBLE: {
union {
int64_t c;
double d;
} a;
if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value);
a.d = Z_DVAL_P(value);
transport.writeI64(a.c);
} return;
case T_UTF8:
case T_UTF16:
case T_STRING:
if (Z_TYPE_P(value) != IS_STRING) convert_to_string(value);
transport.writeString(Z_STRVAL_P(value), Z_STRLEN_P(value));
return;
case T_MAP: {
if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value);
if (Z_TYPE_P(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_MAP)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_P(value);
zval* val_ptr;
val_ptr = zend_hash_str_find(fieldspec, "ktype", sizeof("ktype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t keytype = Z_LVAL_P(val_ptr);
transport.writeI8(keytype);
val_ptr = zend_hash_str_find(fieldspec, "vtype", sizeof("vtype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t valtype = Z_LVAL_P(val_ptr);
transport.writeI8(valtype);
val_ptr = zend_hash_str_find(fieldspec, "val", sizeof("val")-1);
HashTable* valspec = Z_ARRVAL_P(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr);
(val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr;
zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
binary_serialize(valtype, transport, val_ptr, valspec);
}
} return;
case T_LIST: {
if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value);
if (Z_TYPE_P(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_LIST)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_P(value);
zval* val_ptr;
val_ptr = zend_hash_str_find(fieldspec, "etype", sizeof("etype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t valtype = Z_LVAL_P(val_ptr);
transport.writeI8(valtype);
val_ptr = zend_hash_str_find(fieldspec, "elem", sizeof("elem")-1);
HashTable* valspec = Z_ARRVAL_P(val_ptr);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr);
(val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr;
zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize(valtype, transport, val_ptr, valspec);
}
} return;
case T_SET: {
if (Z_TYPE_P(value) != IS_ARRAY) convert_to_array(value);
if (Z_TYPE_P(value) != IS_ARRAY) {
throw_tprotocolexception("Attempt to send an incompatible type as an array (T_SET)", INVALID_DATA);
}
HashTable* ht = Z_ARRVAL_P(value);
zval* val_ptr;
val_ptr = zend_hash_str_find(fieldspec, "etype", sizeof("etype")-1);
if (Z_TYPE_P(val_ptr) != IS_LONG) convert_to_long(val_ptr);
uint8_t keytype = Z_LVAL_P(val_ptr);
transport.writeI8(keytype);
transport.writeI32(zend_hash_num_elements(ht));
HashPosition key_ptr;
for (zend_hash_internal_pointer_reset_ex(ht, &key_ptr);
(val_ptr = zend_hash_get_current_data_ex(ht, &key_ptr)) != nullptr;
zend_hash_move_forward_ex(ht, &key_ptr)) {
binary_serialize_hashtable_key(keytype, transport, ht, key_ptr);
}
} return;
};
char errbuf[128];
snprintf(errbuf, 128, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(errbuf, INVALID_DATA);
}
