/**
* Copies of internal methods from Zend/zend_execute_API.c
* These are used to call internal methods (not in the function table) from the external method.
* TODO: See if xdebug works
*/
int runkit_forward_call_user_function(zend_function *fbc, zend_function *fbc_inner, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
{
uint32_t i;
zend_execute_data *call, dummy_execute_data;
zend_fcall_info_cache fci_cache_local = {0};
zend_function *func;
/* {{{ patch for runkit */
zend_fcall_info fci = {0};
zend_fcall_info_cache *fci_cache = NULL;
fci.size = sizeof(fci);
fci.object = NULL; // FIXME for methods? // object ? Z_OBJ_P(object) : NULL;
ZVAL_STR(&fci.function_name, fbc_inner->common.function_name);
zend_string_addref(fbc_inner->common.function_name);
fci.retval = return_value;
fci.param_count = ZEND_CALL_NUM_ARGS(EG(current_execute_data));
fci.params = ZEND_CALL_ARG(EG(current_execute_data), 1); // params and param_count From zend_API.c
fci.no_separation = (zend_bool)1; // ???
/* end patch for runkit }}} */
ZVAL_UNDEF(fci.retval);
if (!EG(active)) {
return FAILURE; /* executor is already inactive */
}
if (EG(exception)) {
return FAILURE; /* we would result in an unstable executor otherwise */
}
/* Initialize execute_data */
if (!EG(current_execute_data)) {
/* This only happens when we're called outside any execute()'s
* It shouldn't be strictly necessary to NULL execute_data out,
* but it may make bugs easier to spot
*/
memset(&dummy_execute_data, 0, sizeof(zend_execute_data));
EG(current_execute_data) = &dummy_execute_data;
} else if (EG(current_execute_data)->func &&
ZEND_USER_CODE(EG(current_execute_data)->func->common.type) &&
EG(current_execute_data)->opline->opcode != ZEND_DO_FCALL &&
EG(current_execute_data)->opline->opcode != ZEND_DO_ICALL &&
EG(current_execute_data)->opline->opcode != ZEND_DO_UCALL &&
EG(current_execute_data)->opline->opcode != ZEND_DO_FCALL_BY_NAME) {
/* Insert fake frame in case of include or magic calls */
dummy_execute_data = *EG(current_execute_data);
dummy_execute_data.prev_execute_data = EG(current_execute_data);
dummy_execute_data.call = NULL;
dummy_execute_data.opline = NULL;
dummy_execute_data.func = NULL;
EG(current_execute_data) = &dummy_execute_data;
}
if (!fci_cache || !RUNKIT_IS_FCI_CACHE_INITIALIZED(fci_cache)) {
zend_string *callable_name;
char *error = NULL;
if (!fci_cache) {
fci_cache = &fci_cache_local;
}
if (!zend_is_callable_ex(&fci.function_name, fci.object, IS_CALLABLE_CHECK_SILENT, &callable_name, fci_cache, &error)) {
if (error) {
zend_error(E_WARNING, "Invalid callback %s, %s", ZSTR_VAL(callable_name), error);
efree(error);
}
if (callable_name) {
zend_string_release(callable_name);
}
if (EG(current_execute_data) == &dummy_execute_data) {
EG(current_execute_data) = dummy_execute_data.prev_execute_data;
}
return FAILURE;
} else if (error) {
/* Capitalize the first latter of the error message */
if (error[0] >= 'a' && error[0] <= 'z') {
error[0] += ('A' - 'a');
}
zend_error(E_DEPRECATED, "%s", error);
efree(error);
}
zend_string_release(callable_name);
}
func = fbc_inner;
fci.object = (func->common.fn_flags & ZEND_ACC_STATIC) ?
NULL : fci_cache->object;
call = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_FUNCTION | ZEND_CALL_DYNAMIC,
func, fci.param_count, fci_cache->called_scope, fci.object);
if (fci.object &&
(!EG(objects_store).object_buckets ||
!IS_OBJ_VALID(EG(objects_store).object_buckets[fci.object->handle]))) {
if (EG(current_execute_data) == &dummy_execute_data) {
EG(current_execute_data) = dummy_execute_data.prev_execute_data;
}
return FAILURE;
}
if (func->common.fn_flags & (ZEND_ACC_ABSTRACT | ZEND_ACC_DEPRECATED)) {
if (func->common.fn_flags & ZEND_ACC_ABSTRACT) {
zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name));
if (EG(current_execute_data) == &dummy_execute_data) {
EG(current_execute_data) = dummy_execute_data.prev_execute_data;
}
return FAILURE;
}
if (func->common.fn_flags & ZEND_ACC_DEPRECATED) {
zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
func->common.scope ? ZSTR_VAL(func->common.scope->name) : "",
func->common.scope ? "::" : "",
ZSTR_VAL(func->common.function_name));
}
}
for (i = 0; i < fci.param_count; i++) {
zval *param;
zval *arg = &fci.params[i];
if (ARG_SHOULD_BE_SENT_BY_REF(func, i + 1)) {
if (UNEXPECTED(!Z_ISREF_P(arg))) {
if (!fci.no_separation) {
/* Separation is enabled -- create a ref */
ZVAL_NEW_REF(arg, arg);
} else if (!ARG_MAY_BE_SENT_BY_REF(func, i + 1)) {
/* By-value send is not allowed -- emit a warning,
* but still perform the call with a by-value send. */
zend_error(E_WARNING,
"Parameter %d to %s%s%s() expected to be a reference, value given", i + 1,
func->common.scope ? ZSTR_VAL(func->common.scope->name) : "",
func->common.scope ? "::" : "",
ZSTR_VAL(func->common.function_name));
}
}
} else {
if (Z_ISREF_P(arg) &&
!(func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
/* don't separate references for __call */
arg = Z_REFVAL_P(arg);
}
}
param = ZEND_CALL_ARG(call, i + 1);
ZVAL_COPY(param, arg);
}
if (UNEXPECTED(func->op_array.fn_flags & ZEND_ACC_CLOSURE)) {
ZEND_ASSERT(GC_TYPE((zend_object *)func->op_array.prototype) == IS_OBJECT);
GC_ADDREF((zend_object *)func->op_array.prototype);
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_CLOSURE);
}
if (func->type == ZEND_USER_FUNCTION) {
int call_via_handler = (func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0;
zend_init_execute_data(call, &func->op_array, fci.retval);
zend_execute_ex(call);
if (call_via_handler) {
/* We must re-initialize function again */
RUNKIT_CLEAR_FCI_CACHE(fci_cache);
}
} else if (func->type == ZEND_INTERNAL_FUNCTION) {
int call_via_handler = (func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0;
ZVAL_NULL(fci.retval);
call->prev_execute_data = EG(current_execute_data);
call->return_value = NULL; /* this is not a constructor call */
EG(current_execute_data) = call;
if (EXPECTED(zend_execute_internal == NULL)) {
/* saves one function call if zend_execute_internal is not used */
func->internal_function.handler(call, fci.retval);
} else {
zend_execute_internal(call, fci.retval);
}
EG(current_execute_data) = call->prev_execute_data;
zend_vm_stack_free_args(call);
/* We shouldn't fix bad extensions here,
because it can break proper ones (Bug #34045)
if (!EX(function_state).function->common.return_reference)
{
INIT_PZVAL(f->retval);
}*/
if (EG(exception)) {
zval_ptr_dtor(fci.retval);
ZVAL_UNDEF(fci.retval);
}
if (call_via_handler) {
/* We must re-initialize function again */
RUNKIT_CLEAR_FCI_CACHE(fci_cache);
}
} else { /* ZEND_OVERLOADED_FUNCTION */
ZVAL_NULL(fci.retval);
/* Not sure what should be done here if it's a static method */
if (fci.object) {
call->prev_execute_data = EG(current_execute_data);
EG(current_execute_data) = call;
fci.object->handlers->call_method(func->common.function_name, fci.object, call, fci.retval);
EG(current_execute_data) = call->prev_execute_data;
} else {
zend_throw_error(NULL, "Cannot call overloaded function for non-object");
}
zend_vm_stack_free_args(call);
if (func->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
zend_string_release(func->common.function_name);
}
efree(func);
if (EG(exception)) {
zval_ptr_dtor(fci.retval);
ZVAL_UNDEF(fci.retval);
}
}
zend_vm_stack_free_call_frame(call);
if (EG(current_execute_data) == &dummy_execute_data) {
EG(current_execute_data) = dummy_execute_data.prev_execute_data;
}
if (EG(exception)) {
zend_throw_exception_internal(NULL);
}
return SUCCESS;
}
SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data)
{
char *res = NULL, *var, *val, *separator = NULL;
const char *c_var;
zval array;
int free_buffer = 0;
char *strtok_buf = NULL;
zend_long count = 0;
ZVAL_UNDEF(&array);
switch (arg) {
case PARSE_POST:
case PARSE_GET:
case PARSE_COOKIE:
array_init(&array);
switch (arg) {
case PARSE_POST:
zval_ptr_dtor_nogc(&PG(http_globals)[TRACK_VARS_POST]);
ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_POST], &array);
break;
case PARSE_GET:
zval_ptr_dtor_nogc(&PG(http_globals)[TRACK_VARS_GET]);
ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_GET], &array);
break;
case PARSE_COOKIE:
zval_ptr_dtor_nogc(&PG(http_globals)[TRACK_VARS_COOKIE]);
ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_COOKIE], &array);
break;
}
break;
default:
ZVAL_COPY_VALUE(&array, destArray);
break;
}
if (arg == PARSE_POST) {
sapi_handle_post(&array);
return;
}
if (arg == PARSE_GET) { /* GET data */
c_var = SG(request_info).query_string;
if (c_var && *c_var) {
res = (char *) estrdup(c_var);
free_buffer = 1;
} else {
free_buffer = 0;
}
} else if (arg == PARSE_COOKIE) { /* Cookie data */
c_var = SG(request_info).cookie_data;
if (c_var && *c_var) {
res = (char *) estrdup(c_var);
free_buffer = 1;
} else {
free_buffer = 0;
}
} else if (arg == PARSE_STRING) { /* String data */
res = str;
free_buffer = 1;
}
if (!res) {
return;
}
switch (arg) {
case PARSE_GET:
case PARSE_STRING:
separator = PG(arg_separator).input;
break;
case PARSE_COOKIE:
separator = ";\0";
break;
}
var = php_strtok_r(res, separator, &strtok_buf);
while (var) {
val = strchr(var, '=');
if (arg == PARSE_COOKIE) {
/* Remove leading spaces from cookie names, needed for multi-cookie header where ; can be followed by a space */
while (isspace(*var)) {
var++;
}
if (var == val || *var == '\0') {
goto next_cookie;
}
}
if (++count > PG(max_input_vars)) {
php_error_docref(NULL, E_WARNING, "Input variables exceeded " ZEND_LONG_FMT ". To increase the limit change max_input_vars in php.ini.", PG(max_input_vars));
break;
}
if (val) { /* have a value */
size_t val_len;
size_t new_val_len;
*val++ = '\0';
php_url_decode(var, strlen(var));
val_len = php_url_decode(val, strlen(val));
val = estrndup(val, val_len);
if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len)) {
php_register_variable_safe(var, val, new_val_len, &array);
}
efree(val);
} else {
size_t val_len;
size_t new_val_len;
php_url_decode(var, strlen(var));
val_len = 0;
val = estrndup("", val_len);
if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len)) {
php_register_variable_safe(var, val, new_val_len, &array);
}
efree(val);
}
next_cookie:
var = php_strtok_r(NULL, separator, &strtok_buf);
}
if (free_buffer) {
efree(res);
}
}
zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref)
{
php_com_dotnet_object *obj;
struct php_com_iterator *I;
IEnumVARIANT *iev = NULL;
DISPPARAMS dp;
VARIANT v;
unsigned long n_fetched;
zval ptr;
if (by_ref) {
zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
}
obj = CDNO_FETCH(object);
if (V_VT(&obj->v) != VT_DISPATCH && !V_ISARRAY(&obj->v)) {
php_error_docref(NULL, E_WARNING, "variant is not an object or array VT=%d", V_VT(&obj->v));
return NULL;
}
memset(&dp, 0, sizeof(dp));
VariantInit(&v);
I = (struct php_com_iterator*)ecalloc(1, sizeof(*I));
zend_iterator_init(&I->iter);
I->iter.funcs = &com_iter_funcs;
Z_PTR(I->iter.data) = I;
I->code_page = obj->code_page;
ZVAL_UNDEF(&I->zdata);
VariantInit(&I->safe_array);
VariantInit(&I->v);
if (V_ISARRAY(&obj->v)) {
LONG bound;
UINT dims;
dims = SafeArrayGetDim(V_ARRAY(&obj->v));
if (dims != 1) {
php_error_docref(NULL, E_WARNING,
"Can only handle single dimension variant arrays (this array has %d)", dims);
goto fail;
}
/* same semantics as foreach on a PHP array;
* make a copy and enumerate that copy */
VariantCopy(&I->safe_array, &obj->v);
/* determine the key value for the array */
SafeArrayGetLBound(V_ARRAY(&I->safe_array), 1, &bound);
SafeArrayGetUBound(V_ARRAY(&I->safe_array), 1, &I->sa_max);
/* pre-fetch the element */
if (php_com_safearray_get_elem(&I->safe_array, &I->v, bound)) {
I->key = bound;
ZVAL_NULL(&ptr);
php_com_zval_from_variant(&ptr, &I->v, I->code_page);
ZVAL_COPY_VALUE(&I->zdata, &ptr);
} else {
I->key = (ulong)-1;
}
} else {
/* can we enumerate it? */
if (FAILED(IDispatch_Invoke(V_DISPATCH(&obj->v), DISPID_NEWENUM,
&IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
&dp, &v, NULL, NULL))) {
goto fail;
}
/* get something useful out of it */
if (V_VT(&v) == VT_UNKNOWN) {
IUnknown_QueryInterface(V_UNKNOWN(&v), &IID_IEnumVARIANT, (void**)&iev);
} else if (V_VT(&v) == VT_DISPATCH) {
IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IEnumVARIANT, (void**)&iev);
}
VariantClear(&v);
if (iev == NULL) {
goto fail;
}
I->ev = iev;
/* Get the first element now */
if (SUCCEEDED(IEnumVARIANT_Next(I->ev, 1, &I->v, &n_fetched)) && n_fetched > 0) {
/* indicate that we have element 0 */
I->key = 0;
ZVAL_NULL(&ptr);
php_com_zval_from_variant(&ptr, &I->v, I->code_page);
ZVAL_COPY_VALUE(&I->zdata, &ptr);
} else {
/* indicate that there are no more items */
I->key = (ulong)-1;
}
}
return &I->iter;
fail:
if (I) {
VariantClear(&I->safe_array);
VariantClear(&I->v);
efree(I);
}
return NULL;
}
/* {{{ zend_call_method
Only returns the returned zval if retval_ptr != NULL */
ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval_ptr, int param_count, zval* arg1, zval* arg2)
{
int result;
zend_fcall_info fci;
zval retval;
zval params[2];
if (param_count > 0) {
ZVAL_COPY_VALUE(¶ms[0], arg1);
}
if (param_count > 1) {
ZVAL_COPY_VALUE(¶ms[1], arg2);
}
fci.size = sizeof(fci);
fci.object = object ? Z_OBJ_P(object) : NULL;
fci.retval = retval_ptr ? retval_ptr : &retval;
fci.param_count = param_count;
fci.params = params;
fci.no_separation = 1;
if (!fn_proxy && !obj_ce) {
/* no interest in caching and no information already present that is
* needed later inside zend_call_function. */
ZVAL_STRINGL(&fci.function_name, function_name, function_name_len);
result = zend_call_function(&fci, NULL);
zval_ptr_dtor(&fci.function_name);
} else {
zend_fcall_info_cache fcic;
ZVAL_UNDEF(&fci.function_name); /* Unused */
if (!obj_ce) {
obj_ce = object ? Z_OBJCE_P(object) : NULL;
}
if (!fn_proxy || !*fn_proxy) {
if (EXPECTED(obj_ce)) {
fcic.function_handler = zend_hash_str_find_ptr(
&obj_ce->function_table, function_name, function_name_len);
if (UNEXPECTED(fcic.function_handler == NULL)) {
/* error at c-level */
zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s::%s", ZSTR_VAL(obj_ce->name), function_name);
}
} else {
fcic.function_handler = zend_fetch_function_str(function_name, function_name_len);
if (UNEXPECTED(fcic.function_handler == NULL)) {
/* error at c-level */
zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for function %s", function_name);
}
}
if (fn_proxy) {
*fn_proxy = fcic.function_handler;
}
} else {
fcic.function_handler = *fn_proxy;
}
if (object) {
fcic.called_scope = Z_OBJCE_P(object);
} else {
zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));
if (obj_ce &&
(!called_scope ||
!instanceof_function(called_scope, obj_ce))) {
fcic.called_scope = obj_ce;
} else {
fcic.called_scope = called_scope;
}
}
fcic.object = object ? Z_OBJ_P(object) : NULL;
result = zend_call_function(&fci, &fcic);
}
if (result == FAILURE) {
/* error at c-level */
if (!obj_ce) {
obj_ce = object ? Z_OBJCE_P(object) : NULL;
}
if (!EG(exception)) {
zend_error_noreturn(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? ZSTR_VAL(obj_ce->name) : "", obj_ce ? "::" : "", function_name);
}
}
if (!retval_ptr) {
zval_ptr_dtor(&retval);
return NULL;
}
return retval_ptr;
}
/* {{{ proto void SplDoublyLinkedList::offsetUnset(mixed index)
Unsets the value at the specified $index. */
SPL_METHOD(SplDoublyLinkedList, offsetUnset)
{
zval *zindex;
zend_long index;
spl_dllist_object *intern;
spl_ptr_llist_element *element;
spl_ptr_llist *llist;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
return;
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
index = spl_offset_convert_to_long(zindex);
llist = intern->llist;
if (index < 0 || index >= intern->llist->count) {
zend_throw_exception(spl_ce_OutOfRangeException, "Offset out of range", 0);
return;
}
element = spl_ptr_llist_offset(intern->llist, index, intern->flags & SPL_DLLIST_IT_LIFO);
if (element != NULL) {
/* connect the neightbors */
if (element->prev) {
element->prev->next = element->next;
}
if (element->next) {
element->next->prev = element->prev;
}
/* take care of head/tail */
if (element == llist->head) {
llist->head = element->next;
}
if (element == llist->tail) {
llist->tail = element->prev;
}
/* finally, delete the element */
llist->count--;
if(llist->dtor) {
llist->dtor(element);
}
if (intern->traverse_pointer == element) {
SPL_LLIST_DELREF(element);
intern->traverse_pointer = NULL;
}
zval_ptr_dtor(&element->data);
ZVAL_UNDEF(&element->data);
SPL_LLIST_DELREF(element);
} else {
zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid", 0);
return;
}
} /* }}} */
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, get) {
zval _1;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime = NULL, lifetime_sub, __$null, frontend, prefixedKey, conditions, document, cachedContent, _0, _2, _3;
zval keyName;
zval *this_ptr = getThis();
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&lifetime_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&frontend);
ZVAL_UNDEF(&prefixedKey);
ZVAL_UNDEF(&conditions);
ZVAL_UNDEF(&document);
ZVAL_UNDEF(&cachedContent);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime);
zephir_get_strval(&keyName, keyName_param);
if (!lifetime) {
lifetime = &lifetime_sub;
lifetime = &__$null;
}
ZEPHIR_INIT_VAR(&conditions);
array_init(&conditions);
ZEPHIR_OBS_VAR(&frontend);
zephir_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
zephir_read_property(&_0, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_VAR(&prefixedKey);
ZEPHIR_CONCAT_VV(&prefixedKey, &_0, &keyName);
zephir_update_property_zval(this_ptr, SL("_lastKey"), &prefixedKey);
zephir_array_update_string(&conditions, SL("key"), &prefixedKey, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(&_1);
zephir_create_array(&_1, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_2);
zephir_time(&_2);
zephir_array_update_string(&_1, SL("$gt"), &_2, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&conditions, SL("time"), &_1, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "_getcollection", NULL, 104);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&document, &_3, "findone", NULL, 0, &conditions);
zephir_check_call_status();
if (Z_TYPE_P(&document) == IS_ARRAY) {
ZEPHIR_OBS_VAR(&cachedContent);
if (zephir_array_isset_string_fetch(&cachedContent, &document, SL("data"), 0)) {
if (zephir_is_numeric(&cachedContent)) {
RETURN_CCTOR(&cachedContent);
}
ZEPHIR_RETURN_CALL_METHOD(&frontend, "afterretrieve", NULL, 0, &cachedContent);
zephir_check_call_status();
RETURN_MM();
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The cache is corrupt", "phalcon/cache/backend/mongo.zep", 164);
return;
}
}
RETURN_MM_NULL();
}
/* {{{ */
static inline zend_string* php_memoize_args(uint32_t argc, const zval *argv) {
php_serialize_data_t data;
zval serial;
uint32_t it;
smart_str smart = {0};
ZVAL_UNDEF(&serial);
switch (argc) {
case 0:
return zend_string_copy(CG(empty_string));
case 1: {
switch (Z_TYPE_P(argv)) {
case IS_STRING:
return zend_string_copy(Z_STR_P(argv));
case IS_LONG:
case IS_DOUBLE:
return zval_get_string((zval*) argv);
case IS_TRUE:
return zend_string_copy(PHP_MEMOIZE_STRING_TRUE);
case IS_FALSE:
return zend_string_copy(PHP_MEMOIZE_STRING_FALSE);
case IS_NULL:
return zend_string_copy(PHP_MEMOIZE_STRING_NULL);
}
ZVAL_COPY(&serial, argv);
}
/* intentionally fall through */
default: {
if (Z_TYPE(serial) == IS_UNDEF) {
array_init(&serial);
for (it = 0; it < argc; it++) {
if (add_index_zval(&serial, it, (zval*) argv + it) == SUCCESS) {
Z_TRY_ADDREF_P((zval*) argv + it);
}
}
}
PHP_VAR_SERIALIZE_INIT(data);
php_var_serialize(&smart, &serial, &data);
PHP_VAR_SERIALIZE_DESTROY(data);
if (EG(exception)) {
zval_ptr_dtor(&serial);
zend_clear_exception();
return NULL;
}
}
}
zval_ptr_dtor(&serial);
return smart.s;
} /* }}} */
static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops)
{
while (elements-- > 0) {
zval key, *data, d, *old_data;
ZVAL_UNDEF(&key);
if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
zval_dtor(&key);
return 0;
}
if (Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING) {
zval_dtor(&key);
return 0;
}
data = NULL;
ZVAL_UNDEF(&d);
if (!objprops) {
switch (Z_TYPE(key)) {
case IS_LONG:
if ((old_data = zend_hash_index_find(ht, Z_LVAL(key))) != NULL) {
//??? update hash
var_push_dtor(var_hash, old_data);
}
data = zend_hash_index_update(ht, Z_LVAL(key), &d);
break;
case IS_STRING:
if ((old_data = zend_symtable_find(ht, Z_STR(key))) != NULL) {
//??? update hash
var_push_dtor(var_hash, old_data);
}
data = zend_symtable_update(ht, Z_STR(key), &d);
break;
}
} else {
/* object properties should include no integers */
convert_to_string(&key);
//???
#if 1
data = zend_hash_update_ind(ht, Z_STR(key), &d);
#else
if ((data = zend_hash_find(ht, Z_STR(key))) != NULL) {
if (Z_TYPE_P(data) == IS_INDIRECT) {
data = Z_INDIRECT_P(data);
}
zval_ptr_dtor(data);
//??? var_push_dtor(var_hash, data);
ZVAL_UNDEF(data);
} else {
data = zend_hash_update(ht, Z_STR(key), &d);
}
#endif
}
zval_dtor(&key);
if (!php_var_unserialize(data, p, max, var_hash TSRMLS_CC)) {
return 0;
}
if (elements && *(*p-1) != ';' && *(*p-1) != '}') {
(*p)--;
return 0;
}
}
return 1;
}
static zend_bool tokenize(zval *return_value, zend_string *source)
{
zval source_zval;
zend_lex_state original_lex_state;
zval token;
zval keyword;
int token_type;
int token_line = 1;
int need_tokens = -1; /* for __halt_compiler lexing. -1 = disabled */
ZVAL_STR_COPY(&source_zval, source);
zend_save_lexical_state(&original_lex_state);
if (zend_prepare_string_for_scanning(&source_zval, "") == FAILURE) {
zend_restore_lexical_state(&original_lex_state);
return 0;
}
LANG_SCNG(yy_state) = yycINITIAL;
array_init(return_value);
ZVAL_UNDEF(&token);
while ((token_type = lex_scan(&token))) {
if (token_type == T_CLOSE_TAG && zendtext[zendleng - 1] != '>') {
CG(zend_lineno)++;
}
if (token_type >= 256) {
array_init(&keyword);
add_next_index_long(&keyword, token_type);
if (token_type == T_END_HEREDOC) {
if (CG(increment_lineno)) {
token_line = ++CG(zend_lineno);
CG(increment_lineno) = 0;
}
}
add_next_index_stringl(&keyword, (char *)zendtext, zendleng);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
} else {
add_next_index_stringl(return_value, (char *)zendtext, zendleng);
}
if (Z_TYPE(token) != IS_UNDEF) {
zval_dtor(&token);
ZVAL_UNDEF(&token);
}
/* after T_HALT_COMPILER collect the next three non-dropped tokens */
if (need_tokens != -1) {
if (token_type != T_WHITESPACE && token_type != T_OPEN_TAG
&& token_type != T_COMMENT && token_type != T_DOC_COMMENT
&& --need_tokens == 0
) {
/* fetch the rest into a T_INLINE_HTML */
if (zendcursor != zendlimit) {
array_init(&keyword);
add_next_index_long(&keyword, T_INLINE_HTML);
add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
}
break;
}
} else if (token_type == T_HALT_COMPILER) {
need_tokens = 3;
}
token_line = CG(zend_lineno);
}
zval_dtor(&source_zval);
zend_restore_lexical_state(&original_lex_state);
return 1;
}
static void php_assert_init_globals(zend_assert_globals *assert_globals_p) /* {{{ */
{
ZVAL_UNDEF(&assert_globals_p->callback);
assert_globals_p->cb = NULL;
}
/* {{{ php_parserr */
static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, zval *subarray)
{
int type;
u_long ttl;
type = pRec->wType;
ttl = pRec->dwTtl;
if (type_to_fetch != DNS_TYPE_ANY && type != type_to_fetch) {
return;
}
if (!store) {
return;
}
array_init(subarray);
add_assoc_string(subarray, "host", pRec->pName);
add_assoc_string(subarray, "class", "IN");
add_assoc_long(subarray, "ttl", ttl);
if (raw) {
add_assoc_long(subarray, "type", type);
add_assoc_stringl(subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength);
return;
}
switch (type) {
case DNS_TYPE_A: {
IN_ADDR ipaddr;
ipaddr.S_un.S_addr = (pRec->Data.A.IpAddress);
add_assoc_string(subarray, "type", "A");
add_assoc_string(subarray, "ip", inet_ntoa(ipaddr));
break;
}
case DNS_TYPE_MX:
add_assoc_string(subarray, "type", "MX");
add_assoc_long(subarray, "pri", pRec->Data.Srv.wPriority);
/* no break; */
case DNS_TYPE_CNAME:
if (type == DNS_TYPE_CNAME) {
add_assoc_string(subarray, "type", "CNAME");
}
/* no break; */
case DNS_TYPE_NS:
if (type == DNS_TYPE_NS) {
add_assoc_string(subarray, "type", "NS");
}
/* no break; */
case DNS_TYPE_PTR:
if (type == DNS_TYPE_PTR) {
add_assoc_string(subarray, "type", "PTR");
}
add_assoc_string(subarray, "target", pRec->Data.MX.pNameExchange);
break;
/* Not available on windows, the query is possible but there is no DNS_HINFO_DATA structure */
case DNS_TYPE_HINFO:
case DNS_TYPE_TEXT:
{
DWORD i = 0;
DNS_TXT_DATA *data_txt = &pRec->Data.TXT;
DWORD count = data_txt->dwStringCount;
zend_string *txt;
char *txt_dst;
long txt_len = 0;
zval entries;
add_assoc_string(subarray, "type", "TXT");
array_init(&entries);
for (i = 0; i < count; i++) {
txt_len += strlen(data_txt->pStringArray[i]) + 1;
}
txt = STR_SAFE_ALLOC(txt_len, 2, 0, 0);
txt_dst = txt->val;
for (i = 0; i < count; i++) {
int len = strlen(data_txt->pStringArray[i]);
memcpy(txt_dst, data_txt->pStringArray[i], len);
add_next_index_stringl(&entries, data_txt->pStringArray[i], len);
txt_dst += len;
}
txt->len = txt_dst - txt->val;
add_assoc_str(subarray, "txt", txt);
add_assoc_zval(subarray, "entries", &entries);
}
break;
case DNS_TYPE_SOA:
{
DNS_SOA_DATA *data_soa = &pRec->Data.Soa;
add_assoc_string(subarray, "type", "SOA");
add_assoc_string(subarray, "mname", data_soa->pNamePrimaryServer);
add_assoc_string(subarray, "rname", data_soa->pNameAdministrator);
add_assoc_long(subarray, "serial", data_soa->dwSerialNo);
add_assoc_long(subarray, "refresh", data_soa->dwRefresh);
add_assoc_long(subarray, "retry", data_soa->dwRetry);
add_assoc_long(subarray, "expire", data_soa->dwExpire);
add_assoc_long(subarray, "minimum-ttl", data_soa->dwDefaultTtl);
}
break;
case DNS_TYPE_AAAA:
{
DNS_AAAA_DATA *data_aaaa = &pRec->Data.AAAA;
char buf[sizeof("AAAA:AAAA:AAAA:AAAA:AAAA:AAAA:AAAA:AAAA")];
char *tp = buf;
int i;
unsigned short out[8];
int have_v6_break = 0, in_v6_break = 0;
for (i = 0; i < 4; ++i) {
DWORD chunk = data_aaaa->Ip6Address.IP6Dword[i];
out[i * 2] = htons(LOWORD(chunk));
out[i * 2 + 1] = htons(HIWORD(chunk));
}
for(i=0; i < 8; i++) {
if (out[i] != 0) {
if (tp > (u_char *)buf) {
in_v6_break = 0;
tp[0] = ':';
tp++;
}
tp += sprintf((char*)tp,"%x", out[i]);
} else {
if (!have_v6_break) {
have_v6_break = 1;
in_v6_break = 1;
tp[0] = ':';
tp++;
} else if (!in_v6_break) {
tp[0] = ':';
tp++;
tp[0] = '0';
tp++;
}
}
}
if (have_v6_break && in_v6_break) {
tp[0] = ':';
tp++;
}
tp[0] = '\0';
add_assoc_string(subarray, "type", "AAAA");
add_assoc_string(subarray, "ipv6", buf);
}
break;
#if 0
/* Won't be implemented. A6 is deprecated. (Pierre) */
case DNS_TYPE_A6:
break;
#endif
case DNS_TYPE_SRV:
{
DNS_SRV_DATA *data_srv = &pRec->Data.Srv;
add_assoc_string(subarray, "type", "SRV");
add_assoc_long(subarray, "pri", data_srv->wPriority);
add_assoc_long(subarray, "weight", data_srv->wWeight);
add_assoc_long(subarray, "port", data_srv->wPort);
add_assoc_string(subarray, "target", data_srv->pNameTarget);
}
break;
#if _MSC_VER >= 1500
case DNS_TYPE_NAPTR:
{
DNS_NAPTR_DATA * data_naptr = &pRec->Data.Naptr;
add_assoc_string(subarray, "type", "NAPTR");
add_assoc_long(subarray, "order", data_naptr->wOrder);
add_assoc_long(subarray, "pref", data_naptr->wPreference);
add_assoc_string(subarray, "flags", data_naptr->pFlags);
add_assoc_string(subarray, "services", data_naptr->pService);
add_assoc_string(subarray, "regex", data_naptr->pRegularExpression);
add_assoc_string(subarray, "replacement", data_naptr->pReplacement);
}
break;
#endif
default:
/* unknown type */
ZVAL_UNDEF(subarray);
return;
}
}
ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr) /* {{{ */
{
zend_closure *closure;
object_init_ex(res, zend_ce_closure);
closure = (zend_closure *)Z_OBJ_P(res);
if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) {
/* use dummy scope if we're binding an object without specifying a scope */
/* maybe it would be better to create one for this purpose */
scope = zend_ce_closure;
}
if (func->type == ZEND_USER_FUNCTION) {
memcpy(&closure->func, func, sizeof(zend_op_array));
closure->func.common.prototype = (zend_function*)closure;
closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
if (closure->func.op_array.static_variables) {
HashTable *static_variables = closure->func.op_array.static_variables;
ALLOC_HASHTABLE(closure->func.op_array.static_variables);
zend_hash_init(closure->func.op_array.static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
zend_hash_apply_with_arguments(static_variables, zval_copy_static_var, 1, closure->func.op_array.static_variables);
}
if (UNEXPECTED(!closure->func.op_array.run_time_cache)) {
closure->func.op_array.run_time_cache = func->op_array.run_time_cache = zend_arena_alloc(&CG(arena), func->op_array.cache_size);
memset(func->op_array.run_time_cache, 0, func->op_array.cache_size);
}
if (closure->func.op_array.refcount) {
(*closure->func.op_array.refcount)++;
}
} else {
memcpy(&closure->func, func, sizeof(zend_internal_function));
closure->func.common.prototype = (zend_function*)closure;
closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
/* wrap internal function handler to avoid memory leak */
if (UNEXPECTED(closure->func.internal_function.handler == zend_closure_internal_handler)) {
/* avoid infinity recursion, by taking handler from nested closure */
zend_closure *nested = (zend_closure*)((char*)func - XtOffsetOf(zend_closure, func));
ZEND_ASSERT(nested->std.ce == zend_ce_closure);
closure->orig_internal_handler = nested->orig_internal_handler;
} else {
closure->orig_internal_handler = closure->func.internal_function.handler;
}
closure->func.internal_function.handler = zend_closure_internal_handler;
/* verify that we aren't binding internal function to a wrong scope */
if(func->common.scope != NULL) {
if(scope && !instanceof_function(scope, func->common.scope)) {
zend_error(E_WARNING, "Cannot bind function %s::%s to scope class %s", ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name), ZSTR_VAL(scope->name));
scope = NULL;
}
if(scope && this_ptr && (func->common.fn_flags & ZEND_ACC_STATIC) == 0 &&
!instanceof_function(Z_OBJCE_P(this_ptr), closure->func.common.scope)) {
zend_error(E_WARNING, "Cannot bind function %s::%s to object of class %s", ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name), ZSTR_VAL(Z_OBJCE_P(this_ptr)->name));
scope = NULL;
this_ptr = NULL;
}
} else {
/* if it's a free function, we won't set scope & this since they're meaningless */
this_ptr = NULL;
scope = NULL;
}
}
ZVAL_UNDEF(&closure->this_ptr);
/* Invariant:
* If the closure is unscoped or static, it has no bound object. */
closure->func.common.scope = scope;
closure->called_scope = called_scope;
if (scope) {
closure->func.common.fn_flags |= ZEND_ACC_PUBLIC;
if (this_ptr && Z_TYPE_P(this_ptr) == IS_OBJECT && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {
ZVAL_COPY(&closure->this_ptr, this_ptr);
}
}
}
PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) {
zval _7, _9;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval options, *options_param = NULL, client, persistentId, prefix, servers, statsKey, ttl, _1, _2, _3, _4, _5, _6, _8;
zval *this_ptr = getThis();
ZVAL_UNDEF(&options);
ZVAL_UNDEF(&client);
ZVAL_UNDEF(&persistentId);
ZVAL_UNDEF(&prefix);
ZVAL_UNDEF(&servers);
ZVAL_UNDEF(&statsKey);
ZVAL_UNDEF(&ttl);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_5);
ZVAL_UNDEF(&_6);
ZVAL_UNDEF(&_8);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_9);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options_param);
if (!options_param) {
ZEPHIR_INIT_VAR(&options);
array_init(&options);
} else {
ZEPHIR_OBS_COPY_OR_DUP(&options, options_param);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_libmemcached_ce, getThis(), "__construct", &_0, 0, &options);
zephir_check_call_status();
zephir_read_property(&_1, this_ptr, SL("options"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CPY_WRT(&options, &_1);
ZEPHIR_OBS_VAR(&servers);
if (!(zephir_array_isset_string_fetch(&servers, &options, SL("servers"), 0))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "No 'servers' specified in the options", "phalcon/session/adapter/libmemcached.zep", 62);
return;
}
ZEPHIR_INIT_VAR(&_2);
array_init(&_2);
ZEPHIR_INIT_VAR(&_3);
ZVAL_STRING(&_3, "client");
ZEPHIR_CALL_METHOD(&client, this_ptr, "arraygetdefault", NULL, 0, &options, &_3, &_2);
zephir_check_call_status();
zephir_read_property(&_1, this_ptr, SL("ttl"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_NVAR(&_3);
ZVAL_STRING(&_3, "ttl");
ZEPHIR_CALL_METHOD(&ttl, this_ptr, "arraygetdefault", NULL, 0, &options, &_3, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_3);
ZVAL_STRING(&_3, "statsKey");
ZEPHIR_INIT_VAR(&_4);
ZVAL_STRING(&_4, "");
ZEPHIR_CALL_METHOD(&statsKey, this_ptr, "arraygetdefault", NULL, 0, &options, &_3, &_4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_3);
ZVAL_STRING(&_3, "persistent_id");
ZEPHIR_INIT_NVAR(&_4);
ZVAL_STRING(&_4, "phalcon-session");
ZEPHIR_CALL_METHOD(&persistentId, this_ptr, "arraygetdefault", NULL, 0, &options, &_3, &_4);
zephir_check_call_status();
ZVAL_LONG(&_5, 2592000);
ZEPHIR_CALL_FUNCTION(&_6, "min", NULL, 423, &ttl, &_5);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("ttl"), &_6);
ZEPHIR_INIT_NVAR(&_3);
object_init_ex(&_3, phalcon_cache_backend_libmemcached_ce);
ZEPHIR_INIT_NVAR(&_4);
object_init_ex(&_4, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(&_7);
zephir_create_array(&_7, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(&_8);
zephir_read_property(&_8, this_ptr, SL("ttl"), PH_NOISY_CC);
zephir_array_update_string(&_7, SL("lifetime"), &_8, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, &_4, "__construct", NULL, 328, &_7);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_9);
zephir_create_array(&_9, 5, 0 TSRMLS_CC);
zephir_array_update_string(&_9, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_9, SL("client"), &client, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_9, SL("prefix"), &prefix, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_9, SL("statsKey"), &statsKey, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_9, SL("persistent_id"), &persistentId, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 329, &_4, &_9);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("connection"), &_3);
ZEPHIR_MM_RESTORE();
}
ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini)
{
zval token;
int token_type;
char *last_color = syntax_highlighter_ini->highlight_html;
char *next_color;
zend_printf("<code>");
zend_printf("<span style=\"color: %s\">\n", last_color);
/* highlight stuff coming back from zendlex() */
ZVAL_UNDEF(&token);
while ((token_type=lex_scan(&token))) {
switch (token_type) {
case T_INLINE_HTML:
next_color = syntax_highlighter_ini->highlight_html;
break;
case T_COMMENT:
case T_DOC_COMMENT:
next_color = syntax_highlighter_ini->highlight_comment;
break;
case T_OPEN_TAG:
case T_OPEN_TAG_WITH_ECHO:
case T_CLOSE_TAG:
case T_LINE:
case T_FILE:
case T_DIR:
case T_TRAIT_C:
case T_METHOD_C:
case T_FUNC_C:
case T_NS_C:
case T_CLASS_C:
next_color = syntax_highlighter_ini->highlight_default;
break;
case '"':
case T_ENCAPSED_AND_WHITESPACE:
case T_CONSTANT_ENCAPSED_STRING:
next_color = syntax_highlighter_ini->highlight_string;
break;
case T_WHITESPACE:
zend_html_puts((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng)); /* no color needed */
ZVAL_UNDEF(&token);
continue;
break;
default:
if (Z_TYPE(token) == IS_UNDEF) {
next_color = syntax_highlighter_ini->highlight_keyword;
} else {
next_color = syntax_highlighter_ini->highlight_default;
}
break;
}
if (last_color != next_color) {
if (last_color != syntax_highlighter_ini->highlight_html) {
zend_printf("</span>");
}
last_color = next_color;
if (last_color != syntax_highlighter_ini->highlight_html) {
zend_printf("<span style=\"color: %s\">", last_color);
}
}
zend_html_puts((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
if (Z_TYPE(token) == IS_STRING) {
switch (token_type) {
case T_OPEN_TAG:
case T_OPEN_TAG_WITH_ECHO:
case T_CLOSE_TAG:
case T_WHITESPACE:
case T_COMMENT:
case T_DOC_COMMENT:
break;
default:
zend_string_release(Z_STR(token));
break;
}
}
ZVAL_UNDEF(&token);
}
if (last_color != syntax_highlighter_ini->highlight_html) {
zend_printf("</span>\n");
}
zend_printf("</span>\n");
zend_printf("</code>");
}
ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr) /* {{{ */
{
zend_closure *closure;
object_init_ex(res, zend_ce_closure);
closure = (zend_closure *)Z_OBJ_P(res);
if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) {
/* use dummy scope if we're binding an object without specifying a scope */
/* maybe it would be better to create one for this purpose */
scope = zend_ce_closure;
}
if (func->type == ZEND_USER_FUNCTION) {
memcpy(&closure->func, func, sizeof(zend_op_array));
closure->func.common.prototype = (zend_function*)closure;
closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
if (closure->func.op_array.static_variables) {
closure->func.op_array.static_variables =
zend_array_dup(closure->func.op_array.static_variables);
}
if (UNEXPECTED(!closure->func.op_array.run_time_cache)) {
closure->func.op_array.run_time_cache = func->op_array.run_time_cache = zend_arena_alloc(&CG(arena), func->op_array.cache_size);
memset(func->op_array.run_time_cache, 0, func->op_array.cache_size);
}
if (closure->func.op_array.refcount) {
(*closure->func.op_array.refcount)++;
}
} else {
memcpy(&closure->func, func, sizeof(zend_internal_function));
closure->func.common.prototype = (zend_function*)closure;
closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
/* wrap internal function handler to avoid memory leak */
if (UNEXPECTED(closure->func.internal_function.handler == zend_closure_internal_handler)) {
/* avoid infinity recursion, by taking handler from nested closure */
zend_closure *nested = (zend_closure*)((char*)func - XtOffsetOf(zend_closure, func));
ZEND_ASSERT(nested->std.ce == zend_ce_closure);
closure->orig_internal_handler = nested->orig_internal_handler;
} else {
closure->orig_internal_handler = closure->func.internal_function.handler;
}
closure->func.internal_function.handler = zend_closure_internal_handler;
if (!func->common.scope) {
/* if it's a free function, we won't set scope & this since they're meaningless */
this_ptr = NULL;
scope = NULL;
}
}
ZVAL_UNDEF(&closure->this_ptr);
/* Invariant:
* If the closure is unscoped or static, it has no bound object. */
closure->func.common.scope = scope;
closure->called_scope = called_scope;
if (scope) {
closure->func.common.fn_flags |= ZEND_ACC_PUBLIC;
if (this_ptr && Z_TYPE_P(this_ptr) == IS_OBJECT && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {
ZVAL_COPY(&closure->this_ptr, this_ptr);
}
}
}
PHP_METHOD(Test_SpectralNorm, process) {
zend_bool _1, _7, _12;
zephir_fcall_cache_entry *_6 = NULL, *_11 = NULL, *_17 = NULL;
zval *n_param = NULL, u, v, w, _0, _4$$3, _5$$3, _10$$4, _15$$5, _16$$5, _18$$5, _19$$5, _20$$5;
zend_long n, ZEPHIR_LAST_CALL_STATUS, i = 0, vv, vBv, _2, _3, _8, _9, _13, _14;
zval *this_ptr = getThis();
ZVAL_UNDEF(&u);
ZVAL_UNDEF(&v);
ZVAL_UNDEF(&w);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_4$$3);
ZVAL_UNDEF(&_5$$3);
ZVAL_UNDEF(&_10$$4);
ZVAL_UNDEF(&_15$$5);
ZVAL_UNDEF(&_16$$5);
ZVAL_UNDEF(&_18$$5);
ZVAL_UNDEF(&_19$$5);
ZVAL_UNDEF(&_20$$5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &n_param);
n = zephir_get_intval(n_param);
vv = 0;
vBv = 0;
ZEPHIR_INIT_VAR(&u);
object_init_ex(&u, spl_ce_SplFixedArray);
ZVAL_LONG(&_0, n);
ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 74, &_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&v);
object_init_ex(&v, spl_ce_SplFixedArray);
ZVAL_LONG(&_0, n);
ZEPHIR_CALL_METHOD(NULL, &v, "__construct", NULL, 74, &_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&w);
object_init_ex(&w, spl_ce_SplFixedArray);
ZVAL_LONG(&_0, n);
ZEPHIR_CALL_METHOD(NULL, &w, "__construct", NULL, 74, &_0);
zephir_check_call_status();
_3 = (n - 1);
_2 = 0;
_1 = 0;
if (_2 <= _3) {
while (1) {
if (_1) {
_2++;
if (!(_2 <= _3)) {
break;
}
} else {
_1 = 1;
}
i = _2;
ZVAL_LONG(&_4$$3, i);
ZVAL_LONG(&_5$$3, 1);
ZEPHIR_CALL_METHOD(NULL, &u, "offsetset", &_6, 75, &_4$$3, &_5$$3);
zephir_check_call_status();
ZVAL_LONG(&_4$$3, i);
ZVAL_LONG(&_5$$3, 1);
ZEPHIR_CALL_METHOD(NULL, &v, "offsetset", &_6, 75, &_4$$3, &_5$$3);
zephir_check_call_status();
ZVAL_LONG(&_4$$3, i);
ZVAL_LONG(&_5$$3, 1);
ZEPHIR_CALL_METHOD(NULL, &w, "offsetset", &_6, 75, &_4$$3, &_5$$3);
zephir_check_call_status();
}
}
_9 = 9;
_8 = 0;
_7 = 0;
if (_8 <= _9) {
while (1) {
if (_7) {
_8++;
if (!(_8 <= _9)) {
break;
}
} else {
_7 = 1;
}
i = _8;
ZVAL_LONG(&_10$$4, n);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "atau", &_11, 76, &_10$$4, &u, &v, &w);
zephir_check_call_status();
ZVAL_LONG(&_10$$4, n);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "atau", &_11, 76, &_10$$4, &v, &u, &w);
zephir_check_call_status();
}
}
_14 = (n - 1);
_13 = 0;
_12 = 0;
if (_13 <= _14) {
while (1) {
if (_12) {
_13++;
if (!(_13 <= _14)) {
break;
}
} else {
_12 = 1;
}
i = _13;
ZVAL_LONG(&_16$$5, i);
ZEPHIR_CALL_METHOD(&_15$$5, &u, "offsetget", &_17, 77, &_16$$5);
zephir_check_call_status();
ZVAL_LONG(&_16$$5, i);
ZEPHIR_CALL_METHOD(&_18$$5, &v, "offsetget", &_17, 77, &_16$$5);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_19$$5);
mul_function(&_19$$5, &_15$$5, &_18$$5 TSRMLS_CC);
vBv += zephir_get_numberval(&_19$$5);
ZVAL_LONG(&_16$$5, i);
ZEPHIR_CALL_METHOD(&_15$$5, &v, "offsetget", &_17, 77, &_16$$5);
zephir_check_call_status();
ZVAL_LONG(&_16$$5, i);
ZEPHIR_CALL_METHOD(&_18$$5, &v, "offsetget", &_17, 77, &_16$$5);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_20$$5);
mul_function(&_20$$5, &_15$$5, &_18$$5 TSRMLS_CC);
vv += zephir_get_numberval(&_20$$5);
}
}
ZVAL_DOUBLE(&_0, zephir_safe_div_long_long(vBv, vv TSRMLS_CC));
RETURN_MM_DOUBLE(sqrt(zephir_safe_div_long_long(vBv, vv TSRMLS_CC)));
}
/**
* Returns a MongoDb collection based on the backend parameters
*
* @return MongoCollection
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, _getCollection) {
zend_bool _0$$6, _1$$3, _2$$3;
zval options, mongo, server, database, collection, mongoCollection, _3$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&options);
ZVAL_UNDEF(&mongo);
ZVAL_UNDEF(&server);
ZVAL_UNDEF(&database);
ZVAL_UNDEF(&collection);
ZVAL_UNDEF(&mongoCollection);
ZVAL_UNDEF(&_3$$3);
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(&mongoCollection);
zephir_read_property(&mongoCollection, this_ptr, SL("_collection"), PH_NOISY_CC);
if (Z_TYPE_P(&mongoCollection) != IS_OBJECT) {
ZEPHIR_OBS_VAR(&options);
zephir_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(&mongo);
if (zephir_array_isset_string_fetch(&mongo, &options, SL("mongo"), 0)) {
if (Z_TYPE_P(&mongo) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The 'mongo' parameter must be a valid Mongo instance", "phalcon/cache/backend/mongo.zep", 99);
return;
}
} else {
ZEPHIR_OBS_VAR(&server);
zephir_array_fetch_string(&server, &options, SL("server"), PH_NOISY, "phalcon/cache/backend/mongo.zep", 107 TSRMLS_CC);
_0$$6 = !zephir_is_true(&server);
if (!(_0$$6)) {
_0$$6 = Z_TYPE_P(&server) != IS_STRING;
}
if (_0$$6) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB connection string", "phalcon/cache/backend/mongo.zep", 109);
return;
}
ZEPHIR_INIT_NVAR(&mongo);
object_init_ex(&mongo, zephir_get_internal_ce(SL("mongoclient")));
if (zephir_has_constructor(&mongo TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, &mongo, "__construct", NULL, 0, &server);
zephir_check_call_status();
}
}
ZEPHIR_OBS_VAR(&database);
zephir_array_fetch_string(&database, &options, SL("db"), PH_NOISY, "phalcon/cache/backend/mongo.zep", 118 TSRMLS_CC);
_1$$3 = !zephir_is_true(&database);
if (!(_1$$3)) {
_1$$3 = Z_TYPE_P(&database) != IS_STRING;
}
if (_1$$3) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB db", "phalcon/cache/backend/mongo.zep", 120);
return;
}
ZEPHIR_OBS_VAR(&collection);
zephir_array_fetch_string(&collection, &options, SL("collection"), PH_NOISY, "phalcon/cache/backend/mongo.zep", 126 TSRMLS_CC);
_2$$3 = !zephir_is_true(&collection);
if (!(_2$$3)) {
_2$$3 = Z_TYPE_P(&collection) != IS_STRING;
}
if (_2$$3) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB collection", "phalcon/cache/backend/mongo.zep", 128);
return;
}
ZEPHIR_CALL_METHOD(&_3$$3, &mongo, "selectdb", NULL, 0, &database);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&mongoCollection, &_3$$3, "selectcollection", NULL, 0, &collection);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("_collection"), &mongoCollection);
}
RETURN_CCTOR(&mongoCollection);
}
PHP_METHOD(Test_SpectralNorm, Au) {
zend_bool _0, _3$$3;
zephir_fcall_cache_entry *_9 = NULL, *_11 = NULL, *_15 = NULL;
zval *n_param = NULL, *u, u_sub, *v, v_sub, _13$$3, _14$$3, _6$$4, _7$$4, _8$$4, _10$$4, _12$$4;
zend_long n, ZEPHIR_LAST_CALL_STATUS, t = 0, i = 0, j = 0, _1, _2, _4$$3, _5$$3;
zval *this_ptr = getThis();
ZVAL_UNDEF(&u_sub);
ZVAL_UNDEF(&v_sub);
ZVAL_UNDEF(&_13$$3);
ZVAL_UNDEF(&_14$$3);
ZVAL_UNDEF(&_6$$4);
ZVAL_UNDEF(&_7$$4);
ZVAL_UNDEF(&_8$$4);
ZVAL_UNDEF(&_10$$4);
ZVAL_UNDEF(&_12$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &n_param, &u, &v);
n = zephir_get_intval(n_param);
_2 = (n - 1);
_1 = 0;
_0 = 0;
if (_1 <= _2) {
while (1) {
if (_0) {
_1++;
if (!(_1 <= _2)) {
break;
}
} else {
_0 = 1;
}
i = _1;
t = 0;
_5$$3 = (n - 1);
_4$$3 = 0;
_3$$3 = 0;
if (_4$$3 <= _5$$3) {
while (1) {
if (_3$$3) {
_4$$3++;
if (!(_4$$3 <= _5$$3)) {
break;
}
} else {
_3$$3 = 1;
}
j = _4$$3;
ZVAL_LONG(&_7$$4, i);
ZVAL_LONG(&_8$$4, j);
ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "ax", &_9, 71, &_7$$4, &_8$$4);
zephir_check_call_status();
ZVAL_LONG(&_7$$4, j);
ZEPHIR_CALL_METHOD(&_10$$4, u, "offsetget", &_11, 0, &_7$$4);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_12$$4);
mul_function(&_12$$4, &_6$$4, &_10$$4 TSRMLS_CC);
t += zephir_get_numberval(&_12$$4);
}
}
ZVAL_LONG(&_13$$3, i);
ZVAL_LONG(&_14$$3, t);
ZEPHIR_CALL_METHOD(NULL, v, "offsetset", &_15, 0, &_13$$3, &_14$$3);
zephir_check_call_status();
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string keyName
* @param string content
* @param int lifetime
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, save) {
zval _2$$14;
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, keyName_sub, *content = NULL, content_sub, *lifetime = NULL, lifetime_sub, *stopBuffer_param = NULL, __$true, __$false, __$null, lastkey, frontend, cachedContent, tmp, ttl, collection, timestamp, conditions, document, preparedContent, isBuffering, data, success, _1, _0$$4, _3$$14;
zval *this_ptr = getThis();
ZVAL_UNDEF(&keyName_sub);
ZVAL_UNDEF(&content_sub);
ZVAL_UNDEF(&lifetime_sub);
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&lastkey);
ZVAL_UNDEF(&frontend);
ZVAL_UNDEF(&cachedContent);
ZVAL_UNDEF(&tmp);
ZVAL_UNDEF(&ttl);
ZVAL_UNDEF(&collection);
ZVAL_UNDEF(×tamp);
ZVAL_UNDEF(&conditions);
ZVAL_UNDEF(&document);
ZVAL_UNDEF(&preparedContent);
ZVAL_UNDEF(&isBuffering);
ZVAL_UNDEF(&data);
ZVAL_UNDEF(&success);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_0$$4);
ZVAL_UNDEF(&_3$$14);
ZVAL_UNDEF(&_2$$14);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = &keyName_sub;
keyName = &__$null;
}
if (!content) {
content = &content_sub;
content = &__$null;
}
if (!lifetime) {
lifetime = &lifetime_sub;
lifetime = &__$null;
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
ZEPHIR_INIT_VAR(&conditions);
array_init(&conditions);
ZEPHIR_INIT_VAR(&data);
array_init(&data);
if (Z_TYPE_P(keyName) == IS_NULL) {
ZEPHIR_OBS_VAR(&lastkey);
zephir_read_property(&lastkey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
zephir_read_property(&_0$$4, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_NVAR(&lastkey);
ZEPHIR_CONCAT_VV(&lastkey, &_0$$4, keyName);
zephir_update_property_zval(this_ptr, SL("_lastKey"), &lastkey);
}
if (!(zephir_is_true(&lastkey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/mongo.zep", 195);
return;
}
ZEPHIR_OBS_VAR(&frontend);
zephir_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (Z_TYPE_P(content) == IS_NULL) {
ZEPHIR_CALL_METHOD(&cachedContent, &frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(&cachedContent, content);
}
if (!(zephir_is_numeric(&cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, &frontend, "beforestore", NULL, 0, &cachedContent);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(&preparedContent, &cachedContent);
}
if (Z_TYPE_P(lifetime) == IS_NULL) {
ZEPHIR_OBS_VAR(&tmp);
zephir_read_property(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(&tmp))) {
ZEPHIR_CALL_METHOD(&ttl, &frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(&ttl, &tmp);
}
} else {
ZEPHIR_CPY_WRT(&ttl, lifetime);
}
ZEPHIR_CALL_METHOD(&collection, this_ptr, "_getcollection", NULL, 104);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_1);
zephir_time(&_1);
ZEPHIR_INIT_VAR(×tamp);
ZVAL_LONG(×tamp, (zephir_get_numberval(&_1) + zephir_get_intval(&ttl)));
zephir_array_update_string(&conditions, SL("key"), &lastkey, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&document, &collection, "findone", NULL, 0, &conditions);
zephir_check_call_status();
if (Z_TYPE_P(&document) == IS_ARRAY) {
zephir_array_update_string(&document, SL("time"), ×tamp, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&document, SL("data"), &preparedContent, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(&_2$$14);
zephir_create_array(&_2$$14, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(&_3$$14);
zephir_array_fetch_string(&_3$$14, &document, SL("_id"), PH_NOISY, "phalcon/cache/backend/mongo.zep", 230 TSRMLS_CC);
zephir_array_update_string(&_2$$14, SL("_id"), &_3$$14, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&success, &collection, "update", NULL, 0, &_2$$14, &document);
zephir_check_call_status();
} else {
zephir_array_update_string(&data, SL("key"), &lastkey, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&data, SL("time"), ×tamp, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&data, SL("data"), &preparedContent, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&success, &collection, "insert", NULL, 0, &data);
zephir_check_call_status();
}
if (!(zephir_is_true(&success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed storing data in mongodb", "phalcon/cache/backend/mongo.zep", 239);
return;
}
ZEPHIR_CALL_METHOD(&isBuffering, &frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, &frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(&isBuffering)) {
zend_print_zval(&cachedContent, 0);
}
if (0) {
zephir_update_property_zval(this_ptr, SL("_started"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_started"), &__$false);
}
RETURN_CCTOR(&success);
}
void shutdown_executor(void) /* {{{ */
{
zend_function *func;
zend_class_entry *ce;
zend_try {
/* Removed because this can not be safely done, e.g. in this situation:
Object 1 creates object 2
Object 3 holds reference to object 2.
Now when 1 and 2 are destroyed, 3 can still access 2 in its destructor, with
very problematic results */
/* zend_objects_store_call_destructors(&EG(objects_store)); */
/* Moved after symbol table cleaners, because some of the cleaners can call
destructors, which would use EG(symtable_cache_ptr) and thus leave leaks */
/* while (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
zend_hash_destroy(*EG(symtable_cache_ptr));
efree(*EG(symtable_cache_ptr));
EG(symtable_cache_ptr)--;
}
*/
zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_deactivator);
if (CG(unclean_shutdown)) {
EG(symbol_table).pDestructor = zend_unclean_zval_ptr_dtor;
}
zend_hash_graceful_reverse_destroy(&EG(symbol_table));
} zend_end_try();
EG(valid_symbol_table) = 0;
zend_try {
zval *zeh;
/* remove error handlers before destroying classes and functions,
* so that if handler used some class, crash would not happen */
if (Z_TYPE(EG(user_error_handler)) != IS_UNDEF) {
zeh = &EG(user_error_handler);
zval_ptr_dtor(zeh);
ZVAL_UNDEF(&EG(user_error_handler));
}
if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) {
zeh = &EG(user_exception_handler);
zval_ptr_dtor(zeh);
ZVAL_UNDEF(&EG(user_exception_handler));
}
zend_stack_clean(&EG(user_error_handlers_error_reporting), NULL, 1);
zend_stack_clean(&EG(user_error_handlers), (void (*)(void *))ZVAL_DESTRUCTOR, 1);
zend_stack_clean(&EG(user_exception_handlers), (void (*)(void *))ZVAL_DESTRUCTOR, 1);
} zend_end_try();
zend_try {
/* Cleanup static data for functions and arrays.
* We need a separate cleanup stage because of the following problem:
* Suppose we destroy class X, which destroys the class's function table,
* and in the function table we have function foo() that has static $bar.
* Now if an object of class X is assigned to $bar, its destructor will be
* called and will fail since X's function table is in mid-destruction.
* So we want first of all to clean up all data and then move to tables destruction.
* Note that only run-time accessed data need to be cleaned up, pre-defined data can
* not contain objects and thus are not probelmatic */
if (EG(full_tables_cleanup)) {
ZEND_HASH_FOREACH_PTR(EG(function_table), func) {
if (func->type == ZEND_USER_FUNCTION) {
zend_cleanup_op_array_data((zend_op_array *) func);
}
} ZEND_HASH_FOREACH_END();
ZEND_HASH_REVERSE_FOREACH_PTR(EG(class_table), ce) {
if (ce->type == ZEND_USER_CLASS) {
zend_cleanup_user_class_data(ce);
} else {
zend_cleanup_internal_class_data(ce);
}
} ZEND_HASH_FOREACH_END();
} else {
ZEND_HASH_REVERSE_FOREACH_PTR(EG(function_table), func) {
if (func->type != ZEND_USER_FUNCTION) {
break;
}
zend_cleanup_op_array_data((zend_op_array *) func);
} ZEND_HASH_FOREACH_END();
ZEND_HASH_REVERSE_FOREACH_PTR(EG(class_table), ce) {
if (ce->type != ZEND_USER_CLASS) {
break;
}
zend_cleanup_user_class_data(ce);
} ZEND_HASH_FOREACH_END();
zend_cleanup_internal_classes();
}
} zend_end_try();
/**
* Resolves the service
*
* @param array parameters
* @return mixed
*/
PHP_METHOD(Phalcon_Di_Service, resolve) {
zend_class_entry *_1$$15;
zend_bool found = 0;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *parameters = NULL, parameters_sub, *dependencyInjector = NULL, dependencyInjector_sub, __$true, __$false, __$null, shared, definition, sharedInstance, instance, builder, _0$$15, _2$$22;
zval *this_ptr = getThis();
ZVAL_UNDEF(¶meters_sub);
ZVAL_UNDEF(&dependencyInjector_sub);
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&shared);
ZVAL_UNDEF(&definition);
ZVAL_UNDEF(&sharedInstance);
ZVAL_UNDEF(&instance);
ZVAL_UNDEF(&builder);
ZVAL_UNDEF(&_0$$15);
ZVAL_UNDEF(&_2$$22);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, ¶meters, &dependencyInjector);
if (!parameters) {
parameters = ¶meters_sub;
parameters = &__$null;
}
if (!dependencyInjector) {
dependencyInjector = &dependencyInjector_sub;
dependencyInjector = &__$null;
}
ZEPHIR_OBS_VAR(&shared);
zephir_read_property(&shared, this_ptr, SL("_shared"), PH_NOISY_CC);
if (zephir_is_true(&shared)) {
ZEPHIR_OBS_VAR(&sharedInstance);
zephir_read_property(&sharedInstance, this_ptr, SL("_sharedInstance"), PH_NOISY_CC);
if (Z_TYPE_P(&sharedInstance) != IS_NULL) {
RETURN_CCTOR(&sharedInstance);
}
}
found = 1;
ZEPHIR_INIT_VAR(&instance);
ZVAL_NULL(&instance);
ZEPHIR_OBS_VAR(&definition);
zephir_read_property(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);
if (Z_TYPE_P(&definition) == IS_STRING) {
if (zephir_class_exists(&definition, 1 TSRMLS_CC)) {
if (Z_TYPE_P(parameters) == IS_ARRAY) {
if (zephir_fast_count_int(parameters TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(&instance, &definition, parameters TSRMLS_CC);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&instance, &definition TSRMLS_CC);
zephir_check_call_status();
}
} else {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&instance, &definition TSRMLS_CC);
zephir_check_call_status();
}
} else {
found = 0;
}
} else {
if (Z_TYPE_P(&definition) == IS_OBJECT) {
if (zephir_instance_of_ev(&definition, zend_ce_closure TSRMLS_CC)) {
if (Z_TYPE_P(dependencyInjector) == IS_OBJECT) {
_1$$15 = zephir_fetch_class_str_ex(SL("Closure"), ZEND_FETCH_CLASS_AUTO);
ZEPHIR_CALL_CE_STATIC(&_0$$15, _1$$15, "bind", NULL, 0, &definition, dependencyInjector);
zephir_check_call_status();
ZEPHIR_CPY_WRT(&definition, &_0$$15);
}
if (Z_TYPE_P(parameters) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_CALL_USER_FUNC_ARRAY(&instance, &definition, parameters);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(&instance);
ZEPHIR_CALL_USER_FUNC(&instance, &definition);
zephir_check_call_status();
}
} else {
ZEPHIR_CPY_WRT(&instance, &definition);
}
} else {
if (Z_TYPE_P(&definition) == IS_ARRAY) {
ZEPHIR_INIT_VAR(&builder);
object_init_ex(&builder, phalcon_di_service_builder_ce);
if (zephir_has_constructor(&builder TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, &builder, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&instance, &builder, "build", NULL, 171, dependencyInjector, &definition, parameters);
zephir_check_call_status();
} else {
found = 0;
}
}
}
if (found == 0) {
ZEPHIR_INIT_VAR(&_2$$22);
object_init_ex(&_2$$22, phalcon_di_exception_serviceresolutionexception_ce);
ZEPHIR_CALL_METHOD(NULL, &_2$$22, "__construct", NULL, 4);
zephir_check_call_status();
zephir_throw_exception_debug(&_2$$22, "phalcon/di/service.zep", 186 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (zephir_is_true(&shared)) {
zephir_update_property_zval(this_ptr, SL("_sharedInstance"), &instance);
}
if (1) {
zephir_update_property_zval(this_ptr, SL("_resolved"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_resolved"), &__$false);
}
RETURN_CCTOR(&instance);
}
void init_executor(void) /* {{{ */
{
zend_init_fpu();
ZVAL_NULL(&EG(uninitialized_zval));
ZVAL_ERROR(&EG(error_zval));
/* destroys stack frame, therefore makes core dumps worthless */
#if 0&&ZEND_DEBUG
original_sigsegv_handler = signal(SIGSEGV, zend_handle_sigsegv);
#endif
EG(symtable_cache_ptr) = EG(symtable_cache) - 1;
EG(symtable_cache_limit) = EG(symtable_cache) + SYMTABLE_CACHE_SIZE - 1;
EG(no_extensions) = 0;
EG(function_table) = CG(function_table);
EG(class_table) = CG(class_table);
EG(in_autoload) = NULL;
EG(autoload_func) = NULL;
EG(error_handling) = EH_NORMAL;
zend_vm_stack_init();
zend_hash_init(&EG(symbol_table), 64, NULL, ZVAL_PTR_DTOR, 0);
zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_activator);
zend_hash_init(&EG(included_files), 8, NULL, NULL, 0);
EG(ticks_count) = 0;
ZVAL_UNDEF(&EG(user_error_handler));
ZVAL_UNDEF(&EG(user_exception_handler));
EG(current_execute_data) = NULL;
zend_stack_init(&EG(user_error_handlers_error_reporting), sizeof(int));
zend_stack_init(&EG(user_error_handlers), sizeof(zval));
zend_stack_init(&EG(user_exception_handlers), sizeof(zval));
zend_objects_store_init(&EG(objects_store), 1024);
EG(full_tables_cleanup) = 0;
EG(vm_interrupt) = 0;
EG(timed_out) = 0;
EG(exception) = NULL;
EG(prev_exception) = NULL;
EG(fake_scope) = NULL;
EG(ht_iterators_count) = sizeof(EG(ht_iterators_slots)) / sizeof(HashTableIterator);
EG(ht_iterators_used) = 0;
EG(ht_iterators) = EG(ht_iterators_slots);
memset(EG(ht_iterators), 0, sizeof(EG(ht_iterators_slots)));
EG(each_deprecation_thrown) = 0;
EG(active) = 1;
}
/* {{{ spl_ptr_llist */
static void spl_ptr_llist_zval_dtor(spl_ptr_llist_element *elem) { /* {{{ */
if (!Z_ISUNDEF(elem->data)) {
zval_ptr_dtor(&elem->data);
ZVAL_UNDEF(&elem->data);
}
}
static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
int argc, sqlite3_value **argv, sqlite3_context *context,
int is_agg)
{
zval *zargs = NULL;
zval retval;
int i;
int ret;
int fake_argc;
zend_reference *agg_context = NULL;
if (is_agg) {
is_agg = 2;
}
fake_argc = argc + is_agg;
fc->fci.size = sizeof(fc->fci);
fc->fci.function_table = EG(function_table);
ZVAL_COPY_VALUE(&fc->fci.function_name, cb);
fc->fci.symbol_table = NULL;
fc->fci.object = NULL;
fc->fci.retval = &retval;
fc->fci.param_count = fake_argc;
/* build up the params */
if (fake_argc) {
zargs = safe_emalloc(fake_argc, sizeof(zval), 0);
}
if (is_agg) {
agg_context = (zend_reference*)sqlite3_aggregate_context(context, sizeof(zend_reference));
if (!agg_context) {
ZVAL_NULL(&zargs[0]);
} else {
if (Z_ISUNDEF(agg_context->val)) {
GC_REFCOUNT(agg_context) = 1;
GC_TYPE_INFO(agg_context) = IS_REFERENCE;
ZVAL_NULL(&agg_context->val);
}
ZVAL_REF(&zargs[0], agg_context);
}
ZVAL_LONG(&zargs[1], sqlite3_aggregate_count(context));
}
for (i = 0; i < argc; i++) {
/* get the value */
switch (sqlite3_value_type(argv[i])) {
case SQLITE_INTEGER:
ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int(argv[i]));
break;
case SQLITE_FLOAT:
ZVAL_DOUBLE(&zargs[i + is_agg], sqlite3_value_double(argv[i]));
break;
case SQLITE_NULL:
ZVAL_NULL(&zargs[i + is_agg]);
break;
case SQLITE_BLOB:
case SQLITE3_TEXT:
default:
ZVAL_STRINGL(&zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]));
break;
}
}
fc->fci.params = zargs;
if ((ret = zend_call_function(&fc->fci, &fc->fcc)) == FAILURE) {
php_error_docref(NULL, E_WARNING, "An error occurred while invoking the callback");
}
/* clean up the params */
if (zargs) {
for (i = is_agg; i < fake_argc; i++) {
zval_ptr_dtor(&zargs[i]);
}
if (is_agg) {
zval_ptr_dtor(&zargs[1]);
}
efree(zargs);
}
if (!is_agg || !argv) {
/* only set the sqlite return value if we are a scalar function,
* or if we are finalizing an aggregate */
if (!Z_ISUNDEF(retval)) {
switch (Z_TYPE(retval)) {
case IS_LONG:
sqlite3_result_int(context, Z_LVAL(retval));
break;
case IS_NULL:
sqlite3_result_null(context);
break;
case IS_DOUBLE:
sqlite3_result_double(context, Z_DVAL(retval));
break;
default:
convert_to_string_ex(&retval);
sqlite3_result_text(context, Z_STRVAL(retval), Z_STRLEN(retval), SQLITE_TRANSIENT);
break;
}
} else {
sqlite3_result_error(context, "failed to invoke callback", 0);
}
if (agg_context) {
zval_ptr_dtor(&agg_context->val);
}
} else {
/* we're stepping in an aggregate; the return value goes into
* the context */
if (agg_context) {
zval_ptr_dtor(&agg_context->val);
}
if (!Z_ISUNDEF(retval)) {
ZVAL_COPY_VALUE(&agg_context->val, &retval);
ZVAL_UNDEF(&retval);
} else {
ZVAL_UNDEF(&agg_context->val);
}
}
if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
return ret;
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Between, validate) {
zend_bool _3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, value, minimum, maximum, message, label, replacePairs, code, _0, _1$$3, _2$$4, _4$$5, _5$$5, _6$$5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&minimum);
ZVAL_UNDEF(&maximum);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2$$4);
ZVAL_UNDEF(&_4$$5);
ZVAL_UNDEF(&_5$$5);
ZVAL_UNDEF(&_6$$5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_0);
ZVAL_STRING(&_0, "minimum");
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, &_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_0);
ZVAL_STRING(&_0, "maximum");
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, &_0);
zephir_check_call_status();
if (Z_TYPE_P(&minimum) == IS_ARRAY) {
zephir_array_fetch(&_1$$3, &minimum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/between.zep", 79 TSRMLS_CC);
ZEPHIR_CPY_WRT(&minimum, &_1$$3);
}
if (Z_TYPE_P(&maximum) == IS_ARRAY) {
zephir_array_fetch(&_2$$4, &maximum, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/between.zep", 83 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maximum, &_2$$4);
}
_3 = ZEPHIR_LT(&value, &minimum);
if (!(_3)) {
_3 = ZEPHIR_GT(&value, &maximum);
}
if (_3) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_4$$5);
ZVAL_STRING(&_4$$5, "Between");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_4$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 3, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minimum, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maximum, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_4$$5);
object_init_ex(&_4$$5, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_5$$5, "strtr", NULL, 48, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_6$$5);
ZVAL_STRING(&_6$$5, "Between");
ZEPHIR_CALL_METHOD(NULL, &_4$$5, "__construct", NULL, 300, &_5$$5, field, &_6$$5, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_4$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Set an specific argument
*/
PHP_METHOD(Phalcon_Cli_Console, setArgument) {
zephir_fcall_cache_entry *_5 = NULL, *_24 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool str, shift, _0;
zval *arguments_param = NULL, *str_param = NULL, *shift_param = NULL, __$true, arg, pos, args, opts, handleArgs, *_1, _2$$5, _3$$5, _4$$5, _6$$6, _7$$7, _8$$7, _9$$7, _10$$7, _11$$7, _12$$7, _13$$7, _14$$8, _15$$8, _16$$8, _17$$9, _18$$9, _19$$9, _20$$10, _21$$10, _22$$13, _23$$13, _25$$15, _26$$16, _27$$17;
zval arguments;
zval *this_ptr = getThis();
ZVAL_UNDEF(&arguments);
ZVAL_BOOL(&__$true, 1);
ZVAL_UNDEF(&arg);
ZVAL_UNDEF(&pos);
ZVAL_UNDEF(&args);
ZVAL_UNDEF(&opts);
ZVAL_UNDEF(&handleArgs);
ZVAL_UNDEF(&_2$$5);
ZVAL_UNDEF(&_3$$5);
ZVAL_UNDEF(&_4$$5);
ZVAL_UNDEF(&_6$$6);
ZVAL_UNDEF(&_7$$7);
ZVAL_UNDEF(&_8$$7);
ZVAL_UNDEF(&_9$$7);
ZVAL_UNDEF(&_10$$7);
ZVAL_UNDEF(&_11$$7);
ZVAL_UNDEF(&_12$$7);
ZVAL_UNDEF(&_13$$7);
ZVAL_UNDEF(&_14$$8);
ZVAL_UNDEF(&_15$$8);
ZVAL_UNDEF(&_16$$8);
ZVAL_UNDEF(&_17$$9);
ZVAL_UNDEF(&_18$$9);
ZVAL_UNDEF(&_19$$9);
ZVAL_UNDEF(&_20$$10);
ZVAL_UNDEF(&_21$$10);
ZVAL_UNDEF(&_22$$13);
ZVAL_UNDEF(&_23$$13);
ZVAL_UNDEF(&_25$$15);
ZVAL_UNDEF(&_26$$16);
ZVAL_UNDEF(&_27$$17);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 3, &arguments_param, &str_param, &shift_param);
if (!arguments_param) {
ZEPHIR_INIT_VAR(&arguments);
array_init(&arguments);
} else {
ZEPHIR_OBS_COPY_OR_DUP(&arguments, arguments_param);
}
if (!str_param) {
str = 1;
} else {
if (UNEXPECTED(Z_TYPE_P(str_param) != IS_TRUE && Z_TYPE_P(str_param) != IS_FALSE)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be of the type bool") TSRMLS_CC);
RETURN_MM_NULL();
}
str = (Z_TYPE_P(str_param) == IS_TRUE);
}
if (!shift_param) {
shift = 1;
} else {
if (UNEXPECTED(Z_TYPE_P(shift_param) != IS_TRUE && Z_TYPE_P(shift_param) != IS_FALSE)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'shift' must be of the type bool") TSRMLS_CC);
RETURN_MM_NULL();
}
shift = (Z_TYPE_P(shift_param) == IS_TRUE);
}
ZEPHIR_INIT_VAR(&args);
array_init(&args);
ZEPHIR_INIT_VAR(&opts);
array_init(&opts);
ZEPHIR_INIT_VAR(&handleArgs);
array_init(&handleArgs);
_0 = shift;
if (_0) {
_0 = ((zephir_fast_count_int(&arguments TSRMLS_CC)) ? 1 : 0);
}
if (_0) {
ZEPHIR_MAKE_REF(&arguments);
ZEPHIR_CALL_FUNCTION(NULL, "array_shift", NULL, 11, &arguments);
ZEPHIR_UNREF(&arguments);
zephir_check_call_status();
}
zephir_is_iterable(&arguments, 0, "phalcon/cli/console.zep", 176);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&arguments), _1)
{
ZEPHIR_INIT_NVAR(&arg);
ZVAL_COPY(&arg, _1);
if (Z_TYPE_P(&arg) == IS_STRING) {
ZEPHIR_INIT_NVAR(&_2$$5);
ZVAL_STRING(&_2$$5, "--");
ZVAL_LONG(&_3$$5, 2);
ZEPHIR_CALL_FUNCTION(&_4$$5, "strncmp", &_5, 117, &arg, &_2$$5, &_3$$5);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(&_4$$5, 0)) {
ZEPHIR_INIT_NVAR(&_6$$6);
ZVAL_STRING(&_6$$6, "=");
ZEPHIR_INIT_NVAR(&pos);
zephir_fast_strpos(&pos, &arg, &_6$$6, 0 );
if (zephir_is_true(&pos)) {
ZEPHIR_INIT_NVAR(&_7$$7);
ZVAL_LONG(&_8$$7, (zephir_get_numberval(&pos) + 1));
ZEPHIR_INIT_NVAR(&_9$$7);
zephir_substr(&_9$$7, &arg, zephir_get_intval(&_8$$7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_fast_trim(&_7$$7, &_9$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
ZEPHIR_INIT_NVAR(&_10$$7);
ZVAL_LONG(&_11$$7, 2);
ZVAL_LONG(&_12$$7, (zephir_get_numberval(&pos) - 2));
ZEPHIR_INIT_NVAR(&_13$$7);
zephir_substr(&_13$$7, &arg, 2 , zephir_get_intval(&_12$$7), 0);
zephir_fast_trim(&_10$$7, &_13$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
zephir_array_update_zval(&opts, &_10$$7, &_7$$7, PH_COPY | PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(&_14$$8);
ZVAL_LONG(&_15$$8, 2);
ZEPHIR_INIT_NVAR(&_16$$8);
zephir_substr(&_16$$8, &arg, 2 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_fast_trim(&_14$$8, &_16$$8, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
zephir_array_update_zval(&opts, &_14$$8, &__$true, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_NVAR(&_17$$9);
ZVAL_STRING(&_17$$9, "-");
ZVAL_LONG(&_18$$9, 1);
ZEPHIR_CALL_FUNCTION(&_19$$9, "strncmp", &_5, 117, &arg, &_17$$9, &_18$$9);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(&_19$$9, 0)) {
ZVAL_LONG(&_20$$10, 1);
ZEPHIR_INIT_NVAR(&_21$$10);
zephir_substr(&_21$$10, &arg, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_array_update_zval(&opts, &_21$$10, &__$true, PH_COPY | PH_SEPARATE);
} else {
zephir_array_append(&args, &arg, PH_SEPARATE, "phalcon/cli/console.zep", 168);
}
}
} else {
zephir_array_append(&args, &arg, PH_SEPARATE, "phalcon/cli/console.zep", 172);
}
} ZEND_HASH_FOREACH_END();
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zend_bool _1, _2, _3, _5, _6, _11, _12, _14, _20, _21, _50, _57$$16, _64$$21;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, *_SERVER, *_POST, *_FILES, value, message, label, replacePairs, types, byteUnits, unit, maxSize, matches, bytes, mime, tmp, width, height, minResolution, maxResolution, minWidth, maxWidth, minHeight, maxHeight, fieldTypes, code, minResolutionArray, maxResolutionArray, _0, _4, _7, _13, _15, _16, _25, _26, _42, _49, _51, _8$$3, _9$$3, _10$$3, _17$$4, _18$$4, _19$$4, _22$$5, _23$$5, _24$$5, _27$$6, _29$$6, _30$$6, _31$$6, _32$$6, _33$$6, _34$$6, _35$$6, _36$$6, _37$$6, _38$$6, _28$$7, _39$$9, _40$$9, _41$$9, _43$$10, _44$$13, _45$$13, _46$$15, _47$$15, _48$$15, _52$$16, _53$$16, _54$$16, _61$$16, _55$$17, _56$$18, _58$$20, _59$$20, _60$$20, _62$$21, _63$$22, _65$$23, _66$$23, _67$$23;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&types);
ZVAL_UNDEF(&byteUnits);
ZVAL_UNDEF(&unit);
ZVAL_UNDEF(&maxSize);
ZVAL_UNDEF(&matches);
ZVAL_UNDEF(&bytes);
ZVAL_UNDEF(&mime);
ZVAL_UNDEF(&tmp);
ZVAL_UNDEF(&width);
ZVAL_UNDEF(&height);
ZVAL_UNDEF(&minResolution);
ZVAL_UNDEF(&maxResolution);
ZVAL_UNDEF(&minWidth);
ZVAL_UNDEF(&maxWidth);
ZVAL_UNDEF(&minHeight);
ZVAL_UNDEF(&maxHeight);
ZVAL_UNDEF(&fieldTypes);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&minResolutionArray);
ZVAL_UNDEF(&maxResolutionArray);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_13);
ZVAL_UNDEF(&_15);
ZVAL_UNDEF(&_16);
ZVAL_UNDEF(&_25);
ZVAL_UNDEF(&_26);
ZVAL_UNDEF(&_42);
ZVAL_UNDEF(&_49);
ZVAL_UNDEF(&_51);
ZVAL_UNDEF(&_8$$3);
ZVAL_UNDEF(&_9$$3);
ZVAL_UNDEF(&_10$$3);
ZVAL_UNDEF(&_17$$4);
ZVAL_UNDEF(&_18$$4);
ZVAL_UNDEF(&_19$$4);
ZVAL_UNDEF(&_22$$5);
ZVAL_UNDEF(&_23$$5);
ZVAL_UNDEF(&_24$$5);
ZVAL_UNDEF(&_27$$6);
ZVAL_UNDEF(&_29$$6);
ZVAL_UNDEF(&_30$$6);
ZVAL_UNDEF(&_31$$6);
ZVAL_UNDEF(&_32$$6);
ZVAL_UNDEF(&_33$$6);
ZVAL_UNDEF(&_34$$6);
ZVAL_UNDEF(&_35$$6);
ZVAL_UNDEF(&_36$$6);
ZVAL_UNDEF(&_37$$6);
ZVAL_UNDEF(&_38$$6);
ZVAL_UNDEF(&_28$$7);
ZVAL_UNDEF(&_39$$9);
ZVAL_UNDEF(&_40$$9);
ZVAL_UNDEF(&_41$$9);
ZVAL_UNDEF(&_43$$10);
ZVAL_UNDEF(&_44$$13);
ZVAL_UNDEF(&_45$$13);
ZVAL_UNDEF(&_46$$15);
ZVAL_UNDEF(&_47$$15);
ZVAL_UNDEF(&_48$$15);
ZVAL_UNDEF(&_52$$16);
ZVAL_UNDEF(&_53$$16);
ZVAL_UNDEF(&_54$$16);
ZVAL_UNDEF(&_61$$16);
ZVAL_UNDEF(&_55$$17);
ZVAL_UNDEF(&_56$$18);
ZVAL_UNDEF(&_58$$20);
ZVAL_UNDEF(&_59$$20);
ZVAL_UNDEF(&_60$$20);
ZVAL_UNDEF(&_62$$21);
ZVAL_UNDEF(&_63$$22);
ZVAL_UNDEF(&_65$$23);
ZVAL_UNDEF(&_66$$23);
ZVAL_UNDEF(&_67$$23);
ZEPHIR_MM_GROW();
zephir_get_global(&_FILES, SL("_FILES"));
zephir_get_global(&_POST, SL("_POST"));
zephir_get_global(&_SERVER, SL("_SERVER"));
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_1 = ZEPHIR_IS_STRING(&_0, "POST");
if (_1) {
_1 = ZEPHIR_IS_EMPTY(_POST);
}
_2 = _1;
if (_2) {
_2 = ZEPHIR_IS_EMPTY(_FILES);
}
_3 = _2;
if (_3) {
zephir_array_fetch_string(&_4, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(&_4, 0);
}
_5 = _3;
if (!(_5)) {
_6 = zephir_array_isset_string(&value, SL("error"));
if (_6) {
zephir_array_fetch_string(&_7, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC);
_6 = ZEPHIR_IS_LONG_IDENTICAL(&_7, 1);
}
_5 = _6;
}
if (_5) {
ZEPHIR_INIT_VAR(&_8$$3);
ZVAL_STRING(&_8$$3, "FileIniSize");
ZEPHIR_INIT_VAR(&_9$$3);
ZVAL_STRING(&_9$$3, "messageIniSize");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_8$$3, &_9$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_8$$3);
object_init_ex(&_8$$3, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_9$$3);
ZVAL_STRING(&_9$$3, "FileIniSize");
ZEPHIR_CALL_METHOD(NULL, &_8$$3, "__construct", NULL, 299, &_10$$3, field, &_9$$3, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_8$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_11 = !(zephir_array_isset_string(&value, SL("error")));
if (!(_11)) {
_11 = !(zephir_array_isset_string(&value, SL("tmp_name")));
}
_12 = _11;
if (!(_12)) {
zephir_array_fetch_string(&_13, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC);
_12 = !ZEPHIR_IS_LONG_IDENTICAL(&_13, 0);
}
_14 = _12;
if (!(_14)) {
zephir_array_fetch_string(&_15, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_16, "is_uploaded_file", NULL, 232, &_15);
zephir_check_call_status();
_14 = !zephir_is_true(&_16);
}
if (_14) {
ZEPHIR_INIT_VAR(&_17$$4);
ZVAL_STRING(&_17$$4, "FileEmpty");
ZEPHIR_INIT_VAR(&_18$$4);
ZVAL_STRING(&_18$$4, "messageEmpty");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_17$$4, &_18$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_17$$4);
object_init_ex(&_17$$4, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_19$$4, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_18$$4);
ZVAL_STRING(&_18$$4, "FileEmpty");
ZEPHIR_CALL_METHOD(NULL, &_17$$4, "__construct", NULL, 299, &_19$$4, field, &_18$$4, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_17$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_20 = !(zephir_array_isset_string(&value, SL("name")));
if (!(_20)) {
_20 = !(zephir_array_isset_string(&value, SL("type")));
}
_21 = _20;
if (!(_21)) {
_21 = !(zephir_array_isset_string(&value, SL("size")));
}
if (_21) {
ZEPHIR_INIT_VAR(&_22$$5);
ZVAL_STRING(&_22$$5, "FileValid");
ZEPHIR_INIT_VAR(&_23$$5);
ZVAL_STRING(&_23$$5, "messageValid");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_22$$5, &_23$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_22$$5);
object_init_ex(&_22$$5, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_24$$5, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_23$$5);
ZVAL_STRING(&_23$$5, "FileValid");
ZEPHIR_CALL_METHOD(NULL, &_22$$5, "__construct", NULL, 299, &_24$$5, field, &_23$$5, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_22$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(&_26);
ZVAL_STRING(&_26, "maxSize");
ZEPHIR_CALL_METHOD(&_25, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
if (zephir_is_true(&_25)) {
ZEPHIR_INIT_VAR(&byteUnits);
zephir_create_array(&byteUnits, 9, 0 TSRMLS_CC);
add_assoc_long_ex(&byteUnits, SL("B"), 0);
add_assoc_long_ex(&byteUnits, SL("K"), 10);
add_assoc_long_ex(&byteUnits, SL("M"), 20);
add_assoc_long_ex(&byteUnits, SL("G"), 30);
add_assoc_long_ex(&byteUnits, SL("T"), 40);
add_assoc_long_ex(&byteUnits, SL("KB"), 10);
add_assoc_long_ex(&byteUnits, SL("MB"), 20);
add_assoc_long_ex(&byteUnits, SL("GB"), 30);
add_assoc_long_ex(&byteUnits, SL("TB"), 40);
ZEPHIR_INIT_VAR(&_27$$6);
ZVAL_STRING(&_27$$6, "maxSize");
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, &_27$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&matches);
ZVAL_NULL(&matches);
ZEPHIR_INIT_VAR(&unit);
ZVAL_STRING(&unit, "B");
if (Z_TYPE_P(&maxSize) == IS_ARRAY) {
zephir_array_fetch(&_28$$7, &maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 159 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maxSize, &_28$$7);
}
ZEPHIR_INIT_NVAR(&_27$$6);
ZEPHIR_INIT_VAR(&_29$$6);
zephir_array_keys(&_29$$6, &byteUnits TSRMLS_CC);
zephir_fast_join_str(&_27$$6, SL("|"), &_29$$6 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_30$$6);
ZEPHIR_CONCAT_SVS(&_30$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", &_27$$6, ")?$/Di");
ZEPHIR_INIT_VAR(&_31$$6);
zephir_preg_match(&_31$$6, &_30$$6, &maxSize, &matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_array_isset_long(&matches, 2)) {
ZEPHIR_OBS_NVAR(&unit);
zephir_array_fetch_long(&unit, &matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 165 TSRMLS_CC);
}
zephir_array_fetch_long(&_32$$6, &matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 323, &_32$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_34$$6);
zephir_array_fetch(&_35$$6, &byteUnits, &unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
ZVAL_LONG(&_36$$6, 2);
zephir_pow_function(&_34$$6, &_36$$6, &_35$$6);
ZEPHIR_INIT_VAR(&bytes);
mul_function(&bytes, &_33$$6, &_34$$6 TSRMLS_CC);
zephir_array_fetch_string(&_37$$6, &value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 170 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 323, &_37$$6);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_38$$6, "floatval", NULL, 323, &bytes);
zephir_check_call_status();
if (ZEPHIR_GT(&_33$$6, &_38$$6)) {
ZEPHIR_INIT_VAR(&_39$$9);
ZVAL_STRING(&_39$$9, "FileSize");
ZEPHIR_INIT_VAR(&_40$$9);
ZVAL_STRING(&_40$$9, "messageSize");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_39$$9, &_40$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxSize, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_39$$9);
object_init_ex(&_39$$9, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_41$$9, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_40$$9);
ZVAL_STRING(&_40$$9, "FileSize");
ZEPHIR_CALL_METHOD(NULL, &_39$$9, "__construct", NULL, 299, &_41$$9, field, &_40$$9, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_39$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "allowedTypes");
ZEPHIR_CALL_METHOD(&_42, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
if (zephir_is_true(&_42)) {
ZEPHIR_INIT_VAR(&_43$$10);
ZVAL_STRING(&_43$$10, "allowedTypes");
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, &_43$$10);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&fieldTypes);
if (zephir_array_isset_fetch(&fieldTypes, &types, field, 0 TSRMLS_CC)) {
ZEPHIR_CPY_WRT(&types, &fieldTypes);
}
if (Z_TYPE_P(&types) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 196);
return;
}
if ((zephir_function_exists_ex(SL("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZVAL_LONG(&_44$$13, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 229, &_44$$13);
zephir_check_call_status();
zephir_array_fetch_string(&_45$$13, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 201 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 230, &tmp, &_45$$13);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 231, &tmp);
zephir_check_call_status();
} else {
ZEPHIR_OBS_NVAR(&mime);
zephir_array_fetch_string(&mime, &value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 205 TSRMLS_CC);
}
if (!(zephir_fast_in_array(&mime, &types TSRMLS_CC))) {
ZEPHIR_INIT_VAR(&_46$$15);
ZVAL_STRING(&_46$$15, "FileType");
ZEPHIR_INIT_VAR(&_47$$15);
ZVAL_STRING(&_47$$15, "messageType");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_46$$15, &_47$$15);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_46$$15);
zephir_fast_join_str(&_46$$15, SL(", "), &types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_46$$15, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_46$$15);
object_init_ex(&_46$$15, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_48$$15, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_47$$15);
ZVAL_STRING(&_47$$15, "FileType");
ZEPHIR_CALL_METHOD(NULL, &_46$$15, "__construct", NULL, 299, &_48$$15, field, &_47$$15, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_46$$15);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "minResolution");
ZEPHIR_CALL_METHOD(&_49, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
_50 = zephir_is_true(&_49);
if (!(_50)) {
ZEPHIR_INIT_NVAR(&_26);
ZVAL_STRING(&_26, "maxResolution");
ZEPHIR_CALL_METHOD(&_51, this_ptr, "hasoption", NULL, 0, &_26);
zephir_check_call_status();
_50 = zephir_is_true(&_51);
}
if (_50) {
zephir_array_fetch_string(&_52$$16, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 226 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 241, &_52$$16);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&width);
zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 227 TSRMLS_CC);
ZEPHIR_OBS_VAR(&height);
zephir_array_fetch_long(&height, &tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_VAR(&_54$$16);
ZVAL_STRING(&_54$$16, "minResolution");
ZEPHIR_CALL_METHOD(&_53$$16, this_ptr, "hasoption", NULL, 0, &_54$$16);
zephir_check_call_status();
if (zephir_is_true(&_53$$16)) {
ZEPHIR_INIT_VAR(&_55$$17);
ZVAL_STRING(&_55$$17, "minResolution");
ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, &_55$$17);
zephir_check_call_status();
if (Z_TYPE_P(&minResolution) == IS_ARRAY) {
zephir_array_fetch(&_56$$18, &minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 233 TSRMLS_CC);
ZEPHIR_CPY_WRT(&minResolution, &_56$$18);
}
ZEPHIR_INIT_VAR(&minResolutionArray);
zephir_fast_explode_str(&minResolutionArray, SL("x"), &minResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(&minWidth);
zephir_array_fetch_long(&minWidth, &minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 236 TSRMLS_CC);
ZEPHIR_OBS_VAR(&minHeight);
zephir_array_fetch_long(&minHeight, &minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 237 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(&minWidth);
ZVAL_LONG(&minWidth, 1);
ZEPHIR_INIT_NVAR(&minHeight);
ZVAL_LONG(&minHeight, 1);
}
_57$$16 = ZEPHIR_LT(&width, &minWidth);
if (!(_57$$16)) {
_57$$16 = ZEPHIR_LT(&height, &minHeight);
}
if (_57$$16) {
ZEPHIR_INIT_VAR(&_58$$20);
ZVAL_STRING(&_58$$20, "FileMinResolution");
ZEPHIR_INIT_VAR(&_59$$20);
ZVAL_STRING(&_59$$20, "messageMinResolution");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_58$$20, &_59$$20);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_58$$20);
object_init_ex(&_58$$20, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_60$$20, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_59$$20);
ZVAL_STRING(&_59$$20, "FileMinResolution");
ZEPHIR_CALL_METHOD(NULL, &_58$$20, "__construct", NULL, 299, &_60$$20, field, &_59$$20, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_58$$20);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(&_54$$16);
ZVAL_STRING(&_54$$16, "maxResolution");
ZEPHIR_CALL_METHOD(&_61$$16, this_ptr, "hasoption", NULL, 0, &_54$$16);
zephir_check_call_status();
if (zephir_is_true(&_61$$16)) {
ZEPHIR_INIT_VAR(&_62$$21);
ZVAL_STRING(&_62$$21, "maxResolution");
ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, &_62$$21);
zephir_check_call_status();
if (Z_TYPE_P(&maxResolution) == IS_ARRAY) {
zephir_array_fetch(&_63$$22, &maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 263 TSRMLS_CC);
ZEPHIR_CPY_WRT(&maxResolution, &_63$$22);
}
ZEPHIR_INIT_VAR(&maxResolutionArray);
zephir_fast_explode_str(&maxResolutionArray, SL("x"), &maxResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(&maxWidth);
zephir_array_fetch_long(&maxWidth, &maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 266 TSRMLS_CC);
ZEPHIR_OBS_VAR(&maxHeight);
zephir_array_fetch_long(&maxHeight, &maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 267 TSRMLS_CC);
_64$$21 = ZEPHIR_GT(&width, &maxWidth);
if (!(_64$$21)) {
_64$$21 = ZEPHIR_GT(&height, &maxHeight);
}
if (_64$$21) {
ZEPHIR_INIT_VAR(&_65$$23);
ZVAL_STRING(&_65$$23, "FileMaxResolution");
ZEPHIR_INIT_VAR(&_66$$23);
ZVAL_STRING(&_66$$23, "messageMaxResolution");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_65$$23, &_66$$23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&replacePairs);
zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_65$$23);
object_init_ex(&_65$$23, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_67$$23, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_66$$23);
ZVAL_STRING(&_66$$23, "FileMaxResolution");
ZEPHIR_CALL_METHOD(NULL, &_65$$23, "__construct", NULL, 299, &_67$$23, field, &_66$$23, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_65$$23);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Handle the whole command-line tasks
*/
PHP_METHOD(Phalcon_Cli_Console, handle) {
zend_bool _5;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *arguments_param = NULL, __$false, dependencyInjector, router, eventsManager, moduleName, modules, module, path, className, moduleObject, dispatcher, task, _0, _3, _4, _15, _16, _17, _18, _1$$4, _2$$4, _6$$6, _7$$10, _8$$10, _9$$12, _10$$12, _11$$17, _12$$17, _13$$18, _14$$18, _19$$20, _20$$20, _21$$22;
zval arguments;
zval *this_ptr = getThis();
ZVAL_UNDEF(&arguments);
ZVAL_BOOL(&__$false, 0);
ZVAL_UNDEF(&dependencyInjector);
ZVAL_UNDEF(&router);
ZVAL_UNDEF(&eventsManager);
ZVAL_UNDEF(&moduleName);
ZVAL_UNDEF(&modules);
ZVAL_UNDEF(&module);
ZVAL_UNDEF(&path);
ZVAL_UNDEF(&className);
ZVAL_UNDEF(&moduleObject);
ZVAL_UNDEF(&dispatcher);
ZVAL_UNDEF(&task);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_15);
ZVAL_UNDEF(&_16);
ZVAL_UNDEF(&_17);
ZVAL_UNDEF(&_18);
ZVAL_UNDEF(&_1$$4);
ZVAL_UNDEF(&_2$$4);
ZVAL_UNDEF(&_6$$6);
ZVAL_UNDEF(&_7$$10);
ZVAL_UNDEF(&_8$$10);
ZVAL_UNDEF(&_9$$12);
ZVAL_UNDEF(&_10$$12);
ZVAL_UNDEF(&_11$$17);
ZVAL_UNDEF(&_12$$17);
ZVAL_UNDEF(&_13$$18);
ZVAL_UNDEF(&_14$$18);
ZVAL_UNDEF(&_19$$20);
ZVAL_UNDEF(&_20$$20);
ZVAL_UNDEF(&_21$$22);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments_param);
if (!arguments_param) {
ZEPHIR_INIT_VAR(&arguments);
array_init(&arguments);
} else {
zephir_get_arrval(&arguments, arguments_param);
}
ZEPHIR_OBS_VAR(&dependencyInjector);
zephir_read_property(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(&dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "A dependency injection object is required to access internal services", "phalcon/cli/console.zep", 42);
return;
}
zephir_read_property(&_0, this_ptr, SL("_eventsManager"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CPY_WRT(&eventsManager, &_0);
if (Z_TYPE_P(&eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(&_2$$4);
ZVAL_STRING(&_2$$4, "console:boot");
ZEPHIR_CALL_METHOD(&_1$$4, &eventsManager, "fire", NULL, 0, &_2$$4, this_ptr);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(&_1$$4)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_VAR(&_4);
ZVAL_STRING(&_4, "router");
ZEPHIR_CALL_METHOD(&_3, &dependencyInjector, "getshared", NULL, 0, &_4);
zephir_check_call_status();
ZEPHIR_CPY_WRT(&router, &_3);
_5 = !(zephir_fast_count_int(&arguments TSRMLS_CC));
if (_5) {
zephir_read_property(&_0, this_ptr, SL("_arguments"), PH_NOISY_CC | PH_READONLY);
_5 = zephir_is_true(&_0);
}
if (_5) {
zephir_read_property(&_6$$6, this_ptr, SL("_arguments"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(NULL, &router, "handle", NULL, 0, &_6$$6);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, &router, "handle", NULL, 0, &arguments);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&moduleName, &router, "getmodulename", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(&moduleName))) {
ZEPHIR_OBS_NVAR(&moduleName);
zephir_read_property(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
}
if (zephir_is_true(&moduleName)) {
if (Z_TYPE_P(&eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(&_8$$10);
ZVAL_STRING(&_8$$10, "console:beforeStartModule");
ZEPHIR_CALL_METHOD(&_7$$10, &eventsManager, "fire", NULL, 0, &_8$$10, this_ptr, &moduleName);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(&_7$$10)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_OBS_VAR(&modules);
zephir_read_property(&modules, this_ptr, SL("_modules"), PH_NOISY_CC);
if (!(zephir_array_isset(&modules, &moduleName))) {
ZEPHIR_INIT_VAR(&_9$$12);
object_init_ex(&_9$$12, phalcon_cli_console_exception_ce);
ZEPHIR_INIT_VAR(&_10$$12);
ZEPHIR_CONCAT_SVS(&_10$$12, "Module '", &moduleName, "' isn't registered in the console container");
ZEPHIR_CALL_METHOD(NULL, &_9$$12, "__construct", NULL, 4, &_10$$12);
zephir_check_call_status();
zephir_throw_exception_debug(&_9$$12, "phalcon/cli/console.zep", 82 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(&module);
zephir_array_fetch(&module, &modules, &moduleName, PH_NOISY, "phalcon/cli/console.zep", 85 TSRMLS_CC);
if (Z_TYPE_P(&module) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "Invalid module definition path", "phalcon/cli/console.zep", 87);
return;
}
ZEPHIR_OBS_VAR(&className);
if (!(zephir_array_isset_string_fetch(&className, &module, SL("className"), 0))) {
ZEPHIR_INIT_NVAR(&className);
ZVAL_STRING(&className, "Module");
}
ZEPHIR_OBS_VAR(&path);
if (zephir_array_isset_string_fetch(&path, &module, SL("path"), 0)) {
if (!(zephir_class_exists(&className, zephir_is_true(&__$false) TSRMLS_CC))) {
if (!((zephir_file_exists(&path TSRMLS_CC) == SUCCESS))) {
ZEPHIR_INIT_VAR(&_11$$17);
object_init_ex(&_11$$17, phalcon_cli_console_exception_ce);
ZEPHIR_INIT_VAR(&_12$$17);
ZEPHIR_CONCAT_SVS(&_12$$17, "Module definition path '", &path, "' doesn't exist");
ZEPHIR_CALL_METHOD(NULL, &_11$$17, "__construct", NULL, 4, &_12$$17);
zephir_check_call_status();
zephir_throw_exception_debug(&_11$$17, "phalcon/cli/console.zep", 97 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (zephir_require_zval(&path TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
}
}
ZEPHIR_CALL_METHOD(&moduleObject, &dependencyInjector, "get", NULL, 0, &className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, &moduleObject, "registerautoloaders", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, &moduleObject, "registerservices", NULL, 0, &dependencyInjector);
zephir_check_call_status();
if (Z_TYPE_P(&eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(&_14$$18);
ZVAL_STRING(&_14$$18, "console:afterStartModule");
ZEPHIR_CALL_METHOD(&_13$$18, &eventsManager, "fire", NULL, 0, &_14$$18, this_ptr, &moduleObject);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(&_13$$18)) {
RETURN_MM_BOOL(0);
}
}
}
ZEPHIR_INIT_NVAR(&_4);
ZVAL_STRING(&_4, "dispatcher");
ZEPHIR_CALL_METHOD(&_3, &dependencyInjector, "getshared", NULL, 0, &_4);
zephir_check_call_status();
ZEPHIR_CPY_WRT(&dispatcher, &_3);
ZEPHIR_CALL_METHOD(&_3, &router, "getmodulename", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, &dispatcher, "setmodulename", NULL, 0, &_3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_15, &router, "gettaskname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, &dispatcher, "settaskname", NULL, 0, &_15);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_16, &router, "getactionname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, &dispatcher, "setactionname", NULL, 0, &_16);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_17, &router, "getparams", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, &dispatcher, "setparams", NULL, 0, &_17);
zephir_check_call_status();
zephir_read_property(&_18, this_ptr, SL("_options"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(NULL, &dispatcher, "setoptions", NULL, 0, &_18);
zephir_check_call_status();
if (Z_TYPE_P(&eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(&_20$$20);
ZVAL_STRING(&_20$$20, "console:beforeHandleTask");
ZEPHIR_CALL_METHOD(&_19$$20, &eventsManager, "fire", NULL, 0, &_20$$20, this_ptr, &dispatcher);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(&_19$$20)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_CALL_METHOD(&task, &dispatcher, "dispatch", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(&eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(&_21$$22);
ZVAL_STRING(&_21$$22, "console:afterHandleTask");
ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_21$$22, this_ptr, &task);
zephir_check_call_status();
}
RETURN_CCTOR(&task);
}
/**
* Do an internal require to a plain php file taking care of the value returned by the file
*/
int zephir_require_ret(zval *return_value_ptr, const char *require_path)
{
zend_file_handle file_handle;
int ret, use_ret;
zend_op_array *new_op_array;
zval dummy, local_retval;
ZVAL_UNDEF(&local_retval);
#ifndef ZEPHIR_RELEASE
if (return_value_ptr != NULL && Z_TYPE_P(return_value_ptr) > IS_NULL) {
fprintf(stderr, "%s: *return_value_ptr is expected to be NULL", __func__);
zephir_print_backtrace();
abort();
}
#endif
if (!require_path) {
/* @TODO, throw an exception here */
return FAILURE;
}
use_ret = !!return_value_ptr;
file_handle.filename = require_path;
file_handle.free_filename = 0;
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.opened_path = NULL;
file_handle.handle.fp = NULL;
new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE);
if (new_op_array) {
if (file_handle.handle.stream.handle) {
ZVAL_NULL(&dummy);
if (!file_handle.opened_path) {
file_handle.opened_path = zend_string_init(require_path, strlen(require_path), 0);
}
zend_hash_add(&EG(included_files), file_handle.opened_path, &dummy);
zend_destroy_file_handle(&file_handle);
}
zend_execute(new_op_array, &local_retval);
if (return_value_ptr) {
zval_ptr_dtor(return_value_ptr);
ZVAL_COPY_VALUE(return_value_ptr, &local_retval);
} else {
zval_ptr_dtor(&local_retval);
}
destroy_op_array(new_op_array);
efree_size(new_op_array, sizeof(zend_op_array));
if (EG(exception)) {
ret = FAILURE;
}
else {
ret = SUCCESS;
}
return ret;
}
else {
zend_destroy_file_handle(&file_handle);
}
return FAILURE;
}
void __function_invoke(zend_fcall_info_cache fcc, zval *obj, zval *return_value, zend_bool dtor TSRMLS_DC, const char *params_format, ...) {
#if PHP_MAJOR_VERSION < 7
zval *retval_ptr = NULL;
zval ***params = NULL;
#else
zval retval;
zval *params = NULL;
#endif
int i;
int result;
int argc;
zend_fcall_info fci;
argc = strlen(params_format);
if (argc) {
#if PHP_MAJOR_VERSION < 7
params = safe_emalloc(sizeof(zval **), argc, 0);
va_list ap;
va_start(ap, params_format);
for (i = 0; i < argc; ++i) {
params[i] = emalloc(sizeof(zval *));
switch (params_format[i]) {
case 's': {
char *str = va_arg(ap, char *);
long len = va_arg(ap, long);
MAKE_STD_ZVAL(*params[i]);
ZVAL_STRINGL(*params[i], str, len, 0);
break;
}
case 'l': {
long l = va_arg(ap, long);
MAKE_STD_ZVAL(*params[i]);
ZVAL_LONG(*params[i], l);
break;
}
case 'd': {
double d = va_arg(ap, double);
MAKE_STD_ZVAL(*params[i]);
ZVAL_DOUBLE(*params[i], d);
break;
}
case 'n': {
MAKE_STD_ZVAL(*params[i]);
ZVAL_NULL(*params[i]);
break;
}
case 'b': {
zend_bool b = va_arg(ap, int);
MAKE_STD_ZVAL(*params[i]);
ZVAL_BOOL(*params[i], b);
break;
}
case 'z': {
zval *v = va_arg(ap, zval *);
if (v) {
Z_ADDREF_P(v);
*params[i] = v;
}
else {
MAKE_STD_ZVAL(*params[i]);
ZVAL_NULL(*params[i]);
}
break;
}
default:
zend_throw_exception_ex(
NULL, 0 TSRMLS_CC,
"Unsupported type:%c in function_invoke",
params_format[i]);
return;
}
}
va_end(ap);
#else
params = safe_emalloc(sizeof(zval), argc, 0);
va_list ap;
va_start(ap, params_format);
for (i = 0; i < argc; ++i) {
switch (params_format[i]) {
case 's': {
char *str = va_arg(ap, char *);
long len = va_arg(ap, long);
ZVAL_STRINGL(¶ms[i], str, len);
break;
}
case 'l': {
long l = va_arg(ap, long);
ZVAL_LONG(¶ms[i], l);
break;
}
case 'd': {
double d = va_arg(ap, double);
ZVAL_DOUBLE(¶ms[i], d);
break;
}
case 'n': {
ZVAL_NULL(¶ms[i]);
break;
}
case 'b': {
zend_bool b = va_arg(ap, int);
ZVAL_BOOL(¶ms[i], b);
break;
}
case 'z': {
zval *v = va_arg(ap, zval *);
if (v) {
ZVAL_COPY(¶ms[i], v);
}
else {
ZVAL_NULL(¶ms[i]);
}
break;
}
default:
zend_throw_exception_ex(
NULL, 0,
"Unsupported type:%c in function_invoke",
params_format[i]);
return;
}
}
va_end(ap);
#endif
}
fci.size = sizeof(fci);
fci.function_table = NULL;
#if PHP_MAJOR_VERSION < 7
fci.function_name = NULL;
fci.retval_ptr_ptr = &retval_ptr;
#else
ZVAL_UNDEF(&fci.function_name);
fci.retval = &retval;
#endif
fci.symbol_table = NULL;
fci.param_count = argc;
fci.params = params;
fci.no_separation = 1;
if (obj != NULL && Z_TYPE_P(obj) == IS_OBJECT) {
#if PHP_API_VERSION < 20090626
fci.object_pp = &obj;
fcc.object_pp = &obj;
#elif PHP_MAJOR_VERSION < 7
fci.object_ptr = obj;
fcc.object_ptr = obj;
#else
fci.object = Z_OBJ_P(obj);
fcc.object = Z_OBJ_P(obj);
#endif
fcc.calling_scope = Z_OBJCE_P(obj);
}
else {
#if PHP_API_VERSION < 20090626
fci.object_pp = fcc.object_pp;
#elif PHP_MAJOR_VERSION < 7
fci.object_ptr = fcc.object_ptr;
#else
fci.object = fcc.object;
#endif
}
#if PHP_MAJOR_VERSION < 7
result = zend_call_function(&fci, &fcc TSRMLS_CC);
for (i = 0; i < argc; i++) {
if (params_format[i] == 's') {
ZVAL_EMPTY_STRING(*params[i]);
}
zval_ptr_dtor(params[i]);
efree(params[i]);
}
if (argc) {
efree(params);
}
if (result == FAILURE) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC,
"Invocation of function %s() failed",
fcc.function_handler->common.function_name);
return;
}
if (retval_ptr) {
if (return_value) {
if (return_value != retval_ptr) {
if (dtor) {
zval_dtor(return_value);
}
COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
}
else {
if (dtor) {
zval_ptr_dtor(&retval_ptr);
}
}
}
else {
zval_ptr_dtor(&retval_ptr);
}
}
#else
result = zend_call_function(&fci, &fcc);
for (i = 0; i < argc; i++) {
zval_ptr_dtor(¶ms[i]);
}
if (argc) {
efree(params);
}
if (result == FAILURE) {
zend_throw_exception_ex(NULL, 0,
"Invocation of function %s() failed",
fcc.function_handler->common.function_name->val);
return;
}
if (Z_TYPE(retval) != IS_UNDEF) {
if (return_value) {
if (dtor) {
zval_ptr_dtor(return_value);
}
ZVAL_COPY_VALUE(return_value, &retval);
}
else {
zval_ptr_dtor(&retval);
}
}
#endif
}
