/** * Converts strings to camelize style * * * * @param string $str * @return string */ PHP_METHOD(Phalcon_Text, camelize){ zval *str = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " ", 1); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "", 1); PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "_", 1); PHALCON_INIT_VAR(c3); ZVAL_STRING(c3, " ", 1); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "strtolower", str); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_fast_str_replace(r1, c2, c3, r0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_FUNC_PARAMS_1(r2, "ucwords", r1); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_fast_str_replace(r3, c0, c1, r2 TSRMLS_CC); RETURN_DZVAL(r3); }
/** * Generates the SQL for a MySQL LIMIT clause * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, limit){ zval *sql_query = NULL, *number = NULL, *limit = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "is_numeric", number); if (zend_is_true(r0)) { PHALCON_INIT_VAR(limit); PHALCON_CALL_FUNC_PARAMS_1(limit, "intval", number); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_VSV(r1, sql_query, " LIMIT ", limit); RETURN_CTOR(r1); } else { RETURN_CCTOR(sql_query); } PHALCON_MM_RESTORE(); }
/** * Generates the SQL for LIMIT clause * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect, limit){ zval *sql_query = NULL, *number = NULL, *is_numeric = NULL, *limit = NULL, *sql_limit = 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(is_numeric); PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", number); if (Z_TYPE_P(is_numeric) == IS_BOOL && Z_BVAL_P(is_numeric)) { PHALCON_INIT_VAR(limit); PHALCON_CALL_FUNC_PARAMS_1(limit, "intval", number); PHALCON_INIT_VAR(sql_limit); PHALCON_CONCAT_VSV(sql_limit, sql_query, " LIMIT ", limit); RETURN_CTOR(sql_limit); } RETURN_CCTOR(sql_query); }
/** * Uncamelize strings which are camelized * *<code> * echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo *</code> * * @param string $str * @return string */ PHP_METHOD(Phalcon_Text, uncamelize){ zval *str = NULL, *patterns = NULL, *replacement = NULL, *pattern = NULL, *match_pattern = NULL; zval *pattern_replace = NULL, *lower_pattern = NULL, *lower_str = NULL; HashTable *ah0; HashPosition hp0; 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", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(patterns); array_init(patterns); add_assoc_stringl_ex(patterns, SL("/(?<=(?:[A-Z]))([A-Z]+)([A-Z][A-z])/")+1, SL("\\1_\\2"), 1); add_assoc_stringl_ex(patterns, SL("/(?<=(?:[a-z]))([A-Z])/")+1, SL("_\\1"), 1); if (!phalcon_valid_foreach(patterns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(patterns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_f8ee_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_f8ee_0; } PHALCON_INIT_VAR(pattern); PHALCON_GET_FOREACH_KEY(pattern, ah0, hp0); PHALCON_INIT_VAR(replacement); ZVAL_ZVAL(replacement, *hd, 1, 0); PHALCON_INIT_VAR(match_pattern); PHALCON_CALL_FUNC_PARAMS_2(match_pattern, "preg_match", pattern, str); if (zend_is_true(match_pattern)) { PHALCON_INIT_VAR(pattern_replace); PHALCON_CALL_FUNC_PARAMS_3(pattern_replace, "preg_replace", pattern, replacement, str); PHALCON_INIT_VAR(lower_pattern); PHALCON_CALL_FUNC_PARAMS_1(lower_pattern, "strtolower", pattern_replace); RETURN_CTOR(lower_pattern); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_f8ee_0; fee_f8ee_0: PHALCON_INIT_VAR(lower_str); PHALCON_CALL_FUNC_PARAMS_1(lower_str, "strtolower", str); RETURN_CTOR(lower_str); }
/** * 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(); }
/** * Gets active server address IP * * @return string */ PHP_METHOD(Phalcon_Http_Request, getServerAddress){ zval *server = NULL, *server_addr = NULL, *localhost = NULL; zval *g0 = NULL; int eval_int; PHALCON_MM_GROW(); phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC); PHALCON_CPY_WRT(server, g0); eval_int = phalcon_array_isset_string(server, SL("SERVER_ADDR")+1); if (eval_int) { PHALCON_INIT_VAR(server_addr); phalcon_array_fetch_string(&server_addr, server, SL("SERVER_ADDR"), PH_NOISY_CC); RETURN_CCTOR(server_addr); } PHALCON_INIT_VAR(localhost); ZVAL_STRING(localhost, "localhost", 1); PHALCON_INIT_VAR(server_addr); PHALCON_CALL_FUNC_PARAMS_1(server_addr, "gethostbyname", localhost); RETURN_CCTOR(server_addr); }
/** * 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); }
/** * Returns last error code from MySQL * * @param string $errorString * @param resurce $resultQuery * @return int */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, noError){ zval *result_query = NULL, *id_connection = NULL; zval *t0 = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &result_query) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!result_query) { PHALCON_INIT_VAR(result_query); ZVAL_NULL(result_query); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id_connection, t0); if (!zend_is_true(id_connection)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "mysqli_errno", id_connection); RETURN_DZVAL(r0); }
/** * Check that the options are valid * */ PHP_METHOD(Phalcon_Model_Validator_Exclusionin, checkOptions) { zval *r0 = NULL, *r1 = NULL, *r2 = NULL; zval *c0 = NULL, *c1 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "domain", 1); PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "issetoption", c0, PHALCON_NO_CHECK); if (!zend_is_true(r0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_model_exception_ce, "The option 'domain' is required for this validator"); return; } PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "domain", 1); PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "getoption", c1, PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_1(r1, "is_array", r2, 0x03D); if (!zend_is_true(r1)) { PHALCON_THROW_EXCEPTION_STR(phalcon_model_exception_ce, "Option 'domain' must be an array"); return; } PHALCON_MM_RESTORE(); }
/** * Gets the active connection unique identifier. A mysqli object * * @param boolean $asString * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, getConnectionId){ zval *as_string = NULL, *id_connection = NULL; zval *t0 = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &as_string) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!as_string) { PHALCON_INIT_VAR(as_string); ZVAL_BOOL(as_string, 0); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id_connection, t0); if (zend_is_true(as_string)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "mysqli_thread_id", id_connection); PHALCON_CONCAT_SV(r0, "Connection", r1); RETURN_CTOR(r0); } else { RETURN_CHECK_CTOR(id_connection); } PHALCON_MM_RESTORE(); }
/** * Loads a model throwing an exception if it doesn't exist * * @return Phalcon\Mvc\Model */ PHP_METHOD(Phalcon_Mvc_Model_Manager, load){ zval *model_name = NULL, *model_exists = NULL, *model = NULL, *exception_message = NULL; zval *exception = NULL; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(model_exists); PHALCON_CALL_FUNC_PARAMS_1(model_exists, "class_exists", model_name); if (zend_is_true(model_exists)) { ce0 = phalcon_fetch_class(model_name TSRMLS_CC); PHALCON_INIT_VAR(model); object_init_ex(model, ce0); PHALCON_CALL_METHOD_NORETURN(model, "__construct", PH_CHECK); RETURN_CTOR(model); } PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "The model '", model_name, "' could not be loaded"); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_mvc_model_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Serializing a resultset will dump all related rows into a big array * * @return string */ PHP_METHOD(Phalcon_Model_Resultset, serialize){ zval *records = NULL; zval *a0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(records, a0); PHALCON_CALL_METHOD_NORETURN(this_ptr, "rewind", PHALCON_NO_CHECK); ws_fd08_1: PHALCON_INIT_VAR(r0); PHALCON_CALL_METHOD(r0, this_ptr, "valid", PHALCON_NO_CHECK); if (Z_TYPE_P(r0) != IS_BOOL || (Z_TYPE_P(r0) == IS_BOOL && !Z_BVAL_P(r0))) { goto we_fd08_1; } PHALCON_INIT_VAR(r1); PHALCON_CALL_METHOD(r1, this_ptr, "current", PHALCON_NO_CHECK); phalcon_array_append(&records, r1, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_CALL_METHOD_NORETURN(this_ptr, "next", PHALCON_NO_CHECK); goto ws_fd08_1; we_fd08_1: PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_FUNC_PARAMS_1(r2, "serialize", records, 0x057); PHALCON_RETURN_DZVAL(r2); }
/** * Renders a view using the template engine * * @param string $path * @param array $params */ PHP_METHOD(Phalcon_View_Engine_Mustache, render){ zval *path = NULL, *params = NULL; zval *t0 = NULL, *t1 = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &path, ¶ms) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_view"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, SL("_mustache"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "file_get_contents", path); PHALCON_CALL_METHOD_PARAMS_2(r0, t1, "render", r1, this_ptr, PHALCON_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(t0, "setcontent", r0, PHALCON_NO_CHECK); PHALCON_MM_RESTORE(); }
/** * 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); }
/** * Unserializing a resultset will allow to only works on the rows present in the saved state * * @param string $data */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, unserialize){ zval *data = NULL, *resultset = NULL, *model = NULL, *rows = NULL, *cache = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } phalcon_update_property_long(this_ptr, SL("_type"), 0 TSRMLS_CC); PHALCON_INIT_VAR(resultset); PHALCON_CALL_FUNC_PARAMS_1(resultset, "unserialize", data); if (Z_TYPE_P(resultset) == IS_ARRAY) { PHALCON_INIT_VAR(model); phalcon_array_fetch_string(&model, resultset, SL("model"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_model"), model TSRMLS_CC); PHALCON_INIT_VAR(rows); phalcon_array_fetch_string(&rows, resultset, SL("rows"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC); PHALCON_INIT_VAR(cache); phalcon_array_fetch_string(&cache, resultset, SL("cache"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_cache"), cache TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Invalid serialization data"); return; } PHALCON_MM_RESTORE(); }
/** * Gets HTTP raw request body * * @return string */ PHP_METHOD(Phalcon_Http_Request, getRawBody){ zval *raw_body, *input, *contents; PHALCON_MM_GROW(); PHALCON_OBS_VAR(raw_body); phalcon_read_property(&raw_body, this_ptr, SL("_rawBody"), PH_NOISY_CC); if (!zend_is_true(raw_body)) { PHALCON_INIT_VAR(input); ZVAL_STRING(input, "php://input", 1); PHALCON_INIT_VAR(contents); PHALCON_CALL_FUNC_PARAMS_1(contents, "file_get_contents", input); /** * We need store the read raw body because it can be read again */ phalcon_update_property_zval(this_ptr, SL("_rawBody"), contents TSRMLS_CC); RETURN_CCTOR(contents); } RETURN_CCTOR(raw_body); }
/** * Starts the profile of a SQL sentence * * @param string $sqlStatement * @return Phalcon\Db\Profiler */ PHP_METHOD(Phalcon_Db_Profiler, startProfile){ zval *sql_statement, *active_profile, *micro; zval *time; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_statement) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(active_profile); object_init_ex(active_profile, phalcon_db_profiler_item_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(active_profile, "setsqlstatement", sql_statement, PH_NO_CHECK); PHALCON_INIT_VAR(micro); ZVAL_BOOL(micro, 1); PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC_PARAMS_1(time, "microtime", micro); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(active_profile, "setinitialtime", time, PH_NO_CHECK); if (phalcon_method_exists_ex(this_ptr, SS("beforestartprofile") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "beforestartprofile", active_profile, PH_NO_CHECK); } phalcon_update_property_zval(this_ptr, SL("_activeProfile"), active_profile TSRMLS_CC); RETURN_CTOR(this_ptr); }
/** * Phalcon_Logger constructor * * @param string $adapter * @param string $name * @param array $options */ PHP_METHOD(Phalcon_Logger, __construct){ zval *adapter = NULL, *name = NULL, *options = NULL, *class_name = NULL; zval *a0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; zval *i0 = NULL, *i1 = NULL; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzz", &adapter, &name, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!adapter) { PHALCON_INIT_VAR(adapter); ZVAL_STRING(adapter, "File", 1); } if (!name) { PHALCON_INIT_VAR(name); ZVAL_NULL(name); } if (!options) { PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(options, a0); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_LEFT(r0, "Phalcon_Logger_Adapter_", adapter); PHALCON_CPY_WRT(class_name, r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "class_exists", class_name, 0x012); if (!zend_is_true(r1)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_logger_exception_ce); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_BOTH(r2, "Logger adapter '", class_name, "' cannot be found"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r2, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } ce0 = phalcon_fetch_class(class_name TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, ce0); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i1, "__construct", name, options, PHALCON_CHECK); phalcon_update_property_zval(this_ptr, "_adapter", strlen("_adapter"), i1 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Counts how many rows are in the resultset * * @return int */ PHP_METHOD(Phalcon_Model_Resultset, count){ zval *count = NULL, *result_resource = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_count", sizeof("_count")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_1(r0, "is_null", t0, 0x041); if (zend_is_true(r0)) { PHALCON_INIT_VAR(count); ZVAL_LONG(count, 0); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t1)) { PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_resultResource", sizeof("_resultResource")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(result_resource, t2); if (Z_TYPE_P(result_resource) != IS_BOOL || (Z_TYPE_P(result_resource) == IS_BOOL && Z_BVAL_P(result_resource))) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1(r2, t3, "numrows", result_resource, PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_1(r1, "intval", r2, 0x020); PHALCON_CPY_WRT(count, r1); } } else { PHALCON_ALLOC_ZVAL_MM(t4); phalcon_read_property(&t4, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_fast_count(r3, t4 TSRMLS_CC); PHALCON_CPY_WRT(count, r3); } phalcon_update_property_zval(this_ptr, "_count", strlen("_count"), count TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(t5); phalcon_read_property(&t5, this_ptr, "_count", sizeof("_count")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t5); }
/** * Returns the active version (string) * * @return string */ PHP_METHOD(Phalcon_Version, get){ zval *version, *major, *medium, *minor, *special, *special_number; zval *result, *suffix = NULL, *final_version; PHALCON_MM_GROW(); PHALCON_INIT_VAR(version); PHALCON_CALL_SELF(version, this_ptr, "_getversion"); PHALCON_INIT_VAR(major); phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC); PHALCON_INIT_VAR(medium); phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC); PHALCON_INIT_VAR(minor); phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC); PHALCON_INIT_VAR(special); phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC); PHALCON_INIT_VAR(special_number); phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC); PHALCON_INIT_VAR(result); PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " "); if (phalcon_compare_strict_long(special, 1 TSRMLS_CC)) { PHALCON_INIT_VAR(suffix); PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number); goto ph_end_0; } if (phalcon_compare_strict_long(special, 2 TSRMLS_CC)) { PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "BETA ", special_number); goto ph_end_0; } if (phalcon_compare_strict_long(special, 1 TSRMLS_CC)) { PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "RC ", special_number); goto ph_end_0; } PHALCON_INIT_NVAR(suffix); ZVAL_STRING(suffix, "", 1); goto ph_end_0; ph_end_0: phalcon_concat_self(result, suffix TSRMLS_CC); PHALCON_INIT_VAR(final_version); PHALCON_CALL_FUNC_PARAMS_1(final_version, "trim", result); RETURN_CCTOR(final_version); }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Model_Resultset, valid){ zval *result = NULL, *row = NULL, *rows = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; zval *c0 = NULL, *c1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t0)) { PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_result", sizeof("_result")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(result, t1); if (Z_TYPE_P(result) != IS_BOOL || (Z_TYPE_P(result) == IS_BOOL && Z_BVAL_P(result))) { PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", c0, PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, result, "fetcharray", result, PHALCON_NO_CHECK); PHALCON_CPY_WRT(row, r0); if (zend_is_true(row)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_model", sizeof("_model")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_STATIC_PARAMS_2(r1, "phalcon_model_base", "dumpresult", t2, row); phalcon_update_property_zval(this_ptr, "_activeRow", strlen("_activeRow"), r1 TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } else { PHALCON_INIT_VAR(c1); ZVAL_LONG(c1, 2); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", c1, PHALCON_NO_CHECK); } } } else { PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(rows, t3); PHALCON_ALLOC_ZVAL_MM(r2); Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1(r2, "current", rows, 0x054); Z_UNSET_ISREF_P(rows); PHALCON_CPY_WRT(row, r2); if (zend_is_true(row)) { Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059); Z_UNSET_ISREF_P(rows); phalcon_update_property_zval(this_ptr, "_activeRow", strlen("_activeRow"), row TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_TRUE; } } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Sends/Writes messages to the file log * * @param string $message * @param int $type */ PHP_METHOD(Phalcon_Logger_Adapter_File, log){ zval *message = NULL, *type = NULL, *msg = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *c0 = NULL; zval *i0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &message, &type) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Cannot send message to the log because it is invalid"); return; } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "is_scalar", message, 0x045); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(c0); ZVAL_BOOL(c0, 1); PHALCON_CALL_FUNC_PARAMS_2(r1, "print_r", message, c0, 0x008); PHALCON_CPY_WRT(msg, r1); } PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_transaction", sizeof("_transaction")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t1)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_logger_item_ce); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_FUNC(r2, "time", 0x018); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(i0, "__construct", message, type, r2, PHALCON_CHECK); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_quenue", sizeof("_quenue")-1, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(&t2, i0, PHALCON_NO_SEPARATE_THX TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_quenue", strlen("_quenue"), t2 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD_PARAMS_2(r4, this_ptr, "_applyformat", message, type, PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(t4); zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t4 TSRMLS_CC); PHALCON_CONCAT_VV(r3, r4, t4); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t3, r3, 0x04F); } PHALCON_MM_RESTORE(); }
/** * Gets external uri where app is executed * * @return string */ PHP_METHOD(Phalcon_Controller_Front, getBaseUri){ zval *uri = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; zval *g0 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_baseUri", sizeof("_baseUri")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { phalcon_get_global(&g0, "_SERVER", sizeof("_SERVER") TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, "PHP_SELF", strlen("PHP_SELF")+1); if (eval_int) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "/", 1); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, g0, "PHP_SELF", strlen("PHP_SELF"), PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_1(r1, "dirname", r2, 0x049); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_fast_explode(r3, c1, r1 TSRMLS_CC); PHALCON_INIT_VAR(c2); ZVAL_LONG(c2, 1); PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 1); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, -1); PHALCON_ALLOC_ZVAL_MM(r4); mul_function(r4, t1, t2 TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_3(r0, "array_slice", r3, c2, r4, 0x01F); PHALCON_ALLOC_ZVAL_MM(r5); phalcon_fast_join(r5, c0, r0 TSRMLS_CC); PHALCON_CPY_WRT(uri, r5); } else { PHALCON_INIT_VAR(uri); ZVAL_STRING(uri, "", 1); } if (!zend_is_true(uri)) { phalcon_update_property_string(this_ptr, "_baseUri", strlen("_baseUri"), "/" TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_CONCAT_SVS(r6, "/", uri, "/"); phalcon_update_property_zval(this_ptr, "_baseUri", strlen("_baseUri"), r6 TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_baseUri", sizeof("_baseUri")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_RETURN_CHECK_CTOR(t3); }
/** * Returns the prefix for all the generated urls. By default / * * @return string */ PHP_METHOD(Phalcon_Mvc_Url, getBaseUri){ zval *base_uri = NULL, *slash, *one, *minus_one = NULL, *php_self; zval *dirname, *dir_parts, *slice, *uri = NULL; zval *g0 = NULL; zval *c0 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(base_uri); phalcon_read_property(&base_uri, this_ptr, SL("_baseUri"), PH_NOISY_CC); if (Z_TYPE_P(base_uri) == IS_NULL) { PHALCON_INIT_VAR(slash); ZVAL_STRING(slash, "/", 1); phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, SS("PHP_SELF")); if (eval_int) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, -1); PHALCON_CPY_WRT(minus_one, c0); PHALCON_INIT_VAR(php_self); phalcon_array_fetch_string(&php_self, g0, SL("PHP_SELF"), PH_NOISY_CC); PHALCON_INIT_VAR(dirname); PHALCON_CALL_FUNC_PARAMS_1(dirname, "dirname", php_self); PHALCON_INIT_VAR(dir_parts); phalcon_fast_explode(dir_parts, slash, dirname TSRMLS_CC); PHALCON_INIT_VAR(slice); PHALCON_CALL_FUNC_PARAMS_3(slice, "array_slice", dir_parts, one, minus_one); PHALCON_INIT_VAR(uri); phalcon_fast_join(uri, slash, slice TSRMLS_CC); } else { PHALCON_INIT_NVAR(uri); ZVAL_STRING(uri, "", 1); } if (PHALCON_COMPARE_STRING(uri, "")) { PHALCON_CPY_WRT(base_uri, slash); } else { PHALCON_INIT_NVAR(base_uri); PHALCON_CONCAT_VVV(base_uri, slash, uri, slash); } phalcon_update_property_zval(this_ptr, SL("_baseUri"), base_uri TSRMLS_CC); } RETURN_CCTOR(base_uri); }
/** * Returns the active version (string) * * <code> * echo Phalcon\Version::get(); * </code> * * @return string */ PHP_METHOD(Phalcon_Version, get){ zval *version, *major, *medium, *minor, *special, *special_number; zval *result, *suffix = NULL, *final_version; PHALCON_MM_GROW(); PHALCON_INIT_VAR(version); PHALCON_CALL_SELF(version, this_ptr, "_getversion"); PHALCON_OBS_VAR(major); phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC); PHALCON_OBS_VAR(medium); phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC); PHALCON_OBS_VAR(minor); phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC); PHALCON_OBS_VAR(special); phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC); PHALCON_OBS_VAR(special_number); phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC); PHALCON_INIT_VAR(result); PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " "); switch (phalcon_get_intval(special)) { case 1: PHALCON_INIT_VAR(suffix); PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number); break; case 2: PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "BETA ", special_number); break; case 3: PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "RC ", special_number); break; default: PHALCON_INIT_NVAR(suffix); ZVAL_STRING(suffix, "", 1); break; } phalcon_concat_self(&result, suffix TSRMLS_CC); PHALCON_INIT_VAR(final_version); PHALCON_CALL_FUNC_PARAMS_1(final_version, "trim", result); RETURN_CCTOR(final_version); }
/** * Converts strings to camelize style * *<code> * echo Phalcon\Text::camelize('coco_bongo'); //CocoBongo *</code> * * @param string $str * @return string */ PHP_METHOD(Phalcon_Text, camelize){ zval *str = NULL, *space = NULL, *lower_str = NULL, *underscore = NULL, *no_underscore_str = NULL; zval *dash = NULL, *no_dash_str = NULL, *empty_str = NULL, *uc_string = NULL; zval *camelized = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(space); ZVAL_STRING(space, " ", 1); PHALCON_INIT_VAR(lower_str); PHALCON_CALL_FUNC_PARAMS_1(lower_str, "strtolower", str); PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(no_underscore_str); phalcon_fast_str_replace(no_underscore_str, underscore, space, lower_str TSRMLS_CC); PHALCON_INIT_VAR(dash); ZVAL_STRING(dash, "-", 1); PHALCON_INIT_VAR(no_dash_str); phalcon_fast_str_replace(no_dash_str, dash, space, no_underscore_str TSRMLS_CC); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(uc_string); PHALCON_CALL_FUNC_PARAMS_1(uc_string, "ucwords", no_dash_str); PHALCON_INIT_VAR(camelized); phalcon_fast_str_replace(camelized, space, empty_str, uc_string TSRMLS_CC); RETURN_CTOR(camelized); }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Numericality, validate){ zval *record, *option = NULL, *field, *value, *is_numeric; zval *message = NULL, *type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field); PHALCON_CALL_METHOD_PARAMS_1(field, this_ptr, "getoption", option, PH_NO_CHECK); if (Z_TYPE_P(field) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string"); return; } PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); /** * Check if the value is numeric using is_numeric in the PHP userland */ PHALCON_INIT_VAR(is_numeric); PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", value); if (!zend_is_true(is_numeric)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); PHALCON_CALL_METHOD_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK); if (!zend_is_true(message)) { PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "Value of field '", field, "' must be numeric"); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Numericality", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field, type, PH_NO_CHECK); PHALCON_MM_RESTORE(); RETURN_FALSE; } PHALCON_MM_RESTORE(); RETURN_TRUE; }
/** * 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); }
/** * Gets external uri where app is executed * * @return string */ PHP_METHOD(Phalcon_Controller_Front, getBaseUri){ zval *base_uri = NULL, *slash = NULL, *uri = NULL; zval *g0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *c0 = NULL; zval *t0 = NULL, *t1 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(base_uri); phalcon_read_property(&base_uri, this_ptr, SL("_baseUri"), PH_NOISY_CC); if (!zend_is_true(base_uri)) { PHALCON_INIT_VAR(slash); ZVAL_STRING(slash, "/", 1); phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, SL("PHP_SELF")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, g0, SL("PHP_SELF"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "dirname", r0); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_fast_explode(r2, slash, r1 TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_LONG(c0, 1); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 1); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, -1); PHALCON_ALLOC_ZVAL_MM(r3); mul_function(r3, t0, t1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_FUNC_PARAMS_3(r4, "array_slice", r2, c0, r3); PHALCON_INIT_VAR(uri); phalcon_fast_join(uri, slash, r4 TSRMLS_CC); } else { PHALCON_INIT_VAR(uri); ZVAL_STRING(uri, "", 1); } if (!zend_is_true(uri)) { PHALCON_CPY_WRT(base_uri, slash); } else { PHALCON_INIT_VAR(base_uri); PHALCON_CONCAT_VVV(base_uri, slash, uri, slash); } phalcon_update_property_zval(this_ptr, SL("_baseUri"), base_uri TSRMLS_CC); } RETURN_CCTOR(base_uri); }
/** * Changes internal pointer to a specific position in the resultset */ PHP_METHOD(Phalcon_Model_Resultset, seek){ zval *position = NULL, *rows = NULL, *i = NULL; zval *r0 = NULL, *r1 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "intval", position, 0x020); phalcon_update_property_zval(this_ptr, "_pointer", strlen("_pointer"), r0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t0)) { PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_resultResource", sizeof("_resultResource")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(t1, "dataseek", position, t2, PHALCON_NO_CHECK); } else { PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(rows, t3); Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows, 0x055); Z_UNSET_ISREF_P(rows); PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); fs_fd08_0: PHALCON_INIT_VAR(r1); is_smaller_function(r1, i, position TSRMLS_CC); if (!zend_is_true(r1)) { goto fe_fd08_0; } Z_SET_ISREF_P(rows); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059); Z_UNSET_ISREF_P(rows); PHALCON_SEPARATE(i); increment_function(i); goto fs_fd08_0; fe_fd08_0: if(0){} } PHALCON_MM_RESTORE(); }