void
trickle_down(struct heap* h, int index) {
assert(h != NULL);
assert(index >= 0);
ASSERT_HEAP(h);
struct array* vals = h->vals;
int j;
unsigned int r, l;
void* t;
while (index >= 0) {
j = -1;
r = RIGHT(index);
if (r < h->vals->num &&
h->comparator(array_get(vals, r), array_get(vals, index))) {
l = LEFT(index);
if (h->comparator(array_get(vals, l), array_get(vals, r)))
j = l;
else
j = r;
} else {
l = LEFT(index);
if (l < h->vals->num &&
h->comparator(array_get(vals, l), array_get(vals, index)))
j = l;
}
if (j >= 0) {
/* SWAP */
t = array_get(vals, j);
array_set(vals, j, array_get(vals, index));
array_set(vals, index, t);
}
index = j;
}
}
persistent_array_map_t* map_assoc(persistent_array_map_t* map, map_key_t* key, map_value_t* value) {
int key_index = map_index_of_key(map, key);
if (key_index > -1) { // key exists
map_value_t* existing_value = array_get(map->arr, key_index + 1);
if (existing_value->equals(existing_value, value)) {
return map; // key exists and value is the same, do nothing
} else {
persistent_array_map_t* new_map = malloc(sizeof(persistent_array_map_t));
array_t* old_arr = map->arr;
array_t* new_arr = make_array(old_arr->size);
array_copy(old_arr, 0, new_arr, 0, old_arr->size);
new_map->arr = new_arr;
array_set(new_arr, key_index, (void*)key);
array_set(new_arr, key_index + 1, (void*)value);
return new_map;
}
} else {
persistent_array_map_t* new_map = malloc(sizeof(persistent_array_map_t));
array_t* old_arr = map->arr;
array_t* new_arr = make_array(old_arr->size + 2);
array_copy(old_arr, 0, new_arr, 2, old_arr->size);
new_map->arr = new_arr;
array_set(new_arr, 0, (void*)key);
array_set(new_arr, 1, (void*)value);
return new_map;
}
}
int
sys_close(int fd){
struct file* f;
struct lock* rwlock;
//fd 0,1,2 reserved for console, cannot close.
if(fd > 127 || fd < 3) {
return EBADF;
}
f = array_get(curproc->filetable, fd);
if(f == NULL) {
return EBADF;
}
rwlock = f->readwritelock;
lock_acquire(rwlock);
//kprintf("CLOSED FD %d \n", fd);
//kprintf("LOCK NAME %d: %s ACQUIRED! \n", fd, rwlock->lk_name);
KASSERT(f->fvnode != NULL);
array_set(curproc->filetable, fd, NULL);
lock_release(rwlock);
//kprintf("LOCK NAME %d: %s RELEASED! \n", fd, rwlock->lk_name);
//cleanupfile closes the vnode, destroys the lock, frees everything else
cleanupfile(f);
return 0;
}
// Run backwards through an array chain doing array_set operations
// to produce the array type that incorporates the effects of any
// intermediate defining dims.
Type currentChainType(MIS& env, Type val) {
auto it = env.arrayChain.rbegin();
for (; it != env.arrayChain.rend(); ++it) {
val = array_set(it->first, it->second, val);
}
return val;
}
static void
array_set_numeric(awk_array_t array, const char *sub, double num)
{
awk_value_t tmp;
array_set(array, sub, make_number(num, & tmp));
}
uint8_t _bfs_cb(bfs_state_t *state, void *context) {
uint64_t i;
uint32_t ni;
cstack_t *st;
array_t level;
st = (cstack_t *)context;
if (array_create(&level, sizeof(uint32_t), state->thislevel.size))
goto fail;
for (i = 0; i < state->thislevel.size; i++) {
array_get(&(state->thislevel), i, &ni);
array_set(&level, i, &ni);
}
stack_push(st, &level);
return 0;
fail:
return 1;
}
void test_array_set(void) {
void *test_data = malloc(TEST_STR_SIZE);
memset(test_data, 1, TEST_STR_SIZE);
test_ptr = test_data;
array_set(&test_array, 0, test_data);
CU_ASSERT(test_array.filled == 1);
}
uint8_t _mk_id_map(nlbl_map_t *map, uint16_t inidx) {
uint64_t i;
uint32_t navgnodes;
uint32_t ninnodes;
uint32_t avgnodeid;
int64_t innodeid;
array_t *idmap;
array_t *nodeids;
idmap = array_getd(&(map->idmap), inidx);
ninnodes = *(uint32_t *)array_getd(&(map->sizes), inidx);
navgnodes = map->labels.size;
if (array_create(idmap, sizeof(uint32_t), ninnodes)) goto fail;
for (i = 0; i < navgnodes; i++) {
nodeids = array_getd(&(map->nodeids), i);
innodeid = *(int64_t *)array_getd(nodeids, inidx);
if (innodeid == -1) continue;
avgnodeid = i;
array_set(idmap, innodeid, &avgnodeid);
}
return 0;
fail:
return 1;
}
int lang_init() {
// Get filename
const char *filename = pm_get_resource_path(DAT_ENGLISH);
// Load up language file
language = malloc(sizeof(sd_language));
if(sd_language_create(language) != SD_SUCCESS) {
goto error_0;
}
if(sd_language_load(language, filename)) {
PERROR("Unable to load language file '%s'!", filename);
goto error_1;
}
// Load language strings
array_create(&language_strings);
for(int i = 0; i < language->count; i++) {
array_set(&language_strings, i, language->strings[i].data);
}
INFO("Loaded language file '%s'.", filename);
return 0;
error_1:
sd_language_free(language);
error_0:
free(language);
return 1;
}
static void list_put(struct context *context, enum Opcode op, bool really)
{
DEBUGPRINT("PUT\n");
if (!context->runtime)
return;
struct variable* recipient = variable_pop(context);
struct variable* key = variable_pop(context);
struct variable *value = get_value(context, op);
if (!really && custom_method(context, RESERVED_SET, recipient, key, value))
return;
switch (key->type) {
case VAR_INT:
switch (recipient->type) {
case VAR_LST:
array_set(recipient->list, key->integer, value);
break;
case VAR_STR:
case VAR_BYT:
byte_array_set(recipient->str, key->integer, value->integer);
break;
default:
vm_exit_message(context, "indexing non-indexable");
} break;
case VAR_STR:
variable_map_insert(recipient, key->str, value);
break;
default:
vm_exit_message(context, "bad index type");
break;
}
}
void array_set_ptr(array_t* array, uint32_t idx, heapptr_t ptr)
{
assert (ptr != NULL);
value_t val_pair;
val_pair.word.heapptr = ptr;
val_pair.tag = get_tag(ptr);
array_set(array, idx, val_pair);
}
uint8_t _update_nlbl_map(
graph_t *g, uint16_t ninputs, uint16_t inidx, nlbl_map_t *map) {
graph_label_t *lbl;
int64_t i;
int64_t tmp;
uint32_t j;
uint32_t lblidx;
uint32_t nnodes;
array_t nodeids;
array_t *pnodeids;
tmp = -1;
nnodes = graph_num_nodes(g);
array_set(&(map->sizes), inidx, &nnodes);
for (i = 0; i < nnodes; i++) {
lbl = graph_get_nodelabel(g, i);
switch (array_insert_sorted(&(map->labels), lbl, 1, &lblidx)) {
case 0:
if (array_create(&nodeids, sizeof(int64_t), ninputs)) goto fail;
for (j = 0; j < ninputs; j++) array_set(&nodeids, j, &tmp);
if (array_insert(&(map->nodeids), lblidx, &nodeids)) goto fail;
break;
case 1:
break;
default: goto fail;
}
pnodeids = array_getd(&(map->nodeids), lblidx);
array_set(pnodeids, inidx, &i);
}
return 0;
fail:
return 1;
}
VALUE array_index_set(const CallFrame* here, VALUE self, VALUE it) {
ObjectPtr<Array> array = self;
if (array == NULL) return NULL;
if (type_of(it) != IntegerType) {
throw_exception_with_description("Array#set called with a non-integer index %@.", value_inspect(it));
}
Value val = here->args->size() > 1 ? (*here->args)[1] : Value(SN_NIL);
return array_set(array, value_to_integer(it), val);
}
int main() {
array_t* arr = array_new();
char* s = "a";
array_set(arr, 0, s);
assert(array_get(arr, 0) == s);
assert(array_get(arr, 10) == NULL);
assert(arr->len == 1);
array_set(arr, 10, s);
assert(array_get(arr, 10) == s);
assert(array_get(arr, 0) == s);
assert(arr->len == 2);
array_free(arr);
return 0;
}
int test(struct IridiumContext * context) {
struct array * ary = array_new();
struct array * ary2 = array_new();
struct array * ary3 = array_new();
ary = array_new();
ary2 = array_new();
array_set(ary, 0, 5);
array_set(ary2, 1, 6);
ary3 = array_merge(ary, ary2);
assertEqual(array_get(ary3, 0), 5);
assertEqual(array_get(ary3, 1), NULL);
assertEqual(array_get(ary3, 2), 6);
assertEqual(array_get(ary3, 3), NULL);
return 0;
}
void
bubble_up(struct heap* h, int index) {
assert(h != NULL);
assert(index >= 0);
ASSERT_HEAP(h);
struct array* vals = h->vals;
int p = PARENT(index);
void* t;
while (index > 0 &&
h->comparator(array_get(vals, index), array_get(vals, p))) {
/* SWAP */
t = array_get(vals, index);
array_set(vals, index, array_get(vals, p));
array_set(vals, p, t);
index = p;
p = PARENT(index);
}
}
void ignored_object_add(HANDLE object_handle)
{
uintptr_t index = (uintptr_t) object_handle / 4;
// The value doesn't matter - it just has to be non-null.
if(array_set(&g_ignored_handles, index, &ignored_object_add) < 0) {
pipe("CRITICAL:Error adding ignored object handle!");
}
}
void *array_remove(t_array *array, unsigned int index)
{
void *tmp;
ft_assert(array->size > 0);
tmp = array_get(array, index);
array->size -= 1;
array_set(array, index, array_get(array, array->size));
return (tmp);
}
void sprite_remove_child(struct sprite* self, struct sprite* child) {
// here we should release the memory??? yes.
if (child) {
sprite_free(child);
// we only remove the child, but we don't move the array
// TODO: move the array after set the element to NULL :)
array_set(self->children, child->child_index, NULL);
}
}
/// Inserts an item at the given index into the array. If \a item is 0, the
/// location in the array remains uninitialized and may be populated by
/// different means.
/// \return Returns a pointer to the location in the array.
void*
array_insert(array_t *self, unsigned index, const void *item) {
assert(self);
assert(index <= self->size);
array_grow(self, 1);
if (index < self->size)
array_move_tail(self, index, index+1);
self->size++;
if (item)
array_set(self, index, item);
return self->items + index*self->item_size;
}
int main(void)
{
{
array_t *ar = array_create(sizeof(char));
char data[] = "Hello Array!\n";
char buff[] = " ";
int num = strlen(data);
int i=0;
for (; i < num; ++i) {
array_set(ar, i, &data[i]);
}
for (i=0; i < num; ++i) {
buff[i] = *((char*)array_get(ar, i));
}
printf(buff);
}
{
array_t *ar = array_create(sizeof(char));
char data[] = "Hello Array!\n";
int num = strlen(data);
int i=0;
for (; i < num; ++i) {
array_set(ar, i, &data[i]);
}
char *d = NULL;
array_iterate(d, ar) {
printf("%c", *d);
}
array_iterate(d, ar) {
printf("%c", *d);
}
uint deps_add_evr(struct deps *deps, const char *name, int flags, uint epoch,
const char *version, const char *release) {
uint i, iter = 0, hash, size = array_get_size(&deps->names), ver, rel, nam;
nam = strings_add(deps->strings, name);
ver = strings_add(deps->strings, version != NULL ? version : "");
rel = strings_add(deps->strings, release != NULL ? release : "");
if (hashtable_resize(&deps->hashtable)) {
for (i = 0; i < size; i++) {
hash = dephash(array_get(&deps->names, i));
hashtable_add(&deps->hashtable, i, hash);
}
}
hash = dephash(nam);
while ((i = hashtable_find(&deps->hashtable, hash, &iter)) != -1)
if (array_get(&deps->names, i) == nam &&
array_get(&deps->epochs, i) == epoch &&
array_get(&deps->vers, i) == ver &&
array_get(&deps->rels, i) == rel &&
array_get(&deps->flags, i) == flags)
break;
if (i != -1)
/* already stored */
return i;
i = size;
array_set(&deps->names, i, nam);
array_set(&deps->epochs, i, epoch);
array_set(&deps->vers, i, ver);
array_set(&deps->rels, i, rel);
array_set(&deps->flags, i, flags);
hashtable_add_dir(&deps->hashtable, i, hash, iter);
return i;
}
void*
heap_pop(struct heap* h) {
assert(h != NULL);
ASSERT_HEAP(h);
if (h->vals->num == 0)
return NULL;
void* top = array_get(h->vals, 0);
void* last = array_get(h->vals, h->vals->num - 1);
array_set(h->vals, 0, last);
--h->vals->num;
trickle_down(h, 0);
/* TODO: array does not yet support shrinking */
return top;
}
/*-----------------------------------------------------------------------------
* array_append :
* push an element onto the end of a one-dimensional array
*----------------------------------------------------------------------------
*/
Datum
array_append(PG_FUNCTION_ARGS)
{
ArrayType *v;
Datum newelem;
bool isNull;
ArrayType *result;
int *dimv,
*lb;
int indx;
ArrayMetaState *my_extra;
v = fetch_array_arg_replace_nulls(fcinfo, 0);
isNull = PG_ARGISNULL(1);
if (isNull)
newelem = (Datum) 0;
else
newelem = PG_GETARG_DATUM(1);
if (ARR_NDIM(v) == 1)
{
/* append newelem */
int ub;
lb = ARR_LBOUND(v);
dimv = ARR_DIMS(v);
ub = dimv[0] + lb[0] - 1;
indx = ub + 1;
/* overflow? */
if (indx < ub)
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("integer out of range")));
}
else if (ARR_NDIM(v) == 0)
indx = 1;
else
ereport(ERROR,
(errcode(ERRCODE_DATA_EXCEPTION),
errmsg("argument must be empty or one-dimensional array")));
/* Perform element insertion */
my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
result = array_set(v, 1, &indx, newelem, isNull,
-1, my_extra->typlen, my_extra->typbyval, my_extra->typalign);
PG_RETURN_ARRAYTYPE_P(result);
}
int removeDescriptor(int index, struct fdManager * manager){
struct filedescriptor * descriptor = getFileDescriptor(index, manager);
if (descriptor == NULL) {
kprintf("remove Descriptor not initiailized\n");
return -1;
}
fddestroy(descriptor);
array_set(manager->fdm_descriptors, index, NULL);
if (index < manager->fdm_next) {
manager->fdm_next = index;
}
return 0;
}
/*-----------------------------------------------------------------------------
* array_prepend :
* push an element onto the front of a one-dimensional array
*----------------------------------------------------------------------------
*/
Datum
array_prepend(PG_FUNCTION_ARGS)
{
ArrayType *v;
Datum newelem;
bool isNull;
ArrayType *result;
int *lb;
int indx;
ArrayMetaState *my_extra;
isNull = PG_ARGISNULL(0);
if (isNull)
newelem = (Datum) 0;
else
newelem = PG_GETARG_DATUM(0);
v = fetch_array_arg_replace_nulls(fcinfo, 1);
if (ARR_NDIM(v) == 1)
{
/* prepend newelem */
lb = ARR_LBOUND(v);
indx = lb[0] - 1;
/* overflow? */
if (indx > lb[0])
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("integer out of range")));
}
else if (ARR_NDIM(v) == 0)
indx = 1;
else
ereport(ERROR,
(errcode(ERRCODE_DATA_EXCEPTION),
errmsg("argument must be empty or one-dimensional array")));
/* Perform element insertion */
my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
result = array_set(v, 1, &indx, newelem, isNull,
-1, my_extra->typlen, my_extra->typbyval, my_extra->typalign);
/* Readjust result's LB to match the input's, as expected for prepend */
if (ARR_NDIM(v) == 1)
ARR_LBOUND(result)[0] = ARR_LBOUND(v)[0];
PG_RETURN_ARRAYTYPE_P(result);
}
Array * page_rank(Table * inbound, unsigned int order, float alpha, float convergence, unsigned int max_times)
{
register int t = 0, k, i;
register float norm2 = 1.0, prod_scalar, x;
unsigned int total_size = order;
Array * vector = initial(total_size);
Array * new_vector = initial(total_size);
Array * tmp;
x = 1.0 - alpha;
while (t < max_times && norm2 >= convergence) {
t++;
norm2 = 0.0;
prod_scalar = 0.0;
for (k = 0; k < total_size; k++) {
if (is_sink(inbound, k))
prod_scalar += array_get(vector, k) * alpha;
}
prod_scalar += x;
for (k = 0; k < total_size; k++) {
array_set(new_vector, k, prod_scalar);
if (!is_sink(inbound, k)) {
tmp = table_get(inbound, k);
for (i = 0; i < array_len(tmp); i++) {
array_incr(new_vector, k,
array_get(vector,
(int)array_get(tmp, i)) *
alpha);
}
}
norm2 += (array_get(new_vector, k) - array_get(vector, k)) *
(array_get(new_vector, k) - array_get(vector, k));
}
t++;
norm2 = sqrt((double)norm2) / total_size;
array_copy(vector, new_vector);
}
array_delete(new_vector);
return normalize(vector);
}
bool stack_push(struct stack_s* self, const void* data)
{
int top_index = self->top;
if(top_index < self->element_num)
{
array_set(self->array, top_index, data);
self->top++;
return true;
}
else
{
return false;
}
}
Type resolveArrayChain(MIS& env, Type val) {
static UNUSED const char prefix[] = " ";
FTRACE(5, "{}chain\n", prefix, show(val));
do {
auto arr = std::move(env.arrayChain.back().first);
auto key = std::move(env.arrayChain.back().second);
assert(arr.subtypeOf(TArr));
env.arrayChain.pop_back();
FTRACE(5, "{} | {} := {} in {}\n", prefix,
show(key), show(val), show(arr));
val = array_set(std::move(arr), key, val);
} while (!env.arrayChain.empty());
FTRACE(5, "{} = {}\n", prefix, show(val));
return val;
}
int animation_create(animation *ani, sd_animation *sdani, sd_palette *pal, int overlay, char *soundtable) {
ani->sdani = sdani;
array_create(&ani->sprites);
ani->soundtable = soundtable;
// Load textures
sd_rgba_image *img = 0;
for(int i = 0; i < sdani->frame_count; i++) {
img = sd_sprite_image_decode(sdani->sprites[i]->img, pal, overlay);
texture *tex = malloc(sizeof(texture));
texture_create(tex, img->data, img->w, img->h);
array_set(&ani->sprites, i, tex);
sd_rgba_image_delete(img);
}
return 0;
}
