/** * Adds a number to a string or increment that number if it already is defined * * <code> * echo Phalcon\Text::increment("a"); // "a_1" * echo Phalcon\Text::increment("a_1"); // "a_2" * </code> */ PHP_METHOD(Phalcon_Text, increment) { zval *str_param = NULL, *separator_param = NULL, *parts = NULL, *number = NULL, *_0; zval *str = NULL, *separator = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &str_param, &separator_param); zephir_get_strval(str, str_param); if (!separator_param) { ZEPHIR_INIT_VAR(separator); ZVAL_STRING(separator, "_", 1); } else { zephir_get_strval(separator, separator_param); } ZEPHIR_INIT_VAR(parts); zephir_fast_explode(parts, separator, str, LONG_MAX TSRMLS_CC); ZEPHIR_OBS_VAR(number); if (zephir_array_isset_long_fetch(&number, parts, 1, 0 TSRMLS_CC)) { ZEPHIR_SEPARATE(number); zephir_increment(number); } else { ZEPHIR_INIT_NVAR(number); ZVAL_LONG(number, 1); } zephir_array_fetch_long(&_0, parts, 0, PH_NOISY | PH_READONLY, "phalcon/text.zep", 87 TSRMLS_CC); ZEPHIR_CONCAT_VVV(return_value, _0, separator, number); RETURN_MM(); }
PHP_METHOD(Test_Strings, testExplode) { zval *delimiter, *str; zephir_fetch_params(0, 2, 0, &delimiter, &str); zephir_fast_explode(return_value, delimiter, str, LONG_MAX TSRMLS_CC); return; }
PHP_METHOD(Test_Strings, testExplode) { zval *delimiter, delimiter_sub, *str, str_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&delimiter_sub); ZVAL_UNDEF(&str_sub); zephir_fetch_params(0, 2, 0, &delimiter, &str); zephir_fast_explode(return_value, delimiter, str, LONG_MAX TSRMLS_CC); return; }
PHP_METHOD(Test_Strings, testExplode) { zval *delimiter, delimiter_sub, *str, str_sub; zval this_zv; zval *this_ptr = getThis(); if (EXPECTED(this_ptr)) { ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr)); this_ptr = &this_zv; } else this_ptr = NULL; ZVAL_UNDEF(&delimiter_sub); ZVAL_UNDEF(&str_sub); zephir_fetch_params(0, 2, 0, &delimiter, &str); zephir_fast_explode(return_value, delimiter, str, LONG_MAX TSRMLS_CC); return; }
/** * Handles routing information received from command-line arguments * * @param array arguments */ PHP_METHOD(Phalcon_Cli_Router, handle) { zephir_fcall_cache_entry *_18 = NULL; zval *_15 = NULL; zval *_5 = NULL, *_10 = NULL; int ZEPHIR_LAST_CALL_STATUS; HashTable *_3, *_7; HashPosition _2, _6; zend_bool _0; zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_8, *_9 = NULL, *_11, *_12, *_13, *_14, _16, *_17 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &arguments); if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(routeFound); ZVAL_BOOL(routeFound, 0); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(params); array_init(params); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); if (Z_TYPE_P(arguments) != IS_ARRAY) { _0 = Z_TYPE_P(arguments) != IS_STRING; if (_0) { _0 = Z_TYPE_P(arguments) != IS_NULL; } if (_0) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 204); return; } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC); zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 304); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_backwards_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(route, _4); ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0); zephir_check_call_status(); if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 214)) { ZEPHIR_INIT_NVAR(routeFound); zephir_preg_match(routeFound, pattern, arguments, matches, 0, 0 , 0 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(routeFound); ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments)); } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(beforeMatch) != IS_NULL) { if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 232); return; } ZEPHIR_INIT_NVAR(_5); zephir_create_array(_5, 3, 0 TSRMLS_CC); zephir_array_fast_append(_5, arguments); zephir_array_fast_append(_5, route); zephir_array_fast_append(_5, this_ptr); ZEPHIR_INIT_NVAR(routeFound); ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _5); zephir_check_call_status(); } } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(parts, paths); if (Z_TYPE_P(matches) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0); zephir_check_call_status(); zephir_is_iterable(paths, &_7, &_6, 0, 0, "phalcon/cli/router.zep", 293); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(part, _7, _6); ZEPHIR_GET_HVALUE(position, _8); ZEPHIR_OBS_NVAR(matchPosition); if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_INIT_NVAR(_5); zephir_create_array(_5, 1, 0 TSRMLS_CC); zephir_array_fast_append(_5, matchPosition); ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _5); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE); continue; } } zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); ZEPHIR_INIT_NVAR(_10); zephir_create_array(_10, 1, 0 TSRMLS_CC); zephir_array_fast_append(_10, position); ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _10); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE); } } } } zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); break; } } if (zephir_is_true(routeFound)) { zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); _11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _11 TSRMLS_CC); _12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_task"), _12 TSRMLS_CC); _13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _13 TSRMLS_CC); _14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_params"), _14 TSRMLS_CC); RETURN_THIS(); } } else { ZEPHIR_CPY_WRT(parts, arguments); } ZEPHIR_INIT_VAR(moduleName); ZVAL_NULL(moduleName); ZEPHIR_INIT_VAR(taskName); ZVAL_NULL(taskName); ZEPHIR_INIT_VAR(actionName); ZVAL_NULL(actionName); ZEPHIR_OBS_NVAR(moduleName); if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(moduleName); zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(taskName); if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(taskName); zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(actionName); if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(actionName); zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC); } if (zephir_is_true(routeFound)) { ZEPHIR_OBS_NVAR(params); if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) { if (Z_TYPE_P(params) != IS_ARRAY) { zephir_get_strval(_15, params); ZEPHIR_SINIT_VAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_VAR(strParams); zephir_substr(strParams, _15, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); if (zephir_is_true(strParams)) { ZEPHIR_CALL_CE_STATIC(&_17, phalcon_cli_router_route_ce, "getdelimiter", &_18, 121); zephir_check_call_status(); ZEPHIR_INIT_NVAR(params); zephir_fast_explode(params, _17, strParams, LONG_MAX TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(params); array_init(params); } } zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE); } if (zephir_fast_count_int(params TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_9); zephir_fast_array_merge(_9, &(params), &(parts) TSRMLS_CC); ZEPHIR_CPY_WRT(params, _9); } else { ZEPHIR_CPY_WRT(params, parts); } } else { ZEPHIR_CPY_WRT(params, parts); } zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * @return mixed */ PHP_METHOD(Lynx_Annotation_RegexDocParser, parseValue) { int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_14 = NULL; HashTable *_11; HashPosition _10; zend_bool _3, _15, _20; zval *value, *val = NULL, *vals, *v = NULL, _0, _1, *_2, _4, *_5, _6 = zval_used_for_init, _7 = zval_used_for_init, *_8 = NULL, _9 = zval_used_for_init, **_12, *_13 = NULL, *_16, _17, _18, *_19, _21, *_22, _23, _24, *_25 = NULL, *_26; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value); ZEPHIR_INIT_VAR(val); zephir_fast_trim(val, value, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 0); ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(_2); zephir_substr(_2, val, 0 , 1 , 0); _3 = ZEPHIR_IS_STRING(_2, "["); if (_3) { ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, -1); ZEPHIR_INIT_VAR(_5); zephir_substr(_5, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); _3 = ZEPHIR_IS_STRING(_5, "]"); } if (_3) { ZEPHIR_INIT_VAR(vals); ZEPHIR_SINIT_VAR(_6); ZVAL_LONG(&_6, 1); ZEPHIR_SINIT_VAR(_7); ZVAL_LONG(&_7, -1); ZEPHIR_INIT_VAR(_8); zephir_substr(_8, val, 1 , -1 , 0); ZEPHIR_SINIT_VAR(_9); ZVAL_LONG(&_9, ','); zephir_fast_explode(vals, &_9, _8, LONG_MAX TSRMLS_CC); ZEPHIR_INIT_NVAR(val); array_init(val); zephir_is_iterable(vals, &_11, &_10, 0, 0, "lynx/Annotation/RegexDocParser.zep", 89); for ( ; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS ; zephir_hash_move_forward_ex(_11, &_10) ) { ZEPHIR_GET_HVALUE(v, _12); ZEPHIR_CALL_SELF(&_13, "parsevalue", &_14, v); zephir_check_call_status(); zephir_array_append(&val, _13, PH_SEPARATE, "lynx/Annotation/RegexDocParser.zep", 86); } RETURN_CCTOR(val); } else { ZEPHIR_SINIT_NVAR(_6); ZVAL_LONG(&_6, 0); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, 1); ZEPHIR_INIT_NVAR(_8); zephir_substr(_8, val, 0 , 1 , 0); _15 = ZEPHIR_IS_STRING(_8, "{"); if (_15) { ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, -1); ZEPHIR_INIT_VAR(_16); zephir_substr(_16, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); _15 = ZEPHIR_IS_STRING(_16, "}"); } if (_15) { zephir_json_decode(return_value, &(return_value), val, 0 TSRMLS_CC); RETURN_MM(); } else { ZEPHIR_SINIT_VAR(_17); ZVAL_LONG(&_17, 0); ZEPHIR_SINIT_VAR(_18); ZVAL_LONG(&_18, 1); ZEPHIR_INIT_VAR(_19); zephir_substr(_19, val, 0 , 1 , 0); _20 = ZEPHIR_IS_STRING(_19, "\""); if (_20) { ZEPHIR_SINIT_VAR(_21); ZVAL_LONG(&_21, -1); ZEPHIR_INIT_VAR(_22); zephir_substr(_22, val, -1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); _20 = ZEPHIR_IS_STRING(_22, "\""); } if (_20) { ZEPHIR_SINIT_VAR(_23); ZVAL_LONG(&_23, 1); ZEPHIR_SINIT_VAR(_24); ZVAL_LONG(&_24, -1); ZEPHIR_INIT_VAR(_25); zephir_substr(_25, val, 1 , -1 , 0); ZEPHIR_CPY_WRT(val, _25); ZEPHIR_RETURN_CALL_SELF("parsevalue", &_14, val); zephir_check_call_status(); RETURN_MM(); } else { ZEPHIR_INIT_NVAR(_25); zephir_fast_strtolower(_25, val); if (ZEPHIR_IS_STRING(_25, "true")) { RETURN_MM_BOOL(1); } else { ZEPHIR_INIT_VAR(_26); zephir_fast_strtolower(_26, val); if (ZEPHIR_IS_STRING(_26, "false")) { RETURN_MM_BOOL(0); } else { if (zephir_is_numeric(val)) { if (zephir_get_doubleval(val) == zephir_get_intval(val)) { RETURN_MM_LONG(zephir_get_intval(val)); } else { RETURN_MM_DOUBLE(zephir_get_doubleval(val)); } } } } } } } RETURN_CCTOR(val); }
/** * Prepare an HTML string of information about a single variable. */ PHP_METHOD(Phalcon_Debug_Dump, output) { zend_bool _17$$5, _18$$5, _19$$5; HashTable *_8$$4, *_42$$11, *_76$$20; HashPosition _7$$4, _41$$11, _75$$20; zval *_123, *_1$$4, *_13$$5 = NULL, *_26$$8, *_68$$8, *_32$$9, *_46$$12 = NULL, *_60$$14 = NULL, *_81$$22 = NULL, *_87$$23 = NULL, *_95$$24, *_100$$25, *_104$$26, *_108$$27, *_114$$28, *_119$$29; zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL, *_12 = NULL, *_23 = NULL, *_31 = NULL, *_53 = NULL, *_57 = NULL, *_62 = NULL; int tab, ZEPHIR_LAST_CALL_STATUS; zval *name = NULL, *_0$$3; zval *variable, *name_param = NULL, *tab_param = NULL, *key = NULL, *value = NULL, *output = NULL, *space = NULL, *type = NULL, *attr = NULL, *_99 = NULL, *_124 = NULL, *_125, _126, *_2$$4 = NULL, *_3$$4, _5$$4 = zval_used_for_init, **_9$$4, *_25$$4 = NULL, _10$$5 = zval_used_for_init, *_11$$5 = NULL, *_14$$5 = NULL, *_15$$5 = NULL, *_16$$5 = NULL, *_20$$7 = NULL, *_21$$7 = NULL, *_22$$7 = NULL, *_24$$7 = NULL, *_27$$8 = NULL, *_28$$8 = NULL, _29$$8 = zval_used_for_init, *_30$$8 = NULL, *_36$$8, *_67$$8 = NULL, *_69$$8 = NULL, *_70$$8, *_71$$8, *_94$$8 = NULL, *_33$$9 = NULL, *_34$$9, _35$$9, _37$$10, *_38$$10 = NULL, *_39$$10, *_40$$11 = NULL, **_43$$11, _44$$12 = zval_used_for_init, *_45$$12 = NULL, *_47$$12 = NULL, *_48$$12 = NULL, *_49$$12 = NULL, *_50$$12 = NULL, *_51$$12 = NULL, *_52$$12 = NULL, *_54$$14 = NULL, _55$$14 = zval_used_for_init, *_56$$14 = NULL, *_59$$14 = NULL, *_61$$14 = NULL, *_63$$14 = NULL, *_64$$14 = NULL, *_65$$14 = NULL, *_66$$14 = NULL, *_58$$17, _72$$19, *_73$$19 = NULL, *_74$$19, **_77$$20, _91$$20, *_92$$20 = NULL, *_93$$20, *_78$$21 = NULL, _79$$22 = zval_used_for_init, *_80$$22 = NULL, *_82$$22 = NULL, *_83$$22 = NULL, *_84$$22 = NULL, _85$$23 = zval_used_for_init, *_86$$23 = NULL, *_88$$23 = NULL, *_89$$23 = NULL, *_90$$23 = NULL, *_96$$24 = NULL, *_97$$24, _98$$24, *_101$$25 = NULL, *_102$$25, _103$$25, *_105$$26 = NULL, *_106$$26, _107$$26, *_109$$27 = NULL, *_110$$27, _111$$27 = zval_used_for_init, _112$$27, *_113$$27 = NULL, *_115$$28 = NULL, *_116$$28, *_117$$28 = NULL, _118$$28, *_120$$29 = NULL, *_121$$29, _122$$29; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &variable, &name_param, &tab_param); if (!name_param) { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } else { zephir_get_strval(name, name_param); } if (!tab_param) { tab = 1; } else { tab = zephir_get_intval(tab_param); } ZEPHIR_INIT_VAR(space); ZVAL_STRING(space, " ", 1); ZEPHIR_INIT_VAR(output); ZVAL_STRING(output, "", 1); if (!(!name) && Z_STRLEN_P(name)) { ZEPHIR_INIT_VAR(_0$$3); ZEPHIR_CONCAT_VS(_0$$3, name, " "); ZEPHIR_CPY_WRT(output, _0$$3); } if (Z_TYPE_P(variable) == IS_ARRAY) { ZEPHIR_INIT_VAR(_1$$4); zephir_create_array(_1$$4, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_3$$4); ZVAL_STRING(_3$$4, "arr", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "getstyle", &_4, 0, _3$$4); zephir_check_temp_parameter(_3$$4); zephir_check_call_status(); zephir_array_update_string(&_1$$4, SL(":style"), &_2$$4, PH_COPY | PH_SEPARATE); add_assoc_long_ex(_1$$4, SS(":count"), zephir_fast_count_int(variable TSRMLS_CC)); ZEPHIR_SINIT_VAR(_5$$4); ZVAL_STRING(&_5$$4, "<b style =':style'>Array</b> (<span style =':style'>:count</span>) (\n", 0); ZEPHIR_CALL_FUNCTION(&_2$$4, "strtr", &_6, 26, &_5$$4, _1$$4); zephir_check_call_status(); zephir_concat_self(&output, _2$$4 TSRMLS_CC); zephir_is_iterable(variable, &_8$$4, &_7$$4, 0, 0, "phalcon/debug/dump.zep", 156); for ( ; zephir_hash_get_current_data_ex(_8$$4, (void**) &_9$$4, &_7$$4) == SUCCESS ; zephir_hash_move_forward_ex(_8$$4, &_7$$4) ) { ZEPHIR_GET_HMKEY(key, _8$$4, _7$$4); ZEPHIR_GET_HVALUE(value, _9$$4); ZEPHIR_SINIT_NVAR(_10$$5); ZVAL_LONG(&_10$$5, tab); ZEPHIR_CALL_FUNCTION(&_11$$5, "str_repeat", &_12, 142, space, &_10$$5); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_13$$5); zephir_create_array(_13$$5, 2, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(_15$$5); ZVAL_STRING(_15$$5, "arr", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_14$$5, this_ptr, "getstyle", &_4, 0, _15$$5); zephir_check_temp_parameter(_15$$5); zephir_check_call_status(); zephir_array_update_string(&_13$$5, SL(":style"), &_14$$5, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_13$$5, SL(":key"), &key, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_NVAR(_10$$5); ZVAL_STRING(&_10$$5, "[<span style=':style'>:key</span>] => ", 0); ZEPHIR_CALL_FUNCTION(&_14$$5, "strtr", &_6, 26, &_10$$5, _13$$5); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_16$$5); ZEPHIR_CONCAT_VV(_16$$5, _11$$5, _14$$5); zephir_concat_self(&output, _16$$5 TSRMLS_CC); _17$$5 = tab == 1; if (_17$$5) { _17$$5 = !ZEPHIR_IS_STRING(name, ""); } _18$$5 = _17$$5; if (_18$$5) { _18$$5 = !(Z_TYPE_P(key) == IS_LONG); } _19$$5 = _18$$5; if (_19$$5) { _19$$5 = ZEPHIR_IS_EQUAL(name, key); } if (_19$$5) { continue; } else { ZEPHIR_INIT_NVAR(_21$$7); ZVAL_STRING(_21$$7, "", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_22$$7); ZVAL_LONG(_22$$7, (tab + 1)); ZEPHIR_CALL_METHOD(&_20$$7, this_ptr, "output", &_23, 175, value, _21$$7, _22$$7); zephir_check_temp_parameter(_21$$7); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_24$$7); ZEPHIR_CONCAT_VS(_24$$7, _20$$7, "\n"); zephir_concat_self(&output, _24$$7 TSRMLS_CC); } } ZEPHIR_SINIT_NVAR(_5$$4); ZVAL_LONG(&_5$$4, (tab - 1)); ZEPHIR_CALL_FUNCTION(&_25$$4, "str_repeat", &_12, 142, space, &_5$$4); zephir_check_call_status(); ZEPHIR_CONCAT_VVS(return_value, output, _25$$4, ")"); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_OBJECT) { ZEPHIR_INIT_VAR(_26$$8); zephir_create_array(_26$$8, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_28$$8); ZVAL_STRING(_28$$8, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_27$$8, this_ptr, "getstyle", &_4, 0, _28$$8); zephir_check_temp_parameter(_28$$8); zephir_check_call_status(); zephir_array_update_string(&_26$$8, SL(":style"), &_27$$8, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_28$$8); zephir_get_class(_28$$8, variable, 0 TSRMLS_CC); zephir_array_update_string(&_26$$8, SL(":class"), &_28$$8, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_29$$8); ZVAL_STRING(&_29$$8, "<b style=':style'>Object</b> :class", 0); ZEPHIR_CALL_FUNCTION(&_27$$8, "strtr", &_6, 26, &_29$$8, _26$$8); zephir_check_call_status(); zephir_concat_self(&output, _27$$8 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_30$$8, "get_parent_class", &_31, 176, variable); zephir_check_call_status(); if (zephir_is_true(_30$$8)) { ZEPHIR_INIT_VAR(_32$$9); zephir_create_array(_32$$9, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_34$$9); ZVAL_STRING(_34$$9, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_33$$9, this_ptr, "getstyle", &_4, 0, _34$$9); zephir_check_temp_parameter(_34$$9); zephir_check_call_status(); zephir_array_update_string(&_32$$9, SL(":style"), &_33$$9, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_FUNCTION(&_33$$9, "get_parent_class", &_31, 176, variable); zephir_check_call_status(); zephir_array_update_string(&_32$$9, SL(":parent"), &_33$$9, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_35$$9); ZVAL_STRING(&_35$$9, " <b style=':style'>extends</b> :parent", 0); ZEPHIR_CALL_FUNCTION(&_33$$9, "strtr", &_6, 26, &_35$$9, _32$$9); zephir_check_call_status(); zephir_concat_self(&output, _33$$9 TSRMLS_CC); } zephir_concat_self_str(&output, SL(" (\n") TSRMLS_CC); _36$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_detailed"), PH_NOISY_CC); if (zephir_instance_of_ev(variable, phalcon_di_ce TSRMLS_CC)) { ZEPHIR_SINIT_VAR(_37$$10); ZVAL_LONG(&_37$$10, tab); ZEPHIR_CALL_FUNCTION(&_38$$10, "str_repeat", &_12, 142, space, &_37$$10); zephir_check_call_status(); ZEPHIR_INIT_VAR(_39$$10); ZEPHIR_CONCAT_VS(_39$$10, _38$$10, "[skipped]\n"); zephir_concat_self(&output, _39$$10 TSRMLS_CC); } else if (!(zephir_is_true(_36$$8))) { ZEPHIR_CALL_FUNCTION(&_40$$11, "get_object_vars", NULL, 21, variable); zephir_check_call_status(); zephir_is_iterable(_40$$11, &_42$$11, &_41$$11, 0, 0, "phalcon/debug/dump.zep", 177); for ( ; zephir_hash_get_current_data_ex(_42$$11, (void**) &_43$$11, &_41$$11) == SUCCESS ; zephir_hash_move_forward_ex(_42$$11, &_41$$11) ) { ZEPHIR_GET_HMKEY(key, _42$$11, _41$$11); ZEPHIR_GET_HVALUE(value, _43$$11); ZEPHIR_SINIT_NVAR(_44$$12); ZVAL_LONG(&_44$$12, tab); ZEPHIR_CALL_FUNCTION(&_45$$12, "str_repeat", &_12, 142, space, &_44$$12); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_46$$12); zephir_create_array(_46$$12, 3, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(_48$$12); ZVAL_STRING(_48$$12, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_47$$12, this_ptr, "getstyle", &_4, 0, _48$$12); zephir_check_temp_parameter(_48$$12); zephir_check_call_status(); zephir_array_update_string(&_46$$12, SL(":style"), &_47$$12, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_46$$12, SL(":key"), &key, PH_COPY | PH_SEPARATE); add_assoc_stringl_ex(_46$$12, SS(":type"), SL("public"), 1); ZEPHIR_SINIT_NVAR(_44$$12); ZVAL_STRING(&_44$$12, "-><span style=':style'>:key</span> (<span style=':style'>:type</span>) = ", 0); ZEPHIR_CALL_FUNCTION(&_47$$12, "strtr", &_6, 26, &_44$$12, _46$$12); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_49$$12); ZEPHIR_CONCAT_VV(_49$$12, _45$$12, _47$$12); zephir_concat_self(&output, _49$$12 TSRMLS_CC); ZEPHIR_INIT_NVAR(_48$$12); ZVAL_STRING(_48$$12, "", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_51$$12); ZVAL_LONG(_51$$12, (tab + 1)); ZEPHIR_CALL_METHOD(&_50$$12, this_ptr, "output", &_23, 175, value, _48$$12, _51$$12); zephir_check_temp_parameter(_48$$12); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_52$$12); ZEPHIR_CONCAT_VS(_52$$12, _50$$12, "\n"); zephir_concat_self(&output, _52$$12 TSRMLS_CC); } } else { do { ZEPHIR_MAKE_REF(variable); ZEPHIR_CALL_FUNCTION(&attr, "each", &_53, 177, variable); ZEPHIR_UNREF(variable); zephir_check_call_status(); if (!(zephir_is_true(attr))) { continue; } ZEPHIR_OBS_NVAR(key); zephir_array_fetch_string(&key, attr, SL("key"), PH_NOISY, "phalcon/debug/dump.zep", 187 TSRMLS_CC); ZEPHIR_OBS_NVAR(value); zephir_array_fetch_string(&value, attr, SL("value"), PH_NOISY, "phalcon/debug/dump.zep", 188 TSRMLS_CC); if (!(zephir_is_true(key))) { continue; } ZEPHIR_INIT_NVAR(_54$$14); ZEPHIR_SINIT_NVAR(_55$$14); ZVAL_LONG(&_55$$14, 0); ZEPHIR_CALL_FUNCTION(&_56$$14, "chr", &_57, 141, &_55$$14); zephir_check_call_status(); zephir_fast_explode(_54$$14, _56$$14, key, LONG_MAX TSRMLS_CC); ZEPHIR_CPY_WRT(key, _54$$14); ZEPHIR_INIT_NVAR(type); ZVAL_STRING(type, "public", 1); if (zephir_array_isset_long(key, 1)) { ZEPHIR_INIT_NVAR(type); ZVAL_STRING(type, "private", 1); zephir_array_fetch_long(&_58$$17, key, 1, PH_NOISY | PH_READONLY, "phalcon/debug/dump.zep", 200 TSRMLS_CC); if (ZEPHIR_IS_STRING(_58$$17, "*")) { ZEPHIR_INIT_NVAR(type); ZVAL_STRING(type, "protected", 1); } } ZEPHIR_SINIT_NVAR(_55$$14); ZVAL_LONG(&_55$$14, tab); ZEPHIR_CALL_FUNCTION(&_59$$14, "str_repeat", &_12, 142, space, &_55$$14); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_60$$14); zephir_create_array(_60$$14, 3, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(_54$$14); ZVAL_STRING(_54$$14, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_61$$14, this_ptr, "getstyle", &_4, 0, _54$$14); zephir_check_temp_parameter(_54$$14); zephir_check_call_status(); zephir_array_update_string(&_60$$14, SL(":style"), &_61$$14, PH_COPY | PH_SEPARATE); ZEPHIR_MAKE_REF(key); ZEPHIR_CALL_FUNCTION(&_61$$14, "end", &_62, 178, key); ZEPHIR_UNREF(key); zephir_check_call_status(); zephir_array_update_string(&_60$$14, SL(":key"), &_61$$14, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_60$$14, SL(":type"), &type, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_NVAR(_55$$14); ZVAL_STRING(&_55$$14, "-><span style=':style'>:key</span> (<span style=':style'>:type</span>) = ", 0); ZEPHIR_CALL_FUNCTION(&_61$$14, "strtr", &_6, 26, &_55$$14, _60$$14); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_63$$14); ZEPHIR_CONCAT_VV(_63$$14, _59$$14, _61$$14); zephir_concat_self(&output, _63$$14 TSRMLS_CC); ZEPHIR_INIT_NVAR(_54$$14); ZVAL_STRING(_54$$14, "", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_65$$14); ZVAL_LONG(_65$$14, (tab + 1)); ZEPHIR_CALL_METHOD(&_64$$14, this_ptr, "output", &_23, 175, value, _54$$14, _65$$14); zephir_check_temp_parameter(_54$$14); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_66$$14); ZEPHIR_CONCAT_VS(_66$$14, _64$$14, "\n"); zephir_concat_self(&output, _66$$14 TSRMLS_CC); } while (zephir_is_true(attr)); } ZEPHIR_CALL_FUNCTION(&attr, "get_class_methods", NULL, 179, variable); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_29$$8); ZVAL_LONG(&_29$$8, tab); ZEPHIR_CALL_FUNCTION(&_67$$8, "str_repeat", &_12, 142, space, &_29$$8); zephir_check_call_status(); ZEPHIR_INIT_VAR(_68$$8); zephir_create_array(_68$$8, 3, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(_28$$8); ZVAL_STRING(_28$$8, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_69$$8, this_ptr, "getstyle", &_4, 0, _28$$8); zephir_check_temp_parameter(_28$$8); zephir_check_call_status(); zephir_array_update_string(&_68$$8, SL(":style"), &_69$$8, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_28$$8); zephir_get_class(_28$$8, variable, 0 TSRMLS_CC); zephir_array_update_string(&_68$$8, SL(":class"), &_28$$8, PH_COPY | PH_SEPARATE); add_assoc_long_ex(_68$$8, SS(":count"), zephir_fast_count_int(attr TSRMLS_CC)); ZEPHIR_SINIT_NVAR(_29$$8); ZVAL_STRING(&_29$$8, ":class <b style=':style'>methods</b>: (<span style=':style'>:count</span>) (\n", 0); ZEPHIR_CALL_FUNCTION(&_69$$8, "strtr", &_6, 26, &_29$$8, _68$$8); zephir_check_call_status(); ZEPHIR_INIT_VAR(_70$$8); ZEPHIR_CONCAT_VV(_70$$8, _67$$8, _69$$8); zephir_concat_self(&output, _70$$8 TSRMLS_CC); ZEPHIR_INIT_NVAR(_28$$8); zephir_get_class(_28$$8, variable, 0 TSRMLS_CC); _71$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_methods"), PH_NOISY_CC); if (zephir_fast_in_array(_28$$8, _71$$8 TSRMLS_CC)) { ZEPHIR_SINIT_VAR(_72$$19); ZVAL_LONG(&_72$$19, tab); ZEPHIR_CALL_FUNCTION(&_73$$19, "str_repeat", &_12, 142, space, &_72$$19); zephir_check_call_status(); ZEPHIR_INIT_VAR(_74$$19); ZEPHIR_CONCAT_VS(_74$$19, _73$$19, "[already listed]\n"); zephir_concat_self(&output, _74$$19 TSRMLS_CC); } else { zephir_is_iterable(attr, &_76$$20, &_75$$20, 0, 0, "phalcon/debug/dump.zep", 226); for ( ; zephir_hash_get_current_data_ex(_76$$20, (void**) &_77$$20, &_75$$20) == SUCCESS ; zephir_hash_move_forward_ex(_76$$20, &_75$$20) ) { ZEPHIR_GET_HVALUE(value, _77$$20); ZEPHIR_INIT_NVAR(_78$$21); zephir_get_class(_78$$21, variable, 0 TSRMLS_CC); zephir_update_property_array_append(this_ptr, SL("_methods"), _78$$21 TSRMLS_CC); if (ZEPHIR_IS_STRING(value, "__construct")) { ZEPHIR_SINIT_NVAR(_79$$22); ZVAL_LONG(&_79$$22, (tab + 1)); ZEPHIR_CALL_FUNCTION(&_80$$22, "str_repeat", &_12, 142, space, &_79$$22); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_81$$22); zephir_create_array(_81$$22, 2, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(_83$$22); ZVAL_STRING(_83$$22, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_82$$22, this_ptr, "getstyle", &_4, 0, _83$$22); zephir_check_temp_parameter(_83$$22); zephir_check_call_status(); zephir_array_update_string(&_81$$22, SL(":style"), &_82$$22, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_81$$22, SL(":method"), &value, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_NVAR(_79$$22); ZVAL_STRING(&_79$$22, "-><span style=':style'>:method</span>(); [<b style=':style'>constructor</b>]\n", 0); ZEPHIR_CALL_FUNCTION(&_82$$22, "strtr", &_6, 26, &_79$$22, _81$$22); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_84$$22); ZEPHIR_CONCAT_VV(_84$$22, _80$$22, _82$$22); zephir_concat_self(&output, _84$$22 TSRMLS_CC); } else { ZEPHIR_SINIT_NVAR(_85$$23); ZVAL_LONG(&_85$$23, (tab + 1)); ZEPHIR_CALL_FUNCTION(&_86$$23, "str_repeat", &_12, 142, space, &_85$$23); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_87$$23); zephir_create_array(_87$$23, 2, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(_89$$23); ZVAL_STRING(_89$$23, "obj", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_88$$23, this_ptr, "getstyle", &_4, 0, _89$$23); zephir_check_temp_parameter(_89$$23); zephir_check_call_status(); zephir_array_update_string(&_87$$23, SL(":style"), &_88$$23, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_87$$23, SL(":method"), &value, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_NVAR(_85$$23); ZVAL_STRING(&_85$$23, "-><span style=':style'>:method</span>();\n", 0); ZEPHIR_CALL_FUNCTION(&_88$$23, "strtr", &_6, 26, &_85$$23, _87$$23); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_90$$23); ZEPHIR_CONCAT_VV(_90$$23, _86$$23, _88$$23); zephir_concat_self(&output, _90$$23 TSRMLS_CC); } } ZEPHIR_SINIT_VAR(_91$$20); ZVAL_LONG(&_91$$20, tab); ZEPHIR_CALL_FUNCTION(&_92$$20, "str_repeat", &_12, 142, space, &_91$$20); zephir_check_call_status(); ZEPHIR_INIT_VAR(_93$$20); ZEPHIR_CONCAT_VS(_93$$20, _92$$20, ")\n"); zephir_concat_self(&output, _93$$20 TSRMLS_CC); } ZEPHIR_SINIT_NVAR(_29$$8); ZVAL_LONG(&_29$$8, (tab - 1)); ZEPHIR_CALL_FUNCTION(&_94$$8, "str_repeat", &_12, 142, space, &_29$$8); zephir_check_call_status(); ZEPHIR_CONCAT_VVS(return_value, output, _94$$8, ")"); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_LONG) { ZEPHIR_INIT_VAR(_95$$24); zephir_create_array(_95$$24, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_97$$24); ZVAL_STRING(_97$$24, "int", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_96$$24, this_ptr, "getstyle", &_4, 0, _97$$24); zephir_check_temp_parameter(_97$$24); zephir_check_call_status(); zephir_array_update_string(&_95$$24, SL(":style"), &_96$$24, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_95$$24, SL(":var"), &variable, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_98$$24); ZVAL_STRING(&_98$$24, "<b style=':style'>Integer</b> (<span style=':style'>:var</span>)", 0); ZEPHIR_CALL_FUNCTION(&_96$$24, "strtr", &_6, 26, &_98$$24, _95$$24); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _96$$24); RETURN_MM(); } ZEPHIR_CALL_FUNCTION(&_99, "is_float", NULL, 180, variable); zephir_check_call_status(); if (zephir_is_true(_99)) { ZEPHIR_INIT_VAR(_100$$25); zephir_create_array(_100$$25, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_102$$25); ZVAL_STRING(_102$$25, "float", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_101$$25, this_ptr, "getstyle", &_4, 0, _102$$25); zephir_check_temp_parameter(_102$$25); zephir_check_call_status(); zephir_array_update_string(&_100$$25, SL(":style"), &_101$$25, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_100$$25, SL(":var"), &variable, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_103$$25); ZVAL_STRING(&_103$$25, "<b style=':style'>Float</b> (<span style=':style'>:var</span>)", 0); ZEPHIR_CALL_FUNCTION(&_101$$25, "strtr", &_6, 26, &_103$$25, _100$$25); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _101$$25); RETURN_MM(); } if (zephir_is_numeric(variable)) { ZEPHIR_INIT_VAR(_104$$26); zephir_create_array(_104$$26, 3, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_106$$26); ZVAL_STRING(_106$$26, "num", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_105$$26, this_ptr, "getstyle", &_4, 0, _106$$26); zephir_check_temp_parameter(_106$$26); zephir_check_call_status(); zephir_array_update_string(&_104$$26, SL(":style"), &_105$$26, PH_COPY | PH_SEPARATE); add_assoc_long_ex(_104$$26, SS(":length"), zephir_fast_strlen_ev(variable)); zephir_array_update_string(&_104$$26, SL(":var"), &variable, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_107$$26); ZVAL_STRING(&_107$$26, "<b style=':style'>Numeric string</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 0); ZEPHIR_CALL_FUNCTION(&_105$$26, "strtr", &_6, 26, &_107$$26, _104$$26); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _105$$26); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_STRING) { ZEPHIR_INIT_VAR(_108$$27); zephir_create_array(_108$$27, 3, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_110$$27); ZVAL_STRING(_110$$27, "str", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_109$$27, this_ptr, "getstyle", &_4, 0, _110$$27); zephir_check_temp_parameter(_110$$27); zephir_check_call_status(); zephir_array_update_string(&_108$$27, SL(":style"), &_109$$27, PH_COPY | PH_SEPARATE); add_assoc_long_ex(_108$$27, SS(":length"), zephir_fast_strlen_ev(variable)); ZEPHIR_SINIT_VAR(_111$$27); ZVAL_LONG(&_111$$27, 4); ZEPHIR_SINIT_VAR(_112$$27); ZVAL_STRING(&_112$$27, "utf-8", 0); ZEPHIR_CALL_FUNCTION(&_109$$27, "htmlentities", NULL, 161, variable, &_111$$27, &_112$$27); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_113$$27, "nl2br", NULL, 181, _109$$27); zephir_check_call_status(); zephir_array_update_string(&_108$$27, SL(":var"), &_113$$27, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_NVAR(_111$$27); ZVAL_STRING(&_111$$27, "<b style=':style'>String</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 0); ZEPHIR_CALL_FUNCTION(&_113$$27, "strtr", &_6, 26, &_111$$27, _108$$27); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _113$$27); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_BOOL) { ZEPHIR_INIT_VAR(_114$$28); zephir_create_array(_114$$28, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_116$$28); ZVAL_STRING(_116$$28, "bool", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_115$$28, this_ptr, "getstyle", &_4, 0, _116$$28); zephir_check_temp_parameter(_116$$28); zephir_check_call_status(); zephir_array_update_string(&_114$$28, SL(":style"), &_115$$28, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(_117$$28); if (zephir_is_true(variable)) { ZEPHIR_INIT_NVAR(_117$$28); ZVAL_STRING(_117$$28, "TRUE", 1); } else { ZEPHIR_INIT_NVAR(_117$$28); ZVAL_STRING(_117$$28, "FALSE", 1); } zephir_array_update_string(&_114$$28, SL(":var"), &_117$$28, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_118$$28); ZVAL_STRING(&_118$$28, "<b style=':style'>Boolean</b> (<span style=':style'>:var</span>)", 0); ZEPHIR_CALL_FUNCTION(&_115$$28, "strtr", &_6, 26, &_118$$28, _114$$28); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _115$$28); RETURN_MM(); } if (Z_TYPE_P(variable) == IS_NULL) { ZEPHIR_INIT_VAR(_119$$29); zephir_create_array(_119$$29, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_121$$29); ZVAL_STRING(_121$$29, "null", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_120$$29, this_ptr, "getstyle", &_4, 0, _121$$29); zephir_check_temp_parameter(_121$$29); zephir_check_call_status(); zephir_array_update_string(&_119$$29, SL(":style"), &_120$$29, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_122$$29); ZVAL_STRING(&_122$$29, "<b style=':style'>NULL</b>", 0); ZEPHIR_CALL_FUNCTION(&_120$$29, "strtr", &_6, 26, &_122$$29, _119$$29); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _120$$29); RETURN_MM(); } ZEPHIR_INIT_VAR(_123); zephir_create_array(_123, 2, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_125); ZVAL_STRING(_125, "other", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_124, this_ptr, "getstyle", &_4, 0, _125); zephir_check_temp_parameter(_125); zephir_check_call_status(); zephir_array_update_string(&_123, SL(":style"), &_124, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_123, SL(":var"), &variable, PH_COPY | PH_SEPARATE); ZEPHIR_SINIT_VAR(_126); ZVAL_STRING(&_126, "(<span style=':style'>:var</span>)", 0); ZEPHIR_CALL_FUNCTION(&_124, "strtr", &_6, 26, &_126, _123); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, output, _124); RETURN_MM(); }
/** * Generates random text in accordance with the template * * <code> * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob * echo Phalcon\Text::dynamic("[Hi/Hello], my name is a [Zyxep/Mark]!", '[', ']', '/'); // Hello my name is a Zyxep * </code> */ PHP_METHOD(Phalcon_Text, dynamic) { zend_bool _11$$6; HashTable *_9$$5; HashPosition _8$$5; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_14 = NULL, *_19 = NULL; zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ldS = NULL, *rdS = NULL, *pattern = NULL, *matches = NULL, *match = NULL, *words = NULL, *word = NULL, *sub = NULL, *_0 = NULL, *_2 = NULL, *_6, *_7 = NULL, *_3$$3, **_10$$5, *_12$$6, *_13$$6 = NULL, *_15$$6, *_16$$6 = NULL, *_17$$6 = NULL, *_18$$6 = NULL; zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_4$$3; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_param); if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(text_param) == IS_STRING)) { zephir_get_strval(text, text_param); } else { ZEPHIR_INIT_VAR(text); ZVAL_EMPTY_STRING(text); } if (!leftDelimiter_param) { ZEPHIR_INIT_VAR(leftDelimiter); ZVAL_STRING(leftDelimiter, "{", 1); } else { if (unlikely(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) { zephir_get_strval(leftDelimiter, leftDelimiter_param); } else { ZEPHIR_INIT_VAR(leftDelimiter); ZVAL_EMPTY_STRING(leftDelimiter); } } if (!rightDelimiter_param) { ZEPHIR_INIT_VAR(rightDelimiter); ZVAL_STRING(rightDelimiter, "}", 1); } else { if (unlikely(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) { zephir_get_strval(rightDelimiter, rightDelimiter_param); } else { ZEPHIR_INIT_VAR(rightDelimiter); ZVAL_EMPTY_STRING(rightDelimiter); } } if (!separator_param) { ZEPHIR_INIT_VAR(separator); ZVAL_STRING(separator, "|", 1); } else { if (unlikely(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(separator_param) == IS_STRING)) { zephir_get_strval(separator, separator_param); } else { ZEPHIR_INIT_VAR(separator); ZVAL_EMPTY_STRING(separator); } } ZEPHIR_CALL_FUNCTION(&_0, "substr_count", &_1, 445, text, leftDelimiter); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_2, "substr_count", &_1, 445, text, rightDelimiter); zephir_check_call_status(); if (!ZEPHIR_IS_IDENTICAL(_0, _2)) { ZEPHIR_INIT_VAR(_3$$3); object_init_ex(_3$$3, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(_4$$3); ZEPHIR_CONCAT_SVS(_4$$3, "Syntax error in string \"", text, "\""); ZEPHIR_CALL_METHOD(NULL, _3$$3, "__construct", NULL, 446, _4$$3); zephir_check_call_status(); zephir_throw_exception_debug(_3$$3, "phalcon/text.zep", 265 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", &_5, 447, leftDelimiter); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", &_5, 447, rightDelimiter); zephir_check_call_status(); ZEPHIR_INIT_VAR(pattern); ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ldS, "([^", ldS, rdS, "]+)", rdS, "/"); ZEPHIR_INIT_VAR(matches); array_init(matches); ZEPHIR_INIT_VAR(_6); ZVAL_LONG(_6, 2); ZEPHIR_MAKE_REF(matches); ZEPHIR_CALL_FUNCTION(&_7, "preg_match_all", NULL, 38, pattern, text, matches, _6); ZEPHIR_UNREF(matches); zephir_check_call_status(); if (!(zephir_is_true(_7))) { RETURN_CTOR(text); } if (Z_TYPE_P(matches) == IS_ARRAY) { zephir_is_iterable(matches, &_9$$5, &_8$$5, 0, 0, "phalcon/text.zep", 288); for ( ; zephir_hash_get_current_data_ex(_9$$5, (void**) &_10$$5, &_8$$5) == SUCCESS ; zephir_hash_move_forward_ex(_9$$5, &_8$$5) ) { ZEPHIR_GET_HVALUE(match, _10$$5); _11$$6 = !(zephir_array_isset_long(match, 0)); if (!(_11$$6)) { _11$$6 = !(zephir_array_isset_long(match, 1)); } if (_11$$6) { continue; } zephir_array_fetch_long(&_12$$6, match, 1, PH_NOISY | PH_READONLY, "phalcon/text.zep", 283 TSRMLS_CC); ZEPHIR_INIT_NVAR(words); zephir_fast_explode(words, separator, _12$$6, LONG_MAX TSRMLS_CC); ZEPHIR_OBS_NVAR(word); ZEPHIR_CALL_FUNCTION(&_13$$6, "array_rand", &_14, 448, words); zephir_check_call_status(); zephir_array_fetch(&word, words, _13$$6, PH_NOISY, "phalcon/text.zep", 284 TSRMLS_CC); zephir_array_fetch_long(&_15$$6, match, 0, PH_NOISY | PH_READONLY, "phalcon/text.zep", 285 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&sub, "preg_quote", &_5, 447, _15$$6, separator); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_16$$6); ZEPHIR_CONCAT_SVS(_16$$6, "/", sub, "/"); ZEPHIR_INIT_NVAR(_17$$6); ZVAL_LONG(_17$$6, 1); ZEPHIR_CALL_FUNCTION(&_18$$6, "preg_replace", &_19, 39, _16$$6, word, text, _17$$6); zephir_check_call_status(); zephir_get_strval(text, _18$$6); } } RETURN_CTOR(text); }
/** * @todo this method can be write differently with (P< style match * Matches a user submitted path with parts defined by a map. Assigns and * returns an array of variables on a successful match. * * @param string $path Path used to match against this routing map * @return array|false An array of assigned values or a false on a mismatch */ PHP_METHOD(Yaf_Route_Rewrite, _match) { zephir_nts_static zephir_fcall_cache_entry *_27 = NULL, *_33 = NULL; zend_bool _12, _28, _32; HashTable *_7, *_22, *_35; HashPosition _6, _21, _34; int staticCount, pathStaticCount, ZEPHIR_LAST_CALL_STATUS; zval *path_param = NULL, *values, *matchedPath = NULL, *parts, *variables, *wildcardData, *name = NULL, *part = NULL, *pos = NULL, *pathMatch, *count = NULL, *i = NULL, *varr = NULL, *pathPart = NULL, *tmpReturn = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, _4 = zval_used_for_init, _5 = zval_used_for_init, **_8, _9 = zval_used_for_init, _10 = zval_used_for_init, *_11 = NULL, _13 = zval_used_for_init, _14 = zval_used_for_init, *_15 = NULL, _16 = zval_used_for_init, _17 = zval_used_for_init, *_18 = NULL, _19 = zval_used_for_init, *_20 = NULL, **_23, *_24 = NULL, *_25, *_26, *_29 = NULL, *_30, *_31 = NULL, **_36; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path_param); zephir_get_strval(path, path_param); staticCount = 0; pathStaticCount = 0; ZEPHIR_INIT_VAR(values); array_init(values); ZEPHIR_INIT_VAR(matchedPath); ZVAL_STRING(matchedPath, "", 1); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(variables); array_init(variables); ZEPHIR_INIT_VAR(wildcardData); array_init(wildcardData); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); if (!ZEPHIR_IS_STRING_IDENTICAL(_0, "")) { ZEPHIR_INIT_VAR(_1); ZEPHIR_INIT_VAR(_2); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_trim(_2, _3, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_SINIT_VAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_explode(_1, &_5, _2, LONG_MAX TSRMLS_CC); zephir_is_iterable(_1, &_7, &_6, 0, 0, "yaf/Route/rewrite.zep", 135); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(pos, _7, _6); ZEPHIR_GET_HVALUE(part, _8); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 0 , 1 , 0); _12 = ZEPHIR_IS_STRING(_11, ":"); if (_12) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_SINIT_NVAR(_14); ZVAL_LONG(&_14, 1); ZEPHIR_INIT_NVAR(_15); zephir_substr(_15, part, 1 , 1 , 0); _12 = !ZEPHIR_IS_STRING(_15, ":"); } if (_12) { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_NVAR(name); zephir_substr(name, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&parts, pos, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE); zephir_array_update_zval(&variables, pos, &name, PH_COPY | PH_SEPARATE); } else { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 0); ZEPHIR_SINIT_NVAR(_17); ZVAL_LONG(&_17, 1); ZEPHIR_INIT_NVAR(_18); zephir_substr(_18, part, 0 , 1 , 0); if (ZEPHIR_IS_STRING(_18, ":")) { ZEPHIR_SINIT_NVAR(_19); ZVAL_LONG(&_19, 1); ZEPHIR_INIT_NVAR(_20); zephir_substr(_20, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _20); } zephir_array_update_zval(&parts, pos, &part, PH_COPY | PH_SEPARATE); if (!ZEPHIR_IS_STRING_IDENTICAL(part, "*")) { staticCount++; } } } } if (!ZEPHIR_IS_STRING_IDENTICAL(path, "")) { ZEPHIR_INIT_VAR(pathMatch); ZEPHIR_SINIT_NVAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_explode(pathMatch, &_4, path, LONG_MAX TSRMLS_CC); zephir_is_iterable(pathMatch, &_22, &_21, 0, 0, "yaf/Route/rewrite.zep", 193); for ( ; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS ; zephir_hash_move_forward_ex(_22, &_21) ) { ZEPHIR_GET_HMKEY(pos, _22, _21); ZEPHIR_GET_HVALUE(pathPart, _23); if (!(zephir_array_key_exists(parts, pos TSRMLS_CC))) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_LNVAR(_24); ZEPHIR_CONCAT_VS(_24, pathPart, "/"); zephir_concat_self(&matchedPath, _24 TSRMLS_CC); zephir_array_fetch(&_25, parts, pos, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 150 TSRMLS_CC); if (ZEPHIR_IS_STRING(_25, "*")) { ZEPHIR_INIT_NVAR(count); ZVAL_LONG(count, zephir_fast_count_int(pathMatch TSRMLS_CC)); ZEPHIR_CPY_WRT(i, pos); while (1) { if (!(ZEPHIR_LT(i, count))) { break; } zephir_array_fetch(&_26, pathMatch, i, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 154 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&varr, "urldecode", &_27, _26); zephir_check_call_status(); _12 = !(zephir_array_isset(wildcardData, varr)); if (_12) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); _12 = !(zephir_array_isset(_3, varr)); } _28 = _12; if (_28) { _28 = !(zephir_array_isset(values, varr)); } if (_28) { ZEPHIR_INIT_LNVAR(_29); if (zephir_array_isset_long(pathMatch, (zephir_get_numberval(i) + 1))) { zephir_array_fetch_long(&_30, pathMatch, (zephir_get_numberval(i) + 1), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 157 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_29, "urldecode", &_27, _30); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_29); ZVAL_NULL(_29); } zephir_array_update_zval(&wildcardData, varr, &_29, PH_COPY | PH_SEPARATE); } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, 2); ZEPHIR_ADD_ASSIGN(i, _1); } ZEPHIR_INIT_NVAR(matchedPath); ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_join(matchedPath, &_5, pathMatch TSRMLS_CC); break; } if (zephir_array_isset(variables, pos)) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch(&name, variables, pos, PH_NOISY, "yaf/Route/rewrite.zep", 165 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(name); ZVAL_NULL(name); } ZEPHIR_CALL_FUNCTION(&_31, "urldecode", &_27, pathPart); zephir_check_call_status(); ZEPHIR_CPY_WRT(pathPart, _31); ZEPHIR_OBS_NVAR(part); zephir_array_fetch(&part, parts, pos, PH_NOISY, "yaf/Route/rewrite.zep", 167 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 2); ZEPHIR_INIT_NVAR(_2); zephir_substr(_2, part, 0 , 2 , 0); if (ZEPHIR_IS_STRING_IDENTICAL(_2, "@@")) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _11); } _28 = Z_TYPE_P(name) == IS_NULL; if (_28) { _28 = !ZEPHIR_IS_EQUAL(part, pathPart); } if (_28) { RETURN_MM_BOOL(0); } _32 = Z_TYPE_P(part) != IS_NULL; if (_32) { ZEPHIR_INIT_LNVAR(_29); ZEPHIR_CONCAT_VSSS(_29, part, "#^", "$#", "iu"); ZEPHIR_CALL_FUNCTION(&_31, "preg_match", &_33, _29, pathPart); zephir_check_call_status(); _32 = !zephir_is_true(_31); } if (_32) { RETURN_MM_BOOL(0); } if (Z_TYPE_P(name) != IS_NULL) { zephir_array_update_zval(&values, name, &pathPart, PH_COPY | PH_SEPARATE); } else { pathStaticCount++; } } } if (staticCount != pathStaticCount) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(tmpReturn); zephir_add_function_ex(tmpReturn, values, wildcardData TSRMLS_CC); zephir_is_iterable(variables, &_35, &_34, 0, 0, "yaf/Route/rewrite.zep", 212); for ( ; zephir_hash_get_current_data_ex(_35, (void**) &_36, &_34) == SUCCESS ; zephir_hash_move_forward_ex(_35, &_34) ) { ZEPHIR_GET_HVALUE(varr, _36); if (!(zephir_array_key_exists(tmpReturn, varr TSRMLS_CC))) { RETURN_MM_BOOL(0); } } _12 = Z_TYPE_P(values) == IS_NULL; if (_12) { _12 = Z_TYPE_P(wildcardData) == IS_NULL; } _32 = _12; if (_32) { _32 = staticCount != 0; } if (_32) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); ZEPHIR_INIT_LNVAR(_24); zephir_add_function_ex(_24, tmpReturn, _3 TSRMLS_CC); ZEPHIR_CPY_WRT(tmpReturn, _24); } RETURN_CCTOR(tmpReturn); }