void Hashmap_destroy(Hashmap *map)
{
int i = 0;
int j = 0;
if(map)
{
if(map->buckets)
{
for(i = 0; i < DArray_count(map->buckets); i++)
{
DArray *bucket = DArray_get(map->buckets, i);
if(bucket)
{
for(j = 0; j < DArray_count(bucket); j++)
{
free(DArray_get(bucket,j));
}
DArray_destroy(bucket);
}
}
DArray_destroy(map->buckets);
}
free(map);
}
}
DArray DArray_group_by(DArray array, DArray_group_by_fn *group_by_fn)
{
if (DArray_is_empty(array) || !group_by_fn) return NULL;
DArray groups = DArray_create(sizeof(DArray), 10);
DArray group;
int idx;
void *el;
size_t count = (size_t) DArray_count(array);
for (size_t i = 0; i < count; i++) {
el = DArray_remove(array, i);
if (!el) continue;
idx = group_by_fn(el);
if (idx == -1) continue;
group = DArray_get(groups, idx);
if (!group) {
group = DArray_create(array->element_size, DArray_count(array) + 1);
DArray_ensure_capacity(groups, idx + 1);
DArray_set(groups, idx, group);
}
DArray_push(group, el);
}
return groups;
}
void Hashmap_destroy(Hashmap *map)
{
int i = 0;
int j = 0;
if (map) {
if (map->buckets) {
for (i = 0; i < DArray_count(map->buckets); i++) {
DArray *bucket = DArray_get(map->buckets, i);
if (bucket) {
for (j = 0; j < DArray_count(bucket); j++) {
HashmapNode *node = DArray_get(bucket, j);
if (node != NULL) {
free(node->data);
map->free_key(node->key);
}
}
DArray_clear_destroy(bucket);
DArray_remove(map->buckets, i);
}
}
DArray_clear_destroy(map->buckets);
}
free(map);
}
}
void
Hashmap_destroy(Hashmap *map)
{
int i = 0;
int j = 0;
if(!map){
return;
}
if(!map->buckets){
return;
}
for(i = 0; i < DArray_count(map->buckets); i++){
//用DArray作桶,但桶里的每个元素也是DArray
//用DArray代替链表避免hash碰撞
//最后一层的DArray里放的才是HashmapNode
DArray *bucket = DArray_get(map->buckets, i);
if(!bucket){
continue;
}
for(j = 0; j < DArray_count(bucket); j++){
free(DArray_get(bucket,j));
}
DArray_destroy(bucket);
}
}
void Hashmap_destroy(Hashmap *map, Hashmap_destroy_func destroy_f)
{
int i = 0;
int j = 0;
if (map) {
if (map->buckets) {
for (i = 0; i < DArray_count(map->buckets); i++) {
DArray *bucket = DArray_get(map->buckets, i);
if (!bucket) continue;
for (j = 0; j < DArray_count(bucket); j++) {
void *val = DArray_get(bucket, j);
HashmapNode *node = val;
bdestroy(node->key);
if (destroy_f != NULL) {
destroy_f(node->data);
}
free(val);
}
DArray_destroy(bucket);
}
DArray_destroy(map->buckets);
}
free(map);
}
}
NodeAddress *getFSFromServicePool() {
NodeAddress *fsAddress = NULL;
if (DArray_count(fsList) > 0) {
fsAddress = DArray_get(fsList, fsPosition++);
if (fsPosition == DArray_count(fsList))
fsPosition = 0;
}
return fsAddress;
}
char *test_getlines()
{
bstring str = bfromcstr("one\ntwo\nthree\nfour\nfive\n");
struct bstrList *file = bsplit(str, '\n');
DArray *lines = getlines(file, 2, 4);
bstring two = bfromcstr("two");
bstring three = bfromcstr("three");
bstring four = bfromcstr("four");
mu_assert(DArray_count(lines) == 3, "Wrong number of lines.");
mu_assert(bstrcmp((bstring)DArray_at(lines, 0), two) == 0, "First line is wrong.");
mu_assert(bstrcmp((bstring)DArray_at(lines, 1), three) == 0, "Second line is wrong.");
mu_assert(bstrcmp((bstring)DArray_at(lines, 2), four) == 0, "Third line is wrong.");
bstrListDestroy(file);
bdestroy(str);
bdestroy(two);
bdestroy(three);
bdestroy(four);
DArray_destroy(lines);
return NULL;
}
void VM_start(bstring binary, bstring filename)
{
STATE = State_new();
Runtime_init(state);
VALUE lobby = Lobby_new(state); // toplevel object
state->lobby = lobby;
state->binary = binary;
BytecodeFile *file = BytecodeFile_new(state, filename);
int fn_count = DArray_count(file->function_names);
for(int j=0; j < fn_count; j++) {
bstring fn_name = (bstring)DArray_at(file->function_names, j);
Function *fn = (Function*)Hashmap_get(file->functions, fn_name);
Hashmap_set(state->functions, fn_name, fn);
}
bstring main_fn = bfromcstr("0_main");
CallFrame *top_frame = CallFrame_new(lobby, STATE_FN(main_fn), NULL);
bdestroy(main_fn);
top_frame->name = "main";
Stack_push(FRAMES, top_frame);
// now we're ready to bootstrap
State_bootstrap(state);
// and run the codes!
VM_run(state);
State_destroy(state);
}
void
State_bootstrap(STATE)
{
DArray *filenames = kernel_files(state);
int count = DArray_count(filenames);
// Expose toplevel constants
expose_VM(state, state->lobby);
int reenable_debugger = 0;
// Disable debugger while loading kernel files
if(Debug) {
reenable_debugger = 1;
Debug = 0;
}
// Load all files.
for(int i=0; i < count; i++) {
bstring filename = (bstring)DArray_at(filenames, i);
bstring path = bfromcstr("kernel/");
bconcat(path, filename);
Primitive_require(state, String_new(state, bdata(path)), NULL, NULL);
bdestroy(path);
bdestroy(filename);
}
DArray_destroy(filenames);
// Reenable debugger if needed
if(reenable_debugger) Debug = 1;
}
DArray *
CloseNodes_GetNodes(CloseNodes *close)
{
assert(close != NULL && "NULL CloseNodes pointer");
DArray *nodes = DArray_create(sizeof(Node *),
DArray_max(close->close_nodes));
check(nodes != NULL, "DArray_create failed");
int i = 0;
for (i = 0; i < DArray_count(close->close_nodes); i++)
{
struct CloseNode *close_node = DArray_get(close->close_nodes, i);
check(close_node != NULL, "NULL CloseNodes entry");
check(close_node->node != NULL, "NULL Node pointer in CloseNodes entry");
int rc = DArray_push(nodes, close_node->node);
check(rc == 0, "DArray_push failed");
}
return nodes;
error:
DArray_destroy(nodes);
return NULL;
}
void Value_print_all(STATE, DArray* objs)
{
for(int i=0; i < DArray_count(objs); i++) {
Value_print(state, (VALUE)DArray_at(objs, i));
printf("\n");
}
}
int
CloseNodes_Add(CloseNodes *close, Node *node)
{
assert(close != NULL && "NULL CloseNodes pointer");
assert(node != NULL && "NULL Node pointer");
Distance distance = Hash_Distance(&close->id, &node->id);
int i = FindIndex(close->close_nodes, &distance);
if (i < 0)
return 0;
struct CloseNode *close_node = malloc(sizeof(struct CloseNode));
check_mem(close_node);
close_node->node = node;
close_node->distance = distance;
if (DArray_count(close->close_nodes) < BUCKET_K)
DArray_push(close->close_nodes, NULL);
ShiftFrom(close->close_nodes, i);
DArray_set(close->close_nodes, i, close_node);
return 0;
error:
return -1;
}
int DArray_qsort(DArray* array, DArray_compare cmp)
{
DArray_check(array);
qsort(array->contents, DArray_count(array), sizeof(void*), cmp);
return 0;
error:
return 1;
}
int* get_parents(const FeaturedSentence sent) {
int *parents = (int*) malloc(sizeof (int) * (DArray_count(sent->words) + 1));
check_mem(parents);
parents[0] = -1;
for (int i = 0; i < DArray_count(sent->words); i++) {
Word w = (Word) DArray_get(sent->words, i);
parents[i + 1] = w->parent;
}
return parents;
error:
log_err("Error in allocating parents");
exit(1);
}
void Vector_each_with_index(VALUE vector, Vector_iter_idx iter)
{
DArray *array = VAL2ARY(vector);
int count = DArray_count(array);
for(int i=0; i<count; i++) {
iter((VALUE)DArray_at(array, i), i);
}
}
void Vector_each(VALUE vector, Vector_iter iter)
{
DArray *array = VAL2ARY(vector);
int count = DArray_count(array);
for(int i=0; i<count; i++) {
iter((VALUE)DArray_at(array, i));
}
}
int Hashmap_traverse(Hashmap* map, Hashmap_traverse_cb traverse_cb) {
int i = 0;
int j = 0;
int rc = 0;
for(i = 0; i < DArray_count(map->buckets); i++) {
DArray* bucket = DArray_get(map->buckets, i);
if(bucket) {
for(j = 0; j < DArray_count(bucket); j++) {
HashmapNode* node = DArray_get(bucket, j);
rc = traverse_cb(node);
if(rc != 0) return rc;
}
}
}
return 0;
}
void free_sentence_structures(FeaturedSentence sentence) {
for (int i = 0; i < DArray_count(sentence->words); i++) {
free(sentence->adjacency_matrix[i]);
}
free(sentence->adjacency_matrix);
sentence->adjacency_matrix = NULL;
}
void fill_distribution(int *stats, DArray *keys, Hashmap_hash hash_func) {
int i = 0;
uint32_t hash = 0;
for(i = 0; i < DArray_count(keys); i++) {
hash = hash_func(DArray_get(keys, i));
stats[hash % BUCKETS] += 1;
}
}
void fill_distribution(int *stats, DArray *keys, Hashmap_hash hash_func)//keys from gen keys to fill stats array
{ //goes through all keys does the hash then finds its bucket same as hashmap
int i = 0;
uint32_t hash = 0;
for(i = 0; i < DArray_count(keys); i++) {
hash = hash_func(DArray_get(keys, i));
stats[hash % BUCKETS] += 1;
}
}
int Hashmap_traverse(Hashmap *map, Hashmap_traverse_cb traverse_cb)
{//walks every bucket if bucket has any values then traverse_cb on each value scans whole hash map for its values
int i = 0;
int j = 0;
int rc = 0;
for(i = 0; i < DArray_count(map->buckets); i++) {
DArray *bucket = DArray_get(map->buckets, i);
if(bucket) {
for(j = 0; j < DArray_count(bucket); j++) {
HashmapNode *node = DArray_get(bucket, j);
rc = traverse_cb(node);
if(rc != 0) return rc;
}
}
}
return 0;
}
int is_sorted(DArray *array)
{
int i = 0;
for (i = 0; i < DArray_count(array) - 1; i++) {
if (strcmp(DArray_get(array, i), DArray_get(array, i+1)) > 0) {
return 0;
}
}
return 1;
}
void Object_destroy(Object *object)
{
if(object != NULL) {
if(object->immortal == 1) return;
switch(object->type) {
case tString:
bdestroy(object->value.string);
break;
case tFunction:
if (object->native) {
NativeMethod_destroy((NativeMethod*)object->value.other);
} else {
VMMethod_destroy((VMMethod*)object->value.other);
}
break;
case tArray: {
DArray *array = (DArray*)object->value.other;
int i=0;
for(i=0; i < DArray_count(array); i++) {
release((Object*)DArray_at(array, i));
}
DArray_destroy(array);
break;
}
case tHash: {
Hashmap *map = (Hashmap*)object->value.other;
Hashmap_traverse(map, delete_object_node);
Hashmap_destroy(map);
break;
}
default:
break;
}
if(object->slots) {
Hashmap_traverse(object->slots, delete_node);
Hashmap_destroy(object->slots);
}
if(object->parent) {
// FIXME: Releasing toplevel Object causes segfault :(
/* printf("Me ("); */
/* Object_print(object); */
/* printf(") I am releasing my parent ("); */
/* Object_print(object->parent); */
/* printf(")\\n"); */
/* release(object->parent); */
}
free(object);
}
}
void
CloseNodes_Destroy(CloseNodes *close)
{
if (close == NULL)
return;
while (DArray_count(close->close_nodes) > 0)
{
free(DArray_pop(close->close_nodes));
}
DArray_destroy(close->close_nodes);
free(close);
}
static inline void TSTree_empty_content(DArray *darray)
{
check(darray != NULL, "DArray can't be NULL.");
int i = 0;
if(!DArray_empty(darray)) {
for(i = 0; i <= DArray_count(darray); i++) {
DArray_pop(darray);
}
}
error:
return;
}
DArray DArray_find(DArray array, DArray_find_fn *filter_fn, void* args)
{
if (DArray_is_empty(array)) return NULL;
DArray filtered = DArray_create(array->element_size, array->size);
for (int i = 0; i < DArray_count(array); i++) {
void *item = DArray_get(array, i);
if (filter_fn(item, args))
DArray_push(filtered, item);
}
return filtered;
}
char * test_get_name()
{
DArray * array = DB_get_name("select db");
int count = DArray_count(array);
int i;
for(i=0;i<count;i++)
{
snippet_print(DArray_get(array,i),stdout);
}
DArray_clear_destroy(array,snippet_destroy);
return NULL;
}
void Object_print(Object* object) {
assert(object != NULL && "Cannot print null object");
if(object == Lobby) {
printf("Lobby");
return;
}
switch(object->type) {
case tInteger:
printf("%i", object->value.integer);
break;
case tString:
printf("%s", bdata(object->value.string));
break;
case tArray:
printf("[");
DArray *array = (DArray*)object->value.other;
int i = 0, count = DArray_count(array);
for(i=0; i < count; i++) {
Object_print((Object*)DArray_at(array, i));
if (i+1 != count) printf(", ");
}
printf("]");
break;
case tHash:
printf("#<tHash:%p>", object);
break;
case tFunction:
printf("#<tFunction:%p @method=\"%p\">", object, object->value.other);
break;
case tTrue:
printf("true");
break;
case tFalse:
printf("false");
break;
case tNil:
printf("nil");
break;
case tObject:
printf("#<tObject:%p>", object);
break;
}
}
bstring
Object_to_string(Object *object)
{
char *str = NULL;
switch(object->type) {
case tInteger: {
str = calloc(100, sizeof(char));
sprintf(str, "%i", object->value.as_integer);
break;
}
case tString: {
int size = blength(object->value.as_string);
str = calloc(size, sizeof(char));
sprintf(str, "\"%s\"", bdata(object->value.as_string));
break;
}
case tArray: {
DArray *ary = object->value.as_array;
str = calloc(1024, sizeof(char));
strcat(str, "[");
int i = 0;
int count = DArray_count(ary);
for(i=0; i < count; i++) {
bstring elm = Object_to_string(DArray_get(ary, i));
strcat(str, bdata(elm));
if(i != count - 1) strcat(str, ", ");
}
strcat(str, "]");
break;
}
default: {
str = calloc(4, sizeof(char));
sprintf(str, "nil");
break;
}
}
return S(str);
}
int main(int argc, char **argv) {
FeaturedSentence sent = FeatureSentence_create();
sent->section = 2;
DArray *words = split(mysentence, "\n");
for (int i = 0; i < DArray_count(words); ++i) {
char *line = (char *) DArray_get(words, i);
if (strcmp(line, "\n") != 0) {
Word w = parse_word(line);
add_word(sent, w);
//printMatrix("Embedding", w->embedding, stdout);
}
}
const char *template[] = {"p-1postag_p0postag_p1postag_c-1postag_c0v_c1postag_betweenpostag",