void ShaderNode_clear_links(ShaderNode _sn) { ShaderObject exec_so = {NULL}; /** if ( to_ptr(_sn->result_link) != NULL ) { ShaderObject_delete(_sn->result_link); _sn->result_link = exec_so; } **/ for (euint32 i = 0; i < array_n(_sn->input_links); i++) { ShaderObject so = array_safe_get(_sn->input_links, i); if ( to_ptr(so) != NULL ) ShaderObject_delete(so); } array_delete(_sn->input_links); _sn->input_links = array_new(ShaderObject, 5, exec_so); for (euint32 i = 0; i < array_n(_sn->output_links); i++) { ShaderObject so = array_safe_get(_sn->output_links, i); if ( to_ptr(so) != NULL ) ShaderObject_delete(so); } array_delete(_sn->output_links); _sn->output_links = array_new(ShaderObject, 5, exec_so); }
/* Interface. */ int atms_add_node(atms tms, const signed char assumption, const signed char contradiction) { atms_node node = (atms_node)malloc(sizeof(struct str_atms_node)); if (NULL == node) { return -1; } memset(node, 0, sizeof(struct str_atms_node)); node->index = tms->nodes->sz; node->assumption = assumption; node->contradiction = contradiction; node->consequences = array_new(NULL, NULL); node->label = trie_new((trie_node_destroy_func_t)array_free, (trie_node_clone_func_t)array_copy); array_append(tms->nodes, node); if (assumption) { /* The label of this node is a singleton environment with this node only. */ array env = array_append(array_new(NULL, NULL), node); array key = get_environment_key(env); trie_add(node->label, key, env); array_free(key); } return node->index - 1; }
void test_new() { value0 = array_new(array); mu_assert(value0 != NULL, "Failed to make a new element"); value1 = array_new(array); mu_assert(value1 != NULL, "Failed to make a new element"); }
component_h add_input_handler_component( game_context_s *context, component_h parent) { context = game_add_component(context, parent, release_component); component_subscribe(context, tick); input_handler_s *input_handler = malloc(sizeof(input_handler_s)); game_set_component_data(context, input_handler); for(int i = 0; i < MAX_JOYSTICKS; i++) { input_handler->joysticks[i].joystick = i + 1; input_handler->joysticks[i].axes = array_new(); input_handler->joysticks[i].buttons = array_new(); } // only get input events when we explicitly ask with glfwPollEvents() glfwDisable(GLFW_AUTO_POLL_EVENTS); // set the callbacks. actually the callbacks might be called on setting // right now, particularly the window size one. target_context = context; glfwSetKeyCallback(key_callback); glfwSetWindowSizeCallback(window_size_callback); glfwSetWindowCloseCallback(window_close_callback); target_context = NULL; return game_get_self(context); }
void mpiReduce_pickerV3(float *resDataAbsMaxPaddedGlobal, size_t *resDataMaxIndPaddedGlobal, size_t resSize, eXCorrMerge bAbs) { resSizeMPI = resSize; MPI_Datatype mpiType; MPI_Type_contiguous((int) 2, MPI_FLOAT, &mpiType); MPI_Type_commit(&mpiType); float *resDataGlobalNode = NULL; float *resDataGlobalNodeReduce = NULL; array_new(resDataGlobalNode, 2*resSize); array_new(resDataGlobalNodeReduce, 2*resSize); memcpy(resDataGlobalNode, resDataAbsMaxPaddedGlobal, resSize*sizeof(float)); mpiOp_array_typecast(resDataMaxIndPaddedGlobal, resDataGlobalNode+resSize, resSize); MPI_Op mpiOp; switch (bAbs) { case XCORR_MERGE_NEGATIVE: MPI_Op_create((MPI_User_function *) mpiOp_xcorrMergeResultGlobalV3Abs, 1, // commutative &mpiOp); break; case XCORR_MERGE_POSITIVE: MPI_Op_create((MPI_User_function *) mpiOp_xcorrMergeResultGlobalV3, 1, // commutative &mpiOp); break; default: ERROR("mpiReduce_pickerV3", "unsupported merging mode"); } MPI_Reduce(resDataGlobalNode, resDataGlobalNodeReduce, (int) resSize, // resSize elements of size 2*sizeof(float) mpiType, mpiOp, 0, MPI_COMM_WORLD); MPI_Op_free(&mpiOp); memcpy(resDataAbsMaxPaddedGlobal, resDataGlobalNodeReduce, resSize*sizeof(float)); mpiOp_array_typecast(resDataGlobalNodeReduce+resSize, resDataMaxIndPaddedGlobal, resSize); array_delete(resDataGlobalNode); array_delete(resDataGlobalNodeReduce); MPI_Type_free(&mpiType); }
struct program_state *program_state_new(struct context *context, struct map *env) { null_check(context); struct program_state *state = (struct program_state*)malloc(sizeof(struct program_state)); state->named_variables = map_copy(env); state->all_variables = array_new(); state->args = array_new(); stack_push(context->program_stack, state); return state; }
void init_quarks(void) { size_t index; if (quarks) return; quarks = array_new((free_function_t)array_free); array_reserve(quarks, HASH_SIZE); for (index = 0; index < HASH_SIZE; ++index) array_append(quarks, array_new((free_function_t)free)); quarks_index = array_new(NULL); }
int ipp_add_tag( IPP *ipp, char tag_type, char *name, void *value, short val_len, int set ) { struct _ipp_attr_seq *s; struct _ipp_attr_value *attr_value; IPP_ATTR *attr; ARRAY *vals; int i; if( tag_type&0xF0 ) { // Value s = array_get( ipp->seqs, array_len( ipp->seqs ) - 1 ); for( i = 0; i < array_len( s->attr ); i++ ) { attr = array_get( s->attr, i ); if( strcmp( attr->name, name ) == 0 ) { if( set ) { vals = attr->values; } else { array_free( attr->values ); vals = attr->values = array_new(); } break; } } if( i == array_len( s->attr ) ) { attr = calloc( 1, sizeof( IPP_ATTR ) ); attr->name = strdup( name ); vals = attr->values = array_new(); array_add( s->attr, attr ); } attr_value = malloc( sizeof( struct _ipp_attr_value ) ); attr_value->type = tag_type; if( tag_type & (IPP_TAG_INTEGERS|IPP_TAG_OCTET_STRING) ) { // Binary attr_value->value = malloc( val_len ); memcpy( attr_value->value, value, val_len ); } else if ( tag_type & IPP_TAG_CHAR_STRING ) { // CHARACTER-STRING attr_value->value = malloc( val_len + 1 ); // Terminating NUL memcpy( attr_value->value, value, val_len ); ((char *)attr_value->value)[val_len] = '\0'; } attr_value->len = val_len; array_add( vals, attr_value ); } else { ipp_add_seq( ipp, tag_type ); } return 1; }
/** * Creates a new condition given a place and it's pre-event * @arg pl the image for the condition in the original net_t * @arg ev the single event in the preset of the condition * @return the newly created condition */ cond_t *nc_cond_new(place_t *pl, event_t *ev) { struct cond_t *cond = (cond_t*)MYmalloc(sizeof(cond_t)); cond->num = cond_last++; cond->pre_ev = ev; cond->origin = pl; cond->postset = array_new(0); cond->readarcs = array_new(0); cond->co_private = g_hash_table_new(NULL, NULL); return cond; }
/* Data structures. */ atms atms_new() { atms tms = (atms)malloc(sizeof(struct str_atms)); if (NULL == tms) { return tms; } tms->nodes = array_new((array_element_destroy_func_t)atms_node_free, NULL); tms->justifications = array_new((array_element_destroy_func_t)atms_justification_free, NULL); /* The "F" node is special. An environment of the "F" node is a "nogood". */ atms_add_node(tms, 0, 1); return tms; }
/*! \memberof array prepare cubic spline interpolation by calculating the a[i]'s */ array_t * array_cspline_prepare(array_t * s, array_t * h, array_t * f) { int k; // because the matrix is symmetic and the subdiagonals are never touched by the // calculation only two new vectors are needed: diag and b // all other values can be taken directly from the precalculated h vector // create and initialize matrix diagonal array_t * diag = array_new(s->length - 2); for (k = 0; k < diag->length; k++) { diag->data[k] = 2 * (h->data[k] + h->data[k + 1]); } // create and initialize value vector array_t * b = array_new(diag->length); for (k = 0; k < b->length; k++) { double f1 = f->data[k]; double f2 = f->data[k + 1]; double f3 = f->data[k + 2]; double h1 = h->data[k]; double h2 = h->data[k + 1]; b->data[k] = 6 * ((f3 - f2) / h2 - (f2 - f1) / h1); } // calculate the new diagonal of the twodiagonal matrix for (k = 1 /* ! */; k < b->length; k++) { double lu = h->data[k]; double dd = diag->data[k - 1]; diag->data[k] += - lu * lu / dd; double tt = b->data[k - 1]; b->data[k] += - lu * tt / dd; } // this will be the coefficients vector array_t * a = array_new(s->length); // natural cspline boundary condition a->data[0] = 0; a->data[a->length - 1] = 0; // calculate the rest of a[i] for (k = b->length - 1; k >= 0; k--) { a->data[k + 1] = (b->data[k] - h->data[k + 1] * a->data[k + 2]) / diag->data[k]; } // dispose of garbage free(diag); free(b); return a; }
STATIC mp_obj_t array_construct(char typecode, mp_obj_t initializer) { uint len; // Try to create array of exact len if initializer len is known mp_obj_t len_in = mp_obj_len_maybe(initializer); if (len_in == MP_OBJ_NULL) { len = 0; } else { len = MP_OBJ_SMALL_INT_VALUE(len_in); } mp_obj_array_t *array = array_new(typecode, len); mp_obj_t iterable = mp_getiter(initializer); mp_obj_t item; int i = 0; while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) { if (len == 0) { array_append(array, item); } else { mp_binary_set_val_array(typecode, array->items, i++, item); } } return array; }
iridium_method(File, each_line) { object self = local(self); object filename = local(filename); // From self object fn = local(fn); object str = NULL; FILE * f = get_file(context, self); size_t file_size = file_length(context, f, filename); char * buffer = GC_MALLOC((file_size+1)*sizeof(char)); assert(buffer); int nchars; char * line = NULL; while ((nchars = getline(&buffer, &file_size, f)) != -1) { // Remove the newline, if present if (buffer[nchars-1] == '\n') { buffer[nchars-1] = 0; } line = GC_MALLOC((nchars + 1) * sizeof(char)); assert(line); strncpy(line, buffer, nchars); str = IR_STRING(line); calls(context, fn, array_push(array_new(), str)); } return NIL; }
int test(struct IridiumContext * context) { struct array * ary = array_new(); assertEqual(array_get(ary, 0), NULL); return 0; }
void test_array() { struct array* a = array_new(10); for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } array_debug_print(a); for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } for (int i = 0; i < 10; ++i) { array_push_back(a, (void*)i); } array_debug_print(a); }
void replace_word(array_t** stack, string_t word, string_t rule) { string_t from; size_t word_len = strlen(word), to_len, offset; from = strsep(&rule, RULE_SEPARATOR_STR); assert(0 != *rule); /* something to replace must be there */ /*fprintf(stdout, "%s %s\n", word, from);*/ if(0 != strcasecmp(word, from)) return; to_len = strlen(rule); if(to_len > word_len) { /* need to extend 'word' memory */ if(ARR_FULL(*stack, to_len - word_len)) { /* re-alloc, adjust word */ offset = PTR_DIFF(word, *stack); assert(NULL != (*stack = array_new(SMRZR_FALSE, 0, 0, *stack))); word = PTR_ADD(string_t, *stack, offset); } } strcpy(word, rule); /* replace */ (*stack)->curr = PTR_ADD(elem_t, word, to_len + 1); /* adjust curr */ }
DEFINEFN vinfo_t* PsycoFunction_New(PsycoObject* po, vinfo_t* fcode, vinfo_t* fglobals, vinfo_t* fdefaults) { vinfo_t* r; /* fdefaults contains potential arguments; mutable objects there must be forced out of virtual-time right now */ if (fdefaults != NULL && !psyco_forking(po, fdefaults->array)) return NULL; /* Build a virtual function object */ r = vinfo_new(VirtualTime_New(&psyco_computed_function)); r->array = array_new(FUNC_TOTAL); r->array->items[iOB_TYPE] = vinfo_new(CompileTime_New((long)(&PyFunction_Type))); vinfo_incref(fcode); r->array->items[iFUNC_CODE] = fcode; vinfo_incref(fglobals); r->array->items[iFUNC_GLOBALS] = fglobals; if (fdefaults == NULL) fdefaults = psyco_vi_Zero(); else vinfo_incref(fdefaults); r->array->items[iFUNC_DEFAULTS] = fdefaults; return r; }
void physics_add(Entity ent) { PhysicsInfo *info; if (entitypool_get(pool, ent)) return; /* already has physics */ transform_add(ent); info = entitypool_add(pool, ent); info->mass = 1.0; info->type = PB_DYNAMIC; /* create, init cpBody */ info->body = cpSpaceAddBody(space, cpBodyNew(info->mass, 1.0)); cpBodySetUserData(info->body, ent); /* for cpBody -> Entity mapping */ cpBodySetPos(info->body, cpv_of_vec2(transform_get_position(ent))); cpBodySetAngle(info->body, transform_get_rotation(ent)); info->last_dirty_count = transform_get_dirty_count(ent); /* initially no shapes */ info->shapes = array_new(ShapeInfo); /* initialize last_pos/last_ang info for kinematic bodies */ info->last_pos = cpBodyGetPos(info->body); info->last_ang = cpBodyGetAngle(info->body); info->collisions = NULL; }
struct stack_s* stack_new(int num, int element_size) { struct stack_s* ret = (struct stack_s*)malloc(sizeof(struct stack_s)); if(NULL != ret) { memset(ret, 0, sizeof(*ret)); ret->array = array_new(num, element_size); if(NULL != ret->array) { ret->element_num = num; ret->top = 0; } else { stack_delete(ret); ret = NULL; } } return ret; }
static BREthereumMessage provisionCreateMessageLES (BREthereumProvision *provisionMulti, size_t messageContentLimit, size_t messageIdBase, size_t index) { uint64_t messageId = messageIdBase + index; switch (provisionMulti->type) { case PROVISION_BLOCK_HEADERS: { BREthereumProvisionHeaders *provision = &provisionMulti->u.headers; if (NULL == provision->headers) { array_new (provision->headers, provision->limit); array_set_count (provision->headers, provision->limit); } uint64_t start = provision->start + index * messageContentLimit; size_t count = provision->limit - index * messageContentLimit; return (BREthereumMessage) { MESSAGE_LES, { .les = { LES_MESSAGE_GET_BLOCK_HEADERS, { .getBlockHeaders = { messageId, 1, // use 'number' { .number = start }, (uint32_t) minimum (count, messageContentLimit), provision->skip, ETHEREUM_BOOLEAN_IS_TRUE (provision->reverse) }}}} }; }
source *source_new() { source *src = (source*)calloc(1,sizeof(source)); src->scombs = array_new(sizeof(scomb*),0); list_push(&src->newimports,strdup("prelude")); return src; }
void * array_append(array_t *array, void const *element) { void *ptr = array_new(array); if (ptr != NULL) memcpy(ptr, element, array->e_size); return ptr; }
TEST_F(ArrTest, testEnsure) { Foo *f = array_new(Foo, 1); array_hdr_t *hdr = array_hdr(f); Foo *tail = array_ensure_tail(&f, Foo); // Make sure Valgrind does not complain! tail->x = 0; tail->y = 0; Foo *middle = array_ensure_at(&f, 5, Foo); ASSERT_EQ(0, middle->x); ASSERT_EQ(0, middle->y); for (size_t ii = 0; ii < array_len(f); ++ii) { ASSERT_EQ(0, f[ii].x); ASSERT_EQ(0, f[ii].y); } // Try again with ensure_tail tail = array_ensure_tail(&f, Foo); f->x = 99; f->y = 990; tail->x = 100; tail->y = 200; // ensure_append Foo threeFoos[] = {{10, 11}, {20, 21}, {30, 31}}; size_t prevlen = array_len(f); f = array_ensure_append(f, &threeFoos, 3, Foo); ASSERT_EQ(10, f[prevlen].x); ASSERT_EQ(20, f[prevlen + 1].x); ASSERT_EQ(30, f[prevlen + 2].x); array_free(f); }
/*! \memberof array returns a vector of interpolated values of f for points in x */ array_t * array_cspline_dinterpolate(array_t * x, array_t * s, array_t * h, array_t * f, array_t * a) { int k; array_t * p = array_new(x->length); for (k = 0; k < x->length; k++) { double z = x->data[k]; int idx = array_getmaxindex(s, z); if (idx >= 0) { double s1 = s->data[idx]; double s2 = s->data[idx + 1]; double f1 = f->data[idx]; double f2 = f->data[idx + 1]; double a1 = a->data[idx]; double a2 = a->data[idx + 1]; double d1 = z - s1; double d2 = z - s2; double ih = h->data[idx]; p->data[k] = (-(a2*(pow(ih,2) - 3*pow(d1,2))) + a1*(pow(ih,2) - 3*pow(d2,2)) - 6*f1 + 6*f2)/(6.*ih); } else { p->data[k] = 0; } } return p; }
static value_t* ruby_to_value(VALUE v) { switch (TYPE(v)) { case T_NIL: return value_new_void(); case T_BIGNUM: case T_FIXNUM: return value_new_int32(NUM2INT(v)); case T_TRUE: return value_new_boolean(true); case T_FALSE: return value_new_boolean(false); case T_FLOAT: return value_new_float32(NUM2DBL(v)); case T_SYMBOL: return value_new_string(rb_id2name(SYM2ID(v))); case T_STRING: return value_new_string(StringValuePtr(v)); case T_ARRAY: { /* process Array */ value_t*array = array_new(); int len = RARRAY(v)->len; int i; for(i=0;i<len;i++) { volatile VALUE item = RARRAY(v)->ptr[i]; array_append(array, ruby_to_value(item)); } return array; } default: /* raise exception */ rb_raise(rb_eTypeError, "not valid value"); } }
void free_(void *p) { t_chunk *c; t_mem *m; if (!p) return ; g_malloc_memory = g_malloc_memory ? GMEM : array_new(sizeof(t_chunk), 0); while ((c = (t_chunk *)array_next(g_malloc_memory))) { if ((char *)p < c->start || (char *)p > c->start + c->size) continue ; while ((m = (t_mem *)array_next(c->mem))) { if ((char *)p < m->start || (char *)p > m->start + m->size) continue ; array_remove(c->mem, c->mem->it - 1); c->mem->it = 0; g_malloc_memory->it = 0; if (c->mem->size == 0) array_remove(g_malloc_memory, g_malloc_memory->it); return ; } c->mem->it = 0; } g_malloc_memory->it = 0; free__(p); }
int main(void) { t_array *arr; arr = array_new(sizeof(int), 0); array_add(arr, (int[]) { 17 });
elem_t array_search_or_alloc(array_t** array, const elem_t key, compfunc_t cf, bool_t* is_new) { size_t num_elems; elem_t elem0, center, elem; int lo, hi, mid; array_t * a = *array; assert(SMRZR_TRUE == a->is_array && 0 != a->elem_sz); elem0 = PTR_ADD(elem_t, a, sizeof(array_t)); num_elems = PTR_DIFF(a->curr, elem0) / a->elem_sz; if(!num_elems) { a->curr = PTR_ADD(elem_t, elem0, a->elem_sz); *is_new = SMRZR_TRUE; return(elem0); } lo = 0; hi = num_elems-1; while(lo <= hi) { mid = (lo + hi)/2; center = PTR_ADD(elem_t, elem0, mid * a->elem_sz); switch(cf(center, key)) { case SMRZR_EQ: *is_new = SMRZR_FALSE; return(center); case SMRZR_GT: hi = mid - 1; break; case SMRZR_LT: lo = mid + 1; break; default: assert(SMRZR_FALSE); } } /* insert just before lo */ if(SMRZR_TRUE == ARR_FULL(a, a->elem_sz)) { if(NULL == (*array = array_new(a->is_array, a->elem_sz, 2 * a->num_elems, a))) return(NULL); a = *array; elem0 = PTR_ADD(elem_t, a, sizeof(array_t)); } elem = PTR_ADD(elem_t, elem0, lo * a->elem_sz); memmove(PTR_ADD(elem_t, elem, a->elem_sz), elem, PTR_DIFF(a->curr, elem)); a->curr = PTR_ADD(elem_t, a->curr, a->elem_sz); *is_new = SMRZR_TRUE; return(elem); }
static void bench_parmap_full(int nthreads, e_xbt_parmap_mode_t mode) { unsigned *a; xbt_dynar_t data; xbt_parmap_t parmap; int i; double start_time, elapsed_time; printf("** mode = %-15s ", parmap_mode_name(mode)); fflush(stdout); if (parmap_skip_mode(mode)) return; array_new(&a, &data); i = 0; start_time = xbt_os_time(); do { parmap = xbt_parmap_new(nthreads, mode); xbt_parmap_apply(parmap, fun_to_apply, data); xbt_parmap_destroy(parmap); elapsed_time = xbt_os_time() - start_time; i++; } while (elapsed_time < TIMEOUT); printf("ran %d times in %g seconds (%g/s)\n", i, elapsed_time, i / elapsed_time); xbt_dynar_free(&data); xbt_free(a); }
/** * Creates an event for the unfolding */ event_t *nc_event_new(trans_t *tr, array_t *pre, array_t *read) { event_t *ev = (event_t*)MYmalloc(sizeof(event_t)); ev->num = event_last++; ev->origin = tr; ev->preset = pre; ev->readarcs = read; // Adds a new condition for each place in the postset: array_t *post = ev->postset = array_new(tr->postset_size); nodelist_t *ps = tr->postset; while (ps) { cond_t *cond = nc_cond_new(ps->node, ev); array_append(post, cond); ps = ps->next; } array_sort(post); #ifdef __DEBUG__ g_assert(array_ordered(post)); #endif ev->hist = g_hash_table_new(NULL, NULL); return ev; }