MARIJuANA
— DIOS — NO — CREA — NADA — EN — VANO —
Linux instance-20230208-1745 6.8.0-1013-oracle #13~22.04.1-Ubuntu SMP Mon Sep 2 13:02:56 UTC 2024 x86_64
  SOFT : Apache/2.4.52 (Ubuntu) PHP : 8.1.2-1ubuntu2.19
/var/www/guajeru/transparencia/assets/ckfinder/core/connector/php/vendor/pimple/pimple/ext/pimple/
10.0.0.135

 
[ NAME ] [ SIZE ] [ PERM ] [ DATE ] [ ACT ]
+FILE +DIR
  README.md 0.162 KB -rw-r--r-- 2021-07-19 12:55 R E G D
  config.m4 2.039 KB -rw-r--r-- 2021-07-19 12:55 R E G D
  config.w32 0.289 KB -rw-r--r-- 2021-07-19 12:56 R E G D
  php_pimple.h 6.298 KB -rw-r--r-- 2021-07-19 12:56 R E G D
  pimple.c 37.916 KB -rw-r--r-- 2021-07-19 12:55 R E G D
  pimple_compat.h 2.93 KB -rw-r--r-- 2021-07-19 12:55 R E G D
REQUEST EXIT
/* * This file is part of Pimple. * * Copyright (c) 2014 Fabien Potencier * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is furnished * to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "php.h" #include "php_ini.h" #include "ext/standard/info.h" #include "php_pimple.h" #include "pimple_compat.h" #include "zend_interfaces.h" #include "zend.h" #include "Zend/zend_closures.h" #include "ext/spl/spl_exceptions.h" #include "Zend/zend_exceptions.h" #include "main/php_output.h" #include "SAPI.h" static zend_class_entry *pimple_ce_PsrContainerInterface; static zend_class_entry *pimple_ce_PsrContainerExceptionInterface; static zend_class_entry *pimple_ce_PsrNotFoundExceptionInterface; static zend_class_entry *pimple_ce_ExpectedInvokableException; static zend_class_entry *pimple_ce_FrozenServiceException; static zend_class_entry *pimple_ce_InvalidServiceIdentifierException; static zend_class_entry *pimple_ce_UnknownIdentifierException; static zend_class_entry *pimple_ce; static zend_object_handlers pimple_object_handlers; static zend_class_entry *pimple_closure_ce; static zend_class_entry *pimple_serviceprovider_ce; static zend_object_handlers pimple_closure_object_handlers; static zend_internal_function pimple_closure_invoker_function; #define FETCH_DIM_HANDLERS_VARS pimple_object *pimple_obj = NULL; \ ulong index; \ pimple_obj = (pimple_object *)zend_object_store_get_object(object TSRMLS_CC); \ #define PIMPLE_OBJECT_HANDLE_INHERITANCE_OBJECT_HANDLERS do { \ if (ce != pimple_ce) { \ zend_hash_find(&ce->function_table, ZEND_STRS("offsetget"), (void **)&function); \ if (function->common.scope != ce) { /* if the function is not defined in this actual class */ \ pimple_object_handlers.read_dimension = pimple_object_read_dimension; /* then overwrite the handler to use custom one */ \ } \ zend_hash_find(&ce->function_table, ZEND_STRS("offsetset"), (void **)&function); \ if (function->common.scope != ce) { \ pimple_object_handlers.write_dimension = pimple_object_write_dimension; \ } \ zend_hash_find(&ce->function_table, ZEND_STRS("offsetexists"), (void **)&function); \ if (function->common.scope != ce) { \ pimple_object_handlers.has_dimension = pimple_object_has_dimension; \ } \ zend_hash_find(&ce->function_table, ZEND_STRS("offsetunset"), (void **)&function); \ if (function->common.scope != ce) { \ pimple_object_handlers.unset_dimension = pimple_object_unset_dimension; \ } \ } else { \ pimple_object_handlers.read_dimension = pimple_object_read_dimension; \ pimple_object_handlers.write_dimension = pimple_object_write_dimension; \ pimple_object_handlers.has_dimension = pimple_object_has_dimension; \ pimple_object_handlers.unset_dimension = pimple_object_unset_dimension; \ }\ } while(0); #define PIMPLE_CALL_CB do { \ zend_fcall_info_argn(&fci TSRMLS_CC, 1, &object); \ fci.size = sizeof(fci); \ fci.object_ptr = retval->fcc.object_ptr; \ fci.function_name = retval->value; \ fci.no_separation = 1; \ fci.retval_ptr_ptr = &retval_ptr_ptr; \ \ zend_call_function(&fci, &retval->fcc TSRMLS_CC); \ efree(fci.params); \ if (EG(exception)) { \ return EG(uninitialized_zval_ptr); \ } \ } while(0); /* Psr\Container\ContainerInterface */ ZEND_BEGIN_ARG_INFO_EX(arginfo_pimple_PsrContainerInterface_get, 0, 0, 1) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_pimple_PsrContainerInterface_has, 0, 0, 1) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() static const zend_function_entry pimple_ce_PsrContainerInterface_functions[] = { PHP_ABSTRACT_ME(ContainerInterface, get, arginfo_pimple_PsrContainerInterface_get) PHP_ABSTRACT_ME(ContainerInterface, has, arginfo_pimple_PsrContainerInterface_has) PHP_FE_END }; /* Psr\Container\ContainerExceptionInterface */ static const zend_function_entry pimple_ce_PsrContainerExceptionInterface_functions[] = { PHP_FE_END }; /* Psr\Container\NotFoundExceptionInterface */ static const zend_function_entry pimple_ce_PsrNotFoundExceptionInterface_functions[] = { PHP_FE_END }; /* Pimple\Exception\FrozenServiceException */ ZEND_BEGIN_ARG_INFO_EX(arginfo_FrozenServiceException___construct, 0, 0, 1) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() static const zend_function_entry pimple_ce_FrozenServiceException_functions[] = { PHP_ME(FrozenServiceException, __construct, arginfo_FrozenServiceException___construct, ZEND_ACC_PUBLIC) PHP_FE_END }; /* Pimple\Exception\InvalidServiceIdentifierException */ ZEND_BEGIN_ARG_INFO_EX(arginfo_InvalidServiceIdentifierException___construct, 0, 0, 1) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() static const zend_function_entry pimple_ce_InvalidServiceIdentifierException_functions[] = { PHP_ME(InvalidServiceIdentifierException, __construct, arginfo_InvalidServiceIdentifierException___construct, ZEND_ACC_PUBLIC) PHP_FE_END }; /* Pimple\Exception\UnknownIdentifierException */ ZEND_BEGIN_ARG_INFO_EX(arginfo_UnknownIdentifierException___construct, 0, 0, 1) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() static const zend_function_entry pimple_ce_UnknownIdentifierException_functions[] = { PHP_ME(UnknownIdentifierException, __construct, arginfo_UnknownIdentifierException___construct, ZEND_ACC_PUBLIC) PHP_FE_END }; /* Pimple\Container */ ZEND_BEGIN_ARG_INFO_EX(arginfo___construct, 0, 0, 0) ZEND_ARG_ARRAY_INFO(0, value, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetset, 0, 0, 2) ZEND_ARG_INFO(0, offset) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetget, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetexists, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetunset, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_factory, 0, 0, 1) ZEND_ARG_INFO(0, callable) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_protect, 0, 0, 1) ZEND_ARG_INFO(0, callable) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_raw, 0, 0, 1) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_extend, 0, 0, 2) ZEND_ARG_INFO(0, id) ZEND_ARG_INFO(0, callable) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_keys, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_register, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, provider, Pimple\\ServiceProviderInterface, 0) ZEND_ARG_ARRAY_INFO(0, values, 1) ZEND_END_ARG_INFO() static const zend_function_entry pimple_ce_functions[] = { PHP_ME(Pimple, __construct, arginfo___construct, ZEND_ACC_PUBLIC) PHP_ME(Pimple, factory, arginfo_factory, ZEND_ACC_PUBLIC) PHP_ME(Pimple, protect, arginfo_protect, ZEND_ACC_PUBLIC) PHP_ME(Pimple, raw, arginfo_raw, ZEND_ACC_PUBLIC) PHP_ME(Pimple, extend, arginfo_extend, ZEND_ACC_PUBLIC) PHP_ME(Pimple, keys, arginfo_keys, ZEND_ACC_PUBLIC) PHP_ME(Pimple, register, arginfo_register, ZEND_ACC_PUBLIC) PHP_ME(Pimple, offsetSet, arginfo_offsetset, ZEND_ACC_PUBLIC) PHP_ME(Pimple, offsetGet, arginfo_offsetget, ZEND_ACC_PUBLIC) PHP_ME(Pimple, offsetExists, arginfo_offsetexists, ZEND_ACC_PUBLIC) PHP_ME(Pimple, offsetUnset, arginfo_offsetunset, ZEND_ACC_PUBLIC) PHP_FE_END }; /* Pimple\ServiceProviderInterface */ ZEND_BEGIN_ARG_INFO_EX(arginfo_serviceprovider_register, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, pimple, Pimple\\Container, 0) ZEND_END_ARG_INFO() static const zend_function_entry pimple_serviceprovider_iface_ce_functions[] = { PHP_ABSTRACT_ME(ServiceProviderInterface, register, arginfo_serviceprovider_register) PHP_FE_END }; /* parent::__construct(sprintf("Something with %s", $arg1)) */ static void pimple_exception_call_parent_constructor(zval *this_ptr, const char *format, const char *arg1 TSRMLS_DC) { zend_class_entry *ce = Z_OBJCE_P(this_ptr); char *message = NULL; int message_len; zval *constructor_arg; message_len = spprintf(&message, 0, format, arg1); ALLOC_INIT_ZVAL(constructor_arg); ZVAL_STRINGL(constructor_arg, message, message_len, 1); zend_call_method_with_1_params(&this_ptr, ce, &ce->parent->constructor, "__construct", NULL, constructor_arg); efree(message); zval_ptr_dtor(&constructor_arg); } /** * Pass a single string parameter to exception constructor and throw */ static void pimple_throw_exception_string(zend_class_entry *ce, const char *message, zend_uint message_len TSRMLS_DC) { zval *exception, *param; ALLOC_INIT_ZVAL(exception); object_init_ex(exception, ce); ALLOC_INIT_ZVAL(param); ZVAL_STRINGL(param, message, message_len, 1); zend_call_method_with_1_params(&exception, ce, &ce->constructor, "__construct", NULL, param); zend_throw_exception_object(exception TSRMLS_CC); zval_ptr_dtor(¶m); } static void pimple_closure_free_object_storage(pimple_closure_object *obj TSRMLS_DC) { zend_object_std_dtor(&obj->zobj TSRMLS_CC); if (obj->factory) { zval_ptr_dtor(&obj->factory); } if (obj->callable) { zval_ptr_dtor(&obj->callable); } efree(obj); } static void pimple_free_object_storage(pimple_object *obj TSRMLS_DC) { zend_hash_destroy(&obj->factories); zend_hash_destroy(&obj->protected); zend_hash_destroy(&obj->values); zend_object_std_dtor(&obj->zobj TSRMLS_CC); efree(obj); } static void pimple_free_bucket(pimple_bucket_value *bucket) { if (bucket->raw) { zval_ptr_dtor(&bucket->raw); } } static zend_object_value pimple_closure_object_create(zend_class_entry *ce TSRMLS_DC) { zend_object_value retval; pimple_closure_object *pimple_closure_obj = NULL; pimple_closure_obj = ecalloc(1, sizeof(pimple_closure_object)); ZEND_OBJ_INIT(&pimple_closure_obj->zobj, ce); pimple_closure_object_handlers.get_constructor = pimple_closure_get_constructor; retval.handlers = &pimple_closure_object_handlers; retval.handle = zend_objects_store_put(pimple_closure_obj, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t) pimple_closure_free_object_storage, NULL TSRMLS_CC); return retval; } static zend_function *pimple_closure_get_constructor(zval *obj TSRMLS_DC) { zend_error(E_ERROR, "Pimple\\ContainerClosure is an internal class and cannot be instantiated"); return NULL; } static int pimple_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, union _zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) { *zobj_ptr = obj; *ce_ptr = Z_OBJCE_P(obj); *fptr_ptr = (zend_function *)&pimple_closure_invoker_function; return SUCCESS; } static zend_object_value pimple_object_create(zend_class_entry *ce TSRMLS_DC) { zend_object_value retval; pimple_object *pimple_obj = NULL; zend_function *function = NULL; pimple_obj = emalloc(sizeof(pimple_object)); ZEND_OBJ_INIT(&pimple_obj->zobj, ce); PIMPLE_OBJECT_HANDLE_INHERITANCE_OBJECT_HANDLERS retval.handlers = &pimple_object_handlers; retval.handle = zend_objects_store_put(pimple_obj, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t) pimple_free_object_storage, NULL TSRMLS_CC); zend_hash_init(&pimple_obj->factories, PIMPLE_DEFAULT_ZVAL_CACHE_NUM, NULL, (dtor_func_t)pimple_bucket_dtor, 0); zend_hash_init(&pimple_obj->protected, PIMPLE_DEFAULT_ZVAL_CACHE_NUM, NULL, (dtor_func_t)pimple_bucket_dtor, 0); zend_hash_init(&pimple_obj->values, PIMPLE_DEFAULT_ZVAL_VALUES_NUM, NULL, (dtor_func_t)pimple_bucket_dtor, 0); return retval; } static void pimple_object_write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC) { FETCH_DIM_HANDLERS_VARS pimple_bucket_value pimple_value = {0}, *found_value = NULL; ulong hash; pimple_zval_to_pimpleval(value, &pimple_value TSRMLS_CC); if (!offset) {/* $p[] = 'foo' when not overloaded */ zend_hash_next_index_insert(&pimple_obj->values, (void *)&pimple_value, sizeof(pimple_bucket_value), NULL); Z_ADDREF_P(value); return; } switch (Z_TYPE_P(offset)) { case IS_STRING: hash = zend_hash_func(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); zend_hash_quick_find(&pimple_obj->values, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hash, (void **)&found_value); if (found_value && found_value->type == PIMPLE_IS_SERVICE && found_value->initialized == 1) { pimple_free_bucket(&pimple_value); pimple_throw_exception_string(pimple_ce_FrozenServiceException, Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC); return; } if (zend_hash_quick_update(&pimple_obj->values, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hash, (void *)&pimple_value, sizeof(pimple_bucket_value), NULL) == FAILURE) { pimple_free_bucket(&pimple_value); return; } Z_ADDREF_P(value); break; case IS_DOUBLE: case IS_BOOL: case IS_LONG: if (Z_TYPE_P(offset) == IS_DOUBLE) { index = (ulong)Z_DVAL_P(offset); } else { index = Z_LVAL_P(offset); } zend_hash_index_find(&pimple_obj->values, index, (void **)&found_value); if (found_value && found_value->type == PIMPLE_IS_SERVICE && found_value->initialized == 1) { pimple_free_bucket(&pimple_value); convert_to_string(offset); pimple_throw_exception_string(pimple_ce_FrozenServiceException, Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC); return; } if (zend_hash_index_update(&pimple_obj->values, index, (void *)&pimple_value, sizeof(pimple_bucket_value), NULL) == FAILURE) { pimple_free_bucket(&pimple_value); return; } Z_ADDREF_P(value); break; case IS_NULL: /* $p[] = 'foo' when overloaded */ zend_hash_next_index_insert(&pimple_obj->values, (void *)&pimple_value, sizeof(pimple_bucket_value), NULL); Z_ADDREF_P(value); break; default: pimple_free_bucket(&pimple_value); zend_error(E_WARNING, "Unsupported offset type"); } } static void pimple_object_unset_dimension(zval *object, zval *offset TSRMLS_DC) { FETCH_DIM_HANDLERS_VARS switch (Z_TYPE_P(offset)) { case IS_STRING: zend_symtable_del(&pimple_obj->values, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); zend_symtable_del(&pimple_obj->factories, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); zend_symtable_del(&pimple_obj->protected, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1); break; case IS_DOUBLE: case IS_BOOL: case IS_LONG: if (Z_TYPE_P(offset) == IS_DOUBLE) { index = (ulong)Z_DVAL_P(offset); } else { index = Z_LVAL_P(offset); } zend_hash_index_del(&pimple_obj->values, index); zend_hash_index_del(&pimple_obj->factories, index); zend_hash_index_del(&pimple_obj->protected, index); break; default: zend_error(E_WARNING, "Unsupported offset type"); } } static int pimple_object_has_dimension(zval *object, zval *offset, int check_empty TSRMLS_DC) { FETCH_DIM_HANDLERS_VARS pimple_bucket_value *retval = NULL; switch (Z_TYPE_P(offset)) { case IS_STRING: if (zend_symtable_find(&pimple_obj->values, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **)&retval) == SUCCESS) { switch (check_empty) { case 0: /* isset */ return 1; /* Differs from PHP behavior (Z_TYPE_P(retval->value) != IS_NULL;) */ case 1: /* empty */ default: return zend_is_true(retval->value); } } return 0; break; case IS_DOUBLE: case IS_BOOL: case IS_LONG: if (Z_TYPE_P(offset) == IS_DOUBLE) { index = (ulong)Z_DVAL_P(offset); } else { index = Z_LVAL_P(offset); } if (zend_hash_index_find(&pimple_obj->values, index, (void **)&retval) == SUCCESS) { switch (check_empty) { case 0: /* isset */ return 1; /* Differs from PHP behavior (Z_TYPE_P(retval->value) != IS_NULL;)*/ case 1: /* empty */ default: return zend_is_true(retval->value); } } return 0; break; default: zend_error(E_WARNING, "Unsupported offset type"); return 0; } } static zval *pimple_object_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) { FETCH_DIM_HANDLERS_VARS pimple_bucket_value *retval = NULL; zend_fcall_info fci = {0}; zval *retval_ptr_ptr = NULL; switch (Z_TYPE_P(offset)) { case IS_STRING: if (zend_symtable_find(&pimple_obj->values, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **)&retval) == FAILURE) { pimple_throw_exception_string(pimple_ce_UnknownIdentifierException, Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC); return EG(uninitialized_zval_ptr); } break; case IS_DOUBLE: case IS_BOOL: case IS_LONG: if (Z_TYPE_P(offset) == IS_DOUBLE) { index = (ulong)Z_DVAL_P(offset); } else { index = Z_LVAL_P(offset); } if (zend_hash_index_find(&pimple_obj->values, index, (void **)&retval) == FAILURE) { return EG(uninitialized_zval_ptr); } break; case IS_NULL: /* $p[][3] = 'foo' first dim access */ return EG(uninitialized_zval_ptr); break; default: zend_error(E_WARNING, "Unsupported offset type"); return EG(uninitialized_zval_ptr); } if(retval->type == PIMPLE_IS_PARAM) { return retval->value; } if (zend_hash_index_exists(&pimple_obj->protected, retval->handle_num)) { /* Service is protected, return the value every time */ return retval->value; } if (zend_hash_index_exists(&pimple_obj->factories, retval->handle_num)) { /* Service is a factory, call it every time and never cache its result */ PIMPLE_CALL_CB Z_DELREF_P(retval_ptr_ptr); /* fetch dim addr will increment refcount */ return retval_ptr_ptr; } if (retval->initialized == 1) { /* Service has already been called, return its cached value */ return retval->value; } ALLOC_INIT_ZVAL(retval->raw); MAKE_COPY_ZVAL(&retval->value, retval->raw); PIMPLE_CALL_CB retval->initialized = 1; zval_ptr_dtor(&retval->value); retval->value = retval_ptr_ptr; return retval->value; } static int pimple_zval_is_valid_callback(zval *_zval, pimple_bucket_value *_pimple_bucket_value TSRMLS_DC) { if (Z_TYPE_P(_zval) != IS_OBJECT) { return FAILURE; } if (_pimple_bucket_value->fcc.called_scope) { return SUCCESS; } if (Z_OBJ_HANDLER_P(_zval, get_closure) && Z_OBJ_HANDLER_P(_zval, get_closure)(_zval, &_pimple_bucket_value->fcc.calling_scope, &_pimple_bucket_value->fcc.function_handler, &_pimple_bucket_value->fcc.object_ptr TSRMLS_CC) == SUCCESS) { _pimple_bucket_value->fcc.called_scope = _pimple_bucket_value->fcc.calling_scope; return SUCCESS; } else { return FAILURE; } } static int pimple_zval_to_pimpleval(zval *_zval, pimple_bucket_value *_pimple_bucket_value TSRMLS_DC) { _pimple_bucket_value->value = _zval; if (Z_TYPE_P(_zval) != IS_OBJECT) { return PIMPLE_IS_PARAM; } if (pimple_zval_is_valid_callback(_zval, _pimple_bucket_value TSRMLS_CC) == SUCCESS) { _pimple_bucket_value->type = PIMPLE_IS_SERVICE; _pimple_bucket_value->handle_num = Z_OBJ_HANDLE_P(_zval); } return PIMPLE_IS_SERVICE; } static void pimple_bucket_dtor(pimple_bucket_value *bucket) { zval_ptr_dtor(&bucket->value); pimple_free_bucket(bucket); } PHP_METHOD(FrozenServiceException, __construct) { char *id = NULL; int id_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &id, &id_len) == FAILURE) { return; } pimple_exception_call_parent_constructor(getThis(), "Cannot override frozen service \"%s\".", id TSRMLS_CC); } PHP_METHOD(InvalidServiceIdentifierException, __construct) { char *id = NULL; int id_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &id, &id_len) == FAILURE) { return; } pimple_exception_call_parent_constructor(getThis(), "Identifier \"%s\" does not contain an object definition.", id TSRMLS_CC); } PHP_METHOD(UnknownIdentifierException, __construct) { char *id = NULL; int id_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &id, &id_len) == FAILURE) { return; } pimple_exception_call_parent_constructor(getThis(), "Identifier \"%s\" is not defined.", id TSRMLS_CC); } PHP_METHOD(Pimple, protect) { zval *protected = NULL; pimple_object *pobj = NULL; pimple_bucket_value bucket = {0}; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &protected) == FAILURE) { return; } if (pimple_zval_is_valid_callback(protected, &bucket TSRMLS_CC) == FAILURE) { pimple_free_bucket(&bucket); zend_throw_exception(pimple_ce_ExpectedInvokableException, "Callable is not a Closure or invokable object.", 0 TSRMLS_CC); return; } pimple_zval_to_pimpleval(protected, &bucket TSRMLS_CC); pobj = (pimple_object *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_hash_index_update(&pobj->protected, bucket.handle_num, (void *)&bucket, sizeof(pimple_bucket_value), NULL) == SUCCESS) { Z_ADDREF_P(protected); RETURN_ZVAL(protected, 1 , 0); } else { pimple_free_bucket(&bucket); } RETURN_FALSE; } PHP_METHOD(Pimple, raw) { zval *offset = NULL; pimp