PHP_METHOD(Test_Trie, getTrieNodeByKey) { zend_class_entry *_5; zephir_nts_static zephir_fcall_cache_entry *_2 = NULL; int i, ZEPHIR_LAST_CALL_STATUS; zend_bool create; zval *key_param = NULL, *create_param = NULL, *trieNode = NULL, *keyLen, *character = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_3 = NULL, *_4 = NULL, *_6 = NULL, *_7; zval *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &key_param, &create_param); zephir_get_strval(key, key_param); if (!create_param) { create = 0; } else { create = zephir_get_boolval(create_param); } ZEPHIR_OBS_VAR(trieNode); zephir_read_property_this(&trieNode, this_ptr, SL("trie"), PH_NOISY_CC); ZEPHIR_INIT_VAR(keyLen); ZVAL_LONG(keyLen, zephir_fast_strlen_ev(key)); i = 0; while (1) { if (!(ZEPHIR_GT_LONG(keyLen, i))) { break; } ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, i); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 1); ZEPHIR_CALL_FUNCTION(&character, "substr", &_2, key, &_0, &_1); zephir_check_call_status(); ZEPHIR_OBS_NVAR(_3); zephir_read_property(&_3, trieNode, SL("children"), PH_NOISY_CC); if (!(zephir_array_isset(_3, character))) { if (create) { ZEPHIR_INIT_LNVAR(_4); _5 = zend_fetch_class(SL("tries\\trienode"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(_4, _5); if (zephir_has_constructor(_4 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL); zephir_check_call_status(); } zephir_update_property_array(trieNode, SL("children"), character, _4 TSRMLS_CC); } else { RETURN_MM_BOOL(0); } } ZEPHIR_OBS_NVAR(_6); zephir_read_property(&_6, trieNode, SL("children"), PH_NOISY_CC); zephir_array_fetch(&_7, _6, character, PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CPY_WRT(trieNode, _7); i += 1; } RETURN_CCTOR(trieNode); }
/** * Returns an array of default parameters */ PHP_METHOD(Phalcon_Mvc_Router, getDefaults) { zval *_0 = NULL; ZEPHIR_MM_GROW(); zephir_create_array(return_value, 5, 0 TSRMLS_CC); ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultNamespace"), PH_NOISY_CC); zephir_array_update_string(&return_value, SL("namespace"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_array_update_string(&return_value, SL("module"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultController"), PH_NOISY_CC); zephir_array_update_string(&return_value, SL("controller"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_array_update_string(&return_value, SL("action"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_array_update_string(&return_value, SL("params"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); }
/** * Magic function so that $obj->value will work. * * @param string $name * @return mixed */ PHP_METHOD(Yaf_Session, __get) { zval *name_param = NULL, *result = NULL, *_0, *_1, *_SESSION; zval *name = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); zephir_get_strval(name, name_param); ZEPHIR_INIT_VAR(result); ZVAL_NULL(result); if (ZEPHIR_IS_STRING(name, "")) { RETURN_MM_NULL(); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("session"), PH_NOISY_CC); if (zephir_array_key_exists(_0, name TSRMLS_CC)) { _1 = zephir_fetch_nproperty_this(this_ptr, SL("session"), PH_NOISY_CC); ZEPHIR_OBS_NVAR(result); zephir_array_fetch(&result, _1, name, PH_NOISY, "yaf/session.zep", 81 TSRMLS_CC); } else { zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC); if (zephir_array_key_exists(_SESSION, name TSRMLS_CC)) { zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC); ZEPHIR_OBS_NVAR(result); zephir_array_fetch(&result, _SESSION, name, PH_NOISY, "yaf/session.zep", 85 TSRMLS_CC); } } RETURN_CCTOR(result); }
/** * Get the server variable SERVER_NAME * * @return string server name */ PHP_METHOD(Phady_Util_Tools, getServerName) { zend_bool _0; zval *server = NULL, *_SERVER, *_1; ZEPHIR_MM_GROW(); zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); ZEPHIR_INIT_VAR(server); ZVAL_STRING(server, "", 1); _0 = zephir_array_isset_string(_SERVER, SS("HTTP_X_FORWARDED_SERVER")); if (_0) { zephir_array_fetch_string(&_1, _SERVER, SL("HTTP_X_FORWARDED_SERVER"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 37 TSRMLS_CC); _0 = zephir_is_true(_1); } if (_0) { ZEPHIR_OBS_NVAR(server); zephir_array_fetch_string(&server, _SERVER, SL("HTTP_X_FORWARDED_SERVER"), PH_NOISY, "phady/util/tools.zep", 38 TSRMLS_CC); } else { ZEPHIR_OBS_NVAR(server); zephir_array_fetch_string(&server, _SERVER, SL("SERVER_NAME"), PH_NOISY, "phady/util/tools.zep", 40 TSRMLS_CC); } RETURN_CCTOR(server); }
/** * Serializing a resultset will dump all related rows into a big array */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, serialize) { zval *_1 = NULL, *_2 = NULL, *_3; zval *_0; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(_0); zephir_create_array(_0, 5, 0 TSRMLS_CC); ZEPHIR_OBS_VAR(_1); zephir_read_property_this(&_1, this_ptr, SL("_model"), PH_NOISY_CC); zephir_array_update_string(&_0, SL("model"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_1); zephir_read_property_this(&_1, this_ptr, SL("_cache"), PH_NOISY_CC); zephir_array_update_string(&_0, SL("cache"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(_3); ZVAL_BOOL(_3, 0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "toarray", NULL, 0, _3); zephir_check_call_status(); zephir_array_update_string(&_0, SL("rows"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_1); zephir_read_property_this(&_1, this_ptr, SL("_columnMap"), PH_NOISY_CC); zephir_array_update_string(&_0, SL("columnMap"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_1); zephir_read_property_this(&_1, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); zephir_array_update_string(&_0, SL("hydrateMode"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_RETURN_CALL_FUNCTION("serialize", NULL, 65, _0); zephir_check_call_status(); RETURN_MM(); }
/** * Adds a javascript resource to the collection * * @param string path * @param boolean local * @param boolean filter * @param array attributes * @return \Phalcon\Assets\Collection */ PHP_METHOD(Phalcon_Assets_Collection, addJs) { int ZEPHIR_LAST_CALL_STATUS; zend_bool filter; zval *path_param = NULL, *local = NULL, *filter_param = NULL, *attributes = NULL, *collectionLocal = NULL, *collectionAttributes = NULL, *_0, *_1; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 3, &path_param, &local, &filter_param, &attributes); if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(path_param) == IS_STRING)) { zephir_get_strval(path, path_param); } else { ZEPHIR_INIT_VAR(path); ZVAL_EMPTY_STRING(path); } if (!local) { local = ZEPHIR_GLOBAL(global_null); } if (!filter_param) { filter = 1; } else { filter = zephir_get_boolval(filter_param); } if (!attributes) { attributes = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(local) == IS_BOOL) { ZEPHIR_CPY_WRT(collectionLocal, local); } else { ZEPHIR_OBS_NVAR(collectionLocal); zephir_read_property_this(&collectionLocal, this_ptr, SL("_local"), PH_NOISY_CC); } if (Z_TYPE_P(attributes) == IS_ARRAY) { ZEPHIR_CPY_WRT(collectionAttributes, attributes); } else { ZEPHIR_OBS_NVAR(collectionAttributes); zephir_read_property_this(&collectionAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC); } ZEPHIR_INIT_VAR(_0); object_init_ex(_0, phalcon_assets_resource_js_ce); ZEPHIR_INIT_VAR(_1); if (filter) { ZVAL_BOOL(_1, 1); } else { ZVAL_BOOL(_1, 0); } ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 102, path, collectionLocal, _1, collectionAttributes); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("_resources"), _0 TSRMLS_CC); RETURN_THIS(); }
PHP_METHOD(Owl_Router_Router, match) { zend_bool _5, _7; int ZEPHIR_LAST_CALL_STATUS; HashTable *_2; HashPosition _1; zval *uri_param = NULL, *method_param = NULL, *router = NULL, *_0, **_3, *_4 = NULL, *_6 = NULL, *_8 = NULL; zval *uri = NULL, *method = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &uri_param, &method_param); zephir_get_strval(uri, uri_param); if (!method_param) { ZEPHIR_INIT_VAR(method); ZVAL_STRING(method, "GET", 1); } else { zephir_get_strval(method, method_param); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("routers"), PH_NOISY_CC); zephir_is_iterable(_0, &_2, &_1, 0, 0, "owl/Router/Router.zep", 56); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HVALUE(router, _3); ZEPHIR_CALL_METHOD(&_4, router, "match", NULL, 0, uri); zephir_check_call_status(); _5 = zephir_is_true(_4); if (_5) { ZEPHIR_OBS_NVAR(_6); zephir_read_property(&_6, router, SL("method"), PH_NOISY_CC); _7 = ZEPHIR_IS_LONG(_6, 7); if (!(_7)) { ZEPHIR_OBS_NVAR(_8); zephir_read_property(&_8, router, SL("method"), PH_NOISY_CC); _7 = ZEPHIR_IS_EQUAL(_8, method); } _5 = _7; } if (_5) { RETURN_CCTOR(router); } } RETURN_MM_BOOL(0); }
/** * @inheritdoc */ PHP_METHOD(Owl_Log_Formatter_Json, format) { int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_2 = NULL; zval *_0; zval *record, *_1 = NULL, *_3, *_4 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &record); ZEPHIR_INIT_VAR(_0); zephir_create_array(_0, 3, 0 TSRMLS_CC); ZEPHIR_OBS_VAR(_3); zephir_read_property(&_3, record, SL("level"), PH_NOISY_CC); ZEPHIR_CALL_CE_STATIC(&_1, owl_log_logger_ce, "getleveltitle", &_2, 18, _3); zephir_check_call_status(); zephir_array_update_string(&_0, SL("type"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_VAR(_4); zephir_read_property(&_4, record, SL("message"), PH_NOISY_CC); zephir_array_update_string(&_0, SL("message"), &_4, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(_4); zephir_read_property(&_4, record, SL("timestamp"), PH_NOISY_CC); zephir_array_update_string(&_0, SL("timestamp"), &_4, PH_COPY | PH_SEPARATE); zephir_json_encode(return_value, &(return_value), _0, 0 TSRMLS_CC); RETURN_MM(); }
/** * Filter records by levels */ PHP_METHOD(Owl_Log_AbstractWriter, filterRecords) { HashTable *_2; HashPosition _1; zval *records_param = NULL, *index = NULL, *record = NULL, *_0, **_3, *_4 = NULL, *_5; zval *records = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &records_param); zephir_get_arrval(records, records_param); ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("levels"), PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(_0)) { RETURN_CTOR(records); } zephir_is_iterable(records, &_2, &_1, 1, 0, "owl/Log/AbstractWriter.zep", 125); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(index, _2, _1); ZEPHIR_GET_HVALUE(record, _3); ZEPHIR_OBS_NVAR(_4); zephir_read_property(&_4, record, SL("level"), PH_NOISY_CC); _5 = zephir_fetch_nproperty_this(this_ptr, SL("levels"), PH_NOISY_CC); if (!(zephir_fast_in_array(_4, _5 TSRMLS_CC))) { zephir_array_unset(&records, index, PH_SEPARATE); } } RETURN_CTOR(records); }
/** * @param \Phal\Entity * @param array data * @return void */ PHP_METHOD(Phal_Format_Reader_Hal_JsonReader, transformMetadata) { int ZEPHIR_LAST_CALL_STATUS; zval *resource, *data, *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &resource, &data); if (!(zephir_instance_of_ev(resource, phal_entity_ce TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'resource' must be an instance of 'Phal\\Entity'", "", 0); return; } if (Z_TYPE_P(data) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "data must be array", "phal/format/reader/hal/jsonreader.zep", 43); return; } ZEPHIR_OBS_VAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("_links"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "transformlinks", NULL, resource, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("_embedded"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "transformembeddeds", NULL, resource, key); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); }
/** * Phalcon\Logger\Adapter\File constructor * * @param string name * @param array options */ PHP_METHOD(Phalcon_Logger_Adapter_File, __construct) { int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_0 = NULL, *_3 = NULL; zval *name_param = NULL, *options = NULL, *mode = NULL, *handler = NULL, *_1; zval *name = NULL, *_2; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &name_param, &options); if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(name_param) == IS_STRING)) { zephir_get_strval(name, name_param); } else { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } if (!options) { options = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(mode); ZVAL_NULL(mode); if (Z_TYPE_P(options) == IS_ARRAY) { ZEPHIR_OBS_NVAR(mode); if (zephir_array_isset_string_fetch(&mode, options, SS("mode"), 0 TSRMLS_CC)) { if (zephir_memnstr_str(mode, SL("r"), "phalcon/logger/adapter/file.zep", 72)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_logger_exception_ce, "Logger must be opened in append or write mode", "phalcon/logger/adapter/file.zep", 73); return; } } } if (Z_TYPE_P(mode) == IS_NULL) { ZEPHIR_INIT_NVAR(mode); ZVAL_STRING(mode, "ab", 1); } ZEPHIR_CALL_FUNCTION(&handler, "fopen", &_0, name, mode); zephir_check_call_status(); if (Z_TYPE_P(handler) != IS_RESOURCE) { ZEPHIR_INIT_VAR(_1); object_init_ex(_1, phalcon_logger_exception_ce); ZEPHIR_INIT_VAR(_2); ZEPHIR_CONCAT_SVS(_2, "Can't open log file at '", name, "'"); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", &_3, _2); zephir_check_call_status(); zephir_throw_exception_debug(_1, "phalcon/logger/adapter/file.zep", 87 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } zephir_update_property_this(this_ptr, SL("_path"), name TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_options"), options TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_fileHandler"), handler TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Adds a inline javascript to the collection */ PHP_METHOD(Phalcon_Assets_Collection, addInlineJs) { int ZEPHIR_LAST_CALL_STATUS; zend_bool filter; zval *content_param = NULL, *filter_param = NULL, *attributes = NULL, *collectionAttributes = NULL, *_0; zval *content = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &content_param, &filter_param, &attributes); zephir_get_strval(content, content_param); if (!filter_param) { filter = 1; } else { filter = zephir_get_boolval(filter_param); } if (!attributes) { attributes = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(attributes) == IS_ARRAY) { ZEPHIR_CPY_WRT(collectionAttributes, attributes); } else { ZEPHIR_OBS_NVAR(collectionAttributes); zephir_read_property_this(&collectionAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC); } ZEPHIR_INIT_VAR(_0); object_init_ex(_0, phalcon_assets_inline_js_ce); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 95, content, (filter ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)), collectionAttributes); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("_codes"), _0 TSRMLS_CC); RETURN_THIS(); }
/** * Returns the complete location where the resource is located */ PHP_METHOD(Phalcon_Assets_Resource, getRealSourcePath) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *basePath_param = NULL, *sourcePath = NULL, *_0, *_1$$4; zval *basePath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &basePath_param); if (!basePath_param) { ZEPHIR_INIT_VAR(basePath); ZVAL_EMPTY_STRING(basePath); } else { zephir_get_strval(basePath, basePath_param); } ZEPHIR_OBS_VAR(sourcePath); zephir_read_property_this(&sourcePath, this_ptr, SL("_sourcePath"), PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(sourcePath)) { ZEPHIR_OBS_NVAR(sourcePath); zephir_read_property_this(&sourcePath, this_ptr, SL("_path"), PH_NOISY_CC); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_local"), PH_NOISY_CC); if (zephir_is_true(_0)) { ZEPHIR_INIT_VAR(_1$$4); ZEPHIR_CONCAT_VV(_1$$4, basePath, sourcePath); ZEPHIR_RETURN_CALL_FUNCTION("realpath", NULL, 67, _1$$4); zephir_check_call_status(); RETURN_MM(); } RETURN_CCTOR(sourcePath); }
/** * Create a Phalcon\Cache based on the internal cache options */ PHP_METHOD(Phalcon_Mvc_View_Simple, _createCache) { int ZEPHIR_LAST_CALL_STATUS; zval *dependencyInjector, *cacheService = NULL, *cacheOptions, *viewCache = NULL, *_0 = NULL; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the view cache services", "phalcon/mvc/view/simple.zep", 478); return; } ZEPHIR_INIT_VAR(cacheService); ZVAL_STRING(cacheService, "viewCache", 1); ZEPHIR_OBS_VAR(cacheOptions); zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC); if (Z_TYPE_P(cacheOptions) == IS_ARRAY) { if (zephir_array_isset_string(cacheOptions, SS("service"))) { ZEPHIR_OBS_NVAR(cacheService); zephir_array_isset_string_fetch(&cacheService, cacheOptions, SS("service"), 0 TSRMLS_CC); } } ZEPHIR_CALL_METHOD(&_0, dependencyInjector, "getshared", NULL, 0, cacheService); zephir_check_call_status(); ZEPHIR_CPY_WRT(viewCache, _0); if (Z_TYPE_P(viewCache) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "The injected caching service is invalid", "phalcon/mvc/view/simple.zep", 495); return; } RETURN_CCTOR(viewCache); }
/** * Reads the ordered/reversed column map for certain model * *<code> * print_r($metaData->readColumnMap(new Robots())); *</code> */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMap) { int ZEPHIR_LAST_CALL_STATUS; zval *model, *keyName, *data = NULL, *_0, *_1, *_2, *_3, *_4; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &model); if (!(ZEPHIR_GLOBAL(orm).column_renaming)) { RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(keyName); zephir_get_class(keyName, model, 1 TSRMLS_CC); ZEPHIR_OBS_VAR(data); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC); if (!(zephir_array_isset_fetch(&data, _0, keyName, 0 TSRMLS_CC))) { ZEPHIR_INIT_VAR(_1); ZVAL_NULL(_1); ZEPHIR_INIT_VAR(_2); ZVAL_NULL(_2); ZEPHIR_INIT_VAR(_3); ZVAL_NULL(_3); ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, _1, _2, _3); zephir_check_call_status(); _4 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC); ZEPHIR_OBS_NVAR(data); zephir_array_fetch(&data, _4, keyName, PH_NOISY, "phalcon/mvc/model/metadata.zep", 329 TSRMLS_CC); } RETURN_CCTOR(data); }
PHP_METHOD(Test_Bench_Foo, read_static) { int _1; zend_bool _0; zval *n, *x = NULL, *i = NULL, *_2 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); ZEPHIR_CPY_WRT(_2, n); _1 = 1; _0 = 0; if (ZEPHIR_GE_LONG(_2, _1)) { while (1) { if (_0) { _1++; if (!(ZEPHIR_GE_LONG(_2, _1))) { break; } } else { _0 = 1; } ZEPHIR_INIT_NVAR(i); ZVAL_LONG(i, _1); ZEPHIR_OBS_NVAR(x); zephir_read_static_property_ce(&x, test_bench_foo_ce, SL("a") TSRMLS_CC); } } ZEPHIR_MM_RESTORE(); }
/** * Reads column-map information for certain model using a MODEL_* constant * *<code> * print_r( * $metaData->readColumnMapIndex( * new Robots(), * MetaData::MODELS_REVERSE_COLUMN_MAP * ) * ); *</code> */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMapIndex) { int index, ZEPHIR_LAST_CALL_STATUS; zval *model, *index_param = NULL, *keyName = NULL, *columnMapModel = NULL, *map = NULL, *_0, *_1$$4, *_2$$4, *_3$$4, *_4$$4; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &model, &index_param); index = zephir_get_intval(index_param); if (!(ZEPHIR_GLOBAL(orm).column_renaming)) { RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(keyName); zephir_get_class(keyName, model, 1 TSRMLS_CC); ZEPHIR_OBS_VAR(columnMapModel); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC); if (!(zephir_array_isset_fetch(&columnMapModel, _0, keyName, 0 TSRMLS_CC))) { ZEPHIR_INIT_VAR(_1$$4); ZVAL_NULL(_1$$4); ZEPHIR_INIT_VAR(_2$$4); ZVAL_NULL(_2$$4); ZEPHIR_INIT_VAR(_3$$4); ZVAL_NULL(_3$$4); ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 10, model, _1$$4, _2$$4, _3$$4); zephir_check_call_status(); _4$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC); ZEPHIR_OBS_NVAR(columnMapModel); zephir_array_fetch(&columnMapModel, _4$$4, keyName, PH_NOISY, "phalcon/mvc/model/metadata.zep", 378 TSRMLS_CC); } zephir_array_isset_long_fetch(&map, columnMapModel, index, 1 TSRMLS_CC); RETURN_CTOR(map); }
PHP_METHOD(Test_Oo_PropertyAccess, __construct) { zval *test, *test1, *_0, *_1, *_2, *_3, *_4, *_5, *_6, *_7 = NULL, *_8, *_9; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(test); object_init(test); ZEPHIR_INIT_VAR(_0); array_init_size(_0, 6); ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, 1); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_LONG(_1, 2); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_LONG(_1, 3); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_LONG(_1, 5); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_DOUBLE(_1, 6.00); zephir_array_fast_append(_0, _1); zephir_update_property_zval(test, SL("test"), _0 TSRMLS_CC); ZEPHIR_OBS_VAR(_2); zephir_read_property(&_2, test, SL("test"), PH_NOISY_CC); zephir_array_fetch_long(&_3, _2, 0, PH_NOISY | PH_READONLY TSRMLS_CC); zephir_update_property_zval(test, SL("test2"), _3 TSRMLS_CC); ZEPHIR_OBS_VAR(_4); zephir_read_property(&_4, test, SL("test"), PH_NOISY_CC); zephir_array_fetch_long(&_5, _4, 1, PH_NOISY | PH_READONLY TSRMLS_CC); zephir_update_property_zval(test, SL("test3"), _5 TSRMLS_CC); ZEPHIR_INIT_BNVAR(_1); array_init_size(_1, 5); ZEPHIR_OBS_VAR(_6); zephir_read_property(&_6, test, SL("test"), PH_NOISY_CC); ZEPHIR_OBS_VAR(_7); zephir_array_fetch_long(&_7, _6, 1, PH_NOISY TSRMLS_CC); zephir_array_fast_append(_1, _7); ZEPHIR_INIT_VAR(_8); ZVAL_LONG(_8, 1); zephir_array_fast_append(_1, _8); ZEPHIR_INIT_BNVAR(_8); ZVAL_LONG(_8, 2); zephir_array_fast_append(_1, _8); ZEPHIR_INIT_BNVAR(_8); ZVAL_LONG(_8, 3); zephir_array_fast_append(_1, _8); zephir_update_property_zval(test, SL("test3"), _1 TSRMLS_CC); zephir_update_property_this(this_ptr, SL("a"), test TSRMLS_CC); _9 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC); ZEPHIR_OBS_NVAR(_7); zephir_read_property(&_7, _9, SL("test2"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("b"), _7 TSRMLS_CC); test1 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC); ZEPHIR_MM_RESTORE(); }
PHP_METHOD(Test_Bench_Foo, empty_prop) { int _1; zend_bool x, _0; zval *n, *i = NULL, *_2 = NULL, *_3 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); ZEPHIR_CPY_WRT(_2, n); _1 = 1; _0 = 0; if (ZEPHIR_GE_LONG(_2, _1)) { while (1) { if (_0) { _1++; if (!(ZEPHIR_GE_LONG(_2, _1))) { break; } } else { _0 = 1; } ZEPHIR_INIT_NVAR(i); ZVAL_LONG(i, _1); ZEPHIR_OBS_NVAR(_3); zephir_read_property_this(&_3, this_ptr, SL("b"), PH_NOISY_CC); x = ZEPHIR_IS_EMPTY(_3); } } ZEPHIR_MM_RESTORE(); }
/** * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read * * @return string */ PHP_METHOD(Test_Router, getRewriteUri) { zval *url = NULL, *urlParts, *realUri, *_0, *_GET, *_SERVER; ZEPHIR_MM_GROW(); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_uriSource"), PH_NOISY_CC); if (!(zephir_is_true(_0))) { ZEPHIR_OBS_VAR(url); zephir_get_global(&_GET, SS("_GET") TSRMLS_CC); if (zephir_array_isset_string_fetch(&url, _GET, SS("_url"), 0 TSRMLS_CC)) { if (!(zephir_is_true(url))) { RETURN_CCTOR(url); } } } else { ZEPHIR_OBS_NVAR(url); zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); if (zephir_array_isset_string_fetch(&url, _SERVER, SS("REQUEST_URI"), 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(urlParts); zephir_fast_explode_str(urlParts, SL("?"), url, LONG_MAX TSRMLS_CC); zephir_array_fetch_long(&realUri, urlParts, 0, PH_NOISY | PH_READONLY TSRMLS_CC); if (!(zephir_is_true(realUri))) { RETURN_CTOR(realUri); } } } RETURN_MM_STRING("/", 1); }
/** * 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) { int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_0 = NULL; zval *descriptor = NULL, *dbname; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &descriptor); if (!descriptor) { ZEPHIR_CPY_WRT(descriptor, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(descriptor); } if (Z_TYPE_P(descriptor) == IS_NULL) { ZEPHIR_OBS_NVAR(descriptor); zephir_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC); } ZEPHIR_OBS_VAR(dbname); if (!(zephir_array_isset_string_fetch(&dbname, descriptor, SS("dbname"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "dbname must be specified", "phalcon/db/adapter/pdo/sqlite.zep", 70); return; } zephir_array_update_string(&descriptor, SL("dsn"), &dbname, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_PARENT(NULL, phalcon_db_adapter_pdo_sqlite_ce, this_ptr, "connect", &_0, 141, descriptor); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
PHP_METHOD(Test_Geometry, runOptimize) { zephir_fcall_cache_entry *_0 = NULL; int count, ZEPHIR_LAST_CALL_STATUS, i; zval *list_param = NULL, *count_param = NULL, *item = NULL, *_1$$3, *_2$$3, *_3$$3, *_4$$3; zval *list = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &list_param, &count_param); zephir_get_arrval(list, list_param); count = zephir_get_intval(count_param); i = 0; while (1) { if (!(i < count)) { break; } ZEPHIR_OBS_NVAR(item); zephir_array_fetch_long(&item, list, i, PH_NOISY, "test/geometry.zep", 22 TSRMLS_CC); zephir_array_fetch_long(&_1$$3, item, 0, PH_NOISY | PH_READONLY, "test/geometry.zep", 24 TSRMLS_CC); zephir_array_fetch_long(&_2$$3, item, 1, PH_NOISY | PH_READONLY, "test/geometry.zep", 24 TSRMLS_CC); zephir_array_fetch_long(&_3$$3, item, 2, PH_NOISY | PH_READONLY, "test/geometry.zep", 24 TSRMLS_CC); zephir_array_fetch_long(&_4$$3, item, 3, PH_NOISY | PH_READONLY, "test/geometry.zep", 24 TSRMLS_CC); ZEPHIR_CALL_STATIC(NULL, "distancestatic", &_0, 0, _1$$3, _2$$3, _3$$3, _4$$3); zephir_check_call_status(); i++; } ZEPHIR_MM_RESTORE(); }
/** * Gets number of rows returned by a resultset * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * echo 'There are ', $result->numRows(), ' rows in the resultset'; *</code> */ PHP_METHOD(Phalcon_Db_Result_Pdo, numRows) { zend_bool _0$$3; zval *sqlStatement = NULL, *rowCount = NULL, *connection = NULL, *type = NULL, *pdoStatement = NULL, *matches = NULL, *result = NULL, *row = NULL, *_1$$6, _2$$6, *_3$$7, *_4$$7, *_5$$7, *_6$$7; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(rowCount); zephir_read_property_this(&rowCount, this_ptr, SL("_rowCount"), PH_NOISY_CC); if (ZEPHIR_IS_FALSE_IDENTICAL(rowCount)) { ZEPHIR_OBS_VAR(connection); zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&type, connection, "gettype", NULL, 0); zephir_check_call_status(); _0$$3 = ZEPHIR_IS_STRING(type, "mysql"); if (!(_0$$3)) { _0$$3 = ZEPHIR_IS_STRING(type, "pgsql"); } if (_0$$3) { ZEPHIR_OBS_VAR(pdoStatement); zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&rowCount, pdoStatement, "rowcount", NULL, 0); zephir_check_call_status(); } if (ZEPHIR_IS_FALSE_IDENTICAL(rowCount)) { ZEPHIR_OBS_VAR(sqlStatement); zephir_read_property_this(&sqlStatement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC); if (!(zephir_start_with_str(sqlStatement, SL("SELECT COUNT(*) ")))) { ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); ZEPHIR_INIT_VAR(_1$$6); ZEPHIR_SINIT_VAR(_2$$6); ZVAL_STRING(&_2$$6, "/^SELECT\\s+(.*)/i", 0); zephir_preg_match(_1$$6, &_2$$6, sqlStatement, matches, 0, 0 , 0 TSRMLS_CC); if (zephir_is_true(_1$$6)) { zephir_array_fetch_long(&_3$$7, matches, 1, PH_NOISY | PH_READONLY, "phalcon/db/result/pdo.zep", 217 TSRMLS_CC); ZEPHIR_INIT_VAR(_4$$7); ZEPHIR_CONCAT_SVS(_4$$7, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", _3$$7, ")"); _5$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_bindParams"), PH_NOISY_CC); _6$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_bindTypes"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&result, connection, "query", NULL, 0, _4$$7, _5$$7, _6$$7); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&row, result, "fetch", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(rowCount); zephir_array_fetch_string(&rowCount, row, SL("numrows"), PH_NOISY, "phalcon/db/result/pdo.zep", 219 TSRMLS_CC); } } else { ZEPHIR_INIT_NVAR(rowCount); ZVAL_LONG(rowCount, 1); } } zephir_update_property_this(this_ptr, SL("_rowCount"), rowCount TSRMLS_CC); } RETURN_CCTOR(rowCount); }
PHP_METHOD(PocketMine_Math_Vector2, distanceSquared) { zephir_nts_static zephir_fcall_cache_entry *_5 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *x, *y = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, _3 = zval_used_for_init, _4 = zval_used_for_init, *_6 = NULL, *_7; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &x, &y); if (!y) { ZEPHIR_INIT_VAR(y); ZVAL_LONG(y, 0); } if (zephir_instance_of_ev(x, pocketmine_math_vector2_ce TSRMLS_CC)) { ZEPHIR_OBS_VAR(_1); zephir_read_property(&_1, x, SL("x"), PH_NOISY_CC); ZEPHIR_OBS_VAR(_2); zephir_read_property(&_2, x, SL("y"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_0, this_ptr, "distancesquared", NULL, _1, _2); zephir_check_call_status(); RETURN_MM_DOUBLE(zephir_get_doubleval(_0)); } ZEPHIR_OBS_NVAR(_1); zephir_read_property_this(&_1, this_ptr, SL("x"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_3); ZVAL_DOUBLE(&_3, (zephir_get_doubleval(_1) - zephir_get_doubleval(x))); ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, 2); ZEPHIR_CALL_FUNCTION(&_0, "pow", &_5, &_3, &_4); zephir_check_call_status(); ZEPHIR_OBS_NVAR(_2); zephir_read_property_this(&_2, this_ptr, SL("y"), PH_NOISY_CC); ZEPHIR_SINIT_NVAR(_3); ZVAL_DOUBLE(&_3, (zephir_get_doubleval(_2) - zephir_get_doubleval(y))); ZEPHIR_SINIT_NVAR(_4); ZVAL_LONG(&_4, 2); ZEPHIR_CALL_FUNCTION(&_6, "pow", &_5, &_3, &_4); zephir_check_call_status(); ZEPHIR_INIT_VAR(_7); zephir_add_function(_7, _0, _6 TSRMLS_CC); RETURN_MM_DOUBLE(zephir_get_doubleval(_7)); }
/** * @param array data * @return \Phal\Link */ PHP_METHOD(Phal_Format_Reader_Hal_JsonReader, doTransformLink) { int ZEPHIR_LAST_CALL_STATUS; zval *data_param = NULL, *link, *key = NULL; zval *data = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &data_param); zephir_get_arrval(data, data_param); ZEPHIR_INIT_VAR(link); object_init_ex(link, phal_link_ce); ZEPHIR_CALL_METHOD(NULL, link, "__construct", NULL); zephir_check_call_status(); ZEPHIR_OBS_VAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("href"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "sethref", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("templated"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "settemplated", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("type"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "settype", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("deprecation"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "setdeprecation", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("name"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "setname", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("profile"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "setprofile", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("title"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "settitle", NULL, key); zephir_check_call_status(); } ZEPHIR_OBS_NVAR(key); if (zephir_array_isset_string_fetch(&key, data, SS("hreflang"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, link, "sethreflang", NULL, key); zephir_check_call_status(); } RETURN_CCTOR(link); }
/** * Load translates from file * * @param string file * @param int length * @param string delimiter * @param string enclosure */ PHP_METHOD(Phalcon_Translate_Adapter_Csv, _load) { zend_bool _6; zephir_fcall_cache_entry *_3 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *file, *length, *delimiter, *enclosure, *data = NULL, *fileHandler = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_4, _5 = zval_used_for_init, *_7, *_8 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &file, &length, &delimiter, &enclosure); ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "rb", 0); ZEPHIR_CALL_FUNCTION(&fileHandler, "fopen", NULL, 292, file, &_0); zephir_check_call_status(); if (Z_TYPE_P(fileHandler) != IS_RESOURCE) { ZEPHIR_INIT_VAR(_1); object_init_ex(_1, phalcon_translate_exception_ce); ZEPHIR_INIT_VAR(_2); ZEPHIR_CONCAT_SVS(_2, "Error opening translation file '", file, "'"); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2); zephir_check_call_status(); zephir_throw_exception_debug(_1, "phalcon/translate/adapter/csv.zep", 64 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } while (1) { ZEPHIR_CALL_FUNCTION(&data, "fgetcsv", &_3, 428, fileHandler, length, delimiter, enclosure); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(data)) { break; } zephir_array_fetch_long(&_4, data, 0, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 74 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, 0); ZEPHIR_SINIT_NVAR(_5); ZVAL_LONG(&_5, 1); ZEPHIR_INIT_NVAR(_1); zephir_substr(_1, _4, 0 , 1 , 0); _6 = ZEPHIR_IS_STRING_IDENTICAL(_1, "#"); if (!(_6)) { _6 = !(zephir_array_isset_long(data, 1)); } if (_6) { continue; } zephir_array_fetch_long(&_7, data, 1, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC); ZEPHIR_OBS_NVAR(_8); zephir_array_fetch_long(&_8, data, 0, PH_NOISY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC); zephir_update_property_array(this_ptr, SL("_translate"), _8, _7 TSRMLS_CC); } zephir_fclose(fileHandler TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Generate the HTML to label the element * * @param array attributes */ PHP_METHOD(Phalcon_Forms_Element, label) { zend_bool _2; zephir_fcall_cache_entry *_0 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *attributes = NULL, *internalAttributes = NULL, *label = NULL, *name = NULL, *code = NULL, *_1, *_3$$7, *_4$$8; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &attributes); if (!attributes) { ZEPHIR_CPY_WRT(attributes, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(attributes); } ZEPHIR_CALL_METHOD(&internalAttributes, this_ptr, "getattributes", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_VAR(name); if (!(zephir_array_isset_string_fetch(&name, internalAttributes, SS("id"), 0 TSRMLS_CC))) { ZEPHIR_OBS_NVAR(name); zephir_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); } if (Z_TYPE_P(attributes) == IS_ARRAY) { if (!(zephir_array_isset_string(attributes, SS("for")))) { zephir_array_update_string(&attributes, SL("for"), &name, PH_COPY | PH_SEPARATE); } } else { ZEPHIR_INIT_NVAR(attributes); zephir_create_array(attributes, 1, 0 TSRMLS_CC); zephir_array_update_string(&attributes, SL("for"), &name, PH_COPY | PH_SEPARATE); } ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "<label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_CE_STATIC(&code, phalcon_tag_ce, "renderattributes", &_0, 4, _1, attributes); zephir_check_temp_parameter(_1); zephir_check_call_status(); ZEPHIR_OBS_VAR(label); zephir_read_property_this(&label, this_ptr, SL("_label"), PH_NOISY_CC); _2 = zephir_is_true(label); if (!(_2)) { _2 = zephir_is_numeric(label); } if (_2) { ZEPHIR_INIT_VAR(_3$$7); ZEPHIR_CONCAT_SVS(_3$$7, ">", label, "</label>"); zephir_concat_self(&code, _3$$7 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_4$$8); ZEPHIR_CONCAT_SVS(_4$$8, ">", name, "</label>"); zephir_concat_self(&code, _4$$8 TSRMLS_CC); } RETURN_CCTOR(code); }
/** * Returns the content of the resource as an string * Optionally a base path where the resource is located can be set */ PHP_METHOD(Phalcon_Assets_Resource, getContent) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *basePath_param = NULL, *sourcePath = NULL, *completePath = NULL, *content = NULL, *_0, *_1$$5, *_2$$5, *_3$$6, *_4$$6; zval *basePath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &basePath_param); if (!basePath_param) { ZEPHIR_INIT_VAR(basePath); ZVAL_EMPTY_STRING(basePath); } else { zephir_get_strval(basePath, basePath_param); } ZEPHIR_OBS_VAR(sourcePath); zephir_read_property_this(&sourcePath, this_ptr, SL("_sourcePath"), PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(sourcePath)) { ZEPHIR_OBS_NVAR(sourcePath); zephir_read_property_this(&sourcePath, this_ptr, SL("_path"), PH_NOISY_CC); } ZEPHIR_INIT_VAR(completePath); ZEPHIR_CONCAT_VV(completePath, basePath, sourcePath); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_local"), PH_NOISY_CC); if (zephir_is_true(_0)) { if (!((zephir_file_exists(completePath TSRMLS_CC) == SUCCESS))) { ZEPHIR_INIT_VAR(_1$$5); object_init_ex(_1$$5, phalcon_assets_exception_ce); ZEPHIR_INIT_VAR(_2$$5); ZEPHIR_CONCAT_SVS(_2$$5, "Resource's content for '", completePath, "' cannot be read"); ZEPHIR_CALL_METHOD(NULL, _1$$5, "__construct", NULL, 9, _2$$5); zephir_check_call_status(); zephir_throw_exception_debug(_1$$5, "phalcon/assets/resource.zep", 183 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } ZEPHIR_INIT_VAR(content); zephir_file_get_contents(content, completePath TSRMLS_CC); if (ZEPHIR_IS_FALSE_IDENTICAL(content)) { ZEPHIR_INIT_VAR(_3$$6); object_init_ex(_3$$6, phalcon_assets_exception_ce); ZEPHIR_INIT_VAR(_4$$6); ZEPHIR_CONCAT_SVS(_4$$6, "Resource's content for '", completePath, "' cannot be read"); ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6); zephir_check_call_status(); zephir_throw_exception_debug(_3$$6, "phalcon/assets/resource.zep", 192 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } RETURN_CCTOR(content); }
PHP_METHOD(Yb_Std, uniqueValues) { HashTable *_1; HashPosition _0; zephir_fcall_cache_entry *_5 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *uniqueKey = NULL; zval *data_param = NULL, *uniqueKey_param = NULL, *k = NULL, *v = NULL, *arr = NULL, *uniqueValue = NULL, **_2, *_3$$4 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_7$$5 = NULL; zval *data = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &data_param, &uniqueKey_param); zephir_get_arrval(data, data_param); zephir_get_strval(uniqueKey, uniqueKey_param); ZEPHIR_INIT_VAR(arr); array_init(arr); zephir_is_iterable(data, &_1, &_0, 0, 0, "yb/std.zep", 377); for ( ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS ; zephir_hash_move_forward_ex(_1, &_0) ) { ZEPHIR_GET_HMKEY(k, _1, _0); ZEPHIR_GET_HVALUE(v, _2); if (unlikely(Z_TYPE_P(v) != IS_ARRAY)) { ZEPHIR_INIT_NVAR(_3$$4); object_init_ex(_3$$4, yb_exception_ce); ZEPHIR_INIT_LNVAR(_4$$4); ZEPHIR_CONCAT_SV(_4$$4, "Invalid item type, array required at: ", k); ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", &_5, 2, _4$$4); zephir_check_call_status(); zephir_throw_exception_debug(_3$$4, "yb/std.zep", 368 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_NVAR(uniqueValue); if (unlikely(!(zephir_array_isset_fetch(&uniqueValue, v, uniqueKey, 0 TSRMLS_CC)))) { ZEPHIR_INIT_NVAR(_6$$5); object_init_ex(_6$$5, yb_exception_ce); ZEPHIR_INIT_LNVAR(_7$$5); ZEPHIR_CONCAT_SV(_7$$5, "Cannot find value of unique at: ", k); ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", &_5, 2, _7$$5); zephir_check_call_status(); zephir_throw_exception_debug(_6$$5, "yb/std.zep", 371 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } zephir_array_update_zval(&arr, uniqueValue, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE); } zephir_array_keys(return_value, arr TSRMLS_CC); RETURN_MM(); }
/** * Returns a cached content */ PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, get) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *keyName_param = NULL, *lifetime = NULL, lifetime_sub, __$null, memcache, prefixedKey, cachedContent, _0, _1, _2; zval keyName; zval *this_ptr = getThis(); ZVAL_UNDEF(&keyName); ZVAL_UNDEF(&lifetime_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&memcache); ZVAL_UNDEF(&prefixedKey); ZVAL_UNDEF(&cachedContent); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime); zephir_get_strval(&keyName, keyName_param); if (!lifetime) { lifetime = &lifetime_sub; lifetime = &__$null; } ZEPHIR_OBS_VAR(&memcache); zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); if (Z_TYPE_P(&memcache) != IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&memcache); zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); } zephir_read_property(&_0, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&prefixedKey); ZEPHIR_CONCAT_VV(&prefixedKey, &_0, &keyName); zephir_update_property_zval(this_ptr, SL("_lastKey"), &prefixedKey); ZEPHIR_CALL_METHOD(&cachedContent, &memcache, "get", NULL, 0, &prefixedKey); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, &memcache, "getresultcode", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 16)) { RETURN_MM_NULL(); } if (zephir_is_numeric(&cachedContent)) { RETURN_CCTOR(&cachedContent); } zephir_read_property(&_2, this_ptr, SL("_frontend"), PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "afterretrieve", NULL, 0, &cachedContent); zephir_check_call_status(); RETURN_MM(); }