/** * Set a param by its name or numeric index * * @param mixed $param * @param mixed $value */ PHP_METHOD(Phalcon_Dispatcher, setParam){ zval *param = NULL, *value = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", ¶m, &value) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_params", sizeof("_params")-1, PHALCON_NOISY TSRMLS_CC); phalcon_array_update(&t0, param, &value, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), t0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * @brief string|null Phalcon\Registry::serialize() */ PHP_METHOD(Phalcon_Registry, serialize){ zval data = {}; phalcon_read_property(&data, getThis(), SL("_data"), PH_NOISY); smart_str buf = { 0 }; php_serialize_data_t var_hash; PHP_VAR_SERIALIZE_INIT(var_hash); php_var_serialize(&buf, &data, &var_hash); PHP_VAR_SERIALIZE_DESTROY(var_hash); if (buf.s) { RETURN_NEW_STR(buf.s); } RETURN_NULL(); }
/** * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch() * *<code> * //Return array with integer indexes * $result->setFetchMode(Phalcon\Db::FETCH_NUM); * * //Return associative array without integer indexes * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC); * * //Return associative array together with integer indexes * $result->setFetchMode(Phalcon\Db::FETCH_BOTH); * * //Return an object * $result->setFetchMode(Phalcon\Db::FETCH_OBJ); *</code> * * @param int $fetchMode */ PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode){ long fetch_mode; zval *pdo_statement, *fetch_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &fetch_mode) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(fetch_type); PHALCON_INIT_VAR(pdo_statement); phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC); if (fetch_mode == 1) { ZVAL_LONG(fetch_type, 2); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", fetch_type, PH_NO_CHECK); phalcon_update_property_long(this_ptr, SL("_fetchMode"), 2 TSRMLS_CC); } else { if (fetch_mode == 2) { ZVAL_LONG(fetch_type, 4); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", fetch_type, PH_NO_CHECK); phalcon_update_property_long(this_ptr, SL("_fetchMode"), 4 TSRMLS_CC); } else { if (fetch_mode == 3) { ZVAL_LONG(fetch_type, 3); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", fetch_type, PH_NO_CHECK); phalcon_update_property_long(this_ptr, SL("_fetchMode"), 3 TSRMLS_CC); } else { if (fetch_mode == 4) { ZVAL_LONG(fetch_type, 5); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", fetch_type, PH_NO_CHECK); phalcon_update_property_long(this_ptr, SL("_fetchMode"), 5 TSRMLS_CC); } } } } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Gets a list of columns with escaped identifiers * *<code> * echo $dialect->getColumnList(array('column1', 'column')); *</code> * * @param array $columnList * @return string */ PHP_METHOD(Phalcon_Db_Dialect, getColumnList){ zval *column_list, *str_list, *escape_char, *column = NULL; zval *column_quoted = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &column_list); PHALCON_INIT_VAR(str_list); array_init(str_list); escape_char = phalcon_read_property(getThis(), SL("_escapeChar"), PH_NOISY); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(column_list), column) { PHALCON_INIT_NVAR(column_quoted); PHALCON_CONCAT_VVV(column_quoted, escape_char, column, escape_char); phalcon_array_append(str_list, column_quoted, PH_COPY); } ZEND_HASH_FOREACH_END();
/** * Appends a LIMIT clause to $sqlQuery argument * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, limit){ zval *sql_query = NULL, *number = NULL, *dialect = NULL, *sql = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } 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, "limit", sql_query, number, PH_NO_CHECK); RETURN_CCTOR(sql); }
/** * Returns a SQL modified with a LOCK IN SHARE MODE clause * * @param string $sqlQuery * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, sharedLock){ zval *sql_query = NULL; zval *t0 = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_query) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, t0, "sharedlock", sql_query, PH_NO_CHECK); RETURN_CTOR(r0); }
/** * Returns the SQL column definition from a column * * @param Phalcon\Db\Column $column * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, getColumnDefinition){ zval *column = NULL; zval *t0 = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, t0, "getcolumndefinition", column, PH_NO_CHECK); RETURN_CTOR(r0); }
/** * Gets a list of columns * * @param array $columnList * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, getColumnList){ zval *column_list = NULL, *dialect = NULL, *transformed_list = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column_list) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(dialect); phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(transformed_list); PHALCON_CALL_METHOD_PARAMS_1(transformed_list, dialect, "getcolumnlist", column_list, PH_NO_CHECK); RETURN_CCTOR(transformed_list); }
/** * Escapes a value to avoid SQL injections * * @param string $str * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, escapeString){ zval *str = NULL; zval *t0 = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_pdo"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, t0, "quote", str, PH_NO_CHECK); RETURN_CTOR(r0); }
/** * Sets a header to be sent at the end of the request * * @param string $name * @param string $value */ PHP_METHOD(Phalcon_Http_Response_Headers, set){ zval *name, *value; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &name, &value) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_headers"), PH_NOISY_CC); phalcon_array_update_zval(&t0, name, &value, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_headers"), t0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Mvc_Model_Query_Status, getMessages){ zval *model = NULL, *messages = NULL, *empty_arr = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(model); phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC); if (Z_TYPE_P(model) != IS_NULL) { PHALCON_INIT_VAR(messages); PHALCON_CALL_METHOD(messages, model, "getmessages", PH_NO_CHECK); RETURN_CCTOR(messages); } PHALCON_INIT_VAR(empty_arr); array_init(empty_arr); RETURN_CTOR(empty_arr); }
/** * Adds parameters to views * * @param string $key * @param mixed $value */ PHP_METHOD(Phalcon_Mvc_View, setVar){ zval *key = NULL, *value = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &key, &value) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_viewParams"), PH_NOISY_CC); phalcon_array_update_zval(&t0, key, &value, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_viewParams"), t0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Escapes a value to avoid SQL injections * * @param string $str * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, escapeString){ zval *str = NULL, *pdo = NULL, *quoted_str = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(pdo); phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); PHALCON_INIT_VAR(quoted_str); PHALCON_CALL_METHOD_PARAMS_1(quoted_str, pdo, "quote", str, PH_NO_CHECK); RETURN_CCTOR(quoted_str); }
/** * Removes an element from the form * * @param string $name * @return boolean */ PHP_METHOD(Phalcon_Forms_Form, remove){ zval *name, *elements; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(elements); phalcon_read_property(&elements, this_ptr, SL("_elements"), PH_NOISY_CC); if (phalcon_array_isset(elements, name)) { phalcon_unset_property_array(this_ptr, SL("_elements"), name TSRMLS_CC); RETURN_MM_TRUE; } RETURN_MM_FALSE; }
/** * Create internal connection to memcached */ PHP_METHOD(Phalcon_Cache_Backend_Memcache, _connect){ zval *options, *memcache, *host, *port, *persistent; zval *success = NULL; zend_class_entry *ce0; PHALCON_MM_GROW(); PHALCON_OBS_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); ce0 = zend_fetch_class(SL("Memcache"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_INIT_VAR(memcache); object_init_ex(memcache, ce0); if (phalcon_has_constructor(memcache TSRMLS_CC)) { PHALCON_CALL_METHOD_NORETURN(memcache, "__construct"); } PHALCON_OBS_VAR(host); phalcon_array_fetch_string(&host, options, SL("host"), PH_NOISY_CC); PHALCON_OBS_VAR(port); phalcon_array_fetch_string(&port, options, SL("port"), PH_NOISY_CC); PHALCON_OBS_VAR(persistent); phalcon_array_fetch_string(&persistent, options, SL("persistent"), PH_NOISY_CC); if (zend_is_true(persistent)) { PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, memcache, "pconnect", host, port); } else { PHALCON_INIT_NVAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, memcache, "connect", host, port); } if (!zend_is_true(success)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server"); return; } phalcon_update_property_zval(this_ptr, SL("_memcache"), memcache TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Set a dispatching parameter * * @param mixed $index * @param mixed $value */ PHP_METHOD(Phalcon_Controller, _setParam){ zval *index = NULL, *value = NULL; zval *r0 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &index, &value) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "dispatcher", sizeof("dispatcher")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2(r0, t0, "setparam", index, value, PHALCON_NO_CHECK); PHALCON_RETURN_DZVAL(r0); }
/** * Check whether a translation key exists * * @param string $translateKey * @return boolean */ PHP_METHOD(Phalcon_Translate, offsetExists){ zval *translate_key = NULL; zval *r0 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &translate_key) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_adapter"), PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1(r0, t0, "exists", translate_key, PHALCON_NO_CHECK); RETURN_DZVAL(r0); }
/** * 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 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!descriptor) { PHALCON_ALLOC_ZVAL_MM(descriptor); ZVAL_NULL(descriptor); } else { PHALCON_SEPARATE_PARAM(descriptor); } if (!zend_is_true(descriptor)) { PHALCON_INIT_VAR(descriptor); phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC); } PHALCON_INIT_VAR(schema); ZVAL_NULL(schema); eval_int = phalcon_array_isset_string(descriptor, SS("schema")); if (eval_int) { PHALCON_INIT_VAR(schema); phalcon_array_fetch_string(&schema, descriptor, SL("schema"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(descriptor); phalcon_array_unset_string(descriptor, SS("schema")); } PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Db\\Adapter\\Pdo\\Postgresql", "connect", descriptor); if (Z_TYPE_P(schema) == IS_STRING) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SET search_path TO '", schema, "'"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "execute", sql, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
PHP_METHOD(Phalcon_Internal_TestDummy, f1){ zval *p1 = NULL; zval *r0 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &p1) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_d1"), PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1(r0, t0, "t12", p1, PHALCON_NO_CHECK); RETURN_DZVAL(r0); }
/** * Check whether resource exist in the resources list * * @param string $resourceName * @return boolean */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isResource){ zval *resource_name, *resources_names, *is_resource = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &resource_name) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(resources_names); phalcon_read_property(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC); PHALCON_INIT_VAR(r0); ZVAL_BOOL(r0, phalcon_array_isset(resources_names, resource_name)); PHALCON_CPY_WRT(is_resource, r0); RETURN_NCTOR(is_resource); }
/** * Unregister the autoload method * * @return Phalcon\Loader */ PHP_METHOD(Phalcon_Loader, unregister){ zval *registered, *autoloader; PHALCON_MM_GROW(); PHALCON_OBS_VAR(registered); phalcon_read_property(®istered, this_ptr, SL("_registered"), PH_NOISY_CC); if (PHALCON_IS_TRUE(registered)) { PHALCON_INIT_VAR(autoloader); array_init_size(autoloader, 2); phalcon_array_append(&autoloader, this_ptr, PH_SEPARATE TSRMLS_CC); add_next_index_stringl(autoloader, SL("autoLoad"), 1); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("spl_autoload_unregister", autoloader); } RETURN_THIS(); }
/** * Gets hasMany related records from a model * * @param string $method * @param string $modelName * @param string $modelRelation * @param Phalcon\Mvc\Model $record * @param array $parameters * @return Phalcon\Mvc\Model\Resultset */ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasManyRecords){ zval *method, *model_name, *model_relation, *record; zval *parameters = NULL, *has_many, *relation, *records; zval *r0 = NULL, *r1 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &method, &model_name, &model_relation, &record, ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_INIT_NVAR(parameters); } PHALCON_INIT_VAR(has_many); phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC); eval_int = phalcon_array_isset(has_many, model_name); if (eval_int) { PHALCON_INIT_VAR(r0); phalcon_array_fetch(&r0, has_many, model_name, PH_NOISY_CC); eval_int = phalcon_array_isset(r0, model_relation); if (!eval_int) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(r1); phalcon_array_fetch(&r1, has_many, model_name, PH_NOISY_CC); PHALCON_INIT_VAR(relation); phalcon_array_fetch(&relation, r1, model_relation, PH_NOISY_CC); PHALCON_INIT_VAR(records); PHALCON_CALL_METHOD_PARAMS_4(records, this_ptr, "_getrelationrecords", relation, method, record, parameters, PH_NO_CHECK); RETURN_CCTOR(records); }
/** * Rollbacks the internal transaction * */ PHP_METHOD(Phalcon_Logger_Adapter_File, rollback){ zval *transaction = NULL, *quenue = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(transaction); phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC); if (!zend_is_true(transaction)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction"); return; } phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC); PHALCON_INIT_VAR(quenue); array_init(quenue); phalcon_update_property_zval(this_ptr, SL("_quenue"), quenue TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns a named argument * * @param string $name * @return mixed */ PHP_METHOD(Phalcon_Annotations_Annotation, getNamedParameter){ zval *name, *arguments, *value; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(arguments); phalcon_read_property(&arguments, this_ptr, SL("_arguments"), PH_NOISY_CC); if (phalcon_array_isset(arguments, name)) { PHALCON_OBS_VAR(value); phalcon_array_fetch(&value, arguments, name, PH_NOISY_CC); RETURN_CCTOR(value); } RETURN_MM_NULL(); }
/** * Sends/Writes an alert message to the log * * @param string $message * @param ing $type */ PHP_METHOD(Phalcon_Logger, alert){ zval *message = NULL; zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &message) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_adapter", sizeof("_adapter")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_get_class_constant(t1, phalcon_logger_ce, "ALERT", strlen("ALERT") TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(t0, "log", message, t1, PHALCON_NO_CHECK); PHALCON_MM_RESTORE(); }
/** * Gets an attribute a message using the array syntax * *<code> * print_r($messages[0]); *</code> * * @param string $index * @return Phalcon\Validation\Message */ PHP_METHOD(Phalcon_Validation_Message_Group, offsetGet){ zval *index, *messages, *message; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(messages); phalcon_read_property(&messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (phalcon_array_isset(messages, index)) { PHALCON_OBS_VAR(message); phalcon_array_fetch(&message, messages, index, PH_NOISY_CC); RETURN_CCTOR(message); } RETURN_MM_NULL(); }
/** * Removes a session variable from an application context * *<code> * $session->remove('auth'); *</code> * * @param string $index */ PHP_METHOD(Phalcon_Session_Adapter, remove){ zval *index, *unique_id, *key, *_SESSION; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(unique_id); phalcon_read_property(&unique_id, this_ptr, SL("_uniqueId"), PH_NOISY_CC); PHALCON_INIT_VAR(key); PHALCON_CONCAT_VV(key, unique_id, index); phalcon_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC); phalcon_array_unset(&_SESSION, key, 0); PHALCON_MM_RESTORE(); }
/** * Stops the active profile * * @access public */ PHP_METHOD(Phalcon_Db_Profiler, stopProfile){ zval *final_time = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; zval *c0 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_INIT_VAR(c0); ZVAL_BOOL(c0, 1); PHALCON_CALL_FUNC_PARAMS_1(r0, "microtime", c0, 0x034); PHALCON_CPY_WRT(final_time, r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(t0, "setfinaltime", final_time, PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_totalSeconds", sizeof("_totalSeconds")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(r1, t2, "getinitialtime", PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r2); sub_function(r2, final_time, r1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_add_function(r3, t1, r2 TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_totalSeconds", strlen("_totalSeconds"), r3 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t4); phalcon_read_property(&t4, this_ptr, "_allProfiles", sizeof("_allProfiles")-1, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(&t4, t3, PHALCON_NO_SEPARATE_THX TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_allProfiles", strlen("_allProfiles"), t4 TSRMLS_CC); if (phalcon_method_exists_ex(this_ptr, "afterendprofile", strlen("afterendprofile") TSRMLS_CC) == SUCCESS) { PHALCON_ALLOC_ZVAL_MM(t5); phalcon_read_property(&t5, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "afterendprofile", t5, PHALCON_NO_CHECK); } PHALCON_MM_RESTORE(); }
/** * Checks if an option is defined * * @param string $key * @return mixed */ PHP_METHOD(Phalcon_Validation_Validator, isSetOption){ zval *key, *options; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &key) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); if (Z_TYPE_P(options) == IS_ARRAY) { if (phalcon_array_isset(options, key)) { RETURN_MM_TRUE; } } RETURN_MM_FALSE; }
/** * Writes the meta-data to $_SESSION * * @param string $key * @param array $data */ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, write) { zval *key, *data, *prefix, *prefix_key, *_SESSION; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &key, &data) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(prefix_key); PHALCON_CONCAT_SV(prefix_key, "$PMM$", prefix); phalcon_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC); phalcon_array_update_multi_2(&_SESSION, prefix_key, key, &data, 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }