/**
* Check if the current page use SSL connection on not
*
* @return bool uses SSL
*/
PHP_METHOD(Phady_Util_Tools, usingSecureMode) {
zval *_SERVER, *_0, *_2 = NULL, *_3;
zend_bool secureMode, _1;
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
if (zephir_array_isset_string(_SERVER, SS("HTTPS"))) {
zephir_array_fetch_string(&_0, _SERVER, SL("HTTPS"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 113 TSRMLS_CC);
_1 = ZEPHIR_IS_LONG(_0, 1);
if (!(_1)) {
ZEPHIR_INIT_VAR(_2);
zephir_array_fetch_string(&_3, _SERVER, SL("HTTPS"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 113 TSRMLS_CC);
zephir_fast_strtolower(_2, _3);
_1 = ZEPHIR_IS_STRING(_2, "on");
}
secureMode = _1;
} else if (zephir_array_isset_string(_SERVER, SS("SSL"))) {
zephir_array_fetch_string(&_0, _SERVER, SL("SSL"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 117 TSRMLS_CC);
_1 = ZEPHIR_IS_LONG(_0, 1);
if (!(_1)) {
ZEPHIR_INIT_NVAR(_2);
zephir_array_fetch_string(&_3, _SERVER, SL("SSL"), PH_NOISY | PH_READONLY, "phady/util/tools.zep", 117 TSRMLS_CC);
zephir_fast_strtolower(_2, _3);
_1 = ZEPHIR_IS_STRING(_2, "on");
}
secureMode = _1;
} else {
secureMode = 0;
}
RETURN_MM_BOOL(secureMode);
}
PHP_METHOD(Auryn_AbstractCachingReflector, getMethod) {
zend_class_entry *_3;
int ZEPHIR_LAST_CALL_STATUS;
zval *methodName = NULL;
zval *classNameOrInstance, *methodName_param = NULL, *className = NULL, *cacheKey, *reflectedMethod = NULL, *_0, *_1, *_2, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &classNameOrInstance, &methodName_param);
if (unlikely(Z_TYPE_P(methodName_param) != IS_STRING && Z_TYPE_P(methodName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'methodName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(methodName_param) == IS_STRING)) {
methodName = methodName_param;
} else {
ZEPHIR_INIT_VAR(methodName);
ZVAL_EMPTY_STRING(methodName);
}
if (Z_TYPE_P(classNameOrInstance) == IS_STRING) {
ZEPHIR_CPY_WRT(className, classNameOrInstance);
} else {
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, classNameOrInstance, 0 TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, className);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strtolower(_1, methodName);
ZEPHIR_INIT_VAR(cacheKey);
ZEPHIR_CONCAT_SVSV(cacheKey, "auryn.refls.methods.", _0, ".", _1);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&reflectedMethod, _2, "fetch", NULL, cacheKey);
zephir_check_call_status();
if (!(zephir_is_true(reflectedMethod))) {
ZEPHIR_INIT_BNVAR(reflectedMethod);
_3 = zend_fetch_class(SL("ReflectionMethod"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(reflectedMethod, _3);
ZEPHIR_CALL_METHOD(NULL, reflectedMethod, "__construct", NULL, className, methodName);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _4, "store", NULL, cacheKey, reflectedMethod);
zephir_check_call_status();
}
RETURN_CCTOR(reflectedMethod);
}
/**
* Writes parsed annotations to XCache
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Xcache, write) {
int ZEPHIR_LAST_CALL_STATUS;
zval *key_param = NULL, *data, *_0, *_2 = NULL;
zval *key = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &key_param, &data);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "_PHAN", key);
zephir_fast_strtolower(_0, _1);
ZEPHIR_CALL_FUNCTION(&_2, "serialize", NULL, 11, data);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "xcache_set", NULL, 12, _0, _2);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Check whether a model is already initialized
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, isInitialized) {
zval *modelName_param = NULL, *_0, *_1;
zval *modelName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &modelName_param);
if (unlikely(Z_TYPE_P(modelName_param) != IS_STRING && Z_TYPE_P(modelName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'modelName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(modelName_param) == IS_STRING)) {
zephir_get_strval(modelName, modelName_param);
} else {
ZEPHIR_INIT_VAR(modelName);
ZVAL_EMPTY_STRING(modelName);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strtolower(_1, modelName);
RETURN_MM_BOOL(zephir_array_isset(_0, _1));
}
/**
* Writes parsed annotations to memory
*
* @param string key
* @param Phalcon\Annotations\Reflection data
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Memory, write) {
zval *key_param = NULL, *data, *lowercasedKey;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &key_param, &data);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
ZEPHIR_INIT_VAR(lowercasedKey);
zephir_fast_strtolower(lowercasedKey, key);
zephir_update_property_array(this_ptr, SL("_data"), lowercasedKey, data TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Reads parsed annotations from memory
*
* @param string key
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Memory, read) {
zval *key_param = NULL, *data, *_0, *_1;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &key_param);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strtolower(_1, key);
if (zephir_array_isset_fetch(&data, _0, _1, 1 TSRMLS_CC)) {
RETURN_CTOR(data);
}
RETURN_MM_BOOL(0);
}
PHP_METHOD(Test_BuiltIn_StringMethods, getLower) {
zval *str_param = NULL, _0;
zval str;
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(&str);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &str_param);
zephir_get_strval(&str, str_param);
ZEPHIR_INIT_VAR(&_0);
zephir_fast_strtolower(&_0, &str);
RETURN_CCTOR(_0);
}
/**
* Reads parsed annotations from APC
*
* @param string key
* @return \Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Apc, read) {
int ZEPHIR_LAST_CALL_STATUS;
zval *key_param = NULL, *_0, *_1, *_2;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &key_param);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
ZEPHIR_INIT_VAR(_0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SVV(_2, "_PHAN", _1, key);
zephir_fast_strtolower(_0, _2);
ZEPHIR_RETURN_CALL_FUNCTION("apc_fetch", NULL, 82, _0);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(Auryn_AbstractCachingReflector, getCtorParams) {
int ZEPHIR_LAST_CALL_STATUS;
zval *className_param = NULL, *cacheKey, *reflectedCtorParams = NULL, *reflectedCtor = NULL, *_0, *_1, *_2;
zval *className = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className_param);
if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(className_param) == IS_STRING)) {
className = className_param;
} else {
ZEPHIR_INIT_VAR(className);
ZVAL_EMPTY_STRING(className);
}
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, className);
ZEPHIR_INIT_VAR(cacheKey);
ZEPHIR_CONCAT_SV(cacheKey, "auryn.refls.ctor-params.", _0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&reflectedCtorParams, _1, "fetch", NULL, cacheKey);
zephir_check_call_status();
if (zephir_is_true(reflectedCtorParams)) {
RETURN_CCTOR(reflectedCtorParams);
} else {
ZEPHIR_CALL_METHOD(&reflectedCtor, this_ptr, "getctor", NULL, className);
zephir_check_call_status();
if (zephir_is_true(reflectedCtor)) {
ZEPHIR_CALL_METHOD(&reflectedCtorParams, reflectedCtor, "getparameters", NULL);
zephir_check_call_status();
} else {
ZEPHIR_INIT_BNVAR(reflectedCtorParams);
ZVAL_NULL(reflectedCtorParams);
}
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _2, "store", NULL, cacheKey, reflectedCtorParams);
zephir_check_call_status();
RETURN_CCTOR(reflectedCtorParams);
}
PHP_METHOD(Test_BuiltIn_StringMethods, getLower) {
zval *str_param = NULL, *_0;
zval *str = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &str_param);
zephir_get_strval(str, str_param);
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, str);
RETURN_CCTOR(_0);
}
/**
* Lowercases a string, this function makes use of the mbstring extension if available
*
* <code>
* echo Phalcon\Text::lower("HELLO"); // hello
* </code>
*/
PHP_METHOD(Phalcon_Text, lower) {
int ZEPHIR_LAST_CALL_STATUS;
zval *str_param = NULL, *encoding_param = NULL;
zval *str = NULL, *encoding = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &str_param, &encoding_param);
if (unlikely(Z_TYPE_P(str_param) != IS_STRING && Z_TYPE_P(str_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(str_param) == IS_STRING)) {
zephir_get_strval(str, str_param);
} else {
ZEPHIR_INIT_VAR(str);
ZVAL_EMPTY_STRING(str);
}
if (!encoding_param) {
ZEPHIR_INIT_VAR(encoding);
ZVAL_STRING(encoding, "UTF-8", 1);
} else {
if (unlikely(Z_TYPE_P(encoding_param) != IS_STRING && Z_TYPE_P(encoding_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'encoding' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(encoding_param) == IS_STRING)) {
zephir_get_strval(encoding, encoding_param);
} else {
ZEPHIR_INIT_VAR(encoding);
ZVAL_EMPTY_STRING(encoding);
}
}
if ((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtolower", NULL, 193, str, encoding);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtolower(return_value, str);
RETURN_MM();
}
/**
* Retrieve the method
* @return string
*/
PHP_METHOD(Yaf_Request_Abstract, getMethod) {
zend_bool _3;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *method = NULL, *sapiType = NULL, *_0, *_1 = NULL, _4, _5, *_6, *_7;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("method"), PH_NOISY_CC);
if (Z_TYPE_P(_0) == IS_NULL) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "REQUEST_METHOD", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&method, this_ptr, "getserver", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(method)) {
zephir_update_property_this(this_ptr, SL("method"), method TSRMLS_CC);
} else {
ZEPHIR_CALL_FUNCTION(&sapiType, "php_sapi_name", &_2);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
zephir_fast_strtolower(_1, sapiType);
_3 = ZEPHIR_IS_STRING(_1, "cli");
if (!(_3)) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 0);
ZEPHIR_SINIT_VAR(_5);
ZVAL_LONG(&_5, 3);
ZEPHIR_INIT_VAR(_6);
zephir_substr(_6, sapiType, 0 , 3 , 0);
_3 = ZEPHIR_IS_STRING(_6, "cgi");
}
if (_3) {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_STRING(_7, "CLI", 1);
zephir_update_property_this(this_ptr, SL("method"), _7 TSRMLS_CC);
} else {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_STRING(_7, "Unknown", 1);
zephir_update_property_this(this_ptr, SL("method"), _7 TSRMLS_CC);
}
}
}
RETURN_MM_MEMBER(this_ptr, "method");
}
/**
* Sets the element's HTML tag.
*
* @param string tag
* @return \Xpl\HtmlElement
*/
PHP_METHOD(Xpl_HtmlElement, setTag) {
zval *tag_param = NULL, *_0;
zval *tag = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &tag_param);
zephir_get_strval(tag, tag_param);
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, tag);
zephir_update_property_this(this_ptr, SL("_tag"), _0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Allows read-only access to the "value" property, "constant" name, and "default" value.
*
* @param string var One of "value", "constant" or "default".
* @return mixed
*
* @throws \OverflowException if var is not "value", "constant" or "default".
*/
PHP_METHOD(Xpl_Enum, __get) {
int ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, *_0, *_1$$6;
zval *property = NULL, *_2$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
zephir_get_strval(property, property_param);
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, property);
do {
if (ZEPHIR_IS_STRING(_0, "value")) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getvalue", NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(_0, "constant")) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getconstantname", NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(_0, "default")) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getdefaultvalue", NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_INIT_VAR(_1$$6);
object_init_ex(_1$$6, spl_ce_OverflowException);
ZEPHIR_INIT_VAR(_2$$6);
ZEPHIR_CONCAT_SV(_2$$6, "Invalid property: ", property);
ZEPHIR_CALL_METHOD(NULL, _1$$6, "__construct", NULL, 99, _2$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$6, "xpl/enum.zep", 118 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
} while(0);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Auryn_AbstractCachingReflector, getFunction) {
zend_class_entry *_1;
int ZEPHIR_LAST_CALL_STATUS;
zval *functionName_param = NULL, *lowFunc, *cacheKey, *reflectedFunc = NULL, *_0, *_2;
zval *functionName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &functionName_param);
if (unlikely(Z_TYPE_P(functionName_param) != IS_STRING && Z_TYPE_P(functionName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'functionName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(functionName_param) == IS_STRING)) {
functionName = functionName_param;
} else {
ZEPHIR_INIT_VAR(functionName);
ZVAL_EMPTY_STRING(functionName);
}
ZEPHIR_INIT_VAR(lowFunc);
zephir_fast_strtolower(lowFunc, functionName);
ZEPHIR_INIT_VAR(cacheKey);
ZEPHIR_CONCAT_SV(cacheKey, "auryn.refls.funcs.", lowFunc);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&reflectedFunc, _0, "fetch", NULL, cacheKey);
zephir_check_call_status();
if (!(zephir_is_true(reflectedFunc))) {
ZEPHIR_INIT_BNVAR(reflectedFunc);
_1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(reflectedFunc, _1);
ZEPHIR_CALL_METHOD(NULL, reflectedFunc, "__construct", NULL, functionName);
zephir_check_call_status();
_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _2, "store", NULL, cacheKey, reflectedFunc);
zephir_check_call_status();
}
RETURN_CCTOR(reflectedFunc);
}
/**
* @var mixed input The text to sanitize
*/
PHP_METHOD(Phalcon_Filter_Sanitize_Lower, __invoke) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *input_param = NULL, _0$$3, _1$$3, _2;
zval input;
zval *this_ptr = getThis();
ZVAL_UNDEF(&input);
ZVAL_UNDEF(&_0$$3);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &input_param);
if (UNEXPECTED(Z_TYPE_P(input_param) != IS_STRING && Z_TYPE_P(input_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'input' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(input_param) == IS_STRING)) {
zephir_get_strval(&input, input_param);
} else {
ZEPHIR_INIT_VAR(&input);
ZVAL_EMPTY_STRING(&input);
}
if (1 == (zephir_function_exists_ex(SL("mb_convert_case") TSRMLS_CC) == SUCCESS)) {
ZVAL_LONG(&_0$$3, 1);
ZEPHIR_INIT_VAR(&_1$$3);
ZVAL_STRING(&_1$$3, "UTF-8");
ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_case", NULL, 189, &input, &_0$$3, &_1$$3);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 190, &input);
zephir_check_call_status();
zephir_fast_strtolower(return_value, &_2);
RETURN_MM();
}
/**
* Reads parsed annotations from XCache
*
* @param string key
* @return Phalcon\Annotations\Reflection
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Xcache, read) {
int ZEPHIR_LAST_CALL_STATUS;
zval *key_param = NULL, *serialized = NULL, *data = NULL, *_0;
zval *key = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &key_param);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "_PHAN", key);
zephir_fast_strtolower(_0, _1);
ZEPHIR_CALL_FUNCTION(&serialized, "xcache_get", NULL, 9, _0);
zephir_check_call_status();
if (Z_TYPE_P(serialized) == IS_STRING) {
ZEPHIR_CALL_FUNCTION(&data, "unserialize", NULL, 10, serialized);
zephir_check_call_status();
if (Z_TYPE_P(data) == IS_OBJECT) {
RETURN_CCTOR(data);
}
}
RETURN_MM_BOOL(0);
}
/**
* Shows a backtrace item
*/
PHP_METHOD(Phalcon_Debug, showTraceItem) {
zephir_fcall_cache_entry *_16 = NULL;
HashTable *_14;
HashPosition _13;
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL, *_8 = NULL, *_11 = NULL, *_12 = NULL, *_19 = NULL, *_24 = NULL;
zval *_1, *_18 = NULL;
zval *trace = NULL;
zval *n_param = NULL, *trace_param = NULL, *space, *twoSpaces, *underscore, *minus, *className, *namespaceSeparator, *prepareInternalClass, *preparedFunctionName, *html = NULL, *classReflection, *prepareUriClass, *functionName, *functionReflection, *traceArgs, *arguments, *argument = NULL, *filez, *line = NULL, *showFiles, *lines = NULL, *numberLines, *showFileFragment, *beforeLine, *afterLine, *lastLine = NULL, *commentPattern, *utf8, *entCompat, *tab, *comment, linePosition = zval_used_for_init, *currentLine = NULL, _0, *_2 = NULL, *_3 = NULL, *_5 = NULL, *_7 = NULL, *_9 = NULL, *_10, **_15, *_17, _20 = zval_used_for_init, _21, *_22, *_23 = NULL;
int n, firstLine, i, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &n_param, &trace_param);
n = zephir_get_intval(n_param);
trace = trace_param;
ZEPHIR_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
ZEPHIR_INIT_VAR(twoSpaces);
ZVAL_STRING(twoSpaces, " ", 1);
ZEPHIR_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
ZEPHIR_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, n);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", &_0, "</td><td>");
ZEPHIR_CPY_WRT(html, _1);
if (zephir_array_isset_string(trace, SS("class"))) {
ZEPHIR_OBS_VAR(className);
zephir_array_fetch_string(&className, trace, SL("class"), PH_NOISY, "phalcon/debug.zep", 355 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "/^Phalcon/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_3, "preg_match", &_4, _2, className);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (zephir_is_true(_3)) {
ZEPHIR_INIT_VAR(namespaceSeparator);
ZVAL_STRING(namespaceSeparator, "\\", 1);
ZEPHIR_INIT_VAR(prepareUriClass);
zephir_fast_str_replace(&prepareUriClass, namespaceSeparator, underscore, className TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_SVSVS(_5, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepareUriClass, ".html\">", className, "</a></span>");
zephir_concat_self(&html, _5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(classReflection);
object_init_ex(classReflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, classReflection, "__construct", &_6, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_7, classReflection, "isinternal", &_8);
zephir_check_call_status();
if (zephir_is_true(_7)) {
ZEPHIR_INIT_VAR(prepareInternalClass);
ZEPHIR_INIT_NVAR(_2);
zephir_fast_strtolower(_2, className);
zephir_fast_str_replace(&prepareInternalClass, underscore, minus, _2 TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SVSVS(_5, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepareInternalClass, ".php\">", className, "</a></span>");
zephir_concat_self(&html, _5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_SVS(_9, "<span class=\"error-class\">", className, "</span>");
zephir_concat_self(&html, _9 TSRMLS_CC);
}
}
zephir_array_fetch_string(&_10, trace, SL("type"), PH_NOISY | PH_READONLY, "phalcon/debug.zep", 396 TSRMLS_CC);
zephir_concat_self(&html, _10 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(functionName);
zephir_array_fetch_string(&functionName, trace, SL("function"), PH_NOISY, "phalcon/debug.zep", 402 TSRMLS_CC);
if (zephir_array_isset_string(trace, SS("class"))) {
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SVS(_5, "<span class=\"error-function\">", functionName, "</span>");
zephir_concat_self(&html, _5 TSRMLS_CC);
} else {
if ((zephir_function_exists(functionName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_VAR(functionReflection);
object_init_ex(functionReflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, functionReflection, "__construct", &_11, functionName);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_3, functionReflection, "isinternal", &_12);
zephir_check_call_status();
if (zephir_is_true(_3)) {
ZEPHIR_INIT_VAR(preparedFunctionName);
zephir_fast_str_replace(&preparedFunctionName, underscore, minus, functionName TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", preparedFunctionName, ".php\">", functionName, "</a></span>");
zephir_concat_self(&html, _9 TSRMLS_CC);
} else {
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVS(_9, "<span class=\"error-function\">", functionName, "</span>");
zephir_concat_self(&html, _9 TSRMLS_CC);
}
} else {
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SVS(_5, "<span class=\"error-function\">", functionName, "</span>");
zephir_concat_self(&html, _5 TSRMLS_CC);
}
}
if (zephir_array_isset_string(trace, SS("args"))) {
ZEPHIR_OBS_VAR(traceArgs);
zephir_array_fetch_string(&traceArgs, trace, SL("args"), PH_NOISY, "phalcon/debug.zep", 436 TSRMLS_CC);
if (zephir_fast_count_int(traceArgs TSRMLS_CC)) {
ZEPHIR_INIT_VAR(arguments);
array_init(arguments);
zephir_is_iterable(traceArgs, &_14, &_13, 0, 0, "phalcon/debug.zep", 451);
for (
; zephir_hash_get_current_data_ex(_14, (void**) &_15, &_13) == SUCCESS
; zephir_hash_move_forward_ex(_14, &_13)
) {
ZEPHIR_GET_HVALUE(argument, _15);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "_getvardump", &_16, argument);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SVS(_5, "<span class=\"error-parameter\">", _3, "</span>");
zephir_array_append(&arguments, _5, PH_SEPARATE, "phalcon/debug.zep", 445);
}
ZEPHIR_INIT_NVAR(_2);
zephir_fast_join_str(_2, SL(", "), arguments TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVS(_9, "(", _2, ")");
zephir_concat_self(&html, _9 TSRMLS_CC);
} else {
zephir_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(filez);
if (zephir_array_isset_string_fetch(&filez, trace, SS("file"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_17);
zephir_array_fetch_string(&_17, trace, SL("line"), PH_NOISY, "phalcon/debug.zep", 462 TSRMLS_CC);
zephir_get_strval(_18, _17);
ZEPHIR_CPY_WRT(line, _18);
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SVSVS(_5, "<br/><div class=\"error-file\">", filez, " (", line, ")</div>");
zephir_concat_self(&html, _5 TSRMLS_CC);
ZEPHIR_OBS_VAR(showFiles);
zephir_read_property_this(&showFiles, this_ptr, SL("_showFiles"), PH_NOISY_CC);
if (zephir_is_true(showFiles)) {
ZEPHIR_CALL_FUNCTION(&lines, "file", &_19, filez);
zephir_check_call_status();
ZEPHIR_INIT_VAR(numberLines);
ZVAL_LONG(numberLines, zephir_fast_count_int(lines TSRMLS_CC));
ZEPHIR_OBS_VAR(showFileFragment);
zephir_read_property_this(&showFileFragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
if (zephir_is_true(showFileFragment)) {
ZEPHIR_INIT_VAR(beforeLine);
ZVAL_LONG(beforeLine, (zephir_get_numberval(line) - 7));
if (ZEPHIR_LT_LONG(beforeLine, 1)) {
firstLine = 1;
} else {
firstLine = zephir_get_numberval(beforeLine);
}
ZEPHIR_INIT_VAR(afterLine);
ZVAL_LONG(afterLine, (zephir_get_numberval(line) + 5));
if (ZEPHIR_GT(afterLine, numberLines)) {
ZEPHIR_CPY_WRT(lastLine, numberLines);
} else {
ZEPHIR_CPY_WRT(lastLine, afterLine);
}
ZEPHIR_SINIT_VAR(_20);
ZVAL_LONG(&_20, firstLine);
ZEPHIR_SINIT_VAR(_21);
ZVAL_LONG(&_21, firstLine);
ZEPHIR_INIT_VAR(_22);
ZEPHIR_CONCAT_SVSVSVS(_22, "<pre class=\"prettyprint highlight:", &_20, ":", line, " linenums:", &_21, "\">");
zephir_concat_self(&html, _22 TSRMLS_CC);
} else {
firstLine = 1;
ZEPHIR_CPY_WRT(lastLine, numberLines);
ZEPHIR_SINIT_NVAR(_20);
ZVAL_LONG(&_20, firstLine);
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "<pre class=\"prettyprint highlight:", &_20, ":", line, " linenums error-scroll\">");
zephir_concat_self(&html, _9 TSRMLS_CC);
}
ZEPHIR_INIT_VAR(commentPattern);
ZVAL_STRING(commentPattern, "#\\*\\/#", 1);
ZEPHIR_INIT_VAR(utf8);
ZVAL_STRING(utf8, "UTF-8", 1);
ZEPHIR_INIT_VAR(entCompat);
ZVAL_LONG(entCompat, 2);
ZEPHIR_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
ZEPHIR_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
i = firstLine;
while (1) {
if (!(ZEPHIR_GE_LONG(lastLine, i))) {
break;
}
ZEPHIR_SINIT_NVAR(linePosition);
ZVAL_LONG(&linePosition, (i - 1));
ZEPHIR_OBS_NVAR(currentLine);
zephir_array_fetch(¤tLine, lines, &linePosition, PH_NOISY, "phalcon/debug.zep", 550 TSRMLS_CC);
if (zephir_is_true(showFileFragment)) {
if (i == firstLine) {
ZEPHIR_INIT_NVAR(_2);
zephir_fast_trim(_2, currentLine, NULL , ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_3, "preg_match", &_4, commentPattern, _2);
zephir_check_call_status();
if (zephir_is_true(_3)) {
ZEPHIR_INIT_NVAR(_23);
zephir_fast_str_replace(&_23, comment, space, currentLine TSRMLS_CC);
ZEPHIR_CPY_WRT(currentLine, _23);
}
}
}
if (ZEPHIR_IS_STRING(currentLine, "\n")) {
zephir_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (ZEPHIR_IS_STRING(currentLine, "\r\n")) {
zephir_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_23);
zephir_fast_str_replace(&_23, tab, twoSpaces, currentLine TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_7, "htmlentities", &_24, _23, entCompat, utf8);
zephir_check_call_status();
zephir_concat_self(&html, _7 TSRMLS_CC);
}
}
i++;
}
zephir_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CCTOR(html);
}
/**
* Gets a value from the internal related entity or from the default value
*/
PHP_METHOD(Phalcon_Forms_Form, getValue) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *entity = NULL, *method = NULL, *value = NULL, *data = NULL, *internal = NULL, *forbidden = NULL, *_1, *_0$$4;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
ZEPHIR_OBS_VAR(entity);
zephir_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if ((zephir_method_exists_ex(this_ptr, SS("getcustomvalue") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getcustomvalue", NULL, 0, name, entity, data);
zephir_check_call_status();
RETURN_MM();
}
if (Z_TYPE_P(entity) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0$$4);
zephir_camelize(_0$$4, name, NULL );
ZEPHIR_INIT_VAR(method);
ZEPHIR_CONCAT_SV(method, "get", _0$$4);
if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(entity, method, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_OBS_VAR(value);
if (zephir_fetch_property_zval(&value, entity, name, PH_SILENT_CC)) {
RETURN_CCTOR(value);
}
}
if (Z_TYPE_P(data) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_fetch(&value, data, name, 0 TSRMLS_CC)) {
RETURN_CCTOR(value);
}
}
ZEPHIR_INIT_VAR(forbidden);
zephir_create_array(forbidden, 12, 0 TSRMLS_CC);
zephir_array_update_string(&forbidden, SL("validation"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("action"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("useroption"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("useroptions"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("entity"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("elements"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("messages"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("messagesfor"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("label"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("value"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("di"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("eventsmanager"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(internal);
zephir_fast_strtolower(internal, name);
if (zephir_array_isset(forbidden, internal)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(_1);
zephir_camelize(_1, name, NULL );
ZEPHIR_INIT_NVAR(method);
ZEPHIR_CONCAT_SV(method, "get", _1);
if ((zephir_method_exists(this_ptr, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(this_ptr, method, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_NULL();
}
/**
* We have to cast values manually because parse_ini_file() has a poor implementation.
*
* @param mixed ini The array casted by `parse_ini_file`
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, _cast) {
zend_bool _5$$5, _6$$5, _8$$5, _9$$5;
HashTable *_1$$3;
HashPosition _0$$3;
zephir_fcall_cache_entry *_4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *ini, *key = NULL, *val = NULL, **_2$$3, *_3$$4 = NULL, *_7$$5, *_10$$5, *_11$$9, *_12$$9, _13$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &ini);
ZEPHIR_SEPARATE_PARAM(ini);
if (Z_TYPE_P(ini) == IS_ARRAY) {
zephir_is_iterable(ini, &_1$$3, &_0$$3, 1, 0, "phalcon/config/adapter/ini.zep", 134);
for (
; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zephir_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HMKEY(key, _1$$3, _0$$3);
ZEPHIR_GET_HVALUE(val, _2$$3);
ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "_cast", &_4, 135, val);
zephir_check_call_status();
zephir_array_update_zval(&ini, key, &_3$$4, PH_COPY | PH_SEPARATE);
}
zend_hash_destroy(_1$$3);
FREE_HASHTABLE(_1$$3);
}
if (Z_TYPE_P(ini) == IS_STRING) {
_5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "true");
if (!(_5$$5)) {
_5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "yes");
}
_6$$5 = _5$$5;
if (!(_6$$5)) {
ZEPHIR_INIT_VAR(_7$$5);
zephir_fast_strtolower(_7$$5, ini);
_6$$5 = ZEPHIR_IS_STRING_IDENTICAL(_7$$5, "on");
}
if (_6$$5) {
RETURN_MM_BOOL(1);
}
_8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "false");
if (!(_8$$5)) {
_8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "no");
}
_9$$5 = _8$$5;
if (!(_9$$5)) {
ZEPHIR_INIT_VAR(_10$$5);
zephir_fast_strtolower(_10$$5, ini);
_9$$5 = ZEPHIR_IS_STRING_IDENTICAL(_10$$5, "off");
}
if (_9$$5) {
RETURN_MM_BOOL(0);
}
if (ZEPHIR_IS_STRING_IDENTICAL(ini, "null")) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(ini)) {
ZEPHIR_INIT_VAR(_11$$9);
ZEPHIR_INIT_VAR(_12$$9);
ZEPHIR_SINIT_VAR(_13$$9);
ZVAL_STRING(&_13$$9, "/[.]+/", 0);
zephir_preg_match(_12$$9, &_13$$9, ini, _11$$9, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_12$$9)) {
RETURN_MM_DOUBLE(zephir_get_doubleval(ini));
} else {
RETURN_MM_LONG(zephir_get_intval(ini));
}
}
}
RETVAL_ZVAL(ini, 1, 0);
RETURN_MM();
}
PHP_METHOD(Auryn_AbstractCachingReflector, getParamTypeHint) {
int ZEPHIR_LAST_CALL_STATUS;
zval *function, *param, *lowParam, *lowClass, *lowMethod, *lowFunc, *paramCacheKey = NULL, *classCacheKey, *typeHint = NULL, *reflectionClass = NULL, *_0, *_1 = NULL, *_2, *_3, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &function, ¶m);
if (!(zephir_is_instance_of(function, SL("ReflectionFunctionAbstract") TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'function' must be an instance of 'ReflectionFunctionAbstract'", "", 0);
return;
}
if (!(zephir_is_instance_of(param, SL("ReflectionParameter") TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'param' must be an instance of 'ReflectionParameter'", "", 0);
return;
}
ZEPHIR_INIT_VAR(lowParam);
ZEPHIR_OBS_VAR(_0);
zephir_read_property(&_0, param, SL("name"), PH_NOISY_CC);
zephir_fast_strtolower(lowParam, _0);
if (zephir_is_instance_of(function, SL("ReflectionMethod") TSRMLS_CC)) {
ZEPHIR_INIT_VAR(lowClass);
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, function, SL("class"), PH_NOISY_CC);
zephir_fast_strtolower(lowClass, _1);
ZEPHIR_INIT_VAR(lowMethod);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, function, SL("name"), PH_NOISY_CC);
zephir_fast_strtolower(lowMethod, _2);
ZEPHIR_INIT_VAR(paramCacheKey);
ZEPHIR_CONCAT_SVSVSVSV(paramCacheKey, "auryn.refls.classes.", lowClass, ".", lowMethod, ".", param, "-", lowParam);
} else {
ZEPHIR_INIT_VAR(lowFunc);
ZEPHIR_OBS_NVAR(_1);
zephir_read_property(&_1, function, SL("name"), PH_NOISY_CC);
zephir_fast_strtolower(lowFunc, _1);
ZEPHIR_INIT_NVAR(paramCacheKey);
if (!ZEPHIR_IS_STRING(lowFunc, "{closure}")) {
ZEPHIR_CONCAT_SSVSVSV(paramCacheKey, "auryn.refls.funcs.", ".", lowFunc, ".", param, "-", lowParam);
} else {
ZVAL_NULL(paramCacheKey);
}
}
if (Z_TYPE_P(paramCacheKey) == IS_NULL) {
ZEPHIR_INIT_VAR(typeHint);
ZVAL_BOOL(typeHint, 0);
} else {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&typeHint, _3, "fetch", NULL, paramCacheKey);
zephir_check_call_status();
}
if (!ZEPHIR_IS_FALSE(typeHint)) {
RETURN_CCTOR(typeHint);
}
ZEPHIR_CALL_METHOD(&reflectionClass, param, "getclass", NULL);
zephir_check_call_status();
if (zephir_is_true(reflectionClass)) {
ZEPHIR_CALL_METHOD(&typeHint, reflectionClass, "getname", NULL);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
zephir_fast_strtolower(_4, typeHint);
ZEPHIR_INIT_VAR(classCacheKey);
ZEPHIR_CONCAT_SV(classCacheKey, "auryn.refls.classes.", _4);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _3, "store", NULL, classCacheKey, reflectionClass);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(typeHint);
ZVAL_NULL(typeHint);
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _3, "store", NULL, paramCacheKey, typeHint);
zephir_check_call_status();
RETURN_CCTOR(typeHint);
}
/**
* @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);
}
/**
* Shows a backtrace item
*/
PHP_METHOD(Phalcon_Debug, showTraceItem) {
zend_bool _40$$24;
HashTable *_18$$14;
HashPosition _17$$14;
zval *_1, *_26$$16 = NULL;
zephir_fcall_cache_entry *_21 = NULL, *_47 = NULL;
zval *trace = NULL;
zval *n_param = NULL, *trace_param = NULL, *className = NULL, *prepareInternalClass = NULL, *preparedFunctionName = NULL, *html = NULL, *classReflection = NULL, *prepareUriClass = NULL, *functionName = NULL, *functionReflection = NULL, *traceArgs = NULL, *arguments = NULL, *argument = NULL, *filez = NULL, *line = NULL, *showFiles = NULL, *lines = NULL, *numberLines = NULL, *showFileFragment = NULL, *beforeLine = NULL, *afterLine = NULL, *lastLine = NULL, *linePosition = NULL, *currentLine = NULL, *classNameWithLink = NULL, *functionNameWithLink = NULL, _0, *_16, *_2$$3, *_3$$3, _4$$3, *_11$$3, *_12$$3, _5$$4, _6$$4, *_7$$5 = NULL, *_8$$6, _9$$6, _10$$6, *_13$$10 = NULL, _14$$11, _15$$11, **_19$$14, *_23$$14, *_24$$14, *_20$$15 = NULL, *_22$$15 = NULL, *_25$$16, *_27$$16, _28$$18, _29$$18, *_30$$18, _31$$23, *_32$$23, *_33$$26 = NULL, *_34$$26 = NULL, *_35$$26 = NULL, _36$$26 = zval_used_for_init, *_37$$27 = NULL, _38$$27 = zval_used_for_init, _39$$27 = zval_used_for_init, *_41$$29 = NULL, _42$$29 = zval_used_for_init, _43$$29 = zval_used_for_init, _44$$29 = zval_used_for_init, _45$$29 = zval_used_for_init, *_46$$29 = NULL;
int n, ZEPHIR_LAST_CALL_STATUS, firstLine = 0, i = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &n_param, &trace_param);
n = zephir_get_intval(n_param);
trace = trace_param;
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, n);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", &_0, "</td><td>");
ZEPHIR_CPY_WRT(html, _1);
ZEPHIR_OBS_VAR(className);
if (zephir_array_isset_string_fetch(&className, trace, SS("class"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_2$$3);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_SINIT_VAR(_4$$3);
ZVAL_STRING(&_4$$3, "/^Phalcon/", 0);
zephir_preg_match(_3$$3, &_4$$3, className, _2$$3, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_3$$3)) {
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_STRING(&_5$$4, "\\", 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_STRING(&_6$$4, "/", 0);
ZEPHIR_INIT_VAR(prepareUriClass);
zephir_fast_str_replace(&prepareUriClass, &_5$$4, &_6$$4, className TSRMLS_CC);
ZEPHIR_INIT_VAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"//api.phalconphp.com/class/", prepareUriClass, ".html\">", className, "</a>");
} else {
ZEPHIR_INIT_VAR(classReflection);
object_init_ex(classReflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, classReflection, "__construct", NULL, 91, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_7$$5, classReflection, "isinternal", NULL, 163);
zephir_check_call_status();
if (zephir_is_true(_7$$5)) {
ZEPHIR_INIT_VAR(_8$$6);
zephir_fast_strtolower(_8$$6, className);
ZEPHIR_SINIT_VAR(_9$$6);
ZVAL_STRING(&_9$$6, "_", 0);
ZEPHIR_SINIT_VAR(_10$$6);
ZVAL_STRING(&_10$$6, "-", 0);
ZEPHIR_INIT_VAR(prepareInternalClass);
zephir_fast_str_replace(&prepareInternalClass, &_9$$6, &_10$$6, _8$$6 TSRMLS_CC);
ZEPHIR_INIT_NVAR(classNameWithLink);
ZEPHIR_CONCAT_SVSVS(classNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/class.", prepareInternalClass, ".php\">", className, "</a>");
} else {
ZEPHIR_CPY_WRT(classNameWithLink, className);
}
}
ZEPHIR_INIT_VAR(_11$$3);
ZEPHIR_CONCAT_SVS(_11$$3, "<span class=\"error-class\">", classNameWithLink, "</span>");
zephir_concat_self(&html, _11$$3 TSRMLS_CC);
zephir_array_fetch_string(&_12$$3, trace, SL("type"), PH_NOISY | PH_READONLY, "phalcon/debug.zep", 386 TSRMLS_CC);
zephir_concat_self(&html, _12$$3 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(functionName);
zephir_array_fetch_string(&functionName, trace, SL("function"), PH_NOISY, "phalcon/debug.zep", 392 TSRMLS_CC);
if (zephir_array_isset_string(trace, SS("class"))) {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
} else {
if ((zephir_function_exists(functionName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_VAR(functionReflection);
object_init_ex(functionReflection, zephir_get_internal_ce(SS("reflectionfunction") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, functionReflection, "__construct", NULL, 82, functionName);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_13$$10, functionReflection, "isinternal", NULL, 164);
zephir_check_call_status();
if (zephir_is_true(_13$$10)) {
ZEPHIR_SINIT_VAR(_14$$11);
ZVAL_STRING(&_14$$11, "_", 0);
ZEPHIR_SINIT_VAR(_15$$11);
ZVAL_STRING(&_15$$11, "-", 0);
ZEPHIR_INIT_VAR(preparedFunctionName);
zephir_fast_str_replace(&preparedFunctionName, &_14$$11, &_15$$11, functionName TSRMLS_CC);
ZEPHIR_INIT_NVAR(functionNameWithLink);
ZEPHIR_CONCAT_SVSVS(functionNameWithLink, "<a target=\"_new\" href=\"http://php.net/manual/en/function.", preparedFunctionName, ".php\">", functionName, "</a>");
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
} else {
ZEPHIR_CPY_WRT(functionNameWithLink, functionName);
}
}
ZEPHIR_INIT_VAR(_16);
ZEPHIR_CONCAT_SVS(_16, "<span class=\"error-function\">", functionNameWithLink, "</span>");
zephir_concat_self(&html, _16 TSRMLS_CC);
ZEPHIR_OBS_VAR(traceArgs);
if (zephir_array_isset_string_fetch(&traceArgs, trace, SS("args"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(arguments);
array_init(arguments);
zephir_is_iterable(traceArgs, &_18$$14, &_17$$14, 0, 0, "phalcon/debug.zep", 441);
for (
; zend_hash_get_current_data_ex(_18$$14, (void**) &_19$$14, &_17$$14) == SUCCESS
; zend_hash_move_forward_ex(_18$$14, &_17$$14)
) {
ZEPHIR_GET_HVALUE(argument, _19$$14);
ZEPHIR_CALL_METHOD(&_20$$15, this_ptr, "_getvardump", &_21, 0, argument);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_22$$15);
ZEPHIR_CONCAT_SVS(_22$$15, "<span class=\"error-parameter\">", _20$$15, "</span>");
zephir_array_append(&arguments, _22$$15, PH_SEPARATE, "phalcon/debug.zep", 435);
}
ZEPHIR_INIT_VAR(_23$$14);
zephir_fast_join_str(_23$$14, SL(", "), arguments TSRMLS_CC);
ZEPHIR_INIT_VAR(_24$$14);
ZEPHIR_CONCAT_SVS(_24$$14, "(", _23$$14, ")");
zephir_concat_self(&html, _24$$14 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(filez);
if (zephir_array_isset_string_fetch(&filez, trace, SS("file"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_25$$16);
zephir_array_fetch_string(&_25$$16, trace, SL("line"), PH_NOISY, "phalcon/debug.zep", 449 TSRMLS_CC);
zephir_get_strval(_26$$16, _25$$16);
ZEPHIR_CPY_WRT(line, _26$$16);
ZEPHIR_INIT_VAR(_27$$16);
ZEPHIR_CONCAT_SVSVS(_27$$16, "<br/><div class=\"error-file\">", filez, " (", line, ")</div>");
zephir_concat_self(&html, _27$$16 TSRMLS_CC);
ZEPHIR_OBS_VAR(showFiles);
zephir_read_property_this(&showFiles, this_ptr, SL("_showFiles"), PH_NOISY_CC);
if (zephir_is_true(showFiles)) {
ZEPHIR_CALL_FUNCTION(&lines, "file", NULL, 165, filez);
zephir_check_call_status();
ZEPHIR_INIT_VAR(numberLines);
ZVAL_LONG(numberLines, zephir_fast_count_int(lines TSRMLS_CC));
ZEPHIR_OBS_VAR(showFileFragment);
zephir_read_property_this(&showFileFragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
if (zephir_is_true(showFileFragment)) {
ZEPHIR_INIT_VAR(beforeLine);
ZVAL_LONG(beforeLine, (zephir_get_numberval(line) - 7));
if (ZEPHIR_LT_LONG(beforeLine, 1)) {
firstLine = 1;
} else {
firstLine = zephir_get_numberval(beforeLine);
}
ZEPHIR_INIT_VAR(afterLine);
ZVAL_LONG(afterLine, (zephir_get_numberval(line) + 5));
if (ZEPHIR_GT(afterLine, numberLines)) {
ZEPHIR_CPY_WRT(lastLine, numberLines);
} else {
ZEPHIR_CPY_WRT(lastLine, afterLine);
}
ZEPHIR_SINIT_VAR(_28$$18);
ZVAL_LONG(&_28$$18, firstLine);
ZEPHIR_SINIT_VAR(_29$$18);
ZVAL_LONG(&_29$$18, firstLine);
ZEPHIR_INIT_VAR(_30$$18);
ZEPHIR_CONCAT_SVSVSVS(_30$$18, "<pre class=\"prettyprint highlight:", &_28$$18, ":", line, " linenums:", &_29$$18, "\">");
zephir_concat_self(&html, _30$$18 TSRMLS_CC);
} else {
firstLine = 1;
ZEPHIR_CPY_WRT(lastLine, numberLines);
ZEPHIR_SINIT_VAR(_31$$23);
ZVAL_LONG(&_31$$23, firstLine);
ZEPHIR_INIT_VAR(_32$$23);
ZEPHIR_CONCAT_SVSVS(_32$$23, "<pre class=\"prettyprint highlight:", &_31$$23, ":", line, " linenums error-scroll\">");
zephir_concat_self(&html, _32$$23 TSRMLS_CC);
}
i = firstLine;
while (1) {
if (!(ZEPHIR_GE_LONG(lastLine, i))) {
break;
}
ZEPHIR_INIT_NVAR(linePosition);
ZVAL_LONG(linePosition, (i - 1));
ZEPHIR_OBS_NVAR(currentLine);
zephir_array_fetch(¤tLine, lines, linePosition, PH_NOISY, "phalcon/debug.zep", 522 TSRMLS_CC);
if (zephir_is_true(showFileFragment)) {
if (i == firstLine) {
ZEPHIR_INIT_NVAR(_33$$26);
ZEPHIR_INIT_NVAR(_34$$26);
ZEPHIR_INIT_NVAR(_35$$26);
zephir_fast_trim(_35$$26, currentLine, NULL , ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_36$$26);
ZVAL_STRING(&_36$$26, "#\\*\\/#", 0);
zephir_preg_match(_34$$26, &_36$$26, _35$$26, _33$$26, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_34$$26)) {
ZEPHIR_INIT_NVAR(_37$$27);
ZEPHIR_SINIT_NVAR(_38$$27);
ZVAL_STRING(&_38$$27, "* /", 0);
ZEPHIR_SINIT_NVAR(_39$$27);
ZVAL_STRING(&_39$$27, " ", 0);
zephir_fast_str_replace(&_37$$27, &_38$$27, &_39$$27, currentLine TSRMLS_CC);
ZEPHIR_CPY_WRT(currentLine, _37$$27);
}
}
}
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\n");
if (!(_40$$24)) {
_40$$24 = ZEPHIR_IS_STRING(currentLine, "\r\n");
}
if (_40$$24) {
zephir_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_41$$29);
ZEPHIR_SINIT_NVAR(_42$$29);
ZVAL_STRING(&_42$$29, "\t", 0);
ZEPHIR_SINIT_NVAR(_43$$29);
ZVAL_STRING(&_43$$29, " ", 0);
zephir_fast_str_replace(&_41$$29, &_42$$29, &_43$$29, currentLine TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_44$$29);
ZVAL_LONG(&_44$$29, 2);
ZEPHIR_SINIT_NVAR(_45$$29);
ZVAL_STRING(&_45$$29, "UTF-8", 0);
ZEPHIR_CALL_FUNCTION(&_46$$29, "htmlentities", &_47, 158, _41$$29, &_44$$29, &_45$$29);
zephir_check_call_status();
zephir_concat_self(&html, _46$$29 TSRMLS_CC);
}
i++;
}
zephir_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
zephir_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CCTOR(html);
}
/**
* Internal sanitize wrapper to filter_var
*/
PHP_METHOD(Phalcon_Filter, _sanitize) {
zephir_fcall_cache_entry *_8 = NULL;
zephir_nts_static zephir_fcall_cache_entry *_7 = NULL, *_9 = NULL, *_11 = NULL, *_12 = NULL, *_14 = NULL;
zval *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *filter = NULL, *_13;
zval *value, *filter_param = NULL, *filterObject, *_0, *_2 = NULL, _3 = zval_used_for_init, _4, _5, *_6 = NULL, *_10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &value, &filter_param);
if (unlikely(Z_TYPE_P(filter_param) != IS_STRING && Z_TYPE_P(filter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filter_param) == IS_STRING)) {
zephir_get_strval(filter, filter_param);
} else {
ZEPHIR_INIT_VAR(filter);
ZVAL_EMPTY_STRING(filter);
}
ZEPHIR_OBS_VAR(filterObject);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_filters"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&filterObject, _0, filter, 0 TSRMLS_CC)) {
if (zephir_instance_of_ev(filterObject, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_1, value);
ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, filterObject, _1);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_RETURN_CALL_METHOD(filterObject, "filter", NULL, value);
zephir_check_call_status();
RETURN_MM();
}
do {
if (ZEPHIR_IS_STRING(filter, "email")) {
ZEPHIR_INIT_VAR(_2);
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "'", 0);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "", 0);
zephir_fast_str_replace(&_2, &_3, &_4, value TSRMLS_CC);
ZEPHIR_SINIT_VAR(_5);
ZVAL_STRING(&_5, "FILTER_SANITIZE_EMAIL", 0);
ZEPHIR_CALL_FUNCTION(&_6, "constant", &_7, &_5);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_8, _2, _6);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "int")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 519);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_8, value, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "int!")) {
RETURN_MM_LONG(zephir_get_intval(value));
}
if (ZEPHIR_IS_STRING(filter, "absint")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, zephir_get_intval(value));
ZEPHIR_RETURN_CALL_FUNCTION("abs", &_9, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "string")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 513);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_8, value, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "float")) {
ZEPHIR_INIT_NVAR(_1);
zephir_create_array(_1, 1, 0 TSRMLS_CC);
add_assoc_long_ex(_1, SS("flags"), 4096);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 520);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_8, value, &_3, _1);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "float!")) {
RETURN_MM_DOUBLE(zephir_get_doubleval(value));
}
if (ZEPHIR_IS_STRING(filter, "alphanum")) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "/[^A-Za-z0-9]/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_10);
ZVAL_STRING(_10, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", &_11, _2, _10, value);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "trim")) {
zephir_fast_trim(return_value, value, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "striptags")) {
ZEPHIR_RETURN_CALL_FUNCTION("strip_tags", &_12, value);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "lower")) {
if ((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtolower", NULL, value);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtolower(return_value, value);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "upper")) {
if ((zephir_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtoupper", NULL, value);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtoupper(return_value, value);
RETURN_MM();
}
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_filter_exception_ce);
ZEPHIR_INIT_VAR(_13);
ZEPHIR_CONCAT_SVS(_13, "Sanitize filter '", filter, "' is not supported");
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_14, _13);
zephir_check_call_status();
zephir_throw_exception_debug(_2, "phalcon/filter.zep", 214 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
} while(0);
ZEPHIR_MM_RESTORE();
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, decrypt) {
zend_bool _12;
zephir_fcall_cache_entry *_4 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *key = NULL, *decryptKey = NULL, *ivSize = NULL, *cipher = NULL, *mode = NULL, *blockSize = NULL, *paddingType = NULL, *decrypted = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_3 = NULL, *_8, _9, *_10, _11, *_5$$9, *_6$$9, *_7$$9 = NULL;
zval *text = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key);
if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!key) {
key = ZEPHIR_GLOBAL(global_null);
}
if (!((zephir_function_exists_ex(SS("openssl_cipher_iv_length") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "openssl extension is required", "phalcon/crypt.zep", 331);
return;
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_OBS_VAR(decryptKey);
zephir_read_property_this(&decryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(decryptKey, key);
}
if (ZEPHIR_IS_EMPTY(decryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Decryption key cannot be empty", "phalcon/crypt.zep", 341);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "-", 0);
ZEPHIR_CALL_FUNCTION(&_1, "strrpos", NULL, 152, cipher, &_0);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, (zephir_get_numberval(_1) - zephir_fast_strlen_ev(cipher)));
ZEPHIR_INIT_VAR(_2);
zephir_substr(_2, cipher, zephir_get_intval(&_0), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_INIT_VAR(mode);
zephir_fast_strtolower(mode, _2);
ZEPHIR_CALL_FUNCTION(&_3, "openssl_get_cipher_methods", NULL, 153, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (!(zephir_fast_in_array(cipher, _3 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Cipher algorithm is unknown", "phalcon/crypt.zep", 348);
return;
}
ZEPHIR_CALL_FUNCTION(&ivSize, "openssl_cipher_iv_length", &_4, 154, cipher);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(ivSize, 0)) {
ZEPHIR_CPY_WRT(blockSize, ivSize);
} else {
ZEPHIR_INIT_VAR(_5$$9);
ZEPHIR_CONCAT_SV(_5$$9, "-", mode);
ZEPHIR_INIT_VAR(_6$$9);
ZVAL_STRING(_6$$9, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&_7$$9, "str_ireplace", NULL, 155, _5$$9, _6$$9, cipher);
zephir_check_temp_parameter(_6$$9);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&blockSize, "openssl_cipher_iv_length", &_4, 154, _7$$9);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(_8);
zephir_substr(_8, text, zephir_get_intval(ivSize), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_SINIT_VAR(_9);
ZVAL_LONG(&_9, 0);
ZEPHIR_INIT_VAR(_10);
zephir_substr(_10, text, 0 , zephir_get_intval(ivSize), 0);
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, 1);
ZEPHIR_CALL_FUNCTION(&decrypted, "openssl_decrypt", NULL, 158, _8, cipher, decryptKey, &_11, _10);
zephir_check_call_status();
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_12 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_12)) {
_12 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_12) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_cryptunpadtext", NULL, 0, decrypted, mode, blockSize, paddingType);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(decrypted);
}
/**
* Initialize the metadata for certain table
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *model, model_sub, *key, key_sub, *table, table_sub, *schema, schema_sub, strategy, className, metaData, data, modelMetadata, modelColumnMap, dependencyInjector, keyName, prefixKey, _2, _0$$8, _1$$8;
zval *this_ptr = getThis();
ZVAL_UNDEF(&model_sub);
ZVAL_UNDEF(&key_sub);
ZVAL_UNDEF(&table_sub);
ZVAL_UNDEF(&schema_sub);
ZVAL_UNDEF(&strategy);
ZVAL_UNDEF(&className);
ZVAL_UNDEF(&metaData);
ZVAL_UNDEF(&data);
ZVAL_UNDEF(&modelMetadata);
ZVAL_UNDEF(&modelColumnMap);
ZVAL_UNDEF(&dependencyInjector);
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&prefixKey);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_0$$8);
ZVAL_UNDEF(&_1$$8);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &model, &key, &table, &schema);
ZEPHIR_INIT_VAR(&strategy);
ZVAL_NULL(&strategy);
ZEPHIR_INIT_VAR(&className);
zephir_get_class(&className, model, 0 TSRMLS_CC);
if (Z_TYPE_P(key) != IS_NULL) {
ZEPHIR_OBS_VAR(&metaData);
zephir_read_property(&metaData, this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!(zephir_array_isset(&metaData, key))) {
ZEPHIR_INIT_VAR(&prefixKey);
ZEPHIR_CONCAT_SV(&prefixKey, "meta-", key);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, &prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(&data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_metaData"), key, &data TSRMLS_CC);
} else {
if ((zephir_method_exists_ex(model, SL("metadata") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&modelMetadata, model, "metadata", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(&modelMetadata) != IS_ARRAY) {
ZEPHIR_INIT_VAR(&_0$$8);
object_init_ex(&_0$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(&_1$$8);
ZEPHIR_CONCAT_SV(&_1$$8, "Invalid meta-data for model ", &className);
ZEPHIR_CALL_METHOD(NULL, &_0$$8, "__construct", NULL, 4, &_1$$8);
zephir_check_call_status();
zephir_throw_exception_debug(&_0$$8, "phalcon/mvc/model/metadata.zep", 113 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_OBS_VAR(&dependencyInjector);
zephir_read_property(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&modelMetadata, &strategy, "getmetadata", NULL, 0, model, &dependencyInjector);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_metaData"), key, &modelMetadata TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, &prefixKey, &modelMetadata);
zephir_check_call_status();
}
}
}
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(&keyName);
zephir_fast_strtolower(&keyName, &className);
zephir_read_property(&_2, this_ptr, SL("_columnMap"), PH_NOISY_CC | PH_READONLY);
if (zephir_array_isset(&_2, &keyName)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_NVAR(&prefixKey);
ZEPHIR_CONCAT_SV(&prefixKey, "map-", &keyName);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, &prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(&data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_columnMap"), &keyName, &data TSRMLS_CC);
RETURN_MM_NULL();
}
if (Z_TYPE_P(&strategy) != IS_OBJECT) {
ZEPHIR_OBS_NVAR(&dependencyInjector);
zephir_read_property(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&modelColumnMap, &strategy, "getcolumnmaps", NULL, 0, model, &dependencyInjector);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_columnMap"), &keyName, &modelColumnMap TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, &prefixKey, &modelColumnMap);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* @return array
*/
PHP_METHOD(Lynx_Annotation_RegexDocParser, parseAnnotations) {
zval *_14 = NULL;
HashTable *_3, *_8;
HashPosition _2, _7;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL, *_11 = NULL;
zval *docComment, *hasAnnotations = NULL, *matches, *anno = NULL, *annoName = NULL, *val = NULL, *hasParams = NULL, *params, *param = NULL, *rex, *_0 = NULL, *annotations, **_4, *_5, *regex1, *_6, **_9, *_10 = NULL, *_12, *_13 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &docComment);
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(rex);
ZVAL_STRING(rex, "/@(\\w+)(?:\\s*(?:\\(\\s*)?(.*?)(?:\\s*\\))?)??\\s*(?:\n|\\*\\/)/", 1);
ZEPHIR_INIT_VAR(annotations);
array_init(annotations);
ZEPHIR_INIT_VAR(regex1);
ZVAL_STRING(regex1, "/(\\w+)\\s*=\\s*(\\[[^\\]]*\\]|\"[^\"]*\"|[^,)]*)\\s*(?:,|$)/", 1);
ZEPHIR_INIT_VAR(val);
ZVAL_BOOL(val, 1);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 2);
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(&hasAnnotations, "preg_match_all", &_1, rex, docComment, matches, _0);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
if (!zephir_is_true(hasAnnotations)) {
array_init(return_value);
RETURN_MM();
}
zephir_is_iterable(matches, &_3, &_2, 0, 0, "lynx/Annotation/RegexDocParser.zep", 67);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(anno, _4);
ZEPHIR_INIT_NVAR(annoName);
zephir_array_fetch_long(&_5, anno, 1, PH_NOISY | PH_READONLY, "lynx/Annotation/RegexDocParser.zep", 33 TSRMLS_CC);
zephir_fast_strtolower(annoName, _5);
ZEPHIR_INIT_NVAR(val);
ZVAL_BOOL(val, 1);
if (zephir_array_isset_long(anno, 2)) {
zephir_array_fetch_long(&_6, anno, 2, PH_NOISY | PH_READONLY, "lynx/Annotation/RegexDocParser.zep", 38 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 2);
Z_SET_ISREF_P(params);
ZEPHIR_CALL_FUNCTION(&hasParams, "preg_match_all", &_1, regex1, _6, params, _0);
Z_UNSET_ISREF_P(params);
zephir_check_call_status();
if (zephir_is_true(hasParams)) {
ZEPHIR_INIT_NVAR(val);
array_init(val);
zephir_is_iterable(params, &_8, &_7, 0, 0, "lynx/Annotation/RegexDocParser.zep", 46);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HVALUE(param, _9);
zephir_array_fetch_long(&_12, param, 2, PH_NOISY | PH_READONLY, "lynx/Annotation/RegexDocParser.zep", 43 TSRMLS_CC);
ZEPHIR_CALL_SELF(&_10, "parsevalue", &_11, _12);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(_13);
zephir_array_fetch_long(&_13, param, 1, PH_NOISY, "lynx/Annotation/RegexDocParser.zep", 43 TSRMLS_CC);
zephir_array_update_zval(&val, _13, &_10, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_NVAR(val);
zephir_array_fetch_long(&_12, anno, 2, PH_NOISY | PH_READONLY, "lynx/Annotation/RegexDocParser.zep", 47 TSRMLS_CC);
zephir_fast_trim(val, _12, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
if (ZEPHIR_IS_STRING(val, "")) {
ZEPHIR_INIT_NVAR(val);
ZVAL_BOOL(val, 1);
} else {
ZEPHIR_CALL_SELF(&_10, "parsevalue", &_11, val);
zephir_check_call_status();
ZEPHIR_CPY_WRT(val, _10);
}
}
}
if (zephir_array_isset(annotations, annoName)) {
zephir_array_fetch(&_6, annotations, annoName, PH_NOISY | PH_READONLY, "lynx/Annotation/RegexDocParser.zep", 58 TSRMLS_CC);
if (!(Z_TYPE_P(_6) == IS_ARRAY)) {
ZEPHIR_INIT_NVAR(_14);
array_init_size(_14, 2);
ZEPHIR_OBS_NVAR(_13);
zephir_array_fetch(&_13, annotations, annoName, PH_NOISY, "lynx/Annotation/RegexDocParser.zep", 59 TSRMLS_CC);
zephir_array_fast_append(_14, _13);
zephir_array_update_zval(&annotations, annoName, &_14, PH_COPY | PH_SEPARATE);
}
zephir_array_update_multi(&annotations, &val TSRMLS_CC, SL("za"), 2, annoName);
} else {
zephir_array_update_zval(&annotations, annoName, &val, PH_COPY | PH_SEPARATE);
}
}
RETURN_CCTOR(annotations);
}
/**
* Initialize the metadata for certain table
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize) {
zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *model, *key, *table, *schema, *strategy = NULL, *className = NULL, *metaData = NULL, *data = NULL, *modelMetadata = NULL, *modelColumnMap = NULL, *dependencyInjector = NULL, *keyName = NULL, *prefixKey = NULL, *_3, *_0$$8, *_1$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &model, &key, &table, &schema);
ZEPHIR_INIT_VAR(strategy);
ZVAL_NULL(strategy);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, model, 0 TSRMLS_CC);
if (Z_TYPE_P(key) != IS_NULL) {
ZEPHIR_OBS_VAR(metaData);
zephir_read_property_this(&metaData, this_ptr, SL("_metaData"), PH_NOISY_CC);
if (!(zephir_array_isset(metaData, key))) {
ZEPHIR_INIT_VAR(prefixKey);
ZEPHIR_CONCAT_SV(prefixKey, "meta-", key);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_metaData"), key, data TSRMLS_CC);
} else {
if ((zephir_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&modelMetadata, model, "metadata", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(modelMetadata) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0$$8);
object_init_ex(_0$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_1$$8);
ZEPHIR_CONCAT_SV(_1$$8, "Invalid meta-data for model ", className);
ZEPHIR_CALL_METHOD(NULL, _0$$8, "__construct", NULL, 9, _1$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$8, "phalcon/mvc/model/metadata.zep", 122 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&modelMetadata, strategy, "getmetadata", NULL, 0, model, dependencyInjector);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_metaData"), key, modelMetadata TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelMetadata);
zephir_check_call_status();
}
}
}
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(keyName);
zephir_fast_strtolower(keyName, className);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC);
if (zephir_array_isset(_3, keyName)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_NVAR(prefixKey);
ZEPHIR_CONCAT_SV(prefixKey, "map-", keyName);
ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey);
zephir_check_call_status();
if (Z_TYPE_P(data) != IS_NULL) {
zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, data TSRMLS_CC);
RETURN_MM_NULL();
}
if (Z_TYPE_P(strategy) != IS_OBJECT) {
ZEPHIR_OBS_NVAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&modelColumnMap, strategy, "getcolumnmaps", NULL, 0, model, dependencyInjector);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, modelColumnMap TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelColumnMap);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Checks for annotations in the public methods of the controller
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation) {
zephir_fcall_cache_entry *_7 = NULL, *_11 = NULL;
HashTable *_5, *_9;
HashPosition _4, _8;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool isRoute, _12;
zval *module_param = NULL, *namespaceName_param = NULL, *controller_param = NULL, *action_param = NULL, *annotation, *name = NULL, *actionName, *routePrefix, *paths = NULL, *value = NULL, *uri = NULL, *route = NULL, *methods = NULL, *converts = NULL, *param = NULL, *convert = NULL, *conversorParam = NULL, *routeName = NULL, *beforeMatch = NULL, *_0, *_1, _2, *_3 = NULL, **_6, **_10;
zval *module = NULL, *namespaceName = NULL, *controller = NULL, *action = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 5, 0, &module_param, &namespaceName_param, &controller_param, &action_param, &annotation);
if (unlikely(Z_TYPE_P(module_param) != IS_STRING && Z_TYPE_P(module_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'module' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(module_param) == IS_STRING)) {
zephir_get_strval(module, module_param);
} else {
ZEPHIR_INIT_VAR(module);
ZVAL_EMPTY_STRING(module);
}
if (unlikely(Z_TYPE_P(namespaceName_param) != IS_STRING && Z_TYPE_P(namespaceName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'namespaceName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(namespaceName_param) == IS_STRING)) {
zephir_get_strval(namespaceName, namespaceName_param);
} else {
ZEPHIR_INIT_VAR(namespaceName);
ZVAL_EMPTY_STRING(namespaceName);
}
if (unlikely(Z_TYPE_P(controller_param) != IS_STRING && Z_TYPE_P(controller_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'controller' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(controller_param) == IS_STRING)) {
zephir_get_strval(controller, controller_param);
} else {
ZEPHIR_INIT_VAR(controller);
ZVAL_EMPTY_STRING(controller);
}
if (unlikely(Z_TYPE_P(action_param) != IS_STRING && Z_TYPE_P(action_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'action' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(action_param) == IS_STRING)) {
zephir_get_strval(action, action_param);
} else {
ZEPHIR_INIT_VAR(action);
ZVAL_EMPTY_STRING(action);
}
isRoute = 0;
ZEPHIR_INIT_VAR(methods);
ZVAL_NULL(methods);
ZEPHIR_CALL_METHOD(&name, annotation, "getname", NULL, 0);
zephir_check_call_status();
do {
if (ZEPHIR_IS_STRING(name, "Route")) {
isRoute = 1;
break;
}
if (ZEPHIR_IS_STRING(name, "Get")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "GET", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Post")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "POST", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Put")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "PUT", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Delete")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "DELETE", 1);
break;
}
if (ZEPHIR_IS_STRING(name, "Options")) {
isRoute = 1;
ZEPHIR_INIT_NVAR(methods);
ZVAL_STRING(methods, "OPTIONS", 1);
break;
}
} while(0);
if (isRoute == 1) {
ZEPHIR_INIT_VAR(_0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_actionSuffix"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
zephir_fast_str_replace(&_0, _1, &_2, action TSRMLS_CC);
ZEPHIR_INIT_VAR(actionName);
zephir_fast_strtolower(actionName, _0);
ZEPHIR_OBS_VAR(routePrefix);
zephir_read_property_this(&routePrefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "paths", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&paths, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(paths) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(paths);
array_init(paths);
}
if (!(ZEPHIR_IS_EMPTY(module))) {
zephir_array_update_string(&paths, SL("module"), &module, PH_COPY | PH_SEPARATE);
}
if (!(ZEPHIR_IS_EMPTY(namespaceName))) {
zephir_array_update_string(&paths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
zephir_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&paths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 0);
ZEPHIR_CALL_METHOD(&value, annotation, "getargument", NULL, 0, _3);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
if (!ZEPHIR_IS_STRING(value, "/")) {
ZEPHIR_INIT_VAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, value);
} else {
if (Z_TYPE_P(routePrefix) != IS_NULL) {
ZEPHIR_CPY_WRT(uri, routePrefix);
} else {
ZEPHIR_CPY_WRT(uri, value);
}
}
} else {
ZEPHIR_INIT_NVAR(uri);
ZEPHIR_CONCAT_VV(uri, routePrefix, actionName);
}
ZEPHIR_CALL_METHOD(&route, this_ptr, "add", NULL, 0, uri, paths);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "methods", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&methods, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(methods) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
} else {
if (Z_TYPE_P(methods) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "via", NULL, 0, methods);
zephir_check_call_status();
}
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "converts", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_5, &_4, 0, 0, "phalcon/mvc/router/annotations.zep", 354);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HMKEY(param, _5, _4);
ZEPHIR_GET_HVALUE(convert, _6);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_7, 0, param, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "conversors", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&converts, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(converts) == IS_ARRAY) {
zephir_is_iterable(converts, &_9, &_8, 0, 0, "phalcon/mvc/router/annotations.zep", 364);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(conversorParam, _9, _8);
ZEPHIR_GET_HVALUE(convert, _10);
ZEPHIR_CALL_METHOD(NULL, route, "convert", &_11, 0, conversorParam, convert);
zephir_check_call_status();
}
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "beforeMatch", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&beforeMatch, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
_12 = Z_TYPE_P(beforeMatch) == IS_ARRAY;
if (!(_12)) {
_12 = Z_TYPE_P(beforeMatch) == IS_STRING;
}
if (_12) {
ZEPHIR_CALL_METHOD(NULL, route, "beforematch", NULL, 0, beforeMatch);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "name", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&routeName, annotation, "getnamedargument", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(routeName) == IS_STRING) {
ZEPHIR_CALL_METHOD(NULL, route, "setname", NULL, 0, routeName);
zephir_check_call_status();
}
RETURN_MM_BOOL(1);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Xs_FieldMeta, fromConfig) {
zend_bool _8, _11, _12, _13;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_3 = NULL, *_5 = NULL;
zval *predef = NULL;
zval *config_param = NULL, *c = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_4 = NULL, *_6, *_7, *_9, *_10;
zval *config = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &config_param);
zephir_get_arrval(config, config_param);
ZEPHIR_OBS_VAR(c);
if (zephir_array_isset_string_fetch(&c, config, SS("type"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtoupper(_0, c);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SSV(_1, "Xs\\FieldMeta", "::TYPE_", _0);
zephir_get_strval(predef, _1);
ZEPHIR_CALL_FUNCTION(&_2, "defined", &_3, 11, predef);
zephir_check_call_status();
if (zephir_is_true(_2)) {
ZEPHIR_CALL_FUNCTION(&_4, "constant", &_5, 12, predef);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("type"), _4 TSRMLS_CC);
_6 = zephir_fetch_nproperty_this(this_ptr, SL("type"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(_6, 10)) {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_LONG(_7, 0x01);
zephir_update_property_this(this_ptr, SL("flag"), _7 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_STRING(_7, "full", 1);
zephir_update_property_this(this_ptr, SL("tokenizer"), _7 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(_6, 11)) {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_LONG(_7, (0x03 | 0x10));
zephir_update_property_this(this_ptr, SL("flag"), _7 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_LONG(_7, 5);
zephir_update_property_this(this_ptr, SL("weight"), _7 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(_6, 12)) {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_LONG(_7, 255);
zephir_update_property_this(this_ptr, SL("vno"), _7 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_LONG(_7, (0x01 | 0x10));
zephir_update_property_this(this_ptr, SL("flag"), _7 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_LONG(_7, 300);
zephir_update_property_this(this_ptr, SL("cutlen"), _7 TSRMLS_CC);
break;
}
} while(0);
}
}
ZEPHIR_OBS_NVAR(c);
_8 = zephir_array_isset_string_fetch(&c, config, SS("index"), 0 TSRMLS_CC);
if (_8) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("type"), PH_NOISY_CC);
_8 = !ZEPHIR_IS_LONG(_6, 12);
}
if (_8) {
ZEPHIR_INIT_NVAR(_0);
zephir_fast_strtoupper(_0, c);
ZEPHIR_INIT_LNVAR(_1);
ZEPHIR_CONCAT_SSV(_1, "Xs\\FieldMeta", "::FLAG_INDEX_", _0);
zephir_get_strval(predef, _1);
ZEPHIR_CALL_FUNCTION(&_2, "defined", &_3, 11, predef);
zephir_check_call_status();
if (zephir_is_true(_2)) {
_7 = zephir_fetch_nproperty_this(this_ptr, SL("flag"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&_4, "constant", &_5, 12, predef);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, ((((int) (zephir_get_numberval(_7)) & ~(0x03))) | zephir_get_intval(_4)));
zephir_update_property_this(this_ptr, SL("flag"), _9 TSRMLS_CC);
}
_6 = zephir_fetch_nproperty_this(this_ptr, SL("type"), PH_NOISY_CC);
if (ZEPHIR_IS_LONG(_6, 10)) {
_9 = zephir_fetch_nproperty_this(this_ptr, SL("flag"), PH_NOISY_CC);
ZEPHIR_INIT_ZVAL_NREF(_10);
ZVAL_LONG(_10, ((int) (zephir_get_numberval(_9)) | 0x01));
zephir_update_property_this(this_ptr, SL("flag"), _10 TSRMLS_CC);
}
}
ZEPHIR_OBS_NVAR(c);
if (zephir_array_isset_string_fetch(&c, config, SS("cutlen"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_ZVAL_NREF(_6);
ZVAL_LONG(_6, zephir_get_intval(c));
zephir_update_property_this(this_ptr, SL("cutlen"), _6 TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(c);
_11 = zephir_array_isset_string_fetch(&c, config, SS("weight"), 0 TSRMLS_CC);
if (_11) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("type"), PH_NOISY_CC);
_11 = !ZEPHIR_IS_LONG(_6, 12);
}
if (_11) {
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, (zephir_get_intval(c) & 0x3f));
zephir_update_property_this(this_ptr, SL("weight"), _9 TSRMLS_CC);
}
ZEPHIR_OBS_NVAR(c);
if (zephir_array_isset_string_fetch(&c, config, SS("phrase"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_0);
zephir_fast_strtolower(_0, c);
do {
if (ZEPHIR_IS_STRING(_0, "yes")) {
_9 = zephir_fetch_nproperty_this(this_ptr, SL("flag"), PH_NOISY_CC);
ZEPHIR_INIT_ZVAL_NREF(_10);
ZVAL_LONG(_10, ((int) (zephir_get_numberval(_9)) | 0x10));
zephir_update_property_this(this_ptr, SL("flag"), _10 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_STRING(_0, "no")) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("flag"), PH_NOISY_CC);
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, ((int) (zephir_get_numberval(_6)) & ~(0x10)));
zephir_update_property_this(this_ptr, SL("flag"), _9 TSRMLS_CC);
break;
}
} while(0);
}
ZEPHIR_OBS_NVAR(c);
if (zephir_array_isset_string_fetch(&c, config, SS("non_bool"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_0);
zephir_fast_strtolower(_0, c);
do {
if (ZEPHIR_IS_STRING(_0, "yes")) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("flag"), PH_NOISY_CC);
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, ((int) (zephir_get_numberval(_6)) | 0x80));
zephir_update_property_this(this_ptr, SL("flag"), _9 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_STRING(_0, "no")) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("flag"), PH_NOISY_CC);
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, ((int) (zephir_get_numberval(_6)) & ~(0x80)));
zephir_update_property_this(this_ptr, SL("flag"), _9 TSRMLS_CC);
break;
}
} while(0);
}
ZEPHIR_OBS_NVAR(c);
_12 = zephir_array_isset_string_fetch(&c, config, SS("tokenizer"), 0 TSRMLS_CC);
if (_12) {
_6 = zephir_fetch_nproperty_this(this_ptr, SL("type"), PH_NOISY_CC);
_12 = !ZEPHIR_IS_LONG(_6, 10);
}
_13 = _12;
if (_13) {
_13 = !ZEPHIR_IS_STRING(c, "default");
}
if (_13) {
zephir_update_property_this(this_ptr, SL("tokenizer"), c TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
