void zephir_init_static_properties_Test_Properties_StaticPropertyArray(TSRMLS_D) {
zval _1;
zval _0;
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&_0);
zephir_create_array(&_0, 4, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_1);
ZVAL_LONG(&_1, 1);
zephir_array_fast_append(&_0, &_1);
ZEPHIR_INIT_NVAR(&_1);
ZVAL_LONG(&_1, 2);
zephir_array_fast_append(&_0, &_1);
ZEPHIR_INIT_NVAR(&_1);
ZVAL_LONG(&_1, 3);
zephir_array_fast_append(&_0, &_1);
ZEPHIR_INIT_NVAR(&_1);
ZVAL_LONG(&_1, 4);
zephir_array_fast_append(&_0, &_1);
zend_update_static_property(test_properties_staticpropertyarray_ce, ZEND_STRL("someArray"), &_0);
ZEPHIR_INIT_NVAR(&_1);
array_init(&_1);
zend_update_static_property(test_properties_staticpropertyarray_ce, ZEND_STRL("someEmptyArray"), &_1);
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);
}
/*{{{ zval* get_instance(TSRMLS_D)
*/
zval* fool_loader_instance(TSRMLS_D)
{
zval* instance;
instance = zend_read_static_property(fool_loader_ce,ZEND_STRL(FOOL_LOADER_PROPERTY_NAME_INSTANCE),1 TSRMLS_CC);
if(Z_TYPE_P(instance) == IS_OBJECT){
//Z_ADDREF_P(instance); ?????????????????
return instance;
}
object_init_ex(instance,fool_loader_ce);
zend_update_static_property(fool_loader_ce,ZEND_STRL(FOOL_LOADER_PROPERTY_NAME_INSTANCE),instance TSRMLS_CC);
char* include_path;// = emalloc(strlen(FOOL_G(class_map)) + strlen(FOOL_G(config_path)) + 2);
spprintf(&include_path,0,"%s/%s",FOOLPHP_G(config_path),FOOLPHP_G(class_map));
if(instance){
//include class_map
fool_loader_include(include_path TSRMLS_CC);
efree(include_path);
return instance;
}
efree(include_path);
return NULL;
}
/**{{{ zval* get_instance(TSRMLS_D)
*/
zval* fool_view_instance(TSRMLS_D)
{
zval* instance;
zval* var;
instance = zend_read_static_property(fool_view_ce,ZEND_STRL(FOOL_VIEW_PROPERTY_NAME_INSTANCE),1 TSRMLS_CC);
if(Z_TYPE_P(instance) == IS_OBJECT){
//Z_ADDREF_P(instance); //?????????????????
return instance;
}
object_init_ex(instance,fool_view_ce);
zend_update_static_property(fool_view_ce,ZEND_STRL(FOOL_VIEW_PROPERTY_NAME_INSTANCE),instance TSRMLS_CC);
if(instance){
MAKE_STD_ZVAL(var);
array_init(var);
zend_update_property(fool_view_ce,instance,ZEND_STRL(FOOL_VIEW_PROPERTY_NAME_VAR),var TSRMLS_CC);
return instance;
}
return NULL;
}
/**
* Sets the default descriptor for database connections.
*
*
*
* @param array $options
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Pool, setDefaultDescriptor){
zval *options = NULL, *descriptor = NULL, *value = NULL, *key = NULL;
zval *i0 = 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", &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(options) != IS_ARRAY) {
if (Z_TYPE_P(options) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The parameter 'options' must be an Array or Object");
return;
}
}
if (Z_TYPE_P(options) == IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init(i0);
PHALCON_CPY_WRT(descriptor, i0);
if (phalcon_valid_foreach(options TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(options);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_162f_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_162f_0;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_update_property_zval_zval(descriptor, key, value TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_162f_0;
fee_162f_0:
if(0){}
} else {
return;
}
} else {
PHALCON_CPY_WRT(descriptor, options);
}
zend_update_static_property(phalcon_db_pool_ce, "_defaultDescriptor", sizeof("_defaultDescriptor")-1, descriptor TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Resets the internal singleton
*/
PHP_METHOD(Phalcon_Controller_Front, reset){
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(t0);
ZVAL_NULL(t0);
zend_update_static_property(phalcon_controller_front_ce, "_instance", sizeof("_instance")-1, t0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**{{{
*/
zval *_getInstance(void) {
zval *instance;
instance = zend_read_static_property(mylogs_ce, ZEND_STRL(MYLOGS_INSTANCE), 0 TSRMLS_CC);
if(IS_OBJECT == Z_TYPE_P(instance)
&& instanceof_function(Z_OBJCE_P(instance), mylogs_ce TSRMLS_CC)) {
return instance;
}
MAKE_STD_ZVAL(instance);
object_init_ex(instance, mylogs_ce);
zend_update_static_property(mylogs_ce, ZEND_STRL(MYLOGS_INSTANCE), instance TSRMLS_CC);
return instance;
}
PHP_METHOD(slightphp, setZoneAlias)
{
char *zone, *alias;
int zone_len, alias_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &zone, &zone_len, &alias ,&alias_len) == FAILURE) {
RETURN_FALSE;
}
zval *zoneAlias = zend_read_static_property(slightphp_ce_ptr,"zoneAlias",sizeof("zoneAlias")-1,1 TSRMLS_CC);
if(!zoneAlias){ RETURN_FALSE; }
if(Z_TYPE_P(zoneAlias)!=IS_ARRAY){
array_init(zoneAlias);
}
add_assoc_string(zoneAlias,zone,alias,1);
zend_update_static_property(slightphp_ce_ptr,"zoneAlias",sizeof("zoneAlias")-1,zoneAlias TSRMLS_CC);
RETURN_TRUE;
}
/**
* Gets the singleton instance of Phalcon_Request
*
* @return Phalcon_Request
*/
PHP_METHOD(Phalcon_Request, getInstance){
zval *t0 = NULL, *t1 = NULL;
zval *i0 = NULL;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(t0);
phalcon_read_static_property(&t0, phalcon_request_ce, "_instance", sizeof("_instance")-1 TSRMLS_CC);
if (!zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_request_ce);
PHALCON_CALL_METHOD_NORETURN(i0, "__construct", PHALCON_CHECK);
zend_update_static_property(phalcon_request_ce, "_instance", sizeof("_instance")-1, i0 TSRMLS_CC);
}
PHALCON_OBSERVE_VAR(t1);
phalcon_read_static_property(&t1, phalcon_request_ce, "_instance", sizeof("_instance")-1 TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(t1);
}
/*{{{ zval* fool_application_instance(TSRMLS_D)
*/
zval* fool_application_instance(TSRMLS_D)
{
zval* instance;
zval* dispatcher;
zval* loader;
instance = zend_read_static_property(fool_application_ce,ZEND_STRL(FOOL_APPLICATION_PROPERTY_NAME_INSTANCE),1 TSRMLS_CC);
if(Z_TYPE_P(instance) == IS_OBJECT){
//Z_ADDREF_P(instance);
return instance;
}
object_init_ex(instance,fool_application_ce);
zend_update_static_property(fool_application_ce,ZEND_STRL(FOOL_APPLICATION_PROPERTY_NAME_INSTANCE),instance TSRMLS_CC);
if(instance){
//init dispatcher
dispatcher = fool_dispatcher_instance(TSRMLS_C);
if(!dispatcher){
return NULL;
}
loader = fool_loader_instance(TSRMLS_CC);
if(!loader){
return NULL;
}
fool_loader_register_autoload(loader TSRMLS_CC);
zend_update_property(fool_application_ce,instance,ZEND_STRL(FOOL_APPLICATION_PROPERTY_NAME_DISPATCHER),dispatcher TSRMLS_CC);
//init config
fool_config_init(TSRMLS_C);
//init object
fool_object_instance(TSRMLS_C);
return instance;
}
return NULL;
}
ZEND_METHOD(myclass_child, __construct)
{
zval *prop1, *prop2;
zend_class_entry *ce;
ce = Z_OBJCE_P(getThis());
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &prop1, &prop2) == FAILURE) {
php_printf("Parameter Error\n");
RETURN_NULL();
}
zend_update_property(ce, getThis(), "prop1", sizeof("prop1") - 1, prop1 TSRMLS_CC); //更新对象属性
zend_update_static_property(ce, "prop2", sizeof("prop2") - 1, prop2 TSRMLS_CC); //更新类静态属性(与具体对象无关)
prop1 = NULL;
prop2 = NULL;
prop1 = zend_read_property(ce, getThis(), "prop1", sizeof("prop1") - 1, 0 TSRMLS_DC);
php_var_dump(&prop1, 1 TSRMLS_CC);
prop2 = zend_read_static_property(ce, "prop2", sizeof("prop2") - 1, 0 TSRMLS_DC);
php_var_dump(&prop2, 1 TSRMLS_CC);
}
yaf_dispatcher_t *yaf_dispatcher_instance(yaf_dispatcher_t *this_ptr) /* {{{ */ {
zval plugins;
yaf_router_t *router, rv = {{0}};
yaf_dispatcher_t *instance;
instance = zend_read_static_property(yaf_dispatcher_ce, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_INSTANCE), 1);
if (IS_OBJECT == Z_TYPE_P(instance)
&& instanceof_function(Z_OBJCE_P(instance), yaf_dispatcher_ce)) {
return instance;
}
if (Z_ISUNDEF_P(this_ptr)) {
object_init_ex(this_ptr, yaf_dispatcher_ce);
} else {
return this_ptr;
}
array_init(&plugins);
zend_update_property(yaf_dispatcher_ce, this_ptr, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_PLUGINS), &plugins);
zval_ptr_dtor(&plugins);
router = yaf_router_instance(&rv);
zend_update_property(yaf_dispatcher_ce, this_ptr, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_ROUTER), router);
zval_ptr_dtor(router);
zend_update_property_str(yaf_dispatcher_ce,
this_ptr, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_MODULE), YAF_G(default_module));
zend_update_property_str(yaf_dispatcher_ce,
this_ptr, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_CONTROLLER), YAF_G(default_controller));
zend_update_property_str(yaf_dispatcher_ce,
this_ptr, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_ACTION), YAF_G(default_action));
zend_update_static_property(yaf_dispatcher_ce, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_INSTANCE), this_ptr);
return this_ptr;
}
/* {{{ proto void run()
*/
PHP_METHOD(slightphp, run)
{
zval *zone=NULL;
zval *page=NULL;
zval *entry=NULL;
zval **token;
zval *path_array;
//{{{
int isPart;
zval * path = NULL;
if (ZEND_NUM_ARGS()>0 && zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &path) != FAILURE) {
if (Z_TYPE_P(path)!= IS_STRING){
RETURN_FALSE;
}
isPart = 1;
}else{
isPart = 0;
path = zend_read_static_property(slightphp_ce_ptr,"pathInfo",sizeof("pathInfo")-1,1 TSRMLS_CC);
int s = Z_STRLEN_P(path);
if(s==0){
zend_is_auto_global("_SERVER", sizeof("_SERVER") - 1 TSRMLS_CC);
if(zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_GET]),
"PATH_INFO", sizeof("PATH_INFO"), (void **) &token) == SUCCESS
){
path = *token;
}else if(zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]),
"PATH_INFO", sizeof("PATH_INFO"), (void **) &token) == SUCCESS
){
path = *token;
}
}
}
//}}}
MAKE_STD_ZVAL(path_array);
array_init(path_array);
if (path){
//{{{
zval quotedFlag;
regex_t re;
char *regex;
regmatch_t subs[1];
int err,size;
char *strp = Z_STRVAL_P(path);
char *endp = strp + Z_STRLEN_P(path);
zval *splitFlag = zend_read_static_property(slightphp_ce_ptr,"splitFlag",sizeof("splitFlag")-1,1 TSRMLS_CC);
if(preg_quote(splitFlag,"edFlag)>0){
spprintf(®ex,0,"[%s\\/]",Z_STRVAL(quotedFlag));
}else{
spprintf(®ex,0,"[\\/]");
}
err = regcomp(&re, regex, REG_ICASE);
if (err) {
}else{
while (!(err = regexec(&re, strp, 1, subs, 0))) {
if (subs[0].rm_so == 0 && subs[0].rm_eo) {
//ignore empty string
strp += subs[0].rm_eo;
}else if (subs[0].rm_so == 0 && subs[0].rm_eo == 0) {
}else{
size = subs[0].rm_so;
add_next_index_stringl(path_array, strp, size, 1);
strp += size;
}
}
if (!err || err == REG_NOMATCH) {
size = endp - strp;
if(size>0) add_next_index_stringl(path_array, strp, size, 1);
}
regfree(&re);
}
efree(regex);
//}}}
int n_elems = zend_hash_num_elements(Z_ARRVAL_P(path_array));
if(zend_hash_index_find(Z_ARRVAL_P(path_array), 0, (void **)&token) != FAILURE) {
zone = *token;
}
if(zend_hash_index_find(Z_ARRVAL_P(path_array), 1, (void **)&token) != FAILURE) {
page = *token;
}
if(zend_hash_index_find(Z_ARRVAL_P(path_array), 2, (void **)&token) != FAILURE) {
entry = *token;
}
}
if(!zone){
zone = zend_read_static_property(slightphp_ce_ptr,"defaultZone",sizeof("defaultZone")-1,1 TSRMLS_CC);
zend_hash_next_index_insert(Z_ARRVAL_P(path_array),&zone,sizeof(zval*),NULL);
}
if(!page){
page = zend_read_static_property(slightphp_ce_ptr,"defaultPage",sizeof("defaultPage")-1,1 TSRMLS_CC);
zend_hash_next_index_insert(Z_ARRVAL_P(path_array),&page,sizeof(zval*),NULL);
}
if(!entry){
entry = zend_read_static_property(slightphp_ce_ptr,"defaultEntry",sizeof("defaultEntry")-1,1 TSRMLS_CC);
zend_hash_next_index_insert(Z_ARRVAL_P(path_array),&entry,sizeof(zval*),NULL);
}
//{{{
zval *zoneAlias = zend_read_static_property(slightphp_ce_ptr,"zoneAlias",sizeof("zoneAlias")-1,1 TSRMLS_CC);
if(zoneAlias && Z_TYPE_P(zoneAlias)==IS_ARRAY){
char *string_key;uint str_key_len;ulong num_key;
HashPosition pos;
zval **entry2;
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zoneAlias), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(zoneAlias), (void **)&entry2, &pos) == SUCCESS) {
if(strcmp(Z_STRVAL_PP(entry2) ,Z_STRVAL_P(zone))==0){
switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(zoneAlias), &string_key, &str_key_len, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING:
ZVAL_STRING(zone,string_key,1);
break;
}
}
zend_hash_move_forward_ex(Z_ARRVAL_P(zoneAlias), &pos);
}
if(entry2)zval_ptr_dtor(entry2);
if(string_key)efree(string_key);
}
//if(zoneAlias)FREE_ZVAL(zoneAlias);
//}}}
if(!isPart){
zend_update_static_property(slightphp_ce_ptr,"zone",sizeof("zone")-1,zone TSRMLS_CC);
zend_update_static_property(slightphp_ce_ptr,"page",sizeof("page")-1,page TSRMLS_CC);
zend_update_static_property(slightphp_ce_ptr,"entry",sizeof("entry")-1,entry TSRMLS_CC);
}else{
if(
strcmp(Z_STRVAL_P(zone),Z_STRVAL_P(zend_read_static_property(slightphp_ce_ptr,"zone",sizeof("zone")-1,1 TSRMLS_CC)))==0
&&
strcmp(Z_STRVAL_P(page),Z_STRVAL_P(zend_read_static_property(slightphp_ce_ptr,"page",sizeof("page")-1,1 TSRMLS_CC)))==0
&&
strcmp(Z_STRVAL_P(entry),Z_STRVAL_P(zend_read_static_property(slightphp_ce_ptr,"entry",sizeof("entry")-1,1 TSRMLS_CC)))==0
){
debug("part ignored [%s]",Z_STRVAL_P(path));
return;
}
}
zval *appDir = zend_read_static_property(slightphp_ce_ptr,"appDir",sizeof("appDir")-1,1 TSRMLS_CC);
zval *params[1];
params[0]=path_array;
if(slightphp_load(appDir,zone,page TSRMLS_CC) == SUCCESS){
if(slightphp_run(zone,page,entry,return_value,1,params TSRMLS_CC)==SUCCESS){
if(path_array)FREE_ZVAL(path_array);
RETURN_ZVAL(return_value,1,0);
};
}
if(path_array)FREE_ZVAL(path_array);
RETURN_FALSE;
}
/* {{{ proto void run()
*/
PHP_METHOD(slightphp, run)
{
zval *zone=NULL;
zval *page=NULL;
zval *entry=NULL;
zval path_array;
//{{{
int isPart;
zval *path;
if (ZEND_NUM_ARGS()>0 && zend_parse_parameters(ZEND_NUM_ARGS() , "z/", &path) != FAILURE) {
if (Z_TYPE_P(path)!= IS_STRING){
RETURN_FALSE;
}
isPart = 1;
}else{
isPart = 0;
zend_is_auto_global_str(ZEND_STRL("_SERVER"));
zval *server_vars;
if ((server_vars = zend_hash_str_find(&EG(symbol_table), ZEND_STRL("_SERVER"))) != NULL && Z_TYPE_P(server_vars) == IS_ARRAY){
if((path= zend_hash_str_find(Z_ARRVAL_P(server_vars), ZEND_STRL("PATH_INFO")))!=NULL && Z_TYPE_P(path) == IS_STRING) {
//
}else if((path= zend_hash_str_find(Z_ARRVAL_P(server_vars), ZEND_STRL("REQUEST_URI")))!=NULL && Z_TYPE_P(path) == IS_STRING) {
//
}else{
debug("path not set in params or server.path_info, server.request_uri");
RETURN_FALSE;
}
}
}
/* Skip leading / */
int len = Z_STRLEN_P(path);
int start=0;
for(start=0;start<len;start++){
if(*(Z_STRVAL_P(path)+start) != '/'){
break;
}
}
zval url;
php_url *resource=NULL;
resource = php_url_parse(Z_STRVAL_P(path)+start);
if(resource != NULL){
if(resource->path != NULL){
ZVAL_STRING(&url,resource->path);
}else{
ZVAL_STRING(&url,Z_STRVAL_P(path));
}
php_url_free(resource);
}else{
ZVAL_STRING(&url,Z_STRVAL_P(path));
}
zend_update_static_property(slightphp_ce_ptr,"pathInfo",sizeof("pathInfo")-1,&url TSRMLS_CC);
//zend_print_flat_zval_r(path);
//}}}
array_init(&path_array);
{
//{{{
zval quotedFlag;
regex_t re;
char *regex;
regmatch_t subs[1];
int err,size;
char *strp = Z_STRVAL(url);
char *endp = strp + Z_STRLEN(url);
zval *splitFlag = zend_read_static_property(slightphp_ce_ptr,"splitFlag",sizeof("splitFlag")-1,1 );
if(preg_quote(splitFlag,"edFlag)>0){
spprintf(®ex,0,"[%s\\/]",Z_STRVAL(quotedFlag));
}else{
spprintf(®ex,0,"[\\/]");
}
err = regcomp(&re, regex, REG_ICASE);
if (err) {
}else{
while (!(err = regexec(&re, strp, 1, subs, 0))) {
if (subs[0].rm_so == 0 && subs[0].rm_eo) {
//ignore empty string
strp += subs[0].rm_eo;
}else if (subs[0].rm_so == 0 && subs[0].rm_eo == 0) {
}else{
size = subs[0].rm_so;
add_next_index_stringl(&path_array, strp, size);
strp += size;
}
}
if (!err || err == REG_NOMATCH) {
size = endp - strp;
if(size>0) add_next_index_stringl(&path_array, strp, size);
}
regfree(&re);
}
efree(regex);
zval_dtor("edFlag);
//}}}
if((zone = zend_hash_index_find(Z_ARRVAL(path_array), 0)) != NULL ) {
}
if((page = zend_hash_index_find(Z_ARRVAL(path_array), 1)) != NULL ) {
}
if((entry = zend_hash_index_find(Z_ARRVAL(path_array), 2)) != NULL) {
}
}
if(!zone){
zone = zend_read_static_property(slightphp_ce_ptr,"defaultZone",sizeof("defaultZone")-1,1 );
add_next_index_string(&path_array, Z_STRVAL_P(zone));
}
if(!page){
page = zend_read_static_property(slightphp_ce_ptr,"defaultPage",sizeof("defaultPage")-1,1 );
add_next_index_string(&path_array, Z_STRVAL_P(page));
}
if(!entry){
entry = zend_read_static_property(slightphp_ce_ptr,"defaultEntry",sizeof("defaultEntry")-1,1 );
add_next_index_string(&path_array, Z_STRVAL_P(entry));
}
//{{{
zval *zoneAlias = zend_read_static_property(slightphp_ce_ptr,"zoneAlias",sizeof("zoneAlias")-1,1 );
if(zoneAlias && Z_TYPE_P(zoneAlias)==IS_ARRAY){
zend_ulong num_key;
zend_string *string_key= NULL;
HashPosition pos;
zval *entry2=NULL;
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zoneAlias), &pos);
for (;; zend_hash_move_forward_ex(Z_ARRVAL_P(zoneAlias), &pos)) {
if (NULL == (entry2= zend_hash_get_current_data_ex(Z_ARRVAL_P(zoneAlias), &pos))) {
break;
}
if(strcmp(Z_STRVAL_P(entry2) ,Z_STRVAL_P(zone))==0){
switch (pos = zend_hash_get_current_key_ex(Z_ARRVAL_P(zoneAlias), &string_key, &num_key,&pos)) {
case HASH_KEY_IS_STRING:
ZVAL_STR_COPY(zone,string_key);
break;
}
}
}
}
//}}}
if(!isPart){
zend_update_static_property(slightphp_ce_ptr,"zone",sizeof("zone")-1,zone );
zend_update_static_property(slightphp_ce_ptr,"page",sizeof("page")-1,page );
zend_update_static_property(slightphp_ce_ptr,"entry",sizeof("entry")-1,entry );
}else{
if(
strcmp(Z_STRVAL_P(zone),Z_STRVAL_P(zend_read_static_property(slightphp_ce_ptr,"zone",sizeof("zone")-1,1 )))==0
&&
strcmp(Z_STRVAL_P(page),Z_STRVAL_P(zend_read_static_property(slightphp_ce_ptr,"page",sizeof("page")-1,1 )))==0
&&
strcmp(Z_STRVAL_P(entry),Z_STRVAL_P(zend_read_static_property(slightphp_ce_ptr,"entry",sizeof("entry")-1,1 )))==0
){
debug("part ignored [%s]",Z_STRVAL(url));
zval_dtor(&path_array);
zval_dtor(&url);
return;
}
}
zval *appDir = zend_read_static_property(slightphp_ce_ptr,"appDir",sizeof("appDir")-1,1 );
if(slightphp_load(appDir,zone,page ) == SUCCESS){
zval ret;
if(slightphp_run(zone,page,entry,&ret,1,&path_array)==SUCCESS){
zval_dtor(&path_array);
zval_dtor(&url);
RETURN_ZVAL(&ret,0,1);
};
}
zval_dtor(&url);
zval_dtor(&path_array);
RETURN_FALSE;
}
/**
* Returns a connection builded with the default descriptor parameters
*
*
*
* @param boolean $newConnection
* @param boolean $renovate
* @return Phalcon_Db
*/
PHP_METHOD(Phalcon_Db_Pool, getConnection){
zval *new_connection = NULL, *renovate = NULL, *database = NULL, *connection = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &new_connection, &renovate) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!new_connection) {
PHALCON_INIT_VAR(new_connection);
ZVAL_BOOL(new_connection, 0);
}
if (!renovate) {
PHALCON_INIT_VAR(renovate);
ZVAL_BOOL(renovate, 0);
}
PHALCON_OBSERVE_VAR(t0);
phalcon_read_static_property(&t0, phalcon_db_pool_ce, "_defaultDescriptor", sizeof("_defaultDescriptor")-1 TSRMLS_CC);
PHALCON_CPY_WRT(database, t0);
if (!zend_is_true(database)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Default database connection parameters was not defined");
return;
}
eval_int = phalcon_isset_property(database, "adapter", strlen("adapter") TSRMLS_CC);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "A valid adapter name is required");
return;
}
if (zend_is_true(new_connection)) {
if (zend_is_true(renovate)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, database, "adapter", sizeof("adapter")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db", "factory", t1, database);
zend_update_static_property(phalcon_db_pool_ce, "_connection", sizeof("_connection")-1, r0 TSRMLS_CC);
PHALCON_OBSERVE_VAR(t2);
phalcon_read_static_property(&t2, phalcon_db_pool_ce, "_connection", sizeof("_connection")-1 TSRMLS_CC);
PHALCON_CPY_WRT(connection, t2);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, database, "adapter", sizeof("adapter")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r1, "phalcon_db", "factory", t3, database);
PHALCON_CPY_WRT(connection, r1);
}
} else {
PHALCON_OBSERVE_VAR(t4);
phalcon_read_static_property(&t4, phalcon_db_pool_ce, "_connection", sizeof("_connection")-1 TSRMLS_CC);
if (!zend_is_true(t4)) {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, database, "adapter", sizeof("adapter")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r2, "phalcon_db", "factory", t5, database);
zend_update_static_property(phalcon_db_pool_ce, "_connection", sizeof("_connection")-1, r2 TSRMLS_CC);
}
PHALCON_OBSERVE_VAR(t6);
phalcon_read_static_property(&t6, phalcon_db_pool_ce, "_connection", sizeof("_connection")-1 TSRMLS_CC);
PHALCON_CPY_WRT(connection, t6);
}
PHALCON_RETURN_CHECK_CTOR(connection);
}
