/* {{{ zend_user_unserialize */
ZEND_API int zend_user_unserialize(zval *object, zend_class_entry *ce, const unsigned char *buf, size_t buf_len, zend_unserialize_data *data)
{
zval zdata;
if (UNEXPECTED(object_init_ex(object, ce) != SUCCESS)) {
return FAILURE;
}
ZVAL_STRINGL(&zdata, (char*)buf, buf_len);
zend_call_method_with_1_params(object, ce, &ce->unserialize_func, "unserialize", NULL, &zdata);
zval_ptr_dtor(&zdata);
if (EG(exception)) {
return FAILURE;
} else {
return SUCCESS;
}
}
ZEND_API int zend_hash_rehash(HashTable *ht)
{
Bucket *p;
uint nIndex;
IS_CONSISTENT(ht);
if (UNEXPECTED(ht->nNumOfElements == 0)) {
return SUCCESS;
}
memset(ht->arBuckets, 0, ht->nTableSize * sizeof(Bucket *));
p = ht->pListHead;
while (p != NULL) {
nIndex = p->h & ht->nTableMask;
CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
ht->arBuckets[nIndex] = p;
p = p->pListNext;
}
return SUCCESS;
}
void setLiteralsAndValues(char *lits, unsigned litCount, unsigned *vals, unsigned valCount) {
// Check wether process is already running
if (processRunning) {
fprintf(stderr, "Process already started - literals and values cannot be set at this stage");
return;
}
// Copy the literals and values
if (UNEXPECTED((literals = (char *)malloc(litCount * sizeof(char))) == NULL)) {
fprintf(stderr, "Not enough memory");
return;
} else {
memcpy(literals, lits, sizeof(unsigned)*litCount);
}
values = copyUnsigned(vals, valCount);
literalCount = litCount;
valueCount = valCount;
literalsSet = true;
}
/**
* Changes the padding scheme used
*/
PHP_METHOD(Phalcon_Crypt, setPadding) {
zval *scheme_param = NULL, *_0;
zend_long scheme;
zephir_fetch_params(0, 1, 0, &scheme_param);
if (UNEXPECTED(Z_TYPE_P(scheme_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'scheme' must be a int") TSRMLS_CC);
RETURN_NULL();
}
scheme = Z_LVAL_P(scheme_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, scheme);
zephir_update_property_this(getThis(), SL("_padding"), _0 TSRMLS_CC);
RETURN_THISW();
}
/**
* @var mixed input The text to sanitize
*/
PHP_METHOD(Phalcon_Filter_Sanitize_Lower, __invoke) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *input_param = NULL, _0$$3, _1$$3, _2;
zval input;
zval *this_ptr = getThis();
ZVAL_UNDEF(&input);
ZVAL_UNDEF(&_0$$3);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &input_param);
if (UNEXPECTED(Z_TYPE_P(input_param) != IS_STRING && Z_TYPE_P(input_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'input' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(input_param) == IS_STRING)) {
zephir_get_strval(&input, input_param);
} else {
ZEPHIR_INIT_VAR(&input);
ZVAL_EMPTY_STRING(&input);
}
if (1 == (zephir_function_exists_ex(SL("mb_convert_case") TSRMLS_CC) == SUCCESS)) {
ZVAL_LONG(&_0$$3, 1);
ZEPHIR_INIT_VAR(&_1$$3);
ZVAL_STRING(&_1$$3, "UTF-8");
ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_case", NULL, 189, &input, &_0$$3, &_1$$3);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 190, &input);
zephir_check_call_status();
zephir_fast_strtolower(return_value, &_2);
RETURN_MM();
}
static void zend_accel_function_hash_copy(HashTable *target, HashTable *source)
{
zend_function *function1, *function2;
uint idx;
Bucket *p;
zval *t;
for (idx = 0; idx < source->nNumUsed; idx++) {
p = source->arData + idx;
if (Z_TYPE(p->val) == IS_UNDEF) continue;
ZEND_ASSERT(p->key);
t = zend_hash_add(target, p->key, &p->val);
if (UNEXPECTED(t == NULL)) {
if (p->key->len > 0 && p->key->val[0] == 0) {
/* Mangled key */
t = zend_hash_update(target, p->key, &p->val);
} else {
t = zend_hash_find(target, p->key);
goto failure;
}
}
}
target->nInternalPointer = target->nNumOfElements ? 0 : INVALID_IDX;
return;
failure:
function1 = Z_PTR(p->val);
function2 = Z_PTR_P(t);
CG(in_compilation) = 1;
zend_set_compiled_filename(function1->op_array.filename);
CG(zend_lineno) = function1->op_array.opcodes[0].lineno;
if (function2->type == ZEND_USER_FUNCTION
&& function2->op_array.last > 0) {
zend_error(E_ERROR, "Cannot redeclare %s() (previously declared in %s:%d)",
function1->common.function_name->val,
function2->op_array.filename->val,
(int)function2->op_array.opcodes[0].lineno);
} else {
zend_error(E_ERROR, "Cannot redeclare %s()", function1->common.function_name->val);
}
}
/**
* Phalcon\Acl\Operation constructor
*/
PHP_METHOD(Phalcon_Acl_Operation, __construct) {
zval *name_param = NULL, *description_param = NULL;
zval name, description;
zval *this_ptr = getThis();
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&description);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &name_param, &description_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(&name, name_param);
} else {
ZEPHIR_INIT_VAR(&name);
ZVAL_EMPTY_STRING(&name);
}
if (!description_param) {
ZEPHIR_INIT_VAR(&description);
ZVAL_STRING(&description, "");
} else {
zephir_get_strval(&description, description_param);
}
if (ZEPHIR_IS_STRING(&name, "*")) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Operation name cannot be '*'", "phalcon/acl/operation.zep", 40);
return;
}
zephir_update_property_zval(this_ptr, SL("name"), &name);
if (!(Z_TYPE_P(&description) == IS_UNDEF) && Z_STRLEN_P(&description)) {
zephir_update_property_zval(this_ptr, SL("description"), &description);
}
ZEPHIR_MM_RESTORE();
}
static zend_bool class_name_type_hint(const zend_op_array *op_array, uint32_t arg_num)
{
zend_arg_info *arg_info;
if (arg_num > 0) {
if (op_array->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
if (EXPECTED(arg_num <= op_array->num_args)) {
arg_info = &op_array->arg_info[arg_num-1];
} else if (UNEXPECTED(op_array->fn_flags & ZEND_ACC_VARIADIC)) {
arg_info = &op_array->arg_info[op_array->num_args];
} else {
return 0;
}
return ZEND_TYPE_IS_CLASS(arg_info->type);
}
} else {
arg_info = op_array->arg_info - 1;
return ZEND_TYPE_IS_CLASS(arg_info->type);
}
return 0;
}
static int process_args(args_t * args)
{
assert(args != NULL);
switch (args->cmd) {
case c_INJECT:
command_inject(args);
break;
case c_REMOVE:
command_remove(args);
break;
case c_HEXDUMP:
command_hexdump(args);
break;
default:
UNEXPECTED("NOT IMPLEMENTED YET => '%c'", args->cmd);
return -1;
}
return 0;
}
/**
* Gets an attribute a message using the array syntax
*
*<code>
* print_r(
* $messages[0]
* );
*</code>
*
* @param int index
* @return \Phalcon\Validation\Message
*/
PHP_METHOD(Phalcon_Validation_Message_Group, offsetGet) {
zval *index_param = NULL, *message = NULL, *_0;
zend_long index;
zephir_fetch_params(0, 1, 0, &index_param);
if (UNEXPECTED(Z_TYPE_P(index_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a int") TSRMLS_CC);
RETURN_NULL();
}
index = Z_LVAL_P(index_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC);
if (zephir_array_isset_long_fetch(&message, _0, index, 1 TSRMLS_CC)) {
RETURN_CTORW(message);
}
RETURN_BOOL(0);
}
PHP_METHOD(jz_data, offsetUnset) {
zval *readonly = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME_READONLY), 1, NULL);
if (Z_TYPE_P(readonly) == IS_FALSE) {
zval *props;
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
}
props = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
if (UNEXPECTED(Z_TYPE_P(props) != IS_ARRAY)) {
RETURN_FALSE;
}
if (zend_hash_del(Z_ARRVAL_P(props), name) == SUCCESS) {
RETURN_TRUE;
}
}
RETURN_FALSE;
}
/**
* Phalcon\Mvc\Model\Relation constructor
*
* @param int type
* @param string|array fields
* @param string|array referencedFields
* @param array options
*/
PHP_METHOD(Phalcon_Mvc_Model_Relation, __construct) {
zval referencedModel;
zval *type, type_sub, *referencedModel_param = NULL, *fields, fields_sub, *referencedFields, referencedFields_sub, *options = NULL, options_sub, __$null;
zval *this_ptr = getThis();
ZVAL_UNDEF(&type_sub);
ZVAL_UNDEF(&fields_sub);
ZVAL_UNDEF(&referencedFields_sub);
ZVAL_UNDEF(&options_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&referencedModel);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 1, &type, &referencedModel_param, &fields, &referencedFields, &options);
if (UNEXPECTED(Z_TYPE_P(referencedModel_param) != IS_STRING && Z_TYPE_P(referencedModel_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'referencedModel' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(referencedModel_param) == IS_STRING)) {
zephir_get_strval(&referencedModel, referencedModel_param);
} else {
ZEPHIR_INIT_VAR(&referencedModel);
ZVAL_EMPTY_STRING(&referencedModel);
}
if (!options) {
options = &options_sub;
options = &__$null;
}
zephir_update_property_zval(this_ptr, SL("_type"), type);
zephir_update_property_zval(this_ptr, SL("_referencedModel"), &referencedModel);
zephir_update_property_zval(this_ptr, SL("_fields"), fields);
zephir_update_property_zval(this_ptr, SL("_referencedFields"), referencedFields);
zephir_update_property_zval(this_ptr, SL("_options"), options);
ZEPHIR_MM_RESTORE();
}
/**
* Removes a property from the internal bag
*
*<code>
* $user->remove("name");
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, remove) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, *_0, *data = NULL, *_1$$4, *_2$$4;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(property, property_param);
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if (zephir_array_isset(data, property)) {
zephir_array_unset(&data, property, PH_SEPARATE);
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_session"), PH_NOISY_CC);
_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _1$$4, "set", NULL, 0, _2$$4, data);
zephir_check_call_status();
zephir_update_property_this(getThis(), SL("_data"), data TSRMLS_CC);
RETURN_MM_BOOL(1);
}
RETURN_MM_BOOL(0);
}
/** see http://lxr.php.net/xref/PHP_7_0/Zend/zend_vm_def.h#2892 */
static int oop_method_call_handler(zend_execute_data *execute_data)
{
const zend_op *opline = execute_data->opline;
zend_free_op free_op1, free_op2;
zval *obj = NULL, *method = NULL;
zend_class_entry *ce = NULL;
zend_function *fbc = NULL;
zend_execute_data *call = NULL;
obj = zend_get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R);
method = zend_get_zval_ptr(opline->op2_type, &opline->op2, execute_data, &free_op2, BP_VAR_R);
if (Z_TYPE_P(obj) == IS_STRING) {
ce = OOP_G(oop_handlers)[Z_TYPE_P(obj)];
if (!ce) {
return ZEND_USER_OPCODE_DISPATCH;
}
fbc = zend_std_get_static_method(ce, Z_STR_P(method), NULL);
if (UNEXPECTED(fbc == NULL)) {
php_error(E_ERROR, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(method));
}
fbc = oop_get_indirection_func(ce, fbc, method, obj);
call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, fbc, opline->extended_value, ce, NULL);
call->prev_execute_data = EX(call);
EX(call) = call;
FREE_OP(free_op2);
FREE_OP_IF_VAR(free_op1);
execute_data->opline++;
return ZEND_USER_OPCODE_CONTINUE;
}
return ZEND_USER_OPCODE_DISPATCH;
}
ZEND_API void ZEND_FASTCALL gc_remove_from_buffer(zend_refcounted *ref)
{
gc_root_buffer *root;
uint32_t idx = GC_REF_ADDRESS(ref);
GC_BENCH_INC(zval_remove_from_buffer);
if (!GC_REF_CHECK_COLOR(ref, GC_BLACK)) {
GC_TRACE_SET_COLOR(ref, GC_BLACK);
}
GC_REF_SET_INFO(ref, 0);
/* Perform decompression only in case of large buffers */
if (UNEXPECTED(GC_G(first_unused) >= GC_MAX_UNCOMPRESSED)) {
gc_remove_compressed(ref, idx);
return;
}
ZEND_ASSERT(idx);
root = GC_IDX2PTR(idx);
gc_remove_from_roots(root);
}
int parse_offset(const char *str, off_t *offset)
{
assert(offset != NULL);
if (str == NULL) {
*offset = 0;
return 0;
}
char *end = NULL;
errno = 0;
*offset = strtoull(str, &end, 0);
if (errno != 0) {
ERRNO(errno);
return -1;
}
if (*end != '\0') {
if (!strcmp(end, "KiB") ||
!strcasecmp(end, "KB") ||
!strcasecmp(end, "K"))
*offset <<= 10;
else if (!strcmp(end, "MiB") ||
!strcasecmp(end, "MB") ||
!strcasecmp(end, "M"))
*offset <<= 20;
else if (!strcmp(end, "GiB") ||
!strcasecmp(end, "GB") ||
!strcasecmp(end, "G"))
*offset <<= 30;
else {
UNEXPECTED("invalid offset specified '%s'", end);
return -1;
}
}
return 0;
}
/**
* Sets if the main handler must be lazy loaded
*/
PHP_METHOD(Phalcon_Mvc_Micro_Collection, setLazy) {
zval *lazy_param = NULL;
zend_bool lazy;
zephir_fetch_params(0, 1, 0, &lazy_param);
if (UNEXPECTED(Z_TYPE_P(lazy_param) != IS_BOOL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'lazy' must be a bool") TSRMLS_CC);
RETURN_NULL();
}
lazy = Z_BVAL_P(lazy_param);
if (lazy) {
zephir_update_property_this(getThis(), SL("_lazy"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_lazy"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_THISW();
}
/** {{{ proto public Yaf_Config_Simple::offsetUnset($index)
*/
PHP_METHOD(yaf_config_simple, offsetUnset) {
zval *readonly = zend_read_property(yaf_config_simple_ce,
getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME_READONLY), 1, NULL);
if (Z_TYPE_P(readonly) == IS_FALSE) {
zval *props;
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
}
props = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
if (UNEXPECTED(Z_TYPE_P(props) != IS_ARRAY)) {
RETURN_FALSE;
}
if (zend_hash_del(Z_ARRVAL_P(props), name) == SUCCESS) {
RETURN_TRUE;
}
}
RETURN_FALSE;
}
/**
* Phalcon\Db\Index constructor
*/
PHP_METHOD(Phalcon_Db_Index, __construct) {
zval columns;
zval *name_param = NULL, *columns_param = NULL, *type_param = NULL;
zval name, type;
zval *this_ptr = getThis();
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&type);
ZVAL_UNDEF(&columns);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &name_param, &columns_param, &type_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(&name, name_param);
} else {
ZEPHIR_INIT_VAR(&name);
ZVAL_EMPTY_STRING(&name);
}
ZEPHIR_OBS_COPY_OR_DUP(&columns, columns_param);
if (!type_param) {
ZEPHIR_INIT_VAR(&type);
ZVAL_STRING(&type, "");
} else {
zephir_get_strval(&type, type_param);
}
zephir_update_property_zval(this_ptr, SL("_name"), &name);
zephir_update_property_zval(this_ptr, SL("_columns"), &columns);
zephir_update_property_zval(this_ptr, SL("_type"), &type);
ZEPHIR_MM_RESTORE();
}
static ZEND_INI_MH(OnUpdateMemoryConsumption)
{
zend_long *p;
zend_long memsize;
#ifndef ZTS
char *base = (char *) mh_arg2;
#else
char *base = (char *) ts_resource(*((int *) mh_arg2));
#endif
/* keep the compiler happy */
(void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
p = (zend_long *) (base + (size_t)mh_arg1);
memsize = atoi(ZSTR_VAL(new_value));
/* sanity check we must use at least 8 MB */
if (memsize < 8) {
const char *new_new_value = "8";
zend_ini_entry *ini_entry;
memsize = 8;
zend_accel_error(ACCEL_LOG_WARNING, "opcache.memory_consumption is set below the required 8MB.\n");
zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal 8MB configuration.\n");
if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
"opcache.memory_consumption",
sizeof("opcache.memory_consumption")-1)) == NULL) {
return FAILURE;
}
ini_entry->value = zend_string_init(new_new_value, 1, 1);
}
if (UNEXPECTED(memsize > ZEND_ULONG_MAX / (1024 * 1024))) {
*p = ZEND_ULONG_MAX;
} else {
*p = memsize * (1024 * 1024);
}
return SUCCESS;
}
int mqueue_close(mqueue_t * self, char *path)
{
assert(self != NULL);
if (path != NULL) {
char *endp = NULL;
(void)strtol(path + 1, &endp, 10);
if (strncmp(endp, "->", 2) == 0) {
if (self->in != (mqd_t) - 1)
mq_close(self->in), self->in = (mqd_t) - 1;
} else if (strncmp(endp, "<-", 2) == 0) {
if (self->out != (mqd_t) - 1)
mq_close(self->out), self->out = (mqd_t) - 1;
} else {
UNEXPECTED("'%s' invalid service", path);
return -1;
}
}
return 0;
}
void TextureViewDesc_to_D3D12_RTV_DESC(const TextureViewDesc& RTVDesc, D3D12_RENDER_TARGET_VIEW_DESC &D3D12RTVDesc, Uint32 SampleCount)
{
TextureViewDesc_to_D3D_RTV_DESC(RTVDesc, D3D12RTVDesc, SampleCount);
switch (RTVDesc.TextureDim)
{
case RESOURCE_DIM_TEX_1D:
break;
case RESOURCE_DIM_TEX_1D_ARRAY:
break;
case RESOURCE_DIM_TEX_2D:
if( SampleCount > 1 )
{
}
else
{
D3D12RTVDesc.Texture2D.PlaneSlice = 0;
}
break;
case RESOURCE_DIM_TEX_2D_ARRAY:
if( SampleCount > 1 )
{
}
else
{
D3D12RTVDesc.Texture2DArray.PlaneSlice = 0;
}
break;
case RESOURCE_DIM_TEX_3D:
break;
default:
UNEXPECTED( "Unexpected view type" );
}
}
void zend_hash_display(const HashTable *ht)
{
Bucket *p;
uint i;
if (UNEXPECTED(ht->nNumOfElements == 0)) {
zend_output_debug_string(0, "The hash is empty");
return;
}
for (i = 0; i < ht->nNumOfElements; i++) {
p = ht->arBuckets[i];
while (p != NULL) {
zend_output_debug_string(0, "%s <==> 0x%lX\n", p->arKey, p->h);
p = p->pNext;
}
}
p = ht->pListTail;
while (p != NULL) {
zend_output_debug_string(0, "%s <==> 0x%lX\n", p->arKey, p->h);
p = p->pListLast;
}
}
/* 对哈希表进行重新哈希操作 */
ZEND_API int zend_hash_rehash(HashTable *ht)
{
Bucket *p;
uint nIndex;
IS_CONSISTENT(ht);
if (UNEXPECTED(ht->nNumOfElements == 0)) {
return SUCCESS;
}
/* 先将arBuckets重新初始化为0 */
memset(ht->arBuckets, 0, ht->nTableSize * sizeof(Bucket *));
/* p指向pListHead，pListHead指向数组的第一个元素，保存这个指针在重新哈希的时候也非常有用
*/
p = ht->pListHead;
while (p != NULL) {
/* 逐个计算下标然后添加到相同哈希值的bucket中 */
nIndex = p->h & ht->nTableMask;
CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
ht->arBuckets[nIndex] = p;
p = p->pListNext;
}
return SUCCESS;
}
// Parses a single import statement.
void parse_import(Parser *parser) {
Lexer *lexer = parser->lexer;
// Parse a multi-import statement if the next token is
// an open parenthesis
if (lexer->token == TOKEN_OPEN_PARENTHESIS) {
// Consume the open parenthesis
lexer_next(lexer);
// Multi-import statement
parse_multi_import(parser);
} else if (lexer->token == TOKEN_STRING) {
// Single import statement
char *name = lexer_extract_string(lexer->value.identifier);
import(parser, name);
// Consume the string token
lexer_next(lexer);
} else {
// Unexpected token
UNEXPECTED("Expected package name or `(` after `import`");
}
}
// Parses a single statement.
void parse_statement(Parser *parser) {
Lexer *lexer = parser->lexer;
switch (lexer->token) {
// Trigger a special error for misplaced imports
case TOKEN_IMPORT:
ERROR("Imports must be placed at the top of the file");
case TOKEN_LET:
parse_initial_assignment(parser);
break;
default:
// Could be a function call or an assignment
if (call_or_assignment(parser)) {
break;
}
// Unrecognised statement
UNEXPECTED("Expected statement (eg. `if`, `while`)");
break;
}
}
/**
* Returns an element added to the form by its name
*/
PHP_METHOD(Phalcon_Forms_Form, get) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *element = NULL, *_0, *_1;
zval *name = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
ZEPHIR_OBS_VAR(element);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&element, _0, name, 0 TSRMLS_CC)) {
RETURN_CCTOR(element);
}
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_forms_exception_ce);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SVS(_2, "Element with ID=", name, " is not part of the form");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/forms/form.zep", 482 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Can delay any new job being reserved for a given time.
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, pauseTube) {
int delay, ZEPHIR_LAST_CALL_STATUS;
zval *tube_param = NULL, *delay_param = NULL, *response = NULL, _0, *_2;
zval *tube = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &tube_param, &delay_param);
if (UNEXPECTED(Z_TYPE_P(tube_param) != IS_STRING && Z_TYPE_P(tube_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tube' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(tube_param) == IS_STRING)) {
zephir_get_strval(tube, tube_param);
} else {
ZEPHIR_INIT_VAR(tube);
ZVAL_EMPTY_STRING(tube);
}
delay = zephir_get_intval(delay_param);
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, delay);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVSV(_1, "pause-tube ", tube, " ", &_0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&response, this_ptr, "readstatus", NULL, 409);
zephir_check_call_status();
zephir_array_fetch_long(&_2, response, 0, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 289 TSRMLS_CC);
if (!ZEPHIR_IS_STRING(_2, "PAUSED")) {
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Obtains a value from the session bag optionally setting a default value
*
*<code>
* echo $user->get("name", "Kimbra");
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, get) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, *defaultValue = NULL, *value = NULL, *_0, *_1;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &property_param, &defaultValue);
if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(property, property_param);
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
if (!defaultValue) {
defaultValue = ZEPHIR_GLOBAL(global_null);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&value, _1, property, 1 TSRMLS_CC)) {
RETURN_CTOR(value);
}
RETVAL_ZVAL(defaultValue, 1, 0);
RETURN_MM();
}
/**
* Phalcon\Config\Adapter\Json constructor
*/
PHP_METHOD(Phalcon_Config_Adapter_Json, __construct) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *filePath_param = NULL, __$true, _1, _2;
zval filePath;
zval *this_ptr = getThis();
ZVAL_UNDEF(&filePath);
ZVAL_BOOL(&__$true, 1);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &filePath_param);
if (UNEXPECTED(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(filePath_param) == IS_STRING)) {
zephir_get_strval(&filePath, filePath_param);
} else {
ZEPHIR_INIT_VAR(&filePath);
ZVAL_EMPTY_STRING(&filePath);
}
ZEPHIR_INIT_VAR(&_1);
ZEPHIR_INIT_VAR(&_2);
zephir_file_get_contents(&_2, &filePath TSRMLS_CC);
zephir_json_decode(&_1, &_2, zephir_get_intval(&__$true) );
ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_json_ce, getThis(), "__construct", &_0, 0, &_1);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
