/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize){ zval *records, *cache, *column_types, *hydrate_mode; zval *data, *serialized; PHALCON_MM_GROW(); /** * Obtain the records as an array */ PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD(records, this_ptr, "toarray"); PHALCON_OBS_VAR(cache); phalcon_read_property_this(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_OBS_VAR(column_types); phalcon_read_property_this(&column_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC); PHALCON_OBS_VAR(hydrate_mode); phalcon_read_property_this(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init_size(data, 4); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("columnTypes"), &column_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("hydrateMode"), &hydrate_mode, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(serialized); PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data); RETURN_CCTOR(serialized); }
/** * Returns an HTML string of information about a single variable. * * <code> * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo"); * </code> */ PHP_METHOD(Phalcon_Debug_Dump, variable){ zval *variable, *name = NULL, *str, *type, *style = NULL, *output = NULL, *replace_pairs; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &variable, &name); if (!name) { name = PHALCON_GLOBAL(z_null); } PHALCON_INIT_VAR(str); ZVAL_STRING(str, "<pre style=':style'>:output</pre>", 1); PHALCON_INIT_VAR(type); ZVAL_STRING(type, "pre", 1); PHALCON_CALL_SELF(&style, "getstyle", type); PHALCON_CALL_SELF(&output, "output", variable, name); PHALCON_INIT_VAR(replace_pairs); array_init(replace_pairs); phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY); phalcon_array_update_string(&replace_pairs, SL(":output"), output, PH_COPY); phalcon_strtr_array(return_value, str, replace_pairs TSRMLS_CC); RETURN_MM(); }
PHP_METHOD(Phalcon_Mvc_Router, __construct){ zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); zend_update_property(phalcon_mvc_router_ce, this_ptr, SL("_params"), a0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(a1); array_init(a1); PHALCON_ALLOC_ZVAL_MM(a2); array_init(a2); add_assoc_stringl_ex(a2, SL("pattern")+1, SL("#^/([a-zA-Z0-9\\_]+)[/]{0,1}$#"), 1); PHALCON_ALLOC_ZVAL_MM(a3); array_init(a3); add_assoc_long_ex(a3, SL("controller")+1, 1); phalcon_array_update_string(&a2, SL("paths"), &a3, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_append(&a1, a2, PH_SEPARATE TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(a4); array_init(a4); add_assoc_stringl_ex(a4, SL("pattern")+1, SL("#^/([a-zA-Z0-9\\_]+)/([a-zA-Z0-9\\_]+)(/.*)*$#"), 1); PHALCON_ALLOC_ZVAL_MM(a5); array_init(a5); add_assoc_long_ex(a5, SL("controller")+1, 1); add_assoc_long_ex(a5, SL("action")+1, 2); add_assoc_long_ex(a5, SL("params")+1, 3); phalcon_array_update_string(&a4, SL("paths"), &a5, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_append(&a1, a4, PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_routes"), a1 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * $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); } }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize){ zval *records = NULL, *cache, *column_types, *hydrate_mode; zval *data, *serialized; PHALCON_MM_GROW(); /** * Obtain the records as an array */ PHALCON_CALL_METHOD(&records, this_ptr, "toarray"); cache = phalcon_fetch_nproperty_this(this_ptr, SL("_cache"), PH_NOISY TSRMLS_CC); column_types = phalcon_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY TSRMLS_CC); hydrate_mode = phalcon_fetch_nproperty_this(this_ptr, SL("_hydrateMode"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(data); array_init_size(data, 4); phalcon_array_update_string(&data, SL("cache"), cache, PH_COPY); phalcon_array_update_string(&data, SL("rows"), records, PH_COPY); phalcon_array_update_string(&data, SL("columnTypes"), column_types, PH_COPY); phalcon_array_update_string(&data, SL("hydrateMode"), hydrate_mode, PH_COPY); PHALCON_INIT_VAR(serialized); phalcon_serialize(serialized, &data TSRMLS_CC); /** * Avoid return bad serialized data */ if (Z_TYPE_P(serialized) != IS_STRING) { RETURN_MM_NULL(); } RETURN_CTOR(serialized); }
/** * Adds the limit parameter to the criteria * * @param int $limit * @param int $offset * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, limit){ zval *limit, *offset = NULL, *limit_clause; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &limit, &offset); if (!offset) { PHALCON_INIT_VAR(offset); } if (!phalcon_is_numeric(limit)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Rows limit parameter must be integer"); return; } if (Z_TYPE_P(offset) == IS_NULL) { phalcon_update_property_array_string(this_ptr, SL("_params"), SS("limit"), limit TSRMLS_CC); } else { PHALCON_INIT_VAR(limit_clause); array_init_size(limit_clause, 2); phalcon_array_update_string(&limit_clause, SL("number"), &limit, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&limit_clause, SL("offset"), &offset, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_array_string(this_ptr, SL("_params"), SS("limit"), limit_clause TSRMLS_CC); } RETURN_THIS(); }
/** * Applies a format to a message before sent it to the internal log * * @param string $message * @param int $type * @param int $timestamp * @param array $context * @return string */ PHP_METHOD(Phalcon_Logger_Formatter_Json, format){ zval *message, *type, *timestamp, *context, *interpolated = NULL, *type_str = NULL, *log, *json; PHALCON_MM_GROW(); phalcon_fetch_params(1, 4, 0, &message, &type, ×tamp, &context); if (Z_TYPE_P(context) == IS_ARRAY) { PHALCON_CALL_METHOD(&interpolated, this_ptr, "interpolate", message, context); } else { interpolated = message; } PHALCON_CALL_METHOD(&type_str, this_ptr, "gettypestring", type); PHALCON_INIT_VAR(log); array_init_size(log, 3); phalcon_array_update_string(&log, SL("type"), type_str, PH_COPY); phalcon_array_update_string(&log, SL("message"), interpolated, PH_COPY); phalcon_array_update_string(&log, SL("timestamp"), timestamp, PH_COPY); PHALCON_INIT_VAR(json); RETURN_MM_ON_FAILURE(phalcon_json_encode(json, log, 0 TSRMLS_CC)); PHALCON_CONCAT_VS(return_value, json, PHP_EOL); RETURN_MM(); }
/** * Restore a Phalcon\Db\Reference object from export * * @param array $data * @return Phalcon\Db\Reference */ PHP_METHOD(Phalcon_Db_Reference, __set_state){ zval *data, *constraint_name, *referenced_schema = NULL; zval *referenced_table = NULL, *columns = NULL, *referenced_columns = NULL; zval *definition; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &data); if (!phalcon_array_isset_string(data, SS("_referenceName"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "_referenceName parameter is required"); return; } else { PHALCON_OBS_VAR(constraint_name); phalcon_array_fetch_string(&constraint_name, data, SL("_referenceName"), PH_NOISY); } if (phalcon_array_isset_string(data, SS("_referencedSchema"))) { PHALCON_OBS_VAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, data, SL("_referencedSchema"), PH_NOISY); } else { PHALCON_INIT_NVAR(referenced_schema); } if (phalcon_array_isset_string(data, SS("_referencedTable"))) { PHALCON_OBS_VAR(referenced_table); phalcon_array_fetch_string(&referenced_table, data, SL("_referencedTable"), PH_NOISY); } else { PHALCON_INIT_NVAR(referenced_table); } if (phalcon_array_isset_string(data, SS("_columns"))) { PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, data, SL("_columns"), PH_NOISY); } else { PHALCON_INIT_NVAR(columns); } if (phalcon_array_isset_string(data, SS("_referencedColumns"))) { PHALCON_OBS_VAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, data, SL("_referencedColumns"), PH_NOISY); } else { PHALCON_INIT_NVAR(referenced_columns); } PHALCON_INIT_VAR(definition); array_init_size(definition, 4); phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE); object_init_ex(return_value, phalcon_db_reference_ce); phalcon_call_method_p2_noret(return_value, "__construct", constraint_name, definition); RETURN_MM(); }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, serialize){ zval *type = NULL, *result = NULL, *records = NULL, *row_count = NULL, *model = NULL; zval *cache = NULL, *data = NULL, *serialized = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(type); phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_CALL_METHOD_NORETURN(result, "execute", PH_NO_CHECK); PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD(records, result, "fetchall", PH_NO_CHECK); } else { PHALCON_INIT_VAR(records); array_init(records); } } else { PHALCON_INIT_VAR(records); phalcon_read_property(&records, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(records) == IS_NULL) { PHALCON_INIT_VAR(result); phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD(records, result, "fetchall", PH_NO_CHECK); PHALCON_INIT_VAR(row_count); phalcon_fast_count(row_count, records TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_rows"), row_count TSRMLS_CC); } } } PHALCON_INIT_VAR(model); phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC); PHALCON_INIT_VAR(cache); phalcon_read_property(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init(data); phalcon_array_update_string(&data, SL("model"), &model, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(serialized); PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data); RETURN_CCTOR(serialized); }
/** * Phalcon\Acl\Adapter\Memory constructor */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, __construct){ zval *a0 = NULL, *a1 = NULL, *a2 = NULL; PHALCON_MM_GROW(); phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_rolesNames") TSRMLS_CC); phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_roles") TSRMLS_CC); phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_resources") TSRMLS_CC); phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_access") TSRMLS_CC); phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_roleInherits") TSRMLS_CC); PHALCON_INIT_VAR(a0); array_init_size(a0, 1); add_assoc_bool_ex(a0, SS("*"), 1); zend_update_property(phalcon_acl_adapter_memory_ce, this_ptr, SL("_resourcesNames"), a0 TSRMLS_CC); PHALCON_INIT_VAR(a1); array_init_size(a1, 1); PHALCON_INIT_VAR(a2); array_init_size(a2, 1); add_assoc_bool_ex(a2, SS("*"), 1); phalcon_array_update_string(&a1, SL("*"), &a2, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_update_property(phalcon_acl_adapter_memory_ce, this_ptr, SL("_accessList"), a1 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * $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); }
/** * Adds the limit parameter to the criteria * * @param string $orderColumns * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, limit){ zval *limit = NULL; zval *r0 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &limit) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "is_numeric", limit); if (!zend_is_true(r0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Rows limit parameter must be integer"); return; } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_params"), PH_NOISY_CC); phalcon_array_update_string(&t0, SL("limit"), &limit, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_params"), t0 TSRMLS_CC); RETURN_CCTOR(this_ptr); }
/** * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor. * Call it when you need to restore a database connection. * * @param array $descriptor * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, connect){ zval *descriptor = NULL, *dbname; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) { RETURN_MM_NULL(); } if (!descriptor) { PHALCON_INIT_VAR(descriptor); } else { PHALCON_SEPARATE_PARAM(descriptor); } if (!zend_is_true(descriptor)) { PHALCON_OBS_NVAR(descriptor); phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC); } if (!phalcon_array_isset_string(descriptor, SS("dbname"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "dbname must be specified"); return; } else { PHALCON_OBS_VAR(dbname); phalcon_array_fetch_string(&dbname, descriptor, SL("dbname"), PH_NOISY_CC); phalcon_array_update_string(&descriptor, SL("dsn"), &dbname, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Db\\Adapter\\Pdo\\Sqlite", "connect", descriptor); PHALCON_MM_RESTORE(); }
/** * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor. * Call it when you need to restore a database connection. * * Support set search_path after connectted if schema is specified in config. * * @param array $descriptor * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect){ zval *descriptor = NULL, *schema = NULL, *sql, *password; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &descriptor); if (!descriptor) { PHALCON_INIT_VAR(descriptor); } else { PHALCON_SEPARATE_PARAM(descriptor); } if (!zend_is_true(descriptor)) { PHALCON_OBS_NVAR(descriptor); phalcon_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC); } if (phalcon_array_isset_string(descriptor, SS("schema"))) { PHALCON_OBS_VAR(schema); phalcon_array_fetch_string(&schema, descriptor, SL("schema"), PH_NOISY); phalcon_array_unset_string(&descriptor, SS("schema"), PH_COPY); phalcon_update_property_this(this_ptr, SL("_schema"), schema TSRMLS_CC); } else { PHALCON_INIT_VAR(schema); } if (phalcon_array_isset_string_fetch(&password, descriptor, SS("password"))) { /* There is a bug in pdo_pgsql driver when the password is empty, * the driver tries to access invalid memory: * * if (dbh->password[0] != '\'' && dbh->password[strlen(dbh->password) - 1] != '\'') * * To avoid this we set the password to null */ if (Z_TYPE_P(password) == IS_STRING && Z_STRLEN_P(password) == 0) { phalcon_array_update_string(&descriptor, SL("password"), PHALCON_GLOBAL(z_null), PH_COPY); } } PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_postgresql_ce, this_ptr, "connect", descriptor); /** * Execute the search path in the after connect */ if (Z_TYPE_P(schema) == IS_STRING) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SET search_path TO '", schema, "'"); PHALCON_CALL_METHOD(NULL, this_ptr, "execute", sql); } PHALCON_MM_RESTORE(); }
int phalcon_array_update_string_long(zval **arr, char *index, uint index_length, long value, int flags TSRMLS_DC){ zval *zvalue; ALLOC_INIT_ZVAL(zvalue); ZVAL_LONG(zvalue, value); return phalcon_array_update_string(arr, index, index_length, &zvalue, flags TSRMLS_CC); }
/** * Phalcon\Acl\Adapter\Memory constructor * */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, __construct){ zval *resources_names, *access_list; PHALCON_MM_GROW(); PHALCON_INIT_VAR(resources_names); array_init_size(resources_names, 1); phalcon_array_update_string(&resources_names, SL("*"), PHALCON_GLOBAL(z_true), PH_COPY); phalcon_update_property_this(this_ptr, SL("_resourcesNames"), resources_names TSRMLS_CC); PHALCON_INIT_VAR(access_list); array_init_size(access_list, 1); phalcon_array_update_string(&access_list, SL("*!*"), PHALCON_GLOBAL(z_true), PH_COPY); phalcon_update_property_this(this_ptr, SL("_accessList"), access_list TSRMLS_CC); PHALCON_MM_RESTORE(); }
int phalcon_array_update_string_string(zval **arr, char *index, uint index_length, char *value, uint value_length, int flags TSRMLS_DC){ zval *zvalue; ALLOC_INIT_ZVAL(zvalue); ZVAL_STRINGL(zvalue, value, value_length, 1); return phalcon_array_update_string(arr, index, index_length, &zvalue, flags TSRMLS_CC); }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, serialize){ zval *records, *model, *cache, *column_map, *hydrate_mode; zval *data, *serialized; PHALCON_MM_GROW(); PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD(records, this_ptr, "toarray"); PHALCON_OBS_VAR(model); phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC); PHALCON_OBS_VAR(cache); phalcon_read_property(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_OBS_VAR(column_map); phalcon_read_property(&column_map, this_ptr, SL("_columnMap"), PH_NOISY_CC); PHALCON_OBS_VAR(hydrate_mode); phalcon_read_property(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init_size(data, 5); phalcon_array_update_string(&data, SL("model"), &model, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("columnMap"), &column_map, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("hydrateMode"), &hydrate_mode, PH_COPY | PH_SEPARATE TSRMLS_CC); /** * Force to re-execute the query */ phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); /** * Serialize the cache using the serialize function */ PHALCON_INIT_VAR(serialized); PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data); RETURN_CCTOR(serialized); }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize){ zval *records, *cache, *column_types, *hydrate_mode; zval *data, *serialized; PHALCON_MM_GROW(); /** * Obtain the records as an array */ PHALCON_INIT_VAR(records); phalcon_call_method(records, this_ptr, "toarray"); PHALCON_OBS_VAR(cache); phalcon_read_property_this(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_OBS_VAR(column_types); phalcon_read_property_this(&column_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC); PHALCON_OBS_VAR(hydrate_mode); phalcon_read_property_this(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init_size(data, 4); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&data, SL("columnTypes"), &column_types, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&data, SL("hydrateMode"), &hydrate_mode, PH_COPY | PH_SEPARATE); PHALCON_INIT_VAR(serialized); phalcon_serialize(serialized, &data TSRMLS_CC); /** * Avoid return bad serialized data */ if (Z_TYPE_P(serialized) != IS_STRING) { RETURN_MM_NULL(); } RETURN_CTOR(serialized); }
/** * Changes a parameter in the definition without resolve the service * * @param long $position * @param array $parameter * @return Phalcon\DI\Service */ PHP_METHOD(Phalcon_DI_Service, setParameter){ zval *position, *parameter, *definition, *arguments = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &position, ¶meter) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(definition); phalcon_read_property(&definition, this_ptr, SL("_definition"), PH_NOISY_CC); if (Z_TYPE_P(definition) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "Definition must be an array to update its parameters"); return; } if (Z_TYPE_P(position) != IS_LONG) { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "Position must be integer"); return; } if (Z_TYPE_P(parameter) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "The parameter must be an array"); return; } /** * Update the parameter */ if (phalcon_array_isset_string(definition, SS("arguments"))) { PHALCON_OBS_VAR(arguments); phalcon_array_fetch_string(&arguments, definition, SL("arguments"), PH_NOISY_CC); phalcon_array_update_zval(&arguments, position, ¶meter, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(arguments); array_init_size(arguments, 1); phalcon_array_update_zval(&arguments, position, ¶meter, PH_COPY | PH_SEPARATE TSRMLS_CC); } /** * Re-update the arguments */ phalcon_array_update_string(&definition, SL("arguments"), &arguments, PH_COPY | PH_SEPARATE TSRMLS_CC); /** * Re-update the definition */ phalcon_update_property_zval(this_ptr, SL("_definition"), definition TSRMLS_CC); RETURN_THIS(); }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize){ zval *records, *valid = NULL, *current = NULL, *cache, *data, *serialized; zval *r0 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(records); array_init(records); PHALCON_CALL_METHOD_NORETURN(this_ptr, "rewind", PH_NO_CHECK); ph_cycle_start_0: PHALCON_INIT_NVAR(r0); PHALCON_CALL_METHOD(r0, this_ptr, "valid", PH_NO_CHECK); PHALCON_CPY_WRT(valid, r0); if (PHALCON_IS_NOT_TRUE(valid)) { goto ph_cycle_end_0; } PHALCON_INIT_NVAR(current); PHALCON_CALL_METHOD(current, this_ptr, "current", PH_NO_CHECK); phalcon_array_append(&records, current, PH_SEPARATE TSRMLS_CC); PHALCON_CALL_METHOD_NORETURN(this_ptr, "next", PH_NO_CHECK); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_VAR(cache); phalcon_read_property(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init(data); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(serialized); PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data); RETURN_CCTOR(serialized); }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, serialize){ zval *records = NULL, *valid = NULL, *current = NULL, *cache = NULL, *data = NULL, *serialized = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(records); array_init(records); PHALCON_CALL_METHOD_NORETURN(this_ptr, "rewind", PH_NO_CHECK); ws_c3ae_0: PHALCON_INIT_VAR(r0); PHALCON_CALL_METHOD(r0, this_ptr, "valid", PH_NO_CHECK); PHALCON_CPY_WRT(valid, r0); if (Z_TYPE_P(valid) != IS_BOOL || (Z_TYPE_P(valid) == IS_BOOL && !Z_BVAL_P(valid))) { goto we_c3ae_0; } PHALCON_INIT_VAR(current); PHALCON_CALL_METHOD(current, this_ptr, "current", PH_NO_CHECK); phalcon_array_append(&records, current, PH_SEPARATE TSRMLS_CC); PHALCON_CALL_METHOD_NORETURN(this_ptr, "next", PH_NO_CHECK); goto ws_c3ae_0; we_c3ae_0: PHALCON_INIT_VAR(cache); phalcon_read_property(&cache, this_ptr, SL("_cache"), PH_NOISY_CC); PHALCON_INIT_VAR(data); array_init(data); phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(serialized); PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data); RETURN_CCTOR(serialized); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Mongo, get){ zval *key_name, *lifetime = NULL, *frontend, *prefix, *prefixed_key; zval *collection = NULL, *conditions, *document = NULL, *time_condition; zval *cached_content; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &key_name, &lifetime); frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC); prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, key_name); phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_CALL_METHOD(&collection, this_ptr, "_getcollection"); PHALCON_INIT_VAR(conditions); array_init_size(conditions, 2); phalcon_array_update_string(&conditions, SL("key"), prefixed_key, PH_COPY); MAKE_STD_ZVAL(time_condition); array_init_size(time_condition, 1); add_assoc_long_ex(time_condition, SS("$gt"), (long int)time(NULL)); add_assoc_zval_ex(conditions, SS("time"), time_condition); PHALCON_CALL_METHOD(&document, collection, "findone", conditions); if (Z_TYPE_P(document) == IS_ARRAY) { if (likely(phalcon_array_isset_string_fetch(&cached_content, document, SS("data")))) { if (phalcon_is_numeric(cached_content)) { RETURN_CCTOR(cached_content); } else { PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content); RETURN_MM(); } } else { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache is corrupt"); return; } } else { RETURN_MM_NULL(); } }
/** * 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); } }
PHP_METHOD(Phalcon_Internal_TestTemp, e10a){ zval *a = NULL; zval *a0 = NULL; zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(a, a0); PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, "LOL", 1); phalcon_array_update_long(&a, 0, &t0, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 0); phalcon_array_update_string(&a, "LOL", strlen("LOL"), &t1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_RETURN_CTOR(a); }
/** * Adds the conditions parameter to the criteria * * @param string $conditions * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, where){ zval *conditions = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &conditions) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(conditions) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Conditions must be string"); return; } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_params"), PH_NOISY_CC); phalcon_array_update_string(&t0, SL("conditions"), &conditions, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_params"), t0 TSRMLS_CC); RETURN_CCTOR(this_ptr); }
/** * Adds the "shared_lock" parameter to the criteria * * @param string $orderColumns * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, sharedLock){ zval *shared_lock = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &shared_lock) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!shared_lock) { PHALCON_ALLOC_ZVAL_MM(shared_lock); ZVAL_BOOL(shared_lock, 1); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_params"), PH_NOISY_CC); phalcon_array_update_string(&t0, SL("shared_lock"), &shared_lock, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_params"), t0 TSRMLS_CC); RETURN_CCTOR(this_ptr); }
/** * Phalcon\DI\FactoryDefault constructor */ PHP_METHOD(Phalcon_DI_FactoryDefault, __construct){ zval *shared, *name = NULL, *definition = NULL, *router, *dispatcher; zval *url, *models_manager, *models_metadata; zval *response, *cookies, *request, *filter, *escaper; zval *annotations, *security, *crypt, *flash, *flash_session; zval *tag, *session, *session_bag, *events_manager; zval *transaction_manager, *assets, *services; PHALCON_MM_GROW(); PHALCON_CALL_PARENT_NORETURN(this_ptr, "Phalcon\\DI\\FactoryDefault", "__construct"); PHALCON_INIT_VAR(shared); ZVAL_BOOL(shared, 1); PHALCON_INIT_VAR(name); ZVAL_STRING(name, "router", 1); PHALCON_INIT_VAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Router", 1); PHALCON_INIT_VAR(router); object_init_ex(router, phalcon_di_service_ce); phalcon_call_method_p3_noret(router, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "dispatcher", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Dispatcher", 1); PHALCON_INIT_VAR(dispatcher); object_init_ex(dispatcher, phalcon_di_service_ce); phalcon_call_method_p3_noret(dispatcher, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "url", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Url", 1); PHALCON_INIT_VAR(url); object_init_ex(url, phalcon_di_service_ce); phalcon_call_method_p3_noret(url, "__construct", name, definition, shared); /** * Models manager for ORM */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Manager", 1); PHALCON_INIT_VAR(models_manager); object_init_ex(models_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(models_manager, "__construct", name, definition, shared); /** * Models meta-data using the Memory adapter */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "modelsMetadata", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\MetaData\\Memory", 1); PHALCON_INIT_VAR(models_metadata); object_init_ex(models_metadata, phalcon_di_service_ce); phalcon_call_method_p3_noret(models_metadata, "__construct", name, definition, shared); /** * Request/Response are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "response", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Response", 1); PHALCON_INIT_VAR(response); object_init_ex(response, phalcon_di_service_ce); phalcon_call_method_p3_noret(response, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "cookies", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Response\\Cookies", 1); PHALCON_INIT_VAR(cookies); object_init_ex(cookies, phalcon_di_service_ce); phalcon_call_method_p3_noret(cookies, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "request", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Http\\Request", 1); PHALCON_INIT_VAR(request); object_init_ex(request, phalcon_di_service_ce); phalcon_call_method_p3_noret(request, "__construct", name, definition, shared); /** * Filter/Escaper services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "filter", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Filter", 1); PHALCON_INIT_VAR(filter); object_init_ex(filter, phalcon_di_service_ce); phalcon_call_method_p3_noret(filter, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "escaper", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Escaper", 1); PHALCON_INIT_VAR(escaper); object_init_ex(escaper, phalcon_di_service_ce); phalcon_call_method_p3_noret(escaper, "__construct", name, definition, shared); /** * Default annotations service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "annotations", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Annotations\\Adapter\\Memory", 1); PHALCON_INIT_VAR(annotations); object_init_ex(annotations, phalcon_di_service_ce); phalcon_call_method_p3_noret(annotations, "__construct", name, definition, shared); /** * Security doesn't need to be shared, but anyways we register it as shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "security", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Security", 1); PHALCON_INIT_VAR(security); object_init_ex(security, phalcon_di_service_ce); phalcon_call_method_p3_noret(security, "__construct", name, definition, shared); /** * Crypt Service */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "crypt", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Crypt", 1); PHALCON_INIT_VAR(crypt); object_init_ex(crypt, phalcon_di_service_ce); phalcon_call_method_p3_noret(crypt, "__construct", name, definition, shared); /** * Flash services are always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "flash", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Flash\\Direct", 1); PHALCON_INIT_VAR(flash); object_init_ex(flash, phalcon_di_service_ce); phalcon_call_method_p3_noret(flash, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "flashSession", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Flash\\Session", 1); PHALCON_INIT_VAR(flash_session); object_init_ex(flash_session, phalcon_di_service_ce); phalcon_call_method_p3_noret(flash_session, "__construct", name, definition, shared); /** * Tag/Helpers */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "tag", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Tag", 1); PHALCON_INIT_VAR(tag); object_init_ex(tag, phalcon_di_service_ce); phalcon_call_method_p3_noret(tag, "__construct", name, definition, shared); /** * Session is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "session", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Session\\Adapter\\Files", 1); PHALCON_INIT_VAR(session); object_init_ex(session, phalcon_di_service_ce); phalcon_call_method_p3_noret(session, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "sessionBag", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Session\\Bag", 1); PHALCON_INIT_VAR(session_bag); object_init_ex(session_bag, phalcon_di_service_ce); phalcon_call_method_p2_noret(session_bag, "__construct", name, definition); /** * Events Manager is always shared */ PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "eventsManager", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Events\\Manager", 1); PHALCON_INIT_VAR(events_manager); object_init_ex(events_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(events_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "transactions", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Mvc\\Model\\Transaction\\Manager", 1); PHALCON_INIT_VAR(transaction_manager); object_init_ex(transaction_manager, phalcon_di_service_ce); phalcon_call_method_p3_noret(transaction_manager, "__construct", name, definition, shared); PHALCON_INIT_NVAR(name); ZVAL_STRING(name, "assets", 1); PHALCON_INIT_NVAR(definition); ZVAL_STRING(definition, "Phalcon\\Assets\\Manager", 1); PHALCON_INIT_VAR(assets); object_init_ex(assets, phalcon_di_service_ce); phalcon_call_method_p3_noret(assets, "__construct", name, definition, shared); /** * Register services */ PHALCON_INIT_VAR(services); array_init_size(services, 21); phalcon_array_update_string(&services, SL("router"), &router, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("dispatcher"), &dispatcher, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("url"), &url, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("modelsManager"), &models_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("modelsMetadata"), &models_metadata, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("response"), &response, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("cookies"), &cookies, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("request"), &request, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("filter"), &filter, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("escaper"), &escaper, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("security"), &security, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("crypt"), &crypt, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("annotations"), &annotations, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("flash"), &flash, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("flashSession"), &flash_session, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("tag"), &tag, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("session"), &session, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("sessionBag"), &session_bag, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("eventsManager"), &events_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("transactionManager"), &transaction_manager, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&services, SL("assets"), &assets, PH_COPY | PH_SEPARATE); /** * Update the internal services properties */ phalcon_update_property_this(this_ptr, SL("_services"), services TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Helper method to query records based on a relation definition * * @param array $relation * @param string $method * @param Phalcon\Mvc\Model $record * @param array $parameters * @return Phalcon\Mvc\Model\Resultset\Simple */ PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){ zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL; zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL; zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL; zval *referenced_fields = NULL, *join_conditions = NULL; zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL; zval *reference_table = NULL, *referenced_entity = NULL; zval *connection_service = NULL, *call_object = NULL, *records = NULL; zval *c0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_ALLOC_ZVAL_MM(parameters); ZVAL_NULL(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_string(parameters, SL("bind")+1); if (eval_int) { PHALCON_INIT_VAR(placeholders); phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("bind")+1); } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } PHALCON_INIT_VAR(pre_conditions); ZVAL_NULL(pre_conditions); if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_long(parameters, 0); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_long(parameters, 0); } else { eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("conditions")+1); } } } else { if (Z_TYPE_P(parameters) == IS_STRING) { PHALCON_CPY_WRT(pre_conditions, parameters); } } if (Z_TYPE_P(pre_conditions) != IS_NULL) { PHALCON_INIT_VAR(conditions); array_init(conditions); phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(conditions); array_init(conditions); } PHALCON_INIT_VAR(fields); phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC); if (Z_TYPE_P(fields) != IS_ARRAY) { PHALCON_CPY_WRT(field, fields); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VS(condition, referenced_field, " = ?0"); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(referenced_fields); phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), PH_NOISY_CC); if (!phalcon_valid_foreach(fields TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fields); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_74b5_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_74b5_0; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch(&referenced_field, referenced_fields, i, PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_74b5_0; fee_74b5_0: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_INIT_VAR(join_conditions); phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC); PHALCON_INIT_VAR(find_params); array_init(find_params); phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(parameters) == IS_ARRAY) { PHALCON_INIT_VAR(find_arguments); PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters); } else { PHALCON_CPY_WRT(find_arguments, find_params); } PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, find_arguments, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(reference_table); phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC); ce0 = phalcon_fetch_class(reference_table TSRMLS_CC); PHALCON_INIT_VAR(referenced_entity); object_init_ex(referenced_entity, ce0); PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK); PHALCON_INIT_VAR(connection_service); PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, PH_NO_CHECK); PHALCON_INIT_VAR(call_object); array_init(call_object); phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(records); PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments); RETURN_CCTOR(records); }
/** * Setup a relation 1-n between two models * * @param Phalcon\Mvc\Model $model * @param mixed $fields * @param string $referenceModel * @param mixed $referencedFields * @param array $options */ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany){ zval *model = NULL, *fields = NULL, *reference_model = NULL, *referenced_fields = NULL; zval *options = NULL, *entity_name = NULL, *has_many = NULL, *number_fields = NULL; zval *number_referenced = NULL, *diferent_fields = NULL; zval *relation = NULL; zval *a0 = NULL; zval *r0 = NULL; zval *t0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &model, &fields, &reference_model, &referenced_fields, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_VAR(options); array_init(options); } PHALCON_INIT_VAR(entity_name); phalcon_get_class(entity_name, model TSRMLS_CC); PHALCON_INIT_VAR(has_many); phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC); eval_int = phalcon_array_isset(has_many, entity_name); if (!eval_int) { PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); phalcon_array_update_zval(&has_many, entity_name, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch(&r0, has_many, entity_name, PH_NOISY_CC); eval_int = phalcon_array_isset(r0, reference_model); if (!eval_int) { if (Z_TYPE_P(referenced_fields) == IS_ARRAY) { PHALCON_INIT_VAR(number_fields); phalcon_fast_count(number_fields, fields TSRMLS_CC); PHALCON_INIT_VAR(number_referenced); phalcon_fast_count(number_referenced, referenced_fields TSRMLS_CC); PHALCON_INIT_VAR(diferent_fields); is_not_equal_function(diferent_fields, number_fields, number_referenced TSRMLS_CC); if (zend_is_true(diferent_fields)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Number of referenced fields are not the same"); return; } } PHALCON_INIT_VAR(relation); array_init(relation); phalcon_array_update_string(&relation, SL("fi"), &fields, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("rt"), &reference_model, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("rf"), &referenced_fields, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&relation, SL("op"), &options, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_hasMany"), PH_NOISY_CC); phalcon_array_update_multi_2(&t0, entity_name, reference_model, &relation, 0 TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_hasMany"), t0 TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } PHALCON_MM_RESTORE(); RETURN_FALSE; }