collabvm/r3
8
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
r3/php/r3/r3_mux.c
c9s c3ef959539 Add route namespace 
Summary:

    type route now becomes R3Route

Related issue #63
2015-11-18 14:16:26 +08:00

1196 lines
43 KiB
C
Raw Blame History

#include "php.h"
#include "string.h"
#include "main/php_main.h"
#include "Zend/zend_API.h"
#include "Zend/zend_variables.h"
#include "zend_exceptions.h"
#include "zend_interfaces.h"
#include "zend_object_handlers.h"
#include "ext/pcre/php_pcre.h"
#include "ext/standard/php_string.h"
#include "ext/standard/php_var.h"
#include "ext/standard/php_smart_str.h"
#include "ext/standard/php_array.h"
#include "php_r3.h"
#include "ct_helper.h"
#include "r3_functions.h"
#include "r3_controller.h"
#include "r3_mux.h"
zend_class_entry *ce_r3_mux;
const zend_function_entry mux_methods[] = {
PHP_ME(Mux, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
PHP_ME(Mux, __destruct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_DTOR)
PHP_ME(Mux, getId, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, add, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, any, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, compile, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, sort, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, dispatch, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, length, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, mount, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, appendRoute, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, appendPCRERoute, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, match, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, getRoutes, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, setRoutes, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, getRoute, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, getSubMux, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, getRequestMethodConstant, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, export, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, get, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, post, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, put, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, delete, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, head, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, patch, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, options, NULL, ZEND_ACC_PUBLIC)
PHP_ME(Mux, __set_state, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
PHP_ME(Mux, generate_id, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
PHP_FE_END
};
void r3_init_mux(TSRMLS_D) {
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, "R3\\Mux", mux_methods);
ce_r3_mux = zend_register_internal_class(&ce TSRMLS_CC);
zend_declare_property_null(ce_r3_mux, "id", strlen("id"), ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_null(ce_r3_mux, "routes", strlen("routes"), ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_null(ce_r3_mux, "routesById", strlen("routesById"), ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_null(ce_r3_mux, "staticRoutes", strlen("staticRoutes"), ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_null(ce_r3_mux, "submux", strlen("submux"), ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_bool(ce_r3_mux, "expand", strlen("expand"), 1, ZEND_ACC_PUBLIC TSRMLS_CC);
zend_declare_property_long(ce_r3_mux, "id_counter", strlen("id_counter"), 0, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC TSRMLS_CC);
}
zend_class_entry ** get_pattern_compiler_ce(TSRMLS_D) {
zend_class_entry **ce_pattern_compiler = NULL;
if ( zend_lookup_class( "R3\\PatternCompiler", strlen("R3\\PatternCompiler") , &ce_pattern_compiler TSRMLS_CC) == FAILURE ) {
php_error(E_ERROR, "Class R3\\PatternCompiler not found.");
return NULL;
}
if ( ce_pattern_compiler == NULL || *ce_pattern_compiler == NULL ) {
php_error(E_ERROR, "Class R3\\PatternCompiler not found.");
return NULL;
}
return ce_pattern_compiler;
}
// Returns compiled R3Route zval
zval * compile_route_pattern(zval *z_pattern, zval *z_options, zend_class_entry **ce_pattern_compiler TSRMLS_DC)
{
// zend_class_entry **ce_pattern_compiler;
if ( ce_pattern_compiler == NULL ) {
ce_pattern_compiler = get_pattern_compiler_ce(TSRMLS_C);
if ( ce_pattern_compiler == NULL ) {
return NULL;
}
}
zval *z_compiled_R3Route = NULL; // will be an array
zend_call_method( NULL, *ce_pattern_compiler, NULL, "compile", strlen("compile"), &z_compiled_route, 2, z_pattern, z_options TSRMLS_CC );
if ( z_compiled_R3Route == NULL ) {
return NULL;
} else if ( Z_TYPE_P(z_compiled_route) == IS_NULL ) {
zval_ptr_dtor(&z_compiled_route);
return NULL;
}
if ( Z_TYPE_P(z_compiled_route) != IS_ARRAY ) {
zval_ptr_dtor(&z_compiled_route);
return NULL;
}
return z_compiled_route;
}
static void var_export(zval *return_value, zval *what TSRMLS_DC)
{
smart_str buf = {0};
php_var_export_ex(&what, 0, &buf TSRMLS_CC);
smart_str_0 (&buf);
ZVAL_STRINGL(return_value, buf.c, buf.len, 0);
}
PHP_METHOD(Mux, __construct) {
zval *z_routes = NULL, *z_routes_by_id , *z_submux = NULL, *z_static_routes = NULL;
MAKE_STD_ZVAL(z_routes);
MAKE_STD_ZVAL(z_routes_by_id);
MAKE_STD_ZVAL(z_static_routes);
MAKE_STD_ZVAL(z_submux);
array_init(z_routes);
array_init(z_routes_by_id);
array_init(z_static_routes);
array_init(z_submux);
zend_update_property(ce_r3_mux, this_ptr, "routes", sizeof("routes")-1, z_routes TSRMLS_CC);
zend_update_property(ce_r3_mux, this_ptr, "routesById", sizeof("routesById")-1, z_routes_by_id TSRMLS_CC);
zend_update_property(ce_r3_mux, this_ptr, "staticRoutes", sizeof("staticRoutes")-1, z_static_routes TSRMLS_CC);
zend_update_property(ce_r3_mux, this_ptr, "submux", sizeof("submux")-1, z_submux TSRMLS_CC);
}
PHP_METHOD(Mux, __destruct) {
zval * val;
val = zend_read_property(ce_r3_mux, getThis(), "routes", sizeof("routes")-1, 1 TSRMLS_CC);
zval_ptr_dtor(&val);
val = zend_read_property(ce_r3_mux, getThis(), "routesById", sizeof("routesById")-1, 1 TSRMLS_CC);
zval_ptr_dtor(&val);
val = zend_read_property(ce_r3_mux, getThis(), "staticRoutes", sizeof("staticRoutes")-1, 1 TSRMLS_CC);
zval_ptr_dtor(&val);
val = zend_read_property(ce_r3_mux, getThis(), "submux", sizeof("submux")-1, 1 TSRMLS_CC);
zval_ptr_dtor(&val);
}
PHP_METHOD(Mux, generate_id) {
zval * z_counter = NULL;
long counter = 0;
z_counter = zend_read_static_property(ce_r3_mux, "id_counter", strlen("id_counter") , 0 TSRMLS_CC);
if ( z_counter != NULL ) {
counter = Z_LVAL_P(z_counter);
}
counter++;
Z_LVAL_P(z_counter) = counter;
RETURN_LONG(counter);
}
PHP_METHOD(Mux, __set_state) {
zval *z_array;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &z_array) == FAILURE) {
RETURN_FALSE;
}
object_init_ex(return_value, ce_r3_mux);
// XXX: put this back if we have problem
// CALL_METHOD(Mux, __construct, return_value, return_value);
zval **z_id = NULL;
zval **z_routes = NULL;
zval **z_static_routes = NULL;
zval **z_routes_by_id = NULL;
zval **z_submux = NULL;
zval **z_expand = NULL;
if ( zend_hash_quick_find(Z_ARRVAL_P(z_array), "id", sizeof("id"), zend_inline_hash_func(ZEND_STRS("id")), (void**)&z_id) == SUCCESS ) {
zend_update_property(ce_r3_mux, return_value, "id", sizeof("id")-1, *z_id TSRMLS_CC);
}
if ( zend_hash_quick_find(Z_ARRVAL_P(z_array), "routes", sizeof("routes"), zend_inline_hash_func(ZEND_STRS("routes")), (void**)&z_routes) == SUCCESS ) {
Z_ADDREF_PP(z_routes);
zend_update_property(ce_r3_mux, return_value, "routes", sizeof("routes")-1, *z_routes TSRMLS_CC);
}
if ( zend_hash_quick_find(Z_ARRVAL_P(z_array), "staticRoutes", sizeof("staticRoutes"), zend_inline_hash_func(ZEND_STRS("staticRoutes")), (void**)&z_static_routes) == SUCCESS ) {
Z_ADDREF_PP(z_static_routes);
zend_update_property(ce_r3_mux, return_value, "staticRoutes", sizeof("staticRoutes")-1, *z_static_routes TSRMLS_CC);
}
if ( zend_hash_quick_find(Z_ARRVAL_P(z_array), "routesById", sizeof("routesById"), zend_inline_hash_func(ZEND_STRS("routesById")), (void**)&z_routes_by_id) == SUCCESS ) {
Z_ADDREF_PP(z_routes_by_id);
zend_update_property(ce_r3_mux, return_value, "routesById", sizeof("routesById")-1, *z_routes_by_id TSRMLS_CC);
}
if ( zend_hash_quick_find(Z_ARRVAL_P(z_array), "submux", sizeof("submux"), zend_inline_hash_func(ZEND_STRS("submux")), (void**)&z_submux) == SUCCESS ) {
Z_ADDREF_PP(z_submux);
zend_update_property(ce_r3_mux, return_value, "submux", sizeof("submux")-1, *z_submux TSRMLS_CC);
}
if ( zend_hash_quick_find(Z_ARRVAL_P(z_array), "expand", sizeof("expand"), zend_inline_hash_func(ZEND_STRS("expand")), (void**)&z_expand) == SUCCESS ) {
zend_update_property(ce_r3_mux, return_value, "expand", sizeof("expand")-1, *z_expand TSRMLS_CC);
}
}
/**
* get_mux_function_entry("method", sizeof("method"), zend_inline_hash_func(ZEND_STRS("pattern")));
*/
inline zend_function * get_mux_function_entry(char * method_name, int method_name_len, ulong h) {
zend_function *fe;
if ( zend_hash_quick_find( &ce_r3_mux->function_table, method_name, method_name_len, h, (void **) &fe) == SUCCESS ) {
return fe;
}
php_error(E_ERROR, "%s method not found", method_name);
return NULL;
}
inline zval * call_mux_method(zval * object , char * method_name , int method_name_len, int param_count, zval* arg1, zval* arg2, zval* arg3 TSRMLS_DC)
{
zend_function *fe;
if ( zend_hash_find( &ce_r3_mux->function_table, method_name, method_name_len, (void **) &fe) == FAILURE ) {
php_error(E_ERROR, "%s method not found", method_name);
}
// call export method
zval *z_retval = NULL;
zend_call_method_with_3_params( &object, ce_r3_mux, &fe, method_name, method_name_len, &z_retval, param_count, arg1, arg2, arg3 TSRMLS_CC );
return z_retval;
}
PHP_METHOD(Mux, get) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
// $options['method'] = REQ_METHOD_GET;
add_assoc_long(z_options, "method", REQ_METHOD_GET);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( this_ptr, "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
// zval_ptr_dtor(&z_retval);
}
PHP_METHOD(Mux, put) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
add_assoc_long(z_options, "method", REQ_METHOD_PUT);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( getThis(), "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
// zval_ptr_dtor(&z_retval);
}
PHP_METHOD(Mux, delete) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
add_assoc_long(z_options, "method", REQ_METHOD_DELETE);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( getThis(), "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
// zval_ptr_dtor(&z_retval);
}
PHP_METHOD(Mux, post) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
add_assoc_long(z_options, "method", REQ_METHOD_POST);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( getThis(), "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
}
PHP_METHOD(Mux, patch) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
add_assoc_long(z_options, "method", REQ_METHOD_PATCH);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( getThis(), "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
}
PHP_METHOD(Mux, head) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
add_assoc_long(z_options, "method", REQ_METHOD_HEAD);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( getThis(), "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
}
PHP_METHOD(Mux, options) {
zval *z_pattern = NULL, *z_callback = NULL, *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|a", &z_pattern, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init_size(z_options, 1);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init_size(z_options, 1);
}
add_assoc_long(z_options, "method", REQ_METHOD_OPTIONS);
// $this->add($pattern, $callback, $options);
zval * z_retval = call_mux_method( getThis(), "add" , sizeof("add"), 3 , z_pattern, z_callback, z_options TSRMLS_CC);
if ( z_retval ) {
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
}
PHP_METHOD(Mux, mount) {
char *pattern;
int pattern_len;
zval *z_mux = NULL;
zval *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|a", &pattern, &pattern_len, &z_mux, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( Z_TYPE_P(z_mux) == IS_NULL ) {
RETURN_FALSE;
}
if ( Z_TYPE_P(z_mux) == IS_OBJECT ) {
if ( instanceof_function( Z_OBJCE_P(z_mux), ce_r3_controller TSRMLS_CC) ) {
zval *rv;
zend_call_method(&z_mux, ce_r3_controller, NULL, "expand", strlen("expand"), &rv, 0, NULL, NULL TSRMLS_CC );
z_mux = rv;
}
}
Z_ADDREF_P(z_mux);
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init(z_options);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init(z_options);
}
zend_class_entry **ce_pattern_compiler = get_pattern_compiler_ce(TSRMLS_C);
if ( ce_pattern_compiler == NULL ) {
RETURN_FALSE;
}
zval *z_routes;
zval *z_expand;
zval *z_mux_routes;
z_routes = zend_read_property( ce_r3_mux, getThis(), "routes", sizeof("routes")-1, 1 TSRMLS_CC);
z_expand = zend_read_property( ce_r3_mux, getThis(), "expand", sizeof("expand")-1, 1 TSRMLS_CC);
// TODO: merge routesById and staticRoutes properties
if ( Z_BVAL_P(z_expand) ) {
// fetch routes from $mux
//
z_mux_routes = zend_read_property( ce_r3_mux, z_mux, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
HashPosition route_pointer;
HashTable *mux_routes_hash;
mux_routes_hash = Z_ARRVAL_P(z_mux_routes);
zval **z_mux_route;
// iterate mux
for(zend_hash_internal_pointer_reset_ex(mux_routes_hash, &route_pointer);
zend_hash_get_current_data_ex(mux_routes_hash, (void**) &z_mux_route, &route_pointer) == SUCCESS;
zend_hash_move_forward_ex(mux_routes_hash, &route_pointer))
{
// zval for new route
zval *z_new_routes;
// zval for R3Route item
zval **z_is_pcre; // route[0]
zval **z_route_pattern;
zval **z_route_callback;
zval **z_route_options;
zval **z_route_original_pattern; // for PCRE pattern
if ( zend_hash_index_find( Z_ARRVAL_PP(z_mux_route), 0, (void**) &z_is_pcre) == FAILURE ) {
continue;
}
if ( zend_hash_index_find( Z_ARRVAL_PP(z_mux_route), 1, (void**) &z_route_pattern) == FAILURE ) {
continue;
}
if ( zend_hash_index_find( Z_ARRVAL_PP(z_mux_route), 2, (void**) &z_route_callback) == FAILURE ) {
continue;
}
if ( zend_hash_index_find( Z_ARRVAL_PP(z_mux_route), 3, (void**) &z_route_options) == FAILURE ) {
continue;
}
// Z_ADDREF_P(z_route_callback);
// Z_ADDREF_P(z_route_options); // reference it so it will not be recycled.
MAKE_STD_ZVAL(z_new_routes);
array_init(z_new_routes);
if ( Z_BVAL_PP(z_is_pcre) ) {
// $newPattern = $pattern . $route[3]['pattern'];
if ( zend_hash_quick_find( Z_ARRVAL_PP(z_route_options), "pattern", sizeof("pattern"), zend_inline_hash_func(ZEND_STRS("pattern")), (void**) &z_route_original_pattern) == FAILURE ) {
php_error( E_ERROR, "Can not compile pattern, original pattern not found");
}
char new_pattern[120] = { 0 };
int new_pattern_len;
strncat( new_pattern, pattern , pattern_len );
strncat( new_pattern, Z_STRVAL_PP(z_route_original_pattern) , Z_STRLEN_PP(z_route_original_pattern) );
new_pattern_len = pattern_len + Z_STRLEN_PP(z_route_original_pattern);
zval *z_new_pattern = NULL;
MAKE_STD_ZVAL(z_new_pattern);
ZVAL_STRINGL(z_new_pattern, new_pattern, new_pattern_len, 1);
// TODO: merge options
// $routeArgs = PatternCompiler::compile($newPattern,
// array_merge_recursive($route[3], $options) );
zval *z_compiled_R3Route = compile_route_pattern(z_new_pattern, *z_route_options, ce_pattern_compiler TSRMLS_CC);
if ( z_compiled_R3Route == NULL || Z_TYPE_P(z_compiled_route) == IS_NULL ) {
php_error( E_ERROR, "Cannot compile pattern: %s", new_pattern);
}
zval **z_compiled_route_pattern;
if ( zend_hash_quick_find( Z_ARRVAL_P(z_compiled_route) , "compiled", sizeof("compiled"), zend_inline_hash_func(ZEND_STRS("compiled")), (void**)&z_compiled_route_pattern) == FAILURE ) {
php_error( E_ERROR, "compiled pattern not found: %s", new_pattern);
}
zend_hash_quick_update( Z_ARRVAL_P(z_compiled_route), "pattern", sizeof("pattern"), zend_inline_hash_func(ZEND_STRS("pattern")), &z_new_pattern, sizeof(zval *), NULL);
Z_ADDREF_PP(z_compiled_route_pattern);
Z_ADDREF_PP(z_route_callback);
Z_ADDREF_P(z_compiled_route);
Z_ADDREF_P(z_new_routes);
// create new R3Route and append to mux->routes
add_index_bool(z_new_routes, 0 , 1); // pcre flag == false
add_index_zval(z_new_routes, 1, *z_compiled_route_pattern);
add_index_zval(z_new_routes, 2 , *z_route_callback);
add_index_zval(z_new_routes, 3, z_compiled_route);
add_next_index_zval(z_routes, z_new_routes);
} else {
// $this->routes[] = array(
// false,
// $pattern . $route[1],
// $route[2],
// $options,
// );
char new_pattern[120] = { 0 };
strncat(new_pattern, pattern, pattern_len);
strncat(new_pattern, Z_STRVAL_PP(z_route_pattern), Z_STRLEN_PP(z_route_pattern) );
int new_pattern_len = pattern_len + Z_STRLEN_PP(z_route_pattern);
// Merge the mount options with the R3Route options
zval *z_new_route_options;
MAKE_STD_ZVAL(z_new_route_options);
array_init(z_new_route_options);
php_array_merge(Z_ARRVAL_P(z_new_route_options), Z_ARRVAL_P(z_options), 0 TSRMLS_CC);
php_array_merge(Z_ARRVAL_P(z_new_route_options), Z_ARRVAL_P(*z_route_options), 0 TSRMLS_CC);
Z_ADDREF_PP(z_route_callback);
Z_ADDREF_P(z_new_route_options);
Z_ADDREF_P(z_new_routes);
/* make the array: [ pcreFlag, pattern, callback, options ] */
add_index_bool(z_new_routes, 0 , 0); // pcre flag == false
add_index_stringl(z_new_routes, 1 , new_pattern , new_pattern_len, 1);
add_index_zval( z_new_routes, 2 , *z_route_callback);
add_index_zval( z_new_routes, 3 , z_new_route_options);
add_next_index_zval(z_routes, z_new_routes);
}
}
} else {
zend_function *fe_getid = NULL; // method entry
zend_function *fe_add = NULL; // method entry
if ( zend_hash_quick_find(&ce_r3_mux->function_table, "getid", sizeof("getid"), zend_inline_hash_func(ZEND_STRS("getid")), (void **) &fe_getid) == FAILURE ) {
php_error(E_ERROR, "Cannot call method Mux::getid()");
RETURN_FALSE;
}
if ( zend_hash_quick_find(&ce_r3_mux->function_table, "add", sizeof("add"), zend_inline_hash_func(ZEND_STRS("add")), (void **) &fe_add) == FAILURE ) {
php_error(E_ERROR, "Cannot call method Mux::add()");
RETURN_FALSE;
}
// $muxId = $mux->getId();
// $this->add($pattern, $muxId, $options);
// $this->submux[ $muxId ] = $mux;
// zval *z_mux_id = call_mux_method(z_mux, "getid", sizeof("getid") , );
zval *z_mux_id = NULL;
zend_call_method( &z_mux, ce_r3_mux, &fe_getid, "getid", strlen("getid"), &z_mux_id, 0, NULL, NULL TSRMLS_CC );
if ( z_mux_id == NULL || Z_TYPE_P(z_mux_id) == IS_NULL ) {
php_error(E_ERROR, "Mux id is required. got NULL.");
}
// create pattern
zval *z_pattern = NULL;
MAKE_STD_ZVAL(z_pattern);
ZVAL_STRINGL(z_pattern, pattern, pattern_len, 1); // duplicate
zval *z_retval = NULL;
zend_call_method_with_3_params( &this_ptr, ce_r3_mux, &fe_add, "add",
strlen("add"), &z_retval, 3, z_pattern, z_mux_id, z_options TSRMLS_CC);
zval *z_submux_array = zend_read_property( ce_r3_mux, this_ptr , "submux", sizeof("submux") - 1, 1 TSRMLS_CC);
add_index_zval(z_submux_array, Z_LVAL_P(z_mux_id) , z_mux);
// release zvals
zval_ptr_dtor(&z_mux_id);
// zval_ptr_dtor(&z_pattern);
}
}
PHP_METHOD(Mux, getSubMux) {
long submux_id = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &submux_id ) == FAILURE) {
RETURN_FALSE;
}
zval *z_submux_array;
zval **z_submux;
z_submux_array = zend_read_property( Z_OBJCE_P(this_ptr), this_ptr, "submux", sizeof("submux")-1, 1 TSRMLS_CC);
if ( zend_hash_index_find( Z_ARRVAL_P(z_submux_array), submux_id , (void**) &z_submux) == SUCCESS ) {
*return_value = **z_submux;
zval_copy_ctor(return_value);
return;
}
RETURN_FALSE;
}
PHP_METHOD(Mux, getRequestMethodConstant) {
char *req_method = NULL, *mthit, *mthp;
long req_method_const = 0;
long req_method_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &req_method, &req_method_len) != FAILURE) {
mthit = mthp = estrndup(req_method, strlen(req_method));
while(( *mthit = toupper(*mthit))) mthit++;
if (strcmp(mthp, "GET") == 0) {
req_method_const = REQ_METHOD_GET;
} else if (strcmp(mthp, "POST") == 0) {
req_method_const = REQ_METHOD_POST;
} else if (strcmp(mthp, "PUT") == 0) {
req_method_const = REQ_METHOD_PUT;
} else if (strcmp(mthp, "DELETE") == 0) {
req_method_const = REQ_METHOD_DELETE;
} else if (strcmp(mthp, "HEAD") == 0) {
req_method_const = REQ_METHOD_HEAD;
} else if (strcmp(mthp, "OPTIONS") == 0) {
req_method_const = REQ_METHOD_OPTIONS;
} else if (strcmp(mthp, "PATCH") == 0) {
req_method_const = REQ_METHOD_PATCH;
}
efree(req_method);
}
RETURN_LONG(req_method_const);
}
PHP_METHOD(Mux, getRoute) {
char * route_id = NULL;
int route_id_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &route_id, &route_id_len ) == FAILURE) {
RETURN_FALSE;
}
zval *z_routes_by_id = NULL;
zval **z_R3Route = NULL;
z_routes_by_id = zend_read_property( ce_r3_mux , this_ptr, "routesById", sizeof("routesById")-1, 1 TSRMLS_CC);
// php_var_dump(&z_routes_by_id, 1 TSRMLS_CC);
if ( zend_hash_find( Z_ARRVAL_P(z_routes_by_id) , route_id, route_id_len + 1, (void**) &z_R3Route ) == SUCCESS ) {
*return_value = **z_route;
zval_copy_ctor(return_value);
return;
}
RETURN_NULL();
}
PHP_METHOD(Mux, setRoutes) {
zval * routes;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &routes ) == FAILURE) {
RETURN_FALSE;
}
zend_update_property(ce_r3_mux , this_ptr, "routes", sizeof("routes")-1, routes TSRMLS_CC);
RETURN_TRUE;
}
PHP_METHOD(Mux, getRoutes) {
zval *z_routes;
z_routes = zend_read_property(ce_r3_mux, this_ptr, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
*return_value = *z_routes;
zval_copy_ctor(return_value);
}
PHP_METHOD(Mux, export) {
smart_str buf = {0};
php_var_export_ex(&this_ptr, 0, &buf TSRMLS_CC);
smart_str_0 (&buf);
RETVAL_STRINGL(buf.c, buf.len, 0);
}
PHP_METHOD(Mux, getId) {
zval *z_id;
long counter = 0;
z_id = zend_read_property(ce_r3_mux, getThis(), "id", sizeof("id")-1, 1 TSRMLS_CC);
if ( z_id != NULL && Z_TYPE_P(z_id) != IS_NULL ) {
RETURN_LONG( Z_LVAL_P(z_id) );
}
zval *rv = NULL;
zend_call_method( NULL, ce_r3_mux, NULL, "generate_id", strlen("generate_id"), &rv, 0, NULL, NULL TSRMLS_CC );
if ( rv ) {
counter = Z_LVAL_P(rv);
zend_update_property_long(ce_r3_mux, this_ptr, "id" , sizeof("id") - 1, counter TSRMLS_CC);
zval_ptr_dtor(&rv);
}
RETURN_LONG(counter);
}
PHP_METHOD(Mux, length) {
zval *z_routes;
z_routes = zend_read_property(ce_r3_mux, this_ptr, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
long length = zend_hash_num_elements( Z_ARRVAL_P(z_routes) );
RETURN_LONG(length);
}
PHP_METHOD(Mux, sort) {
zval *z_routes;
z_routes = zend_read_property(Z_OBJCE_P(this_ptr) , this_ptr, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
zval *retval_ptr = NULL;
zval *z_sort_callback = NULL;
MAKE_STD_ZVAL(z_sort_callback);
ZVAL_STRING( z_sort_callback, "r3_sort_routes" , 1 );
Z_SET_ISREF_P(z_routes);
zend_call_method( NULL, NULL, NULL, "usort", strlen("usort"), &retval_ptr, 2,
z_routes, z_sort_callback TSRMLS_CC );
zval_ptr_dtor(&z_sort_callback);
if (retval_ptr) {
zval_ptr_dtor(&retval_ptr);
}
}
PHP_METHOD(Mux, compile) {
char *filename;
int filename_len;
zend_bool sort_before_compile = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &filename_len, &sort_before_compile) == FAILURE) {
RETURN_FALSE;
}
if (sort_before_compile) {
zval *z_routes;
z_routes = zend_read_property(ce_r3_mux, this_ptr, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
Z_SET_ISREF_P(z_routes);
// duplicated code to sort method
zval *rv = NULL;
zval *z_sort_callback = NULL;
MAKE_STD_ZVAL(z_sort_callback);
ZVAL_STRING( z_sort_callback, "r3_sort_routes" , 1 );
zend_call_method( NULL, NULL, NULL, "usort", strlen("usort"), &rv, 2,
z_routes, z_sort_callback TSRMLS_CC );
zval_ptr_dtor(&z_sort_callback); // recycle sort callback zval
// php_error(E_ERROR,"R3Route sort failed.");
// zend_update_property(ce_r3_mux, getThis(), "routes", sizeof("routes")-1, z_routes TSRMLS_CC);
}
// $code = '<?php return ' . $this->export() . ';';
// get export method function entry
zend_function *fe_export;
if ( zend_hash_quick_find( &Z_OBJCE_P(this_ptr)->function_table, "export", sizeof("export"), zend_inline_hash_func(ZEND_STRS("export")), (void **) &fe_export) == FAILURE ) {
php_error(E_ERROR, "export method not found");
}
// call export method
zval *compiled_code = NULL;
zend_call_method( &this_ptr, Z_OBJCE_P(this_ptr) , &fe_export, "export", strlen("export"), &compiled_code, 0, NULL, NULL TSRMLS_CC );
if ( compiled_code == NULL || Z_TYPE_P(compiled_code) == IS_NULL ) {
php_error(E_ERROR, "Cannot compile routes.");
}
int buf_len = Z_STRLEN_P(compiled_code) + strlen("<?php return ;") + 1;
char *buf = (char* ) ecalloc(buf_len, sizeof(char));
strncat(buf, "<?php return ", strlen("<?php return ") );
strncat(buf, Z_STRVAL_P(compiled_code), Z_STRLEN_P(compiled_code));
strncat(buf, ";", 1);
*(buf + buf_len - 1) = '\0';
// memcpytrncat(buf, "\0", 1);
zval *z_code = NULL;
zval *z_filename = NULL;
zval *retval = NULL;
MAKE_STD_ZVAL(z_code);
MAKE_STD_ZVAL(z_filename);
ZVAL_STRING(z_code, buf, 1);
// CHECK_ZVAL_STRING(z_code);
ZVAL_STRINGL(z_filename, filename, filename_len, 1);
zend_call_method( NULL, NULL, NULL, "file_put_contents", strlen("file_put_contents"), &retval, 2, z_filename, z_code TSRMLS_CC );
zval_ptr_dtor(&z_filename);
zval_ptr_dtor(&z_code);
zval_ptr_dtor(&compiled_code);
if (retval) {
*return_value = *retval;
zval_copy_ctor(return_value);
}
}
PHP_METHOD(Mux, dispatch) {
char *path;
int path_len;
zval *z_path;
zval *z_return_R3Route = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
RETURN_FALSE;
}
MAKE_STD_ZVAL(z_path);
ZVAL_STRINGL(z_path, path, path_len, 1);
zend_function *fe; // method entry
zend_hash_quick_find( &ce_r3_mux->function_table, "match", sizeof("match"), zend_inline_hash_func(ZEND_STRS("match")), (void **) &fe);
zend_call_method( &this_ptr, ce_r3_mux, &fe, "match", strlen("match"), &z_return_route, 1, z_path, NULL TSRMLS_CC );
if ( ! z_return_R3Route || Z_TYPE_P(z_return_route) == IS_NULL ) {
zval_ptr_dtor(&z_path);
RETURN_NULL();
}
// read data from matched route
zval **z_pcre;
zval **z_pattern;
zval **z_callback;
zval **z_options;
zend_hash_index_find( Z_ARRVAL_P(z_return_route) , 0 , (void**) &z_pcre );
zend_hash_index_find( Z_ARRVAL_P(z_return_route) , 1 , (void**) &z_pattern );
zend_hash_index_find( Z_ARRVAL_P(z_return_route) , 2 , (void**) &z_callback );
zend_hash_index_find( Z_ARRVAL_P(z_return_route) , 3 , (void**) &z_options );
zval *z_submux_array = NULL;
zval **z_submux = NULL;
zval *z_retval = NULL;
// dispatch to submux if the callback is an ID.
if ( Z_TYPE_PP(z_callback) == IS_LONG ) {
z_submux_array = zend_read_property( ce_r3_mux, this_ptr, "submux", sizeof("submux")-1, 1 TSRMLS_CC);
if ( z_submux_array == NULL ) {
zend_throw_exception(ce_r3_exception, "submux property is null", 0 TSRMLS_CC);
return;
}
if ( zend_hash_index_find( Z_ARRVAL_P(z_submux_array), Z_LVAL_PP(z_callback) , (void**) &z_submux) == FAILURE ) {
zend_throw_exception(ce_r3_exception, "submux not found", 0 TSRMLS_CC);
return;
}
if ( z_submux == NULL || *z_submux == NULL ) {
zend_throw_exception(ce_r3_exception, "submux not found", 0 TSRMLS_CC);
return;
}
// php_var_dump(z_submux, 1 TSRMLS_CC);
// $matchedString = $route[3]['vars'][0];
// return $submux->dispatch(substr($path, strlen($matchedString))
if ( Z_BVAL_PP(z_pcre) ) {
zval **z_route_vars = NULL;
zval **z_route_vars_0 = NULL;
zval *z_substr;
if ( zend_hash_quick_find( Z_ARRVAL_PP(z_options) , "vars", sizeof("vars"), zend_inline_hash_func(ZEND_STRS("vars")), (void**) &z_route_vars ) == FAILURE ) {
php_error(E_ERROR, "require R3Route vars");
RETURN_FALSE;
}
if ( zend_hash_index_find( Z_ARRVAL_PP(z_options) , 0 , (void**) &z_route_vars_0 ) == FAILURE ) {
php_error(E_ERROR, "require R3Route vars[0]");
RETURN_FALSE;
}
MAKE_STD_ZVAL(z_substr);
ZVAL_STRING(z_substr, path + Z_STRLEN_PP(z_route_vars_0), 1);
z_retval = call_mux_method( *z_submux, "dispatch" , sizeof("dispatch"), 1 , z_substr, NULL, NULL TSRMLS_CC);
zval_ptr_dtor(&z_substr);
if (z_retval) {
Z_ADDREF_P(z_retval);
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
// zval_ptr_dtor(&z_return_route);
RETURN_FALSE;
return;
} else {
zval *z_substr;
MAKE_STD_ZVAL(z_substr);
ZVAL_STRING(z_substr, path + Z_STRLEN_PP(z_pattern), 1);
// return $submux->dispatch(
// substr($path, strlen($route[1]))
// );
z_retval = call_mux_method( *z_submux, "dispatch" , sizeof("dispatch"), 1 , z_substr, NULL, NULL TSRMLS_CC);
zval_ptr_dtor(&z_substr);
if ( z_retval ) {
Z_ADDREF_P(z_retval);
*return_value = *z_retval;
zval_copy_ctor(return_value);
}
// zval_ptr_dtor(&z_return_route);
return;
}
}
if ( z_return_R3Route ) {
*return_value = *z_return_route;
zval_copy_ctor(return_value);
}
zval_ptr_dtor(&z_path);
zval_ptr_dtor(&z_return_route);
return;
}
PHP_METHOD(Mux, match) {
char *path;
int path_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
RETURN_FALSE;
}
zval **z_route_pp = NULL;
zval *z_R3Route = NULL;
if ( zend_hash_find( Z_ARRVAL_P( zend_read_property(ce_r3_mux, this_ptr, "staticRoutes", sizeof("staticRoutes") - 1, 1 TSRMLS_CC) ), path, path_len, (void**)&z_route_pp) == SUCCESS ) {
if ( Z_TYPE_PP(z_route_pp) != IS_NULL ) {
*return_value = **z_route_pp;
Z_ADDREF_PP(z_route_pp);
zval_copy_ctor(return_value);
return;
}
}
z_R3Route = php_r3_match(zend_read_property(ce_r3_mux , this_ptr , "routes", sizeof("routes")-1, 1 TSRMLS_CC), path, path_len TSRMLS_CC);
if ( z_R3Route != NULL ) {
*return_value = *z_route;
zval_copy_ctor(return_value);
Z_ADDREF_P(z_route);
return;
}
RETURN_NULL();
}
PHP_METHOD(Mux, appendRoute) {
char *pattern;
int pattern_len;
zval *z_callback;
zval *z_options;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a", &pattern, &pattern_len, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
zval *z_routes;
zval *z_new_routes;
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init(z_options);
}
if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init(z_options);
}
z_routes = zend_read_property(Z_OBJCE_P(this_ptr), this_ptr, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
MAKE_STD_ZVAL(z_new_routes);
array_init_size(z_new_routes, 4);
add_index_bool(z_new_routes, 0 , 0); // pcre flag == false
add_index_stringl( z_new_routes, 1 , pattern , pattern_len, 1);
add_index_zval( z_new_routes, 2 , z_callback);
add_index_zval( z_new_routes, 3 , z_options);
add_next_index_zval(z_routes, z_new_routes);
}
PHP_METHOD(Mux, appendPCRERoute) {
char *pattern;
int pattern_len;
zval *z_callback;
zval *z_options;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a", &pattern, &pattern_len, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init(z_options);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
array_init(z_options);
}
zval *z_pattern = NULL;
zval *z_routes;
MAKE_STD_ZVAL(z_pattern);
ZVAL_STRINGL(z_pattern, pattern, pattern_len, 1);
z_routes = zend_read_property(Z_OBJCE_P(this_ptr), getThis(), "routes", sizeof("routes")-1, 1 TSRMLS_CC);
zend_class_entry **ce_pattern_compiler = get_pattern_compiler_ce(TSRMLS_C);
if ( ce_pattern_compiler == NULL ) {
RETURN_FALSE;
}
zval *rv = NULL;
zend_call_method( NULL, *ce_pattern_compiler, NULL, "compile", strlen("compile"), &rv, 1, z_pattern, NULL TSRMLS_CC );
if ( rv == NULL || Z_TYPE_P(rv) == IS_NULL ) {
zend_throw_exception(ce_r3_exception, "Can not compile R3Route pattern", 0 TSRMLS_CC);
RETURN_FALSE;
}
add_next_index_zval(z_routes, rv);
}
inline void mux_add_route(INTERNAL_FUNCTION_PARAMETERS)
{
char *pattern;
int pattern_len;
zval *z_callback = NULL;
zval *z_options = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|a", &pattern, &pattern_len, &z_callback, &z_options) == FAILURE) {
RETURN_FALSE;
}
// $pcre = strpos($pattern,':') !== false;
char *found = find_place_holder(pattern, pattern_len);
if ( z_options == NULL ) {
MAKE_STD_ZVAL(z_options);
array_init(z_options);
} else if ( Z_TYPE_P(z_options) == IS_NULL ) {
// make it as an array
array_init(z_options);
}
// Generalize callback variable
if ( Z_TYPE_P(z_callback) == IS_STRING ) {
if ( strpos( Z_STRVAL_P(z_callback), ":" ) != -1 ) {
zval *delim;
MAKE_STD_ZVAL(delim);
ZVAL_STRINGL(delim, ":" , 1 , 1);
zval *rv;
MAKE_STD_ZVAL(rv);
array_init(rv);
php_explode(delim, z_callback, rv, 2);
z_callback = rv;
// zval_copy_ctor(z_callback);
zval_ptr_dtor(&delim);
}
}
zval * z_routes = zend_read_property(ce_r3_mux, this_ptr, "routes", sizeof("routes")-1, 1 TSRMLS_CC);
// PCRE pattern here
if ( found ) {
zval *z_pattern = NULL;
MAKE_STD_ZVAL(z_pattern);
ZVAL_STRINGL(z_pattern, pattern, pattern_len, 1);
zval *z_compiled_R3Route = compile_route_pattern(z_pattern, z_options, NULL TSRMLS_CC);
if ( z_compiled_R3Route == NULL ) {
zend_throw_exception(ce_r3_exception, "Unable to compile R3Route pattern.", 0 TSRMLS_CC);
RETURN_FALSE;
}
zval_ptr_dtor(&z_pattern);
zval **z_compiled_route_pattern;
if ( zend_hash_quick_find( Z_ARRVAL_P(z_compiled_route) , "compiled", sizeof("compiled"), zend_inline_hash_func(ZEND_STRS("compiled")), (void**)&z_compiled_route_pattern) == FAILURE ) {
zend_throw_exception(ce_r3_exception, "Unable to find compiled pattern.", 0 TSRMLS_CC);
RETURN_FALSE;
}
Z_ADDREF_P(z_callback);
zval *z_new_routes;
MAKE_STD_ZVAL(z_new_routes);
array_init_size(z_new_routes, 4);
add_index_bool(z_new_routes, 0 , 1); // pcre flag == false
add_index_zval(z_new_routes, 1, *z_compiled_route_pattern);
add_index_zval(z_new_routes, 2 , z_callback);
add_index_zval(z_new_routes, 3, z_compiled_route);
add_next_index_zval(z_routes, z_new_routes);
zval **z_route_id;
if ( zend_hash_quick_find( Z_ARRVAL_P(z_options) , "id", sizeof("id"), zend_inline_hash_func(ZEND_STRS("id")), (void**)&z_route_id) == SUCCESS ) {
zval * z_routes_by_id = zend_read_property(ce_r3_mux, this_ptr, "routesById", sizeof("routesById")-1, 1 TSRMLS_CC);
add_assoc_zval(z_routes_by_id, Z_STRVAL_PP(z_route_id), z_new_routes);
}
} else {
Z_ADDREF_P(z_options); // reference it so it will not be recycled.
Z_ADDREF_P(z_callback);
zval *z_new_route;
MAKE_STD_ZVAL(z_new_route);
array_init_size(z_new_route, 4);
/* make the array: [ pcreFlag, pattern, callback, options ] */
add_index_bool(z_new_route, 0 , 0); // pcre flag == false
add_index_stringl( z_new_route, 1 , pattern, pattern_len , 1 );
add_index_zval( z_new_route, 2 , z_callback);
add_index_zval( z_new_route, 3 , z_options);
add_next_index_zval(z_routes, z_new_route);
// if there is no option specified in z_options, we can add the R3Route to our static R3Route hash
if ( zend_hash_num_elements(Z_ARRVAL_P(z_options)) ) {
zval * z_static_routes = zend_read_property(ce_r3_mux, this_ptr, "staticRoutes", sizeof("staticRoutes")-1, 1 TSRMLS_CC);
if ( z_static_routes ) {
add_assoc_zval(z_static_routes, pattern, z_new_route);
}
}
zval **z_route_id;
if ( zend_hash_quick_find( Z_ARRVAL_P(z_options) , "id", sizeof("id"), zend_inline_hash_func(ZEND_STRS("id")), (void**)&z_route_id) == SUCCESS ) {
zval * z_routes_by_id = zend_read_property(ce_r3_mux, this_ptr, "routesById", sizeof("routesById")-1, 1 TSRMLS_CC);
/*
zval *id_R3Route = NULL;
ALLOC_ZVAL(id_route);
ZVAL_COPY_VALUE(id_route, z_new_route);
zval_copy_ctor(id_route);
add_assoc_zval(z_routes_by_id, Z_STRVAL_PP(z_route_id), id_route);
*/
add_assoc_zval(z_routes_by_id, Z_STRVAL_PP(z_route_id), z_new_route);
}
}
}
PHP_METHOD(Mux, add) {
mux_add_route(INTERNAL_FUNCTION_PARAM_PASSTHRU);
}
PHP_METHOD(Mux, any) {
mux_add_route(INTERNAL_FUNCTION_PARAM_PASSTHRU);
}
Reference in a new issue View git blame Copy permalink