static APC_HOTSPOT zend_reference* my_copy_reference(const zend_reference* src, apc_context_t *ctxt) {
apc_pool* pool = ctxt->pool;
zend_reference *dst;
assert(src != NULL);
if (ctxt->copied.nTableSize) {
zend_reference *rc = zend_hash_index_find_ptr(&ctxt->copied, (uintptr_t) src);
if (rc) {
GC_REFCOUNT(rc)++;
return rc;
}
}
if (ctxt->copy == APC_COPY_IN) {
dst = pool->palloc(pool, sizeof(zend_reference));
} else {
dst = emalloc(sizeof(zend_reference));
}
GC_REFCOUNT(dst) = 1;
GC_TYPE_INFO(dst) = IS_REFERENCE;
my_copy_zval(&dst->val, &src->val, ctxt);
if (ctxt->copied.nTableSize) {
zend_hash_index_update_ptr(&ctxt->copied, (uintptr_t) src, dst);
}
return dst;
}
/* {{{ */
void* pthreads_globals_object_alloc(size_t length) {
zend_bool locked = 0;
void *bucket = (void*) ecalloc(1, length);
if (pthreads_globals_lock()) {
zend_hash_index_update_ptr(
&PTHREADS_G(objects),
(zend_ulong) bucket, bucket);
pthreads_globals_unlock();
}
memset(bucket, 0, length);
return bucket;
} /* }}} */
/* {{{ proto void SolrInputDocument::__clone(void)
Clones the current object. Not to be called directly. */
PHP_METHOD(SolrInputDocument, __clone)
{
zval *objptr = getThis();
solr_document_t new_solr_doc;
solr_document_t *new_doc_entry = NULL, *old_doc_entry = NULL;
ulong document_index = SOLR_UNIQUE_DOCUMENT_INDEX();
new_doc_entry = &new_solr_doc;
new_doc_entry = (solr_document_t *) pemalloc(sizeof(solr_document_t), SOLR_DOCUMENT_PERSISTENT);
memset(&new_solr_doc, 0, sizeof(solr_document_t));
/* Retrieve the document entry for the original SolrDocument */
if (solr_fetch_document_entry(objptr, &old_doc_entry TSRMLS_CC) == FAILURE) {
return ;
}
/* Duplicate the doc_entry contents */
memcpy(new_doc_entry, old_doc_entry, sizeof(solr_document_t));
/* Override the document index with a new one and create a new HashTable */
new_doc_entry->document_index = document_index;
/* Allocate new memory for the fields HashTable, using fast cache for HashTables */
ALLOC_HASHTABLE(new_doc_entry->fields);
ALLOC_HASHTABLE(new_doc_entry->children);
/* Initializing the hash table used for storing fields in this SolrDocument */
zend_hash_init(new_doc_entry->fields, old_doc_entry->fields->nTableSize, NULL, (dtor_func_t) solr_destroy_field_list_ht_dtor, SOLR_DOCUMENT_FIELD_PERSISTENT);
zend_hash_init(new_doc_entry->children, old_doc_entry->children->nTableSize, NULL, ZVAL_PTR_DTOR, SOLR_DOCUMENT_FIELD_PERSISTENT);
/* Copy the contents of the old fields HashTable to the new SolrDocument */
zend_hash_copy(new_doc_entry->fields, old_doc_entry->fields, (copy_ctor_func_t) field_copy_constructor);
zend_hash_copy(new_doc_entry->children, old_doc_entry->children, (copy_ctor_func_t) zval_add_ref);
/* Add the document entry to the directory of documents */
zend_hash_index_update_ptr(SOLR_GLOBAL(documents), document_index, (void *) new_doc_entry);
/* Set the value of the internal id property */
zend_update_property_long(solr_ce_SolrInputDocument, objptr, SOLR_INDEX_PROPERTY_NAME, sizeof(SOLR_INDEX_PROPERTY_NAME) - 1, document_index TSRMLS_CC);
/* Keep track of how many SolrDocument instances we currently have */
SOLR_GLOBAL(document_count)++;
}
/* {{{ php_oci_lob_create()
Create LOB descriptor and allocate all the resources needed */
php_oci_descriptor *php_oci_lob_create (php_oci_connection *connection, zend_long type)
{
php_oci_descriptor *descriptor;
sword errstatus;
switch (type) {
case OCI_DTYPE_FILE:
case OCI_DTYPE_LOB:
case OCI_DTYPE_ROWID:
/* these three are allowed */
break;
default:
php_error_docref(NULL, E_WARNING, "Unknown descriptor type %pd", type);
return NULL;
break;
}
descriptor = ecalloc(1, sizeof(php_oci_descriptor));
descriptor->type = (ub4) type;
descriptor->connection = connection;
++GC_REFCOUNT(descriptor->connection->id);
PHP_OCI_CALL_RETURN(errstatus, OCIDescriptorAlloc, (connection->env, (dvoid*)&(descriptor->descriptor), descriptor->type, (size_t) 0, (dvoid **) 0));
if (errstatus != OCI_SUCCESS) {
OCI_G(errcode) = php_oci_error(OCI_G(err), errstatus);
PHP_OCI_HANDLE_ERROR(connection, OCI_G(errcode));
efree(descriptor);
return NULL;
} else {
OCI_G(errcode) = 0; /* retain backwards compat with OCI8 1.4 */
}
PHP_OCI_REGISTER_RESOURCE(descriptor, le_descriptor);
descriptor->lob_current_position = 0;
descriptor->lob_size = -1; /* we should set it to -1 to know, that it's just not initialized */
descriptor->buffering = PHP_OCI_LOB_BUFFER_DISABLED; /* buffering is off by default */
descriptor->charset_form = SQLCS_IMPLICIT; /* default value */
descriptor->charset_id = connection->charset;
descriptor->is_open = 0;
descriptor->chunk_size = 0;
if (descriptor->type == OCI_DTYPE_LOB || descriptor->type == OCI_DTYPE_FILE) {
/* add Lobs & Files to hash. we'll flush them at the end */
if (!connection->descriptors) {
ALLOC_HASHTABLE(connection->descriptors);
zend_hash_init(connection->descriptors, 0, NULL, php_oci_descriptor_flush_hash_dtor, 0);
connection->descriptor_count = 0;
}
descriptor->index = (connection->descriptor_count)++;
if (connection->descriptor_count == LONG_MAX) {
php_error_docref(NULL, E_WARNING, "Internal descriptor counter has reached limit");
php_oci_connection_descriptors_free(connection);
return NULL;
}
zend_hash_index_update_ptr(connection->descriptors, descriptor->index, &descriptor);
}
return descriptor;
}
static APC_HOTSPOT HashTable* my_copy_hashtable(HashTable *source, apc_context_t *ctxt) {
uint32_t idx;
HashTable *target;
apc_pool *pool = ctxt->pool;
if (ctxt->copy == APC_COPY_IN) {
target = (HashTable*) pool->palloc(pool, sizeof(HashTable));
} else ALLOC_HASHTABLE(target);
GC_REFCOUNT(target) = 1;
GC_TYPE_INFO(target) = IS_ARRAY;
zend_hash_index_update_ptr(&ctxt->copied, (uintptr_t) source, target);
target->nTableSize = source->nTableSize;
target->pDestructor = source->pDestructor;
if (source->nNumUsed == 0) {
target->u.flags = (source->u.flags & ~(HASH_FLAG_INITIALIZED|HASH_FLAG_PACKED|HASH_FLAG_PERSISTENT)) | HASH_FLAG_APPLY_PROTECTION | HASH_FLAG_STATIC_KEYS;
target->nTableMask = HT_MIN_MASK;
target->nNumUsed = 0;
target->nNumOfElements = 0;
target->nNextFreeElement = 0;
target->nInternalPointer = HT_INVALID_IDX;
HT_SET_DATA_ADDR(target, &uninitialized_bucket);
} else if (GC_FLAGS(source) & IS_ARRAY_IMMUTABLE) {
target->u.flags = (source->u.flags & ~HASH_FLAG_PERSISTENT) | HASH_FLAG_APPLY_PROTECTION;
target->nTableMask = source->nTableMask;
target->nNumUsed = source->nNumUsed;
target->nNumOfElements = source->nNumOfElements;
target->nNextFreeElement = source->nNextFreeElement;
if (ctxt->copy == APC_COPY_IN) {
HT_SET_DATA_ADDR(target, pool->palloc(pool, HT_SIZE(target)));
} else HT_SET_DATA_ADDR(target, emalloc(HT_SIZE(target)));
target->nInternalPointer = source->nInternalPointer;
memcpy(HT_GET_DATA_ADDR(target), HT_GET_DATA_ADDR(source), HT_USED_SIZE(source));
if (target->nNumOfElements > 0 &&
target->nInternalPointer == HT_INVALID_IDX) {
idx = 0;
while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
idx++;
}
target->nInternalPointer = idx;
}
} else if (source->u.flags & HASH_FLAG_PACKED) {
target->u.flags = (source->u.flags & ~HASH_FLAG_PERSISTENT) | HASH_FLAG_APPLY_PROTECTION;
target->nTableMask = source->nTableMask;
target->nNumUsed = source->nNumUsed;
target->nNumOfElements = source->nNumOfElements;
target->nNextFreeElement = source->nNextFreeElement;
if (ctxt->copy == APC_COPY_IN) {
HT_SET_DATA_ADDR(target, pool->palloc(pool, HT_SIZE(target)));
} else HT_SET_DATA_ADDR(target, emalloc(HT_SIZE(target)));
target->nInternalPointer = source->nInternalPointer;
HT_HASH_RESET_PACKED(target);
if (target->nNumUsed == target->nNumOfElements) {
apc_array_dup_packed_elements(ctxt, source, target, 0);
} else {
apc_array_dup_packed_elements(ctxt, source, target, 1);
}
if (target->nNumOfElements > 0 &&
target->nInternalPointer == HT_INVALID_IDX) {
idx = 0;
while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
idx++;
}
target->nInternalPointer = idx;
}
} else {
target->u.flags = (source->u.flags & ~HASH_FLAG_PERSISTENT) | HASH_FLAG_APPLY_PROTECTION;
target->nTableMask = source->nTableMask;
target->nNextFreeElement = source->nNextFreeElement;
target->nInternalPointer = HT_INVALID_IDX;
if (ctxt->copy == APC_COPY_IN) {
HT_SET_DATA_ADDR(target, pool->palloc(pool, HT_SIZE(target)));
} else HT_SET_DATA_ADDR(target, emalloc(HT_SIZE(target)));
HT_HASH_RESET(target);
if (target->u.flags & HASH_FLAG_STATIC_KEYS) {
if (source->nNumUsed == source->nNumOfElements) {
idx = apc_array_dup_elements(ctxt, source, target, 1, 0);
} else {
idx = apc_array_dup_elements(ctxt, source, target, 1, 1);
}
} else {
if (source->nNumUsed == source->nNumOfElements) {
idx = apc_array_dup_elements(ctxt, source, target, 0, 0);
} else {
idx = apc_array_dup_elements(ctxt, source, target, 0, 1);
}
}
target->nNumUsed = idx;
target->nNumOfElements = idx;
if (idx > 0 && target->nInternalPointer == HT_INVALID_IDX) {
target->nInternalPointer = 0;
}
}
return target;
}
