/**
* Phalcon\Flash constructor
*
* @param array $cssClasses
*/
PHP_METHOD(Phalcon_Flash, __construct){
zval *css_classes = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &css_classes);
if (!css_classes) {
PHALCON_INIT_VAR(css_classes);
} else {
PHALCON_SEPARATE_PARAM(css_classes);
}
if (Z_TYPE_P(css_classes) != IS_ARRAY) {
PHALCON_INIT_NVAR(css_classes);
array_init_size(css_classes, 4);
add_assoc_stringl_ex(css_classes, SS("error"), SL("errorMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("notice"), SL("noticeMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("success"), SL("successMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("warning"), SL("warningMessage"), 1);
}
phalcon_update_property_this(this_ptr, SL("_cssClasses"), css_classes TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Flash constructor
*
* @param array $cssClasses
*/
PHP_METHOD(Phalcon_Flash, __construct){
zval *css_classes = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &css_classes) == FAILURE) {
RETURN_MM_NULL();
}
if (!css_classes) {
PHALCON_INIT_VAR(css_classes);
} else {
PHALCON_SEPARATE_PARAM(css_classes);
}
if (Z_TYPE_P(css_classes) != IS_ARRAY) {
PHALCON_INIT_NVAR(css_classes);
array_init_size(css_classes, 4);
add_assoc_stringl_ex(css_classes, SS("error"), SL("errorMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("notice"), SL("noticeMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("success"), SL("successMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("warning"), SL("warningMessage"), 1);
}
phalcon_update_property_zval(this_ptr, SL("_cssClasses"), css_classes TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Flash constructor
*/
PHP_METHOD(Phalcon_Flash, __construct) {
zval *cssClasses = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &cssClasses);
if (!cssClasses) {
ZEPHIR_CPY_WRT(cssClasses, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(cssClasses);
}
if (Z_TYPE_P(cssClasses) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(cssClasses);
zephir_create_array(cssClasses, 4, 0 TSRMLS_CC);
add_assoc_stringl_ex(cssClasses, SS("error"), SL("errorMessage"), 1);
add_assoc_stringl_ex(cssClasses, SS("notice"), SL("noticeMessage"), 1);
add_assoc_stringl_ex(cssClasses, SS("success"), SL("successMessage"), 1);
add_assoc_stringl_ex(cssClasses, SS("warning"), SL("warningMessage"), 1);
}
zephir_update_property_this(this_ptr, SL("_cssClasses"), cssClasses TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Phalcon_Mvc_Router, __construct){
zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
zend_update_property(phalcon_mvc_router_ce, this_ptr, SL("_params"), a0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(a1);
array_init(a1);
PHALCON_ALLOC_ZVAL_MM(a2);
array_init(a2);
add_assoc_stringl_ex(a2, SL("pattern")+1, SL("#^/([a-zA-Z0-9\\_]+)[/]{0,1}$#"), 1);
PHALCON_ALLOC_ZVAL_MM(a3);
array_init(a3);
add_assoc_long_ex(a3, SL("controller")+1, 1);
phalcon_array_update_string(&a2, SL("paths"), &a3, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&a1, a2, PH_SEPARATE TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(a4);
array_init(a4);
add_assoc_stringl_ex(a4, SL("pattern")+1, SL("#^/([a-zA-Z0-9\\_]+)/([a-zA-Z0-9\\_]+)(/.*)*$#"), 1);
PHALCON_ALLOC_ZVAL_MM(a5);
array_init(a5);
add_assoc_long_ex(a5, SL("controller")+1, 1);
add_assoc_long_ex(a5, SL("action")+1, 2);
add_assoc_long_ex(a5, SL("params")+1, 3);
phalcon_array_update_string(&a4, SL("paths"), &a5, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&a1, a4, PH_SEPARATE TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_routes"), a1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* 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);
}
PHP_METHOD(Test_NativeArray, testArray18) {
zval *a;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(a);
array_init_size(a, 5);
add_assoc_stringl_ex(a, SS("hello1"), SL("a"), 1);
add_assoc_stringl_ex(a, SS("hello2"), SL("b"), 1);
add_assoc_stringl_ex(a, SS("hello3"), SL("c"), 1);
RETURN_CCTOR(a);
}
PHP_METHOD(Test_Json, testEncodeObject) {
zval *obj;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(obj);
array_init_size(obj, 5);
add_assoc_stringl_ex(obj, SS("a"), SL("hello"), 1);
add_assoc_stringl_ex(obj, SS("b"), SL("world"), 1);
add_assoc_long_ex(obj, SS("c"), 128);
zephir_json_encode(return_value, &(return_value), obj, 0 TSRMLS_CC);
RETURN_MM();
}
zval* air_arr_del_index_el(zval *arr) {
HashTable *ht = Z_ARRVAL_P(arr);
zval *tmp;
MAKE_STD_ZVAL(tmp);
array_init(tmp);
for(
zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_forward(ht)
){
int type;
ulong idx;
char *key;
uint key_len;
zval **tmp_data;
type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL);
if(type == HASH_KEY_IS_STRING){
if(zend_hash_get_current_data(ht, (void**)&tmp_data) != FAILURE) {
add_assoc_stringl_ex(tmp, key, key_len, Z_STRVAL_PP(tmp_data), Z_STRLEN_PP(tmp_data), 1);
}
}
}
return tmp;
}
/**
* Generates a link to the current version documentation
*/
PHP_METHOD(Phalcon_Debug, getVersion) {
zval *link = NULL, *_0 = NULL, *_2, *_3, *_4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_6 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(link);
zephir_create_array(link, 4, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_CALL_CE_STATIC(&_0, phalcon_version_ce, "getpart", &_1, 161, _2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SVS(_3, "https://docs.phalconphp.com/en/", _0, ".0.0/");
zephir_array_update_string(&link, SL("action"), &_3, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_CE_STATIC(&_4, phalcon_version_ce, "get", &_5, 160);
zephir_check_call_status();
zephir_array_update_string(&link, SL("text"), &_4, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&link, SL("local"), &ZEPHIR_GLOBAL(global_false), PH_COPY | PH_SEPARATE);
add_assoc_stringl_ex(link, SS("target"), SL("_new"), 1);
ZEPHIR_CALL_CE_STATIC(&_4, phalcon_tag_ce, "linkto", &_6, 162, link);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "<div class='version'>Phalcon Framework ", _4, "</div>");
RETURN_MM();
}
/* {{{ php_foreach_cat
*/
static int php_foreach_cat (int instatus, char *inkey, int inkeylen, char *inval, int invallen, char *indata)
{
int err;
err = ypprot_err (instatus);
if (!err)
{
if (inkeylen) {
char *key = emalloc(inkeylen+1);
strlcpy(key, inkey, inkeylen+1);
add_assoc_stringl_ex((zval *) indata, key, inkeylen+1, inval, invallen, 1);
efree(key);
}
return 0;
}
if (err != YPERR_NOMORE)
{
TSRMLS_FETCH();
YP(error) = err;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (err));
}
return 0;
}
static int httpparser_assign(char *type, int type_len, http_parser *p, const char *buf, size_t len)
{
httpParserObj * Parser;
Parser = (httpParserObj *)p->data;
add_assoc_stringl_ex(Parser->variable, type, type_len, buf, len, 1);
return 0;
}
/** {{{ int yaf_response_alter_header(yaf_response_t *response, char *name, uint name_len, char *value, long value_len, int flag TSRMLS_DC)
*/
int yaf_response_alter_header(yaf_response_t *response, char *name, uint name_len, char *value, long value_len, uint rep TSRMLS_DC) {
zval *z_headers, **ppzval;
char *oheader;
if (!name_len) {
return 1;
}
z_headers = zend_read_property(yaf_response_ce, response, ZEND_STRL(YAF_RESPONSE_PROPERTY_NAME_HEADER), 1 TSRMLS_CC);
if (zend_hash_find(Z_ARRVAL_P(z_headers), name, name_len + 1, (void **)&ppzval) == FAILURE) {
add_assoc_stringl_ex(z_headers, name, name_len + 1, value, value_len, 1);
return 1;
}
oheader = Z_STRVAL_PP(ppzval);
if (rep) {
ZVAL_STRINGL(*ppzval, value, value_len, 1);
} else {
Z_STRLEN_PP(ppzval) = spprintf(&Z_STRVAL_PP(ppzval), 0, "%s, %s", oheader, value);
}
efree(oheader);
return 1;
}
PHP_METHOD(Test_NativeArray, testArray18) {
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(&a, SL("hello1"), SL("a"));
add_assoc_stringl_ex(&a, SL("hello2"), SL("b"));
add_assoc_stringl_ex(&a, SL("hello3"), SL("c"));
RETURN_CCTOR(&a);
}
PHP_METHOD(Test_Issue1521, test) {
zval _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&_0);
zephir_create_array(&_0, 2, 0 TSRMLS_CC);
add_assoc_stringl_ex(&_0, SL("merchantNumber"), SL("0818217122"));
add_assoc_stringl_ex(&_0, SL("zero"), SL("0"));
zephir_update_property_zval(this_ptr, SL("params"), &_0);
RETURN_MM_MEMBER(getThis(), "params");
}
/**
* Gets default options
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, getOptionsDefault) {
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
add_assoc_long_ex(return_value, SS("category"), 0);
add_assoc_stringl_ex(return_value, SS("defaultDomain"), SL("message"), 1);
return;
}
ZEND_RESULT_CODE air_router_route_apply_subpats(zval *r, zval *subpats, char *key, int key_len, char *ro, int ro_len) {
zval *tmp_val = air_arr_find(r, key, key_len);
if(tmp_val){
char *tmp = Z_STRVAL_P(tmp_val);
if(tmp[0] == '$'){
tmp_val = air_arr_find(subpats, tmp+1, strlen(tmp));
if(tmp_val){
add_assoc_stringl_ex(subpats, key, key_len, Z_STRVAL_P(tmp_val), Z_STRLEN_P(tmp_val), 1);
}else{
php_error(E_NOTICE, "ref name '%s' not found in route rule '%s', and 'index' will be set instead,", tmp, ro TSRMLS_CC);
add_assoc_stringl_ex(subpats, key, key_len, ZEND_STRL("index"), 1);
}
}else{
add_assoc_stringl_ex(subpats, key, key_len, Z_STRVAL_P(tmp_val), Z_STRLEN_P(tmp_val), 1);
}
return SUCCESS;
}
return FAILURE;
}
PHP_METHOD(Test_Properties_PublicProperties, __construct) {
zval *_1, *_2 = NULL, *_3;
zval *_0, *_4 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_update_property_this(this_ptr, SL("someGetterSetterArray"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 4, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_2, SS("class"), SL("alert alert-success"), 1);
zephir_array_update_string(&_1, SL("success"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_2, SS("class"), SL("alert alert-info"), 1);
zephir_array_update_string(&_1, SL("info"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_2, SS("class"), SL("alert alert-warning"), 1);
zephir_array_update_string(&_1, SL("warning"), &_2, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_2, SS("class"), SL("alert alert-danger"), 1);
zephir_array_update_string(&_1, SL("danger"), &_2, PH_COPY | PH_SEPARATE);
zephir_update_property_this(this_ptr, SL("someArrayWithSubArray"), _1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(_2, SS("a"), SL("A"), 1);
add_assoc_stringl_ex(_2, SS("b"), SL("B"), 1);
add_assoc_stringl_ex(_2, SS("c"), SL("C"), 1);
zephir_update_property_this(this_ptr, SL("someArrayWithSpecifyKeys"), _2 TSRMLS_CC);
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 4, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, 1);
zephir_array_fast_append(_3, _4);
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, 2);
zephir_array_fast_append(_3, _4);
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, 3);
zephir_array_fast_append(_3, _4);
ZEPHIR_INIT_NVAR(_4);
ZVAL_LONG(_4, 4);
zephir_array_fast_append(_3, _4);
zephir_update_property_this(this_ptr, SL("someArray"), _3 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_4);
array_init(_4);
zephir_update_property_this(this_ptr, SL("someEmptyArray"), _4 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
void air_config_init_default(TSRMLS_D){
zval *_data = NULL;
MAKE_STD_ZVAL(_data);
array_init(_data);
zval *app = NULL;
MAKE_STD_ZVAL(app);
array_init(app);
add_assoc_stringl_ex(app, ZEND_STRS("path"), ZEND_STRL("app"), 1);
zval *exec;
MAKE_STD_ZVAL(exec);
array_init(exec);
add_assoc_stringl_ex(exec, ZEND_STRS("path"), ZEND_STRL("exec"), 1);
add_assoc_zval_ex(app, ZEND_STRS("exec"), exec);
zval *site;
MAKE_STD_ZVAL(site);
array_init(site);
add_assoc_stringl_ex(site, ZEND_STRS("path"), ZEND_STRL("site"), 1);
add_assoc_zval_ex(app, ZEND_STRS("site"), site);
zval *view;
MAKE_STD_ZVAL(view);
array_init(view);
add_assoc_stringl_ex(view, ZEND_STRS("engine"), ZEND_STRL("air\\view"), 1);
add_assoc_stringl_ex(view, ZEND_STRS("path"), ZEND_STRL("view"), 1);
add_assoc_stringl_ex(view, ZEND_STRS("type"), ZEND_STRL(".php"), 1);
add_assoc_zval_ex(app, ZEND_STRS("view"), view);
add_assoc_zval_ex(_data, ZEND_STRS("app"), app);
zend_update_static_property(air_config_ce, ZEND_STRL("_data"), _data TSRMLS_CC);
zval_ptr_dtor(&_data);
}
PHP_METHOD(Test_IssetTest, __construct) {
zval *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_0, SS("a"), SL("true"), 1);
zephir_update_property_this(this_ptr, SL("s"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(phady_8__closure, __invoke) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_0;
zval *flash;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(flash);
object_init_ex(flash, phalcon_flash_session_ce);
if (zephir_has_constructor(flash TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(_0, SS("error"), SL("alert alert-danger"), 1);
add_assoc_stringl_ex(_0, SS("success"), SL("alert alert-success"), 1);
add_assoc_stringl_ex(_0, SS("notice"), SL("alert alert-info"), 1);
ZEPHIR_CALL_METHOD(NULL, flash, "__construct", NULL, 0, _0);
zephir_check_call_status();
}
RETURN_CCTOR(flash);
}
/**
* Phalcon\Cache\Backend\Memcache constructor
*
* @param array options
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, __construct) {
zval _0$$4;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_2 = NULL;
zval *frontend, frontend_sub, *options = NULL, options_sub, __$null, servers, _1$$5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&frontend_sub);
ZVAL_UNDEF(&options_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&servers);
ZVAL_UNDEF(&_1$$5);
ZVAL_UNDEF(&_0$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &frontend, &options);
if (!options) {
options = &options_sub;
ZEPHIR_CPY_WRT(options, &__$null);
} else {
ZEPHIR_SEPARATE_PARAM(options);
}
if (Z_TYPE_P(options) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
if (!(zephir_array_isset_string(options, SL("servers")))) {
ZEPHIR_INIT_VAR(&servers);
zephir_create_array(&servers, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_0$$4);
zephir_create_array(&_0$$4, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(&_0$$4, SL("host"), SL("127.0.0.1"));
add_assoc_long_ex(&_0$$4, SL("port"), 11211);
add_assoc_long_ex(&_0$$4, SL("weight"), 1);
zephir_array_update_long(&servers, 0, &_0$$4, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_string(options, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
}
if (!(zephir_array_isset_string(options, SL("statsKey")))) {
ZEPHIR_INIT_VAR(&_1$$5);
ZVAL_STRING(&_1$$5, "");
zephir_array_update_string(options, SL("statsKey"), &_1$$5, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_cache_backend_libmemcached_ce, getThis(), "__construct", &_2, 0, frontend, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_NativeArray, testArray30) {
zval *b;
zval *a;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(b);
ZVAL_STRING(b, "hello", 1);
ZEPHIR_INIT_VAR(a);
array_init_size(a, 2);
add_assoc_stringl_ex(a, Z_STRVAL_P(b), Z_STRLEN_P(b) + 1, SL("hello"), 1);
RETURN_CCTOR(a);
}
PHP_COUCHBASE_LOCAL
void pcbc_ht_hkstores(zval *assoc, pcbc_ht_key *hk,
const char *value, int nvalue)
{
const char *zh_key;
int zh_nkey;
ISARRAY_SANITY(assoc);
if (nvalue == -1) {
nvalue = strlen(value);
}
HK_STRING(hk, zh_key, zh_nkey);
/* value is duplicated, so it's sane to cast to char */
add_assoc_stringl_ex(assoc, zh_key, zh_nkey, (char *)value, nvalue, 1);
}
/**
* Phalcon\Assets\Inline\Css
*
* @param string content
* @param boolean filter
* @param array attributes
*/
PHP_METHOD(Phalcon_Assets_Inline_Css, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zend_bool filter;
zval *content_param = NULL, *filter_param = NULL, *attributes = NULL, *_1, *_2;
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) {
ZEPHIR_CPY_WRT(attributes, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(attributes);
}
if (Z_TYPE_P(attributes) == IS_NULL) {
ZEPHIR_INIT_NVAR(attributes);
zephir_create_array(attributes, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(attributes, SS("type"), SL("text/css"), 1);
}
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "css", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
if (filter) {
ZVAL_BOOL(_2, 1);
} else {
ZVAL_BOOL(_2, 0);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_assets_inline_css_ce, this_ptr, "__construct", &_0, 104, _1, content, _2, attributes);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_NativeArray, testArray30) {
zval b;
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&b);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&b);
ZVAL_STRING(&b, "hello");
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(&a, Z_STRVAL_P(&b), Z_STRLEN_P(&b), SL("hello"));
RETURN_CCTOR(&a);
}
PHP_METHOD(PhalconPlus_Db_UnitOfWork, update) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool assign, _0;
zval *initial_data = NULL, *_1;
zval *name, *model, *initial_data_param = NULL, *assign_param = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 2, &name, &model, &initial_data_param, &assign_param);
if (!initial_data_param) {
ZEPHIR_INIT_VAR(initial_data);
array_init(initial_data);
} else {
zephir_get_arrval(initial_data, initial_data_param);
}
if (!assign_param) {
assign = 1;
} else {
assign = zephir_get_boolval(assign_param);
}
_0 = !(ZEPHIR_IS_EMPTY(initial_data));
if (_0) {
_0 = assign == 1;
}
if (_0) {
ZEPHIR_CALL_METHOD(NULL, model, "assign", NULL, 0, initial_data);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "detach", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 3, 0 TSRMLS_CC);
add_assoc_stringl_ex(_1, SS("method"), SL("update"), 1);
zephir_array_update_string(&_1, SL("name"), &name, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_1, SL("initial_data"), &initial_data, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "attach", NULL, 0, model, _1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Owl_Http_Response_Json, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_1;
zval *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, owl_std_arraybag_ce);
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_1, SS("Content-Type"), SL("application/json"), 1);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 3, _1);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("headers"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
FOREACH_KEYVAL(pos, param, key, entry) {
if (key.type == HASH_KEY_IS_STRING) {
if (PHP_ICONV_ERR_SUCCESS != php_iconv_string(key.str, key.len-1, &xkey, &xlen, oe, ie)) {
http_error_ex(HE_WARNING, HTTP_E_QUERYSTRING, "Failed to convert '%.*s' from '%s' to '%s'", key.len-1, key.str, ie, oe);
return FAILURE;
}
}
if (Z_TYPE_PP(entry) == IS_STRING) {
if (PHP_ICONV_ERR_SUCCESS != php_iconv_string(Z_STRVAL_PP(entry), Z_STRLEN_PP(entry), &xlate_str, &xlate_len, oe, ie)) {
if (key.type == HASH_KEY_IS_STRING) {
efree(xkey);
}
http_error_ex(HE_WARNING, HTTP_E_QUERYSTRING, "Failed to convert '%.*s' from '%s' to '%s'", Z_STRLEN_PP(entry), Z_STRVAL_PP(entry), ie, oe);
return FAILURE;
}
if (key.type == HASH_KEY_IS_STRING) {
add_assoc_stringl_ex(array, xkey, xlen+1, xlate_str, xlate_len, 0);
} else {
add_index_stringl(array, key.num, xlate_str, xlate_len, 0);
}
} else if (Z_TYPE_PP(entry) == IS_ARRAY) {
zval *subarray;
MAKE_STD_ZVAL(subarray);
array_init(subarray);
if (key.type == HASH_KEY_IS_STRING) {
add_assoc_zval_ex(array, xkey, xlen+1, subarray);
} else {
add_index_zval(array, key.num, subarray);
}
if (SUCCESS != http_querystring_xlate(subarray, *entry, ie, oe)) {
if (key.type == HASH_KEY_IS_STRING) {
efree(xkey);
}
return FAILURE;
}
}
if (key.type == HASH_KEY_IS_STRING) {
efree(xkey);
}
}
PHP_METHOD(phady_6__closure, __invoke) {
zval *_0;
int ZEPHIR_LAST_CALL_STATUS;
zval *view;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(view);
object_init_ex(view, phalcon_mvc_view_ce);
ZEPHIR_CALL_METHOD(NULL, view, "__construct", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 1, 0 TSRMLS_CC);
add_assoc_stringl_ex(_0, SS(".volt"), SL("volt"), 1);
ZEPHIR_CALL_METHOD(NULL, view, "registerengines", NULL, 0, _0);
zephir_check_call_status();
RETURN_CCTOR(view);
}
static int httpparser_append(char *type, int type_len, http_parser *p, const char *buf, size_t len)
{
zval * dest, **fnd;
httpParserObj * Parser;
Parser = (httpParserObj *)p->data;
if (zend_hash_find(Z_ARRVAL_P(Parser->variable), type, type_len, (void**)&fnd) == FAILURE) {
ALLOC_INIT_ZVAL(dest);
array_init(dest);
add_assoc_stringl_ex(Parser->variable, type, type_len, buf, len, 1);
} else {
dest = *fnd;
convert_to_string(dest);
/* Enlarge a's buffer to hold the additional data */
Z_STRVAL_P(dest) = erealloc(Z_STRVAL_P(dest), Z_STRLEN_P(dest) + len + 1);
memcpy(Z_STRVAL_P(dest) + Z_STRLEN_P(dest), buf, len);
Z_STRLEN_P(dest) += len;
}
return 0;
}