/* {{{ zend_implement_serializable */
static int zend_implement_serializable(zend_class_entry *interface, zend_class_entry *class_type)
{
if (class_type->parent
&& (class_type->parent->serialize || class_type->parent->unserialize)
&& !instanceof_function_ex(class_type->parent, zend_ce_serializable, 1)) {
return FAILURE;
}
if (!class_type->serialize) {
class_type->serialize = zend_user_serialize;
}
if (!class_type->unserialize) {
class_type->unserialize = zend_user_unserialize;
}
return SUCCESS;
}
/* {{{ proto string ProtocolBuffersEnum::getName(long $value)
*/
PHP_METHOD(protocolbuffers_enum, getName)
{
#if (PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION < 3)
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "ProtocolBuffersEnum::getName can't work under PHP 5.3. please consider upgrading your PHP");
return;
#else
long value;
zval *result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"l", &value) == FAILURE) {
return;
}
if (zend_call_method_with_0_params(NULL, EG(called_scope), NULL, "getenumdescriptor", &result)) {
zval *values, **entry;
HashPosition pos;
if (!instanceof_function_ex(Z_OBJCE_P(result), php_protocol_buffers_enum_descriptor_class_entry, 0 TSRMLS_CC)) {
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "ProtocolBuffersEnum::getEnumDescriptor returns unexpected value.");
zval_ptr_dtor(&result);
return;
}
php_protocolbuffers_read_protected_property(result, ZEND_STRS("values"), &values TSRMLS_CC);
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(values), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(values), (void **)&entry, &pos) == SUCCESS) {
if (Z_LVAL_PP(entry) == value) {
char *key;
uint key_len;
ulong index;
zend_hash_get_current_key_ex(Z_ARRVAL_P(values), &key, &key_len, &index, 0, &pos);
RETURN_STRINGL(key, key_len, 1);
break;
}
zend_hash_move_forward_ex(Z_ARRVAL_P(values), &pos);
}
zval_ptr_dtor(&result);
RETVAL_FALSE;
} else {
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "cannot call ProtocolBuffersEnum::getEnumDescriptor.");
return;
}
#endif
}
/**
* Handles user-defined error
*
* @param int $severity
* @param string $message
* @param string $file
* @param string $line
* @param array $context
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onUserDefinedError){
zval *severity, *message, *file = NULL, *line = NULL, *context = NULL, *e, *previous = NULL, *exception;
zend_class_entry *default_exception_ce;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 3, &severity, &message, &file, &line, &context);
if (!file) {
file = PHALCON_GLOBAL(z_null);
}
if (!line) {
line = PHALCON_GLOBAL(z_null);
}
if (context && Z_TYPE_P(context) == IS_ARRAY) {
if (
phalcon_array_isset_string_fetch(&e, context, SS("e")) &&
Z_TYPE_P(e) == IS_OBJECT &&
instanceof_function_ex(Z_OBJCE_P(e), zend_exception_get_default(TSRMLS_C), 1 TSRMLS_CC)
) {
PHALCON_CPY_WRT(previous, e);
} else {
previous = PHALCON_GLOBAL(z_null);
}
} else {
previous = PHALCON_GLOBAL(z_null);
}
default_exception_ce = zend_get_error_exception(TSRMLS_C);
ALLOC_INIT_ZVAL(exception);
object_init_ex(exception, default_exception_ce);
PHALCON_CALL_METHOD(NULL, exception, "__construct", message, PHALCON_GLOBAL(z_zero), severity, file, line, previous);
zend_throw_exception_object(exception TSRMLS_CC);
RETURN_MM_TRUE;
}
/**
* Resolves the service based on its configuration
*
* @param string $name
* @param array $parameters
* @return mixed
*/
PHP_METHOD(Phalcon_DI, get){
zval *name, *parameters = NULL, *noerror = NULL, events_manager = {}, event_name = {}, event_data = {}, service = {};
zend_class_entry *ce;
phalcon_fetch_params(0, 1, 2, &name, ¶meters, &noerror);
PHALCON_ENSURE_IS_STRING(name);
if (!parameters) {
parameters = &PHALCON_GLOBAL(z_null);
}
if (!noerror) {
noerror = &PHALCON_GLOBAL(z_false);
}
phalcon_return_property(&events_manager, getThis(), SL("_eventsManager"));
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "di:beforeServiceResolve");
array_init(&event_data);
phalcon_array_update_str(&event_data, SL("name"), name, PH_COPY);
phalcon_array_update_str(&event_data, SL("parameters"), parameters, PH_COPY);
PHALCON_CALL_METHODW(NULL, &events_manager, "fire", &event_name, getThis(), &event_data);
}
if (phalcon_property_array_isset_fetch(&service, getThis(), SL("_services"), name)) {
PHALCON_CALL_METHODW(return_value, &service, "resolve", parameters, getThis());
ce = (Z_TYPE_P(return_value) == IS_OBJECT) ? Z_OBJCE_P(return_value) : NULL;
} else {
/* The DI also acts as builder for any class even if it isn't defined in the DI */
if ((ce = phalcon_class_exists_ex(name, 1)) != NULL) {
if (FAILURE == phalcon_create_instance_params_ce(return_value, ce, parameters)) {
return;
}
} else {
if(!zend_is_true(noerror)) {
zend_throw_exception_ex(phalcon_di_exception_ce, 0, "Service '%s' was not found in the dependency injection container", Z_STRVAL_P(name));
}
RETURN_NULL();
}
}
/* Pass the DI itself if the instance implements Phalcon\DI\InjectionAwareInterface */
if (ce && instanceof_function_ex(ce, phalcon_di_injectionawareinterface_ce, 1)) {
PHALCON_CALL_METHODW(NULL, return_value, "setdi", getThis());
}
if (Z_TYPE(events_manager) == IS_OBJECT) {
ZVAL_STRING(&event_name, "di:afterServiceResolve");
array_init(&event_data);
phalcon_array_update_str(&event_data, SL("name"), name, PH_COPY);
phalcon_array_update_str(&event_data, SL("parameters"), parameters, PH_COPY);
phalcon_array_update_str(&event_data, SL("instance"), return_value, PH_COPY);
PHALCON_CALL_METHODW(NULL, &events_manager, "fire", &event_name, getThis(), &event_data);
}
}
/**
* Executes the validation
*
* @param string $file
* @param int $minsize
* @param int $maxsize
* @param array $mimes
* @param int $minwidth
* @param int $maxwidth
* @param int $minheight
* @param int $maxheight
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_File, valid)
{
zval *value, *minsize = NULL, *maxsize = NULL, *mimes = NULL, *minwidth = NULL, *maxwidth = NULL, *minheight = NULL, *maxheight = NULL;
zval file = {}, size = {}, *constant, finfo = {}, pathname = {}, mime = {}, image = {}, imageinfo = {}, width = {}, height = {}, valid = {};
zend_class_entry *imagick_ce;
phalcon_fetch_params(0, 1, 7, &value, &minsize, &maxsize, &mimes, &minwidth, &maxwidth, &minheight, &maxheight);
if (Z_TYPE_P(value) == IS_STRING) {
object_init_ex(&file, spl_ce_SplFileInfo);
if (phalcon_has_constructor(&file)) {
PHALCON_CALL_METHODW(NULL, &file, "__construct", value);
}
} else if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function_ex(Z_OBJCE_P(value), spl_ce_SplFileInfo, 0)) {
PHALCON_CPY_WRT(&file, value);
}
if (Z_TYPE(file) <= IS_NULL) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TypeUnknow"));
RETURN_FALSE;
}
if (!minsize) {
minsize = &PHALCON_GLOBAL(z_null);
}
if (!maxsize) {
maxsize = &PHALCON_GLOBAL(z_null);
}
if (!mimes) {
mimes = &PHALCON_GLOBAL(z_null);
}
if (!minwidth) {
minwidth = &PHALCON_GLOBAL(z_null);
}
if (!maxwidth) {
maxwidth = &PHALCON_GLOBAL(z_null);
}
if (!minheight) {
minheight = &PHALCON_GLOBAL(z_null);
}
if (!maxheight) {
maxheight = &PHALCON_GLOBAL(z_null);
}
PHALCON_CALL_METHODW(&valid, &file, "isfile");
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("FileValid"));
RETURN_FALSE;
}
PHALCON_CALL_METHODW(&size, &file, "getsize");
if (!PHALCON_IS_EMPTY(minsize)) {
is_smaller_or_equal_function(&valid, minsize, &size);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooSmall"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(maxsize)) {
is_smaller_or_equal_function(&valid, &size, maxsize);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooLarge"));
RETURN_FALSE;
}
}
PHALCON_CALL_METHODW(&pathname, &file, "getpathname");
if (Z_TYPE_P(mimes) == IS_ARRAY) {
if ((constant = zend_get_constant_str(SL("FILEINFO_MIME_TYPE"))) == NULL) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_validation_exception_ce, "Undefined constant `FILEINFO_MIME_TYPE`");
return;
}
PHALCON_CALL_FUNCTIONW(&finfo, "finfo_open", constant);
if (Z_TYPE(finfo) != IS_RESOURCE) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_validation_exception_ce, "Opening fileinfo database failed");
return;
}
PHALCON_CALL_FUNCTIONW(&mime, "finfo_file", &finfo, &pathname);
PHALCON_CALL_FUNCTIONW(NULL, "finfo_close", &finfo);
if (!phalcon_fast_in_array(&mime, mimes)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("MimeValid"));
RETURN_FALSE;
}
}
if (phalcon_class_str_exists(SL("imagick"), 0) != NULL) {
imagick_ce = phalcon_fetch_str_class(SL("Imagick"), ZEND_FETCH_CLASS_AUTO);
object_init_ex(&image, imagick_ce);
PHALCON_CALL_METHODW(NULL, &image, "__construct", &pathname);
PHALCON_CALL_METHODW(&width, &image, "getImageWidth");
PHALCON_CALL_METHODW(&height, &image, "getImageHeight");
} else if (phalcon_function_exists_ex(SL("getimagesize")) != FAILURE) {
PHALCON_CALL_FUNCTIONW(&imageinfo, "getimagesize", &pathname);
if (!phalcon_array_isset_fetch_long(&width, &imageinfo, 0)) {
ZVAL_LONG(&width, -1);
}
if (!phalcon_array_isset_fetch_long(&height, &imageinfo, 1)) {
ZVAL_LONG(&height, -1);
}
} else {
ZVAL_LONG(&width, -1);
ZVAL_LONG(&height, -1);
}
if (!PHALCON_IS_EMPTY(minwidth)) {
is_smaller_or_equal_function(&valid, minwidth, &width);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooNarrow"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(maxwidth)) {
is_smaller_or_equal_function(&valid, &width, maxwidth);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooWide"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(minheight)) {
is_smaller_or_equal_function(&valid, minheight, &height);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooShort"));
RETURN_FALSE;
}
}
if (!PHALCON_IS_EMPTY(maxheight)) {
is_smaller_or_equal_function(&valid, &height, maxheight);
if (!zend_is_true(&valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooLong"));
RETURN_FALSE;
}
}
RETURN_TRUE;
}
/**
* Resolves the service
*
* @param array $parameters
* @param Phalcon\DIInterface $dependencyInjector
* @return object
*/
PHP_METHOD(Phalcon_DI_Service, resolve){
zval *parameters = NULL, *dependency_injector = NULL, name = {}, shared = {}, shared_instance = {}, definition = {}, builder = {};
int found = 0, ishared = 0;
phalcon_fetch_params(0, 0, 2, ¶meters, &dependency_injector);
if (!parameters) {
parameters = &PHALCON_GLOBAL(z_null);
}
if (!dependency_injector) {
dependency_injector = &PHALCON_GLOBAL(z_null);
}
phalcon_return_property(&shared, getThis(), SL("_shared"));
phalcon_return_property(&shared_instance, getThis(), SL("_sharedInstance"));
ishared = zend_is_true(&shared);
/* Check if the service is shared */
if (ishared && Z_TYPE(shared_instance) != IS_NULL) {
RETURN_CTORW(&shared_instance);
}
phalcon_return_property(&definition, getThis(), SL("_definition"));
if (Z_TYPE(definition) == IS_STRING) {
/* String definitions can be class names without implicit parameters */
if (phalcon_class_exists(&definition, 1) != NULL) {
found = 1;
if (Z_TYPE_P(parameters) == IS_ARRAY) {
RETURN_ON_FAILURE(phalcon_create_instance_params(return_value, &definition, parameters));
} else {
RETURN_ON_FAILURE(phalcon_create_instance(return_value, &definition));
}
}
} else if (likely(Z_TYPE(definition) == IS_OBJECT)) {
/* Object definitions can be a Closure or an already resolved instance */
found = 1;
if (instanceof_function_ex(Z_OBJCE(definition), zend_ce_closure, 0)) {
if (likely(Z_TYPE_P(dependency_injector) == IS_OBJECT)) {
PHALCON_CALL_CE_STATICW(&definition, zend_ce_closure, "bind", &definition, dependency_injector);
}
if (Z_TYPE_P(parameters) == IS_ARRAY) {
PHALCON_CALL_USER_FUNC_ARRAYW(return_value, &definition, parameters);
} else {
PHALCON_CALL_USER_FUNCW(return_value, &definition);
}
} else {
PHALCON_CPY_WRT(return_value, &definition);
}
} else if (Z_TYPE(definition) == IS_ARRAY) {
found = 1;
/* Array definitions require a 'className' parameter */
object_init_ex(&builder, phalcon_di_service_builder_ce);
PHALCON_CALL_METHODW(return_value, &builder, "build", dependency_injector, &definition, parameters);
}
if (!EG(exception)) {
if (found) {
if (ishared) {
phalcon_update_property_zval(getThis(), SL("_sharedInstance"), return_value);
}
/* Update the shared instance if the service is shared */
phalcon_update_property_bool(getThis(), SL("_resolved"), 1);
} else {
phalcon_return_property(&name, getThis(), SL("_name"));
PHALCON_THROW_EXCEPTION_FORMATW(phalcon_di_exception_ce, "Service '%s' cannot be resolved", Z_STRVAL(name));
}
}
}
