/* Search for an element in a bucket */
static ght_hash_entry_t *search_in_bucket(ght_hash_table_t *p_ht, ght_uint32_t l_bucket,
ght_hash_key_t *p_key, unsigned char i_heuristics)
{
ght_hash_entry_t *p_e;
for (p_e = p_ht->pp_entries[l_bucket];
p_e;
p_e = p_e->p_next)
{
if ((p_e->key.i_size == p_key->i_size) &&
(memcmp(p_e->key.p_key, p_key->p_key, p_e->key.i_size) == 0))
{
/* Matching entry found - Apply heuristics, if any */
switch (i_heuristics)
{
case GHT_HEURISTICS_MOVE_TO_FRONT:
move_to_front(p_ht, l_bucket, p_e);
break;
case GHT_HEURISTICS_TRANSPOSE:
transpose(p_ht, l_bucket, p_e);
break;
default:
break;
}
return p_e;
}
}
return NULL;
}
int get(int key) {
if(m.find(key)==m.end())
return -1;
node *current=m[key];
current->prev->next=current->next;
current->next->prev=current->prev;
move_to_front(current);
return m[key]->value;
}
/* Order the list of input files so each next file applies to the previous: */
static bool order_input(struct File **files)
{
struct File *cur, *succ;
/* Determine first file */
cur = find_first(*files);
if (cur == NULL) return false;
*files = move_to_front(*files, cur);
/* Order remaining files */
while (cur->next)
{
succ = find_digest(cur->next, cur->diff.digest2);
if (succ == NULL) return false;
cur->next = move_to_front(cur->next, succ);
cur = cur->next;
}
return true;
}
int my_mlx_hook_loop(t_env *e)
{
if (e->mv->left == 1)
e = move_to_left(e);
if (e->mv->right == 1)
e = move_to_right(e);
if (e->mv->front == 1)
e = move_to_front(e);
if (e->mv->back == 1)
e = move_to_back(e);
my_expose_hook(e);
return (0);
}
void Miniball::mtf_mb (It i)
{
support_end = L.begin();
if ((B.size())==BSIZE) return;
for (It k=L.begin(); k!=i;) {
It j=k++;
if (B.excess(*j) > 0) {
if (B.push(*j)) {
mtf_mb (j);
B.pop();
move_to_front(j);
}
}
}
}
// Wake up all processes sleeping on chan.
// The ptable lock must be held.
static void
wakeup1(void *chan)
{
struct proc *p;
int slot_no = -1;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {
++slot_no;
if(p->state == SLEEPING && p->chan == chan) {
p->state = RUNNABLE;
//cprintf("pid: %d wakes up.\n", p->pid);
//dump_queues();
// move to the front of the queue.
int pri = proc_stat.priority[slot_no];
switch(pri) {
case 0:
//cprintf("move to 0 queue front.\n");
move_to_front(&q0_head, &q0_tail, p);
break;
case 1:
//cprintf("move to 1 queue front.\n");
move_to_front(&q1_head, &q1_tail, p);
break;
case 2:
//cprintf("move to 2 queue front.\n");
move_to_front(&q2_head, &q2_tail, p);
break;
case 3:
//cprintf("move to 3 queue front.\n");
move_to_front(&q3_head, &q3_tail, p);
break;
default:
cprintf("Wrong pri again.\n");
}
}
}
}
void set(int key, int value) {
if(get(key)!=-1) {
m[key]->value=value;
return;
}
if(m.size()==capacity) {
node *temp=tail->prev;
m.erase(temp->key);
temp->prev->next=tail;
tail->prev=temp->prev;
delete temp;
}
node *newnode=new node(key,value);
m[key]=newnode;
move_to_front(newnode);
}
void Miniball::pivot_mb (It i)
{
It t = ++L.begin();
mtf_mb (t);
double max_e, old_sqr_r;
do {
It pivot;
max_e = max_excess (t, i, pivot);
if (max_e > 0) {
t = support_end;
if (t==pivot) ++t;
old_sqr_r = B.squared_radius();
B.push (*pivot);
mtf_mb (support_end);
B.pop();
move_to_front (pivot);
}
} while ((max_e > 0) && (B.squared_radius() > old_sqr_r));
}
/* Returns a pointer to a value eq to v in A, and moves it to the front */
void *array_find_MTF(bool (*eq)(void *v, void *d), array_t *A, void *v) {
if (!A)
return NULL;
int i = 0;
for (i = 0; i < A->size; i++) {
if (eq(v, A->vals[i]))
break;
}
/* Could not find v in A */
if (i == A->size) {
return NULL;
} else if (i > 0) {
move_to_front(A, i);
}
return A->vals[0];
}
fz_glyph *
fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix *ctm, fz_colorspace *model, const fz_irect *scissor, int alpha)
{
fz_glyph_cache *cache;
fz_glyph_key key;
fz_matrix subpix_ctm;
fz_irect subpix_scissor;
float size;
fz_glyph *val;
int do_cache, locked, caching;
fz_glyph_cache_entry *entry;
unsigned hash;
fz_var(locked);
fz_var(caching);
fz_var(val);
memset(&key, 0, sizeof key);
size = fz_subpixel_adjust(ctx, ctm, &subpix_ctm, &key.e, &key.f);
if (size <= MAX_GLYPH_SIZE)
{
scissor = &fz_infinite_irect;
do_cache = 1;
}
else
{
if (font->ft_face)
return NULL;
subpix_scissor.x0 = scissor->x0 - floorf(ctm->e);
subpix_scissor.y0 = scissor->y0 - floorf(ctm->f);
subpix_scissor.x1 = scissor->x1 - floorf(ctm->e);
subpix_scissor.y1 = scissor->y1 - floorf(ctm->f);
scissor = &subpix_scissor;
do_cache = 0;
}
cache = ctx->glyph_cache;
key.font = font;
key.gid = gid;
key.a = subpix_ctm.a * 65536;
key.b = subpix_ctm.b * 65536;
key.c = subpix_ctm.c * 65536;
key.d = subpix_ctm.d * 65536;
key.aa = fz_text_aa_level(ctx);
hash = do_hash((unsigned char *)&key, sizeof(key)) % GLYPH_HASH_LEN;
fz_lock(ctx, FZ_LOCK_GLYPHCACHE);
entry = cache->entry[hash];
while (entry)
{
if (memcmp(&entry->key, &key, sizeof(key)) == 0)
{
move_to_front(cache, entry);
val = fz_keep_glyph(ctx, entry->val);
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
return val;
}
entry = entry->bucket_next;
}
locked = 1;
caching = 0;
val = NULL;
fz_try(ctx)
{
if (font->ft_face)
{
val = fz_render_ft_glyph(ctx, font, gid, &subpix_ctm, key.aa);
}
else if (font->t3procs)
{
/* We drop the glyphcache here, and execute the t3
* glyph code. The danger here is that some other
* thread will come along, and want the same glyph
* too. If it does, we may both end up rendering
* pixmaps. We cope with this later on, by ensuring
* that only one gets inserted into the cache. If
* we insert ours to find one already there, we
* abandon ours, and use the one there already.
*/
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
locked = 0;
val = fz_render_t3_glyph(ctx, font, gid, &subpix_ctm, model, scissor);
fz_lock(ctx, FZ_LOCK_GLYPHCACHE);
locked = 1;
}
else
{
fz_warn(ctx, "assert: uninitialized font structure");
}
if (val && do_cache)
{
if (val->w < MAX_GLYPH_SIZE && val->h < MAX_GLYPH_SIZE)
{
/* If we throw an exception whilst caching,
* just ignore the exception and carry on. */
caching = 1;
if (!font->ft_face)
{
/* We had to unlock. Someone else might
* have rendered in the meantime */
entry = cache->entry[hash];
while (entry)
{
if (memcmp(&entry->key, &key, sizeof(key)) == 0)
{
fz_drop_glyph(ctx, val);
move_to_front(cache, entry);
val = fz_keep_glyph(ctx, entry->val);
goto unlock_and_return_val;
}
entry = entry->bucket_next;
}
}
entry = fz_malloc_struct(ctx, fz_glyph_cache_entry);
entry->key = key;
entry->hash = hash;
entry->bucket_next = cache->entry[hash];
if (entry->bucket_next)
entry->bucket_next->bucket_prev = entry;
cache->entry[hash] = entry;
entry->val = fz_keep_glyph(ctx, val);
fz_keep_font(ctx, key.font);
entry->lru_next = cache->lru_head;
if (entry->lru_next)
entry->lru_next->lru_prev = entry;
else
cache->lru_tail = entry;
cache->lru_head = entry;
cache->total += fz_glyph_size(ctx, val);
while (cache->total > MAX_CACHE_SIZE)
{
#ifndef NDEBUG
cache->num_evictions++;
cache->evicted += fz_glyph_size(ctx, cache->lru_tail->val);
#endif
drop_glyph_cache_entry(ctx, cache->lru_tail);
}
}
}
unlock_and_return_val:
{
}
}
fz_always(ctx)
{
if (locked)
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
}
fz_catch(ctx)
{
if (caching)
fz_warn(ctx, "cannot encache glyph; continuing");
else
fz_rethrow(ctx);
}
return val;
}
/* Add v to A at the start of the array */
void array_insert_MTF(array_t **A, void *v) {
array_insert(A, v);
move_to_front((*A), (*A)->size - 1);
}
error_t cache_get(cache_t* c, cache_id_t id, void** ret_data)
{
cache_list_entry_t* le;
void* data;
error_t err;
hm_entry_t entry;
long idx;
int data_number;
entry.key = id;
entry.value = NULL;
// first, check the mapping.
if( hashmap_retrieve(&c->mapping, &entry) ) {
idx = (long) entry.value;
if( 0 == c->mapping.cmp(id, c->list[idx].id ) ) {
// it's a valid mapping.
// move it to the front of the list.
//printf("Cache before mtf; id=%p\n", c->list[idx].id);
move_to_front(c, idx, c->list[idx].id);
data_number = idx;
data = ((unsigned char*) c->data) + data_number * c->data_size;
*ret_data = data;
return ERR_NOERR;
}
}
// if it's not an valid mapping, we'll evict the data
// item pointed to by the last list element, then
// load the new item, and finally move it to the front
// of the list.
// find a home for the new data item.
// does the tail item in the list already have a data item?
le = & c->list[c->tail];
data_number = c->tail;
data = ((unsigned char*) c->data) + data_number * c->data_size;
if( le->id && c->evict ) {
c->evict(le->id, c->data_size, data, c->context);
}
// load the new item.
//printf("Cache before fault; id=%p\n", id);
err = c->fault(id, c->data_size, data, c->context);
if( err ) {
if( le->id ) {
// remove the old entry
entry.key = le->id;
entry.value = NULL;
hashmap_delete(&c->mapping, &entry);
c->free_id(le->id);
le->id = NULL;
}
return err;
}
//printf("Cache after fault; id=%p\n", id);
// move the tail element to the front of the list.
move_to_front(c, c->tail, id);
*ret_data = data;
return ERR_NOERR;
}
int wedge(FLOAT halves[][2],
int m,
int next[],
int prev[],
FLOAT cw_vec[],
FLOAT ccw_vec[],
int *degen)
{
int i;
FLOAT d_cw, d_ccw;
int offensive;
*degen = 0;
for(i=0;i!=m;i = next[i]) {
if(!unit2(halves[i],ccw_vec,EPS)) {
/* clock-wise */
cw_vec[0] = ccw_vec[1];
cw_vec[1] = -ccw_vec[0];
/* counter-clockwise */
ccw_vec[0] = -cw_vec[0];
ccw_vec[1] = -cw_vec[1];
break;
}
}
if(i==m) return(UNBOUNDED);
i = 0;
while(i!=m) {
offensive = 0;
d_cw = dot2(cw_vec,halves[i]);
d_ccw = dot2(ccw_vec,halves[i]);
if(d_ccw >= 2*EPS) {
if(d_cw <= -2*EPS) {
cw_vec[0] = halves[i][1];
cw_vec[1] = -halves[i][0];
(void)unit2(cw_vec,cw_vec,EPS);
offensive = 1;
}
} else if(d_cw >= 2*EPS) {
if(d_ccw <= -2*EPS) {
ccw_vec[0] = -halves[i][1];
ccw_vec[1] = halves[i][0];
(void)unit2(ccw_vec,ccw_vec,EPS);
offensive = 1;
}
} else if(d_ccw <= -2*EPS && d_cw <= -2*EPS) {
return(INFEASIBLE);
} else if((d_cw <= -2*EPS) ||
(d_ccw <= -2*EPS) ||
(cross2(cw_vec,halves[i]) < 0.0)) {
/* degenerate */
if(d_cw <= -2*EPS) {
(void)unit2(ccw_vec,cw_vec,EPS);
} else if(d_ccw <= -2*EPS) {
(void)unit2(cw_vec,ccw_vec,EPS);
}
*degen = 1;
offensive = 1;
}
/* place this offensive plane in second place */
if(offensive) i = move_to_front(i,next,prev);
i = next[i];
if(*degen) break;
}
if(*degen) {
while(i!=m) {
d_cw = dot2(cw_vec,halves[i]);
d_ccw = dot2(ccw_vec,halves[i]);
if(d_cw < -2*EPS) {
if(d_ccw < -2*EPS) {
return(INFEASIBLE);
} else {
cw_vec[0] = ccw_vec[0];
cw_vec[1] = ccw_vec[1];
}
} else if(d_ccw < -2*EPS) {
ccw_vec[0] = cw_vec[0];
ccw_vec[1] = cw_vec[1];
}
i = next[i];
}
}
return(MINIMUM);
}
/*
Render a glyph and return a bitmap.
If the glyph is too large to fit the cache we have two choices:
1) Return NULL so the caller can draw the glyph using an outline.
Only supported for freetype fonts.
2) Render a clipped glyph by using the scissor rectangle.
Only supported for type 3 fonts.
This must not be inserted into the cache.
*/
fz_pixmap *
fz_render_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *ctm, fz_colorspace *model, fz_irect scissor)
{
fz_glyph_cache *cache;
fz_glyph_key key;
fz_pixmap *val;
float size = fz_matrix_expansion(ctm);
int do_cache, locked, caching;
fz_matrix local_ctm = *ctm;
fz_glyph_cache_entry *entry;
unsigned hash;
fz_var(locked);
fz_var(caching);
if (size <= MAX_GLYPH_SIZE)
{
scissor = fz_infinite_irect;
do_cache = 1;
}
else
{
/* SumatraPDF: don't break clipping by larger glyphs */
if (font->ft_face && size > 3000)
return NULL;
do_cache = 0;
}
cache = ctx->glyph_cache;
memset(&key, 0, sizeof key);
key.font = font;
key.gid = gid;
key.a = local_ctm.a * 65536;
key.b = local_ctm.b * 65536;
key.c = local_ctm.c * 65536;
key.d = local_ctm.d * 65536;
key.e = (local_ctm.e - floorf(local_ctm.e)) * 256;
key.f = (local_ctm.f - floorf(local_ctm.f)) * 256;
key.aa = fz_aa_level(ctx);
local_ctm.e = floorf(local_ctm.e) + key.e / 256.0f;
local_ctm.f = floorf(local_ctm.f) + key.f / 256.0f;
fz_lock(ctx, FZ_LOCK_GLYPHCACHE);
hash = do_hash((unsigned char *)&key, sizeof(key)) % GLYPH_HASH_LEN;
entry = cache->entry[hash];
while (entry)
{
if (memcmp(&entry->key, &key, sizeof(key)) == 0)
{
move_to_front(cache, entry);
val = fz_keep_pixmap(ctx, entry->val);
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
return val;
}
entry = entry->bucket_next;
}
locked = 1;
caching = 0;
fz_try(ctx)
{
if (font->ft_face)
{
val = fz_render_ft_glyph(ctx, font, gid, &local_ctm, key.aa);
}
else if (font->t3procs)
{
/* We drop the glyphcache here, and execute the t3
* glyph code. The danger here is that some other
* thread will come along, and want the same glyph
* too. If it does, we may both end up rendering
* pixmaps. We cope with this later on, by ensuring
* that only one gets inserted into the cache. If
* we insert ours to find one already there, we
* abandon ours, and use the one there already.
*/
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
locked = 0;
val = fz_render_t3_glyph(ctx, font, gid, &local_ctm, model, scissor);
fz_lock(ctx, FZ_LOCK_GLYPHCACHE);
locked = 1;
}
else
{
fz_warn(ctx, "assert: uninitialized font structure");
val = NULL;
}
if (val && do_cache)
{
if (val->w < MAX_GLYPH_SIZE && val->h < MAX_GLYPH_SIZE)
{
/* If we throw an exception whilst caching,
* just ignore the exception and carry on. */
caching = 1;
if (!font->ft_face)
{
/* We had to unlock. Someone else might
* have rendered in the meantime */
entry = cache->entry[hash];
while (entry)
{
if (memcmp(&entry->key, &key, sizeof(key)) == 0)
{
fz_drop_pixmap(ctx, val);
move_to_front(cache, entry);
val = fz_keep_pixmap(ctx, entry->val);
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
return val;
}
entry = entry->bucket_next;
}
}
entry = fz_malloc_struct(ctx, fz_glyph_cache_entry);
entry->key = key;
entry->hash = hash;
entry->bucket_next = cache->entry[hash];
if (entry->bucket_next)
entry->bucket_next->bucket_prev = entry;
cache->entry[hash] = entry;
entry->val = fz_keep_pixmap(ctx, val);
fz_keep_font(ctx, key.font);
entry->lru_next = cache->lru_head;
if (entry->lru_next)
entry->lru_next->lru_prev = entry;
else
cache->lru_tail = entry;
cache->lru_head = entry;
cache->total += val->w * val->h;
while (cache->total > MAX_CACHE_SIZE)
{
drop_glyph_cache_entry(ctx, cache->lru_tail);
}
}
}
}
fz_always(ctx)
{
if (locked)
fz_unlock(ctx, FZ_LOCK_GLYPHCACHE);
}
fz_catch(ctx)
{
if (caching)
fz_warn(ctx, "cannot encache glyph; continuing");
else
fz_rethrow(ctx);
}
return val;
}
