static void
texture_tower_create_texture (MetaTextureTower *tower,
int level,
int width,
int height)
{
if ((!is_power_of_two (width) || !is_power_of_two (height)) &&
meta_texture_rectangle_check (tower->textures[level - 1]))
{
tower->textures[level] =
meta_texture_rectangle_new (width, height,
/* data format */
TEXTURE_FORMAT,
/* rowstride */
width * 4,
/* data */
NULL);
}
else
{
tower->textures[level] = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_AUTO_MIPMAP,
TEXTURE_FORMAT);
}
tower->invalid[level].x1 = 0;
tower->invalid[level].y1 = 0;
tower->invalid[level].x2 = width;
tower->invalid[level].y2 = height;
}
int hash_verify(hash_t *hash)
{
hashcount_t count = 0;
hash_val_t chain;
hnode_t *hptr;
if (hash->dynamic) { /* 1 */
if (hash->lowmark >= hash->highmark)
return 0;
if (!is_power_of_two(hash->highmark))
return 0;
if (!is_power_of_two(hash->lowmark))
return 0;
}
for (chain = 0; chain < hash->nchains; chain++) { /* 2 */
for (hptr = hash->table[chain]; hptr != NULL; hptr = hptr->next) {
if ((hptr->hkey & hash->mask) != chain)
return 0;
count++;
}
}
if (count != hash->nodecount)
return 0;
return 1;
}
static void
texture_tower_create_texture (MetaTextureTower *tower,
int level,
int width,
int height)
{
if ((!is_power_of_two (width) || !is_power_of_two (height)) &&
meta_texture_rectangle_check (tower->textures[level - 1]))
{
ClutterBackend *backend = clutter_get_default_backend ();
CoglContext *context = clutter_backend_get_cogl_context (backend);
tower->textures[level] = cogl_texture_rectangle_new_with_size (context, width, height);
}
else
{
tower->textures[level] = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_AUTO_MIPMAP,
TEXTURE_FORMAT);
}
tower->invalid[level].x1 = 0;
tower->invalid[level].y1 = 0;
tower->invalid[level].x2 = width;
tower->invalid[level].y2 = height;
}
bool supports_mipmaps_for(Size size)
{
#if GLLIB_GLES
return is_power_of_two(size.x) && is_power_of_two(size.y);
#else
(void)size;
return true;
#endif
}
/*
* Extend the table: make it twice as large.
*/
static void stbl_extend(stbl_t *sym_table) {
stbl_rec_t **tmp;
stbl_rec_t *list;
uint32_t i, n, old_size, mask;
old_size = sym_table->size;
n = old_size << 1;
if (n == 0 || n >= MAX_STBL_SIZE) {
// overflow: cannot expand
out_of_memory();
}
assert(is_power_of_two(n));
// new data array
tmp = (stbl_rec_t **) safe_malloc(n * sizeof(stbl_rec_t *));
for (i=0; i<n; i++) {
tmp[i] = NULL;
}
// move the data lists to tmp
mask = n-1;
for (i=0; i<old_size; i++) {
list = sym_table->data[i];
if (list != NULL) {
stbl_restore_list(tmp, mask, list);
}
}
// clean up
safe_free(sym_table->data);
sym_table->data = tmp;
sym_table->size = n;
}
/**
*
* @brief Set the number of priority groups based on the number of exception
* priorities desired
*
* Exception priorities can be divided in priority groups, inside which there is
* no preemption. The priorities inside a group are only used to decide which
* exception will run when more than one is ready to be handled.
*
* The number of priorities has to be a power of two, from 1 to 128.
*
* @param n the number of priorities
*
* @return N/A
*/
void _ScbNumPriGroupSet(unsigned int n)
{
unsigned int set;
union __aircr reg;
__ASSERT(is_power_of_two(n) && (n <= 128),
"invalid number of priorities");
set = find_lsb_set(n);
reg.val = __scs.scb.aircr.val;
/* num pri bit set prigroup
* ---------------------------------
* 1 1 7
* 2 2 6
* 4 3 5
* 8 4 4
* 16 5 3
* 32 6 2
* 64 7 1
* 128 8 0
*/
reg.bit.prigroup = 8 - set;
reg.bit.vectkey = SCB_AIRCR_VECTKEY_EN_W;
__scs.scb.aircr.val = reg.val;
}
/*
* Initialize: empty table of size n. n must be a power of 2.
* If n = 0, the default size is used.
*/
void init_stbl(stbl_t *sym_table, uint32_t n) {
uint32_t i;
stbl_rec_t **tmp;
if (n == 0) {
n = STBL_DEFAULT_SIZE;
}
if (n >= MAX_STBL_SIZE) {
out_of_memory(); // abort if too large
}
assert(is_power_of_two(n));
tmp = (stbl_rec_t**) safe_malloc(n * sizeof(stbl_rec_t *));
for (i=0; i<n; i++) {
tmp[i] = NULL;
}
sym_table->size = n;
sym_table->nelems = 0;
sym_table->ndeleted = 0;
sym_table->bnk = NULL;
sym_table->free_idx = 0;
sym_table->free_rec = NULL;
sym_table->data = tmp;
sym_table->finalize = default_stbl_finalizer;
}
static uint64_t ivshmem_get_size(IVShmemState * s) {
uint64_t value;
char *ptr;
value = strtoull(s->sizearg, &ptr, 10);
switch (*ptr) {
case 0: case 'M': case 'm':
value <<= 20;
break;
case 'G': case 'g':
value <<= 30;
break;
default:
fprintf(stderr, "qemu: invalid ram size: %s\n", s->sizearg);
exit(1);
}
/* BARs must be a power of 2 */
if (!is_power_of_two(value)) {
fprintf(stderr, "ivshmem: size must be power of 2\n");
exit(1);
}
return value;
}
int rs_rb_init(struct rs_rb *rb, void *buffer, size_t size)
{
/*
* this initialization is absurd, but it is to silence gcc which issues
* a warning because it isn't smart enough to see that page_size is
* initialized AND used iif rb->mirror is true
*/
long page_size = 0;
if (rb == NULL)
return -EINVAL;
rb->mirror = buffer == NULL;
if (rb->mirror) {
/* augment size to the next multiple of page size */
page_size = sysconf(_SC_PAGE_SIZE);
if ((size % page_size) != 0)
size = ((size / page_size) + 1) * page_size;
}
if (!is_power_of_two(size))
return -EINVAL;
rb->base = buffer;
rb->size = size;
rb->size_mask = size - 1;
rb->read = 0;
rb->write = 0;
rb->len = 0;
if (rb->mirror)
return allocate_mirrored_buffer(rb, size, page_size);
return 0;
}
// Returns the pointer to the Enclave instance on success.
uintptr_t _ECREATE(page_info_t* pi)
{
secs_t* secs = reinterpret_cast<secs_t*>(pi->src_page);
// Enclave size must be at least 2 pages and a power of 2.
GP_ON(!is_power_of_two((size_t)secs->size));
GP_ON(secs->size < (SE_PAGE_SIZE << 1));
CEnclaveSim* ce = new CEnclaveSim(secs);
void* addr;
// `ce' is not checked against NULL, since it is not
// allocated with new(std::no_throw).
addr = se_virtual_alloc(NULL, (size_t)secs->size, MEM_COMMIT);
if (addr == NULL) {
delete ce;
return 0;
}
// Mark all the memory inaccessible.
se_virtual_protect(addr, (size_t)secs->size, SGX_PROT_NONE);
ce->get_secs()->base = addr;
CEnclaveMngr::get_instance()->add(ce);
return reinterpret_cast<uintptr_t>(ce);
}
/*
* Initialization:
* - n = initial size (must be a power of 2)
* - if n = 0, the default size is used
*/
void init_strmap(strmap_t *hmap, uint32_t n) {
strmap_rec_t *tmp;
uint32_t i;
if (n == 0) {
n = STRMAP_DEF_SIZE;
}
if (n >= STRMAP_MAX_SIZE) {
out_of_memory();
}
assert(is_power_of_two(n));
tmp = (strmap_rec_t *) safe_malloc(n * sizeof(strmap_rec_t));
for (i=0; i<n; i++) {
tmp[i].key = NULL;
}
hmap->data = tmp;
hmap->size = n;
hmap->nelems = 0;
hmap->ndeleted = 0;
hmap->resize_threshold = (uint32_t) (n * STRMAP_RESIZE_RATIO);
hmap->cleanup_threshold = (uint32_t) (n * STRMAP_CLEANUP_RATIO);
}
static hash_val_t compute_mask(hashcount_t size)
{
assert (is_power_of_two(size));
assert (size >= 2);
return size - 1;
}
void Texture::set_wrap_mode(WrapMode s, WrapMode t)
{
NAME_PAINT_FUNCTION();
// How to map WrapModes to GL.
auto translate_mode = [](WrapMode mode)
{
if (mode == WrapMode::Mirror) {
return GL_MIRRORED_REPEAT;
} else if (mode == WrapMode::Repeat) {
return GL_REPEAT;
} else {
return GL_CLAMP_TO_EDGE;
}
};
#if GLLIB_GLES
// See Section 3.8.7 Texture Completeness in OpenGl ES 2.0 spec.
if (!is_power_of_two()) {
assert(s==WrapMode::Clamp && t==WrapMode::Clamp);
}
#endif
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, translate_mode(s));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, translate_mode(t));
}
int gr_opengl_bm_make_render_target(int n, int *width, int *height, ubyte *bpp, int *mm_lvl, int flags)
{
Assert( (n >= 0) && (n < MAX_BITMAPS) );
if ( !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) || Cmdline_no_fbo ) {
return 0;
}
if ( (flags & BMP_FLAG_CUBEMAP) && !Is_Extension_Enabled(OGL_ARB_TEXTURE_CUBE_MAP) ) {
return 0;
}
if ( (flags & BMP_FLAG_CUBEMAP) && (*width != *height) ) {
MIN(*width, *height) = MAX(*width, *height);
}
// Only enforce power of two size if not supported
if (!(Is_Extension_Enabled(OGL_ARB_TEXTURE_NON_POWER_OF_TWO)))
{
Assert( is_power_of_two(*width, *height) );
}
if ( opengl_make_render_target(bm_bitmaps[n].handle, n, width, height, bpp, mm_lvl, flags) ) {
return 1;
}
return 0;
}
pa_shmasyncq *pa_shmasyncq_new(unsigned n_elements, size_t element_size, void *data, int fd[2]) {
pa_shmasyncq *l;
pa_assert(n_elements > 0);
pa_assert(is_power_of_two(n_elements));
pa_assert(element_size > 0);
pa_assert(data);
pa_assert(fd);
l = pa_xnew(pa_shmasyncq, 1);
l->data = data;
memset(data, 0, PA_SHMASYNCQ_SIZE(n_elements, element_size));
l->data->n_elements = n_elements;
l->data->element_size = element_size;
if (!(l->read_fdsem = pa_fdsem_new_shm(&d->read_fdsem_data))) {
pa_xfree(l);
return NULL;
}
fd[0] = pa_fdsem_get(l->read_fdsem);
if (!(l->write_fdsem = pa_fdsem_new(&d->write_fdsem_data, &fd[1]))) {
pa_fdsem_free(l->read_fdsem);
pa_xfree(l);
return NULL;
}
return l;
}
void emit_math1(struct brw_wm_compile *c,
GLuint function,
const struct brw_reg *dst,
GLuint mask,
const struct brw_reg *arg0)
{
struct brw_compile *p = &c->func;
struct intel_context *intel = &p->brw->intel;
int dst_chan = _mesa_ffs(mask & WRITEMASK_XYZW) - 1;
GLuint saturate = ((mask & SATURATE) ?
BRW_MATH_SATURATE_SATURATE :
BRW_MATH_SATURATE_NONE);
struct brw_reg src;
if (!(mask & WRITEMASK_XYZW))
return; /* Do not emit dead code */
assert(is_power_of_two(mask & WRITEMASK_XYZW));
if (intel->gen >= 6 && ((arg0[0].hstride == BRW_HORIZONTAL_STRIDE_0 ||
arg0[0].file != BRW_GENERAL_REGISTER_FILE) ||
arg0[0].negate || arg0[0].abs)) {
/* Gen6 math requires that source and dst horizontal stride be 1,
* and that the argument be in the GRF.
*
* The hardware ignores source modifiers (negate and abs) on math
* instructions, so we also move to a temp to set those up.
*/
src = dst[dst_chan];
brw_MOV(p, src, arg0[0]);
} else {
src = arg0[0];
}
/* Send two messages to perform all 16 operations:
*/
brw_push_insn_state(p);
brw_set_compression_control(p, BRW_COMPRESSION_NONE);
brw_math(p,
dst[dst_chan],
function,
saturate,
2,
src,
BRW_MATH_DATA_VECTOR,
BRW_MATH_PRECISION_FULL);
if (c->dispatch_width == 16) {
brw_set_compression_control(p, BRW_COMPRESSION_2NDHALF);
brw_math(p,
offset(dst[dst_chan],1),
function,
saturate,
3,
sechalf(src),
BRW_MATH_DATA_VECTOR,
BRW_MATH_PRECISION_FULL);
}
brw_pop_insn_state(p);
}
static VALUE
ffts_plan_initialize(VALUE self, VALUE rb_frames, VALUE rb_sign) {
ffts_plan_t *plan;
size_t n = RARRAY_LEN(rb_frames);
if (!is_power_of_two(n)) {
rb_raise(rb_eRuntimeError, "Frames must be a power of 2.");
return Qnil;
}
int sign_v = NUM2INT(rb_sign);
if (sign_v != -1 && sign_v != 1) {
rb_raise(rb_eRuntimeError, "Sign must be 1 or -1.");
return Qnil;
}
plan = ffts_init_1d(n, sign_v);
VALUE rb_plan = Data_Wrap_Struct(cCPlan, NULL, ffts_free, plan);
rb_funcall(self, rb_intern("n="), 1, INT2NUM(n));
rb_funcall(self, rb_intern("frames="), 1, rb_frames);
rb_funcall(self, rb_intern("sign="), 1, rb_sign);
rb_funcall(self, rb_intern("plan="), 1, rb_plan);
return self;
}
bool cePatchMeshGL20::CreatePatches(iDevice *device, unsigned numP, unsigned numQ, bool wrapP, bool wrapQ)
{
unsigned testP = _numP - 1;
unsigned testQ = _numQ - 1;
// check whether the number of vertices is at least dividable by the number
// of patches we want
if (testP % numP) return false;
if (testQ % numQ) return false;
unsigned numPerPatchP = testP / numP;
unsigned numPerPatchQ = testQ / numQ;
// check if the number of vertices per patch is of power of two
if (!is_power_of_two(numPerPatchP)) return false;
if (!is_power_of_two(numPerPatchQ)) return false;
_wrapP = wrapP;
_wrapQ = wrapQ;
_numPatchP = numP;
_numPatchQ = numQ;
_patches.clear ();
for (unsigned q=0; q<numQ; q++)
{
unsigned offsetQ = q * numPerPatchQ * _numP;
for (unsigned p=0; p<numP; p++)
{
unsigned offset = offsetQ + (p * numPerPatchP);
Patch* patch = CreatePatch(device, offset, numPerPatchP+1, numPerPatchQ+1);
_patches.push_back (patch);
}
}
for (int q=0; q<numQ; q++)
{
for (int p=0; p<numP; p++)
{
Patch* patch = GetPatch(p, q);
patch->neighbours[PN_NegP] = GetPatch(p-1, q , wrapP, wrapQ);
patch->neighbours[PN_NegQ] = GetPatch(p , q-1, wrapP, wrapQ);
patch->neighbours[PN_PosP] = GetPatch(p+1, q , wrapP, wrapQ);
patch->neighbours[PN_PosQ] = GetPatch(p , q+1, wrapP, wrapQ);
}
}
_dirty = true;
return true;
}
int main() {
int i = 1;
while( ++i < 10000000 )
{
if( is_power_of_two( i ) )
printf("%d\n",i);
}
}
/*
setup a textbox for rendering text
*/
static TextBox *do_render_text(float x, float y, char *str, TextColor color, int flags) {
TextBox *box;
if ((box = new_TextBox()) == NULL)
return NULL;
if (str != NULL && *str) {
if ((box->str = strdup(str)) == NULL) {
destroy_TextBox(box);
return NULL;
}
} else
box->str = NULL;
box->x = x;
box->y = y;
box->color = color;
box->flags = flags;
if (str != NULL && *str)
box->w = text_width_bitfont(str, box->flags);
else
box->w = FONT_W;
box->h = font_height+FONT_LINING; /* blit_text() adds black lining */
/* ensure power of two for textures */
if (!is_power_of_two(box->w))
box->w = next_power_of_two(box->w);
if (!is_power_of_two(box->h))
box->h = next_power_of_two(box->h);
if (box->w > TEXT_TILE_W)
box->w = TEXT_TILE_W;
if (box->h > TEXT_TILE_H)
box->h = TEXT_TILE_H;
mktexture_textbox(box);
return box;
}
static void hash_table_init(struct hash_table* ht, hash_fn_t hash_fn, eql_fn_t eql_fn, size_t capacity)
{
ht->size = 0;
ht->capacity = capacity;
ht->hash_fn = hash_fn;
ht->eql_fn = eql_fn;
ht->table = calloc(ht->capacity, sizeof(*ht->table));
ht->hashes = calloc(ht->capacity, sizeof(*ht->hashes));
assert(is_power_of_two(ht->capacity));
}
void TestUtilities::testIsPowerOfTwo()
{
UASSERT(is_power_of_two(0) == false);
UASSERT(is_power_of_two(1) == true);
UASSERT(is_power_of_two(2) == true);
UASSERT(is_power_of_two(3) == false);
for (int exponent = 2; exponent <= 31; ++exponent) {
UASSERT(is_power_of_two((1 << exponent) - 1) == false);
UASSERT(is_power_of_two((1 << exponent)) == true);
UASSERT(is_power_of_two((1 << exponent) + 1) == false);
}
UASSERT(is_power_of_two(U32_MAX) == false);
}
static void* stack_alloc(WasmAllocator* allocator,
size_t size,
size_t align,
const char* file,
int line) {
WasmStackAllocator* stack_allocator = (WasmStackAllocator*)allocator;
assert(is_power_of_two(align));
WasmStackAllocatorChunk* chunk = stack_allocator->last;
assert(size < SIZE_MAX - align + 1);
size_t alloc_size = size + align - 1;
void* result;
if (alloc_size >= CHUNK_MAX_AVAIL) {
chunk = allocate_chunk(stack_allocator, alloc_size, file, line);
result = align_up(chunk->current, align);
assert((void*)((intptr_t)result + size) <= chunk->end);
chunk->current = chunk->end;
/* thread this chunk before first. There's no available space, so it's not
worth considering. */
stack_allocator->first->prev = chunk;
stack_allocator->first = chunk;
} else {
assert(chunk);
chunk->current = align_up(chunk->current, align);
void* new_current = (void*)((intptr_t)chunk->current + size);
if (new_current < chunk->end) {
result = chunk->current;
chunk->current = new_current;
} else {
chunk = allocate_chunk(stack_allocator, CHUNK_MAX_AVAIL, file, line);
chunk->prev = stack_allocator->last;
stack_allocator->last = chunk;
chunk->current = align_up(chunk->current, align);
result = chunk->current;
chunk->current = (void*)((intptr_t)chunk->current + size);
assert(chunk->current <= chunk->end);
}
stack_allocator->last_allocation = result;
}
#if TRACE_ALLOCATOR
if (file) {
TRACEF("%s:%d: stack_alloc(%" PRIzd ", align=%" PRIzd ") => %p\n", file,
line, size, align, result);
}
#endif /* TRACE_ALLOCATOR */
#if WASM_STACK_ALLOCATOR_STATS
stack_allocator->alloc_count++;
stack_allocator->total_alloc_bytes += size;
#endif /* WASM_STACK_ALLOCATOR_STATS */
return result;
}
void xio_tcp_demux_init (xio_dmxinfo_t *dmxinfo, uint hashsize)
{
int i;
dmxinfo->hashsize = (hashsize) ? hashsize : XIO_TCP_DEMUX_HASHSIZE;
assert (is_power_of_two (dmxinfo->hashsize));
for (i=0; i<dmxinfo->hashsize; i++) {
LIST_INIT (&dmxinfo->hashtable[i]);
}
LIST_INIT (&dmxinfo->listenlist);
dmxinfo->numhashed = 0;
}
void veb_tree_print(struct veb *veb)
{
int i;
for (i=0; i < (1 << veb->height) - 1; i++)
{
if (is_power_of_two(i+1))
printf("\n");
printf("%04d ", node_at(veb, i+1)->key);
}
printf("\n");
}
int
console_init(console_rx_cb rx_cb)
{
struct console_tty *ct = &console_tty;
struct uart_conf uc = {
.uc_speed = MYNEWT_VAL(CONSOLE_BAUD),
.uc_databits = 8,
.uc_stopbits = 1,
.uc_parity = UART_PARITY_NONE,
.uc_flow_ctl = MYNEWT_VAL(CONSOLE_FLOW_CONTROL),
.uc_tx_char = console_tx_char,
.uc_rx_char = console_rx_char,
.uc_cb_arg = ct
};
ct->ct_rx_cb = rx_cb;
if (!ct->ct_dev) {
ct->ct_tx.cr_size = MYNEWT_VAL(CONSOLE_TX_BUF_SIZE);
ct->ct_tx.cr_buf = ct->ct_tx_buf;
ct->ct_rx.cr_size = MYNEWT_VAL(CONSOLE_RX_BUF_SIZE);
ct->ct_rx.cr_buf = ct->ct_rx_buf;
ct->ct_write_char = console_queue_char;
ct->ct_dev = (struct uart_dev *)os_dev_open(CONSOLE_UART,
OS_TIMEOUT_NEVER, &uc);
if (!ct->ct_dev) {
return -1;
}
ct->ct_echo_off = ! MYNEWT_VAL(CONSOLE_ECHO);
}
/* must be a power of 2 */
assert(is_power_of_two(MYNEWT_VAL(CONSOLE_RX_BUF_SIZE)));
#if MYNEWT_VAL(CONSOLE_HIST_ENABLE)
console_hist_init();
#endif
return 0;
}
void
console_pkg_init(void)
{
int rc;
/* Ensure this function only gets called by sysinit. */
SYSINIT_ASSERT_ACTIVE();
rc = console_init(NULL);
SYSINIT_PANIC_ASSERT(rc == 0);
}
bool reduce_quantifier(
quantifier * q,
expr * old_body,
expr * const * new_patterns,
expr * const * new_no_patterns,
expr_ref & result,
proof_ref & result_pr) {
if (q->get_kind() == lambda_k) return false;
m_sorts.reset();
expr_ref_vector bounds(m);
bool found = false;
for (unsigned i = 0; i < q->get_num_decls(); ++i) {
sort* s = q->get_decl_sort(i);
if (m_imp.is_fd(s)) {
unsigned bv_size = get_bv_size(s);
m_sorts.push_back(m_bv.mk_sort(bv_size));
unsigned nc = m_dt.get_datatype_num_constructors(s);
if (!is_power_of_two(nc) || nc == 1) {
bounds.push_back(m_bv.mk_ule(m.mk_var(q->get_num_decls()-i-1, m_sorts[i]), m_bv.mk_numeral(nc-1, bv_size)));
}
found = true;
}
else {
m_sorts.push_back(s);
}
}
if (!found) {
return false;
}
expr_ref new_body_ref(old_body, m), tmp(m);
if (!bounds.empty()) {
switch (q->get_kind()) {
case forall_k:
new_body_ref = m.mk_implies(mk_and(bounds), new_body_ref);
break;
case exists_k:
bounds.push_back(new_body_ref);
new_body_ref = mk_and(bounds);
break;
case lambda_k:
UNREACHABLE();
break;
}
}
result = m.mk_quantifier(q->get_kind(), q->get_num_decls(), m_sorts.c_ptr(), q->get_decl_names(), new_body_ref,
q->get_weight(), q->get_qid(), q->get_skid(),
q->get_num_patterns(), new_patterns,
q->get_num_no_patterns(), new_no_patterns);
result_pr = nullptr;
return true;
}
bool reduce_arg(expr* a, expr_ref& result) {
sort* s = get_sort(a);
if (!m_imp.is_fd(s)) {
return false;
}
unsigned bv_size = get_bv_size(s);
if (is_var(a)) {
result = m.mk_var(to_var(a)->get_idx(), m_bv.mk_sort(bv_size));
return true;
}
SASSERT(is_app(a));
func_decl* f = to_app(a)->get_decl();
if (m_dt.is_constructor(f)) {
unsigned idx = m_dt.get_constructor_idx(f);
result = m_bv.mk_numeral(idx, bv_size);
}
else if (is_uninterp_const(a)) {
func_decl* f_fresh;
if (m_imp.m_enum2bv.find(f, f_fresh)) {
result = m.mk_const(f_fresh);
return true;
}
// create a fresh variable, add bounds constraints for it.
unsigned nc = m_dt.get_datatype_num_constructors(s);
result = m.mk_fresh_const(f->get_name().str().c_str(), m_bv.mk_sort(bv_size));
f_fresh = to_app(result)->get_decl();
if (!is_power_of_two(nc) || nc == 1) {
m_imp.m_bounds.push_back(m_bv.mk_ule(result, m_bv.mk_numeral(nc-1, bv_size)));
}
expr_ref f_def(m);
ptr_vector<func_decl> const& cs = *m_dt.get_datatype_constructors(s);
f_def = m.mk_const(cs[nc-1]);
for (unsigned i = nc - 1; i > 0; ) {
--i;
f_def = m.mk_ite(m.mk_eq(result, m_bv.mk_numeral(i,bv_size)), m.mk_const(cs[i]), f_def);
}
m_imp.m_enum2def.insert(f, f_def);
m_imp.m_enum2bv.insert(f, f_fresh);
m_imp.m_bv2enum.insert(f_fresh, f);
m_imp.m_enum_consts.push_back(f);
m_imp.m_enum_bvs.push_back(f_fresh);
m_imp.m_enum_defs.push_back(f_def);
}
else {
throw_non_fd(a);
}
++m_imp.m_num_translated;
return true;
}
// Get closest extrusion mesh for given image dimensions
// Caller must drop the returned pointer
scene::IMesh* create(core::dimension2d<u32> dim)
{
// handle non-power of two textures inefficiently without cache
if (!is_power_of_two(dim.Width) || !is_power_of_two(dim.Height)) {
return createExtrusionMesh(dim.Width, dim.Height);
}
int maxdim = MYMAX(dim.Width, dim.Height);
std::map<int, scene::IMesh*>::iterator
it = m_extrusion_meshes.lower_bound(maxdim);
if (it == m_extrusion_meshes.end()) {
// no viable resolution found; use largest one
it = m_extrusion_meshes.find(MAX_EXTRUSION_MESH_RESOLUTION);
sanity_check(it != m_extrusion_meshes.end());
}
scene::IMesh *mesh = it->second;
mesh->grab();
return mesh;
}
void kat_init(kat_matrix_t **kat, int width, int height, int nnz, int sm_size) {
/*
* XXX: be strict here. It's for testing purposes and we want to avoid
* edge cases.
*/
assert(width == height);
assert(is_power_of_two(width));
assert(is_power_of_two(sm_size));
assert(is_power_of_two(KAT_N));
*kat = calloc(1, sizeof(kat_matrix_t));
assert(*kat != NULL);
(*kat)->_.object_size += sizeof(kat_matrix_t);
(*kat)->_.type = KAT;
(*kat)->_.f = kat_vmt;
(*kat)->_.w = width;
(*kat)->_.h = height;
(*kat)->sm_size = sm_size;
(*kat)->_.nnz = nnz;
(*kat)->root = NULL;
/*
* This is not needed.
*/
// (*kat)->height =
// ceil(
// (log((width * height) / (sm_size * sm_size))
// / (double) log(KAT_K)));
// printf("_kat init h=%d w=%d height=%d\n", width, height, (*kat)->height);
// not really
// assert(width < sm_size * KAT_N);
// _s_debugf(KAT_DEBUG,
// "initializing kat_matrix_t with: n=%d, nnz=%d, sm_size=%d, height=%d\n",
// width, nnz, sm_size, (*kat)->height);
}
