/* {{{ 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)); } } }