/**
* Append one directory to the context's include path.
*/
XKB_EXPORT int
xkb_context_include_path_append(struct xkb_context *ctx, const char *path)
{
struct stat stat_buf;
int err;
char *tmp;
tmp = strdup(path);
if (!tmp)
goto err;
err = stat(path, &stat_buf);
if (err != 0)
goto err;
if (!S_ISDIR(stat_buf.st_mode))
goto err;
#if defined(HAVE_EACCESS)
if (eaccess(path, R_OK | X_OK) != 0)
goto err;
#elif defined(HAVE_EUIDACCESS)
if (euidaccess(path, R_OK | X_OK) != 0)
goto err;
#endif
darray_append(ctx->includes, tmp);
return 1;
err:
darray_append(ctx->failed_includes, tmp);
return 0;
}
static void unbreak_backslash_broken_lines(struct token_list *tl, tok_message_queue *mq) {
const char *s = tl->orig, *e = s+tl->orig_size;
darray_char *txt = talloc_darray(tl);
darray(const char*) *olines = talloc_darray(tl);
darray(const char*) *tlines = talloc_darray(tl);
do {
const char *line_start = s, *line_end;
const char *lnw; //last non-white
size_t start_offset = txt->size;
//scan to the next line and find the last non-white character in the line
while (s<e && !creturn(*s)) s++;
line_end = s;
lnw = s;
while (lnw>line_start && cspace(lnw[-1])) lnw--;
if (s<e && creturn(*s)) {
s++;
//check for non-standard newlines (i.e. "\r", "\r\n", or "\n\r")
if (s<e && *s=='\n'+'\r'-s[-1])
s++;
}
//add the backslash-break-free version of the text
if (lnw>line_start && lnw[-1]=='\\' && line_end<e) {
darray_append_items(*txt, line_start, lnw-1-line_start);
if (lnw<e && cspace(*lnw)) {
tok_msg_warn(spaces_after_backslash_break, lnw,
"Trailing spaces after backslash-broken line");
}
} else
darray_append_items(*txt, line_start, s-line_start);
//add the line starts for this line
darray_append(*olines, line_start);
darray_append(*tlines, (const char*)start_offset);
//Since the txt buffer moves when expanded, we're storing offsets
// for now. Once we're done building txt, we can add the base
// of it to all the offsets to make them pointers.
} while (s<e);
//stick a null terminator at the end of the text
darray_realloc(*txt, txt->size+1);
txt->item[txt->size] = 0;
//convert the line start offsets to pointers
{
const char **i;
darray_foreach(i, *tlines)
*i = txt->item + (size_t)(*i);
}
tl->olines = olines->item;
tl->olines_size = olines->size;
tl->txt = txt->item;
tl->txt_size = txt->size;
tl->tlines = tlines->item;
tl->tlines_size = tlines->size;
}
tree_ptr tree_new_assign(tree_ptr l, tree_ptr r) {
// TODO: Check l's type.
tree_ptr t = tree_new(eval_assign);
t->child = darray_new();
darray_append(t->child, l);
darray_append(t->child, r);
return t;
}
void type_function_init(struct type *t, struct type *arg_type, struct type *ret_type)
{
t->category = TYPE_CATEGORY_OPERATOR;
t->operator.type = TYPEOP_IMPLICATION;
darray_append(t->operator.operands, arg_type);
darray_append(t->operator.operands, ret_type);
}
tree_ptr tree_new_define(tree_ptr id, tree_ptr parm, tree_ptr body) {
tree_ptr t = tree_new(eval_define);
t->child = darray_new();
darray_append(t->child, id);
darray_append(t->child, parm);
darray_append(t->child, body);
return t;
}
tree_ptr tree_new_ternary(tree_ptr cond, tree_ptr t1, tree_ptr t2) {
tree_ptr t = tree_new(eval_ternary);
t->child = darray_new();
darray_append(t->child, cond);
darray_append(t->child, t1);
darray_append(t->child, t2);
return t;
}
void problem_02_test_basic(){
/* declare and initialize a new array */
DArray array;
int majority = 0;
darray_init(&array);
/* initialize array */
darray_append(&array, 3);
darray_append(&array, 3);
darray_append(&array, 4);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 4);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 4);
majority = find_majority_basic(&array);
if(majority == FAILURE){
printf("No majority value found!\n");
}else{
printf("Majority value: %d\n", majority);
}
/* free up the underlying array */
darray_free(&array);
}
DArray* graph_vertex_get_out_edges(const Graph *g, const Vertex *v)
{
unsigned long index;
DArray *out_edges;
Edge *e;
assert(g != NULL);
assert(v != NULL);
out_edges = darray_create();
if(NULL == out_edges) {
fprintf(stderr, "Cannot create out-edge list (%s:%d)\n",
__FUNCTION__, __LINE__);
return NULL;
}
for(index = 0; index < darray_size(v->edges); index++) {
e = (Edge *)darray_index(v->edges, index);
if(v == e->source) {
if(darray_append(out_edges, e) < 0) {
fprintf(stderr, "Cannot construct out-edge list (%s:%d)\n",
__FUNCTION__, __LINE__);
darray_free(out_edges);
return NULL;
}
}
}
return out_edges;
}
int graph_edge_add(Graph *g, Edge *e)
{
unsigned long index;
Vertex *v;
assert(g != NULL);
assert(e != NULL);
for(index = 0; index < darray_size(g->vertices); index++) {
v = (Vertex *)darray_index(g->vertices, index);
if(v == e->source) {
v->out_degree++;
darray_append(v->edges, e);
g->edge_count++;
}
if((v == e->target)) {
/* For undirected graphs, insert an extra edge to allow
* traversal from the target vertex back to the source
* vertex, except in the case where an edge is a loop.
*/
if(graph_is_undirected(g)) {
v->out_degree++;
if(e->target != e->source) {
darray_append(v->edges,
edge_create(e->target, e->source, e->weight));
} else {
/* Loops are counted twice */
v->out_degree++;
}
} else {
/* Keep track of the number of edges directed
* toward this vertex, but not which edges
*
* TODO Keep a separate in-edge list for each
* node?
*/
v->in_degree++;
}
}
}
return 0;
}
int graph_vertex_add(Graph *g, Vertex *v)
{
assert(g != NULL);
assert(v != NULL);
v->idx = darray_size(g->vertices);
return darray_append(g->vertices, v);
}
/* Complexity: O(log n), worst-case */
int heap_push(Heap *heap, void *data)
{
assert(heap != NULL);
darray_append(heap->h, data);
heapify_up(heap, darray_size(heap->h) - 1);
return 0;
}
char* mml_serialize_compact(MMLObject* mml) {
DArray out;
out = darray_create(sizeof(char), 0);
_serialize_compact(mml, &out, 0);
darray_append(&out, "\0");
// Look at mml_serialize for explanation
return (char*)out.data;
}
void problem_05_test_sum(){
/* declare and initialize a new array */
DArray array;
int missing;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 5);
darray_append(&array, 6);
missing = get_missing_number_sum_formula(&array, 5);
printf("The missing number is: %d\n", missing);
/* free up the underlying array */
darray_free(&array);
}
char* mml_serialize(MMLObject* mml) {
DArray out;
out = darray_create(sizeof(char), 0);
_serialize(mml, &out, 0, 0);
darray_append(&out, "\0");
// This is a hack, but saves one alloc/free pair.
// Freeing out.data is mostly the same as calling darray_free.
return (char*)out.data;
}
static void record(element_t asum, element_t bsum, element_t snark,
darray_t hole, mpz_t counter) {
snapshot_ptr ss = pbc_malloc(sizeof(struct snapshot_s));
element_init_same_as(ss->a, asum);
element_init_same_as(ss->b, bsum);
element_init_same_as(ss->snark, snark);
element_set(ss->a, asum);
element_set(ss->b, bsum);
element_set(ss->snark, snark);
darray_append(hole, ss);
element_printf("snark %Zd: %B\n", counter, snark);
}
void _serialize_compact(MMLObject* mml, DArray* out, NodeIdx node) {
assert(mml);
assert(out);
MMLNode* node_ptr = mml_get_nodeptr(mml, node);
const char* name = mml_get_str(mml, node_ptr->name_start);
const char* value = mml_get_str(mml, node_ptr->value_start);
darray_append(out, "(");
mml_insert_escapes(name, out);
darray_append(out, " ");
mml_insert_escapes(value, out);
NodeIdx child = node_ptr->first_child_idx;
while(child) {
_serialize_compact(mml, out, child);
child = mml_get_next(mml, child);
}
darray_append(out, ")");
}
void symtab_put(symtab_t t, void *data, const char *key) {
int i, n = t->list->count;
entry_ptr e;
for (i=0; i<n; i++) {
e = t->list->item[i];
if (!strcmp(e->key, key)) goto doit;
}
e = pbc_malloc(sizeof(entry_t));
e->key = pbc_strdup(key);
darray_append(t->list, e);
doit:
e->data = data;
}
void _serialize(MMLObject* mml, DArray* out, NodeIdx node, uint padding) {
assert(mml);
assert(out);
MMLNode* node_ptr = mml_get_nodeptr(mml, node);
uint i = padding;
while(i--) {
darray_append(out, " ");
}
const char* name = mml_get_str(mml, node_ptr->name_start);
const char* value = mml_get_str(mml, node_ptr->value_start);
darray_append_multi(out, "( ", 2);
mml_insert_escapes(name, out);
darray_append(out, " ");
mml_insert_escapes(value, out);
if(node_ptr->first_child_idx == 0) {
// node has no children, print it on a single line
darray_append_multi(out, " )\n", 3);
return;
}
else {
// node has children, recurse
darray_append(out, "\n");
NodeIdx child = node_ptr->first_child_idx;
while(child) {
_serialize(mml, out, child, padding + 4);
child = mml_get_next(mml, child);
}
i = padding;
while(i--) {
darray_append(out, " ");
}
darray_append_multi(out, ")\n", 2);
}
}
void video_draw_line(uint layer, const Vector2* start,
const Vector2* end, Color color) {
assert(layer < bucket_count);
assert(start);
assert(end);
LineDesc new_line;
new_line.start = *start;
new_line.end = *end;
new_line.color = color;
if(!line_buckets[layer].reserved)
line_buckets[layer] = darray_create(sizeof(LineDesc), 32);
darray_append(&line_buckets[layer], &new_line);
}
int main(int argc, char *argv[])
{
dyn_array_t arr = darray_make(4);
// Store 1,2,3,4 in array
for (int i = 0; i < darray_size(arr); ++i) darray_set(arr, i, i);
// Print arr[i] = i for i=[1,4]
for (int i = 0; i < darray_size(arr); ++i) printf("arr[%d] = %d\n", i, *darray_get(arr, i));
darray_append(&arr, 5);
darray_append(&arr, 6);
darray_prepend(&arr, 7);
darray_prepend(&arr, 8);
// Print arr[i] = j for i=[1,8]
for (int i = 0; i < darray_size(arr); ++i) printf("arr[%d] = %d\n", i, *darray_get(arr, i));
darray_free(&arr);
arr = NULL;
return 0;
}
static struct tcmu_conf_option *
tcmu_register_option(char *key, tcmu_option_type type)
{
struct tcmu_conf_option option, *opt;
option.key = key;
option.type = type;
darray_append(tcmu_options, option);
darray_foreach(opt, tcmu_options) {
if (!strcmp(opt->key, key))
return opt;
}
tcmu_err("failed to register new option!\n");
return NULL;
}
DArray _gen_edges(DArray points, DArray geometry) {
DArray edges = darray_create(sizeof(Edge), 0);
Vector2* points_vec2 = DARRAY_DATA_PTR(points, Vector2);
for(uint i = 0; i < points.size; ++i) {
for(uint j = 0; j < points.size; ++j) {
if(i >= j)
continue;
float sqr_dist = _node_distance_sq(points_vec2[i], points_vec2[j]);
if(sqr_dist <= max_edge_distance*max_edge_distance) {
Edge n = {i, j};
Segment s = ai_shortest_path(points_vec2[i], points_vec2[j]);
Segment s1, s2;
bool split = ai_split_path(s, &s1, &s2);
// Check for wall intersection
Segment* geometry_s = DARRAY_DATA_PTR(geometry, Segment);
bool intersects_arena = false;
for(uint k = 0; k < geometry.size; ++k) {
if(segment_intersect(s1, geometry_s[k], NULL)) {
intersects_arena = true;
break;
}
if(split && segment_intersect(s2, geometry_s[k], NULL)) {
intersects_arena = true;
break;
}
}
// Check distance to walls at midpoint
Vector2 midpoint = vec2_scale(vec2_add(s1.p1, s1.p2), 0.5f);
if(ai_wall_distance(midpoint, geometry) < min_wall_distance)
intersects_arena = true;
if(!intersects_arena)
darray_append(&edges, (void*)&n);
}
}
}
return edges;
}
DArray _gen_navpoints(DArray geometry, DArray platforms) {
DArray points = darray_create(sizeof(Vector2), 0);
darray_append_multi(&points, platforms.data, platforms.size);
uint fail_count = 0;
do {
Vector2 navpoint = vec2(rand_float_range(0.0f, SCREEN_WIDTH),
rand_float_range(0.0f, SCREEN_HEIGHT));
float wdist = ai_wall_distance(navpoint, geometry);
float pdist = _point_distance(navpoint, points);
if(wdist >= min_wall_distance && pdist >= min_point_distance) {
darray_append(&points, (void*)&navpoint);
fail_count = 0;
}
else {
fail_count++;
}
} while(fail_count < 1200);
return points;
}
int main(int argc, char** argv)
{
CU_pSuite pSuite;
CU_initialize_registry();
pSuite = CU_add_suite("TestHello", TestInit, TestClean);
CU_add_test(pSuite, "testAssertTrue", testAssertTrue);
CU_console_run_tests();
CU_cleanup_registry();
DArray* darray = (DArray*) malloc( sizeof( DArray ));
memset( darray, 0x00 ,sizeof(DArray));
char* name = (char*) malloc( sizeof(char)*100);
sprintf( name, "kakasi");
darray_append( darray, sizeof(char)*strlen(name), name);
darray_for_each( darray, print_content_char, NULL );
darray_destory( darray );
return 0;
}
int main(int argc, char* argv[])
{
int i = 0;
int n = 100;
int data = 0;
DArray* darray = darray_create(NULL, NULL);
for (i = 0; i < n; i++) {
darray_append(darray, (void*)(rand() % n));
}
darray_sort(darray, quick_sort, cmp_int);
darray_foreach(darray, print_int, NULL);
printf("\n");
darray_get_by_index(darray, 0, (void*)&data);
data = !data;
darray_foreach(darray, unique_print_int, &data);
printf("\n");
darray_destroy(darray);
return 0;
}
void problem_01_test_hash(){
/* declare and initialize a new array */
DArray array;
int search = 16;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 4);
darray_append(&array, 45);
darray_append(&array, 6);
darray_append(&array, 10);
darray_append(&array, -8);
array_has_sum_of_hash(&array, array.size, search);
/* free up the underlying array */
darray_free(&array);
}
void problem_01_test_sort(){
/* declare and initialize a new array */
DArray array;
int search = 16;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 4);
darray_append(&array, 45);
darray_append(&array, 6);
darray_append(&array, 10);
darray_append(&array, -8);
if(!array_has_sum_of(&array, array.capacity, search)){
printf("Array has two elements with sum %d\n", search);
}else{
printf("Array doesn't have two elements with sum %d\n", search);
}
/* free up the underlying array */
darray_free(&array);
}
void minimap_track(ObjRabbit* rabbit){
darray_append(&minimap_pointers, &rabbit);
results[minimap_pointers.size-1] = rabbit;
}
void tree_set_fun(tree_ptr f, tree_ptr src) {
darray_append(f->child, src);
}
void tree_append(tree_ptr f, tree_ptr p) {
darray_append(f->child, p);
}
