/* HashTable容量满了的时候重新分配大小 */
static int zend_hash_do_resize(HashTable *ht)
{
Bucket **t;
#ifdef ZEND_SIGNALS
TSRMLS_FETCH();
#endif
IS_CONSISTENT(ht);
if ((ht->nTableSize << 1) > 0) { /* Let's double the table size */
/* 重新分配大小 */
t = (Bucket **)perealloc_recoverable(
ht->arBuckets, (ht->nTableSize << 1) * sizeof(Bucket *),
ht->persistent);
if (t) {
HANDLE_BLOCK_INTERRUPTIONS();
ht->arBuckets = t;
/* 设置nTableSize */
ht->nTableSize = (ht->nTableSize << 1);
/* nTableMask随着nTableSize改变，永远是nTableSize-1 */
ht->nTableMask = ht->nTableSize - 1;
/* 修改HashTable大小之后需要重新哈希 */
zend_hash_rehash(ht);
HANDLE_UNBLOCK_INTERRUPTIONS();
return SUCCESS;
}
return FAILURE;
}
return SUCCESS;
}
static int zend_hash_do_resize(HashTable *ht)
{
Bucket **t;
IS_CONSISTENT(ht);
if ((ht->nTableSize << 1) > 0) { /* Let's double the table size */
t = (Bucket **) perealloc_recoverable(ht->arBuckets, (ht->nTableSize << 1) * sizeof(Bucket *), ht->persistent);
if (t) {
HANDLE_BLOCK_INTERRUPTIONS();
ht->arBuckets = t;
ht->nTableSize = (ht->nTableSize << 1);
ht->nTableMask = ht->nTableSize - 1;
zend_hash_rehash(ht);
HANDLE_UNBLOCK_INTERRUPTIONS();
#if DEBUG_RESIZE
asm("int3");
printf("#%d resized %d\n", ++resizes, ht->nTableSize);
#endif
return SUCCESS;
}
return FAILURE;
}
return SUCCESS;
}
ZEND_API void zend_hash_packed_to_hash(HashTable *ht)
{
HANDLE_BLOCK_INTERRUPTIONS();
ht->u.flags &= ~HASH_FLAG_PACKED;
ht->arData = (Bucket *) safe_perealloc(ht->arData, ht->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, ht->u.flags & HASH_FLAG_PERSISTENT);
ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize);
zend_hash_rehash(ht);
HANDLE_UNBLOCK_INTERRUPTIONS();
}
ZEND_API int zend_ts_hash_rehash(TsHashTable *ht)
{
int retval;
begin_write(ht);
retval = zend_hash_rehash(TS_HASH(ht));
end_write(ht);
return retval;
}
static int compact_hash_table(HashTable *ht)
{
uint i = 3;
uint j;
uint nSize;
Bucket *d;
Bucket *p;
if (!ht->nNumOfElements || (ht->u.flags & HASH_FLAG_PACKED)) {
/* Empty tables don't allocate space for Buckets */
return 1;
}
if (ht->nNumOfElements >= 0x80000000) {
/* prevent overflow */
nSize = 0x80000000;
} else {
while ((1U << i) < ht->nNumOfElements) {
i++;
}
nSize = 1 << i;
}
if (nSize >= ht->nTableSize) {
/* Keep the size */
return 1;
}
d = (Bucket *)pemalloc(nSize * (sizeof(Bucket) + sizeof(zend_uint)), ht->u.flags & HASH_FLAG_PERSISTENT);
if (!d) {
return 0;
}
for (i = 0, j = 0; i < ht->nNumUsed; i++) {
p = ht->arData + i;
if (Z_TYPE(p->val) != IS_UNDEF) {
d[j++] = *p;
}
}
ht->nNumUsed = j;
pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT);
ht->arData = d;
ht->arHash = (zend_uint *)(d + nSize);
ht->nTableSize = nSize;
ht->nTableMask = ht->nTableSize - 1;
zend_hash_rehash(ht);
return 1;
}
static void zend_hash_do_resize(HashTable *ht)
{
Bucket **t;
#ifdef ZEND_SIGNALS
TSRMLS_FETCH();
#endif
IS_CONSISTENT(ht);
if ((ht->nTableSize << 1) > 0) { /* Let's double the table size */
t = (Bucket **) perealloc(ht->arBuckets, (ht->nTableSize << 1) * sizeof(Bucket *), ht->persistent);
HANDLE_BLOCK_INTERRUPTIONS();
ht->arBuckets = t;
ht->nTableSize = (ht->nTableSize << 1);
ht->nTableMask = ht->nTableSize - 1;
zend_hash_rehash(ht);
HANDLE_UNBLOCK_INTERRUPTIONS();
}
}
static int compact_hash_table(HashTable *ht)
{
uint i = 3;
uint nSize;
Bucket **t;
if (!ht->nNumOfElements) {
/* Empty tables don't allocate space for Buckets */
return 1;
}
if (ht->nNumOfElements >= 0x80000000) {
/* prevent overflow */
nSize = 0x80000000;
} else {
while ((1U << i) < ht->nNumOfElements) {
i++;
}
nSize = 1 << i;
}
if (nSize >= ht->nTableSize) {
/* Keep the size */
return 1;
}
t = (Bucket **)pemalloc(nSize * sizeof(Bucket *), ht->persistent);
if (!t) {
return 0;
}
pefree(ht->arBuckets, ht->persistent);
ht->arBuckets = t;
ht->nTableSize = nSize;
ht->nTableMask = ht->nTableSize - 1;
zend_hash_rehash(ht);
return 1;
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
zval *message, *type, *type_str = NULL, *timestamp, *context, *interpolated = NULL;
zval *payload, *body, *backtrace = NULL, *meta, *encoded;
zval *show_backtrace, *enable_labels;
int i_show_backtrace, i_enable_labels;
smart_str result = { NULL, 0, 0 };
uint i;
Bucket *p;
phalcon_fetch_params(0, 4, 0, &message, &type, ×tamp, &context);
/*
* We intentionally do not use Phalcon's MM for better performance.
* All variables allocated with ALLOC_INIT_ZVAL() will have
* their reference count set to 1 and therefore they can be nicely
* put into the result array; when that array will be destroyed,
* all inserted variables will be automatically destroyed, too
* and we will just save some time by not using Z_ADDREF_P and Z_DELREF_P
*/
if (Z_TYPE_P(context) == IS_ARRAY) {
PHALCON_CALL_METHODW(&interpolated, this_ptr, "interpolate", message, context);
}
else {
interpolated = message;
Z_ADDREF_P(interpolated);
}
{
zval *params[] = { type };
if (FAILURE == phalcon_call_method(&type_str, this_ptr, "gettypestring", 1, params TSRMLS_CC)) {
zval_ptr_dtor(&interpolated);
return;
}
}
show_backtrace = phalcon_fetch_nproperty_this(getThis(), SL("_showBacktrace"), PH_NOISY TSRMLS_CC);
enable_labels = phalcon_fetch_nproperty_this(getThis(), SL("_enableLabels"), PH_NOISY TSRMLS_CC);
i_show_backtrace = zend_is_true(show_backtrace);
i_enable_labels = zend_is_true(enable_labels);
/*
* Get the backtrace. This differs for different PHP versions.
* 5.3.6+ allows us to skip the function arguments which will save some memory
* For 5.4+ there is an extra argument.
*/
if (i_show_backtrace) {
ALLOC_INIT_ZVAL(backtrace);
#if PHP_VERSION_ID < 50306
zend_fetch_debug_backtrace(backtrace, 1, 0 TSRMLS_CC);
#elif PHP_VERSION_ID < 50400
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS TSRMLS_CC);
#else
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS, 0 TSRMLS_CC);
#endif
if (Z_TYPE_P(backtrace) == IS_ARRAY) {
HashPosition pos;
HashTable *ht = Z_ARRVAL_P(backtrace);
zval **ppzval;
int found = 0;
ulong idx;
char *key;
uint key_len;
/*
* At this point we know that the backtrace is the array.
* Again, we intentionally do not use Phalcon's API because we know
* that we are working with the array / hash table and thus we can
* save some time by omitting Z_TYPE_P(x) == IS_ARRAY checks
*/
for (
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS;
) {
zend_hash_get_current_data_ex(ht, (void**)&ppzval, &pos);
zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, &pos);
zend_hash_move_forward_ex(ht, &pos);
if (Z_TYPE_PP(ppzval) == IS_ARRAY) {
/*
* Here we need to skip the latest calls into Phalcon's core.
* Calls to Zend internal functions will have "file" index not set.
* We remove these entries from the array.
*/
if (!found && !zend_hash_quick_exists(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")))) {
zend_hash_index_del(ht, idx);
}
else {
/*
* Remove args and object indices. They usually give
* too much information; this is not suitable to send
* in the HTTP headers
*/
zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "args", sizeof("args"), zend_inline_hash_func(SS("args")));
zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "object", sizeof("object"), zend_inline_hash_func(SS("object")));
found = 1;
}
}
}
/*
* Now we need to renumber the hash table because we removed several
* heading elements. If we don't do this, json_encode() will convert
* this array to a JavaScript object which is an unwanted side effect
*/
p = ht->pListHead;
i = 0;
while (p != NULL) {
p->nKeyLength = 0;
p->h = i++;
p = p->pListNext;
}
ht->nNextFreeElement = i;
zend_hash_rehash(ht);
}
}
/*
* The result will looks like this:
*
* array(
* array('Type' => 'message type', 'Label' => 'message'),
* array('backtrace' => array(backtrace goes here)
* )
*/
MAKE_STD_ZVAL(payload);
array_init_size(payload, 2);
MAKE_STD_ZVAL(meta);
array_init_size(meta, 4);
add_assoc_zval_ex(meta, SS("Type"), type_str);
if (i_show_backtrace && Z_TYPE_P(backtrace) == IS_ARRAY) {
zval **ppzval;
if (likely(SUCCESS == zend_hash_index_find(Z_ARRVAL_P(backtrace), 0, (void**)&ppzval)) && likely(Z_TYPE_PP(ppzval) == IS_ARRAY)) {
zval **file = NULL, **line = NULL;
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")), (void**)&file);
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("line"), zend_inline_hash_func(SS("line")), (void**)&line);
if (likely(file != NULL)) {
Z_ADDREF_PP(file);
add_assoc_zval_ex(meta, SS("File"), *file);
}
if (likely(line != NULL)) {
Z_ADDREF_PP(line);
add_assoc_zval_ex(meta, SS("Line"), *line);
}
}
}
if (i_enable_labels) {
add_assoc_zval_ex(meta, SS("Label"), interpolated);
}
if (!i_enable_labels && !i_show_backtrace) {
body = interpolated;
}
else if (i_enable_labels && !i_show_backtrace) {
MAKE_STD_ZVAL(body);
ZVAL_EMPTY_STRING(body);
}
else {
MAKE_STD_ZVAL(body);
array_init_size(body, 2);
if (i_show_backtrace) {
add_assoc_zval_ex(body, SS("backtrace"), backtrace);
}
if (!i_enable_labels) {
add_assoc_zval_ex(body, SS("message"), interpolated);
}
}
add_next_index_zval(payload, meta);
add_next_index_zval(payload, body);
/* Convert everything to JSON */
ALLOC_INIT_ZVAL(encoded);
if (FAILURE == phalcon_json_encode(encoded, payload, 0 TSRMLS_CC)) {
zval_ptr_dtor(&payload);
zval_ptr_dtor(&encoded);
return;
}
/* As promised, kill the payload and all associated elements */
zval_ptr_dtor(&payload);
/*
* We don't want to use Phalcon's concatenation API because it
* requires the memory manager. Therefore we fall back to using smart strings.
* smart_str_alloc4() will allocate all required memory amount (plus some more)
* in one go and this allows us to avoid performance penalties due to
* memory reallocations.
*/
if (Z_TYPE_P(encoded) == IS_STRING && Z_STRVAL_P(encoded) != NULL) {
smart_str_alloc4(&result, (uint)(Z_STRLEN_P(encoded) + 2 + 5), 0, i);
/*
* The format is:
*
* <size>|[meta,body]|
*
* Meta and body are contained in encoded inside the array, as required
* by the protocol specification
* @see http://www.firephp.org/Wiki/Reference/Protocol
*/
smart_str_append_long(&result, Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_appendl(&result, Z_STRVAL_P(encoded), Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_0(&result);
}
/* We don't need the JSON message anymore */
zval_ptr_dtor(&encoded);
/* Do not free the smart string because we steal its data for zval */
RETURN_STRINGL(result.c, result.len, 0);
}
static const char *zend_new_interned_string_int(const char *arKey, int nKeyLength, int free_src TSRMLS_DC)
{
#ifndef ZTS
ulong h;
uint nIndex;
Bucket *p;
if (IS_INTERNED(arKey)) {
return arKey;
}
h = zend_inline_hash_func(arKey, nKeyLength);
nIndex = h & CG(interned_strings).nTableMask;
p = CG(interned_strings).arBuckets[nIndex];
while (p != NULL) {
if ((p->h == h) && (p->nKeyLength == nKeyLength)) {
if (!memcmp(p->arKey, arKey, nKeyLength)) {
if (free_src) {
efree((void *)arKey);
}
return p->arKey;
}
}
p = p->pNext;
}
if (CG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength) >=
CG(interned_strings_end)) {
/* no memory */
return arKey;
}
p = (Bucket *) CG(interned_strings_top);
CG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength);
#if ZEND_DEBUG_INTERNED_STRINGS
mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_READ | PROT_WRITE);
#endif
p->arKey = (char*)(p+1);
memcpy((char*)p->arKey, arKey, nKeyLength);
if (free_src) {
efree((void *)arKey);
}
p->nKeyLength = nKeyLength;
p->h = h;
p->pData = &p->pDataPtr;
p->pDataPtr = p;
p->pNext = CG(interned_strings).arBuckets[nIndex];
p->pLast = NULL;
if (p->pNext) {
p->pNext->pLast = p;
}
HANDLE_BLOCK_INTERRUPTIONS();
p->pListLast = CG(interned_strings).pListTail;
CG(interned_strings).pListTail = p;
p->pListNext = NULL;
if (p->pListLast != NULL) {
p->pListLast->pListNext = p;
}
if (!CG(interned_strings).pListHead) {
CG(interned_strings).pListHead = p;
}
CG(interned_strings).arBuckets[nIndex] = p;
HANDLE_UNBLOCK_INTERRUPTIONS();
CG(interned_strings).nNumOfElements++;
if (CG(interned_strings).nNumOfElements > CG(interned_strings).nTableSize) {
if ((CG(interned_strings).nTableSize << 1) > 0) { /* Let's double the table size */
Bucket **t = (Bucket **) perealloc_recoverable(CG(interned_strings).arBuckets, (CG(interned_strings).nTableSize << 1) * sizeof(Bucket *), CG(interned_strings).persistent);
if (t) {
HANDLE_BLOCK_INTERRUPTIONS();
CG(interned_strings).arBuckets = t;
CG(interned_strings).nTableSize = (CG(interned_strings).nTableSize << 1);
CG(interned_strings).nTableMask = CG(interned_strings).nTableSize - 1;
zend_hash_rehash(&CG(interned_strings));
HANDLE_UNBLOCK_INTERRUPTIONS();
}
}
}
#if ZEND_DEBUG_INTERNED_STRINGS
mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_READ);
#endif
return p->arKey;
#else
return arKey;
#endif
}
