PHP_METHOD(Test_Fcall, testCall1) {
zval _0, _1;
ZEPHIR_MM_GROW();
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "hello", 0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "h", 0);
zephir_call_func_p2(return_value, "strpos", &_0, &_1);
RETURN_MM();
}
PHP_METHOD(Test_Fcall, testCall3) {
zend_function *_2 = NULL;
zval *handle, *handle2, *buffer = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init;
ZEPHIR_MM_GROW();
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "inputfile.txt", 0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "r", 0);
ZEPHIR_INIT_VAR(handle);
zephir_call_func_p2(handle, "fopen", &_0, &_1);
ZEPHIR_SINIT_NVAR(_0);
ZVAL_STRING(&_0, "outputfile.txt", 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, "w", 0);
ZEPHIR_INIT_VAR(handle2);
zephir_call_func_p2(handle2, "fopen", &_0, &_1);
if (zephir_is_true(handle)) {
while (1) {
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 4096);
ZEPHIR_INIT_NVAR(buffer);
ZEPHIR_CALL_INTERNAL_FUNCTION(buffer, &buffer, "fgets", &_2, 2, handle, &_0);
if (ZEPHIR_IS_FALSE(buffer)) {
break;
}
zephir_fwrite(NULL, handle2, buffer TSRMLS_CC);
}
zephir_fclose(handle TSRMLS_CC);
zephir_fclose(handle2 TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Fcall, testStrtokVarBySlash) {
zval *value, _0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &value);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "/", 0);
zephir_call_func_p2(return_value, "strtok", value, &_0);
RETURN_MM();
}
PHP_METHOD(Test_Fcall, testCall1FromVar) {
zval *funcName, *_0, *_1;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(funcName);
ZVAL_STRING(funcName, "strpos", 1);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "hello", 1);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "l", 1);
zephir_call_func_p2(return_value, (Z_TYPE_P(funcName) == IS_STRING ? Z_STRVAL_P(funcName) : ""), _0, _1);
RETURN_MM();
}
PHP_METHOD(ADOdb_Cache, serializeStatement) {
zval *statement, *_0, *_1, _2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &statement);
if (!(zephir_is_instance_of(statement, SL("ADOdb\\Statement") TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_STR(spl_ce_InvalidArgumentException, "Parameter 'statement' must be an instance of 'ADOdb\\Statement'");
return;
}
ZEPHIR_INIT_VAR(_0);
zephir_call_method(_0, statement, "dump");
ZEPHIR_INIT_VAR(_1);
zephir_call_func_p1(_1, "serialize", _0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, 3);
zephir_call_func_p2(return_value, "gzcompress", _1, &_2);
RETURN_MM();
}
/**
* Reconfigure the route adding a new pattern and a set of paths
*
* @param string pattern
* @param array paths
*/
PHP_METHOD(Test_Router_Route, reConfigure) {
int _1;
zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted, _0, *_2 = NULL, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
ZEPHIR_CPY_WRT(paths, ZEPHIR_GLOBAL(global_null));
}
if ((Z_TYPE_P(pattern) != IS_STRING)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The pattern must be string");
return;
}
if ((Z_TYPE_P(paths) != IS_NULL)) {
if ((Z_TYPE_P(paths) == IS_STRING)) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "::", 0);
ZEPHIR_INIT_VAR(parts);
zephir_call_func_p2(parts, "explode", &_0, paths);
do {
_1 = zephir_fast_count_int(parts TSRMLS_CC);
if ((_1 == 3)) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY TSRMLS_CC);
break;
}
if ((_1 == 2)) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY TSRMLS_CC);
break;
}
if ((_1 == 1)) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if ((Z_TYPE_P(moduleName) != IS_NULL)) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if ((Z_TYPE_P(controllerName) != IS_NULL)) {
if (zephir_memnstr_str(controllerName, SL("\\"), "test/router/route.zep", 313)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_call_func_p1(realClassName, "get_class_ns", controllerName);
ZEPHIR_INIT_VAR(namespaceName);
zephir_call_func_p1(namespaceName, "get_ns_class", controllerName);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_2);
zephir_uncamelize(_2, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_2, PH_COPY | PH_SEPARATE);
}
if ((Z_TYPE_P(actionName) != IS_NULL)) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if ((Z_TYPE_P(routePaths) != IS_ARRAY)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "The route contains invalid paths");
return;
}
if (!(zephir_start_with_str(pattern, SL("#")))) {
if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 351)) {
ZEPHIR_INIT_VAR(extracted);
zephir_call_method_p1(extracted, this_ptr, "extractnamedparams", pattern);
ZEPHIR_OBS_VAR(pcrePattern);
zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY TSRMLS_CC);
ZEPHIR_INIT_NVAR(_2);
zephir_array_fetch_long(&_3, extracted, 1, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_fast_array_merge(_2, &(routePaths), &(_3) TSRMLS_CC);
ZEPHIR_CPY_WRT(routePaths, _2);
} else {
ZEPHIR_CPY_WRT(pcrePattern, pattern);
}
ZEPHIR_INIT_VAR(compiledPattern);
zephir_call_method_p1(compiledPattern, this_ptr, "compilepattern", pcrePattern);
} else {
ZEPHIR_CPY_WRT(compiledPattern, pattern);
}
zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Extracts parameters from a string
*
* @param string pattern
*/
PHP_METHOD(Test_Router_Route, extractNamedParams) {
zend_bool notValid;
int tmp, cursor, cursorVar, marker, bracketCount = 0, parenthesesCount = 0, foundPattern = 0, intermediate = 0, numberMatches = 0, _0, _5, _10;
char ch;
zval *pattern_param = NULL, *matches, _1 = zval_used_for_init, _2 = zval_used_for_init, *_3 = NULL, *_6 = NULL, *_8 = NULL;
zval *pattern = NULL, *route, *item = NULL, *variable = NULL, *regexp = NULL, *_4 = NULL, *_7 = NULL, *_9 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
zephir_get_strval(pattern, pattern_param);
if ((zephir_fast_strlen_ev(pattern) <= 0)) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(route);
ZVAL_EMPTY_STRING(route);
for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) {
cursor = _0;
ch = Z_STRVAL_P(pattern)[_0];
if ((parenthesesCount == 0)) {
if ((ch == '{')) {
if ((bracketCount == 0)) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if ((ch == '}')) {
bracketCount--;
if ((intermediate > 0)) {
if ((bracketCount == 0)) {
numberMatches++;
ZEPHIR_INIT_NVAR(variable);
ZVAL_EMPTY_STRING(variable);
ZEPHIR_INIT_NVAR(regexp);
ZVAL_EMPTY_STRING(regexp);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, marker);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_LONG(&_2, (cursor - marker));
ZEPHIR_INIT_NVAR(_3);
zephir_call_func_p3(_3, "substr", pattern, &_1, &_2);
zephir_get_strval(_4, _3);
ZEPHIR_CPY_WRT(item, _4);
for (_5 = 0; _5 < Z_STRLEN_P(item); _5++) {
cursorVar = _5;
ch = Z_STRVAL_P(item)[_5];
if ((ch == '\0')) {
break;
}
if (((cursorVar == 0) && !(((((ch >= 'a') && (ch <= 'z'))) || (((ch >= 'A') && (ch <= 'Z'))))))) {
notValid = 1;
break;
}
if (((((((((ch >= 'a') && (ch <= 'z'))) || (((ch >= 'A') && (ch <= 'Z')))) || (((ch >= '0') && (ch <= '9')))) || (ch == '-')) || (ch == '_')) || (ch == ':'))) {
if ((ch == ':')) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_LONG(&_2, cursorVar);
ZEPHIR_INIT_NVAR(_6);
zephir_call_func_p3(_6, "substr", item, &_1, &_2);
zephir_get_strval(_7, _6);
ZEPHIR_CPY_WRT(variable, _7);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, (cursorVar + 1));
ZEPHIR_INIT_NVAR(_8);
zephir_call_func_p2(_8, "substr", item, &_1);
zephir_get_strval(_9, _8);
ZEPHIR_CPY_WRT(regexp, _9);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
if ((variable && Z_STRLEN_P(variable)) && (regexp && Z_STRLEN_P(regexp))) {
foundPattern = 0;
for (_10 = 0; _10 < Z_STRLEN_P(regexp); _10++) {
ch = Z_STRVAL_P(regexp)[_10];
if ((ch == '\0')) {
break;
}
if (!(foundPattern)) {
if ((ch == '(')) {
foundPattern = 1;
}
} else {
if ((ch == ')')) {
foundPattern = 2;
break;
}
}
}
if ((foundPattern != 2)) {
zephir_concat_self_str(&route, "(", sizeof("(")-1 TSRMLS_CC);
zephir_concat_self(&route, regexp TSRMLS_CC);
zephir_concat_self_str(&route, ")", sizeof(")")-1 TSRMLS_CC);
} else {
zephir_concat_self(&route, regexp TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_6);
ZVAL_LONG(_6, tmp);
zephir_array_update_zval(&matches, variable, &_6, PH_COPY | PH_SEPARATE);
} else {
zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, tmp);
zephir_array_update_zval(&matches, item, &_8, PH_COPY | PH_SEPARATE);
}
} else {
zephir_concat_self_str(&route, "{", sizeof("{")-1 TSRMLS_CC);
zephir_concat_self(&route, item TSRMLS_CC);
zephir_concat_self_str(&route, "}", sizeof("}")-1 TSRMLS_CC);
}
continue;
}
}
}
}
}
if ((bracketCount == 0)) {
if ((ch == '(')) {
parenthesesCount++;
} else {
if ((ch == ')')) {
parenthesesCount--;
if ((parenthesesCount == 0)) {
numberMatches++;
}
}
}
}
if ((bracketCount > 0)) {
intermediate++;
} else {
zephir_concat_self_char(&route, ch TSRMLS_CC);
}
}
array_init(return_value);
zephir_array_fast_append(return_value, route);
zephir_array_fast_append(return_value, matches);
RETURN_MM();
}
/**
* Extracts parameters from a string
*
* @param string pattern
*/
PHP_METHOD(Test_Router_Route, extractNamedParams) {
zend_bool notValid;
int tmp, cursor, cursorVar, marker, bracketCount = 0, parenthesesCount = 0, foundPattern = 0, intermediate = 0, numberMatches = 0, _1, _7, _12;
char ch;
zval *pattern_param = NULL, *matches, _0, _2 = zval_used_for_init, _3 = zval_used_for_init, _4 = zval_used_for_init, *_5 = NULL, *_8 = NULL, *_10 = NULL;
zephir_str *pattern = NULL, *route = NULL, *item = NULL, *variable = NULL, *regexp = NULL, *_6 = NULL, *_9 = NULL, *_11 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
zephir_get_strval(pattern_param, &pattern);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRINGL(&_0, pattern->str, pattern->len, 0);
if ((zephir_fast_strlen_ev(&_0) <= 0)) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
for (_1 = 0; _1 < pattern->len; _1++) {
cursor = _1;
ch = pattern->str[_1];
if ((parenthesesCount == 0)) {
if ((ch == '{')) {
if ((bracketCount == 0)) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if ((ch == '}')) {
bracketCount--;
if ((intermediate > 0)) {
if ((bracketCount == 0)) {
numberMatches++;
zephir_str_assign(variable, "", sizeof("")-1);
zephir_str_assign(regexp, "", sizeof("")-1);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRINGL(&_2, pattern->str, pattern->len, 0);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, marker);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, (cursor - marker));
ZEPHIR_INIT_NVAR(_5);
zephir_call_func_p3(_5, "substr", &_2, &_3, &_4);
zephir_get_strval(_5, &_6);
zephir_str_assign(item, _6->str, _6->len);
for (_7 = 0; _7 < item->len; _7++) {
cursorVar = _7;
ch = item->str[_7];
if ((ch == '\0')) {
break;
}
if (((cursorVar == 0) && !(((((ch >= 'a') && (ch <= 'z'))) || (((ch >= 'A') && (ch <= 'Z'))))))) {
notValid = 1;
break;
}
if (((((((((ch >= 'a') && (ch <= 'z'))) || (((ch >= 'A') && (ch <= 'Z')))) || (((ch >= '0') && (ch <= '9')))) || (ch == '-')) || (ch == '_')) || (ch == ':'))) {
if ((ch == ':')) {
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRINGL(&_2, item->str, item->len, 0);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 0);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, cursorVar);
ZEPHIR_INIT_NVAR(_8);
zephir_call_func_p3(_8, "substr", &_2, &_3, &_4);
zephir_get_strval(_8, &_9);
zephir_str_assign(variable, _9->str, _9->len);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRINGL(&_2, item->str, item->len, 0);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (cursorVar + 1));
ZEPHIR_INIT_NVAR(_10);
zephir_call_func_p2(_10, "substr", &_2, &_3);
zephir_get_strval(_10, &_11);
zephir_str_assign(regexp, _11->str, _11->len);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
if ((variable && variable->len) && (regexp && regexp->len)) {
foundPattern = 0;
for (_12 = 0; _12 < regexp->len; _12++) {
ch = regexp->str[_12];
if ((ch == '\0')) {
break;
}
if (!(foundPattern)) {
if ((ch == '(')) {
foundPattern = 1;
}
} else {
if ((ch == ')')) {
foundPattern = 2;
break;
}
}
}
if ((foundPattern != 2)) {
zephir_str_append_char(route, '(');
zephir_str_append(route, regexp->str, regexp->len);
zephir_str_append_char(route, ')');
} else {
zephir_str_append(route, regexp->str, regexp->len);
}
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, tmp);
zephir_array_update_string(&matches, variable->str, variable->len, &_8, PH_COPY | PH_SEPARATE);
} else {
zephir_str_append(route, "([^/]*)", sizeof("([^/]*)")-1);
ZEPHIR_INIT_NVAR(_10);
ZVAL_LONG(_10, tmp);
zephir_array_update_string(&matches, item->str, item->len, &_10, PH_COPY | PH_SEPARATE);
}
} else {
zephir_str_append_char(route, '{');
zephir_str_append(route, item->str, item->len);
zephir_str_append_char(route, '}');
}
continue;
}
}
}
}
}
if ((bracketCount == 0)) {
if ((ch == '(')) {
parenthesesCount++;
} else {
if ((ch == ')')) {
parenthesesCount--;
if ((parenthesesCount == 0)) {
numberMatches++;
}
}
}
}
if ((bracketCount > 0)) {
intermediate++;
} else {
zephir_str_append_char(route, ch);
}
}
array_init(return_value);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRINGL(_5, route->str, route->len, 1);
zephir_array_append(&return_value, _5, 0);
zephir_array_append(&return_value, matches, 0);
RETURN_MM();
}
