/* Initialize the search and replace history lists. */ void history_init(void) { search_history = make_new_node(NULL); search_history->data = mallocstrcpy(NULL, ""); searchage = search_history; searchbot = search_history; replace_history = make_new_node(NULL); replace_history->data = mallocstrcpy(NULL, ""); replaceage = replace_history; replacebot = replace_history; }
node *make_new_leaf() { node *leaf; leaf = make_new_node(); leaf->is_leaf = true; return leaf; }
// huffman coding algorithm // based on a pseudocode on 16.3 CLRS 3rd. SharedNode make_tree(FrequencyMap<Char, Freq> const& map) const { auto greater = [](SharedNode lhs, SharedNode rhs) { if (lhs->freq_ != rhs->freq_) return lhs->freq_ > rhs->freq_; else return lhs->character_ > rhs->character_; }; using MinPriorityQueue = std::priority_queue < SharedNode, std::vector<SharedNode>, decltype(greater) > ; MinPriorityQueue queue(greater); for (auto const& pair : map) queue.push(make_new_node(pair.first, pair.second)); for (int count = 1; count != map.size(); ++count) { auto merge = make_new_node<Char, Freq>(); merge->left_ = queue.top(); queue.pop(); merge->right_ = queue.top(); queue.pop(); merge->freq_ = merge->left_->freq_ + merge->right_->freq_; queue.push(merge); } return queue.top(); }
/* Update a history list. h should be the current position in the * list. */ void update_history(linestruct **h, const char *s) { linestruct **hage = NULL, **hbot = NULL, *p; assert(h != NULL && s != NULL); if (*h == search_history) { hage = &searchage; hbot = &searchbot; } else if (*h == replace_history) { hage = &replaceage; hbot = &replacebot; } assert(hage != NULL && hbot != NULL); /* If this string is already in the history, delete it. */ p = find_history(*hage, *hbot, s, strlen(s)); if (p != NULL) { linestruct *foo, *bar; /* If the string is at the beginning, move the beginning down to * the next string. */ if (p == *hage) *hage = (*hage)->next; /* Delete the string. */ foo = p; bar = p->next; unlink_node(foo); delete_node(foo); renumber(bar); } /* If the history is full, delete the beginning entry to make room * for the new entry at the end. We assume that MAX_SEARCH_HISTORY * is greater than zero. */ if ((*hbot)->lineno == MAX_SEARCH_HISTORY + 1) { linestruct *foo = *hage; *hage = (*hage)->next; unlink_node(foo); delete_node(foo); renumber(*hage); } /* Add the new entry to the end. */ (*hbot)->data = mallocstrcpy((*hbot)->data, s); splice_node(*hbot, make_new_node(*hbot), (*hbot)->next); *hbot = (*hbot)->next; (*hbot)->data = mallocstrcpy(NULL, ""); /* Indicate that the history's been changed. */ history_changed = TRUE; /* Set the current position in the list to the bottom. */ *h = *hbot; }
/* Initialize the lists of historical search and replace strings * and the list of historical executed commands. */ void history_init(void) { search_history = make_new_node(NULL); search_history->data = mallocstrcpy(NULL, ""); searchtop = search_history; searchbot = search_history; replace_history = make_new_node(NULL); replace_history->data = mallocstrcpy(NULL, ""); replacetop = replace_history; replacebot = replace_history; execute_history = make_new_node(NULL); execute_history->data = mallocstrcpy(NULL, ""); executetop = execute_history; executebot = execute_history; }
node *make_new_leaf() { node *leaf = NULL; leaf = make_new_node(); if(leaf) leaf->is_leaf = true; return leaf; }
node *insert_into_node_after_splitting(node *root, node *nd, node *right, int index, char *key) { int i, split; node **temp_ps, *new_nd, *child; char **temp_ks, *new_key; temp_ps = malloc((size + 1) * sizeof(node *)); temp_ks = malloc(size * sizeof(char *)); for (i = 0; i < size + 1; i++){ if (i == index + 1) temp_ps[i] = right; else if (i < index + 1) temp_ps[i] = nd->pointers[i]; else temp_ps[i] = nd->pointers[i-1]; } for (i = 0; i < size; i++){ if (i == index){ temp_ks[i] = malloc(MAX_KEY_LEN); strcpy(temp_ks[i], key); } else if (i < index) temp_ks[i] = nd->keys[i]; else temp_ks[i] = nd->keys[i-1]; } split = size % 2 ? size / 2 + 1 : size / 2; // split is #pointers nd->num_keys = split - 1; for (i = 0; i < split - 1; i++){ nd->pointers[i] = temp_ps[i]; nd->keys[i] = temp_ks[i]; } nd->pointers[i] = temp_ps[i]; // i == split - 1 new_key = temp_ks[split - 1]; new_nd = make_new_node(); new_nd->num_keys = size - split; for (++i; i < size; i++){ new_nd->pointers[i - split] = temp_ps[i]; new_nd->keys[i - split] = temp_ks[i]; } new_nd->pointers[i - split] = temp_ps[i]; new_nd->parent = nd->parent; for (i = 0; i <= new_nd->num_keys; i++){ // #pointers == num_keys + 1 child = (node *)(new_nd->pointers[i]); child->parent = new_nd; } free(temp_ps); free(temp_ks); return insert_into_parent(root, nd, new_nd, new_key); }
/* Update a history list (the one in which item is the current position) * with a fresh string text. That is: add text, or move it to the end. */ void update_history(linestruct **item, const char *text) { linestruct **htop = NULL, **hbot = NULL, *thesame; if (*item == search_history) { htop = &searchtop; hbot = &searchbot; } else if (*item == replace_history) { htop = &replacetop; hbot = &replacebot; } else if (*item == execute_history) { htop = &executetop; hbot = &executebot; } /* See if the string is already in the history. */ thesame = find_history(*hbot, *htop, text, HIGHEST_POSITIVE); /* If an identical string was found, delete that item. */ if (thesame != NULL) { linestruct *after = thesame->next; /* If the string is at the head of the list, move the head. */ if (thesame == *htop) *htop = after; unlink_node(thesame); renumber_from(after); } /* If the history is full, delete the oldest item (the one at the * head of the list), to make room for a new item at the end. */ if ((*hbot)->lineno == MAX_SEARCH_HISTORY + 1) { linestruct *oldest = *htop; *htop = (*htop)->next; unlink_node(oldest); renumber_from(*htop); } /* Store the fresh string in the last item, then create a new item. */ (*hbot)->data = mallocstrcpy((*hbot)->data, text); splice_node(*hbot, make_new_node(*hbot)); *hbot = (*hbot)->next; (*hbot)->data = mallocstrcpy(NULL, ""); /* Indicate that the history needs to be saved on exit. */ history_changed = TRUE; /* Set the current position in the list to the bottom. */ *item = *hbot; }
node *make_new_root(node *left, node *right, char *key) { node *root; root = make_new_node(); root->pointers[0] = left; root->pointers[1] = right; root->keys[0] = malloc(MAX_KEY_LEN); strcpy(root->keys[0], key); root->num_keys++; left->parent = root; right->parent = root; return root; }
static PyObject* insert_before(LinkedListObject* self, LinkedListNode* node, PyObject* obj) { LinkedListNode* new_node; PyObject* retval; new_node = make_new_node(obj, node->prev, node); if(!new_node) return NULL; node->prev->next = new_node; node->prev = new_node; self->count += 1; retval = (PyObject*)LinkedListIterObject_new(self, new_node); return retval; }
static PyObject* LinkedList_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { LinkedListObject *self; LinkedListNode *sentinal; self = (LinkedListObject *)type->tp_alloc(type, 0); if (self == NULL) return NULL; sentinal = make_new_node(NULL, NULL, NULL); if(!sentinal) { Py_DECREF(self); return NULL; } self->sentinal = sentinal->next = sentinal->prev = sentinal; sentinal->iter_count = 1; // prevent the sentinal from being deleted self->count = 0; return (PyObject *)self; }
node *make_new_root(node *left, node *right, char *key,unsigned long key_id) { node *root; root = make_new_node(); root->pointers[0] = left; root->pointers[1] = right; root->keys[0] = malloc(MAX_KEY_LEN); strcpy(root->keys[0], key); root->num_keys++; left->parent = root; right->parent = root; root->block->pointers_id[0] = left->block->node_id; root->block->pointers_id[1] = right->block->node_id; root->block->keys_id[0] = key_id; root->block->num_keys = root->num_keys; left->block->parent_id = root->block->node_id; right->block->parent_id = root->block->node_id; return root; }
node *insert_into_node_after_splitting(node *root, node *nd, node *right, int index, char *key,unsigned long key_id) { int i, split; node **temp_ps, *new_nd, *child; char **temp_ks, *new_key; unsigned long *temp_ps_block,*temp_ks_block; unsigned long new_key_id; temp_ps = malloc((size + 1) * sizeof(node *)); temp_ks = malloc(size * sizeof(char *)); temp_ps_block = malloc((size+1)*sizeof(unsigned long)); temp_ks_block = malloc(size*sizeof(unsigned long)); for (i = 0; i < size + 1; i++){ if (i == index + 1){ temp_ps[i] = right; temp_ps_block[i] = right->block->node_id; } else if (i < index + 1){ temp_ps[i] = nd->pointers[i]; temp_ps_block[i] = nd->block->pointers_id[i]; } else { temp_ps[i] = nd->pointers[i-1]; temp_ps_block[i] = nd->block->pointers_id[i-1]; } } #if 1 for (i = 0; i < size; i++){ if (i == index){ temp_ks[i] = malloc(MAX_KEY_LEN); strcpy(temp_ks[i], key); temp_ks_block[i] = key_id; } else if (i < index){ temp_ks[i] = nd->keys[i]; temp_ks_block[i] = nd->block->keys_id[i]; } else { temp_ks[i] = nd->keys[i-1]; temp_ks_block[i] = nd->block->keys_id[i-1]; } } #endif split = size % 2 ? size / 2 + 1 : size / 2; // split is #pointers nd->num_keys = split - 1; nd->block->num_keys = split-1; for (i = 0; i < split - 1; i++){ nd->pointers[i] = temp_ps[i]; nd->keys[i] = temp_ks[i]; nd->block->pointers_id[i] = temp_ps_block[i]; nd->block->keys_id[i] = temp_ks_block[i]; } nd->pointers[i] = temp_ps[i]; // i == split - 1 nd->block->pointers_id[i] = temp_ps_block[i]; new_key = temp_ks[split - 1]; new_key_id = temp_ks_block[split - 1]; new_nd = make_new_node(); new_nd->num_keys = size - split; new_nd->block->num_keys= size - split; for (++i; i < size; i++){ new_nd->pointers[i - split] = temp_ps[i]; new_nd->keys[i - split] = temp_ks[i]; new_nd->block->pointers_id[i - split] = temp_ps_block[i]; new_nd->block->keys_id[i - split] = temp_ks_block[i]; } new_nd->pointers[i - split] = temp_ps[i]; new_nd->block->pointers_id[i - split] = temp_ps_block[i]; new_nd->parent = nd->parent; new_nd->block->parent_id = nd->parent->block->node_id; for (i = 0; i <= new_nd->num_keys; i++){ // #pointers == num_keys + 1 child = (node *)(new_nd->pointers[i]); child->parent = new_nd; child->block->parent_id = new_nd->block->node_id; } free(temp_ps); free(temp_ks); free(temp_ps_block); free(temp_ks_block); return insert_into_parent(root, nd, new_nd, new_key,new_key_id); }